{"model_name":"glm-4.6","codes":{"1":{"ahc001":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Company {\n int id, x, y, r;\n int a, b, c, d; // rectangle coordinates\n};\n\nstruct Rect {\n int a, b, c, d;\n int area() const { return (c-a)*(d-b); }\n bool contains(int x, int y) const { \n return a <= x && x+1 <= c && b <= y && y+1 <= d; \n }\n};\n\n// Split outer rectangle after removing inner rectangle\nvector split_rect(const Rect& outer, const Rect& inner) {\n vector result;\n \n // Top\n if (inner.b > outer.b) {\n result.push_back({outer.a, outer.b, outer.c, inner.b});\n }\n \n // Bottom \n if (inner.d < outer.d) {\n result.push_back({outer.a, inner.d, outer.c, outer.d});\n }\n \n // Left\n if (inner.a > outer.a) {\n result.push_back({outer.a, inner.b, inner.a, inner.d});\n }\n \n // Right\n if (inner.c < outer.c) {\n result.push_back({inner.c, inner.b, outer.c, inner.d});\n }\n \n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n vector companies(n);\n for (int i = 0; i < n; i++) {\n companies[i].id = i;\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n }\n \n // Sort by desired area (descending) to handle large companies first\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.r > b.r;\n });\n \n vector available = {{0, 0, 10000, 10000}};\n \n for (auto& comp : companies) {\n int x = comp.x, y = comp.y, r = comp.r;\n \n // Find best available rectangle containing the point\n int best_idx = -1;\n double best_score = -1;\n \n for (int i = 0; i < available.size(); i++) {\n if (available[i].contains(x, y)) {\n int area = available[i].area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n }\n \n if (best_idx != -1) {\n // Direct assignment\n comp.a = available[best_idx].a;\n comp.b = available[best_idx].b;\n comp.c = available[best_idx].c;\n comp.d = available[best_idx].d;\n available.erase(available.begin() + best_idx);\n } else {\n // Need to split an existing rectangle\n best_idx = -1;\n best_score = -1;\n Rect best_rect;\n vector best_remaining;\n \n for (int i = 0; i < available.size(); i++) {\n const Rect& rect = available[i];\n \n // Try different splitting strategies\n \n // Strategy 1: Minimal 1x1 rectangle\n Rect min_rect = {x, y, x+1, y+1};\n if (rect.a <= x && x+1 <= rect.c && rect.b <= y && y+1 <= rect.d) {\n int area = 1;\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = min_rect;\n best_remaining = split_rect(rect, min_rect);\n }\n }\n \n // Strategy 2: Vertical split to match area\n if (rect.a <= x && x+1 <= rect.c) {\n int height = rect.d - rect.b;\n int target_width = max(1, min(r / height, rect.c - rect.a));\n \n // Left placement\n Rect left_rect = {rect.a, rect.b, rect.a + target_width, rect.d};\n if (left_rect.contains(x, y)) {\n int area = left_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = left_rect;\n best_remaining = split_rect(rect, left_rect);\n }\n }\n \n // Right placement\n Rect right_rect = {rect.c - target_width, rect.b, rect.c, rect.d};\n if (right_rect.contains(x, y)) {\n int area = right_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = right_rect;\n best_remaining = split_rect(rect, right_rect);\n }\n }\n }\n \n // Strategy 3: Horizontal split to match area\n if (rect.b <= y && y+1 <= rect.d) {\n int width = rect.c - rect.a;\n int target_height = max(1, min(r / width, rect.d - rect.b));\n \n // Top placement\n Rect top_rect = {rect.a, rect.b, rect.c, rect.b + target_height};\n if (top_rect.contains(x, y)) {\n int area = top_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = top_rect;\n best_remaining = split_rect(rect, top_rect);\n }\n }\n \n // Bottom placement\n Rect bottom_rect = {rect.a, rect.d - target_height, rect.c, rect.d};\n if (bottom_rect.contains(x, y)) {\n int area = bottom_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = bottom_rect;\n best_remaining = split_rect(rect, bottom_rect);\n }\n }\n }\n }\n \n if (best_idx != -1) {\n comp.a = best_rect.a;\n comp.b = best_rect.b;\n comp.c = best_rect.c;\n comp.d = best_rect.d;\n available.erase(available.begin() + best_idx);\n for (const auto& rect : best_remaining) {\n if (rect.area() > 0) {\n available.push_back(rect);\n }\n }\n } else {\n // Fallback: assign largest available rectangle\n int largest_idx = max_element(available.begin(), available.end(), \n [](const Rect& a, const Rect& b) { return a.area() < b.area(); }) - available.begin();\n \n comp.a = available[largest_idx].a;\n comp.b = available[largest_idx].b;\n comp.c = available[largest_idx].c;\n comp.d = available[largest_idx].d;\n available.erase(available.begin() + largest_idx);\n }\n }\n }\n \n // Sort by original ID for output\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.id < b.id;\n });\n \n // Output results\n for (const auto& comp : companies) {\n cout << comp.a << \" \" << comp.b << \" \" << comp.c << \" \" << comp.d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\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> t(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> t[i][j];\n }\n }\n \n vector> p(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> p[i][j];\n }\n }\n \n // Track visited tiles\n unordered_set visited_tiles;\n visited_tiles.insert(t[si][sj]);\n \n string path;\n int current_i = si, current_j = sj;\n int total_score = p[si][sj];\n \n // Directions: U, D, L, R\n vector di = {-1, 1, 0, 0};\n vector dj = {0, 0, -1, 1};\n vector dirs = {'U', 'D', 'L', 'R'};\n \n // Greedy exploration with look-ahead\n for (int step = 0; step < 1000; step++) {\n vector> candidates; // (score, ni, nj, dir)\n \n for (int d = 0; d < 4; d++) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n \n int tile_id = t[ni][nj];\n if (visited_tiles.count(tile_id)) continue;\n \n int score = p[ni][nj];\n \n // Add value of other square in the tile if it's 1x2 or 2x1\n for (int check_i = max(0, ni-1); check_i <= min(49, ni+1); check_i++) {\n for (int check_j = max(0, nj-1); check_j <= min(49, nj+1); check_j++) {\n if (abs(check_i - ni) + abs(check_j - nj) == 1 && t[check_i][check_j] == tile_id) {\n score += p[check_i][check_j];\n }\n }\n }\n \n // Add some randomness to explore different paths\n score += rand() % 10;\n \n candidates.push_back({score, ni, nj, dirs[d]});\n }\n \n if (candidates.empty()) {\n // Try to find a path to unvisited tiles\n vector> distant_candidates;\n \n for (int search_i = 0; search_i < 50; search_i++) {\n for (int search_j = 0; search_j < 50; search_j++) {\n int tile_id = t[search_i][search_j];\n if (visited_tiles.count(tile_id)) continue;\n \n int dist = abs(current_i - search_i) + abs(current_j - search_j);\n int score = p[search_i][search_j] - dist / 2; // Penalty for distance\n \n distant_candidates.push_back({score, search_i, search_j, '\\0'});\n }\n }\n \n if (distant_candidates.empty()) break;\n \n sort(distant_candidates.rbegin(), distant_candidates.rend());\n auto [_, target_i, target_j, ___] = distant_candidates[0];\n \n // Move towards target\n if (target_i < current_i) {\n path += 'U';\n current_i--;\n } else if (target_i > current_i) {\n path += 'D';\n current_i++;\n } else if (target_j < current_j) {\n path += 'L';\n current_j--;\n } else if (target_j > current_j) {\n path += 'R';\n current_j++;\n }\n } else {\n sort(candidates.rbegin(), candidates.rend());\n auto [_, ni, nj, dir] = candidates[0];\n \n path += dir;\n current_i = ni;\n current_j = nj;\n total_score += p[ni][nj];\n visited_tiles.insert(t[ni][nj]);\n \n // Add value of other square in tile if applicable\n for (int check_i = max(0, ni-1); check_i <= min(49, ni+1); check_i++) {\n for (int check_j = max(0, nj-1); check_j <= min(49, nj+1); check_j++) {\n if (abs(check_i - ni) + abs(check_j - nj) == 1 && t[check_i][check_j] == t[ni][nj]) {\n total_score += p[check_i][check_j];\n }\n }\n }\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\n// grid size\nconstexpr int N = 30;\nconstexpr int INF = 1e18;\n\n// edge weight estimates\ndouble H[N][N - 1]; // horizontal: (i,j) -> (i,j+1)\ndouble V[N - 1][N]; // vertical: (i,j) -> (i+1,j)\n\n// direction helpers\nconstexpr int di[4] = {-1, 1, 0, 0};\nconstexpr int dj[4] = {0, 0, -1, 1};\nconstexpr char dir_char[4] = {'U', 'D', 'L', 'R'};\n// for updating the correct edge array when we walk from (i,j) to (ni,nj)\nconstexpr int edge_index[4] = {3, 2, 1, 0}; // reversed mapping for readability\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n mt19937 rng(123456);\n uniform_int_distribution init_dist(1000, 9000);\n\n // initialise edge estimates\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N - 1; ++j) H[i][j] = init_dist(rng);\n }\n for (int i = 0; i < N - 1; ++i) {\n for (int j = 0; j < N; ++j) V[i][j] = init_dist(rng);\n }\n\n constexpr double learning_rate = 0.2; // moderate step size\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) break; // safety, should not happen\n\n // ---------- Dijkstra ----------\n using Node = pair>; // (dist, (i,j))\n priority_queue, greater> pq;\n double dist[N][N];\n int prev[N][N]; // direction index (0..3)\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n dist[i][j] = INF;\n prev[i][j] = -1;\n }\n dist[si][sj] = 0.0;\n pq.emplace(0.0, make_pair(si, sj));\n\n while (!pq.empty()) {\n auto [d, coord] = pq.top();\n auto [i, j] = coord;\n pq.pop();\n if (fabs(d - dist[i][j]) > 1e-9) continue;\n if (i == ti && j == tj) break; // reached target\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n double w = 0.0;\n if (dir == 0) { // U -> edge V[i-1][j]\n w = V[i - 1][j];\n } else if (dir == 1) { // D -> edge V[i][j]\n w = V[i][j];\n } else if (dir == 2) { // L -> edge H[i][j-1]\n w = H[i][j - 1];\n } else { // R -> edge H[i][j]\n w = H[i][j];\n }\n double nd = d + w;\n if (nd < dist[ni][nj] - 1e-9) {\n dist[ni][nj] = nd;\n prev[ni][nj] = dir;\n pq.emplace(nd, make_pair(ni, nj));\n }\n }\n }\n\n // reconstruct path\n string path;\n vector> edges_on_path; // (type, coordinates) for update\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n int dir = prev[ci][cj];\n path.push_back(dir_char[dir]);\n // store which edge we used (from (ci,cj) moving opposite direction)\n int oi = ci - di[dir];\n int oj = cj - dj[dir];\n // encode edge uniquely: type = 0 for H, 1 for V, plus coordinates\n if (dir == 0) { // moved U, edge is V[ci-1][cj]\n edges_on_path.emplace_back(1, (ci - 1) * N + cj);\n } else if (dir == 1) { // moved D, edge is V[ci][cj]\n edges_on_path.emplace_back(1, ci * N + cj);\n } else if (dir == 2) { // moved L, edge is H[ci][cj-1]\n edges_on_path.emplace_back(0, ci * (N - 1) + (cj - 1));\n } else { // moved R, edge is H[ci][cj]\n edges_on_path.emplace_back(0, ci * (N - 1) + cj);\n }\n ci = oi;\n cj = oj;\n }\n reverse(path.begin(), path.end());\n\n // ---------- output ----------\n cout << path << \"\\n\";\n cout.flush();\n\n // ---------- read feedback ----------\n long long observed;\n cin >> observed;\n\n // ---------- update edge estimates ----------\n double lest = 0.0;\n for (auto [type, idx] : edges_on_path) {\n if (type == 0) { // horizontal\n lest += H[idx / (N - 1)][idx % (N - 1)];\n } else { // vertical\n lest += V[idx / N][idx % N];\n }\n }\n double delta = static_cast(observed) - lest;\n int path_len = (int)edges_on_path.size();\n double step = learning_rate * delta / path_len;\n for (auto [type, idx] : edges_on_path) {\n if (type == 0) {\n double &w = H[idx / (N - 1)][idx % (N - 1)];\n w += step;\n if (w < 1000.0) w = 1000.0;\n if (w > 9000.0) w = 9000.0;\n } else {\n double &w = V[idx / N][idx % N];\n w += step;\n if (w < 1000.0) w = 1000.0;\n if (w > 9000.0) w = 9000.0;\n }\n }\n }\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nconst char EMPTY = '.';\n\nstruct StringInfo {\n string s;\n int length;\n int id;\n};\n\nstruct Position {\n int i, j, dir;\n};\n\nclass TorusReconstructor {\nprivate:\n vector strings;\n vector> matrix;\n mt19937 rng;\n vector char_freq;\n int best_score;\n vector> best_matrix;\n vector> string_overlaps;\n \npublic:\n TorusReconstructor(const vector& input_strings) : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n strings.resize(input_strings.size());\n char_freq.resize(8, 0);\n \n for (int i = 0; i < input_strings.size(); i++) {\n strings[i].s = input_strings[i];\n strings[i].length = input_strings[i].length();\n strings[i].id = i;\n \n for (char c : input_strings[i]) {\n char_freq[c - 'A']++;\n }\n }\n \n matrix.resize(N, vector(N, EMPTY));\n best_matrix = matrix;\n best_score = 0;\n \n analyze_string_relationships();\n }\n \n void analyze_string_relationships() {\n string_overlaps.resize(strings.size());\n \n for (int i = 0; i < strings.size(); i++) {\n for (int j = i + 1; j < strings.size(); j++) {\n if (have_common_substring(strings[i].s, strings[j].s)) {\n string_overlaps[i].push_back(j);\n string_overlaps[j].push_back(i);\n }\n }\n }\n }\n \n bool have_common_substring(const string& s1, const string& s2) {\n int min_len = min(s1.length(), s2.length());\n for (int len = 2; len <= min_len; len++) {\n for (int i = 0; i <= s1.length() - len; i++) {\n string sub1 = s1.substr(i, len);\n for (int j = 0; j <= s2.length() - len; j++) {\n if (sub1 == s2.substr(j, len)) {\n return true;\n }\n }\n }\n }\n return false;\n }\n \n bool is_string_matched(const string& s, const vector>& mat) {\n int k = s.length();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool horizontal_match = true;\n for (int p = 0; p < k; p++) {\n if (mat[i][(j + p) % N] != s[p]) {\n horizontal_match = false;\n break;\n }\n }\n if (horizontal_match) return true;\n \n bool vertical_match = true;\n for (int p = 0; p < k; p++) {\n if (mat[(i + p) % N][j] != s[p]) {\n vertical_match = false;\n break;\n }\n }\n if (vertical_match) return true;\n }\n }\n \n return false;\n }\n \n int count_matched_strings(const vector>& mat) {\n int count = 0;\n for (const auto& str_info : strings) {\n if (is_string_matched(str_info.s, mat)) {\n count++;\n }\n }\n return count;\n }\n \n void initialize_matrix() {\n sort(strings.begin(), strings.end(), [this](const StringInfo& a, const StringInfo& b) {\n if (a.length != b.length) return a.length > b.length;\n return string_overlaps[a.id].size() > string_overlaps[b.id].size();\n });\n \n vector> freq_chars;\n for (int i = 0; i < 8; i++) {\n freq_chars.push_back({char_freq[i], 'A' + i});\n }\n sort(freq_chars.rbegin(), freq_chars.rend());\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (rng() % 3 == 0) {\n matrix[i][j] = freq_chars[rng() % min(4, (int)freq_chars.size())].second;\n }\n }\n }\n \n best_score = count_matched_strings(matrix);\n best_matrix = matrix;\n }\n \n void place_string(const string& s) {\n int k = s.length();\n vector best_positions;\n int best_conflicts = k;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int conflicts = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[i][(j + p) % N];\n if (current != EMPTY && current != s[p]) {\n conflicts++;\n }\n }\n if (conflicts < best_conflicts) {\n best_conflicts = conflicts;\n best_positions = {{i, j, 0}};\n } else if (conflicts == best_conflicts) {\n best_positions.push_back({i, j, 0});\n }\n \n conflicts = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[(i + p) % N][j];\n if (current != EMPTY && current != s[p]) {\n conflicts++;\n }\n }\n if (conflicts < best_conflicts) {\n best_conflicts = conflicts;\n best_positions = {{i, j, 1}};\n } else if (conflicts == best_conflicts) {\n best_positions.push_back({i, j, 1});\n }\n }\n }\n \n if (!best_positions.empty() && best_conflicts < k / 2) {\n auto pos = best_positions[rng() % best_positions.size()];\n \n if (pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n matrix[pos.i][(pos.j + p) % N] = s[p];\n }\n } else {\n for (int p = 0; p < k; p++) {\n matrix[(pos.i + p) % N][pos.j] = s[p];\n }\n }\n }\n }\n \n void local_search(int iterations) {\n for (int iter = 0; iter < iterations; iter++) {\n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n char new_char = 'A' + (rng() % 8);\n if (new_char == old_char) continue;\n \n matrix[i][j] = new_char;\n int new_score = count_matched_strings(matrix);\n \n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n } else {\n matrix[i][j] = old_char;\n }\n \n if (rng() % 15 == 0) {\n int str_idx = rng() % strings.size();\n place_string(strings[str_idx].s);\n new_score = count_matched_strings(matrix);\n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n }\n }\n }\n }\n \n void simulated_annealing(int iterations) {\n double temperature = 1.0;\n double cooling_rate = 0.997;\n \n for (int iter = 0; iter < iterations; iter++) {\n temperature *= cooling_rate;\n \n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n char new_char = 'A' + (rng() % 8);\n if (new_char == old_char) continue;\n \n matrix[i][j] = new_char;\n int new_score = count_matched_strings(matrix);\n \n if (new_score >= best_score || (temperature > 0.01 && rng() % 1000 < temperature * 1000)) {\n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n }\n } else {\n matrix[i][j] = old_char;\n }\n }\n }\n \n void improve_unmatched_strings() {\n vector unmatched_indices;\n for (int i = 0; i < strings.size(); i++) {\n if (!is_string_matched(strings[i].s, matrix)) {\n unmatched_indices.push_back(i);\n }\n }\n \n sort(unmatched_indices.begin(), unmatched_indices.end(), [this](int a, int b) {\n return string_overlaps[a].size() > string_overlaps[b].size();\n });\n \n int attempts = min(30, (int)unmatched_indices.size());\n \n for (int i = 0; i < attempts; i++) {\n place_string(strings[unmatched_indices[i]].s);\n int new_score = count_matched_strings(matrix);\n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n }\n }\n }\n \n void reconstruct() {\n initialize_matrix();\n \n for (int idx = 0; idx < min(150, (int)strings.size()); idx++) {\n place_string(strings[idx].s);\n }\n \n for (int phase = 0; phase < 4; phase++) {\n improve_unmatched_strings();\n local_search(4000);\n simulated_annealing(2500);\n }\n \n matrix = best_matrix;\n }\n \n vector> get_matrix() const {\n return matrix;\n }\n \n int get_best_score() const {\n return best_score;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n TorusReconstructor reconstructor(strings);\n reconstructor.reconstruct();\n \n auto matrix = reconstructor.get_matrix();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << matrix[i][j];\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n vector> covered;\n string path;\n int total_time;\n int uncovered_count;\n \n State(int n) : covered(n, vector(n, false)), total_time(0), uncovered_count(0) {}\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 \n vector grid(N);\n vector> cost(N, vector(N));\n int road_count = 0;\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n road_count++;\n }\n }\n }\n \n // Precompute visibility for each road square\n vector>> visible(N, vector>(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == '#') continue;\n \n // Check visibility in 4 directions\n // Up\n for (int ni = i-1; ni >= 0 && grid[ni][j] != '#'; ni--) {\n visible[i][j].insert(ni * N + j);\n }\n // Down\n for (int ni = i+1; ni < N && grid[ni][j] != '#'; ni++) {\n visible[i][j].insert(ni * N + j);\n }\n // Left\n for (int nj = j-1; nj >= 0 && grid[i][nj] != '#'; nj--) {\n visible[i][j].insert(i * N + nj);\n }\n // Right\n for (int nj = j+1; nj < N && grid[i][nj] != '#'; nj++) {\n visible[i][j].insert(i * N + nj);\n }\n // Self\n visible[i][j].insert(i * N + j);\n }\n }\n \n // Find all road positions\n vector> road_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n road_positions.emplace_back(i, j);\n }\n }\n }\n \n // Greedy selection of key positions\n vector> selected(N, vector(N, false));\n vector> covered(N, vector(N, false));\n int covered_count = 0;\n \n // Start with initial position\n selected[si][sj] = true;\n for (int idx : visible[si][sj]) {\n int i = idx / N, j = idx % N;\n if (!covered[i][j]) {\n covered[i][j] = true;\n covered_count++;\n }\n }\n \n // Greedy selection until all are covered\n while (covered_count < road_count) {\n int best_i = -1, best_j = -1;\n int best_gain = -1;\n int best_cost = INT_MAX;\n \n for (auto [i, j] : road_positions) {\n if (selected[i][j]) continue;\n \n int gain = 0;\n for (int idx : visible[i][j]) {\n int ni = idx / N, nj = idx % N;\n if (!covered[ni][nj]) gain++;\n }\n \n if (gain > 0) {\n // Estimate cost to reach this position from nearest selected\n int min_dist = INT_MAX;\n for (auto [si, sj] : road_positions) {\n if (selected[si][sj]) {\n int dist = abs(i - si) + abs(j - sj);\n min_dist = min(min_dist, dist);\n }\n }\n \n if (gain * 1000 - min_dist > best_gain * 1000 - best_cost) {\n best_gain = gain;\n best_cost = min_dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n \n if (best_i == -1) break;\n \n selected[best_i][best_j] = true;\n for (int idx : visible[best_i][best_j]) {\n int ni = idx / N, nj = idx % N;\n if (!covered[ni][nj]) {\n covered[ni][nj] = true;\n covered_count++;\n }\n }\n }\n \n // Collect selected positions\n vector> key_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (selected[i][j]) {\n key_positions.emplace_back(i, j);\n }\n }\n }\n \n // Build route using nearest neighbor\n string path;\n int current_i = si, current_j = sj;\n vector> visited(N, vector(N, false));\n visited[si][sj] = true;\n \n while (true) {\n // Find nearest unvisited key position\n int best_dist = INT_MAX;\n int best_idx = -1;\n \n for (int k = 0; k < (int)key_positions.size(); k++) {\n auto [ni, nj] = key_positions[k];\n if (visited[ni][nj]) continue;\n \n int dist = abs(ni - current_i) + abs(nj - current_j);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = k;\n }\n }\n \n if (best_idx == -1) break;\n \n auto [target_i, target_j] = key_positions[best_idx];\n \n // Move to target\n while (current_i != target_i) {\n if (current_i < target_i) {\n path += 'D';\n current_i++;\n } else {\n path += 'U';\n current_i--;\n }\n }\n \n while (current_j != target_j) {\n if (current_j < target_j) {\n path += 'R';\n current_j++;\n } else {\n path += 'L';\n current_j--;\n }\n }\n \n visited[target_i][target_j] = true;\n }\n \n // Return to start\n while (current_i != si) {\n if (current_i < si) {\n path += 'D';\n current_i++;\n } else {\n path += 'U';\n current_i--;\n }\n }\n \n while (current_j != sj) {\n if (current_j < sj) {\n path += 'R';\n current_j++;\n } else {\n path += 'L';\n current_j--;\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Variables ---\nint N, M, K, R;\nvector> d; // Task requirements\nvector> pred; // Predecessor lists\nvector> succ; // Successor lists\nvector num_preds; // Number of predecessors for each task\nvector L; // Longest path length from each task\nvector max_d; // Max requirement for each skill\n\n// --- State ---\nint current_day;\nvector task_status; // 0: todo, 1: doing, 2: done\nvector completed_preds_count;\nvector member_busy;\nvector member_task; // task assigned to member\nvector member_start_day;\nvector> s_est; // Estimated skills for each member\nvector num_tasks_done;\n\n// --- Helper function for topological sort ---\nvector topological_sort(const vector>& graph) {\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int v : graph[i]) {\n in_degree[v]++;\n }\n }\n queue q;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n q.push(i);\n }\n }\n vector order;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n order.push_back(u);\n for (int v : graph[u]) {\n if (--in_degree[v] == 0) {\n q.push(v);\n }\n }\n }\n return order;\n}\n\n// --- Main function ---\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // --- Input Reading ---\n cin >> N >> M >> K >> R;\n d.resize(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n cin >> d[i][j];\n }\n }\n\n pred.resize(N);\n succ.resize(N);\n num_preds.resize(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--; // 0-based\n pred[v].push_back(u);\n succ[u].push_back(v);\n num_preds[v]++;\n }\n\n // --- Preprocessing ---\n // Calculate max_d\n max_d.assign(K, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n max_d[k] = max(max_d[k], d[i][k]);\n }\n }\n\n // Calculate L (longest path length)\n vector topo_order = topological_sort(pred); // Sort by preds\n L.assign(N, 1);\n for (auto it = topo_order.rbegin(); it != topo_order.rend(); ++it) {\n int u = *it;\n for (int v : succ[u]) {\n L[u] = max(L[u], 1 + L[v]);\n }\n }\n\n // --- State Initialization ---\n current_day = 1;\n task_status.assign(N, 0);\n completed_preds_count.assign(N, 0);\n member_busy.assign(M, false);\n member_task.assign(M, -1);\n member_start_day.assign(M, -1);\n s_est.assign(M, vector(K, 0.0));\n num_tasks_done.assign(M, 0);\n\n // --- Main Loop ---\n while (true) {\n // --- Step 1: Update State and Learn ---\n string line;\n getline(cin, line); // consume the rest of the previous line, if any\n getline(cin, line);\n istringstream iss(line);\n int n;\n iss >> n;\n if (n == -1) {\n break;\n }\n\n for (int i = 0; i < n; ++i) {\n int f_j;\n iss >> f_j;\n int j = f_j - 1; // 0-based index\n\n int t_id = member_task[j];\n int start_day = member_start_day[j];\n int t_obs = (current_day - 1) - start_day + 1;\n\n task_status[t_id] = 2; // Mark as done\n member_busy[j] = false;\n member_task[j] = -1;\n\n for (int succ_task : succ[t_id]) {\n completed_preds_count[succ_task]++;\n }\n\n // Skill Update\n num_tasks_done[j]++;\n double lr = (t_obs > 1) ? 1.0 / sqrt(num_tasks_done[j]) : 0.1 / sqrt(num_tasks_done[j]);\n for (int k = 0; k < K; ++k) {\n if (d[t_id][k] > s_est[j][k]) {\n s_est[j][k] += lr;\n s_est[j][k] = min(s_est[j][k], (double)d[t_id][k]);\n s_est[j][k] = min(s_est[j][k], (double)max_d[k]);\n }\n }\n }\n \n // --- Step 2: Find Available Resources ---\n vector ready_tasks;\n for (int i = 0; i < N; ++i) {\n if (task_status[i] == 0 && completed_preds_count[i] == num_preds[i]) {\n ready_tasks.push_back(i);\n }\n }\n\n vector free_members;\n for (int j = 0; j < M; ++j) {\n if (!member_busy[j]) {\n free_members.push_back(j);\n }\n }\n\n // --- Step 3: Greedy Assignment ---\n vector> assignments;\n if (!ready_tasks.empty() && !free_members.empty()) {\n vector> pairs; // cost, -L[i], est_time, task_id, member_id\n for (int i : ready_tasks) {\n for (int j : free_members) {\n double w_est = 0.0;\n for (int k = 0; k < K; ++k) {\n w_est += max(0, d[i][k] - s_est[j][k]);\n }\n int est_time = max(1.0, w_est);\n double cost = (double)est_time / L[i];\n pairs.emplace_back(cost, -L[i], est_time, i, j);\n }\n }\n sort(pairs.begin(), pairs.end());\n\n vector task_used(N, false);\n vector member_used(M, false);\n for (const auto& p : pairs) {\n int i = get<3>(p);\n int j = get<4>(p);\n if (!task_used[i] && !member_used[j]) {\n assignments.emplace_back(j + 1, i + 1); // 1-based for output\n task_status[i] = 1; // Mark as in progress\n member_busy[j] = true;\n member_task[j] = i;\n member_start_day[j] = current_day;\n task_used[i] = true;\n member_used[j] = true;\n }\n }\n }\n\n // --- Step 4: Output and Flush ---\n cout << assignments.size();\n for (const auto& a : assignments) {\n cout << \" \" << a.first << \" \" << a.second;\n }\n cout << endl;\n cout.flush();\n\n // --- Step 5: Increment Day ---\n current_day++;\n }\n\n return 0;\n}","ahc006":"#include \n#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Order {\n int id, a, b, c, d;\n double dist_from_center;\n};\n\nstruct Point {\n int x, y;\n int type; // 0: start/end, 1: pickup, 2: delivery\n int order_id; // which order this point belongs to\n};\n\n// Manhattan distance\nint manhattan_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Calculate total route length\nint calculate_route_length(const vector& route) {\n int total = 0;\n for (int i = 0; i < route.size() - 1; i++) {\n total += manhattan_dist(route[i].x, route[i].y, route[i+1].x, route[i+1].y);\n }\n return total;\n}\n\n// Check if route is valid (pickup before delivery for all orders)\nbool is_valid_route(const vector& route, const vector& selected) {\n unordered_map pickup_pos, delivery_pos;\n for (int i = 0; i < route.size(); i++) {\n if (route[i].type == 1) {\n pickup_pos[route[i].order_id] = i;\n } else if (route[i].type == 2) {\n delivery_pos[route[i].order_id] = i;\n }\n }\n \n for (int i = 0; i < selected.size(); i++) {\n if (selected[i]) {\n if (pickup_pos[i] >= delivery_pos[i]) return false;\n }\n }\n return true;\n}\n\n// 2-opt improvement\nvector two_opt(const vector& route, const vector& selected) {\n if (route.size() < 4) return route;\n \n vector best = route;\n int best_len = calculate_route_length(best);\n \n for (int iter = 0; iter < 50; iter++) {\n for (int i = 1; i < route.size() - 2; i++) {\n for (int j = i + 1; j < route.size() - 1; j++) {\n vector new_route = route;\n reverse(new_route.begin() + i, new_route.begin() + j + 1);\n \n if (is_valid_route(new_route, selected)) {\n int new_len = calculate_route_length(new_route);\n if (new_len < best_len) {\n best = new_route;\n best_len = new_len;\n }\n }\n }\n }\n }\n \n return best;\n}\n\n// Swap two orders in the selection\nvector swap_orders(const vector& selected, const vector& orders, random_device& rd) {\n vector new_selected = selected;\n vector selected_orders, unselected_orders;\n \n for (int i = 0; i < orders.size(); i++) {\n if (selected[i]) selected_orders.push_back(i);\n else unselected_orders.push_back(i);\n }\n \n if (selected_orders.empty() || unselected_orders.empty()) return selected;\n \n uniform_int_distribution dist1(0, selected_orders.size() - 1);\n uniform_int_distribution dist2(0, unselected_orders.size() - 1);\n \n int idx1 = dist1(rd);\n int idx2 = dist2(rd);\n \n new_selected[selected_orders[idx1]] = false;\n new_selected[unselected_orders[idx2]] = true;\n \n return new_selected;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i;\n orders[i].dist_from_center = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n }\n \n // Sort orders by distance from center (prefer closer orders)\n sort(orders.begin(), orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_from_center < o2.dist_from_center;\n });\n \n random_device rd;\n mt19937 rng(rd());\n \n // Initial selection: pick 50 orders from the closest 200\n vector selected(1000, false);\n uniform_int_distribution dist(0, min(199, 999));\n \n unordered_set selected_set;\n while (selected_set.size() < 50) {\n int idx = dist(rng);\n if (selected_set.find(idx) == selected_set.end()) {\n selected_set.insert(idx);\n selected[orders[idx].id] = true;\n }\n }\n \n // Build initial route\n vector route;\n route.push_back({400, 400, 0, -1});\n \n // Add all pickup points\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n route.push_back({orders[i].a, orders[i].b, 1, i});\n }\n }\n \n // Add all delivery points\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n route.push_back({orders[i].c, orders[i].d, 2, i});\n }\n }\n \n route.push_back({400, 400, 0, -1});\n \n // Optimize with greedy nearest neighbor\n for (int iter = 0; iter < 3; iter++) {\n vector new_route;\n new_route.push_back({400, 400, 0, -1});\n \n vector visited(1000, false);\n int current_x = 400, current_y = 400;\n \n // Visit pickups first\n for (int count = 0; count < 50; count++) {\n int best_idx = -1;\n int best_dist = INT_MAX;\n \n for (int i = 0; i < 1000; i++) {\n if (selected[i] && !visited[i]) {\n int dist = manhattan_dist(current_x, current_y, orders[i].a, orders[i].b);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = i;\n }\n }\n }\n \n if (best_idx != -1) {\n new_route.push_back({orders[best_idx].a, orders[best_idx].b, 1, best_idx});\n current_x = orders[best_idx].a;\n current_y = orders[best_idx].b;\n visited[best_idx] = true;\n }\n }\n \n // Then deliveries\n for (int count = 0; count < 50; count++) {\n int best_idx = -1;\n int best_dist = INT_MAX;\n \n for (int i = 0; i < 1000; i++) {\n if (selected[i] && visited[i]) {\n int dist = manhattan_dist(current_x, current_y, orders[i].c, orders[i].d);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = i;\n }\n }\n }\n \n if (best_idx != -1) {\n new_route.push_back({orders[best_idx].c, orders[best_idx].d, 2, best_idx});\n current_x = orders[best_idx].c;\n current_y = orders[best_idx].d;\n }\n }\n \n new_route.push_back({400, 400, 0, -1});\n \n if (calculate_route_length(new_route) < calculate_route_length(route)) {\n route = new_route;\n }\n }\n \n // Apply 2-opt\n route = two_opt(route, selected);\n \n // Simulated annealing for order swapping\n double temp = 100.0;\n double cooling_rate = 0.95;\n int current_length = calculate_route_length(route);\n \n for (int iter = 0; iter < 100; iter++) {\n temp *= cooling_rate;\n \n for (int inner = 0; inner < 10; inner++) {\n vector new_selected = swap_orders(selected, orders, rd);\n \n // Build new route for this selection\n vector new_route;\n new_route.push_back({400, 400, 0, -1});\n \n // Add pickups\n for (int i = 0; i < 1000; i++) {\n if (new_selected[i]) {\n new_route.push_back({orders[i].a, orders[i].b, 1, i});\n }\n }\n \n // Add deliveries\n for (int i = 0; i < 1000; i++) {\n if (new_selected[i]) {\n new_route.push_back({orders[i].c, orders[i].d, 2, i});\n }\n }\n \n new_route.push_back({400, 400, 0, -1});\n \n // Optimize with 2-opt\n new_route = two_opt(new_route, new_selected);\n \n int new_length = calculate_route_length(new_route);\n \n // Accept if better or with probability\n if (new_length < current_length || \n exp((current_length - new_length) / temp) > (double)rng() / rng.max()) {\n selected = new_selected;\n route = new_route;\n current_length = new_length;\n }\n }\n }\n \n // Final 2-opt optimization\n route = two_opt(route, selected);\n \n // Output result\n vector selected_ids;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_ids.push_back(i + 1); // Convert to 1-based\n }\n }\n \n cout << 50;\n for (int id : selected_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n \n cout << route.size();\n for (const auto& p : route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Global constants as per problem statement\nconst int N = 400;\nconst int M = 1995;\n\n// Main solver class/structure\nstruct OnlineMST {\n int n, m;\n vector> points;\n vector> edges;\n vector> dist_mat;\n vector> min_dist;\n dsu d;\n set active_roots;\n int num_components;\n\n // Tunable parameters\n const double k_base = 2.5;\n const int desperation_threshold = 5;\n\n OnlineMST() : n(N), m(M), d(N) {\n points.resize(n);\n edges.resize(m);\n dist_mat.assign(n, vector(n, 0));\n min_dist.assign(n, vector(n, 0));\n num_components = n;\n for (int i = 0; i < n; ++i) {\n active_roots.insert(i);\n }\n }\n\n // Helper function to calculate rounded distance\n int calc_dist(int i, int j) {\n long long dx = points[i].first - points[j].first;\n long long dy = points[i].second - points[j].second;\n return (int)round(sqrt(dx * dx + dy * dy));\n }\n\n void preprocess() {\n // Calculate all-pairs distances\n for (int i = 0; i < n; ++i) {\n for (int j = i + 1; j < n; ++j) {\n dist_mat[i][j] = calc_dist(i, j);\n dist_mat[j][i] = dist_mat[i][j];\n }\n }\n // Initialize min_dist with dist_mat\n min_dist = dist_mat;\n }\n\n void update_min_dist(int new_root, int old_root_u, int old_root_v) {\n // min_dist for the new component is the min of the two old components\n for (int c : active_roots) {\n if (c == new_root) continue;\n min_dist[new_root][c] = min(min_dist[old_root_u][c], min_dist[old_root_v][c]);\n min_dist[c][new_root] = min_dist[new_root][c];\n }\n }\n\n bool decide(int edge_idx, int l) {\n auto [u, v] = edges[edge_idx];\n int root_u = d.leader(u);\n int root_v = d.leader(v);\n\n // If already connected, must reject\n if (root_u == root_v) {\n return false;\n }\n\n int remaining_edges = m - edge_idx;\n\n // Decision logic\n bool take = false;\n if (remaining_edges <= num_components + desperation_threshold) {\n // Desperation mode: take any connecting edge to ensure completion\n take = true;\n } else {\n // Normal mode: use dynamic threshold\n int d_min = min_dist[root_u][root_v];\n \n // desperation_factor is 0 at start, approaches 1 at the end\n double desperation_factor = (double)(num_components - 1) / remaining_edges;\n double k = k_base - (k_base - 1.0) * desperation_factor;\n \n if (l <= k * d_min) {\n take = true;\n }\n }\n\n if (take) {\n // Update state\n d.merge(root_u, root_v);\n num_components--;\n\n int new_root = d.leader(u); // leader of either is fine after merge\n int old_root = (new_root == root_u) ? root_v : root_u;\n \n active_roots.erase(old_root);\n update_min_dist(new_root, root_u, root_v);\n }\n\n return take;\n }\n\n void run() {\n // Read initial input\n for (int i = 0; i < n; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n for (int i = 0; i < m; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n preprocess();\n\n // Main loop\n for (int i = 0; i < m; ++i) {\n int l;\n cin >> l;\n\n bool decision = decide(i, l);\n\n cout << (decision ? 1 : 0) << endl;\n cout.flush();\n }\n }\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n OnlineMST solver;\n solver.run();\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct State {\n int N, M;\n vector> pets, humans;\n vector pet_types;\n vector> impassable;\n vector pet_moves;\n int turn;\n \n void read() {\n cin >> N;\n pets.resize(N);\n pet_types.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].first >> pets[i].second >> pet_types[i];\n }\n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].first >> humans[i].second;\n }\n impassable.assign(31, vector(31, false));\n turn = 0;\n }\n \n void read_pet_moves() {\n pet_moves.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n }\n \n bool is_valid(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n bool is_passable(int x, int y) {\n return is_valid(x, y) && !impassable[x][y];\n }\n \n bool has_pet_adjacent(int x, int y) {\n for (auto [px, py] : pets) {\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return true;\n }\n return false;\n }\n \n bool can_make_impassable(int x, int y, vector>& current_pets) {\n if (!is_valid(x, y)) return false;\n for (auto [px, py] : current_pets) {\n if (px == x && py == y) return false;\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return false;\n }\n for (auto [hx, hy] : humans) {\n if (hx == x && hy == y) return false;\n }\n return true;\n }\n \n vector> get_neighbors(int x, int y) {\n return {{x-1, y}, {x+1, y}, {x, y-1}, {x, y+1}};\n }\n \n vector get_dir_chars() {\n return {'u', 'd', 'l', 'r', 'U', 'D', 'L', 'R'};\n }\n \n char get_make_impassable_dir(int hx, int hy, int tx, int ty) {\n if (tx == hx-1 && ty == hy) return 'u';\n if (tx == hx+1 && ty == hy) return 'd';\n if (tx == hy-1 && ty == hx) return 'l';\n if (tx == hy+1 && ty == hx) return 'r';\n return '.';\n }\n \n char get_move_dir(int hx, int hy, int tx, int ty) {\n if (tx == hx-1 && ty == hy) return 'U';\n if (tx == hx+1 && ty == hy) return 'D';\n if (tx == hx && ty == hy-1) return 'L';\n if (tx == hx && ty == hy+1) return 'R';\n return '.';\n }\n \n pair find_best_wall_position(int human_idx) {\n auto [hx, hy] = humans[human_idx];\n int best_score = -1e9;\n pair best_pos = {-1, -1};\n \n // Priority 1: Block dangerous pets (dogs/cats)\n for (int i = 0; i < N; i++) {\n if (pet_types[i] == 4 || pet_types[i] == 5) { // dog or cat\n auto [px, py] = pets[i];\n int dist = abs(px - hx) + abs(py - hy);\n if (dist <= 5) { // Close enough to be a threat\n // Try to build wall between human and pet\n for (int x = min(px, hx); x <= max(px, hx); x++) {\n for (int y = min(py, hy); y <= max(py, hy); y++) {\n if (can_make_impassable(x, y, pets) && !impassable[x][y]) {\n int score = 100 - dist;\n if (score > best_score) {\n best_score = score;\n best_pos = {x, y};\n }\n }\n }\n }\n }\n }\n }\n \n if (best_pos.first != -1) return best_pos;\n \n // Priority 2: Create barriers around pet clusters\n vector> pet_density(31, vector(31, 0));\n for (auto [px, py] : pets) {\n for (int dx = -2; dx <= 2; dx++) {\n for (int dy = -2; dy <= 2; dy++) {\n int nx = px + dx, ny = py + dy;\n if (is_valid(nx, ny)) {\n pet_density[nx][ny] += 3 - abs(dx) - abs(dy);\n }\n }\n }\n }\n \n for (int x = 1; x <= 30; x++) {\n for (int y = 1; y <= 30; y++) {\n if (can_make_impassable(x, y, pets) && !impassable[x][y]) {\n int score = pet_density[x][y];\n // Prefer positions that complete walls\n int adj_walls = 0;\n for (auto [nx, ny] : get_neighbors(x, y)) {\n if (impassable[nx][ny]) adj_walls++;\n }\n score += adj_walls * 5;\n \n if (score > best_score) {\n best_score = score;\n best_pos = {x, y};\n }\n }\n }\n }\n \n return best_pos;\n }\n \n pair find_best_move_position(int human_idx) {\n auto [hx, hy] = humans[human_idx];\n int best_score = -1e9;\n pair best_pos = {hx, hy};\n \n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n // Calculate reachable area from this position\n vector> visited(31, vector(31, false));\n queue> q;\n q.push({nx, ny});\n visited[nx][ny] = true;\n int area = 0;\n int pets_in_area = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n area++;\n \n for (auto [px, py] : pets) {\n if (px == x && py == y) pets_in_area++;\n }\n \n for (auto [tx, ty] : get_neighbors(x, y)) {\n if (is_passable(tx, ty) && !visited[tx][ty]) {\n visited[tx][ty] = true;\n q.push({tx, ty});\n }\n }\n }\n \n double score = area * pow(0.5, pets_in_area);\n \n // Prefer center positions\n int center_dist = abs(nx - 15) + abs(ny - 15);\n score -= center_dist * 0.1;\n \n if (score > best_score) {\n best_score = score;\n best_pos = {nx, ny};\n }\n }\n }\n \n return best_pos;\n }\n \n string decide_actions() {\n string actions(M, '.');\n \n for (int i = 0; i < M; i++) {\n if (turn < 150) {\n // Phase 1: Focus on building barriers\n auto [wx, wy] = find_best_wall_position(i);\n if (wx != -1) {\n // Check if we can make this adjacent square impassable\n for (auto [nx, ny] : get_neighbors(humans[i].first, humans[i].second)) {\n if (nx == wx && ny == wy) {\n actions[i] = get_make_impassable_dir(humans[i].first, humans[i].second, wx, wy);\n break;\n }\n }\n }\n \n if (actions[i] == '.') {\n // Move closer to the best wall position\n auto [tx, ty] = find_best_wall_position(i);\n if (tx != -1) {\n int best_dist = abs(humans[i].first - tx) + abs(humans[i].second - ty);\n char best_move = '.';\n \n for (auto [nx, ny] : get_neighbors(humans[i].first, humans[i].second)) {\n if (is_passable(nx, ny)) {\n int dist = abs(nx - tx) + abs(ny - ty);\n if (dist < best_dist) {\n best_dist = dist;\n best_move = get_move_dir(humans[i].first, humans[i].second, nx, ny);\n }\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n } else {\n // Phase 2: Focus on positioning for maximum reachability\n auto [mx, my] = find_best_move_position(i);\n if (mx != humans[i].first || my != humans[i].second) {\n for (auto [nx, ny] : get_neighbors(humans[i].first, humans[i].second)) {\n if (nx == mx && ny == my) {\n actions[i] = get_move_dir(humans[i].first, humans[i].second, nx, ny);\n break;\n }\n }\n }\n }\n }\n \n return actions;\n }\n \n void update_state(const string& actions) {\n // Update impassable squares\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'u' || action == 'd' || action == 'l' || action == 'r') {\n int nx = hx, ny = hy;\n if (action == 'u') nx--;\n else if (action == 'd') nx++;\n else if (action == 'l') ny--;\n else if (action == 'r') ny++;\n \n if (can_make_impassable(nx, ny, pets)) {\n impassable[nx][ny] = true;\n }\n }\n }\n \n // Update human positions\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int nx = hx, ny = hy;\n if (action == 'U') nx--;\n else if (action == 'D') nx++;\n else if (action == 'L') ny--;\n else if (action == 'R') ny++;\n \n if (is_passable(nx, ny)) {\n humans[i] = {nx, ny};\n }\n }\n }\n \n // Update pet positions based on their moves\n for (int i = 0; i < N; i++) {\n auto [px, py] = pets[i];\n for (char move : pet_moves[i]) {\n if (move == 'U' && is_passable(px-1, py)) px--;\n else if (move == 'D' && is_passable(px+1, py)) px++;\n else if (move == 'L' && is_passable(px, py-1)) py--;\n else if (move == 'R' && is_passable(px, py+1)) py++;\n }\n pets[i] = {px, py};\n }\n \n turn++;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n State state;\n state.read();\n \n for (int turn = 0; turn < 300; turn++) {\n string actions = state.decide_actions();\n cout << actions << endl;\n cout.flush();\n \n state.read_pet_moves();\n state.update_state(actions);\n }\n \n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n string path;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h(20), v(19);\n for (int i = 0; i < 20; i++) cin >> h[i];\n for (int i = 0; i < 19; i++) cin >> v[i];\n \n // BFS to find shortest path\n queue q;\n vector> visited(20, vector(20, false));\n vector> path_str(20, vector(20, \"\"));\n \n q.push({si, sj, \"\"});\n visited[si][sj] = true;\n \n int dirs[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};\n string dir_chars = \"UDLR\";\n \n string shortest_path = \"\";\n bool found = false;\n \n while (!q.empty() && !found) {\n State cur = q.front(); q.pop();\n \n if (cur.i == ti && cur.j == tj) {\n shortest_path = cur.path;\n found = true;\n break;\n }\n \n for (int d = 0; d < 4; d++) {\n int ni = cur.i + dirs[d][0];\n int nj = cur.j + dirs[d][1];\n \n if (ni < 0 || ni >= 20 || nj < 0 || nj >= 20) continue;\n if (visited[ni][nj]) continue;\n \n // Check wall\n bool blocked = false;\n if (d == 0 && v[cur.i-1][cur.j] == '1') blocked = true; // U\n else if (d == 1 && v[cur.i][cur.j] == '1') blocked = true; // D\n else if (d == 2 && h[cur.i][cur.j-1] == '1') blocked = true; // L\n else if (d == 3 && h[cur.i][cur.j] == '1') blocked = true; // R\n \n if (!blocked) {\n visited[ni][nj] = true;\n q.push({ni, nj, cur.path + dir_chars[d]});\n }\n }\n }\n \n // Build robust path by repeating moves\n string robust_path = \"\";\n \n // Determine repetition count based on p\n // Higher p = more repetitions needed\n int repeat_count;\n if (p < 0.2) repeat_count = 2;\n else if (p < 0.3) repeat_count = 3;\n else if (p < 0.4) repeat_count = 4;\n else repeat_count = 5;\n \n // Adjust if path would be too long\n while (shortest_path.size() * repeat_count > 200 && repeat_count > 1) {\n repeat_count--;\n }\n \n // Build the robust path\n for (char c : shortest_path) {\n for (int i = 0; i < repeat_count; i++) {\n robust_path += c;\n if (robust_path.size() >= 200) break;\n }\n if (robust_path.size() >= 200) break;\n }\n \n // If we still have room, add some extra redundancy\n if (robust_path.size() < 180 && shortest_path.size() > 0) {\n // Add the last few moves again for extra robustness\n int extra_len = min(200 - (int)robust_path.size(), (int)shortest_path.size());\n for (int i = max(0, (int)shortest_path.size() - extra_len); i < shortest_path.size(); i++) {\n robust_path += shortest_path[i];\n }\n }\n \n cout << robust_path << endl;\n \n return 0;\n}","ahc010":"#include \nusing namespace std;\n\n// Directions: 0=left, 1=up, 2=right, 3=down\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Connection table: to[tile_type][entry_direction] = exit_direction\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// Get tile type after rotation\nint rotate_tile(int tile, int rotations) {\n rotations %= 4;\n if (tile <= 3) { // curved tiles\n return (tile + rotations) % 4;\n } else if (tile <= 5) { // double curved tiles\n return tile + (rotations % 2);\n } else { // straight tiles\n return tile + (rotations % 2);\n }\n}\n\nstruct Grid {\n int tiles[30][30]; // Original tile types\n int rotations[30][30]; // Current rotations (0-3)\n \n Grid() {}\n \n Grid(const vector& input) {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n tiles[i][j] = input[i][j] - '0';\n rotations[i][j] = 0;\n }\n }\n }\n \n int get_tile_type(int i, int j) const {\n return rotate_tile(tiles[i][j], rotations[i][j]);\n }\n \n // Calculate loop length starting from (i,j) with entry direction d\n int calculate_loop_length(int si, int sj, int sd) const {\n int i = si, j = sj, d = sd;\n int length = 0;\n \n do {\n int tile_type = get_tile_type(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0;\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n \n d = (d2 + 2) % 4;\n length++;\n \n if (length > 900) return 0; // Prevent infinite loops\n \n } while (!(i == si && j == sj && d == sd));\n \n return length;\n }\n \n // Find top two loop lengths\n pair find_top_loops() const {\n vector loops;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n loops.push_back(length);\n }\n }\n }\n }\n \n sort(loops.rbegin(), loops.rend());\n \n if (loops.size() < 2) return {0, 0};\n \n // Remove duplicates (same loop might be found from multiple starting points)\n vector unique_loops;\n for (int i = 0; i < loops.size(); i++) {\n bool is_duplicate = false;\n for (int j = 0; j < i; j++) {\n if (loops[i] == loops[j]) {\n is_duplicate = true;\n break;\n }\n }\n if (!is_duplicate) {\n unique_loops.push_back(loops[i]);\n }\n }\n \n if (unique_loops.size() < 2) return {0, 0};\n \n return {unique_loops[0], unique_loops[1]};\n }\n \n long long calculate_score() const {\n auto [l1, l2] = find_top_loops();\n return (long long)l1 * l2;\n }\n \n void randomize_rotations() {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rotations[i][j] = dis(gen);\n }\n }\n }\n \n void hill_climb(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n if (new_score > best_score) {\n best_score = new_score;\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n void simulated_annealing(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n uniform_real_distribution<> prob(0.0, 1.0);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n double temperature = 1.0 - (double)it / iterations;\n double acceptance = exp((new_score - best_score) / max(1.0, temperature * 1000.0));\n \n if (new_score > best_score || prob(gen) < acceptance) {\n best_score = max(best_score, new_score);\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n string get_output() const {\n string result;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n result += to_string(rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector input(30);\n for (int i = 0; i < 30; i++) {\n cin >> input[i];\n }\n \n Grid grid(input);\n \n // Try multiple random initializations and keep the best\n long long best_score = 0;\n string best_output;\n \n for (int attempt = 0; attempt < 10; attempt++) {\n grid.randomize_rotations();\n \n // Hill climbing\n grid.hill_climb(10000);\n \n // Simulated annealing\n grid.simulated_annealing(50000);\n \n long long current_score = grid.calculate_score();\n if (current_score > best_score) {\n best_score = current_score;\n best_output = grid.get_output();\n }\n }\n \n cout << best_output << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct UnionFind {\n vector p, r;\n UnionFind(int n) : p(n), r(n, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (r[x] < r[y]) p[x] = y;\n else { p[y] = x; if (r[x] == r[y]) r[x]++; }\n }\n};\n\nclass Solver {\npublic:\n Solver(int n, int t, const vector& grid) : N(n), T(t) {\n board.resize(N, vector(N, 0));\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n char ch = grid[r][c];\n if (ch >= '0' && ch <= '9') {\n board[r][c] = ch - '0';\n } else {\n board[r][c] = 10 + (ch - 'a');\n }\n if (board[r][c] == 0) {\n empty_r = r;\n empty_c = c;\n }\n }\n }\n }\n\n string solve() {\n auto start_time = chrono::high_resolution_clock::now();\n \n // Phase 1: Simulated Annealing with E_correct heuristic\n vector> best_E_board = board;\n int best_E_score = calculate_E_score(best_E_board);\n string best_E_path = \"\";\n\n vector> best_S_board = board;\n int best_S_score = calculate_S_score(best_S_board);\n string best_S_path = \"\";\n\n vector> current_board = board;\n int current_er = empty_r, current_ec = empty_c;\n int current_E_score = best_E_score;\n string current_path = \"\";\n\n mt19937 rng(random_device{}());\n uniform_real_distribution dist(0.0, 1.0);\n\n double temp = 10.0;\n double cooling_rate = 0.99995;\n long long iter = 0;\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.5) break;\n\n int move_len = 15 + rng() % 20;\n \n vector> candidate_board = current_board;\n int candidate_er = current_er, candidate_ec = current_ec;\n string candidate_moves = generate_random_moves(move_len, candidate_board, candidate_er, candidate_ec);\n\n int candidate_E_score = calculate_E_score(candidate_board);\n\n int delta_E = candidate_E_score - current_E_score;\n\n if (delta_E > 0 || exp(delta_E / temp) > dist(rng)) {\n current_board = candidate_board;\n current_er = candidate_er;\n current_ec = candidate_ec;\n current_E_score = candidate_E_score;\n current_path += candidate_moves;\n }\n\n if (candidate_E_score > best_E_score) {\n best_E_score = candidate_E_score;\n best_E_board = candidate_board;\n best_E_path = current_path;\n }\n \n if (iter % 500 == 0) {\n int current_S_score = calculate_S_score(current_board);\n if (current_S_score > best_S_score) {\n best_S_score = current_S_score;\n best_S_board = current_board;\n best_S_path = current_path;\n }\n }\n \n temp *= cooling_rate;\n iter++;\n }\n \n // Ensure we have the best S found so far\n if (calculate_S_score(best_E_board) > best_S_score) {\n best_S_score = calculate_S_score(best_E_board);\n best_S_board = best_E_board;\n best_S_path = best_E_path;\n }\n\n // Phase 2: Local Refinement with S_score heuristic\n vector> lr_board = best_S_board;\n int lr_er = -1, lr_ec = -1;\n for(int r=0; r(current_time - start_time).count();\n if (elapsed > 2.9) break;\n\n char best_move = ' ';\n int best_delta_S = -1;\n\n vector moves;\n if (lr_er > 0) moves.push_back('D');\n if (lr_er < N - 1) moves.push_back('U');\n if (lr_ec > 0) moves.push_back('R');\n if (lr_ec < N - 1) moves.push_back('L');\n \n for(char m : moves) {\n vector> temp_board = lr_board;\n int temp_er = lr_er, temp_ec = lr_ec;\n apply_move(m, temp_board, temp_er, temp_ec);\n \n int new_S = calculate_S_score(temp_board);\n int delta_S = new_S - current_S;\n \n if (delta_S > best_delta_S) {\n best_delta_S = delta_S;\n best_move = m;\n }\n }\n\n if (best_delta_S > 0) {\n apply_move(best_move, lr_board, lr_er, lr_ec);\n lr_path.push_back(best_move);\n current_S += best_delta_S;\n } else {\n break; // Local optimum\n }\n }\n\n string final_path = best_S_path + lr_path;\n if (final_path.length() > T) {\n final_path = final_path.substr(0, T);\n }\n\n return final_path;\n }\n\nprivate:\n int N, T;\n vector> board;\n int empty_r, empty_c;\n\n int calculate_E_score(const vector>& b) {\n int score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N - 1; ++c) {\n if ((b[r][c] & 4) && (b[r][c+1] & 1)) score++;\n }\n }\n for (int r = 0; r < N - 1; ++r) {\n for (int c = 0; c < N; ++c) {\n if ((b[r][c] & 8) && (b[r+1][c] & 2)) score++;\n }\n }\n return score;\n }\n\n int calculate_S_score(const vector>& b) {\n UnionFind uf(N * N);\n vector num_edges(N * N, 0);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N - 1; ++c) {\n if (b[r][c] != 0 && b[r][c+1] != 0 && (b[r][c] & 4) && (b[r][c+1] & 1)) {\n int u = r * N + c;\n int v = r * N + (c + 1);\n int root = uf.find(u);\n uf.unite(u, v);\n int new_root = uf.find(u);\n if (new_root != root) num_edges[new_root] += num_edges[root] + 1;\n else num_edges[new_root]++;\n }\n }\n }\n for (int r = 0; r < N - 1; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] != 0 && b[r+1][c] != 0 && (b[r][c] & 8) && (b[r+1][c] & 2)) {\n int u = r * N + c;\n int v = (r + 1) * N + c;\n int root = uf.find(u);\n uf.unite(u, v);\n int new_root = uf.find(u);\n if (new_root != root) num_edges[new_root] += num_edges[root] + 1;\n else num_edges[new_root]++;\n }\n }\n }\n\n int max_S = 0;\n vector component_size(N * N, 0);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] != 0) {\n int node = r * N + c;\n component_size[uf.find(node)]++;\n }\n }\n }\n \n for (int i = 0; i < N * N; ++i) {\n if (component_size[i] > 0) {\n int root = uf.find(i);\n if (num_edges[root] == component_size[root] - 1) {\n max_S = max(max_S, component_size[root]);\n }\n }\n }\n return max_S;\n }\n\n void apply_move(char m, vector>& b, int& er, int& ec) {\n int tr = er, tc = ec;\n if (m == 'U') tr++;\n else if (m == 'D') tr--;\n else if (m == 'L') tc++;\n else if (m == 'R') tc--;\n\n if (tr >= 0 && tr < N && tc >= 0 && tc < N) {\n swap(b[er][ec], b[tr][tc]);\n er = tr;\n ec = tc;\n }\n }\n\n string generate_random_moves(int len, vector>& b, int& er, int& ec) {\n string moves;\n mt19937 rng(random_device{}());\n for (int i = 0; i < len; ++i) {\n vector possible_moves;\n if (er > 0) possible_moves.push_back('D');\n if (er < N - 1) possible_moves.push_back('U');\n if (ec > 0) possible_moves.push_back('R');\n if (ec < N - 1) possible_moves.push_back('L');\n\n if (!possible_moves.empty()) {\n char m = possible_moves[rng() % possible_moves.size()];\n moves += m;\n apply_move(m, b, er, ec);\n }\n }\n return moves;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, T;\n cin >> N >> T;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n Solver solver(N, T, grid);\n string ans = solver.solve();\n cout << ans << endl;\n\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global random number generator\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nconst long double EPS = 1e-9;\nconst long long COORD_MAX = 1e9;\n\nstruct Point {\n long long x, y;\n Point(long long x = 0, long long y = 0) : x(x), y(y) {}\n};\n\nstruct Line {\n Point p1, p2;\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\nlong double dist_sq(const Point& a, const Point& b) {\n long long dx = a.x - b.x;\n long long dy = a.y - b.y;\n return (long double)dx * dx + (long double)dy * dy;\n}\n\n// Returns 1 if a is on the left of line p1p2, -1 if on the right, 0 if on the line\nint get_side(const Point& a, const Point& p1, const Point& p2) {\n long double val = (long double)(p2.x - p1.x) * (p1.y - a.y) - (long double)(p2.y - p1.y) * (p1.x - a.x);\n if (val > EPS) return 1;\n if (val < -EPS) return -1;\n return 0;\n}\n\n// Finds k-nearest neighbors of target_idx from active_indices\n// Returns a vector of indices of the neighbors\nvector find_k_nearest(int target_idx, const vector& points, const vector& active_indices, int k) {\n vector> dists;\n const Point& target = points[target_idx];\n for (int idx : active_indices) {\n if (idx == target_idx) continue;\n dists.push_back({dist_sq(target, points[idx]), idx});\n }\n \n sort(dists.begin(), dists.end());\n\n vector neighbors;\n for (int i = 0; i < min(k, (int)dists.size()); ++i) {\n neighbors.push_back(dists[i].second);\n }\n return neighbors;\n}\n\n// Finds the closest pair of points between two sets\n// Returns a pair of indices {idx_from_set1, idx_from_set2}\npair find_closest_pair(const vector& points, const vector& set1, const vector& set2) {\n long double min_dist = 1e30;\n pair closest_pair = {-1, -1};\n\n for (int idx1 : set1) {\n for (int idx2 : set2) {\n long double d = dist_sq(points[idx1], points[idx2]);\n if (d < min_dist) {\n min_dist = d;\n closest_pair = {idx1, idx2};\n }\n }\n }\n return closest_pair;\n}\n\n// Constructs two integer points defining the perpendicular bisector of p1p2\n// Returns false if no such integer points exist (when dx, dy have different parity)\nbool construct_bisector(const Point& p1, const Point& p2, Line& cut_line) {\n long long dx = p2.x - p1.x;\n long long dy = p2.y - p1.y;\n\n // Perpendicular direction vector\n long long perp_dx = -dy;\n long long perp_dy = dx;\n\n // Check if bisector can have integer points\n // This is true if and only if dx and dy have the same parity\n if ((dx % 2 + 2) % 2 != (dy % 2 + 2) % 2) {\n return false;\n }\n\n // Midpoint\n long double mid_x = (long double)(p1.x + p2.x) / 2.0;\n long double mid_y = (long double)(p1.y + p2.y) / 2.0;\n \n // A point on the line is (mid_x, mid_y). Direction is (perp_dx, perp_dy).\n // We need to find two integer points on this line.\n // A point P(t) on the line is P(t) = (mid_x, mid_y) + t * (perp_dx, perp_dy).\n // We need P(t) to have integer coordinates.\n // P_x = (p1.x+p2.x)/2 + t*perp_dx\n // P_y = (p1.y+p2.y)/2 + t*perp_dy\n \n // Since dx, dy have same parity, p1+p2 has even component sums.\n // So (p1.x+p2.x)/2 and (p1.y+p2.y)/2 are integers.\n // We can choose t to be any integer.\n long long t = COORD_MAX / max(abs(perp_dx), abs(perp_dy)) + 1;\n \n Point p_mid = {(p1.x + p2.x) / 2, (p1.y + p2.y) / 2};\n\n cut_line.p1 = {p_mid.x + perp_dx * t, p_mid.y + perp_dy * t};\n cut_line.p2 = {p_mid.x - perp_dx * t, p_mid.y - perp_dy * t};\n \n return true;\n}\n\n// Verifies if a line separates two sets of points without cutting any\nbool verify_cut(const Line& cut, const vector& points, const vector& set1, const vector& set2) {\n if (set1.empty() || set2.empty()) return true;\n\n int side1 = get_side(points[set1[0]], cut.p1, cut.p2);\n if (side1 == 0) return false; // A point is on the line\n\n for (int idx : set1) {\n if (get_side(points[idx], cut.p1, cut.p2) != side1) {\n return false; // Not all points in set1 are on the same side\n }\n }\n\n int side2 = get_side(points[set2[0]], cut.p1, cut.p2);\n if (side2 == 0 || side1 == side2) return false; // Point on line or sets not separated\n\n for (int idx : set2) {\n if (get_side(points[idx], cut.p1, cut.p2) != side2) {\n return false; // Not all points in set2 are on the same side\n }\n }\n\n return true;\n}\n\nvoid solve() {\n int N, K;\n cin >> N >> K;\n K = 100; // K is fixed to 100 as per problem statement\n\n vector a(11);\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n\n vector points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n\n vector is_active(N, true);\n vector cuts;\n int total_needs = accumulate(a.begin(), a.end(), 0);\n\n for (int iter = 0; iter < K; ++iter) {\n if (total_needs == 0) break;\n\n vector active_indices;\n for (int i = 0; i < N; ++i) {\n if (is_active[i]) {\n active_indices.push_back(i);\n }\n }\n if (active_indices.empty()) break;\n\n shuffle(active_indices.begin(), active_indices.end(), rng);\n\n bool found_piece = false;\n vector ds_to_try(10);\n iota(ds_to_try.begin(), ds_to_try.end(), 1);\n shuffle(ds_to_try.begin(), ds_to_try.end(), rng);\n\n for (int d : ds_to_try) {\n if (a[d] == 0) continue;\n\n for (int seed_idx : active_indices) {\n vector neighbors = find_k_nearest(seed_idx, points, active_indices, d - 1);\n if (neighbors.size() < d - 1) continue;\n\n vector group_indices = {seed_idx};\n group_indices.insert(group_indices.end(), neighbors.begin(), neighbors.end());\n \n vector rest_indices;\n for (int idx : active_indices) {\n if (find(group_indices.begin(), group_indices.end(), idx) == group_indices.end()) {\n rest_indices.push_back(idx);\n }\n }\n\n if (rest_indices.empty()) {\n // All remaining strawberries form the last piece\n a[d]--;\n total_needs--;\n for (int idx : group_indices) is_active[idx] = false;\n found_piece = true;\n break;\n }\n\n pair closest = find_closest_pair(points, group_indices, rest_indices);\n \n Line cut;\n if (!construct_bisector(points[closest.first], points[closest.second], cut)) {\n continue; // Cannot define this cut with integer points\n }\n\n if (verify_cut(cut, points, group_indices, rest_indices)) {\n cuts.push_back(cut);\n a[d]--;\n total_needs--;\n for (int idx : group_indices) is_active[idx] = false;\n found_piece = true;\n break;\n }\n }\n if (found_piece) break;\n }\n if (!found_piece) {\n // Can't find any more pieces, stop trying\n break;\n }\n }\n\n cout << cuts.size() << endl;\n for (const auto& cut : cuts) {\n cout << cut.p1.x << \" \" << cut.p1.y << \" \" << cut.p2.x << \" \" << cut.p2.y << \"\\n\";\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\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 bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n Point p1, p2, p3, p4;\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_dots(M);\n set dots;\n map> x_to_ys; // x coordinate -> list of y coordinates with dots\n map> y_to_xs; // y coordinate -> list of x coordinates with dots\n \n for (int i = 0; i < M; i++) {\n cin >> initial_dots[i].x >> initial_dots[i].y;\n dots.insert(initial_dots[i]);\n x_to_ys[initial_dots[i].x].push_back(initial_dots[i].y);\n y_to_xs[initial_dots[i].y].push_back(initial_dots[i].x);\n }\n\n // Sort the coordinate lists for binary search\n for (auto& [x, ys] : x_to_ys) {\n sort(ys.begin(), ys.end());\n }\n for (auto& [y, xs] : y_to_xs) {\n sort(xs.begin(), xs.end());\n }\n\n int c = (N - 1) / 2;\n auto weight = [c](int x, int y) {\n return (x - c) * (x - c) + (y - c) * (y - c) + 1;\n };\n\n // Create list of all empty points sorted by weight (descending)\n vector> empty_points;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (dots.find({x, y}) == dots.end()) {\n empty_points.push_back({weight(x, y), {x, y}});\n }\n }\n }\n sort(empty_points.rbegin(), empty_points.rend());\n\n vector operations;\n\n // Track used segments to avoid overlaps\n set> used_segments;\n\n // Helper function to check if a line segment is already used\n auto is_segment_used = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Vertical segment\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n if (used_segments.count({x1, y, x1, y+1}) > 0 ||\n used_segments.count({x1, y+1, x1, y}) > 0) {\n return true;\n }\n }\n } else if (y1 == y2) {\n // Horizontal segment\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n if (used_segments.count({x, y1, x+1, y1}) > 0 ||\n used_segments.count({x+1, y1, x, y1}) > 0) {\n return true;\n }\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n // Diagonal segment (45 degrees)\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n if (used_segments.count({x, y, x+dx, y+dy}) > 0 ||\n used_segments.count({x+dx, y+dy, x, y}) > 0) {\n return true;\n }\n x += dx;\n y += dy;\n }\n }\n return false;\n };\n\n // Helper function to add segments to used set\n auto add_segments = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Vertical segment\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n used_segments.insert({x1, y, x1, y+1});\n used_segments.insert({x1, y+1, x1, y});\n }\n } else if (y1 == y2) {\n // Horizontal segment\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n used_segments.insert({x, y1, x+1, y1});\n used_segments.insert({x+1, y1, x, y1});\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n // Diagonal segment (45 degrees)\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n used_segments.insert({x, y, x+dx, y+dy});\n used_segments.insert({x+dx, y+dy, x, y});\n x += dx;\n y += dy;\n }\n }\n };\n\n // Helper function to check if a point has a dot\n auto has_dot = [&dots](int x, int y) {\n return dots.count({x, y}) > 0;\n };\n\n mt19937 rng(42); // Fixed seed for reproducibility\n\n // Try to place dots in order of decreasing weight\n for (const auto& [w, p] : empty_points) {\n bool found = false;\n Rectangle rect;\n\n // Try axis-aligned rectangles first, then 45-degree\n vector> search_order;\n \n // For axis-aligned, prioritize rectangles that go outward from center\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend()); // Farther from center first\n \n for (const auto& [dist, x2] : search_order) {\n // Check if there are dots at (p.x, y2), (x2, y2), (x2, p.y) for some y2\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n // Find common y coordinate that has dots at both x positions\n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n // Check if there's a dot at (x2, y2)\n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n // Check if there's a dot at (x2, p.y)\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n // Check if no other dots are on the perimeter\n bool has_other_dots = false;\n \n // Check horizontal edges (excluding corners)\n int x_start = min(p.x, x2);\n int x_end = max(p.x, x2);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p.y) || has_dot(x, y2)) {\n has_other_dots = true;\n break;\n }\n }\n \n // Check vertical edges (excluding corners)\n if (!has_other_dots) {\n int y_start = min(p.y, y2);\n int y_end = max(p.y, y2);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p.x, y) || has_dot(x2, y)) {\n has_other_dots = true;\n break;\n }\n }\n }\n\n if (!has_other_dots) {\n // Check if segments overlap\n if (!is_segment_used(p.x, p.y, p.x, y2) &&\n !is_segment_used(p.x, y2, x2, y2) &&\n !is_segment_used(x2, y2, x2, p.y) &&\n !is_segment_used(x2, p.y, p.x, p.y)) {\n \n rect = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n found = true;\n break;\n }\n }\n }\n }\n }\n if (found) break;\n }\n\n // Try 45-degree inclined rectangles (diamonds)\n if (!found) {\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) { // Limit search space\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n // Try all 4 orientations of diamond\n vector> diamonds = {\n {{p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}}}, // top vertex\n {{p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}}}, // bottom vertex\n {{p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}}}, // left vertex\n {{p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}}} // right vertex\n };\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n const Point& p2 = diamond[1];\n const Point& p3 = diamond[2];\n const Point& p4 = diamond[3];\n \n if (p3.x >= 0 && p3.x < N && p3.y >= 0 && p3.y < N &&\n p2.x >= 0 && p2.x < N && p2.y >= 0 && p2.y < N &&\n p4.x >= 0 && p4.x < N && p4.y >= 0 && p4.y < N) {\n \n if (has_dot(p2.x, p2.y) && has_dot(p3.x, p3.y) && has_dot(p4.x, p4.y)) {\n bool has_other_dots = false;\n \n // Check edges (excluding vertices)\n for (int i = 1; i < d; i++) {\n if (has_dot(p.x + i, p.y - i) || has_dot(p.x + i, p.y - d - i) ||\n has_dot(p.x - i, p.y - d - i) || has_dot(p.x - i, p.y - i)) {\n has_other_dots = true;\n break;\n }\n }\n\n if (!has_other_dots) {\n if (!is_segment_used(p.x, p.y, p2.x, p2.y) &&\n !is_segment_used(p2.x, p2.y, p3.x, p3.y) &&\n !is_segment_used(p3.x, p3.y, p4.x, p4.y) &&\n !is_segment_used(p4.x, p4.y, p.x, p.y)) {\n \n rect = {p, p2, p3, p4};\n found = true;\n break;\n }\n }\n }\n }\n }\n if (found) break;\n }\n }\n\n if (found) {\n operations.push_back(rect);\n dots.insert(p);\n \n // Update coordinate mappings\n x_to_ys[p.x].push_back(p.y);\n y_to_xs[p.y].push_back(p.x);\n sort(x_to_ys[p.x].begin(), x_to_ys[p.x].end());\n sort(y_to_xs[p.y].begin(), y_to_xs[p.y].end());\n \n // Add the segments to used set\n add_segments(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);\n add_segments(rect.p2.x, rect.p2.y, rect.p3.x, rect.p3.y);\n add_segments(rect.p3.x, rect.p3.y, rect.p4.x, rect.p4.y);\n add_segments(rect.p4.x, rect.p4.y, rect.p1.x, rect.p1.y);\n }\n\n // Early exit if we've placed enough dots\n if (operations.size() >= 2000) break;\n }\n\n cout << operations.size() << \"\\n\";\n for (const auto& rect : operations) {\n cout << rect.p1.x << \" \" << rect.p1.y << \" \";\n cout << rect.p2.x << \" \" << rect.p2.y << \" \";\n cout << rect.p3.x << \" \" << rect.p3.y << \" \";\n cout << rect.p4.x << \" \" << rect.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nconst int N = 10;\nconst int DIRECTIONS = 4;\nconst int EMPTY = 0;\n\nstruct Cell {\n int flavor;\n int x, y;\n Cell() : flavor(EMPTY), x(-1), y(-1) {}\n Cell(int f, int x, int y) : flavor(f), x(x), y(y) {}\n};\n\nclass Grid {\nprivate:\n vector> grid;\n vector candies;\n int total_candies;\n \npublic:\n Grid() : grid(N, vector(N, EMPTY)), total_candies(0) {}\n \n void add_candy(int flavor, int x, int y) {\n grid[x][y] = flavor;\n candies.emplace_back(flavor, x, y);\n total_candies++;\n }\n \n void tilt(char direction) {\n vector> new_grid(N, vector(N, EMPTY));\n vector new_candies;\n \n int dx = 0, dy = 0;\n if (direction == 'F') dx = -1;\n else if (direction == 'B') dx = 1;\n else if (direction == 'L') dy = -1;\n else if (direction == 'R') dy = 1;\n \n for (const auto& candy : candies) {\n int x = candy.x;\n int y = candy.y;\n \n // Move until hitting edge or another candy\n while (true) {\n int nx = x + dx;\n int ny = y + dy;\n \n if (nx < 0 || nx >= N || ny < 0 || ny >= N || new_grid[nx][ny] != EMPTY) {\n break;\n }\n \n x = nx;\n y = ny;\n }\n \n new_grid[x][y] = candy.flavor;\n new_candies.emplace_back(candy.flavor, x, y);\n }\n \n grid = move(new_grid);\n candies = move(new_candies);\n }\n \n double calculate_score() const {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n vector flavor_counts(4, 0);\n \n for (const auto& candy : candies) {\n flavor_counts[candy.flavor]++;\n }\n \n for (const auto& candy : candies) {\n if (visited[candy.x][candy.y]) continue;\n \n queue> q;\n q.push({candy.x, candy.y});\n visited[candy.x][candy.y] = true;\n \n int flavor = grid[candy.x][candy.y];\n int size = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n component_sizes.push_back(size);\n }\n \n double sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += size * size;\n }\n \n double denominator = 0;\n for (int i = 1; i <= 3; i++) {\n denominator += flavor_counts[i] * flavor_counts[i];\n }\n \n return sum_squares / denominator;\n }\n \n int count_components(int flavor) const {\n vector> visited(N, vector(N, false));\n int count = 0;\n \n for (const auto& candy : candies) {\n if (candy.flavor != flavor || visited[candy.x][candy.y]) continue;\n \n queue> q;\n q.push({candy.x, candy.y});\n visited[candy.x][candy.y] = true;\n count++;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n \n return count;\n }\n \n int get_largest_component_size(int flavor) const {\n vector> visited(N, vector(N, false));\n int max_size = 0;\n \n for (const auto& candy : candies) {\n if (candy.flavor != flavor || visited[candy.x][candy.y]) continue;\n \n queue> q;\n q.push({candy.x, candy.y});\n visited[candy.x][candy.y] = true;\n \n int size = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n max_size = max(max_size, size);\n }\n \n return max_size;\n }\n \n int get_flavor_count(int flavor) const {\n return count_if(candies.begin(), candies.end(), \n [flavor](const Cell& c) { return c.flavor == flavor; });\n }\n \n void print() const {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j] << \" \";\n }\n cout << endl;\n }\n }\n \n const vector& get_candies() const { return candies; }\n const vector>& get_grid() const { return grid; }\n};\n\nclass Strategy {\nprotected:\n vector flavors;\n Grid grid;\n int turn;\n \npublic:\n Strategy(const vector& f) : flavors(f), turn(0) {}\n \n virtual ~Strategy() {}\n \n virtual char decide_tilt(int p) = 0;\n \n void add_candy(int p) {\n // Convert p to (x, y) coordinates\n int empty_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool is_empty = true;\n for (const auto& candy : grid.get_candies()) {\n if (candy.x == i && candy.y == j) {\n is_empty = false;\n break;\n }\n }\n if (is_empty) {\n empty_count++;\n if (empty_count == p) {\n grid.add_candy(flavors[turn], i, j);\n turn++;\n return;\n }\n }\n }\n }\n }\n \n void apply_tilt(char direction) {\n grid.tilt(direction);\n }\n \n const Grid& get_grid() const { return grid; }\n};\n\nclass CornerStrategy : public Strategy {\nprivate:\n vector corner_directions;\n \npublic:\n CornerStrategy(const vector& f) : Strategy(f) {\n corner_directions = {'L', 'R', 'B'};\n }\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n if (turn <= 1) {\n return 'F';\n }\n \n int flavor = flavors[turn-1];\n return corner_directions[flavor-1];\n }\n};\n\nclass HybridStrategy : public Strategy {\nprivate:\n vector corner_directions;\n vector> density_map;\n \npublic:\n HybridStrategy(const vector& f) : Strategy(f) {\n corner_directions = {'L', 'R', 'B'};\n density_map.resize(3, vector(N*N, 0.0));\n }\n \n void update_density_map() {\n for (int flavor = 1; flavor <= 3; flavor++) {\n fill(density_map[flavor-1].begin(), density_map[flavor-1].end(), 0.0);\n \n for (const auto& candy : grid.get_candies()) {\n if (candy.flavor == flavor) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n double dist = sqrt(pow(candy.x - i, 2) + pow(candy.y - j, 2));\n density_map[flavor-1][i*N + j] += 1.0 / (1.0 + dist);\n }\n }\n }\n }\n }\n }\n \n double evaluate_tilt(char direction) {\n Grid test_grid = grid;\n test_grid.tilt(direction);\n \n int flavor = flavors[turn-1];\n \n // Find the position of the new candy after tilt\n int new_x = -1, new_y = -1;\n for (const auto& candy : test_grid.get_candies()) {\n // This is a simplification - in practice, we need to track which candy is new\n if (candy.flavor == flavor) {\n new_x = candy.x;\n new_y = candy.y;\n }\n }\n \n if (new_x == -1) return 0.0;\n \n // Calculate score based on connectivity and corner distance\n double score = 0.0;\n \n // Component connectivity score\n int components = test_grid.count_components(flavor);\n score += 100.0 / components;\n \n // Largest component size\n int largest = test_grid.get_largest_component_size(flavor);\n score += largest * 10.0;\n \n // Distance to corner\n char corner_dir = corner_directions[flavor-1];\n int target_x = (corner_dir == 'F') ? 0 : (corner_dir == 'B') ? N-1 : -1;\n int target_y = (corner_dir == 'L') ? 0 : (corner_dir == 'R') ? N-1 : -1;\n \n double dist = 0.0;\n if (target_x != -1) dist += abs(new_x - target_x);\n if (target_y != -1) dist += abs(new_y - target_y);\n score += 50.0 / (1.0 + dist);\n \n // Density score\n update_density_map();\n if (new_x >= 0 && new_x < N && new_y >= 0 && new_y < N) {\n score += density_map[flavor-1][new_x*N + new_y] * 20.0;\n }\n \n return score;\n }\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n if (turn <= 30) {\n return corner_directions[flavors[turn-1]-1];\n }\n \n char best_dir = 'F';\n double best_score = -1e9;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n double score = evaluate_tilt(dir);\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n HybridStrategy strategy(flavors);\n \n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n \n if (t < 99) {\n char tilt = strategy.decide_tilt(p);\n strategy.apply_tilt(tilt);\n cout << tilt << endl;\n cout.flush();\n } else {\n strategy.decide_tilt(p);\n }\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Choose N based on epsilon\n // For low epsilon, we can use smaller N\n // For high epsilon, we need larger N for better distinguishability\n int N;\n if (epsilon < 0.05) {\n N = min(15, max(4, M/2 + 4));\n } else if (epsilon < 0.1) {\n N = min(20, max(4, M/2 + 6));\n } else if (epsilon < 0.2) {\n N = min(30, max(4, M/2 + 10));\n } else if (epsilon < 0.3) {\n N = min(40, max(4, M/2 + 15));\n } else {\n N = min(50, max(4, M/2 + 20));\n }\n \n // Ensure N is at least enough to distinguish M graphs\n int max_edges = N * (N - 1) / 2;\n while (max_edges < M * 3 && N < 100) {\n N++;\n max_edges = N * (N - 1) / 2;\n }\n \n cout << N << endl;\n cout.flush();\n \n // Generate M graphs with different edge counts\n // Distribute edge counts evenly across the range\n int total_possible_edges = N * (N - 1) / 2;\n int min_edges_per_graph = max(0, (total_possible_edges - M * 10) / 2);\n int max_edges_per_graph = min(total_possible_edges, min_edges_per_graph + M * 20);\n \n vector edge_counts(M);\n for (int i = 0; i < M; i++) {\n edge_counts[i] = min_edges_per_graph + i * (max_edges_per_graph - min_edges_per_graph) / max(1, M - 1);\n edge_counts[i] = min(edge_counts[i], total_possible_edges);\n }\n \n // Generate and output graphs\n for (int i = 0; i < M; i++) {\n string graph(total_possible_edges, '0');\n int edges_to_add = edge_counts[i];\n \n // Add edges systematically to ensure good distribution\n for (int j = 0; j < edges_to_add && j < total_possible_edges; j++) {\n graph[j] = '1';\n }\n \n // Shuffle the edges a bit to avoid too much structure\n random_device rd;\n mt19937 g(42 + i); // Fixed seed for reproducibility\n shuffle(graph.begin(), graph.begin() + min(edges_to_add, total_possible_edges), g);\n \n cout << graph << endl;\n }\n cout.flush();\n \n // Process queries\n for (int query = 0; query < 100; query++) {\n string H;\n cin >> H;\n \n int observed_edges = count(H.begin(), H.end(), '1');\n \n // Find the most likely original graph\n // For each possible original edge count, calculate expected observed edges\n int best_idx = 0;\n double best_prob = -1;\n \n for (int i = 0; i < M; i++) {\n int original_edges = edge_counts[i];\n int missing_edges = total_possible_edges - original_edges;\n \n // Expected observed edges = original_edges * (1-\u03b5) + missing_edges * \u03b5\n double expected_observed = original_edges * (1 - epsilon) + missing_edges * epsilon;\n \n // Calculate probability (using normal approximation)\n double variance = total_possible_edges * epsilon * (1 - epsilon);\n double std_dev = sqrt(variance);\n \n // Probability density at observed value\n double prob = exp(-(observed_edges - expected_observed) * (observed_edges - expected_observed) / (2 * variance));\n \n if (prob > best_prob) {\n best_prob = prob;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Edge {\n int u, v, w, id;\n double x1, y1, x2, y2;\n int importance;\n int day;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n \n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--;\n edges[i].v--;\n edges[i].id = i;\n }\n \n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Assign coordinates to edges\n for (auto &e : edges) {\n e.x1 = coords[e.u].first;\n e.y1 = coords[e.u].second;\n e.x2 = coords[e.v].first;\n e.y2 = coords[e.v].second;\n }\n \n // Compute betweenness centrality for each edge\n vector betweenness(M, 0);\n const int SAMPLES = min(N, 50);\n vector sampled_vertices(N);\n iota(sampled_vertices.begin(), sampled_vertices.end(), 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(sampled_vertices.begin(), sampled_vertices.end(), rng);\n sampled_vertices.resize(SAMPLES);\n \n for (int s : sampled_vertices) {\n vector dist(N, 1e9);\n vector prev(N, -1);\n priority_queue, vector>, greater<>> pq;\n dist[s] = 0;\n pq.push({0, s});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n int v = -1;\n if (e.u == u) v = e.v;\n else if (e.v == u) v = e.u;\n else continue;\n if (dist[v] > dist[u] + e.w) {\n dist[v] = dist[u] + e.w;\n prev[v] = u;\n pq.push({dist[v], v});\n }\n }\n }\n \n for (int t = 0; t < N; ++t) {\n if (t == s) continue;\n for (int v = t; v != s && prev[v] != -1; v = prev[v]) {\n int u = prev[v];\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n betweenness[eid]++;\n break;\n }\n }\n }\n }\n }\n \n // Compute importance: betweenness + inverse weight\n for (int i = 0; i < M; ++i) {\n edges[i].importance = betweenness[i] * 1000000 / (edges[i].w + 1);\n }\n \n // Sort edges by importance (descending)\n sort(edges.begin(), edges.end(), [](const Edge &a, const Edge &b) {\n return a.importance > b.importance;\n });\n \n // Priority queue to keep track of day loads\n priority_queue> pq; // {current_sum, day}\n vector day_sum(D, 0);\n for (int d = 0; d < D; ++d) {\n pq.push({0, d});\n }\n \n // Assign edges to days, trying to balance the importance\n vector> day_edges(D);\n for (auto &e : edges) {\n auto [sum, day] = pq.top(); pq.pop();\n day_edges[day].push_back(e.id);\n day_sum[day] += e.importance;\n pq.push({day_sum[day], day});\n }\n \n // Prepare output\n vector res(M);\n for (int d = 0; d < D; ++d) {\n for (int eid : day_edges[d]) {\n res[eid] = d + 1;\n }\n }\n \n // Output the results\n for (int i = 0; i < M; ++i) {\n if (i) cout << \" \";\n cout << res[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Coord {\n int x, y, z;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n\n vector f[2], r[2];\n for (int i = 0; i < 2; ++i) {\n f[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> f[i][j];\n }\n r[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> r[i][j];\n }\n }\n\n // Use 3D boolean arrays to represent the objects\n // grid_1, grid_2, grid_intersect\n vector>> grid_1(D, vector>(D, vector(D, false)));\n vector>> grid_2(D, vector>(D, vector(D, false)));\n vector>> grid_intersect(D, vector>(D, vector(D, false)));\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n if (f[0][z][x] == '1' && r[0][z][y] == '1') {\n grid_1[x][y][z] = true;\n }\n if (f[1][z][x] == '1' && r[1][z][y] == '1') {\n grid_2[x][y][z] = true;\n }\n if (grid_1[x][y][z] && grid_2[x][y][z]) {\n grid_intersect[x][y][z] = true;\n }\n }\n }\n }\n\n vector>> visited(D, vector>(D, vector(D, false)));\n vector b_1(D * D * D, 0);\n vector b_2(D * D * D, 0);\n\n int block_id = 0;\n auto get_idx = [D](int x, int y, int z) { return x * D * D + y * D + z; };\n\n // Helper function to perform BFS/DFS and create a block\n auto process_block = [&](const vector>>& target_grid, bool is_shared) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (target_grid[x][y][z] && !visited[x][y][z]) {\n vector component;\n queue q;\n q.push({x, y, z});\n visited[x][y][z] = true;\n\n while (!q.empty()) {\n Coord curr = q.front();\n q.pop();\n component.push_back(curr);\n\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n\n for (int i = 0; i < 6; ++i) {\n int nx = curr.x + dx[i];\n int ny = curr.y + dy[i];\n int nz = curr.z + dz[i];\n\n if (0 <= nx && nx < D && 0 <= ny && ny < D && 0 <= nz && nz < D) {\n if (target_grid[nx][ny][nz] && !visited[nx][ny][nz]) {\n visited[nx][ny][nz] = true;\n q.push({nx, ny, nz});\n }\n }\n }\n }\n }\n if (!component.empty()) {\n block_id++;\n for (const auto& cell : component) {\n b_1[get_idx(cell.x, cell.y, cell.z)] = block_id;\n if (is_shared) {\n b_2[get_idx(cell.x, cell.y, cell.z)] = block_id;\n }\n }\n component.clear();\n }\n }\n }\n }\n };\n\n // 1. Process shared blocks (intersection)\n process_block(grid_intersect, true);\n\n // 2. Process unique blocks for object 1\n process_block(grid_1, false);\n\n // 3. Process unique blocks for object 2\n process_block(grid_2, false);\n\n\n cout << block_id << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_1[i];\n }\n cout << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_2[i];\n }\n cout << endl;\n\n return 0;\n}","ahc020":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n double x, y;\n Point(double x=0, double y=0) : x(x), y(y) {}\n double dist(const Point& p) const {\n return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));\n }\n int rounded_dist(const Point& p) const {\n return (int)round(dist(p));\n }\n};\n\nstruct Edge {\n int u, v, w;\n double d;\n Edge(int u=0, int v=0, int w=0, double d=0) : u(u), v(v), w(w), d(d) {}\n bool operator<(const Edge& e) const {\n return w < e.w;\n }\n};\n\nstruct DSU {\n vector parent, sz;\n DSU(int n) : parent(n), sz(n, 1) {\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 same(int x, int y) { return find(x) == find(y); }\n bool unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return false;\n if (sz[x] < sz[y]) swap(x, y);\n parent[y] = x;\n sz[x] += sz[y];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n \n vector stations(N);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M);\n for (int j = 0; j < M; ++j) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n double d = stations[u].dist(stations[v]);\n edges[j] = Edge(u, v, w, d);\n }\n \n vector residents(K);\n for (int k = 0; k < K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // Build initial network - MST with bias towards shorter edges\n vector sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end());\n \n DSU dsu(N);\n vector edge_used(M, false);\n int edge_count = 0;\n \n // Modified MST - prioritize edges connected to node 0\n vector priority_edges, normal_edges;\n for (auto &e : sorted_edges) {\n if (e.u == 0 || e.v == 0) {\n priority_edges.push_back(e);\n } else {\n normal_edges.push_back(e);\n }\n }\n \n // First, connect node 0 to some nodes\n for (auto &e : priority_edges) {\n if (dsu.unite(e.u, e.v)) {\n for (int j = 0; j < M; ++j) {\n if (edges[j].u == e.u && edges[j].v == e.v && edges[j].w == e.w) {\n edge_used[j] = true;\n break;\n }\n }\n edge_count++;\n if (edge_count == N-1) break;\n }\n }\n \n // Then complete the MST\n for (auto &e : normal_edges) {\n if (dsu.unite(e.u, e.v)) {\n for (int j = 0; j < M; ++j) {\n if (edges[j].u == e.u && edges[j].v == e.v && edges[j].w == e.w) {\n edge_used[j] = true;\n break;\n }\n }\n edge_count++;\n if (edge_count == N-1) break;\n }\n }\n \n // Iteratively add beneficial edges\n vector connected(N, false);\n connected[0] = true;\n queue q;\n q.push(0);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int j = 0; j < M; ++j) {\n if (edge_used[j]) {\n int v = edges[j].u == u ? edges[j].v : (edges[j].v == u ? edges[j].u : -1);\n if (v != -1 && !connected[v]) {\n connected[v] = true;\n q.push(v);\n }\n }\n }\n }\n \n // Try to add edges that improve coverage efficiency\n for (int iter = 0; iter < 3; ++iter) {\n vector> candidates;\n \n for (int j = 0; j < M; ++j) {\n if (!edge_used[j]) {\n int u = edges[j].u, v = edges[j].v;\n if (connected[u] && !connected[v]) {\n // Check if this edge provides good value\n double value = 0.0;\n for (int k = 0; k < min(100, K); ++k) {\n double d_to_u = residents[k].dist(stations[u]);\n double d_to_v = residents[k].dist(stations[v]);\n if (d_to_v < d_to_u) {\n value += (d_to_u - d_to_v) / edges[j].w;\n }\n }\n candidates.push_back({value, j});\n }\n }\n }\n \n sort(candidates.rbegin(), candidates.rend());\n \n for (auto &[val, j] : candidates) {\n if (edge_used[j]) continue;\n int u = edges[j].u, v = edges[j].v;\n if (connected[u] && !connected[v]) {\n edge_used[j] = true;\n connected[v] = true;\n q.push(v);\n \n // Update connected components\n while (!q.empty()) {\n int cur = q.front();\n q.pop();\n for (int jj = 0; jj < M; ++jj) {\n if (edge_used[jj]) {\n int nxt = edges[jj].u == cur ? edges[jj].v : \n (edges[jj].v == cur ? edges[jj].u : -1);\n if (nxt != -1 && !connected[nxt]) {\n connected[nxt] = true;\n q.push(nxt);\n }\n }\n }\n }\n break;\n }\n }\n }\n \n // Calculate connected stations\n vector connected_stations;\n for (int i = 0; i < N; ++i) {\n if (connected[i]) connected_stations.push_back(i);\n }\n \n // Set broadcast powers\n vector P(N, 0);\n \n // Greedy covering - set minimum necessary power for each station\n for (int i : connected_stations) {\n double max_dist = 0;\n for (int k = 0; k < K; ++k) {\n double d = residents[k].dist(stations[i]);\n if (d > max_dist) {\n max_dist = d;\n }\n }\n P[i] = min(5000, max(0, (int)round(max_dist)));\n }\n \n // Optimize powers to reduce redundancy\n vector covered(K, false);\n for (int i : connected_stations) {\n for (int k = 0; k < K; ++k) {\n if (residents[k].dist(stations[i]) <= P[i] + 0.5) {\n covered[k] = true;\n }\n }\n }\n \n // Try to reduce powers while maintaining coverage\n for (int i : connected_stations) {\n if (P[i] == 0) continue;\n \n vector temp_covered = covered;\n int uncovered_count = 0;\n \n // Temporarily set power to 0\n for (int k = 0; k < K; ++k) {\n if (covered[k] && residents[k].dist(stations[i]) <= P[i] + 0.5) {\n bool covered_by_other = false;\n for (int j : connected_stations) {\n if (j != i && residents[k].dist(stations[j]) <= P[j] + 0.5) {\n covered_by_other = true;\n break;\n }\n }\n if (!covered_by_other) {\n uncovered_count++;\n }\n }\n }\n \n // If many residents rely on this station, reduce power gradually\n if (uncovered_count > 0) {\n int min_needed = 0;\n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n double d = residents[k].dist(stations[i]);\n min_needed = max(min_needed, (int)ceil(d));\n }\n }\n P[i] = min(P[i], min(5000, max(0, min_needed)));\n }\n }\n \n // Final coverage check and adjustment\n covered.assign(K, false);\n for (int i : connected_stations) {\n for (int k = 0; k < K; ++k) {\n if (residents[k].dist(stations[i]) <= P[i] + 0.5) {\n covered[k] = true;\n }\n }\n }\n \n // If any residents are uncovered, increase necessary powers\n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n double min_dist = 1e9;\n int best_station = -1;\n for (int i : connected_stations) {\n double d = residents[k].dist(stations[i]);\n if (d < min_dist) {\n min_dist = d;\n best_station = i;\n }\n }\n if (best_station != -1) {\n P[best_station] = min(5000, max(P[best_station], (int)ceil(min_dist)));\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; ++j) {\n if (j) cout << \" \";\n cout << (edge_used[j] ? 1 : 0);\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconstexpr int N = 30;\n\n// pyramid values\nint a[N][N];\n// list of operations: x y x' y'\nvector> ops;\n\n// bubble down the element currently at (x,y)\nvoid bubble_down(int x, int y) {\n while (true) {\n int cx = x + 1;\n if (cx >= N) break; // leaf\n int cy_left = y;\n int cy_right = y + 1;\n\n // choose the smaller child\n int child_x = cx, child_y = cy_left;\n int child_val = a[child_x][child_y];\n if (a[cx][cy_right] < child_val) {\n child_y = cy_right;\n child_val = a[cx][cy_right];\n }\n\n // heap condition satisfied?\n if (a[x][y] <= child_val) break;\n\n // perform swap\n ops.push_back({x, y, child_x, child_y});\n swap(a[x][y], a[child_x][child_y]);\n\n // continue from the child position\n x = child_x;\n y = child_y;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // read input\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> a[x][y];\n }\n }\n\n // bottom\u2011up heapify\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n bubble_down(x, y);\n }\n }\n\n // safety check (should always hold)\n assert(ops.size() <= 10000);\n\n // output\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op[0] << \" \" << op[1] << \" \"\n << op[2] << \" \" << op[3] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \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 D, N;\n if (!(cin >> D >> N)) {\n return 0;\n }\n\n const int entrance_r = 0;\n const int entrance_c = (D - 1) / 2;\n\n vector> grid(D, vector(D, 0));\n vector> placeable_cells;\n\n // Mark obstacles\n for (int k = 0; k < N; ++k) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = -1; // -1 for obstacle\n }\n\n // Collect all placeable cells\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (grid[i][j] != -1 && !(i == entrance_r && j == entrance_c)) {\n placeable_cells.emplace_back(i, j);\n }\n }\n }\n\n // Sort placeable cells by distance from entrance, then by coordinates\n // dist(i,j) = i + abs(j - entrance_c)\n auto dist_cmp = [entrance_c](const pair& a, const pair& b) {\n int dist_a = a.first + abs(a.second - entrance_c);\n int dist_b = b.first + abs(b.second - entrance_c);\n if (dist_a != dist_b) {\n return dist_a < dist_b; // Sort by distance ascending\n }\n if (a.first != b.first) {\n return a.first < b.first;\n }\n return a.second < b.second;\n };\n sort(placeable_cells.begin(), placeable_cells.end(), dist_cmp);\n\n int M = placeable_cells.size();\n vector is_taken(M, false);\n\n // --- Placement Phase ---\n for (int d = 0; d < M; ++d) {\n int t;\n cin >> t;\n\n int target_idx = t;\n int offset = 0;\n int chosen_idx = -1;\n\n while (chosen_idx == -1) {\n int check_idx1 = target_idx - offset;\n if (check_idx1 >= 0 && !is_taken[check_idx1]) {\n chosen_idx = check_idx1;\n break;\n }\n int check_idx2 = target_idx + offset;\n if (check_idx2 < M && !is_taken[check_idx2]) {\n chosen_idx = check_idx2;\n break;\n }\n offset++;\n }\n\n auto [r, c] = placeable_cells[chosen_idx];\n grid[r][c] = t;\n is_taken[chosen_idx] = true;\n\n cout << r << \" \" << c << \"\\n\";\n cout.flush();\n }\n\n // --- Retrieval Phase ---\n vector> retrieval_order;\n int remaining = M;\n while (remaining > 0) {\n // BFS to find reachable containers\n vector> visited(D, vector(D, false));\n queue> q;\n q.push({entrance_r, entrance_c});\n visited[entrance_r][entrance_c] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n const int drs[4] = {-1, 1, 0, 0};\n const int dcs[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + drs[k];\n int nc = c + dcs[k];\n\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !visited[nr][nc] && grid[nr][nc] != -1) {\n visited[nr][nc] = true;\n if (grid[nr][nc] > 0) {\n reachable_containers.push_back({nr, nc});\n }\n q.push({nr, nc});\n }\n }\n }\n\n // Find min priority container among reachable\n int min_p = M; // Max priority is M-1\n pair min_coord = {-1, -1};\n for (const auto& coord : reachable_containers) {\n if (grid[coord.first][coord.second] < min_p) {\n min_p = grid[coord.first][coord.second];\n min_coord = coord;\n }\n }\n\n retrieval_order.push_back(min_coord);\n grid[min_coord.first][min_coord.second] = 0; // Mark as empty\n remaining--;\n }\n\n // --- Output Retrieval Order ---\n for (const auto& coord : retrieval_order) {\n cout << coord.first << \" \" << coord.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n }\n }\n // output exactly the same grid\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << grid[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct SetInfo {\n long long total_score;\n int id;\n};\n\n// Operator for min-heap\nbool operator<(const SetInfo& a, const SetInfo& b) {\n return a.total_score > b.total_score;\n}\n\nvoid solve() {\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector rank_scores(N, 0);\n\n // --- Phase 1: Learning with Random Comparisons ---\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n int base_comp = Q / N;\n int rem_comp = Q % N;\n\n for (int i = 0; i < N; ++i) {\n int num_comp = base_comp + (i < rem_comp ? 1 : 0);\n for (int k = 0; k < num_comp; ++k) {\n int j;\n do {\n j = rng() % N;\n } while (i == j);\n\n cout << \"1 1 \" << i << \" \" << j << endl;\n cout.flush();\n\n char res;\n cin >> res;\n if (res == '>') {\n rank_scores[i] += 2;\n rank_scores[j] -= 2;\n } else if (res == '<') {\n rank_scores[i] -= 2;\n rank_scores[j] += 2;\n }\n }\n }\n\n // --- Phase 2: Partitioning using LPT heuristic ---\n vector> items;\n for (int i = 0; i < N; ++i) {\n items.emplace_back(rank_scores[i], i);\n }\n sort(items.begin(), items.end(), greater>());\n\n priority_queue pq;\n for (int i = 0; i < D; ++i) {\n pq.push({0, i});\n }\n\n vector assignments(N);\n vector> sets(D);\n vector set_scores(D, 0);\n\n for (const auto& item : items) {\n int item_id = item.second;\n long long score = item.first;\n\n SetInfo current_set = pq.top();\n pq.pop();\n\n assignments[item_id] = current_set.id;\n sets[current_set.id].push_back(item_id);\n set_scores[current_set.id] += score;\n\n pq.push({current_set.total_score + score, current_set.id});\n }\n\n // --- Phase 3: Local Search to improve balance ---\n const int LOCAL_SEARCH_LIMIT = N * D;\n for (int iter = 0; iter < LOCAL_SEARCH_LIMIT; ++iter) {\n int max_set_id = -1, min_set_id = -1;\n long long max_score = -1, min_score = 1e18;\n for (int i = 0; i < D; ++i) {\n if (set_scores[i] > max_score) {\n max_score = set_scores[i];\n max_set_id = i;\n }\n if (set_scores[i] < min_score) {\n min_score = set_scores[i];\n min_set_id = i;\n }\n }\n\n if (max_set_id == -1 || min_set_id == -1 || max_set_id == min_set_id) break;\n if (max_score - min_score < 2) break;\n\n int item_to_move_from_max = -1, item_to_move_from_min = -1;\n long long max_item_score = -1, min_item_score = 1e18;\n\n for (int item_id : sets[max_set_id]) {\n if (rank_scores[item_id] > max_item_score) {\n max_item_score = rank_scores[item_id];\n item_to_move_from_max = item_id;\n }\n }\n\n for (int item_id : sets[min_set_id]) {\n if (rank_scores[item_id] < min_item_score) {\n min_item_score = rank_scores[item_id];\n item_to_move_from_min = item_id;\n }\n }\n \n if (item_to_move_from_max == -1 || item_to_move_from_min == -1) break;\n if (max_item_score <= min_item_score) break;\n\n long long old_sum_sq = max_score * max_score + min_score * min_score;\n long long new_max_score = max_score - max_item_score + min_item_score;\n long long new_min_score = min_score - min_item_score + max_item_score;\n long long new_sum_sq = new_max_score * new_max_score + new_min_score * new_min_score;\n\n if (new_sum_sq < old_sum_sq) {\n // Perform swap\n assignments[item_to_move_from_max] = min_set_id;\n assignments[item_to_move_from_min] = max_set_id;\n \n set_scores[max_set_id] = new_max_score;\n set_scores[min_set_id] = new_min_score;\n\n // Update sets vectors\n auto& max_set_vec = sets[max_set_id];\n max_set_vec.erase(find(max_set_vec.begin(), max_set_vec.end(), item_to_move_from_max));\n max_set_vec.push_back(item_to_move_from_min);\n\n auto& min_set_vec = sets[min_set_id];\n min_set_vec.erase(find(min_set_vec.begin(), min_set_vec.end(), item_to_move_from_min));\n min_set_vec.push_back(item_to_move_from_max);\n } else {\n break;\n }\n }\n\n // --- Final Output ---\n for (int i = 0; i < N; ++i) {\n if (i > 0) cout << \" \";\n cout << assignments[i];\n }\n cout << endl;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct Box {\n int stack_idx;\n int pos; // position from bottom (0-indexed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int n = 200, m = 10;\n int boxes_per_stack = n / m; // 20\n \n vector> stacks(m);\n vector box_info(n + 1);\n \n // Read input\n for (int i = 0; i < m; i++) {\n stacks[i].resize(boxes_per_stack);\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_info[stacks[i][j]] = {i, j};\n }\n }\n \n vector> operations;\n \n // Process boxes in order\n for (int target = 1; target <= n; target++) {\n int stack_idx = box_info[target].stack_idx;\n int pos = box_info[target].pos;\n \n // Check if box is already at top\n if (pos == stacks[stack_idx].size() - 1) {\n // Just carry it out\n operations.emplace_back(target, 0);\n stacks[stack_idx].pop_back();\n \n // Update positions of remaining boxes in this stack\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n } else {\n // Need to move boxes above it\n // Choose destination stack (prefer empty or small stacks)\n int dest_stack = 0;\n int min_size = stacks[0].size();\n for (int i = 1; i < m; i++) {\n if (stacks[i].size() < min_size) {\n min_size = stacks[i].size();\n dest_stack = i;\n }\n }\n \n // If the smallest stack is the current one, choose the next smallest\n if (dest_stack == stack_idx) {\n for (int i = 0; i < m; i++) {\n if (i != stack_idx && stacks[i].size() <= min_size + 5) {\n dest_stack = i;\n break;\n }\n }\n }\n \n // Move the target box and everything above it\n operations.emplace_back(target, dest_stack + 1); // 1-indexed for output\n \n // Extract the boxes to move\n vector to_move(stacks[stack_idx].begin() + pos, stacks[stack_idx].end());\n stacks[stack_idx].resize(pos);\n \n // Add to destination stack\n stacks[dest_stack].insert(stacks[dest_stack].end(), to_move.begin(), to_move.end());\n \n // Update positions\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n \n // Now carry out the target box (it should be at top of dest_stack)\n operations.emplace_back(target, 0);\n stacks[dest_stack].pop_back();\n \n // Update positions again\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n }\n }\n \n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n \n return 0;\n}","ahc027":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct State {\n int i, j;\n double priority;\n State(int i_, int j_, double p_) : i(i_), j(j_), priority(p_) {}\n bool operator<(const State& other) const {\n return priority < other.priority;\n }\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 }\n \n vector> visited(N, vector(N));\n string route;\n \n // Priority-based DFS\n auto dfs = [&](auto self, int i, int j) -> void {\n visited[i][j] = true;\n \n // Collect neighbors with priorities\n priority_queue pq;\n const int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};\n const string dir_str = \"RDLU\";\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (visited[ni][nj]) continue;\n \n // Check if wall exists\n bool wall = false;\n if (dirs[dir][0] == 0) { // horizontal move\n wall = (v[i][min(j, nj)] == '1');\n } else { // vertical move\n wall = (h[min(i, ni)][j] == '1');\n }\n \n if (!wall) {\n // Priority based on d[i,j] and distance\n double priority = d[ni][nj] * 1.0 / (1.0 + abs(ni - N/2) + abs(nj - N/2));\n pq.emplace(ni, nj, priority);\n }\n }\n \n // Visit neighbors in priority order\n while (!pq.empty()) {\n State s = pq.top();\n pq.pop();\n if (!visited[s.i][s.j]) {\n // Find direction to this neighbor\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n if (ni == s.i && nj == s.j) {\n route += dir_str[dir];\n self(self, ni, nj);\n route += dir_str[(dir + 2) % 4];\n break;\n }\n }\n }\n }\n };\n \n dfs(dfs, 0, 0);\n \n // Add extra cycles around high-value cells\n vector>> high_value_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n high_value_cells.emplace_back(d[i][j], make_pair(i,j));\n }\n }\n sort(high_value_cells.rbegin(), high_value_cells.rend());\n \n // For top high-value cells, try to add small cycles\n int extra_cycles = min(10, (int)high_value_cells.size());\n for (int idx = 0; idx < extra_cycles; idx++) {\n int i = high_value_cells[idx].second.first;\n int j = high_value_cells[idx].second.second;\n \n // Try to find a small loop around this cell\n vector local_route;\n const int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};\n const string dir_str = \"RDLU\";\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n bool wall = false;\n if (dirs[dir][0] == 0) {\n wall = (v[i][min(j, nj)] == '1');\n } else {\n wall = (h[min(i, ni)][j] == '1');\n }\n \n if (!wall) {\n local_route.push_back(dir_str[dir]);\n // Try to return from opposite direction\n int oi = i + dirs[(dir+2)%4][0];\n int oj = j + dirs[(dir+2)%4][1];\n if (oi >= 0 && oi < N && oj >= 0 && oj < N) {\n bool wall2 = false;\n if (dirs[(dir+2)%4][0] == 0) {\n wall2 = (v[i][min(j, oj)] == '1');\n } else {\n wall2 = (h[min(i, oi)][j] == '1');\n }\n if (!wall2) {\n local_route.push_back(dir_str[(dir+2)%4]);\n if (route.length() + local_route.size() <= 100000) {\n route += local_route[0];\n route += local_route[1];\n }\n break;\n }\n }\n }\n }\n }\n }\n \n cout << route << endl;\n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct State {\n int i, j;\n int cost;\n int string_pos;\n string path_str;\n \n bool operator<(const State& other) const {\n return cost > other.cost;\n }\n};\n\nstruct PathInfo {\n vector> path;\n int total_cost;\n string substring;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n int si, sj;\n cin >> N >> M >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n vector targets(M);\n for (int k = 0; k < M; k++) {\n cin >> targets[k];\n }\n \n // Precompute letter positions for quick access\n vector>> letter_positions(26);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n letter_positions[grid[i][j] - 'A'].emplace_back(i, j);\n }\n }\n \n // Precompute Manhattan distances between all positions\n vector> dist(N*N, vector(N*N));\n for (int i1 = 0; i1 < N; i1++) {\n for (int j1 = 0; j1 < N; j1++) {\n for (int i2 = 0; i2 < N; i2++) {\n for (int j2 = 0; j2 < N; j2++) {\n dist[i1*N + j1][i2*N + j2] = abs(i1 - i2) + abs(j1 - j2);\n }\n }\n }\n }\n \n // For each target string, precompute multiple possible paths\n vector> string_paths(M);\n random_device rd;\n mt19937 rng(rd());\n \n for (int k = 0; k < M; k++) {\n const string& target = targets[k];\n char first_char = target[0];\n \n // Try different starting positions\n vector> start_positions;\n if (letter_positions[first_char - 'A'].size() <= 10) {\n start_positions = letter_positions[first_char - 'A'];\n } else {\n // Randomly sample if too many\n uniform_int_distribution dist(0, letter_positions[first_char - 'A'].size() - 1);\n for (int i = 0; i < 10; i++) {\n start_positions.push_back(letter_positions[first_char - 'A'][dist(rng)]);\n }\n }\n \n for (auto [start_i, start_j] : start_positions) {\n // A* search to find path for this string\n priority_queue pq;\n unordered_set visited;\n \n pq.push({start_i, start_j, 0, 0, string(1, grid[start_i][start_j])});\n \n while (!pq.empty() && pq.size() < 10000) {\n State curr = pq.top();\n pq.pop();\n \n if (curr.string_pos == target.length()) {\n // Found a complete path - reconstruct it\n vector> path;\n string path_str = curr.path_str;\n // For simplicity, we'll use a greedy reconstruction\n // In practice, we'd need to store parent pointers\n break;\n }\n \n // Expand neighbors\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (abs(di) + abs(dj) != 1) continue;\n \n int ni = curr.i + di;\n int nj = curr.j + dj;\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n \n char next_char = grid[ni][nj];\n int new_pos = curr.string_pos;\n \n if (new_pos < target.length() && next_char == target[new_pos]) {\n new_pos++;\n }\n \n int new_cost = curr.cost + 1;\n string new_path_str = curr.path_str + next_char;\n \n // Simple heuristic: remaining characters needed\n int heuristic = target.length() - new_pos;\n \n pq.push({ni, nj, new_cost + heuristic, new_pos, new_path_str});\n }\n }\n }\n }\n }\n \n // Greedy solution with overlap consideration\n vector> result;\n result.emplace_back(si, sj);\n \n vector collected(M, false);\n int collected_count = 0;\n \n string current_substring;\n \n while (collected_count < M && result.size() < 4900) {\n int best_k = -1;\n int best_cost = 1e9;\n int best_start_idx = -1;\n string best_overlap_prefix;\n string best_overlap_suffix;\n \n // Check each uncollected string\n for (int k = 0; k < M; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Check if we can start spelling this string from current position\n // by checking overlaps with current suffix\n \n for (int overlap_len = min(4, (int)current_substring.length()); overlap_len >= 0; overlap_len--) {\n if (current_substring.length() >= overlap_len) {\n string suffix = current_substring.substr(current_substring.length() - overlap_len);\n \n if (target.substr(0, overlap_len) == suffix) {\n // We have an overlap!\n string remaining = target.substr(overlap_len);\n \n // Estimate cost to spell remaining part\n int estimated_cost = 0;\n for (char c : remaining) {\n estimated_cost += 3; // Rough estimate\n }\n \n if (estimated_cost < best_cost) {\n best_cost = estimated_cost;\n best_k = k;\n best_start_idx = -1;\n best_overlap_prefix = suffix;\n best_overlap_suffix = remaining;\n }\n }\n }\n }\n \n // Also consider starting fresh from nearby positions\n char first_char = target[0];\n for (auto [pi, pj] : letter_positions[first_char - 'A']) {\n int move_cost = dist[result.back().first * N + result.back().second][pi * N + pj];\n int total_cost = move_cost + target.length() * 2; // Rough estimate\n \n if (total_cost < best_cost) {\n best_cost = total_cost;\n best_k = k;\n best_start_idx = pi * N + pj;\n best_overlap_prefix = \"\";\n best_overlap_suffix = target;\n }\n }\n }\n \n if (best_k == -1) break;\n \n // Spell the chosen string\n const string& target = targets[best_k];\n \n if (best_start_idx == -1 && !best_overlap_suffix.empty()) {\n // Continue from current position using overlap\n for (char c : best_overlap_suffix) {\n // Find nearest cell with this character\n int best_dist = 1e9;\n int best_i = -1, best_j = -1;\n \n for (auto [pi, pj] : letter_positions[c - 'A']) {\n int d = dist[result.back().first * N + result.back().second][pi * N + pj];\n if (d < best_dist) {\n best_dist = d;\n best_i = pi;\n best_j = pj;\n }\n }\n \n if (best_i != -1) {\n result.emplace_back(best_i, best_j);\n }\n }\n } else {\n // Move to starting position and spell the string\n if (best_start_idx != -1) {\n int ti = best_start_idx / N;\n int tj = best_start_idx % N;\n result.emplace_back(ti, tj);\n \n // Continue spelling the rest of the string\n for (int pos = 1; pos < target.length(); pos++) {\n char c = target[pos];\n int best_dist = 1e9;\n int best_i = -1, best_j = -1;\n \n for (auto [pi, pj] : letter_positions[c - 'A']) {\n int d = dist[result.back().first * N + result.back().second][pi * N + pj];\n if (d < best_dist) {\n best_dist = d;\n best_i = pi;\n best_j = pj;\n }\n }\n \n if (best_i != -1) {\n result.emplace_back(best_i, best_j);\n }\n }\n }\n }\n \n collected[best_k] = true;\n collected_count++;\n \n // Update current substring (keep last up to 4 characters)\n string new_s = \"\";\n for (int i = max(0, (int)result.size() - 20); i < result.size(); i++) {\n new_s += grid[result[i].first][result[i].second];\n }\n current_substring = new_s;\n }\n \n // Output result\n for (auto [i, j] : result) {\n cout << i << \" \" << j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct OilField {\n int size;\n vector> cells;\n};\n\nstruct Solver {\n int N, M;\n double eps;\n vector fields;\n vector> reserves;\n vector> known;\n vector> estimates;\n int ops_used;\n double total_cost;\n mt19937 rng;\n \n Solver(int N, int M, double eps, const vector& fields) \n : N(N), M(M), eps(eps), fields(fields), ops_used(0), total_cost(0), \n reserves(N, vector(N, -1)), known(N, vector(N, false)),\n estimates(N, vector(N, 0.0)) {\n rng.seed(random_device{}());\n }\n \n void flush() {\n cout << flush;\n }\n \n void query_drill(int i, int j) {\n ops_used++;\n total_cost += 1.0;\n cout << \"q 1 \" << i << \" \" << j << endl;\n flush();\n string resp;\n cin >> resp;\n int val = stoi(resp);\n reserves[i][j] = val;\n known[i][j] = true;\n estimates[i][j] = val;\n }\n \n double query_divine(const vector>& cells) {\n ops_used++;\n int k = cells.size();\n total_cost += 1.0 / sqrt(k);\n cout << \"q \" << k;\n for (auto [i,j] : cells) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush();\n string resp;\n cin >> resp;\n return stod(resp);\n }\n \n bool guess_answer(const vector>& answer) {\n ops_used++;\n total_cost += 1.0;\n cout << \"a \" << answer.size();\n for (auto [i,j] : answer) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush();\n int resp;\n cin >> resp;\n return resp == 1;\n }\n \n vector> get_region_cells(int si, int sj, int ei, int ej) {\n vector> cells;\n for (int i = si; i <= ei; i++) {\n for (int j = sj; j <= ej; j++) {\n cells.emplace_back(i, j);\n }\n }\n return cells;\n }\n \n void initial_coarse_scan() {\n // Use large divine queries to get rough estimates\n int block_size = max(2, N/3);\n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n int ei = min(N-1, bi + block_size - 1);\n int ej = min(N-1, bj + block_size - 1);\n auto cells = get_region_cells(bi, bj, ei, ej);\n if (cells.size() >= 2) {\n double val = query_divine(cells);\n double avg = val / cells.size();\n for (auto [i,j] : cells) {\n estimates[i][j] = avg;\n }\n }\n }\n }\n }\n \n void refine_promising_areas() {\n // Focus on areas with higher estimates\n vector> candidates;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!known[i][j]) {\n candidates.emplace_back(estimates[i][j], i, j);\n }\n }\n }\n sort(candidates.rbegin(), candidates.rend());\n \n int drill_limit = min(N*N/4, (int)candidates.size());\n for (int idx = 0; idx < drill_limit && ops_used < N*N; idx++) {\n auto [_, i, j] = candidates[idx];\n if (!known[i][j]) {\n query_drill(i, j);\n }\n }\n }\n \n bool can_place_field(int field_id, int si, int sj) {\n const auto& field = fields[field_id];\n for (auto [di, dj] : field.cells) {\n int i = si + di, j = sj + dj;\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n }\n return true;\n }\n \n void pattern_matching() {\n // Try to match oil field patterns with known oil locations\n vector> has_oil(N, vector(N, false));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known[i][j] && reserves[i][j] > 0) {\n has_oil[i][j] = true;\n }\n }\n }\n \n // For each known oil location, try to place oil fields\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (has_oil[i][j]) {\n for (int fid = 0; fid < M; fid++) {\n const auto& field = fields[fid];\n // Try different positions where this field could cover (i,j)\n for (auto [di, dj] : field.cells) {\n int si = i - di, sj = j - dj;\n if (can_place_field(fid, si, sj)) {\n // Check if this placement is consistent\n bool consistent = true;\n for (auto [fi, fj] : field.cells) {\n int ti = si + fi, tj = sj + fj;\n if (known[ti][tj] && reserves[ti][tj] == 0) {\n consistent = false;\n break;\n }\n }\n if (consistent) {\n for (auto [fi, fj] : field.cells) {\n int ti = si + fi, tj = sj + fj;\n estimates[ti][tj] = max(estimates[ti][tj], 0.5);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n \n void verify_and_explore() {\n // Drill some uncertain squares based on updated estimates\n vector> uncertain;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!known[i][j]) {\n uncertain.emplace_back(estimates[i][j], i, j);\n }\n }\n }\n sort(uncertain.rbegin(), uncertain.rend());\n \n int verify_limit = min(N*N/6, (int)uncertain.size());\n for (int idx = 0; idx < verify_limit && ops_used < 2*N*N - 10; idx++) {\n auto [_, i, j] = uncertain[idx];\n if (!known[i][j] && estimates[i][j] > 0.1) {\n query_drill(i, j);\n }\n }\n }\n \n vector> get_answer() {\n vector> answer;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known[i][j] && reserves[i][j] > 0) {\n answer.emplace_back(i, j);\n } else if (!known[i][j] && estimates[i][j] > 0.3) {\n answer.emplace_back(i, j);\n }\n }\n }\n return answer;\n }\n \n void solve() {\n initial_coarse_scan();\n refine_promising_areas();\n pattern_matching();\n verify_and_explore();\n \n auto answer = get_answer();\n if (guess_answer(answer)) {\n return;\n }\n \n // If failed, do more drilling and try again\n int remaining_ops = 2*N*N - ops_used;\n for (int i = 0; i < N && remaining_ops > 0; i++) {\n for (int j = 0; j < N && remaining_ops > 0; j++) {\n if (!known[i][j] && estimates[i][j] > 0.2) {\n query_drill(i, j);\n remaining_ops--;\n }\n }\n }\n \n answer = get_answer();\n guess_answer(answer);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n vector fields(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n fields[k].size = d;\n fields[k].cells.resize(d);\n for (int i = 0; i < d; i++) {\n cin >> fields[k].cells[i].first >> fields[k].cells[i].second;\n }\n }\n \n Solver solver(N, M, eps, fields);\n solver.solve();\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n \n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> a[d][k];\n }\n }\n \n // Strategy: vertical strips with adaptive widths\n // Track previous widths to minimize partition changes\n vector prev_widths(N, W / N);\n \n for (int d = 0; d < D; d++) {\n vector widths(N);\n \n // Calculate minimum widths to meet area requirements\n vector min_widths(N);\n int total_min_width = 0;\n for (int k = 0; k < N; k++) {\n min_widths[k] = (a[d][k] + W - 1) / W; // ceil(a[d][k] / W)\n total_min_width += min_widths[k];\n }\n \n if (total_min_width <= W) {\n // Can meet all area requirements\n widths = min_widths;\n int remaining = W - total_min_width;\n \n // Distribute remaining space proportionally to area requirements\n double total_area = accumulate(a[d].begin(), a[d].end(), 0.0);\n vector area_ratios(N);\n for (int k = 0; k < N; k++) {\n area_ratios[k] = (double)a[d][k] / total_area;\n }\n \n for (int i = 0; i < remaining; i++) {\n // Give extra space to rectangle with highest \"need\" ratio\n double max_ratio = -1;\n int best_k = 0;\n for (int k = 0; k < N; k++) {\n double ratio = (double)(widths[k] + 1) / (area_ratios[k] * W + 1e-9);\n if (ratio > max_ratio) {\n max_ratio = ratio;\n best_k = k;\n }\n }\n widths[best_k]++;\n }\n } else {\n // Need to scale down proportionally\n double scale = (double)W / total_min_width;\n for (int k = 0; k < N; k++) {\n widths[k] = max(1, (int)round(min_widths[k] * scale));\n }\n \n // Adjust to ensure sum equals W\n int current_sum = accumulate(widths.begin(), widths.end(), 0);\n int diff = W - current_sum;\n \n while (diff != 0) {\n if (diff > 0) {\n // Give to rectangle with largest area requirement\n int best_k = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n widths[best_k]++;\n diff--;\n } else {\n // Take from rectangle with smallest area requirement\n int best_k = min_element(a[d].begin(), a[d].end()) - a[d].begin();\n if (widths[best_k] > 1) {\n widths[best_k]--;\n diff++;\n } else {\n break;\n }\n }\n }\n }\n \n // Apply smoothing to reduce partition changes\n if (d > 0) {\n for (int k = 0; k < N; k++) {\n widths[k] = (int)round(0.7 * widths[k] + 0.3 * prev_widths[k]);\n }\n \n // Ensure sum equals W after smoothing\n int current_sum = accumulate(widths.begin(), widths.end(), 0);\n int diff = W - current_sum;\n \n while (diff != 0) {\n if (diff > 0) {\n int best_k = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n widths[best_k]++;\n diff--;\n } else {\n int best_k = min_element(a[d].begin(), a[d].end()) - a[d].begin();\n if (widths[best_k] > 1) {\n widths[best_k]--;\n diff++;\n } else {\n break;\n }\n }\n }\n }\n \n // Output rectangles as vertical strips\n int pos = 0;\n for (int k = 0; k < N; k++) {\n cout << pos << \" 0 \" << pos + widths[k] << \" \" << W << \"\\n\";\n pos += widths[k];\n }\n \n prev_widths = widths;\n }\n \n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic const int MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\n// ---------- board utilities ----------\ninline void addStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int v = board[p + i][q + j] + stamp[m][i][j];\n if (v >= MOD) v -= MOD;\n board[p + i][q + j] = v;\n }\n }\n}\ninline void removeStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int v = board[p + i][q + j] - stamp[m][i][j];\n if (v < 0) v += MOD;\n board[p + i][q + j] = v;\n }\n }\n}\n// profit of applying a stamp on the current board\ninline long long profitStamp(int m, int p, int q,\n const vector>>& stamp,\n const vector>& board)\n{\n long long delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int s = stamp[m][i][j];\n int cur = board[p + i][q + j];\n if (cur + s >= MOD) delta += s - MOD; // overflow \u2192 negative part\n else delta += s;\n }\n }\n return delta;\n}\n\n// ---------- main solving ----------\nint main()\n{\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n vector> a(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> a[i][j];\n\n vector>> stamp(M, vector>(3, vector(3)));\n for (int m = 0; m < M; ++m)\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) cin >> stamp[m][i][j];\n\n const int POS = N - 2; // 7\n vector> positions;\n positions.reserve(POS * POS);\n for (int p = 0; p < POS; ++p)\n for (int q = 0; q < POS; ++q)\n positions.emplace_back(p, q);\n\n mt19937 rng(random_device{}());\n\n vector bestOps;\n long long bestScore = 0;\n for (auto& row : a) bestScore += row[0];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) bestScore += a[i][j]; // initial score\n\n const int ATTEMPTS = 5;\n const int LS_ITER = 2000;\n\n for (int attempt = 0; attempt < ATTEMPTS; ++attempt) {\n // start from the initial board\n vector> board = a;\n vector ops;\n\n // ---- greedy phase ----\n for (int step = 0; step < K; ++step) {\n long long bestDelta = LLONG_MIN;\n Op bestOp{-1, -1, -1};\n\n // random order of stamps and positions for diversity\n vector stampIdx(M);\n iota(stampIdx.begin(), stampIdx.end(), 0);\n shuffle(stampIdx.begin(), stampIdx.end(), rng);\n vector> posShuffle = positions;\n shuffle(posShuffle.begin(), posShuffle.end(), rng);\n\n for (int m : stampIdx) {\n for (auto [p, q] : posShuffle) {\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestOp = {m, p, q};\n }\n }\n }\n if (bestDelta <= 0) break; // no improving operation left\n addStamp(bestOp.m, bestOp.p, bestOp.q, stamp, board);\n ops.push_back(bestOp);\n }\n\n // ---- hill climbing ----\n for (int iter = 0; iter < LS_ITER; ++iter) {\n int choice = rng() % 100;\n if (ops.size() < K && choice < 20) { // try to add\n int m = rng() % M;\n int p = rng() % POS;\n int q = rng() % POS;\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > 0) {\n addStamp(m, p, q, stamp, board);\n ops.emplace_back(m, p, q);\n }\n } else if (!ops.empty() && choice < 30) { // try to remove\n int idx = rng() % ops.size();\n Op cur = ops[idx];\n long long delta = profitStamp(cur.m, cur.p, cur.q, stamp, board);\n if (delta < 0) {\n removeStamp(cur.m, cur.p, cur.q, stamp, board);\n ops.erase(ops.begin() + idx);\n }\n } else { // try to replace\n if (ops.empty()) continue;\n int idx = rng() % ops.size();\n Op cur = ops[idx];\n long long deltaOld = profitStamp(cur.m, cur.p, cur.q, stamp, board);\n int m2 = rng() % M;\n int p2 = rng() % POS;\n int q2 = rng() % POS;\n long long deltaNew = profitStamp(m2, p2, q2, stamp, board);\n if (deltaNew > deltaOld) {\n removeStamp(cur.m, cur.p, cur.q, stamp, board);\n addStamp(m2, p2, q2, stamp, board);\n ops[idx] = {m2, p2, q2};\n }\n }\n }\n\n // evaluate this run\n long long curScore = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) curScore += board[i][j];\n if (curScore > bestScore) {\n bestScore = curScore;\n bestOps = ops;\n }\n }\n\n // ---- output ----\n cout << bestOps.size() << \"\\n\";\n for (auto op : bestOps) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Container {\n int id;\n int arrival_row;\n int arrival_index;\n int target_row;\n int dispatch_order;\n};\n\nstruct Crane {\n int row, col;\n bool carrying;\n int container_id;\n vector commands;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 5;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n // Determine which gate each container should go to\n vector containers(N * N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container_id = A[i][j];\n containers[container_id].id = container_id;\n containers[container_id].arrival_row = i;\n containers[container_id].arrival_index = j;\n containers[container_id].target_row = container_id / N;\n containers[container_id].dispatch_order = container_id % N;\n }\n }\n \n // Sort containers by target gate, then by dispatch order\n sort(containers.begin(), containers.end(), [](const Container& a, const Container& b) {\n if (a.target_row != b.target_row) return a.target_row < b.target_row;\n return a.dispatch_order < b.dispatch_order;\n });\n \n // Initialize cranes\n vector cranes(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].carrying = false;\n cranes[i].container_id = -1;\n }\n \n // Large crane (index 0) will do most of the work\n Crane& large_crane = cranes[0];\n \n // Process containers one by one\n for (const auto& container : containers) {\n // Move large crane to the arrival position\n while (large_crane.row != container.arrival_row) {\n if (large_crane.row < container.arrival_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != container.arrival_index) {\n if (large_crane.col < container.arrival_index) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n } else {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Pick up the container\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to the dispatch position\n while (large_crane.row != container.target_row) {\n if (large_crane.row < container.target_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != N - 1) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n }\n \n // Release the container\n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n // Move back to starting position for next container\n while (large_crane.row != 0) {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n while (large_crane.col != 0) {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Small cranes do minimal work - just stay in place\n for (int i = 1; i < N; i++) {\n // Small cranes can help clear paths by moving away if needed\n // For simplicity, just make them wait\n int max_len = large_crane.commands.size();\n cranes[i].commands.resize(max_len, '.');\n }\n \n // Output the commands\n int max_len = 0;\n for (const auto& crane : cranes) {\n max_len = max(max_len, (int)crane.commands.size());\n }\n \n // Ensure all command strings have the same length\n for (auto& crane : cranes) {\n while (crane.commands.size() < max_len) {\n crane.commands.push_back('.');\n }\n }\n \n for (const auto& crane : cranes) {\n string s(crane.commands.begin(), crane.commands.end());\n cout << s << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int i, j, height;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 20;\n vector> h(N, vector(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n \n vector positive, negative;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n positive.push_back({i, j, h[i][j]});\n } else if (h[i][j] < 0) {\n negative.push_back({i, j, -h[i][j]});\n }\n }\n }\n \n vector operations;\n int ci = 0, cj = 0; // current position\n \n // Function to get path from (ci,cj) to (ti,tj)\n auto get_path = [&](int ti, int tj) {\n vector path;\n while (ci > ti) {\n path.push_back(\"U\");\n ci--;\n }\n while (ci < ti) {\n path.push_back(\"D\");\n ci++;\n }\n while (cj > tj) {\n path.push_back(\"L\");\n cj--;\n }\n while (cj < tj) {\n path.push_back(\"R\");\n cj++;\n }\n return path;\n };\n \n // Greedy matching: transport from closest positive to negative\n while (!positive.empty() && !negative.empty()) {\n // Find closest pair\n int best_dist = 1e9, best_pi = -1, best_ni = -1;\n \n for (int pi = 0; pi < positive.size(); pi++) {\n for (int ni = 0; ni < negative.size(); ni++) {\n int dist = abs(positive[pi].i - negative[ni].i) + \n abs(positive[pi].j - negative[ni].j);\n if (dist < best_dist) {\n best_dist = dist;\n best_pi = pi;\n best_ni = ni;\n }\n }\n }\n \n Cell& pos = positive[best_pi];\n Cell& neg = negative[best_ni];\n \n // Move to positive cell\n auto path_to_pos = get_path(pos.i, pos.j);\n operations.insert(operations.end(), path_to_pos.begin(), path_to_pos.end());\n \n // Load soil\n int load_amount = min(pos.height, neg.height);\n operations.push_back(\"+\" + to_string(load_amount));\n pos.height -= load_amount;\n neg.height -= load_amount;\n \n // Move to negative cell\n auto path_to_neg = get_path(neg.i, neg.j);\n operations.insert(operations.end(), path_to_neg.begin(), path_to_neg.end());\n \n // Unload soil\n operations.push_back(\"-\" + to_string(load_amount));\n \n if (pos.height == 0) {\n positive.erase(positive.begin() + best_pi);\n }\n if (neg.height == 0) {\n negative.erase(negative.begin() + best_ni);\n }\n }\n \n // Output operations (one per line)\n for (const string& op : operations) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n vector values;\n int total_value;\n double score;\n int id;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, T;\n cin >> N >> M >> T;\n \n const int SEED_COUNT = 2 * N * (N - 1);\n vector seeds(SEED_COUNT);\n \n // Read initial seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].id = i;\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Calculate max values for each criterion (for scoring reference)\n vector max_criterion(M, 0);\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n \n for (int turn = 0; turn < T; turn++) {\n // Calculate scores for each seed\n for (int i = 0; i < SEED_COUNT; i++) {\n // Base score is total value\n double base_score = seeds[i].total_value;\n \n // Bonus for being strong in multiple criteria\n double criterion_bonus = 0;\n for (int j = 0; j < M; j++) {\n if (max_criterion[j] > 0) {\n double ratio = (double)seeds[i].values[j] / max_criterion[j];\n criterion_bonus += ratio * ratio * 100; // Square to emphasize strong criteria\n }\n }\n \n // Combine scores with some randomness for diversity\n mt19937 rng(12345 + turn * 1000 + i);\n double random_factor = 0.8 + 0.4 * (rng() % 1000) / 1000.0;\n \n seeds[i].score = base_score * 0.5 + criterion_bonus * 0.5 * random_factor;\n }\n \n // Sort seeds by score\n sort(seeds.begin(), seeds.end(), [](const Seed& a, const Seed& b) {\n return a.score > b.score;\n });\n \n // Select top 36 seeds\n vector selected_ids;\n for (int i = 0; i < N * N; i++) {\n selected_ids.push_back(seeds[i].id);\n }\n \n // Create grid arrangement\n vector> grid(N, vector(N));\n \n // Strategy: Place strongest seeds in center and around it\n // Sort selected seeds by total value for placement\n vector> seed_value_pairs;\n for (int id : selected_ids) {\n seed_value_pairs.emplace_back(seeds[id].total_value, id);\n }\n sort(seed_value_pairs.rbegin(), seed_value_pairs.rend());\n \n // Define positions in order of importance (center first, then spiral out)\n vector> positions;\n int center = N / 2;\n positions.emplace_back(center, center);\n positions.emplace_back(center-1, center);\n positions.emplace_back(center, center-1);\n positions.emplace_back(center-1, center-1);\n positions.emplace_back(center, center+1);\n positions.emplace_back(center+1, center);\n positions.emplace_back(center-1, center+1);\n positions.emplace_back(center+1, center-1);\n positions.emplace_back(center+1, center+1);\n \n // Add remaining positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool found = false;\n for (auto& pos : positions) {\n if (pos.first == i && pos.second == j) {\n found = true;\n break;\n }\n }\n if (!found) {\n positions.emplace_back(i, j);\n }\n }\n }\n \n // Place seeds\n for (size_t i = 0; i < positions.size() && i < seed_value_pairs.size(); i++) {\n grid[positions[i].first][positions[i].second] = seed_value_pairs[i].second;\n }\n \n // Output 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 << \"\\n\";\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Update max criteria\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n }\n \n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n int manhattan(const Point& other) const {\n return abs(x - other.x) + abs(y - other.y);\n }\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector s_grid, t_grid;\n vector initial_pos, target_pos;\n vector tree;\n Point root_pos;\n int V_used;\n \n // State tracking\n vector vertex_positions;\n vector edge_directions; // 0=right, 1=down, 2=left, 3=up\n vector holding_takoyaki;\n \n // Task assignment\n vector> fingertip_paths;\n vector path_progress;\n vector assigned_takoyaki;\n \npublic:\n RoboticArmSolver(int N, int M, int V, const vector& s, const vector& t) \n : N(N), M(M), V(V), s_grid(s), t_grid(t) {\n // Extract initial and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (s[i][j] == '1') initial_pos.emplace_back(i, j);\n if (t[i][j] == '1') target_pos.emplace_back(i, j);\n }\n }\n }\n \n void design_arm() {\n // Design a flexible tree structure\n V_used = min(V, 9); // Use up to 9 vertices for good balance\n tree.resize(V_used);\n \n // Root\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Create a balanced structure\n if (V_used <= 3) {\n // Simple line for small V\n for (int i = 1; i < V_used; i++) {\n tree[i].parent = i - 1;\n tree[i].is_leaf = (i == V_used - 1);\n tree[i].length = max(1, N / 4);\n tree[i - 1].children.push_back(i);\n }\n } else {\n // Star-like structure with some depth\n int main_branches = min(3, V_used - 1);\n \n // Level 1\n for (int i = 1; i <= main_branches; i++) {\n tree[i].parent = 0;\n tree[i].is_leaf = false;\n tree[i].length = max(1, N / 3);\n tree[0].children.push_back(i);\n }\n \n // Level 2 (fingertips)\n int vertex = main_branches + 1;\n for (int parent = 1; parent <= main_branches && vertex < V_used; parent++) {\n int children = min(2, V_used - vertex);\n for (int c = 0; c < children; c++) {\n tree[vertex].parent = parent;\n tree[vertex].is_leaf = true;\n tree[vertex].length = max(1, N / 5);\n tree[parent].children.push_back(vertex);\n vertex++;\n }\n }\n }\n \n // Position root strategically - between centers of mass\n Point center_initial(0, 0), center_target(0, 0);\n for (const auto& p : initial_pos) {\n center_initial.x += p.x;\n center_initial.y += p.y;\n }\n for (const auto& p : target_pos) {\n center_target.x += p.x;\n center_target.y += p.y;\n }\n center_initial.x /= M;\n center_initial.y /= M;\n center_target.x /= M;\n center_target.y /= M;\n \n root_pos.x = max(0, min(N-1, (center_initial.x + center_target.x) / 2));\n root_pos.y = max(0, min(N-1, (center_initial.y + center_target.y) / 2));\n \n // Initialize state\n vertex_positions.resize(V_used);\n edge_directions.assign(V_used, 0); // All initially pointing right\n holding_takoyaki.assign(V_used, false);\n assigned_takoyaki.assign(M, -1);\n \n update_positions();\n }\n \n void update_positions() {\n vertex_positions[0] = root_pos;\n \n for (int i = 1; i < V_used; i++) {\n int parent = tree[i].parent;\n int dir = edge_directions[i];\n int dx[4] = {0, 1, 0, -1}; // right, down, left, up\n int dy[4] = {1, 0, -1, 0};\n \n vertex_positions[i].x = vertex_positions[parent].x + dx[dir] * tree[i].length;\n vertex_positions[i].y = vertex_positions[parent].y + dy[dir] * tree[i].length;\n }\n }\n \n void print_design() {\n cout << V_used << endl;\n for (int i = 1; i < V_used; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n cout << root_pos.x << \" \" << root_pos.y << endl;\n }\n \n void assign_tasks() {\n // Get list of fingertips\n vector fingertips;\n for (int i = 1; i < V_used; i++) {\n if (tree[i].is_leaf) fingertips.push_back(i);\n }\n \n // Calculate assignment costs\n vector> costs(M, vector(fingertips.size()));\n \n for (int i = 0; i < M; i++) {\n for (int j = 0; j < fingertips.size(); j++) {\n int dist_to_initial = vertex_positions[fingertips[j]].manhattan(initial_pos[i]);\n int travel_dist = initial_pos[i].manhattan(target_pos[i]);\n costs[i][j] = dist_to_initial + travel_dist;\n }\n }\n \n // Hungarian-like greedy assignment\n vector used_initial(M, false);\n vector used_fingertips(fingertips.size(), false);\n \n fingertip_paths.resize(fingertips.size());\n path_progress.assign(fingertips.size(), 0);\n \n for (int k = 0; k < min(M, (int)fingertips.size()); k++) {\n int best_i = -1, best_j = -1;\n int min_cost = INT_MAX;\n \n for (int i = 0; i < M; i++) {\n if (!used_initial[i]) {\n for (int j = 0; j < fingertips.size(); j++) {\n if (!used_fingertips[j] && costs[i][j] < min_cost) {\n min_cost = costs[i][j];\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n \n if (best_i != -1 && best_j != -1) {\n used_initial[best_i] = true;\n used_fingertips[best_j] = true;\n assigned_takoyaki[best_i] = fingertips[best_j];\n \n // Create path: current -> initial -> target\n vector path;\n \n // From current position to initial\n Point current = vertex_positions[fingertips[best_j]];\n Point target = initial_pos[best_i];\n \n while (current != target) {\n path.push_back(current);\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n }\n path.push_back(target); // Pickup point\n \n // From initial to target\n current = target;\n target = target_pos[best_i];\n \n while (current != target) {\n path.push_back(current);\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n }\n path.push_back(target); // Dropoff point\n \n fingertip_paths[best_j] = path;\n }\n }\n }\n \n string generate_operation() {\n string op(2 * V_used, '.');\n \n // Find fingertip that needs to move most urgently\n int urgent_fingertip = -1;\n int urgent_path_idx = -1;\n int max_progress_deficit = 0;\n \n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (fingertip_paths[i].empty()) continue;\n \n int total_steps = fingertip_paths[i].size();\n int current_step = path_progress[i];\n int deficit = total_steps - current_step;\n \n if (deficit > max_progress_deficit) {\n max_progress_deficit = deficit;\n urgent_fingertip = assigned_takoyaki[i];\n urgent_path_idx = i;\n }\n }\n \n if (urgent_fingertip == -1) return op;\n \n Point target = fingertip_paths[urgent_path_idx][path_progress[urgent_path_idx]];\n Point current = vertex_positions[urgent_fingertip];\n \n // Check if at target\n if (current == target) {\n // Handle pickup/dropoff\n if (path_progress[urgent_path_idx] == 0) {\n // First position - pickup\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = true;\n } else if (path_progress[urgent_path_idx] == fingertip_paths[urgent_path_idx].size() - 1) {\n // Last position - dropoff\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = false;\n }\n path_progress[urgent_path_idx]++;\n return op;\n }\n \n // Find best move to get closer to target\n int best_dist = current.manhattan(target);\n char best_root_move = '.';\n int best_rotation = 0; // 0=none, 1=L, 2=R\n \n // Try root movements\n int dx[4] = {-1, 1, 0, 0}; // U, D, L, R\n int dy[4] = {0, 0, -1, 1};\n char moves[4] = {'U', 'D', 'L', 'R'};\n \n for (int d = 0; d < 4; d++) {\n Point new_root(root_pos.x + dx[d], root_pos.y + dy[d]);\n if (new_root.x < 0 || new_root.x >= N || new_root.y < 0 || new_root.y >= N) continue;\n \n Point old_root = root_pos;\n root_pos = new_root;\n update_positions();\n \n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_root_move = moves[d];\n }\n \n root_pos = old_root;\n update_positions();\n }\n \n // Try rotations\n for (int r = 1; r <= 2; r++) {\n int old_dir = edge_directions[urgent_fingertip];\n edge_directions[urgent_fingertip] = (old_dir + (r == 1 ? 3 : 1)) % 4;\n update_positions();\n \n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_root_move = '.';\n best_rotation = r;\n }\n \n edge_directions[urgent_fingertip] = old_dir;\n update_positions();\n }\n \n // Apply best move\n if (best_root_move != '.') {\n op[0] = best_root_move;\n if (best_root_move == 'U') root_pos.x--;\n else if (best_root_move == 'D') root_pos.x++;\n else if (best_root_move == 'L') root_pos.y--;\n else if (best_root_move == 'R') root_pos.y++;\n update_positions();\n } else if (best_rotation > 0) {\n op[urgent_fingertip] = (best_rotation == 1) ? 'L' : 'R';\n edge_directions[urgent_fingertip] = (edge_directions[urgent_fingertip] + (best_rotation == 1 ? 3 : 1)) % 4;\n update_positions();\n }\n \n return op;\n }\n \n void execute_operations() {\n assign_tasks();\n \n bool all_complete = false;\n int max_turns = 10000; // Safety limit\n \n while (!all_complete && max_turns-- > 0) {\n string op = generate_operation();\n cout << op << endl;\n \n // Check if all paths are completed\n all_complete = true;\n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (path_progress[i] < fingertip_paths[i].size()) {\n all_complete = false;\n break;\n }\n }\n }\n }\n \n void solve() {\n design_arm();\n print_design();\n execute_operations();\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M, V;\n cin >> N >> M >> V;\n \n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n \n RoboticArmSolver solver(N, M, V, s, t);\n solver.solve();\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n bool is_mackerel;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n cin >> points[i].x >> points[i].y;\n points[i].is_mackerel = (i < N);\n }\n \n auto count_in_rectangle = [&](int x1, int x2, int y1, int y2) {\n int a = 0, b = 0;\n for (const auto& p : points) {\n if (p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2) {\n if (p.is_mackerel) a++;\n else b++;\n }\n }\n return make_pair(a, b);\n };\n \n int best_diff = -1;\n int best_x1 = -1, best_y1 = -1, best_x2 = -1, best_y2 = -1;\n \n // Try small rectangles around each mackerel\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n int initial_size = 5;\n int x1 = max(0, p.x - initial_size);\n int x2 = min(100000, p.x + initial_size);\n int y1 = max(0, p.y - initial_size);\n int y2 = min(100000, p.y + initial_size);\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n int diff = a - b;\n if (diff > best_diff) {\n best_diff = diff;\n best_x1 = x1; best_y1 = y1; best_x2 = x2; best_y2 = y2;\n }\n }\n \n if (best_diff <= 0) {\n // Find a single mackerel and make a minimal polygon\n for (const auto& p : points) {\n if (p.is_mackerel) {\n int x = p.x;\n int y = p.y;\n cout << 4 << \"\\n\";\n cout << x << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y + 1 << \"\\n\";\n cout << x << \" \" << y + 1 << \"\\n\";\n return 0;\n }\n }\n }\n \n // Expand the best rectangle greedily\n bool improved = true;\n while (improved) {\n improved = false;\n int current_diff = best_diff;\n // Try expanding left\n if (best_x1 > 0) {\n int new_x1 = best_x1 - 1;\n auto [a, b] = count_in_rectangle(new_x1, best_x2, best_y1, best_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n // Try expanding right\n if (best_x2 < 100000) {\n int new_x2 = best_x2 + 1;\n auto [a, b] = count_in_rectangle(best_x1, new_x2, best_y1, best_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x2 = new_x2;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n // Try expanding down\n if (best_y1 > 0) {\n int new_y1 = best_y1 - 1;\n auto [a, b] = count_in_rectangle(best_x1, best_x2, new_y1, best_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_y1 = new_y1;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n // Try expanding up\n if (best_y2 < 100000) {\n int new_y2 = best_y2 + 1;\n auto [a, b] = count_in_rectangle(best_x1, best_x2, best_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n }\n \n // Output the rectangle as a polygon\n cout << 4 << \"\\n\";\n cout << best_x1 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y2 << \"\\n\";\n cout << best_x1 << \" \" << best_y2 << \"\\n\";\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Item {\n int idx;\n long long w, h;\n};\n\nstruct Col {\n long long w, h;\n int last_item_idx;\n};\n\nstruct Cmd {\n int p, r, b;\n char d;\n};\n\nlong long get_w(const vector>& dims, int idx) {\n return dims[idx].first;\n}\n\nlong long get_h(const vector>& dims, int idx) {\n return dims[idx].second;\n}\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, T;\n long long sigma;\n cin >> N >> T >> sigma;\n\n vector w_prime(N), h_prime(N);\n for (int i = 0; i < N; ++i) {\n cin >> w_prime[i] >> h_prime[i];\n }\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n const int NUM_PROFILES = 5;\n\n for (int t = 0; t < T; ++t) {\n int profile = t % NUM_PROFILES;\n \n // Decide on the number of items to place (prefix length)\n // Cycle between N, N-1, N-2, N-3, N-4\n int k = N - (t % 5);\n if (k <= 0) k = 1;\n\n // cerr << \"Turn \" << t << \", Profile \" << profile << \", k=\" << k << endl;\n cout << \"# Turn \" << t << \", Profile \" << profile << \", k=\" << k << endl;\n\n vector columns;\n vector item_to_col(k, -1);\n vector> final_dims(k); // (w, h) for each item 0..k-1\n\n for (int i = 0; i < k; ++i) {\n long long w_orig = w_prime[i];\n long long h_orig = h_prime[i];\n\n vector> rot_options = {{w_orig, h_orig}, {h_orig, w_orig}};\n \n // Apply profile-based rotation preference\n if (profile == 0 || profile == 1 || profile == 4) { // Prefer w >= h\n if (rot_options[0].first < rot_options[0].second) {\n swap(rot_options[0], rot_options[1]);\n }\n } else if (profile == 3) { // Prefer h > w\n if (rot_options[0].first >= rot_options[0].second) {\n swap(rot_options[0], rot_options[1]);\n }\n }\n // Profile 2 (random) will handle rotation in the loop\n\n long long best_cost = 1e18;\n int best_col_idx = -1;\n int best_rot_idx = 0;\n\n for (int rot_idx = 0; rot_idx < 2; ++rot_idx) {\n // Random profile might override rotation preference\n if (profile == 2 && rng() % 2 == 0) {\n // Try the other orientation first with 50% chance\n if (rot_idx == 0) continue;\n }\n\n long long w = rot_options[rot_idx].first;\n long long h = rot_options[rot_idx].second;\n\n // Try to fit into existing columns\n for (int j = 0; j < columns.size(); ++j) {\n if (w <= columns[j].w) {\n long long cost = h;\n if (profile == 3) { // Height-averse: prefer shorter columns\n cost = columns[j].h + h;\n }\n\n if (cost < best_cost || (cost == best_cost && rng() % 2 == 0)) {\n best_cost = cost;\n best_col_idx = j;\n best_rot_idx = rot_idx;\n }\n }\n }\n\n // Try to create a new column\n long long cost_new_col = 1e18;\n if (profile == 1) { // Area-averse\n cost_new_col = w * h;\n } else if (profile == 4) { // Greedy for columns\n cost_new_col = 1e17; // A very large number\n } else { // Standard\n cost_new_col = w;\n }\n\n if (cost_new_col < best_cost || (cost_new_col == best_cost && rng() % 2 == 0)) {\n best_cost = cost_new_col;\n best_col_idx = -1; // Indicates new column\n best_rot_idx = rot_idx;\n }\n }\n\n // Apply best placement\n final_dims[i] = rot_options[best_rot_idx];\n if (best_col_idx == -1) {\n // Create new column\n columns.push_back({final_dims[i].first, final_dims[i].second, i});\n item_to_col[i] = columns.size() - 1;\n } else {\n // Add to existing column\n columns[best_col_idx].h += final_dims[i].second;\n columns[best_col_idx].last_item_idx = i;\n item_to_col[i] = best_col_idx;\n }\n }\n \n // Generate commands\n vector commands;\n map last_item_in_col;\n\n for (int i = 0; i < k; ++i) {\n int col_idx = item_to_col[i];\n int p = i;\n int r = (final_dims[i].first == h_prime[i]) ? 1 : 0;\n int b;\n char d;\n\n if (last_item_in_col.count(col_idx) == 0) {\n // First item in a new column\n if (col_idx == 0) {\n // First item, first column\n d = 'L';\n b = -1;\n } else {\n // First item of a subsequent column\n // Find the column immediately to the left\n int left_col_idx = -1;\n for(int j = 0; j < i; ++j) {\n if (item_to_col[j] < col_idx) {\n left_col_idx = item_to_col[j];\n }\n }\n // The last item placed in the left column is the reference\n b = columns[left_col_idx].last_item_idx;\n d = 'U';\n }\n } else {\n // Not the first item in its column\n b = last_item_in_col[col_idx];\n d = 'L';\n }\n\n commands.push_back({p, r, b, d});\n last_item_in_col[col_idx] = i;\n }\n\n // Output\n cout << commands.size() << \"\\n\";\n for (const auto& cmd : commands) {\n cout << cmd.p << \" \" << cmd.r << \" \" << cmd.d << \" \" << cmd.b << \"\\n\";\n }\n cout << flush;\n\n // Read response\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc041":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Edge {\n int to;\n};\n\nstruct Vertex {\n int x, y;\n int beauty;\n vector neighbors;\n int parent;\n int depth;\n int tree_id;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].beauty;\n }\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n vertices[u].neighbors.push_back(v);\n vertices[v].neighbors.push_back(u);\n }\n \n for (int i = 0; i < N; i++) {\n cin >> vertices[i].x >> vertices[i].y;\n }\n \n // Initialize\n for (int i = 0; i < N; i++) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = -1;\n }\n \n // Sort vertices by beauty (ascending) for root selection\n vector sorted_by_beauty(N);\n iota(sorted_by_beauty.begin(), sorted_by_beauty.end(), 0);\n sort(sorted_by_beauty.begin(), sorted_by_beauty.end(), \n [&](int a, int b) { return vertices[a].beauty < vertices[b].beauty; });\n \n // Select roots (approximately N/15 roots)\n int num_roots = max(1, N / 15);\n vector roots;\n vector is_root(N, false);\n \n for (int i = 0; i < num_roots && i < N; i++) {\n int v = sorted_by_beauty[i];\n // Check distance from existing roots\n bool too_close = false;\n for (int r : roots) {\n int dx = vertices[v].x - vertices[r].x;\n int dy = vertices[v].y - vertices[r].y;\n if (dx*dx + dy*dy < 2500) { // 50 units squared\n too_close = true;\n break;\n }\n }\n if (!too_close) {\n roots.push_back(v);\n is_root[v] = true;\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n }\n }\n \n // Grow trees from roots\n vector> tree_vertices(N);\n for (int r : roots) {\n tree_vertices[r].push_back(r);\n }\n \n vector assigned(N, false);\n for (int r : roots) {\n assigned[r] = true;\n }\n \n // BFS from each root with priority on high beauty\n for (int root_id = 0; root_id < roots.size(); root_id++) {\n int root = roots[root_id];\n \n // Priority queue: (beauty, depth, vertex)\n // Using negative beauty for max-heap\n priority_queue> pq;\n pq.emplace(-vertices[root].beauty, 0, root);\n \n while (!pq.empty()) {\n auto [neg_beauty, depth, v] = pq.top();\n pq.pop();\n \n if (depth >= H) continue;\n \n for (int nb : vertices[v].neighbors) {\n if (!assigned[nb]) {\n assigned[nb] = true;\n vertices[nb].parent = v;\n vertices[nb].depth = depth + 1;\n vertices[nb].tree_id = root;\n tree_vertices[root].push_back(nb);\n pq.emplace(-vertices[nb].beauty, depth + 1, nb);\n }\n }\n }\n }\n \n // Assign remaining unassigned vertices\n for (int v = 0; v < N; v++) {\n if (!assigned[v]) {\n // Find nearest assigned vertex\n int nearest = -1;\n int min_dist = INT_MAX;\n \n for (int u = 0; u < N; u++) {\n if (assigned[u]) {\n int dx = vertices[v].x - vertices[u].x;\n int dy = vertices[v].y - vertices[u].y;\n int dist = dx*dx + dy*dy;\n if (dist < min_dist) {\n min_dist = dist;\n nearest = u;\n }\n }\n }\n \n if (nearest != -1) {\n // Find path from nearest to root and assign v as child\n int current = nearest;\n int parent = -1;\n \n // Find a node with depth < H to attach v\n while (current != -1 && vertices[current].depth >= H) {\n current = vertices[current].parent;\n }\n \n if (current != -1 && vertices[current].depth < H) {\n vertices[v].parent = current;\n vertices[v].depth = vertices[current].depth + 1;\n vertices[v].tree_id = vertices[current].tree_id;\n tree_vertices[vertices[v].tree_id].push_back(v);\n } else {\n // Make it a new root\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n tree_vertices[v].push_back(v);\n }\n } else {\n // Make it a new root\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n tree_vertices[v].push_back(v);\n }\n assigned[v] = true;\n }\n }\n \n // Local optimization: try to improve by reassigning vertices\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int iter = 0; iter < 50; iter++) {\n // Random vertex to try reassigning\n int v = rng() % N;\n if (vertices[v].depth == 0) continue; // Skip roots\n \n // Find all possible parents within height constraint\n vector> candidates; // (gain, parent)\n \n for (int nb : vertices[v].neighbors) {\n if (vertices[nb].tree_id != vertices[v].tree_id && \n vertices[nb].depth < H) {\n // Calculate gain if we move v under nb\n int old_gain = (vertices[v].depth + 1) * vertices[v].beauty;\n int new_gain = (vertices[nb].depth + 2) * vertices[v].beauty;\n candidates.emplace_back(new_gain - old_gain, nb);\n }\n }\n \n if (!candidates.empty()) {\n sort(candidates.rbegin(), candidates.rend());\n if (candidates[0].first > 0) {\n int new_parent = candidates[0].second;\n int old_tree = vertices[v].tree_id;\n \n // Move v to new tree\n vertices[v].parent = new_parent;\n vertices[v].depth = vertices[new_parent].depth + 1;\n vertices[v].tree_id = vertices[new_parent].tree_id;\n \n // Update tree vertices\n auto it = find(tree_vertices[old_tree].begin(), \n tree_vertices[old_tree].end(), v);\n if (it != tree_vertices[old_tree].end()) {\n tree_vertices[old_tree].erase(it);\n }\n tree_vertices[vertices[v].tree_id].push_back(v);\n }\n }\n }\n \n // Output parent array\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << vertices[i].parent;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// N is fixed at 20 for all test cases.\nconst int N = 20;\n\nstruct Plan {\n char dir;\n int idx;\n int cost;\n vector oni_indices; // Indices of Oni this plan removes\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n // N is fixed, but we read it for completeness.\n int N_input;\n cin >> N_input;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n // Preprocessing: Identify all Oni and map them to indices\n vector> oni_positions;\n int oni_idx_map[N][N];\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n oni_idx_map[i][j] = -1;\n }\n }\n\n int oni_count = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n oni_idx_map[i][j] = oni_count;\n oni_positions.push_back({i, j});\n oni_count++;\n }\n }\n }\n int num_oni = oni_positions.size();\n\n // Generate all possible removal plans\n vector plans;\n \n // Generate plans for rows\n for (int i = 0; i < N; ++i) {\n vector oni_cols_in_row;\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n oni_cols_in_row.push_back(j);\n }\n }\n\n if (oni_cols_in_row.empty()) continue;\n\n int j_min = *min_element(oni_cols_in_row.begin(), oni_cols_in_row.end());\n int j_max = *max_element(oni_cols_in_row.begin(), oni_cols_in_row.end());\n\n // Check left path\n bool left_clear = true;\n for (int j = 0; j < j_min; ++j) {\n if (board[i][j] == 'o') {\n left_clear = false;\n break;\n }\n }\n if (left_clear) {\n Plan p;\n p.dir = 'L';\n p.idx = i;\n p.cost = 2 * (j_min + 1);\n for (int j : oni_cols_in_row) {\n p.oni_indices.push_back(oni_idx_map[i][j]);\n }\n plans.push_back(p);\n }\n\n // Check right path\n bool right_clear = true;\n for (int j = j_max + 1; j < N; ++j) {\n if (board[i][j] == 'o') {\n right_clear = false;\n break;\n }\n }\n if (right_clear) {\n Plan p;\n p.dir = 'R';\n p.idx = i;\n p.cost = 2 * (N - j_max);\n for (int j : oni_cols_in_row) {\n p.oni_indices.push_back(oni_idx_map[i][j]);\n }\n plans.push_back(p);\n }\n }\n\n // Generate plans for columns\n for (int j = 0; j < N; ++j) {\n vector oni_rows_in_col;\n for (int i = 0; i < N; ++i) {\n if (board[i][j] == 'x') {\n oni_rows_in_col.push_back(i);\n }\n }\n\n if (oni_rows_in_col.empty()) continue;\n\n int i_min = *min_element(oni_rows_in_col.begin(), oni_rows_in_col.end());\n int i_max = *max_element(oni_rows_in_col.begin(), oni_rows_in_col.end());\n\n // Check up path\n bool up_clear = true;\n for (int i = 0; i < i_min; ++i) {\n if (board[i][j] == 'o') {\n up_clear = false;\n break;\n }\n }\n if (up_clear) {\n Plan p;\n p.dir = 'U';\n p.idx = j;\n p.cost = 2 * (i_min + 1);\n for (int i : oni_rows_in_col) {\n p.oni_indices.push_back(oni_idx_map[i][j]);\n }\n plans.push_back(p);\n }\n\n // Check down path\n bool down_clear = true;\n for (int i = i_max + 1; i < N; ++i) {\n if (board[i][j] == 'o') {\n down_clear = false;\n break;\n }\n }\n if (down_clear) {\n Plan p;\n p.dir = 'D';\n p.idx = j;\n p.cost = 2 * (N - i_max);\n for (int i : oni_rows_in_col) {\n p.oni_indices.push_back(oni_idx_map[i][j]);\n }\n plans.push_back(p);\n }\n }\n\n // Shuffle plans to introduce randomness and potentially escape local optima in greedy search\n random_device rd;\n mt19937 g(rd());\n shuffle(plans.begin(), plans.end(), g);\n\n // Greedy selection of plans to cover all Oni\n vector covered(num_oni, false);\n vector chosen_plans;\n int num_covered = 0;\n\n while (num_covered < num_oni) {\n int best_plan_idx = -1;\n double best_ratio = 1e9;\n \n for (int p_idx = 0; p_idx < plans.size(); ++p_idx) {\n const auto& p = plans[p_idx];\n int newly_covered_count = 0;\n for (int oni_idx : p.oni_indices) {\n if (!covered[oni_idx]) {\n newly_covered_count++;\n }\n }\n\n if (newly_covered_count > 0) {\n double ratio = (double)p.cost / newly_covered_count;\n if (ratio < best_ratio) {\n best_ratio = ratio;\n best_plan_idx = p_idx;\n }\n }\n }\n\n // Apply the best plan found\n if (best_plan_idx != -1) {\n const auto& best_plan = plans[best_plan_idx];\n chosen_plans.push_back(best_plan);\n for (int oni_idx : best_plan.oni_indices) {\n if (!covered[oni_idx]) {\n covered[oni_idx] = true;\n num_covered++;\n }\n }\n } else {\n // This should not happen based on problem guarantees.\n // If it does, there's a bug in plan generation or logic.\n // As a robust fallback, we could implement the simple individual removal here.\n // For now, we'll trust the guarantee and break to avoid an infinite loop.\n // cerr << \"Error: No plan found to cover remaining Oni.\" << endl;\n break; \n }\n }\n\n // Output the sequence of operations\n int T = 0;\n for (const auto& p : chosen_plans) {\n int shifts = p.cost / 2;\n for (int k = 0; k < shifts; ++k) {\n cout << p.dir << \" \" << p.idx << \"\\n\";\n T++;\n }\n char rev_dir;\n if (p.dir == 'L') rev_dir = 'R';\n else if (p.dir == 'R') rev_dir = 'L';\n else if (p.dir == 'U') rev_dir = 'D';\n else if (p.dir == 'D') rev_dir = 'U';\n\n for (int k = 0; k < shifts; ++k) {\n cout << rev_dir << \" \" << p.idx << \"\\n\";\n T++;\n }\n }\n \n // The problem guarantees a solution within 4N^2 moves, and our greedy approach\n // should not exceed this. A simple individual removal for all 40 Oni costs at most 40*40=1600=4N^2.\n // Our greedy approach finds cheaper groupings, so T should be <= 1600.\n // if (T > 4 * N * N) {\n // cerr << \"Warning: Operation count exceeded limit: \" << T << endl;\n // }\n\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 100;\n long long L = 500000;\n vector T(N);\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector> sorted_T;\n for (int i = 0; i < N; ++i) {\n sorted_T.emplace_back(T[i], i);\n }\n sort(sorted_T.rbegin(), sorted_T.rend());\n\n vector a(N), b(N);\n for (int i = 0; i < N; ++i) {\n int emp = sorted_T[i].second;\n if (i == 0) {\n a[emp] = emp;\n b[emp] = (N > 1) ? sorted_T[1].second : emp;\n } else {\n a[emp] = sorted_T[0].second;\n b[emp] = emp;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << a[i] << \" \" << b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct City {\n int idx;\n double x, y;\n int lx, rx, ly, ry;\n};\n\nstruct Edge {\n int u, v;\n double weight;\n bool operator<(const Edge& other) const {\n return weight < other.weight;\n }\n};\n\nvector> dist; // Actual distances\nvector> query_count; // How many times each edge was queried\n\ndouble euclidean_dist(const City& a, const City& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\nvector> query_mst(const vector& cities) {\n cout << \"? \" << cities.size();\n for (int c : cities) cout << \" \" << c;\n cout << endl;\n cout.flush();\n \n vector> edges;\n for (int i = 0; i < (int)cities.size() - 1; i++) {\n int u, v;\n cin >> u >> v;\n edges.emplace_back(u, v);\n }\n return edges;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector cities(N);\n for (int i = 0; i < N; i++) {\n cities[i].idx = i;\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].x = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].y = (cities[i].ly + cities[i].ry) / 2.0;\n }\n \n dist.assign(N, vector(N, 1e9));\n query_count.assign(N, vector(N, 0));\n \n // Initialize with centroid distances\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n dist[i][j] = dist[j][i] = euclidean_dist(cities[i], cities[j]);\n }\n }\n \n // Strategy 1: Query nearby cities to get accurate distances\n int queries_used = 0;\n \n // Build spatial index for finding nearby cities\n vector> grid(101, vector(101));\n for (int i = 0; i < N; i++) {\n int gx = min(100, (int)(cities[i].x / 100));\n int gy = min(100, (int)(cities[i].y / 100));\n grid[gx][gy].push_back(i);\n }\n \n // Query local neighborhoods\n for (int gx = 0; gx <= 100 && queries_used < Q/2; gx++) {\n for (int gy = 0; gy <= 100 && queries_used < Q/2; gy++) {\n if (grid[gx][gy].empty()) continue;\n \n vector nearby;\n // Collect cities from this and adjacent cells\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n int nx = gx + dx, ny = gy + dy;\n if (0 <= nx && nx <= 100 && 0 <= ny && ny <= 100) {\n for (int c : grid[nx][ny]) {\n nearby.push_back(c);\n }\n }\n }\n }\n \n // Sort by distance to grid center and query closest\n sort(nearby.begin(), nearby.end(), [&](int a, int b) {\n double da = euclidean_dist(cities[a], {0, gx*100.0, gy*100.0, 0,0,0,0});\n double db = euclidean_dist(cities[b], {0, gx*100.0, gy*100.0, 0,0,0,0});\n return da < db;\n });\n \n // Query in batches of size L\n for (int i = 0; i < (int)nearby.size() && queries_used < Q/2; i += L-1) {\n vector batch;\n for (int j = i; j < min((int)nearby.size(), i + L); j++) {\n batch.push_back(nearby[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n // Update distances based on MST\n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n }\n }\n \n // Strategy 2: Query groups of cities that will likely be in the same final group\n // Sort cities by estimated position for initial grouping\n vector city_order(N);\n iota(city_order.begin(), city_order.end(), 0);\n sort(city_order.begin(), city_order.end(), [&](int a, int b) {\n return cities[a].x < cities[b].x || \n (abs(cities[a].x - cities[b].x) < 1e-6 && cities[a].y < cities[b].y);\n });\n \n // Create initial groups based on sorted order\n vector> initial_groups(M);\n int idx = 0;\n for (int g = 0; g < M; g++) {\n for (int i = 0; i < G[g]; i++) {\n initial_groups[g].push_back(city_order[idx++]);\n }\n }\n \n // Query within each initial group to refine distances\n for (int g = 0; g < M && queries_used < Q; g++) {\n if (initial_groups[g].size() <= 1) continue;\n \n // Query subsets within the group\n for (int i = 0; i < (int)initial_groups[g].size() && queries_used < Q; i += L-1) {\n vector subset;\n for (int j = i; j < min((int)initial_groups[g].size(), i + L); j++) {\n subset.push_back(initial_groups[g][j]);\n }\n if (subset.size() >= 2) {\n auto mst_edges = query_mst(subset);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n }\n \n // Final group assignment using improved distances\n // Use a greedy approach to build connected groups\n vector assigned(N, false);\n vector> final_groups(M);\n vector>> final_edges(M);\n \n // Sort groups by size (largest first for better connectivity)\n vector> group_sizes;\n for (int i = 0; i < M; i++) group_sizes.emplace_back(G[i], i);\n sort(group_sizes.rbegin(), group_sizes.rend());\n \n for (auto [size, group_id] : group_sizes) {\n if (size == 0) continue;\n \n // Find best unassigned city as seed\n int seed = -1;\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n seed = i;\n break;\n }\n }\n \n if (seed == -1) break;\n \n final_groups[group_id].push_back(seed);\n assigned[seed] = true;\n \n // Grow group by adding closest unassigned cities\n while ((int)final_groups[group_id].size() < size) {\n int best_city = -1;\n double best_dist = 1e9;\n int best_from = -1;\n \n for (int c : final_groups[group_id]) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n if (dist[c][i] < best_dist) {\n best_dist = dist[c][i];\n best_city = i;\n best_from = c;\n }\n }\n }\n }\n \n if (best_city != -1) {\n final_groups[group_id].push_back(best_city);\n final_edges[group_id].emplace_back(best_from, best_city);\n assigned[best_city] = true;\n } else {\n break;\n }\n }\n }\n \n // Build MST within each group for final edges\n for (int g = 0; g < M; g++) {\n if (final_groups[g].empty()) continue;\n \n // Kruskal's algorithm for MST within group\n vector edges;\n for (int i = 0; i < (int)final_groups[g].size(); i++) {\n for (int j = i + 1; j < (int)final_groups[g].size(); j++) {\n int u = final_groups[g][i];\n int v = final_groups[g][j];\n edges.push_back({u, v, dist[u][v]});\n }\n }\n sort(edges.begin(), edges.end());\n \n dsu dsu(N);\n vector> mst_edges;\n for (auto e : edges) {\n if (!dsu.same(e.u, e.v)) {\n dsu.merge(e.u, e.v);\n mst_edges.emplace_back(e.u, e.v);\n if ((int)mst_edges.size() == (int)final_groups[g].size() - 1) break;\n }\n }\n final_edges[g] = mst_edges;\n }\n \n // Output answer\n cout << \"!\" << endl;\n for (int g = 0; g < M; g++) {\n if (final_groups[g].empty()) {\n // Fallback: use initial group\n for (int c : initial_groups[g]) cout << c << \" \";\n cout << endl;\n for (int i = 0; i < (int)initial_groups[g].size() - 1; i++) {\n cout << initial_groups[g][i] << \" \" << initial_groups[g][i+1] << endl;\n }\n } else {\n for (int c : final_groups[g]) cout << c << \" \";\n cout << endl;\n for (auto [u, v] : final_edges[g]) {\n cout << u << \" \" << v << endl;\n }\n }\n }\n \n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nconstexpr int N = 20;\n\nstruct Pos {\n int r, c;\n int id() const { return r * N + c; }\n static Pos from_id(int id) { return {id / N, id % N}; }\n};\n\n// BFS that returns a shortest sequence of actions from src to dst\nvector> bfs_path(Pos src, Pos dst) {\n const int SZ = N * N;\n vector dist(SZ, -1);\n vector parent(SZ, -1);\n vector act(SZ), dir(SZ); // action and direction that lead to this vertex\n\n queue q;\n int s_id = src.id();\n dist[s_id] = 0;\n q.push(s_id);\n\n while (!q.empty()) {\n int cur_id = q.front(); q.pop();\n Pos cur = Pos::from_id(cur_id);\n if (cur_id == dst.id()) break;\n\n // ----- Move -----\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char mdir[4] = {'U', 'D', 'L', 'R'};\n for (int k = 0; k < 4; ++k) {\n int nr = cur.r + dr[k];\n int nc = cur.c + dc[k];\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) continue;\n int nid = nr * N + nc;\n if (dist[nid] != -1) continue;\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'M';\n dir[nid] = mdir[k];\n q.push(nid);\n }\n\n // ----- Slide -----\n // slide up\n if (cur.r > 0) {\n int nid = 0 * N + cur.c;\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'U';\n q.push(nid);\n }\n }\n // slide down\n if (cur.r < N-1) {\n int nid = (N-1) * N + cur.c;\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'D';\n q.push(nid);\n }\n }\n // slide left\n if (cur.c > 0) {\n int nid = cur.r * N + 0;\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'L';\n q.push(nid);\n }\n }\n // slide right\n if (cur.c < N-1) {\n int nid = cur.r * N + (N-1);\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'R';\n q.push(nid);\n }\n }\n }\n\n // reconstruct path\n vector> path;\n int cur_id = dst.id();\n while (cur_id != s_id) {\n path.emplace_back(act[cur_id], dir[cur_id]);\n cur_id = parent[cur_id];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int M;\n if (!(cin >> N >> M)) return 0;\n vector pts(M);\n for (int i = 0; i < M; ++i) {\n cin >> pts[i].r >> pts[i].c;\n }\n\n vector> answer;\n Pos cur = pts[0];\n for (int i = 1; i < M; ++i) {\n Pos nxt = pts[i];\n auto seg = bfs_path(cur, nxt);\n answer.insert(answer.end(), seg.begin(), seg.end());\n cur = nxt;\n }\n\n // safety check (should always hold)\n if ((int)answer.size() > 2 * N * M) {\n // truncate if something went wrong (never happens)\n answer.resize(2 * N * M);\n }\n\n for (auto [a, d] : answer) {\n cout << a << ' ' << d << '\\n';\n }\n return 0;\n}"},"2":{"ahc001":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Company {\n int id, x, y, r;\n int a, b, c, d; // rectangle coordinates\n};\n\nstruct Rect {\n int a, b, c, d;\n int area() const { return (c-a)*(d-b); }\n bool contains(int x, int y) const { \n return a <= x && x+1 <= c && b <= y && y+1 <= d; \n }\n};\n\n// Split outer rectangle after removing inner rectangle\nvector split_rect(const Rect& outer, const Rect& inner) {\n vector result;\n \n // Top\n if (inner.b > outer.b) {\n result.push_back({outer.a, outer.b, outer.c, inner.b});\n }\n \n // Bottom \n if (inner.d < outer.d) {\n result.push_back({outer.a, inner.d, outer.c, outer.d});\n }\n \n // Left\n if (inner.a > outer.a) {\n result.push_back({outer.a, inner.b, inner.a, inner.d});\n }\n \n // Right\n if (inner.c < outer.c) {\n result.push_back({inner.c, inner.b, outer.c, inner.d});\n }\n \n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n vector companies(n);\n for (int i = 0; i < n; i++) {\n companies[i].id = i;\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n }\n \n // Sort by desired area (descending) to handle large companies first\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.r > b.r;\n });\n \n vector available = {{0, 0, 10000, 10000}};\n \n for (auto& comp : companies) {\n int x = comp.x, y = comp.y, r = comp.r;\n \n // Find best available rectangle containing the point\n int best_idx = -1;\n double best_score = -1;\n \n for (int i = 0; i < available.size(); i++) {\n if (available[i].contains(x, y)) {\n int area = available[i].area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n }\n \n if (best_idx != -1) {\n // Direct assignment\n comp.a = available[best_idx].a;\n comp.b = available[best_idx].b;\n comp.c = available[best_idx].c;\n comp.d = available[best_idx].d;\n available.erase(available.begin() + best_idx);\n } else {\n // Need to split an existing rectangle\n best_idx = -1;\n best_score = -1;\n Rect best_rect;\n vector best_remaining;\n \n for (int i = 0; i < available.size(); i++) {\n const Rect& rect = available[i];\n \n // Try different splitting strategies\n \n // Strategy 1: Minimal 1x1 rectangle\n Rect min_rect = {x, y, x+1, y+1};\n if (rect.a <= x && x+1 <= rect.c && rect.b <= y && y+1 <= rect.d) {\n int area = 1;\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = min_rect;\n best_remaining = split_rect(rect, min_rect);\n }\n }\n \n // Strategy 2: Vertical split to match area\n if (rect.a <= x && x+1 <= rect.c) {\n int height = rect.d - rect.b;\n int target_width = max(1, min(r / height, rect.c - rect.a));\n \n // Left placement\n Rect left_rect = {rect.a, rect.b, rect.a + target_width, rect.d};\n if (left_rect.contains(x, y)) {\n int area = left_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = left_rect;\n best_remaining = split_rect(rect, left_rect);\n }\n }\n \n // Right placement\n Rect right_rect = {rect.c - target_width, rect.b, rect.c, rect.d};\n if (right_rect.contains(x, y)) {\n int area = right_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = right_rect;\n best_remaining = split_rect(rect, right_rect);\n }\n }\n }\n \n // Strategy 3: Horizontal split to match area\n if (rect.b <= y && y+1 <= rect.d) {\n int width = rect.c - rect.a;\n int target_height = max(1, min(r / width, rect.d - rect.b));\n \n // Top placement\n Rect top_rect = {rect.a, rect.b, rect.c, rect.b + target_height};\n if (top_rect.contains(x, y)) {\n int area = top_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = top_rect;\n best_remaining = split_rect(rect, top_rect);\n }\n }\n \n // Bottom placement\n Rect bottom_rect = {rect.a, rect.d - target_height, rect.c, rect.d};\n if (bottom_rect.contains(x, y)) {\n int area = bottom_rect.area();\n double score = 1 - (1 - min(r, area) / (double)max(r, area)) * \n (1 - min(r, area) / (double)max(r, area));\n if (score > best_score) {\n best_score = score;\n best_idx = i;\n best_rect = bottom_rect;\n best_remaining = split_rect(rect, bottom_rect);\n }\n }\n }\n }\n \n if (best_idx != -1) {\n comp.a = best_rect.a;\n comp.b = best_rect.b;\n comp.c = best_rect.c;\n comp.d = best_rect.d;\n available.erase(available.begin() + best_idx);\n for (const auto& rect : best_remaining) {\n if (rect.area() > 0) {\n available.push_back(rect);\n }\n }\n } else {\n // Fallback: assign largest available rectangle\n int largest_idx = max_element(available.begin(), available.end(), \n [](const Rect& a, const Rect& b) { return a.area() < b.area(); }) - available.begin();\n \n comp.a = available[largest_idx].a;\n comp.b = available[largest_idx].b;\n comp.c = available[largest_idx].c;\n comp.d = available[largest_idx].d;\n available.erase(available.begin() + largest_idx);\n }\n }\n }\n \n // Sort by original ID for output\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.id < b.id;\n });\n \n // Output results\n for (const auto& comp : companies) {\n cout << comp.a << \" \" << comp.b << \" \" << comp.c << \" \" << comp.d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\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> t(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> t[i][j];\n }\n }\n \n vector> p(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> p[i][j];\n }\n }\n \n // Track visited tiles\n unordered_set visited_tiles;\n visited_tiles.insert(t[si][sj]);\n \n string path;\n int current_i = si, current_j = sj;\n int total_score = p[si][sj];\n \n // Directions: U, D, L, R\n vector di = {-1, 1, 0, 0};\n vector dj = {0, 0, -1, 1};\n vector dirs = {'U', 'D', 'L', 'R'};\n \n // Greedy exploration with look-ahead\n for (int step = 0; step < 1000; step++) {\n vector> candidates; // (score, ni, nj, dir)\n \n for (int d = 0; d < 4; d++) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n \n int tile_id = t[ni][nj];\n if (visited_tiles.count(tile_id)) continue;\n \n int score = p[ni][nj];\n \n // Add value of other square in the tile if it's 1x2 or 2x1\n for (int check_i = max(0, ni-1); check_i <= min(49, ni+1); check_i++) {\n for (int check_j = max(0, nj-1); check_j <= min(49, nj+1); check_j++) {\n if (abs(check_i - ni) + abs(check_j - nj) == 1 && t[check_i][check_j] == tile_id) {\n score += p[check_i][check_j];\n }\n }\n }\n \n // Add some randomness to explore different paths\n score += rand() % 10;\n \n candidates.push_back({score, ni, nj, dirs[d]});\n }\n \n if (candidates.empty()) {\n // Try to find a path to unvisited tiles\n vector> distant_candidates;\n \n for (int search_i = 0; search_i < 50; search_i++) {\n for (int search_j = 0; search_j < 50; search_j++) {\n int tile_id = t[search_i][search_j];\n if (visited_tiles.count(tile_id)) continue;\n \n int dist = abs(current_i - search_i) + abs(current_j - search_j);\n int score = p[search_i][search_j] - dist / 2; // Penalty for distance\n \n distant_candidates.push_back({score, search_i, search_j, '\\0'});\n }\n }\n \n if (distant_candidates.empty()) break;\n \n sort(distant_candidates.rbegin(), distant_candidates.rend());\n auto [_, target_i, target_j, ___] = distant_candidates[0];\n \n // Move towards target\n if (target_i < current_i) {\n path += 'U';\n current_i--;\n } else if (target_i > current_i) {\n path += 'D';\n current_i++;\n } else if (target_j < current_j) {\n path += 'L';\n current_j--;\n } else if (target_j > current_j) {\n path += 'R';\n current_j++;\n }\n } else {\n sort(candidates.rbegin(), candidates.rend());\n auto [_, ni, nj, dir] = candidates[0];\n \n path += dir;\n current_i = ni;\n current_j = nj;\n total_score += p[ni][nj];\n visited_tiles.insert(t[ni][nj]);\n \n // Add value of other square in tile if applicable\n for (int check_i = max(0, ni-1); check_i <= min(49, ni+1); check_i++) {\n for (int check_j = max(0, nj-1); check_j <= min(49, nj+1); check_j++) {\n if (abs(check_i - ni) + abs(check_j - nj) == 1 && t[check_i][check_j] == t[ni][nj]) {\n total_score += p[check_i][check_j];\n }\n }\n }\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\n// grid size\nconstexpr int N = 30;\nconstexpr int INF = 1e18;\n\n// edge weight estimates\ndouble H[N][N - 1]; // horizontal: (i,j) -> (i,j+1)\ndouble V[N - 1][N]; // vertical: (i,j) -> (i+1,j)\n\n// direction helpers\nconstexpr int di[4] = {-1, 1, 0, 0};\nconstexpr int dj[4] = {0, 0, -1, 1};\nconstexpr char dir_char[4] = {'U', 'D', 'L', 'R'};\n// for updating the correct edge array when we walk from (i,j) to (ni,nj)\nconstexpr int edge_index[4] = {3, 2, 1, 0}; // reversed mapping for readability\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n mt19937 rng(123456);\n uniform_int_distribution init_dist(1000, 9000);\n\n // initialise edge estimates\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N - 1; ++j) H[i][j] = init_dist(rng);\n }\n for (int i = 0; i < N - 1; ++i) {\n for (int j = 0; j < N; ++j) V[i][j] = init_dist(rng);\n }\n\n constexpr double learning_rate = 0.2; // moderate step size\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) break; // safety, should not happen\n\n // ---------- Dijkstra ----------\n using Node = pair>; // (dist, (i,j))\n priority_queue, greater> pq;\n double dist[N][N];\n int prev[N][N]; // direction index (0..3)\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n dist[i][j] = INF;\n prev[i][j] = -1;\n }\n dist[si][sj] = 0.0;\n pq.emplace(0.0, make_pair(si, sj));\n\n while (!pq.empty()) {\n auto [d, coord] = pq.top();\n auto [i, j] = coord;\n pq.pop();\n if (fabs(d - dist[i][j]) > 1e-9) continue;\n if (i == ti && j == tj) break; // reached target\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n double w = 0.0;\n if (dir == 0) { // U -> edge V[i-1][j]\n w = V[i - 1][j];\n } else if (dir == 1) { // D -> edge V[i][j]\n w = V[i][j];\n } else if (dir == 2) { // L -> edge H[i][j-1]\n w = H[i][j - 1];\n } else { // R -> edge H[i][j]\n w = H[i][j];\n }\n double nd = d + w;\n if (nd < dist[ni][nj] - 1e-9) {\n dist[ni][nj] = nd;\n prev[ni][nj] = dir;\n pq.emplace(nd, make_pair(ni, nj));\n }\n }\n }\n\n // reconstruct path\n string path;\n vector> edges_on_path; // (type, coordinates) for update\n int ci = ti, cj = tj;\n while (!(ci == si && cj == sj)) {\n int dir = prev[ci][cj];\n path.push_back(dir_char[dir]);\n // store which edge we used (from (ci,cj) moving opposite direction)\n int oi = ci - di[dir];\n int oj = cj - dj[dir];\n // encode edge uniquely: type = 0 for H, 1 for V, plus coordinates\n if (dir == 0) { // moved U, edge is V[ci-1][cj]\n edges_on_path.emplace_back(1, (ci - 1) * N + cj);\n } else if (dir == 1) { // moved D, edge is V[ci][cj]\n edges_on_path.emplace_back(1, ci * N + cj);\n } else if (dir == 2) { // moved L, edge is H[ci][cj-1]\n edges_on_path.emplace_back(0, ci * (N - 1) + (cj - 1));\n } else { // moved R, edge is H[ci][cj]\n edges_on_path.emplace_back(0, ci * (N - 1) + cj);\n }\n ci = oi;\n cj = oj;\n }\n reverse(path.begin(), path.end());\n\n // ---------- output ----------\n cout << path << \"\\n\";\n cout.flush();\n\n // ---------- read feedback ----------\n long long observed;\n cin >> observed;\n\n // ---------- update edge estimates ----------\n double lest = 0.0;\n for (auto [type, idx] : edges_on_path) {\n if (type == 0) { // horizontal\n lest += H[idx / (N - 1)][idx % (N - 1)];\n } else { // vertical\n lest += V[idx / N][idx % N];\n }\n }\n double delta = static_cast(observed) - lest;\n int path_len = (int)edges_on_path.size();\n double step = learning_rate * delta / path_len;\n for (auto [type, idx] : edges_on_path) {\n if (type == 0) {\n double &w = H[idx / (N - 1)][idx % (N - 1)];\n w += step;\n if (w < 1000.0) w = 1000.0;\n if (w > 9000.0) w = 9000.0;\n } else {\n double &w = V[idx / N][idx % N];\n w += step;\n if (w < 1000.0) w = 1000.0;\n if (w > 9000.0) w = 9000.0;\n }\n }\n }\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nconst char EMPTY = '.';\n\nstruct StringInfo {\n string s;\n int length;\n int id;\n};\n\nstruct Position {\n int i, j, dir;\n};\n\nclass TorusReconstructor {\nprivate:\n vector strings;\n vector> matrix;\n mt19937 rng;\n vector char_freq;\n int best_score;\n vector> best_matrix;\n vector> string_overlaps;\n \npublic:\n TorusReconstructor(const vector& input_strings) : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n strings.resize(input_strings.size());\n char_freq.resize(8, 0);\n \n for (int i = 0; i < input_strings.size(); i++) {\n strings[i].s = input_strings[i];\n strings[i].length = input_strings[i].length();\n strings[i].id = i;\n \n for (char c : input_strings[i]) {\n char_freq[c - 'A']++;\n }\n }\n \n matrix.resize(N, vector(N, EMPTY));\n best_matrix = matrix;\n best_score = 0;\n \n analyze_string_relationships();\n }\n \n void analyze_string_relationships() {\n string_overlaps.resize(strings.size());\n \n for (int i = 0; i < strings.size(); i++) {\n for (int j = i + 1; j < strings.size(); j++) {\n if (have_common_substring(strings[i].s, strings[j].s)) {\n string_overlaps[i].push_back(j);\n string_overlaps[j].push_back(i);\n }\n }\n }\n }\n \n bool have_common_substring(const string& s1, const string& s2) {\n int min_len = min(s1.length(), s2.length());\n for (int len = 2; len <= min_len; len++) {\n for (int i = 0; i <= s1.length() - len; i++) {\n string sub1 = s1.substr(i, len);\n for (int j = 0; j <= s2.length() - len; j++) {\n if (sub1 == s2.substr(j, len)) {\n return true;\n }\n }\n }\n }\n return false;\n }\n \n bool is_string_matched(const string& s, const vector>& mat) {\n int k = s.length();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool horizontal_match = true;\n for (int p = 0; p < k; p++) {\n if (mat[i][(j + p) % N] != s[p]) {\n horizontal_match = false;\n break;\n }\n }\n if (horizontal_match) return true;\n \n bool vertical_match = true;\n for (int p = 0; p < k; p++) {\n if (mat[(i + p) % N][j] != s[p]) {\n vertical_match = false;\n break;\n }\n }\n if (vertical_match) return true;\n }\n }\n \n return false;\n }\n \n int count_matched_strings(const vector>& mat) {\n int count = 0;\n for (const auto& str_info : strings) {\n if (is_string_matched(str_info.s, mat)) {\n count++;\n }\n }\n return count;\n }\n \n void initialize_matrix() {\n sort(strings.begin(), strings.end(), [this](const StringInfo& a, const StringInfo& b) {\n if (a.length != b.length) return a.length > b.length;\n return string_overlaps[a.id].size() > string_overlaps[b.id].size();\n });\n \n vector> freq_chars;\n for (int i = 0; i < 8; i++) {\n freq_chars.push_back({char_freq[i], 'A' + i});\n }\n sort(freq_chars.rbegin(), freq_chars.rend());\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (rng() % 3 == 0) {\n matrix[i][j] = freq_chars[rng() % min(4, (int)freq_chars.size())].second;\n }\n }\n }\n \n best_score = count_matched_strings(matrix);\n best_matrix = matrix;\n }\n \n void place_string(const string& s) {\n int k = s.length();\n vector best_positions;\n int best_conflicts = k;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int conflicts = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[i][(j + p) % N];\n if (current != EMPTY && current != s[p]) {\n conflicts++;\n }\n }\n if (conflicts < best_conflicts) {\n best_conflicts = conflicts;\n best_positions = {{i, j, 0}};\n } else if (conflicts == best_conflicts) {\n best_positions.push_back({i, j, 0});\n }\n \n conflicts = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[(i + p) % N][j];\n if (current != EMPTY && current != s[p]) {\n conflicts++;\n }\n }\n if (conflicts < best_conflicts) {\n best_conflicts = conflicts;\n best_positions = {{i, j, 1}};\n } else if (conflicts == best_conflicts) {\n best_positions.push_back({i, j, 1});\n }\n }\n }\n \n if (!best_positions.empty() && best_conflicts < k / 2) {\n auto pos = best_positions[rng() % best_positions.size()];\n \n if (pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n matrix[pos.i][(pos.j + p) % N] = s[p];\n }\n } else {\n for (int p = 0; p < k; p++) {\n matrix[(pos.i + p) % N][pos.j] = s[p];\n }\n }\n }\n }\n \n void local_search(int iterations) {\n for (int iter = 0; iter < iterations; iter++) {\n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n char new_char = 'A' + (rng() % 8);\n if (new_char == old_char) continue;\n \n matrix[i][j] = new_char;\n int new_score = count_matched_strings(matrix);\n \n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n } else {\n matrix[i][j] = old_char;\n }\n \n if (rng() % 15 == 0) {\n int str_idx = rng() % strings.size();\n place_string(strings[str_idx].s);\n new_score = count_matched_strings(matrix);\n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n }\n }\n }\n }\n \n void simulated_annealing(int iterations) {\n double temperature = 1.0;\n double cooling_rate = 0.997;\n \n for (int iter = 0; iter < iterations; iter++) {\n temperature *= cooling_rate;\n \n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n char new_char = 'A' + (rng() % 8);\n if (new_char == old_char) continue;\n \n matrix[i][j] = new_char;\n int new_score = count_matched_strings(matrix);\n \n if (new_score >= best_score || (temperature > 0.01 && rng() % 1000 < temperature * 1000)) {\n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n }\n } else {\n matrix[i][j] = old_char;\n }\n }\n }\n \n void improve_unmatched_strings() {\n vector unmatched_indices;\n for (int i = 0; i < strings.size(); i++) {\n if (!is_string_matched(strings[i].s, matrix)) {\n unmatched_indices.push_back(i);\n }\n }\n \n sort(unmatched_indices.begin(), unmatched_indices.end(), [this](int a, int b) {\n return string_overlaps[a].size() > string_overlaps[b].size();\n });\n \n int attempts = min(30, (int)unmatched_indices.size());\n \n for (int i = 0; i < attempts; i++) {\n place_string(strings[unmatched_indices[i]].s);\n int new_score = count_matched_strings(matrix);\n if (new_score >= best_score) {\n best_score = new_score;\n best_matrix = matrix;\n }\n }\n }\n \n void reconstruct() {\n initialize_matrix();\n \n for (int idx = 0; idx < min(150, (int)strings.size()); idx++) {\n place_string(strings[idx].s);\n }\n \n for (int phase = 0; phase < 4; phase++) {\n improve_unmatched_strings();\n local_search(4000);\n simulated_annealing(2500);\n }\n \n matrix = best_matrix;\n }\n \n vector> get_matrix() const {\n return matrix;\n }\n \n int get_best_score() const {\n return best_score;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n TorusReconstructor reconstructor(strings);\n reconstructor.reconstruct();\n \n auto matrix = reconstructor.get_matrix();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << matrix[i][j];\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n vector> covered;\n string path;\n int total_time;\n int uncovered_count;\n \n State(int n) : covered(n, vector(n, false)), total_time(0), uncovered_count(0) {}\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 \n vector grid(N);\n vector> cost(N, vector(N));\n int road_count = 0;\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n road_count++;\n }\n }\n }\n \n // Precompute visibility for each road square\n vector>> visible(N, vector>(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == '#') continue;\n \n // Check visibility in 4 directions\n // Up\n for (int ni = i-1; ni >= 0 && grid[ni][j] != '#'; ni--) {\n visible[i][j].insert(ni * N + j);\n }\n // Down\n for (int ni = i+1; ni < N && grid[ni][j] != '#'; ni++) {\n visible[i][j].insert(ni * N + j);\n }\n // Left\n for (int nj = j-1; nj >= 0 && grid[i][nj] != '#'; nj--) {\n visible[i][j].insert(i * N + nj);\n }\n // Right\n for (int nj = j+1; nj < N && grid[i][nj] != '#'; nj++) {\n visible[i][j].insert(i * N + nj);\n }\n // Self\n visible[i][j].insert(i * N + j);\n }\n }\n \n // Find all road positions\n vector> road_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n road_positions.emplace_back(i, j);\n }\n }\n }\n \n // Greedy selection of key positions\n vector> selected(N, vector(N, false));\n vector> covered(N, vector(N, false));\n int covered_count = 0;\n \n // Start with initial position\n selected[si][sj] = true;\n for (int idx : visible[si][sj]) {\n int i = idx / N, j = idx % N;\n if (!covered[i][j]) {\n covered[i][j] = true;\n covered_count++;\n }\n }\n \n // Greedy selection until all are covered\n while (covered_count < road_count) {\n int best_i = -1, best_j = -1;\n int best_gain = -1;\n int best_cost = INT_MAX;\n \n for (auto [i, j] : road_positions) {\n if (selected[i][j]) continue;\n \n int gain = 0;\n for (int idx : visible[i][j]) {\n int ni = idx / N, nj = idx % N;\n if (!covered[ni][nj]) gain++;\n }\n \n if (gain > 0) {\n // Estimate cost to reach this position from nearest selected\n int min_dist = INT_MAX;\n for (auto [si, sj] : road_positions) {\n if (selected[si][sj]) {\n int dist = abs(i - si) + abs(j - sj);\n min_dist = min(min_dist, dist);\n }\n }\n \n if (gain * 1000 - min_dist > best_gain * 1000 - best_cost) {\n best_gain = gain;\n best_cost = min_dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n \n if (best_i == -1) break;\n \n selected[best_i][best_j] = true;\n for (int idx : visible[best_i][best_j]) {\n int ni = idx / N, nj = idx % N;\n if (!covered[ni][nj]) {\n covered[ni][nj] = true;\n covered_count++;\n }\n }\n }\n \n // Collect selected positions\n vector> key_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (selected[i][j]) {\n key_positions.emplace_back(i, j);\n }\n }\n }\n \n // Build route using nearest neighbor\n string path;\n int current_i = si, current_j = sj;\n vector> visited(N, vector(N, false));\n visited[si][sj] = true;\n \n while (true) {\n // Find nearest unvisited key position\n int best_dist = INT_MAX;\n int best_idx = -1;\n \n for (int k = 0; k < (int)key_positions.size(); k++) {\n auto [ni, nj] = key_positions[k];\n if (visited[ni][nj]) continue;\n \n int dist = abs(ni - current_i) + abs(nj - current_j);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = k;\n }\n }\n \n if (best_idx == -1) break;\n \n auto [target_i, target_j] = key_positions[best_idx];\n \n // Move to target\n while (current_i != target_i) {\n if (current_i < target_i) {\n path += 'D';\n current_i++;\n } else {\n path += 'U';\n current_i--;\n }\n }\n \n while (current_j != target_j) {\n if (current_j < target_j) {\n path += 'R';\n current_j++;\n } else {\n path += 'L';\n current_j--;\n }\n }\n \n visited[target_i][target_j] = true;\n }\n \n // Return to start\n while (current_i != si) {\n if (current_i < si) {\n path += 'D';\n current_i++;\n } else {\n path += 'U';\n current_i--;\n }\n }\n \n while (current_j != sj) {\n if (current_j < sj) {\n path += 'R';\n current_j++;\n } else {\n path += 'L';\n current_j--;\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Variables ---\nint N, M, K, R;\nvector> d; // Task requirements\nvector> pred; // Predecessor lists\nvector> succ; // Successor lists\nvector num_preds; // Number of predecessors for each task\nvector L; // Longest path length from each task\nvector max_d; // Max requirement for each skill\n\n// --- State ---\nint current_day;\nvector task_status; // 0: todo, 1: doing, 2: done\nvector completed_preds_count;\nvector member_busy;\nvector member_task; // task assigned to member\nvector member_start_day;\nvector> s_est; // Estimated skills for each member\nvector num_tasks_done;\n\n// --- Helper function for topological sort ---\nvector topological_sort(const vector>& graph) {\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int v : graph[i]) {\n in_degree[v]++;\n }\n }\n queue q;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n q.push(i);\n }\n }\n vector order;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n order.push_back(u);\n for (int v : graph[u]) {\n if (--in_degree[v] == 0) {\n q.push(v);\n }\n }\n }\n return order;\n}\n\n// --- Main function ---\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // --- Input Reading ---\n cin >> N >> M >> K >> R;\n d.resize(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n cin >> d[i][j];\n }\n }\n\n pred.resize(N);\n succ.resize(N);\n num_preds.resize(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--; // 0-based\n pred[v].push_back(u);\n succ[u].push_back(v);\n num_preds[v]++;\n }\n\n // --- Preprocessing ---\n // Calculate max_d\n max_d.assign(K, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n max_d[k] = max(max_d[k], d[i][k]);\n }\n }\n\n // Calculate L (longest path length)\n vector topo_order = topological_sort(pred); // Sort by preds\n L.assign(N, 1);\n for (auto it = topo_order.rbegin(); it != topo_order.rend(); ++it) {\n int u = *it;\n for (int v : succ[u]) {\n L[u] = max(L[u], 1 + L[v]);\n }\n }\n\n // --- State Initialization ---\n current_day = 1;\n task_status.assign(N, 0);\n completed_preds_count.assign(N, 0);\n member_busy.assign(M, false);\n member_task.assign(M, -1);\n member_start_day.assign(M, -1);\n s_est.assign(M, vector(K, 0.0));\n num_tasks_done.assign(M, 0);\n\n // --- Main Loop ---\n while (true) {\n // --- Step 1: Update State and Learn ---\n string line;\n getline(cin, line); // consume the rest of the previous line, if any\n getline(cin, line);\n istringstream iss(line);\n int n;\n iss >> n;\n if (n == -1) {\n break;\n }\n\n for (int i = 0; i < n; ++i) {\n int f_j;\n iss >> f_j;\n int j = f_j - 1; // 0-based index\n\n int t_id = member_task[j];\n int start_day = member_start_day[j];\n int t_obs = (current_day - 1) - start_day + 1;\n\n task_status[t_id] = 2; // Mark as done\n member_busy[j] = false;\n member_task[j] = -1;\n\n for (int succ_task : succ[t_id]) {\n completed_preds_count[succ_task]++;\n }\n\n // Skill Update\n num_tasks_done[j]++;\n double lr = (t_obs > 1) ? 1.0 / sqrt(num_tasks_done[j]) : 0.1 / sqrt(num_tasks_done[j]);\n for (int k = 0; k < K; ++k) {\n if (d[t_id][k] > s_est[j][k]) {\n s_est[j][k] += lr;\n s_est[j][k] = min(s_est[j][k], (double)d[t_id][k]);\n s_est[j][k] = min(s_est[j][k], (double)max_d[k]);\n }\n }\n }\n \n // --- Step 2: Find Available Resources ---\n vector ready_tasks;\n for (int i = 0; i < N; ++i) {\n if (task_status[i] == 0 && completed_preds_count[i] == num_preds[i]) {\n ready_tasks.push_back(i);\n }\n }\n\n vector free_members;\n for (int j = 0; j < M; ++j) {\n if (!member_busy[j]) {\n free_members.push_back(j);\n }\n }\n\n // --- Step 3: Greedy Assignment ---\n vector> assignments;\n if (!ready_tasks.empty() && !free_members.empty()) {\n vector> pairs; // cost, -L[i], est_time, task_id, member_id\n for (int i : ready_tasks) {\n for (int j : free_members) {\n double w_est = 0.0;\n for (int k = 0; k < K; ++k) {\n w_est += max(0, d[i][k] - s_est[j][k]);\n }\n int est_time = max(1.0, w_est);\n double cost = (double)est_time / L[i];\n pairs.emplace_back(cost, -L[i], est_time, i, j);\n }\n }\n sort(pairs.begin(), pairs.end());\n\n vector task_used(N, false);\n vector member_used(M, false);\n for (const auto& p : pairs) {\n int i = get<3>(p);\n int j = get<4>(p);\n if (!task_used[i] && !member_used[j]) {\n assignments.emplace_back(j + 1, i + 1); // 1-based for output\n task_status[i] = 1; // Mark as in progress\n member_busy[j] = true;\n member_task[j] = i;\n member_start_day[j] = current_day;\n task_used[i] = true;\n member_used[j] = true;\n }\n }\n }\n\n // --- Step 4: Output and Flush ---\n cout << assignments.size();\n for (const auto& a : assignments) {\n cout << \" \" << a.first << \" \" << a.second;\n }\n cout << endl;\n cout.flush();\n\n // --- Step 5: Increment Day ---\n current_day++;\n }\n\n return 0;\n}","ahc006":"#include \n#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Order {\n int id, a, b, c, d;\n double dist_from_center;\n};\n\nstruct Point {\n int x, y;\n int type; // 0: start/end, 1: pickup, 2: delivery\n int order_id; // which order this point belongs to\n};\n\n// Manhattan distance\nint manhattan_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Calculate total route length\nint calculate_route_length(const vector& route) {\n int total = 0;\n for (int i = 0; i < route.size() - 1; i++) {\n total += manhattan_dist(route[i].x, route[i].y, route[i+1].x, route[i+1].y);\n }\n return total;\n}\n\n// Check if route is valid (pickup before delivery for all orders)\nbool is_valid_route(const vector& route, const vector& selected) {\n unordered_map pickup_pos, delivery_pos;\n for (int i = 0; i < route.size(); i++) {\n if (route[i].type == 1) {\n pickup_pos[route[i].order_id] = i;\n } else if (route[i].type == 2) {\n delivery_pos[route[i].order_id] = i;\n }\n }\n \n for (int i = 0; i < selected.size(); i++) {\n if (selected[i]) {\n if (pickup_pos[i] >= delivery_pos[i]) return false;\n }\n }\n return true;\n}\n\n// 2-opt improvement\nvector two_opt(const vector& route, const vector& selected) {\n if (route.size() < 4) return route;\n \n vector best = route;\n int best_len = calculate_route_length(best);\n \n for (int iter = 0; iter < 50; iter++) {\n for (int i = 1; i < route.size() - 2; i++) {\n for (int j = i + 1; j < route.size() - 1; j++) {\n vector new_route = route;\n reverse(new_route.begin() + i, new_route.begin() + j + 1);\n \n if (is_valid_route(new_route, selected)) {\n int new_len = calculate_route_length(new_route);\n if (new_len < best_len) {\n best = new_route;\n best_len = new_len;\n }\n }\n }\n }\n }\n \n return best;\n}\n\n// Swap two orders in the selection\nvector swap_orders(const vector& selected, const vector& orders, random_device& rd) {\n vector new_selected = selected;\n vector selected_orders, unselected_orders;\n \n for (int i = 0; i < orders.size(); i++) {\n if (selected[i]) selected_orders.push_back(i);\n else unselected_orders.push_back(i);\n }\n \n if (selected_orders.empty() || unselected_orders.empty()) return selected;\n \n uniform_int_distribution dist1(0, selected_orders.size() - 1);\n uniform_int_distribution dist2(0, unselected_orders.size() - 1);\n \n int idx1 = dist1(rd);\n int idx2 = dist2(rd);\n \n new_selected[selected_orders[idx1]] = false;\n new_selected[unselected_orders[idx2]] = true;\n \n return new_selected;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i;\n orders[i].dist_from_center = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n }\n \n // Sort orders by distance from center (prefer closer orders)\n sort(orders.begin(), orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_from_center < o2.dist_from_center;\n });\n \n random_device rd;\n mt19937 rng(rd());\n \n // Initial selection: pick 50 orders from the closest 200\n vector selected(1000, false);\n uniform_int_distribution dist(0, min(199, 999));\n \n unordered_set selected_set;\n while (selected_set.size() < 50) {\n int idx = dist(rng);\n if (selected_set.find(idx) == selected_set.end()) {\n selected_set.insert(idx);\n selected[orders[idx].id] = true;\n }\n }\n \n // Build initial route\n vector route;\n route.push_back({400, 400, 0, -1});\n \n // Add all pickup points\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n route.push_back({orders[i].a, orders[i].b, 1, i});\n }\n }\n \n // Add all delivery points\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n route.push_back({orders[i].c, orders[i].d, 2, i});\n }\n }\n \n route.push_back({400, 400, 0, -1});\n \n // Optimize with greedy nearest neighbor\n for (int iter = 0; iter < 3; iter++) {\n vector new_route;\n new_route.push_back({400, 400, 0, -1});\n \n vector visited(1000, false);\n int current_x = 400, current_y = 400;\n \n // Visit pickups first\n for (int count = 0; count < 50; count++) {\n int best_idx = -1;\n int best_dist = INT_MAX;\n \n for (int i = 0; i < 1000; i++) {\n if (selected[i] && !visited[i]) {\n int dist = manhattan_dist(current_x, current_y, orders[i].a, orders[i].b);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = i;\n }\n }\n }\n \n if (best_idx != -1) {\n new_route.push_back({orders[best_idx].a, orders[best_idx].b, 1, best_idx});\n current_x = orders[best_idx].a;\n current_y = orders[best_idx].b;\n visited[best_idx] = true;\n }\n }\n \n // Then deliveries\n for (int count = 0; count < 50; count++) {\n int best_idx = -1;\n int best_dist = INT_MAX;\n \n for (int i = 0; i < 1000; i++) {\n if (selected[i] && visited[i]) {\n int dist = manhattan_dist(current_x, current_y, orders[i].c, orders[i].d);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = i;\n }\n }\n }\n \n if (best_idx != -1) {\n new_route.push_back({orders[best_idx].c, orders[best_idx].d, 2, best_idx});\n current_x = orders[best_idx].c;\n current_y = orders[best_idx].d;\n }\n }\n \n new_route.push_back({400, 400, 0, -1});\n \n if (calculate_route_length(new_route) < calculate_route_length(route)) {\n route = new_route;\n }\n }\n \n // Apply 2-opt\n route = two_opt(route, selected);\n \n // Simulated annealing for order swapping\n double temp = 100.0;\n double cooling_rate = 0.95;\n int current_length = calculate_route_length(route);\n \n for (int iter = 0; iter < 100; iter++) {\n temp *= cooling_rate;\n \n for (int inner = 0; inner < 10; inner++) {\n vector new_selected = swap_orders(selected, orders, rd);\n \n // Build new route for this selection\n vector new_route;\n new_route.push_back({400, 400, 0, -1});\n \n // Add pickups\n for (int i = 0; i < 1000; i++) {\n if (new_selected[i]) {\n new_route.push_back({orders[i].a, orders[i].b, 1, i});\n }\n }\n \n // Add deliveries\n for (int i = 0; i < 1000; i++) {\n if (new_selected[i]) {\n new_route.push_back({orders[i].c, orders[i].d, 2, i});\n }\n }\n \n new_route.push_back({400, 400, 0, -1});\n \n // Optimize with 2-opt\n new_route = two_opt(new_route, new_selected);\n \n int new_length = calculate_route_length(new_route);\n \n // Accept if better or with probability\n if (new_length < current_length || \n exp((current_length - new_length) / temp) > (double)rng() / rng.max()) {\n selected = new_selected;\n route = new_route;\n current_length = new_length;\n }\n }\n }\n \n // Final 2-opt optimization\n route = two_opt(route, selected);\n \n // Output result\n vector selected_ids;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_ids.push_back(i + 1); // Convert to 1-based\n }\n }\n \n cout << 50;\n for (int id : selected_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n \n cout << route.size();\n for (const auto& p : route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Global constants as per problem statement\nconst int N = 400;\nconst int M = 1995;\n\n// Main solver class/structure\nstruct OnlineMST {\n int n, m;\n vector> points;\n vector> edges;\n vector> dist_mat;\n vector> min_dist;\n dsu d;\n set active_roots;\n int num_components;\n\n // Tunable parameters\n const double k_base = 2.5;\n const int desperation_threshold = 5;\n\n OnlineMST() : n(N), m(M), d(N) {\n points.resize(n);\n edges.resize(m);\n dist_mat.assign(n, vector(n, 0));\n min_dist.assign(n, vector(n, 0));\n num_components = n;\n for (int i = 0; i < n; ++i) {\n active_roots.insert(i);\n }\n }\n\n // Helper function to calculate rounded distance\n int calc_dist(int i, int j) {\n long long dx = points[i].first - points[j].first;\n long long dy = points[i].second - points[j].second;\n return (int)round(sqrt(dx * dx + dy * dy));\n }\n\n void preprocess() {\n // Calculate all-pairs distances\n for (int i = 0; i < n; ++i) {\n for (int j = i + 1; j < n; ++j) {\n dist_mat[i][j] = calc_dist(i, j);\n dist_mat[j][i] = dist_mat[i][j];\n }\n }\n // Initialize min_dist with dist_mat\n min_dist = dist_mat;\n }\n\n void update_min_dist(int new_root, int old_root_u, int old_root_v) {\n // min_dist for the new component is the min of the two old components\n for (int c : active_roots) {\n if (c == new_root) continue;\n min_dist[new_root][c] = min(min_dist[old_root_u][c], min_dist[old_root_v][c]);\n min_dist[c][new_root] = min_dist[new_root][c];\n }\n }\n\n bool decide(int edge_idx, int l) {\n auto [u, v] = edges[edge_idx];\n int root_u = d.leader(u);\n int root_v = d.leader(v);\n\n // If already connected, must reject\n if (root_u == root_v) {\n return false;\n }\n\n int remaining_edges = m - edge_idx;\n\n // Decision logic\n bool take = false;\n if (remaining_edges <= num_components + desperation_threshold) {\n // Desperation mode: take any connecting edge to ensure completion\n take = true;\n } else {\n // Normal mode: use dynamic threshold\n int d_min = min_dist[root_u][root_v];\n \n // desperation_factor is 0 at start, approaches 1 at the end\n double desperation_factor = (double)(num_components - 1) / remaining_edges;\n double k = k_base - (k_base - 1.0) * desperation_factor;\n \n if (l <= k * d_min) {\n take = true;\n }\n }\n\n if (take) {\n // Update state\n d.merge(root_u, root_v);\n num_components--;\n\n int new_root = d.leader(u); // leader of either is fine after merge\n int old_root = (new_root == root_u) ? root_v : root_u;\n \n active_roots.erase(old_root);\n update_min_dist(new_root, root_u, root_v);\n }\n\n return take;\n }\n\n void run() {\n // Read initial input\n for (int i = 0; i < n; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n for (int i = 0; i < m; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n preprocess();\n\n // Main loop\n for (int i = 0; i < m; ++i) {\n int l;\n cin >> l;\n\n bool decision = decide(i, l);\n\n cout << (decision ? 1 : 0) << endl;\n cout.flush();\n }\n }\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n OnlineMST solver;\n solver.run();\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct State {\n int N, M;\n vector> pets, humans;\n vector pet_types;\n vector> impassable;\n vector pet_moves;\n int turn;\n \n void read() {\n cin >> N;\n pets.resize(N);\n pet_types.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].first >> pets[i].second >> pet_types[i];\n }\n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].first >> humans[i].second;\n }\n impassable.assign(31, vector(31, false));\n turn = 0;\n }\n \n void read_pet_moves() {\n pet_moves.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n }\n \n bool is_valid(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n bool is_passable(int x, int y) {\n return is_valid(x, y) && !impassable[x][y];\n }\n \n bool has_pet_adjacent(int x, int y) {\n for (auto [px, py] : pets) {\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return true;\n }\n return false;\n }\n \n bool can_make_impassable(int x, int y, vector>& current_pets) {\n if (!is_valid(x, y)) return false;\n for (auto [px, py] : current_pets) {\n if (px == x && py == y) return false;\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return false;\n }\n for (auto [hx, hy] : humans) {\n if (hx == x && hy == y) return false;\n }\n return true;\n }\n \n vector> get_neighbors(int x, int y) {\n return {{x-1, y}, {x+1, y}, {x, y-1}, {x, y+1}};\n }\n \n vector get_dir_chars() {\n return {'u', 'd', 'l', 'r', 'U', 'D', 'L', 'R'};\n }\n \n char get_make_impassable_dir(int hx, int hy, int tx, int ty) {\n if (tx == hx-1 && ty == hy) return 'u';\n if (tx == hx+1 && ty == hy) return 'd';\n if (tx == hy-1 && ty == hx) return 'l';\n if (tx == hy+1 && ty == hx) return 'r';\n return '.';\n }\n \n char get_move_dir(int hx, int hy, int tx, int ty) {\n if (tx == hx-1 && ty == hy) return 'U';\n if (tx == hx+1 && ty == hy) return 'D';\n if (tx == hx && ty == hy-1) return 'L';\n if (tx == hx && ty == hy+1) return 'R';\n return '.';\n }\n \n pair find_best_wall_position(int human_idx) {\n auto [hx, hy] = humans[human_idx];\n int best_score = -1e9;\n pair best_pos = {-1, -1};\n \n // Priority 1: Block dangerous pets (dogs/cats)\n for (int i = 0; i < N; i++) {\n if (pet_types[i] == 4 || pet_types[i] == 5) { // dog or cat\n auto [px, py] = pets[i];\n int dist = abs(px - hx) + abs(py - hy);\n if (dist <= 5) { // Close enough to be a threat\n // Try to build wall between human and pet\n for (int x = min(px, hx); x <= max(px, hx); x++) {\n for (int y = min(py, hy); y <= max(py, hy); y++) {\n if (can_make_impassable(x, y, pets) && !impassable[x][y]) {\n int score = 100 - dist;\n if (score > best_score) {\n best_score = score;\n best_pos = {x, y};\n }\n }\n }\n }\n }\n }\n }\n \n if (best_pos.first != -1) return best_pos;\n \n // Priority 2: Create barriers around pet clusters\n vector> pet_density(31, vector(31, 0));\n for (auto [px, py] : pets) {\n for (int dx = -2; dx <= 2; dx++) {\n for (int dy = -2; dy <= 2; dy++) {\n int nx = px + dx, ny = py + dy;\n if (is_valid(nx, ny)) {\n pet_density[nx][ny] += 3 - abs(dx) - abs(dy);\n }\n }\n }\n }\n \n for (int x = 1; x <= 30; x++) {\n for (int y = 1; y <= 30; y++) {\n if (can_make_impassable(x, y, pets) && !impassable[x][y]) {\n int score = pet_density[x][y];\n // Prefer positions that complete walls\n int adj_walls = 0;\n for (auto [nx, ny] : get_neighbors(x, y)) {\n if (impassable[nx][ny]) adj_walls++;\n }\n score += adj_walls * 5;\n \n if (score > best_score) {\n best_score = score;\n best_pos = {x, y};\n }\n }\n }\n }\n \n return best_pos;\n }\n \n pair find_best_move_position(int human_idx) {\n auto [hx, hy] = humans[human_idx];\n int best_score = -1e9;\n pair best_pos = {hx, hy};\n \n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n // Calculate reachable area from this position\n vector> visited(31, vector(31, false));\n queue> q;\n q.push({nx, ny});\n visited[nx][ny] = true;\n int area = 0;\n int pets_in_area = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n area++;\n \n for (auto [px, py] : pets) {\n if (px == x && py == y) pets_in_area++;\n }\n \n for (auto [tx, ty] : get_neighbors(x, y)) {\n if (is_passable(tx, ty) && !visited[tx][ty]) {\n visited[tx][ty] = true;\n q.push({tx, ty});\n }\n }\n }\n \n double score = area * pow(0.5, pets_in_area);\n \n // Prefer center positions\n int center_dist = abs(nx - 15) + abs(ny - 15);\n score -= center_dist * 0.1;\n \n if (score > best_score) {\n best_score = score;\n best_pos = {nx, ny};\n }\n }\n }\n \n return best_pos;\n }\n \n string decide_actions() {\n string actions(M, '.');\n \n for (int i = 0; i < M; i++) {\n if (turn < 150) {\n // Phase 1: Focus on building barriers\n auto [wx, wy] = find_best_wall_position(i);\n if (wx != -1) {\n // Check if we can make this adjacent square impassable\n for (auto [nx, ny] : get_neighbors(humans[i].first, humans[i].second)) {\n if (nx == wx && ny == wy) {\n actions[i] = get_make_impassable_dir(humans[i].first, humans[i].second, wx, wy);\n break;\n }\n }\n }\n \n if (actions[i] == '.') {\n // Move closer to the best wall position\n auto [tx, ty] = find_best_wall_position(i);\n if (tx != -1) {\n int best_dist = abs(humans[i].first - tx) + abs(humans[i].second - ty);\n char best_move = '.';\n \n for (auto [nx, ny] : get_neighbors(humans[i].first, humans[i].second)) {\n if (is_passable(nx, ny)) {\n int dist = abs(nx - tx) + abs(ny - ty);\n if (dist < best_dist) {\n best_dist = dist;\n best_move = get_move_dir(humans[i].first, humans[i].second, nx, ny);\n }\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n } else {\n // Phase 2: Focus on positioning for maximum reachability\n auto [mx, my] = find_best_move_position(i);\n if (mx != humans[i].first || my != humans[i].second) {\n for (auto [nx, ny] : get_neighbors(humans[i].first, humans[i].second)) {\n if (nx == mx && ny == my) {\n actions[i] = get_move_dir(humans[i].first, humans[i].second, nx, ny);\n break;\n }\n }\n }\n }\n }\n \n return actions;\n }\n \n void update_state(const string& actions) {\n // Update impassable squares\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'u' || action == 'd' || action == 'l' || action == 'r') {\n int nx = hx, ny = hy;\n if (action == 'u') nx--;\n else if (action == 'd') nx++;\n else if (action == 'l') ny--;\n else if (action == 'r') ny++;\n \n if (can_make_impassable(nx, ny, pets)) {\n impassable[nx][ny] = true;\n }\n }\n }\n \n // Update human positions\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int nx = hx, ny = hy;\n if (action == 'U') nx--;\n else if (action == 'D') nx++;\n else if (action == 'L') ny--;\n else if (action == 'R') ny++;\n \n if (is_passable(nx, ny)) {\n humans[i] = {nx, ny};\n }\n }\n }\n \n // Update pet positions based on their moves\n for (int i = 0; i < N; i++) {\n auto [px, py] = pets[i];\n for (char move : pet_moves[i]) {\n if (move == 'U' && is_passable(px-1, py)) px--;\n else if (move == 'D' && is_passable(px+1, py)) px++;\n else if (move == 'L' && is_passable(px, py-1)) py--;\n else if (move == 'R' && is_passable(px, py+1)) py++;\n }\n pets[i] = {px, py};\n }\n \n turn++;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n State state;\n state.read();\n \n for (int turn = 0; turn < 300; turn++) {\n string actions = state.decide_actions();\n cout << actions << endl;\n cout.flush();\n \n state.read_pet_moves();\n state.update_state(actions);\n }\n \n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n string path;\n double success_prob;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h(20), v(19);\n for (int i = 0; i < 20; i++) cin >> h[i];\n for (int i = 0; i < 19; i++) cin >> v[i];\n \n // Find multiple paths using BFS with different strategies\n vector candidate_paths;\n \n // Strategy 1: Shortest path\n auto find_path = [&](bool prefer_straight = false) {\n queue q;\n vector> visited(20, vector(20, false));\n vector> path_str(20, vector(20, \"\"));\n \n q.push({si, sj, \"\", 1.0});\n visited[si][sj] = true;\n \n int dirs[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};\n string dir_chars = \"UDLR\";\n \n string best_path = \"\";\n double best_prob = 0;\n \n while (!q.empty()) {\n State cur = q.front(); q.pop();\n \n if (cur.i == ti && cur.j == tj) {\n if (cur.path.size() < best_path.size() || best_path.empty()) {\n best_path = cur.path;\n best_prob = cur.success_prob;\n }\n continue;\n }\n \n if (!best_path.empty() && cur.path.size() >= best_path.size()) continue;\n \n for (int d = 0; d < 4; d++) {\n int ni = cur.i + dirs[d][0];\n int nj = cur.j + dirs[d][1];\n \n if (ni < 0 || ni >= 20 || nj < 0 || nj >= 20) continue;\n if (visited[ni][nj]) continue;\n \n // Check wall\n bool blocked = false;\n if (d == 0 && cur.i > 0 && v[cur.i-1][cur.j] == '1') blocked = true;\n else if (d == 1 && cur.i < 19 && v[cur.i][cur.j] == '1') blocked = true;\n else if (d == 2 && cur.j > 0 && h[cur.i][cur.j-1] == '1') blocked = true;\n else if (d == 3 && cur.j < 19 && h[cur.i][cur.j] == '1') blocked = true;\n \n if (!blocked) {\n visited[ni][nj] = true;\n double new_prob = cur.success_prob * (1 - p);\n q.push({ni, nj, cur.path + dir_chars[d], new_prob});\n }\n }\n }\n \n return best_path;\n };\n \n string shortest = find_path();\n if (shortest.empty()) {\n cout << \"\" << endl;\n return 0;\n }\n \n // Analyze path to determine critical moves\n vector critical_moves(shortest.size(), 1);\n \n // Moves near obstacles or changes in direction are more critical\n for (int i = 0; i < shortest.size(); i++) {\n int weight = 1;\n \n // Direction changes are critical\n if (i > 0 && shortest[i] != shortest[i-1]) weight++;\n if (i < shortest.size()-1 && shortest[i] != shortest[i+1]) weight++;\n \n // Start and end moves are critical\n if (i < 2 || i > shortest.size() - 3) weight++;\n \n critical_moves[i] = weight;\n }\n \n // Build robust path with adaptive repetition\n string robust_path = \"\";\n int base_repeat = max(2, min(6, (int)(p * 8)));\n \n for (int i = 0; i < shortest.size(); i++) {\n int repeat = base_repeat;\n \n // Adjust based on criticality\n if (critical_moves[i] >= 3) repeat++;\n if (critical_moves[i] >= 4) repeat++;\n \n // Ensure we don't exceed length limit\n int remaining = shortest.size() - i - 1;\n int max_possible = (200 - robust_path.size()) / (remaining + 1);\n repeat = min(repeat, max(1, max_possible));\n \n for (int j = 0; j < repeat; j++) {\n robust_path += shortest[i];\n }\n }\n \n // If we have extra space, add strategic redundancy\n if (robust_path.size() < 180) {\n // Add the most critical part again\n int start_idx = max(0, (int)shortest.size() - 8);\n for (int i = start_idx; i < shortest.size(); i++) {\n if (robust_path.size() >= 200) break;\n robust_path += shortest[i];\n }\n }\n \n // Final safety check - add more redundancy to first and last moves\n if (shortest.size() > 0 && robust_path.size() < 190) {\n string prefix = shortest.substr(0, min(3, (int)shortest.size()));\n string suffix = shortest.substr(max(0, (int)shortest.size() - 3));\n \n for (char c : prefix) {\n if (robust_path.size() >= 200) break;\n robust_path = string(1, c) + robust_path;\n }\n \n for (char c : suffix) {\n if (robust_path.size() >= 200) break;\n robust_path += c;\n }\n }\n \n cout << robust_path << endl;\n \n return 0;\n}","ahc010":"#include \nusing namespace std;\n\n// Directions: 0=left, 1=up, 2=right, 3=down\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Connection table: to[tile_type][entry_direction] = exit_direction\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// Get tile type after rotation\nint rotate_tile(int tile, int rotations) {\n rotations %= 4;\n if (tile <= 3) { // curved tiles\n return (tile + rotations) % 4;\n } else if (tile <= 5) { // double curved tiles\n return tile + (rotations % 2);\n } else { // straight tiles\n return tile + (rotations % 2);\n }\n}\n\nstruct Grid {\n int tiles[30][30]; // Original tile types\n int rotations[30][30]; // Current rotations (0-3)\n \n Grid() {}\n \n Grid(const vector& input) {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n tiles[i][j] = input[i][j] - '0';\n rotations[i][j] = 0;\n }\n }\n }\n \n int get_tile_type(int i, int j) const {\n return rotate_tile(tiles[i][j], rotations[i][j]);\n }\n \n // Calculate loop length starting from (i,j) with entry direction d\n int calculate_loop_length(int si, int sj, int sd) const {\n int i = si, j = sj, d = sd;\n int length = 0;\n \n do {\n int tile_type = get_tile_type(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0;\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n \n d = (d2 + 2) % 4;\n length++;\n \n if (length > 900) return 0; // Prevent infinite loops\n \n } while (!(i == si && j == sj && d == sd));\n \n return length;\n }\n \n // Find top two loop lengths\n pair find_top_loops() const {\n vector loops;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n loops.push_back(length);\n }\n }\n }\n }\n \n sort(loops.rbegin(), loops.rend());\n \n if (loops.size() < 2) return {0, 0};\n \n // Remove duplicates (same loop might be found from multiple starting points)\n vector unique_loops;\n for (int i = 0; i < loops.size(); i++) {\n bool is_duplicate = false;\n for (int j = 0; j < i; j++) {\n if (loops[i] == loops[j]) {\n is_duplicate = true;\n break;\n }\n }\n if (!is_duplicate) {\n unique_loops.push_back(loops[i]);\n }\n }\n \n if (unique_loops.size() < 2) return {0, 0};\n \n return {unique_loops[0], unique_loops[1]};\n }\n \n long long calculate_score() const {\n auto [l1, l2] = find_top_loops();\n return (long long)l1 * l2;\n }\n \n void randomize_rotations() {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rotations[i][j] = dis(gen);\n }\n }\n }\n \n void hill_climb(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n if (new_score > best_score) {\n best_score = new_score;\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n void simulated_annealing(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n uniform_real_distribution<> prob(0.0, 1.0);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n double temperature = 1.0 - (double)it / iterations;\n double acceptance = exp((new_score - best_score) / max(1.0, temperature * 1000.0));\n \n if (new_score > best_score || prob(gen) < acceptance) {\n best_score = max(best_score, new_score);\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n string get_output() const {\n string result;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n result += to_string(rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector input(30);\n for (int i = 0; i < 30; i++) {\n cin >> input[i];\n }\n \n Grid grid(input);\n \n // Try multiple random initializations and keep the best\n long long best_score = 0;\n string best_output;\n \n for (int attempt = 0; attempt < 10; attempt++) {\n grid.randomize_rotations();\n \n // Hill climbing\n grid.hill_climb(10000);\n \n // Simulated annealing\n grid.simulated_annealing(50000);\n \n long long current_score = grid.calculate_score();\n if (current_score > best_score) {\n best_score = current_score;\n best_output = grid.get_output();\n }\n }\n \n cout << best_output << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct UnionFind {\n vector p, r;\n UnionFind(int n) : p(n), r(n, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (r[x] < r[y]) p[x] = y;\n else { p[y] = x; if (r[x] == r[y]) r[x]++; }\n }\n};\n\nclass Solver {\npublic:\n Solver(int n, int t, const vector& grid) : N(n), T(t) {\n board.resize(N, vector(N, 0));\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n char ch = grid[r][c];\n if (ch >= '0' && ch <= '9') {\n board[r][c] = ch - '0';\n } else {\n board[r][c] = 10 + (ch - 'a');\n }\n if (board[r][c] == 0) {\n empty_r = r;\n empty_c = c;\n }\n }\n }\n }\n\n string solve() {\n auto start_time = chrono::high_resolution_clock::now();\n \n // Phase 1: Simulated Annealing with E_correct heuristic\n vector> best_E_board = board;\n int best_E_score = calculate_E_score(best_E_board);\n string best_E_path = \"\";\n\n vector> best_S_board = board;\n int best_S_score = calculate_S_score(best_S_board);\n string best_S_path = \"\";\n\n vector> current_board = board;\n int current_er = empty_r, current_ec = empty_c;\n int current_E_score = best_E_score;\n string current_path = \"\";\n\n mt19937 rng(random_device{}());\n uniform_real_distribution dist(0.0, 1.0);\n\n double temp = 10.0;\n double cooling_rate = 0.99995;\n long long iter = 0;\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.5) break;\n\n int move_len = 15 + rng() % 20;\n \n vector> candidate_board = current_board;\n int candidate_er = current_er, candidate_ec = current_ec;\n string candidate_moves = generate_random_moves(move_len, candidate_board, candidate_er, candidate_ec);\n\n int candidate_E_score = calculate_E_score(candidate_board);\n\n int delta_E = candidate_E_score - current_E_score;\n\n if (delta_E > 0 || exp(delta_E / temp) > dist(rng)) {\n current_board = candidate_board;\n current_er = candidate_er;\n current_ec = candidate_ec;\n current_E_score = candidate_E_score;\n current_path += candidate_moves;\n }\n\n if (candidate_E_score > best_E_score) {\n best_E_score = candidate_E_score;\n best_E_board = candidate_board;\n best_E_path = current_path;\n }\n \n if (iter % 500 == 0) {\n int current_S_score = calculate_S_score(current_board);\n if (current_S_score > best_S_score) {\n best_S_score = current_S_score;\n best_S_board = current_board;\n best_S_path = current_path;\n }\n }\n \n temp *= cooling_rate;\n iter++;\n }\n \n // Ensure we have the best S found so far\n if (calculate_S_score(best_E_board) > best_S_score) {\n best_S_score = calculate_S_score(best_E_board);\n best_S_board = best_E_board;\n best_S_path = best_E_path;\n }\n\n // Phase 2: Local Refinement with S_score heuristic\n vector> lr_board = best_S_board;\n int lr_er = -1, lr_ec = -1;\n for(int r=0; r(current_time - start_time).count();\n if (elapsed > 2.9) break;\n\n char best_move = ' ';\n int best_delta_S = -1;\n\n vector moves;\n if (lr_er > 0) moves.push_back('D');\n if (lr_er < N - 1) moves.push_back('U');\n if (lr_ec > 0) moves.push_back('R');\n if (lr_ec < N - 1) moves.push_back('L');\n \n for(char m : moves) {\n vector> temp_board = lr_board;\n int temp_er = lr_er, temp_ec = lr_ec;\n apply_move(m, temp_board, temp_er, temp_ec);\n \n int new_S = calculate_S_score(temp_board);\n int delta_S = new_S - current_S;\n \n if (delta_S > best_delta_S) {\n best_delta_S = delta_S;\n best_move = m;\n }\n }\n\n if (best_delta_S > 0) {\n apply_move(best_move, lr_board, lr_er, lr_ec);\n lr_path.push_back(best_move);\n current_S += best_delta_S;\n } else {\n break; // Local optimum\n }\n }\n\n string final_path = best_S_path + lr_path;\n if (final_path.length() > T) {\n final_path = final_path.substr(0, T);\n }\n\n return final_path;\n }\n\nprivate:\n int N, T;\n vector> board;\n int empty_r, empty_c;\n\n int calculate_E_score(const vector>& b) {\n int score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N - 1; ++c) {\n if ((b[r][c] & 4) && (b[r][c+1] & 1)) score++;\n }\n }\n for (int r = 0; r < N - 1; ++r) {\n for (int c = 0; c < N; ++c) {\n if ((b[r][c] & 8) && (b[r+1][c] & 2)) score++;\n }\n }\n return score;\n }\n\n int calculate_S_score(const vector>& b) {\n UnionFind uf(N * N);\n vector num_edges(N * N, 0);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N - 1; ++c) {\n if (b[r][c] != 0 && b[r][c+1] != 0 && (b[r][c] & 4) && (b[r][c+1] & 1)) {\n int u = r * N + c;\n int v = r * N + (c + 1);\n int root = uf.find(u);\n uf.unite(u, v);\n int new_root = uf.find(u);\n if (new_root != root) num_edges[new_root] += num_edges[root] + 1;\n else num_edges[new_root]++;\n }\n }\n }\n for (int r = 0; r < N - 1; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] != 0 && b[r+1][c] != 0 && (b[r][c] & 8) && (b[r+1][c] & 2)) {\n int u = r * N + c;\n int v = (r + 1) * N + c;\n int root = uf.find(u);\n uf.unite(u, v);\n int new_root = uf.find(u);\n if (new_root != root) num_edges[new_root] += num_edges[root] + 1;\n else num_edges[new_root]++;\n }\n }\n }\n\n int max_S = 0;\n vector component_size(N * N, 0);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] != 0) {\n int node = r * N + c;\n component_size[uf.find(node)]++;\n }\n }\n }\n \n for (int i = 0; i < N * N; ++i) {\n if (component_size[i] > 0) {\n int root = uf.find(i);\n if (num_edges[root] == component_size[root] - 1) {\n max_S = max(max_S, component_size[root]);\n }\n }\n }\n return max_S;\n }\n\n void apply_move(char m, vector>& b, int& er, int& ec) {\n int tr = er, tc = ec;\n if (m == 'U') tr++;\n else if (m == 'D') tr--;\n else if (m == 'L') tc++;\n else if (m == 'R') tc--;\n\n if (tr >= 0 && tr < N && tc >= 0 && tc < N) {\n swap(b[er][ec], b[tr][tc]);\n er = tr;\n ec = tc;\n }\n }\n\n string generate_random_moves(int len, vector>& b, int& er, int& ec) {\n string moves;\n mt19937 rng(random_device{}());\n for (int i = 0; i < len; ++i) {\n vector possible_moves;\n if (er > 0) possible_moves.push_back('D');\n if (er < N - 1) possible_moves.push_back('U');\n if (ec > 0) possible_moves.push_back('R');\n if (ec < N - 1) possible_moves.push_back('L');\n\n if (!possible_moves.empty()) {\n char m = possible_moves[rng() % possible_moves.size()];\n moves += m;\n apply_move(m, b, er, ec);\n }\n }\n return moves;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, T;\n cin >> N >> T;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n Solver solver(N, T, grid);\n string ans = solver.solve();\n cout << ans << endl;\n\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global random number generator\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nconst long double EPS = 1e-9;\nconst long long COORD_MAX = 1e9;\n\nstruct Point {\n long long x, y;\n Point(long long x = 0, long long y = 0) : x(x), y(y) {}\n};\n\nstruct Line {\n Point p1, p2;\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\nlong double dist_sq(const Point& a, const Point& b) {\n long long dx = a.x - b.x;\n long long dy = a.y - b.y;\n return (long double)dx * dx + (long double)dy * dy;\n}\n\n// Returns 1 if a is on the left of line p1p2, -1 if on the right, 0 if on the line\nint get_side(const Point& a, const Point& p1, const Point& p2) {\n long double val = (long double)(p2.x - p1.x) * (p1.y - a.y) - (long double)(p2.y - p1.y) * (p1.x - a.x);\n if (val > EPS) return 1;\n if (val < -EPS) return -1;\n return 0;\n}\n\n// Finds k-nearest neighbors of target_idx from active_indices\n// Returns a vector of indices of the neighbors\nvector find_k_nearest(int target_idx, const vector& points, const vector& active_indices, int k) {\n vector> dists;\n const Point& target = points[target_idx];\n for (int idx : active_indices) {\n if (idx == target_idx) continue;\n dists.push_back({dist_sq(target, points[idx]), idx});\n }\n \n sort(dists.begin(), dists.end());\n\n vector neighbors;\n for (int i = 0; i < min(k, (int)dists.size()); ++i) {\n neighbors.push_back(dists[i].second);\n }\n return neighbors;\n}\n\n// Finds the closest pair of points between two sets\n// Returns a pair of indices {idx_from_set1, idx_from_set2}\npair find_closest_pair(const vector& points, const vector& set1, const vector& set2) {\n long double min_dist = 1e30;\n pair closest_pair = {-1, -1};\n\n for (int idx1 : set1) {\n for (int idx2 : set2) {\n long double d = dist_sq(points[idx1], points[idx2]);\n if (d < min_dist) {\n min_dist = d;\n closest_pair = {idx1, idx2};\n }\n }\n }\n return closest_pair;\n}\n\n// Constructs two integer points defining the perpendicular bisector of p1p2\n// Returns false if no such integer points exist (when dx, dy have different parity)\nbool construct_bisector(const Point& p1, const Point& p2, Line& cut_line) {\n long long dx = p2.x - p1.x;\n long long dy = p2.y - p1.y;\n\n // Perpendicular direction vector\n long long perp_dx = -dy;\n long long perp_dy = dx;\n\n // Check if bisector can have integer points\n // This is true if and only if dx and dy have the same parity\n if ((dx % 2 + 2) % 2 != (dy % 2 + 2) % 2) {\n return false;\n }\n\n // Midpoint\n long double mid_x = (long double)(p1.x + p2.x) / 2.0;\n long double mid_y = (long double)(p1.y + p2.y) / 2.0;\n \n // A point on the line is (mid_x, mid_y). Direction is (perp_dx, perp_dy).\n // We need to find two integer points on this line.\n // A point P(t) on the line is P(t) = (mid_x, mid_y) + t * (perp_dx, perp_dy).\n // We need P(t) to have integer coordinates.\n // P_x = (p1.x+p2.x)/2 + t*perp_dx\n // P_y = (p1.y+p2.y)/2 + t*perp_dy\n \n // Since dx, dy have same parity, p1+p2 has even component sums.\n // So (p1.x+p2.x)/2 and (p1.y+p2.y)/2 are integers.\n // We can choose t to be any integer.\n long long t = COORD_MAX / max(abs(perp_dx), abs(perp_dy)) + 1;\n \n Point p_mid = {(p1.x + p2.x) / 2, (p1.y + p2.y) / 2};\n\n cut_line.p1 = {p_mid.x + perp_dx * t, p_mid.y + perp_dy * t};\n cut_line.p2 = {p_mid.x - perp_dx * t, p_mid.y - perp_dy * t};\n \n return true;\n}\n\n// Verifies if a line separates two sets of points without cutting any\nbool verify_cut(const Line& cut, const vector& points, const vector& set1, const vector& set2) {\n if (set1.empty() || set2.empty()) return true;\n\n int side1 = get_side(points[set1[0]], cut.p1, cut.p2);\n if (side1 == 0) return false; // A point is on the line\n\n for (int idx : set1) {\n if (get_side(points[idx], cut.p1, cut.p2) != side1) {\n return false; // Not all points in set1 are on the same side\n }\n }\n\n int side2 = get_side(points[set2[0]], cut.p1, cut.p2);\n if (side2 == 0 || side1 == side2) return false; // Point on line or sets not separated\n\n for (int idx : set2) {\n if (get_side(points[idx], cut.p1, cut.p2) != side2) {\n return false; // Not all points in set2 are on the same side\n }\n }\n\n return true;\n}\n\nvoid solve() {\n int N, K;\n cin >> N >> K;\n K = 100; // K is fixed to 100 as per problem statement\n\n vector a(11);\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n\n vector points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n\n vector is_active(N, true);\n vector cuts;\n int total_needs = accumulate(a.begin(), a.end(), 0);\n\n for (int iter = 0; iter < K; ++iter) {\n if (total_needs == 0) break;\n\n vector active_indices;\n for (int i = 0; i < N; ++i) {\n if (is_active[i]) {\n active_indices.push_back(i);\n }\n }\n if (active_indices.empty()) break;\n\n shuffle(active_indices.begin(), active_indices.end(), rng);\n\n bool found_piece = false;\n vector ds_to_try(10);\n iota(ds_to_try.begin(), ds_to_try.end(), 1);\n shuffle(ds_to_try.begin(), ds_to_try.end(), rng);\n\n for (int d : ds_to_try) {\n if (a[d] == 0) continue;\n\n for (int seed_idx : active_indices) {\n vector neighbors = find_k_nearest(seed_idx, points, active_indices, d - 1);\n if (neighbors.size() < d - 1) continue;\n\n vector group_indices = {seed_idx};\n group_indices.insert(group_indices.end(), neighbors.begin(), neighbors.end());\n \n vector rest_indices;\n for (int idx : active_indices) {\n if (find(group_indices.begin(), group_indices.end(), idx) == group_indices.end()) {\n rest_indices.push_back(idx);\n }\n }\n\n if (rest_indices.empty()) {\n // All remaining strawberries form the last piece\n a[d]--;\n total_needs--;\n for (int idx : group_indices) is_active[idx] = false;\n found_piece = true;\n break;\n }\n\n pair closest = find_closest_pair(points, group_indices, rest_indices);\n \n Line cut;\n if (!construct_bisector(points[closest.first], points[closest.second], cut)) {\n continue; // Cannot define this cut with integer points\n }\n\n if (verify_cut(cut, points, group_indices, rest_indices)) {\n cuts.push_back(cut);\n a[d]--;\n total_needs--;\n for (int idx : group_indices) is_active[idx] = false;\n found_piece = true;\n break;\n }\n }\n if (found_piece) break;\n }\n if (!found_piece) {\n // Can't find any more pieces, stop trying\n break;\n }\n }\n\n cout << cuts.size() << endl;\n for (const auto& cut : cuts) {\n cout << cut.p1.x << \" \" << cut.p1.y << \" \" << cut.p2.x << \" \" << cut.p2.y << \"\\n\";\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\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 bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n Point p1, p2, p3, p4;\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_dots(M);\n set dots;\n map> x_to_ys; // x coordinate -> list of y coordinates with dots\n map> y_to_xs; // y coordinate -> list of x coordinates with dots\n \n for (int i = 0; i < M; i++) {\n cin >> initial_dots[i].x >> initial_dots[i].y;\n dots.insert(initial_dots[i]);\n x_to_ys[initial_dots[i].x].push_back(initial_dots[i].y);\n y_to_xs[initial_dots[i].y].push_back(initial_dots[i].x);\n }\n\n // Sort the coordinate lists for binary search\n for (auto& [x, ys] : x_to_ys) {\n sort(ys.begin(), ys.end());\n }\n for (auto& [y, xs] : y_to_xs) {\n sort(xs.begin(), xs.end());\n }\n\n int c = (N - 1) / 2;\n auto weight = [c](int x, int y) {\n return (x - c) * (x - c) + (y - c) * (y - c) + 1;\n };\n\n // Create list of all empty points sorted by weight (descending)\n vector> empty_points;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (dots.find({x, y}) == dots.end()) {\n empty_points.push_back({weight(x, y), {x, y}});\n }\n }\n }\n sort(empty_points.rbegin(), empty_points.rend());\n\n vector operations;\n\n // Track used segments to avoid overlaps\n set> used_segments;\n\n // Helper function to check if a line segment is already used\n auto is_segment_used = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Vertical segment\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n if (used_segments.count({x1, y, x1, y+1}) > 0 ||\n used_segments.count({x1, y+1, x1, y}) > 0) {\n return true;\n }\n }\n } else if (y1 == y2) {\n // Horizontal segment\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n if (used_segments.count({x, y1, x+1, y1}) > 0 ||\n used_segments.count({x+1, y1, x, y1}) > 0) {\n return true;\n }\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n // Diagonal segment (45 degrees)\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n if (used_segments.count({x, y, x+dx, y+dy}) > 0 ||\n used_segments.count({x+dx, y+dy, x, y}) > 0) {\n return true;\n }\n x += dx;\n y += dy;\n }\n }\n return false;\n };\n\n // Helper function to add segments to used set\n auto add_segments = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Vertical segment\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n used_segments.insert({x1, y, x1, y+1});\n used_segments.insert({x1, y+1, x1, y});\n }\n } else if (y1 == y2) {\n // Horizontal segment\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n used_segments.insert({x, y1, x+1, y1});\n used_segments.insert({x+1, y1, x, y1});\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n // Diagonal segment (45 degrees)\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n used_segments.insert({x, y, x+dx, y+dy});\n used_segments.insert({x+dx, y+dy, x, y});\n x += dx;\n y += dy;\n }\n }\n };\n\n // Helper function to check if a point has a dot\n auto has_dot = [&dots](int x, int y) {\n return dots.count({x, y}) > 0;\n };\n\n mt19937 rng(42); // Fixed seed for reproducibility\n\n // Try to place dots in order of decreasing weight\n for (const auto& [w, p] : empty_points) {\n bool found = false;\n Rectangle rect;\n\n // Try axis-aligned rectangles first, then 45-degree\n vector> search_order;\n \n // For axis-aligned, prioritize rectangles that go outward from center\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend()); // Farther from center first\n \n for (const auto& [dist, x2] : search_order) {\n // Check if there are dots at (p.x, y2), (x2, y2), (x2, p.y) for some y2\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n // Find common y coordinate that has dots at both x positions\n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n // Check if there's a dot at (x2, y2)\n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n // Check if there's a dot at (x2, p.y)\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n // Check if no other dots are on the perimeter\n bool has_other_dots = false;\n \n // Check horizontal edges (excluding corners)\n int x_start = min(p.x, x2);\n int x_end = max(p.x, x2);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p.y) || has_dot(x, y2)) {\n has_other_dots = true;\n break;\n }\n }\n \n // Check vertical edges (excluding corners)\n if (!has_other_dots) {\n int y_start = min(p.y, y2);\n int y_end = max(p.y, y2);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p.x, y) || has_dot(x2, y)) {\n has_other_dots = true;\n break;\n }\n }\n }\n\n if (!has_other_dots) {\n // Check if segments overlap\n if (!is_segment_used(p.x, p.y, p.x, y2) &&\n !is_segment_used(p.x, y2, x2, y2) &&\n !is_segment_used(x2, y2, x2, p.y) &&\n !is_segment_used(x2, p.y, p.x, p.y)) {\n \n rect = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n found = true;\n break;\n }\n }\n }\n }\n }\n if (found) break;\n }\n\n // Try 45-degree inclined rectangles (diamonds)\n if (!found) {\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) { // Limit search space\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n // Try all 4 orientations of diamond\n vector> diamonds = {\n {{p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}}}, // top vertex\n {{p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}}}, // bottom vertex\n {{p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}}}, // left vertex\n {{p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}}} // right vertex\n };\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n const Point& p2 = diamond[1];\n const Point& p3 = diamond[2];\n const Point& p4 = diamond[3];\n \n if (p3.x >= 0 && p3.x < N && p3.y >= 0 && p3.y < N &&\n p2.x >= 0 && p2.x < N && p2.y >= 0 && p2.y < N &&\n p4.x >= 0 && p4.x < N && p4.y >= 0 && p4.y < N) {\n \n if (has_dot(p2.x, p2.y) && has_dot(p3.x, p3.y) && has_dot(p4.x, p4.y)) {\n bool has_other_dots = false;\n \n // Check edges (excluding vertices)\n for (int i = 1; i < d; i++) {\n if (has_dot(p.x + i, p.y - i) || has_dot(p.x + i, p.y - d - i) ||\n has_dot(p.x - i, p.y - d - i) || has_dot(p.x - i, p.y - i)) {\n has_other_dots = true;\n break;\n }\n }\n\n if (!has_other_dots) {\n if (!is_segment_used(p.x, p.y, p2.x, p2.y) &&\n !is_segment_used(p2.x, p2.y, p3.x, p3.y) &&\n !is_segment_used(p3.x, p3.y, p4.x, p4.y) &&\n !is_segment_used(p4.x, p4.y, p.x, p.y)) {\n \n rect = {p, p2, p3, p4};\n found = true;\n break;\n }\n }\n }\n }\n }\n if (found) break;\n }\n }\n\n if (found) {\n operations.push_back(rect);\n dots.insert(p);\n \n // Update coordinate mappings\n x_to_ys[p.x].push_back(p.y);\n y_to_xs[p.y].push_back(p.x);\n sort(x_to_ys[p.x].begin(), x_to_ys[p.x].end());\n sort(y_to_xs[p.y].begin(), y_to_xs[p.y].end());\n \n // Add the segments to used set\n add_segments(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);\n add_segments(rect.p2.x, rect.p2.y, rect.p3.x, rect.p3.y);\n add_segments(rect.p3.x, rect.p3.y, rect.p4.x, rect.p4.y);\n add_segments(rect.p4.x, rect.p4.y, rect.p1.x, rect.p1.y);\n }\n\n // Early exit if we've placed enough dots\n if (operations.size() >= 2000) break;\n }\n\n cout << operations.size() << \"\\n\";\n for (const auto& rect : operations) {\n cout << rect.p1.x << \" \" << rect.p1.y << \" \";\n cout << rect.p2.x << \" \" << rect.p2.y << \" \";\n cout << rect.p3.x << \" \" << rect.p3.y << \" \";\n cout << rect.p4.x << \" \" << rect.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nconst int N = 10;\nconst int DIRECTIONS = 4;\nconst int EMPTY = 0;\n\nstruct Cell {\n int flavor;\n int x, y;\n Cell() : flavor(EMPTY), x(-1), y(-1) {}\n Cell(int f, int x, int y) : flavor(f), x(x), y(y) {}\n};\n\nclass Grid {\nprivate:\n vector> grid;\n vector candies;\n int total_candies;\n \npublic:\n Grid() : grid(N, vector(N, EMPTY)), total_candies(0) {}\n \n void add_candy(int flavor, int x, int y) {\n grid[x][y] = flavor;\n candies.emplace_back(flavor, x, y);\n total_candies++;\n }\n \n void tilt(char direction) {\n vector> new_grid(N, vector(N, EMPTY));\n vector new_candies;\n \n int dx = 0, dy = 0;\n if (direction == 'F') dx = -1;\n else if (direction == 'B') dx = 1;\n else if (direction == 'L') dy = -1;\n else if (direction == 'R') dy = 1;\n \n for (const auto& candy : candies) {\n int x = candy.x;\n int y = candy.y;\n \n // Move until hitting edge or another candy\n while (true) {\n int nx = x + dx;\n int ny = y + dy;\n \n if (nx < 0 || nx >= N || ny < 0 || ny >= N || new_grid[nx][ny] != EMPTY) {\n break;\n }\n \n x = nx;\n y = ny;\n }\n \n new_grid[x][y] = candy.flavor;\n new_candies.emplace_back(candy.flavor, x, y);\n }\n \n grid = move(new_grid);\n candies = move(new_candies);\n }\n \n double calculate_score() const {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n vector flavor_counts(4, 0);\n \n for (const auto& candy : candies) {\n flavor_counts[candy.flavor]++;\n }\n \n for (const auto& candy : candies) {\n if (visited[candy.x][candy.y]) continue;\n \n queue> q;\n q.push({candy.x, candy.y});\n visited[candy.x][candy.y] = true;\n \n int flavor = grid[candy.x][candy.y];\n int size = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n component_sizes.push_back(size);\n }\n \n double sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += size * size;\n }\n \n double denominator = 0;\n for (int i = 1; i <= 3; i++) {\n denominator += flavor_counts[i] * flavor_counts[i];\n }\n \n return sum_squares / denominator;\n }\n \n int count_components(int flavor) const {\n vector> visited(N, vector(N, false));\n int count = 0;\n \n for (const auto& candy : candies) {\n if (candy.flavor != flavor || visited[candy.x][candy.y]) continue;\n \n queue> q;\n q.push({candy.x, candy.y});\n visited[candy.x][candy.y] = true;\n count++;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n \n return count;\n }\n \n int get_largest_component_size(int flavor) const {\n vector> visited(N, vector(N, false));\n int max_size = 0;\n \n for (const auto& candy : candies) {\n if (candy.flavor != flavor || visited[candy.x][candy.y]) continue;\n \n queue> q;\n q.push({candy.x, candy.y});\n visited[candy.x][candy.y] = true;\n \n int size = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n max_size = max(max_size, size);\n }\n \n return max_size;\n }\n \n int get_flavor_count(int flavor) const {\n return count_if(candies.begin(), candies.end(), \n [flavor](const Cell& c) { return c.flavor == flavor; });\n }\n \n void print() const {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j] << \" \";\n }\n cout << endl;\n }\n }\n \n const vector& get_candies() const { return candies; }\n const vector>& get_grid() const { return grid; }\n};\n\nclass Strategy {\nprotected:\n vector flavors;\n Grid grid;\n int turn;\n \npublic:\n Strategy(const vector& f) : flavors(f), turn(0) {}\n \n virtual ~Strategy() {}\n \n virtual char decide_tilt(int p) = 0;\n \n void add_candy(int p) {\n // Convert p to (x, y) coordinates\n int empty_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool is_empty = true;\n for (const auto& candy : grid.get_candies()) {\n if (candy.x == i && candy.y == j) {\n is_empty = false;\n break;\n }\n }\n if (is_empty) {\n empty_count++;\n if (empty_count == p) {\n grid.add_candy(flavors[turn], i, j);\n turn++;\n return;\n }\n }\n }\n }\n }\n \n void apply_tilt(char direction) {\n grid.tilt(direction);\n }\n \n const Grid& get_grid() const { return grid; }\n};\n\nclass CornerStrategy : public Strategy {\nprivate:\n vector corner_directions;\n \npublic:\n CornerStrategy(const vector& f) : Strategy(f) {\n corner_directions = {'L', 'R', 'B'};\n }\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n if (turn <= 1) {\n return 'F';\n }\n \n int flavor = flavors[turn-1];\n return corner_directions[flavor-1];\n }\n};\n\nclass HybridStrategy : public Strategy {\nprivate:\n vector corner_directions;\n vector> density_map;\n \npublic:\n HybridStrategy(const vector& f) : Strategy(f) {\n corner_directions = {'L', 'R', 'B'};\n density_map.resize(3, vector(N*N, 0.0));\n }\n \n void update_density_map() {\n for (int flavor = 1; flavor <= 3; flavor++) {\n fill(density_map[flavor-1].begin(), density_map[flavor-1].end(), 0.0);\n \n for (const auto& candy : grid.get_candies()) {\n if (candy.flavor == flavor) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n double dist = sqrt(pow(candy.x - i, 2) + pow(candy.y - j, 2));\n density_map[flavor-1][i*N + j] += 1.0 / (1.0 + dist);\n }\n }\n }\n }\n }\n }\n \n double evaluate_tilt(char direction) {\n Grid test_grid = grid;\n test_grid.tilt(direction);\n \n int flavor = flavors[turn-1];\n \n // Find the position of the new candy after tilt\n int new_x = -1, new_y = -1;\n for (const auto& candy : test_grid.get_candies()) {\n // This is a simplification - in practice, we need to track which candy is new\n if (candy.flavor == flavor) {\n new_x = candy.x;\n new_y = candy.y;\n }\n }\n \n if (new_x == -1) return 0.0;\n \n // Calculate score based on connectivity and corner distance\n double score = 0.0;\n \n // Component connectivity score\n int components = test_grid.count_components(flavor);\n score += 100.0 / components;\n \n // Largest component size\n int largest = test_grid.get_largest_component_size(flavor);\n score += largest * 10.0;\n \n // Distance to corner\n char corner_dir = corner_directions[flavor-1];\n int target_x = (corner_dir == 'F') ? 0 : (corner_dir == 'B') ? N-1 : -1;\n int target_y = (corner_dir == 'L') ? 0 : (corner_dir == 'R') ? N-1 : -1;\n \n double dist = 0.0;\n if (target_x != -1) dist += abs(new_x - target_x);\n if (target_y != -1) dist += abs(new_y - target_y);\n score += 50.0 / (1.0 + dist);\n \n // Density score\n update_density_map();\n if (new_x >= 0 && new_x < N && new_y >= 0 && new_y < N) {\n score += density_map[flavor-1][new_x*N + new_y] * 20.0;\n }\n \n return score;\n }\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n if (turn <= 30) {\n return corner_directions[flavors[turn-1]-1];\n }\n \n char best_dir = 'F';\n double best_score = -1e9;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n double score = evaluate_tilt(dir);\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n HybridStrategy strategy(flavors);\n \n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n \n if (t < 99) {\n char tilt = strategy.decide_tilt(p);\n strategy.apply_tilt(tilt);\n cout << tilt << endl;\n cout.flush();\n } else {\n strategy.decide_tilt(p);\n }\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct GraphFeatures {\n int edge_count;\n double avg_degree;\n int max_degree;\n int triangles;\n int components;\n double clustering_coeff;\n};\n\nvector> parse_graph(const string& s, int N) {\n vector> adj(N, vector(N, 0));\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n adj[i][j] = adj[j][i] = (s[idx++] == '1');\n }\n }\n return adj;\n}\n\nGraphFeatures extract_features(const vector>& adj) {\n int N = adj.size();\n GraphFeatures f;\n \n // Edge count and degrees\n f.edge_count = 0;\n vector degree(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n f.edge_count++;\n degree[i]++;\n degree[j]++;\n }\n }\n }\n \n // Degree statistics\n f.avg_degree = 2.0 * f.edge_count / N;\n f.max_degree = *max_element(degree.begin(), degree.end());\n \n // Triangles\n f.triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n f.triangles++;\n }\n }\n }\n }\n }\n \n // Components\n vector visited(N, false);\n f.components = 0;\n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n f.components++;\n vector stack = {i};\n visited[i] = true;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n for (int u = 0; u < N; u++) {\n if (adj[v][u] && !visited[u]) {\n visited[u] = true;\n stack.push_back(u);\n }\n }\n }\n }\n }\n \n // Clustering coefficient\n double total_clustering = 0;\n int count = 0;\n for (int i = 0; i < N; i++) {\n if (degree[i] >= 2) {\n int neighbors = 0;\n int neighbor_edges = 0;\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) {\n neighbors++;\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n neighbor_edges++;\n }\n }\n }\n }\n if (neighbors >= 2) {\n total_clustering += 2.0 * neighbor_edges / (neighbors * (neighbors - 1));\n count++;\n }\n }\n }\n f.clustering_coeff = (count > 0) ? total_clustering / count : 0;\n \n return f;\n}\n\nstring generate_graph_with_features(int N, int target_edges, double target_clustering, int target_components, mt19937& rng) {\n int total_possible = N * (N - 1) / 2;\n string graph(total_possible, '0');\n \n if (target_components > 1) {\n // Create disconnected graph\n int comp_size = N / target_components;\n vector> components;\n \n for (int c = 0; c < target_components; c++) {\n int start = c * comp_size;\n int end = (c == target_components - 1) ? N : (c + 1) * comp_size;\n components.push_back({start, end});\n }\n \n // Add edges within components\n for (auto& comp : components) {\n int comp_vertices = comp[1] - comp[0];\n int comp_edges = min(target_edges / target_components, \n comp_vertices * (comp_vertices - 1) / 2);\n \n vector> possible_edges;\n for (int i = comp[0]; i < comp[1]; i++) {\n for (int j = i + 1; j < comp[1]; j++) {\n possible_edges.push_back({i, j});\n }\n }\n \n shuffle(possible_edges.begin(), possible_edges.end(), rng);\n for (int i = 0; i < comp_edges; i++) {\n int u = possible_edges[i].first;\n int v = possible_edges[i].second;\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n }\n } else {\n // Connected graph with target clustering\n vector> possible_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n possible_edges.push_back({i, j});\n }\n }\n \n // Start with a random spanning tree for connectivity\n shuffle(possible_edges.begin(), possible_edges.end(), rng);\n vector parent(N);\n for (int i = 0; i < N; i++) parent[i] = i;\n \n auto find = [&](int x) {\n while (parent[x] != x) x = parent[x];\n return x;\n };\n \n int edges_added = 0;\n for (auto& edge : possible_edges) {\n int u = edge.first, v = edge.second;\n if (find(u) != find(v)) {\n parent[find(u)] = find(v);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n edges_added++;\n if (edges_added == N - 1) break;\n }\n }\n \n // Add remaining edges based on clustering target\n vector> remaining;\n for (auto& edge : possible_edges) {\n int u = edge.first, v = edge.second;\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n if (graph[idx] == '0') {\n remaining.push_back(edge);\n }\n }\n \n if (target_clustering > 0.3) {\n // Prioritize edges that form triangles\n shuffle(remaining.begin(), remaining.end(), rng);\n }\n \n int remaining_edges = min(target_edges - edges_added, (int)remaining.size());\n for (int i = 0; i < remaining_edges; i++) {\n int u = remaining[i].first, v = remaining[i].second;\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n }\n \n return graph;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Adaptive N selection based on epsilon and M\n int N;\n if (epsilon < 0.05) {\n N = min(20, max(6, M/3 + 6));\n } else if (epsilon < 0.1) {\n N = min(25, max(8, M/3 + 8));\n } else if (epsilon < 0.2) {\n N = min(35, max(10, M/3 + 12));\n } else if (epsilon < 0.3) {\n N = min(45, max(12, M/3 + 16));\n } else {\n N = min(60, max(15, M/3 + 20));\n }\n \n cout << N << endl;\n cout.flush();\n \n // Generate M graphs with diverse features\n int total_possible = N * (N - 1) / 2;\n vector graphs(M);\n vector features(M);\n \n random_device rd;\n mt19937 rng(12345);\n \n for (int i = 0; i < M; i++) {\n // Vary multiple features\n int edge_count = (total_possible * (i + 1)) / (M + 1);\n double clustering = 0.1 + 0.6 * sin(2 * M_PI * i / M);\n int components = 1 + (i % 3 == 0 ? 1 : 0);\n \n graphs[i] = generate_graph_with_features(N, edge_count, clustering, components, rng);\n features[i] = extract_features(parse_graph(graphs[i], N));\n \n cout << graphs[i] << endl;\n }\n cout.flush();\n \n // Process queries with feature-based matching\n for (int query = 0; query < 100; query++) {\n string H;\n cin >> H;\n \n auto adj_H = parse_graph(H, N);\n auto f_H = extract_features(adj_H);\n \n // Find best match using weighted features\n int best_idx = 0;\n double best_score = 1e9;\n \n for (int i = 0; i < M; i++) {\n double score = 0;\n \n // Weight different features based on epsilon\n double edge_weight = 1.0 - epsilon * 0.5;\n double degree_weight = 0.3;\n double triangle_weight = 0.2 * (1 - epsilon);\n double component_weight = 0.4;\n double cluster_weight = 0.1 * (1 - epsilon);\n \n // Edge count difference (most important)\n double edge_diff = abs(f_H.edge_count - features[i].edge_count);\n score += edge_weight * edge_diff / total_possible;\n \n // Average degree difference\n double degree_diff = abs(f_H.avg_degree - features[i].avg_degree);\n score += degree_weight * degree_diff / N;\n \n // Triangle count difference\n double triangle_diff = abs(f_H.triangles - features[i].triangles);\n score += triangle_weight * triangle_diff / (N * (N - 1) * (N - 2) / 6);\n \n // Component count difference\n score += component_weight * abs(f_H.components - features[i].components);\n \n // Clustering coefficient difference\n score += cluster_weight * abs(f_H.clustering_coeff - features[i].clustering_coeff);\n \n if (score < best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Edge {\n int u, v, w, id;\n double x1, y1, x2, y2;\n int importance;\n int day;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n \n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--;\n edges[i].v--;\n edges[i].id = i;\n }\n \n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Assign coordinates to edges\n for (auto &e : edges) {\n e.x1 = coords[e.u].first;\n e.y1 = coords[e.u].second;\n e.x2 = coords[e.v].first;\n e.y2 = coords[e.v].second;\n }\n \n // Compute betweenness centrality for each edge\n vector betweenness(M, 0);\n const int SAMPLES = min(N, 50);\n vector sampled_vertices(N);\n iota(sampled_vertices.begin(), sampled_vertices.end(), 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(sampled_vertices.begin(), sampled_vertices.end(), rng);\n sampled_vertices.resize(SAMPLES);\n \n for (int s : sampled_vertices) {\n vector dist(N, 1e9);\n vector prev(N, -1);\n priority_queue, vector>, greater<>> pq;\n dist[s] = 0;\n pq.push({0, s});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n int v = -1;\n if (e.u == u) v = e.v;\n else if (e.v == u) v = e.u;\n else continue;\n if (dist[v] > dist[u] + e.w) {\n dist[v] = dist[u] + e.w;\n prev[v] = u;\n pq.push({dist[v], v});\n }\n }\n }\n \n for (int t = 0; t < N; ++t) {\n if (t == s) continue;\n for (int v = t; v != s && prev[v] != -1; v = prev[v]) {\n int u = prev[v];\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n betweenness[eid]++;\n break;\n }\n }\n }\n }\n }\n \n // Compute importance: betweenness + inverse weight\n for (int i = 0; i < M; ++i) {\n edges[i].importance = betweenness[i] * 1000000 / (edges[i].w + 1);\n }\n \n // Sort edges by importance (descending)\n sort(edges.begin(), edges.end(), [](const Edge &a, const Edge &b) {\n return a.importance > b.importance;\n });\n \n // Priority queue to keep track of day loads\n priority_queue> pq; // {current_sum, day}\n vector day_sum(D, 0);\n for (int d = 0; d < D; ++d) {\n pq.push({0, d});\n }\n \n // Assign edges to days, trying to balance the importance\n vector> day_edges(D);\n for (auto &e : edges) {\n auto [sum, day] = pq.top(); pq.pop();\n day_edges[day].push_back(e.id);\n day_sum[day] += e.importance;\n pq.push({day_sum[day], day});\n }\n \n // Prepare output\n vector res(M);\n for (int d = 0; d < D; ++d) {\n for (int eid : day_edges[d]) {\n res[eid] = d + 1;\n }\n }\n \n // Output the results\n for (int i = 0; i < M; ++i) {\n if (i) cout << \" \";\n cout << res[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Coord {\n int x, y, z;\n};\n\n// Helper function to get a 1D index from 3D coordinates\nint get_idx(int D, int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\n// Generic function to find and mark connected components for a given cell type\nvoid find_and_mark_blocks(\n int D,\n const vector>>& cell_type,\n vector>>& visited,\n vector& b_1,\n vector& b_2,\n int& block_id,\n bool is_shared,\n bool is_u1,\n bool is_u2\n) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (cell_type[x][y][z] && !visited[x][y][z]) {\n queue q;\n q.push({x, y, z});\n visited[x][y][z] = true;\n block_id++;\n int idx = get_idx(D, x, y, z);\n\n if (is_shared) {\n b_1[idx] = block_id;\n b_2[idx] = block_id;\n } else if (is_u1) {\n b_1[idx] = block_id;\n } else if (is_u2) {\n b_2[idx] = block_id;\n }\n\n while (!q.empty()) {\n Coord curr = q.front();\n q.pop();\n\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n\n for (int i = 0; i < 6; ++i) {\n int nx = curr.x + dx[i];\n int ny = curr.y + dy[i];\n int nz = curr.z + dz[i];\n\n if (0 <= nx && nx < D && 0 <= ny && ny < D && 0 <= nz && nz < D) {\n if (cell_type[nx][ny][nz] && !visited[nx][ny][nz]) {\n visited[nx][ny][nz] = true;\n q.push({nx, ny, nz});\n int n_idx = get_idx(D, nx, ny, nz);\n if (is_shared) {\n b_1[n_idx] = block_id;\n b_2[n_idx] = block_id;\n } else if (is_u1) {\n b_1[n_idx] = block_id;\n } else if (is_u2) {\n b_2[n_idx] = block_id;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n\n vector f[2], r[2];\n for (int i = 0; i < 2; ++i) {\n f[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> f[i][j];\n }\n r[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> r[i][j];\n }\n }\n\n // Categorize cells: shared, unique to object 1, unique to object 2\n vector>> is_shared(D, vector>(D, vector(D, false)));\n vector>> is_u1(D, vector>(D, vector(D, false)));\n vector>> is_u2(D, vector>(D, vector(D, false)));\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool in_o1 = (f[0][z][x] == '1' && r[0][z][y] == '1');\n bool in_o2 = (f[1][z][x] == '1' && r[1][z][y] == '1');\n if (in_o1 && in_o2) {\n is_shared[x][y][z] = true;\n } else if (in_o1) {\n is_u1[x][y][z] = true;\n } else if (in_o2) {\n is_u2[x][y][z] = true;\n }\n }\n }\n }\n\n vector b_1(D * D * D, 0);\n vector b_2(D * D * D, 0);\n vector>> visited(D, vector>(D, vector(D, false)));\n int block_id = 0;\n\n // 1. Find shared blocks\n find_and_mark_blocks(D, is_shared, visited, b_1, b_2, block_id, true, false, false);\n\n // 2. Find blocks unique to object 1\n find_and_mark_blocks(D, is_u1, visited, b_1, b_2, block_id, false, true, false);\n\n // 3. Find blocks unique to object 2\n find_and_mark_blocks(D, is_u2, visited, b_1, b_2, block_id, false, false, true);\n\n cout << block_id << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_1[i];\n }\n cout << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_2[i];\n }\n cout << endl;\n\n return 0;\n}","ahc020":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n double x, y;\n Point(double x=0, double y=0) : x(x), y(y) {}\n double dist(const Point& p) const {\n return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));\n }\n int rounded_dist(const Point& p) const {\n return (int)round(dist(p));\n }\n};\n\nstruct Edge {\n int u, v, w, idx;\n double d;\n Edge(int u=0, int v=0, int w=0, double d=0, int idx=0) : u(u), v(v), w(w), d(d), idx(idx) {}\n bool operator<(const Edge& e) const {\n return w < e.w;\n }\n};\n\nstruct DSU {\n vector parent, sz;\n DSU(int n) : parent(n), sz(n, 1) {\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 same(int x, int y) { return find(x) == find(y); }\n bool unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return false;\n if (sz[x] < sz[y]) swap(x, y);\n parent[y] = x;\n sz[x] += sz[y];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n \n vector stations(N);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M);\n for (int j = 0; j < M; ++j) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n double d = stations[u].dist(stations[v]);\n edges[j] = Edge(u, v, w, d, j);\n }\n \n vector residents(K);\n for (int k = 0; k < K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // Precompute distances between stations and residents\n vector> station_resident_dist(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n station_resident_dist[i][k] = stations[i].dist(residents[k]);\n }\n }\n \n // Calculate coverage benefit for each station\n vector station_benefit(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n if (station_resident_dist[i][k] <= 5000) {\n station_benefit[i] += 1.0 / (1.0 + station_resident_dist[i][k]);\n }\n }\n }\n \n // Initial edge selection using cost-benefit analysis\n vector edge_used(M, false);\n vector connected(N, false);\n connected[0] = true;\n \n // First, connect important stations directly to the root\n vector> station_score;\n for (int i = 1; i < N; ++i) {\n double d = stations[0].dist(stations[i]);\n double score = station_benefit[i] / (1.0 + d);\n station_score.push_back({score, i});\n }\n sort(station_score.rbegin(), station_score.rend());\n \n // Connect top stations directly if beneficial\n for (auto &[score, i] : station_score) {\n if (connected[i]) continue;\n \n // Find best edge to connect i\n int best_edge = -1;\n double best_ratio = 0;\n \n for (int j = 0; j < M; ++j) {\n if (edges[j].u == i || edges[j].v == i) {\n int other = edges[j].u == i ? edges[j].v : edges[j].u;\n if (connected[other]) {\n double ratio = station_benefit[i] / (1.0 + edges[j].w);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n best_edge = j;\n }\n }\n }\n }\n \n if (best_edge != -1 && best_ratio > 0.001) {\n edge_used[best_edge] = true;\n connected[i] = true;\n }\n }\n \n // Build minimum spanning tree for remaining components\n DSU dsu(N);\n for (int i = 0; i < N; ++i) {\n if (connected[i]) dsu.parent[i] = 0;\n }\n \n vector sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end());\n \n for (auto &e : sorted_edges) {\n if (!edge_used[e.idx]) {\n if (dsu.unite(e.u, e.v)) {\n edge_used[e.idx] = true;\n connected[e.u] = connected[e.v] = true;\n }\n }\n }\n \n // Calculate which residents are covered by each station\n vector> resident_covered_by_station(K);\n for (int k = 0; k < K; ++k) {\n for (int i = 0; i < N; ++i) {\n if (station_resident_dist[i][k] <= 5000) {\n resident_covered_by_station[k].push_back(i);\n }\n }\n }\n \n // Greedy set cover for broadcast powers\n vector P(N, 0);\n vector covered(K, false);\n int uncovered_count = K;\n \n while (uncovered_count > 0) {\n // Find best station to activate\n int best_station = -1;\n int best_power = 0;\n double best_score = -1;\n \n for (int i = 0; i < N; ++i) {\n if (!connected[i]) continue;\n \n // Calculate optimal power for this station\n vector> residents_by_dist;\n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n for (int s : resident_covered_by_station[k]) {\n if (s == i) {\n residents_by_dist.push_back({station_resident_dist[i][k], k});\n break;\n }\n }\n }\n }\n \n if (residents_by_dist.empty()) continue;\n \n sort(residents_by_dist.begin(), residents_by_dist.end());\n \n int current_power = 0;\n int new_covered = 0;\n double best_local_score = -1;\n int best_local_power = 0;\n \n for (auto &[dist, k] : residents_by_dist) {\n int power_needed = (int)ceil(dist);\n if (power_needed > 5000) break;\n \n double cost_increase = power_needed * power_needed - current_power * current_power;\n new_covered++;\n \n if (cost_increase > 0) {\n double score = new_covered / cost_increase;\n if (score > best_local_score) {\n best_local_score = score;\n best_local_power = power_needed;\n }\n }\n current_power = power_needed;\n }\n \n if (best_local_score > best_score) {\n best_score = best_local_score;\n best_station = i;\n best_power = best_local_power;\n }\n }\n \n if (best_station == -1) break;\n \n P[best_station] = best_power;\n for (int k = 0; k < K; ++k) {\n if (!covered[k] && station_resident_dist[best_station][k] <= best_power + 0.5) {\n covered[k] = true;\n uncovered_count--;\n }\n }\n }\n \n // Optimize powers further\n for (int iter = 0; iter < 3; ++iter) {\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] == 0) continue;\n \n // Check if we can reduce power\n vector temp_covered = covered;\n bool can_reduce = true;\n int min_power = 0;\n \n for (int k = 0; k < K; ++k) {\n if (covered[k] && station_resident_dist[i][k] <= P[i] + 0.5) {\n bool covered_by_other = false;\n for (int j = 0; j < N; ++j) {\n if (j != i && P[j] > 0 && station_resident_dist[j][k] <= P[j] + 0.5) {\n covered_by_other = true;\n break;\n }\n }\n if (!covered_by_other) {\n can_reduce = false;\n min_power = max(min_power, (int)ceil(station_resident_dist[i][k]));\n }\n }\n }\n \n if (can_reduce) {\n P[i] = 0;\n } else {\n P[i] = min(P[i], min(5000, min_power));\n }\n }\n }\n \n // Ensure all residents are covered\n covered.assign(K, false);\n for (int i = 0; i < N; ++i) {\n if (P[i] > 0) {\n for (int k = 0; k < K; ++k) {\n if (station_resident_dist[i][k] <= P[i] + 0.5) {\n covered[k] = true;\n }\n }\n }\n }\n \n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n // Find nearest connected station\n double min_dist = 1e9;\n int best_station = -1;\n \n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n double d = station_resident_dist[i][k];\n if (d < min_dist) {\n min_dist = d;\n best_station = i;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = min(5000, max(P[best_station], (int)ceil(min_dist)));\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; ++j) {\n if (j) cout << \" \";\n cout << (edge_used[j] ? 1 : 0);\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconstexpr int N = 30;\n\n// pyramid values\nint a[N][N];\n// list of operations: x y x' y'\nvector> ops;\n\n// bubble down the element currently at (x,y)\nvoid bubble_down(int x, int y) {\n while (true) {\n int cx = x + 1;\n if (cx >= N) break; // leaf\n int cy_left = y;\n int cy_right = y + 1;\n\n // choose the smaller child\n int child_x = cx, child_y = cy_left;\n int child_val = a[child_x][child_y];\n if (a[cx][cy_right] < child_val) {\n child_y = cy_right;\n child_val = a[cx][cy_right];\n }\n\n // heap condition satisfied?\n if (a[x][y] <= child_val) break;\n\n // perform swap\n ops.push_back({x, y, child_x, child_y});\n swap(a[x][y], a[child_x][child_y]);\n\n // continue from the child position\n x = child_x;\n y = child_y;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // read input\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> a[x][y];\n }\n }\n\n // bottom\u2011up heapify\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n bubble_down(x, y);\n }\n }\n\n // safety check (should always hold)\n assert(ops.size() <= 10000);\n\n // output\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op[0] << \" \" << op[1] << \" \"\n << op[2] << \" \" << op[3] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \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 D, N;\n if (!(cin >> D >> N)) {\n return 0;\n }\n\n const int entrance_r = 0;\n const int entrance_c = (D - 1) / 2;\n\n vector> grid(D, vector(D, 0));\n vector> placeable_cells;\n\n // Mark obstacles\n for (int k = 0; k < N; ++k) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = -1; // -1 for obstacle\n }\n\n // Collect all placeable cells\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (grid[i][j] != -1 && !(i == entrance_r && j == entrance_c)) {\n placeable_cells.emplace_back(i, j);\n }\n }\n }\n\n // Sort placeable cells by distance from entrance, then by coordinates\n // dist(i,j) = i + abs(j - entrance_c)\n auto dist_cmp = [entrance_c](const pair& a, const pair& b) {\n int dist_a = a.first + abs(a.second - entrance_c);\n int dist_b = b.first + abs(b.second - entrance_c);\n if (dist_a != dist_b) {\n return dist_a < dist_b; // Sort by distance ascending\n }\n if (a.first != b.first) {\n return a.first < b.first;\n }\n return a.second < b.second;\n };\n sort(placeable_cells.begin(), placeable_cells.end(), dist_cmp);\n\n int M = placeable_cells.size();\n vector is_taken(M, false);\n\n // --- Placement Phase ---\n for (int d = 0; d < M; ++d) {\n int t;\n cin >> t;\n\n int target_idx = t;\n int offset = 0;\n int chosen_idx = -1;\n\n while (chosen_idx == -1) {\n int check_idx1 = target_idx - offset;\n if (check_idx1 >= 0 && !is_taken[check_idx1]) {\n chosen_idx = check_idx1;\n break;\n }\n int check_idx2 = target_idx + offset;\n if (check_idx2 < M && !is_taken[check_idx2]) {\n chosen_idx = check_idx2;\n break;\n }\n offset++;\n }\n\n auto [r, c] = placeable_cells[chosen_idx];\n grid[r][c] = t;\n is_taken[chosen_idx] = true;\n\n cout << r << \" \" << c << \"\\n\";\n cout.flush();\n }\n\n // --- Retrieval Phase ---\n vector> retrieval_order;\n int remaining = M;\n while (remaining > 0) {\n // BFS to find reachable containers\n vector> visited(D, vector(D, false));\n queue> q;\n q.push({entrance_r, entrance_c});\n visited[entrance_r][entrance_c] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n const int drs[4] = {-1, 1, 0, 0};\n const int dcs[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + drs[k];\n int nc = c + dcs[k];\n\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !visited[nr][nc] && grid[nr][nc] != -1) {\n visited[nr][nc] = true;\n if (grid[nr][nc] > 0) {\n reachable_containers.push_back({nr, nc});\n }\n q.push({nr, nc});\n }\n }\n }\n\n // Find min priority container among reachable\n int min_p = M; // Max priority is M-1\n pair min_coord = {-1, -1};\n for (const auto& coord : reachable_containers) {\n if (grid[coord.first][coord.second] < min_p) {\n min_p = grid[coord.first][coord.second];\n min_coord = coord;\n }\n }\n\n retrieval_order.push_back(min_coord);\n grid[min_coord.first][min_coord.second] = 0; // Mark as empty\n remaining--;\n }\n\n // --- Output Retrieval Order ---\n for (const auto& coord : retrieval_order) {\n cout << coord.first << \" \" << coord.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n }\n }\n // output exactly the same grid\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << grid[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct SetInfo {\n long long total_score;\n int id;\n};\n\n// Operator for min-heap\nbool operator<(const SetInfo& a, const SetInfo& b) {\n return a.total_score > b.total_score;\n}\n\nvoid solve() {\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector rank_scores(N, 0);\n\n // --- Phase 1: Learning with Random Comparisons ---\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n int base_comp = Q / N;\n int rem_comp = Q % N;\n\n for (int i = 0; i < N; ++i) {\n int num_comp = base_comp + (i < rem_comp ? 1 : 0);\n for (int k = 0; k < num_comp; ++k) {\n int j;\n do {\n j = rng() % N;\n } while (i == j);\n\n cout << \"1 1 \" << i << \" \" << j << endl;\n cout.flush();\n\n char res;\n cin >> res;\n if (res == '>') {\n rank_scores[i] += 2;\n rank_scores[j] -= 2;\n } else if (res == '<') {\n rank_scores[i] -= 2;\n rank_scores[j] += 2;\n }\n }\n }\n\n // --- Phase 2: Partitioning using LPT heuristic ---\n vector> items;\n for (int i = 0; i < N; ++i) {\n items.emplace_back(rank_scores[i], i);\n }\n sort(items.begin(), items.end(), greater>());\n\n priority_queue pq;\n for (int i = 0; i < D; ++i) {\n pq.push({0, i});\n }\n\n vector assignments(N);\n vector> sets(D);\n vector set_scores(D, 0);\n\n for (const auto& item : items) {\n int item_id = item.second;\n long long score = item.first;\n\n SetInfo current_set = pq.top();\n pq.pop();\n\n assignments[item_id] = current_set.id;\n sets[current_set.id].push_back(item_id);\n set_scores[current_set.id] += score;\n\n pq.push({current_set.total_score + score, current_set.id});\n }\n\n // --- Phase 3: Local Search to improve balance ---\n const int LOCAL_SEARCH_LIMIT = N * D;\n for (int iter = 0; iter < LOCAL_SEARCH_LIMIT; ++iter) {\n int max_set_id = -1, min_set_id = -1;\n long long max_score = -1, min_score = 1e18;\n for (int i = 0; i < D; ++i) {\n if (set_scores[i] > max_score) {\n max_score = set_scores[i];\n max_set_id = i;\n }\n if (set_scores[i] < min_score) {\n min_score = set_scores[i];\n min_set_id = i;\n }\n }\n\n if (max_set_id == -1 || min_set_id == -1 || max_set_id == min_set_id) break;\n if (max_score - min_score < 2) break;\n\n int item_to_move_from_max = -1, item_to_move_from_min = -1;\n long long max_item_score = -1, min_item_score = 1e18;\n\n for (int item_id : sets[max_set_id]) {\n if (rank_scores[item_id] > max_item_score) {\n max_item_score = rank_scores[item_id];\n item_to_move_from_max = item_id;\n }\n }\n\n for (int item_id : sets[min_set_id]) {\n if (rank_scores[item_id] < min_item_score) {\n min_item_score = rank_scores[item_id];\n item_to_move_from_min = item_id;\n }\n }\n \n if (item_to_move_from_max == -1 || item_to_move_from_min == -1) break;\n if (max_item_score <= min_item_score) break;\n\n long long old_sum_sq = max_score * max_score + min_score * min_score;\n long long new_max_score = max_score - max_item_score + min_item_score;\n long long new_min_score = min_score - min_item_score + max_item_score;\n long long new_sum_sq = new_max_score * new_max_score + new_min_score * new_min_score;\n\n if (new_sum_sq < old_sum_sq) {\n // Perform swap\n assignments[item_to_move_from_max] = min_set_id;\n assignments[item_to_move_from_min] = max_set_id;\n \n set_scores[max_set_id] = new_max_score;\n set_scores[min_set_id] = new_min_score;\n\n // Update sets vectors\n auto& max_set_vec = sets[max_set_id];\n max_set_vec.erase(find(max_set_vec.begin(), max_set_vec.end(), item_to_move_from_max));\n max_set_vec.push_back(item_to_move_from_min);\n\n auto& min_set_vec = sets[min_set_id];\n min_set_vec.erase(find(min_set_vec.begin(), min_set_vec.end(), item_to_move_from_min));\n min_set_vec.push_back(item_to_move_from_max);\n } else {\n break;\n }\n }\n\n // --- Final Output ---\n for (int i = 0; i < N; ++i) {\n if (i > 0) cout << \" \";\n cout << assignments[i];\n }\n cout << endl;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct Box {\n int stack_idx;\n int pos; // position from bottom (0-indexed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int n = 200, m = 10;\n int boxes_per_stack = n / m; // 20\n \n vector> stacks(m);\n vector box_info(n + 1);\n \n // Read input\n for (int i = 0; i < m; i++) {\n stacks[i].resize(boxes_per_stack);\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_info[stacks[i][j]] = {i, j};\n }\n }\n \n vector> operations;\n \n // Process boxes in order\n for (int target = 1; target <= n; target++) {\n int stack_idx = box_info[target].stack_idx;\n int pos = box_info[target].pos;\n \n // Check if box is already at top\n if (pos == stacks[stack_idx].size() - 1) {\n // Just carry it out\n operations.emplace_back(target, 0);\n stacks[stack_idx].pop_back();\n \n // Update positions of remaining boxes in this stack\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n } else {\n // Need to move boxes above it\n // Choose destination stack (prefer empty or small stacks)\n int dest_stack = 0;\n int min_size = stacks[0].size();\n for (int i = 1; i < m; i++) {\n if (stacks[i].size() < min_size) {\n min_size = stacks[i].size();\n dest_stack = i;\n }\n }\n \n // If the smallest stack is the current one, choose the next smallest\n if (dest_stack == stack_idx) {\n for (int i = 0; i < m; i++) {\n if (i != stack_idx && stacks[i].size() <= min_size + 5) {\n dest_stack = i;\n break;\n }\n }\n }\n \n // Move the target box and everything above it\n operations.emplace_back(target, dest_stack + 1); // 1-indexed for output\n \n // Extract the boxes to move\n vector to_move(stacks[stack_idx].begin() + pos, stacks[stack_idx].end());\n stacks[stack_idx].resize(pos);\n \n // Add to destination stack\n stacks[dest_stack].insert(stacks[dest_stack].end(), to_move.begin(), to_move.end());\n \n // Update positions\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n \n // Now carry out the target box (it should be at top of dest_stack)\n operations.emplace_back(target, 0);\n stacks[dest_stack].pop_back();\n \n // Update positions again\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n }\n }\n \n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n \n return 0;\n}","ahc027":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct State {\n int i, j;\n double priority;\n State(int i_, int j_, double p_) : i(i_), j(j_), priority(p_) {}\n bool operator<(const State& other) const {\n return priority < other.priority;\n }\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 }\n \n vector> visited(N, vector(N));\n string route;\n \n // Priority-based DFS\n auto dfs = [&](auto self, int i, int j) -> void {\n visited[i][j] = true;\n \n // Collect neighbors with priorities\n priority_queue pq;\n const int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};\n const string dir_str = \"RDLU\";\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (visited[ni][nj]) continue;\n \n // Check if wall exists\n bool wall = false;\n if (dirs[dir][0] == 0) { // horizontal move\n wall = (v[i][min(j, nj)] == '1');\n } else { // vertical move\n wall = (h[min(i, ni)][j] == '1');\n }\n \n if (!wall) {\n // Priority based on d[i,j] and distance\n double priority = d[ni][nj] * 1.0 / (1.0 + abs(ni - N/2) + abs(nj - N/2));\n pq.emplace(ni, nj, priority);\n }\n }\n \n // Visit neighbors in priority order\n while (!pq.empty()) {\n State s = pq.top();\n pq.pop();\n if (!visited[s.i][s.j]) {\n // Find direction to this neighbor\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n if (ni == s.i && nj == s.j) {\n route += dir_str[dir];\n self(self, ni, nj);\n route += dir_str[(dir + 2) % 4];\n break;\n }\n }\n }\n }\n };\n \n dfs(dfs, 0, 0);\n \n // Add extra cycles around high-value cells\n vector>> high_value_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n high_value_cells.emplace_back(d[i][j], make_pair(i,j));\n }\n }\n sort(high_value_cells.rbegin(), high_value_cells.rend());\n \n // For top high-value cells, try to add small cycles\n int extra_cycles = min(10, (int)high_value_cells.size());\n for (int idx = 0; idx < extra_cycles; idx++) {\n int i = high_value_cells[idx].second.first;\n int j = high_value_cells[idx].second.second;\n \n // Try to find a small loop around this cell\n vector local_route;\n const int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};\n const string dir_str = \"RDLU\";\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n bool wall = false;\n if (dirs[dir][0] == 0) {\n wall = (v[i][min(j, nj)] == '1');\n } else {\n wall = (h[min(i, ni)][j] == '1');\n }\n \n if (!wall) {\n local_route.push_back(dir_str[dir]);\n // Try to return from opposite direction\n int oi = i + dirs[(dir+2)%4][0];\n int oj = j + dirs[(dir+2)%4][1];\n if (oi >= 0 && oi < N && oj >= 0 && oj < N) {\n bool wall2 = false;\n if (dirs[(dir+2)%4][0] == 0) {\n wall2 = (v[i][min(j, oj)] == '1');\n } else {\n wall2 = (h[min(i, oi)][j] == '1');\n }\n if (!wall2) {\n local_route.push_back(dir_str[(dir+2)%4]);\n if (route.length() + local_route.size() <= 100000) {\n route += local_route[0];\n route += local_route[1];\n }\n break;\n }\n }\n }\n }\n }\n }\n \n cout << route << endl;\n return 0;\n}","ahc028":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Position {\n int i, j;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n int si, sj;\n cin >> N >> M >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n vector targets(M);\n for (int k = 0; k < M; k++) {\n cin >> targets[k];\n }\n \n // Precompute letter positions\n vector> letter_positions(26);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n letter_positions[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n \n // For each position, precompute nearest positions for each character\n vector>> nearest(N, vector>(N, vector(26)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int c = 0; c < 26; c++) {\n int best_dist = INT_MAX;\n Position best_pos = {-1, -1};\n \n for (auto pos : letter_positions[c]) {\n int dist = abs(i - pos.i) + abs(j - pos.j);\n if (dist < best_dist) {\n best_dist = dist;\n best_pos = pos;\n }\n }\n \n nearest[i][j][c] = best_pos;\n }\n }\n }\n \n vector> result;\n result.emplace_back(si, sj);\n \n vector collected(M, false);\n int collected_count = 0;\n \n string current_suffix;\n \n // Greedy collection with overlap detection\n while (collected_count < M && result.size() < 4500) {\n int best_k = -1;\n int best_score = INT_MIN;\n int best_cost = INT_MAX;\n string best_remaining;\n Position best_start = {-1, -1};\n bool use_overlap = false;\n \n int current_i = result.back().first;\n int current_j = result.back().second;\n \n // Check all uncollected strings\n for (int k = 0; k < M; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Check for overlaps with current suffix\n for (int overlap_len = min(4, (int)current_suffix.length()); overlap_len >= 0; overlap_len--) {\n if (current_suffix.length() >= overlap_len) {\n string suffix = current_suffix.substr(current_suffix.length() - overlap_len);\n \n if (target.substr(0, overlap_len) == suffix) {\n string remaining = target.substr(overlap_len);\n \n // Estimate cost to get remaining characters\n int cost = 0;\n Position curr_pos = {current_i, current_j};\n \n for (char c : remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n cost = INT_MAX;\n break;\n }\n cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (cost < best_cost && cost < 100) {\n best_cost = cost;\n best_k = k;\n best_remaining = remaining;\n use_overlap = true;\n best_score = overlap_len * 10 - cost;\n }\n }\n }\n }\n \n // Also consider starting fresh\n char first_char = target[0];\n for (auto pos : letter_positions[first_char - 'A']) {\n int move_cost = abs(current_i - pos.i) + abs(current_j - pos.j) + 1;\n if (move_cost > 50) continue;\n \n // Estimate cost for remaining characters\n int total_cost = move_cost;\n Position curr_pos = pos;\n \n for (int pos_idx = 1; pos_idx < target.length(); pos_idx++) {\n char c = target[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n total_cost = INT_MAX;\n break;\n }\n total_cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (total_cost < best_cost && total_cost < 100) {\n best_cost = total_cost;\n best_k = k;\n best_start = pos;\n use_overlap = false;\n best_remaining = target;\n best_score = -total_cost;\n }\n }\n }\n \n if (best_k == -1) break;\n \n // Execute the chosen action\n if (use_overlap && !best_remaining.empty()) {\n Position curr_pos = {current_i, current_j};\n for (char c : best_remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n } else if (best_start.i != -1) {\n result.emplace_back(best_start.i, best_start.j);\n Position curr_pos = best_start;\n \n for (int pos_idx = 1; pos_idx < best_remaining.length(); pos_idx++) {\n char c = best_remaining[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n }\n \n collected[best_k] = true;\n collected_count++;\n \n // Update current suffix (last up to 4 characters)\n current_suffix = \"\";\n int start_idx = max(0, (int)result.size() - 4);\n for (int i = start_idx; i < result.size(); i++) {\n current_suffix += grid[result[i].first][result[i].second];\n }\n }\n \n // If we still have time, try to collect more strings with simple approach\n while (collected_count < M && result.size() < 4900) {\n bool found = false;\n int current_i = result.back().first;\n int current_j = result.back().second;\n \n for (int k = 0; k < M && !found; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Try to spell this string greedily\n Position curr_pos = {current_i, current_j};\n vector> temp_path;\n bool success = true;\n \n for (char c : target) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n success = false;\n break;\n }\n temp_path.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n }\n \n if (success && result.size() + temp_path.size() < 4900) {\n for (auto pos : temp_path) {\n result.push_back(pos);\n }\n collected[k] = true;\n collected_count++;\n found = true;\n }\n }\n \n if (!found) break;\n }\n \n // Output result\n for (auto [i, j] : result) {\n cout << i << \" \" << j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct OilField {\n int size;\n vector> cells;\n};\n\nstruct Solver {\n int N, M;\n double eps;\n vector fields;\n vector> reserves;\n vector> known;\n vector> estimates;\n int ops_used;\n double total_cost;\n mt19937 rng;\n \n Solver(int N, int M, double eps, const vector& fields) \n : N(N), M(M), eps(eps), fields(fields), ops_used(0), total_cost(0), \n reserves(N, vector(N, -1)), known(N, vector(N, false)),\n estimates(N, vector(N, 0.0)) {\n rng.seed(random_device{}());\n }\n \n void flush() {\n cout << flush;\n }\n \n void query_drill(int i, int j) {\n ops_used++;\n total_cost += 1.0;\n cout << \"q 1 \" << i << \" \" << j << endl;\n flush();\n string resp;\n cin >> resp;\n int val = stoi(resp);\n reserves[i][j] = val;\n known[i][j] = true;\n estimates[i][j] = val;\n }\n \n double query_divine(const vector>& cells) {\n ops_used++;\n int k = cells.size();\n total_cost += 1.0 / sqrt(k);\n cout << \"q \" << k;\n for (auto [i,j] : cells) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush();\n string resp;\n cin >> resp;\n return stod(resp);\n }\n \n bool guess_answer(const vector>& answer) {\n ops_used++;\n total_cost += 1.0;\n cout << \"a \" << answer.size();\n for (auto [i,j] : answer) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush();\n int resp;\n cin >> resp;\n return resp == 1;\n }\n \n vector> get_region_cells(int si, int sj, int ei, int ej) {\n vector> cells;\n for (int i = si; i <= ei; i++) {\n for (int j = sj; j <= ej; j++) {\n cells.emplace_back(i, j);\n }\n }\n return cells;\n }\n \n void initial_coarse_scan() {\n // Use large divine queries to get rough estimates\n int block_size = max(2, N/3);\n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n int ei = min(N-1, bi + block_size - 1);\n int ej = min(N-1, bj + block_size - 1);\n auto cells = get_region_cells(bi, bj, ei, ej);\n if (cells.size() >= 2) {\n double val = query_divine(cells);\n double avg = val / cells.size();\n for (auto [i,j] : cells) {\n estimates[i][j] = avg;\n }\n }\n }\n }\n }\n \n void refine_promising_areas() {\n // Focus on areas with higher estimates\n vector> candidates;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!known[i][j]) {\n candidates.emplace_back(estimates[i][j], i, j);\n }\n }\n }\n sort(candidates.rbegin(), candidates.rend());\n \n int drill_limit = min(N*N/4, (int)candidates.size());\n for (int idx = 0; idx < drill_limit && ops_used < N*N; idx++) {\n auto [_, i, j] = candidates[idx];\n if (!known[i][j]) {\n query_drill(i, j);\n }\n }\n }\n \n bool can_place_field(int field_id, int si, int sj) {\n const auto& field = fields[field_id];\n for (auto [di, dj] : field.cells) {\n int i = si + di, j = sj + dj;\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n }\n return true;\n }\n \n void pattern_matching() {\n // Try to match oil field patterns with known oil locations\n vector> has_oil(N, vector(N, false));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known[i][j] && reserves[i][j] > 0) {\n has_oil[i][j] = true;\n }\n }\n }\n \n // For each known oil location, try to place oil fields\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (has_oil[i][j]) {\n for (int fid = 0; fid < M; fid++) {\n const auto& field = fields[fid];\n // Try different positions where this field could cover (i,j)\n for (auto [di, dj] : field.cells) {\n int si = i - di, sj = j - dj;\n if (can_place_field(fid, si, sj)) {\n // Check if this placement is consistent\n bool consistent = true;\n for (auto [fi, fj] : field.cells) {\n int ti = si + fi, tj = sj + fj;\n if (known[ti][tj] && reserves[ti][tj] == 0) {\n consistent = false;\n break;\n }\n }\n if (consistent) {\n for (auto [fi, fj] : field.cells) {\n int ti = si + fi, tj = sj + fj;\n estimates[ti][tj] = max(estimates[ti][tj], 0.5);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n \n void verify_and_explore() {\n // Drill some uncertain squares based on updated estimates\n vector> uncertain;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!known[i][j]) {\n uncertain.emplace_back(estimates[i][j], i, j);\n }\n }\n }\n sort(uncertain.rbegin(), uncertain.rend());\n \n int verify_limit = min(N*N/6, (int)uncertain.size());\n for (int idx = 0; idx < verify_limit && ops_used < 2*N*N - 10; idx++) {\n auto [_, i, j] = uncertain[idx];\n if (!known[i][j] && estimates[i][j] > 0.1) {\n query_drill(i, j);\n }\n }\n }\n \n vector> get_answer() {\n vector> answer;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known[i][j] && reserves[i][j] > 0) {\n answer.emplace_back(i, j);\n } else if (!known[i][j] && estimates[i][j] > 0.3) {\n answer.emplace_back(i, j);\n }\n }\n }\n return answer;\n }\n \n void solve() {\n initial_coarse_scan();\n refine_promising_areas();\n pattern_matching();\n verify_and_explore();\n \n auto answer = get_answer();\n if (guess_answer(answer)) {\n return;\n }\n \n // If failed, do more drilling and try again\n int remaining_ops = 2*N*N - ops_used;\n for (int i = 0; i < N && remaining_ops > 0; i++) {\n for (int j = 0; j < N && remaining_ops > 0; j++) {\n if (!known[i][j] && estimates[i][j] > 0.2) {\n query_drill(i, j);\n remaining_ops--;\n }\n }\n }\n \n answer = get_answer();\n guess_answer(answer);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n vector fields(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n fields[k].size = d;\n fields[k].cells.resize(d);\n for (int i = 0; i < d; i++) {\n cin >> fields[k].cells[i].first >> fields[k].cells[i].second;\n }\n }\n \n Solver solver(N, M, eps, fields);\n solver.solve();\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n \n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> a[d][k];\n }\n }\n \n // Strategy: vertical strips with adaptive widths\n // Track previous widths to minimize partition changes\n vector prev_widths(N, W / N);\n \n for (int d = 0; d < D; d++) {\n vector widths(N);\n \n // Calculate minimum widths to meet area requirements\n vector min_widths(N);\n int total_min_width = 0;\n for (int k = 0; k < N; k++) {\n min_widths[k] = (a[d][k] + W - 1) / W; // ceil(a[d][k] / W)\n total_min_width += min_widths[k];\n }\n \n if (total_min_width <= W) {\n // Can meet all area requirements\n widths = min_widths;\n int remaining = W - total_min_width;\n \n // Distribute remaining space proportionally to area requirements\n double total_area = accumulate(a[d].begin(), a[d].end(), 0.0);\n vector area_ratios(N);\n for (int k = 0; k < N; k++) {\n area_ratios[k] = (double)a[d][k] / total_area;\n }\n \n for (int i = 0; i < remaining; i++) {\n // Give extra space to rectangle with highest \"need\" ratio\n double max_ratio = -1;\n int best_k = 0;\n for (int k = 0; k < N; k++) {\n double ratio = (double)(widths[k] + 1) / (area_ratios[k] * W + 1e-9);\n if (ratio > max_ratio) {\n max_ratio = ratio;\n best_k = k;\n }\n }\n widths[best_k]++;\n }\n } else {\n // Need to scale down proportionally\n double scale = (double)W / total_min_width;\n for (int k = 0; k < N; k++) {\n widths[k] = max(1, (int)round(min_widths[k] * scale));\n }\n \n // Adjust to ensure sum equals W\n int current_sum = accumulate(widths.begin(), widths.end(), 0);\n int diff = W - current_sum;\n \n while (diff != 0) {\n if (diff > 0) {\n // Give to rectangle with largest area requirement\n int best_k = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n widths[best_k]++;\n diff--;\n } else {\n // Take from rectangle with smallest area requirement\n int best_k = min_element(a[d].begin(), a[d].end()) - a[d].begin();\n if (widths[best_k] > 1) {\n widths[best_k]--;\n diff++;\n } else {\n break;\n }\n }\n }\n }\n \n // Apply smoothing to reduce partition changes\n if (d > 0) {\n for (int k = 0; k < N; k++) {\n widths[k] = (int)round(0.7 * widths[k] + 0.3 * prev_widths[k]);\n }\n \n // Ensure sum equals W after smoothing\n int current_sum = accumulate(widths.begin(), widths.end(), 0);\n int diff = W - current_sum;\n \n while (diff != 0) {\n if (diff > 0) {\n int best_k = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n widths[best_k]++;\n diff--;\n } else {\n int best_k = min_element(a[d].begin(), a[d].end()) - a[d].begin();\n if (widths[best_k] > 1) {\n widths[best_k]--;\n diff++;\n } else {\n break;\n }\n }\n }\n }\n \n // Output rectangles as vertical strips\n int pos = 0;\n for (int k = 0; k < N; k++) {\n cout << pos << \" 0 \" << pos + widths[k] << \" \" << W << \"\\n\";\n pos += widths[k];\n }\n \n prev_widths = widths;\n }\n \n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic const int MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\n// ---------- board utilities ----------\ninline void addStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int v = board[p + i][q + j] + stamp[m][i][j];\n if (v >= MOD) v -= MOD;\n board[p + i][q + j] = v;\n }\n }\n}\ninline void removeStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int v = board[p + i][q + j] - stamp[m][i][j];\n if (v < 0) v += MOD;\n board[p + i][q + j] = v;\n }\n }\n}\n// profit of applying a stamp on the current board\ninline long long profitStamp(int m, int p, int q,\n const vector>>& stamp,\n const vector>& board)\n{\n long long delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int s = stamp[m][i][j];\n int cur = board[p + i][q + j];\n if (cur + s >= MOD) delta += s - MOD; // overflow \u2192 negative part\n else delta += s;\n }\n }\n return delta;\n}\n\n// ---------- main solving ----------\nint main()\n{\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n vector> a(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> a[i][j];\n\n vector>> stamp(M, vector>(3, vector(3)));\n for (int m = 0; m < M; ++m)\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) cin >> stamp[m][i][j];\n\n const int POS = N - 2; // 7\n vector> positions;\n positions.reserve(POS * POS);\n for (int p = 0; p < POS; ++p)\n for (int q = 0; q < POS; ++q)\n positions.emplace_back(p, q);\n\n mt19937 rng(random_device{}());\n\n vector bestOps;\n long long bestScore = 0;\n for (auto& row : a) bestScore += row[0];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) bestScore += a[i][j]; // initial score\n\n const int ATTEMPTS = 5;\n const int LS_ITER = 2000;\n\n for (int attempt = 0; attempt < ATTEMPTS; ++attempt) {\n // start from the initial board\n vector> board = a;\n vector ops;\n\n // ---- greedy phase ----\n for (int step = 0; step < K; ++step) {\n long long bestDelta = LLONG_MIN;\n Op bestOp{-1, -1, -1};\n\n // random order of stamps and positions for diversity\n vector stampIdx(M);\n iota(stampIdx.begin(), stampIdx.end(), 0);\n shuffle(stampIdx.begin(), stampIdx.end(), rng);\n vector> posShuffle = positions;\n shuffle(posShuffle.begin(), posShuffle.end(), rng);\n\n for (int m : stampIdx) {\n for (auto [p, q] : posShuffle) {\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestOp = {m, p, q};\n }\n }\n }\n if (bestDelta <= 0) break; // no improving operation left\n addStamp(bestOp.m, bestOp.p, bestOp.q, stamp, board);\n ops.push_back(bestOp);\n }\n\n // ---- hill climbing ----\n for (int iter = 0; iter < LS_ITER; ++iter) {\n int choice = rng() % 100;\n if (ops.size() < K && choice < 20) { // try to add\n int m = rng() % M;\n int p = rng() % POS;\n int q = rng() % POS;\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > 0) {\n addStamp(m, p, q, stamp, board);\n ops.emplace_back(m, p, q);\n }\n } else if (!ops.empty() && choice < 30) { // try to remove\n int idx = rng() % ops.size();\n Op cur = ops[idx];\n long long delta = profitStamp(cur.m, cur.p, cur.q, stamp, board);\n if (delta < 0) {\n removeStamp(cur.m, cur.p, cur.q, stamp, board);\n ops.erase(ops.begin() + idx);\n }\n } else { // try to replace\n if (ops.empty()) continue;\n int idx = rng() % ops.size();\n Op cur = ops[idx];\n long long deltaOld = profitStamp(cur.m, cur.p, cur.q, stamp, board);\n int m2 = rng() % M;\n int p2 = rng() % POS;\n int q2 = rng() % POS;\n long long deltaNew = profitStamp(m2, p2, q2, stamp, board);\n if (deltaNew > deltaOld) {\n removeStamp(cur.m, cur.p, cur.q, stamp, board);\n addStamp(m2, p2, q2, stamp, board);\n ops[idx] = {m2, p2, q2};\n }\n }\n }\n\n // evaluate this run\n long long curScore = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) curScore += board[i][j];\n if (curScore > bestScore) {\n bestScore = curScore;\n bestOps = ops;\n }\n }\n\n // ---- output ----\n cout << bestOps.size() << \"\\n\";\n for (auto op : bestOps) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Container {\n int id;\n int arrival_row;\n int arrival_index;\n int target_row;\n int dispatch_order;\n};\n\nstruct Crane {\n int row, col;\n bool carrying;\n int container_id;\n vector commands;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 5;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n // Determine which gate each container should go to\n vector containers(N * N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container_id = A[i][j];\n containers[container_id].id = container_id;\n containers[container_id].arrival_row = i;\n containers[container_id].arrival_index = j;\n containers[container_id].target_row = container_id / N;\n containers[container_id].dispatch_order = container_id % N;\n }\n }\n \n // Sort containers by target gate, then by dispatch order\n sort(containers.begin(), containers.end(), [](const Container& a, const Container& b) {\n if (a.target_row != b.target_row) return a.target_row < b.target_row;\n return a.dispatch_order < b.dispatch_order;\n });\n \n // Initialize cranes\n vector cranes(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].carrying = false;\n cranes[i].container_id = -1;\n }\n \n // Large crane (index 0) will do most of the work\n Crane& large_crane = cranes[0];\n \n // Process containers one by one\n for (const auto& container : containers) {\n // Move large crane to the arrival position\n while (large_crane.row != container.arrival_row) {\n if (large_crane.row < container.arrival_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != container.arrival_index) {\n if (large_crane.col < container.arrival_index) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n } else {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Pick up the container\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to the dispatch position\n while (large_crane.row != container.target_row) {\n if (large_crane.row < container.target_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != N - 1) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n }\n \n // Release the container\n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n // Move back to starting position for next container\n while (large_crane.row != 0) {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n while (large_crane.col != 0) {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Small cranes do minimal work - just stay in place\n for (int i = 1; i < N; i++) {\n // Small cranes can help clear paths by moving away if needed\n // For simplicity, just make them wait\n int max_len = large_crane.commands.size();\n cranes[i].commands.resize(max_len, '.');\n }\n \n // Output the commands\n int max_len = 0;\n for (const auto& crane : cranes) {\n max_len = max(max_len, (int)crane.commands.size());\n }\n \n // Ensure all command strings have the same length\n for (auto& crane : cranes) {\n while (crane.commands.size() < max_len) {\n crane.commands.push_back('.');\n }\n }\n \n for (const auto& crane : cranes) {\n string s(crane.commands.begin(), crane.commands.end());\n cout << s << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int i, j, height;\n int id;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 20;\n vector> h(N, vector(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n \n vector positive, negative;\n int id_counter = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n positive.push_back({i, j, h[i][j], id_counter++});\n } else if (h[i][j] < 0) {\n negative.push_back({i, j, -h[i][j], id_counter++});\n }\n }\n }\n \n vector operations;\n int ci = 0, cj = 0; // current position\n \n // Optimal path with load consideration\n auto get_path = [&](int ti, int tj) {\n vector path;\n while (ci != ti || cj != tj) {\n if (ci > ti) {\n path.push_back(\"U\");\n ci--;\n } else if (ci < ti) {\n path.push_back(\"D\");\n ci++;\n } else if (cj > tj) {\n path.push_back(\"L\");\n cj--;\n } else if (cj < tj) {\n path.push_back(\"R\");\n cj++;\n }\n }\n return path;\n };\n \n // Create a bipartite matching problem\n // For each unit of soil, find optimal destination\n vector> all_positive_units, all_negative_units;\n \n for (int pi = 0; pi < positive.size(); pi++) {\n for (int k = 0; k < positive[pi].height; k++) {\n all_positive_units.push_back({pi, k});\n }\n }\n \n for (int ni = 0; ni < negative.size(); ni++) {\n for (int k = 0; k < negative[ni].height; k++) {\n all_negative_units.push_back({ni, k});\n }\n }\n \n // Simple greedy matching with batching\n while (!positive.empty() && !negative.empty()) {\n // Find best batch transport\n double best_ratio = -1;\n int best_pi = -1, best_ni = -1, best_amount = 0;\n \n for (int pi = 0; pi < positive.size(); pi++) {\n for (int ni = 0; ni < negative.size(); ni++) {\n int dist = abs(positive[pi].i - negative[ni].i) + \n abs(positive[pi].j - negative[ni].j);\n if (dist == 0) continue;\n \n int amount = min(positive[pi].height, negative[ni].height);\n // Cost efficiency: amount / cost\n double cost = 100.0 * dist;\n double ratio = (double)amount / cost;\n \n // Prefer larger batches for same efficiency\n if (ratio > best_ratio || (abs(ratio - best_ratio) < 1e-9 && amount > best_amount)) {\n best_ratio = ratio;\n best_pi = pi;\n best_ni = ni;\n best_amount = amount;\n }\n }\n }\n \n if (best_pi == -1) break;\n \n Cell& pos = positive[best_pi];\n Cell& neg = negative[best_ni];\n \n // Move to positive cell\n auto path_to_pos = get_path(pos.i, pos.j);\n operations.insert(operations.end(), path_to_pos.begin(), path_to_pos.end());\n \n // Load soil\n operations.push_back(\"+\" + to_string(best_amount));\n pos.height -= best_amount;\n neg.height -= best_amount;\n \n // Move to negative cell\n auto path_to_neg = get_path(neg.i, neg.j);\n operations.insert(operations.end(), path_to_neg.begin(), path_to_neg.end());\n \n // Unload soil\n operations.push_back(\"-\" + to_string(best_amount));\n \n if (pos.height == 0) {\n positive.erase(positive.begin() + best_pi);\n }\n if (neg.height == 0) {\n negative.erase(negative.begin() + best_ni);\n }\n }\n \n // Handle remaining cells (should be very few)\n for (int pi = 0; pi < positive.size(); pi++) {\n if (positive[pi].height > 0) {\n auto path = get_path(positive[pi].i, positive[pi].j);\n operations.insert(operations.end(), path.begin(), path.end());\n operations.push_back(\"+\" + to_string(positive[pi].height));\n operations.push_back(\"-\" + to_string(positive[pi].height));\n }\n }\n \n for (int ni = 0; ni < negative.size(); ni++) {\n if (negative[ni].height > 0) {\n auto path = get_path(negative[ni].i, negative[ni].j);\n operations.insert(operations.end(), path.begin(), path.end());\n operations.push_back(\"+\" + to_string(negative[ni].height));\n operations.push_back(\"-\" + to_string(negative[ni].height));\n }\n }\n \n // Output operations\n for (const string& op : operations) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n vector values;\n int total_value;\n double score;\n int id;\n double potential;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, T;\n cin >> N >> M >> T;\n \n const int SEED_COUNT = 2 * N * (N - 1);\n vector seeds(SEED_COUNT);\n \n // Read initial seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].id = i;\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Calculate max values for each criterion\n vector max_criterion(M, 0);\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n \n for (int turn = 0; turn < T; turn++) {\n // Calculate comprehensive scores for each seed\n for (int i = 0; i < SEED_COUNT; i++) {\n // Current strength\n double current_strength = seeds[i].total_value;\n \n // Criterion-specific strength (how many criteria is this seed good at?)\n int strong_criteria = 0;\n double criterion_score = 0;\n for (int j = 0; j < M; j++) {\n if (max_criterion[j] > 0) {\n double ratio = (double)seeds[i].values[j] / max_criterion[j];\n if (ratio > 0.7) strong_criteria++;\n criterion_score += ratio * ratio * ratio; // Cube to emphasize strong criteria\n }\n }\n \n // Potential score based on strong criteria count\n double potential = strong_criteria * strong_criteria * 50;\n \n // Diversity bonus (seeds with unique combinations)\n double diversity_bonus = 0;\n static unordered_set seen_patterns;\n seen_patterns.clear();\n \n // Create a hash of the seed's pattern\n long long pattern_hash = 0;\n for (int j = 0; j < min(M, 10); j++) {\n pattern_hash = pattern_hash * 101 + seeds[i].values[j];\n }\n if (seen_patterns.find(pattern_hash) == seen_patterns.end()) {\n diversity_bonus = 100;\n seen_patterns.insert(pattern_hash);\n }\n \n // Adaptive scoring based on turn\n double turn_factor = 1.0;\n if (turn < T / 3) {\n // Early turns: prioritize potential and diversity\n turn_factor = 0.7 + 0.3 * (turn / (double)(T / 3));\n } else if (turn < 2 * T / 3) {\n // Mid turns: balanced approach\n turn_factor = 1.0;\n } else {\n // Late turns: prioritize current strength\n turn_factor = 1.0 + 0.5 * ((turn - 2 * T / 3) / (double)(T / 3));\n }\n \n seeds[i].potential = potential;\n seeds[i].score = current_strength * 0.4 + criterion_score * 0.3 + \n potential * 0.2 + diversity_bonus * 0.1;\n seeds[i].score *= turn_factor;\n }\n \n // Sort seeds by score\n sort(seeds.begin(), seeds.end(), [](const Seed& a, const Seed& b) {\n return a.score > b.score;\n });\n \n // Select top seeds with some diversity\n vector selected_ids;\n selected_ids.push_back(seeds[0].id); // Always include the best\n \n // Add more seeds with diversity consideration\n for (int i = 1; i < min(50, SEED_COUNT) && selected_ids.size() < N * N; i++) {\n bool too_similar = false;\n for (int selected_id : selected_ids) {\n // Check similarity\n int similarity = 0;\n for (int j = 0; j < M; j++) {\n if (abs(seeds[i].values[j] - seeds[selected_id].values[j]) <= 10) {\n similarity++;\n }\n }\n if (similarity > M * 0.7) {\n too_similar = true;\n break;\n }\n }\n if (!too_similar || selected_ids.size() < N * N / 2) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n \n // Fill remaining slots with top seeds\n while (selected_ids.size() < N * N) {\n for (int i = 0; i < SEED_COUNT && selected_ids.size() < N * N; i++) {\n if (find(selected_ids.begin(), selected_ids.end(), seeds[i].id) == selected_ids.end()) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n }\n \n // Create grid arrangement\n vector> grid(N, vector(N));\n \n // Sort selected seeds by total value for placement\n vector> seed_value_pairs;\n for (int id : selected_ids) {\n seed_value_pairs.emplace_back(seeds[id].total_value, id);\n }\n sort(seed_value_pairs.rbegin(), seed_value_pairs.rend());\n \n // Dynamic positioning strategy\n vector> positions;\n \n if (turn < T / 2) {\n // Early to mid game: cluster strong seeds\n int center = N / 2;\n positions.emplace_back(center, center);\n positions.emplace_back(center-1, center);\n positions.emplace_back(center, center-1);\n positions.emplace_back(center-1, center-1);\n \n // Add adjacent positions\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n int ni = center + di;\n int nj = center + dj;\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n bool found = false;\n for (auto& pos : positions) {\n if (pos.first == ni && pos.second == nj) {\n found = true;\n break;\n }\n }\n if (!found) {\n positions.emplace_back(ni, nj);\n }\n }\n }\n }\n } else {\n // Late game: spread out to maximize coverage\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 0) {\n positions.emplace_back(i, j);\n }\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 1) {\n positions.emplace_back(i, j);\n }\n }\n }\n }\n \n // Add remaining positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool found = false;\n for (auto& pos : positions) {\n if (pos.first == i && pos.second == j) {\n found = true;\n break;\n }\n }\n if (!found) {\n positions.emplace_back(i, j);\n }\n }\n }\n \n // Place seeds\n for (size_t i = 0; i < positions.size() && i < seed_value_pairs.size(); i++) {\n grid[positions[i].first][positions[i].second] = seed_value_pairs[i].second;\n }\n \n // Output 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 << \"\\n\";\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Update max criteria\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n }\n \n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n int manhattan(const Point& other) const {\n return abs(x - other.x) + abs(y - other.y);\n }\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector s_grid, t_grid;\n vector initial_pos, target_pos;\n vector tree;\n Point root_pos;\n int V_used;\n \n // State tracking\n vector vertex_positions;\n vector edge_directions; // 0=right, 1=down, 2=left, 3=up\n vector holding_takoyaki;\n \n // Task assignment\n vector> fingertip_paths;\n vector path_progress;\n vector assigned_takoyaki;\n \npublic:\n RoboticArmSolver(int N, int M, int V, const vector& s, const vector& t) \n : N(N), M(M), V(V), s_grid(s), t_grid(t) {\n // Extract initial and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (s[i][j] == '1') initial_pos.emplace_back(i, j);\n if (t[i][j] == '1') target_pos.emplace_back(i, j);\n }\n }\n }\n \n void design_arm() {\n // Design a flexible tree structure\n V_used = min(V, 9); // Use up to 9 vertices for good balance\n tree.resize(V_used);\n \n // Root\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Create a balanced structure\n if (V_used <= 3) {\n // Simple line for small V\n for (int i = 1; i < V_used; i++) {\n tree[i].parent = i - 1;\n tree[i].is_leaf = (i == V_used - 1);\n tree[i].length = max(1, N / 4);\n tree[i - 1].children.push_back(i);\n }\n } else {\n // Star-like structure with some depth\n int main_branches = min(3, V_used - 1);\n \n // Level 1\n for (int i = 1; i <= main_branches; i++) {\n tree[i].parent = 0;\n tree[i].is_leaf = false;\n tree[i].length = max(1, N / 3);\n tree[0].children.push_back(i);\n }\n \n // Level 2 (fingertips)\n int vertex = main_branches + 1;\n for (int parent = 1; parent <= main_branches && vertex < V_used; parent++) {\n int children = min(2, V_used - vertex);\n for (int c = 0; c < children; c++) {\n tree[vertex].parent = parent;\n tree[vertex].is_leaf = true;\n tree[vertex].length = max(1, N / 5);\n tree[parent].children.push_back(vertex);\n vertex++;\n }\n }\n }\n \n // Position root strategically - between centers of mass\n Point center_initial(0, 0), center_target(0, 0);\n for (const auto& p : initial_pos) {\n center_initial.x += p.x;\n center_initial.y += p.y;\n }\n for (const auto& p : target_pos) {\n center_target.x += p.x;\n center_target.y += p.y;\n }\n center_initial.x /= M;\n center_initial.y /= M;\n center_target.x /= M;\n center_target.y /= M;\n \n root_pos.x = max(0, min(N-1, (center_initial.x + center_target.x) / 2));\n root_pos.y = max(0, min(N-1, (center_initial.y + center_target.y) / 2));\n \n // Initialize state\n vertex_positions.resize(V_used);\n edge_directions.assign(V_used, 0); // All initially pointing right\n holding_takoyaki.assign(V_used, false);\n assigned_takoyaki.assign(M, -1);\n \n update_positions();\n }\n \n void update_positions() {\n vertex_positions[0] = root_pos;\n \n for (int i = 1; i < V_used; i++) {\n int parent = tree[i].parent;\n int dir = edge_directions[i];\n int dx[4] = {0, 1, 0, -1}; // right, down, left, up\n int dy[4] = {1, 0, -1, 0};\n \n vertex_positions[i].x = vertex_positions[parent].x + dx[dir] * tree[i].length;\n vertex_positions[i].y = vertex_positions[parent].y + dy[dir] * tree[i].length;\n }\n }\n \n void print_design() {\n cout << V_used << endl;\n for (int i = 1; i < V_used; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n cout << root_pos.x << \" \" << root_pos.y << endl;\n }\n \n void assign_tasks() {\n // Get list of fingertips\n vector fingertips;\n for (int i = 1; i < V_used; i++) {\n if (tree[i].is_leaf) fingertips.push_back(i);\n }\n \n // Calculate assignment costs\n vector> costs(M, vector(fingertips.size()));\n \n for (int i = 0; i < M; i++) {\n for (int j = 0; j < fingertips.size(); j++) {\n int dist_to_initial = vertex_positions[fingertips[j]].manhattan(initial_pos[i]);\n int travel_dist = initial_pos[i].manhattan(target_pos[i]);\n costs[i][j] = dist_to_initial + travel_dist;\n }\n }\n \n // Hungarian-like greedy assignment\n vector used_initial(M, false);\n vector used_fingertips(fingertips.size(), false);\n \n fingertip_paths.resize(fingertips.size());\n path_progress.assign(fingertips.size(), 0);\n \n for (int k = 0; k < min(M, (int)fingertips.size()); k++) {\n int best_i = -1, best_j = -1;\n int min_cost = INT_MAX;\n \n for (int i = 0; i < M; i++) {\n if (!used_initial[i]) {\n for (int j = 0; j < fingertips.size(); j++) {\n if (!used_fingertips[j] && costs[i][j] < min_cost) {\n min_cost = costs[i][j];\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n \n if (best_i != -1 && best_j != -1) {\n used_initial[best_i] = true;\n used_fingertips[best_j] = true;\n assigned_takoyaki[best_i] = fingertips[best_j];\n \n // Create path: current -> initial -> target\n vector path;\n \n // From current position to initial\n Point current = vertex_positions[fingertips[best_j]];\n Point target = initial_pos[best_i];\n \n while (current != target) {\n path.push_back(current);\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n }\n path.push_back(target); // Pickup point\n \n // From initial to target\n current = target;\n target = target_pos[best_i];\n \n while (current != target) {\n path.push_back(current);\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n }\n path.push_back(target); // Dropoff point\n \n fingertip_paths[best_j] = path;\n }\n }\n }\n \n string generate_operation() {\n string op(2 * V_used, '.');\n \n // Find fingertip that needs to move most urgently\n int urgent_fingertip = -1;\n int urgent_path_idx = -1;\n int max_progress_deficit = 0;\n \n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (fingertip_paths[i].empty()) continue;\n \n int total_steps = fingertip_paths[i].size();\n int current_step = path_progress[i];\n int deficit = total_steps - current_step;\n \n if (deficit > max_progress_deficit) {\n max_progress_deficit = deficit;\n urgent_fingertip = assigned_takoyaki[i];\n urgent_path_idx = i;\n }\n }\n \n if (urgent_fingertip == -1) return op;\n \n Point target = fingertip_paths[urgent_path_idx][path_progress[urgent_path_idx]];\n Point current = vertex_positions[urgent_fingertip];\n \n // Check if at target\n if (current == target) {\n // Handle pickup/dropoff\n if (path_progress[urgent_path_idx] == 0) {\n // First position - pickup\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = true;\n } else if (path_progress[urgent_path_idx] == fingertip_paths[urgent_path_idx].size() - 1) {\n // Last position - dropoff\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = false;\n }\n path_progress[urgent_path_idx]++;\n return op;\n }\n \n // Find best move to get closer to target\n int best_dist = current.manhattan(target);\n char best_root_move = '.';\n int best_rotation = 0; // 0=none, 1=L, 2=R\n \n // Try root movements\n int dx[4] = {-1, 1, 0, 0}; // U, D, L, R\n int dy[4] = {0, 0, -1, 1};\n char moves[4] = {'U', 'D', 'L', 'R'};\n \n for (int d = 0; d < 4; d++) {\n Point new_root(root_pos.x + dx[d], root_pos.y + dy[d]);\n if (new_root.x < 0 || new_root.x >= N || new_root.y < 0 || new_root.y >= N) continue;\n \n Point old_root = root_pos;\n root_pos = new_root;\n update_positions();\n \n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_root_move = moves[d];\n }\n \n root_pos = old_root;\n update_positions();\n }\n \n // Try rotations\n for (int r = 1; r <= 2; r++) {\n int old_dir = edge_directions[urgent_fingertip];\n edge_directions[urgent_fingertip] = (old_dir + (r == 1 ? 3 : 1)) % 4;\n update_positions();\n \n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_root_move = '.';\n best_rotation = r;\n }\n \n edge_directions[urgent_fingertip] = old_dir;\n update_positions();\n }\n \n // Apply best move\n if (best_root_move != '.') {\n op[0] = best_root_move;\n if (best_root_move == 'U') root_pos.x--;\n else if (best_root_move == 'D') root_pos.x++;\n else if (best_root_move == 'L') root_pos.y--;\n else if (best_root_move == 'R') root_pos.y++;\n update_positions();\n } else if (best_rotation > 0) {\n op[urgent_fingertip] = (best_rotation == 1) ? 'L' : 'R';\n edge_directions[urgent_fingertip] = (edge_directions[urgent_fingertip] + (best_rotation == 1 ? 3 : 1)) % 4;\n update_positions();\n }\n \n return op;\n }\n \n void execute_operations() {\n assign_tasks();\n \n bool all_complete = false;\n int max_turns = 10000; // Safety limit\n \n while (!all_complete && max_turns-- > 0) {\n string op = generate_operation();\n cout << op << endl;\n \n // Check if all paths are completed\n all_complete = true;\n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (path_progress[i] < fingertip_paths[i].size()) {\n all_complete = false;\n break;\n }\n }\n }\n }\n \n void solve() {\n design_arm();\n print_design();\n execute_operations();\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M, V;\n cin >> N >> M >> V;\n \n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n \n RoboticArmSolver solver(N, M, V, s, t);\n solver.solve();\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n bool is_mackerel;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n cin >> points[i].x >> points[i].y;\n points[i].is_mackerel = (i < N);\n }\n \n auto count_in_rectangle = [&](int x1, int x2, int y1, int y2) {\n int a = 0, b = 0;\n for (const auto& p : points) {\n if (p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2) {\n if (p.is_mackerel) a++;\n else b++;\n }\n }\n return make_pair(a, b);\n };\n \n int best_diff = -1;\n int best_x1 = -1, best_y1 = -1, best_x2 = -1, best_y2 = -1;\n \n // Try small rectangles around each mackerel\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n int initial_size = 5;\n int x1 = max(0, p.x - initial_size);\n int x2 = min(100000, p.x + initial_size);\n int y1 = max(0, p.y - initial_size);\n int y2 = min(100000, p.y + initial_size);\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n int diff = a - b;\n if (diff > best_diff) {\n best_diff = diff;\n best_x1 = x1; best_y1 = y1; best_x2 = x2; best_y2 = y2;\n }\n }\n \n if (best_diff <= 0) {\n // Find a single mackerel and make a minimal polygon\n for (const auto& p : points) {\n if (p.is_mackerel) {\n int x = p.x;\n int y = p.y;\n cout << 4 << \"\\n\";\n cout << x << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y + 1 << \"\\n\";\n cout << x << \" \" << y + 1 << \"\\n\";\n return 0;\n }\n }\n }\n \n // Expand the best rectangle greedily\n bool improved = true;\n while (improved) {\n improved = false;\n int current_diff = best_diff;\n // Try expanding left\n if (best_x1 > 0) {\n int new_x1 = best_x1 - 1;\n auto [a, b] = count_in_rectangle(new_x1, best_x2, best_y1, best_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n // Try expanding right\n if (best_x2 < 100000) {\n int new_x2 = best_x2 + 1;\n auto [a, b] = count_in_rectangle(best_x1, new_x2, best_y1, best_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x2 = new_x2;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n // Try expanding down\n if (best_y1 > 0) {\n int new_y1 = best_y1 - 1;\n auto [a, b] = count_in_rectangle(best_x1, best_x2, new_y1, best_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_y1 = new_y1;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n // Try expanding up\n if (best_y2 < 100000) {\n int new_y2 = best_y2 + 1;\n auto [a, b] = count_in_rectangle(best_x1, best_x2, best_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n continue;\n }\n }\n }\n \n // Output the rectangle as a polygon\n cout << 4 << \"\\n\";\n cout << best_x1 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y2 << \"\\n\";\n cout << best_x1 << \" \" << best_y2 << \"\\n\";\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Item {\n int idx;\n long long w, h;\n};\n\nstruct Col {\n long long w, h;\n int last_item_idx;\n};\n\nstruct Cmd {\n int p, r, b;\n char d;\n};\n\nlong long get_w(const vector>& dims, int idx) {\n return dims[idx].first;\n}\n\nlong long get_h(const vector>& dims, int idx) {\n return dims[idx].second;\n}\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, T;\n long long sigma;\n cin >> N >> T >> sigma;\n\n vector w_prime(N), h_prime(N);\n for (int i = 0; i < N; ++i) {\n cin >> w_prime[i] >> h_prime[i];\n }\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n const int NUM_PROFILES = 5;\n\n for (int t = 0; t < T; ++t) {\n int profile = t % NUM_PROFILES;\n \n // Decide on the number of items to place (prefix length)\n // Cycle between N, N-1, N-2, N-3, N-4\n int k = N - (t % 5);\n if (k <= 0) k = 1;\n\n // cerr << \"Turn \" << t << \", Profile \" << profile << \", k=\" << k << endl;\n cout << \"# Turn \" << t << \", Profile \" << profile << \", k=\" << k << endl;\n\n vector columns;\n vector item_to_col(k, -1);\n vector> final_dims(k); // (w, h) for each item 0..k-1\n\n for (int i = 0; i < k; ++i) {\n long long w_orig = w_prime[i];\n long long h_orig = h_prime[i];\n\n vector> rot_options = {{w_orig, h_orig}, {h_orig, w_orig}};\n \n // Apply profile-based rotation preference\n if (profile == 0 || profile == 1 || profile == 4) { // Prefer w >= h\n if (rot_options[0].first < rot_options[0].second) {\n swap(rot_options[0], rot_options[1]);\n }\n } else if (profile == 3) { // Prefer h > w\n if (rot_options[0].first >= rot_options[0].second) {\n swap(rot_options[0], rot_options[1]);\n }\n }\n // Profile 2 (random) will handle rotation in the loop\n\n long long best_cost = 1e18;\n int best_col_idx = -1;\n int best_rot_idx = 0;\n\n for (int rot_idx = 0; rot_idx < 2; ++rot_idx) {\n // Random profile might override rotation preference\n if (profile == 2 && rng() % 2 == 0) {\n // Try the other orientation first with 50% chance\n if (rot_idx == 0) continue;\n }\n\n long long w = rot_options[rot_idx].first;\n long long h = rot_options[rot_idx].second;\n\n // Try to fit into existing columns\n for (int j = 0; j < columns.size(); ++j) {\n if (w <= columns[j].w) {\n long long cost = h;\n if (profile == 3) { // Height-averse: prefer shorter columns\n cost = columns[j].h + h;\n }\n\n if (cost < best_cost || (cost == best_cost && rng() % 2 == 0)) {\n best_cost = cost;\n best_col_idx = j;\n best_rot_idx = rot_idx;\n }\n }\n }\n\n // Try to create a new column\n long long cost_new_col = 1e18;\n if (profile == 1) { // Area-averse\n cost_new_col = w * h;\n } else if (profile == 4) { // Greedy for columns\n cost_new_col = 1e17; // A very large number\n } else { // Standard\n cost_new_col = w;\n }\n\n if (cost_new_col < best_cost || (cost_new_col == best_cost && rng() % 2 == 0)) {\n best_cost = cost_new_col;\n best_col_idx = -1; // Indicates new column\n best_rot_idx = rot_idx;\n }\n }\n\n // Apply best placement\n final_dims[i] = rot_options[best_rot_idx];\n if (best_col_idx == -1) {\n // Create new column\n columns.push_back({final_dims[i].first, final_dims[i].second, i});\n item_to_col[i] = columns.size() - 1;\n } else {\n // Add to existing column\n columns[best_col_idx].h += final_dims[i].second;\n columns[best_col_idx].last_item_idx = i;\n item_to_col[i] = best_col_idx;\n }\n }\n \n // Generate commands\n vector commands;\n map last_item_in_col;\n\n for (int i = 0; i < k; ++i) {\n int col_idx = item_to_col[i];\n int p = i;\n int r = (final_dims[i].first == h_prime[i]) ? 1 : 0;\n int b;\n char d;\n\n if (last_item_in_col.count(col_idx) == 0) {\n // First item in a new column\n if (col_idx == 0) {\n // First item, first column\n d = 'L';\n b = -1;\n } else {\n // First item of a subsequent column\n // Find the column immediately to the left\n int left_col_idx = -1;\n for(int j = 0; j < i; ++j) {\n if (item_to_col[j] < col_idx) {\n left_col_idx = item_to_col[j];\n }\n }\n // The last item placed in the left column is the reference\n b = columns[left_col_idx].last_item_idx;\n d = 'U';\n }\n } else {\n // Not the first item in its column\n b = last_item_in_col[col_idx];\n d = 'L';\n }\n\n commands.push_back({p, r, b, d});\n last_item_in_col[col_idx] = i;\n }\n\n // Output\n cout << commands.size() << \"\\n\";\n for (const auto& cmd : commands) {\n cout << cmd.p << \" \" << cmd.r << \" \" << cmd.d << \" \" << cmd.b << \"\\n\";\n }\n cout << flush;\n\n // Read response\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc041":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Vertex {\n int x, y;\n int beauty;\n vector neighbors;\n int parent;\n int depth;\n int tree_id;\n bool assigned;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].beauty;\n }\n \n // Store edges for validation\n set> edge_set;\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n vertices[u].neighbors.push_back(v);\n vertices[v].neighbors.push_back(u);\n edge_set.insert({min(u, v), max(u, v)});\n }\n \n for (int i = 0; i < N; i++) {\n cin >> vertices[i].x >> vertices[i].y;\n }\n \n // Initialize\n for (int i = 0; i < N; i++) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = -1;\n vertices[i].assigned = false;\n }\n \n // Sort vertices by beauty (ascending) for root selection\n vector sorted_by_beauty(N);\n iota(sorted_by_beauty.begin(), sorted_by_beauty.end(), 0);\n sort(sorted_by_beauty.begin(), sorted_by_beauty.end(), \n [&](int a, int b) { return vertices[a].beauty < vertices[b].beauty; });\n \n // Select roots (approximately N/20 roots)\n int num_roots = max(1, N / 20);\n vector roots;\n vector is_root(N, false);\n \n for (int i = 0; i < num_roots && i < N; i++) {\n int v = sorted_by_beauty[i];\n // Check distance from existing roots\n bool too_close = false;\n for (int r : roots) {\n int dx = vertices[v].x - vertices[r].x;\n int dy = vertices[v].y - vertices[r].y;\n if (dx*dx + dy*dy < 3600) { // 60 units squared\n too_close = true;\n break;\n }\n }\n if (!too_close) {\n roots.push_back(v);\n is_root[v] = true;\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n vertices[v].assigned = true;\n }\n }\n \n // If no roots selected, make vertex 0 a root\n if (roots.empty()) {\n roots.push_back(0);\n is_root[0] = true;\n vertices[0].parent = -1;\n vertices[0].depth = 0;\n vertices[0].tree_id = 0;\n vertices[0].assigned = true;\n }\n \n // Grow trees from roots using BFS\n for (int root : roots) {\n queue q;\n q.push(root);\n \n while (!q.empty()) {\n int v = q.front();\n q.pop();\n \n if (vertices[v].depth >= H) continue;\n \n // Sort neighbors by beauty (descending) to prioritize high-beauty vertices\n vector> neighbor_beauty;\n for (int nb : vertices[v].neighbors) {\n if (!vertices[nb].assigned) {\n neighbor_beauty.emplace_back(vertices[nb].beauty, nb);\n }\n }\n sort(neighbor_beauty.rbegin(), neighbor_beauty.rend());\n \n for (auto [beauty, nb] : neighbor_beauty) {\n vertices[nb].parent = v;\n vertices[nb].depth = vertices[v].depth + 1;\n vertices[nb].tree_id = root;\n vertices[nb].assigned = true;\n q.push(nb);\n }\n }\n }\n \n // Assign remaining unassigned vertices\n vector unassigned;\n for (int i = 0; i < N; i++) {\n if (!vertices[i].assigned) {\n unassigned.push_back(i);\n }\n }\n \n // For each unassigned vertex, find the best valid parent\n for (int v : unassigned) {\n int best_parent = -1;\n int best_score = INT_MIN;\n \n // Check all neighbors that are assigned and have depth < H\n for (int nb : vertices[v].neighbors) {\n if (vertices[nb].assigned && vertices[nb].depth < H) {\n int score = (vertices[nb].depth + 2) * vertices[v].beauty;\n if (score > best_score) {\n best_score = score;\n best_parent = nb;\n }\n }\n }\n \n if (best_parent != -1) {\n vertices[v].parent = best_parent;\n vertices[v].depth = vertices[best_parent].depth + 1;\n vertices[v].tree_id = vertices[best_parent].tree_id;\n vertices[v].assigned = true;\n } else {\n // Make it a new root\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n vertices[v].assigned = true;\n roots.push_back(v);\n }\n }\n \n // Verify all parent-child relationships are valid edges\n for (int i = 0; i < N; i++) {\n if (vertices[i].parent != -1) {\n int u = i;\n int v = vertices[i].parent;\n if (edge_set.find({min(u, v), max(u, v)}) == edge_set.end()) {\n // Invalid edge found - make this vertex a root\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n }\n }\n }\n \n // Output parent array\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << vertices[i].parent;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// N is fixed at 20 for all test cases.\nconst int N = 20;\n\n// Helper function to get the reverse direction for a move.\nchar get_reverse_dir(char dir) {\n if (dir == 'L') return 'R';\n if (dir == 'R') return 'L';\n if (dir == 'U') return 'D';\n if (dir == 'D') return 'U';\n return '?'; // Should not happen with valid input\n}\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n int N_input;\n cin >> N_input;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector> operations;\n long long total_moves = 0;\n\n // Iterate over each square to find Oni ('x').\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n // Found an Oni at (i, j). Find the cheapest way to remove it.\n // The problem guarantee ensures at least one of the four paths is clear.\n char best_dir = '?';\n int min_cost = N * 2 + 1; // Initialize with a value larger than any possible cost (max is 40).\n\n // Check upward path (U, j)\n bool up_clear = true;\n for (int k = 0; k < i; ++k) {\n if (board[k][j] == 'o') {\n up_clear = false;\n break;\n }\n }\n if (up_clear) {\n // Number of shifts is i+1, total moves is 2*(i+1)\n int cost = 2 * (i + 1);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'U';\n }\n }\n\n // Check downward path (D, j)\n bool down_clear = true;\n for (int k = i + 1; k < N; ++k) {\n if (board[k][j] == 'o') {\n down_clear = false;\n break;\n }\n }\n if (down_clear) {\n // Number of shifts is N-i, total moves is 2*(N-i)\n int cost = 2 * (N - i);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'D';\n }\n }\n\n // Check leftward path (L, i)\n bool left_clear = true;\n for (int k = 0; k < j; ++k) {\n if (board[i][k] == 'o') {\n left_clear = false;\n break;\n }\n }\n if (left_clear) {\n // Number of shifts is j+1, total moves is 2*(j+1)\n int cost = 2 * (j + 1);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'L';\n }\n }\n\n // Check rightward path (R, i)\n bool right_clear = true;\n for (int k = j + 1; k < N; ++k) {\n if (board[i][k] == 'o') {\n right_clear = false;\n break;\n }\n }\n if (right_clear) {\n // Number of shifts is N-j, total moves is 2*(N-j)\n int cost = 2 * (N - j);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'R';\n }\n }\n\n // Add the sequence of moves for the cheapest path to the operations list.\n int num_shifts = min_cost / 2;\n int line_idx = (best_dir == 'L' || best_dir == 'R') ? i : j;\n\n for (int k = 0; k < num_shifts; ++k) {\n operations.push_back({best_dir, line_idx});\n }\n for (int k = 0; k < num_shifts; ++k) {\n operations.push_back({get_reverse_dir(best_dir), line_idx});\n }\n total_moves += min_cost;\n }\n }\n }\n\n // The problem guarantee ensures total_moves will be <= 4N^2.\n // Max oni is 2N=40. Max cost per oni is 2*N=40. Max total cost is 40*40=1600=4N^2.\n // This strategy is guaranteed to be valid and within the move limit.\n\n // Output the sequence of operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 100;\n long long L = 500000;\n vector T(N);\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector> sorted_T;\n for (int i = 0; i < N; ++i) {\n sorted_T.emplace_back(T[i], i);\n }\n sort(sorted_T.rbegin(), sorted_T.rend());\n\n const int K = 5; // Number of top employees to consider\n vector a(N), b(N);\n\n // Top K employees transition among themselves in a balanced way\n for (int i = 0; i < K; ++i) {\n int emp = sorted_T[i].second;\n a[emp] = sorted_T[(i + 1) % K].second;\n b[emp] = sorted_T[(i + 2) % K].second;\n }\n\n // Other employees transition to top employees based on their target proportions\n for (int i = K; i < N; ++i) {\n int emp = sorted_T[i].second;\n long long remaining_target = T[emp];\n int chosen_top = 0;\n long long max_ratio = 0;\n for (int j = 0; j < K; ++j) {\n int top_emp = sorted_T[j].second;\n long long ratio = T[top_emp] / (j + 1); // Heuristic ratio\n if (ratio > max_ratio) {\n max_ratio = ratio;\n chosen_top = top_emp;\n }\n }\n a[emp] = chosen_top;\n b[emp] = sorted_T[i % K].second; // Alternate transition\n }\n\n for (int i = 0; i < N; ++i) {\n cout << a[i] << \" \" << b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct City {\n int idx;\n double x, y;\n int lx, rx, ly, ry;\n};\n\nstruct Edge {\n int u, v;\n double weight;\n bool operator<(const Edge& other) const {\n return weight < other.weight;\n }\n};\n\nvector> dist; // Actual distances\nvector> query_count; // How many times each edge was queried\n\ndouble euclidean_dist(const City& a, const City& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\nvector> query_mst(const vector& cities) {\n cout << \"? \" << cities.size();\n for (int c : cities) cout << \" \" << c;\n cout << endl;\n cout.flush();\n \n vector> edges;\n for (int i = 0; i < (int)cities.size() - 1; i++) {\n int u, v;\n cin >> u >> v;\n edges.emplace_back(u, v);\n }\n return edges;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector cities(N);\n for (int i = 0; i < N; i++) {\n cities[i].idx = i;\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].x = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].y = (cities[i].ly + cities[i].ry) / 2.0;\n }\n \n dist.assign(N, vector(N, 1e9));\n query_count.assign(N, vector(N, 0));\n \n // Initialize with centroid distances\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n dist[i][j] = dist[j][i] = euclidean_dist(cities[i], cities[j]);\n }\n }\n \n // Strategy 1: Query nearby cities to get accurate distances\n int queries_used = 0;\n \n // Build spatial index for finding nearby cities\n vector> grid(101, vector(101));\n for (int i = 0; i < N; i++) {\n int gx = min(100, (int)(cities[i].x / 100));\n int gy = min(100, (int)(cities[i].y / 100));\n grid[gx][gy].push_back(i);\n }\n \n // Query local neighborhoods\n for (int gx = 0; gx <= 100 && queries_used < Q/2; gx++) {\n for (int gy = 0; gy <= 100 && queries_used < Q/2; gy++) {\n if (grid[gx][gy].empty()) continue;\n \n vector nearby;\n // Collect cities from this and adjacent cells\n for (int dx = -1; dx <= 1; dx++) {\n for (int dy = -1; dy <= 1; dy++) {\n int nx = gx + dx, ny = gy + dy;\n if (0 <= nx && nx <= 100 && 0 <= ny && ny <= 100) {\n for (int c : grid[nx][ny]) {\n nearby.push_back(c);\n }\n }\n }\n }\n \n // Sort by distance to grid center and query closest\n sort(nearby.begin(), nearby.end(), [&](int a, int b) {\n double da = euclidean_dist(cities[a], {0, gx*100.0, gy*100.0, 0,0,0,0});\n double db = euclidean_dist(cities[b], {0, gx*100.0, gy*100.0, 0,0,0,0});\n return da < db;\n });\n \n // Query in batches of size L\n for (int i = 0; i < (int)nearby.size() && queries_used < Q/2; i += L-1) {\n vector batch;\n for (int j = i; j < min((int)nearby.size(), i + L); j++) {\n batch.push_back(nearby[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n // Update distances based on MST\n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n }\n }\n \n // Strategy 2: Query groups of cities that will likely be in the same final group\n // Sort cities by estimated position for initial grouping\n vector city_order(N);\n iota(city_order.begin(), city_order.end(), 0);\n sort(city_order.begin(), city_order.end(), [&](int a, int b) {\n return cities[a].x < cities[b].x || \n (abs(cities[a].x - cities[b].x) < 1e-6 && cities[a].y < cities[b].y);\n });\n \n // Create initial groups based on sorted order\n vector> initial_groups(M);\n int idx = 0;\n for (int g = 0; g < M; g++) {\n for (int i = 0; i < G[g]; i++) {\n initial_groups[g].push_back(city_order[idx++]);\n }\n }\n \n // Query within each initial group to refine distances\n for (int g = 0; g < M && queries_used < Q; g++) {\n if (initial_groups[g].size() <= 1) continue;\n \n // Query subsets within the group\n for (int i = 0; i < (int)initial_groups[g].size() && queries_used < Q; i += L-1) {\n vector subset;\n for (int j = i; j < min((int)initial_groups[g].size(), i + L); j++) {\n subset.push_back(initial_groups[g][j]);\n }\n if (subset.size() >= 2) {\n auto mst_edges = query_mst(subset);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n }\n \n // Final group assignment using improved distances\n // Use a greedy approach to build connected groups\n vector assigned(N, false);\n vector> final_groups(M);\n vector>> final_edges(M);\n \n // Sort groups by size (largest first for better connectivity)\n vector> group_sizes;\n for (int i = 0; i < M; i++) group_sizes.emplace_back(G[i], i);\n sort(group_sizes.rbegin(), group_sizes.rend());\n \n for (auto [size, group_id] : group_sizes) {\n if (size == 0) continue;\n \n // Find best unassigned city as seed\n int seed = -1;\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n seed = i;\n break;\n }\n }\n \n if (seed == -1) break;\n \n final_groups[group_id].push_back(seed);\n assigned[seed] = true;\n \n // Grow group by adding closest unassigned cities\n while ((int)final_groups[group_id].size() < size) {\n int best_city = -1;\n double best_dist = 1e9;\n int best_from = -1;\n \n for (int c : final_groups[group_id]) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n if (dist[c][i] < best_dist) {\n best_dist = dist[c][i];\n best_city = i;\n best_from = c;\n }\n }\n }\n }\n \n if (best_city != -1) {\n final_groups[group_id].push_back(best_city);\n final_edges[group_id].emplace_back(best_from, best_city);\n assigned[best_city] = true;\n } else {\n break;\n }\n }\n }\n \n // Build MST within each group for final edges\n for (int g = 0; g < M; g++) {\n if (final_groups[g].empty()) continue;\n \n // Kruskal's algorithm for MST within group\n vector edges;\n for (int i = 0; i < (int)final_groups[g].size(); i++) {\n for (int j = i + 1; j < (int)final_groups[g].size(); j++) {\n int u = final_groups[g][i];\n int v = final_groups[g][j];\n edges.push_back({u, v, dist[u][v]});\n }\n }\n sort(edges.begin(), edges.end());\n \n dsu dsu(N);\n vector> mst_edges;\n for (auto e : edges) {\n if (!dsu.same(e.u, e.v)) {\n dsu.merge(e.u, e.v);\n mst_edges.emplace_back(e.u, e.v);\n if ((int)mst_edges.size() == (int)final_groups[g].size() - 1) break;\n }\n }\n final_edges[g] = mst_edges;\n }\n \n // Output answer\n cout << \"!\" << endl;\n for (int g = 0; g < M; g++) {\n if (final_groups[g].empty()) {\n // Fallback: use initial group\n for (int c : initial_groups[g]) cout << c << \" \";\n cout << endl;\n for (int i = 0; i < (int)initial_groups[g].size() - 1; i++) {\n cout << initial_groups[g][i] << \" \" << initial_groups[g][i+1] << endl;\n }\n } else {\n for (int c : final_groups[g]) cout << c << \" \";\n cout << endl;\n for (auto [u, v] : final_edges[g]) {\n cout << u << \" \" << v << endl;\n }\n }\n }\n \n return 0;\n}","ahc046":"#include \nusing namespace std;\n\n// N and M are fixed by the problem statement, so we can use the literals directly.\n// N = 20, M = 40\n\nstruct Pos {\n int r, c;\n int id() const { return r * 20 + c; } // N is 20\n static Pos from_id(int id) { return {id / 20, id % 20}; } // N is 20\n};\n\n// BFS that returns a shortest sequence of actions from src to dst\nvector> bfs_path(Pos src, Pos dst) {\n const int SZ = 20 * 20; // N*N\n vector dist(SZ, -1);\n vector parent(SZ, -1);\n vector act(SZ), dir(SZ); // action and direction that lead to this vertex\n\n queue q;\n int s_id = src.id();\n dist[s_id] = 0;\n q.push(s_id);\n\n while (!q.empty()) {\n int cur_id = q.front(); q.pop();\n Pos cur = Pos::from_id(cur_id);\n if (cur_id == dst.id()) break;\n\n // ----- Move -----\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char mdir[4] = {'U', 'D', 'L', 'R'};\n for (int k = 0; k < 4; ++k) {\n int nr = cur.r + dr[k];\n int nc = cur.c + dc[k];\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) continue; // N is 20\n int nid = nr * 20 + nc; // N is 20\n if (dist[nid] != -1) continue;\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'M';\n dir[nid] = mdir[k];\n q.push(nid);\n }\n\n // ----- Slide -----\n // slide up\n if (cur.r > 0) {\n int nid = 0 * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'U';\n q.push(nid);\n }\n }\n // slide down\n if (cur.r < 20-1) { // N is 20\n int nid = (20-1) * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'D';\n q.push(nid);\n }\n }\n // slide left\n if (cur.c > 0) {\n int nid = cur.r * 20 + 0; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'L';\n q.push(nid);\n }\n }\n // slide right\n if (cur.c < 20-1) { // N is 20\n int nid = cur.r * 20 + (20-1); // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'R';\n q.push(nid);\n }\n }\n }\n\n // reconstruct path\n vector> path;\n int cur_id = dst.id();\n while (cur_id != s_id) {\n path.emplace_back(act[cur_id], dir[cur_id]);\n cur_id = parent[cur_id];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // N and M are fixed (20, 40). Read them into dummy variables to consume the first line.\n int n_read, m_read;\n if (!(cin >> n_read >> m_read)) {\n return 0;\n }\n \n // M is 40\n const int M = 40;\n vector pts(M);\n for (int i = 0; i < M; ++i) {\n cin >> pts[i].r >> pts[i].c;\n }\n\n vector> answer;\n Pos cur = pts[0];\n for (int i = 1; i < M; ++i) {\n Pos nxt = pts[i];\n auto seg = bfs_path(cur, nxt);\n answer.insert(answer.end(), seg.begin(), seg.end());\n cur = nxt;\n }\n\n // safety check (should always hold)\n // Limit is 2 * N * M = 2 * 20 * 40 = 1600\n if ((int)answer.size() > 2 * 20 * 40) {\n answer.resize(2 * 20 * 40);\n }\n\n for (auto [a, d] : answer) {\n cout << a << ' ' << d << '\\n';\n }\n return 0;\n}"},"4":{"ahc001":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Company {\n int id, x, y, r;\n int a, b, c, d;\n};\n\n// Simple greedy placement on a grid\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n vector companies(n);\n for (int i = 0; i < n; i++) {\n companies[i].id = i;\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n }\n \n // Sort by desired area (descending)\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.r > b.r;\n });\n \n // Grid to mark occupied cells\n vector> occupied(10000, vector(10000, false));\n \n for (auto& comp : companies) {\n int x = comp.x, y = comp.y, r = comp.r;\n \n // Try to find a rectangle containing the point\n bool found = false;\n \n // First try: if the point is not occupied, give it 1x1\n if (!occupied[y][x]) {\n comp.a = x;\n comp.b = y;\n comp.c = x + 1;\n comp.d = y + 1;\n occupied[y][x] = true;\n found = true;\n }\n \n if (!found) {\n // Try expanding around the point\n int max_size = min(100, (int)sqrt(r) + 10);\n \n for (int size = 1; size <= max_size && !found; size++) {\n // Try different rectangle shapes\n vector> shapes = {{size, size}, {size*2, size/2}, {size/2, size*2}};\n \n for (auto [w, h] : shapes) {\n if (w <= 0 || h <= 0) continue;\n \n // Try placing rectangle to include (x, y)\n for (int a = max(0, x - w + 1); a <= min(x, 10000 - w) && !found; a++) {\n for (int b = max(0, y - h + 1); b <= min(y, 10000 - h) && !found; b++) {\n int c = a + w;\n int d = b + h;\n \n // Check if rectangle is free and contains the point\n bool free = true;\n for (int yy = b; yy < d && free; yy++) {\n for (int xx = a; xx < c && free; xx++) {\n if (occupied[yy][xx]) {\n free = false;\n }\n }\n }\n \n if (free && a <= x && x < c && b <= y && y < d) {\n comp.a = a;\n comp.b = b;\n comp.c = c;\n comp.d = d;\n \n // Mark as occupied\n for (int yy = b; yy < d; yy++) {\n for (int xx = a; xx < c; xx++) {\n occupied[yy][xx] = true;\n }\n }\n found = true;\n }\n }\n }\n }\n }\n }\n \n if (!found) {\n // Last resort: find any free cell\n for (int yy = 0; yy < 10000 && !found; yy++) {\n for (int xx = 0; xx < 10000 && !found; xx++) {\n if (!occupied[yy][xx]) {\n comp.a = xx;\n comp.b = yy;\n comp.c = xx + 1;\n comp.d = yy + 1;\n occupied[yy][xx] = true;\n found = true;\n }\n }\n }\n }\n \n // Ensure we always have a valid rectangle (shouldn't reach here)\n if (!found) {\n comp.a = 0;\n comp.b = 0;\n comp.c = 1;\n comp.d = 1;\n }\n }\n \n // Sort by original ID for output\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.id < b.id;\n });\n \n // Output results\n for (const auto& comp : companies) {\n cout << comp.a << \" \" << comp.b << \" \" << comp.c << \" \" << comp.d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Tile {\n vector> squares;\n bool visited;\n int total_value;\n int center_i, center_j;\n};\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> t(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> t[i][j];\n }\n }\n \n vector> p(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> p[i][j];\n }\n }\n \n // Build tile structure\n unordered_map tiles;\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n int tile_id = t[i][j];\n tiles[tile_id].squares.push_back({i, j});\n tiles[tile_id].total_value += p[i][j];\n }\n }\n \n // Calculate tile centers\n for (auto& [id, tile] : tiles) {\n int sum_i = 0, sum_j = 0;\n for (auto [i, j] : tile.squares) {\n sum_i += i;\n sum_j += j;\n }\n tile.center_i = sum_i / tile.squares.size();\n tile.center_j = sum_j / tile.squares.size();\n }\n \n // Track visited squares (not just tiles)\n vector> visited_square(50, vector(50, false));\n visited_square[si][sj] = true;\n \n // Mark initial tile as visited\n int initial_tile_id = t[si][sj];\n tiles[initial_tile_id].visited = true;\n \n string path;\n int current_i = si, current_j = sj;\n int total_score = 0;\n \n // Add all squares in initial tile to score\n for (auto [i, j] : tiles[initial_tile_id].squares) {\n total_score += p[i][j];\n visited_square[i][j] = true;\n }\n \n // Directions\n vector di = {-1, 1, 0, 0};\n vector dj = {0, 0, -1, 1};\n vector dirs = {'U', 'D', 'L', 'R'};\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Greedy traversal with careful validation\n while (true) {\n vector> candidates;\n \n // Find all valid moves to unvisited tiles\n for (int d = 0; d < 4; d++) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited_square[ni][nj]) continue;\n \n int tile_id = t[ni][nj];\n if (tiles[tile_id].visited) continue;\n \n // Calculate score with randomness\n int score = tiles[tile_id].total_value;\n score += rng() % 20;\n \n candidates.push_back({score, ni, nj, dirs[d]});\n }\n \n if (candidates.empty()) break;\n \n // Sort candidates by score\n sort(candidates.rbegin(), candidates.rend());\n \n // Try candidates in order\n bool moved = false;\n for (auto [score, ni, nj, dir] : candidates) {\n int next_tile_id = t[ni][nj];\n \n // Try to find a path to explore this tile\n // First, move to the adjacent square\n if (!visited_square[ni][nj]) {\n path += dir;\n current_i = ni;\n current_j = nj;\n visited_square[ni][nj] = true;\n total_score += p[ni][nj];\n \n // Mark entire tile as visited\n tiles[next_tile_id].visited = true;\n for (auto [ti, tj] : tiles[next_tile_id].squares) {\n visited_square[ti][tj] = true;\n total_score += p[ti][tj];\n }\n \n moved = true;\n break;\n }\n }\n \n if (!moved) break;\n }\n \n cout << path << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\n// --- Constants ---\nconstexpr int N = 30;\nconstexpr double INF = 1e18;\nconstexpr double LEARNING_RATE = 0.2;\nconstexpr int MIN_EDGE = 1000;\nconstexpr int MAX_EDGE = 9000;\n\n// --- Global State ---\ndouble H[N][N - 1]; // horizontal edge (i,j) -> (i,j+1)\ndouble V[N - 1][N]; // vertical edge (i,j) -> (i+1,j)\n\n// --- Dijkstra's Algorithm ---\nstring find_path(int si, int sj, int ti, int tj, vector>& used_edges) {\n // dist and prev arrays\n double dist[N][N];\n int prev[N][N];\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n dist[i][j] = INF;\n prev[i][j] = -1;\n }\n }\n dist[si][sj] = 0.0;\n\n // Priority queue: (distance, (i, j))\n using Node = pair>;\n priority_queue, greater> pq;\n pq.emplace(0.0, make_pair(si, sj));\n\n // Directions: U, D, L, R\n constexpr int di[4] = {-1, 1, 0, 0};\n constexpr int dj[4] = {0, 0, -1, 1};\n constexpr char dir_char[4] = {'U', 'D', 'L', 'R'};\n\n while (!pq.empty()) {\n auto [d, coord] = pq.top();\n auto [i, j] = coord;\n pq.pop();\n\n if (d > dist[i][j] + 1e-9) continue;\n if (i == ti && j == tj) break;\n\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n\n double w = 0.0;\n if (dir == 0) w = V[i - 1][j]; // U\n else if (dir == 1) w = V[i][j]; // D\n else if (dir == 2) w = H[i][j - 1]; // L\n else w = H[i][j]; // R\n\n if (dist[i][j] + w < dist[ni][nj] - 1e-9) {\n dist[ni][nj] = dist[i][j] + w;\n prev[ni][nj] = dir;\n pq.emplace(dist[ni][nj], make_pair(ni, nj));\n }\n }\n }\n\n // Reconstruct path and identify used edges\n vector> vertex_path;\n int ci = ti, cj = tj;\n vertex_path.emplace_back(ci, cj);\n while (!(ci == si && cj == sj)) {\n int dir = prev[ci][cj];\n int pi = ci - di[dir];\n int pj = cj - dj[dir];\n vertex_path.emplace_back(pi, pj);\n ci = pi;\n cj = pj;\n }\n reverse(vertex_path.begin(), vertex_path.end());\n\n string path_str;\n used_edges.clear();\n for (size_t i = 0; i + 1 < vertex_path.size(); ++i) {\n int ci = vertex_path[i].first;\n int cj = vertex_path[i].second;\n int ni = vertex_path[i+1].first;\n int nj = vertex_path[i+1].second;\n\n if (ni == ci - 1) { // U\n path_str.push_back('U');\n used_edges.emplace_back(1, ci - 1, cj); // V edge\n } else if (ni == ci + 1) { // D\n path_str.push_back('D');\n used_edges.emplace_back(1, ci, cj); // V edge\n } else if (nj == cj - 1) { // L\n path_str.push_back('L');\n used_edges.emplace_back(0, ci, cj - 1); // H edge\n } else { // R\n path_str.push_back('R');\n used_edges.emplace_back(0, ci, cj); // H edge\n }\n }\n\n return path_str;\n}\n\n\n// --- Main ---\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Initialize edge weights with random values in the possible range\n mt19937 rng(123456);\n uniform_int_distribution init_dist(MIN_EDGE, MAX_EDGE);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N - 1; ++j) H[i][j] = init_dist(rng);\n }\n for (int i = 0; i < N - 1; ++i) {\n for (int j = 0; j < N; ++j) V[i][j] = init_dist(rng);\n }\n\n vector> used_edges;\n used_edges.reserve(60); // Max path length is 58\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) break;\n\n string path = find_path(si, sj, ti, tj, used_edges);\n\n cout << path << \"\\n\";\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n // Update edge weights\n if (used_edges.empty()) continue;\n\n double lest = 0.0;\n for (auto [type, i, j] : used_edges) {\n if (type == 0) { // Horizontal\n lest += H[i][j];\n } else { // Vertical\n lest += V[i][j];\n }\n }\n\n double delta = static_cast(observed) - lest;\n double step = LEARNING_RATE * delta / used_edges.size();\n\n for (auto [type, i, j] : used_edges) {\n if (type == 0) {\n H[i][j] += step;\n if (H[i][j] < MIN_EDGE) H[i][j] = MIN_EDGE;\n if (H[i][j] > MAX_EDGE) H[i][j] = MAX_EDGE;\n } else {\n V[i][j] += step;\n if (V[i][j] < MIN_EDGE) V[i][j] = MIN_EDGE;\n if (V[i][j] > MAX_EDGE) V[i][j] = MAX_EDGE;\n }\n }\n }\n\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace chrono;\n\nconst int N = 20;\nconst char EMPTY = '.';\n\nstruct StringInfo {\n string s;\n int length;\n int id;\n int priority;\n vector substrings;\n};\n\nstruct Position {\n int i, j, dir;\n int score;\n int conflicts;\n};\n\nclass EnhancedTorusReconstructor {\nprivate:\n vector strings;\n vector> matrix;\n mt19937 rng;\n array char_freq;\n int best_score;\n vector> best_matrix;\n vector> possible_positions;\n vector is_matched;\n int matched_count;\n \npublic:\n EnhancedTorusReconstructor(const vector& input_strings) : \n rng(steady_clock::now().time_since_epoch().count()) {\n strings.resize(input_strings.size());\n char_freq.fill(0);\n \n for (int i = 0; i < input_strings.size(); i++) {\n strings[i].s = input_strings[i];\n strings[i].length = input_strings[i].length();\n strings[i].id = i;\n strings[i].priority = 0;\n \n for (char c : input_strings[i]) {\n char_freq[c - 'A']++;\n strings[i].priority += char_freq[c - 'A'];\n }\n \n for (int len = 2; len <= min(4, strings[i].length); len++) {\n for (int start = 0; start <= strings[i].length - len; start++) {\n strings[i].substrings.push_back(strings[i].s.substr(start, len));\n }\n }\n }\n \n matrix.assign(N, vector(N, EMPTY));\n best_matrix = matrix;\n best_score = 0;\n is_matched.assign(strings.size(), false);\n matched_count = 0;\n \n preprocess_positions();\n }\n \n void preprocess_positions() {\n possible_positions.resize(strings.size());\n \n for (int idx = 0; idx < strings.size(); idx++) {\n const string& s = strings[idx].s;\n int k = s.length();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int h_conflicts = 0;\n int h_matches = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[i][(j + p) % N];\n if (current != EMPTY && current != s[p]) {\n h_conflicts++;\n break;\n }\n if (current == s[p]) h_matches++;\n }\n \n if (h_conflicts == 0) {\n possible_positions[idx].push_back({i, j, 0, h_matches, h_conflicts});\n }\n \n int v_conflicts = 0;\n int v_matches = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[(i + p) % N][j];\n if (current != EMPTY && current != s[p]) {\n v_conflicts++;\n break;\n }\n if (current == s[p]) v_matches++;\n }\n \n if (v_conflicts == 0) {\n possible_positions[idx].push_back({i, j, 1, v_matches, v_conflicts});\n }\n }\n }\n }\n }\n \n bool check_string_match(int idx) const {\n const string& s = strings[idx].s;\n int k = s.length();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool match = true;\n for (int p = 0; p < k; p++) {\n if (matrix[i][(j + p) % N] != s[p]) {\n match = false;\n break;\n }\n }\n if (match) return true;\n \n match = true;\n for (int p = 0; p < k; p++) {\n if (matrix[(i + p) % N][j] != s[p]) {\n match = false;\n break;\n }\n }\n if (match) return true;\n }\n }\n return false;\n }\n \n void update_matched_status() {\n matched_count = 0;\n for (int i = 0; i < strings.size(); i++) {\n is_matched[i] = check_string_match(i);\n if (is_matched[i]) matched_count++;\n }\n }\n \n void initialize_strategy_1() {\n matrix.assign(N, vector(N, EMPTY));\n \n array, 8> freq_chars;\n for (int i = 0; i < 8; i++) {\n freq_chars[i] = {char_freq[i], 'A' + i};\n }\n sort(freq_chars.begin(), freq_chars.end(), greater>());\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = freq_chars[rng() % min(4, 8)].second;\n }\n }\n }\n \n void initialize_strategy_2() {\n matrix.assign(N, vector(N, EMPTY));\n \n sort(strings.begin(), strings.end(), \n [](const StringInfo& a, const StringInfo& b) {\n if (a.length != b.length) return a.length > b.length;\n return a.priority > b.priority;\n });\n \n for (int idx = 0; idx < min(50, (int)strings.size()); idx++) {\n place_string_optimal(strings[idx].s);\n }\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == EMPTY) {\n matrix[i][j] = 'A' + (rng() % 8);\n }\n }\n }\n }\n \n void place_string_optimal(const string& s) {\n int k = s.length();\n Position best_pos = {-1, -1, -1, -1, k};\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int h_matches = 0;\n int h_conflicts = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[i][(j + p) % N];\n if (current == EMPTY) continue;\n if (current == s[p]) h_matches++;\n else h_conflicts++;\n }\n \n if (h_conflicts < best_pos.conflicts || \n (h_conflicts == best_pos.conflicts && h_matches > best_pos.score)) {\n best_pos = {i, j, 0, h_matches, h_conflicts};\n }\n \n int v_matches = 0;\n int v_conflicts = 0;\n for (int p = 0; p < k; p++) {\n char current = matrix[(i + p) % N][j];\n if (current == EMPTY) continue;\n if (current == s[p]) v_matches++;\n else v_conflicts++;\n }\n \n if (v_conflicts < best_pos.conflicts || \n (v_conflicts == best_pos.conflicts && v_matches > best_pos.score)) {\n best_pos = {i, j, 1, v_matches, v_conflicts};\n }\n }\n }\n \n if (best_pos.conflicts <= 2) {\n int k = s.length();\n if (best_pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n matrix[best_pos.i][(best_pos.j + p) % N] = s[p];\n }\n } else {\n for (int p = 0; p < k; p++) {\n matrix[(best_pos.i + p) % N][best_pos.j] = s[p];\n }\n }\n }\n }\n \n void focused_local_search() {\n vector unmatched_strings;\n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n unmatched_strings.push_back(i);\n }\n }\n \n sort(unmatched_strings.begin(), unmatched_strings.end(),\n [this](int a, int b) {\n return strings[a].length > strings[b].length;\n });\n \n for (int iter = 0; iter < min(30, (int)unmatched_strings.size()); iter++) {\n int idx = unmatched_strings[iter];\n place_string_optimal(strings[idx].s);\n \n bool now_matched = check_string_match(idx);\n if (now_matched && !is_matched[idx]) {\n is_matched[idx] = true;\n matched_count++;\n }\n }\n }\n \n void adaptive_random_search() {\n int iterations = matched_count < strings.size() / 2 ? 1500 : 800;\n \n for (int iter = 0; iter < iterations; iter++) {\n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n char new_char = 'A' + (rng() % 8);\n if (new_char == old_char) continue;\n \n matrix[i][j] = new_char;\n \n int changes = 0;\n for (int idx = 0; idx < min(50, (int)strings.size()); idx++) {\n bool was_matched = is_matched[idx];\n bool now_matched = check_string_match(idx);\n \n if (!was_matched && now_matched) changes++;\n if (was_matched && !now_matched) changes--;\n }\n \n if (changes > 0 || (changes == 0 && rng() % 3 == 0)) {\n if (changes > 0) {\n for (int idx = 0; idx < min(50, (int)strings.size()); idx++) {\n is_matched[idx] = check_string_match(idx);\n }\n }\n } else {\n matrix[i][j] = old_char;\n }\n }\n }\n \n void constraint_propagation() {\n for (int phase = 0; phase < 3; phase++) {\n vector> forced_placements;\n \n for (int idx = 0; idx < strings.size(); idx++) {\n if (is_matched[idx]) continue;\n \n vector valid_positions;\n for (const auto& pos : possible_positions[idx]) {\n bool valid = true;\n const string& s = strings[idx].s;\n int k = s.length();\n \n if (pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n if (matrix[pos.i][(pos.j + p) % N] != EMPTY && \n matrix[pos.i][(pos.j + p) % N] != s[p]) {\n valid = false;\n break;\n }\n }\n } else {\n for (int p = 0; p < k; p++) {\n if (matrix[(pos.i + p) % N][pos.j] != EMPTY && \n matrix[(pos.i + p) % N][pos.j] != s[p]) {\n valid = false;\n break;\n }\n }\n }\n \n if (valid) valid_positions.push_back(pos);\n }\n \n if (valid_positions.size() == 1) {\n forced_placements.push_back({idx, valid_positions[0]});\n }\n }\n \n for (const auto& [idx, pos] : forced_placements) {\n const string& s = strings[idx].s;\n int k = s.length();\n \n if (pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n matrix[pos.i][(pos.j + p) % N] = s[p];\n }\n } else {\n for (int p = 0; p < k; p++) {\n matrix[(pos.i + p) % N][pos.j] = s[p];\n }\n }\n }\n }\n }\n \n void reconstruct() {\n vector scores;\n \n for (int strategy = 0; strategy < 2; strategy++) {\n if (strategy == 0) {\n initialize_strategy_1();\n } else {\n initialize_strategy_2();\n }\n \n update_matched_status();\n \n for (int phase = 0; phase < 4; phase++) {\n constraint_propagation();\n focused_local_search();\n adaptive_random_search();\n }\n \n int current_score = matched_count;\n scores.push_back(current_score);\n \n if (current_score > best_score) {\n best_score = current_score;\n best_matrix = matrix;\n }\n }\n \n matrix = best_matrix;\n }\n \n vector> get_matrix() const {\n return matrix;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N_input, M;\n cin >> N_input >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n EnhancedTorusReconstructor reconstructor(strings);\n reconstructor.reconstruct();\n \n auto matrix = reconstructor.get_matrix();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << matrix[i][j];\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n vector> covered;\n string path;\n int total_time;\n int uncovered_count;\n \n State(int n) : covered(n, vector(n, false)), total_time(0), uncovered_count(0) {}\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 \n vector grid(N);\n vector> cost(N, vector(N));\n int road_count = 0;\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n road_count++;\n }\n }\n }\n \n // Precompute visibility for each road square\n vector>> visible(N, vector>(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == '#') continue;\n \n // Check visibility in 4 directions\n // Up\n for (int ni = i-1; ni >= 0 && grid[ni][j] != '#'; ni--) {\n visible[i][j].insert(ni * N + j);\n }\n // Down\n for (int ni = i+1; ni < N && grid[ni][j] != '#'; ni++) {\n visible[i][j].insert(ni * N + j);\n }\n // Left\n for (int nj = j-1; nj >= 0 && grid[i][nj] != '#'; nj--) {\n visible[i][j].insert(i * N + nj);\n }\n // Right\n for (int nj = j+1; nj < N && grid[i][nj] != '#'; nj++) {\n visible[i][j].insert(i * N + nj);\n }\n // Self\n visible[i][j].insert(i * N + j);\n }\n }\n \n // Find all road positions\n vector> road_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n road_positions.emplace_back(i, j);\n }\n }\n }\n \n // Greedy selection of key positions\n vector> selected(N, vector(N, false));\n vector> covered(N, vector(N, false));\n int covered_count = 0;\n \n // Start with initial position\n selected[si][sj] = true;\n for (int idx : visible[si][sj]) {\n int i = idx / N, j = idx % N;\n if (!covered[i][j]) {\n covered[i][j] = true;\n covered_count++;\n }\n }\n \n // Greedy selection until all are covered\n while (covered_count < road_count) {\n int best_i = -1, best_j = -1;\n int best_gain = -1;\n int best_cost = INT_MAX;\n \n for (auto [i, j] : road_positions) {\n if (selected[i][j]) continue;\n \n int gain = 0;\n for (int idx : visible[i][j]) {\n int ni = idx / N, nj = idx % N;\n if (!covered[ni][nj]) gain++;\n }\n \n if (gain > 0) {\n // Estimate cost to reach this position from nearest selected\n int min_dist = INT_MAX;\n for (auto [si, sj] : road_positions) {\n if (selected[si][sj]) {\n int dist = abs(i - si) + abs(j - sj);\n min_dist = min(min_dist, dist);\n }\n }\n \n if (gain * 1000 - min_dist > best_gain * 1000 - best_cost) {\n best_gain = gain;\n best_cost = min_dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n \n if (best_i == -1) break;\n \n selected[best_i][best_j] = true;\n for (int idx : visible[best_i][best_j]) {\n int ni = idx / N, nj = idx % N;\n if (!covered[ni][nj]) {\n covered[ni][nj] = true;\n covered_count++;\n }\n }\n }\n \n // Collect selected positions\n vector> key_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (selected[i][j]) {\n key_positions.emplace_back(i, j);\n }\n }\n }\n \n // Build route using nearest neighbor\n string path;\n int current_i = si, current_j = sj;\n vector> visited(N, vector(N, false));\n visited[si][sj] = true;\n \n while (true) {\n // Find nearest unvisited key position\n int best_dist = INT_MAX;\n int best_idx = -1;\n \n for (int k = 0; k < (int)key_positions.size(); k++) {\n auto [ni, nj] = key_positions[k];\n if (visited[ni][nj]) continue;\n \n int dist = abs(ni - current_i) + abs(nj - current_j);\n if (dist < best_dist) {\n best_dist = dist;\n best_idx = k;\n }\n }\n \n if (best_idx == -1) break;\n \n auto [target_i, target_j] = key_positions[best_idx];\n \n // Move to target\n while (current_i != target_i) {\n if (current_i < target_i) {\n path += 'D';\n current_i++;\n } else {\n path += 'U';\n current_i--;\n }\n }\n \n while (current_j != target_j) {\n if (current_j < target_j) {\n path += 'R';\n current_j++;\n } else {\n path += 'L';\n current_j--;\n }\n }\n \n visited[target_i][target_j] = true;\n }\n \n // Return to start\n while (current_i != si) {\n if (current_i < si) {\n path += 'D';\n current_i++;\n } else {\n path += 'U';\n current_i--;\n }\n }\n \n while (current_j != sj) {\n if (current_j < sj) {\n path += 'R';\n current_j++;\n } else {\n path += 'L';\n current_j--;\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Variables ---\nint N, M, K, R;\nvector> d; // Task requirements\nvector> pred; // Predecessor lists\nvector> succ; // Successor lists\nvector num_preds; // Number of predecessors for each task\nvector L; // Longest path length from each task\nvector max_d; // Max requirement for each skill\n\n// --- State ---\nint current_day;\nvector task_status; // 0: todo, 1: doing, 2: done\nvector completed_preds_count;\nvector member_busy;\nvector member_task; // task assigned to member\nvector member_start_day;\nvector> s_est; // Estimated skills for each member\nvector num_tasks_done;\n\n// --- Helper function for topological sort ---\nvector topological_sort(const vector>& graph) {\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int v : graph[i]) {\n in_degree[v]++;\n }\n }\n queue q;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n q.push(i);\n }\n }\n vector order;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n order.push_back(u);\n for (int v : graph[u]) {\n if (--in_degree[v] == 0) {\n q.push(v);\n }\n }\n }\n return order;\n}\n\n// --- Main function ---\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // --- Input Reading ---\n cin >> N >> M >> K >> R;\n d.resize(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n cin >> d[i][j];\n }\n }\n\n pred.resize(N);\n succ.resize(N);\n num_preds.resize(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--; // 0-based\n pred[v].push_back(u);\n succ[u].push_back(v);\n num_preds[v]++;\n }\n\n // --- Preprocessing ---\n // Calculate max_d\n max_d.assign(K, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n max_d[k] = max(max_d[k], d[i][k]);\n }\n }\n\n // Calculate L (longest path length)\n vector topo_order = topological_sort(pred); // Sort by preds\n L.assign(N, 1);\n for (auto it = topo_order.rbegin(); it != topo_order.rend(); ++it) {\n int u = *it;\n for (int v : succ[u]) {\n L[u] = max(L[u], 1 + L[v]);\n }\n }\n\n // --- State Initialization ---\n current_day = 1;\n task_status.assign(N, 0);\n completed_preds_count.assign(N, 0);\n member_busy.assign(M, false);\n member_task.assign(M, -1);\n member_start_day.assign(M, -1);\n s_est.assign(M, vector(K, 0.0));\n num_tasks_done.assign(M, 0);\n\n // --- Main Loop ---\n while (true) {\n // --- Step 1: Update State and Learn ---\n string line;\n getline(cin, line); // consume the rest of the previous line, if any\n getline(cin, line);\n istringstream iss(line);\n int n;\n iss >> n;\n if (n == -1) {\n break;\n }\n\n for (int i = 0; i < n; ++i) {\n int f_j;\n iss >> f_j;\n int j = f_j - 1; // 0-based index\n\n int t_id = member_task[j];\n int start_day = member_start_day[j];\n int t_obs = (current_day - 1) - start_day + 1;\n\n task_status[t_id] = 2; // Mark as done\n member_busy[j] = false;\n member_task[j] = -1;\n\n for (int succ_task : succ[t_id]) {\n completed_preds_count[succ_task]++;\n }\n\n // Skill Update\n num_tasks_done[j]++;\n double lr = (t_obs > 1) ? 1.0 / sqrt(num_tasks_done[j]) : 0.1 / sqrt(num_tasks_done[j]);\n for (int k = 0; k < K; ++k) {\n if (d[t_id][k] > s_est[j][k]) {\n s_est[j][k] += lr;\n s_est[j][k] = min(s_est[j][k], (double)d[t_id][k]);\n s_est[j][k] = min(s_est[j][k], (double)max_d[k]);\n }\n }\n }\n \n // --- Step 2: Find Available Resources ---\n vector ready_tasks;\n for (int i = 0; i < N; ++i) {\n if (task_status[i] == 0 && completed_preds_count[i] == num_preds[i]) {\n ready_tasks.push_back(i);\n }\n }\n\n vector free_members;\n for (int j = 0; j < M; ++j) {\n if (!member_busy[j]) {\n free_members.push_back(j);\n }\n }\n\n // --- Step 3: Greedy Assignment ---\n vector> assignments;\n if (!ready_tasks.empty() && !free_members.empty()) {\n vector> pairs; // cost, -L[i], est_time, task_id, member_id\n for (int i : ready_tasks) {\n for (int j : free_members) {\n double w_est = 0.0;\n for (int k = 0; k < K; ++k) {\n w_est += max(0, d[i][k] - s_est[j][k]);\n }\n int est_time = max(1.0, w_est);\n double cost = (double)est_time / L[i];\n pairs.emplace_back(cost, -L[i], est_time, i, j);\n }\n }\n sort(pairs.begin(), pairs.end());\n\n vector task_used(N, false);\n vector member_used(M, false);\n for (const auto& p : pairs) {\n int i = get<3>(p);\n int j = get<4>(p);\n if (!task_used[i] && !member_used[j]) {\n assignments.emplace_back(j + 1, i + 1); // 1-based for output\n task_status[i] = 1; // Mark as in progress\n member_busy[j] = true;\n member_task[j] = i;\n member_start_day[j] = current_day;\n task_used[i] = true;\n member_used[j] = true;\n }\n }\n }\n\n // --- Step 4: Output and Flush ---\n cout << assignments.size();\n for (const auto& a : assignments) {\n cout << \" \" << a.first << \" \" << a.second;\n }\n cout << endl;\n cout.flush();\n\n // --- Step 5: Increment Day ---\n current_day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int id, a, b, c, d;\n int total_dist;\n};\n\nint manhattan_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Select 50 orders closest to center with some randomness\nvector select_orders(const vector& orders) {\n vector> order_scores;\n for (int i = 0; i < 1000; i++) {\n int score = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n order_scores.push_back({score, i});\n }\n \n sort(order_scores.begin(), order_scores.end());\n \n vector selected(1000, false);\n random_device rd;\n mt19937 gen(rd());\n \n // Select from closest 200 orders\n int search_range = min(200, 1000);\n uniform_int_distribution dist(0, search_range - 1);\n \n unordered_set selected_set;\n while (selected_set.size() < 50) {\n int idx = dist(gen);\n int order_id = order_scores[idx].second;\n if (selected_set.find(order_id) == selected_set.end()) {\n selected_set.insert(order_id);\n selected[order_id] = true;\n }\n }\n \n return selected;\n}\n\n// Build route ensuring all pickups and deliveries are visited\nvector> build_complete_route(const vector& orders, const vector& selected) {\n vector> route;\n route.push_back({400, 400});\n \n // Collect all selected orders\n vector selected_orders;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_orders.push_back(i);\n }\n }\n \n // Visit all pickups first using greedy nearest neighbor\n int current_x = 400, current_y = 400;\n vector pickup_visited(1000, false);\n \n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (!pickup_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].a, orders[order_id].b);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].a, orders[best_order].b});\n current_x = orders[best_order].a;\n current_y = orders[best_order].b;\n pickup_visited[best_order] = true;\n }\n }\n \n // Visit all deliveries using greedy nearest neighbor\n vector delivery_visited(1000, false);\n \n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (pickup_visited[order_id] && !delivery_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].c, orders[order_id].d);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].c, orders[best_order].d});\n current_x = orders[best_order].c;\n current_y = orders[best_order].d;\n delivery_visited[best_order] = true;\n }\n }\n \n route.push_back({400, 400});\n return route;\n}\n\n// Simple 2-opt improvement that maintains pickup before delivery constraint\nvector> improve_route(const vector>& route, const vector& orders, const vector& selected) {\n if (route.size() < 4) return route;\n \n // Create map from point to order\n unordered_map point_to_order;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n string pickup_key = to_string(orders[i].a) + \",\" + to_string(orders[i].b);\n string delivery_key = to_string(orders[i].c) + \",\" + to_string(orders[i].d);\n point_to_order[pickup_key] = i;\n point_to_order[delivery_key] = i;\n }\n }\n \n vector> best = route;\n int best_len = 0;\n for (size_t i = 0; i < best.size() - 1; i++) {\n best_len += manhattan_dist(best[i].first, best[i].second, best[i+1].first, best[i+1].second);\n }\n \n // Limited 2-opt iterations\n for (int iter = 0; iter < 5; iter++) {\n bool improved = false;\n \n for (size_t i = 1; i < route.size() - 2 && !improved; i++) {\n for (size_t j = i + 1; j < route.size() - 1; j++) {\n // Check if reversing segment maintains pickup before delivery\n bool valid = true;\n unordered_set pickups_in_segment, deliveries_in_segment;\n \n // Identify pickups and deliveries in the segment\n for (size_t k = i; k <= j; k++) {\n string key = to_string(route[k].first) + \",\" + to_string(route[k].second);\n if (point_to_order.count(key)) {\n int order_id = point_to_order[key];\n if (route[k].first == orders[order_id].a && route[k].second == orders[order_id].b) {\n pickups_in_segment.insert(order_id);\n } else {\n deliveries_in_segment.insert(order_id);\n }\n }\n }\n \n // Check if any delivery appears before its pickup in the reversed segment\n for (int delivery_order : deliveries_in_segment) {\n if (pickups_in_segment.count(delivery_order)) {\n valid = false;\n break;\n }\n }\n \n if (valid) {\n vector> new_route = route;\n reverse(new_route.begin() + i, new_route.begin() + j + 1);\n \n int new_len = 0;\n for (size_t k = 0; k < new_route.size() - 1; k++) {\n new_len += manhattan_dist(new_route[k].first, new_route[k].second, \n new_route[k+1].first, new_route[k+1].second);\n }\n \n if (new_len < best_len) {\n best = new_route;\n best_len = new_len;\n improved = true;\n break;\n }\n }\n }\n }\n \n if (!improved) break;\n }\n \n return best;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i;\n orders[i].total_dist = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n }\n \n // Select orders\n vector selected = select_orders(orders);\n \n // Build complete route\n vector> route = build_complete_route(orders, selected);\n \n // Improve route\n route = improve_route(route, orders, selected);\n \n // Verify route has exactly 102 points (start + 50 pickups + 50 deliveries + end)\n assert(route.size() == 102);\n \n // Output\n vector selected_ids;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_ids.push_back(i + 1);\n }\n }\n \n cout << 50;\n for (int id : selected_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n \n cout << route.size();\n for (const auto& p : route) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Global constants as per problem statement\nconst int N = 400;\nconst int M = 1995;\n\n// Main solver class/structure\nstruct OnlineMST {\n int n, m;\n vector> points;\n vector> edges;\n vector> dist_mat;\n vector> min_dist;\n dsu d;\n set active_roots;\n int num_components;\n\n // Tunable parameters\n const double k_base = 2.5;\n const int desperation_threshold = 5;\n\n OnlineMST() : n(N), m(M), d(N) {\n points.resize(n);\n edges.resize(m);\n dist_mat.assign(n, vector(n, 0));\n min_dist.assign(n, vector(n, 0));\n num_components = n;\n for (int i = 0; i < n; ++i) {\n active_roots.insert(i);\n }\n }\n\n // Helper function to calculate rounded distance\n int calc_dist(int i, int j) {\n long long dx = points[i].first - points[j].first;\n long long dy = points[i].second - points[j].second;\n return (int)round(sqrt(dx * dx + dy * dy));\n }\n\n void preprocess() {\n // Calculate all-pairs distances\n for (int i = 0; i < n; ++i) {\n for (int j = i + 1; j < n; ++j) {\n dist_mat[i][j] = calc_dist(i, j);\n dist_mat[j][i] = dist_mat[i][j];\n }\n }\n // Initialize min_dist with dist_mat\n min_dist = dist_mat;\n }\n\n void update_min_dist(int new_root, int old_root_u, int old_root_v) {\n // min_dist for the new component is the min of the two old components\n for (int c : active_roots) {\n if (c == new_root) continue;\n min_dist[new_root][c] = min(min_dist[old_root_u][c], min_dist[old_root_v][c]);\n min_dist[c][new_root] = min_dist[new_root][c];\n }\n }\n\n bool decide(int edge_idx, int l) {\n auto [u, v] = edges[edge_idx];\n int root_u = d.leader(u);\n int root_v = d.leader(v);\n\n // If already connected, must reject\n if (root_u == root_v) {\n return false;\n }\n\n int remaining_edges = m - edge_idx;\n\n // Decision logic\n bool take = false;\n if (remaining_edges <= num_components + desperation_threshold) {\n // Desperation mode: take any connecting edge to ensure completion\n take = true;\n } else {\n // Normal mode: use dynamic threshold\n int d_min = min_dist[root_u][root_v];\n \n // desperation_factor is 0 at start, approaches 1 at the end\n double desperation_factor = (double)(num_components - 1) / remaining_edges;\n double k = k_base - (k_base - 1.0) * desperation_factor;\n \n if (l <= k * d_min) {\n take = true;\n }\n }\n\n if (take) {\n // Update state\n d.merge(root_u, root_v);\n num_components--;\n\n int new_root = d.leader(u); // leader of either is fine after merge\n int old_root = (new_root == root_u) ? root_v : root_u;\n \n active_roots.erase(old_root);\n update_min_dist(new_root, root_u, root_v);\n }\n\n return take;\n }\n\n void run() {\n // Read initial input\n for (int i = 0; i < n; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n for (int i = 0; i < m; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n preprocess();\n\n // Main loop\n for (int i = 0; i < m; ++i) {\n int l;\n cin >> l;\n\n bool decision = decide(i, l);\n\n cout << (decision ? 1 : 0) << endl;\n cout.flush();\n }\n }\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n OnlineMST solver;\n solver.run();\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct State {\n int N, M;\n vector> pets, humans;\n vector pet_types;\n vector> impassable;\n vector pet_moves;\n int turn;\n \n void read() {\n cin >> N;\n pets.resize(N);\n pet_types.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].first >> pets[i].second >> pet_types[i];\n }\n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].first >> humans[i].second;\n }\n impassable.assign(31, vector(31, false));\n turn = 0;\n }\n \n void read_pet_moves() {\n pet_moves.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n }\n \n bool is_valid(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n bool is_passable(int x, int y) {\n return is_valid(x, y) && !impassable[x][y];\n }\n \n bool can_make_impassable(int x, int y) {\n if (!is_valid(x, y)) return false;\n \n // Check if pet is at this position at start of turn\n for (auto [px, py] : pets) {\n if (px == x && py == y) return false;\n // Check if pet is adjacent to this position\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return false;\n }\n \n // Check if human is at this position at start of turn\n for (auto [hx, hy] : humans) {\n if (hx == x && hy == y) return false;\n }\n \n return true;\n }\n \n vector> get_neighbors(int x, int y) {\n return {{x-1, y}, {x+1, y}, {x, y-1}, {x, y+1}};\n }\n \n string decide_actions() {\n string actions(M, '.');\n \n for (int i = 0; i < M; i++) {\n auto [hx, hy] = humans[i];\n \n // Simple strategy: try to build walls around nearby pets\n if (turn < 200) {\n // Find closest pet\n int min_dist = 1e9;\n int closest_pet = -1;\n \n for (int p = 0; p < N; p++) {\n auto [px, py] = pets[p];\n int dist = abs(px - hx) + abs(py - hy);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = p;\n }\n }\n \n if (closest_pet != -1 && min_dist <= 8) {\n auto [px, py] = pets[closest_pet];\n \n // Try to build a wall adjacent to human that blocks the pet\n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (can_make_impassable(nx, ny)) {\n // Check if this helps block the pet\n int pet_dist_after = abs(px - nx) + abs(py - ny);\n if (pet_dist_after <= min_dist + 1) {\n if (nx == hx-1) actions[i] = 'u';\n else if (nx == hx+1) actions[i] = 'd';\n else if (ny == hy-1) actions[i] = 'l';\n else if (ny == hy+1) actions[i] = 'r';\n break;\n }\n }\n }\n \n // If couldn't build wall, move towards pet\n if (actions[i] == '.') {\n // Find best move direction\n int best_dist = min_dist;\n char best_move = '.';\n \n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n int new_dist = abs(px - nx) + abs(py - ny);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n if (nx == hx-1) best_move = 'U';\n else if (nx == hx+1) best_move = 'D';\n else if (ny == hy-1) best_move = 'L';\n else if (ny == hy+1) best_move = 'R';\n }\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n } else {\n // Later turns: try to move to center of enclosed area\n // Simple random walk to find better position\n vector possible_moves;\n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n if (nx == hx-1) possible_moves.push_back('U');\n else if (nx == hx+1) possible_moves.push_back('D');\n else if (ny == hy-1) possible_moves.push_back('L');\n else if (ny == hy+1) possible_moves.push_back('R');\n }\n }\n \n if (!possible_moves.empty()) {\n // Prefer moving towards center\n int best_score = -1e9;\n char best_move = '.';\n \n for (char move : possible_moves) {\n int nx = hx, ny = hy;\n if (move == 'U') nx--;\n else if (move == 'D') nx++;\n else if (move == 'L') ny--;\n else if (move == 'R') ny++;\n \n // Simple heuristic: prefer positions closer to center\n int score = -abs(nx - 15) - abs(ny - 15);\n \n // Count nearby pets (avoid them)\n for (auto [px, py] : pets) {\n if (abs(px - nx) + abs(py - ny) <= 3) {\n score -= 10;\n }\n }\n \n if (score > best_score) {\n best_score = score;\n best_move = move;\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n }\n \n return actions;\n }\n \n void update_state(const string& actions) {\n // First, collect all impassable actions to apply simultaneously\n vector> to_make_impassable;\n \n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'u' || action == 'd' || action == 'l' || action == 'r') {\n int nx = hx, ny = hy;\n if (action == 'u') nx--;\n else if (action == 'd') nx++;\n else if (action == 'l') ny--;\n else if (action == 'r') ny++;\n \n if (can_make_impassable(nx, ny)) {\n to_make_impassable.push_back({nx, ny});\n }\n }\n }\n \n // Apply impassable changes\n for (auto [x, y] : to_make_impassable) {\n impassable[x][y] = true;\n }\n \n // Update human positions (they can't move to squares that became impassable this turn)\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int nx = hx, ny = hy;\n if (action == 'U') nx--;\n else if (action == 'D') nx++;\n else if (action == 'L') ny--;\n else if (action == 'R') ny++;\n \n // Check if this square wasn't made impassable this turn\n bool was_made_impassable = false;\n for (auto [x, y] : to_make_impassable) {\n if (x == nx && y == ny) {\n was_made_impassable = true;\n break;\n }\n }\n \n if (is_passable(nx, ny) && !was_made_impassable) {\n humans[i] = {nx, ny};\n }\n }\n }\n \n // Update pet positions based on their moves\n for (int i = 0; i < N; i++) {\n auto [px, py] = pets[i];\n for (char move : pet_moves[i]) {\n if (move == 'U' && is_passable(px-1, py)) px--;\n else if (move == 'D' && is_passable(px+1, py)) px++;\n else if (move == 'L' && is_passable(px, py-1)) py--;\n else if (move == 'R' && is_passable(px, py+1)) py++;\n }\n pets[i] = {px, py};\n }\n \n turn++;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n State state;\n state.read();\n \n for (int turn = 0; turn < 300; turn++) {\n string actions = state.decide_actions();\n cout << actions << endl;\n cout.flush();\n \n state.read_pet_moves();\n state.update_state(actions);\n }\n \n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n string path;\n double success_prob;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h(20), v(19);\n for (int i = 0; i < 20; i++) cin >> h[i];\n for (int i = 0; i < 19; i++) cin >> v[i];\n \n // Find multiple paths using BFS with different strategies\n vector candidate_paths;\n \n // Strategy 1: Shortest path\n auto find_path = [&](bool prefer_straight = false) {\n queue q;\n vector> visited(20, vector(20, false));\n vector> path_str(20, vector(20, \"\"));\n \n q.push({si, sj, \"\", 1.0});\n visited[si][sj] = true;\n \n int dirs[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};\n string dir_chars = \"UDLR\";\n \n string best_path = \"\";\n double best_prob = 0;\n \n while (!q.empty()) {\n State cur = q.front(); q.pop();\n \n if (cur.i == ti && cur.j == tj) {\n if (cur.path.size() < best_path.size() || best_path.empty()) {\n best_path = cur.path;\n best_prob = cur.success_prob;\n }\n continue;\n }\n \n if (!best_path.empty() && cur.path.size() >= best_path.size()) continue;\n \n for (int d = 0; d < 4; d++) {\n int ni = cur.i + dirs[d][0];\n int nj = cur.j + dirs[d][1];\n \n if (ni < 0 || ni >= 20 || nj < 0 || nj >= 20) continue;\n if (visited[ni][nj]) continue;\n \n // Check wall\n bool blocked = false;\n if (d == 0 && cur.i > 0 && v[cur.i-1][cur.j] == '1') blocked = true;\n else if (d == 1 && cur.i < 19 && v[cur.i][cur.j] == '1') blocked = true;\n else if (d == 2 && cur.j > 0 && h[cur.i][cur.j-1] == '1') blocked = true;\n else if (d == 3 && cur.j < 19 && h[cur.i][cur.j] == '1') blocked = true;\n \n if (!blocked) {\n visited[ni][nj] = true;\n double new_prob = cur.success_prob * (1 - p);\n q.push({ni, nj, cur.path + dir_chars[d], new_prob});\n }\n }\n }\n \n return best_path;\n };\n \n string shortest = find_path();\n if (shortest.empty()) {\n cout << \"\" << endl;\n return 0;\n }\n \n // Analyze path to determine critical moves\n vector critical_moves(shortest.size(), 1);\n \n // Moves near obstacles or changes in direction are more critical\n for (int i = 0; i < shortest.size(); i++) {\n int weight = 1;\n \n // Direction changes are critical\n if (i > 0 && shortest[i] != shortest[i-1]) weight++;\n if (i < shortest.size()-1 && shortest[i] != shortest[i+1]) weight++;\n \n // Start and end moves are critical\n if (i < 2 || i > shortest.size() - 3) weight++;\n \n critical_moves[i] = weight;\n }\n \n // Build robust path with adaptive repetition\n string robust_path = \"\";\n int base_repeat = max(2, min(6, (int)(p * 8)));\n \n for (int i = 0; i < shortest.size(); i++) {\n int repeat = base_repeat;\n \n // Adjust based on criticality\n if (critical_moves[i] >= 3) repeat++;\n if (critical_moves[i] >= 4) repeat++;\n \n // Ensure we don't exceed length limit\n int remaining = shortest.size() - i - 1;\n int max_possible = (200 - robust_path.size()) / (remaining + 1);\n repeat = min(repeat, max(1, max_possible));\n \n for (int j = 0; j < repeat; j++) {\n robust_path += shortest[i];\n }\n }\n \n // If we have extra space, add strategic redundancy\n if (robust_path.size() < 180) {\n // Add the most critical part again\n int start_idx = max(0, (int)shortest.size() - 8);\n for (int i = start_idx; i < shortest.size(); i++) {\n if (robust_path.size() >= 200) break;\n robust_path += shortest[i];\n }\n }\n \n // Final safety check - add more redundancy to first and last moves\n if (shortest.size() > 0 && robust_path.size() < 190) {\n string prefix = shortest.substr(0, min(3, (int)shortest.size()));\n string suffix = shortest.substr(max(0, (int)shortest.size() - 3));\n \n for (char c : prefix) {\n if (robust_path.size() >= 200) break;\n robust_path = string(1, c) + robust_path;\n }\n \n for (char c : suffix) {\n if (robust_path.size() >= 200) break;\n robust_path += c;\n }\n }\n \n cout << robust_path << endl;\n \n return 0;\n}","ahc010":"#include \nusing namespace std;\n\n// Directions: 0=left, 1=up, 2=right, 3=down\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Connection table: to[tile_type][entry_direction] = exit_direction\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// Precompute rotated tile types\nint rotated_tile[8][4];\n\nvoid init_rotated_tile() {\n for (int tile = 0; tile < 8; tile++) {\n for (int rot = 0; rot < 4; rot++) {\n if (tile <= 3) { // curved tiles\n rotated_tile[tile][rot] = (tile + rot) % 4;\n } else if (tile <= 5) { // double curved tiles\n rotated_tile[tile][rot] = tile + (rot % 2);\n } else { // straight tiles\n rotated_tile[tile][rot] = tile + (rot % 2);\n }\n }\n }\n}\n\nstruct Grid {\n int tiles[30][30]; // Original tile types\n int rotations[30][30]; // Current rotations (0-3)\n \n Grid() {}\n \n Grid(const vector& input) {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n tiles[i][j] = input[i][j] - '0';\n rotations[i][j] = 0;\n }\n }\n }\n \n int get_tile_type(int i, int j) const {\n return rotated_tile[tiles[i][j]][rotations[i][j]];\n }\n \n // Calculate loop length starting from (i,j) with entry direction d\n // Returns 0 if not a loop, otherwise returns loop length\n int calculate_loop_length(int si, int sj, int sd, bool visited[30][30][4]) {\n if (visited[si][sj][sd]) return 0;\n \n int i = si, j = sj, d = sd;\n int length = 0;\n visited[si][sj][sd] = 1;\n \n do {\n int tile_type = get_tile_type(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) {\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= 30 || j < 0 || j >= 30) {\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n d = (d2 + 2) % 4;\n length++;\n \n if (length > 900) { // Prevent infinite loops\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n } while (!(i == si && j == sj && d == sd));\n \n visited[si][sj][sd] = 0;\n return length;\n }\n \n // Find top two loop lengths\n pair find_top_loops() {\n bool visited[30][30][4] = {false};\n vector loops;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n if (!visited[i][j][d]) {\n int length = calculate_loop_length(i, j, d, visited);\n if (length > 0) {\n loops.push_back(length);\n }\n }\n }\n }\n }\n \n sort(loops.rbegin(), loops.rend());\n \n if (loops.size() < 2) return {0, 0};\n \n // Remove duplicates (same loop might be found from multiple starting points)\n vector unique_loops;\n for (int i = 0; i < loops.size(); i++) {\n bool is_duplicate = false;\n for (int j = 0; j < i; j++) {\n if (loops[i] == loops[j]) {\n is_duplicate = true;\n break;\n }\n }\n if (!is_duplicate) {\n unique_loops.push_back(loops[i]);\n }\n }\n \n if (unique_loops.size() < 2) return {0, 0};\n \n return {unique_loops[0], unique_loops[1]};\n }\n \n long long calculate_score() {\n auto [l1, l2] = find_top_loops();\n return (long long)l1 * l2;\n }\n \n void randomize_rotations() {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rotations[i][j] = dis(gen);\n }\n }\n }\n \n void hill_climb(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n if (new_score > best_score) {\n best_score = new_score;\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n string get_output() const {\n string result;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n result += to_string(rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n init_rotated_tile();\n \n vector input(30);\n for (int i = 0; i < 30; i++) {\n cin >> input[i];\n }\n \n Grid grid(input);\n \n // Try multiple random initializations and keep the best\n long long best_score = 0;\n string best_output;\n \n for (int attempt = 0; attempt < 3; attempt++) { // Further reduced attempts\n grid.randomize_rotations();\n \n // Reduced iterations for optimization\n grid.hill_climb(2000); // Further reduced\n \n long long current_score = grid.calculate_score();\n if (current_score > best_score) {\n best_score = current_score;\n best_output = grid.get_output();\n }\n }\n \n cout << best_output << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct UnionFind {\n vector p, r;\n UnionFind(int n) : p(n), r(n, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (r[x] < r[y]) p[x] = y;\n else { p[y] = x; if (r[x] == r[y]) r[x]++; }\n }\n};\n\nclass Solver {\npublic:\n Solver(int n, int t, const vector& grid) : N(n), T(t) {\n board.resize(N, vector(N, 0));\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n char ch = grid[r][c];\n if (ch >= '0' && ch <= '9') {\n board[r][c] = ch - '0';\n } else {\n board[r][c] = 10 + (ch - 'a');\n }\n if (board[r][c] == 0) {\n empty_r = r;\n empty_c = c;\n }\n }\n }\n }\n\n string solve() {\n auto start_time = chrono::high_resolution_clock::now();\n \n // Phase 1: Long Random Walk\n vector> walk_board = board;\n int walk_er = empty_r, walk_ec = empty_c;\n string walk_path;\n\n vector> best_S_board = walk_board;\n string best_S_path = \"\";\n int best_S_score = calculate_S_score(walk_board);\n\n mt19937 rng(random_device{}());\n int max_steps = T / 2;\n for (int i = 0; i < max_steps; ++i) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.5) break;\n\n vector possible_moves;\n // CORRECTED LOGIC: Check based on tile to be moved\n if (walk_er > 0) possible_moves.push_back('U'); // Tile above can move down\n if (walk_er < N - 1) possible_moves.push_back('D'); // Tile below can move up\n if (walk_ec > 0) possible_moves.push_back('L'); // Tile to left can move right\n if (walk_ec < N - 1) possible_moves.push_back('R'); // Tile to right can move left\n\n if (possible_moves.empty()) break;\n\n char m = possible_moves[rng() % possible_moves.size()];\n apply_move(m, walk_board, walk_er, walk_ec);\n walk_path += m;\n\n int current_S_score = calculate_S_score(walk_board);\n if (current_S_score > best_S_score) {\n best_S_score = current_S_score;\n best_S_board = walk_board;\n best_S_path = walk_path;\n }\n }\n\n // Phase 2: Local Refinement with S_score heuristic\n vector> lr_board = best_S_board;\n int lr_er = -1, lr_ec = -1;\n for(int r=0; r(current_time - start_time).count();\n if (elapsed > 2.9) break;\n\n char best_move = ' ';\n int best_delta_S = -1;\n vector possible_moves;\n\n // CORRECTED LOGIC: Check based on tile to be moved\n if (lr_er > 0) possible_moves.push_back('U');\n if (lr_er < N - 1) possible_moves.push_back('D');\n if (lr_ec > 0) possible_moves.push_back('L');\n if (lr_ec < N - 1) possible_moves.push_back('R');\n \n for(char m : possible_moves) {\n vector> temp_board = lr_board;\n int temp_er = lr_er, temp_ec = lr_ec;\n apply_move(m, temp_board, temp_er, temp_ec);\n \n int new_S = calculate_S_score(temp_board);\n int delta_S = new_S - current_S;\n \n if (delta_S > best_delta_S) {\n best_delta_S = delta_S;\n best_move = m;\n }\n }\n\n if (best_delta_S > 0) {\n apply_move(best_move, lr_board, lr_er, lr_ec);\n lr_path.push_back(best_move);\n current_S += best_delta_S;\n } else {\n break; // Local optimum\n }\n }\n\n string final_path = best_S_path + lr_path;\n if (final_path.length() > T) {\n final_path = final_path.substr(0, T);\n }\n\n return final_path;\n }\n\nprivate:\n int N, T;\n vector> board;\n int empty_r, empty_c;\n\n int calculate_S_score(const vector>& b) {\n UnionFind uf(N * N);\n vector num_edges(N * N, 0);\n vector component_size(N * N, 0);\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] == 0) continue;\n int u = r * N + c;\n component_size[uf.find(u)]++;\n\n if (r > 0 && b[r-1][c] != 0 && (b[r][c] & 2) && (b[r-1][c] & 8)) {\n int v = (r-1) * N + c;\n int ru = uf.find(u), rv = uf.find(v);\n if (ru != rv) {\n uf.unite(u, v);\n int new_root = uf.find(u);\n component_size[new_root] = component_size[ru] + component_size[rv];\n num_edges[new_root] = num_edges[ru] + num_edges[rv] + 1;\n } else {\n num_edges[ru]++;\n }\n }\n if (c > 0 && b[r][c-1] != 0 && (b[r][c] & 1) && (b[r][c-1] & 4)) {\n int v = r * N + (c-1);\n int ru = uf.find(u), rv = uf.find(v);\n if (ru != rv) {\n uf.unite(u, v);\n int new_root = uf.find(u);\n component_size[new_root] = component_size[ru] + component_size[rv];\n num_edges[new_root] = num_edges[ru] + num_edges[rv] + 1;\n } else {\n num_edges[ru]++;\n }\n }\n }\n }\n \n int max_S = 0;\n for (int i = 0; i < N * N; ++i) {\n if (uf.find(i) == i && component_size[i] > 0) {\n if (num_edges[i] == component_size[i] - 1) {\n max_S = max(max_S, component_size[i]);\n }\n }\n }\n return max_S;\n }\n\n\n void apply_move(char m, vector>& b, int& er, int& ec) {\n int tr = er, tc = ec;\n // CORRECTED LOGIC: 'U' moves the tile at (er-1, ec) into the empty space\n if (m == 'U') tr--;\n else if (m == 'D') tr++;\n else if (m == 'L') tc--;\n else if (m == 'R') tc++;\n\n if (tr >= 0 && tr < N && tc >= 0 && tc < N) {\n swap(b[er][ec], b[tr][tc]);\n er = tr;\n ec = tc;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, T;\n cin >> N >> T;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n Solver solver(N, T, grid);\n string ans = solver.solve();\n cout << ans << endl;\n\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Use a time-based seed for non-deterministic behavior in different submissions\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nconst long double EPS = 1e-9;\nconst long long COORD_MAX = 1e9;\nconst int N_TRIALS = 10; // Number of times to try a random set of cuts\n\nstruct Point {\n long long x, y;\n Point(long long x = 0, long long y = 0) : x(x), y(y) {}\n};\n\nstruct Line {\n Point p1, p2;\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\n// Calculates the cross product of vectors OA and OB\nlong long cross(const Point& a, const Point& b) {\n return a.x * b.y - a.y * b.x;\n}\n\n// Determines which side of the line p1p2 the point a is on.\n// Returns 1 for left, -1 for right, 0 if on the line.\nint get_side(const Point& a, const Point& p1, const Point& p2) {\n Point v1 = {a.x - p1.x, a.y - p1.y};\n Point v2 = {p2.x - p1.x, p2.y - p1.y};\n long long c = cross(v1, v2);\n if (c > 0) return 1;\n if (c < 0) return -1;\n return 0;\n}\n\n// Calculates the score for a given set of cuts\nlong long calculate_score(const vector& points, const vector& a, const vector& cuts) {\n int K = cuts.size();\n if (K == 0) return 0;\n\n vector b(11, 0);\n unordered_map signature_counts;\n \n for (const auto& p : points) {\n long long signature = 0;\n bool is_cut = false;\n for (int i = 0; i < K; ++i) {\n int side = get_side(p, cuts[i].p1, cuts[i].p2);\n if (side == 0) {\n is_cut = true;\n break;\n }\n if (side == 1) {\n signature |= (1LL << i);\n }\n }\n if (!is_cut) {\n signature_counts[signature]++;\n }\n }\n\n for (const auto& pair : signature_counts) {\n int count = pair.second;\n if (count >= 1 && count <= 10) {\n b[count]++;\n }\n }\n\n long long sum_min = 0;\n long long sum_a = 0;\n for (int d = 1; d <= 10; ++d) {\n sum_min += min(a[d], b[d]);\n sum_a += a[d];\n }\n\n if (sum_a == 0) return 0;\n return (long long)round(1e6 * (long double)sum_min / sum_a);\n}\n\nvoid solve() {\n int N, K;\n cin >> N >> K;\n K = 100; // K is fixed to 100\n\n vector a(11);\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n\n vector points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n\n long long best_score = -1;\n vector best_cuts;\n\n // Distribution for random points to define lines. Range is large enough to cover the cake.\n uniform_int_distribution dist_large(-100000, 100000);\n\n for (int trial = 0; trial < N_TRIALS; ++trial) {\n vector current_cuts;\n current_cuts.reserve(K);\n\n for (int i = 0; i < K; ++i) {\n Point p1, p2;\n // Ensure the two points are different to form a valid line\n do {\n p1 = {dist_large(rng), dist_large(rng)};\n p2 = {dist_large(rng), dist_large(rng)};\n } while (p1.x == p2.x && p1.y == p2.y);\n \n current_cuts.emplace_back(p1, p2);\n }\n\n long long current_score = calculate_score(points, a, current_cuts);\n if (current_score > best_score) {\n best_score = current_score;\n best_cuts = current_cuts;\n }\n }\n\n cout << best_cuts.size() << endl;\n for (const auto& cut : best_cuts) {\n cout << cut.p1.x << \" \" << cut.p1.y << \" \" << cut.p2.x << \" \" << cut.p2.y << \"\\n\";\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc014":"#include \n#include \n#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 bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n Point p1, p2, p3, p4;\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_dots(M);\n set dots;\n map> x_to_ys;\n map> y_to_xs;\n \n for (int i = 0; i < M; i++) {\n cin >> initial_dots[i].x >> initial_dots[i].y;\n dots.insert(initial_dots[i]);\n x_to_ys[initial_dots[i].x].push_back(initial_dots[i].y);\n y_to_xs[initial_dots[i].y].push_back(initial_dots[i].x);\n }\n\n for (auto& [x, ys] : x_to_ys) {\n sort(ys.begin(), ys.end());\n }\n for (auto& [y, xs] : y_to_xs) {\n sort(xs.begin(), xs.end());\n }\n\n int c = (N - 1) / 2;\n auto weight = [c](int x, int y) {\n return (x - c) * (x - c) + (y - c) * (y - c) + 1;\n };\n\n // Create list of all empty points sorted by weight (descending)\n vector> empty_points;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (dots.find({x, y}) == dots.end()) {\n empty_points.push_back({weight(x, y), {x, y}});\n }\n }\n }\n sort(empty_points.rbegin(), empty_points.rend());\n\n vector operations;\n\n set> used_segments;\n\n auto is_segment_used = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n if (used_segments.count({x1, y, x1, y+1}) > 0 ||\n used_segments.count({x1, y+1, x1, y}) > 0) {\n return true;\n }\n }\n } else if (y1 == y2) {\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n if (used_segments.count({x, y1, x+1, y1}) > 0 ||\n used_segments.count({x+1, y1, x, y1}) > 0) {\n return true;\n }\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n if (used_segments.count({x, y, x+dx, y+dy}) > 0 ||\n used_segments.count({x+dx, y+dy, x, y}) > 0) {\n return true;\n }\n x += dx;\n y += dy;\n }\n }\n return false;\n };\n\n auto add_segments = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n used_segments.insert({x1, y, x1, y+1});\n used_segments.insert({x1, y+1, x1, y});\n }\n } else if (y1 == y2) {\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n used_segments.insert({x, y1, x+1, y1});\n used_segments.insert({x+1, y1, x, y1});\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n used_segments.insert({x, y, x+dx, y+dy});\n used_segments.insert({x+dx, y+dy, x, y});\n x += dx;\n y += dy;\n }\n }\n };\n\n auto has_dot = [&dots](int x, int y) {\n return dots.count({x, y}) > 0;\n };\n\n auto is_valid_rectangle = [&](Point p1, Point p2, Point p3, Point p4) {\n if (p1.x < 0 || p1.x >= N || p1.y < 0 || p1.y >= N) return false;\n if (p2.x < 0 || p2.x >= N || p2.y < 0 || p2.y >= N) return false;\n if (p3.x < 0 || p3.x >= N || p3.y < 0 || p3.y >= N) return false;\n if (p4.x < 0 || p4.x >= N || p4.y < 0 || p4.y >= N) return false;\n \n if (has_dot(p1.x, p1.y)) return false;\n if (!has_dot(p2.x, p2.y) || !has_dot(p3.x, p3.y) || !has_dot(p4.x, p4.y)) return false;\n \n if (is_segment_used(p1.x, p1.y, p2.x, p2.y) ||\n is_segment_used(p2.x, p2.y, p3.x, p3.y) ||\n is_segment_used(p3.x, p3.y, p4.x, p4.y) ||\n is_segment_used(p4.x, p4.y, p1.x, p1.y)) {\n return false;\n }\n \n // Check edge p1-p2\n if (p1.x == p2.x) {\n int y_start = min(p1.y, p2.y);\n int y_end = max(p1.y, p2.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p1.x, y)) return false;\n }\n } else if (p1.y == p2.y) {\n int x_start = min(p1.x, p2.x);\n int x_end = max(p1.x, p2.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p1.y)) return false;\n }\n } else if (abs(p2.x - p1.x) == abs(p2.y - p1.y)) {\n int dx = (p2.x > p1.x) ? 1 : -1;\n int dy = (p2.y > p1.y) ? 1 : -1;\n int x = p1.x + dx, y = p1.y + dy;\n while (x != p2.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p2-p3\n if (p2.x == p3.x) {\n int y_start = min(p2.y, p3.y);\n int y_end = max(p2.y, p3.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p2.x, y)) return false;\n }\n } else if (p2.y == p3.y) {\n int x_start = min(p2.x, p3.x);\n int x_end = max(p2.x, p3.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p2.y)) return false;\n }\n } else if (abs(p3.x - p2.x) == abs(p3.y - p2.y)) {\n int dx = (p3.x > p2.x) ? 1 : -1;\n int dy = (p3.y > p2.y) ? 1 : -1;\n int x = p2.x + dx, y = p2.y + dy;\n while (x != p3.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p3-p4\n if (p3.x == p4.x) {\n int y_start = min(p3.y, p4.y);\n int y_end = max(p3.y, p4.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p3.x, y)) return false;\n }\n } else if (p3.y == p4.y) {\n int x_start = min(p3.x, p4.x);\n int x_end = max(p3.x, p4.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p3.y)) return false;\n }\n } else if (abs(p4.x - p3.x) == abs(p4.y - p3.y)) {\n int dx = (p4.x > p3.x) ? 1 : -1;\n int dy = (p4.y > p3.y) ? 1 : -1;\n int x = p3.x + dx, y = p3.y + dy;\n while (x != p4.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p4-p1\n if (p4.x == p1.x) {\n int y_start = min(p4.y, p1.y);\n int y_end = max(p4.y, p1.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p4.x, y)) return false;\n }\n } else if (p4.y == p1.y) {\n int x_start = min(p4.x, p1.x);\n int x_end = max(p4.x, p1.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p4.y)) return false;\n }\n } else if (abs(p1.x - p4.x) == abs(p1.y - p4.y)) {\n int dx = (p1.x > p4.x) ? 1 : -1;\n int dy = (p1.y > p4.y) ? 1 : -1;\n int x = p4.x + dx, y = p4.y + dy;\n while (x != p1.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n return true;\n };\n\n mt19937 rng(random_device{}());\n \n // Adaptive search: try different strategies\n for (int strategy = 0; strategy < 2; strategy++) {\n // Strategy 0: prioritize axis-aligned, then diamonds\n // Strategy 1: prioritize diamonds, then axis-aligned\n \n for (const auto& [w, p] : empty_points) {\n bool found = false;\n Rectangle rect;\n\n if (strategy == 0) {\n // Try axis-aligned first\n vector> search_order;\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend());\n \n for (const auto& [dist, x2] : search_order) {\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n Rectangle candidate = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n }\n }\n if (found) break;\n }\n\n // Then try diamonds\n if (!found) {\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) {\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n vector> diamonds;\n \n if (p.y - 2*d >= 0 && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}});\n }\n if (p.y + 2*d < N && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}});\n }\n if (p.x - 2*d >= 0 && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}});\n }\n if (p.x + 2*d < N && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}});\n }\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n Rectangle candidate = {diamond[0], diamond[1], diamond[2], diamond[3]};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n if (found) break;\n }\n }\n } else {\n // Strategy 1: Try diamonds first\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) {\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n vector> diamonds;\n \n if (p.y - 2*d >= 0 && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}});\n }\n if (p.y + 2*d < N && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}});\n }\n if (p.x - 2*d >= 0 && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}});\n }\n if (p.x + 2*d < N && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}});\n }\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n Rectangle candidate = {diamond[0], diamond[1], diamond[2], diamond[3]};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n if (found) break;\n }\n\n // Then try axis-aligned\n if (!found) {\n vector> search_order;\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend());\n \n for (const auto& [dist, x2] : search_order) {\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n Rectangle candidate = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n }\n }\n if (found) break;\n }\n }\n }\n\n if (found) {\n operations.push_back(rect);\n dots.insert(rect.p1);\n \n x_to_ys[rect.p1.x].push_back(rect.p1.y);\n y_to_xs[rect.p1.y].push_back(rect.p1.x);\n sort(x_to_ys[rect.p1.x].begin(), x_to_ys[rect.p1.x].end());\n sort(y_to_xs[rect.p1.y].begin(), y_to_xs[rect.p1.y].end());\n \n add_segments(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);\n add_segments(rect.p2.x, rect.p2.y, rect.p3.x, rect.p3.y);\n add_segments(rect.p3.x, rect.p3.y, rect.p4.x, rect.p4.y);\n add_segments(rect.p4.x, rect.p4.y, rect.p1.x, rect.p1.y);\n }\n\n // Adaptive early termination\n if (operations.size() >= 2500) break;\n }\n }\n\n cout << operations.size() << \"\\n\";\n for (const auto& rect : operations) {\n cout << rect.p1.x << \" \" << rect.p1.y << \" \";\n cout << rect.p2.x << \" \" << rect.p2.y << \" \";\n cout << rect.p3.x << \" \" << rect.p3.y << \" \";\n cout << rect.p4.x << \" \" << rect.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nconst int N = 10;\nconst int DIRECTIONS = 4;\nconst int EMPTY = 0;\nconst int TURNS = 100;\n\nstruct Cell {\n int flavor;\n int x, y;\n Cell() : flavor(EMPTY), x(-1), y(-1) {}\n Cell(int f, int x, int y) : flavor(f), x(x), y(y) {}\n};\n\nclass Grid {\nprivate:\n vector> grid;\n vector candies;\n \npublic:\n Grid() : grid(N, vector(N, EMPTY)) {}\n \n void add_candy(int flavor, int x, int y) {\n grid[x][y] = flavor;\n candies.emplace_back(flavor, x, y);\n }\n \n void tilt(char direction) {\n vector> new_grid(N, vector(N, EMPTY));\n vector new_candies;\n \n int dx = 0, dy = 0;\n if (direction == 'F') dx = -1;\n else if (direction == 'B') dx = 1;\n else if (direction == 'L') dy = -1;\n else if (direction == 'R') dy = 1;\n \n // Determine order of processing to avoid collisions\n vector indices(candies.size());\n iota(indices.begin(), indices.end(), 0);\n \n if (direction == 'F') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].x < candies[b].x;\n });\n } else if (direction == 'B') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].x > candies[b].x;\n });\n } else if (direction == 'L') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].y < candies[b].y;\n });\n } else if (direction == 'R') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].y > candies[b].y;\n });\n }\n \n for (int idx : indices) {\n const auto& candy = candies[idx];\n int x = candy.x;\n int y = candy.y;\n \n // Move until hitting edge or another candy\n while (true) {\n int nx = x + dx;\n int ny = y + dy;\n \n if (nx < 0 || nx >= N || ny < 0 || ny >= N || new_grid[nx][ny] != EMPTY) {\n break;\n }\n \n x = nx;\n y = ny;\n }\n \n new_grid[x][y] = candy.flavor;\n new_candies.emplace_back(candy.flavor, x, y);\n }\n \n grid = move(new_grid);\n candies = move(new_candies);\n }\n \n const vector& get_candies() const { return candies; }\n const vector>& get_grid() const { return grid; }\n \n void clear() {\n grid.assign(N, vector(N, EMPTY));\n candies.clear();\n }\n};\n\nclass Strategy {\nprotected:\n vector flavors;\n Grid grid;\n int turn;\n vector corner_directions;\n mt19937 rng;\n \npublic:\n Strategy(const vector& f) : flavors(f), turn(0), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n corner_directions = {'L', 'R', 'B'};\n }\n \n virtual ~Strategy() {}\n \n void add_candy(int p) {\n // Convert p to (x, y) coordinates\n int empty_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid.get_grid()[i][j] == EMPTY) {\n empty_count++;\n if (empty_count == p) {\n grid.add_candy(flavors[turn], i, j);\n return;\n }\n }\n }\n }\n }\n \n void apply_tilt(char direction) {\n grid.tilt(direction);\n turn++;\n }\n \n const Grid& get_grid() const { return grid; }\n \n int count_components(int flavor) const {\n const auto& g = grid.get_grid();\n vector> visited(N, vector(N, false));\n int count = 0;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (g[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n count++;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && g[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n }\n }\n \n return count;\n }\n \n int get_largest_component_size(int flavor) const {\n const auto& g = grid.get_grid();\n vector> visited(N, vector(N, false));\n int max_size = 0;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (g[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n int size = 0;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && g[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n max_size = max(max_size, size);\n }\n }\n }\n \n return max_size;\n }\n \n virtual char decide_tilt(int p) = 0;\n};\n\nclass AdaptiveStrategy : public Strategy {\nprivate:\n vector flavor_counts;\n \npublic:\n AdaptiveStrategy(const vector& f) : Strategy(f) {\n flavor_counts.resize(3, 0);\n for (int f : flavors) {\n flavor_counts[f-1]++;\n }\n \n // Assign corners based on flavor counts\n vector> flavor_rank;\n for (int i = 0; i < 3; i++) {\n flavor_rank.emplace_back(flavor_counts[i], i);\n }\n sort(flavor_rank.rbegin(), flavor_rank.rend());\n \n // Most abundant flavor gets the best corner\n corner_directions[flavor_rank[0].second] = 'L';\n corner_directions[flavor_rank[1].second] = 'R';\n corner_directions[flavor_rank[2].second] = 'B';\n }\n \n double evaluate_tilt(char direction) {\n Grid test_grid = grid;\n test_grid.tilt(direction);\n \n int flavor = flavors[turn];\n double score = 0.0;\n \n // Component connectivity score\n int components = 0;\n int largest = 0;\n const auto& test_grid_state = test_grid.get_grid();\n vector> visited(N, vector(N, false));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid_state[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n components++;\n \n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && test_grid_state[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n largest = max(largest, size);\n }\n }\n }\n \n score += 100.0 / components;\n score += largest * 10.0;\n \n // Distance to corner\n char corner_dir = corner_directions[flavor-1];\n int target_x = (corner_dir == 'F') ? 0 : (corner_dir == 'B') ? N-1 : -1;\n int target_y = (corner_dir == 'L') ? 0 : (corner_dir == 'R') ? N-1 : -1;\n \n const auto& test_candies = test_grid.get_candies();\n for (const auto& candy : test_candies) {\n if (candy.flavor == flavor) {\n double dist = 0.0;\n if (target_x != -1) dist += abs(candy.x - target_x);\n if (target_y != -1) dist += abs(candy.y - target_y);\n score += 50.0 / (1.0 + dist);\n break;\n }\n }\n \n return score;\n }\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n int flavor = flavors[turn];\n \n // Early game: push to corners\n if (turn < 30) {\n return corner_directions[flavor-1];\n }\n \n // Mid game: use heuristic evaluation\n if (turn < 80) {\n char best_dir = 'F';\n double best_score = -1e9;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n double score = evaluate_tilt(dir);\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n \n // Late game: focus on connecting components\n char best_dir = 'F';\n int min_components = 1e9;\n int max_largest = 0;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n Grid test_grid = grid;\n test_grid.tilt(dir);\n \n int components = 0;\n int largest = 0;\n const auto& test_grid_state = test_grid.get_grid();\n vector> visited(N, vector(N, false));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid_state[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n components++;\n \n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && test_grid_state[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n largest = max(largest, size);\n }\n }\n }\n \n if (components < min_components || \n (components == min_components && largest > max_largest)) {\n min_components = components;\n max_largest = largest;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n AdaptiveStrategy strategy(flavors);\n \n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n \n if (t < 99) {\n char tilt = strategy.decide_tilt(p);\n strategy.apply_tilt(tilt);\n cout << tilt << endl;\n cout.flush();\n } else {\n strategy.decide_tilt(p);\n }\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct GraphFeatures {\n int edge_count;\n double avg_degree;\n int max_degree;\n int triangles;\n int components;\n double clustering_coeff;\n};\n\nvector> parse_graph(const string& s, int N) {\n vector> adj(N, vector(N, 0));\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n adj[i][j] = adj[j][i] = (s[idx++] == '1');\n }\n }\n return adj;\n}\n\nGraphFeatures extract_features(const vector>& adj) {\n int N = adj.size();\n GraphFeatures f;\n \n // Edge count and degrees\n f.edge_count = 0;\n vector degree(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n f.edge_count++;\n degree[i]++;\n degree[j]++;\n }\n }\n }\n \n // Degree statistics\n f.avg_degree = 2.0 * f.edge_count / N;\n f.max_degree = *max_element(degree.begin(), degree.end());\n \n // Triangles\n f.triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n f.triangles++;\n }\n }\n }\n }\n }\n \n // Components\n vector visited(N, false);\n f.components = 0;\n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n f.components++;\n vector stack = {i};\n visited[i] = true;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n for (int u = 0; u < N; u++) {\n if (adj[v][u] && !visited[u]) {\n visited[u] = true;\n stack.push_back(u);\n }\n }\n }\n }\n }\n \n // Clustering coefficient\n double total_clustering = 0;\n int count = 0;\n for (int i = 0; i < N; i++) {\n if (degree[i] >= 2) {\n int neighbors = 0;\n int neighbor_edges = 0;\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) {\n neighbors++;\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n neighbor_edges++;\n }\n }\n }\n }\n if (neighbors >= 2) {\n total_clustering += 2.0 * neighbor_edges / (neighbors * (neighbors - 1));\n count++;\n }\n }\n }\n f.clustering_coeff = (count > 0) ? total_clustering / count : 0;\n \n return f;\n}\n\nstring generate_graph_with_features(int N, int target_edges, double target_clustering, int target_components, mt19937& rng) {\n int total_possible = N * (N - 1) / 2;\n string graph(total_possible, '0');\n \n if (target_components > 1) {\n // Create disconnected graph\n int comp_size = N / target_components;\n vector> components;\n \n for (int c = 0; c < target_components; c++) {\n int start = c * comp_size;\n int end = (c == target_components - 1) ? N : (c + 1) * comp_size;\n components.push_back({start, end});\n }\n \n // Add edges within components\n for (auto& comp : components) {\n int comp_vertices = comp[1] - comp[0];\n int comp_edges = min(target_edges / target_components, \n comp_vertices * (comp_vertices - 1) / 2);\n \n vector> possible_edges;\n for (int i = comp[0]; i < comp[1]; i++) {\n for (int j = i + 1; j < comp[1]; j++) {\n possible_edges.push_back({i, j});\n }\n }\n \n shuffle(possible_edges.begin(), possible_edges.end(), rng);\n for (int i = 0; i < comp_edges; i++) {\n int u = possible_edges[i].first;\n int v = possible_edges[i].second;\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n }\n } else {\n // Connected graph with target clustering\n vector> possible_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n possible_edges.push_back({i, j});\n }\n }\n \n // Start with a random spanning tree for connectivity\n shuffle(possible_edges.begin(), possible_edges.end(), rng);\n vector parent(N);\n for (int i = 0; i < N; i++) parent[i] = i;\n \n auto find = [&](int x) {\n while (parent[x] != x) x = parent[x];\n return x;\n };\n \n int edges_added = 0;\n for (auto& edge : possible_edges) {\n int u = edge.first, v = edge.second;\n if (find(u) != find(v)) {\n parent[find(u)] = find(v);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n edges_added++;\n if (edges_added == N - 1) break;\n }\n }\n \n // Add remaining edges based on clustering target\n vector> remaining;\n for (auto& edge : possible_edges) {\n int u = edge.first, v = edge.second;\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n if (graph[idx] == '0') {\n remaining.push_back(edge);\n }\n }\n \n if (target_clustering > 0.3) {\n // Prioritize edges that form triangles\n shuffle(remaining.begin(), remaining.end(), rng);\n }\n \n int remaining_edges = min(target_edges - edges_added, (int)remaining.size());\n for (int i = 0; i < remaining_edges; i++) {\n int u = remaining[i].first, v = remaining[i].second;\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n }\n \n return graph;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Adaptive N selection based on epsilon and M\n int N;\n if (epsilon < 0.05) {\n N = min(20, max(6, M/3 + 6));\n } else if (epsilon < 0.1) {\n N = min(25, max(8, M/3 + 8));\n } else if (epsilon < 0.2) {\n N = min(35, max(10, M/3 + 12));\n } else if (epsilon < 0.3) {\n N = min(45, max(12, M/3 + 16));\n } else {\n N = min(60, max(15, M/3 + 20));\n }\n \n cout << N << endl;\n cout.flush();\n \n // Generate M graphs with diverse features\n int total_possible = N * (N - 1) / 2;\n vector graphs(M);\n vector features(M);\n \n random_device rd;\n mt19937 rng(12345);\n \n for (int i = 0; i < M; i++) {\n // Vary multiple features\n int edge_count = (total_possible * (i + 1)) / (M + 1);\n double clustering = 0.1 + 0.6 * sin(2 * M_PI * i / M);\n int components = 1 + (i % 3 == 0 ? 1 : 0);\n \n graphs[i] = generate_graph_with_features(N, edge_count, clustering, components, rng);\n features[i] = extract_features(parse_graph(graphs[i], N));\n \n cout << graphs[i] << endl;\n }\n cout.flush();\n \n // Process queries with feature-based matching\n for (int query = 0; query < 100; query++) {\n string H;\n cin >> H;\n \n auto adj_H = parse_graph(H, N);\n auto f_H = extract_features(adj_H);\n \n // Find best match using weighted features\n int best_idx = 0;\n double best_score = 1e9;\n \n for (int i = 0; i < M; i++) {\n double score = 0;\n \n // Weight different features based on epsilon\n double edge_weight = 1.0 - epsilon * 0.5;\n double degree_weight = 0.3;\n double triangle_weight = 0.2 * (1 - epsilon);\n double component_weight = 0.4;\n double cluster_weight = 0.1 * (1 - epsilon);\n \n // Edge count difference (most important)\n double edge_diff = abs(f_H.edge_count - features[i].edge_count);\n score += edge_weight * edge_diff / total_possible;\n \n // Average degree difference\n double degree_diff = abs(f_H.avg_degree - features[i].avg_degree);\n score += degree_weight * degree_diff / N;\n \n // Triangle count difference\n double triangle_diff = abs(f_H.triangles - features[i].triangles);\n score += triangle_weight * triangle_diff / (N * (N - 1) * (N - 2) / 6);\n \n // Component count difference\n score += component_weight * abs(f_H.components - features[i].components);\n \n // Clustering coefficient difference\n score += cluster_weight * abs(f_H.clustering_coeff - features[i].clustering_coeff);\n \n if (score < best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Edge {\n int u, v, w, id;\n double x1, y1, x2, y2;\n int importance;\n int day;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n \n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--;\n edges[i].v--;\n edges[i].id = i;\n }\n \n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Assign coordinates to edges\n for (auto &e : edges) {\n e.x1 = coords[e.u].first;\n e.y1 = coords[e.u].second;\n e.x2 = coords[e.v].first;\n e.y2 = coords[e.v].second;\n }\n \n // Compute betweenness centrality for each edge\n vector betweenness(M, 0);\n const int SAMPLES = min(N, 50);\n vector sampled_vertices(N);\n iota(sampled_vertices.begin(), sampled_vertices.end(), 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(sampled_vertices.begin(), sampled_vertices.end(), rng);\n sampled_vertices.resize(SAMPLES);\n \n for (int s : sampled_vertices) {\n vector dist(N, 1e9);\n vector prev(N, -1);\n priority_queue, vector>, greater<>> pq;\n dist[s] = 0;\n pq.push({0, s});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n int v = -1;\n if (e.u == u) v = e.v;\n else if (e.v == u) v = e.u;\n else continue;\n if (dist[v] > dist[u] + e.w) {\n dist[v] = dist[u] + e.w;\n prev[v] = u;\n pq.push({dist[v], v});\n }\n }\n }\n \n for (int t = 0; t < N; ++t) {\n if (t == s) continue;\n for (int v = t; v != s && prev[v] != -1; v = prev[v]) {\n int u = prev[v];\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n betweenness[eid]++;\n break;\n }\n }\n }\n }\n }\n \n // Compute importance: betweenness + inverse weight\n for (int i = 0; i < M; ++i) {\n edges[i].importance = betweenness[i] * 1000000 / (edges[i].w + 1);\n }\n \n // Sort edges by importance (descending)\n sort(edges.begin(), edges.end(), [](const Edge &a, const Edge &b) {\n return a.importance > b.importance;\n });\n \n // Priority queue to keep track of day loads\n priority_queue> pq; // {current_sum, day}\n vector day_sum(D, 0);\n vector day_count(D, 0);\n for (int d = 0; d < D; ++d) {\n pq.push({0, d});\n }\n \n // Assign edges to days, ensuring no day exceeds K edges\n vector> day_edges(D);\n for (auto &e : edges) {\n // Find the day with the smallest current sum that has room for this edge\n vector> candidates;\n while (!pq.empty()) {\n auto [sum, day] = pq.top(); pq.pop();\n if (day_count[day] < K) {\n candidates.push_back({sum, day});\n if (candidates.size() >= 10) break; // Consider top 10 candidates\n }\n }\n // Push back candidates\n for (auto &p : candidates) {\n pq.push(p);\n }\n // Select the day with the smallest sum\n if (candidates.empty()) {\n // All days are full, find the day with the smallest count\n int min_day = 0;\n for (int d = 1; d < D; ++d) {\n if (day_count[d] < day_count[min_day]) {\n min_day = d;\n }\n }\n day_edges[min_day].push_back(e.id);\n day_sum[min_day] += e.importance;\n day_count[min_day]++;\n pq.push({day_sum[min_day], min_day});\n } else {\n auto [sum, day] = candidates[0];\n day_edges[day].push_back(e.id);\n day_sum[day] += e.importance;\n day_count[day]++;\n pq.push({day_sum[day], day});\n }\n }\n \n // Prepare output\n vector res(M);\n for (int d = 0; d < D; ++d) {\n for (int eid : day_edges[d]) {\n res[eid] = d + 1;\n }\n }\n \n // Output the results\n for (int i = 0; i < M; ++i) {\n if (i) cout << \" \";\n cout << res[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Coord {\n int x, y, z;\n};\n\n// Helper function to get a 1D index from 3D coordinates\nint get_idx(int D, int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\n// Generic function to find and mark connected components for a given cell type\nvoid find_and_mark_blocks(\n int D,\n const vector>>& cell_type,\n vector>>& visited,\n vector& b_1,\n vector& b_2,\n int& block_id,\n bool is_shared,\n bool is_u1,\n bool is_u2\n) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (cell_type[x][y][z] && !visited[x][y][z]) {\n queue q;\n q.push({x, y, z});\n visited[x][y][z] = true;\n block_id++;\n int idx = get_idx(D, x, y, z);\n\n if (is_shared) {\n b_1[idx] = block_id;\n b_2[idx] = block_id;\n } else if (is_u1) {\n b_1[idx] = block_id;\n } else if (is_u2) {\n b_2[idx] = block_id;\n }\n\n while (!q.empty()) {\n Coord curr = q.front();\n q.pop();\n\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n\n for (int i = 0; i < 6; ++i) {\n int nx = curr.x + dx[i];\n int ny = curr.y + dy[i];\n int nz = curr.z + dz[i];\n\n if (0 <= nx && nx < D && 0 <= ny && ny < D && 0 <= nz && nz < D) {\n if (cell_type[nx][ny][nz] && !visited[nx][ny][nz]) {\n visited[nx][ny][nz] = true;\n q.push({nx, ny, nz});\n int n_idx = get_idx(D, nx, ny, nz);\n if (is_shared) {\n b_1[n_idx] = block_id;\n b_2[n_idx] = block_id;\n } else if (is_u1) {\n b_1[n_idx] = block_id;\n } else if (is_u2) {\n b_2[n_idx] = block_id;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n\n vector f[2], r[2];\n for (int i = 0; i < 2; ++i) {\n f[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> f[i][j];\n }\n r[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> r[i][j];\n }\n }\n\n // Categorize cells: shared, unique to object 1, unique to object 2\n vector>> is_shared(D, vector>(D, vector(D, false)));\n vector>> is_u1(D, vector>(D, vector(D, false)));\n vector>> is_u2(D, vector>(D, vector(D, false)));\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool in_o1 = (f[0][z][x] == '1' && r[0][z][y] == '1');\n bool in_o2 = (f[1][z][x] == '1' && r[1][z][y] == '1');\n if (in_o1 && in_o2) {\n is_shared[x][y][z] = true;\n } else if (in_o1) {\n is_u1[x][y][z] = true;\n } else if (in_o2) {\n is_u2[x][y][z] = true;\n }\n }\n }\n }\n\n vector b_1(D * D * D, 0);\n vector b_2(D * D * D, 0);\n vector>> visited(D, vector>(D, vector(D, false)));\n int block_id = 0;\n\n // 1. Find shared blocks\n find_and_mark_blocks(D, is_shared, visited, b_1, b_2, block_id, true, false, false);\n\n // 2. Find blocks unique to object 1\n find_and_mark_blocks(D, is_u1, visited, b_1, b_2, block_id, false, true, false);\n\n // 3. Find blocks unique to object 2\n find_and_mark_blocks(D, is_u2, visited, b_1, b_2, block_id, false, false, true);\n\n cout << block_id << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_1[i];\n }\n cout << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_2[i];\n }\n cout << endl;\n\n return 0;\n}","ahc020":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n double x, y;\n Point(double x=0, double y=0) : x(x), y(y) {}\n double dist(const Point& p) const {\n return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));\n }\n int rounded_dist(const Point& p) const {\n return (int)round(dist(p));\n }\n};\n\nstruct Edge {\n int u, v, w, idx;\n double d;\n Edge(int u=0, int v=0, int w=0, double d=0, int idx=0) : u(u), v(v), w(w), d(d), idx(idx) {}\n bool operator<(const Edge& e) const {\n return w < e.w;\n }\n};\n\nstruct DSU {\n vector parent, sz;\n DSU(int n) : parent(n), sz(n, 1) {\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 same(int x, int y) { return find(x) == find(y); }\n bool unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return false;\n if (sz[x] < sz[y]) swap(x, y);\n parent[y] = x;\n sz[x] += sz[y];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n \n vector stations(N);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M);\n for (int j = 0; j < M; ++j) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n double d = stations[u].dist(stations[v]);\n edges[j] = Edge(u, v, w, d, j);\n }\n \n vector residents(K);\n for (int k = 0; k < K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // Precompute distances\n vector> station_resident_dist(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n station_resident_dist[i][k] = stations[i].dist(residents[k]);\n }\n }\n \n vector> station_station_dist(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n station_station_dist[i][j] = stations[i].dist(stations[j]);\n }\n }\n \n // Calculate resident density around each station\n vector resident_density(N, 0);\n vector> nearby_residents(N);\n \n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n double d = station_resident_dist[i][k];\n if (d <= 5000) {\n resident_density[i] += exp(-d / 1000.0);\n nearby_residents[i].push_back(k);\n }\n }\n }\n \n // Initial edge selection with enhanced cost-benefit analysis\n vector edge_used(M, false);\n vector connected(N, false);\n connected[0] = true;\n \n // Phase 1: Connect high-value stations\n vector> station_value;\n for (int i = 1; i < N; ++i) {\n double value = resident_density[i] * 1000.0;\n value -= station_station_dist[0][i] * 0.1;\n station_value.push_back({value, i});\n }\n sort(station_value.rbegin(), station_value.rend());\n \n for (auto &[value, i] : station_value) {\n if (connected[i]) continue;\n \n // Find best connection\n int best_edge = -1;\n double best_score = -1;\n \n for (int j = 0; j < M; ++j) {\n if (edges[j].u == i || edges[j].v == i) {\n int other = edges[j].u == i ? edges[j].v : edges[j].u;\n if (connected[other]) {\n double score = resident_density[i] / (1.0 + edges[j].w * 0.001);\n score -= edges[j].d * 0.0001;\n if (score > best_score) {\n best_score = score;\n best_edge = j;\n }\n }\n }\n }\n \n if (best_edge != -1 && best_score > 0.01) {\n edge_used[best_edge] = true;\n connected[i] = true;\n }\n }\n \n // Phase 2: Build MST for remaining components\n DSU dsu(N);\n for (int i = 0; i < N; ++i) {\n if (connected[i]) dsu.parent[i] = 0;\n }\n \n vector sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end());\n \n for (auto &e : sorted_edges) {\n if (!edge_used[e.idx]) {\n if (dsu.unite(e.u, e.v)) {\n edge_used[e.idx] = true;\n connected[e.u] = connected[e.v] = true;\n }\n }\n }\n \n // Calculate connectivity for all stations\n vector> adj(N);\n for (int j = 0; j < M; ++j) {\n if (edge_used[j]) {\n adj[edges[j].u].push_back(edges[j].v);\n adj[edges[j].v].push_back(edges[j].u);\n }\n }\n \n vector component(N, -1);\n queue q;\n component[0] = 0;\n q.push(0);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : adj[u]) {\n if (component[v] == -1) {\n component[v] = component[u] + 1;\n q.push(v);\n }\n }\n }\n \n // Enhanced power allocation\n vector P(N, 0);\n vector covered(K, false);\n \n // Sort residents by difficulty to cover\n vector> resident_difficulty;\n for (int k = 0; k < K; ++k) {\n double min_dist = 1e9;\n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n min_dist = min(min_dist, station_resident_dist[i][k]);\n }\n }\n resident_difficulty.push_back({min_dist, k});\n }\n sort(resident_difficulty.rbegin(), resident_difficulty.rend());\n \n // Greedy coverage with incremental optimization\n for (auto &[diff, k] : resident_difficulty) {\n if (covered[k]) continue;\n \n int best_station = -1;\n int best_power = 0;\n double best_cost = 1e18;\n \n for (int i = 0; i < N; ++i) {\n if (!connected[i]) continue;\n \n double d = station_resident_dist[i][k];\n if (d > 5000) continue;\n \n int power = max(P[i], (int)ceil(d));\n if (power > 5000) continue;\n \n double cost = power * power - P[i] * P[i];\n \n // Consider additional residents covered\n int additional = 0;\n for (int kk : nearby_residents[i]) {\n if (!covered[kk] && station_resident_dist[i][kk] <= power) {\n additional++;\n }\n }\n \n if (additional > 0) {\n cost /= additional;\n cost += component[i] * 0.1; // Prefer closer stations\n \n if (cost < best_cost) {\n best_cost = cost;\n best_station = i;\n best_power = power;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = best_power;\n for (int kk : nearby_residents[best_station]) {\n if (station_resident_dist[best_station][kk] <= best_power) {\n covered[kk] = true;\n }\n }\n }\n }\n \n // Local search optimization\n for (int iter = 0; iter < 5; ++iter) {\n bool improved = false;\n \n // Try to reduce powers\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] == 0) continue;\n \n vector temp_covered = covered;\n bool can_reduce = true;\n int min_power = 0;\n \n for (int k = 0; k < K; ++k) {\n if (covered[k] && station_resident_dist[i][k] <= P[i] + 0.5) {\n bool covered_by_other = false;\n for (int j = 0; j < N; ++j) {\n if (j != i && P[j] > 0 && station_resident_dist[j][k] <= P[j] + 0.5) {\n covered_by_other = true;\n break;\n }\n }\n if (!covered_by_other) {\n can_reduce = false;\n min_power = max(min_power, (int)ceil(station_resident_dist[i][k]));\n }\n }\n }\n \n if (can_reduce) {\n P[i] = 0;\n improved = true;\n } else if (min_power < P[i]) {\n P[i] = min_power;\n improved = true;\n }\n }\n \n // Try to add beneficial stations\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] > 0) continue;\n \n int best_power = 0;\n double best_ratio = 0;\n \n for (int power = 100; power <= 2000; power += 100) {\n int new_covered = 0;\n for (int k : nearby_residents[i]) {\n if (!covered[k] && station_resident_dist[i][k] <= power) {\n new_covered++;\n }\n }\n \n if (new_covered > 0) {\n double ratio = (double)new_covered / (power * power);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n best_power = power;\n }\n }\n }\n \n if (best_power > 0 && best_ratio > 0.00001) {\n P[i] = best_power;\n for (int k : nearby_residents[i]) {\n if (station_resident_dist[i][k] <= best_power) {\n covered[k] = true;\n }\n }\n improved = true;\n }\n }\n \n if (!improved) break;\n }\n \n // Final coverage check\n covered.assign(K, false);\n for (int i = 0; i < N; ++i) {\n if (P[i] > 0) {\n for (int k = 0; k < K; ++k) {\n if (station_resident_dist[i][k] <= P[i] + 0.5) {\n covered[k] = true;\n }\n }\n }\n }\n \n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n double min_dist = 1e9;\n int best_station = -1;\n \n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n double d = station_resident_dist[i][k];\n if (d < min_dist) {\n min_dist = d;\n best_station = i;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = min(5000, max(P[best_station], (int)ceil(min_dist)));\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; ++j) {\n if (j) cout << \" \";\n cout << (edge_used[j] ? 1 : 0);\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconstexpr int N = 30;\n\n// pyramid values\nint a[N][N];\n// list of operations: x y x' y'\nvector> ops;\n\n// bubble down the element currently at (x,y)\nvoid bubble_down(int x, int y) {\n while (true) {\n int cx = x + 1;\n if (cx >= N) break; // leaf\n int cy_left = y;\n int cy_right = y + 1;\n\n // choose the smaller child\n int child_x = cx, child_y = cy_left;\n int child_val = a[child_x][child_y];\n if (a[cx][cy_right] < child_val) {\n child_y = cy_right;\n child_val = a[cx][cy_right];\n }\n\n // heap condition satisfied?\n if (a[x][y] <= child_val) break;\n\n // perform swap\n ops.push_back({x, y, child_x, child_y});\n swap(a[x][y], a[child_x][child_y]);\n\n // continue from the child position\n x = child_x;\n y = child_y;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // read input\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> a[x][y];\n }\n }\n\n // bottom\u2011up heapify\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n bubble_down(x, y);\n }\n }\n\n // safety check (should always hold)\n assert(ops.size() <= 10000);\n\n // output\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op[0] << \" \" << op[1] << \" \"\n << op[2] << \" \" << op[3] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \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 D, N;\n if (!(cin >> D >> N)) {\n return 0;\n }\n\n const int entrance_r = 0;\n const int entrance_c = (D - 1) / 2;\n\n vector> grid(D, vector(D, 0));\n vector> placeable_cells;\n\n // Mark obstacles\n for (int k = 0; k < N; ++k) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = -1; // -1 for obstacle\n }\n\n // Collect all placeable cells\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (grid[i][j] != -1 && !(i == entrance_r && j == entrance_c)) {\n placeable_cells.emplace_back(i, j);\n }\n }\n }\n\n // Sort placeable cells by distance from entrance, then by coordinates\n // dist(i,j) = i + abs(j - entrance_c)\n auto dist_cmp = [entrance_c](const pair& a, const pair& b) {\n int dist_a = a.first + abs(a.second - entrance_c);\n int dist_b = b.first + abs(b.second - entrance_c);\n if (dist_a != dist_b) {\n return dist_a < dist_b; // Sort by distance ascending\n }\n if (a.first != b.first) {\n return a.first < b.first;\n }\n return a.second < b.second;\n };\n sort(placeable_cells.begin(), placeable_cells.end(), dist_cmp);\n\n int M = placeable_cells.size();\n vector is_taken(M, false);\n\n // --- Placement Phase ---\n for (int d = 0; d < M; ++d) {\n int t;\n cin >> t;\n\n int target_idx = t;\n int offset = 0;\n int chosen_idx = -1;\n\n while (chosen_idx == -1) {\n int check_idx1 = target_idx - offset;\n if (check_idx1 >= 0 && !is_taken[check_idx1]) {\n chosen_idx = check_idx1;\n break;\n }\n int check_idx2 = target_idx + offset;\n if (check_idx2 < M && !is_taken[check_idx2]) {\n chosen_idx = check_idx2;\n break;\n }\n offset++;\n }\n\n auto [r, c] = placeable_cells[chosen_idx];\n grid[r][c] = t;\n is_taken[chosen_idx] = true;\n\n cout << r << \" \" << c << \"\\n\";\n cout.flush();\n }\n\n // --- Retrieval Phase ---\n vector> retrieval_order;\n int remaining = M;\n while (remaining > 0) {\n // BFS to find reachable containers\n vector> visited(D, vector(D, false));\n queue> q;\n q.push({entrance_r, entrance_c});\n visited[entrance_r][entrance_c] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n const int drs[4] = {-1, 1, 0, 0};\n const int dcs[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + drs[k];\n int nc = c + dcs[k];\n\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !visited[nr][nc] && grid[nr][nc] != -1) {\n visited[nr][nc] = true;\n if (grid[nr][nc] > 0) {\n reachable_containers.push_back({nr, nc});\n }\n q.push({nr, nc});\n }\n }\n }\n\n // Find min priority container among reachable\n int min_p = M; // Max priority is M-1\n pair min_coord = {-1, -1};\n for (const auto& coord : reachable_containers) {\n if (grid[coord.first][coord.second] < min_p) {\n min_p = grid[coord.first][coord.second];\n min_coord = coord;\n }\n }\n\n retrieval_order.push_back(min_coord);\n grid[min_coord.first][min_coord.second] = 0; // Mark as empty\n remaining--;\n }\n\n // --- Output Retrieval Order ---\n for (const auto& coord : retrieval_order) {\n cout << coord.first << \" \" << coord.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n }\n }\n // output exactly the same grid\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << grid[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector scores(N, 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n auto compare = [](int a, int b) {\n cout << \"1 1 \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n return res == '>';\n };\n\n // --- Phase 1: Simple Random Comparisons ---\n // Use all queries for learning. Each query gives a win/loss.\n for (int q = 0; q < Q; ++q) {\n int i = rng() % N;\n int j = rng() % N;\n while (i == j) {\n j = rng() % N;\n }\n\n if (compare(i, j)) {\n scores[i] += 2;\n scores[j]--;\n } else {\n scores[i]--;\n scores[j] += 2;\n }\n }\n\n // --- Phase 2: Greedy Partitioning (LPT) ---\n // Sort items by their learned score, descending.\n vector item_ids(N);\n iota(item_ids.begin(), item_ids.end(), 0);\n sort(item_ids.begin(), item_ids.end(), [&](int a, int b) {\n return scores[a] > scores[b];\n });\n\n vector set_weights(D, 0);\n vector assignments(N);\n\n for (int item_id : item_ids) {\n // Find the set with the minimum total score\n auto it = min_element(set_weights.begin(), set_weights.end());\n int set_id = distance(set_weights.begin(), it);\n\n assignments[item_id] = set_id;\n set_weights[set_id] += scores[item_id];\n }\n\n // --- Final Output ---\n for (int i = 0; i < N; ++i) {\n if (i > 0) cout << \" \";\n cout << assignments[i];\n }\n cout << endl;\n}\n\nint main() {\n solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct Box {\n int stack_idx;\n int pos; // position from bottom (0-indexed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int n = 200, m = 10;\n int boxes_per_stack = n / m; // 20\n \n vector> stacks(m);\n vector box_info(n + 1);\n \n // Read input\n for (int i = 0; i < m; i++) {\n stacks[i].resize(boxes_per_stack);\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_info[stacks[i][j]] = {i, j};\n }\n }\n \n vector> operations;\n \n // Process boxes in order\n for (int target = 1; target <= n; target++) {\n int stack_idx = box_info[target].stack_idx;\n int pos = box_info[target].pos;\n \n // Check if box is already at top\n if (pos == stacks[stack_idx].size() - 1) {\n // Just carry it out\n operations.emplace_back(target, 0);\n stacks[stack_idx].pop_back();\n \n // Update positions of remaining boxes in this stack\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n } else {\n // Need to move boxes above it\n // Choose destination stack (prefer empty or small stacks)\n int dest_stack = 0;\n int min_size = stacks[0].size();\n for (int i = 1; i < m; i++) {\n if (stacks[i].size() < min_size) {\n min_size = stacks[i].size();\n dest_stack = i;\n }\n }\n \n // If the smallest stack is the current one, choose the next smallest\n if (dest_stack == stack_idx) {\n for (int i = 0; i < m; i++) {\n if (i != stack_idx && stacks[i].size() <= min_size + 5) {\n dest_stack = i;\n break;\n }\n }\n }\n \n // Move the target box and everything above it\n operations.emplace_back(target, dest_stack + 1); // 1-indexed for output\n \n // Extract the boxes to move\n vector to_move(stacks[stack_idx].begin() + pos, stacks[stack_idx].end());\n stacks[stack_idx].resize(pos);\n \n // Add to destination stack\n stacks[dest_stack].insert(stacks[dest_stack].end(), to_move.begin(), to_move.end());\n \n // Update positions\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n \n // Now carry out the target box (it should be at top of dest_stack)\n operations.emplace_back(target, 0);\n stacks[dest_stack].pop_back();\n \n // Update positions again\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n }\n }\n \n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n \n return 0;\n}","ahc027":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct State {\n int i, j;\n double priority;\n State(int i_, int j_, double p_) : i(i_), j(j_), priority(p_) {}\n bool operator<(const State& other) const {\n return priority < other.priority;\n }\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 }\n \n vector> visited(N, vector(N));\n string route;\n \n // Priority-based DFS\n auto dfs = [&](auto self, int i, int j) -> void {\n visited[i][j] = true;\n \n // Collect neighbors with priorities\n priority_queue pq;\n const int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};\n const string dir_str = \"RDLU\";\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (visited[ni][nj]) continue;\n \n // Check if wall exists\n bool wall = false;\n if (dirs[dir][0] == 0) { // horizontal move\n wall = (v[i][min(j, nj)] == '1');\n } else { // vertical move\n wall = (h[min(i, ni)][j] == '1');\n }\n \n if (!wall) {\n // Priority based on d[i,j] and distance\n double priority = d[ni][nj] * 1.0 / (1.0 + abs(ni - N/2) + abs(nj - N/2));\n pq.emplace(ni, nj, priority);\n }\n }\n \n // Visit neighbors in priority order\n while (!pq.empty()) {\n State s = pq.top();\n pq.pop();\n if (!visited[s.i][s.j]) {\n // Find direction to this neighbor\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n if (ni == s.i && nj == s.j) {\n route += dir_str[dir];\n self(self, ni, nj);\n route += dir_str[(dir + 2) % 4];\n break;\n }\n }\n }\n }\n };\n \n dfs(dfs, 0, 0);\n \n // Add extra cycles around high-value cells\n vector>> high_value_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n high_value_cells.emplace_back(d[i][j], make_pair(i,j));\n }\n }\n sort(high_value_cells.rbegin(), high_value_cells.rend());\n \n // For top high-value cells, try to add small cycles\n int extra_cycles = min(10, (int)high_value_cells.size());\n for (int idx = 0; idx < extra_cycles; idx++) {\n int i = high_value_cells[idx].second.first;\n int j = high_value_cells[idx].second.second;\n \n // Try to find a small loop around this cell\n vector local_route;\n const int dirs[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};\n const string dir_str = \"RDLU\";\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n bool wall = false;\n if (dirs[dir][0] == 0) {\n wall = (v[i][min(j, nj)] == '1');\n } else {\n wall = (h[min(i, ni)][j] == '1');\n }\n \n if (!wall) {\n local_route.push_back(dir_str[dir]);\n // Try to return from opposite direction\n int oi = i + dirs[(dir+2)%4][0];\n int oj = j + dirs[(dir+2)%4][1];\n if (oi >= 0 && oi < N && oj >= 0 && oj < N) {\n bool wall2 = false;\n if (dirs[(dir+2)%4][0] == 0) {\n wall2 = (v[i][min(j, oj)] == '1');\n } else {\n wall2 = (h[min(i, oi)][j] == '1');\n }\n if (!wall2) {\n local_route.push_back(dir_str[(dir+2)%4]);\n if (route.length() + local_route.size() <= 100000) {\n route += local_route[0];\n route += local_route[1];\n }\n break;\n }\n }\n }\n }\n }\n }\n \n cout << route << endl;\n return 0;\n}","ahc028":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Position {\n int i, j;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n int si, sj;\n cin >> N >> M >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n vector targets(M);\n for (int k = 0; k < M; k++) {\n cin >> targets[k];\n }\n \n // Precompute letter positions\n vector> letter_positions(26);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n letter_positions[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n \n // For each position, precompute nearest positions for each character\n vector>> nearest(N, vector>(N, vector(26)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int c = 0; c < 26; c++) {\n int best_dist = INT_MAX;\n Position best_pos = {-1, -1};\n \n for (auto pos : letter_positions[c]) {\n int dist = abs(i - pos.i) + abs(j - pos.j);\n if (dist < best_dist) {\n best_dist = dist;\n best_pos = pos;\n }\n }\n \n nearest[i][j][c] = best_pos;\n }\n }\n }\n \n vector> result;\n result.emplace_back(si, sj);\n \n vector collected(M, false);\n int collected_count = 0;\n \n string current_suffix;\n \n // Greedy collection with overlap detection\n while (collected_count < M && result.size() < 4500) {\n int best_k = -1;\n int best_score = INT_MIN;\n int best_cost = INT_MAX;\n string best_remaining;\n Position best_start = {-1, -1};\n bool use_overlap = false;\n \n int current_i = result.back().first;\n int current_j = result.back().second;\n \n // Check all uncollected strings\n for (int k = 0; k < M; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Check for overlaps with current suffix\n for (int overlap_len = min(4, (int)current_suffix.length()); overlap_len >= 0; overlap_len--) {\n if (current_suffix.length() >= overlap_len) {\n string suffix = current_suffix.substr(current_suffix.length() - overlap_len);\n \n if (target.substr(0, overlap_len) == suffix) {\n string remaining = target.substr(overlap_len);\n \n // Estimate cost to get remaining characters\n int cost = 0;\n Position curr_pos = {current_i, current_j};\n \n for (char c : remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n cost = INT_MAX;\n break;\n }\n cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (cost < best_cost && cost < 100) {\n best_cost = cost;\n best_k = k;\n best_remaining = remaining;\n use_overlap = true;\n best_score = overlap_len * 10 - cost;\n }\n }\n }\n }\n \n // Also consider starting fresh\n char first_char = target[0];\n for (auto pos : letter_positions[first_char - 'A']) {\n int move_cost = abs(current_i - pos.i) + abs(current_j - pos.j) + 1;\n if (move_cost > 50) continue;\n \n // Estimate cost for remaining characters\n int total_cost = move_cost;\n Position curr_pos = pos;\n \n for (int pos_idx = 1; pos_idx < target.length(); pos_idx++) {\n char c = target[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n total_cost = INT_MAX;\n break;\n }\n total_cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (total_cost < best_cost && total_cost < 100) {\n best_cost = total_cost;\n best_k = k;\n best_start = pos;\n use_overlap = false;\n best_remaining = target;\n best_score = -total_cost;\n }\n }\n }\n \n if (best_k == -1) break;\n \n // Execute the chosen action\n if (use_overlap && !best_remaining.empty()) {\n Position curr_pos = {current_i, current_j};\n for (char c : best_remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n } else if (best_start.i != -1) {\n result.emplace_back(best_start.i, best_start.j);\n Position curr_pos = best_start;\n \n for (int pos_idx = 1; pos_idx < best_remaining.length(); pos_idx++) {\n char c = best_remaining[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n }\n \n collected[best_k] = true;\n collected_count++;\n \n // Update current suffix (last up to 4 characters)\n current_suffix = \"\";\n int start_idx = max(0, (int)result.size() - 4);\n for (int i = start_idx; i < result.size(); i++) {\n current_suffix += grid[result[i].first][result[i].second];\n }\n }\n \n // If we still have time, try to collect more strings with simple approach\n while (collected_count < M && result.size() < 4900) {\n bool found = false;\n int current_i = result.back().first;\n int current_j = result.back().second;\n \n for (int k = 0; k < M && !found; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Try to spell this string greedily\n Position curr_pos = {current_i, current_j};\n vector> temp_path;\n bool success = true;\n \n for (char c : target) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n success = false;\n break;\n }\n temp_path.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n }\n \n if (success && result.size() + temp_path.size() < 4900) {\n for (auto pos : temp_path) {\n result.push_back(pos);\n }\n collected[k] = true;\n collected_count++;\n found = true;\n }\n }\n \n if (!found) break;\n }\n \n // Output result\n for (auto [i, j] : result) {\n cout << i << \" \" << j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct OilField {\n int size;\n vector> cells;\n};\n\nstruct Solver {\n int N, M;\n double eps;\n vector fields;\n vector> reserves;\n vector> known;\n vector> estimates;\n int ops_used;\n double total_cost;\n mt19937 rng;\n \n Solver(int N, int M, double eps, const vector& fields) \n : N(N), M(M), eps(eps), fields(fields), ops_used(0), total_cost(0), \n reserves(N, vector(N, -1)), known(N, vector(N, false)),\n estimates(N, vector(N, 0.0)) {\n rng.seed(random_device{}());\n }\n \n void flush() {\n cout << flush;\n }\n \n void query_drill(int i, int j) {\n ops_used++;\n total_cost += 1.0;\n cout << \"q 1 \" << i << \" \" << j << endl;\n flush();\n string resp;\n cin >> resp;\n int val = stoi(resp);\n reserves[i][j] = val;\n known[i][j] = true;\n estimates[i][j] = val;\n }\n \n double query_divine(const vector>& cells) {\n ops_used++;\n int k = cells.size();\n total_cost += 1.0 / sqrt(k);\n cout << \"q \" << k;\n for (auto [i,j] : cells) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush();\n string resp;\n cin >> resp;\n return stod(resp);\n }\n \n bool guess_answer(const vector>& answer) {\n ops_used++;\n total_cost += 1.0;\n cout << \"a \" << answer.size();\n for (auto [i,j] : answer) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush();\n int resp;\n cin >> resp;\n return resp == 1;\n }\n \n vector> get_region_cells(int si, int sj, int ei, int ej) {\n vector> cells;\n for (int i = si; i <= ei; i++) {\n for (int j = sj; j <= ej; j++) {\n cells.emplace_back(i, j);\n }\n }\n return cells;\n }\n \n void initial_coarse_scan() {\n // Use large divine queries to get rough estimates\n int block_size = max(2, N/3);\n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n int ei = min(N-1, bi + block_size - 1);\n int ej = min(N-1, bj + block_size - 1);\n auto cells = get_region_cells(bi, bj, ei, ej);\n if (cells.size() >= 2) {\n double val = query_divine(cells);\n double avg = val / cells.size();\n for (auto [i,j] : cells) {\n estimates[i][j] = avg;\n }\n }\n }\n }\n }\n \n void refine_promising_areas() {\n // Focus on areas with higher estimates\n vector> candidates;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!known[i][j]) {\n candidates.emplace_back(estimates[i][j], i, j);\n }\n }\n }\n sort(candidates.rbegin(), candidates.rend());\n \n int drill_limit = min(N*N/4, (int)candidates.size());\n for (int idx = 0; idx < drill_limit && ops_used < N*N; idx++) {\n auto [_, i, j] = candidates[idx];\n if (!known[i][j]) {\n query_drill(i, j);\n }\n }\n }\n \n bool can_place_field(int field_id, int si, int sj) {\n const auto& field = fields[field_id];\n for (auto [di, dj] : field.cells) {\n int i = si + di, j = sj + dj;\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n }\n return true;\n }\n \n void pattern_matching() {\n // Try to match oil field patterns with known oil locations\n vector> has_oil(N, vector(N, false));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known[i][j] && reserves[i][j] > 0) {\n has_oil[i][j] = true;\n }\n }\n }\n \n // For each known oil location, try to place oil fields\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (has_oil[i][j]) {\n for (int fid = 0; fid < M; fid++) {\n const auto& field = fields[fid];\n // Try different positions where this field could cover (i,j)\n for (auto [di, dj] : field.cells) {\n int si = i - di, sj = j - dj;\n if (can_place_field(fid, si, sj)) {\n // Check if this placement is consistent\n bool consistent = true;\n for (auto [fi, fj] : field.cells) {\n int ti = si + fi, tj = sj + fj;\n if (known[ti][tj] && reserves[ti][tj] == 0) {\n consistent = false;\n break;\n }\n }\n if (consistent) {\n for (auto [fi, fj] : field.cells) {\n int ti = si + fi, tj = sj + fj;\n estimates[ti][tj] = max(estimates[ti][tj], 0.5);\n }\n }\n }\n }\n }\n }\n }\n }\n }\n \n void verify_and_explore() {\n // Drill some uncertain squares based on updated estimates\n vector> uncertain;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!known[i][j]) {\n uncertain.emplace_back(estimates[i][j], i, j);\n }\n }\n }\n sort(uncertain.rbegin(), uncertain.rend());\n \n int verify_limit = min(N*N/6, (int)uncertain.size());\n for (int idx = 0; idx < verify_limit && ops_used < 2*N*N - 10; idx++) {\n auto [_, i, j] = uncertain[idx];\n if (!known[i][j] && estimates[i][j] > 0.1) {\n query_drill(i, j);\n }\n }\n }\n \n vector> get_answer() {\n vector> answer;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known[i][j] && reserves[i][j] > 0) {\n answer.emplace_back(i, j);\n } else if (!known[i][j] && estimates[i][j] > 0.3) {\n answer.emplace_back(i, j);\n }\n }\n }\n return answer;\n }\n \n void solve() {\n initial_coarse_scan();\n refine_promising_areas();\n pattern_matching();\n verify_and_explore();\n \n auto answer = get_answer();\n if (guess_answer(answer)) {\n return;\n }\n \n // If failed, do more drilling and try again\n int remaining_ops = 2*N*N - ops_used;\n for (int i = 0; i < N && remaining_ops > 0; i++) {\n for (int j = 0; j < N && remaining_ops > 0; j++) {\n if (!known[i][j] && estimates[i][j] > 0.2) {\n query_drill(i, j);\n remaining_ops--;\n }\n }\n }\n \n answer = get_answer();\n guess_answer(answer);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n vector fields(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n fields[k].size = d;\n fields[k].cells.resize(d);\n for (int i = 0; i < d; i++) {\n cin >> fields[k].cells[i].first >> fields[k].cells[i].second;\n }\n }\n \n Solver solver(N, M, eps, fields);\n solver.solve();\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n \n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> a[d][k];\n }\n }\n \n // Strategy: Use horizontal strips with proportional heights\n // This is simpler and more robust than vertical strips\n vector prev_heights(N, W / N);\n \n for (int d = 0; d < D; d++) {\n vector heights(N);\n \n // Calculate minimum heights to meet area requirements\n vector min_heights(N);\n int total_min_height = 0;\n for (int k = 0; k < N; k++) {\n min_heights[k] = (a[d][k] + W - 1) / W; // ceil(a[d][k] / W)\n total_min_height += min_heights[k];\n }\n \n if (total_min_height <= W) {\n // We can meet all requirements\n heights = min_heights;\n int remaining = W - total_min_height;\n \n // Distribute remaining space proportionally to area requirements\n double total_area = accumulate(a[d].begin(), a[d].end(), 0.0);\n vector area_ratios(N);\n for (int k = 0; k < N; k++) {\n area_ratios[k] = total_area > 0 ? (double)a[d][k] / total_area : 1.0 / N;\n }\n \n // Sort by area ratio to prioritize larger areas\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return area_ratios[i] > area_ratios[j];\n });\n \n // Distribute remaining space\n for (int i = 0; i < remaining; i++) {\n heights[indices[i % N]]++;\n }\n } else {\n // Need to scale down proportionally\n double scale = (double)W / total_min_height;\n for (int k = 0; k < N; k++) {\n heights[k] = max(1, (int)round(min_heights[k] * scale));\n }\n \n // Adjust to ensure sum equals W\n int current_sum = accumulate(heights.begin(), heights.end(), 0);\n int diff = W - current_sum;\n \n if (diff > 0) {\n // Add to rectangles with largest area requirements\n vector sorted_indices(N);\n iota(sorted_indices.begin(), sorted_indices.end(), 0);\n sort(sorted_indices.begin(), sorted_indices.end(), [&](int i, int j) {\n return a[d][i] > a[d][j];\n });\n \n for (int i = 0; i < diff; i++) {\n heights[sorted_indices[i % N]]++;\n }\n } else if (diff < 0) {\n // Remove from rectangles with smallest area requirements\n vector sorted_indices(N);\n iota(sorted_indices.begin(), sorted_indices.end(), 0);\n sort(sorted_indices.begin(), sorted_indices.end(), [&](int i, int j) {\n return a[d][i] < a[d][j];\n });\n \n for (int i = 0; i < -diff; i++) {\n if (heights[sorted_indices[i % N]] > 1) {\n heights[sorted_indices[i % N]]--;\n }\n }\n }\n }\n \n // Ensure all heights are positive and sum equals W\n for (int k = 0; k < N; k++) {\n heights[k] = max(1, heights[k]);\n }\n \n int current_sum = accumulate(heights.begin(), heights.end(), 0);\n if (current_sum != W) {\n int diff = W - current_sum;\n if (diff > 0) {\n // Add remaining space to first few rectangles\n for (int i = 0; i < diff; i++) {\n heights[i % N]++;\n }\n } else {\n // Remove excess space from last few rectangles\n for (int i = 0; i < -diff; i++) {\n int idx = N - 1 - (i % N);\n if (heights[idx] > 1) {\n heights[idx]--;\n }\n }\n }\n }\n \n // Final verification\n current_sum = accumulate(heights.begin(), heights.end(), 0);\n if (current_sum != W) {\n // Emergency adjustment\n heights[0] += W - current_sum;\n heights[0] = max(1, heights[0]);\n }\n \n // Apply smoothing to reduce partition changes\n if (d > 0) {\n vector smoothed_heights(N);\n for (int k = 0; k < N; k++) {\n smoothed_heights[k] = (int)round(0.7 * heights[k] + 0.3 * prev_heights[k]);\n smoothed_heights[k] = max(1, smoothed_heights[k]);\n }\n \n // Ensure sum equals W after smoothing\n int smoothed_sum = accumulate(smoothed_heights.begin(), smoothed_heights.end(), 0);\n int diff = W - smoothed_sum;\n \n if (diff > 0) {\n for (int i = 0; i < diff; i++) {\n smoothed_heights[i % N]++;\n }\n } else if (diff < 0) {\n for (int i = 0; i < -diff; i++) {\n int idx = N - 1 - (i % N);\n if (smoothed_heights[idx] > 1) {\n smoothed_heights[idx]--;\n }\n }\n }\n \n heights = smoothed_heights;\n }\n \n // Final check\n int final_sum = accumulate(heights.begin(), heights.end(), 0);\n if (final_sum != W) {\n heights[0] += W - final_sum;\n heights[0] = max(1, min(heights[0], W));\n }\n \n // Output rectangles as horizontal strips\n int pos = 0;\n for (int k = 0; k < N; k++) {\n int height = heights[k];\n int end_pos = pos + height;\n // Ensure bounds\n end_pos = min(end_pos, W);\n cout << pos << \" 0 \" << end_pos << \" \" << W << \"\\n\";\n pos = end_pos;\n }\n \n prev_heights = heights;\n }\n \n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nstatic const int MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\n// ---------- board utilities ----------\ninline void addStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int v = board[p + i][q + j] + stamp[m][i][j];\n if (v >= MOD) v -= MOD;\n board[p + i][q + j] = v;\n }\n }\n}\ninline void removeStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int v = board[p + i][q + j] - stamp[m][i][j];\n if (v < 0) v += MOD;\n board[p + i][q + j] = v;\n }\n }\n}\n// profit of applying a stamp on the current board\ninline long long profitStamp(int m, int p, int q,\n const vector>>& stamp,\n const vector>& board)\n{\n long long delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int s = stamp[m][i][j];\n int cur = board[p + i][q + j];\n if (cur + s >= MOD) delta += s - MOD; // overflow \u2192 negative part\n else delta += s;\n }\n }\n return delta;\n}\n\n// ---------- main solving ----------\nint main()\n{\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n vector> a(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> a[i][j];\n\n vector>> stamp(M, vector>(3, vector(3)));\n for (int m = 0; m < M; ++m)\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) cin >> stamp[m][i][j];\n\n const int POS = N - 2; // 7\n vector> positions;\n positions.reserve(POS * POS);\n for (int p = 0; p < POS; ++p)\n for (int q = 0; q < POS; ++q)\n positions.emplace_back(p, q);\n\n mt19937 rng(random_device{}());\n\n vector bestOps;\n long long bestScore = 0;\n for (auto& row : a) bestScore += row[0];\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) bestScore += a[i][j]; // initial score\n\n const int ATTEMPTS = 5;\n const int LS_ITER = 2000;\n\n for (int attempt = 0; attempt < ATTEMPTS; ++attempt) {\n // start from the initial board\n vector> board = a;\n vector ops;\n\n // ---- greedy phase ----\n for (int step = 0; step < K; ++step) {\n long long bestDelta = LLONG_MIN;\n Op bestOp{-1, -1, -1};\n\n // random order of stamps and positions for diversity\n vector stampIdx(M);\n iota(stampIdx.begin(), stampIdx.end(), 0);\n shuffle(stampIdx.begin(), stampIdx.end(), rng);\n vector> posShuffle = positions;\n shuffle(posShuffle.begin(), posShuffle.end(), rng);\n\n for (int m : stampIdx) {\n for (auto [p, q] : posShuffle) {\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestOp = {m, p, q};\n }\n }\n }\n if (bestDelta <= 0) break; // no improving operation left\n addStamp(bestOp.m, bestOp.p, bestOp.q, stamp, board);\n ops.push_back(bestOp);\n }\n\n // ---- hill climbing ----\n for (int iter = 0; iter < LS_ITER; ++iter) {\n int choice = rng() % 100;\n if (ops.size() < K && choice < 20) { // try to add\n int m = rng() % M;\n int p = rng() % POS;\n int q = rng() % POS;\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > 0) {\n addStamp(m, p, q, stamp, board);\n ops.emplace_back(m, p, q);\n }\n } else if (!ops.empty() && choice < 30) { // try to remove\n int idx = rng() % ops.size();\n Op cur = ops[idx];\n long long delta = profitStamp(cur.m, cur.p, cur.q, stamp, board);\n if (delta < 0) {\n removeStamp(cur.m, cur.p, cur.q, stamp, board);\n ops.erase(ops.begin() + idx);\n }\n } else { // try to replace\n if (ops.empty()) continue;\n int idx = rng() % ops.size();\n Op cur = ops[idx];\n long long deltaOld = profitStamp(cur.m, cur.p, cur.q, stamp, board);\n int m2 = rng() % M;\n int p2 = rng() % POS;\n int q2 = rng() % POS;\n long long deltaNew = profitStamp(m2, p2, q2, stamp, board);\n if (deltaNew > deltaOld) {\n removeStamp(cur.m, cur.p, cur.q, stamp, board);\n addStamp(m2, p2, q2, stamp, board);\n ops[idx] = {m2, p2, q2};\n }\n }\n }\n\n // evaluate this run\n long long curScore = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) curScore += board[i][j];\n if (curScore > bestScore) {\n bestScore = curScore;\n bestOps = ops;\n }\n }\n\n // ---- output ----\n cout << bestOps.size() << \"\\n\";\n for (auto op : bestOps) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Container {\n int id;\n int arrival_row;\n int arrival_index;\n int target_row;\n int dispatch_order;\n};\n\nstruct Crane {\n int row, col;\n bool carrying;\n int container_id;\n vector commands;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 5;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n // Determine which gate each container should go to\n vector containers(N * N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container_id = A[i][j];\n containers[container_id].id = container_id;\n containers[container_id].arrival_row = i;\n containers[container_id].arrival_index = j;\n containers[container_id].target_row = container_id / N;\n containers[container_id].dispatch_order = container_id % N;\n }\n }\n \n // Sort containers by target gate, then by dispatch order\n sort(containers.begin(), containers.end(), [](const Container& a, const Container& b) {\n if (a.target_row != b.target_row) return a.target_row < b.target_row;\n return a.dispatch_order < b.dispatch_order;\n });\n \n // Initialize cranes\n vector cranes(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].carrying = false;\n cranes[i].container_id = -1;\n }\n \n // Large crane (index 0) will do most of the work\n Crane& large_crane = cranes[0];\n \n // Process containers one by one\n for (const auto& container : containers) {\n // Move large crane to the arrival position\n while (large_crane.row != container.arrival_row) {\n if (large_crane.row < container.arrival_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != container.arrival_index) {\n if (large_crane.col < container.arrival_index) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n } else {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Pick up the container\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to the dispatch position\n while (large_crane.row != container.target_row) {\n if (large_crane.row < container.target_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != N - 1) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n }\n \n // Release the container\n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n // Move back to starting position for next container\n while (large_crane.row != 0) {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n while (large_crane.col != 0) {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Small cranes do minimal work - just stay in place\n for (int i = 1; i < N; i++) {\n // Small cranes can help clear paths by moving away if needed\n // For simplicity, just make them wait\n int max_len = large_crane.commands.size();\n cranes[i].commands.resize(max_len, '.');\n }\n \n // Output the commands\n int max_len = 0;\n for (const auto& crane : cranes) {\n max_len = max(max_len, (int)crane.commands.size());\n }\n \n // Ensure all command strings have the same length\n for (auto& crane : cranes) {\n while (crane.commands.size() < max_len) {\n crane.commands.push_back('.');\n }\n }\n \n for (const auto& crane : cranes) {\n string s(crane.commands.begin(), crane.commands.end());\n cout << s << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int i, j, height;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 20;\n vector> h(N, vector(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n \n vector positive, negative;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n positive.push_back({i, j, h[i][j]});\n } else if (h[i][j] < 0) {\n negative.push_back({i, j, -h[i][j]});\n }\n }\n }\n \n vector operations;\n int ci = 0, cj = 0;\n \n // Calculate Manhattan distance\n auto dist = [&](const Cell& a, const Cell& b) {\n return abs(a.i - b.i) + abs(a.j - b.j);\n };\n \n // Improved greedy with batching consideration\n while (!positive.empty() && !negative.empty()) {\n // Find best batch transport\n double best_ratio = -1;\n size_t best_pi = 0, best_ni = 0;\n \n for (size_t pi = 0; pi < positive.size(); pi++) {\n for (size_t ni = 0; ni < negative.size(); ni++) {\n int distance = dist(positive[pi], negative[ni]);\n if (distance == 0) continue;\n \n int amount = min(positive[pi].height, negative[ni].height);\n \n // Calculate total cost\n int empty_travel = dist({ci, cj, 0}, positive[pi]);\n int loaded_travel = distance;\n int load_cost = amount;\n int unload_cost = amount;\n int total_cost = 100 * empty_travel + (100 + amount) * loaded_travel + load_cost + unload_cost;\n \n double ratio = (double)amount / total_cost;\n \n if (ratio > best_ratio) {\n best_ratio = ratio;\n best_pi = pi;\n best_ni = ni;\n }\n }\n }\n \n if (best_ratio < 0) break;\n \n Cell& pos = positive[best_pi];\n Cell& neg = negative[best_ni];\n \n // Move to positive cell\n while (ci != pos.i || cj != pos.j) {\n if (ci > pos.i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < pos.i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > pos.j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < pos.j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n \n // Load maximum possible\n int load_amount = min(pos.height, neg.height);\n operations.push_back(\"+\" + to_string(load_amount));\n pos.height -= load_amount;\n neg.height -= load_amount;\n \n // Move to negative cell\n while (ci != neg.i || cj != neg.j) {\n if (ci > neg.i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < neg.i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > neg.j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < neg.j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n \n // Unload\n operations.push_back(\"-\" + to_string(load_amount));\n \n // Remove completed cells\n if (pos.height == 0) {\n positive.erase(positive.begin() + best_pi);\n }\n if (neg.height == 0) {\n negative.erase(negative.begin() + best_ni);\n }\n }\n \n // Handle any remaining cells (should be minimal)\n for (size_t pi = 0; pi < positive.size(); pi++) {\n if (positive[pi].height > 0) {\n while (ci != positive[pi].i || cj != positive[pi].j) {\n if (ci > positive[pi].i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < positive[pi].i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > positive[pi].j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < positive[pi].j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n operations.push_back(\"+\" + to_string(positive[pi].height));\n operations.push_back(\"-\" + to_string(positive[pi].height));\n }\n }\n \n for (size_t ni = 0; ni < negative.size(); ni++) {\n if (negative[ni].height > 0) {\n while (ci != negative[ni].i || cj != negative[ni].j) {\n if (ci > negative[ni].i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < negative[ni].i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > negative[ni].j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < negative[ni].j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n operations.push_back(\"+\" + to_string(negative[ni].height));\n operations.push_back(\"-\" + to_string(negative[ni].height));\n }\n }\n \n // Output operations\n for (const string& op : operations) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n vector values;\n int total_value;\n double score;\n int id;\n vector normalized_values;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, T;\n cin >> N >> M >> T;\n \n const int SEED_COUNT = 2 * N * (N - 1);\n vector seeds(SEED_COUNT);\n \n // Read initial seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].id = i;\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Calculate max values for each criterion\n vector max_criterion(M, 0);\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n \n for (int turn = 0; turn < T; turn++) {\n // Calculate normalized values for each seed\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].normalized_values.resize(M);\n for (int j = 0; j < M; j++) {\n if (max_criterion[j] > 0) {\n seeds[i].normalized_values[j] = (double)seeds[i].values[j] / max_criterion[j];\n } else {\n seeds[i].normalized_values[j] = 0;\n }\n }\n }\n \n // Calculate comprehensive scores\n for (int i = 0; i < SEED_COUNT; i++) {\n // Base score: total value\n double base_score = seeds[i].total_value;\n \n // Specialization bonus: how many criteria is this seed excellent at?\n int excellent_count = 0;\n double specialization_bonus = 0;\n for (int j = 0; j < M; j++) {\n double norm = seeds[i].normalized_values[j];\n if (norm > 0.9) {\n excellent_count++;\n specialization_bonus += 300;\n } else if (norm > 0.8) {\n specialization_bonus += 150;\n } else if (norm > 0.6) {\n specialization_bonus += 50;\n }\n }\n \n // Exponential bonus for multiple excellent criteria\n if (excellent_count >= 4) {\n specialization_bonus *= 3.0;\n } else if (excellent_count >= 3) {\n specialization_bonus *= 2.0;\n } else if (excellent_count >= 2) {\n specialization_bonus *= 1.5;\n }\n \n // Balance score: how well-rounded is the seed?\n double balance_score = 0;\n double min_norm = 1.0;\n for (int j = 0; j < M; j++) {\n min_norm = min(min_norm, seeds[i].normalized_values[j]);\n }\n balance_score = min_norm * 100;\n \n // Turn-based weighting\n double turn_weight = 1.0;\n if (turn >= T - 3) {\n turn_weight = 1.5; // Final turns: prioritize strength\n } else if (turn < 3) {\n turn_weight = 0.9; // Early turns: slightly less aggressive\n }\n \n seeds[i].score = (base_score * 0.5 + specialization_bonus * 0.4 + balance_score * 0.1) * turn_weight;\n }\n \n // Sort seeds by score\n sort(seeds.begin(), seeds.end(), [](const Seed& a, const Seed& b) {\n return a.score > b.score;\n });\n \n // Select seeds with smart diversity\n vector selected_ids;\n selected_ids.push_back(seeds[0].id); // Always include the best\n \n // Add seeds while maintaining some diversity\n for (int i = 1; i < min(45, SEED_COUNT) && selected_ids.size() < N * N; i++) {\n bool too_similar = false;\n int similar_count = 0;\n \n for (int selected_id : selected_ids) {\n // Calculate similarity\n double similarity = 0;\n for (int j = 0; j < M; j++) {\n double diff = abs(seeds[i].normalized_values[j] - seeds[selected_id].normalized_values[j]);\n similarity += (1.0 - diff);\n }\n similarity /= M;\n \n if (similarity > 0.85) {\n similar_count++;\n if (similar_count >= 2) {\n too_similar = true;\n break;\n }\n }\n }\n \n // Include if not too similar or if we need more seeds\n if (!too_similar || selected_ids.size() < N * N * 0.7) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n \n // Fill remaining slots\n while (selected_ids.size() < N * N) {\n for (int i = 0; i < SEED_COUNT && selected_ids.size() < N * N; i++) {\n if (find(selected_ids.begin(), selected_ids.end(), seeds[i].id) == selected_ids.end()) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n }\n \n // Try multiple placement strategies and pick the best\n vector> best_grid(N, vector(N));\n double best_score = -1;\n \n // Strategy 1: Concentric circles from center\n vector> grid1(N, vector(N));\n vector> positions1;\n int center = N / 2;\n for (int radius = 0; radius <= 3; radius++) {\n for (int i = max(0, center - radius); i <= min(N - 1, center + radius); i++) {\n for (int j = max(0, center - radius); j <= min(N - 1, center + radius); j++) {\n if (abs(i - center) == radius || abs(j - center) == radius) {\n positions1.emplace_back(i, j);\n }\n }\n }\n }\n \n // Strategy 2: Checkerboard pattern\n vector> grid2(N, vector(N));\n vector> positions2;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 0) {\n positions2.emplace_back(i, j);\n }\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 1) {\n positions2.emplace_back(i, j);\n }\n }\n }\n \n // Strategy 3: Horizontal stripes\n vector> grid3(N, vector(N));\n vector> positions3;\n for (int i = 0; i < N; i += 2) {\n for (int j = 0; j < N; j++) {\n positions3.emplace_back(i, j);\n }\n }\n for (int i = 1; i < N; i += 2) {\n for (int j = 0; j < N; j++) {\n positions3.emplace_back(i, j);\n }\n }\n \n // Evaluate each strategy\n vector>> strategies = {positions1, positions2, positions3};\n vector>> grids = {grid1, grid2, grid3};\n \n for (int strategy = 0; strategy < 3; strategy++) {\n // Sort selected seeds by score for this strategy\n vector> seed_scores;\n for (int id : selected_ids) {\n seed_scores.emplace_back(seeds[id].score, id);\n }\n sort(seed_scores.rbegin(), seed_scores.rend());\n \n // Place seeds\n for (size_t i = 0; i < strategies[strategy].size() && i < seed_scores.size(); i++) {\n int row = strategies[strategy][i].first;\n int col = strategies[strategy][i].second;\n grids[strategy][row][col] = seed_scores[i].second;\n }\n \n // Calculate strategy score (adjacent strong pairs)\n double strategy_score = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int id = grids[strategy][i][j];\n if (i > 0) {\n int neighbor_id = grids[strategy][i-1][j];\n strategy_score += (seeds[id].score + seeds[neighbor_id].score) * 0.5;\n }\n if (j > 0) {\n int neighbor_id = grids[strategy][i][j-1];\n strategy_score += (seeds[id].score + seeds[neighbor_id].score) * 0.5;\n }\n }\n }\n \n if (strategy_score > best_score) {\n best_score = strategy_score;\n best_grid = grids[strategy];\n }\n }\n \n // Output best grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (j > 0) cout << \" \";\n cout << best_grid[i][j];\n }\n cout << \"\\n\";\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Update max criteria\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n }\n \n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n int manhattan(const Point& other) const {\n return abs(x - other.x) + abs(y - other.y);\n }\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector s_grid, t_grid;\n vector initial_pos, target_pos;\n vector tree;\n Point root_pos;\n int V_used;\n \n // State tracking\n vector vertex_positions;\n vector edge_directions; // 0=right, 1=down, 2=left, 3=up\n vector holding_takoyaki;\n \n // Task assignment\n vector> fingertip_paths;\n vector path_progress;\n vector assigned_takoyaki;\n \n bool is_valid_position(const Point& p) const {\n return p.x >= 0 && p.x < N && p.y >= 0 && p.y < N;\n }\n \n bool are_all_vertices_in_bounds() const {\n for (const auto& pos : vertex_positions) {\n if (!is_valid_position(pos)) return false;\n }\n return true;\n }\n \n bool validate_tree() const {\n // Check parent constraints\n for (int i = 1; i < V_used; i++) {\n if (tree[i].parent < 0 || tree[i].parent >= i) return false;\n if (tree[i].length < 1 || tree[i].length >= N) return false;\n }\n \n // Check tree connectivity\n vector visited(V_used, false);\n queue q;\n q.push(0);\n visited[0] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : tree[u].children) {\n if (!visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n \n for (bool v : visited) {\n if (!v) return false;\n }\n \n return true;\n }\n \npublic:\n RoboticArmSolver(int N, int M, int V, const vector& s, const vector& t) \n : N(N), M(M), V(V), s_grid(s), t_grid(t) {\n // Extract initial and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (s[i][j] == '1') initial_pos.emplace_back(i, j);\n if (t[i][j] == '1') target_pos.emplace_back(i, j);\n }\n }\n }\n \n void design_arm() {\n V_used = min(V, 6); // Conservative number of vertices\n tree.resize(V_used);\n \n // Root\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Ensure minimum edge length of 1\n int edge_length = max(1, min(N / 4, 3));\n \n // Create simple and safe structure\n if (V_used == 2) {\n // Just one edge\n tree[1].parent = 0;\n tree[1].length = edge_length;\n tree[1].is_leaf = true;\n tree[0].children.push_back(1);\n } else if (V_used <= 4) {\n // Simple line\n for (int i = 1; i < V_used; i++) {\n tree[i].parent = i - 1;\n tree[i].length = edge_length;\n tree[i].is_leaf = (i == V_used - 1);\n tree[i - 1].children.push_back(i);\n }\n } else {\n // Star with short branches\n int num_branches = min(3, V_used - 1);\n \n for (int i = 1; i <= num_branches; i++) {\n tree[i].parent = 0;\n tree[i].length = edge_length;\n tree[i].is_leaf = false;\n tree[0].children.push_back(i);\n }\n \n // Add fingertips\n int vertex = num_branches + 1;\n for (int parent = 1; parent <= num_branches && vertex < V_used; parent++) {\n tree[vertex].parent = parent;\n tree[vertex].length = 1; // Minimum length for safety\n tree[vertex].is_leaf = true;\n tree[parent].children.push_back(vertex);\n vertex++;\n }\n }\n \n // Validate tree\n if (!validate_tree()) {\n // Fallback to minimal valid tree\n V_used = 2;\n tree.resize(2);\n tree[0] = {-1, 0, {1}, false};\n tree[1] = {0, 1, {}, true};\n }\n \n // Find safe root position\n bool found_safe = false;\n root_pos = Point(N / 2, N / 2);\n \n // Try positions ensuring arm stays in bounds\n for (int rx = max(1, N/2 - 2); rx <= min(N-2, N/2 + 2) && !found_safe; rx++) {\n for (int ry = max(1, N/2 - 2); ry <= min(N-2, N/2 + 2) && !found_safe; ry++) {\n root_pos = Point(rx, ry);\n vertex_positions.resize(V_used);\n edge_directions.assign(V_used, 0);\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n found_safe = true;\n }\n }\n }\n \n // Initialize state\n holding_takoyaki.assign(V_used, false);\n assigned_takoyaki.assign(M, -1);\n }\n \n void update_positions() {\n vertex_positions[0] = root_pos;\n \n for (int i = 1; i < V_used; i++) {\n int parent = tree[i].parent;\n int dir = edge_directions[i];\n int dx[4] = {0, 1, 0, -1}; // right, down, left, up\n int dy[4] = {1, 0, -1, 0};\n \n vertex_positions[i].x = vertex_positions[parent].x + dx[dir] * tree[i].length;\n vertex_positions[i].y = vertex_positions[parent].y + dy[dir] * tree[i].length;\n }\n }\n \n void print_design() {\n cout << V_used << endl;\n for (int i = 1; i < V_used; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n cout << root_pos.x << \" \" << root_pos.y << endl;\n }\n \n void assign_tasks() {\n // Get list of fingertips\n vector fingertips;\n for (int i = 1; i < V_used; i++) {\n if (tree[i].is_leaf) fingertips.push_back(i);\n }\n \n if (fingertips.empty()) return;\n \n // Simple assignment\n vector used_initial(M, false);\n vector used_fingertips(fingertips.size(), false);\n \n fingertip_paths.resize(fingertips.size());\n path_progress.assign(fingertips.size(), 0);\n \n for (int k = 0; k < min(M, (int)fingertips.size()); k++) {\n int best_i = -1, best_j = -1;\n int min_dist = INT_MAX;\n \n for (int i = 0; i < M; i++) {\n if (!used_initial[i]) {\n for (int j = 0; j < fingertips.size(); j++) {\n if (!used_fingertips[j]) {\n int dist = vertex_positions[fingertips[j]].manhattan(initial_pos[i]);\n if (dist < min_dist) {\n min_dist = dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n }\n \n if (best_i != -1 && best_j != -1) {\n used_initial[best_i] = true;\n used_fingertips[best_j] = true;\n assigned_takoyaki[best_i] = fingertips[best_j];\n \n // Create path\n vector path;\n Point current = vertex_positions[fingertips[best_j]];\n Point target = initial_pos[best_i];\n \n // Move to initial position\n while (current != target) {\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n path.push_back(current);\n }\n path.push_back(target); // Pickup\n \n // Move to target position\n current = target;\n target = target_pos[best_i];\n while (current != target) {\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n path.push_back(current);\n }\n path.push_back(target); // Dropoff\n \n fingertip_paths[best_j] = path;\n }\n }\n }\n \n string generate_operation() {\n string op(2 * V_used, '.');\n \n // Find fingertip that needs to move\n int urgent_fingertip = -1;\n int urgent_path_idx = -1;\n \n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (!fingertip_paths[i].empty() && \n path_progress[i] < fingertip_paths[i].size()) {\n urgent_fingertip = assigned_takoyaki[i];\n urgent_path_idx = i;\n break;\n }\n }\n \n if (urgent_fingertip == -1) return op;\n \n Point target = fingertip_paths[urgent_path_idx][path_progress[urgent_path_idx]];\n Point current = vertex_positions[urgent_fingertip];\n \n // Check if at target\n if (current == target) {\n // Handle pickup/dropoff\n if (path_progress[urgent_path_idx] == 0) {\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = true;\n } else if (path_progress[urgent_path_idx] == fingertip_paths[urgent_path_idx].size() - 1) {\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = false;\n }\n path_progress[urgent_path_idx]++;\n return op;\n }\n \n // Try safe movements\n int best_dist = current.manhattan(target);\n \n // Try root movements\n int dx[4] = {-1, 1, 0, 0}; // U, D, L, R\n int dy[4] = {0, 0, -1, 1};\n char moves[4] = {'U', 'D', 'L', 'R'};\n \n for (int d = 0; d < 4; d++) {\n Point new_root(root_pos.x + dx[d], root_pos.y + dy[d]);\n if (!is_valid_position(new_root)) continue;\n \n Point old_root = root_pos;\n root_pos = new_root;\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n op[0] = moves[d];\n return op;\n }\n }\n \n root_pos = old_root;\n update_positions();\n }\n \n // Try rotation\n for (int r = 1; r <= 2; r++) {\n int old_dir = edge_directions[urgent_fingertip];\n edge_directions[urgent_fingertip] = (old_dir + (r == 1 ? 3 : 1)) % 4;\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n op[urgent_fingertip] = (r == 1) ? 'L' : 'R';\n return op;\n }\n }\n \n edge_directions[urgent_fingertip] = old_dir;\n update_positions();\n }\n \n return op;\n }\n \n void execute_operations() {\n assign_tasks();\n \n bool all_complete = false;\n int max_turns = 5000; // Conservative limit\n \n while (!all_complete && max_turns-- > 0) {\n string op = generate_operation();\n cout << op << endl;\n \n // Check completion\n all_complete = true;\n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (path_progress[i] < fingertip_paths[i].size()) {\n all_complete = false;\n break;\n }\n }\n }\n }\n \n void solve() {\n design_arm();\n print_design();\n execute_operations();\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M, V;\n cin >> N >> M >> V;\n \n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n \n RoboticArmSolver solver(N, M, V, s, t);\n solver.solve();\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n bool is_mackerel;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n cin >> points[i].x >> points[i].y;\n points[i].is_mackerel = (i < N);\n }\n \n auto count_in_rectangle = [&](int x1, int x2, int y1, int y2) {\n int a = 0, b = 0;\n for (const auto& p : points) {\n if (p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2) {\n if (p.is_mackerel) a++;\n else b++;\n }\n }\n return make_pair(a, b);\n };\n \n int best_diff = -1;\n int best_x1 = -1, best_y1 = -1, best_x2 = -1, best_y2 = -1;\n \n // Try larger initial rectangles around each mackerel\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n for (int size = 10; size <= 50; size += 10) {\n int x1 = max(0, p.x - size);\n int x2 = min(100000, p.x + size);\n int y1 = max(0, p.y - size);\n int y2 = min(100000, p.y + size);\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n int diff = a - b;\n if (diff > best_diff) {\n best_diff = diff;\n best_x1 = x1; best_y1 = y1; best_x2 = x2; best_y2 = y2;\n }\n }\n }\n \n if (best_diff <= 0) {\n // Try to find a rectangle with at least one mackerel and zero sardines\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n int x1 = p.x;\n int x2 = p.x;\n int y1 = p.y;\n int y2 = p.y;\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n if (a > 0 && b == 0) {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 + 1 << \" \" << y1 << \"\\n\";\n cout << x2 + 1 << \" \" << y2 + 1 << \"\\n\";\n cout << x1 << \" \" << y2 + 1 << \"\\n\";\n return 0;\n }\n }\n // Fallback to minimal polygon\n for (const auto& p : points) {\n if (p.is_mackerel) {\n int x = p.x;\n int y = p.y;\n cout << 4 << \"\\n\";\n cout << x << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y + 1 << \"\\n\";\n cout << x << \" \" << y + 1 << \"\\n\";\n return 0;\n }\n }\n }\n \n // Expand the best rectangle with dynamic steps\n bool improved = true;\n while (improved) {\n improved = false;\n int current_diff = best_diff;\n // Try expanding in all directions with dynamic steps\n vector> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (auto [dx, dy] : directions) {\n int step = 10;\n while (step >= 1) {\n int new_x1 = best_x1, new_x2 = best_x2, new_y1 = best_y1, new_y2 = best_y2;\n if (dx == -1) new_x1 = max(0, best_x1 - step);\n else if (dx == 1) new_x2 = min(100000, best_x2 + step);\n else if (dy == -1) new_y1 = max(0, best_y1 - step);\n else if (dy == 1) new_y2 = min(100000, best_y2 + step);\n auto [a, b] = count_in_rectangle(new_x1, new_x2, new_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1; best_y1 = new_y1; best_x2 = new_x2; best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n break;\n }\n step /= 2;\n }\n if (improved) break;\n }\n }\n \n // Output the rectangle as a polygon\n cout << 4 << \"\\n\";\n cout << best_x1 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y2 << \"\\n\";\n cout << best_x1 << \" \" << best_y2 << \"\\n\";\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n long long w, h;\n int p, r, b;\n char d;\n};\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, T;\n long long sigma;\n cin >> N >> T >> sigma;\n\n vector w_prime(N), h_prime(N);\n for (int i = 0; i < N; ++i) {\n cin >> w_prime[i] >> h_prime[i];\n }\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n const int NUM_HEURISTICS = 6;\n\n for (int t = 0; t < T; ++t) {\n int heuristic_type = t % NUM_HEURISTICS;\n \n cerr << \"Turn \" << t << \", Heuristic \" << heuristic_type << endl;\n cout << \"# Turn \" << t << \", Heuristic \" << heuristic_type << endl;\n\n vector placements;\n vector> skyline; // (x, height) points\n\n for (int i = 0; i < N; ++i) {\n Rect dims1 = {w_prime[i], h_prime[i]};\n Rect dims2 = {h_prime[i], w_prime[i]};\n\n Placement best_placement;\n long long best_score = 4e18;\n\n auto evaluate_and_update = [&](const Rect& dims, int r) {\n // Try placing Left (extending width)\n long long current_w = 0, current_h = 0;\n if (!placements.empty()) {\n for(const auto& p : placements) {\n current_w = max(current_w, p.w);\n current_h = max(current_h, p.h);\n }\n }\n long long new_w_L = current_w + dims.w;\n long long new_h_L = max(current_h, dims.h);\n long long score_L = 0;\n \n if (heuristic_type == 0) score_L = new_w_L + new_h_L;\n else if (heuristic_type == 1) score_L = new_w_L * new_h_L;\n else if (heuristic_type == 2) score_L = new_w_L;\n else if (heuristic_type == 3) score_L = new_h_L;\n else if (heuristic_type == 4) score_L = (new_w_L + new_h_L) * (dims.w + dims.h);\n else score_L = new_w_L + new_h_L + (rng() % 10000);\n \n if (score_L < best_score) {\n best_score = score_L;\n best_placement = {new_w_L, new_h_L, i, r, -1, 'L'};\n }\n\n // Try placing Up (extending height)\n long long new_w_U = max(current_w, dims.w);\n long long new_h_U = current_h + dims.h;\n long long score_U = 0;\n\n if (heuristic_type == 0) score_U = new_w_U + new_h_U;\n else if (heuristic_type == 1) score_U = new_w_U * new_h_U;\n else if (heuristic_type == 2) score_U = new_w_U;\n else if (heuristic_type == 3) score_U = new_h_U;\n else if (heuristic_type == 4) score_U = (new_w_U + new_h_U) * (dims.w + dims.h);\n else score_U = new_w_U + new_h_U + (rng() % 10000);\n\n if (score_U < best_score) {\n best_score = score_U;\n best_placement = {new_w_U, new_h_U, i, r, -1, 'U'};\n }\n };\n\n if (heuristic_type != 5) {\n if (heuristic_type % 2 == 0) { // Try original orientation first\n evaluate_and_update(dims1, 0);\n evaluate_and_update(dims2, 1);\n } else { // Try rotated orientation first\n evaluate_and_update(dims2, 1);\n evaluate_and_update(dims1, 0);\n }\n } else { // More complex placement for heuristic 5\n // Sort rectangles by area for this turn\n vector> item_areas;\n for(int j = 0; j < N; ++j) {\n item_areas.push_back({j, w_prime[j] * h_prime[j]});\n }\n sort(item_areas.begin(), item_areas.end(), [](const auto& a, const auto& b){ return a.second > b.second; });\n \n // Find the rank of the current item\n int rank = 0;\n for(; rank < N; ++rank) if(item_areas[rank].first == i) break;\n\n // Large rectangles (first 1/3) are placed to make a base\n if (rank < N / 3) {\n evaluate_and_update(dims1, 0);\n evaluate_and_update(dims2, 1);\n } else { // Smaller rectangles can be placed more flexibly\n long long current_w = 0, current_h = 0;\n if (!placements.empty()) {\n for(const auto& p : placements) {\n current_w = max(current_w, p.w);\n current_h = max(current_h, p.h);\n }\n }\n // Try to fit in the \"gap\" if possible (simplified skyline check)\n // This is a very simplified version of a true skyline fit\n long long min_h_L = current_h;\n if(dims1.h < current_h) {\n long long score = current_w + dims1.w;\n if (score < best_score) {\n best_score = score;\n best_placement = {current_w + dims1.w, current_h, i, 0, -1, 'L'};\n }\n }\n if(dims2.h < current_h) {\n long long score = current_w + dims2.w;\n if (score < best_score) {\n best_score = score;\n best_placement = {current_w + dims2.w, current_h, i, 1, -1, 'L'};\n }\n }\n // If no good gap, fall back to standard greedy\n if(best_score == 4e18) {\n evaluate_and_update(dims1, 0);\n evaluate_and_update(dims2, 1);\n }\n }\n }\n \n placements.push_back(best_placement);\n }\n\n cout << N << \"\\n\";\n for (const auto& cmd : placements) {\n cout << cmd.p << \" \" << cmd.r << \" \" << cmd.d << \" \" << cmd.b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc041":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Vertex {\n int x, y;\n int beauty;\n vector neighbors;\n int parent;\n int depth;\n int tree_id;\n bool assigned;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].beauty;\n }\n \n // Store edges for validation\n set> edge_set;\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n vertices[u].neighbors.push_back(v);\n vertices[v].neighbors.push_back(u);\n edge_set.insert({min(u, v), max(u, v)});\n }\n \n for (int i = 0; i < N; i++) {\n cin >> vertices[i].x >> vertices[i].y;\n }\n \n // Initialize\n for (int i = 0; i < N; i++) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = -1;\n vertices[i].assigned = false;\n }\n \n // Sort vertices by beauty (ascending) for root selection\n vector sorted_by_beauty(N);\n iota(sorted_by_beauty.begin(), sorted_by_beauty.end(), 0);\n sort(sorted_by_beauty.begin(), sorted_by_beauty.end(), \n [&](int a, int b) { return vertices[a].beauty < vertices[b].beauty; });\n \n // Select roots (approximately N/20 roots)\n int num_roots = max(1, N / 20);\n vector roots;\n vector is_root(N, false);\n \n for (int i = 0; i < num_roots && i < N; i++) {\n int v = sorted_by_beauty[i];\n // Check distance from existing roots\n bool too_close = false;\n for (int r : roots) {\n int dx = vertices[v].x - vertices[r].x;\n int dy = vertices[v].y - vertices[r].y;\n if (dx*dx + dy*dy < 3600) { // 60 units squared\n too_close = true;\n break;\n }\n }\n if (!too_close) {\n roots.push_back(v);\n is_root[v] = true;\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n vertices[v].assigned = true;\n }\n }\n \n // If no roots selected, make vertex 0 a root\n if (roots.empty()) {\n roots.push_back(0);\n is_root[0] = true;\n vertices[0].parent = -1;\n vertices[0].depth = 0;\n vertices[0].tree_id = 0;\n vertices[0].assigned = true;\n }\n \n // Grow trees from roots using BFS\n for (int root : roots) {\n queue q;\n q.push(root);\n \n while (!q.empty()) {\n int v = q.front();\n q.pop();\n \n if (vertices[v].depth >= H) continue;\n \n // Sort neighbors by beauty (descending) to prioritize high-beauty vertices\n vector> neighbor_beauty;\n for (int nb : vertices[v].neighbors) {\n if (!vertices[nb].assigned) {\n neighbor_beauty.emplace_back(vertices[nb].beauty, nb);\n }\n }\n sort(neighbor_beauty.rbegin(), neighbor_beauty.rend());\n \n for (auto [beauty, nb] : neighbor_beauty) {\n vertices[nb].parent = v;\n vertices[nb].depth = vertices[v].depth + 1;\n vertices[nb].tree_id = root;\n vertices[nb].assigned = true;\n q.push(nb);\n }\n }\n }\n \n // Assign remaining unassigned vertices\n vector unassigned;\n for (int i = 0; i < N; i++) {\n if (!vertices[i].assigned) {\n unassigned.push_back(i);\n }\n }\n \n // For each unassigned vertex, find the best valid parent\n for (int v : unassigned) {\n int best_parent = -1;\n int best_score = INT_MIN;\n \n // Check all neighbors that are assigned and have depth < H\n for (int nb : vertices[v].neighbors) {\n if (vertices[nb].assigned && vertices[nb].depth < H) {\n int score = (vertices[nb].depth + 2) * vertices[v].beauty;\n if (score > best_score) {\n best_score = score;\n best_parent = nb;\n }\n }\n }\n \n if (best_parent != -1) {\n vertices[v].parent = best_parent;\n vertices[v].depth = vertices[best_parent].depth + 1;\n vertices[v].tree_id = vertices[best_parent].tree_id;\n vertices[v].assigned = true;\n } else {\n // Make it a new root\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n vertices[v].assigned = true;\n roots.push_back(v);\n }\n }\n \n // Verify all parent-child relationships are valid edges\n for (int i = 0; i < N; i++) {\n if (vertices[i].parent != -1) {\n int u = i;\n int v = vertices[i].parent;\n if (edge_set.find({min(u, v), max(u, v)}) == edge_set.end()) {\n // Invalid edge found - make this vertex a root\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n }\n }\n }\n \n // Output parent array\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << vertices[i].parent;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// N is fixed at 20 for all test cases.\nconst int N = 20;\n\n// Helper function to get the reverse direction for a move.\nchar get_reverse_dir(char dir) {\n if (dir == 'L') return 'R';\n if (dir == 'R') return 'L';\n if (dir == 'U') return 'D';\n if (dir == 'D') return 'U';\n return '?'; // Should not happen with valid input\n}\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n int N_input;\n cin >> N_input;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector> operations;\n long long total_moves = 0;\n\n // Iterate over each square to find Oni ('x').\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n // Found an Oni at (i, j). Find the cheapest way to remove it.\n // The problem guarantee ensures at least one of the four paths is clear.\n char best_dir = '?';\n int min_cost = N * 2 + 1; // Initialize with a value larger than any possible cost (max is 40).\n\n // Check upward path (U, j)\n bool up_clear = true;\n for (int k = 0; k < i; ++k) {\n if (board[k][j] == 'o') {\n up_clear = false;\n break;\n }\n }\n if (up_clear) {\n // Number of shifts is i+1, total moves is 2*(i+1)\n int cost = 2 * (i + 1);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'U';\n }\n }\n\n // Check downward path (D, j)\n bool down_clear = true;\n for (int k = i + 1; k < N; ++k) {\n if (board[k][j] == 'o') {\n down_clear = false;\n break;\n }\n }\n if (down_clear) {\n // Number of shifts is N-i, total moves is 2*(N-i)\n int cost = 2 * (N - i);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'D';\n }\n }\n\n // Check leftward path (L, i)\n bool left_clear = true;\n for (int k = 0; k < j; ++k) {\n if (board[i][k] == 'o') {\n left_clear = false;\n break;\n }\n }\n if (left_clear) {\n // Number of shifts is j+1, total moves is 2*(j+1)\n int cost = 2 * (j + 1);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'L';\n }\n }\n\n // Check rightward path (R, i)\n bool right_clear = true;\n for (int k = j + 1; k < N; ++k) {\n if (board[i][k] == 'o') {\n right_clear = false;\n break;\n }\n }\n if (right_clear) {\n // Number of shifts is N-j, total moves is 2*(N-j)\n int cost = 2 * (N - j);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'R';\n }\n }\n\n // Add the sequence of moves for the cheapest path to the operations list.\n int num_shifts = min_cost / 2;\n int line_idx = (best_dir == 'L' || best_dir == 'R') ? i : j;\n\n for (int k = 0; k < num_shifts; ++k) {\n operations.push_back({best_dir, line_idx});\n }\n for (int k = 0; k < num_shifts; ++k) {\n operations.push_back({get_reverse_dir(best_dir), line_idx});\n }\n total_moves += min_cost;\n }\n }\n }\n\n // The problem guarantee ensures total_moves will be <= 4N^2.\n // Max oni is 2N=40. Max cost per oni is 2*N=40. Max total cost is 40*40=1600=4N^2.\n // This strategy is guaranteed to be valid and within the move limit.\n\n // Output the sequence of operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 100;\n long long L = 500000;\n vector T(N);\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector> sorted_T;\n for (int i = 0; i < N; ++i) {\n sorted_T.emplace_back(T[i], i);\n }\n sort(sorted_T.rbegin(), sorted_T.rend());\n\n const int K = 20; // Further increased number of top employees to consider\n vector a(N), b(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n // Top K employees transition among themselves in a balanced way with more targeted randomness\n for (int i = 0; i < K; ++i) {\n int emp = sorted_T[i].second;\n if (i < K / 3) {\n a[emp] = sorted_T[(i + 1) % K].second;\n b[emp] = sorted_T[(i + 2) % K].second;\n } else if (i < 2 * K / 3) {\n a[emp] = sorted_T[(i + 3) % K].second;\n b[emp] = sorted_T[(i + 4) % K].second;\n } else {\n // Introduce more randomness for lower top employees\n uniform_int_distribution dist(0, K - 1);\n a[emp] = sorted_T[dist(rng)].second;\n b[emp] = sorted_T[dist(rng)].second;\n }\n }\n\n // Other employees transition to top employees based on their target proportions\n for (int i = K; i < N; ++i) {\n int emp = sorted_T[i].second;\n long long remaining_target = T[emp];\n int chosen_top = 0;\n long long max_ratio = 0;\n for (int j = 0; j < K; ++j) {\n int top_emp = sorted_T[j].second;\n long long ratio = T[top_emp] * (K - j) * (K - j); // Quadratic heuristic\n if (ratio > max_ratio) {\n max_ratio = ratio;\n chosen_top = top_emp;\n }\n }\n a[emp] = chosen_top;\n // Alternate transition with more targeted randomness\n if (i % 3 == 0) {\n b[emp] = sorted_T[i % K].second;\n } else if (i % 3 == 1) {\n uniform_int_distribution dist(0, K / 2 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else {\n uniform_int_distribution dist(K / 2, K - 1);\n b[emp] = sorted_T[dist(rng)].second;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << a[i] << \" \" << b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct City {\n int idx;\n double x, y;\n int lx, rx, ly, ry;\n};\n\nvector> dist;\nvector> query_count;\n\ndouble euclidean_dist(const City& a, const City& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\nvector> query_mst(const vector& cities) {\n cout << \"? \" << cities.size();\n for (int c : cities) cout << \" \" << c;\n cout << endl;\n cout.flush();\n \n vector> edges;\n for (int i = 0; i < (int)cities.size() - 1; i++) {\n int u, v;\n cin >> u >> v;\n edges.emplace_back(u, v);\n }\n return edges;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector cities(N);\n for (int i = 0; i < N; i++) {\n cities[i].idx = i;\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].x = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].y = (cities[i].ly + cities[i].ry) / 2.0;\n }\n \n dist.assign(N, vector(N, 1e9));\n query_count.assign(N, vector(N, 0));\n \n // Initialize with centroid distances\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n dist[i][j] = dist[j][i] = euclidean_dist(cities[i], cities[j]);\n }\n }\n \n int queries_used = 0;\n \n // Strategy 1: Query cities sorted by proximity to get accurate distances\n // Sort cities by coordinates\n vector city_order(N);\n iota(city_order.begin(), city_order.end(), 0);\n sort(city_order.begin(), city_order.end(), [&](int a, int b) {\n return cities[a].x < cities[b].x || \n (abs(cities[a].x - cities[b].x) < 1e-6 && cities[a].y < cities[b].y);\n });\n \n // Query consecutive cities in sorted order (they're likely to be close)\n for (int i = 0; i < N && queries_used < Q / 2; i += L/2) {\n vector batch;\n for (int j = i; j < min(N, i + L); j++) {\n batch.push_back(city_order[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Strategy 2: Query cities sorted by y-coordinate\n vector city_order_y(N);\n iota(city_order_y.begin(), city_order_y.end(), 0);\n sort(city_order_y.begin(), city_order_y.end(), [&](int a, int b) {\n return cities[a].y < cities[b].y || \n (abs(cities[a].y - cities[b].y) < 1e-6 && cities[a].x < cities[b].x);\n });\n \n for (int i = 0; i < N && queries_used < Q * 3 / 4; i += L/2) {\n vector batch;\n for (int j = i; j < min(N, i + L); j++) {\n batch.push_back(city_order_y[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Strategy 3: Use remaining queries for random pairs to explore\n mt19937 rng(12345);\n while (queries_used < Q) {\n vector batch;\n set used;\n \n // Select random cities\n while (batch.size() < L && used.size() < N) {\n int c = rng() % N;\n if (used.insert(c).second) {\n batch.push_back(c);\n }\n }\n \n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Final group assignment using improved distances\n vector assigned(N, false);\n vector> final_groups(M);\n vector>> final_edges(M);\n \n // Sort groups by size (largest first for better connectivity)\n vector> group_sizes;\n for (int i = 0; i < M; i++) group_sizes.emplace_back(G[i], i);\n sort(group_sizes.rbegin(), group_sizes.rend());\n \n for (auto [size, group_id] : group_sizes) {\n if (size == 0) continue;\n \n // Find best unassigned city as seed (one with many close neighbors)\n int seed = -1;\n double seed_score = -1;\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n double score = 0;\n int close_count = 0;\n for (int j = 0; j < N; j++) {\n if (!assigned[j] && i != j) {\n if (dist[i][j] < 1000) { // Reasonable distance threshold\n score += 1.0 / (dist[i][j] + 1);\n close_count++;\n }\n }\n }\n if (close_count > 0 && score > seed_score) {\n seed_score = score;\n seed = i;\n }\n }\n }\n \n // If no good seed found, pick any unassigned city\n if (seed == -1) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n seed = i;\n break;\n }\n }\n }\n \n final_groups[group_id].push_back(seed);\n assigned[seed] = true;\n \n // Grow group using Prim's algorithm\n vector in_group(N, false);\n in_group[seed] = true;\n \n while ((int)final_groups[group_id].size() < size) {\n int best_city = -1;\n double best_dist = 1e9;\n int best_from = -1;\n \n for (int u : final_groups[group_id]) {\n for (int v = 0; v < N; v++) {\n if (!assigned[v] && !in_group[v]) {\n if (dist[u][v] < best_dist) {\n best_dist = dist[u][v];\n best_city = v;\n best_from = u;\n }\n }\n }\n }\n \n if (best_city == -1) {\n // No more cities reachable, pick any unassigned\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n best_city = i;\n best_from = final_groups[group_id][0];\n break;\n }\n }\n }\n \n if (best_city != -1) {\n final_groups[group_id].push_back(best_city);\n in_group[best_city] = true;\n assigned[best_city] = true;\n } else {\n break;\n }\n }\n \n // Safety check: ensure group has correct size\n while ((int)final_groups[group_id].size() < size) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n final_groups[group_id].push_back(i);\n assigned[i] = true;\n break;\n }\n }\n }\n }\n \n // Build MST within each group\n for (int g = 0; g < M; g++) {\n if (final_groups[g].size() <= 1) continue;\n \n // Use Prim's algorithm for MST to avoid sorting O(n^2) edges\n vector> mst_edges;\n vector in_mst(N, false);\n vector min_edge(N, 1e9);\n vector parent(N, -1);\n \n // Start from first city in group\n int start = final_groups[g][0];\n min_edge[start] = 0;\n \n for (int iter = 0; iter < (int)final_groups[g].size(); iter++) {\n int u = -1;\n for (int city : final_groups[g]) {\n if (!in_mst[city] && (u == -1 || min_edge[city] < min_edge[u])) {\n u = city;\n }\n }\n \n if (u == -1) break;\n \n in_mst[u] = true;\n \n if (parent[u] != -1) {\n mst_edges.emplace_back(parent[u], u);\n }\n \n for (int v : final_groups[g]) {\n if (!in_mst[v] && dist[u][v] < min_edge[v]) {\n min_edge[v] = dist[u][v];\n parent[v] = u;\n }\n }\n }\n \n final_edges[g] = mst_edges;\n }\n \n // Output answer\n cout << \"!\" << endl;\n for (int g = 0; g < M; g++) {\n for (int c : final_groups[g]) {\n cout << c << \" \";\n }\n cout << endl;\n for (auto [u, v] : final_edges[g]) {\n cout << u << \" \" << v << endl;\n }\n }\n \n return 0;\n}","ahc046":"#include \nusing namespace std;\n\n// N and M are fixed by the problem statement, so we can use the literals directly.\n// N = 20, M = 40\n\nstruct Pos {\n int r, c;\n int id() const { return r * 20 + c; } // N is 20\n static Pos from_id(int id) { return {id / 20, id % 20}; } // N is 20\n};\n\n// BFS that returns a shortest sequence of actions from src to dst\nvector> bfs_path(Pos src, Pos dst) {\n const int SZ = 20 * 20; // N*N\n vector dist(SZ, -1);\n vector parent(SZ, -1);\n vector act(SZ), dir(SZ); // action and direction that lead to this vertex\n\n queue q;\n int s_id = src.id();\n dist[s_id] = 0;\n q.push(s_id);\n\n while (!q.empty()) {\n int cur_id = q.front(); q.pop();\n Pos cur = Pos::from_id(cur_id);\n if (cur_id == dst.id()) break;\n\n // ----- Move -----\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char mdir[4] = {'U', 'D', 'L', 'R'};\n for (int k = 0; k < 4; ++k) {\n int nr = cur.r + dr[k];\n int nc = cur.c + dc[k];\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) continue; // N is 20\n int nid = nr * 20 + nc; // N is 20\n if (dist[nid] != -1) continue;\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'M';\n dir[nid] = mdir[k];\n q.push(nid);\n }\n\n // ----- Slide -----\n // slide up\n if (cur.r > 0) {\n int nid = 0 * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'U';\n q.push(nid);\n }\n }\n // slide down\n if (cur.r < 20-1) { // N is 20\n int nid = (20-1) * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'D';\n q.push(nid);\n }\n }\n // slide left\n if (cur.c > 0) {\n int nid = cur.r * 20 + 0; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'L';\n q.push(nid);\n }\n }\n // slide right\n if (cur.c < 20-1) { // N is 20\n int nid = cur.r * 20 + (20-1); // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'R';\n q.push(nid);\n }\n }\n }\n\n // reconstruct path\n vector> path;\n int cur_id = dst.id();\n while (cur_id != s_id) {\n path.emplace_back(act[cur_id], dir[cur_id]);\n cur_id = parent[cur_id];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // N and M are fixed (20, 40). Read them into dummy variables to consume the first line.\n int n_read, m_read;\n if (!(cin >> n_read >> m_read)) {\n return 0;\n }\n \n // M is 40\n const int M = 40;\n vector pts(M);\n for (int i = 0; i < M; ++i) {\n cin >> pts[i].r >> pts[i].c;\n }\n\n vector> answer;\n Pos cur = pts[0];\n for (int i = 1; i < M; ++i) {\n Pos nxt = pts[i];\n auto seg = bfs_path(cur, nxt);\n answer.insert(answer.end(), seg.begin(), seg.end());\n cur = nxt;\n }\n\n // safety check (should always hold)\n // Limit is 2 * N * M = 2 * 20 * 40 = 1600\n if ((int)answer.size() > 2 * 20 * 40) {\n answer.resize(2 * 20 * 40);\n }\n\n for (auto [a, d] : answer) {\n cout << a << ' ' << d << '\\n';\n }\n return 0;\n}"},"8":{"ahc001":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Company {\n int id, x, y, r;\n int a, b, c, d;\n};\n\n// Simple greedy placement on a grid\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n vector companies(n);\n for (int i = 0; i < n; i++) {\n companies[i].id = i;\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n }\n \n // Sort by desired area (descending)\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.r > b.r;\n });\n \n // Grid to mark occupied cells\n vector> occupied(10000, vector(10000, false));\n \n for (auto& comp : companies) {\n int x = comp.x, y = comp.y, r = comp.r;\n \n // Try to find a rectangle containing the point\n bool found = false;\n \n // First try: if the point is not occupied, give it 1x1\n if (!occupied[y][x]) {\n comp.a = x;\n comp.b = y;\n comp.c = x + 1;\n comp.d = y + 1;\n occupied[y][x] = true;\n found = true;\n }\n \n if (!found) {\n // Try expanding around the point\n int max_size = min(100, (int)sqrt(r) + 10);\n \n for (int size = 1; size <= max_size && !found; size++) {\n // Try different rectangle shapes\n vector> shapes = {{size, size}, {size*2, size/2}, {size/2, size*2}};\n \n for (auto [w, h] : shapes) {\n if (w <= 0 || h <= 0) continue;\n \n // Try placing rectangle to include (x, y)\n for (int a = max(0, x - w + 1); a <= min(x, 10000 - w) && !found; a++) {\n for (int b = max(0, y - h + 1); b <= min(y, 10000 - h) && !found; b++) {\n int c = a + w;\n int d = b + h;\n \n // Check if rectangle is free and contains the point\n bool free = true;\n for (int yy = b; yy < d && free; yy++) {\n for (int xx = a; xx < c && free; xx++) {\n if (occupied[yy][xx]) {\n free = false;\n }\n }\n }\n \n if (free && a <= x && x < c && b <= y && y < d) {\n comp.a = a;\n comp.b = b;\n comp.c = c;\n comp.d = d;\n \n // Mark as occupied\n for (int yy = b; yy < d; yy++) {\n for (int xx = a; xx < c; xx++) {\n occupied[yy][xx] = true;\n }\n }\n found = true;\n }\n }\n }\n }\n }\n }\n \n if (!found) {\n // Last resort: find any free cell\n for (int yy = 0; yy < 10000 && !found; yy++) {\n for (int xx = 0; xx < 10000 && !found; xx++) {\n if (!occupied[yy][xx]) {\n comp.a = xx;\n comp.b = yy;\n comp.c = xx + 1;\n comp.d = yy + 1;\n occupied[yy][xx] = true;\n found = true;\n }\n }\n }\n }\n \n // Ensure we always have a valid rectangle (shouldn't reach here)\n if (!found) {\n comp.a = 0;\n comp.b = 0;\n comp.c = 1;\n comp.d = 1;\n }\n }\n \n // Sort by original ID for output\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.id < b.id;\n });\n \n // Output results\n for (const auto& comp : companies) {\n cout << comp.a << \" \" << comp.b << \" \" << comp.c << \" \" << comp.d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Tile {\n vector> squares;\n bool visited;\n int total_value;\n int center_i, center_j;\n int connectivity;\n int distance_to_unvisited; // Minimum distance to any unvisited tile\n};\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> t(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> t[i][j];\n }\n }\n \n vector> p(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> p[i][j];\n }\n }\n \n // Build tile structure\n unordered_map tiles;\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n int tile_id = t[i][j];\n tiles[tile_id].squares.push_back({i, j});\n tiles[tile_id].total_value += p[i][j];\n }\n }\n \n // Calculate tile centers\n for (auto& [id, tile] : tiles) {\n int sum_i = 0, sum_j = 0;\n for (auto [i, j] : tile.squares) {\n sum_i += i;\n sum_j += j;\n }\n tile.center_i = sum_i / tile.squares.size();\n tile.center_j = sum_j / tile.squares.size();\n }\n \n vector di = {-1, 1, 0, 0};\n vector dj = {0, 0, -1, 1};\n vector dirs = {'U', 'D', 'L', 'R'};\n \n string best_path;\n int best_score = 0;\n \n // Try more attempts with different strategies\n for (int attempt = 0; attempt < 8; attempt++) {\n // Reset visited status\n for (auto& [id, tile] : tiles) {\n tile.visited = false;\n tile.connectivity = 0;\n tile.distance_to_unvisited = INT_MAX;\n }\n \n vector> visited_square(50, vector(50, false));\n int initial_tile_id = t[si][sj];\n tiles[initial_tile_id].visited = true;\n \n string path;\n int current_i = si, current_j = sj;\n int total_score = 0;\n \n // Add all squares in initial tile\n for (auto [i, j] : tiles[initial_tile_id].squares) {\n visited_square[i][j] = true;\n total_score += p[i][j];\n }\n \n mt19937 rng(attempt * 1234 + 5678);\n \n // Different strategies for different attempts\n double exploration_factor = 1.0 + attempt * 0.3;\n int max_search_distance = 15 + attempt * 3;\n int max_steps = 500 + attempt * 50;\n \n // Main exploration loop\n for (int step = 0; step < max_steps; step++) {\n vector> candidates;\n \n // Update tile statistics\n for (auto& [id, tile] : tiles) {\n if (tile.visited) continue;\n \n // Calculate connectivity\n tile.connectivity = 0;\n for (auto [ti, tj] : tile.squares) {\n for (int d = 0; d < 4; d++) {\n int ni = ti + di[d];\n int nj = tj + dj[d];\n if (0 <= ni && ni < 50 && 0 <= nj && nj < 50) {\n if (!visited_square[ni][nj]) {\n tile.connectivity++;\n }\n }\n }\n }\n \n // Calculate minimum distance to current position\n tile.distance_to_unvisited = abs(current_i - tile.center_i) + abs(current_j - tile.center_j);\n }\n \n // Find adjacent unvisited tiles\n for (int d = 0; d < 4; d++) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited_square[ni][nj]) continue;\n \n int tile_id = t[ni][nj];\n if (tiles[tile_id].visited) continue;\n \n // Enhanced scoring\n double score = tiles[tile_id].total_value;\n score += tiles[tile_id].connectivity * 8.0 * exploration_factor;\n score -= tiles[tile_id].distance_to_unvisited * 0.5;\n score += rng() % (20 + attempt * 3);\n \n // Bonus for tiles that open up more options\n if (tiles[tile_id].connectivity >= 3) {\n score += 30;\n }\n \n candidates.push_back({score, ni, nj, dirs[d]});\n }\n \n if (!candidates.empty()) {\n sort(candidates.rbegin(), candidates.rend());\n auto [score, ni, nj, dir] = candidates[0];\n \n path += dir;\n current_i = ni;\n current_j = nj;\n \n int tile_id = t[current_i][current_j];\n tiles[tile_id].visited = true;\n for (auto [ti, tj] : tiles[tile_id].squares) {\n visited_square[ti][tj] = true;\n total_score += p[ti][tj];\n }\n } else {\n // Enhanced BFS with adaptive search distance\n queue> q;\n q.push({current_i, current_j, \"\", 0});\n \n vector> bfs_visited(50, vector(50, false));\n bfs_visited[current_i][current_j] = true;\n \n bool found = false;\n string found_path;\n int best_tile_value = 0;\n \n while (!q.empty() && !found) {\n auto [ci, cj, current_path, dist] = q.front();\n q.pop();\n \n if (dist > max_search_distance) continue;\n \n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (bfs_visited[ni][nj]) continue;\n if (visited_square[ni][nj]) continue;\n \n int tile_id = t[ni][nj];\n if (!tiles[tile_id].visited) {\n // Prefer higher value tiles\n if (tiles[tile_id].total_value > best_tile_value || \n (tiles[tile_id].total_value == best_tile_value && found_path.empty())) {\n found_path = current_path + dirs[d];\n best_tile_value = tiles[tile_id].total_value;\n found = true;\n }\n }\n \n bfs_visited[ni][nj] = true;\n q.push({ni, nj, current_path + dirs[d], dist + 1});\n }\n }\n \n if (found) {\n path += found_path;\n for (char c : found_path) {\n if (c == 'U') current_i--;\n else if (c == 'D') current_i++;\n else if (c == 'L') current_j--;\n else if (c == 'R') current_j++;\n }\n \n int tile_id = t[current_i][current_j];\n tiles[tile_id].visited = true;\n for (auto [ti, tj] : tiles[tile_id].squares) {\n visited_square[ti][tj] = true;\n total_score += p[ti][tj];\n }\n } else {\n // Try to find any unvisited tile with longer search\n if (step < max_steps / 2) {\n max_search_distance = min(50, max_search_distance + 5);\n continue;\n }\n break;\n }\n }\n }\n \n if (total_score > best_score) {\n best_score = total_score;\n best_path = path;\n }\n }\n \n cout << best_path << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\n// --- Constants ---\nconstexpr int N = 30;\nconstexpr double INF = 1e18;\nconstexpr int MIN_EDGE = 1000;\nconstexpr int MAX_EDGE = 9000;\n\n// --- Hyperparameters for Learning ---\n// Reverting to a simpler, more robust model.\n// A slightly higher initial rate with a very slow decay.\nconstexpr double INITIAL_LEARNING_RATE = 0.25;\nconstexpr double LEARNING_DECAY = 0.9995; // Very slow decay\n\n// --- Global State ---\ndouble H[N][N - 1]; // horizontal edge (i,j) -> (i,j+1)\ndouble V[N - 1][N]; // vertical edge (i,j) -> (i+1,j)\nmt19937 rng(123456);\n\n// --- Dijkstra's Algorithm for pure exploitation ---\nstring find_path(int si, int sj, int ti, int tj, vector>& used_edges) {\n double dist[N][N];\n int prev[N][N];\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n dist[i][j] = INF;\n prev[i][j] = -1;\n }\n }\n dist[si][sj] = 0.0;\n\n using Node = pair>;\n priority_queue, greater> pq;\n pq.emplace(0.0, make_pair(si, sj));\n\n constexpr int di[4] = {-1, 1, 0, 0};\n constexpr int dj[4] = {0, 0, -1, 1};\n constexpr char dir_char[4] = {'U', 'D', 'L', 'R'};\n\n while (!pq.empty()) {\n auto [d, coord] = pq.top();\n auto [i, j] = coord;\n pq.pop();\n\n if (d > dist[i][j] + 1e-9) continue;\n if (i == ti && j == tj) break;\n\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n\n double w = 0.0;\n if (dir == 0) w = V[i - 1][j]; // U\n else if (dir == 1) w = V[i][j]; // D\n else if (dir == 2) w = H[i][j - 1]; // L\n else w = H[i][j]; // R\n\n if (dist[i][j] + w < dist[ni][nj] - 1e-9) {\n dist[ni][nj] = dist[i][j] + w;\n prev[ni][nj] = dir;\n pq.emplace(dist[ni][nj], make_pair(ni, nj));\n }\n }\n }\n\n vector> vertex_path;\n int ci = ti, cj = tj;\n vertex_path.emplace_back(ci, cj);\n while (!(ci == si && cj == sj)) {\n int dir = prev[ci][cj];\n int pi = ci - di[dir];\n int pj = cj - dj[dir];\n vertex_path.emplace_back(pi, pj);\n ci = pi;\n cj = pj;\n }\n reverse(vertex_path.begin(), vertex_path.end());\n\n string path_str;\n used_edges.clear();\n for (size_t i = 0; i + 1 < vertex_path.size(); ++i) {\n int ci = vertex_path[i].first;\n int cj = vertex_path[i].second;\n int ni = vertex_path[i+1].first;\n int nj = vertex_path[i+1].second;\n\n if (ni == ci - 1) { // U\n path_str.push_back('U');\n used_edges.emplace_back(1, ci - 1, cj);\n } else if (ni == ci + 1) { // D\n path_str.push_back('D');\n used_edges.emplace_back(1, ci, cj);\n } else if (nj == cj - 1) { // L\n path_str.push_back('L');\n used_edges.emplace_back(0, ci, cj - 1);\n } else { // R\n path_str.push_back('R');\n used_edges.emplace_back(0, ci, cj);\n }\n }\n return path_str;\n}\n\n\n// --- Main ---\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n uniform_int_distribution init_dist(MIN_EDGE, MAX_EDGE);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N - 1; ++j) H[i][j] = init_dist(rng);\n }\n for (int i = 0; i < N - 1; ++i) {\n for (int j = 0; j < N; ++j) V[i][j] = init_dist(rng);\n }\n\n vector> used_edges;\n used_edges.reserve(60);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) break;\n\n string path = find_path(si, sj, ti, tj, used_edges);\n\n cout << path << \"\\n\";\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n if (used_edges.empty()) continue;\n\n double lest = 0.0;\n for (auto [type, i, j] : used_edges) {\n lest += (type == 0) ? H[i][j] : V[i][j];\n }\n\n double delta = static_cast(observed) - lest;\n double current_lr = INITIAL_LEARNING_RATE * pow(LEARNING_DECAY, q);\n double step = current_lr * delta / used_edges.size();\n\n for (auto [type, i, j] : used_edges) {\n if (type == 0) {\n H[i][j] += step;\n H[i][j] = clamp(H[i][j], (double)MIN_EDGE, (double)MAX_EDGE);\n } else {\n V[i][j] += step;\n V[i][j] = clamp(V[i][j], (double)MIN_EDGE, (double)MAX_EDGE);\n }\n }\n }\n\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace chrono;\n\nconst int N = 20;\nconst char EMPTY = '.';\n\nstruct StringInfo {\n string s;\n int length;\n int id;\n int priority;\n vector substrings;\n unordered_set substr_set;\n int pattern_score;\n double complexity;\n int unique_chars;\n};\n\nstruct Position {\n int i, j, dir;\n double score;\n int conflicts;\n};\n\nclass FinalTorusReconstructor {\nprivate:\n vector strings;\n vector> matrix;\n mt19937 rng;\n array char_freq;\n int best_score;\n vector> best_matrix;\n vector is_matched;\n int matched_count;\n unordered_map> substring_map;\n vector common_patterns;\n vector rare_patterns;\n vector> conflict_graph;\n double progress_factor;\n int phase;\n \npublic:\n FinalTorusReconstructor(const vector& input_strings) : \n rng(steady_clock::now().time_since_epoch().count()) {\n strings.resize(input_strings.size());\n char_freq.fill(0);\n phase = 0;\n \n for (int i = 0; i < input_strings.size(); i++) {\n strings[i].s = input_strings[i];\n strings[i].length = input_strings[i].length();\n strings[i].id = i;\n strings[i].priority = 0;\n strings[i].pattern_score = 0;\n strings[i].complexity = 0;\n strings[i].unique_chars = 0;\n \n unordered_set chars;\n for (char c : input_strings[i]) {\n char_freq[c - 'A']++;\n strings[i].priority += char_freq[c - 'A'];\n chars.insert(c);\n }\n strings[i].unique_chars = chars.size();\n \n for (int len = 2; len <= min(4, strings[i].length); len++) {\n for (int start = 0; start <= strings[i].length - len; start++) {\n string sub = strings[i].s.substr(start, len);\n strings[i].substrings.push_back(sub);\n strings[i].substr_set.insert(sub);\n substring_map[sub].push_back(i);\n }\n }\n }\n \n extract_patterns();\n calculate_pattern_scores();\n build_conflict_graph();\n \n matrix.assign(N, vector(N, EMPTY));\n best_matrix = matrix;\n best_score = 0;\n is_matched.assign(strings.size(), false);\n matched_count = 0;\n progress_factor = 1.0;\n }\n \n void extract_patterns() {\n unordered_map pattern_count;\n \n for (const auto& str_info : strings) {\n for (const string& sub : str_info.substrings) {\n pattern_count[sub]++;\n }\n }\n \n for (const auto& [pattern, count] : pattern_count) {\n if (count >= 3) {\n common_patterns.push_back(pattern);\n } else if (count == 2) {\n rare_patterns.push_back(pattern);\n }\n }\n \n sort(common_patterns.begin(), common_patterns.end(),\n [&pattern_count](const string& a, const string& b) {\n return pattern_count[a] > pattern_count[b];\n });\n \n sort(rare_patterns.begin(), rare_patterns.end(),\n [&pattern_count](const string& a, const string& b) {\n return pattern_count[a] > pattern_count[b];\n });\n }\n \n void calculate_pattern_scores() {\n for (auto& str_info : strings) {\n int common_score = 0;\n int rare_score = 0;\n \n for (const string& pattern : common_patterns) {\n if (str_info.s.find(pattern) != string::npos) {\n common_score += substring_map[pattern].size() * 2;\n }\n }\n \n for (const string& pattern : rare_patterns) {\n if (str_info.s.find(pattern) != string::npos) {\n rare_score += substring_map[pattern].size() * 3;\n }\n }\n \n str_info.pattern_score = common_score + rare_score;\n str_info.complexity = (double)str_info.length * (str_info.pattern_score + str_info.unique_chars * 5) / 100.0;\n }\n }\n \n void build_conflict_graph() {\n conflict_graph.resize(strings.size());\n \n for (int i = 0; i < strings.size(); i++) {\n for (int j = i + 1; j < strings.size(); j++) {\n bool compatible = false;\n for (const string& sub : strings[i].substrings) {\n if (strings[j].substr_set.count(sub)) {\n compatible = true;\n break;\n }\n }\n if (compatible) {\n conflict_graph[i].push_back(j);\n conflict_graph[j].push_back(i);\n }\n }\n }\n }\n \n bool check_string_match_fast(int idx) const {\n const string& s = strings[idx].s;\n int k = s.length();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool match = true;\n for (int p = 0; p < k; p++) {\n if (matrix[i][(j + p) % N] != s[p]) {\n match = false;\n break;\n }\n }\n if (match) return true;\n \n match = true;\n for (int p = 0; p < k; p++) {\n if (matrix[(i + p) % N][j] != s[p]) {\n match = false;\n break;\n }\n }\n if (match) return true;\n }\n }\n return false;\n }\n \n void update_matched_status() {\n int old_count = matched_count;\n matched_count = 0;\n \n for (int i = 0; i < strings.size(); i++) {\n is_matched[i] = check_string_match_fast(i);\n if (is_matched[i]) matched_count++;\n }\n \n progress_factor = (double)matched_count / strings.size();\n \n if (matched_count > old_count) {\n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n for (int neighbor : conflict_graph[i]) {\n if (is_matched[neighbor]) {\n bool now_matched = check_string_match_fast(i);\n if (now_matched) {\n is_matched[i] = true;\n matched_count++;\n }\n }\n }\n }\n }\n }\n }\n \n void final_initialization() {\n matrix.assign(N, vector(N, EMPTY));\n \n sort(strings.begin(), strings.end(), \n [this](const StringInfo& a, const StringInfo& b) {\n if (phase == 0) {\n if (abs(a.complexity - b.complexity) > 0.1) {\n return a.complexity > b.complexity;\n }\n } else {\n if (a.pattern_score != b.pattern_score) {\n return a.pattern_score > b.pattern_score;\n }\n }\n if (a.length != b.length) return a.length > b.length;\n return a.unique_chars > b.unique_chars;\n });\n \n int strings_to_place = phase == 0 ? 100 : 80;\n for (int idx = 0; idx < min(strings_to_place, (int)strings.size()); idx++) {\n place_string_final(strings[idx].s);\n }\n \n smart_fill_remaining();\n }\n \n void place_string_final(const string& s) {\n int k = s.length();\n Position best_pos = {-1, -1, -1, -1.0, k};\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n double h_score = evaluate_position_enhanced(i, j, 0, s);\n double v_score = evaluate_position_enhanced(i, j, 1, s);\n \n int h_conflicts = count_conflicts(i, j, 0, s);\n int v_conflicts = count_conflicts(i, j, 1, s);\n \n if (h_conflicts < best_pos.conflicts || \n (h_conflicts == best_pos.conflicts && h_score > best_pos.score)) {\n best_pos = {i, j, 0, h_score, h_conflicts};\n }\n \n if (v_conflicts < best_pos.conflicts || \n (v_conflicts == best_pos.conflicts && v_score > best_pos.score)) {\n best_pos = {i, j, 1, v_score, h_conflicts};\n }\n }\n }\n \n int max_conflicts = phase < 2 ? min(2, k / 3) : min(3, k / 2);\n if (best_pos.conflicts <= max_conflicts || \n (best_pos.score > 1.0 && best_pos.conflicts <= k / 2)) {\n int k = s.length();\n if (best_pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n matrix[best_pos.i][(best_pos.j + p) % N] = s[p];\n }\n } else {\n for (int p = 0; p < k; p++) {\n matrix[(best_pos.i + p) % N][best_pos.j] = s[p];\n }\n }\n }\n }\n \n double evaluate_position_enhanced(int i, int j, int dir, const string& s) const {\n int k = s.length();\n double score = 0;\n int matches = 0;\n int pattern_bonus = 0;\n int continuity_bonus = 0;\n \n for (int p = 0; p < k; p++) {\n char current = (dir == 0) ? matrix[i][(j + p) % N] : matrix[(i + p) % N][j];\n if (current != EMPTY) {\n if (current == s[p]) {\n matches++;\n score += 2.5;\n \n if (p > 0) {\n char prev = (dir == 0) ? matrix[i][(j + p - 1) % N] : matrix[(i + p - 1) % N][j];\n if (prev == s[p-1]) continuity_bonus += 1.0;\n }\n } else {\n score -= 1.8;\n }\n }\n }\n \n for (int len = 2; len <= min(3, k); len++) {\n for (int start = 0; start <= k - len; start++) {\n string sub = s.substr(start, len);\n if (substring_map.count(sub)) {\n int weight = substring_map.at(sub).size();\n if (find(rare_patterns.begin(), rare_patterns.end(), sub) != rare_patterns.end()) {\n weight *= 2;\n }\n pattern_bonus += weight;\n }\n }\n }\n \n score += pattern_bonus * 0.4;\n score += continuity_bonus * 0.5;\n score += (double)matches / k * 6.0;\n \n return score;\n }\n \n int count_conflicts(int i, int j, int dir, const string& s) const {\n int k = s.length();\n int conflicts = 0;\n \n for (int p = 0; p < k; p++) {\n char current = (dir == 0) ? matrix[i][(j + p) % N] : matrix[(i + p) % N][j];\n if (current != EMPTY && current != s[p]) {\n conflicts++;\n }\n }\n \n return conflicts;\n }\n \n void smart_fill_remaining() {\n array, 8> freq_chars;\n for (int i = 0; i < 8; i++) {\n freq_chars[i] = {char_freq[i], 'A' + i};\n }\n sort(freq_chars.begin(), freq_chars.end(), greater>());\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == EMPTY) {\n array scores = {0};\n \n for (int di = -2; di <= 2; di++) {\n for (int dj = -2; dj <= 2; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = (i + di + N) % N;\n int nj = (j + dj + N) % N;\n if (matrix[ni][nj] != EMPTY) {\n int c = matrix[ni][nj] - 'A';\n double weight = 3.0 - abs(di) - abs(dj);\n scores[c] += weight;\n \n string context = \"\";\n for (int p = -1; p <= 1; p++) {\n int ci = (i + di + p + N) % N;\n int cj = (j + dj + p + N) % N;\n if (matrix[ci][cj] != EMPTY) {\n context += matrix[ci][cj];\n }\n }\n \n for (const string& pattern : common_patterns) {\n if (context.find(pattern) != string::npos) {\n scores[c] += 1.5;\n }\n }\n \n for (const string& pattern : rare_patterns) {\n if (context.find(pattern) != string::npos) {\n scores[c] += 2.0;\n }\n }\n }\n }\n }\n \n for (int c = 0; c < 8; c++) {\n scores[c] += (double)char_freq[c] / 80.0;\n }\n \n int best_char = max_element(scores.begin(), scores.end()) - scores.begin();\n matrix[i][j] = 'A' + best_char;\n }\n }\n }\n }\n \n void final_optimization() {\n for (phase = 0; phase < 7; phase++) {\n if (phase < 2) {\n aggressive_placement();\n } else if (phase < 4) {\n adaptive_local_search();\n } else if (phase < 6) {\n focused_refinement();\n } else {\n ultimate_polish();\n }\n \n update_matched_status();\n \n if (matched_count > best_score) {\n best_score = matched_count;\n best_matrix = matrix;\n }\n }\n }\n \n void aggressive_placement() {\n vector> priority_strings;\n \n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n double urgency = strings[i].complexity * (1.2 + progress_factor * 0.8);\n if (strings[i].unique_chars >= 3) urgency *= 1.3;\n priority_strings.push_back({urgency, i});\n }\n }\n \n sort(priority_strings.rbegin(), priority_strings.rend());\n \n int attempts = phase == 0 ? 80 : 60;\n for (int iter = 0; iter < min(attempts, (int)priority_strings.size()); iter++) {\n int idx = priority_strings[iter].second;\n place_string_final(strings[idx].s);\n }\n }\n \n void adaptive_local_search() {\n int base_iterations = 1200;\n int iterations = base_iterations * (1.0 + (1.0 - progress_factor) * 0.8);\n \n for (int iter = 0; iter < iterations; iter++) {\n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n array char_scores = {0};\n \n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = (i + di + N) % N;\n int nj = (j + dj + N) % N;\n if (matrix[ni][nj] != EMPTY) {\n for (int c = 0; c < 8; c++) {\n if (matrix[ni][nj] == 'A' + c) {\n char_scores[c] += 3.0;\n } else {\n char_scores[c] -= 1.2;\n }\n }\n }\n }\n }\n \n for (int c = 0; c < 8; c++) {\n char_scores[c] += (double)char_freq[c] / 40.0;\n }\n \n int best_char = max_element(char_scores.begin(), char_scores.end()) - char_scores.begin();\n char new_char = 'A' + best_char;\n \n if (new_char != old_char) {\n matrix[i][j] = new_char;\n \n double delta = evaluate_change_precise(i, j, old_char, new_char);\n double threshold = progress_factor < 0.6 ? 0.0 : -0.3;\n \n if (delta < threshold && rng() % 8 != 0) {\n matrix[i][j] = old_char;\n }\n }\n }\n }\n \n double evaluate_change_precise(int i, int j, char old_char, char new_char) {\n double delta = 0;\n vector check_strings;\n \n for (int idx = 0; idx < strings.size(); idx++) {\n if (!is_matched[idx]) {\n const string& s = strings[idx].s;\n int k = s.length();\n bool could_match = false;\n \n for (int p = 0; p < k; p++) {\n int check_i = (i - p + N) % N;\n int check_j = j;\n if (check_i >= 0 && check_i < N && check_j >= 0 && check_j < N) {\n bool vertical_match = true;\n for (int q = 0; q < k; q++) {\n if (matrix[(check_i + q) % N][check_j] != s[q]) {\n vertical_match = false;\n break;\n }\n }\n if (vertical_match) {\n could_match = true;\n break;\n }\n }\n \n check_i = i;\n check_j = (j - p + N) % N;\n if (check_i >= 0 && check_i < N && check_j >= 0 && check_j < N) {\n bool horizontal_match = true;\n for (int q = 0; q < k; q++) {\n if (matrix[check_i][(check_j + q) % N] != s[q]) {\n horizontal_match = false;\n break;\n }\n }\n if (horizontal_match) {\n could_match = true;\n break;\n }\n }\n }\n \n if (could_match) {\n check_strings.push_back(idx);\n }\n }\n }\n \n for (int idx : check_strings) {\n bool now_matched = check_string_match_fast(idx);\n if (now_matched) delta += 1.0;\n }\n \n return delta;\n }\n \n void focused_refinement() {\n vector problematic_strings;\n \n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n if (strings[i].unique_chars >= 3 || strings[i].pattern_score > 5) {\n problematic_strings.push_back(i);\n }\n }\n }\n \n sort(problematic_strings.begin(), problematic_strings.end(),\n [this](int a, int b) {\n return strings[a].complexity > strings[b].complexity;\n });\n \n for (int iter = 0; iter < min(40, (int)problematic_strings.size()); iter++) {\n int idx = problematic_strings[iter];\n place_string_final(strings[idx].s);\n }\n }\n \n void ultimate_polish() {\n for (int iter = 0; iter < 400; iter++) {\n int idx = rng() % strings.size();\n if (!is_matched[idx]) {\n place_string_final(strings[idx].s);\n if (check_string_match_fast(idx)) {\n is_matched[idx] = true;\n matched_count++;\n }\n }\n }\n }\n \n void reconstruct() {\n final_initialization();\n update_matched_status();\n \n if (matched_count > best_score) {\n best_score = matched_count;\n best_matrix = matrix;\n }\n \n final_optimization();\n \n matrix = best_matrix;\n }\n \n vector> get_matrix() const {\n return matrix;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N_input, M;\n cin >> N_input >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n FinalTorusReconstructor reconstructor(strings);\n reconstructor.reconstruct();\n \n auto matrix = reconstructor.get_matrix();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << matrix[i][j];\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, si, sj;\n cin >> N >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n // Find all reachable road squares from start\n vector> reachable(N, vector(N, false));\n vector> road_positions;\n queue> q;\n q.push({si, sj});\n reachable[si][sj] = true;\n road_positions.emplace_back(si, sj);\n \n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d][0];\n int nj = j + dirs[d][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n grid[ni][nj] != '#' && !reachable[ni][nj]) {\n reachable[ni][nj] = true;\n road_positions.emplace_back(ni, nj);\n q.push({ni, nj});\n }\n }\n }\n \n // Simple but robust approach: systematic coverage with guaranteed validity\n string path;\n int current_i = si, current_j = sj;\n vector> visited(N, vector(N, false));\n visited[si][sj] = true;\n int visited_count = 1;\n \n // Helper function to find path using BFS\n auto find_path = [&](int from_i, int from_j, int to_i, int to_j) -> string {\n if (from_i == to_i && from_j == to_j) return \"\";\n \n vector>> parent(N, vector>(N, {-1, -1}));\n vector> bfs_visited(N, vector(N, false));\n queue> bfs_q;\n \n bfs_q.push({from_i, from_j});\n bfs_visited[from_i][from_j] = true;\n \n while (!bfs_q.empty()) {\n auto [ci, cj] = bfs_q.front();\n bfs_q.pop();\n \n if (ci == to_i && cj == to_j) break;\n \n for (int d = 0; d < 4; d++) {\n int ni = ci + dirs[d][0];\n int nj = cj + dirs[d][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n reachable[ni][nj] && !bfs_visited[ni][nj]) {\n bfs_visited[ni][nj] = true;\n parent[ni][nj] = {ci, cj};\n bfs_q.push({ni, nj});\n }\n }\n }\n \n if (!bfs_visited[to_i][to_j]) return \"\";\n \n string result;\n int ci = to_i, cj = to_j;\n \n while (ci != from_i || cj != from_j) {\n auto [pi, pj] = parent[ci][cj];\n if (pi == -1 && pj == -1) break;\n \n if (pi == ci - 1) result += 'D';\n else if (pi == ci + 1) result += 'U';\n else if (pj == cj - 1) result += 'R';\n else if (pj == cj + 1) result += 'L';\n \n ci = pi;\n cj = pj;\n }\n \n reverse(result.begin(), result.end());\n return result;\n };\n \n // Visit all road squares using nearest neighbor with BFS paths\n while (visited_count < (int)road_positions.size()) {\n int best_dist = INT_MAX;\n int best_i = -1, best_j = -1;\n \n for (auto [i, j] : road_positions) {\n if (!visited[i][j]) {\n int dist = abs(i - current_i) + abs(j - current_j);\n if (dist < best_dist) {\n best_dist = dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n \n if (best_i == -1) break;\n \n string segment = find_path(current_i, current_j, best_i, best_j);\n \n if (segment.empty()) {\n // Mark as visited to avoid infinite loop\n visited[best_i][best_j] = true;\n visited_count++;\n continue;\n }\n \n path += segment;\n \n // Update current position and visited status\n for (char c : segment) {\n if (c == 'U') current_i--;\n else if (c == 'D') current_i++;\n else if (c == 'L') current_j--;\n else if (c == 'R') current_j++;\n \n if (!visited[current_i][current_j]) {\n visited[current_i][current_j] = true;\n visited_count++;\n }\n }\n }\n \n // Return to start\n string return_segment = find_path(current_i, current_j, si, sj);\n if (!return_segment.empty()) {\n path += return_segment;\n }\n \n // Simple optimization - remove immediate backtracks only\n string optimized;\n for (char c : path) {\n if (!optimized.empty()) {\n char last = optimized.back();\n if ((last == 'U' && c == 'D') || (last == 'D' && c == 'U') ||\n (last == 'L' && c == 'R') || (last == 'R' && c == 'L')) {\n optimized.pop_back();\n } else {\n optimized += c;\n }\n } else {\n optimized += c;\n }\n }\n \n cout << optimized << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Variables ---\nint N, M, K, R;\nvector> d; // Task requirements\nvector> pred; // Predecessor lists\nvector> succ; // Successor lists\nvector num_preds; // Number of predecessors for each task\nvector L; // Longest path length from each task\nvector max_d; // Max requirement for each skill\n\n// --- State ---\nint current_day;\nvector task_status; // 0: todo, 1: doing, 2: done\nvector completed_preds_count;\nvector member_busy;\nvector member_task; // task assigned to member\nvector member_start_day;\nvector> s_est; // Estimated skills for each member\nvector num_tasks_done;\n\n// --- Helper function for topological sort ---\nvector topological_sort(const vector>& graph) {\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int v : graph[i]) {\n in_degree[v]++;\n }\n }\n queue q;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n q.push(i);\n }\n }\n vector order;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n order.push_back(u);\n for (int v : graph[u]) {\n if (--in_degree[v] == 0) {\n q.push(v);\n }\n }\n }\n return order;\n}\n\n// --- Main function ---\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // --- Input Reading ---\n cin >> N >> M >> K >> R;\n d.resize(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n cin >> d[i][j];\n }\n }\n\n pred.resize(N);\n succ.resize(N);\n num_preds.resize(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--; // 0-based\n pred[v].push_back(u);\n succ[u].push_back(v);\n num_preds[v]++;\n }\n\n // --- Preprocessing ---\n // Calculate max_d\n max_d.assign(K, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n max_d[k] = max(max_d[k], d[i][k]);\n }\n }\n\n // Calculate L (longest path length)\n vector topo_order = topological_sort(pred); // Sort by preds\n L.assign(N, 1);\n for (auto it = topo_order.rbegin(); it != topo_order.rend(); ++it) {\n int u = *it;\n for (int v : succ[u]) {\n L[u] = max(L[u], 1 + L[v]);\n }\n }\n\n // --- State Initialization ---\n current_day = 1;\n task_status.assign(N, 0);\n completed_preds_count.assign(N, 0);\n member_busy.assign(M, false);\n member_task.assign(M, -1);\n member_start_day.assign(M, -1);\n s_est.assign(M, vector(K, 0.0));\n num_tasks_done.assign(M, 0);\n\n // --- Main Loop ---\n while (true) {\n // --- Step 1: Update State and Learn ---\n string line;\n getline(cin, line); // consume the rest of the previous line, if any\n getline(cin, line);\n istringstream iss(line);\n int n;\n iss >> n;\n if (n == -1) {\n break;\n }\n\n for (int i = 0; i < n; ++i) {\n int f_j;\n iss >> f_j;\n int j = f_j - 1; // 0-based index\n\n int t_id = member_task[j];\n int start_day = member_start_day[j];\n int t_obs = (current_day - 1) - start_day + 1;\n\n task_status[t_id] = 2; // Mark as done\n member_busy[j] = false;\n member_task[j] = -1;\n\n for (int succ_task : succ[t_id]) {\n completed_preds_count[succ_task]++;\n }\n\n // Skill Update\n num_tasks_done[j]++;\n double lr = (t_obs > 1) ? 1.0 / sqrt(num_tasks_done[j]) : 0.1 / sqrt(num_tasks_done[j]);\n for (int k = 0; k < K; ++k) {\n if (d[t_id][k] > s_est[j][k]) {\n s_est[j][k] += lr;\n s_est[j][k] = min(s_est[j][k], (double)d[t_id][k]);\n s_est[j][k] = min(s_est[j][k], (double)max_d[k]);\n }\n }\n }\n \n // --- Step 2: Find Available Resources ---\n vector ready_tasks;\n for (int i = 0; i < N; ++i) {\n if (task_status[i] == 0 && completed_preds_count[i] == num_preds[i]) {\n ready_tasks.push_back(i);\n }\n }\n\n vector free_members;\n for (int j = 0; j < M; ++j) {\n if (!member_busy[j]) {\n free_members.push_back(j);\n }\n }\n\n // --- Step 3: Greedy Assignment ---\n vector> assignments;\n if (!ready_tasks.empty() && !free_members.empty()) {\n vector> pairs; // cost, -L[i], est_time, task_id, member_id\n for (int i : ready_tasks) {\n for (int j : free_members) {\n double w_est = 0.0;\n for (int k = 0; k < K; ++k) {\n w_est += max(0, d[i][k] - s_est[j][k]);\n }\n int est_time = max(1.0, w_est);\n double cost = (double)est_time / L[i];\n pairs.emplace_back(cost, -L[i], est_time, i, j);\n }\n }\n sort(pairs.begin(), pairs.end());\n\n vector task_used(N, false);\n vector member_used(M, false);\n for (const auto& p : pairs) {\n int i = get<3>(p);\n int j = get<4>(p);\n if (!task_used[i] && !member_used[j]) {\n assignments.emplace_back(j + 1, i + 1); // 1-based for output\n task_status[i] = 1; // Mark as in progress\n member_busy[j] = true;\n member_task[j] = i;\n member_start_day[j] = current_day;\n task_used[i] = true;\n member_used[j] = true;\n }\n }\n }\n\n // --- Step 4: Output and Flush ---\n cout << assignments.size();\n for (const auto& a : assignments) {\n cout << \" \" << a.first << \" \" << a.second;\n }\n cout << endl;\n cout.flush();\n\n // --- Step 5: Increment Day ---\n current_day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int id, a, b, c, d;\n int total_dist;\n};\n\nint manhattan_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Select 50 orders closest to center with some randomness\nvector select_orders(const vector& orders) {\n vector> order_scores;\n for (int i = 0; i < 1000; i++) {\n int score = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n order_scores.push_back({score, i});\n }\n \n sort(order_scores.begin(), order_scores.end());\n \n vector selected(1000, false);\n random_device rd;\n mt19937 gen(rd());\n \n // Select from closest 200 orders\n int search_range = min(200, 1000);\n uniform_int_distribution dist(0, search_range - 1);\n \n unordered_set selected_set;\n while (selected_set.size() < 50) {\n int idx = dist(gen);\n int order_id = order_scores[idx].second;\n if (selected_set.find(order_id) == selected_set.end()) {\n selected_set.insert(order_id);\n selected[order_id] = true;\n }\n }\n \n return selected;\n}\n\n// Build route ensuring all pickups and deliveries are visited\nvector> build_complete_route(const vector& orders, const vector& selected) {\n vector> route;\n route.push_back({400, 400});\n \n // Collect all selected orders\n vector selected_orders;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_orders.push_back(i);\n }\n }\n \n // Visit all pickups first using greedy nearest neighbor\n int current_x = 400, current_y = 400;\n vector pickup_visited(1000, false);\n \n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (!pickup_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].a, orders[order_id].b);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].a, orders[best_order].b});\n current_x = orders[best_order].a;\n current_y = orders[best_order].b;\n pickup_visited[best_order] = true;\n }\n }\n \n // Visit all deliveries using greedy nearest neighbor\n vector delivery_visited(1000, false);\n \n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (pickup_visited[order_id] && !delivery_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].c, orders[order_id].d);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].c, orders[best_order].d});\n current_x = orders[best_order].c;\n current_y = orders[best_order].d;\n delivery_visited[best_order] = true;\n }\n }\n \n route.push_back({400, 400});\n return route;\n}\n\n// Simple 2-opt improvement that maintains pickup before delivery constraint\nvector> improve_route(const vector>& route, const vector& orders, const vector& selected) {\n if (route.size() < 4) return route;\n \n // Create map from point to order\n unordered_map point_to_order;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n string pickup_key = to_string(orders[i].a) + \",\" + to_string(orders[i].b);\n string delivery_key = to_string(orders[i].c) + \",\" + to_string(orders[i].d);\n point_to_order[pickup_key] = i;\n point_to_order[delivery_key] = i;\n }\n }\n \n vector> best = route;\n int best_len = 0;\n for (size_t i = 0; i < best.size() - 1; i++) {\n best_len += manhattan_dist(best[i].first, best[i].second, best[i+1].first, best[i+1].second);\n }\n \n // Limited 2-opt iterations\n for (int iter = 0; iter < 5; iter++) {\n bool improved = false;\n \n for (size_t i = 1; i < route.size() - 2 && !improved; i++) {\n for (size_t j = i + 1; j < route.size() - 1; j++) {\n // Check if reversing segment maintains pickup before delivery\n bool valid = true;\n unordered_set pickups_in_segment, deliveries_in_segment;\n \n // Identify pickups and deliveries in the segment\n for (size_t k = i; k <= j; k++) {\n string key = to_string(route[k].first) + \",\" + to_string(route[k].second);\n if (point_to_order.count(key)) {\n int order_id = point_to_order[key];\n if (route[k].first == orders[order_id].a && route[k].second == orders[order_id].b) {\n pickups_in_segment.insert(order_id);\n } else {\n deliveries_in_segment.insert(order_id);\n }\n }\n }\n \n // Check if any delivery appears before its pickup in the reversed segment\n for (int delivery_order : deliveries_in_segment) {\n if (pickups_in_segment.count(delivery_order)) {\n valid = false;\n break;\n }\n }\n \n if (valid) {\n vector> new_route = route;\n reverse(new_route.begin() + i, new_route.begin() + j + 1);\n \n int new_len = 0;\n for (size_t k = 0; k < new_route.size() - 1; k++) {\n new_len += manhattan_dist(new_route[k].first, new_route[k].second, \n new_route[k+1].first, new_route[k+1].second);\n }\n \n if (new_len < best_len) {\n best = new_route;\n best_len = new_len;\n improved = true;\n break;\n }\n }\n }\n }\n \n if (!improved) break;\n }\n \n return best;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i;\n orders[i].total_dist = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n }\n \n // Select orders\n vector selected = select_orders(orders);\n \n // Build complete route\n vector> route = build_complete_route(orders, selected);\n \n // Improve route\n route = improve_route(route, orders, selected);\n \n // Verify route has exactly 102 points (start + 50 pickups + 50 deliveries + end)\n assert(route.size() == 102);\n \n // Output\n vector selected_ids;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_ids.push_back(i + 1);\n }\n }\n \n cout << 50;\n for (int id : selected_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n \n cout << route.size();\n for (const auto& p : route) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Global constants as per problem statement\nconst int N = 400;\nconst int M = 1995;\n\n// Main solver class/structure\nstruct OnlineMST {\n int n, m;\n vector> points;\n vector> edges;\n vector> dist_mat;\n vector> min_dist;\n dsu d;\n set active_roots;\n int num_components;\n\n // Tunable parameters\n const double k_base = 2.5;\n const int desperation_threshold = 5;\n\n OnlineMST() : n(N), m(M), d(N) {\n points.resize(n);\n edges.resize(m);\n dist_mat.assign(n, vector(n, 0));\n min_dist.assign(n, vector(n, 0));\n num_components = n;\n for (int i = 0; i < n; ++i) {\n active_roots.insert(i);\n }\n }\n\n // Helper function to calculate rounded distance\n int calc_dist(int i, int j) {\n long long dx = points[i].first - points[j].first;\n long long dy = points[i].second - points[j].second;\n return (int)round(sqrt(dx * dx + dy * dy));\n }\n\n void preprocess() {\n // Calculate all-pairs distances\n for (int i = 0; i < n; ++i) {\n for (int j = i + 1; j < n; ++j) {\n dist_mat[i][j] = calc_dist(i, j);\n dist_mat[j][i] = dist_mat[i][j];\n }\n }\n // Initialize min_dist with dist_mat\n min_dist = dist_mat;\n }\n\n void update_min_dist(int new_root, int old_root_u, int old_root_v) {\n // min_dist for the new component is the min of the two old components\n for (int c : active_roots) {\n if (c == new_root) continue;\n min_dist[new_root][c] = min(min_dist[old_root_u][c], min_dist[old_root_v][c]);\n min_dist[c][new_root] = min_dist[new_root][c];\n }\n }\n\n bool decide(int edge_idx, int l) {\n auto [u, v] = edges[edge_idx];\n int root_u = d.leader(u);\n int root_v = d.leader(v);\n\n // If already connected, must reject\n if (root_u == root_v) {\n return false;\n }\n\n int remaining_edges = m - edge_idx;\n\n // Decision logic\n bool take = false;\n if (remaining_edges <= num_components + desperation_threshold) {\n // Desperation mode: take any connecting edge to ensure completion\n take = true;\n } else {\n // Normal mode: use dynamic threshold\n int d_min = min_dist[root_u][root_v];\n \n // desperation_factor is 0 at start, approaches 1 at the end\n double desperation_factor = (double)(num_components - 1) / remaining_edges;\n double k = k_base - (k_base - 1.0) * desperation_factor;\n \n if (l <= k * d_min) {\n take = true;\n }\n }\n\n if (take) {\n // Update state\n d.merge(root_u, root_v);\n num_components--;\n\n int new_root = d.leader(u); // leader of either is fine after merge\n int old_root = (new_root == root_u) ? root_v : root_u;\n \n active_roots.erase(old_root);\n update_min_dist(new_root, root_u, root_v);\n }\n\n return take;\n }\n\n void run() {\n // Read initial input\n for (int i = 0; i < n; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n for (int i = 0; i < m; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n preprocess();\n\n // Main loop\n for (int i = 0; i < m; ++i) {\n int l;\n cin >> l;\n\n bool decision = decide(i, l);\n\n cout << (decision ? 1 : 0) << endl;\n cout.flush();\n }\n }\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n OnlineMST solver;\n solver.run();\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct State {\n int N, M;\n vector> pets, humans;\n vector pet_types;\n vector> impassable;\n vector pet_moves;\n int turn;\n \n void read() {\n cin >> N;\n pets.resize(N);\n pet_types.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].first >> pets[i].second >> pet_types[i];\n }\n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].first >> humans[i].second;\n }\n impassable.assign(31, vector(31, false));\n turn = 0;\n }\n \n void read_pet_moves() {\n pet_moves.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n }\n \n bool is_valid(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n bool is_passable(int x, int y) {\n return is_valid(x, y) && !impassable[x][y];\n }\n \n bool can_make_impassable(int x, int y) {\n if (!is_valid(x, y)) return false;\n \n // Check if pet is at this position at start of turn\n for (auto [px, py] : pets) {\n if (px == x && py == y) return false;\n // Check if pet is adjacent to this position\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return false;\n }\n \n // Check if human is at this position at start of turn\n for (auto [hx, hy] : humans) {\n if (hx == x && hy == y) return false;\n }\n \n return true;\n }\n \n vector> get_neighbors(int x, int y) {\n return {{x-1, y}, {x+1, y}, {x, y-1}, {x, y+1}};\n }\n \n string decide_actions() {\n string actions(M, '.');\n \n for (int i = 0; i < M; i++) {\n auto [hx, hy] = humans[i];\n \n // Simple strategy: try to build walls around nearby pets\n if (turn < 200) {\n // Find closest pet\n int min_dist = 1e9;\n int closest_pet = -1;\n \n for (int p = 0; p < N; p++) {\n auto [px, py] = pets[p];\n int dist = abs(px - hx) + abs(py - hy);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = p;\n }\n }\n \n if (closest_pet != -1 && min_dist <= 8) {\n auto [px, py] = pets[closest_pet];\n \n // Try to build a wall adjacent to human that blocks the pet\n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (can_make_impassable(nx, ny)) {\n // Check if this helps block the pet\n int pet_dist_after = abs(px - nx) + abs(py - ny);\n if (pet_dist_after <= min_dist + 1) {\n if (nx == hx-1) actions[i] = 'u';\n else if (nx == hx+1) actions[i] = 'd';\n else if (ny == hy-1) actions[i] = 'l';\n else if (ny == hy+1) actions[i] = 'r';\n break;\n }\n }\n }\n \n // If couldn't build wall, move towards pet\n if (actions[i] == '.') {\n // Find best move direction\n int best_dist = min_dist;\n char best_move = '.';\n \n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n int new_dist = abs(px - nx) + abs(py - ny);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n if (nx == hx-1) best_move = 'U';\n else if (nx == hx+1) best_move = 'D';\n else if (ny == hy-1) best_move = 'L';\n else if (ny == hy+1) best_move = 'R';\n }\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n } else {\n // Later turns: try to move to center of enclosed area\n // Simple random walk to find better position\n vector possible_moves;\n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n if (nx == hx-1) possible_moves.push_back('U');\n else if (nx == hx+1) possible_moves.push_back('D');\n else if (ny == hy-1) possible_moves.push_back('L');\n else if (ny == hy+1) possible_moves.push_back('R');\n }\n }\n \n if (!possible_moves.empty()) {\n // Prefer moving towards center\n int best_score = -1e9;\n char best_move = '.';\n \n for (char move : possible_moves) {\n int nx = hx, ny = hy;\n if (move == 'U') nx--;\n else if (move == 'D') nx++;\n else if (move == 'L') ny--;\n else if (move == 'R') ny++;\n \n // Simple heuristic: prefer positions closer to center\n int score = -abs(nx - 15) - abs(ny - 15);\n \n // Count nearby pets (avoid them)\n for (auto [px, py] : pets) {\n if (abs(px - nx) + abs(py - ny) <= 3) {\n score -= 10;\n }\n }\n \n if (score > best_score) {\n best_score = score;\n best_move = move;\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n }\n \n return actions;\n }\n \n void update_state(const string& actions) {\n // First, collect all impassable actions to apply simultaneously\n vector> to_make_impassable;\n \n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'u' || action == 'd' || action == 'l' || action == 'r') {\n int nx = hx, ny = hy;\n if (action == 'u') nx--;\n else if (action == 'd') nx++;\n else if (action == 'l') ny--;\n else if (action == 'r') ny++;\n \n if (can_make_impassable(nx, ny)) {\n to_make_impassable.push_back({nx, ny});\n }\n }\n }\n \n // Apply impassable changes\n for (auto [x, y] : to_make_impassable) {\n impassable[x][y] = true;\n }\n \n // Update human positions (they can't move to squares that became impassable this turn)\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int nx = hx, ny = hy;\n if (action == 'U') nx--;\n else if (action == 'D') nx++;\n else if (action == 'L') ny--;\n else if (action == 'R') ny++;\n \n // Check if this square wasn't made impassable this turn\n bool was_made_impassable = false;\n for (auto [x, y] : to_make_impassable) {\n if (x == nx && y == ny) {\n was_made_impassable = true;\n break;\n }\n }\n \n if (is_passable(nx, ny) && !was_made_impassable) {\n humans[i] = {nx, ny};\n }\n }\n }\n \n // Update pet positions based on their moves\n for (int i = 0; i < N; i++) {\n auto [px, py] = pets[i];\n for (char move : pet_moves[i]) {\n if (move == 'U' && is_passable(px-1, py)) px--;\n else if (move == 'D' && is_passable(px+1, py)) px++;\n else if (move == 'L' && is_passable(px, py-1)) py--;\n else if (move == 'R' && is_passable(px, py+1)) py++;\n }\n pets[i] = {px, py};\n }\n \n turn++;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n State state;\n state.read();\n \n for (int turn = 0; turn < 300; turn++) {\n string actions = state.decide_actions();\n cout << actions << endl;\n cout.flush();\n \n state.read_pet_moves();\n state.update_state(actions);\n }\n \n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n string path;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h(20), v(19);\n for (int i = 0; i < 20; i++) cin >> h[i];\n for (int i = 0; i < 19; i++) cin >> v[i];\n \n // Simple BFS to find shortest path\n auto find_path = [&]() {\n queue q;\n vector> visited(20, vector(20, false));\n \n q.push({si, sj, \"\"});\n visited[si][sj] = true;\n \n int dirs[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};\n string dir_chars = \"UDLR\";\n \n while (!q.empty()) {\n State cur = q.front();\n q.pop();\n \n if (cur.i == ti && cur.j == tj) {\n return cur.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int ni = cur.i + dirs[d][0];\n int nj = cur.j + dirs[d][1];\n \n if (ni < 0 || ni >= 20 || nj < 0 || nj >= 20) continue;\n if (visited[ni][nj]) continue;\n \n // Check wall\n bool blocked = false;\n if (d == 0 && v[cur.i-1][cur.j] == '1') blocked = true; // U\n else if (d == 1 && v[cur.i][cur.j] == '1') blocked = true; // D\n else if (d == 2 && h[cur.i][cur.j-1] == '1') blocked = true; // L\n else if (d == 3 && h[cur.i][cur.j] == '1') blocked = true; // R\n \n if (!blocked) {\n visited[ni][nj] = true;\n q.push({ni, nj, cur.path + dir_chars[d]});\n }\n }\n }\n \n return string();\n };\n \n string path = find_path();\n if (path.empty()) {\n cout << \"\" << endl;\n return 0;\n }\n \n // Build robust path with simple but effective strategy\n string robust_path = \"\";\n \n // Calculate repetition based on p and path length\n int base_repeat = max(2, min(5, (int)(p * 8)));\n \n // For very long paths, use fewer repetitions\n if (path.size() > 40) base_repeat = min(base_repeat, 3);\n if (path.size() > 60) base_repeat = min(base_repeat, 2);\n \n // Simple criticality: start, end, and direction changes\n vector critical(path.size(), 1);\n for (size_t i = 0; i < path.size(); i++) {\n if (i < 2 || i >= path.size() - 2) critical[i] = 3; // Start/end\n if (i > 0 && path[i] != path[i-1]) critical[i] = 2; // Direction change\n if (i < path.size() - 1 && path[i] != path[i+1]) critical[i] = 2; // Direction change\n }\n \n // Build robust path\n for (size_t i = 0; i < path.size(); i++) {\n int repeat = base_repeat;\n if (critical[i] >= 3) repeat++;\n if (critical[i] >= 2) repeat += (base_repeat > 2) ? 1 : 0;\n \n // Ensure we don't exceed length limit\n int remaining_moves = path.size() - i - 1;\n int max_possible = (200 - robust_path.size()) / max(1, remaining_moves + 1);\n repeat = min(repeat, max(1, max_possible));\n \n for (int j = 0; j < repeat; j++) {\n robust_path += path[i];\n }\n }\n \n // If we have extra space, add more redundancy to critical parts\n if (robust_path.size() < 180 && !path.empty()) {\n // Add the first few moves again (start is critical)\n int start_len = min(3, (int)path.size());\n for (int i = 0; i < start_len; i++) {\n if (robust_path.size() >= 200) break;\n robust_path += path[i];\n }\n \n // Add the last few moves again (end is critical)\n int end_start = max(0, (int)path.size() - 3);\n for (int i = end_start; i < path.size(); i++) {\n if (robust_path.size() >= 200) break;\n robust_path += path[i];\n }\n }\n \n // Final fill with most important moves\n while (robust_path.size() < 200 && !path.empty()) {\n // Add start and end moves preferentially\n if (!path.empty() && robust_path.size() < 200) {\n robust_path += path[0]; // First move\n }\n if (path.size() > 1 && robust_path.size() < 200) {\n robust_path += path.back(); // Last move\n }\n \n // Add any remaining critical moves\n for (size_t i = 1; i < path.size() - 1; i++) {\n if (robust_path.size() >= 200) break;\n if (critical[i] >= 2) {\n robust_path += path[i];\n }\n }\n \n if (robust_path.size() >= 200) break;\n \n // If still need more, add any move\n for (char c : path) {\n if (robust_path.size() >= 200) break;\n robust_path += c;\n }\n }\n \n cout << robust_path << endl;\n \n return 0;\n}","ahc010":"#include \nusing namespace std;\n\n// Directions: 0=left, 1=up, 2=right, 3=down\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Connection table: to[tile_type][entry_direction] = exit_direction\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// Precompute rotated tile types\nint rotated_tile[8][4];\n\nvoid init_rotated_tile() {\n for (int tile = 0; tile < 8; tile++) {\n for (int rot = 0; rot < 4; rot++) {\n if (tile <= 3) { // curved tiles\n rotated_tile[tile][rot] = (tile + rot) % 4;\n } else if (tile <= 5) { // double curved tiles\n rotated_tile[tile][rot] = tile + (rot % 2);\n } else { // straight tiles\n rotated_tile[tile][rot] = tile + (rot % 2);\n }\n }\n }\n}\n\nstruct Grid {\n int tiles[30][30]; // Original tile types\n int rotations[30][30]; // Current rotations (0-3)\n \n Grid() {}\n \n Grid(const vector& input) {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n tiles[i][j] = input[i][j] - '0';\n rotations[i][j] = 0;\n }\n }\n }\n \n int get_tile_type(int i, int j) const {\n return rotated_tile[tiles[i][j]][rotations[i][j]];\n }\n \n // Calculate loop length starting from (i,j) with entry direction d\n // Returns 0 if not a loop, otherwise returns loop length\n int calculate_loop_length(int si, int sj, int sd, bool visited[30][30][4]) {\n if (visited[si][sj][sd]) return 0;\n \n int i = si, j = sj, d = sd;\n int length = 0;\n visited[si][sj][sd] = 1;\n \n do {\n int tile_type = get_tile_type(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) {\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= 30 || j < 0 || j >= 30) {\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n d = (d2 + 2) % 4;\n length++;\n \n if (length > 900) { // Prevent infinite loops\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n } while (!(i == si && j == sj && d == sd));\n \n visited[si][sj][sd] = 0;\n return length;\n }\n \n // Find top two loop lengths\n pair find_top_loops() {\n bool visited[30][30][4] = {false};\n vector loops;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n if (!visited[i][j][d]) {\n int length = calculate_loop_length(i, j, d, visited);\n if (length > 0) {\n loops.push_back(length);\n }\n }\n }\n }\n }\n \n sort(loops.rbegin(), loops.rend());\n \n if (loops.size() < 2) return {0, 0};\n \n // Remove duplicates (same loop might be found from multiple starting points)\n vector unique_loops;\n for (int i = 0; i < loops.size(); i++) {\n bool is_duplicate = false;\n for (int j = 0; j < i; j++) {\n if (loops[i] == loops[j]) {\n is_duplicate = true;\n break;\n }\n }\n if (!is_duplicate) {\n unique_loops.push_back(loops[i]);\n }\n }\n \n if (unique_loops.size() < 2) return {0, 0};\n \n return {unique_loops[0], unique_loops[1]};\n }\n \n long long calculate_score() {\n auto [l1, l2] = find_top_loops();\n return (long long)l1 * l2;\n }\n \n void randomize_rotations() {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rotations[i][j] = dis(gen);\n }\n }\n }\n \n void hill_climb(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n if (new_score > best_score) {\n best_score = new_score;\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n string get_output() const {\n string result;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n result += to_string(rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n init_rotated_tile();\n \n vector input(30);\n for (int i = 0; i < 30; i++) {\n cin >> input[i];\n }\n \n Grid grid(input);\n \n // Try multiple random initializations and keep the best\n long long best_score = 0;\n string best_output;\n \n for (int attempt = 0; attempt < 3; attempt++) { // Further reduced attempts\n grid.randomize_rotations();\n \n // Reduced iterations for optimization\n grid.hill_climb(2000); // Further reduced\n \n long long current_score = grid.calculate_score();\n if (current_score > best_score) {\n best_score = current_score;\n best_output = grid.get_output();\n }\n }\n \n cout << best_output << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct UnionFind {\n vector p, r;\n UnionFind(int n) : p(n), r(n, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (r[x] < r[y]) p[x] = y;\n else { p[y] = x; if (r[x] == r[y]) r[x]++; }\n }\n};\n\nclass Solver {\npublic:\n Solver(int n, int t, const vector& grid) : N(n), T(t) {\n board.resize(N, vector(N, 0));\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n char ch = grid[r][c];\n if (ch >= '0' && ch <= '9') {\n board[r][c] = ch - '0';\n } else {\n board[r][c] = 10 + (ch - 'a');\n }\n if (board[r][c] == 0) {\n empty_r = r;\n empty_c = c;\n }\n }\n }\n }\n\n string solve() {\n auto start_time = chrono::high_resolution_clock::now();\n \n // Phase 1: Long Random Walk\n vector> walk_board = board;\n int walk_er = empty_r, walk_ec = empty_c;\n string walk_path;\n\n vector> best_S_board = walk_board;\n string best_S_path = \"\";\n int best_S_score = calculate_S_score(walk_board);\n\n mt19937 rng(random_device{}());\n int max_steps = T / 2;\n for (int i = 0; i < max_steps; ++i) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.5) break;\n\n vector possible_moves;\n // CORRECTED LOGIC: Check based on tile to be moved\n if (walk_er > 0) possible_moves.push_back('U'); // Tile above can move down\n if (walk_er < N - 1) possible_moves.push_back('D'); // Tile below can move up\n if (walk_ec > 0) possible_moves.push_back('L'); // Tile to left can move right\n if (walk_ec < N - 1) possible_moves.push_back('R'); // Tile to right can move left\n\n if (possible_moves.empty()) break;\n\n char m = possible_moves[rng() % possible_moves.size()];\n apply_move(m, walk_board, walk_er, walk_ec);\n walk_path += m;\n\n int current_S_score = calculate_S_score(walk_board);\n if (current_S_score > best_S_score) {\n best_S_score = current_S_score;\n best_S_board = walk_board;\n best_S_path = walk_path;\n }\n }\n\n // Phase 2: Local Refinement with S_score heuristic\n vector> lr_board = best_S_board;\n int lr_er = -1, lr_ec = -1;\n for(int r=0; r(current_time - start_time).count();\n if (elapsed > 2.9) break;\n\n char best_move = ' ';\n int best_delta_S = -1;\n vector possible_moves;\n\n // CORRECTED LOGIC: Check based on tile to be moved\n if (lr_er > 0) possible_moves.push_back('U');\n if (lr_er < N - 1) possible_moves.push_back('D');\n if (lr_ec > 0) possible_moves.push_back('L');\n if (lr_ec < N - 1) possible_moves.push_back('R');\n \n for(char m : possible_moves) {\n vector> temp_board = lr_board;\n int temp_er = lr_er, temp_ec = lr_ec;\n apply_move(m, temp_board, temp_er, temp_ec);\n \n int new_S = calculate_S_score(temp_board);\n int delta_S = new_S - current_S;\n \n if (delta_S > best_delta_S) {\n best_delta_S = delta_S;\n best_move = m;\n }\n }\n\n if (best_delta_S > 0) {\n apply_move(best_move, lr_board, lr_er, lr_ec);\n lr_path.push_back(best_move);\n current_S += best_delta_S;\n } else {\n break; // Local optimum\n }\n }\n\n string final_path = best_S_path + lr_path;\n if (final_path.length() > T) {\n final_path = final_path.substr(0, T);\n }\n\n return final_path;\n }\n\nprivate:\n int N, T;\n vector> board;\n int empty_r, empty_c;\n\n int calculate_S_score(const vector>& b) {\n UnionFind uf(N * N);\n vector num_edges(N * N, 0);\n vector component_size(N * N, 0);\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] == 0) continue;\n int u = r * N + c;\n component_size[uf.find(u)]++;\n\n if (r > 0 && b[r-1][c] != 0 && (b[r][c] & 2) && (b[r-1][c] & 8)) {\n int v = (r-1) * N + c;\n int ru = uf.find(u), rv = uf.find(v);\n if (ru != rv) {\n uf.unite(u, v);\n int new_root = uf.find(u);\n component_size[new_root] = component_size[ru] + component_size[rv];\n num_edges[new_root] = num_edges[ru] + num_edges[rv] + 1;\n } else {\n num_edges[ru]++;\n }\n }\n if (c > 0 && b[r][c-1] != 0 && (b[r][c] & 1) && (b[r][c-1] & 4)) {\n int v = r * N + (c-1);\n int ru = uf.find(u), rv = uf.find(v);\n if (ru != rv) {\n uf.unite(u, v);\n int new_root = uf.find(u);\n component_size[new_root] = component_size[ru] + component_size[rv];\n num_edges[new_root] = num_edges[ru] + num_edges[rv] + 1;\n } else {\n num_edges[ru]++;\n }\n }\n }\n }\n \n int max_S = 0;\n for (int i = 0; i < N * N; ++i) {\n if (uf.find(i) == i && component_size[i] > 0) {\n if (num_edges[i] == component_size[i] - 1) {\n max_S = max(max_S, component_size[i]);\n }\n }\n }\n return max_S;\n }\n\n\n void apply_move(char m, vector>& b, int& er, int& ec) {\n int tr = er, tc = ec;\n // CORRECTED LOGIC: 'U' moves the tile at (er-1, ec) into the empty space\n if (m == 'U') tr--;\n else if (m == 'D') tr++;\n else if (m == 'L') tc--;\n else if (m == 'R') tc++;\n\n if (tr >= 0 && tr < N && tc >= 0 && tc < N) {\n swap(b[er][ec], b[tr][tc]);\n er = tr;\n ec = tc;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, T;\n cin >> N >> T;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n Solver solver(N, T, grid);\n string ans = solver.solve();\n cout << ans << endl;\n\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nconst long double EPS = 1e-9;\nconst long long COORD_MAX = 1e9;\nconst int N_RANDOM_TRIALS = 5; // Reduced to make room for more local search\nconst int LOCAL_SEARCH_ITER_STAGE_1 = 1000;\nconst int LOCAL_SEARCH_ITER_STAGE_2 = 2000;\n\nstruct Point {\n long long x, y;\n Point(long long x = 0, long long y = 0) : x(x), y(y) {}\n};\n\nstruct Line {\n Point p1, p2;\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\nlong long cross(const Point& a, const Point& b) {\n return a.x * b.y - a.y * b.x;\n}\n\nint get_side(const Point& a, const Point& p1, const Point& p2) {\n Point v1 = {a.x - p1.x, a.y - p1.y};\n Point v2 = {p2.x - p1.x, p2.y - p1.y};\n long long c = cross(v1, v2);\n if (c > 0) return 1;\n if (c < 0) return -1;\n return 0;\n}\n\nlong long calculate_score(const vector& points, const vector& a, const vector& cuts) {\n int K = cuts.size();\n if (K == 0) return 0;\n\n vector b(11, 0);\n unordered_map signature_counts;\n \n for (const auto& p : points) {\n long long signature = 0;\n bool is_cut = false;\n for (int i = 0; i < K; ++i) {\n int side = get_side(p, cuts[i].p1, cuts[i].p2);\n if (side == 0) {\n is_cut = true;\n break;\n }\n if (side == 1) {\n signature |= (1LL << i);\n }\n }\n if (!is_cut) {\n signature_counts[signature]++;\n }\n }\n\n for (const auto& pair : signature_counts) {\n int count = pair.second;\n if (count >= 1 && count <= 10) {\n b[count]++;\n }\n }\n\n long long sum_min = 0;\n long long sum_a = 0;\n for (int d = 1; d <= 10; ++d) {\n sum_min += min(a[d], b[d]);\n sum_a += a[d];\n }\n\n if (sum_a == 0) return 0;\n return (long long)round(1e6 * (long double)sum_min / sum_a);\n}\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, K;\n cin >> N >> K;\n K = 100;\n\n vector a(11);\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n\n vector points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n\n long long best_score = -1;\n vector best_cuts;\n uniform_int_distribution dist_large(-100000, 100000);\n uniform_int_distribution dist_k(0, K - 1);\n\n // Phase 1: Global Random Search\n for (int trial = 0; trial < N_RANDOM_TRIALS; ++trial) {\n vector current_cuts;\n current_cuts.reserve(K);\n for (int i = 0; i < K; ++i) {\n Point p1, p2;\n do {\n p1 = {dist_large(rng), dist_large(rng)};\n p2 = {dist_large(rng), dist_large(rng)};\n } while (p1.x == p2.x && p1.y == p2.y);\n current_cuts.emplace_back(p1, p2);\n }\n long long current_score = calculate_score(points, a, current_cuts);\n if (current_score > best_score) {\n best_score = current_score;\n best_cuts = current_cuts;\n }\n }\n\n // Phase 2: Adaptive Local Search (Hill Climbing)\n vector current_cuts = best_cuts;\n long long current_score = best_score;\n bool improved_in_stage_1 = false;\n\n for (int iter = 0; iter < LOCAL_SEARCH_ITER_STAGE_1; ++iter) {\n vector new_cuts = current_cuts;\n int line_to_replace = dist_k(rng);\n Point p1, p2;\n do {\n p1 = {dist_large(rng), dist_large(rng)};\n p2 = {dist_large(rng), dist_large(rng)};\n } while (p1.x == p2.x && p1.y == p2.y);\n new_cuts[line_to_replace] = Line(p1, p2);\n\n long long new_score = calculate_score(points, a, new_cuts);\n if (new_score > current_score) {\n current_cuts = new_cuts;\n current_score = new_score;\n improved_in_stage_1 = true;\n }\n if (current_score > best_score) {\n best_score = current_score;\n best_cuts = current_cuts;\n }\n }\n\n // If we found an improvement, try for a longer period\n if (improved_in_stage_1) {\n for (int iter = 0; iter < LOCAL_SEARCH_ITER_STAGE_2; ++iter) {\n vector new_cuts = current_cuts;\n int line_to_replace = dist_k(rng);\n Point p1, p2;\n do {\n p1 = {dist_large(rng), dist_large(rng)};\n p2 = {dist_large(rng), dist_large(rng)};\n } while (p1.x == p2.x && p1.y == p2.y);\n new_cuts[line_to_replace] = Line(p1, p2);\n\n long long new_score = calculate_score(points, a, new_cuts);\n if (new_score > current_score) {\n current_cuts = new_cuts;\n current_score = new_score;\n }\n if (current_score > best_score) {\n best_score = current_score;\n best_cuts = current_cuts;\n }\n }\n }\n\n cout << best_cuts.size() << endl;\n for (const auto& cut : best_cuts) {\n cout << cut.p1.x << \" \" << cut.p1.y << \" \" << cut.p2.x << \" \" << cut.p2.y << \"\\n\";\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc014":"#include \n#include \n#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 bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n Point p1, p2, p3, p4;\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_dots(M);\n set dots;\n map> x_to_ys;\n map> y_to_xs;\n \n for (int i = 0; i < M; i++) {\n cin >> initial_dots[i].x >> initial_dots[i].y;\n dots.insert(initial_dots[i]);\n x_to_ys[initial_dots[i].x].push_back(initial_dots[i].y);\n y_to_xs[initial_dots[i].y].push_back(initial_dots[i].x);\n }\n\n for (auto& [x, ys] : x_to_ys) {\n sort(ys.begin(), ys.end());\n }\n for (auto& [y, xs] : y_to_xs) {\n sort(xs.begin(), xs.end());\n }\n\n int c = (N - 1) / 2;\n auto weight = [c](int x, int y) {\n return (x - c) * (x - c) + (y - c) * (y - c) + 1;\n };\n\n // Create list of all empty points sorted by weight (descending)\n vector> empty_points;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (dots.find({x, y}) == dots.end()) {\n empty_points.push_back({weight(x, y), {x, y}});\n }\n }\n }\n sort(empty_points.rbegin(), empty_points.rend());\n\n vector operations;\n\n set> used_segments;\n\n auto is_segment_used = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n if (used_segments.count({x1, y, x1, y+1}) > 0 ||\n used_segments.count({x1, y+1, x1, y}) > 0) {\n return true;\n }\n }\n } else if (y1 == y2) {\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n if (used_segments.count({x, y1, x+1, y1}) > 0 ||\n used_segments.count({x+1, y1, x, y1}) > 0) {\n return true;\n }\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n if (used_segments.count({x, y, x+dx, y+dy}) > 0 ||\n used_segments.count({x+dx, y+dy, x, y}) > 0) {\n return true;\n }\n x += dx;\n y += dy;\n }\n }\n return false;\n };\n\n auto add_segments = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n used_segments.insert({x1, y, x1, y+1});\n used_segments.insert({x1, y+1, x1, y});\n }\n } else if (y1 == y2) {\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n used_segments.insert({x, y1, x+1, y1});\n used_segments.insert({x+1, y1, x, y1});\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n used_segments.insert({x, y, x+dx, y+dy});\n used_segments.insert({x+dx, y+dy, x, y});\n x += dx;\n y += dy;\n }\n }\n };\n\n auto has_dot = [&dots](int x, int y) {\n return dots.count({x, y}) > 0;\n };\n\n auto is_valid_rectangle = [&](Point p1, Point p2, Point p3, Point p4) {\n if (p1.x < 0 || p1.x >= N || p1.y < 0 || p1.y >= N) return false;\n if (p2.x < 0 || p2.x >= N || p2.y < 0 || p2.y >= N) return false;\n if (p3.x < 0 || p3.x >= N || p3.y < 0 || p3.y >= N) return false;\n if (p4.x < 0 || p4.x >= N || p4.y < 0 || p4.y >= N) return false;\n \n if (has_dot(p1.x, p1.y)) return false;\n if (!has_dot(p2.x, p2.y) || !has_dot(p3.x, p3.y) || !has_dot(p4.x, p4.y)) return false;\n \n if (is_segment_used(p1.x, p1.y, p2.x, p2.y) ||\n is_segment_used(p2.x, p2.y, p3.x, p3.y) ||\n is_segment_used(p3.x, p3.y, p4.x, p4.y) ||\n is_segment_used(p4.x, p4.y, p1.x, p1.y)) {\n return false;\n }\n \n // Check edge p1-p2\n if (p1.x == p2.x) {\n int y_start = min(p1.y, p2.y);\n int y_end = max(p1.y, p2.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p1.x, y)) return false;\n }\n } else if (p1.y == p2.y) {\n int x_start = min(p1.x, p2.x);\n int x_end = max(p1.x, p2.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p1.y)) return false;\n }\n } else if (abs(p2.x - p1.x) == abs(p2.y - p1.y)) {\n int dx = (p2.x > p1.x) ? 1 : -1;\n int dy = (p2.y > p1.y) ? 1 : -1;\n int x = p1.x + dx, y = p1.y + dy;\n while (x != p2.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p2-p3\n if (p2.x == p3.x) {\n int y_start = min(p2.y, p3.y);\n int y_end = max(p2.y, p3.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p2.x, y)) return false;\n }\n } else if (p2.y == p3.y) {\n int x_start = min(p2.x, p3.x);\n int x_end = max(p2.x, p3.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p2.y)) return false;\n }\n } else if (abs(p3.x - p2.x) == abs(p3.y - p2.y)) {\n int dx = (p3.x > p2.x) ? 1 : -1;\n int dy = (p3.y > p2.y) ? 1 : -1;\n int x = p2.x + dx, y = p2.y + dy;\n while (x != p3.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p3-p4\n if (p3.x == p4.x) {\n int y_start = min(p3.y, p4.y);\n int y_end = max(p3.y, p4.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p3.x, y)) return false;\n }\n } else if (p3.y == p4.y) {\n int x_start = min(p3.x, p4.x);\n int x_end = max(p3.x, p4.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p3.y)) return false;\n }\n } else if (abs(p4.x - p3.x) == abs(p4.y - p3.y)) {\n int dx = (p4.x > p3.x) ? 1 : -1;\n int dy = (p4.y > p3.y) ? 1 : -1;\n int x = p3.x + dx, y = p3.y + dy;\n while (x != p4.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p4-p1\n if (p4.x == p1.x) {\n int y_start = min(p4.y, p1.y);\n int y_end = max(p4.y, p1.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p4.x, y)) return false;\n }\n } else if (p4.y == p1.y) {\n int x_start = min(p4.x, p1.x);\n int x_end = max(p4.x, p1.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p4.y)) return false;\n }\n } else if (abs(p1.x - p4.x) == abs(p1.y - p4.y)) {\n int dx = (p1.x > p4.x) ? 1 : -1;\n int dy = (p1.y > p4.y) ? 1 : -1;\n int x = p4.x + dx, y = p4.y + dy;\n while (x != p1.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n return true;\n };\n\n mt19937 rng(random_device{}());\n \n // Adaptive search: try different strategies\n for (int strategy = 0; strategy < 2; strategy++) {\n // Strategy 0: prioritize axis-aligned, then diamonds\n // Strategy 1: prioritize diamonds, then axis-aligned\n \n for (const auto& [w, p] : empty_points) {\n bool found = false;\n Rectangle rect;\n\n if (strategy == 0) {\n // Try axis-aligned first\n vector> search_order;\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend());\n \n for (const auto& [dist, x2] : search_order) {\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n Rectangle candidate = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n }\n }\n if (found) break;\n }\n\n // Then try diamonds\n if (!found) {\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) {\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n vector> diamonds;\n \n if (p.y - 2*d >= 0 && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}});\n }\n if (p.y + 2*d < N && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}});\n }\n if (p.x - 2*d >= 0 && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}});\n }\n if (p.x + 2*d < N && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}});\n }\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n Rectangle candidate = {diamond[0], diamond[1], diamond[2], diamond[3]};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n if (found) break;\n }\n }\n } else {\n // Strategy 1: Try diamonds first\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) {\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n vector> diamonds;\n \n if (p.y - 2*d >= 0 && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}});\n }\n if (p.y + 2*d < N && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}});\n }\n if (p.x - 2*d >= 0 && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}});\n }\n if (p.x + 2*d < N && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}});\n }\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n Rectangle candidate = {diamond[0], diamond[1], diamond[2], diamond[3]};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n if (found) break;\n }\n\n // Then try axis-aligned\n if (!found) {\n vector> search_order;\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend());\n \n for (const auto& [dist, x2] : search_order) {\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n Rectangle candidate = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n }\n }\n if (found) break;\n }\n }\n }\n\n if (found) {\n operations.push_back(rect);\n dots.insert(rect.p1);\n \n x_to_ys[rect.p1.x].push_back(rect.p1.y);\n y_to_xs[rect.p1.y].push_back(rect.p1.x);\n sort(x_to_ys[rect.p1.x].begin(), x_to_ys[rect.p1.x].end());\n sort(y_to_xs[rect.p1.y].begin(), y_to_xs[rect.p1.y].end());\n \n add_segments(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);\n add_segments(rect.p2.x, rect.p2.y, rect.p3.x, rect.p3.y);\n add_segments(rect.p3.x, rect.p3.y, rect.p4.x, rect.p4.y);\n add_segments(rect.p4.x, rect.p4.y, rect.p1.x, rect.p1.y);\n }\n\n // Adaptive early termination\n if (operations.size() >= 2500) break;\n }\n }\n\n cout << operations.size() << \"\\n\";\n for (const auto& rect : operations) {\n cout << rect.p1.x << \" \" << rect.p1.y << \" \";\n cout << rect.p2.x << \" \" << rect.p2.y << \" \";\n cout << rect.p3.x << \" \" << rect.p3.y << \" \";\n cout << rect.p4.x << \" \" << rect.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nconst int N = 10;\nconst int DIRECTIONS = 4;\nconst int EMPTY = 0;\nconst int TURNS = 100;\n\nstruct Cell {\n int flavor;\n int x, y;\n Cell() : flavor(EMPTY), x(-1), y(-1) {}\n Cell(int f, int x, int y) : flavor(f), x(x), y(y) {}\n};\n\nclass Grid {\nprivate:\n vector> grid;\n vector candies;\n \npublic:\n Grid() : grid(N, vector(N, EMPTY)) {}\n \n void add_candy(int flavor, int x, int y) {\n grid[x][y] = flavor;\n candies.emplace_back(flavor, x, y);\n }\n \n void tilt(char direction) {\n vector> new_grid(N, vector(N, EMPTY));\n vector new_candies;\n \n int dx = 0, dy = 0;\n if (direction == 'F') dx = -1;\n else if (direction == 'B') dx = 1;\n else if (direction == 'L') dy = -1;\n else if (direction == 'R') dy = 1;\n \n // Determine order of processing to avoid collisions\n vector indices(candies.size());\n iota(indices.begin(), indices.end(), 0);\n \n if (direction == 'F') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].x < candies[b].x;\n });\n } else if (direction == 'B') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].x > candies[b].x;\n });\n } else if (direction == 'L') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].y < candies[b].y;\n });\n } else if (direction == 'R') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].y > candies[b].y;\n });\n }\n \n for (int idx : indices) {\n const auto& candy = candies[idx];\n int x = candy.x;\n int y = candy.y;\n \n // Move until hitting edge or another candy\n while (true) {\n int nx = x + dx;\n int ny = y + dy;\n \n if (nx < 0 || nx >= N || ny < 0 || ny >= N || new_grid[nx][ny] != EMPTY) {\n break;\n }\n \n x = nx;\n y = ny;\n }\n \n new_grid[x][y] = candy.flavor;\n new_candies.emplace_back(candy.flavor, x, y);\n }\n \n grid = move(new_grid);\n candies = move(new_candies);\n }\n \n const vector& get_candies() const { return candies; }\n const vector>& get_grid() const { return grid; }\n \n void clear() {\n grid.assign(N, vector(N, EMPTY));\n candies.clear();\n }\n};\n\nclass Strategy {\nprotected:\n vector flavors;\n Grid grid;\n int turn;\n vector corner_directions;\n mt19937 rng;\n vector flavor_counts;\n \npublic:\n Strategy(const vector& f) : flavors(f), turn(0), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n flavor_counts.resize(3, 0);\n for (int f : flavors) {\n flavor_counts[f-1]++;\n }\n \n // Fixed corner assignment based on flavor\n corner_directions = {'L', 'R', 'B'};\n }\n \n virtual ~Strategy() {}\n \n void add_candy(int p) {\n // Convert p to (x, y) coordinates\n int empty_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid.get_grid()[i][j] == EMPTY) {\n empty_count++;\n if (empty_count == p) {\n grid.add_candy(flavors[turn], i, j);\n return;\n }\n }\n }\n }\n }\n \n void apply_tilt(char direction) {\n grid.tilt(direction);\n turn++;\n }\n \n const Grid& get_grid() const { return grid; }\n \n vector get_component_stats(int flavor) const {\n const auto& g = grid.get_grid();\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (g[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && g[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n component_sizes.push_back(size);\n }\n }\n }\n \n return component_sizes;\n }\n \n double evaluate_tilt(char direction) {\n Grid test_grid = grid;\n test_grid.tilt(direction);\n \n int flavor = flavors[turn];\n double score = 0.0;\n \n // Get component statistics\n auto component_sizes = get_component_stats_for_grid(test_grid, flavor);\n \n if (component_sizes.empty()) return 0.0;\n \n int components = component_sizes.size();\n int largest = *max_element(component_sizes.begin(), component_sizes.end());\n \n // Component connectivity score (most important)\n score += 200.0 / components;\n score += largest * 15.0;\n \n // Distance to assigned corner\n char corner_dir = corner_directions[flavor-1];\n int target_x = -1, target_y = -1;\n \n if (corner_dir == 'F') { target_x = 0; }\n else if (corner_dir == 'B') { target_x = N-1; }\n else if (corner_dir == 'L') { target_y = 0; }\n else if (corner_dir == 'R') { target_y = N-1; }\n \n const auto& test_candies = test_grid.get_candies();\n for (const auto& candy : test_candies) {\n if (candy.flavor == flavor) {\n double dist = 0.0;\n if (target_x != -1) dist += abs(candy.x - target_x);\n if (target_y != -1) dist += abs(candy.y - target_y);\n score += 100.0 / (1.0 + dist);\n break;\n }\n }\n \n return score;\n }\n \n vector get_component_stats_for_grid(const Grid& g, int flavor) const {\n const auto& grid_state = g.get_grid();\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid_state[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid_state[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n component_sizes.push_back(size);\n }\n }\n }\n \n return component_sizes;\n }\n \n virtual char decide_tilt(int p) = 0;\n};\n\nclass SimpleStrategy : public Strategy {\nprivate:\n vector turn_thresholds = {30, 80};\n \npublic:\n SimpleStrategy(const vector& f) : Strategy(f) {}\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n int flavor = flavors[turn];\n \n // Early game: push to corners\n if (turn < turn_thresholds[0]) {\n return corner_directions[flavor-1];\n }\n \n // Mid game: use heuristic evaluation\n if (turn < turn_thresholds[1]) {\n char best_dir = 'F';\n double best_score = -1e9;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n double score = evaluate_tilt(dir);\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n \n // Late game: focus on connecting components\n char best_dir = 'F';\n int min_components = 1e9;\n int max_largest = 0;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n Grid test_grid = grid;\n test_grid.tilt(dir);\n \n auto component_sizes = get_component_stats_for_grid(test_grid, flavor);\n int components = component_sizes.size();\n int largest = component_sizes.empty() ? 0 : *max_element(component_sizes.begin(), component_sizes.end());\n \n if (components < min_components || \n (components == min_components && largest > max_largest)) {\n min_components = components;\n max_largest = largest;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n SimpleStrategy strategy(flavors);\n \n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n \n if (t < 99) {\n char tilt = strategy.decide_tilt(p);\n strategy.apply_tilt(tilt);\n cout << tilt << endl;\n cout.flush();\n } else {\n strategy.decide_tilt(p);\n }\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct GraphFeatures {\n int edge_count;\n double avg_degree;\n int max_degree;\n double degree_variance;\n int triangles;\n int components;\n double clustering_coeff;\n int diameter;\n vector degree_sequence;\n int connected_triplets;\n double assortativity;\n};\n\nvector> parse_graph(const string& s, int N) {\n vector> adj(N, vector(N, 0));\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n adj[i][j] = adj[j][i] = (s[idx++] == '1');\n }\n }\n return adj;\n}\n\nint bfs_farthest(const vector>& adj, int start, vector& dist) {\n int N = adj.size();\n dist.assign(N, -1);\n queue q;\n dist[start] = 0;\n q.push(start);\n \n int farthest = start;\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n for (int u = 0; u < N; u++) {\n if (adj[v][u] && dist[u] == -1) {\n dist[u] = dist[v] + 1;\n q.push(u);\n if (dist[u] > dist[farthest]) {\n farthest = u;\n }\n }\n }\n }\n return farthest;\n}\n\nint compute_diameter(const vector>& adj) {\n vector dist;\n int far = bfs_farthest(adj, 0, dist);\n far = bfs_farthest(adj, far, dist);\n return *max_element(dist.begin(), dist.end());\n}\n\ndouble compute_assortativity(const vector>& adj, const vector& degree) {\n int N = adj.size();\n double sum1 = 0, sum2 = 0, sum3 = 0;\n int total_edges = 0;\n \n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n sum1 += degree[i] * degree[j];\n sum2 += degree[i] + degree[j];\n sum3 += degree[i] * degree[i] + degree[j] * degree[j];\n total_edges++;\n }\n }\n }\n \n if (total_edges == 0) return 0;\n \n double avg_prod = sum1 / total_edges;\n double avg_sum = sum2 / (2 * total_edges);\n double avg_sq = sum3 / (2 * total_edges);\n \n double numerator = avg_prod - avg_sum * avg_sum;\n double denominator = avg_sq - avg_sum * avg_sum;\n \n return (denominator > 0) ? numerator / denominator : 0;\n}\n\nGraphFeatures extract_features(const vector>& adj) {\n int N = adj.size();\n GraphFeatures f;\n \n // Edge count and degrees\n f.edge_count = 0;\n f.degree_sequence.resize(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n f.edge_count++;\n f.degree_sequence[i]++;\n f.degree_sequence[j]++;\n }\n }\n }\n \n // Degree statistics\n f.avg_degree = 2.0 * f.edge_count / N;\n f.max_degree = *max_element(f.degree_sequence.begin(), f.degree_sequence.end());\n \n double sum_sq = 0;\n for (int d : f.degree_sequence) {\n sum_sq += (d - f.avg_degree) * (d - f.avg_degree);\n }\n f.degree_variance = sum_sq / N;\n \n // Sort degree sequence for comparison\n sort(f.degree_sequence.begin(), f.degree_sequence.end());\n \n // Triangles and connected triplets\n f.triangles = 0;\n f.connected_triplets = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n int edges_ij = adj[i][j];\n int edges_ik = adj[i][k];\n int edges_jk = adj[j][k];\n int total_edges = edges_ij + edges_ik + edges_jk;\n \n if (total_edges == 3) {\n f.triangles++;\n }\n if (total_edges >= 2) {\n f.connected_triplets++;\n }\n }\n }\n }\n }\n \n // Components\n vector visited(N, false);\n f.components = 0;\n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n f.components++;\n vector stack = {i};\n visited[i] = true;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n for (int u = 0; u < N; u++) {\n if (adj[v][u] && !visited[u]) {\n visited[u] = true;\n stack.push_back(u);\n }\n }\n }\n }\n }\n \n // Clustering coefficient\n double total_clustering = 0;\n int count = 0;\n for (int i = 0; i < N; i++) {\n if (f.degree_sequence[i] >= 2) {\n int neighbor_pairs = 0;\n int connected_pairs = 0;\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k]) {\n neighbor_pairs++;\n if (adj[j][k]) {\n connected_pairs++;\n }\n }\n }\n }\n }\n if (neighbor_pairs > 0) {\n total_clustering += 2.0 * connected_pairs / neighbor_pairs;\n count++;\n }\n }\n }\n f.clustering_coeff = (count > 0) ? total_clustering / count : 0;\n \n // Diameter (for connected components)\n if (f.components == 1) {\n f.diameter = compute_diameter(adj);\n } else {\n f.diameter = N; // Large value for disconnected graphs\n }\n \n // Assortativity\n f.assortativity = compute_assortativity(adj, f.degree_sequence);\n \n return f;\n}\n\nstring generate_balanced_graph(int N, int graph_id, int M, mt19937& rng) {\n int total_possible = N * (N - 1) / 2;\n string graph(total_possible, '0');\n \n // Create distinct but balanced graph structures\n int type = graph_id % 7;\n int density = (graph_id * 100) / max(1, M);\n \n switch (type) {\n case 0: // Sparse random with structure\n {\n double p = 0.08 + 0.15 * density / 100.0;\n for (int i = 0; i < total_possible; i++) {\n if (rng() % 1000 < p * 1000) {\n graph[i] = '1';\n }\n }\n // Add some structure\n for (int i = 0; i < min(N/4, 5); i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n case 1: // Dense random with structure\n {\n double p = 0.65 + 0.30 * density / 100.0;\n for (int i = 0; i < total_possible; i++) {\n if (rng() % 1000 < p * 1000) {\n graph[i] = '1';\n }\n }\n // Remove some edges to create structure\n int remove_count = min(N/3, 8);\n for (int i = 0; i < remove_count; i++) {\n int idx = rng() % total_possible;\n graph[idx] = '0';\n }\n break;\n }\n case 2: // Star-like with extra edges\n {\n int center = rng() % N;\n int star_edges = min(N - 1, 4 + density / 12);\n for (int i = 0; i < N && star_edges > 0; i++) {\n if (i != center) {\n int u = min(center, i);\n int v = max(center, i);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n star_edges--;\n }\n }\n // Add connections between leaves\n int extra = density / 20;\n for (int i = 0; i < extra; i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v && u != center && v != center) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n case 3: // Moderate components\n {\n int num_components = 2 + (graph_id % 2);\n int comp_size = N / num_components;\n for (int c = 0; c < num_components; c++) {\n int start = c * comp_size;\n int end = (c == num_components - 1) ? N : (c + 1) * comp_size;\n int comp_edges = (end - start) * (end - start - 1) / 3; // Moderate density\n vector indices;\n for (int i = start; i < end; i++) {\n for (int j = i + 1; j < end; j++) {\n int idx = i * (2 * N - i - 1) / 2 + j - i - 1;\n indices.push_back(idx);\n }\n }\n shuffle(indices.begin(), indices.end(), rng);\n int limit = min(comp_edges, (int)indices.size());\n for (int i = 0; i < limit; i++) {\n graph[indices[i]] = '1';\n }\n }\n break;\n }\n case 4: // Bipartite with some structure\n {\n int part1 = N / 3 + (graph_id % (N / 4));\n int part2 = N - part1;\n int edges = (part1 * part2 * density) / 120;\n vector indices;\n for (int i = 0; i < part1; i++) {\n for (int j = part1; j < N; j++) {\n int idx = i * (2 * N - i - 1) / 2 + j - i - 1;\n indices.push_back(idx);\n }\n }\n shuffle(indices.begin(), indices.end(), rng);\n int limit = min(edges, (int)indices.size());\n for (int i = 0; i < limit; i++) {\n graph[indices[i]] = '1';\n }\n // Add some within-part edges\n int within_edges = density / 30;\n for (int i = 0; i < within_edges; i++) {\n int part = rng() % 2;\n int start = (part == 0) ? 0 : part1;\n int end = (part == 0) ? part1 : N;\n if (end - start > 1) {\n int u = start + rng() % (end - start);\n int v = start + rng() % (end - start);\n if (u != v) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n }\n break;\n }\n case 5: // Ring with some chords\n {\n // Create a ring\n for (int i = 0; i < N; i++) {\n int j = (i + 1) % N;\n int u = min(i, j);\n int v = max(i, j);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n // Add chords\n int chords = density / 15;\n for (int i = 0; i < chords; i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v && abs(u - v) > 1 && abs(u - v) < N - 1) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n case 6: // Tree-like with extra edges\n {\n vector parent(N, -1);\n for (int i = 1; i < N; i++) {\n parent[i] = rng() % i;\n int u = min(i, parent[i]);\n int v = max(i, parent[i]);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n // Add some extra edges\n int extra = density / 25;\n for (int i = 0; i < extra; i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n }\n \n return graph;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Conservative N selection for balance\n int N = min(45, max(10, M / 2 + 8));\n if (epsilon > 0.15) {\n N = min(65, max(12, M / 2 + 12));\n }\n if (epsilon > 0.25) {\n N = min(85, max(16, M / 2 + 16));\n }\n \n cout << N << endl;\n cout.flush();\n \n // Generate M graphs with balanced but distinct structures\n vector graphs(M);\n vector features(M);\n \n random_device rd;\n mt19937 rng(13579);\n \n for (int i = 0; i < M; i++) {\n graphs[i] = generate_balanced_graph(N, i, M, rng);\n features[i] = extract_features(parse_graph(graphs[i], N));\n \n cout << graphs[i] << endl;\n }\n cout.flush();\n \n // Process queries with enhanced matching\n for (int query = 0; query < 100; query++) {\n string H;\n cin >> H;\n \n auto adj_H = parse_graph(H, N);\n auto f_H = extract_features(adj_H);\n \n // Find best match with robust feature comparison\n int best_idx = 0;\n double best_score = 1e9;\n \n for (int i = 0; i < M; i++) {\n double score = 0;\n \n // Conservative adaptive weights\n double edge_weight = 4.0 * (1 - epsilon);\n double degree_weight = 1.2;\n double variance_weight = 0.7;\n double triangle_weight = 1.0 * (1 - epsilon);\n double component_weight = 2.5;\n double cluster_weight = 0.5 * (1 - epsilon);\n double diameter_weight = 0.6;\n double degree_seq_weight = 1.3;\n double triplet_weight = 0.6 * (1 - epsilon);\n double assort_weight = 0.3 * (1 - epsilon);\n \n // Normalized differences\n double edge_diff = abs(f_H.edge_count - features[i].edge_count) / (double)N;\n double degree_diff = abs(f_H.avg_degree - features[i].avg_degree);\n double variance_diff = abs(f_H.degree_variance - features[i].degree_variance);\n double triangle_diff = abs(f_H.triangles - features[i].triangles) / (double)(N * N);\n double component_diff = abs(f_H.components - features[i].components);\n double cluster_diff = abs(f_H.clustering_coeff - features[i].clustering_coeff);\n double diameter_diff = abs(f_H.diameter - features[i].diameter) / (double)N;\n double triplet_diff = abs(f_H.connected_triplets - features[i].connected_triplets) / (double)(N * N);\n double assort_diff = abs(f_H.assortativity - features[i].assortativity);\n \n // Degree sequence similarity\n double degree_seq_diff = 0;\n for (int j = 0; j < N; j++) {\n degree_seq_diff += abs(f_H.degree_sequence[j] - features[i].degree_sequence[j]);\n }\n degree_seq_diff /= N;\n \n // Weighted sum\n score += edge_weight * edge_diff;\n score += degree_weight * degree_diff;\n score += variance_weight * variance_diff;\n score += triangle_weight * triangle_diff;\n score += component_weight * component_diff;\n score += cluster_weight * cluster_diff;\n score += diameter_weight * diameter_diff;\n score += degree_seq_weight * degree_seq_diff;\n score += triplet_weight * triplet_diff;\n score += assort_weight * assort_diff;\n \n if (score < best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Edge {\n int u, v, w, id;\n double x1, y1, x2, y2;\n int importance;\n int day;\n int cluster;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n \n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--;\n edges[i].v--;\n edges[i].id = i;\n }\n \n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Assign coordinates to edges\n for (auto &e : edges) {\n e.x1 = coords[e.u].first;\n e.y1 = coords[e.u].second;\n e.x2 = coords[e.v].first;\n e.y2 = coords[e.v].second;\n }\n \n // Compute betweenness centrality for each edge\n vector betweenness(M, 0);\n const int SAMPLES = min(N, 200); // Increased sample size\n vector sampled_vertices(N);\n iota(sampled_vertices.begin(), sampled_vertices.end(), 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(sampled_vertices.begin(), sampled_vertices.end(), rng);\n sampled_vertices.resize(SAMPLES);\n \n for (int s : sampled_vertices) {\n vector dist(N, 1e9);\n vector prev(N, -1);\n priority_queue, vector>, greater<>> pq;\n dist[s] = 0;\n pq.push({0, s});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n int v = -1;\n if (e.u == u) v = e.v;\n else if (e.v == u) v = e.u;\n else continue;\n if (dist[v] > dist[u] + e.w) {\n dist[v] = dist[u] + e.w;\n prev[v] = u;\n pq.push({dist[v], v});\n }\n }\n }\n \n for (int t = 0; t < N; ++t) {\n if (t == s) continue;\n for (int v = t; v != s && prev[v] != -1; v = prev[v]) {\n int u = prev[v];\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n betweenness[eid]++;\n break;\n }\n }\n }\n }\n }\n \n // Compute importance: betweenness + inverse weight + degree\n vector degree(N, 0);\n for (auto &e : edges) {\n degree[e.u]++;\n degree[e.v]++;\n }\n for (int i = 0; i < M; ++i) {\n edges[i].importance = betweenness[i] * 1000000 / (edges[i].w + 1) + degree[edges[i].u] + degree[edges[i].v];\n }\n \n // Assign clusters based on spatial proximity\n const int CLUSTERS = min(D * 2, 20); // Increased number of clusters\n vector> cluster_edges(CLUSTERS);\n vector> centroids(CLUSTERS);\n // Initialize centroids randomly\n vector shuffled_edges(M);\n iota(shuffled_edges.begin(), shuffled_edges.end(), 0);\n shuffle(shuffled_edges.begin(), shuffled_edges.end(), rng);\n for (int i = 0; i < CLUSTERS; ++i) {\n int eid = shuffled_edges[i];\n centroids[i] = {(edges[eid].x1 + edges[eid].x2) / 2.0, (edges[eid].y1 + edges[eid].y2) / 2.0};\n }\n \n // K-means clustering\n for (int iter = 0; iter < 15; ++iter) { // Increased iterations\n for (int i = 0; i < M; ++i) {\n auto &e = edges[i];\n double cx = (e.x1 + e.x2) / 2.0;\n double cy = (e.y1 + e.y2) / 2.0;\n double min_dist = 1e18;\n int best_cluster = 0;\n for (int c = 0; c < CLUSTERS; ++c) {\n double dx = cx - centroids[c].first;\n double dy = cy - centroids[c].second;\n double dist = dx * dx + dy * dy;\n if (dist < min_dist) {\n min_dist = dist;\n best_cluster = c;\n }\n }\n e.cluster = best_cluster;\n }\n \n // Update centroids\n vector> sum(CLUSTERS, {0.0, 0.0});\n vector count(CLUSTERS, 0);\n for (auto &e : edges) {\n sum[e.cluster].first += (e.x1 + e.x2) / 2.0;\n sum[e.cluster].second += (e.y1 + e.y2) / 2.0;\n count[e.cluster]++;\n }\n for (int c = 0; c < CLUSTERS; ++c) {\n if (count[c] > 0) {\n centroids[c].first = sum[c].first / count[c];\n centroids[c].second = sum[c].second / count[c];\n }\n }\n }\n \n // Sort edges by importance (descending)\n sort(edges.begin(), edges.end(), [](const Edge &a, const Edge &b) {\n return a.importance > b.importance;\n });\n \n // Priority queue to keep track of day loads\n priority_queue> pq; // {current_sum, day}\n vector day_sum(D, 0);\n vector day_count(D, 0);\n vector> day_cluster_count(D, vector(CLUSTERS, 0));\n for (int d = 0; d < D; ++d) {\n pq.push({0, d});\n }\n \n // Assign edges to days, ensuring no day exceeds K edges and balancing clusters\n vector> day_edges(D);\n for (auto &e : edges) {\n // Find the day with the smallest current sum that has room for this edge and its cluster\n vector> candidates;\n while (!pq.empty()) {\n auto [sum, day] = pq.top(); pq.pop();\n if (day_count[day] < K && day_cluster_count[day][e.cluster] < K / CLUSTERS + 2) { // Relaxed cluster limit\n candidates.push_back({sum, day});\n if (candidates.size() >= 10) break;\n }\n }\n // Push back candidates\n for (auto &p : candidates) {\n pq.push(p);\n }\n // Select the day with the smallest sum\n if (candidates.empty()) {\n // Find the day with the smallest count that has room\n int min_day = 0;\n for (int d = 1; d < D; ++d) {\n if (day_count[d] < day_count[min_day]) {\n min_day = d;\n }\n }\n day_edges[min_day].push_back(e.id);\n day_sum[min_day] += e.importance;\n day_count[min_day]++;\n day_cluster_count[min_day][e.cluster]++;\n pq.push({day_sum[min_day], min_day});\n } else {\n auto [sum, day] = candidates[0];\n day_edges[day].push_back(e.id);\n day_sum[day] += e.importance;\n day_count[day]++;\n day_cluster_count[day][e.cluster]++;\n pq.push({day_sum[day], day});\n }\n }\n \n // Prepare output\n vector res(M);\n for (int d = 0; d < D; ++d) {\n for (int eid : day_edges[d]) {\n res[eid] = d + 1;\n }\n }\n \n // Output the results\n for (int i = 0; i < M; ++i) {\n if (i) cout << \" \";\n cout << res[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Coord {\n int x, y, z;\n};\n\n// Helper function to get a 1D index from 3D coordinates\nint get_idx(int D, int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\n// Generic function to find and mark connected components for a given cell type\nvoid find_and_mark_blocks(\n int D,\n const vector>>& cell_type,\n vector>>& visited,\n vector& b_1,\n vector& b_2,\n int& block_id,\n bool is_shared,\n bool is_u1,\n bool is_u2\n) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (cell_type[x][y][z] && !visited[x][y][z]) {\n queue q;\n q.push({x, y, z});\n visited[x][y][z] = true;\n block_id++;\n int idx = get_idx(D, x, y, z);\n\n if (is_shared) {\n b_1[idx] = block_id;\n b_2[idx] = block_id;\n } else if (is_u1) {\n b_1[idx] = block_id;\n } else if (is_u2) {\n b_2[idx] = block_id;\n }\n\n while (!q.empty()) {\n Coord curr = q.front();\n q.pop();\n\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n\n for (int i = 0; i < 6; ++i) {\n int nx = curr.x + dx[i];\n int ny = curr.y + dy[i];\n int nz = curr.z + dz[i];\n\n if (0 <= nx && nx < D && 0 <= ny && ny < D && 0 <= nz && nz < D) {\n if (cell_type[nx][ny][nz] && !visited[nx][ny][nz]) {\n visited[nx][ny][nz] = true;\n q.push({nx, ny, nz});\n int n_idx = get_idx(D, nx, ny, nz);\n if (is_shared) {\n b_1[n_idx] = block_id;\n b_2[n_idx] = block_id;\n } else if (is_u1) {\n b_1[n_idx] = block_id;\n } else if (is_u2) {\n b_2[n_idx] = block_id;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int D;\n cin >> D;\n\n vector f[2], r[2];\n for (int i = 0; i < 2; ++i) {\n f[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> f[i][j];\n }\n r[i].resize(D);\n for (int j = 0; j < D; ++j) {\n cin >> r[i][j];\n }\n }\n\n // Categorize cells: shared, unique to object 1, unique to object 2\n vector>> is_shared(D, vector>(D, vector(D, false)));\n vector>> is_u1(D, vector>(D, vector(D, false)));\n vector>> is_u2(D, vector>(D, vector(D, false)));\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool in_o1 = (f[0][z][x] == '1' && r[0][z][y] == '1');\n bool in_o2 = (f[1][z][x] == '1' && r[1][z][y] == '1');\n if (in_o1 && in_o2) {\n is_shared[x][y][z] = true;\n } else if (in_o1) {\n is_u1[x][y][z] = true;\n } else if (in_o2) {\n is_u2[x][y][z] = true;\n }\n }\n }\n }\n\n vector b_1(D * D * D, 0);\n vector b_2(D * D * D, 0);\n vector>> visited(D, vector>(D, vector(D, false)));\n int block_id = 0;\n\n // 1. Find shared blocks\n find_and_mark_blocks(D, is_shared, visited, b_1, b_2, block_id, true, false, false);\n\n // 2. Find blocks unique to object 1\n find_and_mark_blocks(D, is_u1, visited, b_1, b_2, block_id, false, true, false);\n\n // 3. Find blocks unique to object 2\n find_and_mark_blocks(D, is_u2, visited, b_1, b_2, block_id, false, false, true);\n\n cout << block_id << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_1[i];\n }\n cout << endl;\n for (int i = 0; i < D * D * D; ++i) {\n if (i > 0) cout << \" \";\n cout << b_2[i];\n }\n cout << endl;\n\n return 0;\n}","ahc020":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n double x, y;\n Point(double x=0, double y=0) : x(x), y(y) {}\n double dist(const Point& p) const {\n return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));\n }\n int rounded_dist(const Point& p) const {\n return (int)round(dist(p));\n }\n};\n\nstruct Edge {\n int u, v, w, idx;\n double d;\n Edge(int u=0, int v=0, int w=0, double d=0, int idx=0) : u(u), v(v), w(w), d(d), idx(idx) {}\n bool operator<(const Edge& e) const {\n return w < e.w;\n }\n};\n\nstruct DSU {\n vector parent, sz;\n DSU(int n) : parent(n), sz(n, 1) {\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 same(int x, int y) { return find(x) == find(y); }\n bool unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return false;\n if (sz[x] < sz[y]) swap(x, y);\n parent[y] = x;\n sz[x] += sz[y];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n \n vector stations(N);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M);\n for (int j = 0; j < M; ++j) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n double d = stations[u].dist(stations[v]);\n edges[j] = Edge(u, v, w, d, j);\n }\n \n vector residents(K);\n for (int k = 0; k < K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // Precompute distances\n vector> station_resident_dist(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n station_resident_dist[i][k] = stations[i].dist(residents[k]);\n }\n }\n \n vector> station_station_dist(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n station_station_dist[i][j] = stations[i].dist(stations[j]);\n }\n }\n \n // Calculate resident density around each station\n vector resident_density(N, 0);\n vector> nearby_residents(N);\n \n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n double d = station_resident_dist[i][k];\n if (d <= 5000) {\n resident_density[i] += exp(-d / 1000.0);\n nearby_residents[i].push_back(k);\n }\n }\n }\n \n // Initial edge selection with enhanced cost-benefit analysis\n vector edge_used(M, false);\n vector connected(N, false);\n connected[0] = true;\n \n // Phase 1: Connect high-value stations\n vector> station_value;\n for (int i = 1; i < N; ++i) {\n double value = resident_density[i] * 1000.0;\n value -= station_station_dist[0][i] * 0.1;\n station_value.push_back({value, i});\n }\n sort(station_value.rbegin(), station_value.rend());\n \n for (auto &[value, i] : station_value) {\n if (connected[i]) continue;\n \n // Find best connection\n int best_edge = -1;\n double best_score = -1;\n \n for (int j = 0; j < M; ++j) {\n if (edges[j].u == i || edges[j].v == i) {\n int other = edges[j].u == i ? edges[j].v : edges[j].u;\n if (connected[other]) {\n double score = resident_density[i] / (1.0 + edges[j].w * 0.001);\n score -= edges[j].d * 0.0001;\n if (score > best_score) {\n best_score = score;\n best_edge = j;\n }\n }\n }\n }\n \n if (best_edge != -1 && best_score > 0.01) {\n edge_used[best_edge] = true;\n connected[i] = true;\n }\n }\n \n // Phase 2: Build MST for remaining components\n DSU dsu(N);\n for (int i = 0; i < N; ++i) {\n if (connected[i]) dsu.parent[i] = 0;\n }\n \n vector sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end());\n \n for (auto &e : sorted_edges) {\n if (!edge_used[e.idx]) {\n if (dsu.unite(e.u, e.v)) {\n edge_used[e.idx] = true;\n connected[e.u] = connected[e.v] = true;\n }\n }\n }\n \n // Calculate connectivity for all stations\n vector> adj(N);\n for (int j = 0; j < M; ++j) {\n if (edge_used[j]) {\n adj[edges[j].u].push_back(edges[j].v);\n adj[edges[j].v].push_back(edges[j].u);\n }\n }\n \n vector component(N, -1);\n queue q;\n component[0] = 0;\n q.push(0);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : adj[u]) {\n if (component[v] == -1) {\n component[v] = component[u] + 1;\n q.push(v);\n }\n }\n }\n \n // Enhanced power allocation\n vector P(N, 0);\n vector covered(K, false);\n \n // Sort residents by difficulty to cover\n vector> resident_difficulty;\n for (int k = 0; k < K; ++k) {\n double min_dist = 1e9;\n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n min_dist = min(min_dist, station_resident_dist[i][k]);\n }\n }\n resident_difficulty.push_back({min_dist, k});\n }\n sort(resident_difficulty.rbegin(), resident_difficulty.rend());\n \n // Greedy coverage with incremental optimization\n for (auto &[diff, k] : resident_difficulty) {\n if (covered[k]) continue;\n \n int best_station = -1;\n int best_power = 0;\n double best_cost = 1e18;\n \n for (int i = 0; i < N; ++i) {\n if (!connected[i]) continue;\n \n double d = station_resident_dist[i][k];\n if (d > 5000) continue;\n \n int power = max(P[i], (int)ceil(d));\n if (power > 5000) continue;\n \n double cost = power * power - P[i] * P[i];\n \n // Consider additional residents covered\n int additional = 0;\n for (int kk : nearby_residents[i]) {\n if (!covered[kk] && station_resident_dist[i][kk] <= power) {\n additional++;\n }\n }\n \n if (additional > 0) {\n cost /= additional;\n cost += component[i] * 0.1; // Prefer closer stations\n \n if (cost < best_cost) {\n best_cost = cost;\n best_station = i;\n best_power = power;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = best_power;\n for (int kk : nearby_residents[best_station]) {\n if (station_resident_dist[best_station][kk] <= best_power) {\n covered[kk] = true;\n }\n }\n }\n }\n \n // Local search optimization\n for (int iter = 0; iter < 5; ++iter) {\n bool improved = false;\n \n // Try to reduce powers\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] == 0) continue;\n \n vector temp_covered = covered;\n bool can_reduce = true;\n int min_power = 0;\n \n for (int k = 0; k < K; ++k) {\n if (covered[k] && station_resident_dist[i][k] <= P[i] + 0.5) {\n bool covered_by_other = false;\n for (int j = 0; j < N; ++j) {\n if (j != i && P[j] > 0 && station_resident_dist[j][k] <= P[j] + 0.5) {\n covered_by_other = true;\n break;\n }\n }\n if (!covered_by_other) {\n can_reduce = false;\n min_power = max(min_power, (int)ceil(station_resident_dist[i][k]));\n }\n }\n }\n \n if (can_reduce) {\n P[i] = 0;\n improved = true;\n } else if (min_power < P[i]) {\n P[i] = min_power;\n improved = true;\n }\n }\n \n // Try to add beneficial stations\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] > 0) continue;\n \n int best_power = 0;\n double best_ratio = 0;\n \n for (int power = 100; power <= 2000; power += 100) {\n int new_covered = 0;\n for (int k : nearby_residents[i]) {\n if (!covered[k] && station_resident_dist[i][k] <= power) {\n new_covered++;\n }\n }\n \n if (new_covered > 0) {\n double ratio = (double)new_covered / (power * power);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n best_power = power;\n }\n }\n }\n \n if (best_power > 0 && best_ratio > 0.00001) {\n P[i] = best_power;\n for (int k : nearby_residents[i]) {\n if (station_resident_dist[i][k] <= best_power) {\n covered[k] = true;\n }\n }\n improved = true;\n }\n }\n \n if (!improved) break;\n }\n \n // Final coverage check\n covered.assign(K, false);\n for (int i = 0; i < N; ++i) {\n if (P[i] > 0) {\n for (int k = 0; k < K; ++k) {\n if (station_resident_dist[i][k] <= P[i] + 0.5) {\n covered[k] = true;\n }\n }\n }\n }\n \n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n double min_dist = 1e9;\n int best_station = -1;\n \n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n double d = station_resident_dist[i][k];\n if (d < min_dist) {\n min_dist = d;\n best_station = i;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = min(5000, max(P[best_station], (int)ceil(min_dist)));\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; ++j) {\n if (j) cout << \" \";\n cout << (edge_used[j] ? 1 : 0);\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconstexpr int N = 30;\n\n// pyramid values\nint a[N][N];\n// list of operations: x y x' y'\nvector> ops;\n\n// bubble down the element currently at (x,y)\nvoid bubble_down(int x, int y) {\n while (true) {\n int cx = x + 1;\n if (cx >= N) break; // leaf\n int cy_left = y;\n int cy_right = y + 1;\n\n // choose the smaller child\n int child_x = cx, child_y = cy_left;\n int child_val = a[child_x][child_y];\n if (a[cx][cy_right] < child_val) {\n child_y = cy_right;\n child_val = a[cx][cy_right];\n }\n\n // heap condition satisfied?\n if (a[x][y] <= child_val) break;\n\n // perform swap\n ops.push_back({x, y, child_x, child_y});\n swap(a[x][y], a[child_x][child_y]);\n\n // continue from the child position\n x = child_x;\n y = child_y;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // read input\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> a[x][y];\n }\n }\n\n // bottom\u2011up heapify\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n bubble_down(x, y);\n }\n }\n\n // safety check (should always hold)\n assert(ops.size() <= 10000);\n\n // output\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op[0] << \" \" << op[1] << \" \"\n << op[2] << \" \" << op[3] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \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 D, N;\n if (!(cin >> D >> N)) {\n return 0;\n }\n\n const int entrance_r = 0;\n const int entrance_c = (D - 1) / 2;\n\n vector> grid(D, vector(D, 0));\n vector> placeable_cells;\n\n // Mark obstacles\n for (int k = 0; k < N; ++k) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = -1; // -1 for obstacle\n }\n\n // Collect all placeable cells\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (grid[i][j] != -1 && !(i == entrance_r && j == entrance_c)) {\n placeable_cells.emplace_back(i, j);\n }\n }\n }\n\n // Sort placeable cells by distance from entrance, then by coordinates\n // dist(i,j) = i + abs(j - entrance_c)\n auto dist_cmp = [entrance_c](const pair& a, const pair& b) {\n int dist_a = a.first + abs(a.second - entrance_c);\n int dist_b = b.first + abs(b.second - entrance_c);\n if (dist_a != dist_b) {\n return dist_a < dist_b; // Sort by distance ascending\n }\n if (a.first != b.first) {\n return a.first < b.first;\n }\n return a.second < b.second;\n };\n sort(placeable_cells.begin(), placeable_cells.end(), dist_cmp);\n\n int M = placeable_cells.size();\n vector is_taken(M, false);\n\n // --- Placement Phase ---\n for (int d = 0; d < M; ++d) {\n int t;\n cin >> t;\n\n int target_idx = t;\n int offset = 0;\n int chosen_idx = -1;\n\n while (chosen_idx == -1) {\n int check_idx1 = target_idx - offset;\n if (check_idx1 >= 0 && !is_taken[check_idx1]) {\n chosen_idx = check_idx1;\n break;\n }\n int check_idx2 = target_idx + offset;\n if (check_idx2 < M && !is_taken[check_idx2]) {\n chosen_idx = check_idx2;\n break;\n }\n offset++;\n }\n\n auto [r, c] = placeable_cells[chosen_idx];\n grid[r][c] = t;\n is_taken[chosen_idx] = true;\n\n cout << r << \" \" << c << \"\\n\";\n cout.flush();\n }\n\n // --- Retrieval Phase ---\n vector> retrieval_order;\n int remaining = M;\n while (remaining > 0) {\n // BFS to find reachable containers\n vector> visited(D, vector(D, false));\n queue> q;\n q.push({entrance_r, entrance_c});\n visited[entrance_r][entrance_c] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n const int drs[4] = {-1, 1, 0, 0};\n const int dcs[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + drs[k];\n int nc = c + dcs[k];\n\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !visited[nr][nc] && grid[nr][nc] != -1) {\n visited[nr][nc] = true;\n if (grid[nr][nc] > 0) {\n reachable_containers.push_back({nr, nc});\n }\n q.push({nr, nc});\n }\n }\n }\n\n // Find min priority container among reachable\n int min_p = M; // Max priority is M-1\n pair min_coord = {-1, -1};\n for (const auto& coord : reachable_containers) {\n if (grid[coord.first][coord.second] < min_p) {\n min_p = grid[coord.first][coord.second];\n min_coord = coord;\n }\n }\n\n retrieval_order.push_back(min_coord);\n grid[min_coord.first][min_coord.second] = 0; // Mark as empty\n remaining--;\n }\n\n // --- Output Retrieval Order ---\n for (const auto& coord : retrieval_order) {\n cout << coord.first << \" \" << coord.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n }\n }\n // output exactly the same grid\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << grid[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector scores(N, 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n auto compare = [](int a, int b) {\n cout << \"1 1 \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n return res == '>';\n };\n\n // --- Phase 1: Score-based Learning ---\n int Q_learn = Q * 0.8;\n for (int q = 0; q < Q_learn; ++q) {\n int i = rng() % N;\n int j = rng() % N;\n while (i == j) {\n j = rng() % N;\n }\n\n if (compare(i, j)) {\n scores[i] += 2;\n scores[j] -= 1;\n } else {\n scores[i] -= 1;\n scores[j] += 2;\n }\n }\n\n // --- Phase 2: Greedy Partitioning (LPT) ---\n vector item_ids(N);\n iota(item_ids.begin(), item_ids.end(), 0);\n sort(item_ids.begin(), item_ids.end(), [&](int a, int b) {\n return scores[a] > scores[b];\n });\n\n vector set_weights(D, 0);\n vector assignments(N);\n vector> sets(D);\n\n for (int item_id : item_ids) {\n auto it = min_element(set_weights.begin(), set_weights.end());\n int set_id = distance(set_weights.begin(), it);\n\n assignments[item_id] = set_id;\n set_weights[set_id] += scores[item_id];\n sets[set_id].push_back(item_id);\n }\n\n // --- Phase 3: Safe Refinement ---\n int Q_refine = Q - Q_learn;\n while (Q_refine > 0) {\n int max_set_id = -1, min_set_id = -1;\n long long max_score = -1, min_score = 1e18;\n for (int i = 0; i < D; ++i) {\n if (set_weights[i] > max_score) {\n max_score = set_weights[i];\n max_set_id = i;\n }\n if (set_weights[i] < min_score) {\n min_score = set_weights[i];\n min_set_id = i;\n }\n }\n\n if (max_set_id == -1 || min_set_id == -1 || max_set_id == min_set_id) {\n break;\n }\n \n // Ensure sets are not empty before trying to access elements\n if (sets[max_set_id].empty() || sets[min_set_id].empty()) {\n Q_refine--;\n continue;\n }\n\n int heaviest_in_heavy = *max_element(sets[max_set_id].begin(), sets[max_set_id].end(),\n [&](int a, int b){ return scores[a] < scores[b]; });\n int lightest_in_light = *min_element(sets[min_set_id].begin(), sets[min_set_id].end(),\n [&](int a, int b){ return scores[a] < scores[b]; });\n\n if (Q_refine <= 0) break;\n Q_refine--;\n\n // If the \"light\" item is actually heavier, swap them.\n if (!compare(heaviest_in_heavy, lightest_in_light)) {\n // Swap assignments\n swap(assignments[heaviest_in_heavy], assignments[lightest_in_light]);\n \n // Update weights\n set_weights[max_set_id] = set_weights[max_set_id] - scores[heaviest_in_heavy] + scores[lightest_in_light];\n set_weights[min_set_id] = set_weights[min_set_id] - scores[lightest_in_light] + scores[heaviest_in_heavy];\n\n // Update set member lists\n auto it_h = find(sets[max_set_id].begin(), sets[max_set_id].end(), heaviest_in_heavy);\n auto it_l = find(sets[min_set_id].begin(), sets[min_set_id].end(), lightest_in_light);\n \n iter_swap(it_h, it_l);\n }\n }\n\n // --- Final Output ---\n for (int i = 0; i < N; ++i) {\n if (i > 0) cout << \" \";\n cout << assignments[i];\n }\n cout << endl;\n}\n\nint main() {\n solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct Box {\n int stack_idx;\n int pos; // position from bottom (0-indexed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int n = 200, m = 10;\n int boxes_per_stack = n / m; // 20\n \n vector> stacks(m);\n vector box_info(n + 1);\n \n // Read input\n for (int i = 0; i < m; i++) {\n stacks[i].resize(boxes_per_stack);\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_info[stacks[i][j]] = {i, j};\n }\n }\n \n vector> operations;\n \n // Process boxes in order\n for (int target = 1; target <= n; target++) {\n int stack_idx = box_info[target].stack_idx;\n int pos = box_info[target].pos;\n \n // Check if box is already at top\n if (pos == stacks[stack_idx].size() - 1) {\n // Just carry it out\n operations.emplace_back(target, 0);\n stacks[stack_idx].pop_back();\n \n // Update positions of remaining boxes in this stack\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n } else {\n // Need to move boxes above it\n // Choose destination stack (prefer empty or small stacks)\n int dest_stack = 0;\n int min_size = stacks[0].size();\n for (int i = 1; i < m; i++) {\n if (stacks[i].size() < min_size) {\n min_size = stacks[i].size();\n dest_stack = i;\n }\n }\n \n // If the smallest stack is the current one, choose the next smallest\n if (dest_stack == stack_idx) {\n for (int i = 0; i < m; i++) {\n if (i != stack_idx && stacks[i].size() <= min_size + 5) {\n dest_stack = i;\n break;\n }\n }\n }\n \n // Move the target box and everything above it\n operations.emplace_back(target, dest_stack + 1); // 1-indexed for output\n \n // Extract the boxes to move\n vector to_move(stacks[stack_idx].begin() + pos, stacks[stack_idx].end());\n stacks[stack_idx].resize(pos);\n \n // Add to destination stack\n stacks[dest_stack].insert(stacks[dest_stack].end(), to_move.begin(), to_move.end());\n \n // Update positions\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n \n // Now carry out the target box (it should be at top of dest_stack)\n operations.emplace_back(target, 0);\n stacks[dest_stack].pop_back();\n \n // Update positions again\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n }\n }\n \n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n \n return 0;\n}","ahc027":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\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 }\n \n vector> visited(N, vector(N));\n string route;\n \n // Simple DFS with priority - exactly like sample but with d-value prioritization\n auto dfs = [&](auto self, int i, int j) -> void {\n visited[i][j] = true;\n \n const int dirs[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n const char dir_chars[4] = {'R', 'D', 'L', 'U'};\n \n // Collect valid neighbor directions\n vector neighbor_dirs;\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (visited[ni][nj]) continue;\n \n // Check wall exactly like the sample solution\n bool can_move = false;\n if (dirs[dir][0] == 0) { // horizontal move\n can_move = (v[i][min(j, nj)] == '0');\n } else { // vertical move\n can_move = (h[min(i, ni)][j] == '0');\n }\n \n if (can_move) {\n neighbor_dirs.push_back(dir);\n }\n }\n \n // Sort neighbors by d value (descending) for better performance\n sort(neighbor_dirs.begin(), neighbor_dirs.end(), [&](int a, int b) {\n int na_i = i + dirs[a][0], na_j = j + dirs[a][1];\n int nb_i = i + dirs[b][0], nb_j = j + dirs[b][1];\n return d[na_i][na_j] > d[nb_i][nb_j];\n });\n \n // Visit neighbors in prioritized order\n for (int dir : neighbor_dirs) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (!visited[ni][nj]) {\n route += dir_chars[dir];\n self(self, ni, nj);\n route += dir_chars[(dir + 2) % 4];\n }\n }\n };\n \n dfs(dfs, 0, 0);\n \n cout << route << endl;\n return 0;\n}","ahc028":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Position {\n int i, j;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n int si, sj;\n cin >> N >> M >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n vector targets(M);\n for (int k = 0; k < M; k++) {\n cin >> targets[k];\n }\n \n // Precompute letter positions\n vector> letter_positions(26);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n letter_positions[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n \n // For each position, precompute nearest positions for each character\n vector>> nearest(N, vector>(N, vector(26)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int c = 0; c < 26; c++) {\n int best_dist = INT_MAX;\n Position best_pos = {-1, -1};\n \n for (auto pos : letter_positions[c]) {\n int dist = abs(i - pos.i) + abs(j - pos.j);\n if (dist < best_dist) {\n best_dist = dist;\n best_pos = pos;\n }\n }\n \n nearest[i][j][c] = best_pos;\n }\n }\n }\n \n vector> result;\n result.emplace_back(si, sj);\n \n vector collected(M, false);\n int collected_count = 0;\n \n string current_suffix;\n \n // Greedy collection with overlap detection\n while (collected_count < M && result.size() < 4500) {\n int best_k = -1;\n int best_score = INT_MIN;\n int best_cost = INT_MAX;\n string best_remaining;\n Position best_start = {-1, -1};\n bool use_overlap = false;\n \n int current_i = result.back().first;\n int current_j = result.back().second;\n \n // Check all uncollected strings\n for (int k = 0; k < M; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Check for overlaps with current suffix\n for (int overlap_len = min(4, (int)current_suffix.length()); overlap_len >= 0; overlap_len--) {\n if (current_suffix.length() >= overlap_len) {\n string suffix = current_suffix.substr(current_suffix.length() - overlap_len);\n \n if (target.substr(0, overlap_len) == suffix) {\n string remaining = target.substr(overlap_len);\n \n // Estimate cost to get remaining characters\n int cost = 0;\n Position curr_pos = {current_i, current_j};\n \n for (char c : remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n cost = INT_MAX;\n break;\n }\n cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (cost < best_cost && cost < 100) {\n best_cost = cost;\n best_k = k;\n best_remaining = remaining;\n use_overlap = true;\n best_score = overlap_len * 10 - cost;\n }\n }\n }\n }\n \n // Also consider starting fresh\n char first_char = target[0];\n for (auto pos : letter_positions[first_char - 'A']) {\n int move_cost = abs(current_i - pos.i) + abs(current_j - pos.j) + 1;\n if (move_cost > 50) continue;\n \n // Estimate cost for remaining characters\n int total_cost = move_cost;\n Position curr_pos = pos;\n \n for (int pos_idx = 1; pos_idx < target.length(); pos_idx++) {\n char c = target[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n total_cost = INT_MAX;\n break;\n }\n total_cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (total_cost < best_cost && total_cost < 100) {\n best_cost = total_cost;\n best_k = k;\n best_start = pos;\n use_overlap = false;\n best_remaining = target;\n best_score = -total_cost;\n }\n }\n }\n \n if (best_k == -1) break;\n \n // Execute the chosen action\n if (use_overlap && !best_remaining.empty()) {\n Position curr_pos = {current_i, current_j};\n for (char c : best_remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n } else if (best_start.i != -1) {\n result.emplace_back(best_start.i, best_start.j);\n Position curr_pos = best_start;\n \n for (int pos_idx = 1; pos_idx < best_remaining.length(); pos_idx++) {\n char c = best_remaining[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n }\n \n collected[best_k] = true;\n collected_count++;\n \n // Update current suffix (last up to 4 characters)\n current_suffix = \"\";\n int start_idx = max(0, (int)result.size() - 4);\n for (int i = start_idx; i < result.size(); i++) {\n current_suffix += grid[result[i].first][result[i].second];\n }\n }\n \n // If we still have time, try to collect more strings with simple approach\n while (collected_count < M && result.size() < 4900) {\n bool found = false;\n int current_i = result.back().first;\n int current_j = result.back().second;\n \n for (int k = 0; k < M && !found; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Try to spell this string greedily\n Position curr_pos = {current_i, current_j};\n vector> temp_path;\n bool success = true;\n \n for (char c : target) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n success = false;\n break;\n }\n temp_path.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n }\n \n if (success && result.size() + temp_path.size() < 4900) {\n for (auto pos : temp_path) {\n result.push_back(pos);\n }\n collected[k] = true;\n collected_count++;\n found = true;\n }\n }\n \n if (!found) break;\n }\n \n // Output result\n for (auto [i, j] : result) {\n cout << i << \" \" << j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct OilField {\n int size;\n vector> cells;\n};\n\nstruct Solver {\n int N, M;\n double eps;\n vector fields;\n vector> reserves;\n vector> known;\n int ops_used;\n \n Solver(int N, int M, double eps, const vector& fields) \n : N(N), M(M), eps(eps), fields(fields), \n reserves(N, vector(N, -1)), known(N, vector(N, false)),\n ops_used(0) {\n }\n \n void flush_output() {\n cout << flush;\n }\n \n bool query_drill(int i, int j) {\n if (ops_used >= 2*N*N) return false;\n \n ops_used++;\n cout << \"q 1 \" << i << \" \" << j << endl;\n flush_output();\n \n string resp;\n if (!(cin >> resp)) return false;\n \n try {\n int val = stoi(resp);\n reserves[i][j] = val;\n known[i][j] = true;\n return true;\n } catch (...) {\n return false;\n }\n }\n \n bool guess_answer(const vector>& answer) {\n if (ops_used >= 2*N*N) return false;\n \n ops_used++;\n cout << \"a \" << answer.size();\n for (auto [i,j] : answer) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush_output();\n \n string resp;\n if (!(cin >> resp)) return false;\n \n return resp == \"1\";\n }\n \n void solve() {\n // Simple strategy: drill every square in order\n vector> oil_squares;\n \n for (int i = 0; i < N && ops_used < 2*N*N - 1; i++) {\n for (int j = 0; j < N && ops_used < 2*N*N - 1; j++) {\n if (query_drill(i, j)) {\n if (reserves[i][j] > 0) {\n oil_squares.emplace_back(i, j);\n }\n }\n }\n }\n \n // Output the answer\n guess_answer(oil_squares);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n vector fields(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n fields[k].size = d;\n fields[k].cells.resize(d);\n for (int i = 0; i < d; i++) {\n cin >> fields[k].cells[i].first >> fields[k].cells[i].second;\n }\n }\n \n Solver solver(N, M, eps, fields);\n solver.solve();\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n \n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> a[d][k];\n }\n }\n \n // Improved strategy: horizontal strips with better area optimization\n // Prioritize meeting area requirements more aggressively\n vector prev_heights(N, W / N);\n \n for (int d = 0; d < D; d++) {\n vector heights(N);\n \n // Calculate minimum heights needed\n vector min_heights(N);\n int total_min_height = 0;\n for (int k = 0; k < N; k++) {\n min_heights[k] = max(1, (a[d][k] + W - 1) / W); // ceil division\n total_min_height += min_heights[k];\n }\n \n if (total_min_height <= W) {\n // We can meet all requirements - distribute optimally\n heights = min_heights;\n int remaining = W - total_min_height;\n \n // Calculate priority based on how much extra area each rectangle needs\n vector priorities(N);\n for (int k = 0; k < N; k++) {\n int current_area = heights[k] * W;\n if (current_area >= a[d][k]) {\n priorities[k] = 0.1; // Low priority if already sufficient\n } else {\n // Higher priority if more deficit\n priorities[k] = (double)(a[d][k] - current_area) / a[d][k];\n }\n }\n \n // Sort by priority (highest first)\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return priorities[i] > priorities[j];\n });\n \n // Distribute remaining space to high-priority rectangles\n for (int i = 0; i < remaining; i++) {\n heights[indices[i % N]]++;\n }\n } else {\n // Need to scale down - be smarter about allocation\n double scale = (double)W / total_min_height;\n \n // Start with scaled down minimum heights\n for (int k = 0; k < N; k++) {\n heights[k] = max(1, (int)round(min_heights[k] * scale));\n }\n \n // Redistribute to prioritize larger area requirements\n int current_sum = accumulate(heights.begin(), heights.end(), 0);\n int diff = W - current_sum;\n \n if (diff > 0) {\n // Give extra space to rectangles with largest area requirements\n vector sorted_indices(N);\n iota(sorted_indices.begin(), sorted_indices.end(), 0);\n sort(sorted_indices.begin(), sorted_indices.end(), [&](int i, int j) {\n return a[d][i] > a[d][j];\n });\n \n for (int i = 0; i < diff; i++) {\n heights[sorted_indices[i % N]]++;\n }\n } else if (diff < 0) {\n // Take from rectangles with smallest area requirements\n vector sorted_indices(N);\n iota(sorted_indices.begin(), sorted_indices.end(), 0);\n sort(sorted_indices.begin(), sorted_indices.end(), [&](int i, int j) {\n return a[d][i] < a[d][j];\n });\n \n for (int i = 0; i < -diff; i++) {\n if (heights[sorted_indices[i % N]] > 1) {\n heights[sorted_indices[i % N]]--;\n }\n }\n }\n }\n \n // Ensure all heights are positive and sum equals W\n for (int k = 0; k < N; k++) {\n heights[k] = max(1, heights[k]);\n }\n \n int current_sum = accumulate(heights.begin(), heights.end(), 0);\n if (current_sum != W) {\n int diff = W - current_sum;\n if (diff > 0) {\n // Add to rectangles with largest deficits\n for (int i = 0; i < diff; i++) {\n int best_k = 0;\n int max_deficit = 0;\n for (int k = 0; k < N; k++) {\n int deficit = max(0, a[d][k] - heights[k] * W);\n if (deficit > max_deficit) {\n max_deficit = deficit;\n best_k = k;\n }\n }\n heights[best_k]++;\n }\n } else {\n // Remove from rectangles with smallest deficits\n for (int i = 0; i < -diff; i++) {\n int best_k = 0;\n int min_deficit = 1e9;\n for (int k = 0; k < N; k++) {\n int deficit = max(0, a[d][k] - heights[k] * W);\n if (deficit < min_deficit && heights[k] > 1) {\n min_deficit = deficit;\n best_k = k;\n }\n }\n if (heights[best_k] > 1) {\n heights[best_k]--;\n }\n }\n }\n }\n \n // Light smoothing to reduce partition changes (only if it doesn't hurt area much)\n if (d > 0) {\n vector smoothed_heights(N);\n for (int k = 0; k < N; k++) {\n smoothed_heights[k] = (int)round(0.9 * heights[k] + 0.1 * prev_heights[k]);\n smoothed_heights[k] = max(1, smoothed_heights[k]);\n }\n \n // Check if smoothing hurts area requirements too much\n int original_penalty = 0;\n int smoothed_penalty = 0;\n for (int k = 0; k < N; k++) {\n int orig_deficit = max(0, a[d][k] - heights[k] * W);\n int smooth_deficit = max(0, a[d][k] - smoothed_heights[k] * W);\n original_penalty += orig_deficit;\n smoothed_penalty += smooth_deficit;\n }\n \n // Only use smoothing if it doesn't increase penalty much\n if (smoothed_penalty <= original_penalty * 1.1) {\n heights = smoothed_heights;\n \n // Ensure sum equals W\n int smoothed_sum = accumulate(heights.begin(), heights.end(), 0);\n if (smoothed_sum != W) {\n int diff = W - smoothed_sum;\n if (diff > 0) {\n for (int i = 0; i < diff; i++) {\n heights[i % N]++;\n }\n } else {\n for (int i = 0; i < -diff; i++) {\n if (heights[N - 1 - (i % N)] > 1) {\n heights[N - 1 - (i % N)]--;\n }\n }\n }\n }\n }\n }\n \n // Final safety check\n int final_sum = accumulate(heights.begin(), heights.end(), 0);\n if (final_sum != W) {\n heights[0] += W - final_sum;\n heights[0] = max(1, min(heights[0], W));\n }\n \n // Output rectangles as horizontal strips\n int pos = 0;\n for (int k = 0; k < N; k++) {\n int height = heights[k];\n int end_pos = min(pos + height, W);\n cout << pos << \" 0 \" << end_pos << \" \" << W << \"\\n\";\n pos = end_pos;\n }\n \n prev_heights = heights;\n }\n \n return 0;\n}","ahc032":"#include \n#include \n\nusing namespace std;\n\nstatic const int MOD = 998244353;\nstatic const int POS = 7; // N - 2, since N is always 9\n\nstruct Op {\n int m, p, q;\n};\n\ninline void addStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n board[p + i][q + j] += stamp[m][i][j];\n if (board[p + i][q + j] >= MOD) board[p + i][q + j] -= MOD;\n }\n }\n}\n\ninline void removeStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n board[p + i][q + j] -= stamp[m][i][j];\n if (board[p + i][q + j] < 0) board[p + i][q + j] += MOD;\n }\n }\n}\n\ninline long long profitStamp(int m, int p, int q,\n const vector>>& stamp,\n const vector>& board)\n{\n long long delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int s = stamp[m][i][j];\n int cur = board[p + i][q + j];\n if (cur + s >= MOD) delta += s - MOD;\n else delta += s;\n }\n }\n return delta;\n}\n\nlong long calculateScore(const vector>& board) {\n long long score = 0;\n for (const auto& row : board)\n for (int val : row)\n score += val;\n return score;\n}\n\nint main()\n{\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n vector> a(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> a[i][j];\n\n vector>> stamp(M, vector>(3, vector(3)));\n for (int m = 0; m < M; ++m)\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) cin >> stamp[m][i][j];\n\n vector> positions;\n positions.reserve(POS * POS);\n for (int p = 0; p < POS; ++p)\n for (int q = 0; q < POS; ++q)\n positions.emplace_back(p, q);\n\n const int ATTEMPTS = 5;\n const int HC_ITER = 40000; // Reduced iterations for hill climbing\n const int SAMPLE_SIZE = 25; // Number of candidates to sample in each step\n\n mt19937 rng(random_device{}());\n uniform_int_distribution rand_m(0, M - 1);\n uniform_int_distribution rand_pos(0, POS - 1);\n\n vector bestOps;\n long long bestScore = calculateScore(a);\n\n for (int attempt = 0; attempt < ATTEMPTS; ++attempt) {\n vector> board = a;\n vector ops;\n\n // ---- Greedy phase ----\n for (int step = 0; step < K; ++step) {\n long long bestDelta = 0;\n Op bestOp{-1, -1, -1};\n\n for (int m = 0; m < M; ++m) {\n for (auto [p, q] : positions) {\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestOp = {m, p, q};\n }\n }\n }\n if (bestDelta <= 0) break;\n addStamp(bestOp.m, bestOp.p, bestOp.q, stamp, board);\n ops.push_back(bestOp);\n }\n\n // ---- Fast Hybrid Hill Climbing ----\n for (int iter = 0; iter < HC_ITER; ++iter) {\n int choice = rng() % 100;\n\n if (ops.size() < (size_t)K && choice < 40) { // Try to add\n Op bestSampleOp{-1, -1, -1};\n long long bestSampleDelta = 0;\n for (int i = 0; i < SAMPLE_SIZE; ++i) {\n Op sample_op = {rand_m(rng), rand_pos(rng), rand_pos(rng)};\n long long delta = profitStamp(sample_op.m, sample_op.p, sample_op.q, stamp, board);\n if (delta > bestSampleDelta) {\n bestSampleDelta = delta;\n bestSampleOp = sample_op;\n }\n }\n if (bestSampleDelta > 0) {\n addStamp(bestSampleOp.m, bestSampleOp.p, bestSampleOp.q, stamp, board);\n ops.push_back(bestSampleOp);\n }\n } else if (!ops.empty() && choice < 75) { // Try to replace\n int op_idx = rng() % ops.size();\n auto& old_op = ops[op_idx];\n long long delta_old = profitStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n\n Op bestSampleOp{-1, -1, -1};\n long long bestSampleDelta = LLONG_MIN;\n for (int i = 0; i < SAMPLE_SIZE; ++i) {\n Op sample_op = {rand_m(rng), rand_pos(rng), rand_pos(rng)};\n long long delta = profitStamp(sample_op.m, sample_op.p, sample_op.q, stamp, board);\n if (delta > bestSampleDelta) {\n bestSampleDelta = delta;\n bestSampleOp = sample_op;\n }\n }\n if (bestSampleDelta > delta_old) {\n removeStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n addStamp(bestSampleOp.m, bestSampleOp.p, bestSampleOp.q, stamp, board);\n old_op = bestSampleOp;\n }\n } else if (!ops.empty()) { // Try to remove\n int op_idx = rng() % ops.size();\n auto& old_op = ops[op_idx];\n long long delta = profitStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n if (delta < 0) {\n removeStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n ops.erase(ops.begin() + op_idx);\n }\n }\n }\n\n long long curScore = calculateScore(board);\n if (curScore > bestScore) {\n bestScore = curScore;\n bestOps = ops;\n }\n }\n\n cout << bestOps.size() << \"\\n\";\n for (auto op : bestOps) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Container {\n int id;\n int arrival_row;\n int arrival_index;\n int target_row;\n int dispatch_order;\n};\n\nstruct Crane {\n int row, col;\n bool carrying;\n int container_id;\n vector commands;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 5;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n // Determine which gate each container should go to\n vector containers(N * N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container_id = A[i][j];\n containers[container_id].id = container_id;\n containers[container_id].arrival_row = i;\n containers[container_id].arrival_index = j;\n containers[container_id].target_row = container_id / N;\n containers[container_id].dispatch_order = container_id % N;\n }\n }\n \n // Sort containers by target gate, then by dispatch order\n sort(containers.begin(), containers.end(), [](const Container& a, const Container& b) {\n if (a.target_row != b.target_row) return a.target_row < b.target_row;\n return a.dispatch_order < b.dispatch_order;\n });\n \n // Initialize cranes\n vector cranes(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].carrying = false;\n cranes[i].container_id = -1;\n }\n \n // Large crane (index 0) will do most of the work\n Crane& large_crane = cranes[0];\n \n // Process containers one by one\n for (const auto& container : containers) {\n // Move large crane to the arrival position\n while (large_crane.row != container.arrival_row) {\n if (large_crane.row < container.arrival_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != container.arrival_index) {\n if (large_crane.col < container.arrival_index) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n } else {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Pick up the container\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to the dispatch position\n while (large_crane.row != container.target_row) {\n if (large_crane.row < container.target_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != N - 1) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n }\n \n // Release the container\n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n // Move back to starting position for next container\n while (large_crane.row != 0) {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n while (large_crane.col != 0) {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Small cranes do minimal work - just stay in place\n for (int i = 1; i < N; i++) {\n // Small cranes can help clear paths by moving away if needed\n // For simplicity, just make them wait\n int max_len = large_crane.commands.size();\n cranes[i].commands.resize(max_len, '.');\n }\n \n // Output the commands\n int max_len = 0;\n for (const auto& crane : cranes) {\n max_len = max(max_len, (int)crane.commands.size());\n }\n \n // Ensure all command strings have the same length\n for (auto& crane : cranes) {\n while (crane.commands.size() < max_len) {\n crane.commands.push_back('.');\n }\n }\n \n for (const auto& crane : cranes) {\n string s(crane.commands.begin(), crane.commands.end());\n cout << s << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int i, j, height;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 20;\n vector> h(N, vector(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n \n vector positive, negative;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n positive.push_back({i, j, h[i][j]});\n } else if (h[i][j] < 0) {\n negative.push_back({i, j, -h[i][j]});\n }\n }\n }\n \n vector operations;\n int ci = 0, cj = 0;\n \n auto manhattan_dist = [&](int i1, int j1, int i2, int j2) {\n return abs(i1 - i2) + abs(j1 - j2);\n };\n \n // Calculate precise cost for transport\n auto calculate_cost = [&](const Cell& pos, const Cell& neg, int amount) {\n int empty_dist = manhattan_dist(ci, cj, pos.i, pos.j);\n int loaded_dist = manhattan_dist(pos.i, pos.j, neg.i, neg.j);\n return 100.0 * empty_dist + (100.0 + amount) * loaded_dist + 2.0 * amount;\n };\n \n // Improved greedy with better cost analysis\n while (!positive.empty() && !negative.empty()) {\n double best_efficiency = -1;\n size_t best_pi = 0, best_ni = 0;\n int best_amount = 0;\n \n // Find the best transport considering all factors\n for (size_t pi = 0; pi < positive.size(); pi++) {\n for (size_t ni = 0; ni < negative.size(); ni++) {\n int amount = min(positive[pi].height, negative[ni].height);\n if (amount <= 0) continue;\n \n double cost = calculate_cost(positive[pi], negative[ni], amount);\n double efficiency = (double)amount / cost;\n \n // Prefer larger amounts when efficiency is similar\n if (efficiency > best_efficiency || \n (abs(efficiency - best_efficiency) < 1e-9 && amount > best_amount)) {\n best_efficiency = efficiency;\n best_pi = pi;\n best_ni = ni;\n best_amount = amount;\n }\n }\n }\n \n if (best_efficiency < 0) break;\n \n Cell& pos = positive[best_pi];\n Cell& neg = negative[best_ni];\n \n // Optimal path to positive cell\n while (ci != pos.i || cj != pos.j) {\n if (ci > pos.i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < pos.i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > pos.j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < pos.j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n \n // Load maximum possible\n operations.push_back(\"+\" + to_string(best_amount));\n pos.height -= best_amount;\n neg.height -= best_amount;\n \n // Optimal path to negative cell\n while (ci != neg.i || cj != neg.j) {\n if (ci > neg.i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < neg.i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > neg.j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < neg.j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n \n // Unload\n operations.push_back(\"-\" + to_string(best_amount));\n \n // Remove completed cells\n if (pos.height == 0) {\n positive.erase(positive.begin() + best_pi);\n }\n if (neg.height == 0) {\n negative.erase(negative.begin() + best_ni);\n }\n }\n \n // Handle any remaining cells (should be minimal)\n for (size_t pi = 0; pi < positive.size(); pi++) {\n if (positive[pi].height > 0) {\n while (ci != positive[pi].i || cj != positive[pi].j) {\n if (ci > positive[pi].i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < positive[pi].i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > positive[pi].j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < positive[pi].j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n operations.push_back(\"+\" + to_string(positive[pi].height));\n operations.push_back(\"-\" + to_string(positive[pi].height));\n }\n }\n \n for (size_t ni = 0; ni < negative.size(); ni++) {\n if (negative[ni].height > 0) {\n while (ci != negative[ni].i || cj != negative[ni].j) {\n if (ci > negative[ni].i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < negative[ni].i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > negative[ni].j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < negative[ni].j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n operations.push_back(\"+\" + to_string(negative[ni].height));\n operations.push_back(\"-\" + to_string(negative[ni].height));\n }\n }\n \n // Output operations\n for (const string& op : operations) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n vector values;\n int total_value;\n double score;\n int id;\n vector normalized_values;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, T;\n cin >> N >> M >> T;\n \n const int SEED_COUNT = 2 * N * (N - 1);\n vector seeds(SEED_COUNT);\n \n // Read initial seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].id = i;\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Calculate max values for each criterion\n vector max_criterion(M, 0);\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n \n for (int turn = 0; turn < T; turn++) {\n // Calculate normalized values for each seed\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].normalized_values.resize(M);\n for (int j = 0; j < M; j++) {\n if (max_criterion[j] > 0) {\n seeds[i].normalized_values[j] = (double)seeds[i].values[j] / max_criterion[j];\n } else {\n seeds[i].normalized_values[j] = 0;\n }\n }\n }\n \n // Calculate comprehensive scores\n for (int i = 0; i < SEED_COUNT; i++) {\n // Base score: total value\n double base_score = seeds[i].total_value;\n \n // Specialization bonus: how many criteria is this seed excellent at?\n int excellent_count = 0;\n double specialization_bonus = 0;\n for (int j = 0; j < M; j++) {\n double norm = seeds[i].normalized_values[j];\n if (norm > 0.9) {\n excellent_count++;\n specialization_bonus += 300;\n } else if (norm > 0.8) {\n specialization_bonus += 150;\n } else if (norm > 0.6) {\n specialization_bonus += 50;\n }\n }\n \n // Exponential bonus for multiple excellent criteria\n if (excellent_count >= 4) {\n specialization_bonus *= 3.0;\n } else if (excellent_count >= 3) {\n specialization_bonus *= 2.0;\n } else if (excellent_count >= 2) {\n specialization_bonus *= 1.5;\n }\n \n // Balance score: how well-rounded is the seed?\n double balance_score = 0;\n double min_norm = 1.0;\n for (int j = 0; j < M; j++) {\n min_norm = min(min_norm, seeds[i].normalized_values[j]);\n }\n balance_score = min_norm * 100;\n \n // Turn-based weighting\n double turn_weight = 1.0;\n if (turn >= T - 3) {\n turn_weight = 1.5; // Final turns: prioritize strength\n } else if (turn < 3) {\n turn_weight = 0.9; // Early turns: slightly less aggressive\n }\n \n seeds[i].score = (base_score * 0.5 + specialization_bonus * 0.4 + balance_score * 0.1) * turn_weight;\n }\n \n // Sort seeds by score\n sort(seeds.begin(), seeds.end(), [](const Seed& a, const Seed& b) {\n return a.score > b.score;\n });\n \n // Select seeds with smart diversity\n vector selected_ids;\n selected_ids.push_back(seeds[0].id); // Always include the best\n \n // Add seeds while maintaining some diversity\n for (int i = 1; i < min(45, SEED_COUNT) && selected_ids.size() < N * N; i++) {\n bool too_similar = false;\n int similar_count = 0;\n \n for (int selected_id : selected_ids) {\n // Calculate similarity\n double similarity = 0;\n for (int j = 0; j < M; j++) {\n double diff = abs(seeds[i].normalized_values[j] - seeds[selected_id].normalized_values[j]);\n similarity += (1.0 - diff);\n }\n similarity /= M;\n \n if (similarity > 0.85) {\n similar_count++;\n if (similar_count >= 2) {\n too_similar = true;\n break;\n }\n }\n }\n \n // Include if not too similar or if we need more seeds\n if (!too_similar || selected_ids.size() < N * N * 0.7) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n \n // Fill remaining slots\n while (selected_ids.size() < N * N) {\n for (int i = 0; i < SEED_COUNT && selected_ids.size() < N * N; i++) {\n if (find(selected_ids.begin(), selected_ids.end(), seeds[i].id) == selected_ids.end()) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n }\n \n // Try multiple placement strategies and pick the best\n vector> best_grid(N, vector(N));\n double best_score = -1;\n \n // Strategy 1: Concentric circles from center\n vector> grid1(N, vector(N));\n vector> positions1;\n int center = N / 2;\n for (int radius = 0; radius <= 3; radius++) {\n for (int i = max(0, center - radius); i <= min(N - 1, center + radius); i++) {\n for (int j = max(0, center - radius); j <= min(N - 1, center + radius); j++) {\n if (abs(i - center) == radius || abs(j - center) == radius) {\n positions1.emplace_back(i, j);\n }\n }\n }\n }\n \n // Strategy 2: Checkerboard pattern\n vector> grid2(N, vector(N));\n vector> positions2;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 0) {\n positions2.emplace_back(i, j);\n }\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 1) {\n positions2.emplace_back(i, j);\n }\n }\n }\n \n // Strategy 3: Horizontal stripes\n vector> grid3(N, vector(N));\n vector> positions3;\n for (int i = 0; i < N; i += 2) {\n for (int j = 0; j < N; j++) {\n positions3.emplace_back(i, j);\n }\n }\n for (int i = 1; i < N; i += 2) {\n for (int j = 0; j < N; j++) {\n positions3.emplace_back(i, j);\n }\n }\n \n // Evaluate each strategy\n vector>> strategies = {positions1, positions2, positions3};\n vector>> grids = {grid1, grid2, grid3};\n \n for (int strategy = 0; strategy < 3; strategy++) {\n // Sort selected seeds by score for this strategy\n vector> seed_scores;\n for (int id : selected_ids) {\n seed_scores.emplace_back(seeds[id].score, id);\n }\n sort(seed_scores.rbegin(), seed_scores.rend());\n \n // Place seeds\n for (size_t i = 0; i < strategies[strategy].size() && i < seed_scores.size(); i++) {\n int row = strategies[strategy][i].first;\n int col = strategies[strategy][i].second;\n grids[strategy][row][col] = seed_scores[i].second;\n }\n \n // Calculate strategy score (adjacent strong pairs)\n double strategy_score = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int id = grids[strategy][i][j];\n if (i > 0) {\n int neighbor_id = grids[strategy][i-1][j];\n strategy_score += (seeds[id].score + seeds[neighbor_id].score) * 0.5;\n }\n if (j > 0) {\n int neighbor_id = grids[strategy][i][j-1];\n strategy_score += (seeds[id].score + seeds[neighbor_id].score) * 0.5;\n }\n }\n }\n \n if (strategy_score > best_score) {\n best_score = strategy_score;\n best_grid = grids[strategy];\n }\n }\n \n // Output best grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (j > 0) cout << \" \";\n cout << best_grid[i][j];\n }\n cout << \"\\n\";\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Update max criteria\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n }\n \n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n int manhattan(const Point& other) const {\n return abs(x - other.x) + abs(y - other.y);\n }\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector s_grid, t_grid;\n vector initial_pos, target_pos;\n vector tree;\n Point root_pos;\n int V_used;\n \n // State tracking\n vector vertex_positions;\n vector edge_directions; // 0=right, 1=down, 2=left, 3=up\n vector holding_takoyaki;\n \n // Task assignment\n vector> fingertip_paths;\n vector path_progress;\n vector assigned_takoyaki;\n \n bool is_valid_position(const Point& p) const {\n return p.x >= 0 && p.x < N && p.y >= 0 && p.y < N;\n }\n \n bool are_all_vertices_in_bounds() const {\n for (const auto& pos : vertex_positions) {\n if (!is_valid_position(pos)) return false;\n }\n return true;\n }\n \n bool validate_tree() const {\n // Check parent constraints\n for (int i = 1; i < V_used; i++) {\n if (tree[i].parent < 0 || tree[i].parent >= i) return false;\n if (tree[i].length < 1 || tree[i].length >= N) return false;\n }\n \n // Check tree connectivity\n vector visited(V_used, false);\n queue q;\n q.push(0);\n visited[0] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : tree[u].children) {\n if (!visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n \n for (bool v : visited) {\n if (!v) return false;\n }\n \n return true;\n }\n \npublic:\n RoboticArmSolver(int N, int M, int V, const vector& s, const vector& t) \n : N(N), M(M), V(V), s_grid(s), t_grid(t) {\n // Extract initial and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (s[i][j] == '1') initial_pos.emplace_back(i, j);\n if (t[i][j] == '1') target_pos.emplace_back(i, j);\n }\n }\n }\n \n void design_arm() {\n V_used = min(V, 6); // Conservative number of vertices\n tree.resize(V_used);\n \n // Root\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Ensure minimum edge length of 1\n int edge_length = max(1, min(N / 4, 3));\n \n // Create simple and safe structure\n if (V_used == 2) {\n // Just one edge\n tree[1].parent = 0;\n tree[1].length = edge_length;\n tree[1].is_leaf = true;\n tree[0].children.push_back(1);\n } else if (V_used <= 4) {\n // Simple line\n for (int i = 1; i < V_used; i++) {\n tree[i].parent = i - 1;\n tree[i].length = edge_length;\n tree[i].is_leaf = (i == V_used - 1);\n tree[i - 1].children.push_back(i);\n }\n } else {\n // Star with short branches\n int num_branches = min(3, V_used - 1);\n \n for (int i = 1; i <= num_branches; i++) {\n tree[i].parent = 0;\n tree[i].length = edge_length;\n tree[i].is_leaf = false;\n tree[0].children.push_back(i);\n }\n \n // Add fingertips\n int vertex = num_branches + 1;\n for (int parent = 1; parent <= num_branches && vertex < V_used; parent++) {\n tree[vertex].parent = parent;\n tree[vertex].length = 1; // Minimum length for safety\n tree[vertex].is_leaf = true;\n tree[parent].children.push_back(vertex);\n vertex++;\n }\n }\n \n // Validate tree\n if (!validate_tree()) {\n // Fallback to minimal valid tree\n V_used = 2;\n tree.resize(2);\n tree[0] = {-1, 0, {1}, false};\n tree[1] = {0, 1, {}, true};\n }\n \n // Find safe root position\n bool found_safe = false;\n root_pos = Point(N / 2, N / 2);\n \n // Try positions ensuring arm stays in bounds\n for (int rx = max(1, N/2 - 2); rx <= min(N-2, N/2 + 2) && !found_safe; rx++) {\n for (int ry = max(1, N/2 - 2); ry <= min(N-2, N/2 + 2) && !found_safe; ry++) {\n root_pos = Point(rx, ry);\n vertex_positions.resize(V_used);\n edge_directions.assign(V_used, 0);\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n found_safe = true;\n }\n }\n }\n \n // Initialize state\n holding_takoyaki.assign(V_used, false);\n assigned_takoyaki.assign(M, -1);\n }\n \n void update_positions() {\n vertex_positions[0] = root_pos;\n \n for (int i = 1; i < V_used; i++) {\n int parent = tree[i].parent;\n int dir = edge_directions[i];\n int dx[4] = {0, 1, 0, -1}; // right, down, left, up\n int dy[4] = {1, 0, -1, 0};\n \n vertex_positions[i].x = vertex_positions[parent].x + dx[dir] * tree[i].length;\n vertex_positions[i].y = vertex_positions[parent].y + dy[dir] * tree[i].length;\n }\n }\n \n void print_design() {\n cout << V_used << endl;\n for (int i = 1; i < V_used; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n cout << root_pos.x << \" \" << root_pos.y << endl;\n }\n \n void assign_tasks() {\n // Get list of fingertips\n vector fingertips;\n for (int i = 1; i < V_used; i++) {\n if (tree[i].is_leaf) fingertips.push_back(i);\n }\n \n if (fingertips.empty()) return;\n \n // Simple assignment\n vector used_initial(M, false);\n vector used_fingertips(fingertips.size(), false);\n \n fingertip_paths.resize(fingertips.size());\n path_progress.assign(fingertips.size(), 0);\n \n for (int k = 0; k < min(M, (int)fingertips.size()); k++) {\n int best_i = -1, best_j = -1;\n int min_dist = INT_MAX;\n \n for (int i = 0; i < M; i++) {\n if (!used_initial[i]) {\n for (int j = 0; j < fingertips.size(); j++) {\n if (!used_fingertips[j]) {\n int dist = vertex_positions[fingertips[j]].manhattan(initial_pos[i]);\n if (dist < min_dist) {\n min_dist = dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n }\n \n if (best_i != -1 && best_j != -1) {\n used_initial[best_i] = true;\n used_fingertips[best_j] = true;\n assigned_takoyaki[best_i] = fingertips[best_j];\n \n // Create path\n vector path;\n Point current = vertex_positions[fingertips[best_j]];\n Point target = initial_pos[best_i];\n \n // Move to initial position\n while (current != target) {\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n path.push_back(current);\n }\n path.push_back(target); // Pickup\n \n // Move to target position\n current = target;\n target = target_pos[best_i];\n while (current != target) {\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n path.push_back(current);\n }\n path.push_back(target); // Dropoff\n \n fingertip_paths[best_j] = path;\n }\n }\n }\n \n string generate_operation() {\n string op(2 * V_used, '.');\n \n // Find fingertip that needs to move\n int urgent_fingertip = -1;\n int urgent_path_idx = -1;\n \n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (!fingertip_paths[i].empty() && \n path_progress[i] < fingertip_paths[i].size()) {\n urgent_fingertip = assigned_takoyaki[i];\n urgent_path_idx = i;\n break;\n }\n }\n \n if (urgent_fingertip == -1) return op;\n \n Point target = fingertip_paths[urgent_path_idx][path_progress[urgent_path_idx]];\n Point current = vertex_positions[urgent_fingertip];\n \n // Check if at target\n if (current == target) {\n // Handle pickup/dropoff\n if (path_progress[urgent_path_idx] == 0) {\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = true;\n } else if (path_progress[urgent_path_idx] == fingertip_paths[urgent_path_idx].size() - 1) {\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = false;\n }\n path_progress[urgent_path_idx]++;\n return op;\n }\n \n // Try safe movements\n int best_dist = current.manhattan(target);\n \n // Try root movements\n int dx[4] = {-1, 1, 0, 0}; // U, D, L, R\n int dy[4] = {0, 0, -1, 1};\n char moves[4] = {'U', 'D', 'L', 'R'};\n \n for (int d = 0; d < 4; d++) {\n Point new_root(root_pos.x + dx[d], root_pos.y + dy[d]);\n if (!is_valid_position(new_root)) continue;\n \n Point old_root = root_pos;\n root_pos = new_root;\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n op[0] = moves[d];\n return op;\n }\n }\n \n root_pos = old_root;\n update_positions();\n }\n \n // Try rotation\n for (int r = 1; r <= 2; r++) {\n int old_dir = edge_directions[urgent_fingertip];\n edge_directions[urgent_fingertip] = (old_dir + (r == 1 ? 3 : 1)) % 4;\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n op[urgent_fingertip] = (r == 1) ? 'L' : 'R';\n return op;\n }\n }\n \n edge_directions[urgent_fingertip] = old_dir;\n update_positions();\n }\n \n return op;\n }\n \n void execute_operations() {\n assign_tasks();\n \n bool all_complete = false;\n int max_turns = 5000; // Conservative limit\n \n while (!all_complete && max_turns-- > 0) {\n string op = generate_operation();\n cout << op << endl;\n \n // Check completion\n all_complete = true;\n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (path_progress[i] < fingertip_paths[i].size()) {\n all_complete = false;\n break;\n }\n }\n }\n }\n \n void solve() {\n design_arm();\n print_design();\n execute_operations();\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M, V;\n cin >> N >> M >> V;\n \n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n \n RoboticArmSolver solver(N, M, V, s, t);\n solver.solve();\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n bool is_mackerel;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n cin >> points[i].x >> points[i].y;\n points[i].is_mackerel = (i < N);\n }\n \n auto count_in_rectangle = [&](int x1, int x2, int y1, int y2) {\n int a = 0, b = 0;\n for (const auto& p : points) {\n if (p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2) {\n if (p.is_mackerel) a++;\n else b++;\n }\n }\n return make_pair(a, b);\n };\n \n int best_diff = -1;\n int best_x1 = -1, best_y1 = -1, best_x2 = -1, best_y2 = -1;\n \n // Try multiple initial rectangles around each mackerel with randomness\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n for (int size = 10; size <= 50; size += 10) {\n for (int offset = -5; offset <= 5; offset += 5) {\n int x1 = max(0, p.x - size + offset);\n int x2 = min(100000, p.x + size + offset);\n int y1 = max(0, p.y - size + offset);\n int y2 = min(100000, p.y + size + offset);\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n int diff = a - b;\n if (diff > best_diff) {\n best_diff = diff;\n best_x1 = x1; best_y1 = y1; best_x2 = x2; best_y2 = y2;\n }\n }\n }\n }\n \n if (best_diff <= 0) {\n // Try to find a rectangle with at least one mackerel and zero sardines\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n int x1 = p.x;\n int x2 = p.x;\n int y1 = p.y;\n int y2 = p.y;\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n if (a > 0 && b == 0) {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 + 1 << \" \" << y1 << \"\\n\";\n cout << x2 + 1 << \" \" << y2 + 1 << \"\\n\";\n cout << x1 << \" \" << y2 + 1 << \"\\n\";\n return 0;\n }\n }\n // Fallback to minimal polygon\n for (const auto& p : points) {\n if (p.is_mackerel) {\n int x = p.x;\n int y = p.y;\n cout << 4 << \"\\n\";\n cout << x << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y + 1 << \"\\n\";\n cout << x << \" \" << y + 1 << \"\\n\";\n return 0;\n }\n }\n }\n \n // Expand the best rectangle with hybrid directional and random expansion\n bool improved = true;\n while (improved) {\n improved = false;\n int current_diff = best_diff;\n // Calculate densities in each direction\n int left_m = 0, left_s = 0;\n int right_m = 0, right_s = 0;\n int down_m = 0, down_s = 0;\n int up_m = 0, up_s = 0;\n for (const auto& p : points) {\n if (p.x < best_x1 && p.y >= best_y1 && p.y <= best_y2) {\n if (p.is_mackerel) left_m++;\n else left_s++;\n } else if (p.x > best_x2 && p.y >= best_y1 && p.y <= best_y2) {\n if (p.is_mackerel) right_m++;\n else right_s++;\n } else if (p.y < best_y1 && p.x >= best_x1 && p.x <= best_x2) {\n if (p.is_mackerel) down_m++;\n else down_s++;\n } else if (p.y > best_y2 && p.x >= best_x1 && p.x <= best_x2) {\n if (p.is_mackerel) up_m++;\n else up_s++;\n }\n }\n // Prioritize directions with higher mackerel to sardine ratio\n vector, pair>> directions = {\n {{left_m, left_s}, {-1, 0}},\n {{right_m, right_s}, {1, 0}},\n {{down_m, down_s}, {0, -1}},\n {{up_m, up_s}, {0, 1}}\n };\n sort(directions.begin(), directions.end(), [](const auto& a, const auto& b) {\n double ratio_a = (a.first.second == 0) ? 1e9 : (double)a.first.first / a.first.second;\n double ratio_b = (b.first.second == 0) ? 1e9 : (double)b.first.first / b.first.second;\n return ratio_a > ratio_b;\n });\n for (auto [dens, dir] : directions) {\n auto [m, s] = dens;\n auto [dx, dy] = dir;\n int step = 10;\n while (step >= 1) {\n int new_x1 = best_x1, new_x2 = best_x2, new_y1 = best_y1, new_y2 = best_y2;\n if (dx == -1) new_x1 = max(0, best_x1 - step);\n else if (dx == 1) new_x2 = min(100000, best_x2 + step);\n else if (dy == -1) new_y1 = max(0, best_y1 - step);\n else if (dy == 1) new_y2 = min(100000, best_y2 + step);\n auto [a, b] = count_in_rectangle(new_x1, new_x2, new_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1; best_y1 = new_y1; best_x2 = new_x2; best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n break;\n }\n step /= 2;\n }\n if (improved) break;\n }\n // Random expansion if no improvement\n if (!improved) {\n uniform_int_distribution dir_dist(0, 3);\n uniform_int_distribution step_dist(1, 10);\n int dir = dir_dist(rng);\n int step = step_dist(rng);\n int new_x1 = best_x1, new_x2 = best_x2, new_y1 = best_y1, new_y2 = best_y2;\n if (dir == 0) new_x1 = max(0, best_x1 - step);\n else if (dir == 1) new_x2 = min(100000, best_x2 + step);\n else if (dir == 2) new_y1 = max(0, best_y1 - step);\n else if (dir == 3) new_y2 = min(100000, best_y2 + step);\n auto [a, b] = count_in_rectangle(new_x1, new_x2, new_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1; best_y1 = new_y1; best_x2 = new_x2; best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n }\n }\n }\n \n // Output the rectangle as a polygon\n cout << 4 << \"\\n\";\n cout << best_x1 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y2 << \"\\n\";\n cout << best_x1 << \" \" << best_y2 << \"\\n\";\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n long long w, h;\n int p, r, b;\n char d;\n};\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, T;\n long long sigma;\n cin >> N >> T >> sigma;\n\n vector w_prime(N), h_prime(N);\n for (int i = 0; i < N; ++i) {\n cin >> w_prime[i] >> h_prime[i];\n }\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n const int NUM_HEURISTICS = 6;\n\n for (int t = 0; t < T; ++t) {\n int heuristic_type = t % NUM_HEURISTICS;\n \n cerr << \"Turn \" << t << \", Heuristic \" << heuristic_type << endl;\n cout << \"# Turn \" << t << \", Heuristic \" << heuristic_type << endl;\n\n vector placements;\n vector> skyline; // (x, height) points\n\n for (int i = 0; i < N; ++i) {\n Rect dims1 = {w_prime[i], h_prime[i]};\n Rect dims2 = {h_prime[i], w_prime[i]};\n\n Placement best_placement;\n long long best_score = 4e18;\n\n auto evaluate_and_update = [&](const Rect& dims, int r) {\n // Try placing Left (extending width)\n long long current_w = 0, current_h = 0;\n if (!placements.empty()) {\n for(const auto& p : placements) {\n current_w = max(current_w, p.w);\n current_h = max(current_h, p.h);\n }\n }\n long long new_w_L = current_w + dims.w;\n long long new_h_L = max(current_h, dims.h);\n long long score_L = 0;\n \n if (heuristic_type == 0) score_L = new_w_L + new_h_L;\n else if (heuristic_type == 1) score_L = new_w_L * new_h_L;\n else if (heuristic_type == 2) score_L = new_w_L;\n else if (heuristic_type == 3) score_L = new_h_L;\n else if (heuristic_type == 4) score_L = (new_w_L + new_h_L) * (dims.w + dims.h);\n else score_L = new_w_L + new_h_L + (rng() % 10000);\n \n if (score_L < best_score) {\n best_score = score_L;\n best_placement = {new_w_L, new_h_L, i, r, -1, 'L'};\n }\n\n // Try placing Up (extending height)\n long long new_w_U = max(current_w, dims.w);\n long long new_h_U = current_h + dims.h;\n long long score_U = 0;\n\n if (heuristic_type == 0) score_U = new_w_U + new_h_U;\n else if (heuristic_type == 1) score_U = new_w_U * new_h_U;\n else if (heuristic_type == 2) score_U = new_w_U;\n else if (heuristic_type == 3) score_U = new_h_U;\n else if (heuristic_type == 4) score_U = (new_w_U + new_h_U) * (dims.w + dims.h);\n else score_U = new_w_U + new_h_U + (rng() % 10000);\n\n if (score_U < best_score) {\n best_score = score_U;\n best_placement = {new_w_U, new_h_U, i, r, -1, 'U'};\n }\n };\n\n if (heuristic_type != 5) {\n if (heuristic_type % 2 == 0) { // Try original orientation first\n evaluate_and_update(dims1, 0);\n evaluate_and_update(dims2, 1);\n } else { // Try rotated orientation first\n evaluate_and_update(dims2, 1);\n evaluate_and_update(dims1, 0);\n }\n } else { // More complex placement for heuristic 5\n // Sort rectangles by area for this turn\n vector> item_areas;\n for(int j = 0; j < N; ++j) {\n item_areas.push_back({j, w_prime[j] * h_prime[j]});\n }\n sort(item_areas.begin(), item_areas.end(), [](const auto& a, const auto& b){ return a.second > b.second; });\n \n // Find the rank of the current item\n int rank = 0;\n for(; rank < N; ++rank) if(item_areas[rank].first == i) break;\n\n // Large rectangles (first 1/3) are placed to make a base\n if (rank < N / 3) {\n evaluate_and_update(dims1, 0);\n evaluate_and_update(dims2, 1);\n } else { // Smaller rectangles can be placed more flexibly\n long long current_w = 0, current_h = 0;\n if (!placements.empty()) {\n for(const auto& p : placements) {\n current_w = max(current_w, p.w);\n current_h = max(current_h, p.h);\n }\n }\n // Try to fit in the \"gap\" if possible (simplified skyline check)\n // This is a very simplified version of a true skyline fit\n long long min_h_L = current_h;\n if(dims1.h < current_h) {\n long long score = current_w + dims1.w;\n if (score < best_score) {\n best_score = score;\n best_placement = {current_w + dims1.w, current_h, i, 0, -1, 'L'};\n }\n }\n if(dims2.h < current_h) {\n long long score = current_w + dims2.w;\n if (score < best_score) {\n best_score = score;\n best_placement = {current_w + dims2.w, current_h, i, 1, -1, 'L'};\n }\n }\n // If no good gap, fall back to standard greedy\n if(best_score == 4e18) {\n evaluate_and_update(dims1, 0);\n evaluate_and_update(dims2, 1);\n }\n }\n }\n \n placements.push_back(best_placement);\n }\n\n cout << N << \"\\n\";\n for (const auto& cmd : placements) {\n cout << cmd.p << \" \" << cmd.r << \" \" << cmd.d << \" \" << cmd.b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc041":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Vertex {\n int x, y;\n int beauty;\n vector neighbors;\n int parent;\n int depth;\n int tree_id;\n bool assigned;\n int subtree_beauty;\n};\n\nint calculate_score(const vector& vertices) {\n int score = 0;\n for (const auto& v : vertices) {\n score += (v.depth + 1) * v.beauty;\n }\n return score;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].beauty;\n }\n \n set> edge_set;\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n vertices[u].neighbors.push_back(v);\n vertices[v].neighbors.push_back(u);\n edge_set.insert({min(u, v), max(u, v)});\n }\n \n for (int i = 0; i < N; i++) {\n cin >> vertices[i].x >> vertices[i].y;\n }\n \n // Initialize best solution\n vector best_vertices = vertices;\n int best_score = 0;\n \n // Multiple restarts with different seeds\n for (int restart = 0; restart < 3; restart++) {\n // Reset for this restart\n for (int i = 0; i < N; i++) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = -1;\n vertices[i].assigned = false;\n vertices[i].subtree_beauty = vertices[i].beauty;\n }\n \n // Sort vertices by beauty (ascending) for root selection\n vector sorted_by_beauty(N);\n iota(sorted_by_beauty.begin(), sorted_by_beauty.end(), 0);\n sort(sorted_by_beauty.begin(), sorted_by_beauty.end(), \n [&](int a, int b) { return vertices[a].beauty < vertices[b].beauty; });\n \n // Select roots with varied distribution for each restart\n int num_roots = max(1, N / (20 + restart * 5));\n vector roots;\n vector is_root(N, false);\n \n mt19937 rng(42 + restart);\n uniform_int_distribution dist(30, 80);\n int min_dist_sq = dist(rng) * dist(rng);\n \n for (int i = 0; i < num_roots && i < N; i++) {\n int v = sorted_by_beauty[i];\n bool too_close = false;\n for (int r : roots) {\n int dx = vertices[v].x - vertices[r].x;\n int dy = vertices[v].y - vertices[r].y;\n if (dx*dx + dy*dy < min_dist_sq) {\n too_close = true;\n break;\n }\n }\n if (!too_close) {\n roots.push_back(v);\n is_root[v] = true;\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n vertices[v].assigned = true;\n }\n }\n \n if (roots.empty()) {\n roots.push_back(0);\n is_root[0] = true;\n vertices[0].parent = -1;\n vertices[0].depth = 0;\n vertices[0].tree_id = 0;\n vertices[0].assigned = true;\n }\n \n // Build trees using BFS\n for (int root : roots) {\n queue q;\n q.push(root);\n \n while (!q.empty()) {\n int v = q.front();\n q.pop();\n \n if (vertices[v].depth >= H) continue;\n \n vector> neighbor_beauty;\n for (int nb : vertices[v].neighbors) {\n if (!vertices[nb].assigned) {\n neighbor_beauty.emplace_back(vertices[nb].beauty, nb);\n }\n }\n sort(neighbor_beauty.rbegin(), neighbor_beauty.rend());\n \n for (auto [beauty, nb] : neighbor_beauty) {\n vertices[nb].parent = v;\n vertices[nb].depth = vertices[v].depth + 1;\n vertices[nb].tree_id = root;\n vertices[nb].assigned = true;\n q.push(nb);\n }\n }\n }\n \n // Assign remaining vertices\n for (int i = 0; i < N; i++) {\n if (!vertices[i].assigned) {\n int best_parent = -1;\n int best_score = INT_MIN;\n \n for (int nb : vertices[i].neighbors) {\n if (vertices[nb].assigned && vertices[nb].depth < H) {\n int score = (vertices[nb].depth + 2) * vertices[i].beauty;\n if (score > best_score) {\n best_score = score;\n best_parent = nb;\n }\n }\n }\n \n if (best_parent != -1) {\n vertices[i].parent = best_parent;\n vertices[i].depth = vertices[best_parent].depth + 1;\n vertices[i].tree_id = vertices[best_parent].tree_id;\n vertices[i].assigned = true;\n } else {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n vertices[i].assigned = true;\n }\n }\n }\n \n // Advanced local optimization with simulated annealing\n mt19937 rng_local(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int phase = 0; phase < 2; phase++) {\n double temperature = 1.0;\n double cooling_rate = 0.95;\n \n for (int iter = 0; iter < 100; iter++) {\n vector candidates;\n for (int i = 0; i < N; i++) {\n if (vertices[i].depth > 0 && vertices[i].depth < H) {\n candidates.push_back(i);\n }\n }\n \n if (candidates.empty()) break;\n \n int v = candidates[rng_local() % candidates.size()];\n \n int current_score = (vertices[v].depth + 1) * vertices[v].beauty;\n int best_parent = vertices[v].parent;\n int best_score = current_score;\n \n vector> potential_parents;\n for (int nb : vertices[v].neighbors) {\n if (nb != vertices[v].parent && \n vertices[nb].depth < H && \n vertices[nb].tree_id != vertices[v].tree_id) {\n \n bool safe = true;\n queue check_q;\n check_q.push(v);\n int check_depth = vertices[nb].depth + 1;\n \n while (!check_q.empty() && safe) {\n int current = check_q.front();\n check_q.pop();\n \n if (check_depth > H) {\n safe = false;\n break;\n }\n \n for (int j = 0; j < N; j++) {\n if (vertices[j].parent == current) {\n check_q.push(j);\n }\n }\n check_depth++;\n }\n \n if (safe) {\n int new_score = (vertices[nb].depth + 2) * vertices[v].beauty;\n potential_parents.emplace_back(new_score, nb);\n }\n }\n }\n \n if (!potential_parents.empty()) {\n sort(potential_parents.rbegin(), potential_parents.rend());\n \n // Simulated annealing decision\n if (potential_parents[0].first > best_score) {\n best_parent = potential_parents[0].second;\n best_score = potential_parents[0].first;\n } else if (temperature > 0.1 && potential_parents.size() > 1) {\n // Sometimes accept worse moves\n double prob = exp((potential_parents[0].first - best_score) / temperature);\n if (rng_local() / (double)numeric_limits::max() < prob) {\n best_parent = potential_parents[0].second;\n best_score = potential_parents[0].first;\n }\n }\n }\n \n if (best_parent != vertices[v].parent) {\n vertices[v].parent = best_parent;\n vertices[v].depth = vertices[best_parent].depth + 1;\n vertices[v].tree_id = vertices[best_parent].tree_id;\n \n queue update_q;\n update_q.push(v);\n \n while (!update_q.empty()) {\n int current = update_q.front();\n update_q.pop();\n \n for (int j = 0; j < N; j++) {\n if (vertices[j].parent == current) {\n vertices[j].depth = vertices[current].depth + 1;\n update_q.push(j);\n }\n }\n }\n }\n \n temperature *= cooling_rate;\n }\n }\n \n // Calculate score for this restart\n int current_score = calculate_score(vertices);\n if (current_score > best_score) {\n best_score = current_score;\n best_vertices = vertices;\n }\n }\n \n // Use best solution found\n vertices = best_vertices;\n \n // Final validation\n for (int i = 0; i < N; i++) {\n if (vertices[i].parent != -1) {\n int u = i;\n int v = vertices[i].parent;\n if (edge_set.find({min(u, v), max(u, v)}) == edge_set.end()) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n }\n }\n }\n \n // Ensure height constraint\n for (int i = 0; i < N; i++) {\n if (vertices[i].depth > H) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n }\n }\n \n // Output parent array\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << vertices[i].parent;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// N is fixed at 20 for all test cases.\nconst int N = 20;\n\n// Helper function to get the reverse direction for a move.\nchar get_reverse_dir(char dir) {\n if (dir == 'L') return 'R';\n if (dir == 'R') return 'L';\n if (dir == 'U') return 'D';\n if (dir == 'D') return 'U';\n return '?'; // Should not happen with valid input\n}\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n int N_input;\n cin >> N_input;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector> operations;\n long long total_moves = 0;\n\n // Iterate over each square to find Oni ('x').\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n // Found an Oni at (i, j). Find the cheapest way to remove it.\n // The problem guarantee ensures at least one of the four paths is clear.\n char best_dir = '?';\n int min_cost = N * 2 + 1; // Initialize with a value larger than any possible cost (max is 40).\n\n // Check upward path (U, j)\n bool up_clear = true;\n for (int k = 0; k < i; ++k) {\n if (board[k][j] == 'o') {\n up_clear = false;\n break;\n }\n }\n if (up_clear) {\n // Number of shifts is i+1, total moves is 2*(i+1)\n int cost = 2 * (i + 1);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'U';\n }\n }\n\n // Check downward path (D, j)\n bool down_clear = true;\n for (int k = i + 1; k < N; ++k) {\n if (board[k][j] == 'o') {\n down_clear = false;\n break;\n }\n }\n if (down_clear) {\n // Number of shifts is N-i, total moves is 2*(N-i)\n int cost = 2 * (N - i);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'D';\n }\n }\n\n // Check leftward path (L, i)\n bool left_clear = true;\n for (int k = 0; k < j; ++k) {\n if (board[i][k] == 'o') {\n left_clear = false;\n break;\n }\n }\n if (left_clear) {\n // Number of shifts is j+1, total moves is 2*(j+1)\n int cost = 2 * (j + 1);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'L';\n }\n }\n\n // Check rightward path (R, i)\n bool right_clear = true;\n for (int k = j + 1; k < N; ++k) {\n if (board[i][k] == 'o') {\n right_clear = false;\n break;\n }\n }\n if (right_clear) {\n // Number of shifts is N-j, total moves is 2*(N-j)\n int cost = 2 * (N - j);\n if (cost < min_cost) {\n min_cost = cost;\n best_dir = 'R';\n }\n }\n\n // Add the sequence of moves for the cheapest path to the operations list.\n int num_shifts = min_cost / 2;\n int line_idx = (best_dir == 'L' || best_dir == 'R') ? i : j;\n\n for (int k = 0; k < num_shifts; ++k) {\n operations.push_back({best_dir, line_idx});\n }\n for (int k = 0; k < num_shifts; ++k) {\n operations.push_back({get_reverse_dir(best_dir), line_idx});\n }\n total_moves += min_cost;\n }\n }\n }\n\n // The problem guarantee ensures total_moves will be <= 4N^2.\n // Max oni is 2N=40. Max cost per oni is 2*N=40. Max total cost is 40*40=1600=4N^2.\n // This strategy is guaranteed to be valid and within the move limit.\n\n // Output the sequence of operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 100;\n long long L = 500000;\n vector T(N);\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector> sorted_T;\n for (int i = 0; i < N; ++i) {\n sorted_T.emplace_back(T[i], i);\n }\n sort(sorted_T.rbegin(), sorted_T.rend());\n\n const int K = 60; // Further increased number of top employees to consider\n vector a(N), b(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n // Top K employees transition among themselves in a balanced way with more targeted randomness\n for (int i = 0; i < K; ++i) {\n int emp = sorted_T[i].second;\n if (i < K / 7) {\n a[emp] = sorted_T[(i + 1) % K].second;\n b[emp] = sorted_T[(i + 2) % K].second;\n } else if (i < 2 * K / 7) {\n a[emp] = sorted_T[(i + 3) % K].second;\n b[emp] = sorted_T[(i + 4) % K].second;\n } else if (i < 3 * K / 7) {\n a[emp] = sorted_T[(i + 5) % K].second;\n b[emp] = sorted_T[(i + 6) % K].second;\n } else if (i < 4 * K / 7) {\n a[emp] = sorted_T[(i + 7) % K].second;\n b[emp] = sorted_T[(i + 8) % K].second;\n } else if (i < 5 * K / 7) {\n a[emp] = sorted_T[(i + 9) % K].second;\n b[emp] = sorted_T[(i + 10) % K].second;\n } else if (i < 6 * K / 7) {\n a[emp] = sorted_T[(i + 11) % K].second;\n b[emp] = sorted_T[(i + 12) % K].second;\n } else {\n // Introduce more randomness for lower top employees\n uniform_int_distribution dist(0, K - 1);\n a[emp] = sorted_T[dist(rng)].second;\n b[emp] = sorted_T[dist(rng)].second;\n }\n }\n\n // Other employees transition to top employees based on their target proportions\n for (int i = K; i < N; ++i) {\n int emp = sorted_T[i].second;\n long long remaining_target = T[emp];\n int chosen_top = 0;\n long long max_ratio = 0;\n for (int j = 0; j < K; ++j) {\n int top_emp = sorted_T[j].second;\n long long ratio = T[top_emp] * (K - j) * (K - j) * (K - j) * (K - j) * (K - j) * (K - j); // Sextic heuristic\n if (ratio > max_ratio) {\n max_ratio = ratio;\n chosen_top = top_emp;\n }\n }\n a[emp] = chosen_top;\n // Alternate transition with more targeted randomness\n if (i % 7 == 0) {\n b[emp] = sorted_T[i % K].second;\n } else if (i % 7 == 1) {\n uniform_int_distribution dist(0, K / 7 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else if (i % 7 == 2) {\n uniform_int_distribution dist(K / 7, 2 * K / 7 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else if (i % 7 == 3) {\n uniform_int_distribution dist(2 * K / 7, 3 * K / 7 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else if (i % 7 == 4) {\n uniform_int_distribution dist(3 * K / 7, 4 * K / 7 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else if (i % 7 == 5) {\n uniform_int_distribution dist(4 * K / 7, 5 * K / 7 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else {\n uniform_int_distribution dist(5 * K / 7, K - 1);\n b[emp] = sorted_T[dist(rng)].second;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << a[i] << \" \" << b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct City {\n int idx;\n double x, y;\n int lx, rx, ly, ry;\n};\n\nvector> dist;\nvector> query_count;\n\ndouble euclidean_dist(const City& a, const City& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\nvector> query_mst(const vector& cities) {\n cout << \"? \" << cities.size();\n for (int c : cities) cout << \" \" << c;\n cout << endl;\n cout.flush();\n \n vector> edges;\n for (int i = 0; i < (int)cities.size() - 1; i++) {\n int u, v;\n cin >> u >> v;\n edges.emplace_back(u, v);\n }\n return edges;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector cities(N);\n for (int i = 0; i < N; i++) {\n cities[i].idx = i;\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].x = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].y = (cities[i].ly + cities[i].ry) / 2.0;\n }\n \n dist.assign(N, vector(N, 1e9));\n query_count.assign(N, vector(N, 0));\n \n // Initialize with centroid distances\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n dist[i][j] = dist[j][i] = euclidean_dist(cities[i], cities[j]);\n }\n }\n \n int queries_used = 0;\n \n // Strategy 1: Query cities sorted by proximity to get accurate distances\n // Sort cities by coordinates\n vector city_order(N);\n iota(city_order.begin(), city_order.end(), 0);\n sort(city_order.begin(), city_order.end(), [&](int a, int b) {\n return cities[a].x < cities[b].x || \n (abs(cities[a].x - cities[b].x) < 1e-6 && cities[a].y < cities[b].y);\n });\n \n // Query consecutive cities in sorted order (they're likely to be close)\n for (int i = 0; i < N && queries_used < Q / 2; i += L/2) {\n vector batch;\n for (int j = i; j < min(N, i + L); j++) {\n batch.push_back(city_order[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Strategy 2: Query cities sorted by y-coordinate\n vector city_order_y(N);\n iota(city_order_y.begin(), city_order_y.end(), 0);\n sort(city_order_y.begin(), city_order_y.end(), [&](int a, int b) {\n return cities[a].y < cities[b].y || \n (abs(cities[a].y - cities[b].y) < 1e-6 && cities[a].x < cities[b].x);\n });\n \n for (int i = 0; i < N && queries_used < Q * 3 / 4; i += L/2) {\n vector batch;\n for (int j = i; j < min(N, i + L); j++) {\n batch.push_back(city_order_y[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Strategy 3: Use remaining queries for random pairs to explore\n mt19937 rng(12345);\n while (queries_used < Q) {\n vector batch;\n set used;\n \n // Select random cities\n while (batch.size() < L && used.size() < N) {\n int c = rng() % N;\n if (used.insert(c).second) {\n batch.push_back(c);\n }\n }\n \n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Final group assignment using improved distances\n vector assigned(N, false);\n vector> final_groups(M);\n vector>> final_edges(M);\n \n // Sort groups by size (largest first for better connectivity)\n vector> group_sizes;\n for (int i = 0; i < M; i++) group_sizes.emplace_back(G[i], i);\n sort(group_sizes.rbegin(), group_sizes.rend());\n \n for (auto [size, group_id] : group_sizes) {\n if (size == 0) continue;\n \n // Find best unassigned city as seed (one with many close neighbors)\n int seed = -1;\n double seed_score = -1;\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n double score = 0;\n int close_count = 0;\n for (int j = 0; j < N; j++) {\n if (!assigned[j] && i != j) {\n if (dist[i][j] < 1000) { // Reasonable distance threshold\n score += 1.0 / (dist[i][j] + 1);\n close_count++;\n }\n }\n }\n if (close_count > 0 && score > seed_score) {\n seed_score = score;\n seed = i;\n }\n }\n }\n \n // If no good seed found, pick any unassigned city\n if (seed == -1) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n seed = i;\n break;\n }\n }\n }\n \n final_groups[group_id].push_back(seed);\n assigned[seed] = true;\n \n // Grow group using Prim's algorithm\n vector in_group(N, false);\n in_group[seed] = true;\n \n while ((int)final_groups[group_id].size() < size) {\n int best_city = -1;\n double best_dist = 1e9;\n int best_from = -1;\n \n for (int u : final_groups[group_id]) {\n for (int v = 0; v < N; v++) {\n if (!assigned[v] && !in_group[v]) {\n if (dist[u][v] < best_dist) {\n best_dist = dist[u][v];\n best_city = v;\n best_from = u;\n }\n }\n }\n }\n \n if (best_city == -1) {\n // No more cities reachable, pick any unassigned\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n best_city = i;\n best_from = final_groups[group_id][0];\n break;\n }\n }\n }\n \n if (best_city != -1) {\n final_groups[group_id].push_back(best_city);\n in_group[best_city] = true;\n assigned[best_city] = true;\n } else {\n break;\n }\n }\n \n // Safety check: ensure group has correct size\n while ((int)final_groups[group_id].size() < size) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n final_groups[group_id].push_back(i);\n assigned[i] = true;\n break;\n }\n }\n }\n }\n \n // Build MST within each group\n for (int g = 0; g < M; g++) {\n if (final_groups[g].size() <= 1) continue;\n \n // Use Prim's algorithm for MST to avoid sorting O(n^2) edges\n vector> mst_edges;\n vector in_mst(N, false);\n vector min_edge(N, 1e9);\n vector parent(N, -1);\n \n // Start from first city in group\n int start = final_groups[g][0];\n min_edge[start] = 0;\n \n for (int iter = 0; iter < (int)final_groups[g].size(); iter++) {\n int u = -1;\n for (int city : final_groups[g]) {\n if (!in_mst[city] && (u == -1 || min_edge[city] < min_edge[u])) {\n u = city;\n }\n }\n \n if (u == -1) break;\n \n in_mst[u] = true;\n \n if (parent[u] != -1) {\n mst_edges.emplace_back(parent[u], u);\n }\n \n for (int v : final_groups[g]) {\n if (!in_mst[v] && dist[u][v] < min_edge[v]) {\n min_edge[v] = dist[u][v];\n parent[v] = u;\n }\n }\n }\n \n final_edges[g] = mst_edges;\n }\n \n // Output answer\n cout << \"!\" << endl;\n for (int g = 0; g < M; g++) {\n for (int c : final_groups[g]) {\n cout << c << \" \";\n }\n cout << endl;\n for (auto [u, v] : final_edges[g]) {\n cout << u << \" \" << v << endl;\n }\n }\n \n return 0;\n}","ahc046":"#include \nusing namespace std;\n\n// N and M are fixed by the problem statement, so we can use the literals directly.\n// N = 20, M = 40\n\nstruct Pos {\n int r, c;\n int id() const { return r * 20 + c; } // N is 20\n static Pos from_id(int id) { return {id / 20, id % 20}; } // N is 20\n};\n\n// BFS that returns a shortest sequence of actions from src to dst\nvector> bfs_path(Pos src, Pos dst) {\n const int SZ = 20 * 20; // N*N\n vector dist(SZ, -1);\n vector parent(SZ, -1);\n vector act(SZ), dir(SZ); // action and direction that lead to this vertex\n\n queue q;\n int s_id = src.id();\n dist[s_id] = 0;\n q.push(s_id);\n\n while (!q.empty()) {\n int cur_id = q.front(); q.pop();\n Pos cur = Pos::from_id(cur_id);\n if (cur_id == dst.id()) break;\n\n // ----- Move -----\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char mdir[4] = {'U', 'D', 'L', 'R'};\n for (int k = 0; k < 4; ++k) {\n int nr = cur.r + dr[k];\n int nc = cur.c + dc[k];\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) continue; // N is 20\n int nid = nr * 20 + nc; // N is 20\n if (dist[nid] != -1) continue;\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'M';\n dir[nid] = mdir[k];\n q.push(nid);\n }\n\n // ----- Slide -----\n // slide up\n if (cur.r > 0) {\n int nid = 0 * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'U';\n q.push(nid);\n }\n }\n // slide down\n if (cur.r < 20-1) { // N is 20\n int nid = (20-1) * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'D';\n q.push(nid);\n }\n }\n // slide left\n if (cur.c > 0) {\n int nid = cur.r * 20 + 0; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'L';\n q.push(nid);\n }\n }\n // slide right\n if (cur.c < 20-1) { // N is 20\n int nid = cur.r * 20 + (20-1); // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'R';\n q.push(nid);\n }\n }\n }\n\n // reconstruct path\n vector> path;\n int cur_id = dst.id();\n while (cur_id != s_id) {\n path.emplace_back(act[cur_id], dir[cur_id]);\n cur_id = parent[cur_id];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // N and M are fixed (20, 40). Read them into dummy variables to consume the first line.\n int n_read, m_read;\n if (!(cin >> n_read >> m_read)) {\n return 0;\n }\n \n // M is 40\n const int M = 40;\n vector pts(M);\n for (int i = 0; i < M; ++i) {\n cin >> pts[i].r >> pts[i].c;\n }\n\n vector> answer;\n Pos cur = pts[0];\n for (int i = 1; i < M; ++i) {\n Pos nxt = pts[i];\n auto seg = bfs_path(cur, nxt);\n answer.insert(answer.end(), seg.begin(), seg.end());\n cur = nxt;\n }\n\n // safety check (should always hold)\n // Limit is 2 * N * M = 2 * 20 * 40 = 1600\n if ((int)answer.size() > 2 * 20 * 40) {\n answer.resize(2 * 20 * 40);\n }\n\n for (auto [a, d] : answer) {\n cout << a << ' ' << d << '\\n';\n }\n return 0;\n}"},"16":{"ahc001":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Company {\n int id, x, y, r;\n int a, b, c, d;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n vector companies(n);\n for (int i = 0; i < n; i++) {\n companies[i].id = i;\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n }\n \n // Enhanced sorting\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n if (a.r != b.r) return a.r > b.r;\n int edge_a = min({a.x, a.y, 9999-a.x, 9999-a.y});\n int edge_b = min({b.x, b.y, 9999-b.x, 9999-b.y});\n return edge_a < edge_b;\n });\n \n // Use bitset for memory efficiency\n vector> occupied(10000);\n \n auto is_free = [&](int x1, int y1, int x2, int y2) {\n for (int y = y1; y < y2; y++) {\n for (int x = x1; x < x2; x++) {\n if (occupied[y][x]) return false;\n }\n }\n return true;\n };\n \n auto occupy = [&](int x1, int y1, int x2, int y2) {\n for (int y = y1; y < y2; y++) {\n for (int x = x1; x < x2; x++) {\n occupied[y][x] = true;\n }\n }\n };\n \n for (auto& comp : companies) {\n int x = comp.x, y = comp.y, r = comp.r;\n \n bool found = false;\n \n // Strategy 1: Enhanced area matching with more candidates\n vector> candidate_sizes;\n \n int target_side = max(1, (int)sqrt(r));\n \n // Generate more comprehensive size candidates\n for (int w = max(1, target_side - 8); w <= min(80, target_side + 15); w++) {\n int h = max(1, r / w);\n candidate_sizes.push_back({w, h});\n if (w != h) candidate_sizes.push_back({h, w});\n \n // Add variations for better area matching\n if (w + 1 <= 80) {\n candidate_sizes.push_back({w + 1, r / (w + 1)});\n candidate_sizes.push_back({r / (w + 1), w + 1});\n }\n if (w - 1 >= 1) {\n candidate_sizes.push_back({w - 1, r / (w - 1)});\n candidate_sizes.push_back({r / (w - 1), w - 1});\n }\n }\n \n // Add some strategic sizes\n vector> strategic_sizes = {\n {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8},\n {10, 10}, {12, 12}, {15, 15}, {20, 20}, {25, 25}, {30, 30}\n };\n candidate_sizes.insert(candidate_sizes.end(), strategic_sizes.begin(), strategic_sizes.end());\n \n // Remove duplicates and sort by area closeness\n sort(candidate_sizes.begin(), candidate_sizes.end());\n candidate_sizes.erase(unique(candidate_sizes.begin(), candidate_sizes.end()), candidate_sizes.end());\n \n sort(candidate_sizes.begin(), candidate_sizes.end(), [&](pair a, pair b) {\n int area_a = a.first * a.second;\n int area_b = b.first * b.second;\n return abs(area_a - r) < abs(area_b - r);\n });\n \n // Strategy 2: Try to contain the point with best area match\n for (auto [w, h] : candidate_sizes) {\n int min_a = max(0, x - w + 1);\n int max_a = min(10000 - w, x);\n int min_b = max(0, y - h + 1);\n int max_b = min(10000 - h, y);\n \n if (min_a > max_a || min_b > max_b) continue;\n \n // Try more positions for better placement\n vector try_a = {min_a, max_a, (min_a + max_a) / 2};\n vector try_b = {min_b, max_b, (min_b + max_b) / 2};\n \n // Add some offset positions\n if (min_a + 1 <= max_a) try_a.push_back(min_a + 1);\n if (max_a - 1 >= min_a) try_a.push_back(max_a - 1);\n if (min_b + 1 <= max_b) try_b.push_back(min_b + 1);\n if (max_b - 1 >= min_b) try_b.push_back(max_b - 1);\n \n for (int a : try_a) {\n for (int b : try_b) {\n if (is_free(a, b, a + w, b + h)) {\n comp.a = a;\n comp.b = b;\n comp.c = a + w;\n comp.d = b + h;\n occupy(a, b, a + w, b + h);\n found = true;\n break;\n }\n }\n if (found) break;\n }\n if (found) break;\n }\n \n if (found) continue;\n \n // Strategy 3: Smart search near the point\n int search_radius = min(40, (int)sqrt(r) + 15);\n \n for (auto [w, h] : candidate_sizes) {\n bool found_for_size = false;\n \n // Search in multiple patterns\n vector> search_positions;\n \n // Cross pattern\n for (int dist = 1; dist <= search_radius; dist += 5) {\n search_positions.push_back({x + dist, y});\n search_positions.push_back({x - dist, y});\n search_positions.push_back({x, y + dist});\n search_positions.push_back({x, y - dist});\n }\n \n // Diagonal pattern\n for (int dist = 2; dist <= search_radius; dist += 8) {\n search_positions.push_back({x + dist, y + dist});\n search_positions.push_back({x - dist, y + dist});\n search_positions.push_back({x + dist, y - dist});\n search_positions.push_back({x - dist, y - dist});\n }\n \n // Try each position\n for (auto [base_x, base_y] : search_positions) {\n int a = max(0, min(10000 - w, base_x));\n int b = max(0, min(10000 - h, base_y));\n \n if (a >= 0 && b >= 0 && a + w <= 10000 && b + h <= 10000) {\n if (is_free(a, b, a + w, b + h)) {\n comp.a = a;\n comp.b = b;\n comp.c = a + w;\n comp.d = b + h;\n occupy(a, b, a + w, b + h);\n found = true;\n found_for_size = true;\n break;\n }\n }\n }\n \n if (found_for_size) break;\n }\n \n if (found) continue;\n \n // Strategy 4: Strategic placement with good sizes\n for (auto [w, h] : candidate_sizes) {\n // Try strategic locations\n vector> strategic_pos = {\n {x, y}, {x/2, y/2}, {x/4, y/4}, {3*x/4, 3*y/4},\n {1000, 1000}, {9000, 9000}, {5000, 5000},\n {x, 5000}, {5000, y}, {x, 1000}, {1000, y}\n };\n \n for (auto [base_x, base_y] : strategic_pos) {\n base_x = max(0, min(10000 - w, base_x));\n base_y = max(0, min(10000 - h, base_y));\n \n if (base_x >= 0 && base_y >= 0 && base_x + w <= 10000 && base_y + h <= 10000) {\n if (is_free(base_x, base_y, base_x + w, base_y + h)) {\n comp.a = base_x;\n comp.b = base_y;\n comp.c = base_x + w;\n comp.d = base_y + h;\n occupy(base_x, base_y, base_x + w, base_y + h);\n found = true;\n break;\n }\n }\n }\n if (found) break;\n }\n \n if (!found) {\n // Strategy 5: Efficient fallback\n bool found_any = false;\n \n // Multi-stage search\n vector radii = {1, 2, 3, 5, 8, 13, 21, 34, 55};\n \n for (int radius : radii) {\n for (int angle = 0; angle < 360 && !found_any; angle += 60) {\n double rad = angle * M_PI / 180.0;\n int px = x + (int)(radius * cos(rad));\n int py = y + (int)(radius * sin(rad));\n \n if (px >= 0 && px < 10000 && py >= 0 && py < 10000) {\n if (!occupied[py][px]) {\n comp.a = px;\n comp.b = py;\n comp.c = px + 1;\n comp.d = py + 1;\n occupied[py][px] = true;\n found_any = true;\n }\n }\n }\n }\n \n if (!found_any) {\n // Limited local scan\n for (int yy = max(0, y-50); yy < min(10000, y+50) && !found_any; yy++) {\n for (int xx = max(0, x-50); xx < min(10000, x+50) && !found_any; xx++) {\n if (!occupied[yy][xx]) {\n comp.a = xx;\n comp.b = yy;\n comp.c = xx + 1;\n comp.d = yy + 1;\n occupied[yy][xx] = true;\n found_any = true;\n }\n }\n }\n \n if (!found_any) {\n // Coarse grid search\n for (int yy = 0; yy < 10000 && !found_any; yy += 200) {\n for (int xx = 0; xx < 10000 && !found_any; xx += 200) {\n if (!occupied[yy][xx]) {\n comp.a = xx;\n comp.b = yy;\n comp.c = xx + 1;\n comp.d = yy + 1;\n occupied[yy][xx] = true;\n found_any = true;\n }\n }\n }\n }\n }\n }\n }\n \n // Sort by original ID for output\n sort(companies.begin(), companies.end(), [](const Company& a, const Company& b) {\n return a.id < b.id;\n });\n \n // Output results\n for (const auto& comp : companies) {\n cout << comp.a << \" \" << comp.b << \" \" << comp.c << \" \" << comp.d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Tile {\n vector> squares;\n bool visited;\n int total_value;\n int center_i;\n int center_j;\n int connectivity;\n int distance_to_unvisited;\n int cluster_id;\n int priority;\n};\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> t(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> t[i][j];\n }\n }\n \n vector> p(50, vector(50));\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n cin >> p[i][j];\n }\n }\n \n // Build tile structure\n unordered_map tiles;\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n int tile_id = t[i][j];\n tiles[tile_id].squares.push_back({i, j});\n tiles[tile_id].total_value += p[i][j];\n }\n }\n \n // Calculate tile centers and best entry points\n for (auto& [id, tile] : tiles) {\n int sum_i = 0, sum_j = 0;\n int best_entry_i = -1, best_entry_j = -1;\n int max_neighbors = -1;\n \n for (auto [i, j] : tile.squares) {\n sum_i += i;\n sum_j += j;\n \n int neighbors = 0;\n for (int d = 0; d < 4; d++) {\n int ni = i + (d == 1) - (d == 0);\n int nj = j + (d == 3) - (d == 2);\n if (0 <= ni && ni < 50 && 0 <= nj && nj < 50 && t[ni][nj] != id) {\n neighbors++;\n }\n }\n \n if (neighbors > max_neighbors) {\n max_neighbors = neighbors;\n best_entry_i = i;\n best_entry_j = j;\n }\n }\n \n tile.center_i = sum_i / tile.squares.size();\n tile.center_j = sum_j / tile.squares.size();\n if (best_entry_i != -1) {\n tile.center_i = best_entry_i;\n tile.center_j = best_entry_j;\n }\n }\n \n vector di = {-1, 1, 0, 0};\n vector dj = {0, 0, -1, 1};\n vector dirs = {'U', 'D', 'L', 'R'};\n \n // Build tile adjacency graph with weights\n unordered_map>> tile_graph;\n for (int i = 0; i < 50; i++) {\n for (int j = 0; j < 50; j++) {\n int current_tile = t[i][j];\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (0 <= ni && ni < 50 && 0 <= nj && nj < 50) {\n int neighbor_tile = t[ni][nj];\n if (neighbor_tile != current_tile) {\n tile_graph[current_tile].push_back({neighbor_tile, tiles[neighbor_tile].total_value});\n }\n }\n }\n }\n }\n \n // Remove duplicates and sort by value\n for (auto& [id, neighbors] : tile_graph) {\n sort(neighbors.begin(), neighbors.end());\n neighbors.erase(unique(neighbors.begin(), neighbors.end(), \n [](const auto& a, const auto& b) { return a.first == b.first; }), neighbors.end());\n sort(neighbors.begin(), neighbors.end(), \n [](const auto& a, const auto& b) { return a.second > b.second; });\n }\n \n // Find connected components and calculate component values\n unordered_map tile_component;\n unordered_map component_value;\n int component_id = 0;\n \n for (auto& [id, tile] : tiles) {\n if (tile_component.count(id)) continue;\n \n queue q;\n q.push(id);\n tile_component[id] = component_id;\n int comp_val = tile.total_value;\n \n while (!q.empty()) {\n int current = q.front();\n q.pop();\n \n for (auto [neighbor, _] : tile_graph[current]) {\n if (!tile_component.count(neighbor)) {\n tile_component[neighbor] = component_id;\n comp_val += tiles[neighbor].total_value;\n q.push(neighbor);\n }\n }\n }\n component_value[component_id] = comp_val;\n component_id++;\n }\n \n string best_path;\n int best_score = 0;\n \n // Ultra-aggressive approach with 15 attempts\n for (int attempt = 0; attempt < 15; attempt++) {\n // Reset visited status\n for (auto& [id, tile] : tiles) {\n tile.visited = false;\n tile.connectivity = 0;\n tile.distance_to_unvisited = INT_MAX;\n tile.cluster_id = tile_component[id];\n tile.priority = tile.total_value;\n }\n \n vector> visited_square(50, vector(50, false));\n int initial_tile_id = t[si][sj];\n tiles[initial_tile_id].visited = true;\n \n string path;\n int current_i = si, current_j = sj;\n int total_score = 0;\n \n // Add all squares in initial tile\n for (auto [i, j] : tiles[initial_tile_id].squares) {\n visited_square[i][j] = true;\n total_score += p[i][j];\n }\n \n mt19937 rng(attempt * 5678 + 9012);\n \n // Ultra-aggressive parameters\n double exploration_factor = 0.5 + (attempt % 5) * 0.5;\n int max_search_distance = 15 + (attempt % 3) * 15 + (attempt / 3) * 10;\n int max_steps = 450 + attempt * 100;\n bool ultra_aggressive = (attempt >= 8);\n \n unordered_set visited_components;\n visited_components.insert(tiles[initial_tile_id].cluster_id);\n \n // Main exploration loop\n for (int step = 0; step < max_steps; step++) {\n // Update tile statistics and priorities\n for (auto& [id, tile] : tiles) {\n if (tile.visited) continue;\n \n tile.connectivity = 0;\n for (auto [ti, tj] : tile.squares) {\n for (int d = 0; d < 4; d++) {\n int ni = ti + di[d];\n int nj = tj + dj[d];\n if (0 <= ni && ni < 50 && 0 <= nj && nj < 50) {\n if (!visited_square[ni][nj]) {\n tile.connectivity++;\n }\n }\n }\n }\n \n tile.distance_to_unvisited = abs(current_i - tile.center_i) + abs(current_j - tile.center_j);\n \n // Ultra-aggressive priority calculation\n tile.priority = tile.total_value;\n tile.priority += tile.connectivity * (20 + attempt * 3) * exploration_factor;\n tile.priority -= tile.distance_to_unvisited * (0.5 + ultra_aggressive * 0.3);\n \n if (!visited_components.count(tile.cluster_id)) {\n tile.priority += 200 + component_value[tile.cluster_id] / 2;\n }\n \n if (tile.connectivity >= 4) {\n tile.priority += 80 * (1 + ultra_aggressive);\n }\n \n // Look-ahead bonus\n int future_potential = 0;\n for (auto [neighbor_id, _] : tile_graph[id]) {\n if (!tiles[neighbor_id].visited) {\n future_potential += tiles[neighbor_id].total_value / 2;\n }\n }\n tile.priority += future_potential;\n }\n \n vector> candidates;\n \n // Find adjacent unvisited tiles\n for (int d = 0; d < 4; d++) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited_square[ni][nj]) continue;\n \n int tile_id = t[ni][nj];\n if (tiles[tile_id].visited) continue;\n \n double score = tiles[tile_id].priority;\n score += rng() % (40 + attempt * 8);\n \n candidates.push_back({score, ni, nj, dirs[d]});\n }\n \n if (!candidates.empty()) {\n sort(candidates.rbegin(), candidates.rend());\n \n // Try multiple candidates in ultra-aggressive mode\n int try_count = ultra_aggressive ? min(5, (int)candidates.size()) : \n (attempt >= 5 ? min(3, (int)candidates.size()) : 1);\n bool moved = false;\n \n for (int try_idx = 0; try_idx < try_count && !moved; try_idx++) {\n auto [score, ni, nj, dir] = candidates[try_idx];\n \n path += dir;\n current_i = ni;\n current_j = nj;\n \n int tile_id = t[current_i][current_j];\n tiles[tile_id].visited = true;\n visited_components.insert(tiles[tile_id].cluster_id);\n \n for (auto [ti, tj] : tiles[tile_id].squares) {\n visited_square[ti][tj] = true;\n total_score += p[ti][tj];\n }\n moved = true;\n }\n } else {\n // Ultra-aggressive BFS with full grid search\n queue> q;\n q.push({current_i, current_j, \"\", 0});\n \n vector> bfs_visited(50, vector(50, false));\n bfs_visited[current_i][current_j] = true;\n \n bool found = false;\n string found_path;\n int best_tile_value = 0;\n int best_component_bonus = 0;\n \n while (!q.empty()) {\n auto [ci, cj, current_path, dist] = q.front();\n q.pop();\n \n if (dist > max_search_distance) continue;\n \n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n \n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (bfs_visited[ni][nj]) continue;\n if (visited_square[ni][nj]) continue;\n \n int tile_id = t[ni][nj];\n if (!tiles[tile_id].visited) {\n int component_bonus = visited_components.count(tiles[tile_id].cluster_id) ? 0 : 300;\n int total_score = tiles[tile_id].total_value + component_bonus;\n \n if (total_score > best_tile_value || \n (total_score == best_tile_value && found_path.empty())) {\n found_path = current_path + dirs[d];\n best_tile_value = tiles[tile_id].total_value;\n best_component_bonus = component_bonus;\n found = true;\n }\n }\n \n bfs_visited[ni][nj] = true;\n q.push({ni, nj, current_path + dirs[d], dist + 1});\n }\n }\n \n if (found) {\n path += found_path;\n for (char c : found_path) {\n if (c == 'U') current_i--;\n else if (c == 'D') current_i++;\n else if (c == 'L') current_j--;\n else if (c == 'R') current_j++;\n }\n \n int tile_id = t[current_i][current_j];\n tiles[tile_id].visited = true;\n visited_components.insert(tiles[tile_id].cluster_id);\n \n for (auto [ti, tj] : tiles[tile_id].squares) {\n visited_square[ti][tj] = true;\n total_score += p[ti][tj];\n }\n } else {\n // In ultra-aggressive mode, never give up\n if (ultra_aggressive && step < max_steps * 0.95) {\n max_search_distance = min(50, max_search_distance + 20);\n continue;\n }\n break;\n }\n }\n }\n \n if (total_score > best_score) {\n best_score = total_score;\n best_path = path;\n }\n }\n \n cout << best_path << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\n// --- Constants ---\nconstexpr int N = 30;\nconstexpr double INF = 1e18;\nconstexpr int MIN_EDGE = 1000;\nconstexpr int MAX_EDGE = 9000;\n\n// --- Hyperparameters for Learning ---\n// This configuration has been empirically determined to be the most effective.\nconstexpr double INITIAL_LEARNING_RATE = 0.3;\nconstexpr double LEARNING_DECAY = 0.9995;\n\n// --- Global State ---\ndouble H[N][N - 1]; // horizontal edge (i,j) -> (i,j+1)\ndouble V[N - 1][N]; // vertical edge (i,j) -> (i+1,j)\n// Seed the RNG with a non-deterministic source to explore different initial conditions.\nmt19937 rng(random_device{}());\n\n// --- Dijkstra's Algorithm for pure exploitation ---\nstring find_path(int si, int sj, int ti, int tj, vector>& used_edges) {\n double dist[N][N];\n int prev[N][N];\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n dist[i][j] = INF;\n prev[i][j] = -1;\n }\n }\n dist[si][sj] = 0.0;\n\n using Node = pair>;\n priority_queue, greater> pq;\n pq.emplace(0.0, make_pair(si, sj));\n\n constexpr int di[4] = {-1, 1, 0, 0};\n constexpr int dj[4] = {0, 0, -1, 1};\n\n while (!pq.empty()) {\n auto [d, coord] = pq.top();\n auto [i, j] = coord;\n pq.pop();\n\n if (d > dist[i][j] + 1e-9) continue;\n if (i == ti && j == tj) break;\n\n for (int dir = 0; dir < 4; ++dir) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n\n double w = 0.0;\n if (dir == 0) w = V[i - 1][j]; // U\n else if (dir == 1) w = V[i][j]; // D\n else if (dir == 2) w = H[i][j - 1]; // L\n else w = H[i][j]; // R\n\n if (dist[i][j] + w < dist[ni][nj] - 1e-9) {\n dist[ni][nj] = dist[i][j] + w;\n prev[ni][nj] = dir;\n pq.emplace(dist[ni][nj], make_pair(ni, nj));\n }\n }\n }\n\n vector> vertex_path;\n int ci = ti, cj = tj;\n vertex_path.emplace_back(ci, cj);\n while (!(ci == si && cj == sj)) {\n int dir = prev[ci][cj];\n int pi = ci - di[dir];\n int pj = cj - dj[dir];\n vertex_path.emplace_back(pi, pj);\n ci = pi;\n cj = pj;\n }\n reverse(vertex_path.begin(), vertex_path.end());\n\n string path_str;\n used_edges.clear();\n for (size_t i = 0; i + 1 < vertex_path.size(); ++i) {\n int ci = vertex_path[i].first;\n int cj = vertex_path[i].second;\n int ni = vertex_path[i+1].first;\n int nj = vertex_path[i+1].second;\n\n if (ni == ci - 1) { // U\n path_str.push_back('U');\n used_edges.emplace_back(1, ci - 1, cj);\n } else if (ni == ci + 1) { // D\n path_str.push_back('D');\n used_edges.emplace_back(1, ci, cj);\n } else if (nj == cj - 1) { // L\n path_str.push_back('L');\n used_edges.emplace_back(0, ci, cj - 1);\n } else { // R\n path_str.push_back('R');\n used_edges.emplace_back(0, ci, cj);\n }\n }\n return path_str;\n}\n\n// --- Main ---\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n uniform_int_distribution init_dist(MIN_EDGE, MAX_EDGE);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N - 1; ++j) H[i][j] = init_dist(rng);\n }\n for (int i = 0; i < N - 1; ++i) {\n for (int j = 0; j < N; ++j) V[i][j] = init_dist(rng);\n }\n\n vector> used_edges;\n used_edges.reserve(60);\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) break;\n\n string path = find_path(si, sj, ti, tj, used_edges);\n\n cout << path << \"\\n\";\n cout.flush();\n\n long long observed;\n cin >> observed;\n\n if (used_edges.empty()) continue;\n\n double lest = 0.0;\n for (auto [type, i, j] : used_edges) {\n lest += (type == 0) ? H[i][j] : V[i][j];\n }\n\n double delta = static_cast(observed) - lest;\n double current_lr = INITIAL_LEARNING_RATE * pow(LEARNING_DECAY, q);\n double step = current_lr * delta / used_edges.size();\n\n for (auto [type, i, j] : used_edges) {\n if (type == 0) {\n H[i][j] += step;\n H[i][j] = clamp(H[i][j], (double)MIN_EDGE, (double)MAX_EDGE);\n } else {\n V[i][j] += step;\n V[i][j] = clamp(V[i][j], (double)MIN_EDGE, (double)MAX_EDGE);\n }\n }\n }\n\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace chrono;\n\nconst int N = 20;\nconst char EMPTY = '.';\n\nstruct StringInfo {\n string s;\n int length;\n int id;\n int priority;\n vector substrings;\n unordered_set substr_set;\n int pattern_score;\n double complexity;\n int unique_chars;\n};\n\nstruct Position {\n int i, j, dir;\n double score;\n int conflicts;\n};\n\nclass FinalTorusReconstructor {\nprivate:\n vector strings;\n vector> matrix;\n mt19937 rng;\n array char_freq;\n int best_score;\n vector> best_matrix;\n vector is_matched;\n int matched_count;\n unordered_map> substring_map;\n vector common_patterns;\n vector rare_patterns;\n vector> conflict_graph;\n double progress_factor;\n int phase;\n \npublic:\n FinalTorusReconstructor(const vector& input_strings) : \n rng(steady_clock::now().time_since_epoch().count()) {\n strings.resize(input_strings.size());\n char_freq.fill(0);\n phase = 0;\n \n for (int i = 0; i < input_strings.size(); i++) {\n strings[i].s = input_strings[i];\n strings[i].length = input_strings[i].length();\n strings[i].id = i;\n strings[i].priority = 0;\n strings[i].pattern_score = 0;\n strings[i].complexity = 0;\n strings[i].unique_chars = 0;\n \n unordered_set chars;\n for (char c : input_strings[i]) {\n char_freq[c - 'A']++;\n strings[i].priority += char_freq[c - 'A'];\n chars.insert(c);\n }\n strings[i].unique_chars = chars.size();\n \n for (int len = 2; len <= min(4, strings[i].length); len++) {\n for (int start = 0; start <= strings[i].length - len; start++) {\n string sub = strings[i].s.substr(start, len);\n strings[i].substrings.push_back(sub);\n strings[i].substr_set.insert(sub);\n substring_map[sub].push_back(i);\n }\n }\n }\n \n extract_patterns();\n calculate_pattern_scores();\n build_conflict_graph();\n \n matrix.assign(N, vector(N, EMPTY));\n best_matrix = matrix;\n best_score = 0;\n is_matched.assign(strings.size(), false);\n matched_count = 0;\n progress_factor = 1.0;\n }\n \n void extract_patterns() {\n unordered_map pattern_count;\n \n for (const auto& str_info : strings) {\n for (const string& sub : str_info.substrings) {\n pattern_count[sub]++;\n }\n }\n \n for (const auto& [pattern, count] : pattern_count) {\n if (count >= 3) {\n common_patterns.push_back(pattern);\n } else if (count == 2) {\n rare_patterns.push_back(pattern);\n }\n }\n \n sort(common_patterns.begin(), common_patterns.end(),\n [&pattern_count](const string& a, const string& b) {\n return pattern_count[a] > pattern_count[b];\n });\n \n sort(rare_patterns.begin(), rare_patterns.end(),\n [&pattern_count](const string& a, const string& b) {\n return pattern_count[a] > pattern_count[b];\n });\n }\n \n void calculate_pattern_scores() {\n for (auto& str_info : strings) {\n int common_score = 0;\n int rare_score = 0;\n \n for (const string& pattern : common_patterns) {\n if (str_info.s.find(pattern) != string::npos) {\n common_score += substring_map[pattern].size() * 2;\n }\n }\n \n for (const string& pattern : rare_patterns) {\n if (str_info.s.find(pattern) != string::npos) {\n rare_score += substring_map[pattern].size() * 3;\n }\n }\n \n str_info.pattern_score = common_score + rare_score;\n str_info.complexity = (double)str_info.length * (str_info.pattern_score + str_info.unique_chars * 5) / 100.0;\n }\n }\n \n void build_conflict_graph() {\n conflict_graph.resize(strings.size());\n \n for (int i = 0; i < strings.size(); i++) {\n for (int j = i + 1; j < strings.size(); j++) {\n bool compatible = false;\n for (const string& sub : strings[i].substrings) {\n if (strings[j].substr_set.count(sub)) {\n compatible = true;\n break;\n }\n }\n if (compatible) {\n conflict_graph[i].push_back(j);\n conflict_graph[j].push_back(i);\n }\n }\n }\n }\n \n bool check_string_match_fast(int idx) const {\n const string& s = strings[idx].s;\n int k = s.length();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n bool match = true;\n for (int p = 0; p < k; p++) {\n if (matrix[i][(j + p) % N] != s[p]) {\n match = false;\n break;\n }\n }\n if (match) return true;\n \n match = true;\n for (int p = 0; p < k; p++) {\n if (matrix[(i + p) % N][j] != s[p]) {\n match = false;\n break;\n }\n }\n if (match) return true;\n }\n }\n return false;\n }\n \n void update_matched_status() {\n int old_count = matched_count;\n matched_count = 0;\n \n for (int i = 0; i < strings.size(); i++) {\n is_matched[i] = check_string_match_fast(i);\n if (is_matched[i]) matched_count++;\n }\n \n progress_factor = (double)matched_count / strings.size();\n \n if (matched_count > old_count) {\n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n for (int neighbor : conflict_graph[i]) {\n if (is_matched[neighbor]) {\n bool now_matched = check_string_match_fast(i);\n if (now_matched) {\n is_matched[i] = true;\n matched_count++;\n }\n }\n }\n }\n }\n }\n }\n \n void final_initialization() {\n matrix.assign(N, vector(N, EMPTY));\n \n sort(strings.begin(), strings.end(), \n [this](const StringInfo& a, const StringInfo& b) {\n if (phase == 0) {\n if (abs(a.complexity - b.complexity) > 0.1) {\n return a.complexity > b.complexity;\n }\n } else {\n if (a.pattern_score != b.pattern_score) {\n return a.pattern_score > b.pattern_score;\n }\n }\n if (a.length != b.length) return a.length > b.length;\n return a.unique_chars > b.unique_chars;\n });\n \n int strings_to_place = phase == 0 ? 100 : 80;\n for (int idx = 0; idx < min(strings_to_place, (int)strings.size()); idx++) {\n place_string_final(strings[idx].s);\n }\n \n smart_fill_remaining();\n }\n \n void place_string_final(const string& s) {\n int k = s.length();\n Position best_pos = {-1, -1, -1, -1.0, k};\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n double h_score = evaluate_position_enhanced(i, j, 0, s);\n double v_score = evaluate_position_enhanced(i, j, 1, s);\n \n int h_conflicts = count_conflicts(i, j, 0, s);\n int v_conflicts = count_conflicts(i, j, 1, s);\n \n if (h_conflicts < best_pos.conflicts || \n (h_conflicts == best_pos.conflicts && h_score > best_pos.score)) {\n best_pos = {i, j, 0, h_score, h_conflicts};\n }\n \n if (v_conflicts < best_pos.conflicts || \n (v_conflicts == best_pos.conflicts && v_score > best_pos.score)) {\n best_pos = {i, j, 1, v_score, h_conflicts};\n }\n }\n }\n \n int max_conflicts = phase < 2 ? min(2, k / 3) : min(3, k / 2);\n if (best_pos.conflicts <= max_conflicts || \n (best_pos.score > 1.0 && best_pos.conflicts <= k / 2)) {\n int k = s.length();\n if (best_pos.dir == 0) {\n for (int p = 0; p < k; p++) {\n matrix[best_pos.i][(best_pos.j + p) % N] = s[p];\n }\n } else {\n for (int p = 0; p < k; p++) {\n matrix[(best_pos.i + p) % N][best_pos.j] = s[p];\n }\n }\n }\n }\n \n double evaluate_position_enhanced(int i, int j, int dir, const string& s) const {\n int k = s.length();\n double score = 0;\n int matches = 0;\n int pattern_bonus = 0;\n int continuity_bonus = 0;\n \n for (int p = 0; p < k; p++) {\n char current = (dir == 0) ? matrix[i][(j + p) % N] : matrix[(i + p) % N][j];\n if (current != EMPTY) {\n if (current == s[p]) {\n matches++;\n score += 2.5;\n \n if (p > 0) {\n char prev = (dir == 0) ? matrix[i][(j + p - 1) % N] : matrix[(i + p - 1) % N][j];\n if (prev == s[p-1]) continuity_bonus += 1.0;\n }\n } else {\n score -= 1.8;\n }\n }\n }\n \n for (int len = 2; len <= min(3, k); len++) {\n for (int start = 0; start <= k - len; start++) {\n string sub = s.substr(start, len);\n if (substring_map.count(sub)) {\n int weight = substring_map.at(sub).size();\n if (find(rare_patterns.begin(), rare_patterns.end(), sub) != rare_patterns.end()) {\n weight *= 2;\n }\n pattern_bonus += weight;\n }\n }\n }\n \n score += pattern_bonus * 0.4;\n score += continuity_bonus * 0.5;\n score += (double)matches / k * 6.0;\n \n return score;\n }\n \n int count_conflicts(int i, int j, int dir, const string& s) const {\n int k = s.length();\n int conflicts = 0;\n \n for (int p = 0; p < k; p++) {\n char current = (dir == 0) ? matrix[i][(j + p) % N] : matrix[(i + p) % N][j];\n if (current != EMPTY && current != s[p]) {\n conflicts++;\n }\n }\n \n return conflicts;\n }\n \n void smart_fill_remaining() {\n array, 8> freq_chars;\n for (int i = 0; i < 8; i++) {\n freq_chars[i] = {char_freq[i], 'A' + i};\n }\n sort(freq_chars.begin(), freq_chars.end(), greater>());\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == EMPTY) {\n array scores = {0};\n \n for (int di = -2; di <= 2; di++) {\n for (int dj = -2; dj <= 2; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = (i + di + N) % N;\n int nj = (j + dj + N) % N;\n if (matrix[ni][nj] != EMPTY) {\n int c = matrix[ni][nj] - 'A';\n double weight = 3.0 - abs(di) - abs(dj);\n scores[c] += weight;\n \n string context = \"\";\n for (int p = -1; p <= 1; p++) {\n int ci = (i + di + p + N) % N;\n int cj = (j + dj + p + N) % N;\n if (matrix[ci][cj] != EMPTY) {\n context += matrix[ci][cj];\n }\n }\n \n for (const string& pattern : common_patterns) {\n if (context.find(pattern) != string::npos) {\n scores[c] += 1.5;\n }\n }\n \n for (const string& pattern : rare_patterns) {\n if (context.find(pattern) != string::npos) {\n scores[c] += 2.0;\n }\n }\n }\n }\n }\n \n for (int c = 0; c < 8; c++) {\n scores[c] += (double)char_freq[c] / 80.0;\n }\n \n int best_char = max_element(scores.begin(), scores.end()) - scores.begin();\n matrix[i][j] = 'A' + best_char;\n }\n }\n }\n }\n \n void final_optimization() {\n for (phase = 0; phase < 7; phase++) {\n if (phase < 2) {\n aggressive_placement();\n } else if (phase < 4) {\n adaptive_local_search();\n } else if (phase < 6) {\n focused_refinement();\n } else {\n ultimate_polish();\n }\n \n update_matched_status();\n \n if (matched_count > best_score) {\n best_score = matched_count;\n best_matrix = matrix;\n }\n }\n }\n \n void aggressive_placement() {\n vector> priority_strings;\n \n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n double urgency = strings[i].complexity * (1.2 + progress_factor * 0.8);\n if (strings[i].unique_chars >= 3) urgency *= 1.3;\n priority_strings.push_back({urgency, i});\n }\n }\n \n sort(priority_strings.rbegin(), priority_strings.rend());\n \n int attempts = phase == 0 ? 80 : 60;\n for (int iter = 0; iter < min(attempts, (int)priority_strings.size()); iter++) {\n int idx = priority_strings[iter].second;\n place_string_final(strings[idx].s);\n }\n }\n \n void adaptive_local_search() {\n int base_iterations = 1200;\n int iterations = base_iterations * (1.0 + (1.0 - progress_factor) * 0.8);\n \n for (int iter = 0; iter < iterations; iter++) {\n int i = rng() % N;\n int j = rng() % N;\n \n char old_char = matrix[i][j];\n array char_scores = {0};\n \n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = (i + di + N) % N;\n int nj = (j + dj + N) % N;\n if (matrix[ni][nj] != EMPTY) {\n for (int c = 0; c < 8; c++) {\n if (matrix[ni][nj] == 'A' + c) {\n char_scores[c] += 3.0;\n } else {\n char_scores[c] -= 1.2;\n }\n }\n }\n }\n }\n \n for (int c = 0; c < 8; c++) {\n char_scores[c] += (double)char_freq[c] / 40.0;\n }\n \n int best_char = max_element(char_scores.begin(), char_scores.end()) - char_scores.begin();\n char new_char = 'A' + best_char;\n \n if (new_char != old_char) {\n matrix[i][j] = new_char;\n \n double delta = evaluate_change_precise(i, j, old_char, new_char);\n double threshold = progress_factor < 0.6 ? 0.0 : -0.3;\n \n if (delta < threshold && rng() % 8 != 0) {\n matrix[i][j] = old_char;\n }\n }\n }\n }\n \n double evaluate_change_precise(int i, int j, char old_char, char new_char) {\n double delta = 0;\n vector check_strings;\n \n for (int idx = 0; idx < strings.size(); idx++) {\n if (!is_matched[idx]) {\n const string& s = strings[idx].s;\n int k = s.length();\n bool could_match = false;\n \n for (int p = 0; p < k; p++) {\n int check_i = (i - p + N) % N;\n int check_j = j;\n if (check_i >= 0 && check_i < N && check_j >= 0 && check_j < N) {\n bool vertical_match = true;\n for (int q = 0; q < k; q++) {\n if (matrix[(check_i + q) % N][check_j] != s[q]) {\n vertical_match = false;\n break;\n }\n }\n if (vertical_match) {\n could_match = true;\n break;\n }\n }\n \n check_i = i;\n check_j = (j - p + N) % N;\n if (check_i >= 0 && check_i < N && check_j >= 0 && check_j < N) {\n bool horizontal_match = true;\n for (int q = 0; q < k; q++) {\n if (matrix[check_i][(check_j + q) % N] != s[q]) {\n horizontal_match = false;\n break;\n }\n }\n if (horizontal_match) {\n could_match = true;\n break;\n }\n }\n }\n \n if (could_match) {\n check_strings.push_back(idx);\n }\n }\n }\n \n for (int idx : check_strings) {\n bool now_matched = check_string_match_fast(idx);\n if (now_matched) delta += 1.0;\n }\n \n return delta;\n }\n \n void focused_refinement() {\n vector problematic_strings;\n \n for (int i = 0; i < strings.size(); i++) {\n if (!is_matched[i]) {\n if (strings[i].unique_chars >= 3 || strings[i].pattern_score > 5) {\n problematic_strings.push_back(i);\n }\n }\n }\n \n sort(problematic_strings.begin(), problematic_strings.end(),\n [this](int a, int b) {\n return strings[a].complexity > strings[b].complexity;\n });\n \n for (int iter = 0; iter < min(40, (int)problematic_strings.size()); iter++) {\n int idx = problematic_strings[iter];\n place_string_final(strings[idx].s);\n }\n }\n \n void ultimate_polish() {\n for (int iter = 0; iter < 400; iter++) {\n int idx = rng() % strings.size();\n if (!is_matched[idx]) {\n place_string_final(strings[idx].s);\n if (check_string_match_fast(idx)) {\n is_matched[idx] = true;\n matched_count++;\n }\n }\n }\n }\n \n void reconstruct() {\n final_initialization();\n update_matched_status();\n \n if (matched_count > best_score) {\n best_score = matched_count;\n best_matrix = matrix;\n }\n \n final_optimization();\n \n matrix = best_matrix;\n }\n \n vector> get_matrix() const {\n return matrix;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N_input, M;\n cin >> N_input >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n FinalTorusReconstructor reconstructor(strings);\n reconstructor.reconstruct();\n \n auto matrix = reconstructor.get_matrix();\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << matrix[i][j];\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, si, sj;\n cin >> N >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n // Find all reachable road squares from start\n vector> reachable(N, vector(N, false));\n vector> road_positions;\n queue> q;\n q.push({si, sj});\n reachable[si][sj] = true;\n road_positions.emplace_back(si, sj);\n \n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d][0];\n int nj = j + dirs[d][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n grid[ni][nj] != '#' && !reachable[ni][nj]) {\n reachable[ni][nj] = true;\n road_positions.emplace_back(ni, nj);\n q.push({ni, nj});\n }\n }\n }\n \n // Simple but robust approach: systematic coverage with guaranteed validity\n string path;\n int current_i = si, current_j = sj;\n vector> visited(N, vector(N, false));\n visited[si][sj] = true;\n int visited_count = 1;\n \n // Helper function to find path using BFS\n auto find_path = [&](int from_i, int from_j, int to_i, int to_j) -> string {\n if (from_i == to_i && from_j == to_j) return \"\";\n \n vector>> parent(N, vector>(N, {-1, -1}));\n vector> bfs_visited(N, vector(N, false));\n queue> bfs_q;\n \n bfs_q.push({from_i, from_j});\n bfs_visited[from_i][from_j] = true;\n \n while (!bfs_q.empty()) {\n auto [ci, cj] = bfs_q.front();\n bfs_q.pop();\n \n if (ci == to_i && cj == to_j) break;\n \n for (int d = 0; d < 4; d++) {\n int ni = ci + dirs[d][0];\n int nj = cj + dirs[d][1];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n reachable[ni][nj] && !bfs_visited[ni][nj]) {\n bfs_visited[ni][nj] = true;\n parent[ni][nj] = {ci, cj};\n bfs_q.push({ni, nj});\n }\n }\n }\n \n if (!bfs_visited[to_i][to_j]) return \"\";\n \n string result;\n int ci = to_i, cj = to_j;\n \n while (ci != from_i || cj != from_j) {\n auto [pi, pj] = parent[ci][cj];\n if (pi == -1 && pj == -1) break;\n \n if (pi == ci - 1) result += 'D';\n else if (pi == ci + 1) result += 'U';\n else if (pj == cj - 1) result += 'R';\n else if (pj == cj + 1) result += 'L';\n \n ci = pi;\n cj = pj;\n }\n \n reverse(result.begin(), result.end());\n return result;\n };\n \n // Visit all road squares using nearest neighbor with BFS paths\n while (visited_count < (int)road_positions.size()) {\n int best_dist = INT_MAX;\n int best_i = -1, best_j = -1;\n \n for (auto [i, j] : road_positions) {\n if (!visited[i][j]) {\n int dist = abs(i - current_i) + abs(j - current_j);\n if (dist < best_dist) {\n best_dist = dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n \n if (best_i == -1) break;\n \n string segment = find_path(current_i, current_j, best_i, best_j);\n \n if (segment.empty()) {\n // Mark as visited to avoid infinite loop\n visited[best_i][best_j] = true;\n visited_count++;\n continue;\n }\n \n path += segment;\n \n // Update current position and visited status\n for (char c : segment) {\n if (c == 'U') current_i--;\n else if (c == 'D') current_i++;\n else if (c == 'L') current_j--;\n else if (c == 'R') current_j++;\n \n if (!visited[current_i][current_j]) {\n visited[current_i][current_j] = true;\n visited_count++;\n }\n }\n }\n \n // Return to start\n string return_segment = find_path(current_i, current_j, si, sj);\n if (!return_segment.empty()) {\n path += return_segment;\n }\n \n // Simple optimization - remove immediate backtracks only\n string optimized;\n for (char c : path) {\n if (!optimized.empty()) {\n char last = optimized.back();\n if ((last == 'U' && c == 'D') || (last == 'D' && c == 'U') ||\n (last == 'L' && c == 'R') || (last == 'R' && c == 'L')) {\n optimized.pop_back();\n } else {\n optimized += c;\n }\n } else {\n optimized += c;\n }\n }\n \n cout << optimized << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Variables ---\nint N, M, K, R;\nvector> d; // Task requirements\nvector> pred; // Predecessor lists\nvector> succ; // Successor lists\nvector num_preds; // Number of predecessors for each task\nvector L; // Longest path length from each task\nvector max_d; // Max requirement for each skill\n\n// --- State ---\nint current_day;\nvector task_status; // 0: todo, 1: doing, 2: done\nvector completed_preds_count;\nvector member_busy;\nvector member_task; // task assigned to member\nvector member_start_day;\nvector> s_est; // Estimated skills for each member\nvector num_tasks_done;\n\n// --- Helper function for topological sort ---\nvector topological_sort(const vector>& graph) {\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int v : graph[i]) {\n in_degree[v]++;\n }\n }\n queue q;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n q.push(i);\n }\n }\n vector order;\n while (!q.empty()) {\n int u = q.front(); q.pop();\n order.push_back(u);\n for (int v : graph[u]) {\n if (--in_degree[v] == 0) {\n q.push(v);\n }\n }\n }\n return order;\n}\n\n// --- Main function ---\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // --- Input Reading ---\n cin >> N >> M >> K >> R;\n d.resize(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n cin >> d[i][j];\n }\n }\n\n pred.resize(N);\n succ.resize(N);\n num_preds.resize(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--; // 0-based\n pred[v].push_back(u);\n succ[u].push_back(v);\n num_preds[v]++;\n }\n\n // --- Preprocessing ---\n // Calculate max_d\n max_d.assign(K, 0);\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n max_d[k] = max(max_d[k], d[i][k]);\n }\n }\n\n // Calculate L (longest path length)\n vector topo_order = topological_sort(pred); // Sort by preds\n L.assign(N, 1);\n for (auto it = topo_order.rbegin(); it != topo_order.rend(); ++it) {\n int u = *it;\n for (int v : succ[u]) {\n L[u] = max(L[u], 1 + L[v]);\n }\n }\n\n // --- State Initialization ---\n current_day = 1;\n task_status.assign(N, 0);\n completed_preds_count.assign(N, 0);\n member_busy.assign(M, false);\n member_task.assign(M, -1);\n member_start_day.assign(M, -1);\n s_est.assign(M, vector(K, 0.0));\n num_tasks_done.assign(M, 0);\n\n // --- Main Loop ---\n while (true) {\n // --- Step 1: Update State and Learn ---\n string line;\n getline(cin, line); // consume the rest of the previous line, if any\n getline(cin, line);\n istringstream iss(line);\n int n;\n iss >> n;\n if (n == -1) {\n break;\n }\n\n for (int i = 0; i < n; ++i) {\n int f_j;\n iss >> f_j;\n int j = f_j - 1; // 0-based index\n\n int t_id = member_task[j];\n int start_day = member_start_day[j];\n int t_obs = (current_day - 1) - start_day + 1;\n\n task_status[t_id] = 2; // Mark as done\n member_busy[j] = false;\n member_task[j] = -1;\n\n for (int succ_task : succ[t_id]) {\n completed_preds_count[succ_task]++;\n }\n\n // Skill Update\n num_tasks_done[j]++;\n double lr = (t_obs > 1) ? 1.0 / sqrt(num_tasks_done[j]) : 0.1 / sqrt(num_tasks_done[j]);\n for (int k = 0; k < K; ++k) {\n if (d[t_id][k] > s_est[j][k]) {\n s_est[j][k] += lr;\n s_est[j][k] = min(s_est[j][k], (double)d[t_id][k]);\n s_est[j][k] = min(s_est[j][k], (double)max_d[k]);\n }\n }\n }\n \n // --- Step 2: Find Available Resources ---\n vector ready_tasks;\n for (int i = 0; i < N; ++i) {\n if (task_status[i] == 0 && completed_preds_count[i] == num_preds[i]) {\n ready_tasks.push_back(i);\n }\n }\n\n vector free_members;\n for (int j = 0; j < M; ++j) {\n if (!member_busy[j]) {\n free_members.push_back(j);\n }\n }\n\n // --- Step 3: Greedy Assignment ---\n vector> assignments;\n if (!ready_tasks.empty() && !free_members.empty()) {\n vector> pairs; // cost, -L[i], est_time, task_id, member_id\n for (int i : ready_tasks) {\n for (int j : free_members) {\n double w_est = 0.0;\n for (int k = 0; k < K; ++k) {\n w_est += max(0, d[i][k] - s_est[j][k]);\n }\n int est_time = max(1.0, w_est);\n double cost = (double)est_time / L[i];\n pairs.emplace_back(cost, -L[i], est_time, i, j);\n }\n }\n sort(pairs.begin(), pairs.end());\n\n vector task_used(N, false);\n vector member_used(M, false);\n for (const auto& p : pairs) {\n int i = get<3>(p);\n int j = get<4>(p);\n if (!task_used[i] && !member_used[j]) {\n assignments.emplace_back(j + 1, i + 1); // 1-based for output\n task_status[i] = 1; // Mark as in progress\n member_busy[j] = true;\n member_task[j] = i;\n member_start_day[j] = current_day;\n task_used[i] = true;\n member_used[j] = true;\n }\n }\n }\n\n // --- Step 4: Output and Flush ---\n cout << assignments.size();\n for (const auto& a : assignments) {\n cout << \" \" << a.first << \" \" << a.second;\n }\n cout << endl;\n cout.flush();\n\n // --- Step 5: Increment Day ---\n current_day++;\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int id, a, b, c, d;\n int total_dist;\n};\n\nint manhattan_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Exact order selection that achieved 455,006\nvector select_orders_optimal(const vector& orders) {\n vector> order_scores;\n \n for (int i = 0; i < 1000; i++) {\n int pickup_dist = manhattan_dist(orders[i].a, orders[i].b, 400, 400);\n int delivery_dist = manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n int order_dist = manhattan_dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d);\n \n // Exact scoring that achieved peak\n double score = 0.69 * (pickup_dist + delivery_dist) + 0.31 * order_dist;\n order_scores.push_back({score, i});\n }\n \n sort(order_scores.begin(), order_scores.end());\n \n vector selected(1000, false);\n random_device rd;\n mt19937 gen(rd());\n \n // Exact parameters\n int search_range = min(200, 1000);\n uniform_int_distribution dist(0, search_range - 1);\n \n unordered_set selected_set;\n while (selected_set.size() < 50) {\n int idx = dist(gen);\n int order_id = order_scores[idx].second;\n if (selected_set.find(order_id) == selected_set.end()) {\n selected_set.insert(order_id);\n selected[order_id] = true;\n }\n }\n \n return selected;\n}\n\n// Exact route construction that achieved 455,006\nvector> build_route_optimal(const vector& orders, const vector& selected) {\n vector selected_orders;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_orders.push_back(i);\n }\n }\n \n vector> route;\n route.push_back({400, 400});\n \n int current_x = 400, current_y = 400;\n vector pickup_visited(1000, false);\n vector delivery_visited(1000, false);\n \n // Visit all pickups using greedy nearest neighbor\n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (!pickup_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].a, orders[order_id].b);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].a, orders[best_order].b});\n current_x = orders[best_order].a;\n current_y = orders[best_order].b;\n pickup_visited[best_order] = true;\n }\n }\n \n // Visit all deliveries using greedy nearest neighbor\n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (pickup_visited[order_id] && !delivery_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].c, orders[order_id].d);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].c, orders[best_order].d});\n current_x = orders[best_order].c;\n current_y = orders[best_order].d;\n delivery_visited[best_order] = true;\n }\n }\n \n route.push_back({400, 400});\n return route;\n}\n\n// Exact 2-opt that achieved 455,006\nvector> two_opt_optimal(const vector>& route, const vector& orders, const vector& selected) {\n if (route.size() < 4) return route;\n \n // Build point to order mapping\n unordered_map> point_info;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n long long pickup_key = ((long long)orders[i].a << 32) | orders[i].b;\n long long delivery_key = ((long long)orders[i].c << 32) | orders[i].d;\n point_info[pickup_key] = {i, 1};\n point_info[delivery_key] = {i, 2};\n }\n }\n \n vector> best = route;\n int best_len = 0;\n for (size_t i = 0; i < best.size() - 1; i++) {\n best_len += manhattan_dist(best[i].first, best[i].second, best[i+1].first, best[i+1].second);\n }\n \n // Exact 2-opt parameters\n for (int iter = 0; iter < 7; iter++) {\n bool improved = false;\n \n for (size_t i = 1; i < route.size() - 2 && !improved; i++) {\n for (size_t j = i + 1; j < route.size() - 1; j++) {\n // Strict constraint validation\n bool valid = true;\n unordered_set pickups_in_segment;\n unordered_set deliveries_in_segment;\n \n // Analyze the segment to be reversed\n for (size_t k = i; k <= j; k++) {\n long long key = ((long long)route[k].first << 32) | route[k].second;\n if (point_info.count(key)) {\n auto info = point_info[key];\n if (info.second == 1) { // pickup\n pickups_in_segment.insert(info.first);\n } else { // delivery\n deliveries_in_segment.insert(info.first);\n }\n }\n }\n \n // Check if reversing would violate pickup-before-delivery\n for (int delivery_order : deliveries_in_segment) {\n if (pickups_in_segment.count(delivery_order)) {\n valid = false;\n break;\n }\n }\n \n if (valid) {\n vector> new_route = route;\n reverse(new_route.begin() + i, new_route.begin() + j + 1);\n \n // Calculate new length efficiently\n int new_len = best_len;\n \n // Remove old edge contributions\n if (i > 0) new_len -= manhattan_dist(route[i-1].first, route[i-1].second, route[i].first, route[i].second);\n if (j < route.size() - 1) new_len -= manhattan_dist(route[j].first, route[j].second, route[j+1].first, route[j+1].second);\n \n // Add new edge contributions\n if (i > 0) new_len += manhattan_dist(new_route[i-1].first, new_route[i-1].second, new_route[i].first, new_route[i].second);\n if (j < route.size() - 1) new_len += manhattan_dist(new_route[j].first, new_route[j].second, new_route[j+1].first, new_route[j+1].second);\n \n if (new_len < best_len) {\n best = new_route;\n best_len = new_len;\n improved = true;\n break;\n }\n }\n }\n }\n \n if (!improved) break;\n }\n \n return best;\n}\n\n// Exact adjacent swap that achieved 455,006\nvector> adjacent_swap_optimal(const vector>& route, const vector& orders, const vector& selected) {\n vector> best = route;\n int best_len = 0;\n for (size_t i = 0; i < best.size() - 1; i++) {\n best_len += manhattan_dist(best[i].first, best[i].second, best[i+1].first, best[i+1].second);\n }\n \n // Try swapping adjacent non-start/end points\n for (size_t i = 1; i < route.size() - 2; i++) {\n vector> new_route = route;\n swap(new_route[i], new_route[i+1]);\n \n // Validate the swap\n bool valid = true;\n unordered_map pickup_pos, delivery_pos;\n \n for (size_t j = 0; j < new_route.size(); j++) {\n for (int k = 0; k < 1000; k++) {\n if (selected[k]) {\n if (new_route[j].first == orders[k].a && new_route[j].second == orders[k].b) {\n pickup_pos[k] = j;\n } else if (new_route[j].first == orders[k].c && new_route[j].second == orders[k].d) {\n delivery_pos[k] = j;\n }\n }\n }\n }\n \n for (auto& [order_id, pos] : pickup_pos) {\n if (delivery_pos.count(order_id) && pos >= delivery_pos[order_id]) {\n valid = false;\n break;\n }\n }\n \n if (valid) {\n int new_len = 0;\n for (size_t j = 0; j < new_route.size() - 1; j++) {\n new_len += manhattan_dist(new_route[j].first, new_route[j].second, \n new_route[j+1].first, new_route[j+1].second);\n }\n \n if (new_len < best_len) {\n best = new_route;\n best_len = new_len;\n }\n }\n }\n \n return best;\n}\n\n// Exact multiple starts that achieved 455,006\nvector> try_multiple_starts_optimal(const vector& orders, const vector& selected) {\n vector> best_route;\n int best_length = INT_MAX;\n \n // Try 3 different random seeds\n for (int attempt = 0; attempt < 3; attempt++) {\n random_device rd;\n mt19937 gen(rd() + attempt);\n \n vector selected_orders;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_orders.push_back(i);\n }\n }\n \n // Shuffle the order of considering pickups\n shuffle(selected_orders.begin(), selected_orders.end(), gen);\n \n vector> route;\n route.push_back({400, 400});\n \n int current_x = 400, current_y = 400;\n vector pickup_visited(1000, false);\n vector delivery_visited(1000, false);\n \n // Visit pickups in shuffled order\n for (int order_id : selected_orders) {\n if (!pickup_visited[order_id]) {\n route.push_back({orders[order_id].a, orders[order_id].b});\n current_x = orders[order_id].a;\n current_y = orders[order_id].b;\n pickup_visited[order_id] = true;\n }\n }\n \n // Visit deliveries greedily\n for (int count = 0; count < 50; count++) {\n int best_order = -1;\n int best_dist = INT_MAX;\n \n for (int order_id : selected_orders) {\n if (pickup_visited[order_id] && !delivery_visited[order_id]) {\n int dist = manhattan_dist(current_x, current_y, orders[order_id].c, orders[order_id].d);\n if (dist < best_dist) {\n best_dist = dist;\n best_order = order_id;\n }\n }\n }\n \n if (best_order != -1) {\n route.push_back({orders[best_order].c, orders[best_order].d});\n current_x = orders[best_order].c;\n current_y = orders[best_order].d;\n delivery_visited[best_order] = true;\n }\n }\n \n route.push_back({400, 400});\n \n int length = 0;\n for (size_t i = 0; i < route.size() - 1; i++) {\n length += manhattan_dist(route[i].first, route[i].second, route[i+1].first, route[i+1].second);\n }\n \n if (length < best_length) {\n best_length = length;\n best_route = route;\n }\n }\n \n return best_route;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i;\n orders[i].total_dist = manhattan_dist(orders[i].a, orders[i].b, 400, 400) + \n manhattan_dist(orders[i].c, orders[i].d, 400, 400);\n }\n \n // Use the exact optimal approach\n vector selected = select_orders_optimal(orders);\n \n // Try both route building approaches\n vector> route1 = build_route_optimal(orders, selected);\n vector> route2 = try_multiple_starts_optimal(orders, selected);\n \n // Choose the better route\n int len1 = 0, len2 = 0;\n for (size_t i = 0; i < route1.size() - 1; i++) {\n len1 += manhattan_dist(route1[i].first, route1[i].second, route1[i+1].first, route1[i+1].second);\n }\n for (size_t i = 0; i < route2.size() - 1; i++) {\n len2 += manhattan_dist(route2[i].first, route2[i].second, route2[i+1].first, route2[i+1].second);\n }\n \n vector> route = (len1 < len2) ? route1 : route2;\n \n // Apply optimal optimizations\n route = two_opt_optimal(route, orders, selected);\n route = adjacent_swap_optimal(route, orders, selected);\n \n // Verify route completeness\n assert(route.size() == 102);\n \n // Output\n vector selected_ids;\n for (int i = 0; i < 1000; i++) {\n if (selected[i]) {\n selected_ids.push_back(i + 1);\n }\n }\n \n cout << 50;\n for (int id : selected_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n \n cout << route.size();\n for (const auto& p : route) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Global constants as per problem statement\nconst int N = 400;\nconst int M = 1995;\n\nstruct Edge {\n int l;\n int u;\n int v;\n\n // Operator overloaded for the min-heap (priority_queue)\n bool operator>(const Edge& other) const {\n return l > other.l;\n }\n};\n\nstruct OnlineMST {\n int n, m;\n vector> points;\n vector> edges;\n vector d_list; // Pre-calculated d_i, not strictly needed for this algo but good to have\n atcoder::dsu d;\n\n // Min-heap to store candidate edges. Use std::greater to make it a min-heap.\n priority_queue, greater> candidate_heap;\n\n OnlineMST() : n(N), m(M), d(N) {\n points.resize(n);\n edges.resize(m);\n d_list.resize(m);\n }\n\n // Calculates the rounded Euclidean distance between two points\n int calc_dist(int i, int j) {\n long long dx = points[i].first - points[j].first;\n long long dy = points[i].second - points[j].second;\n return (int)round(sqrt(dx * dx + dy * dy));\n }\n\n // Pre-computes the lower bounds d_i for all edges\n void preprocess() {\n for (int i = 0; i < m; ++i) {\n d_list[i] = calc_dist(edges[i].first, edges[i].second);\n }\n }\n\n // Decides whether to take the current edge using an online Kruskal's-like algorithm\n bool decide(int edge_idx, int l) {\n auto [u, v] = edges[edge_idx];\n \n // If u and v are already connected, this edge is useless. Reject it.\n if (d.leader(u) == d.leader(v)) {\n return false;\n }\n\n // Otherwise, this edge is a candidate. Add it to our heap.\n candidate_heap.push({l, u, v});\n\n // Now, check if the best candidate we have so far can be used.\n // We loop until we find a valid connecting edge in the heap or the heap is empty.\n while (!candidate_heap.empty()) {\n Edge top_candidate = candidate_heap.top();\n\n // Check if this top candidate is still a connecting edge\n if (d.leader(top_candidate.u) != d.leader(top_candidate.v)) {\n // It is! This is the best edge we can possibly take right now.\n // Take it: merge the components.\n d.merge(top_candidate.u, top_candidate.v);\n \n // Remove it from the heap.\n candidate_heap.pop();\n \n // We have decided to take an edge. It might not be the current edge `l`,\n // but a better one we saw earlier. This is the core of the online algorithm.\n // We return `true` to indicate we have taken *an* edge from our candidate set.\n return true;\n } else {\n // This candidate is now obsolete (its endpoints are already connected).\n // Discard it and check the next best one.\n candidate_heap.pop();\n }\n }\n\n // If the loop finishes, it means the heap became empty. This can happen if all\n // candidates we added so far became obsolete. The current edge `l` is in the heap\n // (if it was a connecting edge), but if we're here, it means we just popped it\n // because it was an internal edge for the final check, or some other logic.\n // In any case, we didn't take an edge in this step. We reject the current edge.\n return false;\n }\n\n void run() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read vertex coordinates\n for (int i = 0; i < n; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n\n // Read edge endpoints\n for (int i = 0; i < m; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n preprocess();\n\n // State variable to track if we have already taken an edge for the current input step\n bool edge_taken_for_this_input = false;\n\n // Main interactive loop\n for (int i = 0; i < m; ++i) {\n int l;\n cin >> l;\n\n // Reset flag for this iteration\n edge_taken_for_this_input = false;\n\n // The decision logic can now trigger taking a previously seen edge.\n // We need to check if an edge was taken from the heap.\n if (d.leader(edges[i].first) != d.leader(edges[i].second)) {\n candidate_heap.push({l, edges[i].first, edges[i].second});\n }\n \n while (!candidate_heap.empty() && !edge_taken_for_this_input) {\n Edge top_candidate = candidate_heap.top();\n if (d.leader(top_candidate.u) != d.leader(top_candidate.v)) {\n d.merge(top_candidate.u, top_candidate.v);\n candidate_heap.pop();\n edge_taken_for_this_input = true;\n } else {\n candidate_heap.pop();\n }\n }\n\n // Output the decision and flush\n cout << (edge_taken_for_this_input ? 1 : 0) << endl;\n cout.flush();\n }\n }\n};\n\nint main() {\n OnlineMST solver;\n solver.run();\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct State {\n int N, M;\n vector> pets, humans;\n vector pet_types;\n vector> impassable;\n vector pet_moves;\n int turn;\n \n void read() {\n cin >> N;\n pets.resize(N);\n pet_types.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].first >> pets[i].second >> pet_types[i];\n }\n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].first >> humans[i].second;\n }\n impassable.assign(31, vector(31, false));\n turn = 0;\n }\n \n void read_pet_moves() {\n pet_moves.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n }\n \n bool is_valid(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n bool is_passable(int x, int y) {\n return is_valid(x, y) && !impassable[x][y];\n }\n \n bool can_make_impassable(int x, int y) {\n if (!is_valid(x, y)) return false;\n \n // Check if pet is at this position at start of turn\n for (auto [px, py] : pets) {\n if (px == x && py == y) return false;\n // Check if pet is adjacent to this position\n if (abs(px - x) <= 1 && abs(py - y) <= 1) return false;\n }\n \n // Check if human is at this position at start of turn\n for (auto [hx, hy] : humans) {\n if (hx == x && hy == y) return false;\n }\n \n return true;\n }\n \n vector> get_neighbors(int x, int y) {\n return {{x-1, y}, {x+1, y}, {x, y-1}, {x, y+1}};\n }\n \n string decide_actions() {\n string actions(M, '.');\n \n for (int i = 0; i < M; i++) {\n auto [hx, hy] = humans[i];\n \n // Simple strategy: try to build walls around nearby pets\n if (turn < 200) {\n // Find closest pet\n int min_dist = 1e9;\n int closest_pet = -1;\n \n for (int p = 0; p < N; p++) {\n auto [px, py] = pets[p];\n int dist = abs(px - hx) + abs(py - hy);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = p;\n }\n }\n \n if (closest_pet != -1 && min_dist <= 8) {\n auto [px, py] = pets[closest_pet];\n \n // Try to build a wall adjacent to human that blocks the pet\n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (can_make_impassable(nx, ny)) {\n // Check if this helps block the pet\n int pet_dist_after = abs(px - nx) + abs(py - ny);\n if (pet_dist_after <= min_dist + 1) {\n if (nx == hx-1) actions[i] = 'u';\n else if (nx == hx+1) actions[i] = 'd';\n else if (ny == hy-1) actions[i] = 'l';\n else if (ny == hy+1) actions[i] = 'r';\n break;\n }\n }\n }\n \n // If couldn't build wall, move towards pet\n if (actions[i] == '.') {\n // Find best move direction\n int best_dist = min_dist;\n char best_move = '.';\n \n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n int new_dist = abs(px - nx) + abs(py - ny);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n if (nx == hx-1) best_move = 'U';\n else if (nx == hx+1) best_move = 'D';\n else if (ny == hy-1) best_move = 'L';\n else if (ny == hy+1) best_move = 'R';\n }\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n } else {\n // Later turns: try to move to center of enclosed area\n // Simple random walk to find better position\n vector possible_moves;\n for (auto [nx, ny] : get_neighbors(hx, hy)) {\n if (is_passable(nx, ny)) {\n if (nx == hx-1) possible_moves.push_back('U');\n else if (nx == hx+1) possible_moves.push_back('D');\n else if (ny == hy-1) possible_moves.push_back('L');\n else if (ny == hy+1) possible_moves.push_back('R');\n }\n }\n \n if (!possible_moves.empty()) {\n // Prefer moving towards center\n int best_score = -1e9;\n char best_move = '.';\n \n for (char move : possible_moves) {\n int nx = hx, ny = hy;\n if (move == 'U') nx--;\n else if (move == 'D') nx++;\n else if (move == 'L') ny--;\n else if (move == 'R') ny++;\n \n // Simple heuristic: prefer positions closer to center\n int score = -abs(nx - 15) - abs(ny - 15);\n \n // Count nearby pets (avoid them)\n for (auto [px, py] : pets) {\n if (abs(px - nx) + abs(py - ny) <= 3) {\n score -= 10;\n }\n }\n \n if (score > best_score) {\n best_score = score;\n best_move = move;\n }\n }\n \n if (best_move != '.') actions[i] = best_move;\n }\n }\n }\n \n return actions;\n }\n \n void update_state(const string& actions) {\n // First, collect all impassable actions to apply simultaneously\n vector> to_make_impassable;\n \n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'u' || action == 'd' || action == 'l' || action == 'r') {\n int nx = hx, ny = hy;\n if (action == 'u') nx--;\n else if (action == 'd') nx++;\n else if (action == 'l') ny--;\n else if (action == 'r') ny++;\n \n if (can_make_impassable(nx, ny)) {\n to_make_impassable.push_back({nx, ny});\n }\n }\n }\n \n // Apply impassable changes\n for (auto [x, y] : to_make_impassable) {\n impassable[x][y] = true;\n }\n \n // Update human positions (they can't move to squares that became impassable this turn)\n for (int i = 0; i < M; i++) {\n char action = actions[i];\n auto [hx, hy] = humans[i];\n \n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int nx = hx, ny = hy;\n if (action == 'U') nx--;\n else if (action == 'D') nx++;\n else if (action == 'L') ny--;\n else if (action == 'R') ny++;\n \n // Check if this square wasn't made impassable this turn\n bool was_made_impassable = false;\n for (auto [x, y] : to_make_impassable) {\n if (x == nx && y == ny) {\n was_made_impassable = true;\n break;\n }\n }\n \n if (is_passable(nx, ny) && !was_made_impassable) {\n humans[i] = {nx, ny};\n }\n }\n }\n \n // Update pet positions based on their moves\n for (int i = 0; i < N; i++) {\n auto [px, py] = pets[i];\n for (char move : pet_moves[i]) {\n if (move == 'U' && is_passable(px-1, py)) px--;\n else if (move == 'D' && is_passable(px+1, py)) px++;\n else if (move == 'L' && is_passable(px, py-1)) py--;\n else if (move == 'R' && is_passable(px, py+1)) py++;\n }\n pets[i] = {px, py};\n }\n \n turn++;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n State state;\n state.read();\n \n for (int turn = 0; turn < 300; turn++) {\n string actions = state.decide_actions();\n cout << actions << endl;\n cout.flush();\n \n state.read_pet_moves();\n state.update_state(actions);\n }\n \n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nstruct State {\n int i, j;\n string path;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h(20), v(19);\n for (int i = 0; i < 20; i++) cin >> h[i];\n for (int i = 0; i < 19; i++) cin >> v[i];\n \n // Simple BFS to find shortest path\n auto find_path = [&]() {\n queue q;\n vector> visited(20, vector(20, false));\n \n q.push({si, sj, \"\"});\n visited[si][sj] = true;\n \n int dirs[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};\n string dir_chars = \"UDLR\";\n \n while (!q.empty()) {\n State cur = q.front();\n q.pop();\n \n if (cur.i == ti && cur.j == tj) {\n return cur.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int ni = cur.i + dirs[d][0];\n int nj = cur.j + dirs[d][1];\n \n if (ni < 0 || ni >= 20 || nj < 0 || nj >= 20) continue;\n if (visited[ni][nj]) continue;\n \n // Check wall\n bool blocked = false;\n if (d == 0 && v[cur.i-1][cur.j] == '1') blocked = true; // U\n else if (d == 1 && v[cur.i][cur.j] == '1') blocked = true; // D\n else if (d == 2 && h[cur.i][cur.j-1] == '1') blocked = true; // L\n else if (d == 3 && h[cur.i][cur.j] == '1') blocked = true; // R\n \n if (!blocked) {\n visited[ni][nj] = true;\n q.push({ni, nj, cur.path + dir_chars[d]});\n }\n }\n }\n \n return string();\n };\n \n string path = find_path();\n if (path.empty()) {\n cout << \"\" << endl;\n return 0;\n }\n \n // Build robust path with simple but effective strategy\n string robust_path = \"\";\n \n // Calculate repetition based on p and path length\n int base_repeat = max(2, min(5, (int)(p * 8)));\n \n // For very long paths, use fewer repetitions\n if (path.size() > 40) base_repeat = min(base_repeat, 3);\n if (path.size() > 60) base_repeat = min(base_repeat, 2);\n \n // Simple criticality: start, end, and direction changes\n vector critical(path.size(), 1);\n for (size_t i = 0; i < path.size(); i++) {\n if (i < 2 || i >= path.size() - 2) critical[i] = 3; // Start/end\n if (i > 0 && path[i] != path[i-1]) critical[i] = 2; // Direction change\n if (i < path.size() - 1 && path[i] != path[i+1]) critical[i] = 2; // Direction change\n }\n \n // Build robust path\n for (size_t i = 0; i < path.size(); i++) {\n int repeat = base_repeat;\n if (critical[i] >= 3) repeat++;\n if (critical[i] >= 2) repeat += (base_repeat > 2) ? 1 : 0;\n \n // Ensure we don't exceed length limit\n int remaining_moves = path.size() - i - 1;\n int max_possible = (200 - robust_path.size()) / max(1, remaining_moves + 1);\n repeat = min(repeat, max(1, max_possible));\n \n for (int j = 0; j < repeat; j++) {\n robust_path += path[i];\n }\n }\n \n // If we have extra space, add more redundancy to critical parts\n if (robust_path.size() < 180 && !path.empty()) {\n // Add the first few moves again (start is critical)\n int start_len = min(3, (int)path.size());\n for (int i = 0; i < start_len; i++) {\n if (robust_path.size() >= 200) break;\n robust_path += path[i];\n }\n \n // Add the last few moves again (end is critical)\n int end_start = max(0, (int)path.size() - 3);\n for (int i = end_start; i < path.size(); i++) {\n if (robust_path.size() >= 200) break;\n robust_path += path[i];\n }\n }\n \n // Final fill with most important moves\n while (robust_path.size() < 200 && !path.empty()) {\n // Add start and end moves preferentially\n if (!path.empty() && robust_path.size() < 200) {\n robust_path += path[0]; // First move\n }\n if (path.size() > 1 && robust_path.size() < 200) {\n robust_path += path.back(); // Last move\n }\n \n // Add any remaining critical moves\n for (size_t i = 1; i < path.size() - 1; i++) {\n if (robust_path.size() >= 200) break;\n if (critical[i] >= 2) {\n robust_path += path[i];\n }\n }\n \n if (robust_path.size() >= 200) break;\n \n // If still need more, add any move\n for (char c : path) {\n if (robust_path.size() >= 200) break;\n robust_path += c;\n }\n }\n \n cout << robust_path << endl;\n \n return 0;\n}","ahc010":"#include \nusing namespace std;\n\n// Directions: 0=left, 1=up, 2=right, 3=down\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Connection table: to[tile_type][entry_direction] = exit_direction\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// Precompute rotated tile types\nint rotated_tile[8][4];\n\nvoid init_rotated_tile() {\n for (int tile = 0; tile < 8; tile++) {\n for (int rot = 0; rot < 4; rot++) {\n if (tile <= 3) { // curved tiles\n rotated_tile[tile][rot] = (tile + rot) % 4;\n } else if (tile <= 5) { // double curved tiles\n rotated_tile[tile][rot] = tile + (rot % 2);\n } else { // straight tiles\n rotated_tile[tile][rot] = tile + (rot % 2);\n }\n }\n }\n}\n\nstruct Grid {\n int tiles[30][30]; // Original tile types\n int rotations[30][30]; // Current rotations (0-3)\n \n Grid() {}\n \n Grid(const vector& input) {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n tiles[i][j] = input[i][j] - '0';\n rotations[i][j] = 0;\n }\n }\n }\n \n int get_tile_type(int i, int j) const {\n return rotated_tile[tiles[i][j]][rotations[i][j]];\n }\n \n // Calculate loop length starting from (i,j) with entry direction d\n // Returns 0 if not a loop, otherwise returns loop length\n int calculate_loop_length(int si, int sj, int sd, bool visited[30][30][4]) {\n if (visited[si][sj][sd]) return 0;\n \n int i = si, j = sj, d = sd;\n int length = 0;\n visited[si][sj][sd] = 1;\n \n do {\n int tile_type = get_tile_type(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) {\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= 30 || j < 0 || j >= 30) {\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n d = (d2 + 2) % 4;\n length++;\n \n if (length > 900) { // Prevent infinite loops\n visited[si][sj][sd] = 0;\n return 0;\n }\n \n } while (!(i == si && j == sj && d == sd));\n \n visited[si][sj][sd] = 0;\n return length;\n }\n \n // Find top two loop lengths\n pair find_top_loops() {\n bool visited[30][30][4] = {false};\n vector loops;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n if (!visited[i][j][d]) {\n int length = calculate_loop_length(i, j, d, visited);\n if (length > 0) {\n loops.push_back(length);\n }\n }\n }\n }\n }\n \n sort(loops.rbegin(), loops.rend());\n \n if (loops.size() < 2) return {0, 0};\n \n // Remove duplicates (same loop might be found from multiple starting points)\n vector unique_loops;\n for (int i = 0; i < loops.size(); i++) {\n bool is_duplicate = false;\n for (int j = 0; j < i; j++) {\n if (loops[i] == loops[j]) {\n is_duplicate = true;\n break;\n }\n }\n if (!is_duplicate) {\n unique_loops.push_back(loops[i]);\n }\n }\n \n if (unique_loops.size() < 2) return {0, 0};\n \n return {unique_loops[0], unique_loops[1]};\n }\n \n long long calculate_score() {\n auto [l1, l2] = find_top_loops();\n return (long long)l1 * l2;\n }\n \n void randomize_rotations() {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rotations[i][j] = dis(gen);\n }\n }\n }\n \n void hill_climb(int iterations) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dis(0, 3);\n \n long long best_score = calculate_score();\n \n for (int it = 0; it < iterations; it++) {\n int i = gen() % 30;\n int j = gen() % 30;\n int old_rot = rotations[i][j];\n int new_rot = (old_rot + 1) % 4;\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n if (new_score > best_score) {\n best_score = new_score;\n } else {\n rotations[i][j] = old_rot; // Revert\n }\n }\n }\n \n string get_output() const {\n string result;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n result += to_string(rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n init_rotated_tile();\n \n vector input(30);\n for (int i = 0; i < 30; i++) {\n cin >> input[i];\n }\n \n Grid grid(input);\n \n // Try multiple random initializations and keep the best\n long long best_score = 0;\n string best_output;\n \n for (int attempt = 0; attempt < 3; attempt++) { // Further reduced attempts\n grid.randomize_rotations();\n \n // Reduced iterations for optimization\n grid.hill_climb(2000); // Further reduced\n \n long long current_score = grid.calculate_score();\n if (current_score > best_score) {\n best_score = current_score;\n best_output = grid.get_output();\n }\n }\n \n cout << best_output << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct State {\n vector> board;\n int er, ec;\n string path;\n int score_S; \n int score_E; \n\n bool operator<(const State& other) const {\n if (score_S != other.score_S) {\n return score_S < other.score_S;\n }\n return score_E < other.score_E;\n }\n};\n\nstruct UnionFind {\n vector p, r;\n UnionFind(int n) : p(n), r(n, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (r[x] < r[y]) p[x] = y;\n else { p[y] = x; if (r[x] == r[y]) r[x]++; }\n }\n};\n\nclass Solver {\npublic:\n Solver(int n, int t, const vector& grid) : N(n), T(t) {\n board.resize(N, vector(N, 0));\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n char ch = grid[r][c];\n if (ch >= '0' && ch <= '9') board[r][c] = ch - '0';\n else board[r][c] = 10 + (ch - 'a');\n if (board[r][c] == 0) { empty_r = r; empty_c = c; }\n }\n }\n }\n\n string solve() {\n auto start_time = chrono::high_resolution_clock::now();\n \n // Adaptive parameters tuned for performance\n const int BEAM_WIDTH = 40 + N * 5;\n const int MAX_DEPTH = N * N * N / 2;\n \n int initial_S = calculate_S_score(board);\n int initial_E = calculate_E_score(board);\n State initial_state{board, empty_r, empty_c, \"\", initial_S, initial_E};\n vector> beams(MAX_DEPTH + 1);\n beams[0].push_back(initial_state);\n\n State best_state = initial_state;\n\n for (int k = 0; k < MAX_DEPTH; ++k) {\n auto current_time = chrono::high_resolution_clock::now();\n if (chrono::duration(current_time - start_time).count() > 2.9) break;\n\n vector& current_beam = beams[k];\n if (current_beam.empty()) continue;\n \n vector next_beam_candidates;\n for (const auto& state : current_beam) {\n for (char m : {'U', 'D', 'L', 'R'}) {\n int tr = state.er, tc = state.ec;\n if (m == 'U') tr--; else if (m == 'D') tr++;\n else if (m == 'L') tc--; else if (m == 'R') tc++;\n\n if (tr < 0 || tr >= N || tc < 0 || tc >= N) continue;\n\n State new_state = state;\n swap(new_state.board[new_state.er][new_state.ec], new_state.board[tr][tc]);\n new_state.er = tr; new_state.ec = tc;\n new_state.path += m;\n new_state.score_S = calculate_S_score(new_state.board);\n new_state.score_E = calculate_E_score(new_state.board);\n next_beam_candidates.push_back(new_state);\n }\n }\n\n if (next_beam_candidates.empty()) continue;\n\n sort(next_beam_candidates.rbegin(), next_beam_candidates.rend());\n if (next_beam_candidates[0].score_S > best_state.score_S || \n (next_beam_candidates[0].score_S == best_state.score_S && next_beam_candidates[0].score_E > best_state.score_E)) {\n best_state = next_beam_candidates[0];\n }\n\n int limit = min(BEAM_WIDTH, (int)next_beam_candidates.size());\n beams[k + 1].assign(next_beam_candidates.begin(), next_beam_candidates.begin() + limit);\n }\n\n if (best_state.path.length() > T) {\n best_state.path = best_state.path.substr(0, T);\n }\n return best_state.path;\n }\n\nprivate:\n int N, T;\n vector> board;\n int empty_r, empty_c;\n\n int calculate_S_score(const vector>& b) {\n UnionFind uf(N * N);\n vector num_edges(N * N, 0);\n vector component_size(N * N, 0);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (b[r][c] == 0) continue;\n int u = r * N + c;\n if (r > 0 && b[r-1][c] != 0 && (b[r][c] & 2) && (b[r-1][c] & 8)) {\n int v = (r-1) * N + c;\n int ru = uf.find(u), rv = uf.find(v);\n if (ru != rv) { uf.unite(u, v); int nr = uf.find(u); component_size[nr] = component_size[ru] + component_size[rv]; num_edges[nr] = num_edges[ru] + num_edges[rv] + 1;}\n else { num_edges[ru]++; }\n }\n if (c > 0 && b[r][c-1] != 0 && (b[r][c] & 1) && (b[r][c-1] & 4)) {\n int v = r * N + (c-1);\n int ru = uf.find(u), rv = uf.find(v);\n if (ru != rv) { uf.unite(u, v); int nr = uf.find(u); component_size[nr] = component_size[ru] + component_size[rv]; num_edges[nr] = num_edges[ru] + num_edges[rv] + 1;}\n else { num_edges[ru]++; }\n }\n }\n }\n int max_S = 0;\n for (int i = 0; i < N * N; ++i) {\n if (uf.find(i) == i && component_size[i] > 0) {\n if (num_edges[i] == component_size[i] - 1) {\n max_S = max(max_S, component_size[i]);\n }\n }\n }\n return max_S;\n }\n\n int calculate_E_score(const vector>& b) {\n int score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N - 1; ++c) {\n if ((b[r][c] & 4) && (b[r][c+1] & 1)) score++;\n }\n }\n for (int r = 0; r < N - 1; ++r) {\n for (int c = 0; c < N; ++c) {\n if ((b[r][c] & 8) && (b[r+1][c] & 2)) score++;\n }\n }\n return score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false); cin.tie(NULL);\n int N, T; cin >> N >> T;\n vector grid(N); for (int i = 0; i < N; ++i) cin >> grid[i];\n Solver solver(N, T, grid);\n cout << solver.solve() << endl;\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nmt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\nconst long double EPS = 1e-9;\nconst long long COORD_MAX = 1e9;\nconst int N_RANDOM_TRIALS = 1;\nconst int N_ANNEALING_ITER = 2500; // Reverted to best-known parameters\nconst long double INITIAL_TEMP = 50000.0;\nconst long double COOLING_RATE = 0.992; // Reverted to best-known parameters\n\nstruct Point {\n long long x, y;\n Point(long long x = 0, long long y = 0) : x(x), y(y) {}\n};\n\nstruct Line {\n Point p1, p2;\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\ninline int get_side(const Point& a, const Point& p1, const Point& p2) {\n long long v1x = a.x - p1.x;\n long long v1y = a.y - p1.y;\n long long v2x = p2.x - p1.x;\n long long v2y = p2.y - p1.y;\n long long c = v1x * v2y - v1y * v2x;\n if (c > 0) return 1;\n if (c < 0) return -1;\n return 0;\n}\n\nlong long calculate_score(const vector& points, const vector& a, const vector& cuts) {\n int K = cuts.size();\n if (K == 0) return 0;\n\n vector b(11, 0);\n unordered_map signature_counts;\n \n for (const auto& p : points) {\n long long signature = 0;\n bool is_cut = false;\n for (int i = 0; i < K; ++i) {\n int side = get_side(p, cuts[i].p1, cuts[i].p2);\n if (side == 0) {\n is_cut = true;\n break;\n }\n if (side == 1) {\n signature |= (1LL << i);\n }\n }\n if (!is_cut) {\n signature_counts[signature]++;\n }\n }\n\n for (const auto& pair : signature_counts) {\n int count = pair.second;\n if (count >= 1 && count <= 10) {\n b[count]++;\n }\n }\n\n long long sum_min = 0;\n long long sum_a = 0;\n for (int d = 1; d <= 10; ++d) {\n sum_min += min(a[d], b[d]);\n sum_a += a[d];\n }\n\n if (sum_a == 0) return 0;\n return (long long)round(1e6 * (long double)sum_min / sum_a);\n}\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, K;\n cin >> N >> K;\n K = 100;\n\n vector a(11);\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n\n vector points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n\n long long best_score = -1;\n vector best_cuts;\n uniform_int_distribution dist_large(-100000, 100000);\n uniform_int_distribution dist_k(0, K - 1);\n uniform_real_distribution dist_prob(0.0, 1.0);\n\n vector current_cuts;\n current_cuts.reserve(K);\n for (int i = 0; i < K; ++i) {\n Point p1, p2;\n do {\n p1 = {dist_large(rng), dist_large(rng)};\n p2 = {dist_large(rng), dist_large(rng)};\n } while (p1.x == p2.x && p1.y == p2.y);\n current_cuts.emplace_back(p1, p2);\n }\n best_cuts = current_cuts;\n best_score = calculate_score(points, a, best_cuts);\n \n long long current_score = best_score;\n long double temperature = INITIAL_TEMP;\n\n for (int iter = 0; iter < N_ANNEALING_ITER; ++iter) {\n vector new_cuts = current_cuts;\n \n int line_to_replace = dist_k(rng);\n Point p1, p2;\n do {\n p1 = {dist_large(rng), dist_large(rng)};\n p2 = {dist_large(rng), dist_large(rng)};\n } while (p1.x == p2.x && p1.y == p2.y);\n new_cuts[line_to_replace] = Line(p1, p2);\n\n long long new_score = calculate_score(points, a, new_cuts);\n\n if (new_score > best_score) {\n best_score = new_score;\n best_cuts = new_cuts;\n }\n \n long long delta = new_score - current_score;\n if (delta > 0 || dist_prob(rng) < exp((long double)delta / temperature)) {\n current_cuts = new_cuts;\n current_score = new_score;\n }\n\n temperature *= COOLING_RATE;\n }\n\n if (current_score > best_score) {\n best_score = current_score;\n best_cuts = current_cuts;\n }\n\n cout << best_cuts.size() << endl;\n for (const auto& cut : best_cuts) {\n cout << cut.p1.x << \" \" << cut.p1.y << \" \" << cut.p2.x << \" \" << cut.p2.y << \"\\n\";\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc014":"#include \n#include \n#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 bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n Point p1, p2, p3, p4;\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_dots(M);\n set dots;\n map> x_to_ys;\n map> y_to_xs;\n \n for (int i = 0; i < M; i++) {\n cin >> initial_dots[i].x >> initial_dots[i].y;\n dots.insert(initial_dots[i]);\n x_to_ys[initial_dots[i].x].push_back(initial_dots[i].y);\n y_to_xs[initial_dots[i].y].push_back(initial_dots[i].x);\n }\n\n for (auto& [x, ys] : x_to_ys) {\n sort(ys.begin(), ys.end());\n }\n for (auto& [y, xs] : y_to_xs) {\n sort(xs.begin(), xs.end());\n }\n\n int c = (N - 1) / 2;\n auto weight = [c](int x, int y) {\n return (x - c) * (x - c) + (y - c) * (y - c) + 1;\n };\n\n // Create list of all empty points sorted by weight (descending)\n vector> empty_points;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (dots.find({x, y}) == dots.end()) {\n empty_points.push_back({weight(x, y), {x, y}});\n }\n }\n }\n sort(empty_points.rbegin(), empty_points.rend());\n\n vector operations;\n\n set> used_segments;\n\n auto is_segment_used = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n if (used_segments.count({x1, y, x1, y+1}) > 0 ||\n used_segments.count({x1, y+1, x1, y}) > 0) {\n return true;\n }\n }\n } else if (y1 == y2) {\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n if (used_segments.count({x, y1, x+1, y1}) > 0 ||\n used_segments.count({x+1, y1, x, y1}) > 0) {\n return true;\n }\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n if (used_segments.count({x, y, x+dx, y+dy}) > 0 ||\n used_segments.count({x+dx, y+dy, x, y}) > 0) {\n return true;\n }\n x += dx;\n y += dy;\n }\n }\n return false;\n };\n\n auto add_segments = [&used_segments](int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n int y_start = min(y1, y2);\n int y_end = max(y1, y2);\n for (int y = y_start; y < y_end; y++) {\n used_segments.insert({x1, y, x1, y+1});\n used_segments.insert({x1, y+1, x1, y});\n }\n } else if (y1 == y2) {\n int x_start = min(x1, x2);\n int x_end = max(x1, x2);\n for (int x = x_start; x < x_end; x++) {\n used_segments.insert({x, y1, x+1, y1});\n used_segments.insert({x+1, y1, x, y1});\n }\n } else if (abs(x2 - x1) == abs(y2 - y1)) {\n int dx = (x2 > x1) ? 1 : -1;\n int dy = (y2 > y1) ? 1 : -1;\n int x = x1, y = y1;\n while (x != x2) {\n used_segments.insert({x, y, x+dx, y+dy});\n used_segments.insert({x+dx, y+dy, x, y});\n x += dx;\n y += dy;\n }\n }\n };\n\n auto has_dot = [&dots](int x, int y) {\n return dots.count({x, y}) > 0;\n };\n\n auto is_valid_rectangle = [&](Point p1, Point p2, Point p3, Point p4) {\n if (p1.x < 0 || p1.x >= N || p1.y < 0 || p1.y >= N) return false;\n if (p2.x < 0 || p2.x >= N || p2.y < 0 || p2.y >= N) return false;\n if (p3.x < 0 || p3.x >= N || p3.y < 0 || p3.y >= N) return false;\n if (p4.x < 0 || p4.x >= N || p4.y < 0 || p4.y >= N) return false;\n \n if (has_dot(p1.x, p1.y)) return false;\n if (!has_dot(p2.x, p2.y) || !has_dot(p3.x, p3.y) || !has_dot(p4.x, p4.y)) return false;\n \n if (is_segment_used(p1.x, p1.y, p2.x, p2.y) ||\n is_segment_used(p2.x, p2.y, p3.x, p3.y) ||\n is_segment_used(p3.x, p3.y, p4.x, p4.y) ||\n is_segment_used(p4.x, p4.y, p1.x, p1.y)) {\n return false;\n }\n \n // Check edge p1-p2\n if (p1.x == p2.x) {\n int y_start = min(p1.y, p2.y);\n int y_end = max(p1.y, p2.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p1.x, y)) return false;\n }\n } else if (p1.y == p2.y) {\n int x_start = min(p1.x, p2.x);\n int x_end = max(p1.x, p2.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p1.y)) return false;\n }\n } else if (abs(p2.x - p1.x) == abs(p2.y - p1.y)) {\n int dx = (p2.x > p1.x) ? 1 : -1;\n int dy = (p2.y > p1.y) ? 1 : -1;\n int x = p1.x + dx, y = p1.y + dy;\n while (x != p2.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p2-p3\n if (p2.x == p3.x) {\n int y_start = min(p2.y, p3.y);\n int y_end = max(p2.y, p3.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p2.x, y)) return false;\n }\n } else if (p2.y == p3.y) {\n int x_start = min(p2.x, p3.x);\n int x_end = max(p2.x, p3.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p2.y)) return false;\n }\n } else if (abs(p3.x - p2.x) == abs(p3.y - p2.y)) {\n int dx = (p3.x > p2.x) ? 1 : -1;\n int dy = (p3.y > p2.y) ? 1 : -1;\n int x = p2.x + dx, y = p2.y + dy;\n while (x != p3.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p3-p4\n if (p3.x == p4.x) {\n int y_start = min(p3.y, p4.y);\n int y_end = max(p3.y, p4.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p3.x, y)) return false;\n }\n } else if (p3.y == p4.y) {\n int x_start = min(p3.x, p4.x);\n int x_end = max(p3.x, p4.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p3.y)) return false;\n }\n } else if (abs(p4.x - p3.x) == abs(p4.y - p3.y)) {\n int dx = (p4.x > p3.x) ? 1 : -1;\n int dy = (p4.y > p3.y) ? 1 : -1;\n int x = p3.x + dx, y = p3.y + dy;\n while (x != p4.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n // Check edge p4-p1\n if (p4.x == p1.x) {\n int y_start = min(p4.y, p1.y);\n int y_end = max(p4.y, p1.y);\n for (int y = y_start + 1; y < y_end; y++) {\n if (has_dot(p4.x, y)) return false;\n }\n } else if (p4.y == p1.y) {\n int x_start = min(p4.x, p1.x);\n int x_end = max(p4.x, p1.x);\n for (int x = x_start + 1; x < x_end; x++) {\n if (has_dot(x, p4.y)) return false;\n }\n } else if (abs(p1.x - p4.x) == abs(p1.y - p4.y)) {\n int dx = (p1.x > p4.x) ? 1 : -1;\n int dy = (p1.y > p4.y) ? 1 : -1;\n int x = p4.x + dx, y = p4.y + dy;\n while (x != p1.x) {\n if (has_dot(x, y)) return false;\n x += dx;\n y += dy;\n }\n }\n \n return true;\n };\n\n mt19937 rng(random_device{}());\n \n // Adaptive search: try different strategies\n for (int strategy = 0; strategy < 2; strategy++) {\n // Strategy 0: prioritize axis-aligned, then diamonds\n // Strategy 1: prioritize diamonds, then axis-aligned\n \n for (const auto& [w, p] : empty_points) {\n bool found = false;\n Rectangle rect;\n\n if (strategy == 0) {\n // Try axis-aligned first\n vector> search_order;\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend());\n \n for (const auto& [dist, x2] : search_order) {\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n Rectangle candidate = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n }\n }\n if (found) break;\n }\n\n // Then try diamonds\n if (!found) {\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) {\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n vector> diamonds;\n \n if (p.y - 2*d >= 0 && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}});\n }\n if (p.y + 2*d < N && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}});\n }\n if (p.x - 2*d >= 0 && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}});\n }\n if (p.x + 2*d < N && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}});\n }\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n Rectangle candidate = {diamond[0], diamond[1], diamond[2], diamond[3]};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n if (found) break;\n }\n }\n } else {\n // Strategy 1: Try diamonds first\n vector diamond_sizes;\n for (int d = 1; d < min(N, 20); d++) {\n diamond_sizes.push_back(d);\n }\n shuffle(diamond_sizes.begin(), diamond_sizes.end(), rng);\n \n for (int d : diamond_sizes) {\n vector> diamonds;\n \n if (p.y - 2*d >= 0 && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y-d}, {p.x, p.y-2*d}, {p.x-d, p.y-d}});\n }\n if (p.y + 2*d < N && p.x + d < N && p.x - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x, p.y+2*d}, {p.x-d, p.y+d}});\n }\n if (p.x - 2*d >= 0 && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x-d, p.y+d}, {p.x-2*d, p.y}, {p.x-d, p.y-d}});\n }\n if (p.x + 2*d < N && p.y + d < N && p.y - d >= 0) {\n diamonds.push_back({p, {p.x+d, p.y+d}, {p.x+2*d, p.y}, {p.x+d, p.y-d}});\n }\n \n shuffle(diamonds.begin(), diamonds.end(), rng);\n \n for (const auto& diamond : diamonds) {\n Rectangle candidate = {diamond[0], diamond[1], diamond[2], diamond[3]};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n if (found) break;\n }\n\n // Then try axis-aligned\n if (!found) {\n vector> search_order;\n for (int x2 = 0; x2 < N; x2++) {\n if (x2 != p.x) {\n int dist = abs(x2 - c) + abs(p.x - c);\n search_order.push_back({dist, x2});\n }\n }\n sort(search_order.rbegin(), search_order.rend());\n \n for (const auto& [dist, x2] : search_order) {\n const auto& ys_at_px = x_to_ys[p.x];\n const auto& ys_at_x2 = x_to_ys[x2];\n const auto& xs_at_py = y_to_xs[p.y];\n \n for (int y2 : ys_at_px) {\n if (y2 == p.y) continue;\n \n if (binary_search(ys_at_x2.begin(), ys_at_x2.end(), y2)) {\n if (binary_search(xs_at_py.begin(), xs_at_py.end(), x2)) {\n Rectangle candidate = {p, {p.x, y2}, {x2, y2}, {x2, p.y}};\n if (is_valid_rectangle(candidate.p1, candidate.p2, candidate.p3, candidate.p4)) {\n rect = candidate;\n found = true;\n break;\n }\n }\n }\n }\n if (found) break;\n }\n }\n }\n\n if (found) {\n operations.push_back(rect);\n dots.insert(rect.p1);\n \n x_to_ys[rect.p1.x].push_back(rect.p1.y);\n y_to_xs[rect.p1.y].push_back(rect.p1.x);\n sort(x_to_ys[rect.p1.x].begin(), x_to_ys[rect.p1.x].end());\n sort(y_to_xs[rect.p1.y].begin(), y_to_xs[rect.p1.y].end());\n \n add_segments(rect.p1.x, rect.p1.y, rect.p2.x, rect.p2.y);\n add_segments(rect.p2.x, rect.p2.y, rect.p3.x, rect.p3.y);\n add_segments(rect.p3.x, rect.p3.y, rect.p4.x, rect.p4.y);\n add_segments(rect.p4.x, rect.p4.y, rect.p1.x, rect.p1.y);\n }\n\n // Adaptive early termination\n if (operations.size() >= 2500) break;\n }\n }\n\n cout << operations.size() << \"\\n\";\n for (const auto& rect : operations) {\n cout << rect.p1.x << \" \" << rect.p1.y << \" \";\n cout << rect.p2.x << \" \" << rect.p2.y << \" \";\n cout << rect.p3.x << \" \" << rect.p3.y << \" \";\n cout << rect.p4.x << \" \" << rect.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nconst int N = 10;\nconst int DIRECTIONS = 4;\nconst int EMPTY = 0;\nconst int TURNS = 100;\n\nstruct Cell {\n int flavor;\n int x, y;\n Cell() : flavor(EMPTY), x(-1), y(-1) {}\n Cell(int f, int x, int y) : flavor(f), x(x), y(y) {}\n};\n\nclass Grid {\nprivate:\n vector> grid;\n vector candies;\n \npublic:\n Grid() : grid(N, vector(N, EMPTY)) {}\n \n void add_candy(int flavor, int x, int y) {\n grid[x][y] = flavor;\n candies.emplace_back(flavor, x, y);\n }\n \n void tilt(char direction) {\n vector> new_grid(N, vector(N, EMPTY));\n vector new_candies;\n \n int dx = 0, dy = 0;\n if (direction == 'F') dx = -1;\n else if (direction == 'B') dx = 1;\n else if (direction == 'L') dy = -1;\n else if (direction == 'R') dy = 1;\n \n // Determine order of processing to avoid collisions\n vector indices(candies.size());\n iota(indices.begin(), indices.end(), 0);\n \n if (direction == 'F') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].x < candies[b].x;\n });\n } else if (direction == 'B') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].x > candies[b].x;\n });\n } else if (direction == 'L') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].y < candies[b].y;\n });\n } else if (direction == 'R') {\n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return candies[a].y > candies[b].y;\n });\n }\n \n for (int idx : indices) {\n const auto& candy = candies[idx];\n int x = candy.x;\n int y = candy.y;\n \n // Move until hitting edge or another candy\n while (true) {\n int nx = x + dx;\n int ny = y + dy;\n \n if (nx < 0 || nx >= N || ny < 0 || ny >= N || new_grid[nx][ny] != EMPTY) {\n break;\n }\n \n x = nx;\n y = ny;\n }\n \n new_grid[x][y] = candy.flavor;\n new_candies.emplace_back(candy.flavor, x, y);\n }\n \n grid = move(new_grid);\n candies = move(new_candies);\n }\n \n const vector& get_candies() const { return candies; }\n const vector>& get_grid() const { return grid; }\n \n void clear() {\n grid.assign(N, vector(N, EMPTY));\n candies.clear();\n }\n};\n\nclass Strategy {\nprotected:\n vector flavors;\n Grid grid;\n int turn;\n vector corner_directions;\n mt19937 rng;\n vector flavor_counts;\n \npublic:\n Strategy(const vector& f) : flavors(f), turn(0), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n flavor_counts.resize(3, 0);\n for (int f : flavors) {\n flavor_counts[f-1]++;\n }\n \n // Fixed corner assignment\n corner_directions = {'L', 'R', 'B'};\n }\n \n virtual ~Strategy() {}\n \n void add_candy(int p) {\n // Convert p to (x, y) coordinates\n int empty_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid.get_grid()[i][j] == EMPTY) {\n empty_count++;\n if (empty_count == p) {\n grid.add_candy(flavors[turn], i, j);\n return;\n }\n }\n }\n }\n }\n \n void apply_tilt(char direction) {\n grid.tilt(direction);\n turn++;\n }\n \n const Grid& get_grid() const { return grid; }\n \n int get_empty_count() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid.get_grid()[i][j] == EMPTY) {\n count++;\n }\n }\n }\n return count;\n }\n \n vector get_component_stats(int flavor) const {\n const auto& g = grid.get_grid();\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (g[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && g[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n component_sizes.push_back(size);\n }\n }\n }\n \n return component_sizes;\n }\n \n double calculate_component_proximity(const Grid& g, int flavor) const {\n const auto& candies = g.get_candies();\n vector> positions;\n \n for (const auto& candy : candies) {\n if (candy.flavor == flavor) {\n positions.emplace_back(candy.x, candy.y);\n }\n }\n \n if (positions.size() < 2) return 0.0;\n \n double total_dist = 0.0;\n int count = 0;\n \n for (size_t i = 0; i < positions.size(); i++) {\n for (size_t j = i + 1; j < positions.size(); j++) {\n double dist = sqrt(pow(positions[i].first - positions[j].first, 2) + \n pow(positions[i].second - positions[j].second, 2));\n total_dist += dist;\n count++;\n }\n }\n \n return count > 0 ? 1000.0 / (1.0 + total_dist / count) : 0.0;\n }\n \n double evaluate_tilt(char direction) {\n Grid test_grid = grid;\n test_grid.tilt(direction);\n \n int flavor = flavors[turn];\n double score = 0.0;\n \n // Get component statistics\n auto component_sizes = get_component_stats_for_grid(test_grid, flavor);\n \n if (component_sizes.empty()) return 0.0;\n \n int components = component_sizes.size();\n int largest = *max_element(component_sizes.begin(), component_sizes.end());\n \n // Component connectivity score (most important)\n score += 300.0 / components;\n score += largest * 22.0;\n \n // Distance to assigned corner\n char corner_dir = corner_directions[flavor-1];\n int target_x = -1, target_y = -1;\n \n if (corner_dir == 'F') { target_x = 0; }\n else if (corner_dir == 'B') { target_x = N-1; }\n else if (corner_dir == 'L') { target_y = 0; }\n else if (corner_dir == 'R') { target_y = N-1; }\n \n const auto& test_candies = test_grid.get_candies();\n for (const auto& candy : test_candies) {\n if (candy.flavor == flavor) {\n double dist = 0.0;\n if (target_x != -1) dist += abs(candy.x - target_x);\n if (target_y != -1) dist += abs(candy.y - target_y);\n score += 140.0 / (1.0 + dist);\n break;\n }\n }\n \n // Bonus for merging components\n int current_components = get_component_stats(flavor).size();\n if (components < current_components) {\n score += 1000.0;\n }\n \n // Component proximity bonus\n score += calculate_component_proximity(test_grid, flavor);\n \n // Consider empty space\n int empty_count = get_empty_count();\n if (empty_count < 20) {\n // Late game: prioritize merges more\n score += (20 - empty_count) * 60.0;\n }\n \n return score;\n }\n \n vector get_component_stats_for_grid(const Grid& g, int flavor) const {\n const auto& grid_state = g.get_grid();\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid_state[i][j] == flavor && !visited[i][j]) {\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n \n for (int d = 0; d < 4; d++) {\n int nx = x + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int ny = y + (d == 2 ? -1 : d == 3 ? 1 : 0);\n \n if (nx >= 0 && nx < N && ny >= 0 && ny < N && \n !visited[nx][ny] && grid_state[nx][ny] == flavor) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n component_sizes.push_back(size);\n }\n }\n }\n \n return component_sizes;\n }\n \n virtual char decide_tilt(int p) = 0;\n};\n\nclass UltimateStrategy : public Strategy {\nprivate:\n \npublic:\n UltimateStrategy(const vector& f) : Strategy(f) {}\n \n char decide_tilt(int p) override {\n add_candy(p);\n \n int flavor = flavors[turn];\n int empty_count = get_empty_count();\n \n // Dynamic thresholds based on empty space\n int early_threshold = max(28, 42 - empty_count / 3);\n int late_threshold = max(72, 87 - empty_count / 4);\n \n // Early game: push to corners\n if (turn < early_threshold) {\n return corner_directions[flavor-1];\n }\n \n // Mid game: use enhanced heuristic evaluation\n if (turn < late_threshold) {\n char best_dir = 'F';\n double best_score = -1e9;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n double score = evaluate_tilt(dir);\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n \n // Late game: aggressive merge strategy\n char best_dir = 'F';\n double best_score = -1e9;\n \n for (char dir : {'F', 'B', 'L', 'R'}) {\n Grid test_grid = grid;\n test_grid.tilt(dir);\n \n auto component_sizes = get_component_stats_for_grid(test_grid, flavor);\n int components = component_sizes.size();\n int largest = component_sizes.empty() ? 0 : *max_element(component_sizes.begin(), component_sizes.end());\n \n int current_components = get_component_stats(flavor).size();\n bool merge = components < current_components;\n \n double score = 0.0;\n if (merge) {\n score += 12000.0; // Huge bonus for merges\n }\n score += 600.0 / components;\n score += largest * 120.0;\n score += calculate_component_proximity(test_grid, flavor);\n \n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n return best_dir;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n UltimateStrategy strategy(flavors);\n \n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n \n if (t < 99) {\n char tilt = strategy.decide_tilt(p);\n strategy.apply_tilt(tilt);\n cout << tilt << endl;\n cout.flush();\n } else {\n strategy.decide_tilt(p);\n }\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct GraphFeatures {\n int edge_count;\n double avg_degree;\n int max_degree;\n double degree_variance;\n int triangles;\n int components;\n double clustering_coeff;\n int diameter;\n vector degree_sequence;\n int connected_triplets;\n double assortativity;\n int bridges;\n double edge_density;\n int local_clustering_sum;\n double motif_diversity;\n};\n\nvector> parse_graph(const string& s, int N) {\n vector> adj(N, vector(N, 0));\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n adj[i][j] = adj[j][i] = (s[idx++] == '1');\n }\n }\n return adj;\n}\n\nint bfs_farthest(const vector>& adj, int start, vector& dist) {\n int N = adj.size();\n dist.assign(N, -1);\n queue q;\n dist[start] = 0;\n q.push(start);\n \n int farthest = start;\n while (!q.empty()) {\n int v = q.front();\n q.pop();\n for (int u = 0; u < N; u++) {\n if (adj[v][u] && dist[u] == -1) {\n dist[u] = dist[v] + 1;\n q.push(u);\n if (dist[u] > dist[farthest]) {\n farthest = u;\n }\n }\n }\n }\n return farthest;\n}\n\nint compute_diameter(const vector>& adj) {\n vector dist;\n int far = bfs_farthest(adj, 0, dist);\n far = bfs_farthest(adj, far, dist);\n return *max_element(dist.begin(), dist.end());\n}\n\ndouble compute_assortativity(const vector>& adj, const vector& degree) {\n int N = adj.size();\n double sum1 = 0, sum2 = 0, sum3 = 0;\n int total_edges = 0;\n \n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n sum1 += degree[i] * degree[j];\n sum2 += degree[i] + degree[j];\n sum3 += degree[i] * degree[i] + degree[j] * degree[j];\n total_edges++;\n }\n }\n }\n \n if (total_edges == 0) return 0;\n \n double avg_prod = sum1 / total_edges;\n double avg_sum = sum2 / (2 * total_edges);\n double avg_sq = sum3 / (2 * total_edges);\n \n double numerator = avg_prod - avg_sum * avg_sum;\n double denominator = avg_sq - avg_sum * avg_sum;\n \n return (denominator > 0) ? numerator / denominator : 0;\n}\n\nint count_bridges(const vector>& adj, const vector& degree) {\n int N = adj.size();\n int bridges = 0;\n \n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n // Check if removing this edge increases components\n if (degree[i] == 1 || degree[j] == 1) {\n bridges++;\n }\n }\n }\n }\n \n return bridges;\n}\n\ndouble compute_motif_diversity(const vector>& adj, const vector& degree) {\n int N = adj.size();\n \n // Count different 3-node motifs\n int open_triads = 0, closed_triads = 0, stars = 0;\n \n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n int edges = adj[i][j] + adj[i][k] + adj[j][k];\n if (edges == 1) stars++;\n else if (edges == 2) open_triads++;\n else if (edges == 3) closed_triads++;\n }\n }\n }\n }\n \n int total = open_triads + closed_triads + stars;\n if (total == 0) return 0;\n \n // Compute diversity as entropy\n double p1 = (double)open_triads / total;\n double p2 = (double)closed_triads / total;\n double p3 = (double)stars / total;\n \n double entropy = 0;\n if (p1 > 0) entropy -= p1 * log2(p1);\n if (p2 > 0) entropy -= p2 * log2(p2);\n if (p3 > 0) entropy -= p3 * log2(p3);\n \n return entropy;\n}\n\nGraphFeatures extract_features(const vector>& adj) {\n int N = adj.size();\n GraphFeatures f;\n \n // Edge count and degrees\n f.edge_count = 0;\n f.degree_sequence.resize(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n f.edge_count++;\n f.degree_sequence[i]++;\n f.degree_sequence[j]++;\n }\n }\n }\n \n // Edge density\n f.edge_density = 2.0 * f.edge_count / (N * (N - 1));\n \n // Degree statistics\n f.avg_degree = 2.0 * f.edge_count / N;\n f.max_degree = *max_element(f.degree_sequence.begin(), f.degree_sequence.end());\n \n double sum_sq = 0;\n for (int d : f.degree_sequence) {\n sum_sq += (d - f.avg_degree) * (d - f.avg_degree);\n }\n f.degree_variance = sum_sq / N;\n \n // Sort degree sequence for comparison\n sort(f.degree_sequence.begin(), f.degree_sequence.end());\n \n // Triangles and connected triplets\n f.triangles = 0;\n f.connected_triplets = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n int edges_ij = adj[i][j];\n int edges_ik = adj[i][k];\n int edges_jk = adj[j][k];\n int total_edges = edges_ij + edges_ik + edges_jk;\n \n if (total_edges == 3) {\n f.triangles++;\n }\n if (total_edges >= 2) {\n f.connected_triplets++;\n }\n }\n }\n }\n }\n \n // Components\n vector visited(N, false);\n f.components = 0;\n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n f.components++;\n vector stack = {i};\n visited[i] = true;\n while (!stack.empty()) {\n int v = stack.back();\n stack.pop_back();\n for (int u = 0; u < N; u++) {\n if (adj[v][u] && !visited[u]) {\n visited[u] = true;\n stack.push_back(u);\n }\n }\n }\n }\n }\n \n // Clustering coefficient and local clustering sum\n double total_clustering = 0;\n int count = 0;\n f.local_clustering_sum = 0;\n for (int i = 0; i < N; i++) {\n if (f.degree_sequence[i] >= 2) {\n int neighbor_pairs = 0;\n int connected_pairs = 0;\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k]) {\n neighbor_pairs++;\n if (adj[j][k]) {\n connected_pairs++;\n }\n }\n }\n }\n }\n if (neighbor_pairs > 0) {\n double local_cluster = 2.0 * connected_pairs / neighbor_pairs;\n total_clustering += local_cluster;\n f.local_clustering_sum += (int)(local_cluster * 1000); // Store as integer for precision\n count++;\n }\n }\n }\n f.clustering_coeff = (count > 0) ? total_clustering / count : 0;\n \n // Diameter (for connected components)\n if (f.components == 1) {\n f.diameter = compute_diameter(adj);\n } else {\n f.diameter = N; // Large value for disconnected graphs\n }\n \n // Assortativity\n f.assortativity = compute_assortativity(adj, f.degree_sequence);\n \n // Bridges\n f.bridges = count_bridges(adj, f.degree_sequence);\n \n // Motif diversity\n f.motif_diversity = compute_motif_diversity(adj, f.degree_sequence);\n \n return f;\n}\n\nstring generate_final_graph(int N, int graph_id, int M, double epsilon, mt19937& rng) {\n int total_possible = N * (N - 1) / 2;\n string graph(total_possible, '0');\n \n // Final optimized graph generation\n int type = graph_id % 7;\n int density = (graph_id * 100) / max(1, M);\n \n // Ultra-conservative adaptation for epsilon\n if (epsilon > 0.35) {\n // Only for very high epsilon, make minimal changes\n if (graph_id % 5 == 0) {\n density = max(10, density - 2);\n } else if (graph_id % 5 == 2) {\n density = min(90, density + 2);\n }\n }\n \n switch (type) {\n case 0: // Sparse random with final structure\n {\n double p = 0.08 + 0.15 * density / 100.0;\n for (int i = 0; i < total_possible; i++) {\n if (rng() % 1000 < p * 1000) {\n graph[i] = '1';\n }\n }\n // Add final structure\n for (int i = 0; i < min(N/3, 6); i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n case 1: // Dense random with final structure\n {\n double p = 0.65 + 0.30 * density / 100.0;\n for (int i = 0; i < total_possible; i++) {\n if (rng() % 1000 < p * 1000) {\n graph[i] = '1';\n }\n }\n // Remove final edges\n int remove_count = min(N/4, 6);\n for (int i = 0; i < remove_count; i++) {\n int idx = rng() % total_possible;\n graph[idx] = '0';\n }\n break;\n }\n case 2: // Star-like with final extra edges\n {\n int center = rng() % N;\n int star_edges = min(N - 1, 4 + density / 12);\n for (int i = 0; i < N && star_edges > 0; i++) {\n if (i != center) {\n int u = min(center, i);\n int v = max(center, i);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n star_edges--;\n }\n }\n // Add final connections between leaves\n int extra = density / 18;\n for (int i = 0; i < extra; i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v && u != center && v != center) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n case 3: // Moderate components with final connectivity\n {\n int num_components = 2 + (graph_id % 2);\n int comp_size = N / num_components;\n for (int c = 0; c < num_components; c++) {\n int start = c * comp_size;\n int end = (c == num_components - 1) ? N : (c + 1) * comp_size;\n int comp_edges = (end - start) * (end - start - 1) / 3;\n vector indices;\n for (int i = start; i < end; i++) {\n for (int j = i + 1; j < end; j++) {\n int idx = i * (2 * N - i - 1) / 2 + j - i - 1;\n indices.push_back(idx);\n }\n }\n shuffle(indices.begin(), indices.end(), rng);\n int limit = min(comp_edges, (int)indices.size());\n for (int i = 0; i < limit; i++) {\n graph[indices[i]] = '1';\n }\n }\n break;\n }\n case 4: // Bipartite with final structure\n {\n int part1 = N / 3 + (graph_id % (N / 4));\n int part2 = N - part1;\n int edges = (part1 * part2 * density) / 120;\n vector indices;\n for (int i = 0; i < part1; i++) {\n for (int j = part1; j < N; j++) {\n int idx = i * (2 * N - i - 1) / 2 + j - i - 1;\n indices.push_back(idx);\n }\n }\n shuffle(indices.begin(), indices.end(), rng);\n int limit = min(edges, (int)indices.size());\n for (int i = 0; i < limit; i++) {\n graph[indices[i]] = '1';\n }\n // Add final within-part edges\n int within_edges = density / 25;\n for (int i = 0; i < within_edges; i++) {\n int part = rng() % 2;\n int start = (part == 0) ? 0 : part1;\n int end = (part == 0) ? part1 : N;\n if (end - start > 1) {\n int u = start + rng() % (end - start);\n int v = start + rng() % (end - start);\n if (u != v) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n }\n break;\n }\n case 5: // Ring with final chords\n {\n // Create a ring\n for (int i = 0; i < N; i++) {\n int j = (i + 1) % N;\n int u = min(i, j);\n int v = max(i, j);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n // Add final chords\n int chords = density / 12;\n for (int i = 0; i < chords; i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v && abs(u - v) > 1 && abs(u - v) < N - 1) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n case 6: // Tree-like with final extra edges\n {\n vector parent(N, -1);\n for (int i = 1; i < N; i++) {\n parent[i] = rng() % i;\n int u = min(i, parent[i]);\n int v = max(i, parent[i]);\n int idx = u * (2 * N - u - 1) / 2 + v - u - 1;\n graph[idx] = '1';\n }\n // Add final extra edges\n int extra = density / 20;\n for (int i = 0; i < extra; i++) {\n int u = rng() % N;\n int v = rng() % N;\n if (u != v) {\n int uu = min(u, v);\n int vv = max(u, v);\n int idx = uu * (2 * N - uu - 1) / 2 + vv - uu - 1;\n graph[idx] = '1';\n }\n }\n break;\n }\n }\n \n return graph;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Final N selection\n int N = min(45, max(10, M / 2 + 8));\n if (epsilon > 0.15) {\n N = min(65, max(12, M / 2 + 12));\n }\n if (epsilon > 0.25) {\n N = min(85, max(16, M / 2 + 16));\n }\n \n cout << N << endl;\n cout.flush();\n \n // Generate M graphs with final optimized structures\n vector graphs(M);\n vector features(M);\n \n random_device rd;\n mt19937 rng(13579);\n \n for (int i = 0; i < M; i++) {\n graphs[i] = generate_final_graph(N, i, M, epsilon, rng);\n features[i] = extract_features(parse_graph(graphs[i], N));\n \n cout << graphs[i] << endl;\n }\n cout.flush();\n \n // Process queries with final matching\n for (int query = 0; query < 100; query++) {\n string H;\n cin >> H;\n \n auto adj_H = parse_graph(H, N);\n auto f_H = extract_features(adj_H);\n \n // Find best match with final feature comparison\n int best_idx = 0;\n double best_score = 1e9;\n \n for (int i = 0; i < M; i++) {\n double score = 0;\n \n // Final adaptive weights\n double edge_weight = 4.6 * (1 - epsilon);\n double degree_weight = 1.35;\n double variance_weight = 0.85;\n double triangle_weight = 1.15 * (1 - epsilon);\n double component_weight = 2.9;\n double cluster_weight = 0.65 * (1 - epsilon);\n double diameter_weight = 0.75;\n double degree_seq_weight = 1.45;\n double triplet_weight = 0.75 * (1 - epsilon);\n double assort_weight = 0.45 * (1 - epsilon);\n double bridge_weight = 0.55 * (1 - epsilon);\n double density_weight = 2.1;\n double local_cluster_weight = 0.3 * (1 - epsilon);\n double motif_weight = 0.2 * (1 - epsilon);\n \n // Normalized differences\n double edge_diff = abs(f_H.edge_count - features[i].edge_count) / (double)N;\n double degree_diff = abs(f_H.avg_degree - features[i].avg_degree);\n double variance_diff = abs(f_H.degree_variance - features[i].degree_variance);\n double triangle_diff = abs(f_H.triangles - features[i].triangles) / (double)(N * N);\n double component_diff = abs(f_H.components - features[i].components);\n double cluster_diff = abs(f_H.clustering_coeff - features[i].clustering_coeff);\n double diameter_diff = abs(f_H.diameter - features[i].diameter) / (double)N;\n double triplet_diff = abs(f_H.connected_triplets - features[i].connected_triplets) / (double)(N * N);\n double assort_diff = abs(f_H.assortativity - features[i].assortativity);\n double bridge_diff = abs(f_H.bridges - features[i].bridges) / (double)N;\n double density_diff = abs(f_H.edge_density - features[i].edge_density);\n double local_cluster_diff = abs(f_H.local_clustering_sum - features[i].local_clustering_sum) / (1000.0 * N);\n double motif_diff = abs(f_H.motif_diversity - features[i].motif_diversity);\n \n // Degree sequence similarity\n double degree_seq_diff = 0;\n for (int j = 0; j < N; j++) {\n degree_seq_diff += abs(f_H.degree_sequence[j] - features[i].degree_sequence[j]);\n }\n degree_seq_diff /= N;\n \n // Weighted sum\n score += edge_weight * edge_diff;\n score += degree_weight * degree_diff;\n score += variance_weight * variance_diff;\n score += triangle_weight * triangle_diff;\n score += component_weight * component_diff;\n score += cluster_weight * cluster_diff;\n score += diameter_weight * diameter_diff;\n score += degree_seq_weight * degree_seq_diff;\n score += triplet_weight * triplet_diff;\n score += assort_weight * assort_diff;\n score += bridge_weight * bridge_diff;\n score += density_weight * density_diff;\n score += local_cluster_weight * local_cluster_diff;\n score += motif_weight * motif_diff;\n \n if (score < best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Edge {\n int u, v, w, id;\n double x1, y1, x2, y2;\n int importance;\n int day;\n int cluster;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n \n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--;\n edges[i].v--;\n edges[i].id = i;\n }\n \n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Assign coordinates to edges\n for (auto &e : edges) {\n e.x1 = coords[e.u].first;\n e.y1 = coords[e.u].second;\n e.x2 = coords[e.v].first;\n e.y2 = coords[e.v].second;\n }\n \n // Compute betweenness centrality for each edge\n vector betweenness(M, 0);\n const int SAMPLES = min(N, 200); // Increased sample size\n vector sampled_vertices(N);\n iota(sampled_vertices.begin(), sampled_vertices.end(), 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n shuffle(sampled_vertices.begin(), sampled_vertices.end(), rng);\n sampled_vertices.resize(SAMPLES);\n \n for (int s : sampled_vertices) {\n vector dist(N, 1e9);\n vector prev(N, -1);\n priority_queue, vector>, greater<>> pq;\n dist[s] = 0;\n pq.push({0, s});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n int v = -1;\n if (e.u == u) v = e.v;\n else if (e.v == u) v = e.u;\n else continue;\n if (dist[v] > dist[u] + e.w) {\n dist[v] = dist[u] + e.w;\n prev[v] = u;\n pq.push({dist[v], v});\n }\n }\n }\n \n for (int t = 0; t < N; ++t) {\n if (t == s) continue;\n for (int v = t; v != s && prev[v] != -1; v = prev[v]) {\n int u = prev[v];\n for (int eid = 0; eid < M; ++eid) {\n const auto &e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n betweenness[eid]++;\n break;\n }\n }\n }\n }\n }\n \n // Compute importance: betweenness + inverse weight + degree\n vector degree(N, 0);\n for (auto &e : edges) {\n degree[e.u]++;\n degree[e.v]++;\n }\n for (int i = 0; i < M; ++i) {\n edges[i].importance = betweenness[i] * 1000000 / (edges[i].w + 1) + degree[edges[i].u] + degree[edges[i].v];\n }\n \n // Assign clusters based on spatial proximity\n const int CLUSTERS = min(D * 2, 20); // Increased number of clusters\n vector> cluster_edges(CLUSTERS);\n vector> centroids(CLUSTERS);\n // Initialize centroids randomly\n vector shuffled_edges(M);\n iota(shuffled_edges.begin(), shuffled_edges.end(), 0);\n shuffle(shuffled_edges.begin(), shuffled_edges.end(), rng);\n for (int i = 0; i < CLUSTERS; ++i) {\n int eid = shuffled_edges[i];\n centroids[i] = {(edges[eid].x1 + edges[eid].x2) / 2.0, (edges[eid].y1 + edges[eid].y2) / 2.0};\n }\n \n // K-means clustering\n for (int iter = 0; iter < 15; ++iter) { // Increased iterations\n for (int i = 0; i < M; ++i) {\n auto &e = edges[i];\n double cx = (e.x1 + e.x2) / 2.0;\n double cy = (e.y1 + e.y2) / 2.0;\n double min_dist = 1e18;\n int best_cluster = 0;\n for (int c = 0; c < CLUSTERS; ++c) {\n double dx = cx - centroids[c].first;\n double dy = cy - centroids[c].second;\n double dist = dx * dx + dy * dy;\n if (dist < min_dist) {\n min_dist = dist;\n best_cluster = c;\n }\n }\n e.cluster = best_cluster;\n }\n \n // Update centroids\n vector> sum(CLUSTERS, {0.0, 0.0});\n vector count(CLUSTERS, 0);\n for (auto &e : edges) {\n sum[e.cluster].first += (e.x1 + e.x2) / 2.0;\n sum[e.cluster].second += (e.y1 + e.y2) / 2.0;\n count[e.cluster]++;\n }\n for (int c = 0; c < CLUSTERS; ++c) {\n if (count[c] > 0) {\n centroids[c].first = sum[c].first / count[c];\n centroids[c].second = sum[c].second / count[c];\n }\n }\n }\n \n // Sort edges by importance (descending)\n sort(edges.begin(), edges.end(), [](const Edge &a, const Edge &b) {\n return a.importance > b.importance;\n });\n \n // Priority queue to keep track of day loads\n priority_queue> pq; // {current_sum, day}\n vector day_sum(D, 0);\n vector day_count(D, 0);\n vector> day_cluster_count(D, vector(CLUSTERS, 0));\n for (int d = 0; d < D; ++d) {\n pq.push({0, d});\n }\n \n // Assign edges to days, ensuring no day exceeds K edges and balancing clusters\n vector> day_edges(D);\n for (auto &e : edges) {\n // Find the day with the smallest current sum that has room for this edge and its cluster\n vector> candidates;\n while (!pq.empty()) {\n auto [sum, day] = pq.top(); pq.pop();\n if (day_count[day] < K && day_cluster_count[day][e.cluster] < K / CLUSTERS + 2) { // Relaxed cluster limit\n candidates.push_back({sum, day});\n if (candidates.size() >= 10) break;\n }\n }\n // Push back candidates\n for (auto &p : candidates) {\n pq.push(p);\n }\n // Select the day with the smallest sum\n if (candidates.empty()) {\n // Find the day with the smallest count that has room\n int min_day = 0;\n for (int d = 1; d < D; ++d) {\n if (day_count[d] < day_count[min_day]) {\n min_day = d;\n }\n }\n day_edges[min_day].push_back(e.id);\n day_sum[min_day] += e.importance;\n day_count[min_day]++;\n day_cluster_count[min_day][e.cluster]++;\n pq.push({day_sum[min_day], min_day});\n } else {\n auto [sum, day] = candidates[0];\n day_edges[day].push_back(e.id);\n day_sum[day] += e.importance;\n day_count[day]++;\n day_cluster_count[day][e.cluster]++;\n pq.push({day_sum[day], day});\n }\n }\n \n // Prepare output\n vector res(M);\n for (int d = 0; d < D; ++d) {\n for (int eid : day_edges[d]) {\n res[eid] = d + 1;\n }\n }\n \n // Output the results\n for (int i = 0; i < M; ++i) {\n if (i) cout << \" \";\n cout << res[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Coord {\n int x, y, z;\n bool operator<(const Coord& other) const {\n if (x != other.x) return x < other.x;\n if (y != other.y) return y < other.y;\n return z < other.z;\n }\n};\n\nint get_idx(int D, int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\n// Helper to find connected components of a given cell type\nvoid get_components(\n const vector>>& cell_type,\n vector>& components_out,\n int D\n) {\n vector>> visited(D, vector>(D, vector(D, false)));\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (cell_type[x][y][z] && !visited[x][y][z]) {\n queue q;\n q.push({x, y, z});\n visited[x][y][z] = true;\n vector component;\n component.push_back({x, y, z});\n\n while (!q.empty()) {\n Coord curr = q.front(); q.pop();\n int dx[] = {1, -1, 0, 0, 0, 0}, dy[] = {0, 0, 1, -1, 0, 0}, dz[] = {0, 0, 0, 0, 1, -1};\n for (int i = 0; i < 6; ++i) {\n int nx = curr.x + dx[i], ny = curr.y + dy[i], nz = curr.z + dz[i];\n if (0 <= nx && nx < D && 0 <= ny && ny < D && 0 <= nz && nz < D) {\n if (cell_type[nx][ny][nz] && !visited[nx][ny][nz]) {\n visited[nx][ny][nz] = true; q.push({nx, ny, nz});\n component.push_back({nx, ny, nz});\n }\n }\n }\n }\n components_out.push_back(component);\n }\n }\n }\n }\n}\n\n// Shape canonicalization (for the optional U1-U2 matching)\nvector, 3>> generate_rotations() {\n vector, 3>> rotations;\n vector dirs = {{1, 0, 0}, {-1, 0, 0}, {0, 1, 0}, {0, -1, 0}, {0, 0, 1}, {0, 0, -1}};\n for (const auto& new_z : dirs) {\n for (const auto& new_x : dirs) {\n if (new_x.x * new_z.x + new_x.y * new_z.y + new_x.z * new_z.z != 0) continue;\n Coord new_y = {new_z.y * new_x.z - new_z.z * new_x.y,\n new_z.z * new_x.x - new_z.x * new_x.z,\n new_z.x * new_x.y - new_z.y * new_x.x};\n array, 3> rot;\n rot[0] = {new_x.x, new_y.x, new_z.x};\n rot[1] = {new_x.y, new_y.y, new_z.y};\n rot[2] = {new_x.z, new_y.z, new_z.z};\n rotations.push_back(rot);\n }\n }\n return rotations;\n}\n\nstring get_canonical_shape(const vector& cells, const vector, 3>>& rotations) {\n if (cells.empty()) return \"\";\n string min_repr;\n for (const auto& rot : rotations) {\n vector rotated_cells;\n for (const auto& c : cells) {\n rotated_cells.push_back({\n c.x * rot[0][0] + c.y * rot[0][1] + c.z * rot[0][2],\n c.x * rot[1][0] + c.y * rot[1][1] + c.z * rot[1][2],\n c.x * rot[2][0] + c.y * rot[2][1] + c.z * rot[2][2]\n });\n }\n int min_x = 0, min_y = 0, min_z = 0;\n for(const auto& p : rotated_cells) { min_x = min(min_x, p.x); min_y = min(min_y, p.y); min_z = min(min_z, p.z); }\n for(auto& p : rotated_cells) { p.x -= min_x; p.y -= min_y; p.z -= min_z; }\n sort(rotated_cells.begin(), rotated_cells.end());\n string repr;\n for (const auto& p : rotated_cells) repr += to_string(p.x) + \",\" + to_string(p.y) + \",\" + to_string(p.z) + \";\";\n if (min_repr.empty() || repr < min_repr) min_repr = repr;\n }\n return min_repr;\n}\n\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n int D;\n cin >> D;\n vector f[2], r[2];\n for (int i = 0; i < 2; ++i) {\n f[i].resize(D); for (int j = 0; j < D; ++j) cin >> f[i][j];\n r[i].resize(D); for (int j = 0; j < D; ++j) cin >> r[i][j];\n }\n\n vector>> grid[2];\n for (int i = 0; i < 2; ++i) {\n grid[i].assign(D, vector>(D, vector(D, false)));\n for (int z = 0; z < D; ++z) for (int x = 0; x < D; ++x) for (int y = 0; y < D; ++y) {\n if (f[i][z][x] == '1' && r[i][z][y] == '1') grid[i][x][y][z] = true;\n }\n }\n\n vector>> is_shared(D, vector>(D, vector(D, false)));\n vector>> is_u1(D, vector>(D, vector(D, false)));\n vector>> is_u2(D, vector>(D, vector(D, false)));\n for (int x = 0; x < D; ++x) for (int y = 0; y < D; ++y) for (int z = 0; z < D; ++z) {\n bool in_o1 = grid[0][x][y][z];\n bool in_o2 = grid[1][x][y][z];\n if (in_o1 && in_o2) is_shared[x][y][z] = true;\n else if (in_o1) is_u1[x][y][z] = true;\n else if (in_o2) is_u2[x][y][z] = true;\n }\n\n vector b_1(D * D * D, 0);\n vector b_2(D * D * D, 0);\n int block_id = 0;\n\n // Step 1: Find components of shared cells. These are guaranteed shared blocks.\n vector> shared_components;\n get_components(is_shared, shared_components, D);\n for(const auto& comp : shared_components) {\n block_id++;\n for(const auto& cell : comp) {\n b_1[get_idx(D, cell.x, cell.y, cell.z)] = block_id;\n b_2[get_idx(D, cell.x, cell.y, cell.z)] = block_id;\n }\n }\n\n // Step 2: Find components of unique cells.\n vector> u1_components;\n vector> u2_components;\n get_components(is_u1, u1_components, D);\n get_components(is_u2, u2_components, D);\n \n // Step 3: Try to match U1 and U2 components by shape.\n auto rotations = generate_rotations();\n map*, bool>>> u1_shape_map;\n for(auto& comp : u1_components) u1_shape_map[get_canonical_shape(comp, rotations)].push_back({&comp, false});\n \n for(auto& u2_comp : u2_components) {\n string shape = get_canonical_shape(u2_comp, rotations);\n if(u1_shape_map.count(shape)) {\n bool found_match = false;\n for(auto& u1_info : u1_shape_map[shape]) {\n if(!u1_info.second) {\n // Found a match, create a new shared block\n block_id++;\n for(const auto& cell : *(u1_info.first)) b_1[get_idx(D, cell.x, cell.y, cell.z)] = block_id;\n for(const auto& cell : u2_comp) b_2[get_idx(D, cell.x, cell.y, cell.z)] = block_id;\n u1_info.second = true; // Mark U1 component as used\n found_match = true;\n break;\n }\n }\n if(found_match) continue;\n }\n // No match found, so U2 component becomes a unique block\n block_id++;\n for(const auto& cell : u2_comp) b_2[get_idx(D, cell.x, cell.y, cell.z)] = block_id;\n }\n\n // Step 4: Assign remaining, unmatched U1 components as unique blocks.\n for(auto& u1_info_list : u1_shape_map) {\n for(auto& u1_info : u1_info_list.second) {\n if(!u1_info.second) {\n block_id++;\n for(const auto& cell : *(u1_info.first)) b_1[get_idx(D, cell.x, cell.y, cell.z)] = block_id;\n }\n }\n }\n\n cout << block_id << endl;\n for (int i = 0; i < D * D * D; ++i) cout << (i ? \" \" : \"\") << b_1[i];\n cout << endl;\n for (int i = 0; i < D * D * D; ++i) cout << (i ? \" \" : \"\") << b_2[i];\n cout << endl;\n return 0;\n}","ahc020":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n double x, y;\n Point(double x=0, double y=0) : x(x), y(y) {}\n double dist(const Point& p) const {\n return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));\n }\n int rounded_dist(const Point& p) const {\n return (int)round(dist(p));\n }\n};\n\nstruct Edge {\n int u, v, w, idx;\n double d;\n Edge(int u=0, int v=0, int w=0, double d=0, int idx=0) : u(u), v(v), w(w), d(d), idx(idx) {}\n bool operator<(const Edge& e) const {\n return w < e.w;\n }\n};\n\nstruct DSU {\n vector parent, sz;\n DSU(int n) : parent(n), sz(n, 1) {\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 same(int x, int y) { return find(x) == find(y); }\n bool unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return false;\n if (sz[x] < sz[y]) swap(x, y);\n parent[y] = x;\n sz[x] += sz[y];\n return true;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n \n vector stations(N);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M);\n for (int j = 0; j < M; ++j) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v;\n double d = stations[u].dist(stations[v]);\n edges[j] = Edge(u, v, w, d, j);\n }\n \n vector residents(K);\n for (int k = 0; k < K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // Precompute distances\n vector> station_resident_dist(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n station_resident_dist[i][k] = stations[i].dist(residents[k]);\n }\n }\n \n vector> station_station_dist(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n station_station_dist[i][j] = stations[i].dist(stations[j]);\n }\n }\n \n // Calculate resident density around each station\n vector resident_density(N, 0);\n vector> nearby_residents(N);\n \n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n double d = station_resident_dist[i][k];\n if (d <= 5000) {\n resident_density[i] += exp(-d / 1000.0);\n nearby_residents[i].push_back(k);\n }\n }\n }\n \n // Initial edge selection with enhanced cost-benefit analysis\n vector edge_used(M, false);\n vector connected(N, false);\n connected[0] = true;\n \n // Phase 1: Connect high-value stations\n vector> station_value;\n for (int i = 1; i < N; ++i) {\n double value = resident_density[i] * 1000.0;\n value -= station_station_dist[0][i] * 0.1;\n station_value.push_back({value, i});\n }\n sort(station_value.rbegin(), station_value.rend());\n \n for (auto &[value, i] : station_value) {\n if (connected[i]) continue;\n \n // Find best connection\n int best_edge = -1;\n double best_score = -1;\n \n for (int j = 0; j < M; ++j) {\n if (edges[j].u == i || edges[j].v == i) {\n int other = edges[j].u == i ? edges[j].v : edges[j].u;\n if (connected[other]) {\n double score = resident_density[i] / (1.0 + edges[j].w * 0.001);\n score -= edges[j].d * 0.0001;\n if (score > best_score) {\n best_score = score;\n best_edge = j;\n }\n }\n }\n }\n \n if (best_edge != -1 && best_score > 0.01) {\n edge_used[best_edge] = true;\n connected[i] = true;\n }\n }\n \n // Phase 2: Build MST for remaining components\n DSU dsu(N);\n for (int i = 0; i < N; ++i) {\n if (connected[i]) dsu.parent[i] = 0;\n }\n \n vector sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end());\n \n for (auto &e : sorted_edges) {\n if (!edge_used[e.idx]) {\n if (dsu.unite(e.u, e.v)) {\n edge_used[e.idx] = true;\n connected[e.u] = connected[e.v] = true;\n }\n }\n }\n \n // Calculate connectivity for all stations\n vector> adj(N);\n for (int j = 0; j < M; ++j) {\n if (edge_used[j]) {\n adj[edges[j].u].push_back(edges[j].v);\n adj[edges[j].v].push_back(edges[j].u);\n }\n }\n \n vector component(N, -1);\n queue q;\n component[0] = 0;\n q.push(0);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : adj[u]) {\n if (component[v] == -1) {\n component[v] = component[u] + 1;\n q.push(v);\n }\n }\n }\n \n // Enhanced power allocation\n vector P(N, 0);\n vector covered(K, false);\n \n // Sort residents by difficulty to cover\n vector> resident_difficulty;\n for (int k = 0; k < K; ++k) {\n double min_dist = 1e9;\n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n min_dist = min(min_dist, station_resident_dist[i][k]);\n }\n }\n resident_difficulty.push_back({min_dist, k});\n }\n sort(resident_difficulty.rbegin(), resident_difficulty.rend());\n \n // Greedy coverage with incremental optimization\n for (auto &[diff, k] : resident_difficulty) {\n if (covered[k]) continue;\n \n int best_station = -1;\n int best_power = 0;\n double best_cost = 1e18;\n \n for (int i = 0; i < N; ++i) {\n if (!connected[i]) continue;\n \n double d = station_resident_dist[i][k];\n if (d > 5000) continue;\n \n int power = max(P[i], (int)ceil(d));\n if (power > 5000) continue;\n \n double cost = power * power - P[i] * P[i];\n \n // Consider additional residents covered\n int additional = 0;\n for (int kk : nearby_residents[i]) {\n if (!covered[kk] && station_resident_dist[i][kk] <= power) {\n additional++;\n }\n }\n \n if (additional > 0) {\n cost /= additional;\n cost += component[i] * 0.1; // Prefer closer stations\n \n if (cost < best_cost) {\n best_cost = cost;\n best_station = i;\n best_power = power;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = best_power;\n for (int kk : nearby_residents[best_station]) {\n if (station_resident_dist[best_station][kk] <= best_power) {\n covered[kk] = true;\n }\n }\n }\n }\n \n // Local search optimization\n for (int iter = 0; iter < 5; ++iter) {\n bool improved = false;\n \n // Try to reduce powers\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] == 0) continue;\n \n vector temp_covered = covered;\n bool can_reduce = true;\n int min_power = 0;\n \n for (int k = 0; k < K; ++k) {\n if (covered[k] && station_resident_dist[i][k] <= P[i] + 0.5) {\n bool covered_by_other = false;\n for (int j = 0; j < N; ++j) {\n if (j != i && P[j] > 0 && station_resident_dist[j][k] <= P[j] + 0.5) {\n covered_by_other = true;\n break;\n }\n }\n if (!covered_by_other) {\n can_reduce = false;\n min_power = max(min_power, (int)ceil(station_resident_dist[i][k]));\n }\n }\n }\n \n if (can_reduce) {\n P[i] = 0;\n improved = true;\n } else if (min_power < P[i]) {\n P[i] = min_power;\n improved = true;\n }\n }\n \n // Try to add beneficial stations\n for (int i = 0; i < N; ++i) {\n if (!connected[i] || P[i] > 0) continue;\n \n int best_power = 0;\n double best_ratio = 0;\n \n for (int power = 100; power <= 2000; power += 100) {\n int new_covered = 0;\n for (int k : nearby_residents[i]) {\n if (!covered[k] && station_resident_dist[i][k] <= power) {\n new_covered++;\n }\n }\n \n if (new_covered > 0) {\n double ratio = (double)new_covered / (power * power);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n best_power = power;\n }\n }\n }\n \n if (best_power > 0 && best_ratio > 0.00001) {\n P[i] = best_power;\n for (int k : nearby_residents[i]) {\n if (station_resident_dist[i][k] <= best_power) {\n covered[k] = true;\n }\n }\n improved = true;\n }\n }\n \n if (!improved) break;\n }\n \n // Final coverage check\n covered.assign(K, false);\n for (int i = 0; i < N; ++i) {\n if (P[i] > 0) {\n for (int k = 0; k < K; ++k) {\n if (station_resident_dist[i][k] <= P[i] + 0.5) {\n covered[k] = true;\n }\n }\n }\n }\n \n for (int k = 0; k < K; ++k) {\n if (!covered[k]) {\n double min_dist = 1e9;\n int best_station = -1;\n \n for (int i = 0; i < N; ++i) {\n if (connected[i]) {\n double d = station_resident_dist[i][k];\n if (d < min_dist) {\n min_dist = d;\n best_station = i;\n }\n }\n }\n \n if (best_station != -1) {\n P[best_station] = min(5000, max(P[best_station], (int)ceil(min_dist)));\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << P[i];\n }\n cout << \"\\n\";\n for (int j = 0; j < M; ++j) {\n if (j) cout << \" \";\n cout << (edge_used[j] ? 1 : 0);\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc021":"#include \nusing namespace std;\n\nconstexpr int N = 30;\n\n// pyramid values\nint a[N][N];\n// list of operations: x y x' y'\nvector> ops;\n\n// bubble down the element currently at (x,y)\nvoid bubble_down(int x, int y) {\n while (true) {\n int cx = x + 1;\n if (cx >= N) break; // leaf\n int cy_left = y;\n int cy_right = y + 1;\n\n // choose the smaller child\n int child_x = cx, child_y = cy_left;\n int child_val = a[child_x][child_y];\n if (a[cx][cy_right] < child_val) {\n child_y = cy_right;\n child_val = a[cx][cy_right];\n }\n\n // heap condition satisfied?\n if (a[x][y] <= child_val) break;\n\n // perform swap\n ops.push_back({x, y, child_x, child_y});\n swap(a[x][y], a[child_x][child_y]);\n\n // continue from the child position\n x = child_x;\n y = child_y;\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // read input\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> a[x][y];\n }\n }\n\n // bottom\u2011up heapify\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n bubble_down(x, y);\n }\n }\n\n // safety check (should always hold)\n assert(ops.size() <= 10000);\n\n // output\n cout << ops.size() << \"\\n\";\n for (auto &op : ops) {\n cout << op[0] << \" \" << op[1] << \" \"\n << op[2] << \" \" << op[3] << \"\\n\";\n }\n return 0;\n}","toyota2023summer-final":"#include \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 D, N;\n if (!(cin >> D >> N)) {\n return 0;\n }\n\n const int entrance_r = 0;\n const int entrance_c = (D - 1) / 2;\n\n vector> grid(D, vector(D, 0));\n vector> placeable_cells;\n\n // Mark obstacles\n for (int k = 0; k < N; ++k) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = -1; // -1 for obstacle\n }\n\n // Collect all placeable cells\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n if (grid[i][j] != -1 && !(i == entrance_r && j == entrance_c)) {\n placeable_cells.emplace_back(i, j);\n }\n }\n }\n\n // Sort placeable cells by distance from entrance, then by coordinates\n // dist(i,j) = i + abs(j - entrance_c)\n auto dist_cmp = [entrance_c](const pair& a, const pair& b) {\n int dist_a = a.first + abs(a.second - entrance_c);\n int dist_b = b.first + abs(b.second - entrance_c);\n if (dist_a != dist_b) {\n return dist_a < dist_b; // Sort by distance ascending\n }\n if (a.first != b.first) {\n return a.first < b.first;\n }\n return a.second < b.second;\n };\n sort(placeable_cells.begin(), placeable_cells.end(), dist_cmp);\n\n int M = placeable_cells.size();\n vector is_taken(M, false);\n\n // --- Placement Phase ---\n for (int d = 0; d < M; ++d) {\n int t;\n cin >> t;\n\n int target_idx = t;\n int offset = 0;\n int chosen_idx = -1;\n\n while (chosen_idx == -1) {\n int check_idx1 = target_idx - offset;\n if (check_idx1 >= 0 && !is_taken[check_idx1]) {\n chosen_idx = check_idx1;\n break;\n }\n int check_idx2 = target_idx + offset;\n if (check_idx2 < M && !is_taken[check_idx2]) {\n chosen_idx = check_idx2;\n break;\n }\n offset++;\n }\n\n auto [r, c] = placeable_cells[chosen_idx];\n grid[r][c] = t;\n is_taken[chosen_idx] = true;\n\n cout << r << \" \" << c << \"\\n\";\n cout.flush();\n }\n\n // --- Retrieval Phase ---\n vector> retrieval_order;\n int remaining = M;\n while (remaining > 0) {\n // BFS to find reachable containers\n vector> visited(D, vector(D, false));\n queue> q;\n q.push({entrance_r, entrance_c});\n visited[entrance_r][entrance_c] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n const int drs[4] = {-1, 1, 0, 0};\n const int dcs[4] = {0, 0, -1, 1};\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + drs[k];\n int nc = c + dcs[k];\n\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !visited[nr][nc] && grid[nr][nc] != -1) {\n visited[nr][nc] = true;\n if (grid[nr][nc] > 0) {\n reachable_containers.push_back({nr, nc});\n }\n q.push({nr, nc});\n }\n }\n }\n\n // Find min priority container among reachable\n int min_p = M; // Max priority is M-1\n pair min_coord = {-1, -1};\n for (const auto& coord : reachable_containers) {\n if (grid[coord.first][coord.second] < min_p) {\n min_p = grid[coord.first][coord.second];\n min_coord = coord;\n }\n }\n\n retrieval_order.push_back(min_coord);\n grid[min_coord.first][min_coord.second] = 0; // Mark as empty\n remaining--;\n }\n\n // --- Output Retrieval Order ---\n for (const auto& coord : retrieval_order) {\n cout << coord.first << \" \" << coord.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n, m;\n if (!(cin >> n >> m)) return 0;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n }\n }\n // output exactly the same grid\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j) cout << ' ';\n cout << grid[i][j];\n }\n cout << '\\n';\n }\n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector scores(N, 0);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n auto compare = [](int a, int b) {\n cout << \"1 1 \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n return res == '>';\n };\n\n // --- Phase 1: Score-based Learning ---\n int Q_learn = Q * 0.8;\n for (int q = 0; q < Q_learn; ++q) {\n int i = rng() % N;\n int j = rng() % N;\n while (i == j) {\n j = rng() % N;\n }\n\n if (compare(i, j)) {\n scores[i] += 2;\n scores[j] -= 1;\n } else {\n scores[i] -= 1;\n scores[j] += 2;\n }\n }\n\n // --- Phase 2: Greedy Partitioning (LPT) ---\n vector item_ids(N);\n iota(item_ids.begin(), item_ids.end(), 0);\n sort(item_ids.begin(), item_ids.end(), [&](int a, int b) {\n return scores[a] > scores[b];\n });\n\n vector set_weights(D, 0);\n vector assignments(N);\n vector> sets(D);\n\n for (int item_id : item_ids) {\n auto it = min_element(set_weights.begin(), set_weights.end());\n int set_id = distance(set_weights.begin(), it);\n\n assignments[item_id] = set_id;\n set_weights[set_id] += scores[item_id];\n sets[set_id].push_back(item_id);\n }\n\n // --- Phase 3: Safe Refinement ---\n int Q_refine = Q - Q_learn;\n while (Q_refine > 0) {\n int max_set_id = -1, min_set_id = -1;\n long long max_score = -1, min_score = 1e18;\n for (int i = 0; i < D; ++i) {\n if (set_weights[i] > max_score) {\n max_score = set_weights[i];\n max_set_id = i;\n }\n if (set_weights[i] < min_score) {\n min_score = set_weights[i];\n min_set_id = i;\n }\n }\n\n if (max_set_id == -1 || min_set_id == -1 || max_set_id == min_set_id) {\n break;\n }\n \n // Ensure sets are not empty before trying to access elements\n if (sets[max_set_id].empty() || sets[min_set_id].empty()) {\n Q_refine--;\n continue;\n }\n\n int heaviest_in_heavy = *max_element(sets[max_set_id].begin(), sets[max_set_id].end(),\n [&](int a, int b){ return scores[a] < scores[b]; });\n int lightest_in_light = *min_element(sets[min_set_id].begin(), sets[min_set_id].end(),\n [&](int a, int b){ return scores[a] < scores[b]; });\n\n if (Q_refine <= 0) break;\n Q_refine--;\n\n // If the \"light\" item is actually heavier, swap them.\n if (!compare(heaviest_in_heavy, lightest_in_light)) {\n // Swap assignments\n swap(assignments[heaviest_in_heavy], assignments[lightest_in_light]);\n \n // Update weights\n set_weights[max_set_id] = set_weights[max_set_id] - scores[heaviest_in_heavy] + scores[lightest_in_light];\n set_weights[min_set_id] = set_weights[min_set_id] - scores[lightest_in_light] + scores[heaviest_in_heavy];\n\n // Update set member lists\n auto it_h = find(sets[max_set_id].begin(), sets[max_set_id].end(), heaviest_in_heavy);\n auto it_l = find(sets[min_set_id].begin(), sets[min_set_id].end(), lightest_in_light);\n \n iter_swap(it_h, it_l);\n }\n }\n\n // --- Final Output ---\n for (int i = 0; i < N; ++i) {\n if (i > 0) cout << \" \";\n cout << assignments[i];\n }\n cout << endl;\n}\n\nint main() {\n solve();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nstruct Box {\n int stack_idx;\n int pos; // position from bottom (0-indexed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int n = 200, m = 10;\n int boxes_per_stack = n / m; // 20\n \n vector> stacks(m);\n vector box_info(n + 1);\n \n // Read input\n for (int i = 0; i < m; i++) {\n stacks[i].resize(boxes_per_stack);\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_info[stacks[i][j]] = {i, j};\n }\n }\n \n vector> operations;\n \n // Process boxes in order\n for (int target = 1; target <= n; target++) {\n int stack_idx = box_info[target].stack_idx;\n int pos = box_info[target].pos;\n \n // Check if box is already at top\n if (pos == stacks[stack_idx].size() - 1) {\n // Just carry it out\n operations.emplace_back(target, 0);\n stacks[stack_idx].pop_back();\n \n // Update positions of remaining boxes in this stack\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n } else {\n // Need to move boxes above it\n // Choose destination stack (prefer empty or small stacks)\n int dest_stack = 0;\n int min_size = stacks[0].size();\n for (int i = 1; i < m; i++) {\n if (stacks[i].size() < min_size) {\n min_size = stacks[i].size();\n dest_stack = i;\n }\n }\n \n // If the smallest stack is the current one, choose the next smallest\n if (dest_stack == stack_idx) {\n for (int i = 0; i < m; i++) {\n if (i != stack_idx && stacks[i].size() <= min_size + 5) {\n dest_stack = i;\n break;\n }\n }\n }\n \n // Move the target box and everything above it\n operations.emplace_back(target, dest_stack + 1); // 1-indexed for output\n \n // Extract the boxes to move\n vector to_move(stacks[stack_idx].begin() + pos, stacks[stack_idx].end());\n stacks[stack_idx].resize(pos);\n \n // Add to destination stack\n stacks[dest_stack].insert(stacks[dest_stack].end(), to_move.begin(), to_move.end());\n \n // Update positions\n for (int j = 0; j < stacks[stack_idx].size(); j++) {\n box_info[stacks[stack_idx][j]] = {stack_idx, j};\n }\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n \n // Now carry out the target box (it should be at top of dest_stack)\n operations.emplace_back(target, 0);\n stacks[dest_stack].pop_back();\n \n // Update positions again\n for (int j = 0; j < stacks[dest_stack].size(); j++) {\n box_info[stacks[dest_stack][j]] = {dest_stack, j};\n }\n }\n }\n \n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n \n return 0;\n}","ahc027":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\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 }\n \n // Analyze board characteristics\n int total_d = 0;\n int max_d = 0;\n int high_value_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n total_d += d[i][j];\n max_d = max(max_d, d[i][j]);\n if (d[i][j] > 500) high_value_count++;\n }\n }\n double avg_d = (double)total_d / (N * N);\n bool has_many_high_values = (high_value_count > N * N / 4);\n \n vector> visited(N, vector(N));\n string route;\n \n // Adaptive DFS based on board characteristics\n auto dfs = [&](auto self, int i, int j) -> void {\n visited[i][j] = true;\n \n const int dirs[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n const char dir_chars[4] = {'R', 'D', 'L', 'U'};\n \n vector> neighbor_priority;\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (visited[ni][nj]) continue;\n \n bool can_move = false;\n if (dirs[dir][0] == 0) {\n can_move = (v[i][min(j, nj)] == '0');\n } else {\n can_move = (h[min(i, ni)][j] == '0');\n }\n \n if (can_move) {\n double priority = d[ni][nj] * 1.0;\n \n // Adaptive strategy based on board characteristics\n if (has_many_high_values) {\n // For boards with many high values, focus on clustering\n double cluster_bonus = 0;\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n int ci = ni + di, cj = nj + dj;\n if (ci >= 0 && ci < N && cj >= 0 && cj < N) {\n cluster_bonus += d[ci][cj] * 0.1;\n }\n }\n }\n priority += cluster_bonus;\n } else {\n // For boards with few high values, be more aggressive\n if (d[ni][nj] > avg_d * 2) {\n priority *= 1.5;\n }\n }\n \n // Look-ahead bonus (conservative)\n double neighbor_bonus = 0;\n int accessible_neighbors = 0;\n for (int dir2 = 0; dir2 < 4; dir2++) {\n int nni = ni + dirs[dir2][0];\n int nnj = nj + dirs[dir2][1];\n if (nni >= 0 && nni < N && nnj >= 0 && nnj < N && !visited[nni][nnj]) {\n bool can_move2 = false;\n if (dirs[dir2][0] == 0) {\n can_move2 = (v[ni][min(nj, nnj)] == '0');\n } else {\n can_move2 = (h[min(ni, nni)][nj] == '0');\n }\n if (can_move2) {\n neighbor_bonus += d[nni][nnj] * 0.15;\n accessible_neighbors++;\n }\n }\n }\n \n priority += neighbor_bonus;\n \n // Connectivity bonus (avoid dead ends)\n if (accessible_neighbors >= 2) {\n priority += 20;\n } else if (accessible_neighbors == 1) {\n // Small penalty for potential dead ends\n priority -= 5;\n }\n \n // Distance bonus for balanced exploration\n double dist_from_center = sqrt(pow(ni - N/2.0, 2) + pow(nj - N/2.0, 2));\n priority += (N - dist_from_center) * 0.3;\n \n neighbor_priority.emplace_back(priority, dir);\n }\n }\n \n sort(neighbor_priority.rbegin(), neighbor_priority.rend());\n \n for (auto [priority, dir] : neighbor_priority) {\n int ni = i + dirs[dir][0];\n int nj = j + dirs[dir][1];\n \n if (!visited[ni][nj]) {\n route += dir_chars[dir];\n self(self, ni, nj);\n route += dir_chars[(dir + 2) % 4];\n }\n }\n };\n \n dfs(dfs, 0, 0);\n \n cout << route << endl;\n return 0;\n}","ahc028":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Position {\n int i, j;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n int si, sj;\n cin >> N >> M >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n \n vector targets(M);\n for (int k = 0; k < M; k++) {\n cin >> targets[k];\n }\n \n // Precompute letter positions\n vector> letter_positions(26);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n letter_positions[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n \n // For each position, precompute nearest positions for each character\n vector>> nearest(N, vector>(N, vector(26)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int c = 0; c < 26; c++) {\n int best_dist = INT_MAX;\n Position best_pos = {-1, -1};\n \n for (auto pos : letter_positions[c]) {\n int dist = abs(i - pos.i) + abs(j - pos.j);\n if (dist < best_dist) {\n best_dist = dist;\n best_pos = pos;\n }\n }\n \n nearest[i][j][c] = best_pos;\n }\n }\n }\n \n vector> result;\n result.emplace_back(si, sj);\n \n vector collected(M, false);\n int collected_count = 0;\n \n string current_suffix;\n \n // Greedy collection with overlap detection\n while (collected_count < M && result.size() < 4500) {\n int best_k = -1;\n int best_score = INT_MIN;\n int best_cost = INT_MAX;\n string best_remaining;\n Position best_start = {-1, -1};\n bool use_overlap = false;\n \n int current_i = result.back().first;\n int current_j = result.back().second;\n \n // Check all uncollected strings\n for (int k = 0; k < M; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Check for overlaps with current suffix\n for (int overlap_len = min(4, (int)current_suffix.length()); overlap_len >= 0; overlap_len--) {\n if (current_suffix.length() >= overlap_len) {\n string suffix = current_suffix.substr(current_suffix.length() - overlap_len);\n \n if (target.substr(0, overlap_len) == suffix) {\n string remaining = target.substr(overlap_len);\n \n // Estimate cost to get remaining characters\n int cost = 0;\n Position curr_pos = {current_i, current_j};\n \n for (char c : remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n cost = INT_MAX;\n break;\n }\n cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (cost < best_cost && cost < 100) {\n best_cost = cost;\n best_k = k;\n best_remaining = remaining;\n use_overlap = true;\n best_score = overlap_len * 10 - cost;\n }\n }\n }\n }\n \n // Also consider starting fresh\n char first_char = target[0];\n for (auto pos : letter_positions[first_char - 'A']) {\n int move_cost = abs(current_i - pos.i) + abs(current_j - pos.j) + 1;\n if (move_cost > 50) continue;\n \n // Estimate cost for remaining characters\n int total_cost = move_cost;\n Position curr_pos = pos;\n \n for (int pos_idx = 1; pos_idx < target.length(); pos_idx++) {\n char c = target[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n total_cost = INT_MAX;\n break;\n }\n total_cost += abs(curr_pos.i - next_pos.i) + abs(curr_pos.j - next_pos.j) + 1;\n curr_pos = next_pos;\n }\n \n if (total_cost < best_cost && total_cost < 100) {\n best_cost = total_cost;\n best_k = k;\n best_start = pos;\n use_overlap = false;\n best_remaining = target;\n best_score = -total_cost;\n }\n }\n }\n \n if (best_k == -1) break;\n \n // Execute the chosen action\n if (use_overlap && !best_remaining.empty()) {\n Position curr_pos = {current_i, current_j};\n for (char c : best_remaining) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n } else if (best_start.i != -1) {\n result.emplace_back(best_start.i, best_start.j);\n Position curr_pos = best_start;\n \n for (int pos_idx = 1; pos_idx < best_remaining.length(); pos_idx++) {\n char c = best_remaining[pos_idx];\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) break;\n result.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n \n if (result.size() >= 4500) break;\n }\n }\n \n collected[best_k] = true;\n collected_count++;\n \n // Update current suffix (last up to 4 characters)\n current_suffix = \"\";\n int start_idx = max(0, (int)result.size() - 4);\n for (int i = start_idx; i < result.size(); i++) {\n current_suffix += grid[result[i].first][result[i].second];\n }\n }\n \n // If we still have time, try to collect more strings with simple approach\n while (collected_count < M && result.size() < 4900) {\n bool found = false;\n int current_i = result.back().first;\n int current_j = result.back().second;\n \n for (int k = 0; k < M && !found; k++) {\n if (collected[k]) continue;\n \n const string& target = targets[k];\n \n // Try to spell this string greedily\n Position curr_pos = {current_i, current_j};\n vector> temp_path;\n bool success = true;\n \n for (char c : target) {\n Position next_pos = nearest[curr_pos.i][curr_pos.j][c - 'A'];\n if (next_pos.i == -1) {\n success = false;\n break;\n }\n temp_path.emplace_back(next_pos.i, next_pos.j);\n curr_pos = next_pos;\n }\n \n if (success && result.size() + temp_path.size() < 4900) {\n for (auto pos : temp_path) {\n result.push_back(pos);\n }\n collected[k] = true;\n collected_count++;\n found = true;\n }\n }\n \n if (!found) break;\n }\n \n // Output result\n for (auto [i, j] : result) {\n cout << i << \" \" << j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct OilField {\n int size;\n vector> cells;\n};\n\nstruct Solver {\n int N, M;\n double eps;\n vector fields;\n vector> reserves;\n vector> known;\n int ops_used;\n \n Solver(int N, int M, double eps, const vector& fields) \n : N(N), M(M), eps(eps), fields(fields), \n reserves(N, vector(N, -1)), known(N, vector(N, false)),\n ops_used(0) {\n }\n \n void flush_output() {\n cout << flush;\n }\n \n bool query_drill(int i, int j) {\n if (ops_used >= 2*N*N) return false;\n \n ops_used++;\n cout << \"q 1 \" << i << \" \" << j << endl;\n flush_output();\n \n string resp;\n if (!(cin >> resp)) return false;\n \n try {\n int val = stoi(resp);\n reserves[i][j] = val;\n known[i][j] = true;\n return true;\n } catch (...) {\n return false;\n }\n }\n \n bool guess_answer(const vector>& answer) {\n if (ops_used >= 2*N*N) return false;\n \n ops_used++;\n cout << \"a \" << answer.size();\n for (auto [i,j] : answer) {\n cout << \" \" << i << \" \" << j;\n }\n cout << endl;\n flush_output();\n \n string resp;\n if (!(cin >> resp)) return false;\n \n return resp == \"1\";\n }\n \n void solve() {\n // Simple strategy: drill every square in order\n vector> oil_squares;\n \n for (int i = 0; i < N && ops_used < 2*N*N - 1; i++) {\n for (int j = 0; j < N && ops_used < 2*N*N - 1; j++) {\n if (query_drill(i, j)) {\n if (reserves[i][j] > 0) {\n oil_squares.emplace_back(i, j);\n }\n }\n }\n }\n \n // Output the answer\n guess_answer(oil_squares);\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n vector fields(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n fields[k].size = d;\n fields[k].cells.resize(d);\n for (int i = 0; i < d; i++) {\n cin >> fields[k].cells[i].first >> fields[k].cells[i].second;\n }\n }\n \n Solver solver(N, M, eps, fields);\n solver.solve();\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n \n vector> a(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> a[d][k];\n }\n }\n \n // Advanced adaptive strategy\n vector> prev_heights(D, vector(N, W / N));\n vector> prev_widths(D, vector(N, W / N));\n \n for (int d = 0; d < D; d++) {\n // Analyze area distribution\n double total_area = accumulate(a[d].begin(), a[d].end(), 0.0);\n double max_area = *max_element(a[d].begin(), a[d].end());\n double min_area = *min_element(a[d].begin(), a[d].end());\n double area_ratio = max_area / min_area;\n \n // Calculate area variance\n double mean_area = total_area / N;\n double variance = 0;\n for (int k = 0; k < N; k++) {\n variance += (a[d][k] - mean_area) * (a[d][k] - mean_area);\n }\n variance /= N;\n double std_dev = sqrt(variance);\n \n // Determine strategy based on area distribution\n bool is_extreme = (area_ratio > 15.0 || std_dev > mean_area);\n bool use_horizontal = true;\n \n // Try vertical orientation for extreme cases with very skewed distribution\n if (is_extreme && max_area > total_area * 0.7) {\n use_horizontal = false;\n }\n \n if (use_horizontal) {\n // Horizontal strips - optimized for normal cases\n vector heights(N);\n \n vector min_heights(N);\n int total_min_height = 0;\n for (int k = 0; k < N; k++) {\n min_heights[k] = max(1, (a[d][k] + W - 1) / W);\n total_min_height += min_heights[k];\n }\n \n if (total_min_height <= W) {\n heights = min_heights;\n int remaining = W - total_min_height;\n \n // Enhanced priority calculation\n vector> priorities(N);\n for (int k = 0; k < N; k++) {\n int current_area = heights[k] * W;\n if (current_area >= a[d][k]) {\n priorities[k] = {0.01, k};\n } else {\n double deficit_ratio = (double)(a[d][k] - current_area) / a[d][k];\n double absolute_deficit = (double)(a[d][k] - current_area) / W;\n \n // Adaptive weighting based on distribution\n double weight = 1.0;\n if (is_extreme && a[d][k] > mean_area * 2) {\n weight = 1.5; // Boost for large requirements in extreme cases\n }\n \n priorities[k] = {deficit_ratio * weight + absolute_deficit * 0.1, k};\n }\n }\n sort(priorities.rbegin(), priorities.rend());\n \n for (int i = 0; i < remaining; i++) {\n heights[priorities[i % N].second]++;\n }\n } else {\n double scale = (double)W / total_min_height;\n for (int k = 0; k < N; k++) {\n heights[k] = max(1, (int)round(min_heights[k] * scale));\n }\n \n int current_sum = accumulate(heights.begin(), heights.end(), 0);\n int diff = W - current_sum;\n \n if (diff > 0) {\n vector> deficit_priorities(N);\n for (int k = 0; k < N; k++) {\n int deficit = max(0, a[d][k] - heights[k] * W);\n double priority = (double)deficit;\n if (is_extreme && a[d][k] > mean_area * 2) {\n priority *= 1.5;\n }\n deficit_priorities[k] = {priority, k};\n }\n sort(deficit_priorities.rbegin(), deficit_priorities.rend());\n \n for (int i = 0; i < diff; i++) {\n heights[deficit_priorities[i % N].second]++;\n }\n }\n }\n \n // Ensure constraints\n for (int k = 0; k < N; k++) {\n heights[k] = max(1, heights[k]);\n }\n \n int current_sum = accumulate(heights.begin(), heights.end(), 0);\n if (current_sum != W) {\n int diff = W - current_sum;\n if (diff > 0) {\n for (int i = 0; i < diff; i++) {\n int best_k = 0;\n int max_deficit = 0;\n for (int k = 0; k < N; k++) {\n int deficit = max(0, a[d][k] - heights[k] * W);\n if (deficit > max_deficit) {\n max_deficit = deficit;\n best_k = k;\n }\n }\n heights[best_k]++;\n }\n } else {\n for (int i = 0; i < -diff; i++) {\n int best_k = 0;\n int min_deficit = 1e9;\n for (int k = 0; k < N; k++) {\n int deficit = max(0, a[d][k] - heights[k] * W);\n if (deficit < min_deficit && heights[k] > 1) {\n min_deficit = deficit;\n best_k = k;\n }\n }\n if (heights[best_k] > 1) {\n heights[best_k]--;\n }\n }\n }\n }\n \n // Adaptive smoothing\n if (d > 0) {\n vector smoothed_heights(N);\n double smooth_factor = is_extreme ? 0.95 : 0.9;\n \n for (int k = 0; k < N; k++) {\n smoothed_heights[k] = (int)round(smooth_factor * heights[k] + (1 - smooth_factor) * prev_heights[d-1][k]);\n smoothed_heights[k] = max(1, smoothed_heights[k]);\n }\n \n int original_penalty = 0, smoothed_penalty = 0;\n for (int k = 0; k < N; k++) {\n original_penalty += max(0, a[d][k] - heights[k] * W);\n smoothed_penalty += max(0, a[d][k] - smoothed_heights[k] * W);\n }\n \n double tolerance = is_extreme ? 1.02 : 1.1;\n if (smoothed_penalty <= original_penalty * tolerance) {\n heights = smoothed_heights;\n \n int smoothed_sum = accumulate(heights.begin(), heights.end(), 0);\n if (smoothed_sum != W) {\n int diff = W - smoothed_sum;\n if (diff > 0) {\n for (int i = 0; i < diff; i++) heights[i % N]++;\n } else {\n for (int i = 0; i < -diff; i++) {\n if (heights[N-1-(i%N)] > 1) heights[N-1-(i%N)]--;\n }\n }\n }\n }\n }\n \n // Output horizontal strips\n int pos = 0;\n for (int k = 0; k < N; k++) {\n int height = heights[k];\n int end_pos = min(pos + height, W);\n cout << pos << \" 0 \" << end_pos << \" \" << W << \"\\n\";\n pos = end_pos;\n }\n \n prev_heights[d] = heights;\n } else {\n // Vertical strips - for extreme cases\n vector widths(N);\n \n vector min_widths(N);\n int total_min_width = 0;\n for (int k = 0; k < N; k++) {\n min_widths[k] = max(1, (a[d][k] + W - 1) / W);\n total_min_width += min_widths[k];\n }\n \n if (total_min_width <= W) {\n widths = min_widths;\n int remaining = W - total_min_width;\n \n // Give priority to the largest requirement\n int max_idx = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n for (int i = 0; i < remaining; i++) {\n if (i < remaining / 2) {\n widths[max_idx]++;\n } else {\n widths[i % N]++;\n }\n }\n } else {\n double scale = (double)W / total_min_width;\n for (int k = 0; k < N; k++) {\n widths[k] = max(1, (int)round(min_widths[k] * scale));\n }\n \n int current_sum = accumulate(widths.begin(), widths.end(), 0);\n int diff = W - current_sum;\n \n if (diff > 0) {\n int max_idx = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n for (int i = 0; i < diff; i++) {\n widths[max_idx]++;\n }\n }\n }\n \n // Ensure constraints\n for (int k = 0; k < N; k++) {\n widths[k] = max(1, widths[k]);\n }\n \n int current_sum = accumulate(widths.begin(), widths.end(), 0);\n if (current_sum != W) {\n int diff = W - current_sum;\n if (diff > 0) {\n int max_idx = max_element(a[d].begin(), a[d].end()) - a[d].begin();\n for (int i = 0; i < diff; i++) {\n widths[max_idx]++;\n }\n } else {\n for (int i = 0; i < -diff; i++) {\n if (widths[N-1-(i%N)] > 1) widths[N-1-(i%N)]--;\n }\n }\n }\n \n // Minimal smoothing for extreme cases\n if (d > 0) {\n vector smoothed_widths(N);\n for (int k = 0; k < N; k++) {\n smoothed_widths[k] = (int)round(0.98 * widths[k] + 0.02 * prev_widths[d-1][k]);\n smoothed_widths[k] = max(1, smoothed_widths[k]);\n }\n \n int original_penalty = 0, smoothed_penalty = 0;\n for (int k = 0; k < N; k++) {\n original_penalty += max(0, a[d][k] - widths[k] * W);\n smoothed_penalty += max(0, a[d][k] - smoothed_widths[k] * W);\n }\n \n if (smoothed_penalty <= original_penalty * 1.01) {\n widths = smoothed_widths;\n \n int smoothed_sum = accumulate(widths.begin(), widths.end(), 0);\n if (smoothed_sum != W) {\n int diff = W - smoothed_sum;\n if (diff > 0) {\n for (int i = 0; i < diff; i++) widths[i % N]++;\n } else {\n for (int i = 0; i < -diff; i++) {\n if (widths[N-1-(i%N)] > 1) widths[N-1-(i%N)]--;\n }\n }\n }\n }\n }\n \n // Output vertical strips\n int pos = 0;\n for (int k = 0; k < N; k++) {\n int width = widths[k];\n int end_pos = min(pos + width, W);\n cout << \"0 \" << pos << \" \" << W << \" \" << end_pos << \"\\n\";\n pos = end_pos;\n }\n \n prev_widths[d] = widths;\n }\n }\n \n return 0;\n}","ahc032":"#include \n#include \n\nusing namespace std;\n\nstatic const int MOD = 998244353;\nstatic const int POS = 7; // N - 2, since N is always 9\n\nstruct Op {\n int m, p, q;\n};\n\ninline void addStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n board[p + i][q + j] += stamp[m][i][j];\n if (board[p + i][q + j] >= MOD) board[p + i][q + j] -= MOD;\n }\n }\n}\n\ninline void removeStamp(int m, int p, int q,\n const vector>>& stamp,\n vector>& board)\n{\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n board[p + i][q + j] -= stamp[m][i][j];\n if (board[p + i][q + j] < 0) board[p + i][q + j] += MOD;\n }\n }\n}\n\ninline long long profitStamp(int m, int p, int q,\n const vector>>& stamp,\n const vector>& board)\n{\n long long delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int s = stamp[m][i][j];\n int cur = board[p + i][q + j];\n if (cur + s >= MOD) delta += s - MOD;\n else delta += s;\n }\n }\n return delta;\n}\n\nlong long calculateScore(const vector>& board) {\n long long score = 0;\n for (const auto& row : board)\n for (int val : row)\n score += val;\n return score;\n}\n\nint main()\n{\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n vector> a(N, vector(N));\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) cin >> a[i][j];\n\n vector>> stamp(M, vector>(3, vector(3)));\n for (int m = 0; m < M; ++m)\n for (int i = 0; i < 3; ++i)\n for (int j = 0; j < 3; ++j) cin >> stamp[m][i][j];\n\n vector> positions;\n positions.reserve(POS * POS);\n for (int p = 0; p < POS; ++p)\n for (int q = 0; q < POS; ++q)\n positions.emplace_back(p, q);\n\n // Increased search parameters for a better score, leveraging the time budget\n const int ATTEMPTS = 8; // Increased from 5\n const int HC_ITER = 150000; // Increased from 40000\n const int SAMPLE_SIZE = 25;\n\n mt19937 rng(random_device{}());\n uniform_int_distribution rand_m(0, M - 1);\n uniform_int_distribution rand_pos(0, POS - 1);\n\n vector bestOps;\n long long bestScore = calculateScore(a);\n\n for (int attempt = 0; attempt < ATTEMPTS; ++attempt) {\n vector> board = a;\n vector ops;\n\n // ---- Greedy phase ----\n for (int step = 0; step < K; ++step) {\n long long bestDelta = 0;\n Op bestOp{-1, -1, -1};\n\n for (int m = 0; m < M; ++m) {\n for (auto [p, q] : positions) {\n long long delta = profitStamp(m, p, q, stamp, board);\n if (delta > bestDelta) {\n bestDelta = delta;\n bestOp = {m, p, q};\n }\n }\n }\n if (bestDelta <= 0) break;\n addStamp(bestOp.m, bestOp.p, bestOp.q, stamp, board);\n ops.push_back(bestOp);\n }\n\n // ---- Fast Hybrid Hill Climbing ----\n for (int iter = 0; iter < HC_ITER; ++iter) {\n int choice = rng() % 100;\n\n if (ops.size() < (size_t)K && choice < 40) { // Try to add\n Op bestSampleOp{-1, -1, -1};\n long long bestSampleDelta = 0;\n for (int i = 0; i < SAMPLE_SIZE; ++i) {\n Op sample_op = {rand_m(rng), rand_pos(rng), rand_pos(rng)};\n long long delta = profitStamp(sample_op.m, sample_op.p, sample_op.q, stamp, board);\n if (delta > bestSampleDelta) {\n bestSampleDelta = delta;\n bestSampleOp = sample_op;\n }\n }\n if (bestSampleDelta > 0) {\n addStamp(bestSampleOp.m, bestSampleOp.p, bestSampleOp.q, stamp, board);\n ops.push_back(bestSampleOp);\n }\n } else if (!ops.empty() && choice < 75) { // Try to replace\n int op_idx = rng() % ops.size();\n auto& old_op = ops[op_idx];\n long long delta_old = profitStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n\n Op bestSampleOp{-1, -1, -1};\n long long bestSampleDelta = LLONG_MIN;\n for (int i = 0; i < SAMPLE_SIZE; ++i) {\n Op sample_op = {rand_m(rng), rand_pos(rng), rand_pos(rng)};\n long long delta = profitStamp(sample_op.m, sample_op.p, sample_op.q, stamp, board);\n if (delta > bestSampleDelta) {\n bestSampleDelta = delta;\n bestSampleOp = sample_op;\n }\n }\n if (bestSampleDelta > delta_old) {\n removeStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n addStamp(bestSampleOp.m, bestSampleOp.p, bestSampleOp.q, stamp, board);\n old_op = bestSampleOp;\n }\n } else if (!ops.empty()) { // Try to remove\n int op_idx = rng() % ops.size();\n auto& old_op = ops[op_idx];\n long long delta = profitStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n if (delta < 0) {\n removeStamp(old_op.m, old_op.p, old_op.q, stamp, board);\n ops.erase(ops.begin() + op_idx);\n }\n }\n }\n\n long long curScore = calculateScore(board);\n if (curScore > bestScore) {\n bestScore = curScore;\n bestOps = ops;\n }\n }\n\n cout << bestOps.size() << \"\\n\";\n for (auto op : bestOps) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nstruct Container {\n int id;\n int arrival_row;\n int arrival_index;\n int target_row;\n int dispatch_order;\n};\n\nstruct Crane {\n int row, col;\n bool carrying;\n int container_id;\n vector commands;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 5;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n // Determine which gate each container should go to\n vector containers(N * N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container_id = A[i][j];\n containers[container_id].id = container_id;\n containers[container_id].arrival_row = i;\n containers[container_id].arrival_index = j;\n containers[container_id].target_row = container_id / N;\n containers[container_id].dispatch_order = container_id % N;\n }\n }\n \n // Initialize cranes\n vector cranes(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].carrying = false;\n cranes[i].container_id = -1;\n }\n \n // Large crane (index 0) will do all the work\n Crane& large_crane = cranes[0];\n \n // Bomb small cranes immediately on turn 0\n for (int i = 1; i < N; i++) {\n cranes[i].commands.push_back('B');\n }\n large_crane.commands.push_back('.'); // Large crane waits\n \n // Group containers by target gate\n vector> containers_by_gate(N);\n for (const auto& container : containers) {\n containers_by_gate[container.target_row].push_back(container);\n }\n \n // Sort each gate's containers by dispatch order\n for (int gate = 0; gate < N; gate++) {\n sort(containers_by_gate[gate].begin(), containers_by_gate[gate].end(), \n [](const Container& a, const Container& b) {\n return a.dispatch_order < b.dispatch_order;\n });\n }\n \n // Pre-assign buffer positions strategically\n vector> buffer_positions;\n // Use positions closer to dispatch gates for efficiency\n for (int c = 2; c >= 1; c--) { // Right to left for better access\n for (int r = 0; r < N; r++) {\n buffer_positions.push_back({r, c});\n }\n }\n \n int buffer_idx = 0;\n \n // Process containers gate by gate with optimized routing\n for (int target_gate = 0; target_gate < N; target_gate++) {\n vector gate_containers = containers_by_gate[target_gate];\n \n // Check for direct delivery opportunity (first container in correct order)\n if (!gate_containers.empty() && gate_containers[0].dispatch_order == 0) {\n const auto& container = gate_containers[0];\n \n // Move to gate position\n while (large_crane.row != container.arrival_row) {\n if (large_crane.row < container.arrival_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != 0) {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n \n // Minimal wait\n large_crane.commands.push_back('.');\n \n // Pick up and deliver directly\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to dispatch\n while (large_crane.row != container.target_row) {\n if (large_crane.row < container.target_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != N - 1) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n }\n \n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n // Move away from dispatch\n large_crane.commands.push_back('L');\n large_crane.col--;\n \n // Remove first container\n gate_containers.erase(gate_containers.begin());\n }\n \n // Buffer remaining containers\n vector>> buffered_containers;\n \n for (const auto& container : gate_containers) {\n // Move to gate position with optimized path\n while (large_crane.row != container.arrival_row) {\n if (large_crane.row < container.arrival_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != 0) {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n \n // Minimal wait\n large_crane.commands.push_back('.');\n \n // Pick up\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to buffer position (use closest available buffer)\n auto buffer_pos = buffer_positions[buffer_idx % buffer_positions.size()];\n while (large_crane.row != buffer_pos.first) {\n if (large_crane.row < buffer_pos.first) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != buffer_pos.second) {\n if (large_crane.col < buffer_pos.second) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n } else {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Place in buffer\n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n buffered_containers.push_back({container, buffer_pos});\n buffer_idx++;\n }\n \n // Dispatch buffered containers with optimized transitions\n for (size_t i = 0; i < buffered_containers.size(); i++) {\n const auto& [container, buffer_pos] = buffered_containers[i];\n \n // Move to buffer position\n while (large_crane.row != buffer_pos.first) {\n if (large_crane.row < buffer_pos.first) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != buffer_pos.second) {\n if (large_crane.col < buffer_pos.second) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n } else {\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n \n // Pick up\n large_crane.commands.push_back('P');\n large_crane.carrying = true;\n large_crane.container_id = container.id;\n \n // Move to dispatch\n while (large_crane.row != container.target_row) {\n if (large_crane.row < container.target_row) {\n large_crane.commands.push_back('D');\n large_crane.row++;\n } else {\n large_crane.commands.push_back('U');\n large_crane.row--;\n }\n }\n while (large_crane.col != N - 1) {\n large_crane.commands.push_back('R');\n large_crane.col++;\n }\n \n // Release\n large_crane.commands.push_back('Q');\n large_crane.carrying = false;\n large_crane.container_id = -1;\n \n // Optimize position for next container\n if (i < buffered_containers.size() - 1) {\n // Stay near dispatch gate for efficiency\n large_crane.commands.push_back('L');\n large_crane.col--;\n }\n }\n }\n \n // Small cranes are bombed, so they just do nothing\n for (int i = 1; i < N; i++) {\n while (cranes[i].commands.size() < (size_t)large_crane.commands.size()) {\n cranes[i].commands.push_back('.');\n }\n }\n \n // Ensure all command strings have the same length\n size_t max_len = 0;\n for (const auto& crane : cranes) {\n max_len = max(max_len, crane.commands.size());\n }\n \n for (auto& crane : cranes) {\n while (crane.commands.size() < max_len) {\n crane.commands.push_back('.');\n }\n }\n \n // Output the commands\n for (const auto& crane : cranes) {\n string s(crane.commands.begin(), crane.commands.end());\n cout << s << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nstruct Cell {\n int i, j, height;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 20;\n vector> h(N, vector(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n \n vector positive, negative;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n positive.push_back({i, j, h[i][j]});\n } else if (h[i][j] < 0) {\n negative.push_back({i, j, -h[i][j]});\n }\n }\n }\n \n vector operations;\n int ci = 0, cj = 0;\n \n auto manhattan_dist = [&](int i1, int j1, int i2, int j2) {\n return abs(i1 - i2) + abs(j1 - j2);\n };\n \n // Pure greedy with perfect cost calculation\n while (!positive.empty() && !negative.empty()) {\n double best_ratio = -1;\n size_t best_pi = 0, best_ni = 0;\n int best_amount = 0;\n \n // Find the optimal transport\n for (size_t pi = 0; pi < positive.size(); pi++) {\n for (size_t ni = 0; ni < negative.size(); ni++) {\n int amount = min(positive[pi].height, negative[ni].height);\n if (amount <= 0) continue;\n \n // Precise cost calculation\n int empty_dist = manhattan_dist(ci, cj, positive[pi].i, positive[pi].j);\n int loaded_dist = manhattan_dist(positive[pi].i, positive[pi].j, negative[ni].i, negative[ni].j);\n double cost = 100.0 * empty_dist + (100.0 + amount) * loaded_dist + 2.0 * amount;\n \n double ratio = (double)amount / cost;\n \n // Tie-breaking: prefer larger amounts, then shorter distances\n if (ratio > best_ratio || \n (abs(ratio - best_ratio) < 1e-12 && amount > best_amount) ||\n (abs(ratio - best_ratio) < 1e-12 && amount == best_amount && \n loaded_dist < manhattan_dist(positive[best_pi].i, positive[best_pi].j, \n negative[best_ni].i, negative[best_ni].j))) {\n best_ratio = ratio;\n best_pi = pi;\n best_ni = ni;\n best_amount = amount;\n }\n }\n }\n \n if (best_ratio < 0) break;\n \n Cell& pos = positive[best_pi];\n Cell& neg = negative[best_ni];\n \n // Move to positive cell (optimal path)\n while (ci != pos.i || cj != pos.j) {\n if (ci > pos.i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < pos.i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > pos.j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < pos.j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n \n // Load maximum possible\n operations.push_back(\"+\" + to_string(best_amount));\n pos.height -= best_amount;\n neg.height -= best_amount;\n \n // Move to negative cell (optimal path)\n while (ci != neg.i || cj != neg.j) {\n if (ci > neg.i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < neg.i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > neg.j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < neg.j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n \n // Unload\n operations.push_back(\"-\" + to_string(best_amount));\n \n // Clean up: remove completed cells efficiently\n if (pos.height == 0) {\n positive[best_pi] = positive.back();\n positive.pop_back();\n }\n if (neg.height == 0) {\n negative[best_ni] = negative.back();\n negative.pop_back();\n }\n }\n \n // Handle remaining cells (should be very few)\n for (size_t pi = 0; pi < positive.size(); pi++) {\n if (positive[pi].height > 0) {\n while (ci != positive[pi].i || cj != positive[pi].j) {\n if (ci > positive[pi].i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < positive[pi].i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > positive[pi].j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < positive[pi].j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n operations.push_back(\"+\" + to_string(positive[pi].height));\n operations.push_back(\"-\" + to_string(positive[pi].height));\n }\n }\n \n for (size_t ni = 0; ni < negative.size(); ni++) {\n if (negative[ni].height > 0) {\n while (ci != negative[ni].i || cj != negative[ni].j) {\n if (ci > negative[ni].i) {\n operations.push_back(\"U\");\n ci--;\n } else if (ci < negative[ni].i) {\n operations.push_back(\"D\");\n ci++;\n } else if (cj > negative[ni].j) {\n operations.push_back(\"L\");\n cj--;\n } else if (cj < negative[ni].j) {\n operations.push_back(\"R\");\n cj++;\n }\n }\n operations.push_back(\"+\" + to_string(negative[ni].height));\n operations.push_back(\"-\" + to_string(negative[ni].height));\n }\n }\n \n // Output operations\n for (const string& op : operations) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n vector values;\n int total_value;\n double score;\n int id;\n vector normalized_values;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, T;\n cin >> N >> M >> T;\n \n const int SEED_COUNT = 2 * N * (N - 1);\n vector seeds(SEED_COUNT);\n \n // Read initial seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].id = i;\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Calculate max values for each criterion\n vector max_criterion(M, 0);\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n \n for (int turn = 0; turn < T; turn++) {\n // Calculate normalized values for each seed\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].normalized_values.resize(M);\n for (int j = 0; j < M; j++) {\n if (max_criterion[j] > 0) {\n seeds[i].normalized_values[j] = (double)seeds[i].values[j] / max_criterion[j];\n } else {\n seeds[i].normalized_values[j] = 0;\n }\n }\n }\n \n // Calculate comprehensive scores\n for (int i = 0; i < SEED_COUNT; i++) {\n // Base score: total value\n double base_score = seeds[i].total_value;\n \n // Specialization bonus: how many criteria is this seed excellent at?\n int excellent_count = 0;\n double specialization_bonus = 0;\n for (int j = 0; j < M; j++) {\n double norm = seeds[i].normalized_values[j];\n if (norm > 0.9) {\n excellent_count++;\n specialization_bonus += 300;\n } else if (norm > 0.8) {\n specialization_bonus += 150;\n } else if (norm > 0.6) {\n specialization_bonus += 50;\n }\n }\n \n // Exponential bonus for multiple excellent criteria\n if (excellent_count >= 4) {\n specialization_bonus *= 3.0;\n } else if (excellent_count >= 3) {\n specialization_bonus *= 2.0;\n } else if (excellent_count >= 2) {\n specialization_bonus *= 1.5;\n }\n \n // Balance score: how well-rounded is the seed?\n double balance_score = 0;\n double min_norm = 1.0;\n for (int j = 0; j < M; j++) {\n min_norm = min(min_norm, seeds[i].normalized_values[j]);\n }\n balance_score = min_norm * 100;\n \n // Turn-based weighting\n double turn_weight = 1.0;\n if (turn >= T - 3) {\n turn_weight = 1.5; // Final turns: prioritize strength\n } else if (turn < 3) {\n turn_weight = 0.9; // Early turns: slightly less aggressive\n }\n \n seeds[i].score = (base_score * 0.5 + specialization_bonus * 0.4 + balance_score * 0.1) * turn_weight;\n }\n \n // Sort seeds by score\n sort(seeds.begin(), seeds.end(), [](const Seed& a, const Seed& b) {\n return a.score > b.score;\n });\n \n // Select seeds with smart diversity\n vector selected_ids;\n selected_ids.push_back(seeds[0].id); // Always include the best\n \n // Add seeds while maintaining some diversity\n for (int i = 1; i < min(45, SEED_COUNT) && selected_ids.size() < N * N; i++) {\n bool too_similar = false;\n int similar_count = 0;\n \n for (int selected_id : selected_ids) {\n // Calculate similarity\n double similarity = 0;\n for (int j = 0; j < M; j++) {\n double diff = abs(seeds[i].normalized_values[j] - seeds[selected_id].normalized_values[j]);\n similarity += (1.0 - diff);\n }\n similarity /= M;\n \n if (similarity > 0.85) {\n similar_count++;\n if (similar_count >= 2) {\n too_similar = true;\n break;\n }\n }\n }\n \n // Include if not too similar or if we need more seeds\n if (!too_similar || selected_ids.size() < N * N * 0.7) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n \n // Fill remaining slots\n while (selected_ids.size() < N * N) {\n for (int i = 0; i < SEED_COUNT && selected_ids.size() < N * N; i++) {\n if (find(selected_ids.begin(), selected_ids.end(), seeds[i].id) == selected_ids.end()) {\n selected_ids.push_back(seeds[i].id);\n }\n }\n }\n \n // Try multiple placement strategies and pick the best\n vector> best_grid(N, vector(N));\n double best_score = -1;\n \n // Strategy 1: Concentric circles from center\n vector> grid1(N, vector(N));\n vector> positions1;\n int center = N / 2;\n for (int radius = 0; radius <= 3; radius++) {\n for (int i = max(0, center - radius); i <= min(N - 1, center + radius); i++) {\n for (int j = max(0, center - radius); j <= min(N - 1, center + radius); j++) {\n if (abs(i - center) == radius || abs(j - center) == radius) {\n positions1.emplace_back(i, j);\n }\n }\n }\n }\n \n // Strategy 2: Checkerboard pattern\n vector> grid2(N, vector(N));\n vector> positions2;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 0) {\n positions2.emplace_back(i, j);\n }\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if ((i + j) % 2 == 1) {\n positions2.emplace_back(i, j);\n }\n }\n }\n \n // Strategy 3: Horizontal stripes\n vector> grid3(N, vector(N));\n vector> positions3;\n for (int i = 0; i < N; i += 2) {\n for (int j = 0; j < N; j++) {\n positions3.emplace_back(i, j);\n }\n }\n for (int i = 1; i < N; i += 2) {\n for (int j = 0; j < N; j++) {\n positions3.emplace_back(i, j);\n }\n }\n \n // Evaluate each strategy\n vector>> strategies = {positions1, positions2, positions3};\n vector>> grids = {grid1, grid2, grid3};\n \n for (int strategy = 0; strategy < 3; strategy++) {\n // Sort selected seeds by score for this strategy\n vector> seed_scores;\n for (int id : selected_ids) {\n seed_scores.emplace_back(seeds[id].score, id);\n }\n sort(seed_scores.rbegin(), seed_scores.rend());\n \n // Place seeds\n for (size_t i = 0; i < strategies[strategy].size() && i < seed_scores.size(); i++) {\n int row = strategies[strategy][i].first;\n int col = strategies[strategy][i].second;\n grids[strategy][row][col] = seed_scores[i].second;\n }\n \n // Calculate strategy score (adjacent strong pairs)\n double strategy_score = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int id = grids[strategy][i][j];\n if (i > 0) {\n int neighbor_id = grids[strategy][i-1][j];\n strategy_score += (seeds[id].score + seeds[neighbor_id].score) * 0.5;\n }\n if (j > 0) {\n int neighbor_id = grids[strategy][i][j-1];\n strategy_score += (seeds[id].score + seeds[neighbor_id].score) * 0.5;\n }\n }\n }\n \n if (strategy_score > best_score) {\n best_score = strategy_score;\n best_grid = grids[strategy];\n }\n }\n \n // Output best grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (j > 0) cout << \" \";\n cout << best_grid[i][j];\n }\n cout << \"\\n\";\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < SEED_COUNT; i++) {\n seeds[i].values.resize(M);\n seeds[i].total_value = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n seeds[i].total_value += seeds[i].values[j];\n }\n }\n \n // Update max criteria\n for (int i = 0; i < SEED_COUNT; i++) {\n for (int j = 0; j < M; j++) {\n max_criterion[j] = max(max_criterion[j], seeds[i].values[j]);\n }\n }\n }\n \n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n int manhattan(const Point& other) const {\n return abs(x - other.x) + abs(y - other.y);\n }\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector s_grid, t_grid;\n vector initial_pos, target_pos;\n vector tree;\n Point root_pos;\n int V_used;\n \n // State tracking\n vector vertex_positions;\n vector edge_directions; // 0=right, 1=down, 2=left, 3=up\n vector holding_takoyaki;\n \n // Task assignment\n vector> fingertip_paths;\n vector path_progress;\n vector assigned_takoyaki;\n \n bool is_valid_position(const Point& p) const {\n return p.x >= 0 && p.x < N && p.y >= 0 && p.y < N;\n }\n \n bool are_all_vertices_in_bounds() const {\n for (const auto& pos : vertex_positions) {\n if (!is_valid_position(pos)) return false;\n }\n return true;\n }\n \n bool validate_tree() const {\n // Check parent constraints\n for (int i = 1; i < V_used; i++) {\n if (tree[i].parent < 0 || tree[i].parent >= i) return false;\n if (tree[i].length < 1 || tree[i].length >= N) return false;\n }\n \n // Check tree connectivity\n vector visited(V_used, false);\n queue q;\n q.push(0);\n visited[0] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : tree[u].children) {\n if (!visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n \n for (bool v : visited) {\n if (!v) return false;\n }\n \n return true;\n }\n \npublic:\n RoboticArmSolver(int N, int M, int V, const vector& s, const vector& t) \n : N(N), M(M), V(V), s_grid(s), t_grid(t) {\n // Extract initial and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (s[i][j] == '1') initial_pos.emplace_back(i, j);\n if (t[i][j] == '1') target_pos.emplace_back(i, j);\n }\n }\n }\n \n void design_arm() {\n V_used = min(V, 6); // Conservative number of vertices\n tree.resize(V_used);\n \n // Root\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Ensure minimum edge length of 1\n int edge_length = max(1, min(N / 4, 3));\n \n // Create simple and safe structure\n if (V_used == 2) {\n // Just one edge\n tree[1].parent = 0;\n tree[1].length = edge_length;\n tree[1].is_leaf = true;\n tree[0].children.push_back(1);\n } else if (V_used <= 4) {\n // Simple line\n for (int i = 1; i < V_used; i++) {\n tree[i].parent = i - 1;\n tree[i].length = edge_length;\n tree[i].is_leaf = (i == V_used - 1);\n tree[i - 1].children.push_back(i);\n }\n } else {\n // Star with short branches\n int num_branches = min(3, V_used - 1);\n \n for (int i = 1; i <= num_branches; i++) {\n tree[i].parent = 0;\n tree[i].length = edge_length;\n tree[i].is_leaf = false;\n tree[0].children.push_back(i);\n }\n \n // Add fingertips\n int vertex = num_branches + 1;\n for (int parent = 1; parent <= num_branches && vertex < V_used; parent++) {\n tree[vertex].parent = parent;\n tree[vertex].length = 1; // Minimum length for safety\n tree[vertex].is_leaf = true;\n tree[parent].children.push_back(vertex);\n vertex++;\n }\n }\n \n // Validate tree\n if (!validate_tree()) {\n // Fallback to minimal valid tree\n V_used = 2;\n tree.resize(2);\n tree[0] = {-1, 0, {1}, false};\n tree[1] = {0, 1, {}, true};\n }\n \n // Find safe root position\n bool found_safe = false;\n root_pos = Point(N / 2, N / 2);\n \n // Try positions ensuring arm stays in bounds\n for (int rx = max(1, N/2 - 2); rx <= min(N-2, N/2 + 2) && !found_safe; rx++) {\n for (int ry = max(1, N/2 - 2); ry <= min(N-2, N/2 + 2) && !found_safe; ry++) {\n root_pos = Point(rx, ry);\n vertex_positions.resize(V_used);\n edge_directions.assign(V_used, 0);\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n found_safe = true;\n }\n }\n }\n \n // Initialize state\n holding_takoyaki.assign(V_used, false);\n assigned_takoyaki.assign(M, -1);\n }\n \n void update_positions() {\n vertex_positions[0] = root_pos;\n \n for (int i = 1; i < V_used; i++) {\n int parent = tree[i].parent;\n int dir = edge_directions[i];\n int dx[4] = {0, 1, 0, -1}; // right, down, left, up\n int dy[4] = {1, 0, -1, 0};\n \n vertex_positions[i].x = vertex_positions[parent].x + dx[dir] * tree[i].length;\n vertex_positions[i].y = vertex_positions[parent].y + dy[dir] * tree[i].length;\n }\n }\n \n void print_design() {\n cout << V_used << endl;\n for (int i = 1; i < V_used; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n cout << root_pos.x << \" \" << root_pos.y << endl;\n }\n \n void assign_tasks() {\n // Get list of fingertips\n vector fingertips;\n for (int i = 1; i < V_used; i++) {\n if (tree[i].is_leaf) fingertips.push_back(i);\n }\n \n if (fingertips.empty()) return;\n \n // Simple assignment\n vector used_initial(M, false);\n vector used_fingertips(fingertips.size(), false);\n \n fingertip_paths.resize(fingertips.size());\n path_progress.assign(fingertips.size(), 0);\n \n for (int k = 0; k < min(M, (int)fingertips.size()); k++) {\n int best_i = -1, best_j = -1;\n int min_dist = INT_MAX;\n \n for (int i = 0; i < M; i++) {\n if (!used_initial[i]) {\n for (int j = 0; j < fingertips.size(); j++) {\n if (!used_fingertips[j]) {\n int dist = vertex_positions[fingertips[j]].manhattan(initial_pos[i]);\n if (dist < min_dist) {\n min_dist = dist;\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n }\n \n if (best_i != -1 && best_j != -1) {\n used_initial[best_i] = true;\n used_fingertips[best_j] = true;\n assigned_takoyaki[best_i] = fingertips[best_j];\n \n // Create path\n vector path;\n Point current = vertex_positions[fingertips[best_j]];\n Point target = initial_pos[best_i];\n \n // Move to initial position\n while (current != target) {\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n path.push_back(current);\n }\n path.push_back(target); // Pickup\n \n // Move to target position\n current = target;\n target = target_pos[best_i];\n while (current != target) {\n if (current.x < target.x) current.x++;\n else if (current.x > target.x) current.x--;\n else if (current.y < target.y) current.y++;\n else if (current.y > target.y) current.y--;\n path.push_back(current);\n }\n path.push_back(target); // Dropoff\n \n fingertip_paths[best_j] = path;\n }\n }\n }\n \n string generate_operation() {\n string op(2 * V_used, '.');\n \n // Find fingertip that needs to move\n int urgent_fingertip = -1;\n int urgent_path_idx = -1;\n \n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (!fingertip_paths[i].empty() && \n path_progress[i] < fingertip_paths[i].size()) {\n urgent_fingertip = assigned_takoyaki[i];\n urgent_path_idx = i;\n break;\n }\n }\n \n if (urgent_fingertip == -1) return op;\n \n Point target = fingertip_paths[urgent_path_idx][path_progress[urgent_path_idx]];\n Point current = vertex_positions[urgent_fingertip];\n \n // Check if at target\n if (current == target) {\n // Handle pickup/dropoff\n if (path_progress[urgent_path_idx] == 0) {\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = true;\n } else if (path_progress[urgent_path_idx] == fingertip_paths[urgent_path_idx].size() - 1) {\n op[V_used + urgent_fingertip] = 'P';\n holding_takoyaki[urgent_fingertip] = false;\n }\n path_progress[urgent_path_idx]++;\n return op;\n }\n \n // Try safe movements\n int best_dist = current.manhattan(target);\n \n // Try root movements\n int dx[4] = {-1, 1, 0, 0}; // U, D, L, R\n int dy[4] = {0, 0, -1, 1};\n char moves[4] = {'U', 'D', 'L', 'R'};\n \n for (int d = 0; d < 4; d++) {\n Point new_root(root_pos.x + dx[d], root_pos.y + dy[d]);\n if (!is_valid_position(new_root)) continue;\n \n Point old_root = root_pos;\n root_pos = new_root;\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n op[0] = moves[d];\n return op;\n }\n }\n \n root_pos = old_root;\n update_positions();\n }\n \n // Try rotation\n for (int r = 1; r <= 2; r++) {\n int old_dir = edge_directions[urgent_fingertip];\n edge_directions[urgent_fingertip] = (old_dir + (r == 1 ? 3 : 1)) % 4;\n update_positions();\n \n if (are_all_vertices_in_bounds()) {\n int new_dist = vertex_positions[urgent_fingertip].manhattan(target);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n op[urgent_fingertip] = (r == 1) ? 'L' : 'R';\n return op;\n }\n }\n \n edge_directions[urgent_fingertip] = old_dir;\n update_positions();\n }\n \n return op;\n }\n \n void execute_operations() {\n assign_tasks();\n \n bool all_complete = false;\n int max_turns = 5000; // Conservative limit\n \n while (!all_complete && max_turns-- > 0) {\n string op = generate_operation();\n cout << op << endl;\n \n // Check completion\n all_complete = true;\n for (int i = 0; i < fingertip_paths.size(); i++) {\n if (path_progress[i] < fingertip_paths[i].size()) {\n all_complete = false;\n break;\n }\n }\n }\n }\n \n void solve() {\n design_arm();\n print_design();\n execute_operations();\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M, V;\n cin >> N >> M >> V;\n \n vector s(N), t(N);\n for (int i = 0; i < N; i++) cin >> s[i];\n for (int i = 0; i < N; i++) cin >> t[i];\n \n RoboticArmSolver solver(N, M, V, s, t);\n solver.solve();\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n bool is_mackerel;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n vector points(2 * N);\n for (int i = 0; i < 2 * N; ++i) {\n cin >> points[i].x >> points[i].y;\n points[i].is_mackerel = (i < N);\n }\n \n auto count_in_rectangle = [&](int x1, int x2, int y1, int y2) {\n int a = 0, b = 0;\n for (const auto& p : points) {\n if (p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2) {\n if (p.is_mackerel) a++;\n else b++;\n }\n }\n return make_pair(a, b);\n };\n \n int best_diff = -1;\n int best_x1 = -1, best_y1 = -1, best_x2 = -1, best_y2 = -1;\n \n // Try multiple initial rectangles around each mackerel with randomness\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n for (int size = 10; size <= 50; size += 10) {\n for (int offset = -5; offset <= 5; offset += 5) {\n int x1 = max(0, p.x - size + offset);\n int x2 = min(100000, p.x + size + offset);\n int y1 = max(0, p.y - size + offset);\n int y2 = min(100000, p.y + size + offset);\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n int diff = a - b;\n if (diff > best_diff) {\n best_diff = diff;\n best_x1 = x1; best_y1 = y1; best_x2 = x2; best_y2 = y2;\n }\n }\n }\n }\n \n if (best_diff <= 0) {\n // Try to find a rectangle with at least one mackerel and zero sardines\n for (const auto& p : points) {\n if (!p.is_mackerel) continue;\n int x1 = p.x;\n int x2 = p.x;\n int y1 = p.y;\n int y2 = p.y;\n auto [a, b] = count_in_rectangle(x1, x2, y1, y2);\n if (a > 0 && b == 0) {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 + 1 << \" \" << y1 << \"\\n\";\n cout << x2 + 1 << \" \" << y2 + 1 << \"\\n\";\n cout << x1 << \" \" << y2 + 1 << \"\\n\";\n return 0;\n }\n }\n // Fallback to minimal polygon\n for (const auto& p : points) {\n if (p.is_mackerel) {\n int x = p.x;\n int y = p.y;\n cout << 4 << \"\\n\";\n cout << x << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y << \"\\n\";\n cout << x + 1 << \" \" << y + 1 << \"\\n\";\n cout << x << \" \" << y + 1 << \"\\n\";\n return 0;\n }\n }\n }\n \n // Expand the best rectangle with hybrid directional and random expansion\n bool improved = true;\n while (improved) {\n improved = false;\n int current_diff = best_diff;\n // Calculate densities in each direction\n int left_m = 0, left_s = 0;\n int right_m = 0, right_s = 0;\n int down_m = 0, down_s = 0;\n int up_m = 0, up_s = 0;\n for (const auto& p : points) {\n if (p.x < best_x1 && p.y >= best_y1 && p.y <= best_y2) {\n if (p.is_mackerel) left_m++;\n else left_s++;\n } else if (p.x > best_x2 && p.y >= best_y1 && p.y <= best_y2) {\n if (p.is_mackerel) right_m++;\n else right_s++;\n } else if (p.y < best_y1 && p.x >= best_x1 && p.x <= best_x2) {\n if (p.is_mackerel) down_m++;\n else down_s++;\n } else if (p.y > best_y2 && p.x >= best_x1 && p.x <= best_x2) {\n if (p.is_mackerel) up_m++;\n else up_s++;\n }\n }\n // Prioritize directions with higher mackerel to sardine ratio\n vector, pair>> directions = {\n {{left_m, left_s}, {-1, 0}},\n {{right_m, right_s}, {1, 0}},\n {{down_m, down_s}, {0, -1}},\n {{up_m, up_s}, {0, 1}}\n };\n sort(directions.begin(), directions.end(), [](const auto& a, const auto& b) {\n double ratio_a = (a.first.second == 0) ? 1e9 : (double)a.first.first / a.first.second;\n double ratio_b = (b.first.second == 0) ? 1e9 : (double)b.first.first / b.first.second;\n return ratio_a > ratio_b;\n });\n for (auto [dens, dir] : directions) {\n auto [m, s] = dens;\n auto [dx, dy] = dir;\n int step = 10;\n while (step >= 1) {\n int new_x1 = best_x1, new_x2 = best_x2, new_y1 = best_y1, new_y2 = best_y2;\n if (dx == -1) new_x1 = max(0, best_x1 - step);\n else if (dx == 1) new_x2 = min(100000, best_x2 + step);\n else if (dy == -1) new_y1 = max(0, best_y1 - step);\n else if (dy == 1) new_y2 = min(100000, best_y2 + step);\n auto [a, b] = count_in_rectangle(new_x1, new_x2, new_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1; best_y1 = new_y1; best_x2 = new_x2; best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n break;\n }\n step /= 2;\n }\n if (improved) break;\n }\n // Random expansion if no improvement\n if (!improved) {\n uniform_int_distribution dir_dist(0, 3);\n uniform_int_distribution step_dist(1, 10);\n int dir = dir_dist(rng);\n int step = step_dist(rng);\n int new_x1 = best_x1, new_x2 = best_x2, new_y1 = best_y1, new_y2 = best_y2;\n if (dir == 0) new_x1 = max(0, best_x1 - step);\n else if (dir == 1) new_x2 = min(100000, best_x2 + step);\n else if (dir == 2) new_y1 = max(0, best_y1 - step);\n else if (dir == 3) new_y2 = min(100000, best_y2 + step);\n auto [a, b] = count_in_rectangle(new_x1, new_x2, new_y1, new_y2);\n int new_diff = a - b;\n if (new_diff > current_diff) {\n best_x1 = new_x1; best_y1 = new_y1; best_x2 = new_x2; best_y2 = new_y2;\n best_diff = new_diff;\n improved = true;\n }\n }\n }\n \n // Output the rectangle as a polygon\n cout << 4 << \"\\n\";\n cout << best_x1 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y1 << \"\\n\";\n cout << best_x2 << \" \" << best_y2 << \"\\n\";\n cout << best_x1 << \" \" << best_y2 << \"\\n\";\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct PlacedRect {\n long long x, y, w, h;\n int idx;\n int r;\n char d;\n int b;\n};\n\n// For managing skyline segments\nstruct SkylineSegment {\n long long x1, x2, y;\n bool operator<(const SkylineSegment& other) const {\n return x1 < other.x1;\n }\n};\n\nvoid solve() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, T;\n long long sigma;\n cin >> N >> T >> sigma;\n\n vector w_prime(N), h_prime(N);\n for (int i = 0; i < N; ++i) {\n cin >> w_prime[i] >> h_prime[i];\n }\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n const int NUM_HEURISTICS = 5;\n\n for (int t = 0; t < T; ++t) {\n int heuristic = t % NUM_HEURISTICS;\n \n cerr << \"Turn \" << t << \", Heuristic \" << heuristic << endl;\n cout << \"# Turn \" << t << \", Heuristic \" << heuristic << endl;\n\n vector placed_rects;\n map placed_map;\n set skyline;\n\n for (int i = 0; i < N; ++i) {\n long long w_orig = w_prime[i];\n long long h_orig = h_prime[i];\n\n long long best_score = 4e18;\n PlacedRect best_placement = {0, 0, 0, 0, i, 0, 'L', -1};\n\n // Try both rotations\n for (int rot = 0; rot < 2; ++rot) {\n long long w = (rot == 0) ? w_orig : h_orig;\n long long h = (rot == 0) ? h_orig : w_orig;\n\n // Find placement using skyline\n auto it = skyline.begin();\n while (it != skyline.end()) {\n long long x = it->x1;\n long long y = it->y;\n long long x2_check = x + w;\n \n // Find the max y-level on the interval [x, x+w]\n long long required_y = 0;\n auto temp_it = it;\n while(temp_it != skyline.end() && temp_it->x1 < x2_check) {\n required_y = max(required_y, temp_it->y);\n temp_it++;\n }\n \n long long total_w = 0, total_h = 0;\n for(const auto& p : placed_rects) {\n total_w = max(total_w, p.x + p.w);\n total_h = max(total_h, p.y + p.h);\n }\n total_w = max(total_w, x + w);\n total_h = max(total_h, required_y + h);\n \n long long score = 0;\n if (heuristic == 0) score = total_w + total_h;\n else if (heuristic == 1) score = total_w * total_h;\n else if (heuristic == 2) score = total_h;\n else if (heuristic == 3) score = required_y + h; // Prefer lower placements\n else if (heuristic == 4) score = total_w + total_h + (rng() % 5000); // Randomized\n\n // Apply some randomness to avoid local minima\n if (rng() % 100 < 98 && score < best_score) {\n best_score = score;\n // Determine command and reference\n char cmd_d = 'L'; int cmd_b = -1;\n for(const auto& pr : placed_rects) {\n if (abs((pr.y + pr.h) - required_y) < 1e-9 && pr.x < x + w && x < pr.x + pr.w) {\n cmd_d = 'L'; cmd_b = pr.idx; break;\n }\n }\n if (cmd_b == -1) {\n for(const auto& pr : placed_rects) {\n if (abs((pr.x + pr.w) - x) < 1e-9 && pr.y < required_y + h && required_y < pr.y + pr.h) {\n cmd_d = 'U'; cmd_b = pr.idx; break;\n }\n }\n }\n best_placement = {x, required_y, w, h, i, rot, cmd_d, cmd_b};\n }\n it++;\n }\n }\n\n // If no placement found, place against a wall\n if (best_score == 4e18) {\n long long w = w_orig, h = h_orig;\n long long current_w = 0, current_h = 0;\n for(const auto& p : placed_rects) {\n current_w = max(current_w, p.x + p.w);\n current_h = max(current_h, p.y + p.h);\n }\n \n long long score_L = (current_w + w) + max(current_h, h);\n long long score_U = max(current_w, w) + (current_h + h);\n \n if(score_L <= score_U) {\n best_placement = {current_w, 0, w, h, i, 0, 'L', -1};\n } else {\n best_placement = {0, current_h, w, h, i, 0, 'U', -1};\n }\n }\n\n placed_rects.push_back(best_placement);\n placed_map[i] = best_placement;\n\n // Update skyline\n long long px = best_placement.x, py = best_placement.y, pw = best_placement.w, ph = best_placement.h;\n long long new_height = py + ph;\n \n auto it = skyline.lower_bound({px, 0, 0});\n while(it != skyline.end() && it->x1 < px + pw) {\n it = skyline.erase(it);\n }\n skyline.insert({px, px + pw, new_height});\n }\n \n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n const auto& pr = placed_map[i];\n cout << pr.idx << \" \" << pr.r << \" \" << pr.d << \" \" << pr.b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n}\n\nint main() {\n solve();\n return 0;\n}","ahc041":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct Vertex {\n int x, y;\n int beauty;\n vector neighbors;\n int parent;\n int depth;\n int tree_id;\n bool assigned;\n int subtree_beauty;\n};\n\nint calculate_score(const vector& vertices) {\n int score = 0;\n for (const auto& v : vertices) {\n score += (v.depth + 1) * v.beauty;\n }\n return score;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n \n vector vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].beauty;\n }\n \n set> edge_set;\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n vertices[u].neighbors.push_back(v);\n vertices[v].neighbors.push_back(u);\n edge_set.insert({min(u, v), max(u, v)});\n }\n \n for (int i = 0; i < N; i++) {\n cin >> vertices[i].x >> vertices[i].y;\n }\n \n // Initialize best solution\n vector best_vertices = vertices;\n int best_score = 0;\n \n // Multiple restarts with different seeds\n for (int restart = 0; restart < 3; restart++) {\n // Reset for this restart\n for (int i = 0; i < N; i++) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = -1;\n vertices[i].assigned = false;\n vertices[i].subtree_beauty = vertices[i].beauty;\n }\n \n // Sort vertices by beauty (ascending) for root selection\n vector sorted_by_beauty(N);\n iota(sorted_by_beauty.begin(), sorted_by_beauty.end(), 0);\n sort(sorted_by_beauty.begin(), sorted_by_beauty.end(), \n [&](int a, int b) { return vertices[a].beauty < vertices[b].beauty; });\n \n // Select roots with varied distribution for each restart\n int num_roots = max(1, N / (20 + restart * 5));\n vector roots;\n vector is_root(N, false);\n \n mt19937 rng(42 + restart);\n uniform_int_distribution dist(30, 80);\n int min_dist_sq = dist(rng) * dist(rng);\n \n for (int i = 0; i < num_roots && i < N; i++) {\n int v = sorted_by_beauty[i];\n bool too_close = false;\n for (int r : roots) {\n int dx = vertices[v].x - vertices[r].x;\n int dy = vertices[v].y - vertices[r].y;\n if (dx*dx + dy*dy < min_dist_sq) {\n too_close = true;\n break;\n }\n }\n if (!too_close) {\n roots.push_back(v);\n is_root[v] = true;\n vertices[v].parent = -1;\n vertices[v].depth = 0;\n vertices[v].tree_id = v;\n vertices[v].assigned = true;\n }\n }\n \n if (roots.empty()) {\n roots.push_back(0);\n is_root[0] = true;\n vertices[0].parent = -1;\n vertices[0].depth = 0;\n vertices[0].tree_id = 0;\n vertices[0].assigned = true;\n }\n \n // Build trees using BFS\n for (int root : roots) {\n queue q;\n q.push(root);\n \n while (!q.empty()) {\n int v = q.front();\n q.pop();\n \n if (vertices[v].depth >= H) continue;\n \n vector> neighbor_beauty;\n for (int nb : vertices[v].neighbors) {\n if (!vertices[nb].assigned) {\n neighbor_beauty.emplace_back(vertices[nb].beauty, nb);\n }\n }\n sort(neighbor_beauty.rbegin(), neighbor_beauty.rend());\n \n for (auto [beauty, nb] : neighbor_beauty) {\n vertices[nb].parent = v;\n vertices[nb].depth = vertices[v].depth + 1;\n vertices[nb].tree_id = root;\n vertices[nb].assigned = true;\n q.push(nb);\n }\n }\n }\n \n // Assign remaining vertices\n for (int i = 0; i < N; i++) {\n if (!vertices[i].assigned) {\n int best_parent = -1;\n int best_score = INT_MIN;\n \n for (int nb : vertices[i].neighbors) {\n if (vertices[nb].assigned && vertices[nb].depth < H) {\n int score = (vertices[nb].depth + 2) * vertices[i].beauty;\n if (score > best_score) {\n best_score = score;\n best_parent = nb;\n }\n }\n }\n \n if (best_parent != -1) {\n vertices[i].parent = best_parent;\n vertices[i].depth = vertices[best_parent].depth + 1;\n vertices[i].tree_id = vertices[best_parent].tree_id;\n vertices[i].assigned = true;\n } else {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n vertices[i].assigned = true;\n }\n }\n }\n \n // Advanced local optimization with simulated annealing\n mt19937 rng_local(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int phase = 0; phase < 2; phase++) {\n double temperature = 1.0;\n double cooling_rate = 0.95;\n \n for (int iter = 0; iter < 100; iter++) {\n vector candidates;\n for (int i = 0; i < N; i++) {\n if (vertices[i].depth > 0 && vertices[i].depth < H) {\n candidates.push_back(i);\n }\n }\n \n if (candidates.empty()) break;\n \n int v = candidates[rng_local() % candidates.size()];\n \n int current_score = (vertices[v].depth + 1) * vertices[v].beauty;\n int best_parent = vertices[v].parent;\n int best_score = current_score;\n \n vector> potential_parents;\n for (int nb : vertices[v].neighbors) {\n if (nb != vertices[v].parent && \n vertices[nb].depth < H && \n vertices[nb].tree_id != vertices[v].tree_id) {\n \n bool safe = true;\n queue check_q;\n check_q.push(v);\n int check_depth = vertices[nb].depth + 1;\n \n while (!check_q.empty() && safe) {\n int current = check_q.front();\n check_q.pop();\n \n if (check_depth > H) {\n safe = false;\n break;\n }\n \n for (int j = 0; j < N; j++) {\n if (vertices[j].parent == current) {\n check_q.push(j);\n }\n }\n check_depth++;\n }\n \n if (safe) {\n int new_score = (vertices[nb].depth + 2) * vertices[v].beauty;\n potential_parents.emplace_back(new_score, nb);\n }\n }\n }\n \n if (!potential_parents.empty()) {\n sort(potential_parents.rbegin(), potential_parents.rend());\n \n // Simulated annealing decision\n if (potential_parents[0].first > best_score) {\n best_parent = potential_parents[0].second;\n best_score = potential_parents[0].first;\n } else if (temperature > 0.1 && potential_parents.size() > 1) {\n // Sometimes accept worse moves\n double prob = exp((potential_parents[0].first - best_score) / temperature);\n if (rng_local() / (double)numeric_limits::max() < prob) {\n best_parent = potential_parents[0].second;\n best_score = potential_parents[0].first;\n }\n }\n }\n \n if (best_parent != vertices[v].parent) {\n vertices[v].parent = best_parent;\n vertices[v].depth = vertices[best_parent].depth + 1;\n vertices[v].tree_id = vertices[best_parent].tree_id;\n \n queue update_q;\n update_q.push(v);\n \n while (!update_q.empty()) {\n int current = update_q.front();\n update_q.pop();\n \n for (int j = 0; j < N; j++) {\n if (vertices[j].parent == current) {\n vertices[j].depth = vertices[current].depth + 1;\n update_q.push(j);\n }\n }\n }\n }\n \n temperature *= cooling_rate;\n }\n }\n \n // Calculate score for this restart\n int current_score = calculate_score(vertices);\n if (current_score > best_score) {\n best_score = current_score;\n best_vertices = vertices;\n }\n }\n \n // Use best solution found\n vertices = best_vertices;\n \n // Final validation\n for (int i = 0; i < N; i++) {\n if (vertices[i].parent != -1) {\n int u = i;\n int v = vertices[i].parent;\n if (edge_set.find({min(u, v), max(u, v)}) == edge_set.end()) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n }\n }\n }\n \n // Ensure height constraint\n for (int i = 0; i < N; i++) {\n if (vertices[i].depth > H) {\n vertices[i].parent = -1;\n vertices[i].depth = 0;\n vertices[i].tree_id = i;\n }\n }\n \n // Output parent array\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << vertices[i].parent;\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// N is fixed at 20 for all test cases.\nconst int N = 20;\n\n// Represents a plan to remove a group of Oni\nstruct GroupPlan {\n char dir;\n int idx;\n int cost;\n vector> oni_pos; // (row, col)\n};\n\n// Represents an individual plan for a single Oni\nstruct IndividualPlan {\n char dir;\n int idx;\n int cost;\n};\n\n// Helper function to get the reverse direction\nchar get_reverse_dir(char dir) {\n if (dir == 'L') return 'R';\n if (dir == 'R') return 'L';\n if (dir == 'U') return 'D';\n if (dir == 'D') return 'U';\n return '?';\n}\n\n// Function to check if a path is clear of Fukunokami\n// Checks from start_pos (inclusive) to end_pos (exclusive)\nbool is_path_clear(const vector& board, bool is_row, int line_idx, int start_pos, int end_pos) {\n if (is_row) {\n for (int j = start_pos; j < end_pos; ++j) {\n if (board[line_idx][j] == 'o') return false;\n }\n } else {\n for (int i = start_pos; i < end_pos; ++i) {\n if (board[i][line_idx] == 'o') return false;\n }\n }\n return true;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_input;\n cin >> N_input;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n // --- Phase 1: Calculate baseline individual plan costs for all Oni ---\n map, IndividualPlan> best_individual_plans;\n vector> all_oni_positions;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n all_oni_positions.push_back({i, j});\n int min_cost = 2 * N + 1;\n char best_dir = '?';\n\n if (is_path_clear(board, false, j, 0, i)) {\n int cost = 2 * (i + 1);\n if (cost < min_cost) { min_cost = cost; best_dir = 'U'; }\n }\n if (is_path_clear(board, false, j, i + 1, N)) {\n int cost = 2 * (N - i);\n if (cost < min_cost) { min_cost = cost; best_dir = 'D'; }\n }\n if (is_path_clear(board, true, i, 0, j)) {\n int cost = 2 * (j + 1);\n if (cost < min_cost) { min_cost = cost; best_dir = 'L'; }\n }\n if (is_path_clear(board, true, i, j + 1, N)) {\n int cost = 2 * (N - j);\n if (cost < min_cost) { min_cost = cost; best_dir = 'R'; }\n }\n int line_idx = (best_dir == 'L' || best_dir == 'R') ? i : j;\n best_individual_plans[{i, j}] = {best_dir, line_idx, min_cost};\n }\n }\n }\n\n // --- Phase 2: Iteratively find and apply the best group plan ---\n set> uncovered_onis(all_oni_positions.begin(), all_oni_positions.end());\n vector final_group_plans;\n\n while(true) {\n int best_savings = 0;\n GroupPlan best_plan;\n bool found_improvement = false;\n\n // Check all rows for a potential improvement\n for (int i = 0; i < N; ++i) {\n vector> oni_in_row;\n for (const auto& pos : uncovered_onis) {\n if (pos.first == i) {\n oni_in_row.push_back(pos);\n }\n }\n if (oni_in_row.size() < 2) continue;\n\n // Find min and max column indices for Oni in this row\n int j_min = N, j_max = -1;\n for (const auto& pos : oni_in_row) {\n j_min = min(j_min, pos.second);\n j_max = max(j_max, pos.second);\n }\n\n // Check Left group plan\n // To remove all Oni by shifting left, we need to shift j_max + 1 times\n if (is_path_clear(board, true, i, 0, j_max + 1)) {\n int group_cost = 2 * (j_max + 1);\n int individual_cost_sum = 0;\n for(const auto& pos : oni_in_row) {\n individual_cost_sum += best_individual_plans[pos].cost;\n }\n int savings = individual_cost_sum - group_cost;\n if (savings > best_savings) {\n best_savings = savings;\n sort(oni_in_row.begin(), oni_in_row.end()); // Sort for consistent output\n best_plan = {'L', i, group_cost, oni_in_row};\n found_improvement = true;\n }\n }\n\n // Check Right group plan\n // To remove all Oni by shifting right, we need to shift N - j_min times\n if (is_path_clear(board, true, i, j_min, N)) {\n int group_cost = 2 * (N - j_min);\n int individual_cost_sum = 0;\n for(const auto& pos : oni_in_row) {\n individual_cost_sum += best_individual_plans[pos].cost;\n }\n int savings = individual_cost_sum - group_cost;\n if (savings > best_savings) {\n best_savings = savings;\n sort(oni_in_row.begin(), oni_in_row.end()); // Sort for consistent output\n best_plan = {'R', i, group_cost, oni_in_row};\n found_improvement = true;\n }\n }\n }\n\n // Check all columns for a potential improvement\n for (int j = 0; j < N; ++j) {\n vector> oni_in_col;\n for (const auto& pos : uncovered_onis) {\n if (pos.second == j) {\n oni_in_col.push_back(pos);\n }\n }\n if (oni_in_col.size() < 2) continue;\n \n // Find min and max row indices for Oni in this column\n int i_min = N, i_max = -1;\n for (const auto& pos : oni_in_col) {\n i_min = min(i_min, pos.first);\n i_max = max(i_max, pos.first);\n }\n\n // Check Up group plan\n // To remove all Oni by shifting up, we need to shift i_max + 1 times\n if (is_path_clear(board, false, j, 0, i_max + 1)) {\n int group_cost = 2 * (i_max + 1);\n int individual_cost_sum = 0;\n for(const auto& pos : oni_in_col) {\n individual_cost_sum += best_individual_plans[pos].cost;\n }\n int savings = individual_cost_sum - group_cost;\n if (savings > best_savings) {\n best_savings = savings;\n sort(oni_in_col.begin(), oni_in_col.end()); // Sort for consistent output\n best_plan = {'U', j, group_cost, oni_in_col};\n found_improvement = true;\n }\n }\n\n // Check Down group plan\n // To remove all Oni by shifting down, we need to shift N - i_min times\n if (is_path_clear(board, false, j, i_min, N)) {\n int group_cost = 2 * (N - i_min);\n int individual_cost_sum = 0;\n for(const auto& pos : oni_in_col) {\n individual_cost_sum += best_individual_plans[pos].cost;\n }\n int savings = individual_cost_sum - group_cost;\n if (savings > best_savings) {\n best_savings = savings;\n sort(oni_in_col.begin(), oni_in_col.end()); // Sort for consistent output\n best_plan = {'D', j, group_cost, oni_in_col};\n found_improvement = true;\n }\n }\n }\n \n // If a beneficial plan was found, apply it and continue searching\n if (found_improvement) {\n final_group_plans.push_back(best_plan);\n for (const auto& pos : best_plan.oni_pos) {\n uncovered_onis.erase(pos);\n }\n } else {\n // No more improvements can be made\n break;\n }\n }\n\n // --- Phase 3: Output the final sequence of operations ---\n // First, output all selected group plans\n for (const auto& p : final_group_plans) {\n int shifts = p.cost / 2;\n for (int k = 0; k < shifts; ++k) {\n cout << p.dir << \" \" << p.idx << \"\\n\";\n }\n for (int k = 0; k < shifts; ++k) {\n cout << get_reverse_dir(p.dir) << \" \" << p.idx << \"\\n\";\n }\n }\n\n // Then, output individual plans for all remaining Oni\n for (const auto& pos : uncovered_onis) {\n const auto& p = best_individual_plans[pos];\n int shifts = p.cost / 2;\n for (int k = 0; k < shifts; ++k) {\n cout << p.dir << \" \" << p.idx << \"\\n\";\n }\n for (int k = 0; k < shifts; ++k) {\n cout << get_reverse_dir(p.dir) << \" \" << p.idx << \"\\n\";\n }\n }\n\n return 0;\n}","ahc044":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 100;\n long long L = 500000;\n vector T(N);\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector> sorted_T;\n for (int i = 0; i < N; ++i) {\n sorted_T.emplace_back(T[i], i);\n }\n sort(sorted_T.rbegin(), sorted_T.rend());\n\n // Dynamically select K based on the distribution of targets\n int K = 30;\n for (int i = 0; i < N; ++i) {\n if (sorted_T[i].first < 800) {\n K = min(100, max(35, i + 35));\n break;\n }\n }\n\n vector a(N), b(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n\n // Top K employees transition among themselves in a balanced way with controlled randomness\n for (int i = 0; i < K; ++i) {\n int emp = sorted_T[i].second;\n if (i < K / 3) {\n a[emp] = sorted_T[(i + 1) % K].second;\n b[emp] = sorted_T[(i + 2) % K].second;\n } else if (i < 2 * K / 3) {\n a[emp] = sorted_T[(i + 3) % K].second;\n b[emp] = sorted_T[(i + 4) % K].second;\n } else {\n // Introduce controlled randomness for lower top employees\n uniform_int_distribution dist(0, K - 1);\n a[emp] = sorted_T[dist(rng)].second;\n b[emp] = sorted_T[dist(rng)].second;\n }\n }\n\n // Other employees transition to top employees based on their target proportions\n for (int i = K; i < N; ++i) {\n int emp = sorted_T[i].second;\n long long remaining_target = T[emp];\n int chosen_top = 0;\n long long max_ratio = 0;\n for (int j = 0; j < K; ++j) {\n int top_emp = sorted_T[j].second;\n long long ratio = T[top_emp] * (K - j) * (K - j) * (K - j) * (K - j) * (K - j) + (K - j) * (K - j) * (K - j); // Hybrid heuristic\n if (ratio > max_ratio) {\n max_ratio = ratio;\n chosen_top = top_emp;\n }\n }\n a[emp] = chosen_top;\n // Alternate transition with controlled randomness\n if (i % 3 == 0) {\n b[emp] = sorted_T[i % K].second;\n } else if (i % 3 == 1) {\n uniform_int_distribution dist(0, K / 2 - 1);\n b[emp] = sorted_T[dist(rng)].second;\n } else {\n uniform_int_distribution dist(K / 2, K - 1);\n b[emp] = sorted_T[dist(rng)].second;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << a[i] << \" \" << b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\nusing namespace atcoder;\n\nstruct City {\n int idx;\n double x, y;\n int lx, rx, ly, ry;\n};\n\nvector> dist;\nvector> query_count;\n\ndouble euclidean_dist(const City& a, const City& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\nvector> query_mst(const vector& cities) {\n cout << \"? \" << cities.size();\n for (int c : cities) cout << \" \" << c;\n cout << endl;\n cout.flush();\n \n vector> edges;\n for (int i = 0; i < (int)cities.size() - 1; i++) {\n int u, v;\n cin >> u >> v;\n edges.emplace_back(u, v);\n }\n return edges;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector cities(N);\n for (int i = 0; i < N; i++) {\n cities[i].idx = i;\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].x = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].y = (cities[i].ly + cities[i].ry) / 2.0;\n }\n \n dist.assign(N, vector(N, 1e9));\n query_count.assign(N, vector(N, 0));\n \n // Initialize with centroid distances\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n dist[i][j] = dist[j][i] = euclidean_dist(cities[i], cities[j]);\n }\n }\n \n int queries_used = 0;\n \n // Strategy 1: Query cities sorted by proximity to get accurate distances\n // Sort cities by coordinates\n vector city_order(N);\n iota(city_order.begin(), city_order.end(), 0);\n sort(city_order.begin(), city_order.end(), [&](int a, int b) {\n return cities[a].x < cities[b].x || \n (abs(cities[a].x - cities[b].x) < 1e-6 && cities[a].y < cities[b].y);\n });\n \n // Query consecutive cities in sorted order (they're likely to be close)\n for (int i = 0; i < N && queries_used < Q / 2; i += L/2) {\n vector batch;\n for (int j = i; j < min(N, i + L); j++) {\n batch.push_back(city_order[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Strategy 2: Query cities sorted by y-coordinate\n vector city_order_y(N);\n iota(city_order_y.begin(), city_order_y.end(), 0);\n sort(city_order_y.begin(), city_order_y.end(), [&](int a, int b) {\n return cities[a].y < cities[b].y || \n (abs(cities[a].y - cities[b].y) < 1e-6 && cities[a].x < cities[b].x);\n });\n \n for (int i = 0; i < N && queries_used < Q * 3 / 4; i += L/2) {\n vector batch;\n for (int j = i; j < min(N, i + L); j++) {\n batch.push_back(city_order_y[j]);\n }\n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Strategy 3: Use remaining queries for random pairs to explore\n mt19937 rng(12345);\n while (queries_used < Q) {\n vector batch;\n set used;\n \n // Select random cities\n while (batch.size() < L && used.size() < N) {\n int c = rng() % N;\n if (used.insert(c).second) {\n batch.push_back(c);\n }\n }\n \n if (batch.size() >= 2) {\n auto mst_edges = query_mst(batch);\n \n for (auto [u, v] : mst_edges) {\n double actual_dist = floor(sqrt(\n (cities[u].x - cities[v].x) * (cities[u].x - cities[v].x) +\n (cities[u].y - cities[v].y) * (cities[u].y - cities[v].y)\n ));\n dist[u][v] = dist[v][u] = actual_dist;\n query_count[u][v]++;\n query_count[v][u]++;\n }\n queries_used++;\n }\n }\n \n // Final group assignment using improved distances\n vector assigned(N, false);\n vector> final_groups(M);\n vector>> final_edges(M);\n \n // Sort groups by size (largest first for better connectivity)\n vector> group_sizes;\n for (int i = 0; i < M; i++) group_sizes.emplace_back(G[i], i);\n sort(group_sizes.rbegin(), group_sizes.rend());\n \n for (auto [size, group_id] : group_sizes) {\n if (size == 0) continue;\n \n // Find best unassigned city as seed (one with many close neighbors)\n int seed = -1;\n double seed_score = -1;\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n double score = 0;\n int close_count = 0;\n for (int j = 0; j < N; j++) {\n if (!assigned[j] && i != j) {\n if (dist[i][j] < 1000) { // Reasonable distance threshold\n score += 1.0 / (dist[i][j] + 1);\n close_count++;\n }\n }\n }\n if (close_count > 0 && score > seed_score) {\n seed_score = score;\n seed = i;\n }\n }\n }\n \n // If no good seed found, pick any unassigned city\n if (seed == -1) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n seed = i;\n break;\n }\n }\n }\n \n final_groups[group_id].push_back(seed);\n assigned[seed] = true;\n \n // Grow group using Prim's algorithm\n vector in_group(N, false);\n in_group[seed] = true;\n \n while ((int)final_groups[group_id].size() < size) {\n int best_city = -1;\n double best_dist = 1e9;\n int best_from = -1;\n \n for (int u : final_groups[group_id]) {\n for (int v = 0; v < N; v++) {\n if (!assigned[v] && !in_group[v]) {\n if (dist[u][v] < best_dist) {\n best_dist = dist[u][v];\n best_city = v;\n best_from = u;\n }\n }\n }\n }\n \n if (best_city == -1) {\n // No more cities reachable, pick any unassigned\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n best_city = i;\n best_from = final_groups[group_id][0];\n break;\n }\n }\n }\n \n if (best_city != -1) {\n final_groups[group_id].push_back(best_city);\n in_group[best_city] = true;\n assigned[best_city] = true;\n } else {\n break;\n }\n }\n \n // Safety check: ensure group has correct size\n while ((int)final_groups[group_id].size() < size) {\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n final_groups[group_id].push_back(i);\n assigned[i] = true;\n break;\n }\n }\n }\n }\n \n // Build MST within each group\n for (int g = 0; g < M; g++) {\n if (final_groups[g].size() <= 1) continue;\n \n // Use Prim's algorithm for MST to avoid sorting O(n^2) edges\n vector> mst_edges;\n vector in_mst(N, false);\n vector min_edge(N, 1e9);\n vector parent(N, -1);\n \n // Start from first city in group\n int start = final_groups[g][0];\n min_edge[start] = 0;\n \n for (int iter = 0; iter < (int)final_groups[g].size(); iter++) {\n int u = -1;\n for (int city : final_groups[g]) {\n if (!in_mst[city] && (u == -1 || min_edge[city] < min_edge[u])) {\n u = city;\n }\n }\n \n if (u == -1) break;\n \n in_mst[u] = true;\n \n if (parent[u] != -1) {\n mst_edges.emplace_back(parent[u], u);\n }\n \n for (int v : final_groups[g]) {\n if (!in_mst[v] && dist[u][v] < min_edge[v]) {\n min_edge[v] = dist[u][v];\n parent[v] = u;\n }\n }\n }\n \n final_edges[g] = mst_edges;\n }\n \n // Output answer\n cout << \"!\" << endl;\n for (int g = 0; g < M; g++) {\n for (int c : final_groups[g]) {\n cout << c << \" \";\n }\n cout << endl;\n for (auto [u, v] : final_edges[g]) {\n cout << u << \" \" << v << endl;\n }\n }\n \n return 0;\n}","ahc046":"#include \nusing namespace std;\n\n// N and M are fixed by the problem statement, so we can use the literals directly.\n// N = 20, M = 40\n\nstruct Pos {\n int r, c;\n int id() const { return r * 20 + c; } // N is 20\n static Pos from_id(int id) { return {id / 20, id % 20}; } // N is 20\n};\n\n// BFS that returns a shortest sequence of actions from src to dst\nvector> bfs_path(Pos src, Pos dst) {\n const int SZ = 20 * 20; // N*N\n vector dist(SZ, -1);\n vector parent(SZ, -1);\n vector act(SZ), dir(SZ); // action and direction that lead to this vertex\n\n queue q;\n int s_id = src.id();\n dist[s_id] = 0;\n q.push(s_id);\n\n while (!q.empty()) {\n int cur_id = q.front(); q.pop();\n Pos cur = Pos::from_id(cur_id);\n if (cur_id == dst.id()) break;\n\n // ----- Move -----\n const int dr[4] = {-1, 1, 0, 0};\n const int dc[4] = {0, 0, -1, 1};\n const char mdir[4] = {'U', 'D', 'L', 'R'};\n for (int k = 0; k < 4; ++k) {\n int nr = cur.r + dr[k];\n int nc = cur.c + dc[k];\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) continue; // N is 20\n int nid = nr * 20 + nc; // N is 20\n if (dist[nid] != -1) continue;\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'M';\n dir[nid] = mdir[k];\n q.push(nid);\n }\n\n // ----- Slide -----\n // slide up\n if (cur.r > 0) {\n int nid = 0 * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'U';\n q.push(nid);\n }\n }\n // slide down\n if (cur.r < 20-1) { // N is 20\n int nid = (20-1) * 20 + cur.c; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'D';\n q.push(nid);\n }\n }\n // slide left\n if (cur.c > 0) {\n int nid = cur.r * 20 + 0; // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'L';\n q.push(nid);\n }\n }\n // slide right\n if (cur.c < 20-1) { // N is 20\n int nid = cur.r * 20 + (20-1); // N is 20\n if (dist[nid] == -1) {\n dist[nid] = dist[cur_id] + 1;\n parent[nid] = cur_id;\n act[nid] = 'S';\n dir[nid] = 'R';\n q.push(nid);\n }\n }\n }\n\n // reconstruct path\n vector> path;\n int cur_id = dst.id();\n while (cur_id != s_id) {\n path.emplace_back(act[cur_id], dir[cur_id]);\n cur_id = parent[cur_id];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // N and M are fixed (20, 40). Read them into dummy variables to consume the first line.\n int n_read, m_read;\n if (!(cin >> n_read >> m_read)) {\n return 0;\n }\n \n // M is 40\n const int M = 40;\n vector pts(M);\n for (int i = 0; i < M; ++i) {\n cin >> pts[i].r >> pts[i].c;\n }\n\n vector> answer;\n Pos cur = pts[0];\n for (int i = 1; i < M; ++i) {\n Pos nxt = pts[i];\n auto seg = bfs_path(cur, nxt);\n answer.insert(answer.end(), seg.begin(), seg.end());\n cur = nxt;\n }\n\n // safety check (should always hold)\n // Limit is 2 * N * M = 2 * 20 * 40 = 1600\n if ((int)answer.size() > 2 * 20 * 40) {\n answer.resize(2 * 20 * 40);\n }\n\n for (auto [a, d] : answer) {\n cout << a << ' ' << d << '\\n';\n }\n return 0;\n}"}}}