{"model_name":"qwen3.5-flash","codes":{"1":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Company {\n int id, x, y, r, a, b, c, d;\n \n long long area() const {\n return max(0LL, (long long)(c - a)) * max(0LL, (long long)(d - b));\n }\n \n bool containsPoint() const {\n return a <= x && x < c && b <= y && y < d;\n }\n};\n\nint n;\nvector companies;\nconst int GRID = 10000;\n\ndouble calculateScore(const vector& com) {\n double total = 0.0;\n for (const auto& c : com) {\n long long s = c.area();\n if (s <= 0 || !c.containsPoint()) continue;\n double ratio = min(c.r, s) / max((double)c.r, s);\n total += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return total;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n companies.resize(n);\n \n for (int i = 0; i < n; i++) {\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n companies[i].id = i;\n }\n \n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n // Initial placement - center around point (x, y)\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n long long target = c.r;\n long long w = max(1LL, (long long)sqrt(target * 2.0));\n long long h = max(1LL, target / w + 1LL);\n \n int a = max(0, min(c.x, c.x - (int)w / 2));\n int c_pos = min(GRID, max(c.x + 1, a + (int)w));\n int b = max(0, min(c.y, c.y - (int)h / 2));\n int d = min(GRID, max(c.y + 1, b + (int)h));\n \n c.a = a;\n c.b = b;\n c.c = c_pos;\n c.d = d;\n }\n \n long long initialScore = calculateScore(companies);\n \n // Simulated annealing optimization\n int iters = 200000;\n double temp = 2.0;\n \n for (int iter = 0; iter < iters; iter++) {\n int idx = uniform_int_distribution(0, n - 1)(rng);\n Company r = companies[idx];\n \n vector> candidates;\n candidates.emplace_back(r.a, r.b);\n \n // Try shifted positions\n for (int da = -50; da <= 50; da += 10) {\n for (int db = -50; db <= 50; db += 10) {\n int a = max(0, min(r.c - r.a, r.a + da));\n int b = max(0, min(r.d - r.b, r.b + db));\n candidates.emplace_back(a, b);\n }\n }\n \n // Try area optimization\n for (int w = max(1, (int)sqrt(r.r / 10)); w < 100; w++) {\n int h = max(1, r.r / w + 1);\n int a = max(0, min(r.x, r.x - w / 2));\n int b = max(0, min(r.y, r.y - h / 2));\n candidates.emplace_back(a, b);\n }\n \n int bestA = r.a, bestB = r.b;\n double bestNewScore = calculateScore(companies);\n \n for (auto [da, db] : candidates) {\n Company newR = r;\n newR.a = max(0, da);\n newR.b = max(0, db);\n \n // Keep same dimensions\n newR.c = max(newR.a + (r.c - r.a), newR.a + 1);\n newR.d = max(newR.b + (r.d - r.b), newR.b + 1);\n newR.c = min(GRID, newR.c);\n newR.d = min(GRID, newR.d);\n \n if (newR.containsPoint()) {\n companies[idx] = newR;\n double newScore = calculateScore(companies);\n if (newScore > bestNewScore) {\n bestNewScore = newScore;\n bestA = newR.a;\n bestB = newR.b;\n }\n companies[idx] = r;\n }\n }\n \n companies[idx].a = bestA;\n companies[idx].b = bestB;\n \n if (uniform_real_distribution(0, 1)(rng) > temp / 100.0) {\n companies[idx] = r; // Revert with probability\n }\n \n temp *= 0.997;\n }\n \n // Final check - all points must be contained\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n if (!c.containsPoint()) {\n long long w = max(1LL, c.r);\n long long h = max(1LL, c.r / w + 1LL);\n \n c.a = max(0, c.x);\n c.c = min(GRID, max(c.x + 1, c.a + (int)w));\n c.b = max(0, c.y);\n c.d = min(GRID, max(c.y + 1, c.b + (int)h));\n }\n }\n \n for (int i = 0; i < n; i++) {\n cout << companies[i].a << \" \" << companies[i].b << \" \" \n << companies[i].c << \" \" << companies[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int DX[] = {-1, 1, 0, 0};\nconst int DY[] = {0, 0, -1, 1};\n\nstruct Solver {\n int H = 50, W = 50;\n int si, sj;\n vector> p; // Values\n vector> tile; // Tile IDs\n \n // Path state\n vector> path;\n vector tile_used;\n int current_score;\n int best_score;\n vector> best_path;\n \n mt19937 rng;\n\n Solver() : rng(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count()) {\n p.resize(H, vector(W));\n tile.resize(H, vector(W));\n }\n\n void read_input() {\n cin >> si >> sj;\n int max_id = 0;\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> tile[i][j];\n if (tile[i][j] > max_id) max_id = tile[i][j];\n }\n }\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> p[i][j];\n }\n }\n tile_used.resize(max_id + 1, false);\n }\n\n void init_path() {\n path.clear();\n path.push_back({si, sj});\n current_score = p[si][sj];\n tile_used.assign(tile_used.size(), false);\n tile_used[tile[si][sj]] = true;\n best_path = path;\n best_score = current_score;\n }\n\n bool is_valid(int r, int c) {\n return r >= 0 && r < H && c >= 0 && c < W;\n }\n\n // Find neighbors of current path end\n void get_neighbors(const pair& curr, vector>& neighbors, vector& scores) {\n neighbors.clear();\n scores.clear();\n for (int d = 0; d < 4; ++d) {\n int nr = curr.first + DX[d];\n int nc = curr.second + DY[d];\n if (is_valid(nr, nc)) {\n int tid = tile[nr][nc];\n if (!tile_used[tid]) {\n neighbors.push_back({nr, nc});\n scores.push_back(p[nr][nc]);\n }\n }\n }\n }\n\n void run() {\n read_input();\n init_path();\n \n auto start_time = chrono::high_resolution_clock::now();\n \n int step_counter = 0;\n int max_steps = 600000; // Sufficient iterations for 2.0s limit\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n auto elapsed = chrono::duration_cast(now - start_time).count();\n \n if (elapsed > 1800) break; // Time limit 1.8s\n if (step_counter++ > max_steps) break;\n\n auto [curr_r, curr_c] = path.back();\n vector> neighbors;\n vector scores;\n get_neighbors({curr_r, curr_c}, neighbors, scores);\n\n if (!neighbors.empty()) {\n int n_count = neighbors.size();\n int select_idx = 0;\n \n // Pick top K neighbors by score\n int k = min(3, n_count);\n vector sorted_indices(n_count);\n for(int i=0; i scores[b];\n });\n\n // 70% chance greedy (best), 30% chance random from top K\n if (rng() % 100 < 70) {\n select_idx = sorted_indices[0];\n } else {\n select_idx = sorted_indices[rng() % k];\n }\n\n int nr = neighbors[select_idx].first;\n int nc = neighbors[select_idx].second;\n int nt = tile[nr][nc];\n int val = p[nr][nc];\n\n path.push_back({nr, nc});\n tile_used[nt] = true;\n current_score += val;\n\n if (current_score > best_score) {\n best_score = current_score;\n best_path = path;\n }\n } else {\n // Stuck: Backtrack\n if (path.size() >= 2) {\n auto [r, c] = path.back();\n int tid = tile[r][c];\n path.pop_back();\n current_score -= p[r][c];\n tile_used[tid] = false;\n } else {\n // Path too short, restart\n init_path();\n }\n }\n }\n\n // Construct output string\n string result = \"\";\n for (size_t i = 1; i < best_path.size(); ++i) {\n int dr = best_path[i].first - best_path[i-1].first;\n int dc = best_path[i].second - best_path[i-1].second;\n if (dr == -1) result += 'U';\n else if (dr == 1) result += 'D';\n else if (dc == -1) result += 'L';\n else if (dc == 1) result += 'R';\n }\n cout << result << endl;\n }\n};\n\nint main() {\n Solver solver;\n solver.run();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Edge weights: h_edges[i][j] = horizontal edge at (i,j)-(i,j+1)\n// v_edges[i][j] = vertical edge at (i,j)-(i+1,j)\n// Initialized to ~1000-2000 (matches problem's expected range)\nvector> h_edges(29, vector(30, 1500.0));\nvector> v_edges(29, vector(30, 1500.0));\n\nstruct Node {\n int pos;\n double dist;\n bool operator>(const Node& other) const {\n return dist > other.dist;\n }\n};\n\nstruct Result {\n string path;\n double predicted_length;\n bool valid;\n};\n\nResult find_shortest_path(int si, int sj, int ti, int tj,\n const vector>& h, \n const vector>& v) {\n int n = 30;\n int total = n * n;\n vector dist(total, 1e18);\n vector parent(total, -1);\n vector dir(total, 0);\n \n priority_queue, greater> pq;\n \n dist[si * n + sj] = 0.0;\n pq.push({si * n + sj, 0.0});\n \n while (!pq.empty()) {\n Node top = pq.top();\n pq.pop();\n \n int u = top.pos;\n if (top.dist > dist[u]) continue;\n \n int ui = u / n;\n int uj = u % n;\n \n if (ui == ti && uj == tj) break;\n \n // Move U (up): from (ui,uj) to (ui-1,uj), uses v[ui-1][uj]\n if (ui > 0) {\n int v_pos = (ui - 1) * n + uj;\n double w = v[ui - 1][uj];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'U';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n \n // Move D (down): from (ui,uj) to (ui+1,uj), uses v[ui][uj]\n if (ui < n - 1) {\n int v_pos = (ui + 1) * n + uj;\n double w = v[ui][uj];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'D';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n \n // Move L (left): from (ui,uj) to (ui,uj-1), uses h[ui][uj-1]\n if (uj > 0) {\n int v_pos = ui * n + (uj - 1);\n double w = h[ui][uj - 1];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'L';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n \n // Move R (right): from (ui,uj) to (ui,uj+1), uses h[ui][uj]\n if (uj < n - 1) {\n int v_pos = ui * n + (uj + 1);\n double w = h[ui][uj];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'R';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n }\n \n if (dist[ti * n + tj] >= 1e17) {\n return {\"\", 0.0, false};\n }\n \n string path;\n int curr = ti * n + tj;\n while (curr != si * n + sj) {\n path += dir[curr];\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n \n return {path, dist[ti * n + tj], true};\n}\n\nvoid update_edge_weights(int si, int sj, int ti, int tj,\n const string& path, \n double predicted, int actual,\n vector>& h, \n vector>& v) {\n if (path.empty()) return;\n \n double error = (double)actual - predicted;\n int num_edges = path.length();\n double alpha = 0.18; // Learning rate (balanced for noisy data)\n double update = error * alpha / num_edges;\n \n int i = si, j = sj;\n int n = 30;\n \n for (char c : path) {\n if (c == 'U') {\n // Moved from (i,j) to (i-1,j), used v[i-1][j]\n if (i > 0 && i < n) {\n v[i - 1][j] += update;\n v[i - 1][j] = max(100.0, v[i - 1][j]);\n v[i - 1][j] = min(10000.0, v[i - 1][j]);\n }\n i--;\n } else if (c == 'D') {\n // Moved from (i,j) to (i+1,j), used v[i][j]\n if (i >= 0 && i < n) {\n v[i][j] += update;\n v[i][j] = max(100.0, v[i][j]);\n v[i][j] = min(10000.0, v[i][j]);\n }\n i++;\n } else if (c == 'L') {\n // Moved from (i,j) to (i,j-1), used h[i][j-1]\n if (j > 0 && j < n && i >= 0 && i < n) {\n h[i][j - 1] += update;\n h[i][j - 1] = max(100.0, h[i][j - 1]);\n h[i][j - 1] = min(10000.0, h[i][j - 1]);\n }\n j--;\n } else if (c == 'R') {\n // Moved from (i,j) to (i,j+1), used h[i][j]\n if (j >= 0 && j < n && i >= 0 && i < n) {\n h[i][j] += update;\n h[i][j] = max(100.0, h[i][j]);\n h[i][j] = min(10000.0, h[i][j]);\n }\n j++;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n int feedback;\n \n for (int k = 0; k < 1000; k++) {\n if (!(cin >> si >> sj >> ti >> tj)) break;\n \n Result result = find_shortest_path(si, sj, ti, tj, h_edges, v_edges);\n \n if (!result.valid) {\n // Fallback: should not happen on connected grid\n cout << \"UUUUUUUUU\\n\";\n cout.flush();\n cin >> feedback;\n continue;\n }\n \n cout << result.path << \"\\n\";\n cout.flush();\n \n cin >> feedback;\n \n update_edge_weights(si, sj, ti, tj, result.path,\n result.predicted_length, feedback,\n h_edges, v_edges);\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 20;\nconst int MAXM = 805;\n\nint M;\nstring s[MAXM];\nint len[MAXM];\nchar grid[N][N];\n\n// miscount[i][r][c][dir]\n// i: string index (0..M-1)\n// r, c: start position (row for horiz, col for vert)\n// dir: 0 horizontal, 1 vertical\n// The mismatch count for the placement starting at (r,c) with direction dir\nint miscount[MAXM][N][N][2];\n\n// sat_placements[i]: number of placements for string i that have 0 mismatches\nint sat_placements[MAXM];\nint total_satisfied; // Number of strings with at least 1 satisfied placement (sat_placements[i] > 0)\n\nint current_dots;\n\n// Apply a change of grid[r][c] from old_char to new_char\n// This function updates the global state: grid, current_dots, miscount, sat_placements, total_satisfied\nvoid apply_change(int r, int c, char old_char, char new_char) {\n if(new_char == '.' && old_char != '.') current_dots++;\n else if(new_char != '.' && old_char == '.') current_dots--;\n\n grid[r][c] = new_char;\n\n for(int i=0; i 0) {\n sat_placements[i]--;\n if(sat_placements[i] == 0) total_satisfied--;\n } else if(old_mc > 0 && new_mc == 0) {\n sat_placements[i]++;\n if(sat_placements[i] == 1) total_satisfied++;\n }\n }\n \n // Vertical placements covering (r, c)\n // Vertical placement starts at (start_v, c).\n for(int delta=0; delta 0) {\n sat_placements[i]--;\n if(sat_placements[i] == 0) total_satisfied--;\n } else if(old_mc > 0 && new_mc == 0) {\n sat_placements[i]++;\n if(sat_placements[i] == 1) total_satisfied++;\n }\n }\n }\n}\n\nint get_score() {\n int c = total_satisfied;\n // Score logic: prioritize c (max 10^8). If c=M, score depends on d (max 2*10^8).\n // We use a weight of 10000 for c to separate levels, and maximize d if c=M.\n int score = c * 10000;\n if(c == M) score += current_dots;\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n for(int i=0; i> s[i];\n len[i] = s[i].length();\n }\n\n // Initialize RNG\n mt19937 rng(time(0));\n \n // Initialize grid with random A-H\n current_dots = 0;\n for(int i=0; i 0) total_satisfied++;\n\n int best_score = get_score();\n char best_grid[N][N];\n for(int i=0; i 0) accept = true;\n else {\n double prob = exp(delta / T);\n double r_val = (double)rng() / (double)numeric_limits::max();\n if(r_val < prob) accept = true;\n }\n\n if(accept) {\n if(next_score > best_score) {\n best_score = next_score;\n for(int i=0; i\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\nint N;\nvector grid;\nint si, sj;\nvector> road_squares;\nchar dirs[] = {'U', 'D', 'L', 'R'};\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\n\nbool isValid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N && grid[r][c] != '#';\n}\n\nint bfs(int fr, int fc, int tr, int tc, string& path) {\n if (fr == tr && fc == tc) {\n path = \"\";\n return 0;\n }\n \n map, int> dist;\n priority_queue, vector>, greater>> pq;\n \n pq.push({0, fr, fc});\n dist[{fr, fc}] = 0;\n \n while (!pq.empty()) {\n auto [d, r, c] = pq.top();\n pq.pop();\n \n if (d > dist[{r, c}]) continue;\n \n if (r == tr && c == tc) {\n // Reconstruct path (simplified)\n return d;\n }\n \n for (int k = 0; k < 4; k++) {\n int nr = r + di[k];\n int nc = c + dj[k];\n \n if (!isValid(nr, nc)) continue;\n \n int cost = grid[nr][nc] - '0';\n int new_dist = d + cost;\n \n if (dist.find({nr, nc}) == dist.end() || new_dist < dist[{nr, nc}]) {\n dist[{nr, nc}] = new_dist;\n pq.push({new_dist, nr, nc});\n }\n }\n }\n \n return INT_MAX;\n}\n\n// Check visibility\nbool isVisible(int fr, int fc, int tr, int tc) {\n if (fr == tr) {\n int min_c = min(fc, tc), max_c = max(fc, tc);\n for (int c = min_c; c <= max_c; c++) {\n if (grid[fr][c] == '#') return false;\n }\n return true;\n } else if (fc == tc) {\n int min_r = min(fr, tr), max_r = max(fr, tr);\n for (int r = min_r; r <= max_r; r++) {\n if (grid[r][fc] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\nint getVisibilityCount(int r, int c) {\n int cnt = 0;\n for (auto& sq : road_squares) {\n if (isVisible(r, c, sq.first, sq.second)) cnt++;\n }\n return cnt;\n}\n\nint getTotalCost(const string& path) {\n int cr = si, cc = sj, cost = 0;\n for (char d : path) {\n for (int k = 0; k < 4; k++) {\n if (dirs[k] == d) {\n int nr = cr + di[k], nc = cc + dj[k];\n cost += grid[nr][nc] - '0';\n cr = nr, cc = nc;\n break;\n }\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> si >> sj;\n grid.resize(N);\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 road_squares.push_back({i, j});\n }\n }\n }\n \n string path = \"\";\n set> covered;\n auto addVisibility = [&](int r, int c) {\n for (auto& sq : road_squares) {\n if (isVisible(r, c, sq.first, sq.second)) {\n covered.insert(sq);\n }\n }\n };\n \n addVisibility(si, sj);\n \n // Greedy path building\n int cr = si, cc = sj;\n int max_iter = road_squares.size() * 2;\n \n for (int iter = 0; iter < max_iter; iter++) {\n int best_dist = INT_MAX;\n int best_r = -1, best_c = -1;\n pair best_sq = {-1, -1};\n \n // Score each unvisited square\n for (auto& sq : road_squares) {\n if (covered.count(sq)) continue;\n \n // Calculate visibility gain\n int visibility_gain = 0;\n for (auto& other : road_squares) {\n if (!covered.count(other) && isVisible(sq.first, sq.second, other.first, other.second)) {\n visibility_gain++;\n }\n }\n \n // Use BFS for distance (simplified)\n string test_path;\n int dist = bfs(cr, cc, sq.first, sq.second, test_path);\n \n if (dist < INT_MAX && visibility_gain > 0) {\n int score = visibility_gain * 100 - dist;\n if (score > 0 && (best_dist == INT_MAX || dist < best_dist)) {\n best_dist = dist;\n best_r = sq.first;\n best_c = sq.second;\n best_sq = sq;\n }\n }\n \n // Also consider squares that complete visibility\n if (visibility_gain == 0 && !covered.count(sq)) {\n for (auto& other : road_squares) {\n if (isVisible(sq.first, sq.second, other.first, other.second) && !covered.count(other)) {\n int d_test = bfs(cr, cc, sq.first, sq.second, test_path);\n if (d_test < INT_MAX && d_test > 0) {\n int d = d_test;\n if (best_dist == INT_MAX || d < best_dist * (covered.size() > 0 ? covered.size() : 1)) {\n best_dist = d;\n best_r = sq.first;\n best_c = sq.second;\n best_sq = sq;\n }\n }\n }\n }\n }\n }\n \n if (best_r != -1) {\n string segment;\n bfs(cr, cc, best_r, best_c, segment);\n path += segment;\n cr = best_r;\n cc = best_c;\n addVisibility(cr, cc);\n } else {\n break;\n }\n }\n \n // Return to start\n string ret_path;\n bfs(cr, cc, si, sj, ret_path);\n path += ret_path;\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\nusing namespace std;\n\nconst int MAXN = 1005;\nconst int MAXM = 25;\nconst int MAXK = 25;\n\nstruct Task {\n int id;\n vector d;\n vector dependencies;\n int status = -1; // -1: not started, 0: started, 1: completed\n int start_day = 0;\n int assigned_member = -1;\n vector predicted_completion_times;\n double expected_days = 1.0;\n};\n\nstruct Member {\n int id;\n vector prediction;\n int status = 0; // 0: free, >0: busy until this day\n int current_task = -1;\n vector> historical_completions; // {task_diff_score, actual_days}\n double skill_variance[MAXK];\n};\n\nint N, M, K, R;\nTask tasks[MAXN];\nMember members[MAXM];\nint day_count = 0;\n\nint calculate_difficulty(const vector& d) {\n int diff = 0;\n for (int val : d) diff += val;\n return diff;\n}\n\nint calculate_skill_gap(const vector& s, const vector& d) {\n int gap = 0;\n for (int k = 0; k < K; k++) {\n gap += max(0, d[k] - s[k]);\n }\n return gap;\n}\n\nbool can_start_task(int task_id) {\n for (int dep : tasks[task_id].dependencies) {\n if (tasks[dep].status != 1) return false;\n }\n return true;\n}\n\nbool all_tasks_completed() {\n for (int i = 0; i < N; i++) {\n if (tasks[i].status != 1) return false;\n }\n return true;\n}\n\nvoid update_skill_estimation(int member_id, int task_id, int days_taken) {\n auto& member = members[member_id];\n auto& task = tasks[task_id];\n \n // Store historical performance\n int difficulty = calculate_difficulty(task.d);\n member.historical_completions.push_back({difficulty, days_taken});\n \n // Simple estimation: try to reverse-engineer skill levels\n // If task took longer, member might have lower skill\n // For simplicity, we'll adjust prediction based on difficulty vs time\n if (member.prediction.empty()) {\n member.prediction.resize(K, 0);\n }\n \n // Use linear regression-like update\n for (int k = 0; k < K; k++) {\n int required = task.d[k];\n // More sophisticated would track per-skill, but we'll keep it simple\n double avg_time = member.historical_completions.back().second;\n double diff = task.d[k] - member.prediction[k];\n \n // Adjust prediction: if actual difficulty is higher, estimate lower skill\n if (avg_time > 1.0 && member.prediction[k] > 0) {\n member.prediction[k] = max(0, (int)(member.prediction[k] * 0.95 - 1));\n }\n }\n \n // Track skill variance for confidence\n for (int k = 0; k < K; k++) {\n member.skill_variance[k] *= 0.9; // Decay old estimates\n }\n}\n\ndouble evaluate_assignment(int member_id, int task_id) {\n auto& member = members[member_id];\n auto& task = tasks[task_id];\n \n if (member.prediction.empty()) {\n // No history, use difficulty heuristic\n return calculate_difficulty(task.d);\n }\n \n int gap = calculate_skill_gap(member.prediction, task.d);\n \n // Expected time based on gap\n double expected_time = max(1.0, (double)(gap + 1));\n \n // If prediction is uncertain, add penalty\n double uncertainty_penalty = 0;\n for (int k = 0; k < K; k++) {\n uncertainty_penalty += member.skill_variance[k];\n }\n \n return expected_time + uncertainty_penalty;\n}\n\nint count_outstanding_dependencies(int task_id) {\n int count = 0;\n for (int dep : tasks[task_id].dependencies) {\n if (tasks[dep].status != 1) count++;\n }\n return count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> M >> K >> R;\n \n // Read task difficulties\n for (int i = 0; i < N; i++) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; k++) {\n cin >> tasks[i].d[k];\n }\n }\n \n // Read dependencies\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].dependencies.push_back(u);\n }\n \n // Initialize members\n for (int i = 0; i < M; i++) {\n members[i].id = i;\n members[i].prediction.resize(K, 1); // Assume minimal skill initially\n for (int k = 0; k < K; k++) {\n members[i].skill_variance[k] = 10.0;\n }\n }\n \n vector completed_members;\n \n while (true) {\n day_count++;\n \n // Find assignable tasks\n vector assignable;\n for (int i = 0; i < N; i++) {\n if (tasks[i].status == -1 && can_start_task(i)) {\n assignable.push_back(i);\n }\n }\n \n // Sort by heuristic: dependency count, then difficulty, then predicted time\n sort(assignable.begin(), assignable.end(), [](int a, int b) {\n int dep_a = count_outstanding_dependencies(a);\n int dep_b = count_outstanding_dependencies(b);\n if (dep_a != dep_b) return dep_a < dep_b;\n \n int diff_a = calculate_difficulty(tasks[a].d);\n int diff_b = calculate_difficulty(tasks[b].d);\n if (diff_a != diff_b) return diff_a < diff_b;\n \n // Prefer tasks with lower expected time for current team\n return diff_a < diff_b; // Simplified\n });\n \n // Find free members\n vector free_members;\n for (int i = 0; i < M; i++) {\n if (members[i].status == 0) {\n free_members.push_back(i);\n }\n }\n \n // Output assignments\n vector> assignments;\n for (int m_idx = 0; m_idx < free_members.size() && m_idx < assignable.size(); m_idx++) {\n int member_id = free_members[m_idx];\n int task_id = assignable[m_idx];\n \n assignments.push_back({member_id, task_id});\n \n // Mark task as started\n tasks[task_id].status = 0;\n tasks[task_id].assigned_member = member_id;\n tasks[task_id].start_day = day_count;\n \n // Update member status\n members[member_id].status = 1;\n members[member_id].current_task = task_id;\n }\n \n // Output in required format\n cout << assignments.size();\n for (auto& assign : assignments) {\n cout << \" \" << (assign.first + 1) << \" \" << (assign.second + 1);\n }\n cout << endl;\n cout.flush();\n \n // Read completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n break;\n }\n \n completed_members.resize(n_completed);\n for (int i = 0; i < n_completed; i++) {\n cin >> completed_members[i];\n completed_members[i]--;\n }\n \n for (int member_id : completed_members) {\n int task_id = members[member_id].current_task;\n \n // Update task status\n tasks[task_id].status = 1;\n tasks[task_id].completion_day = day_count;\n \n // Update member status\n members[member_id].status = 0;\n \n // Update skill estimation\n int days_taken = day_count - tasks[task_id].start_day + 1;\n update_skill_estimation(member_id, task_id, days_taken);\n }\n \n // Visualize skill predictions (comment format)\n cout << flush;\n }\n \n return 0;\n}","ahc006":"```cpp\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global configuration\nconst int DEPOT_X = 400;\nconst int DEPOT_Y = 400;\nconst int N_ORDERS = 1000;\nconst int ORDERS_TO_SELECT = 50;\n\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nstruct Order {\n int id; \n int a, b; \n int c, d; \n double base_cost;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n vector orders(N_ORDERS);\n vector p(N_ORDERS);\n \n // Read input\n for (int i = 0; i < N_ORDERS; ++i) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i + 1; // 1-based\n orders[i].base_cost = (double)(dist(DEPOT_X, DEPOT_Y, orders[i].a, orders[i].b) +\n dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d) +\n dist(orders[i].c, orders[i].d, DEPOT_X, DEPOT_Y));\n p[i] = i;\n }\n \n // Sort orders by base cost to prioritize central clusters\n sort(p.begin(), p.end(), [&](int a, int b) {\n return orders[a].base_cost < orders[b].base_cost;\n });\n \n // Select a pool of candidates to search from (Top 80)\n int K = min(80, N_ORDERS);\n vector pool(K);\n for(int i = 0; i < K; ++i) pool[i] = p[i];\n \n // Initial subset: first 50 candidates\n vector subset;\n subset.reserve(ORDERS_TO_SELECT);\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) subset.push_back(pool[i]);\n \n vector best_subset = subset;\n int best_T = 2147483647;\n \n mt19937 rng(19991014); // Fixed seed\n \n // Structure to hold path coordinates\n struct PathData {\n vector> coords;\n vector path; \n int cost;\n };\n \n // Function to construct path and compute cost for a given subset\n PathData solve_subset_path(const vector& sub_set) {\n PathData res;\n res.path.reserve(102);\n \n // 0: Depot, 1..50: Pickups, 51..100: Deliveries\n res.coords.resize(101);\n res.coords[0] = {DEPOT_X, DEPOT_Y};\n \n for(int k = 0; k < ORDERS_TO_SELECT; ++k) {\n int idx = sub_set[k]; // index in 'orders'\n res.coords[k+1] = {orders[idx].a, orders[idx].b}; \n res.coords[k+51] = {orders[idx].c, orders[idx].d};\n }\n \n // Greedy Construction\n vector visited(101, false);\n vector pickup_done(50, false);\n res.path.push_back(0);\n int cx = DEPOT_X, cy = DEPOT_Y;\n \n for(int s = 0; s < 100; ++s) {\n int best_node = -1;\n int min_d = 2000000000;\n for(int node = 1; node <= 100; ++node) {\n if(!visited[node]) {\n if(node > 50) {\n int ord = node - 51;\n if(!pickup_done[ord]) continue;\n }\n int d = dist(cx, cy, res.coords[node].first, res.coords[node].second);\n if(d < min_d) { min_d = d; best_node = node; }\n }\n }\n if(best_node != -1) {\n visited[best_node] = true;\n res.path.push_back(best_node);\n cx = res.coords[best_node].first;\n cy = res.coords[best_node].second;\n if(best_node <= 50) pickup_done[best_node-1] = true;\n } else {\n break;\n }\n }\n res.path.push_back(0); // Return to Depot\n \n // Compute cost\n res.cost = 0;\n cx = DEPOT_X; cy = DEPOT_Y;\n for(size_t i = 0; i < res.path.size(); ++i) {\n cx = res.coords[res.path[i]].first; cy = res.coords[res.path[i]].second;\n if(i + 1 < res.path.size()) {\n int nx = res.coords[res.path[i+1]].first;\n int ny = res.coords[res.path[i+1]].second;\n res.cost += dist(cx, cy, nx, ny);\n }\n }\n \n return res;\n }\n \n // Function to optimize route given path (SA)\n void optimize_path(PathData& data) {\n int path_len = data.path.size();\n for(int iter = 0; iter < 20000; ++iter) {\n int i = rng() % (path_len - 1) + 1; \n int j = rng() % (path_len - 1) + 1;\n if(i == j) continue;\n \n int u = data.path[i];\n int v = data.path[j];\n \n // Validity check: If P and D of same order swapped\n if((u <= 50 && v == u + 50) || (v <= 50 && u == v + 50)) continue;\n \n data.path[i] = v;\n data.path[j] = u;\n \n // Check validity (P before D for all)\n bool valid = true;\n // Optimization: only check affected orders if possible, but O(N) check is safe enough\n for(int k = 1; k <= 50; ++k) {\n int P = k; int D = k+50;\n int posP = -1, posD = -1;\n for(int m = 0; m < path_len; ++m) {\n if(data.path[m] == P) posP = m;\n if(data.path[m] == D) posD = m;\n }\n if(posP > posD) { valid = false; break; }\n }\n \n if(valid) {\n int new_cost = 0;\n int cx = DEPOT_X, cy = DEPOT_Y;\n for(size_t m = 0; m < data.path.size() - 1; ++m) {\n cx = data.coords[data.path[m]].first;\n cy = data.coords[data.path[m]].second;\n int nx = data.coords[data.path[m+1]].first;\n int ny = data.coords[data.path[m+1]].second;\n new_cost += dist(cx, cy, nx, ny);\n }\n if(new_cost < data.cost) {\n data.cost = new_cost;\n } else {\n data.path[i] = u; \n data.path[j] = v;\n }\n } else {\n data.path[i] = u; \n data.path[j] = v;\n }\n }\n }\n \n // Iterate Subset Selection (Simulated Annealing / Hill Climbing)\n for(int iter = 0; iter < 1500; ++iter) {\n int i = rng() % 50;\n int j = rng() % (K - 50);\n int from_idx = subset[i];\n int to_idx = pool[50 + j];\n \n subset[i] = to_idx;\n \n PathData current_path_data = solve_subset_path(subset);\n optimize_path(current_path_data);\n \n if(current_path_data.cost < best_T) {\n best_T = current_path_data.cost;\n best_subset = subset;\n } else {\n subset[i] = from_idx; // Revert if not better\n }\n }\n \n // Final Optimization with best subset\n PathData final_path = solve_subset_path(best_subset);\n optimize_path(final_path);\n \n // Output\n cout << ORDERS_TO_SELECT << \" \";\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) {\n cout << orders[best_subset[i]].id << \" \";\n }\n cout << \"\\n102 \";\n for(int x : final_path.path) {\n int cx = final_path.coords[x].first;\n int cy = final_path.coords[x].second;\n cout << cx << \" \" << cy << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc007":"/*\n Heuristic Solution for AHC007\n Strategy:\n 1. Precompute Euclidean distances (d) for all edges offline.\n 2. Sort edges by d to determine their global Rank.\n 3. Since l_i is proportional to d_i, edges with lower Rank are expected to be cheaper.\n 4. Use a Rank Threshold (e.g., 2*N) to filter out \"expensive\" edges (high d).\n Given the problem generation ensures 5 MSTs in the edge set, connectivity is robust even with this filter.\n 5. Accept an edge if it connects two disjoint components AND its Rank is within the Threshold.\n This mimics Kruskal's algorithm on the subset of \"good\" edges.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Fixed problem parameters\nconst int FIXED_N = 400;\nconst int FIXED_M = 1995;\n\n// Edge structure\nstruct Edge {\n int u, v;\n int d; // Euclidean distance rounded\n int original_idx;\n};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = FIXED_N;\n int M = FIXED_M;\n\n // Read N vertices coordinates\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) {\n cin >> X[i] >> Y[i];\n }\n\n // Read M edge endpoints\n vector U(M), V(M);\n vector edges(M);\n\n for (int i = 0; i < M; ++i) {\n cin >> U[i] >> V[i];\n long long dx = X[U[i]] - X[V[i]];\n long long dy = Y[U[i]] - Y[V[i]];\n double dist = std::sqrt((double)dx * dx + (double)dy * dy);\n int d_val = std::round(dist);\n \n edges[i] = {U[i], V[i], d_val, i};\n }\n\n // Determine Rank for each edge based on 'd'\n // Rank 0 corresponds to the smallest Euclidean distance\n vector sorted_indices(M);\n std::iota(sorted_indices.begin(), sorted_indices.end(), 0);\n\n // Stable sort or simple sort based on distance\n std::sort(sorted_indices.begin(), sorted_indices.end(), [&](int a, int b) {\n if (edges[a].d != edges[b].d) {\n return edges[a].d < edges[b].d;\n }\n return a < b;\n });\n\n // Map original index to Rank\n vector rank_map(M);\n for (int i = 0; i < M; ++i) {\n rank_map[sorted_indices[i]] = i;\n }\n\n // Threshold for acceptable edge quality\n // We need to form a tree (N-1 edges).\n // T_1 (geometric MST) contains edges with smallest d.\n // We set limit to 2*N to ensure connectivity and capture T_1 + redundancy.\n int limit_rank = 2 * N; \n\n // DSU Setup\n vector parent(N);\n std::iota(parent.begin(), parent.end(), 0);\n\n // Iterative Find with Path Compression\n auto find = [&](int i) {\n int root = i;\n while (parent[root] != root) {\n root = parent[root];\n }\n int curr = i;\n while (curr != root) {\n int next = parent[curr];\n parent[curr] = root;\n curr = next;\n }\n return root;\n };\n\n // Union function\n auto unite = [&](int a, int b) {\n int rootA = find(a);\n int rootB = find(b);\n if (rootA != rootB) {\n parent[rootA] = rootB;\n return true;\n }\n return false;\n };\n\n // Process M queries online\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l; // Read revealed length l_i\n \n // Apply heuristic strategy:\n // 1. Reject if Rank is too high (edge is geometrically long/expensive)\n // 2. If within rank limit, accept if it reduces components (standard MST greedy)\n if (rank_map[i] > limit_rank) {\n cout << 0 << endl;\n } else {\n if (find(U[i]) != find(V[i])) {\n cout << 1 << endl;\n unite(U[i], V[i]);\n } else {\n cout << 0 << endl;\n }\n }\n // Flush output to satisfy interactive constraints\n cout.flush();\n }\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;\nusing namespace atcoder;\n\nclass Solver {\nprivate:\n int N, M;\n struct Pet {\n int px, py, type;\n };\n struct Human {\n int x, y;\n };\n \n vector pets;\n vector humans;\n bool blocked[35][35];\n \n mt19937 rng;\n int currentTurn;\n \n const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // U, D, L, R\n \n bool inBounds(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n // Check if position is blocked or occupied\n bool isBlocked(int x, int y, int turn, bool initial = false) {\n if (blocked[x][y]) return true;\n \n if (initial || turn == 0) {\n for (auto& p : pets) {\n if (p.px == x && p.py == y) return true;\n }\n for (auto& h : humans) {\n if (h.x == x && h.y == y) return true;\n }\n }\n \n // Check adjacency to pets (for blocking)\n for (auto& p : pets) {\n int dist = abs(p.px - x) + abs(p.py - y);\n if (dist <= 1 && (dist != 0)) return true;\n }\n \n return false;\n }\n \n int countReachable(int x, int y) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int count = 1;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n count++;\n q.push({nx, ny});\n }\n }\n }\n return count;\n }\n \n int countPetsInArea(int x, int y) {\n int count = 0;\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n reachable++;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n // Count pets in reachable area\n for (auto& p : pets) {\n if (reachable > 0 && inBounds(p.px, p.py)) {\n // Simple reachability check\n bool visited2[35][35];\n memset(visited2, 0, sizeof(visited2));\n if (canReach(p.px, p.y, x, y, visited2)) {\n count++;\n }\n }\n }\n \n return count;\n }\n \n bool canReach(int x1, int y1, int x2, int y2, bool& visited[35][35]) {\n // BFS to check reachability\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x1, y1});\n visited[x1][y1] = true;\n \n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n if (cx == x2 && cy == y2) return true;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n return false;\n }\n \n bool canReach(int x1, int y1, int x2, int y2) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n return canReach(x1, y1, x2, y2, visited);\n }\n \n // Choose best action for each human\n string decideAction(int humanIdx, int turn) {\n auto& h = humans[humanIdx];\n double bestScore = 0;\n string bestAction = \".\";\n \n // Evaluate all possible actions\n // Action: stay, block (4 directions), move (4 directions)\n \n // Try blocking\n for (int d = 0; d < 4; d++) {\n int bx = h.x + dirs[d][0];\n int by = h.y + dirs[d][1];\n \n bool valid = true;\n if (!inBounds(bx, by)) valid = false;\n if (blocked[bx][by]) valid = false;\n if (turn == 0) {\n // Initial positions - occupied check\n for (auto& p : pets) {\n if (p.px == bx && p.py == by || \n abs(p.px - bx) + abs(p.py - by) == 1) {\n valid = false;\n break;\n }\n }\n if (valid) {\n for (auto& h2 : humans) {\n if ((h2.x == bx && h2.y == by) ||\n (h2.x != h.x || h2.y != h.y) && \n abs(h2.x - bx) + abs(h2.y - by) <= 1) {\n valid = false;\n break;\n }\n }\n }\n }\n \n if (valid) {\n // Calculate score if we block\n blocked[bx][by] = true;\n double score = calculateScore(humanIdx);\n blocked[bx][by] = false;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"udlr\"[d]);\n }\n }\n }\n \n // Try moving\n for (int d = 0; d < 4; d++) {\n int nx = h.x + dirs[d][0];\n int ny = h.y + dirs[d][1];\n \n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[humanIdx] = {nx, ny};\n double score = calculateScore(humanIdx);\n humans[humanIdx] = h;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"UDLR\"[d]);\n }\n }\n }\n \n // Try staying\n double score = calculateScore(humanIdx);\n if (score > bestScore) {\n bestScore = score;\n bestAction = \".\";\n }\n \n return bestAction;\n }\n \n double calculateScore(int humanIdx) {\n auto& h = humans[humanIdx];\n int reachable = countReachable(h.x, h.y);\n int petCount = countPetsInArea(h.x, h.y);\n \n // Score: reachable/900 * 2^(-petCount)\n return (double)reachable / 900.0 / pow(2.0, petCount);\n }\n \npublic:\n Solver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n memset(blocked, 0, sizeof(blocked));\n }\n \n void solve() {\n // Read input\n cin >> N;\n pets.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].px >> pets[i].py >> pets[i].type;\n }\n \n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n \n // Simulate for all turns\n for (currentTurn = 0; currentTurn < MAX_TURNS; currentTurn++) {\n string output = \"\";\n \n for (int i = 0; i < M; i++) {\n output += decideAction(i, currentTurn);\n }\n \n cout << output << endl << flush;\n fflush(stdout);\n \n // Read pet movements\n for (int i = 0; i < M; i++) {\n string moves;\n cin >> moves;\n }\n \n // Update blocked based on blocking actions\n for (int i = 0; i < M; i++) {\n if (output.size() > i) {\n char act = output[i];\n if (act >= 'a' && act <= 'd') {\n // Blocking\n int d = (act == 'u') ? 0 : (act == 'd') ? 1 : (act == 'l') ? 2 : 3;\n int bx = humans[i].x + dirs[d][0];\n int by = humans[i].y + dirs[d][1];\n if (inBounds(bx, by)) {\n blocked[bx][by] = true;\n }\n } else if (act == 'U' || act == 'D' || act == 'L' || act == 'R') {\n // Moving\n int d = (act == 'U') ? 0 : (act == 'D') ? 1 : (act == 'L') ? 2 : 3;\n int nx = humans[i].x + dirs[d][0];\n int ny = humans[i].y + dirs[d][1];\n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[i] = {nx, ny};\n }\n }\n }\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solver solver;\n solver.solve();\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint dr[4] = {-1, 1, 0, 0};\nint dc[4] = {0, 0, -1, 1};\nchar moveChar[4] = {'U', 'D', 'L', 'R'};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n // blocked[r][c][dir] = 1 if moving dir from (r,c) is blocked\n // Directions: 0: U, 1: D, 2: L, 3: R\n bool blocked[20][20][4];\n for(int r=0; r<20; ++r)\n for(int c=0; c<20; ++c)\n for(int d=0; d<4; ++d)\n blocked[r][c][d] = 0;\n\n // Read H walls (horizontal walls between columns)\n // h_{i,0} ... h_{i,18} -> 20 rows\n for (int i = 0; i < 20; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < 19; ++j) {\n if (row[j] == '1') {\n // Wall between (i, j) and (i, j+1)\n // R from (i, j) is blocked\n // L from (i, j+1) is blocked\n blocked[i][j][3] = 1; \n blocked[i][j+1][2] = 1; \n }\n }\n }\n \n // Read V walls (vertical walls between rows)\n // v_{0,0} ... v_{0,19} -> 19 rows (i=0 to 18)\n for (int i = 0; i < 19; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < 20; ++j) {\n if (row[j] == '1') {\n // Wall between (i, j) and (i+1, j)\n // D from (i, j) is blocked\n // U from (i+1, j) is blocked\n blocked[i][j][1] = 1; \n blocked[i+1][j][0] = 1; \n }\n }\n }\n\n const int L = 200;\n const int num_cells = 400;\n \n // dp[t][u] = max expected score starting at step t (1-based) from u\n // t ranges from 1 to L+1.\n // dp[L+1][u] = 0 (no steps left)\n vector> dp(L + 2, vector(num_cells, 0.0));\n \n int si_idx = si * 20 + sj;\n int goal_idx = ti * 20 + tj;\n \n double stay_prob = p;\n double move_prob = 1.0 - p;\n\n // Fill DP table from t = L down to 1\n for (int t = L; t >= 1; --t) {\n // Goal is absorbing state with 0 value for future\n dp[t][goal_idx] = 0.0; \n\n for (int u = 0; u < num_cells; ++u) {\n if (u == goal_idx) continue; \n\n int r = u / 20;\n int c = u % 20;\n\n double best_val = -1.0; // Scores are non-negative\n \n // Try all 4 moves\n for (int m = 0; m < 4; ++m) {\n double curr_val = 0.0;\n \n if (blocked[r][c][m]) {\n // Blocked: stay with prob 1.0 (forget or wall)\n // value = dp[t+1][u]\n curr_val = dp[t+1][u];\n } else {\n // Not blocked\n int nr = r + dr[m];\n int nc = c + dc[m];\n int v = nr * 20 + nc;\n \n // Calculate expected value\n // Recall (1-p): move to v\n // Forget (p): stay at u\n double term = 0.0;\n if (v == goal_idx) {\n // Arrive at Goal: immediate score (401 - t)\n term += move_prob * (401.0 - t);\n } else {\n term += move_prob * dp[t+1][v];\n }\n term += stay_prob * dp[t+1][u];\n curr_val = term;\n }\n \n if (curr_val > best_val) best_val = curr_val;\n }\n dp[t][u] = best_val;\n }\n }\n\n // Greedy construction of the string\n vector prob(num_cells, 0.0);\n prob[si_idx] = 1.0;\n \n string res;\n res.reserve(L);\n \n for (int t = 1; t <= L; ++t) {\n int best_m = -1;\n double max_exp = -1.0;\n \n // Evaluate each move to maximize expected score\n for (int m = 0; m < 4; ++m) {\n double exp_score = 0.0;\n \n // Iterate over all possible current states\n for (int u = 0; u < num_cells; ++u) {\n double p_u = prob[u];\n if (p_u < 1e-10) continue;\n \n // If at Goal, value contribution is 0 (dp[t+1][Goal]-based logic yields 0)\n if (u == goal_idx) continue;\n \n int r = u / 20;\n int c = u % 20;\n \n double val = 0.0;\n if (blocked[r][c][m]) {\n val = dp[t+1][u];\n } else {\n int nr = r + dr[m];\n int nc = c + dc[m];\n int v = nr * 20 + nc;\n \n if (v == goal_idx) {\n val += move_prob * (401.0 - t);\n } else {\n val += move_prob * dp[t+1][v];\n }\n val += stay_prob * dp[t+1][u];\n }\n exp_score += p_u * val;\n }\n \n if (exp_score > max_exp) {\n max_exp = exp_score;\n best_m = m;\n }\n }\n \n // Append move\n res += moveChar[best_m];\n \n // Update probabilities using the chosen move\n vector next_prob(num_cells, 0.0);\n for (int u = 0; u < num_cells; ++u) {\n double p_u = prob[u];\n if (p_u < 1e-10) continue;\n \n // Goal is absorbing (stops execution)\n if (u == goal_idx) {\n next_prob[goal_idx] += p_u;\n continue;\n }\n \n int r = u / 20;\n int c = u % 20;\n \n if (blocked[r][c][best_m]) {\n // Stay with prob 1 (blocked move or forget)\n next_prob[u] += p_u;\n } else {\n // Forget -> stay at u\n next_prob[u] += p_u * stay_prob;\n // Recall -> move to v\n int nr = r + dr[best_m];\n int nc = c + dc[best_m];\n int v = nr * 20 + nc;\n next_prob[v] += p_u * move_prob;\n }\n }\n prob = next_prob;\n }\n \n cout << res << endl;\n\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Grid dimensions\nconst int N = 30;\n\n// Global variables\nint tiles[N][N];\nint r_rot[N][N]; // Current rotation for each tile (0-3)\nint trans[8][4][4]; // Precomputed transitions: trans[type][rotation][entry_dir]\nint t_map[8][4]; // Base transitions for unrotated tiles\n\n// For path tracing and loop detection\nbool vis[N][N][4]; // Visited status to skip redundant checks\nint trace_token[N][N][4]; // Token to track node visitation in current trace\nint global_token = 0; // Incremented for each score calculation\n\n// Path arrays to store visited nodes in the current trace\nint path_i[2500];\nint path_j[2500];\nint path_d[2500];\n\n// Movement vectors: 0=Left, 1=Up, 2=Right, 3=Down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nlong long current_score = 0;\n\n// Initialize the transition tables based on the problem description\nvoid init_to() {\n int base[8][4] = {\n {1, 0, -1, -1}, // 0: [1, 0, -1, -1]\n {3, -1, -1, 0}, // 1: [3, -1, -1, 0]\n {-1, -1, 3, 2}, // 2: [-1, -1, 3, 2]\n {-1, 2, 1, -1}, // 3: [-1, 2, 1, -1]\n {1, 0, 3, 2}, // 4: [1, 0, 3, 2]\n {3, 2, 1, 0}, // 5: [3, 2, 1, 0]\n {2, -1, 0, -1}, // 6: [2, -1, 0, -1]\n {-1, 3, -1, 1} // 7: [-1, 3, -1, 1]\n };\n \n for (int r = 0; r < 8; ++r) {\n // Copy base map for reference/debugging\n for (int d = 0; d < 4; ++d) t_map[r][d] = base[r][d];\n \n // Compute transitions for each rotation 0 to 3\n for (int rot = 0; rot < 4; ++rot) {\n for (int d = 0; d < 4; ++d) {\n // Physical port d maps to logical port (d - rot + 4) % 4\n // Logical output maps to physical port (out + rot) % 4\n int d_internal = (d - rot + 4) % 4;\n int out_internal = base[r][d_internal];\n \n if (out_internal == -1) {\n trans[r][rot][d] = -1;\n } else {\n trans[r][rot][d] = (out_internal + rot) % 4;\n }\n }\n }\n }\n}\n\n// Calculate the score: L_1 * L_2\nlong long calculate_score() {\n // Use tokens to avoid resetting visited arrays completely\n global_token++;\n if (global_token == 0) { \n // Overflow handling\n memset(trace_token, 0, sizeof(trace_token));\n memset(vis, 0, sizeof(vis));\n global_token = 1;\n }\n \n // Collect all loop lengths\n // Using a static buffer for speed, though capacity 900 is small enough\n int lengths[500];\n int num_lengths = 0;\n \n // Iterate over all ports (i, j, d)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int d = 0; d < 4; ++d) {\n // Skip if already visited\n if (vis[i][j][d]) continue;\n \n int path_len = 0;\n int ci = i, cj = j, cd = d;\n \n // Trace the path\n while (true) {\n // Check boundary\n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n\n // Check trace status\n // If token matches current trace, we found a loop within the current path\n if (trace_token[ci][cj][cd] == global_token) {\n // Found a cycle. We need to calculate the length of the loop.\n // The repeated node is (ci, cj, cd).\n // Find where it appears in the path.\n int loop_len = 0;\n for (int k = 0; k < path_len; ++k) {\n if (path_i[k] == ci && path_j[k] == cj && path_d[k] == cd) {\n loop_len = path_len - k;\n break;\n }\n }\n if (loop_len > 0) {\n lengths[num_lengths++] = loop_len;\n }\n break; \n }\n \n // If visited by previous trace (token > 0 and != global_token), it's a merged path.\n if (trace_token[ci][cj][cd] > 0) {\n break;\n }\n \n // Mark as visited in current trace and globally\n trace_token[ci][cj][cd] = global_token;\n vis[ci][cj][cd] = true;\n \n // Add to path\n path_i[path_len] = ci;\n path_j[path_len] = cj;\n path_d[path_len] = cd;\n path_len++;\n \n // Move to next port\n int type = tiles[ci][cj];\n int rot = r_rot[ci][cj];\n int nd = trans[type][rot][cd];\n \n if (nd == -1) break; // Broken link\n \n int ni = ci + di[nd];\n int nj = cj + dj[nd];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) break; // Boundary\n \n ci = ni; cj = nj; \n cd = (nd + 2) % 4; // Direction to enter next tile\n }\n }\n }\n }\n \n if (num_lengths < 2) return 0;\n \n // Sort to find the two largest\n sort(lengths, lengths + num_lengths, greater());\n \n return (long long)lengths[0] * lengths[1];\n}\n\n// Random number generation\nmt19937 rng(1337);\nuniform_int_distribution dist_rot(0, 3);\nuniform_int_distribution dist_pos(0, 29);\nuniform_real_distribution dist_rand_p(0.0, 1.0);\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_to();\n \n // Read input and initialize random rotations\n for (int i = 0; i < N; ++i) {\n string row;\n if (!(cin >> row)) return 0;\n for (int j = 0; j < N; ++j) {\n tiles[i][j] = row[j] - '0';\n r_rot[i][j] = dist_rot(rng);\n }\n }\n \n // Simulated Annealing Parameters\n // Run multiple iterations to optimize\n int iterations = 60000;\n double T_0 = 1000.0;\n double T_final = 0.0001;\n \n long long global_best_score = calculate_score();\n int best_r[N][N];\n // Save initial state\n for(int i=0; i current_score) {\n accept = true;\n } else if (score >= current_score) {\n accept = true; // Equal score usually accepted\n } else {\n double exp_val = exp((double)(score - current_score) / T);\n if (exp_val > p_accept) {\n accept = true;\n }\n }\n \n if (accept) {\n current_score = score;\n if (score > global_best_score) {\n global_best_score = score;\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 10;\nconst int MAX_BOARD_SIZE = MAX_N * MAX_N;\nconst int BEAM_WIDTH = 60; \n// Max nodes estimate: T * W * 4 roughly 2000 * 60 * 4 = 480,000. \n// Using a safe upper bound for vector allocation.\nconst int MAX_NODES = 1000000; \n\nstruct Node {\n int board[MAX_BOARD_SIZE];\n int empty_pos;\n int score;\n int parent_idx; \n char move_char;\n};\n\n// Global vector to store history of all nodes for path reconstruction.\nvector all_nodes;\n// DSU arrays\nint parent[MAX_BOARD_SIZE];\nint sz[MAX_BOARD_SIZE];\nbool is_cyclic[MAX_BOARD_SIZE];\n\n// Directions: U(up), D(down), L(left), R(right).\n// For empty square movement relative to tile slide:\n// U: empty moves -1 in row. Tile moves +1.\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\n// Function to compute the size of the largest tree component in the current board\nint get_score(const int* board, int n, int empty_pos) {\n // Initialize DSU\n for (int i = 0; i < n * n; ++i) {\n parent[i] = i;\n sz[i] = 1;\n is_cyclic[i] = false;\n }\n \n // Add edges based on tile connections\n for (int r = 0; r < n; ++r) {\n for (int c = 0; c < n; ++c) {\n int idx = r * n + c;\n if (board[idx] == 0) continue; // Skip empty square\n \n // Check connection to Right neighbor\n if (c < n - 1) {\n int neighbor_idx = idx + 1;\n if (board[neighbor_idx] != 0) {\n // Right(4) connects to Left(1)\n if ((board[idx] & 4) && (board[neighbor_idx] & 1)) {\n int root_i = dsu_find(idx);\n int root_j = dsu_find(neighbor_idx);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n }\n }\n }\n // Check connection to Down neighbor\n if (r < n - 1) {\n int neighbor_idx = idx + n;\n if (board[neighbor_idx] != 0) {\n // Down(8) connects to Up(2)\n if ((board[idx] & 8) && (board[neighbor_idx] & 2)) {\n int root_i = dsu_find(idx);\n int root_j = dsu_find(neighbor_idx);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n }\n }\n }\n }\n }\n \n int max_tree_size = 0;\n vector processed_root(n * n, false);\n \n // Iterate over all valid vertices (non-empty) to find max tree size\n for (int i = 0; i < n * n; ++i) {\n if (board[i] == 0) continue;\n int root = dsu_find(i);\n if (processed_root[root]) continue;\n processed_root[root] = true;\n \n if (!is_cyclic[root]) {\n if (sz[root] > max_tree_size) {\n max_tree_size = sz[root];\n }\n }\n }\n return max_tree_size;\n}\n\nvoid dsu_union(int i, int j) {\n int root_i = dsu_find(i);\n int root_j = dsu_find(j);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n}\n\nint dsu_find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = dsu_find(parent[i]);\n}\n\n// Reconstruct the move sequence from the best node back to the start\nstring reconstruct_path(int node_id) {\n string path = \"\";\n int current = node_id;\n while (all_nodes[current].parent_idx != -1) {\n path += all_nodes[current].move_char;\n current = all_nodes[current].parent_idx;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint main() {\n // Optimization for faster I/O\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, T;\n if (!(cin >> N >> T)) return 0;\n\n // Reserve memory to avoid reallocations\n all_nodes.reserve(MAX_NODES);\n \n Node start_node;\n memset(start_node.board, 0, sizeof(start_node.board));\n start_node.parent_idx = -1;\n start_node.move_char = 0;\n int empty_pos = -1;\n \n // Read input\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c;\n cin >> c;\n int val = 0;\n if (isdigit(c)) val = c - '0';\n else val = 10 + (c - 'a');\n start_node.board[i * N + j] = val;\n if (val == 0) {\n empty_pos = i * N + j;\n }\n }\n }\n start_node.empty_pos = empty_pos;\n start_node.score = get_score(start_node.board, N, empty_pos);\n start_node.id = 0;\n all_nodes.push_back(start_node);\n\n // Beam Search Vectors\n vector current_layer;\n vector next_layer;\n current_layer.push_back(0);\n \n int best_node_idx = 0;\n int max_score = start_node.score;\n\n // Run Beam Search up to T steps\n for (int step = 1; step <= T; ++step) {\n next_layer.clear();\n // Expand all nodes in the current beam\n for (int idx : current_layer) {\n Node u = all_nodes[idx];\n int er = u.empty_pos / N;\n int ec = u.empty_pos % N;\n \n // Try all 4 directions\n for (int k = 0; k < 4; ++k) {\n int nr = er + dr[k];\n int nc = ec + dc[k];\n \n // Bound check\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n // Heuristic: Don't immediately reverse the previous move to avoid simple loops\n if (u.parent_idx != -1) {\n char prev_move = all_nodes[idx].move_char;\n // Check if 'k' reverses 'prev_move': U<->D (0<->1), L<->R (2<->3)\n if ((prev_move == 'U' && k == 1) ||\n (prev_move == 'D' && k == 0) ||\n (prev_move == 'L' && k == 3) ||\n (prev_move == 'R' && k == 2)) {\n continue; \n }\n }\n \n Node v = u; // Copy state\n // Update empty position: new empty pos is (nr, nc)\n v.empty_pos = nr * N + nc;\n // Update board: tile moves into empty, empty moves to tile position\n v.board[u.empty_pos] = u.board[v.empty_pos]; // Tile value moves to u.empty_pos\n v.board[v.empty_pos] = 0; // New empty position becomes 0\n \n v.parent_idx = idx;\n v.move_char = dir_char[k];\n v.id = (int)all_nodes.size(); // ID for history tracking\n \n v.score = get_score(v.board, N, v.empty_pos);\n \n // Check if we found the target tree\n if (v.score == N * N - 1) {\n cout << reconstruct_path(v.id) << endl;\n return 0;\n }\n \n all_nodes.push_back(v);\n next_layer.push_back(all_nodes.size() - 1);\n }\n }\n }\n \n if (next_layer.empty()) break;\n \n // Sort candidate states by score descending\n sort(next_layer.begin(), next_layer.end(), [&](int a, int b) {\n return all_nodes[a].score > all_nodes[b].score;\n });\n \n // Select top W states for next layer\n current_layer.clear();\n int limit = min((int)next_layer.size(), BEAM_WIDTH);\n for (int i = 0; i < limit; ++i) {\n current_layer.push_back(next_layer[i]);\n // Track the best state found so far in case we don't find a full tree (though guarantee exists)\n if (all_nodes[next_layer[i]].score > max_score) {\n max_score = all_nodes[next_layer[i]].score;\n best_node_idx = next_layer[i];\n }\n }\n }\n \n // Fallback if no full tree found (should not happen based on problem guarantee)\n if (max_score < N * N - 1) {\n cout << reconstruct_path(best_node_idx) << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n\n// AC Library (optional for competitive programming)\n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Data structures\nstruct Point {\n long long x, y;\n};\n\nstruct Line {\n double A, B, C; // Ax + By + C = 0\n};\n\n// Global variables to avoid passing too many parameters\nint N, K;\nvector a(11);\nvector strawberries;\nvector lines;\nvector best_lines;\nvector, int>> sigs; // Stores {signature, original_index}\nvector, int>> temp_sigs; // Reuse buffer if possible, but local is safer for lambda\n// Actually, we'll define sigs inside lambda or make it global. Making it global and resizing once is efficient.\n// But lambda needs access. Let's pass sigs or capture.\n// Let's stick to capturing global 'sigs' or local 'sigs' in main.\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> K)) return 0;\n\n // Read a_d\n int sum_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n sum_a += a[i];\n }\n\n // Read strawberries\n strawberries.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n\n // Random number generator\n mt19937 rng(12345); // Fixed seed for reproducibility\n vector current_lines(K);\n const double PI = 3.14159265358979323846;\n\n // Initialize lines randomly\n for (int i = 0; i < K; ++i) {\n double angle = uniform_real_distribution(0, 2 * PI)(rng);\n current_lines[i].A = cos(angle);\n current_lines[i].B = sin(angle);\n // r is distance from origin. Points are within 10^4 radius.\n // Lines with |C| roughly <= 12000 will intersect the cake significantly.\n double r = uniform_real_distribution(-12000.0, 12000.0)(rng);\n current_lines[i].C = -r;\n }\n\n // Resize sigs vector\n sigs.resize(N);\n\n // Helper lambda to calculate score\n // Note: Using global 'lines' is not possible inside lambda without capture if defined outside.\n // We will capture 'lines' by reference. But since 'lines' changes, we should pass 'lines' or use a shared global.\n // To avoid overhead, I'll implement a function that takes lines as argument.\n auto calculate_score = [&](const vector& curr_lines) -> int {\n // Compute signatures\n for (int i = 0; i < N; ++i) {\n pair sig = {0, 0};\n for (int k = 0; k < K; ++k) {\n double val = curr_lines[k].A * strawberries[i].x + \n curr_lines[k].B * strawberries[i].y + \n curr_lines[k].C;\n // Check side. val >= 0 implies on one side.\n if (val >= 0) {\n if (k < 64) sig.first |= (1LL << k);\n else sig.second |= (1LL << (k - 64));\n }\n }\n sigs[i] = {sig, i};\n }\n\n // Sort signatures to group points by region\n sort(sigs.begin(), sigs.end(), [](const auto& a, const auto& b) {\n if (a.first != b.first) return a.first < b.first; // Compare signatures\n return a.second < b.second;\n });\n\n int cnt[11] = {0}; // b_1 ... b_10\n int current_run = 0;\n for (int i = 0; i < N; ++i) {\n current_run++;\n // Check if next point has different signature\n bool next_diff = (i + 1 == N) || (sigs[i+1].first != sigs[i].first);\n if (next_diff) {\n // Region ended\n if (current_run >= 1 && current_run <= 10) {\n cnt[current_run]++;\n }\n current_run = 0;\n }\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(cnt[d], a[d]);\n }\n return score;\n };\n\n // SA Initialization\n int current_score = calculate_score(current_lines);\n int best_score = current_score;\n best_lines = current_lines;\n\n // SA Parameters\n int num_iterations = 2000; // Adjust based on time limit\n double T = 100000.0; \n double decay = 0.9995; \n\n // SA Loop\n for (int iter = 0; iter < num_iterations; ++iter) {\n double T_iter = T * pow(decay, iter); \n // Or simpler: T *= decay;\n \n // Choose a random line to perturb\n int idx = (rng()() % K);\n\n // Backup current line\n Line old_line = lines[idx]; // Wait, lines is not global in the scope of lambda, need to fix\n // Actually I defined 'lines' as a vector in main. But I need to update 'lines' inside the loop?\n // My lambda takes 'curr_lines'. So I must update 'current_lines' in the main scope if accepted.\n // But I need to backtrack.\n \n // Let's use 'current_lines' as the state.\n Line backup = current_lines[idx];\n\n // Perturb\n double phi = atan2(current_lines[idx].B, current_lines[idx].A);\n double angle_change = (uniform_real_distribution(-0.02, 0.02))(rng);\n current_lines[idx].A = cos(phi + angle_change);\n current_lines[idx].B = sin(phi + angle_change);\n\n double C_change = (uniform_real_distribution(-10.0, 10.0))(rng);\n current_lines[idx].C += C_change;\n\n // Calculate new score\n int new_score = calculate_score(current_lines);\n\n // SA Decision\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n // Probabilistic acceptance\n // diff = new - current (negative)\n double prob = exp((double)(new_score - current_score) / T_iter);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n best_lines = current_lines;\n }\n } else {\n // Revert\n current_lines[idx] = backup;\n }\n }\n\n // Output best lines\n cout << K << \"\\n\";\n \n // Convert best_lines to integer points\n for (int k_idx = 0; k_idx < K; ++k_idx) {\n double A = best_lines[k_idx].A;\n double B = best_lines[k_idx].B;\n double C = best_lines[k_idx].C;\n\n // Find two points on the line.\n // Line: Ax + By + C = 0.\n // Closest point to origin: P0 = (-AC, -BC).\n // Since A^2+B^2=1.\n \n long long x0 = (long long)round(-A * C);\n long long y0 = (long long)round(-B * C);\n\n // Direction vector (-B, A)\n // Scale it to find a second point\n double dx = -B;\n double dy = A;\n long long S = 2000; // Scale factor\n\n long long px1 = x0;\n long long py1 = y0;\n long long px2 = x0 + (long long)round(dx * S);\n long long py2 = y0 + (long long)round(dy * S);\n\n // Safety check to ensure distinct points\n if (px1 == px2 && py1 == py2) {\n // Fallback if direction vector rounds to 0 (unlikely with A^2+B^2=1)\n px2 += 1000; \n // Adjust py2 to maintain line equation if possible, but any distinct point works for valid line output\n // However, we want line to match best approximation.\n // If px2 was 0 (due to round), we move it.\n // Just ensure it's far away enough from x1, y1.\n // But if we move arbitrarily, the line might not match the optimized one.\n // The line should still be close.\n // Since we can't easily fix without complex math, this fallback is risky.\n // However, with S=2000 and A^2+B^2=1, at least one component of (dx, dy) is > 0.7 or similar?\n // No. dx = -B, dy = A. If B=0, dx=0. dy=1. Then py2=py1+2000. Distinct.\n // If A=0, B=1. dx=-1. dy=0. px2=px1-2000. Distinct.\n // So (dx, dy) is never (0,0).\n // But rounding can make them 0.\n // So the code above handles it.\n // In the very unlikely case it fails, we do:\n // px1+=100. (Still within bounds).\n px2 += 1000;\n if (px1 == px2) {\n px2 -= 1000; // Should be fine unless very small coords?\n }\n }\n\n // Output\n cout << px1 << \" \" << py1 << \" \" << px2 << \" \" << py2 << \"\\n\";\n }\n\n return 0;\n}","ahc014":" while (cx != b.x || cy != b.y) {\n if (has_dot[cx][cy]) return true;\n cx += dx_step;\n cy += dy_step;\n }","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\nint grid[N][N];\nint flavors[100];\n\n// Calculate score for a given grid configuration\nint calculate_score(int arr[N][N]) {\n int score = 0;\n bool visited[N][N];\n memset(visited, 0, sizeof(visited));\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (arr[r][c] != 0 && !visited[r][c]) {\n int current_flavor = arr[r][c];\n int count = 0;\n \n // BFS\n int q_r[N*N], q_c[N*N]; \n int head = 0, tail = 0;\n \n q_r[tail] = r; q_c[tail] = c;\n visited[r][c] = true;\n tail++;\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n \n while(head < tail) {\n int cr = q_r[head];\n int cc = q_c[head];\n head++;\n count++;\n \n for(int k=0; k<4; ++k) {\n int nr = cr + dr[k];\n int nc = cc + dc[k];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if(!visited[nr][nc] && arr[nr][nc] == current_flavor) {\n visited[nr][nc] = true;\n q_r[tail] = nr;\n q_c[tail] = nc;\n tail++;\n }\n }\n }\n }\n score += count * count;\n }\n }\n }\n return score;\n}\n\n// Helper to apply a move to a grid\nvoid apply_move(int grid[N][N], char dir) {\n int next_grid[N][N];\n memset(next_grid, 0, sizeof(next_grid));\n \n if (dir == 'F') { // Forward -> Top (Up)\n for (int c = 0; c < N; ++c) {\n int write_idx = 0;\n for (int r = 0; r < N; ++r) {\n if (grid[r][c] != 0) {\n next_grid[write_idx][c] = grid[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'B') { // Backward -> Bottom (Down)\n for (int c = 0; c < N; ++c) {\n int write_idx = N - 1;\n for (int r = N - 1; r >= 0; --r) {\n if (grid[r][c] != 0) {\n next_grid[write_idx][c] = grid[r][c];\n write_idx--;\n }\n }\n }\n } else if (dir == 'L') { // Left -> Left edge\n for (int r = 0; r < N; ++r) {\n int write_idx = 0;\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n next_grid[r][write_idx] = grid[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'R') { // Right -> Right edge\n for (int r = 0; r < N; ++r) {\n int write_idx = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid[r][c] != 0) {\n next_grid[r][write_idx] = grid[r][c];\n write_idx--;\n }\n }\n }\n }\n \n memcpy(grid, next_grid, sizeof(grid));\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Seed random for tie-breaking\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n mt19937 gen(seed);\n\n // Read flavor sequence\n for (int t = 0; t < 100; ++t) {\n cin >> flavors[t];\n }\n\n // Main interaction loop\n for (int t = 0; t < 100; ++t) {\n int p;\n cin >> p;\n \n // Find the p-th empty cell in reading order\n int count = 0;\n bool found = false;\n int r_target = 0, c_target = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] == 0) {\n count++;\n if (count == p) {\n r_target = i;\n c_target = j;\n found = true;\n break;\n }\n }\n }\n if (found) break;\n }\n \n // Place the candy\n if (found) {\n grid[r_target][c_target] = flavors[t];\n }\n\n // Determine tilt direction\n // Problem note: For the 100th step (index 99), we may skip output.\n // We skip output for t == 99 to match the specific instruction \"skip the output\".\n // If t < 99, we must output a tilt direction.\n if (t < 99) { \n char best_move = 'F';\n int best_score = -1;\n \n char moves[] = {'F', 'B', 'L', 'R'};\n \n // Randomize order for tie-breaking fairness\n vector idx(4);\n for(int i=0; i<4; ++i) idx[i] = i;\n shuffle(idx.begin(), idx.end(), gen);\n\n for (auto i : idx) {\n char dir = moves[i];\n // Simulate the move on a copy of the grid\n int sim_grid[N][N];\n memcpy(sim_grid, grid, sizeof(sim_grid));\n \n // Apply move to simulation copy\n apply_move(sim_grid, dir);\n \n // Calculate score\n int score = calculate_score(sim_grid);\n \n // Greedy update\n if (best_score == -1 || score > best_score) {\n best_score = score;\n best_move = dir;\n }\n }\n \n cout << best_move << endl;\n \n // Apply the selected move to the real grid\n apply_move(grid, best_move);\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\n// Graph class with essential operations\nclass Graph {\npublic:\n int n;\n std::vector adj; // Edge list (0/1) for i> adj_matrix; // For fast lookup\n \n Graph(int n = 0) : n(n), adj_matrix(n, std::vector(n, 0)) {\n if (n > 0) {\n int total_edges = n * (n - 1) / 2;\n adj.assign(total_edges, 0);\n }\n }\n \n // Parse from string\n static Graph fromString(const std::string& s, int n) {\n Graph G(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n G.adj[idx] = s[idx] - '0';\n G.adj_matrix[i][j] = G.adj_matrix[j][i] = G.adj[idx];\n idx++;\n }\n }\n return G;\n }\n \n // To string\n std::string toString() const {\n std::string s = \"\";\n for (int x : adj) s += std::to_string(x);\n return s;\n }\n \n // Edge count\n int edgeCount() const {\n return std::accumulate(adj.begin(), adj.end(), 0);\n }\n \n // Degree sequence (sorted)\n std::vector degreeSequence() const {\n std::vector deg(n, 0);\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (adj_matrix[i][j]) {\n deg[i]++;\n deg[j]++;\n }\n }\n }\n std::sort(deg.begin(), deg.end());\n return deg;\n }\n \n // Neighbor list (sorted)\n std::vector> neighborListSorted() const {\n std::vector> neighbors(n);\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (adj_matrix[i][j]) {\n neighbors[i].push_back(j);\n neighbors[j].push_back(i);\n }\n }\n std::sort(neighbors[i].begin(), neighbors[i].end());\n }\n return neighbors;\n }\n};\n\n// Weisfeiler-Lehman hash for rotation-invariant fingerprint\nclass WLHash {\nprivate:\n int n;\n std::vector labels;\n \npublic:\n WLHash(int n) : n(n), labels(n) {}\n \n std::vector compute(const Graph& G, int iterations = 4) {\n // Initialize with degree\n std::vector deg = G.degreeSequence();\n labels = G.degreeSequence(); // Sorted initially\n \n for (int iter = 0; iter < iterations; iter++) {\n std::vector new_labels(n);\n for (int i = 0; i < n; i++) {\n std::vector neighbor_labels;\n for (int j = 0; j < n; j++) {\n if (G.adj_matrix[i][j]) {\n neighbor_labels.push_back(labels[j]);\n }\n }\n std::sort(neighbor_labels.begin(), neighbor_labels.end());\n \n // Hash from (self_label, sorted_neighbor_labels)\n unsigned long h = labels[i];\n for (int nl : neighbor_labels) {\n h = (h * 37 + nl) % (n * n + 100);\n }\n new_labels[i] = h % 1000003;\n }\n labels = new_labels;\n }\n return labels;\n }\n \n // Signature (sorted labels histogram + sum)\n std::pair signature() const {\n std::vector sorted_labels = labels;\n std::sort(sorted_labels.begin(), sorted_labels.end());\n long long sum = 0;\n for (int l : sorted_labels) sum += l;\n return {sorted_labels.size(), sum};\n }\n};\n\n// Graph feature for fast filtering\nstruct GraphFeature {\n int edgeCount;\n std::vector degreeSeq;\n long long wlHashSignature;\n \n GraphFeature(const Graph& G, const WLHash& wl) {\n edgeCount = G.edgeCount();\n degreeSeq = G.degreeSequence();\n labels = wl.compute(G);\n std::vector sorted_labels = labels;\n std::sort(sorted_labels.begin(), sorted_labels.end());\n long long sum = 0;\n for (int x : sorted_labels) sum += x;\n wlHashSignature = sum;\n }\n \n // Distance between two features (lower = more similar)\n int distance(const GraphFeature& other) const {\n int diff = std::abs(edgeCount - other.edgeCount);\n int degDiff = 0;\n for (size_t i = 0; i < degreeSeq.size(); i++) {\n degDiff += std::abs((int)degreeSeq[i] - (int)other.degreeSeq[i]);\n }\n int whDiff = std::abs((int)(wlHashSignature - other.wlHashSignature)) / 1000;\n return diff * 100 + degDiff + whDiff;\n }\n \nprivate:\n std::vector labels;\n};\n\n// Quick approximate isomorphism check\nint approximateMatching(const Graph& H, const Graph& G, double epsilon) {\n int n = H.n;\n if (n != G.n) return -1;\n \n // Initialize greedy vertex matching\n std::vector mapping(n, -1);\n std::vector reverseMapping(n, -1);\n \n // Sort vertices by degree (higher degree first)\n std::vector> h_deg, g_deg;\n for (int i = 0; i < n; i++) {\n int hd = 0, gd = 0;\n for (int j = 0; j < n; j++) {\n if (H.adj_matrix[i][j]) hd++;\n if (G.adj_matrix[i][j]) gd++;\n }\n h_deg.push_back({hd, i});\n g_deg.push_back({gd, i});\n }\n std::sort(h_deg.rbegin(), h_deg.rend());\n std::sort(g_deg.rbegin(), g_deg.rend());\n \n // Greedy matching\n for (int i = 0; i < n; i++) {\n if (reverseMapping[g_deg[i].second] == -1) {\n mapping[h_deg[i].second] = g_deg[i].second;\n reverseMapping[g_deg[i].second] = h_deg[i].second;\n }\n }\n \n // Count matching edges under this mapping\n int matchCount = 0;\n int nonMatchCount = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n bool h_edge = H.adj_matrix[i][j];\n int mi = mapping[i], mj = mapping[j];\n if (mi == -1 || mj == -1 || mi >= n || mj >= n) continue;\n bool g_edge = G.adj_matrix[mi][mj];\n \n if (h_edge == g_edge) {\n matchCount++;\n } else {\n nonMatchCount++;\n }\n }\n }\n \n // Score: expected match count = N*N*(1-epsilon) + match_count*(1-epsilon) + nonMatch_count*epsilon\n // Actually: score = P(data | H, G) under noise model\n double epsilon1 = 1.0 - epsilon;\n double logLikelihood = matchCount * std::log(epsilon1) + nonMatchCount * std::log(epsilon);\n \n return (int)(matchCount - nonMatchCount * 3);\n}\n\n// Main solution\nint main() {\n // Optimization for I/O\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int M;\n double epsilon;\n std::cin >> M >> epsilon;\n \n // Choose N - balance between distinguishability and score\n // Empirical analysis: N around 32-40 works well for M up to 100\n int N = 35;\n \n // Generate M graphs\n std::vector graphs(M, Graph(N));\n std::vector features(M);\n WLHash wl(N);\n \n // Create diverse graphs with different structures\n std::mt19937 rng(42);\n \n for (int k = 0; k < M; k++) {\n int edgeCount = (k * N * (N - 1)) / (2 * M);\n \n // Create base pattern: first add edges to reach target count\n std::vector all_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n all_edges.push_back(i * N + j);\n }\n }\n \n // Add noise to make graphs structurally different\n for (int idx : all_edges) {\n int i = idx / N;\n int j = idx % N;\n if (i >= j) continue;\n \n // Deterministic pattern based on k and idx\n bool addEdge = (idx + k * 137) % (N * N) < edgeCount;\n graphs[k].adj_matrix[i][j] = graphs[k].adj_matrix[j][i] = addEdge;\n }\n \n // Add additional edges for variation\n std::vector remaining;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (!graphs[k].adj_matrix[i][j]) {\n remaining.push_back(i * N + j);\n }\n }\n }\n \n // Add extra edges for graphs that need them\n while (graphs[k].edgeCount() < edgeCount && !remaining.empty()) {\n int idx = remaining.back();\n remaining.pop_back();\n int i = idx / N;\n int j = idx % N;\n graphs[k].adj_matrix[i][j] = graphs[k].adj_matrix[j][i] = 1;\n }\n \n // Store graph edges in adj order\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n graphs[k].adj[idx++] = graphs[k].adj_matrix[i][j];\n }\n }\n \n features[k] = GraphFeature(graphs[k], wl);\n }\n \n // Output N and graphs\n std::cout << N << \"\\n\";\n std::cout.flush();\n \n for (int k = 0; k < M; k++) {\n std::cout << graphs[k].toString() << \"\\n\";\n }\n std::cout.flush();\n \n // Process queries\n std::vector candidates = features;\n \n for (int q = 0; q < 100; q++) {\n std::string H_str;\n std::cin >> H_str;\n Graph H = Graph::fromString(H_str, N);\n \n // First filter: edge count difference\n std::vector candidatesByEdge;\n for (int k = 0; k < M; k++) {\n int diff = std::abs(graphs[k].edgeCount() - H.edgeCount());\n candidatesByEdge.push_back(k * 100 + diff);\n }\n std::sort(candidatesByEdge.begin(), candidatesByEdge.end());\n \n // Take top candidates\n std::vector topCandidates;\n for (int i = 0; i < std::min(10, (int)M); i++) {\n int k = candidatesByEdge[i] / 100;\n topCandidates.push_back(k);\n }\n \n // Second filter: degree sequence similarity\n for (int i = 0; i < (int)M; i++) {\n topCandidates.push_back(i);\n }\n \n // Score each candidate\n std::vector> scored; // (negative score, candidate index)\n for (int k : topCandidates) {\n if (k < 0 || k >= M) continue;\n \n // Compute similarity score\n int score = approximateMatching(H, graphs[k], epsilon);\n scored.push_back({-score, k});\n }\n \n // Find best candidate\n int best_k = std::min_element(scored.begin(), scored.end()) -> second;\n \n std::cout << best_k << \"\\n\";\n std::cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1000000000;\n\nstruct Edge {\n int u, v, w, id;\n};\n\nint main() {\n ios_base::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> adj[N + 1];\n vector edges(M);\n \n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n edges[i] = {u, v, w, i};\n adj[u].push_back(i);\n adj[v].push_back(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 // Precompute original distances\n vector> orig(N + 1, vector(N + 1, INF));\n uniform_int_distribution nodeDist(1, N);\n mt19937 rng(42);\n \n for (int i = 1; i <= N; i++) {\n priority_queue, vector>, greater>> pq;\n pq.push({0, i});\n orig[i][i] = 0;\n \n while (!pq.empty()) {\n int d = pq.top().first;\n int u = pq.top().second;\n pq.pop();\n \n if (d > orig[i][u]) continue;\n \n for (int edgeIdx : adj[u]) {\n int v = (edges[edgeIdx].u == u) ? edges[edgeIdx].v : edges[edgeIdx].u;\n int w = edges[edgeIdx].w;\n \n if (d + w < orig[i][v]) {\n orig[i][v] = d + w;\n pq.push({orig[i][v], v});\n }\n }\n }\n }\n \n // Initialize assignments evenly\n vector assignments(M);\n vector dayCounts(D + 1, 0);\n \n int basePerDay = M / D;\n int extra = M % D;\n for (int i = 0; i < M; i++) {\n int day = (i / basePerDay);\n dayCounts[day + 1] += (day < extra) ? (basePerDay + 1) : basePerDay;\n assignments[i] = day + 1;\n }\n \n // Hill climbing\n for (int iter = 0; iter < 80000; iter++) {\n int edgeIdx = rng() % M;\n int fromDay = assignments[edgeIdx];\n \n // Find edges in fromDay\n vector fromDayEdges;\n for (int i = 0; i < M; i++) {\n if (assignments[i] == fromDay) {\n fromDayEdges.push_back(i);\n }\n }\n \n if (fromDayEdges.empty()) continue;\n \n // Pick random to day\n uniform_int_distribution dayDist(1, D);\n int toDay = dayDist(rng);\n if (toDay == fromDay) continue;\n \n // Check capacity\n if (dayCounts[toDay] >= K) continue;\n if (fromDayEdges.size() == 1) continue;\n \n // Move edge\n assignments[edgeIdx] = toDay;\n dayCounts[fromDay]--;\n dayCounts[toDay]++;\n \n if (iter % 10000 == 0) {\n cout << \"iter \" << iter << \"\\n\";\n }\n }\n \n // Output\n for (int i = 0; i < M; i++) {\n cout << assignments[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold a point in 3D space\nstruct Point3D {\n int x, y, z;\n bool operator<(const Point3D& o) const {\n if (x != o.x) return x < o.x;\n if (y != o.y) return y < o.y;\n return z < o.z;\n }\n bool operator==(const Point3D& o) const {\n return x == o.x && y == o.y && z == o.z;\n }\n};\n\n// Structure to hold rotation matrices\nstruct RotMat {\n int p[3]; // permutation of axes\n int s[3]; // signs for each axis\n};\n\nint D;\nchar f1[15][15], r1[15][15], f2[15][15], r2[15][15];\nint g1[15][15][15], g2[15][15][15];\nint g_common[15][15][15];\nint b1[15][15][15], b2[15][15][15];\nvector common_ccs;\nvector> rem1_c;\nvector> rem2_c;\nvector rotations;\n\nint parity(const vector& p) {\n int c = 0;\n for(int i=0; i<3; ++i) \n for(int j=i+1; j<3; ++j) \n if(p[i] > p[j]) c++;\n return c;\n}\n\nvoid init_rotations() {\n int p[] = {0, 1, 2};\n do {\n vector v_p(p, p+3);\n if (parity(v_p) % 2 == 0) {\n int signs[4][3] = {{1,1,1}, {1,-1,-1}, {-1,1,-1}, {-1,-1,1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n } else {\n int signs[4][3] = {{1,1,-1}, {1,-1,1}, {-1,1,1}, {-1,-1,-1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n }\n } while (next_permutation(p, p+3));\n}\n\nPoint3D transform(const Point3D& src, const RotMat& r) {\n int vals[3] = {src.x, src.y, src.z};\n return {vals[r.p[0]] * r.s[0], vals[r.p[1]] * r.s[1], vals[r.p[2]] * r.s[2]};\n}\n\n// Generate the canonical representation of a shape by trying all rotations\nvector get_canonical_shape(const vector& pts) {\n if (pts.empty()) return {};\n \n vector best;\n bool first = true;\n \n for(const auto& r : rotations) {\n vector current;\n current.reserve(pts.size());\n for(const auto& p : pts) {\n current.push_back(transform(p, r));\n }\n \n int cminx=1000, cminy=1000, cminz=1000;\n for(const auto& p : current) {\n cminx = min(cminx, p.x);\n cminy = min(cminy, p.y);\n cminz = min(cminz, p.z);\n }\n \n sort(current.begin(), current.end());\n for(auto& p : current) {\n p.x -= cminx; p.y -= cminy; p.z -= cminz;\n }\n \n if (first || current < best) {\n best = current;\n first = false;\n }\n }\n return best;\n}\n\nvoid bfs(int grid[15][15][15], vector>& components) {\n for(int x=0; x pts;\n queue, int>> q;\n q.push({{x, y}, z});\n grid[x][y][z] = 0;\n pts.push_back({x,y,z});\n \n while(!q.empty()){\n auto curr = q.front(); q.pop();\n int cx = curr.first.first, cy = curr.first.second, cz = curr.second;\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 for(int i=0; i<6; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n int nz = cz + dz[i];\n if(nx >= 0 && nx < D && ny >= 0 && ny < D && nz >= 0 && nz < D && grid[nx][ny][nz] == 1) {\n grid[nx][ny][nz] = 0;\n q.push({{nx, ny}, nz});\n pts.push_back({nx, ny, nz});\n }\n }\n }\n components.push_back(pts);\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_rotations();\n \n if (!(cin >> D)) return 0;\n \n string s;\n // Read f1\n for(int z=0; z> s; for(int x=0;x> s; for(int y=0;y> s; for(int x=0;x> s; for(int y=0;y, vector> rem2_map;\n for(size_t i=0; i shape = rem2_c[i];\n vector key = get_canonical_shape(shape);\n rem2_map[key].push_back(i);\n }\n \n vector rem1_block_id(rem1_c.size(), 0);\n vector rem2_block_id(rem2_c.size(), 0);\n \n int common_count = common_ccs.size();\n int current_id = common_count + 1;\n \n // Fill Common Blocks with IDs 1 to common_count\n for(size_t i=0; i shape = rem1_c[i];\n vector key = get_canonical_shape(shape);\n \n if (rem2_map.count(key) && !rem2_map[key].empty()) {\n int j = rem2_map[key].back();\n rem2_map[key].pop_back();\n \n rem1_block_id[i] = current_id;\n rem2_block_id[j] = current_id;\n int bid = current_id;\n for(auto& p : rem1_c[i]) b1[p.x][p.y][p.z] = bid;\n for(auto& p : rem2_c[j]) b2[p.x][p.y][p.z] = bid;\n current_id++;\n } else {\n rem1_block_id[i] = current_id;\n current_id++;\n }\n }\n \n // Fill Unique Rem1 components\n for(size_t i=0; i\n","ahc021":"#include \n#include \n#include \n\nusing namespace std;\n\n// Define a structure for edges to connect nodes in adjacent rows\nstruct Edge {\n int x1, y1; // Top node coordinates (row x1, y1)\n int x2, y2; // Bottom node coordinates (row x2, y2)\n};\n\n// Define a structure to store operations\nstruct Op {\n int x1, y1, x2, y2;\n};\n\n// Global variables to store state\nint grid[30][30]; // Stores the value of balls\nint L[466]; // Stores the target level (row index) for each ball value\nvector edges;\n\nint main() {\n // Optimization for faster I/O\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Initialize edges representing valid vertical connections\n // The pyramid has rows 0 to 29.\n // Nodes in row x are (x, 0) to (x, x).\n // Vertical edges connect row x to row x+1.\n // Specifically, (x, y) connects to (x+1, y) and (x+1, y+1).\n for (int x = 0; x < 29; ++x) {\n for (int y = 0; y <= x; ++y) {\n edges.push_back({x, y, x + 1, y});\n edges.push_back({x, y, x + 1, y + 1});\n }\n }\n\n // Read input from Standard Input\n // The input gives the pyramid row by row.\n for (int x = 0; x < 30; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> grid[x][y];\n }\n }\n\n // Calculate the target level L[v] for each ball value v.\n // The problem implies we want to sort the pyramid such that it forms a valid heap.\n // A sufficient condition is \"Level Sorting\": balls with smaller values occupy higher rows.\n // Specifically, level r contains r+1 balls.\n // Balls values 0..0 (size 1) -> Level 0\n // Balls values 1..2 (size 2) -> Level 1\n // ...\n // Balls values S..E (size r+1) -> Level r\n int k = 0;\n for (int r = 0; r < 30; ++r) {\n int cnt = r + 1;\n for (int i = 0; i < cnt; ++i) {\n if (k < 465) {\n L[k] = r;\n k++;\n }\n }\n }\n\n // Perform swaps to sort balls by target level L[v].\n // This acts as a bubble sort on the graph where we sort keys L[v].\n // Since L[v] is monotonic with value v, sorting by L[v] ensures level sorting,\n // which guarantees E=0.\n \n vector ops;\n // Limit operations to 10000 as per problem statement\n while (ops.size() < 10000) {\n bool changed = false;\n // Iterate through all valid edges\n for (const auto& e : edges) {\n int val_top = grid[e.x1][e.y1];\n int val_bottom = grid[e.x2][e.y2];\n \n // e.x1 is always < e.x2 due to our construction (Top node is in upper row)\n // If the ball at the top (val_top) has a larger target level than the ball at bottom (val_bottom),\n // it means val_top should ideally be lower in the pyramid.\n // We swap them to correct the order.\n if (L[val_top] > L[val_bottom]) {\n swap(grid[e.x1][e.y1], grid[e.x2][e.y2]);\n ops.push_back({e.x1, e.y1, e.x2, e.y2});\n changed = true;\n }\n }\n // If no swaps were made in a full pass, the array is sorted by L[v]\n if (!changed) break;\n }\n\n // Output the results\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: up, down, left, right\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\n\nstruct Pos {\n int r, c;\n bool operator<(const Pos& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n bool operator==(const Pos& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nclass Warehouse {\nprivate:\n int D;\n int N;\n vector> grid; // true = obstacle or occupied\n vector container_positions;\n vector priority_at_pos; // priority of container at each position\n vector possible_positions;\n vector possible_distances;\n \n // BFS to find reachable positions and their distances from entrance\n vector> reachable_positions() {\n vector> reachable;\n queue> q;\n vector> visited(D, vector(D, false));\n \n Pos start = {0, (D-1)/2};\n if (grid[start.r][start.c]) return reachable;\n \n q.push({start, 0});\n visited[start.r][start.c] = true;\n \n while (!q.empty()) {\n auto [pos, dist] = q.front();\n q.pop();\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D &&\n !visited[pos.r][pos.c] && !grid[pos.r][pos.c]) {\n reachable.push_back({pos, dist});\n visited[pos.r][pos.c] = true;\n \n for (int i = 0; i < 4; i++) {\n int nr = pos.r + dr[i];\n int nc = pos.c + dc[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && \n !grid[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({{nr, nc}, dist + 1});\n }\n }\n }\n }\n return reachable;\n }\n \n // Calculate distance from entrance for a position\n int distance_from_entrance(Pos pos) {\n int r = pos.r;\n int c = pos.c;\n int entrance_r = 0;\n int entrance_c = (D-1)/2;\n return abs(r - entrance_r) + abs(c - entrance_c);\n }\n \npublic:\n Warehouse(int D, int N, const vector& obstacles) \n : D(D), N(N), grid(D, vector(D, false)), \n container_positions((D*D - N - 1), {-1, -1}),\n priority_at_pos(D*D, -1) {\n \n // Mark obstacle positions\n for (const auto& obs : obstacles) {\n grid[obs.r][obs.c] = true;\n }\n \n // Mark entrance as blocked for storage\n grid[0][(D-1)/2] = true;\n \n // Pre-compute all possible storage positions sorted by distance\n set all_possible;\n for (int r = 0; r < D; r++) {\n for (int c = 0; c < D; c++) {\n if (!grid[r][c]) {\n all_possible.insert({r, c});\n }\n }\n }\n \n vector> sorted_positions;\n for (const auto& pos : all_possible) {\n sorted_positions.push_back({distance_from_entrance(pos), pos});\n }\n sort(sorted_positions.begin(), sorted_positions.end());\n \n for (const auto& item : sorted_positions) {\n possible_positions.push_back(item.second);\n possible_distances.push_back(item.first);\n }\n }\n \n // Find the best position for a container with given priority\n Pos find_placement() {\n vector> reachable = reachable_positions();\n \n if (reachable.empty()) {\n return {-1, -1}; // No valid position\n }\n \n // Heuristic: balance between distance from entrance and priority\n // Lower priority numbers should be closer for easier retrieval\n // Sort reachable positions by distance\n sort(reachable.begin(), reachable.end(),\n [](const pair& a, const pair& b) {\n return a.second < b.second;\n });\n \n // Choose position that allows future flexibility\n // Prefer positions that are not too deep in the warehouse\n for (const auto& [pos, dist] : reachable) {\n // Verify this position can be uniquely reached (not blocked)\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n return pos;\n }\n }\n \n // Fallback: return the most accessible position\n return reachable[0].first;\n }\n \n bool mark_occupied(Pos pos, int priority) {\n if (pos.r < 0 || pos.r >= D || pos.c < 0 || pos.c >= D) {\n return false;\n }\n if (grid[pos.r][pos.c]) {\n return false;\n }\n grid[pos.r][pos.c] = true; // Mark as occupied\n return true;\n }\n \n void free_position(Pos pos) {\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n grid[pos.r][pos.c] = false; // Mark as empty\n }\n }\n \n int total_containers() const {\n return container_positions.size();\n }\n \n const Pos& get_container_pos(int priority) const {\n if (priority >= 0 && priority < total_containers()) {\n return container_positions[priority];\n }\n return container_positions[0];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D, N;\n cin >> D >> N;\n \n vector obstacles;\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n obstacles.push_back({r, c});\n }\n \n Warehouse warehouse(D, N, obstacles);\n int total_containers = warehouse.total_containers();\n \n vector> placements(total_containers);\n \n // Place each container as it arrives\n for (int d = 0; d < total_containers; d++) {\n int priority;\n cin >> priority;\n \n Pos pos = warehouse.find_placement();\n \n while (pos.r == -1) { // Retry if no valid position\n int d2 = warehouse.total_containers();\n // This shouldn't happen with proper logic\n break;\n }\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n warehouse.mark_occupied(pos, priority);\n placements[priority] = {priority, pos};\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n }\n }\n \n // Output transport order: in priority order (0, 1, 2, ...)\n // We simply output containers in their assigned priority order\n for (int p = 0; p < total_containers; p++) {\n if (placements[p].first == p) {\n Pos pos = placements[p].second;\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n // Free the position after transport\n warehouse.free_position(pos);\n }\n }\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, M;\nint grid[55][55];\nint adj[105][105];\nint adj_count[105][105];\nint total_pixels[105];\nint vis[55][55];\nint q_node[2500];\nint bfs_iter = 0;\n\n// Helper to find a starting pixel of a specific color\nint get_start(int color) {\n for(int i=0; i 1000000) { \n // Optimization to avoid int overflow or reset if needed\n // Just clearing vis is safer if needed, but iter is large enough.\n // Just resetting vis every 10^6 iters might be slow. \n // Iter is safe for 2 sec (limit ~2e9).\n }\n\n int head = 0, tail = 0;\n q_node[tail++] = start;\n vis[start / N][start % N] = bfs_iter;\n int reached = 1;\n \n // Count total pixels of this color\n int total_count = 0;\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N && grid[nr][nc] == color) {\n if(vis[nr][nc] != bfs_iter) {\n vis[nr][nc] = bfs_iter;\n q_node[tail++] = nr * N + nc;\n reached++;\n }\n }\n }\n }\n\n return (reached == total_count);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n // Read input\n for(int i=0; i> grid[i][j];\n if(grid[i][j] != 0) total_pixels[grid[i][j]]++;\n }\n }\n\n // Clear arrays\n memset(adj, 0, sizeof(adj));\n memset(adj_count, 0, sizeof(adj_count));\n\n // Compute adjacencies from input map\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n \n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj[u][v] = 1; // Mark adjacency exists in Input\n }\n \n // Count adjacencies\n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj_count[u][v]++;\n }\n }\n }\n }\n\n // Identify candidate pixels (all colored pixels)\n vector> pixels;\n pixels.reserve(N * N);\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n if(grid[nr][nc] == color) neighbors_of_color++;\n }\n }\n\n // If pixel has < 2 neighbors of same color, removing it won't disconnect component\n // This is a strong heuristic. \n // Note: A pixel with 1 neighbor is a leaf or bridge (if 1 edge connects 2 blocks via this pixel).\n // If 1 neighbor, it's not a bridge cutting into >=2 parts.\n // So check connectivity only if >= 2 neighbors.\n bool need_check_connected = (neighbors_of_color >= 2);\n\n // Check adjacency constraints BEFORE modifying grid\n bool valid = true;\n\n // Check if we would break a required adjacency\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If n is 0, we don't lose adjacency with 0 unless p was the ONLY contact between color and 0\n // But we check adj_count logic\n \n if(n != 0 && n != color && adj[color][n] == 1) {\n int u = min(color, n);\n int v = max(color, n);\n // adj_count[u][v] stores contacts. \n // For non-0 neighbors, each contact is counted twice (once from each side).\n // Limit is 2 (meaning count 1 contact -> count 2 total).\n int limit = (u == 0 || v == 0) ? 1 : 2;\n if(adj_count[u][v] <= limit) {\n valid = false;\n break;\n }\n }\n }\n \n // Check if we create forbidden 0 adjacency\n if(valid) {\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n // n is color of neighbor\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If neighbor is color d (!= 0), it will become adjacent to 0 after removal.\n // Check if (0, d) is allowed.\n if(n != 0 && n != color && adj[0][n] == 0) {\n valid = false;\n break;\n }\n }\n }\n\n if(valid) {\n // Check connectivity if needed\n if(need_check_connected) {\n // Temporarily remove\n grid[r][c] = 0;\n int cnt;\n if(!check_connected(color, cnt)) {\n valid = false;\n }\n grid[r][c] = color; // Restore\n }\n }\n \n if(valid) {\n // Perform update\n grid[r][c] = 0;\n total_pixels[color]--;\n \n // Update adjacency counts\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n if(n != 0 && n != color) { // n != 0 because if n=0 we treat 0 as color 0\n // Actually, if n=0, we update adj_count[0][color]\n }\n // We need to update for all neighbors.\n // n can be 0.\n int u = min(color, n);\n int v = max(color, n);\n // If n was a colored pixel (d>0), it contributed 2.\n // If n was 0, it contributed 1.\n // We remove 2 or 1.\n // Since adj_count[u][v] was incremented by 2 for d>0 (when processing u) \n // and by 2 for d>0 (when processing v).\n // Wait, I used `adj_count[u][v]++` in Init loop.\n // When u sees v, count++. When v sees u, count++.\n // So count is 2.\n // When removing u (p), we remove count contribution from u side.\n // So decrement by 1 (from u side).\n // Wait, if n is a pixel, it sees me.\n // In Init loop, if cell `x` sees neighbor `y`, `adj_count` increments.\n // So edge `x-y` contributes 2 to `adj_count`.\n // Removing `x` (which is `p`) removes `x` side of adjacency.\n // So decrement `adj_count` by 2?\n // Yes, because both x and y contribute.\n // Wait, if `y` also sees `x`. `x` is neighbor of `y`.\n // If I remove `p` (x).\n // `adj_count` counts edges.\n // Edge (x, y) contributes 2 to count.\n // Removing x means edge (x, y) is gone.\n // So decrement by 2?\n // Wait, my check `adj_count <= limit` assumes limit 2 means \"unique contact\".\n // If unique contact exists, count is 2. Removing p removes all 2?\n // No. If unique contact exists, p is the ONLY pixel of color touching d.\n // So p's side contributes 1. d's side contributes 1.\n // So total count 2.\n // If I remove p, I remove p's side.\n // Does it remove d's side?\n // d's side contact was with p.\n // So if p is gone, d has no neighbor p.\n // So d's side contribution is lost.\n // So total contribution lost is 2.\n // So decrement by 2.\n \n // Wait, what if `n` is 0.\n // Edge (p, 0).\n // p contributes 1. 0 (outside) not processed.\n // If `0` region exists in grid. p contributes 1. 0 (at neighbor) not processed.\n // So total 1.\n // So decrement by 1 for 0 neighbors?\n // Or is `n` 0 (outside) vs `n` 0 (pixel)?\n // Both treated as `n=0`.\n // But my `adj_count` loop didn't count 0 side.\n // So count is 1.\n // So decrement by 1 if `n==0`?\n \n // Wait, if `grid` has 0 pixel.\n // `p` is color c. Neighbor `q` is 0 pixel.\n // Loop `p`: sees `q` (0). count[0][c]++ (1).\n // Loop `q`: skipped.\n // So count is 1.\n // So decrement `adj_count[0][color]` by 1.\n \n // Wait, if `n` is 0 (outside boundary).\n // Loop `p`: sees boundary 0. count[0][c]++ (1).\n // So count is 1.\n // So decrement by 1.\n \n // So `if (n != 0)`?\n // Wait, `n` is the neighbor's color.\n // If `n != 0` (colored). Decrement 2.\n // If `n == 0`. Decrement 1.\n // Wait, `adj_count` logic in loop:\n // `adj_count[0][color]++`\n // `adj_count[color][d]++`\n // It always increments `adj_count[min][max]`.\n // The issue is `n` could be `color` (if `n` was colored `d`).\n // If `n` (neighbor) is colored `d`.\n // When processing `p` (color `c`), I see `d`. Increment `count[c][d]`.\n // When processing `d` (at neighbor location), I see `c` (which was `p`). Increment `count[d][c]`.\n // So total 2.\n // When `p` removed.\n // `p` side contribution lost: 1.\n // `d` side contribution lost: 1 (since `p` was neighbor).\n // Total 2.\n // So decrement 2.\n // If `n` is 0.\n // `p` sees 0. Increment `count[0][c]` (1).\n // `0` is skipped in loop.\n // So total 1.\n // When `p` removed.\n // `p` contribution lost: 1.\n // `0` contribution lost: 0.\n // Total 1.\n // So decrement 1.\n \n // So: `int dec = (n == 0) ? 1 : 2;` ?\n // Wait, `n` is neighbor color.\n // If `n` is 0 (pixel or boundary).\n // Yes.\n // Wait, `adj[u][v]` check uses `limit`.\n // `limit` logic: if `u==0 || v==0` then `limit=1`.\n // Else `limit=2`.\n // So `dec` should match `limit`.\n \n int dec = (u == 0 || v == 0) ? 1 : 2;\n adj_count[u][v] -= dec;\n }\n }\n }\n }\n\n // Output\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace atcoder;\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int N, D, Q;\n if (!(std::cin >> N >> D >> Q)) return 0;\n \n // Query counter\n int used_queries = 0;\n \n // Store comparison results for building weight estimates\n // weight_score[i] = net score for item i (wins - losses in comparisons)\n std::vector weight_score(N, 0);\n \n // Use a random number generator for better exploration\n std::mt19937 rng(42);\n \n // Strategy: Compare each item with others to build weight ranking\n // First, compare consecutive items to establish a base ranking\n for (int i = 0; i < N - 1 && used_queries <= Q; i++) {\n int left_items[2] = {i};\n int right_items[1] = {i + 1};\n \n std::cout << 1 << \" \" << 1 << \" \" << left_items[0] << \" \" << right_items[0] << std::endl;\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_score[i]++;\n } else if (result == \"<\") {\n weight_score[i + 1]++;\n }\n // If equal, no change\n }\n \n // Second round: Compare items with larger gaps to build better ranking\n for (int gap = 2; gap <= std::min(10, N / 2) && used_queries <= Q; gap++) {\n for (int i = 0; i < N - gap && used_queries <= Q; i++) {\n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << (i + gap) << std::endl;\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_score[i] += 2;\n } else if (result == \"<\") {\n weight_score[i + gap] += 2;\n }\n }\n }\n \n // Third round: Compare with reference (sum of all items)\n std::vector full_set(N);\n std::iota(full_set.begin(), full_set.end(), 0);\n \n // Use some queries to understand weight distribution\n for (int ref_item = 0; ref_item < N && used_queries < Q; ref_item += 2) {\n std::vector ref;\n std::vector test;\n \n if (ref_item == 0) {\n ref.push_back(1);\n } else {\n ref.push_back(0);\n }\n \n test.push_back(ref_item);\n \n std::cout << ref.size() << \" \" << test.size();\n for (int x : ref) std::cout << \" \" << x;\n for (int x : test) std::cout << \" \" << x;\n std::cout << std::endl;\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_score[ref[0]] += 3;\n } else if (result == \"<\") {\n weight_score[test[0]] += 3;\n }\n }\n \n // Also compare some pairs with equal-sized groups to learn distribution\n int pairs_compare = 0;\n for (int i = 0; i < std::min(15, N - 1); i += 2) {\n int j = i + 1;\n std::vector left = {i};\n std::vector right = {j};\n \n std::cout << 1 << \" \" << 1 << \" \" << left[0] << \" \" << right[0] << std::endl;\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_score[i] += 1;\n } else if (result == \"<\") {\n weight_score[j] += 1;\n }\n pairs_compare++;\n \n if (used_queries >= 3 * N) break;\n }\n \n // Sort items by weight_score\n std::vector> items_by_score;\n for (int i = 0; i < N; i++) {\n items_by_score.push_back({weight_score[i], i});\n }\n std::sort(items_by_score.rbegin(), items_by_score.rend());\n \n // LPT Greedy partitioning\n std::vector partition(N);\n std::vector set_weights(D, 0.0);\n \n for (int i = 0; i < N; i++) {\n int item_idx = items_by_score[i].second;\n \n // Find set with minimum weight\n int best_set = 0;\n for (int s = 1; s < D; s++) {\n if (set_weights[s] < set_weights[best_set]) {\n best_set = s;\n }\n }\n \n partition[item_idx] = best_set;\n set_weights[best_set] += weight_score[item_idx];\n }\n \n // Local search refinement: try swapping items to improve balance\n bool improved = true;\n int max_iterations = 8;\n \n while (improved && max_iterations > 0) {\n improved = false;\n max_iterations--;\n \n std::vector current_weights(D, 0.0);\n for (int i = 0; i < N; i++) {\n current_weights[partition[i]] += weight_score[i];\n }\n \n double min_weight = *std::min_element(current_weights.begin(), current_weights.end());\n double max_weight = *std::max_element(current_weights.begin(), current_weights.end());\n \n // Try moving items from heaviest to lightest set\n std::vector max_set_items;\n double max_set_weight = max_weight;\n std::vector min_set_items;\n \n for (int i = 0; i < N; i++) {\n if (current_weights[partition[i]] == max_weight) {\n max_set_items.push_back(i);\n }\n if (current_weights[partition[i]] == min_weight) {\n min_set_items.push_back(i);\n }\n }\n \n for (int candidate : max_set_items) {\n for (auto& target : min_set_items) {\n if (candidate == target) break;\n \n // Try swapping\n int old_partition = partition[candidate];\n int old_target_partition = partition[target];\n \n // Move candidate to min set\n partition[candidate] = old_target_partition;\n \n // Recalculate weights\n std::vector new_weights = current_weights;\n new_weights[old_partition] -= weight_score[candidate];\n new_weights[old_target_partition] += weight_score[candidate];\n \n double new_min = *std::min_element(new_weights.begin(), new_weights.end());\n double new_max = *std::max_element(new_weights.begin(), new_weights.end());\n \n if (new_max - new_min < max_weight - min_weight) {\n // Better partition found\n improved = true;\n current_weights = new_weights;\n break;\n }\n \n // Revert\n partition[candidate] = old_partition;\n // Also try moving target item\n partition[candidate] = old_partition;\n }\n if (improved) break;\n }\n }\n \n // Output final partition\n for (int i = 0; i < N; i++) {\n std::cout << partition[i] << (i == N - 1 ? \"\" : \" \");\n }\n std::cout << std::endl;\n std::flush(std::cout);\n \n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int n, m;\n if (!(cin >> n >> m)) return 0;\n\n // Use a vector of vectors to store the stacks.\n // Each inner vector represents a stack from bottom to top.\n vector> stacks(m);\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int b;\n cin >> b;\n stacks[i].push_back(b);\n }\n }\n\n // We need to output operations.\n vector> operations;\n // Track if a box is carried out.\n vector carried_out(n + 1, false);\n\n for (int v = 1; v <= n; ++v) {\n if (carried_out[v]) continue; // Should not happen if loop is correct.\n\n int src_idx = -1;\n int box_idx = -1;\n // Find stack and index of current box v\n for (int i = 0; i < m; ++i) {\n // We need to check if v is in stack i.\n // Since v is not carried out, it must be in one stack.\n // Note: n is small (200), so linear scan is cheap.\n // However, v is guaranteed to be in the stack if not carried out.\n // To avoid scanning all stacks every time, we can optimize, \n // but O(n*m) is acceptable.\n // Let's just scan.\n for (int j = 0; j < stacks[i].size(); ++j) {\n if (stacks[i][j] == v) {\n src_idx = i;\n box_idx = j;\n break;\n }\n }\n if (src_idx != -1) break;\n }\n\n // If v is at the top of the stack, we can remove it.\n // Note: v is always the smallest remaining box because we iterate 1..n.\n // So if v is at the top, we can perform Op 2.\n if (src_idx != -1 && box_idx == stacks[src_idx].size() - 1) {\n // v is at top\n operations.push_back({v, 0});\n carried_out[v] = true;\n stacks[src_idx].pop_back();\n } \n else {\n // v is buried. We must move boxes above it to expose v.\n // Strategy: Peel the boxes above v one by one.\n // This costs 2 energy per box but minimizes the risk of blocking future operations.\n // However, peeling is safer for the Ops count limit? No, block is better for Ops.\n // Based on analysis, Peeling is safer and fits Ops limit.\n \n // Let's peel boxes from top to bottom.\n // The box at top is stacks[src_idx].back().\n // We need to move it to some dest stack.\n \n // Actually, we can move v's boxes above it directly to dest.\n // We peel them one by one to avoid blocking issues and reduce total energy cost risk?\n // Wait, earlier analysis showed Block is better if lucky.\n // But given random order, Peeling is more robust.\n // Let's implement Peeling.\n // Wait, if we just move top element.\n \n while (src_idx != -1 && box_idx != stacks[src_idx].size() - 1) {\n // Current top of src stack\n int top_val = stacks[src_idx].back();\n // Find best destination.\n // We want to maximize T (top of dest), and prefer empty stacks (T = infinity).\n int best_dest = -1;\n int max_top = -1;\n \n for (int i = 0; i < m; ++i) {\n if (stacks[i].empty()) {\n max_top = 201; // Infinity effectively\n best_dest = i;\n break;\n } else {\n int t = stacks[i].back();\n if (t > max_top) {\n max_top = t;\n best_dest = i;\n }\n }\n }\n \n // If no empty stack, best_dest has max_top.\n // If empty stack found, break.\n \n // Move top_val to best_dest\n operations.push_back({top_val, best_dest + 1}); // 1-based index for output\n \n stacks[best_dest].push_back(top_val);\n stacks[src_idx].pop_back();\n \n // Re-check v's position in updated stack\n // Since we removed top element, box_idx is still valid but might be top now.\n // If src_idx is valid.\n // Let's re-find v position.\n for (int j = 0; j < stacks[src_idx].size(); ++j) {\n if (stacks[src_idx][j] == v) {\n box_idx = j;\n break;\n }\n }\n }\n \n // Now v should be at top\n // Remove v\n if (src_idx != -1 && box_idx == stacks[src_idx].size() - 1) {\n operations.push_back({v, 0});\n carried_out[v] = true;\n stacks[src_idx].pop_back();\n }\n }\n }\n\n // Output operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"void dfs(int u) {\n for (int v : children[u]) {\n for (int k = 0; k < x_vec[v]; ++k) {\n if (v == u + 1) cout << 'R';\n else if (v == u + N) cout << 'D';\n // ...\n dfs(v);\n if (v == u + 1) cout << 'L';\n else if (v == u + N) cout << 'U';\n }\n }\n}","ahc028":"```cpp\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 r, c;\n bool operator==(const Point& o) const { return r == o.r && c == o.c; }\n int dist(const Point& o) const { return abs(r - o.r) + abs(c - o.c); }\n};\n\nstruct Occurrence {\n Point start;\n Point end;\n vector path;\n int internal_cost; \n};\n\nint N, M;\nint s_r, s_c;\nvector A;\nvector words;\nvector> word_occurrences;\n\n// Function to get total cost of a permutation\nint get_total_cost(const vector& perm) {\n // We need a large enough array\n // N=15, M=200.\n static int dp[205][15][15];\n \n // Initialize\n for(int w=0; w= 2e9) continue;\n // Try to extend to every occurrence of current word\n for(const auto& occ : occs_curr) {\n int move_cost = ({r, c}).dist(occ.start);\n int total = dp[w-1][r][c] + move_cost + occ.internal_cost;\n if (total < dp[w][occ.end.r][occ.end.c]) {\n dp[w][occ.end.r][occ.end.c] = total;\n }\n }\n }\n }\n }\n \n // Find min in last word\n int pi = perm[M-1];\n int min_c = 2e9;\n for(int r=0; r dp[M-1][r][c]) {\n min_c = dp[M-1][r][c];\n }\n }\n }\n return min_c;\n}\n\n// Helper to reconstruct path for best permutation\nvoid reconstruct_and_output(const vector& perm) {\n static int dp[205][15][15];\n static int choice_r[205][15][15];\n static int choice_c[205][15][15];\n static int choice_idx[205][15][15]; // index in word_occurrences\n \n // Initialize\n for(int w=0; w= 2e9) continue;\n const auto& occs_curr = word_occurrences[pi];\n for(int i=0; i full_path;\n for(int w = M - 1; w >= 0; --w) {\n pi = perm[w];\n int r = choice_r[w][full_path.empty() ? min_r : 0][full_path.empty() ? min_c : 0]; // Logic fix\n // Wait, backtracking needs to go from end state back to state w-1.\n // But we need to know the state at w-1.\n // We need to store the chosen `r, c` of the CURRENT state at `w`.\n // Then look up `choice_r[w][r][c]` which gives `prev_r, prev_c`.\n // But we need to access the full path to know `full_path.back()`.\n // This is tricky because `full_path` is vector of ALL points.\n // Actually, we should backtrack the OCCURRENCE indices and the grid positions.\n \n // Let's just re-run and record chosen occ index at each step.\n // State at w: (chosen_occ_idx, end_r, end_c).\n }\n \n // Correct backtracking\n vector path_occ_indices;\n int curr_r = min_r;\n int curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n int idx = choice_idx[w][curr_r][curr_c];\n int prev_r = choice_r[w][curr_r][curr_c];\n int prev_c = choice_c[w][curr_r][curr_c]; // Wait, for w=0, prev is (s_r, s_c)\n \n path_occ_indices.push_back(idx);\n curr_r = prev_r;\n curr_c = prev_c;\n }\n reverse(path_occ_indices.begin(), path_occ_indices.end());\n \n // Wait, for w=0, choice_r/choice_c logic needs to return start state (s_r, s_c).\n // My logic above: `choice_r[0][...] = s_r`.\n // So when backtracking w=0, prev_r=s_r, prev_c=s_c.\n // Then we break.\n \n // Also we need to handle the path inside the occurrences.\n // But wait, path_occ_indices only tell us WHICH occurrence.\n // We need to verify the sequence of coordinates.\n // The sequence of coords is simply: occ[0].path + occ[1].path...?\n // NO. occ[1] starts at `occ[1].start`.\n // We move from `occ[0].end` to `occ[1].start`.\n // This move does not append any character!\n // So the sequence of coordinates to OUTPUT is:\n // occ[0].path, occ[1].path, ...\n // Just concatenation.\n \n // Wait, the transition `dist` is movement cost.\n // But we must ensure we output the coords.\n // Yes, we just output `occ[path].path` for each occ sequentially.\n \n // Wait, does the problem require us to output the MOVES?\n // \"Specify square (i, j), move the finger to this square, and then append A_{i,j}\".\n // \"output... (i_l, j_l)\".\n // The sequence of (i_l, j_l) constitutes the chars appended.\n // If we are at `occ[0].end` and want to start `occ[1]` at `occ[1].start` (where `occ[1].start != occ[0].end`),\n // We do NOT output the coords in between!\n // We just jump. The move happens \"inside\" the operation?\n // \"move the finger to this square, and then append\".\n // This implies one operation = one movement + one append.\n // So to go from `occ[0].end` to `occ[1].start`, we need 1 operation!\n // Wait, if we jump, we append `occ[1].start` char.\n // But we skipped `occ[0].end`? No, we already typed it in `occ[0].path`.\n // So we just type `occ[1].start`.\n // So we just output the sequence of points in `occ[1].path` directly?\n // Yes. The string S is formed by chars.\n // My disjoint model: S = char(t_k1) + char(t_k2) + ...\n // So S is formed by the characters of the occurrences' paths.\n // Is the `move cost` paid? Yes.\n // But do we output intermediate points?\n // No. We only output points `(i, j)` that are typed.\n // So if we jump from A to B, we type B.\n // The cost `|rA - rB| + |cA - cB| + 1` is paid.\n // So we don't need to output the path between A and B.\n // We just jump.\n // So my output logic: just concat all `occ.path` vectors.\n \n // BUT wait, my `occurrence` paths already spell the words.\n // If I just concat them, `occ[0]` spells `words[perm[0]]`.\n // `occ[1]` spells `words[perm[1]]`.\n // So S = `words[perm[0]] + words[perm[1]] + ...`\n // This is valid.\n \n for(int idx : path_occ_indices) {\n const auto& occ = word_occurrences[perm[idx]][idx]; // Wait, `idx` is index *in* word_occurrences?\n // `path_occ_indices` stores the index from `word_occurrences[perm[w]]`.\n // So I should access `word_occurrences[perm[w]][idx]`.\n // But I need to track `w`.\n // The loop `w` goes forward for output.\n }\n \n vector final_perm = perm; // need correct permutation\n vector> final_paths;\n curr_r = min_r; curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n final_perm.insert(final_perm.begin() + w, 0); // This is wrong, perm is fixed.\n // I need the `path_occ_indices` vector which is ordered by w.\n // Wait, `path_occ_indices` has size M.\n // It corresponds to w=0 at index 0?\n // The loop pushed from w=M-1 down to 0.\n // So `path_occ_indices` is [occ_idx(M-1), ..., occ_idx(0)].\n // Reversed it to [occ_idx(0), ..., occ_idx(M-1)].\n }\n}\n\nvoid precompute_occurrences() {\n word_occurrences.resize(M);\n for (int k = 0; k < M; ++k) {\n vector current_occs;\n set> seen_pairs;\n \n for (int sr = 0; sr < N; ++sr) {\n for (int sc = 0; sc < N; ++sc) {\n if (A[sr][sc] == words[k][0]) {\n int dist_map[15][15][5];\n Point parent_pos[15][15][5];\n for(int r=0; r> pq; // -cost, {p*r*51 + p*c + depth} ? \n // Let's use struct.\n struct Node {\n Point p;\n int d;\n int cost;\n };\n priority_queue, greater> pq2;\n \n dist_map[sr][sc][0] = 1;\n pq2.push({{sr, sc}, 0, 1});\n \n vector> targets; // r, c, cost\n \n while(!pq2.empty()) {\n Node top = pq2.top();\n pq2.pop();\n int r = top.p.r;\n int c = top.p.c;\n int d = top.d;\n int val = top.cost;\n \n if (dist_map[r][c][d] != -1 && val > dist_map[r][c][d]) continue;\n \n if (d == 4) {\n targets.push_back({r, c, val});\n }\n if (d < 4) {\n int nd = d + 1;\n char needed = words[k][nd];\n for (int dr = -1; dr <= 1; ++dr) {\n for (int dc = -1; dc <= 1; ++dc) {\n int nr = r + dr;\n int nc = c + dc;\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (A[nr][nc] == needed) {\n int move_cost = abs(dr) + abs(dc);\n int new_cost = val + move_cost + 1;\n if (dist_map[nr][nc][nd] == -1 || new_cost < dist_map[nr][nc][nd]) {\n dist_map[nr][nc][nd] = new_cost;\n parent_pos[nr][nc][nd] = {{r, c}};\n pq2.push({{nr, nc}, nd, new_cost});\n }\n }\n }\n }\n }\n }\n }\n \n for(auto& t : targets) {\n int er = get<0>(t);\n int ec = get<1>(t);\n int cost = get<2>(t);\n \n if (seen_pairs.count({sr, sc, er, ec})) continue;\n seen_pairs.insert({sr, sc, er, ec});\n \n // Reconstruct\n vector path;\n int r = er, c = ec;\n for(int d=4; d>=0; --d) {\n path.push_back({r, c});\n // Move to parent\n if (d > 0) {\n Point p_parent = parent_pos[r][c][d];\n r = p_parent.r;\n c = p_parent.c;\n }\n }\n reverse(path.begin(), path.end());\n \n Occurrence occ;\n occ.start = {sr, sc};\n occ.end = {er, ec};\n occ.path = path;\n occ.internal_cost = cost;\n current_occs.push_back(occ);\n }\n }\n }\n }\n \n sort(current_occs.begin(), current_occs.end(), [](const Occurrence& a, const Occurrence& b) {\n return a.internal_cost < b.internal_cost;\n });\n if (current_occs.size() > 50) current_occs.resize(50);\n word_occurrences[k] = current_occs;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (!(cin >> N >> M)) return 0;\n cin >> s_r >> s_c;\n A.resize(N);\n for(int i=0; i> A[i];\n words.resize(M);\n for(int i=0; i> words[i];\n \n precompute_occurrences();\n \n // Random permute\n vector perm(M);\n for(int i=0; i rand_idx(0, M-1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n \n int base_cost = get_total_cost(perm);\n int best_cost = base_cost;\n vector best_perm = perm;\n \n for(int iter=0; iter<200000; ++iter) {\n vector next_perm = perm;\n int i = rand_idx(mt);\n int j = rand_idx(mt);\n swap(next_perm[i], next_perm[j]);\n \n int next_cost = get_total_cost(next_perm);\n if (next_cost < best_cost) {\n best_cost = next_cost;\n best_perm = next_perm;\n }\n // Simulated Annealing logic (optional but good for local optima)\n // Since time is tight, just greedy descent or simple SA\n // Let's use standard SA\n if (next_cost < base_cost) {\n perm = next_perm;\n base_cost = next_cost;\n } else {\n if (rand_prob(mt) < exp((base_cost - next_cost) / 100.0)) {\n perm = next_perm;\n base_cost = next_cost;\n }\n }\n }\n \n // Reconstruct and output\n // Need to run DP again to get occ indices\n static int dp[205][15][15];\n // ... logic from reconstruction above ...\n // (I will incorporate into a helper function in final code)\n \n // Just to be safe, I'll re-implement reconstruction here\n for(int w=0; w= 2e9) continue;\n for(int i=0; i> output_path;\n curr_r = min_r; curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n int idx = choice_idx[w][curr_r][curr_c];\n output_path.push_back(word_occurrences[best_perm[w]][idx].path);\n // curr_r, curr_c updated? No, for w=0 we need previous state?\n // Wait, `choice_idx` only stores the index of occ.\n // We don't store prev_r, prev_c in this version.\n // But for output, we don't need prev_r, prev_c. We just need the path of occ.\n // But wait, for the next step (w-1), we need to know where we ended up from w?\n // Yes. The DP state is (w, r, c) -> min cost.\n // `curr_r, curr_c` is the end position of word `w` that led to optimal.\n // But to get to `w-1`, we need to know the START of `w`.\n // Because `dp[w]` depends on `dp[w-1][prev_r][prev_c]`.\n // So we need `choice_idx[w][r][c]` to retrieve the occ.\n // Does this tell us `prev_r`?\n // No. We need to know `prev_r, prev_c`.\n // We need `choice_prev_r[w][r][c]` and `choice_prev_c[w][r][c]`.\n \n // Let's add that.\n curr_r = ... // Need to find match.\n \n // Simple fix:\n // In DP step, store `best_prev_r` and `best_prev_c`.\n }\n \n // I will implement the reconstruction properly in the final code.\n return 0;\n}","ahc030":"int main() {\n // Read N, M, epsilon\n // ...\n // Call solve()\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Helper function for ceiling integer division\ninline int ceil_div(int a, int b) {\n return (a + b - 1) / b;\n}\n\n// Function to calculate the partition transition cost for a given set of widths\nlong long calculate_partition_cost(int W, int D, int N, \n const vector& w, \n const vector>& a) {\n long long total_cost = 0;\n // We only care about transitions from day d-1 to day d.\n // L_0 is assumed to be 0.\n for (int d = 1; d < D; ++d) {\n long long day_cost = 0;\n for (int k = 0; k < N; ++k) {\n int prev_h = ceil_div(a[d - 1][k], w[k]);\n int curr_h = ceil_div(a[d][k], w[k]);\n int diff = abs(prev_h - curr_h);\n // The cost is proportional to the width of the strip times the change in height.\n // This corresponds to the horizontal partition length moving up/down.\n day_cost += (long long)w[k] * diff;\n }\n total_cost += day_cost;\n }\n return total_cost;\n}\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n // Read reservation areas\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 // Determine widths for each strip (column)\n // We assign each reservation k to strip k.\n // To minimize cost, we want w_k to be such that height changes are minimized.\n // Constraint: height h_{d,k} <= W => w_k >= a_{d,k}/W.\n vector w(N);\n int required_width = 0;\n \n // Calculate minimum required width to satisfy height <= W for all days\n for (int k = 0; k < N; ++k) {\n int max_a = 0;\n for (int d = 0; d < D; ++d) {\n max_a = max(max_a, a[d][k]);\n }\n // Minimal width to fit rectangle of area max_a into height W\n w[k] = ceil_div(max_a, W);\n required_width += w[k];\n }\n\n // Distribute remaining width to minimize partition cost\n // We use a greedy strategy: increment w[k] as long as it reduces the total cost.\n int remaining_width = W - required_width;\n \n // Note: It is possible that required_width > W in pathological cases,\n // but given constraints sum(a) <= W^2, it usually fits.\n // If remaining_width < 0, we proceed with the calculated widths (though it might exceed W).\n // Given the problem constraints, remaining_width is likely >= 0.\n \n if (remaining_width > 0) {\n // Greedily distribute width\n for (int step = 0; step < remaining_width; ++step) {\n int best_k = -1;\n long long min_cost = -1; // We want to minimize cost, so start with infinity (conceptually)\n // Actually we compute the reduction. Let's find the one that gives max reduction.\n \n // Initialize best_k with -1, cost with a sentinel\n long long best_reduction = 0;\n\n // We iterate to find the best k to increment\n for (int k = 0; k < N; ++k) {\n int old_w = w[k];\n int new_w = old_w + 1;\n \n // Calculate contribution of k to the total cost for old and new width\n long long old_contrib = 0;\n long long new_contrib = 0;\n \n for (int d = 1; d < D; ++d) {\n int prev_h_old = ceil_div(a[d - 1][k], old_w);\n int curr_h_old = ceil_div(a[d][k], old_w);\n int diff_old = abs(prev_h_old - curr_h_old);\n \n // Optimization: if diff is 0, cost is 0.\n // But we need to sum up.\n \n int prev_h_new = ceil_div(a[d - 1][k], new_w);\n int curr_h_new = ceil_div(a[d][k], new_w);\n int diff_new = abs(prev_h_new - curr_h_new);\n \n old_contrib += (long long)old_w * diff_old;\n new_contrib += (long long)new_w * diff_new;\n }\n \n if (new_contrib < old_contrib) {\n long long reduction = old_contrib - new_contrib;\n if (best_k == -1 || reduction > best_reduction) {\n best_reduction = reduction;\n best_k = k;\n }\n }\n }\n \n if (best_k != -1) {\n w[best_k]++;\n } else {\n // If adding width doesn't reduce cost (e.g. cost is constant due to ceiling effects),\n // we might as well just stop or pick the first.\n // But usually cost decreases or stays same.\n // To avoid infinite loop (though step loop limits), we just break or add to last.\n // If no reduction, we can distribute remaining to w[0] to fill grid if needed.\n break; \n }\n }\n }\n \n // Adjust if sum of widths is less than W (fill remaining arbitrarily)\n // Or if we need to ensure partition boundaries sum to W.\n // Actually, we can just sum them up.\n int current_sum = 0;\n for (int val : w) current_sum += val;\n if (current_sum < W) {\n // Add the rest to w[0] or any valid place.\n // Adding to w[0] affects layout.\n w[0] += (W - current_sum);\n }\n\n // Calculate starting x coordinates for each strip\n vector x_start(N);\n int curr_x = 0;\n for (int k = 0; k < N; ++k) {\n x_start[k] = curr_x;\n curr_x += w[k];\n }\n\n // Output the configuration\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int h = ceil_div(a[d][k], w[k]);\n // Output format: i j i' j' (top-left to bottom-right)\n // Top-left (0, x_start[k]), Bottom-right (h, x_start[k] + w[k])\n // Wait, i is row (down), j is col (right).\n // My logic: x is column index j, y is row index i.\n // Rect k spans rows 0 to h, cols x_start[k] to x_start[k] + w[k].\n cout << 0 << \" \" << x_start[k] << \" \" << h << \" \" << x_start[k] + w[k] << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 9;\nconst int M = 20;\nconst int K = 81;\nconst int MOD = 998244353;\n\nint board[N][N];\nlong long current_score = 0;\n\n// Move related\nconst int MAX_MOVES = 981; // 20 * 49 + 1 (None)\nint move_impact_flat[MAX_MOVES][N][N]; // Stores value at (r,c) or 0\nvector move_cells_flat[MAX_MOVES]; // Stores packed (r*N + c) for non-zero values\n\nvector valid_moves_list;\nmt19937 rng;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_in, M_in, K_in;\n if (!(cin >> N_in >> M_in >> K_in)) return 0;\n\n // Read initial values\n for (int i = 0; i < N_in; ++i) {\n for (int j = 0; j < N_in; ++j) {\n cin >> board[i][j];\n current_score += board[i][j];\n }\n }\n\n // Read stamps\n vector> stamps(M_in, vector(9));\n for (int m = 0; m < M_in; ++m) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int idx = i * 3 + j;\n cin >> stamps[m][idx];\n }\n }\n }\n\n // Precompute moves\n int p_limit = N_in - 2; // 7\n valid_moves_list.push_back(980); // None move ID\n\n for (int m = 0; m < M_in; ++m) {\n for (int p = 0; p < p_limit; ++p) {\n for (int q = 0; q < p_limit; ++q) {\n int id = m * 49 + (p * 7 + q);\n valid_moves_list.push_back(id);\n\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = p + i;\n int c = q + j;\n if (r >= 0 && r < N_in && c >= 0 && c < N_in) {\n int val = stamps[m][i * 3 + j];\n move_impact_flat[id][r][c] = val;\n if (val != 0) {\n move_cells_flat[id].push_back(r * N_in + c);\n }\n }\n }\n }\n }\n }\n }\n \n // Initialize RNG\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n // Initialize current moves\n vector current_moves(K);\n for (int i = 0; i < K; ++i) {\n int idx = 1 + rng() % (valid_moves_list.size() - 1);\n current_moves[i] = valid_moves_list[idx];\n }\n\n // Apply initial moves\n for (int lid = 0; lid < K; ++lid) {\n int mid = current_moves[lid];\n for (int rc : move_cells_flat[mid]) {\n int r = rc / N_in;\n int c = rc % N_in;\n long long val = board[r][c] + move_impact_flat[mid][r][c];\n if (val >= MOD) val -= MOD;\n board[r][c] = val;\n }\n }\n\n // Recompute score\n current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += board[i][j];\n }\n }\n\n // Simulated Annealing\n int iter_count = 10000; // Number of outer iterations\n double initial_temp = 1000.0;\n double decay = 0.995;\n double temp = initial_temp;\n \n bool visited[81];\n uniform_real_distribution dist(0.0, 1.0);\n\n for (int iter = 0; iter < iter_count; ++iter) {\n int slot_idx = rng() % K;\n int curr_move_id = current_moves[slot_idx];\n \n // Mark curr cells to detect overlap\n for (int rc : move_cells_flat[curr_move_id]) {\n visited[rc] = true;\n }\n \n // Try a few random candidates\n int num_check = 50; \n for (int chk = 0; chk < num_check; ++chk) {\n int cand_id = valid_moves_list[0 + rng() % valid_moves_list.size()]; \n // Randomly pick candidate including None\n \n if (cand_id == curr_move_id) continue;\n \n int delta = 0;\n int r, c;\n \n // Calculate delta\n // Process cells affected by curr_move (subtract curr_impact)\n for (int rc : move_cells_flat[curr_move_id]) {\n r = rc / N; c = rc % N;\n int imp_curr = move_impact_flat[curr_move_id][r][c];\n int imp_cand = move_impact_flat[cand_id][r][c];\n long long val_old = board[r][c];\n long long val_new = (val_old - imp_curr + imp_cand + MOD) % MOD;\n delta += (int)val_new - val_old;\n }\n // Process cells affected by cand (add cand_impact, curr_impact is 0)\n for (int rc : move_cells_flat[cand_id]) {\n r = rc / N; c = rc % N;\n if (visited[rc]) continue; // Already processed in curr loop\n int imp_cand = move_impact_flat[cand_id][r][c];\n long long val_old = board[r][c];\n long long val_new = (val_old + imp_cand);\n if (val_new >= MOD) val_new -= MOD;\n delta += (int)val_new - val_old;\n }\n \n // Simulated Annealing acceptance\n // If delta >= 0, accept. Else accept with prob exp(delta/temp)\n if (delta >= 0 || dist(rng) < exp(delta / temp)) {\n // Accept move\n current_moves[slot_idx] = cand_id;\n \n // Update board\n // Revert curr\n for (int rc : move_cells_flat[curr_move_id]) {\n r = rc / N; c = rc % N;\n long long val = board[r][c] - move_impact_flat[curr_move_id][r][c];\n if (val < 0) val += MOD;\n board[r][c] = val;\n }\n // Apply cand\n for (int rc : move_cells_flat[cand_id]) {\n r = rc / N; c = rc % N;\n long long val = board[r][c] + move_impact_flat[cand_id][r][c];\n if (val >= MOD) val -= MOD;\n board[r][c] = val;\n }\n current_score += delta;\n break; // Move accepted, break candidate loop\n }\n }\n \n // Reset visited array\n for (int rc : move_cells_flat[curr_move_id]) {\n visited[rc] = false;\n }\n \n // Decay temp\n temp *= decay;\n }\n\n // Output result\n vector>> final_ops;\n for (int i = 0; i < K; ++i) {\n if (current_moves[i] != 980) {\n int id = current_moves[i];\n int m = id / 49;\n int rem = id % 49;\n int p = rem / 7;\n int q = rem % 7;\n final_ops.push_back({m, {p, q}});\n }\n }\n \n cout << final_ops.size() << \"\\n\";\n for (auto& op : final_ops) {\n cout << op.first << \" \" << op.second.first << \" \" << op.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_N = 5;\nconst int MAX_TURNS = 5000; // Sufficient for N=5 grid\n\n// Global State\nint grid[MAX_N][MAX_N];\npair crane_pos[MAX_N];\nint crane_load[MAX_N];\nvector> A_matrix;\nvector input_idx[MAX_N];\nvector ans[MAX_N];\n\n// Directions: U, D, L, R\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char move_char[] = {'U', 'D', 'L', 'R'};\n\nvoid solve() {\n // Initialization\n for (int i = 0; i < MAX_N; ++i) {\n for (int j = 0; j < MAX_N; ++j) {\n grid[i][j] = -1;\n }\n input_idx[i] = 0;\n crane_pos[i] = {i, 0};\n crane_load[i] = -1;\n ans[i] = \"\";\n }\n\n int turns = 0;\n // Simulation Loop\n while (turns < MAX_TURNS) {\n // Step 1: Receiving Gate Spawning\n for (int i = 0; i < MAX_N; ++i) {\n if (input_idx[i] == MAX_N) continue;\n // A container spawns at (i, 0) if no container is there AND no crane holding is there.\n // Idle crane at (i, 0) does NOT block spawn based on problem statement.\n bool blocked = (grid[i][0] != -1);\n for (int c = 0; c < MAX_N; ++c) {\n if (crane_pos[c].first == i && crane_pos[c].second == 0) {\n if (crane_load[c] != -1) {\n blocked = true;\n break;\n }\n }\n }\n if (!blocked) {\n grid[i][0] = A_matrix[i][input_idx[i]];\n input_idx[i]++;\n }\n }\n\n // Step 2: Action Planning\n struct Plan {\n int id;\n int type; // 0:Wait, 1:Move, 2:P, 3:Q\n int nr, nc;\n int score;\n };\n Plan plans[MAX_N];\n\n for (int i = 0; i < MAX_N; ++i) {\n plans[i].id = i;\n plans[i].score = 0;\n plans[i].nr = crane_pos[i].first;\n plans[i].nc = crane_pos[i].second;\n\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n\n // 1. Priority Dispatch: 'Q' at Gate\n // Only dispatch if container belongs to current row\n if (c == MAX_N - 1 && crane_load[i] != -1) {\n int row_id = crane_load[i] / MAX_N;\n if (row_id == r) {\n plans[i].type = 3; // Q\n plans[i].score = 20000;\n continue; \n }\n }\n\n // 2. Priority Pickup: 'P' at Gate\n if (plans[i].score == 0 && crane_load[i] == -1) {\n if (grid[r][c] != -1) { // Container available\n plans[i].type = 2; // P\n plans[i].score = 10000;\n continue;\n }\n }\n\n // 3. Move Logic\n if (plans[i].score == 0) {\n plans[i].type = 4; // Wait\n plans[i].score = 0;\n\n // Target logic\n int tr = r, tc = c;\n int desired_dist = 0;\n \n // If holding container, target is its dispatch row\n if (crane_load[i] != -1) {\n tr = crane_load[i] / MAX_N;\n tc = MAX_N - 1;\n desired_dist = 1000;\n } else {\n // Find nearest row with pending input\n bool found = false;\n for (int k = 0; k < MAX_N; ++k) {\n if (input_idx[k] < MAX_N) {\n tr = k;\n tc = 0;\n found = true;\n break;\n }\n }\n if (found) {\n desired_dist = 5;\n } else {\n desired_dist = 0; // No input, stay put\n }\n }\n\n int best_d = 100;\n int best_move = -1;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < MAX_N && nc >= 0 && nc < MAX_N) {\n int d_dist = abs(nr - tr) + abs(nc - tc);\n if (d_dist < best_d) {\n best_d = d_dist;\n best_move = d;\n plans[i].nr = nr;\n plans[i].nc = nc;\n }\n }\n }\n \n if (best_move != -1) {\n plans[i].type = 1; // Move\n plans[i].score = desired_dist * 10 + (crane_load[i] != -1 ? 1000 : 0) - best_d;\n } else {\n plans[i].type = 4; // Wait\n }\n }\n\n // LC Bonus to prioritize clearing paths\n if (i == 0) plans[i].score += 2000;\n }\n\n // Step 3: Conflict Resolution\n // Order by score descending\n int p_idx[MAX_N];\n for(int i=0; i plans[b].score; });\n\n pair final_pos[MAX_N];\n int final_act[MAX_N];\n \n // Initialize with current positions (default for Wait)\n for(int i=0; i other_start, other -> cr_start\n if (final_pos[cr].first != crane_pos[cr].first && // Cr moves\n final_pos[other].first != crane_pos[other].first) { // Other moves\n if (nr == crane_pos[other].first && nc == crane_pos[other].second &&\n final_pos[other] == crane_pos[cr]) {\n collision = true;\n }\n }\n // Check if we both want same square\n if (nr == final_pos[other].first && nc == final_pos[other].second) {\n collision = true;\n }\n }\n\n // Lower priority cranes default to crane_pos[i].\n // If collision with lower priority, we usually win (since sorted desc).\n // But if lower priority is LC? LC has base bonus, but here sorted by score.\n // If LC collides with SC (which has higher score for Q/P), LC yields.\n // If we collide with any other, we yield (to avoid WA).\n \n // Special check: Small Crane carrying container cannot move to occupied.\n // We rely on heuristic planning, but strictly:\n if (collision) type = 4; // Wait\n \n // Check Small Crane movement constraint (Carrying + Occupied)\n // This is implicitly handled by heuristic not choosing blocked paths, but strictly:\n if (type == 1) {\n // If SC carrying, check if final_pos has container\n if (cr > 0 && crane_load[cr] != -1) {\n // We need to check grid state at final_pos\n // Wait, we need current grid state or predicted? Use current grid.\n // If final_pos has container ID, SC cannot move there.\n if (grid[nr][nc] != -1) {\n type = 4;\n }\n }\n }\n \n final_act[cr] = type;\n final_pos[cr] = {nr, nc};\n }\n\n // Step 4: Execute & Record\n int next_grid[MAX_N][MAX_N];\n for(int i=0; i> N)) return 0;\n \n A_matrix.resize(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A_matrix[i][j];\n }\n }\n \n solve();\n \n // Generate output strings with padding\n vector outputs(MAX_N);\n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\nint n;\nvector> heights;\n\nint manhattanDist(int r1, int c1, int r2, int c2) {\n return abs(r2 - r1) + abs(c2 - c1);\n}\n\nstring getMovePath(int fromR, int fromC, int toR, int toC) {\n string path = \"\";\n int curR = fromR, curC = fromC;\n \n while (curR != toR || curC != toC) {\n if (curR < toR) { path += \"D\"; curR++; }\n else if (curR > toR) { path += \"U\"; curR--; }\n else if (curC < toC) { path += \"R\"; curC++; }\n else if (curC > toC) { path += \"L\"; curC--; }\n }\n return path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n heights.resize(n, vector(n));\n \n vector> surplus;\n vector> deficit;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> heights[i][j];\n if (heights[i][j] > 0) {\n surplus.push_back({i, j});\n } else if (heights[i][j] < 0) {\n deficit.push_back({i, j});\n }\n }\n }\n \n struct Transport {\n int fromR, fromC;\n int toR, toC;\n int amt;\n int dist;\n };\n \n vector transports;\n \n for (int i = 0; i < surplus.size(); i++) {\n for (int j = 0; j < deficit.size(); j++) {\n int fr = surplus[i].first, fc = surplus[i].second;\n int tr = deficit[j].first, tc = deficit[j].second;\n int h = min(heights[fr][fc], -heights[tr][tc]);\n \n if (h <= 0) continue;\n \n int dist = manhattanDist(fr, fc, tr, tc);\n transports.push_back({fr, fc, tr, tc, h, dist});\n }\n }\n \n sort(transports.begin(), transports.end(), [](const Transport& a, const Transport& b) {\n return a.dist < b.dist;\n });\n \n vector ops;\n int curR = 0, curC = 0;\n int truckLoad = 0;\n \n for (const auto& t : transports) {\n int amt = t.amt;\n if (amt <= 0) continue;\n \n // Move to source\n string path1 = getMovePath(curR, curC, t.fromR, t.fromC);\n ops.insert(ops.end(), path1.begin(), path1.end());\n curR = t.fromR;\n curC = t.fromC;\n \n // Load\n for (int k = 0; k < amt; k++) {\n ops += \"+1\";\n truckLoad++;\n }\n heights[t.fromR][t.fromC] -= amt;\n \n // Move to destination\n string path2 = getMovePath(curR, curC, t.toR, t.toC);\n ops.insert(ops.end(), path2.begin(), path2.end());\n curR = t.toR;\n curC = t.toC;\n \n // Unload\n for (int k = 0; k < amt; k++) {\n ops += \"-1\";\n truckLoad--;\n }\n heights[t.toR][t.toC] += amt;\n }\n \n cout << ops.size() << \"\\n\";\n for (const string& op : ops) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold seed information\nstruct Seed {\n int id;\n vector values;\n int total_value;\n};\n\n// Grid coordinates with distance metric from center\nstruct Pos {\n int r, c;\n int dist_sq; // Scaled integer distance squared\n};\n\n// Comparator to sort positions: closer to center first, then row-major\nbool comparePos(const Pos& a, const Pos& b) {\n if (a.dist_sq != b.dist_sq) {\n return a.dist_sq < b.dist_sq;\n }\n // Tie-breaker: sort by row, then col\n if (a.r != b.r) {\n return a.r < b.r;\n }\n return a.c < b.c;\n}\n\nint main() {\n // Optimize I/O operations for speed\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n\n int seed_count = 2 * N * (N - 1);\n vector seeds(seed_count);\n\n // Read initial seeds\n for (int k = 0; k < seed_count; ++k) {\n seeds[k].id = k;\n seeds[k].values.resize(M, 0);\n seeds[k].total_value = 0;\n for (int l = 0; l < M; ++l) {\n cin >> seeds[k].values[l];\n seeds[k].total_value += seeds[k].values[l];\n }\n }\n\n // Precompute grid positions order\n // We use integer arithmetic to avoid floating point issues.\n // Distance is scaled by 2: dist_scaled = (2*r - (N-1))^2 + (2*c - (N-1))^2\n // Center is at (N-1)/2.0. 2*Center = N-1.\n int center_val = N - 1;\n \n vector positions;\n positions.reserve(N * N);\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int dr = 2 * r - center_val;\n int dc = 2 * c - center_val;\n int d2 = dr * dr + dc * dc;\n positions.push_back({r, c, d2});\n }\n }\n // Sort positions by distance to center (heuristic for connectivity/degree)\n sort(positions.begin(), positions.end(), comparePos);\n\n // Loop T times to conduct the operations\n for (int t = 0; t < T; ++t) {\n // Identify the best seeds to plant (Top N*N)\n // Sort seeds by total value descending\n // We need to store indices to reconstruct the grid\n vector> seed_indices(seed_count);\n for (int k = 0; k < seed_count; ++k) {\n seed_indices[k] = {seeds[k].total_value, k};\n }\n \n // Sort: descending by total_value\n sort(seed_indices.begin(), seed_indices.end(), [](const pair& a, const pair& b) {\n return a.first > b.first; \n });\n\n // Fill the grid\n // We take the top N*N seeds (indices 0 to N*N-1 in sorted list)\n // and place them in the pre-sorted grid positions\n vector> grid(N, vector(N));\n\n for (int k = 0; k < N * N; ++k) {\n int seed_id = seed_indices[k].second;\n Pos pos = positions[k];\n grid[pos.r][pos.c] = seed_id;\n }\n \n // Output the grid\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cout << grid[r][c];\n if (c < N - 1) cout << \" \";\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n // Read new seeds for the next turn\n int new_seed_count = 2 * N * (N - 1);\n seeds = vector(new_seed_count);\n for (int k = 0; k < new_seed_count; ++k) {\n seeds[k].id = k; // IDs are just indices in the input\n seeds[k].values.resize(M, 0);\n seeds[k].total_value = 0;\n for (int l = 0; l < M; ++l) {\n cin >> seeds[k].values[l];\n seeds[k].total_value += seeds[k].values[l];\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a coordinate pair\nstruct Point {\n int r, c;\n};\n\n// Structure to represent a task (moving an item from src to tgt)\nstruct Task {\n Point src, tgt;\n};\n\nint N, M, V;\nint grid_s[35][35];\nint grid_t[35][35];\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> V)) return 0;\n\n vector sources;\n vector targets;\n\n // Read initial positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_s[i][j] = (s[j] == '1');\n if (grid_s[i][j]) sources.push_back({i, j});\n }\n }\n // Read target positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_t[i][j] = (s[j] == '1');\n if (grid_t[i][j]) targets.push_back({i, j});\n }\n }\n\n // Filter out sources that are already on targets, \n // and targets that are already occupied.\n vector active_sources;\n vector active_targets;\n\n vector> is_target(N, vector(N, false));\n for(const auto& t : targets) is_target[t.r][t.c] = true;\n\n vector> is_source(N, vector(N, false));\n for(const auto& s : sources) is_source[s.r][s.c] = true;\n\n // Identify active sources (sources not on targets)\n for(const auto& s : sources) {\n if(!is_target[s.r][s.c]) active_sources.push_back(s);\n }\n // Identify active targets (targets not on sources)\n for(const auto& t : targets) {\n if(!is_source[t.r][t.c]) active_targets.push_back(t);\n }\n\n // Greedy matching between active sources and active targets\n // Since constraints are small (N<=30, M<=225), O(M^2) is acceptable.\n vector tasks;\n vector tgt_used(active_targets.size(), false);\n\n for (const auto& s : active_sources) {\n int best_idx = -1;\n int min_dist = 2000; // Max dist is roughly 60\n for (int i = 0; i < (int)active_targets.size(); ++i) {\n if (!tgt_used[i]) {\n int d = abs(s.r - active_targets[i].r) + abs(s.c - active_targets[i].c);\n if (d < min_dist) {\n min_dist = d;\n best_idx = i;\n }\n }\n }\n if (best_idx != -1) {\n tgt_used[best_idx] = true;\n tasks.push_back({s, active_targets[best_idx]});\n }\n }\n\n // --- Output Robotic Arm Design ---\n // We use a Star Graph: Root (0) connected to 1, 2, ..., V-1.\n // Edge lengths are all 1.\n cout << V << \"\\n\";\n for (int i = 1; i < V; ++i) {\n cout << 0 << \" \" << 1 << \"\\n\";\n }\n // Initial Root Position: Center of the grid\n cout << (N / 2) << \" \" << (N / 2) << \"\\n\";\n\n // --- Simulation ---\n int root_r = N / 2;\n int root_c = N / 2;\n int finger_dir = 0; // 0: Right, 1: Down, 2: Left, 3: Up. Initial state: Right (0)\n int dx[4] = {0, 1, 0, -1};\n int dy[4] = {1, 0, -1, 0};\n\n // Output buffer string\n string buf(2 * V, '.'); \n\n // Execute each task: Pick from Source -> Move -> Deliver at Target -> Place\n for (const auto& task : tasks) {\n Point src = task.src;\n Point tgt = task.tgt;\n\n // --- STEP 1: PICK UP ---\n \n // Find valid Root position and orientation to reach Source\n int pick_r = -1, pick_c = -1, pick_d = -1;\n int min_cost = 1e9;\n\n // Try all 4 directions for Finger 1\n for (int d = 0; d < 4; ++d) {\n // If finger points at src, Root must be at src - offset\n int r = src.r - dx[d];\n int c = src.c - dy[d];\n // Check bounds\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n // Prefer shorter distance; tie-break with preferred direction if possible\n if (dist < min_cost || (dist == min_cost && d == finger_dir)) {\n min_cost = dist;\n pick_r = r;\n pick_c = c;\n pick_d = d;\n }\n }\n }\n\n // Move Root to pick position\n int dr = 0, dc = 0;\n if (root_r < pick_r) dr = 1;\n if (root_r > pick_r) dr = -1;\n if (root_c < pick_c) dc = 1;\n if (root_c > pick_c) dc = -1;\n\n for (int k = 0; k < min_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n // Rotation and Action are '.' (no-op)\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1 to match direction\n while (finger_dir != pick_d) {\n buf[0] = '.'; // Move is idle\n buf[1] = '.'; // Reset rotation char\n buf[V + 1] = '.'; // Reset action char\n \n int diff = (pick_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R'; // CW 90\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L'; // CCW 90\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Pick Up Action (Vertex 1 Action is at index V + 1)\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n\n // --- STEP 2: DELIVER ---\n \n // Find valid Root position and orientation to reach Target\n int del_r = -1, del_c = -1, del_d = -1;\n int del_cost = 1e9;\n\n for (int d = 0; d < 4; ++d) {\n int r = tgt.r - dx[d];\n int c = tgt.c - dy[d];\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n if (dist < del_cost || (dist == del_cost && d == finger_dir)) {\n del_cost = dist;\n del_r = r;\n del_c = c;\n del_d = d;\n }\n }\n }\n\n // Move Root to target position\n dr = dc = 0;\n if (root_r < del_r) dr = 1;\n if (root_r > del_r) dr = -1;\n if (root_c < del_c) dc = 1;\n if (root_c > del_c) dc = -1;\n\n for (int k = 0; k < del_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1\n while (finger_dir != del_d) {\n buf[0] = '.'; \n buf[1] = '.';\n buf[V + 1] = '.'; \n int diff = (del_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R';\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L';\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Place Action\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n }\n\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n\n// Boost Geometry\n#include \n#include \n#include \n#include \n\nnamespace bg = boost::geometry;\nnamespace bgm = boost::geometry::model;\n\nusing coord = double;\nusing point = bgm::point;\nusing polygon = bgm::polygon;\nusing multi_polygon = bgm::multi_polygon;\n\nstruct RectInfo {\n int x_min, x_max, y_min, y_max;\n int mackerels;\n int sardines;\n int id;\n int score;\n};\n\nbool is_inside(int x, int y, int min_x, int max_x, int min_y, int max_y) {\n return (x >= min_x && x <= max_x && y >= min_y && y <= max_y);\n}\n\nstd::vector> kmeans(int n, int k, const std::vector>& points) {\n std::vector> centroids;\n std::mt19937 rng(42);\n std::uniform_int_distribution dist(0, n - 1);\n for(int i=0; i> members(k);\n for(int iter=0; iter<10; ++iter) {\n std::vector> new_members(k);\n for(int i=0; i> N)) return 0;\n\n std::vector> mackerels(N);\n std::vector> sardines(N);\n\n for(int i=0; i> mackerels[i].first >> mackerels[i].second;\n for(int i=0; i> sardines[i].first >> sardines[i].second;\n\n int k_clusters = 20;\n if (N < k_clusters) k_clusters = N;\n\n std::vector> clusters = kmeans(N, k_clusters, mackerels);\n std::vector all_rects;\n\n for (int i = 0; i < k_clusters; ++i) {\n if (clusters[i].empty()) continue;\n int xmin = 100005, xmax = -1, ymin = 100005, ymax = -1;\n for (int idx : clusters[i]) {\n int x = mackerels[idx].first, y = mackerels[idx].second;\n xmin = std::min(xmin, x); xmax = std::max(xmax, x);\n ymin = std::min(ymin, y); ymax = std::max(ymax, y);\n }\n int mc = 0, sc = 0;\n for (const auto& p : mackerels) if(is_inside(p.first, p.second, xmin, xmax, ymin, ymax)) mc++;\n for (const auto& p : sardines) if(is_inside(p.first, p.second, xmin, xmax, ymin, ymax)) sc++;\n all_rects.push_back({xmin, xmax, ymin, ymax, mc, sc, i, mc - sc});\n }\n\n std::sort(all_rects.begin(), all_rects.end(), [](const RectInfo& a, const RectInfo& b){return a.score > b.score;});\n int k_sel = std::min(10, (int)all_rects.size());\n std::vector selected(all_rects.begin(), all_rects.begin() + k_sel);\n \n std::sort(selected.begin(), selected.end(), [](const RectInfo& a, const RectInfo& b){\n return (a.x_min + a.x_max) < (b.x_min + b.x_max);\n });\n\n multi_polygon mp;\n std::vector polys;\n\n for (const auto& r : selected) {\n polygon p;\n bg::read_wkt(\"POLYGON((\" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_min) + \", \" +\n std::to_string(r.x_max) + \",\" + std::to_string(r.y_min) + \", \" +\n std::to_string(r.x_max) + \",\" + std::to_string(r.y_max) + \", \" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_max) + \", \" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_min) + \"))\", p);\n polys.push_back(p);\n }\n\n for (size_t i = 0; i < polys.size() - 1; ++i) {\n const auto& ri = selected[i]; const auto& rj = selected[i+1];\n int x_start = std::min(ri.x_max, rj.x_max);\n int x_end = std::max(ri.x_min, rj.x_min); // Connect min(x) to max(x)\n if (x_start > x_end) std::swap(x_start, x_end);\n \n int y_int_min = std::max(ri.y_min, rj.y_min);\n int y_int_max = std::min(ri.y_max, rj.y_max);\n if (y_int_min > y_int_max) {\n int mid = (ri.y_min + ri.y_max + rj.y_min + rj.y_max) / 4;\n y_int_min = mid; y_int_max = mid + 1;\n }\n y_int_max += 1;\n\n if (x_start <= x_end) {\n polygon bp;\n bg::read_wkt(\"POLYGON((\" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_min) + \", \" +\n std::to_string(x_end) + \",\" + std::to_string(y_int_min) + \", \" +\n std::to_string(x_end) + \",\" + std::to_string(y_int_max) + \", \" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_max) + \", \" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_min) + \"))\", bp);\n polys.push_back(bp);\n }\n }\n\n for(const auto& p : polys) bg::append(mp, p);\n \n // Union\n multi_polygon result;\n if(!mp.empty()) {\n result = mp;\n for(size_t i=0; i vertices(final_poly.outer().begin(), final_poly.outer().end());\n std::vector simplified;\n if(vertices.size() > 2) {\n simplified.push_back(vertices[0]);\n for(size_t i=1; i 1e-9 || cp < -1e-9) simplified.push_back(vertices[i]);\n }\n simplified.push_back(vertices.back());\n } else simplified = vertices;\n\n std::vector> out;\n for(const auto& v : simplified) out.push_back({(int)std::round(v.x()), (int)std::round(v.y())});\n\n if (out.size() >= 2 && out.front() == out.back()) out.pop_back();\n\n std::cout << out.size() << \"\\n\";\n for(const auto& p : out) std::cout << p.first << \" \" << p.second << \"\\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\n// Structure to represent a placement decision for a rectangle\nstruct Decision {\n int id; // Original rectangle index (0 to N-1)\n int r; // Rotation: 0 or 1\n char d; // Direction: 'U' or 'L'\n int b; // Base rectangle index (value of p_j for j < i, or -1)\n};\n\nstruct Rect {\n long long w, h;\n};\n\nint N, T, sigma;\nvector rects;\n\n// Function to evaluate the cost (W+H) of a configuration based on estimated dimensions w', h'\nlong long get_cost(const vector& config) {\n int N = config.size();\n // Basic validation: IDs must be 0..N-1 in order\n for(int i=0; i> dims(N);\n // pos[i] stores x,y for rect i\n vector> pos(N);\n // col_h[x] stores max y+h of items in column x (skyline height)\n map col_h;\n // row_w[y] stores max x+w of items in row y (skyline width)\n map row_w;\n \n for (int i = 0; i < N; ++i) {\n const Decision& d = config[i];\n \n // Get dimensions based on rotation\n long long w = rects[d.id].w;\n long long h = rects[d.id].h;\n if (d.r == 1) swap(w, h);\n dims[i] = {w, h};\n \n long long x = 0, y = 0;\n \n if (d.d == 'U') {\n // U: Move upward. Align Left edge to Right edge of base b.\n if (d.b == -1) {\n x = 0;\n } else {\n // Base b must have been placed previously (b < i)\n if (d.b < 0 || d.b >= i) return 1e18;\n long long bx = pos[d.b].first;\n long long bw = dims[d.b].first;\n x = bx + bw;\n }\n \n // Placement logic U:\n // Place in column x at the bottom-most available position.\n // The column height y corresponds to the maximum (y+h) of items already in column x.\n // If empty, y=0.\n long long current_h = 0;\n if (col_h.count(x)) current_h = col_h[x];\n y = current_h;\n \n // Update column height.\n col_h[x] = y + h;\n } else { // d.d == 'L'\n // L: Move leftward. Align Top edge to Bottom edge of base b.\n if (d.b == -1) {\n y = 0;\n } else {\n if (d.b < 0 || d.b >= i) return 1e18;\n long long by = pos[d.b].second;\n long long bh = dims[d.b].second;\n y = by + bh;\n }\n \n // Placement logic L:\n // Place in row y at the right-most available position.\n // The row width x corresponds to the maximum (x+w) of items already in row y.\n // If empty, x=0.\n long long current_w = 0;\n if (row_w.count(y)) current_w = row_w[y];\n x = current_w;\n \n // Update row width.\n row_w[y] = x + w;\n }\n \n pos[i] = {x, y};\n }\n \n // Calculate bounding box dimensions\n long long max_row_w = 0;\n for (auto p : row_w) if (p.second > max_row_w) max_row_w = p.second;\n \n long long max_col_h = 0;\n for (auto p : col_h) if (p.second > max_col_h) max_col_h = p.second;\n \n // Return proxy score W+H\n return max_row_w + max_col_h;\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (!(cin >> N >> T >> sigma)) return 0;\n rects.resize(N);\n for(int i=0; i> rects[i].w >> rects[i].h;\n }\n \n mt19937 rng(42);\n \n // Initial config: Place all N rectangles (0 to N-1).\n // Initialize with random choices to start.\n vector best_config(N);\n for(int i=0; i candidate = best_config;\n long long current_best_score = get_cost(candidate);\n \n // Run Hill Climbing with 50 iterations\n for(int iter=0; iter<50; ++iter) {\n int i = rng() % N;\n \n // 1. Try flipping Rotation (R)\n {\n int old_r = candidate[i].r;\n candidate[i].r = 1 - old_r;\n long long sc = get_cost(candidate);\n if (sc < current_best_score) {\n current_best_score = sc;\n // Keep change\n } else {\n candidate[i].r = old_r; // Revert\n }\n }\n \n // 2. Try flipping Direction (D)\n {\n char old_d = candidate[i].d;\n candidate[i].d = (old_d == 'U' ? 'L' : 'U');\n long long sc = get_cost(candidate);\n if (sc < current_best_score) {\n current_best_score = sc;\n // Keep change\n } else {\n candidate[i].d = old_d; // Revert\n }\n }\n \n // 3. Try changing Base (B)\n {\n int old_b = candidate[i].b;\n int new_b = -1;\n // Possible bases: -1, or any index j < i.\n if (i > 0) {\n int r_b = rng() % (i + 1); \n // Map r_b -> {0 -> -1, 1..i -> 0..i-1}\n if (r_b == 0) new_b = -1;\n else new_b = r_b - 1;\n } else {\n new_b = -1;\n }\n candidate[i].b = new_b;\n long long sc = get_cost(candidate);\n if (sc < current_best_score) {\n current_best_score = sc;\n // Keep change\n } else {\n candidate[i].b = old_b; // Revert\n }\n }\n }\n \n // Update global best if we found a better configuration\n // Note: best_config tracks the global best internal score found so far.\n // If candidate found a local improvement better than global history, update.\n // Wait: best_config was initialized. current_best_score is relative to starting point.\n // We should compare `current_best_score` with `get_cost(best_config)`.\n // Actually, since `best_config` is the starting point for `candidate`,\n // `current_best_score` will be at most `get_cost(best_config)`.\n // So if we improved, `candidate` is strictly better or equal.\n // To be robust, we only update if `current_best_score < get_cost(best_config)`.\n // Wait, if equal, no update.\n \n // But wait. We need to check against the best known score *globally*.\n // If `best_config` was updated previously, we should check against `get_cost(best_config)`.\n // However, my logic `best_config` is the *reference* best.\n // `candidate` starts from it. So if I improve `candidate`, I found something better than `best_config`.\n // So I should update `best_config = candidate`.\n // However, checking strictly `<` avoids unnecessary copies.\n // Wait. If `candidate` is better, update.\n \n // But I also need to output `best_config` which might be the one from last turn.\n // If `candidate` is better, I use it.\n // Wait. If I update `best_config = candidate`.\n // Then I output `best_config`.\n \n // Wait. Is there a risk `candidate` is a \"local\" improvement that is actually \"bad\" in reality?\n // We rely on internal score.\n \n // Optimization: Check if strict improvement\n long long best_score_val = get_cost(best_config);\n if (current_best_score < best_score_val) {\n best_config = candidate;\n }\n \n // Output the best configuration found/kept\n // Format:\n // n\n // p0 r0 d0 b0\n // ...\n cout << best_config.size() << \"\\n\";\n for (const auto& d : best_config) {\n cout << d.id << \" \" << d.r << \" \" << d.d << \" \" << d.b << \"\\n\";\n }\n cout.flush();\n \n // Read feedback\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n \n // Calculate score s_t for internal tracking (optional, but useful for debugging or adaptive strategies)\n // Penalty is 0 as we pack all.\n // long long penalty = 0; // assuming all used\n // long long s = W_prime + H_prime; \n // But we rely on proxy score for strategy.\n }\n \n return 0;\n}","ahc041":"#include \n#include \"atcoder/maxflow\"\n#include \"atcoder/internal_bit\"\nusing namespace std;\nusing namespace atcoder;\n\n#define rep(i, n) for (int i = 0; i < (n); ++i)\n#define rep1(i, a, b) for (int i = (a); i <= (b); ++i)\n\nstruct Vertex {\n int id;\n long long beauty;\n int x, y;\n};\n\nstruct Solver {\n int N, M, H;\n vector A;\n vector> edges;\n vector adj[1005];\n vector parent;\n vector depth;\n long long current_score = 0;\n\n Solver(int N, int M, int H, const vector& A, const vector>& edges)\n : N(N), M(M), H(H), A(A), edges(edges), parent(N, -1), depth(N, 0) {}\n\n // Build adjacency list\n void build_graph() {\n rep(i, M) {\n int u = edges[i].first;\n int v = edges[i].second;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n }\n\n // BFS to compute all depths from root assignments\n void compute_depths() {\n queue q;\n fill(depth.begin(), depth.end(), -1);\n\n rep(i, N) {\n if (parent[i] == -1) {\n depth[i] = 0;\n q.push(i);\n }\n }\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n for (int v : adj[u]) {\n if (parent[v] == u && depth[v] == -1) {\n depth[v] = depth[u] + 1;\n q.push(v);\n }\n }\n }\n }\n\n // Recompute score based on current parent assignment\n void recompute_score() {\n compute_depths();\n current_score = 0;\n rep(i, N) {\n if (depth[i] >= 0) {\n current_score += (long long)(depth[i] + 1) * A[i];\n }\n }\n }\n\n long long get_score() const {\n long long total = 0;\n rep(i, N) {\n if (depth[i] >= 0) {\n total += (long long)(depth[i] + 1) * A[i];\n }\n }\n return total;\n }\n\n // Check if moving vertex v to parent p is valid\n bool is_valid_move(int v, int p) {\n if (p == v) return false;\n if (depth[p] >= H) return false;\n if (p != -1 && depth[p] + 1 > H) return false;\n\n // Check if new parent is in adj\n bool in_adj = false;\n for (int neighbor : adj[v]) {\n if (neighbor == p) {\n in_adj = true;\n break;\n }\n }\n if (!in_adj && p != -1) return false;\n\n return true;\n }\n\n // Simulate a move without actually applying it\n long long evaluate_move(int v, int p) {\n if (!is_valid_move(v, p)) return -1;\n\n int old_parent = parent[v];\n int old_depth = depth[v];\n\n long long score_change = 0;\n\n // Change v's contribution\n int new_depth = (p == -1) ? 0 : depth[p] + 1;\n score_change += (long long)(new_depth + 1) * A[v] - (long long)(old_depth + 1) * A[v];\n\n return score_change;\n }\n\n // Actually apply a move\n void apply_move(int v, int p) {\n parent[v] = p;\n recompute_score();\n }\n\n // Local search with simulated annealing\n long long solve() {\n // First, initialize with a heuristic assignment\n initialize();\n\n // Local search with simulated annealing\n long long best_score = get_score();\n int temperature = 1000000;\n double cooling_rate = 0.9998;\n\n mt19937 gen(42);\n uniform_int_distribution dist(0, 1000000);\n\n rep(iter, 50000) {\n // Get current score\n long long cur_score = get_score();\n\n if (cur_score > best_score) best_score = cur_score;\n\n // Try random moves\n int v = uniform_int_distribution(0, N - 1)(gen);\n\n // Try all possible parents including -1 (root)\n vector parents;\n parents.push_back(-1);\n for (int p : adj[v]) parents.push_back(p);\n\n int best_p = parent[v];\n long long best_diff = 0;\n\n for (int p : parents) {\n long long diff = evaluate_move(v, p);\n if (diff > best_diff) {\n best_diff = diff;\n best_p = p;\n }\n }\n\n // Apply move with simulated annealing acceptance\n long long diff = evaluate_move(v, best_p);\n if (diff > 0 || (double)dist(gen) < diff * 100 / (temperature + 1)) {\n apply_move(v, best_p);\n }\n\n // Cool down\n temperature *= cooling_rate;\n }\n\n return get_score();\n }\n\n // Initial assignment using greedy approach\n void initialize() {\n vector visited(N, 0);\n fill(parent.begin(), parent.end(), -1);\n\n // Sort vertices by beauty in descending order\n vector> sorted_nodes(N);\n rep(i, N) sorted_nodes[i] = {A[i], i};\n sort(sorted_nodes.rbegin(), sorted_nodes.rend());\n\n rep(iter, N) {\n int v = sorted_nodes[iter].second;\n if (visited[v]) continue;\n\n // BFS to find a valid assignment with depth constraint\n queue q;\n q.push(v);\n vector tree_nodes;\n tree_nodes.push_back(v);\n visited[v] = 1;\n parent[v] = -1;\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n for (int neighbor : adj[u]) {\n if (visited[neighbor]) continue;\n\n int new_depth = depth[u] + 1;\n if (new_depth > H) continue;\n\n if (depth[u] != -1) {\n visited[neighbor] = 1;\n parent[neighbor] = u;\n depth[neighbor] = new_depth;\n tree_nodes.push_back(neighbor);\n q.push(neighbor);\n }\n }\n }\n }\n\n // Fix up: ensure all vertices are assigned\n rep(i, N) {\n if (parent[i] == -1) {\n // Find a valid parent\n for (int p : adj[i]) {\n if (depth[p] != -1 && depth[p] < H - depth[i]) {\n parent[i] = p;\n break;\n }\n }\n }\n }\n\n recompute_score();\n }\n\n // Final refinement with more aggressive local search\n void refine() {\n int improved = 1;\n while (improved) {\n improved = 0;\n rep(v, N) {\n int old_parent = parent[v];\n long long old_contrib = (parent[v] == -1) ? depth[v] : depth[parent[v]];\n\n for (int p : adj[v]) {\n if (p == v) continue;\n if (depth[p] >= H - 1) continue;\n\n int new_depth = depth[p] + 1;\n long long new_contrib = new_depth;\n\n if (new_contrib != depth[v]) {\n apply_move(v, p);\n long long gain = get_score();\n long long old_val = get_score();\n\n if (gain > old_val) {\n improved = 1;\n continue;\n }\n }\n }\n }\n }\n }\n\n const vector& get_parent() const {\n return parent;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n\n vector A(N);\n rep(i, N) cin >> A[i];\n\n vector> edges(M);\n rep(i, M) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector> coords(N);\n rep(i, N) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n Solver solver(N, M, H, A, edges);\n solver.build_graph();\n\n // Initial greedy assignment\n vector parent(N, -1);\n vector depth(N, 0);\n\n // Start BFS from each unvisited node as root\n vector visited(N, false);\n vector roots;\n rep(i, N) {\n if (!visited[i]) {\n for (int r : roots) {\n if (adj[r].empty()) {\n if (!visited[i]) {\n parent[i] = r;\n visited[i] = true;\n break;\n }\n }\n }\n if (!visited[i]) {\n // BFS to find valid tree\n queue> q;\n q.push({i, 0});\n visited[i] = true;\n parent[i] = -1;\n depth[i] = 0;\n\n while (!q.empty()) {\n auto [u, d] = q.front();\n q.pop();\n\n for (int v : adj[u]) {\n if (!visited[v] && d + 1 <= H) {\n visited[v] = true;\n parent[v] = u;\n depth[v] = d + 1;\n q.push({v, d + 1});\n }\n }\n }\n roots.push_back(i);\n }\n }\n }\n\n // Refine using local search\n auto update_parent = [&](int v, int p) -> bool {\n if (p == v) return false;\n if (parent[v] == p) return false;\n\n if (p != -1 && depth[p] >= H - 1) return false;\n\n int old_parent = parent[v];\n int old_contrib = (old_parent == -1) ? depth[v] + 1 : depth[old_parent] * (v == old_parent ? 0 : 1);\n\n int new_depth = (p == -1) ? 0 : depth[p] + 1;\n int new_contrib = new_depth;\n\n // Apply and check\n parent[v] = p;\n\n // Recompute depths affected\n queue q;\n q.push(v);\n vector affected;\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n affected.push_back(u);\n\n for (int child : adj[u]) {\n if (parent[child] == u) {\n depth[child] = depth[u] + 1;\n if (depth[child] > H) {\n parent[v] = old_parent; // Revert if invalid\n return false;\n }\n q.push(child);\n }\n }\n }\n\n long long new_score = 0;\n rep(i, N) {\n if (i != v) new_score += (long long)(depth[i] + 1) * A[i];\n }\n new_score += (long long)(depth[v] + 1) * A[v];\n\n // Revert if worse\n if (new_score < solver.get_score()) {\n parent[v] = old_parent;\n return false;\n }\n\n return true;\n };\n\n // Simple local search\n rep(iter, 10000) {\n bool improved = false;\n for (int v = 0; v < N; ++v) {\n // Try each neighbor as potential parent\n for (int p : adj[v]) {\n if (depth[p] < H - 1) {\n if (update_parent(v, p)) {\n improved = true;\n break;\n }\n }\n }\n if (improved) break;\n }\n if (!improved) break;\n }\n\n cout << parent[0];\n rep1(i, 1, N - 1) cout << \" \" << parent[i];\n cout << endl;\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Oni {\n int id;\n int r, c;\n};\n\nstruct MoveCandidate {\n int dist; // distance to shift\n char dir; // 'U', 'D', 'L', 'R'\n char opp_dir; // opposite direction\n int cost; // total operations for this move\n int col_or_row; // row index if dir is L/R, col index if dir is U/D\n vector removed_indices; // IDs of Oni removed by this move\n vector> ops; // Output operations sequence\n};\n\nint main() {\n int N;\n if (!(cin >> N)) return 0;\n\n vector board(N);\n vector valid_onis;\n vector> all_fuku;\n\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n valid_onis.push_back({(int)valid_onis.size(), i, j});\n } else if (board[i][j] == 'o') {\n all_fuku.push_back({i, j});\n }\n }\n }\n\n // Check Fukunokami positions for O(1) lookup\n vector> has_fuku(N, vector(N, false));\n for(auto& p : all_fuku) {\n has_fuku[p.first][p.second] = true;\n }\n\n vector move_candidates;\n int num_onis = valid_onis.size();\n\n for(const auto& oni : valid_onis) {\n // 1. Up Direction\n // Safe if no Fuku in (0..r-1, c)\n bool safe = true;\n for(int k=0; k= oni.r) mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n\n // 3. Left Direction\n // Safe if no Fuku in (r, 0..c-1)\n safe = true;\n for(int k=0; k= oni.c) mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n }\n\n vector is_covered(num_onis, false);\n vector> total_ops;\n\n while(true) {\n int remaining_count = 0;\n for(int i=0; i 0) {\n // Greedy strategy: maximize number of newly covered Oni\n // Tie-breaker: minimize cost\n if(best_idx == -1 || current_removed_count > best_removed_count || \n (current_removed_count == best_removed_count && mc.cost < best_cost)) {\n best_idx = i;\n best_removed_count = current_removed_count;\n best_cost = mc.cost;\n }\n }\n }\n\n if(best_idx == -1) break; // Should not happen per problem guarantee\n\n const auto& mc = move_candidates[best_idx];\n total_ops.insert(total_ops.end(), mc.ops.begin(), mc.ops.end());\n\n for(int id : mc.removed_indices) {\n is_covered[id] = true;\n }\n }\n\n cout << total_ops.size() << endl;\n for(const auto& p : total_ops) {\n cout << p.first << \" \" << p.second << endl;\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global variables to store state and results\nint N, L;\nint T[105];\nuint8_t A[105];\nuint8_t B[105];\nint counts[105];\n\n// Best solution found so far\nint best_err = 2000000000; // sufficiently large number\nuint8_t best_A[105];\nuint8_t best_B[105];\n\n// Simulation function to evaluate the configuration\nint simulate() {\n // Reset counts\n for(int i=0; i> N >> L)) return 0;\n for(int i=0; i> T[i];\n \n // Initialize random number generator\n mt19937 rng(4211); \n uniform_int_distribution dist(0, N - 1);\n uniform_real_distribution dist_real(0.0, 1.0);\n \n // Initial random configuration\n for(int i=0; i modify A, 1 -> modify B\n int val = dist(rng);\n \n uint8_t old_val = (type == 0) ? A[i] : B[i];\n if (type == 0) A[i] = (uint8_t)val; else B[i] = (uint8_t)val;\n \n int new_err = simulate();\n bool accepted = false;\n \n // Accept if better, or with probability based on temp (SA)\n if (new_err < current_err) {\n accepted = true;\n } else {\n double delta = (double)(new_err - current_err);\n if (delta > 0 && dist_real(rng) < exp(-delta / temp)) {\n accepted = true;\n }\n }\n \n if (accepted) {\n current_err = new_err;\n if (new_err < best_err) {\n best_err = new_err;\n for(int k=0; k\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n vector G(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; i++) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n \n // Estimate coordinates from rectangle centers\n vector est_x(N), est_y(N);\n for (int i = 0; i < N; i++) {\n est_x[i] = (lx[i] + rx[i]) / 2.0;\n est_y[i] = (ly[i] + ry[i]) / 2.0;\n }\n \n // Create city indices and sort by estimated position (lexicographically by x, then y)\n vector cities(N);\n iota(cities.begin(), cities.end(), 0);\n \n sort(cities.begin(), cities.end(), [&](int a, int b) {\n if (est_x[a] != est_x[b]) return est_x[a] < est_x[b];\n return est_y[a] < est_y[b];\n });\n \n // Partition into groups\n vector> groups(M);\n int idx = 0;\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < G[i]; j++) {\n if (idx < N) {\n groups[i].push_back(cities[idx]);\n idx++;\n }\n }\n }\n \n // Store all edges we find from queries\n // Each group needs G[i] - 1 edges to form a spanning tree\n vector>> group_edges(M);\n \n // Perform queries to get edges for each group\n int query_count = 0;\n for (int m = 0; m < M; m++) {\n if (G[m] < 2) continue;\n \n const auto& group = groups[m];\n int group_size = G[m];\n \n // Use sliding window queries of size 3 to L to get MST edges\n // Each 3-city query gives us 2 edges (MST of 3 nodes has 2 edges)\n \n int edge_count = 0;\n for (int i = 0; i < group_size - 1; i++) {\n if (edge_count >= group_size - 1) break;\n \n // For efficiency, query larger windows when we need more edges\n int window_size = min(L, min(group_size, group_size - i));\n if (window_size < 2) {\n window_size = 2;\n }\n \n if (query_count < Q) {\n vector query_cities;\n int take = min(window_size, group_size - i);\n \n // Take consecutive cities from the sorted group\n for (int j = 0; j < take; j++) {\n query_cities.push_back(group[i + j]);\n }\n \n // Output query\n cout << \"? \" << query_cities.size();\n for (int city : query_cities) {\n cout << \" \" << city;\n }\n cout << endl;\n \n // Read MST edges\n vector> mst_edges;\n for (int k = 0; k < query_cities.size() - 1; k++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n mst_edges.push_back({u, v});\n }\n \n // Filter edges and add to group edges\n for (auto& edge : mst_edges) {\n bool in_group = true;\n // Check if both endpoints are in this group\n for (int city : group) {\n if (edge.first == city || edge.second == city) {\n // Found city\n }\n }\n // Add the edge\n if (edge_count < group_size - 1) {\n int u = edge.first;\n int v = edge.second;\n // Check if edge already exists\n bool exists = false;\n for (auto& e : group_edges[m]) {\n if ((e.first == u && e.second == v) || \n (e.first == v && e.second == u)) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n group_edges[m].push_back({u, v});\n edge_count++;\n }\n }\n }\n \n query_count++;\n }\n }\n \n // If we still need edges, add direct connections between consecutive cities\n // (This will be suboptimal but ensures connectivity)\n // We need G[m] - 1 edges total\n int needed = group_size - 1 - edge_count;\n for (int i = 0; i < needed; i++) {\n // Connect consecutive cities in the group that might not have edges yet\n int u = group[i % group_size];\n int v = group[(i + 1) % group_size];\n // Check if edge already exists\n bool exists = false;\n for (auto& e : group_edges[m]) {\n if ((e.first == u && e.second == v) || \n (e.first == v && e.second == u)) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n group_edges[m].push_back({u, v});\n }\n }\n }\n \n // Output final answer\n cout << \"!\" << endl;\n int city_idx = 0;\n for (int m = 0; m < M; m++) {\n if (G[m] == 0) continue;\n \n // Output cities in group m\n for (int c : groups[m]) {\n cout << c << \" \";\n }\n cout << endl;\n \n // Output edges for group m\n for (auto& e : group_edges[m]) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n \n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAXN = 20;\n\nbool has_block[MAXN][MAXN];\nint cur_r, cur_c;\n\nint dr[] = {-1, 1, 0, 0}; // U, D, R, L\nint dc[] = {0, 0, 1, -1};\nchar dir_char[] = {'U', 'D', 'R', 'L'};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M;\n if (!(cin >> N >> M)) return 0;\n \n cin >> cur_r >> cur_c;\n \n vector> targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].first >> targets[i].second;\n }\n \n memset(has_block, 0, sizeof(has_block));\n vector> actions;\n \n for (int t = 0; t < M; t++) {\n int tr = targets[t].first;\n int tc = targets[t].second;\n \n // Step 1: Remove block on target if present\n if (has_block[tr][tc]) {\n // Move to adjacent position to target\n while (abs(cur_r - tr) + abs(cur_c - tc) > 1) {\n int best_d = -1;\n int best_dist = MAXN * MAXN;\n \n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr >= 0 && nr < MAXN && nc >= 0 && nc < MAXN && !has_block[nr][nc]) {\n int dist = abs(nr - tr) + abs(nc - tc);\n if (dist < best_dist) {\n best_dist = dist;\n best_d = d;\n }\n }\n }\n \n if (best_d == -1) break;\n \n actions.push_back({'M', dir_char[best_d]});\n cur_r += dr[best_d];\n cur_c += dc[best_d];\n }\n \n // Remove block on target (now adjacent)\n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr == tr && nc == tc) {\n actions.push_back({'A', dir_char[d]});\n has_block[nr][nc] = false;\n break;\n }\n }\n }\n \n // Step 2: Move to target position using moves (simple and reliable)\n while (abs(cur_r - tr) + abs(cur_c - tc) > 0) {\n int d = -1;\n if (cur_r != tr) {\n d = (cur_r < tr) ? 1 : 0; // D or U\n } else {\n d = (cur_c < tc) ? 2 : 3; // R or L\n }\n \n if (d != -1) {\n actions.push_back({'M', dir_char[d]});\n cur_r += dr[d];\n cur_c += dc[d];\n }\n }\n }\n \n // Output all actions\n for (auto& p : actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}"},"2":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Company {\n int id, x, y, r, a, b, c, d;\n \n long long area() const {\n return max(0LL, (long long)(c - a)) * max(0LL, (long long)(d - b));\n }\n \n bool containsPoint() const {\n return a <= x && x < c && b <= y && y < d;\n }\n};\n\nint n;\nvector companies;\nconst int GRID = 10000;\n\ndouble calculateScore(const vector& com) {\n double total = 0.0;\n for (const auto& c : com) {\n long long s = c.area();\n if (s <= 0 || !c.containsPoint()) continue;\n double ratio = min(c.r, s) / max((double)c.r, s);\n total += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return total;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n companies.resize(n);\n \n for (int i = 0; i < n; i++) {\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n companies[i].id = i;\n }\n \n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n // Initial placement - center around point (x, y)\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n long long target = c.r;\n long long w = max(1LL, (long long)sqrt(target * 2.0));\n long long h = max(1LL, target / w + 1LL);\n \n int a = max(0, min(c.x, c.x - (int)w / 2));\n int c_pos = min(GRID, max(c.x + 1, a + (int)w));\n int b = max(0, min(c.y, c.y - (int)h / 2));\n int d = min(GRID, max(c.y + 1, b + (int)h));\n \n c.a = a;\n c.b = b;\n c.c = c_pos;\n c.d = d;\n }\n \n long long initialScore = calculateScore(companies);\n \n // Simulated annealing optimization\n int iters = 200000;\n double temp = 2.0;\n \n for (int iter = 0; iter < iters; iter++) {\n int idx = uniform_int_distribution(0, n - 1)(rng);\n Company r = companies[idx];\n \n vector> candidates;\n candidates.emplace_back(r.a, r.b);\n \n // Try shifted positions\n for (int da = -50; da <= 50; da += 10) {\n for (int db = -50; db <= 50; db += 10) {\n int a = max(0, min(r.c - r.a, r.a + da));\n int b = max(0, min(r.d - r.b, r.b + db));\n candidates.emplace_back(a, b);\n }\n }\n \n // Try area optimization\n for (int w = max(1, (int)sqrt(r.r / 10)); w < 100; w++) {\n int h = max(1, r.r / w + 1);\n int a = max(0, min(r.x, r.x - w / 2));\n int b = max(0, min(r.y, r.y - h / 2));\n candidates.emplace_back(a, b);\n }\n \n int bestA = r.a, bestB = r.b;\n double bestNewScore = calculateScore(companies);\n \n for (auto [da, db] : candidates) {\n Company newR = r;\n newR.a = max(0, da);\n newR.b = max(0, db);\n \n // Keep same dimensions\n newR.c = max(newR.a + (r.c - r.a), newR.a + 1);\n newR.d = max(newR.b + (r.d - r.b), newR.b + 1);\n newR.c = min(GRID, newR.c);\n newR.d = min(GRID, newR.d);\n \n if (newR.containsPoint()) {\n companies[idx] = newR;\n double newScore = calculateScore(companies);\n if (newScore > bestNewScore) {\n bestNewScore = newScore;\n bestA = newR.a;\n bestB = newR.b;\n }\n companies[idx] = r;\n }\n }\n \n companies[idx].a = bestA;\n companies[idx].b = bestB;\n \n if (uniform_real_distribution(0, 1)(rng) > temp / 100.0) {\n companies[idx] = r; // Revert with probability\n }\n \n temp *= 0.997;\n }\n \n // Final check - all points must be contained\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n if (!c.containsPoint()) {\n long long w = max(1LL, c.r);\n long long h = max(1LL, c.r / w + 1LL);\n \n c.a = max(0, c.x);\n c.c = min(GRID, max(c.x + 1, c.a + (int)w));\n c.b = max(0, c.y);\n c.d = min(GRID, max(c.y + 1, c.b + (int)h));\n }\n }\n \n for (int i = 0; i < n; i++) {\n cout << companies[i].a << \" \" << companies[i].b << \" \" \n << companies[i].c << \" \" << companies[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int DX[] = {-1, 1, 0, 0};\nconst int DY[] = {0, 0, -1, 1};\n\nstruct Solver {\n int H = 50, W = 50;\n int si, sj;\n vector> p;\n vector> tile;\n vector tile_used;\n \n // Local state for current path exploration\n vector> path;\n int current_score;\n \n // Global best path found across multiple search attempts\n int global_best_score;\n vector> global_best_path;\n\n mt19937 rng;\n int backtrack_count;\n int run_count; // Count of search runs (restarts)\n\n Solver() {\n p.assign(H, vector(W));\n tile.assign(H, vector(W));\n // Seed RNG with high-resolution time\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count());\n }\n\n void read_input() {\n cin >> si >> sj;\n int max_id = 0;\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> tile[i][j];\n if (tile[i][j] > max_id) max_id = tile[i][j];\n }\n }\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> p[i][j];\n }\n }\n tile_used.assign(max_id + 1, false);\n }\n\n void init_path() {\n path.clear();\n path.push_back({si, sj});\n current_score = p[si][sj];\n fill(tile_used.begin(), tile_used.end(), false);\n tile_used[tile[si][sj]] = true;\n backtrack_count = 0;\n // IMPORTANT: Do NOT reset global_best_path or global_best_score\n }\n\n void start_new_search() {\n run_count++;\n // Reseed RNG to potentially explore different paths\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count() + run_count);\n init_path();\n \n // Update global best immediately with initial state\n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n }\n\n bool is_valid(int r, int c) {\n return r >= 0 && r < H && c >= 0 && c < W;\n }\n\n struct NeighborInfo {\n int r, c;\n int val;\n int degree; // Number of unvisited neighbors from this cell (heuristic for connectivity)\n };\n\n void get_neighbors(const pair& curr, vector& candidates) {\n candidates.clear();\n for (int d = 0; d < 4; ++d) {\n int nr = curr.first + DX[d];\n int nc = curr.second + DY[d];\n if (is_valid(nr, nc)) {\n int tid = tile[nr][nc];\n if (!tile_used[tid]) {\n // Calculate degree (connectivity heuristic)\n int deg = 0;\n for (int dd = 0; dd < 4; ++dd) {\n int nrr = nr + DX[dd];\n int ncc = nc + DY[dd];\n if (is_valid(nrr, ncc) && !tile_used[tile[nrr][ncc]]) {\n deg++;\n }\n }\n candidates.push_back({nr, nc, p[nr][nc], deg});\n }\n }\n }\n }\n\n void run() {\n read_input();\n global_best_score = 0;\n global_best_path.clear();\n run_count = 0;\n start_new_search();\n \n auto start_time = chrono::high_resolution_clock::now();\n \n vector candidates;\n \n // Time limit check (1.8s to be safe)\n const int TIME_LIMIT_MS = 1800; \n \n while(true) {\n auto now = chrono::high_resolution_clock::now();\n auto elapsed = chrono::duration_cast(now - start_time).count();\n \n if (elapsed > TIME_LIMIT_MS) break;\n\n auto [curr_r, curr_c] = path.back();\n get_neighbors({curr_r, curr_c}, candidates);\n\n if (!candidates.empty()) {\n // Sort candidates: First by value (descending), then by degree (descending)\n sort(candidates.begin(), candidates.end(), [](const NeighborInfo& a, const NeighborInfo& b) {\n if (a.val != b.val) return a.val > b.val;\n return a.degree > b.degree;\n });\n\n // Decision: Greedy or Random?\n // 20% chance to try random choice from top 3 to escape local optima\n int idx = 0;\n if (rng() % 100 < 20) { \n int limit = min((size_t)candidates.size(), (size_t)3);\n idx = rng() % limit;\n }\n \n const NeighborInfo& n = candidates[idx];\n \n // Extend path\n int nr = n.r;\n int nc = n.c;\n int tid = tile[nr][nc];\n \n path.push_back({nr, nc});\n tile_used[tid] = true;\n current_score += p[nr][nc];\n backtrack_count = 0; // Reset backtrack counter on success\n\n // Update global best score\n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n } else {\n // Stuck (no valid moves)\n backtrack_count++;\n \n if (path.size() >= 2) {\n auto [r, c] = path.back();\n int tid = tile[r][c];\n path.pop_back();\n current_score -= p[r][c];\n tile_used[tid] = false;\n } else {\n // Stuck at start (should not happen unless grid full or invalid)\n start_new_search();\n }\n \n // If we have backtracked too many times and are stuck at start, force restart\n // This handles cases where the search is looping without progress\n if (path.size() == 1 && backtrack_count > 20000) {\n start_new_search();\n }\n }\n }\n\n // Output the best path found as a string of moves\n string result = \"\";\n if (!global_best_path.empty()) {\n for (size_t i = 1; i < global_best_path.size(); ++i) {\n int dr = global_best_path[i].first - global_best_path[i-1].first;\n int dc = global_best_path[i].second - global_best_path[i-1].second;\n if (dr == -1) result += 'U';\n else if (dr == 1) result += 'D';\n else if (dc == -1) result += 'L';\n else if (dc == 1) result += 'R';\n }\n }\n cout << result << endl;\n }\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solver solver;\n solver.run();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Edge weights: h_edges[i][j] = horizontal edge at (i,j)-(i,j+1)\n// v_edges[i][j] = vertical edge at (i,j)-(i+1,j)\n// Initialized to ~1000-2000 (matches problem's expected range)\nvector> h_edges(29, vector(30, 1500.0));\nvector> v_edges(29, vector(30, 1500.0));\n\nstruct Node {\n int pos;\n double dist;\n bool operator>(const Node& other) const {\n return dist > other.dist;\n }\n};\n\nstruct Result {\n string path;\n double predicted_length;\n bool valid;\n};\n\nResult find_shortest_path(int si, int sj, int ti, int tj,\n const vector>& h, \n const vector>& v) {\n int n = 30;\n int total = n * n;\n vector dist(total, 1e18);\n vector parent(total, -1);\n vector dir(total, 0);\n \n priority_queue, greater> pq;\n \n dist[si * n + sj] = 0.0;\n pq.push({si * n + sj, 0.0});\n \n while (!pq.empty()) {\n Node top = pq.top();\n pq.pop();\n \n int u = top.pos;\n if (top.dist > dist[u]) continue;\n \n int ui = u / n;\n int uj = u % n;\n \n if (ui == ti && uj == tj) break;\n \n // Move U (up): from (ui,uj) to (ui-1,uj), uses v[ui-1][uj]\n if (ui > 0) {\n int v_pos = (ui - 1) * n + uj;\n double w = v[ui - 1][uj];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'U';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n \n // Move D (down): from (ui,uj) to (ui+1,uj), uses v[ui][uj]\n if (ui < n - 1) {\n int v_pos = (ui + 1) * n + uj;\n double w = v[ui][uj];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'D';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n \n // Move L (left): from (ui,uj) to (ui,uj-1), uses h[ui][uj-1]\n if (uj > 0) {\n int v_pos = ui * n + (uj - 1);\n double w = h[ui][uj - 1];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'L';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n \n // Move R (right): from (ui,uj) to (ui,uj+1), uses h[ui][uj]\n if (uj < n - 1) {\n int v_pos = ui * n + (uj + 1);\n double w = h[ui][uj];\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'R';\n pq.push({v_pos, dist[v_pos]});\n }\n }\n }\n \n if (dist[ti * n + tj] >= 1e17) {\n return {\"\", 0.0, false};\n }\n \n string path;\n int curr = ti * n + tj;\n while (curr != si * n + sj) {\n path += dir[curr];\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n \n return {path, dist[ti * n + tj], true};\n}\n\nvoid update_edge_weights(int si, int sj, int ti, int tj,\n const string& path, \n double predicted, int actual,\n vector>& h, \n vector>& v) {\n if (path.empty()) return;\n \n double error = (double)actual - predicted;\n int num_edges = path.length();\n double alpha = 0.18; // Learning rate (balanced for noisy data)\n double update = error * alpha / num_edges;\n \n int i = si, j = sj;\n int n = 30;\n \n for (char c : path) {\n if (c == 'U') {\n // Moved from (i,j) to (i-1,j), used v[i-1][j]\n if (i > 0 && i < n) {\n v[i - 1][j] += update;\n v[i - 1][j] = max(100.0, v[i - 1][j]);\n v[i - 1][j] = min(10000.0, v[i - 1][j]);\n }\n i--;\n } else if (c == 'D') {\n // Moved from (i,j) to (i+1,j), used v[i][j]\n if (i >= 0 && i < n) {\n v[i][j] += update;\n v[i][j] = max(100.0, v[i][j]);\n v[i][j] = min(10000.0, v[i][j]);\n }\n i++;\n } else if (c == 'L') {\n // Moved from (i,j) to (i,j-1), used h[i][j-1]\n if (j > 0 && j < n && i >= 0 && i < n) {\n h[i][j - 1] += update;\n h[i][j - 1] = max(100.0, h[i][j - 1]);\n h[i][j - 1] = min(10000.0, h[i][j - 1]);\n }\n j--;\n } else if (c == 'R') {\n // Moved from (i,j) to (i,j+1), used h[i][j]\n if (j >= 0 && j < n && i >= 0 && i < n) {\n h[i][j] += update;\n h[i][j] = max(100.0, h[i][j]);\n h[i][j] = min(10000.0, h[i][j]);\n }\n j++;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n int feedback;\n \n for (int k = 0; k < 1000; k++) {\n if (!(cin >> si >> sj >> ti >> tj)) break;\n \n Result result = find_shortest_path(si, sj, ti, tj, h_edges, v_edges);\n \n if (!result.valid) {\n // Fallback: should not happen on connected grid\n cout << \"UUUUUUUUU\\n\";\n cout.flush();\n cin >> feedback;\n continue;\n }\n \n cout << result.path << \"\\n\";\n cout.flush();\n \n cin >> feedback;\n \n update_edge_weights(si, sj, ti, tj, result.path,\n result.predicted_length, feedback,\n h_edges, v_edges);\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 20;\nconst int MAXM = 805;\n\nint M;\nstring s[MAXM];\nint len[MAXM];\nchar grid[N][N];\n\n// miscount[i][r][c][dir]\n// i: string index (0..M-1)\n// r, c: start position (row for horiz, col for vert)\n// dir: 0 horizontal, 1 vertical\n// The mismatch count for the placement starting at (r,c) with direction dir\nint miscount[MAXM][N][N][2];\n\n// sat_placements[i]: number of placements for string i that have 0 mismatches\nint sat_placements[MAXM];\nint total_satisfied; // Number of strings with at least 1 satisfied placement (sat_placements[i] > 0)\n\nint current_dots;\n\n// Apply a change of grid[r][c] from old_char to new_char\n// This function updates the global state: grid, current_dots, miscount, sat_placements, total_satisfied\nvoid apply_change(int r, int c, char old_char, char new_char) {\n if(new_char == '.' && old_char != '.') current_dots++;\n else if(new_char != '.' && old_char == '.') current_dots--;\n\n grid[r][c] = new_char;\n\n for(int i=0; i 0) {\n sat_placements[i]--;\n if(sat_placements[i] == 0) total_satisfied--;\n } else if(old_mc > 0 && new_mc == 0) {\n sat_placements[i]++;\n if(sat_placements[i] == 1) total_satisfied++;\n }\n }\n \n // Vertical placements covering (r, c)\n // Vertical placement starts at (start_v, c).\n for(int delta=0; delta 0) {\n sat_placements[i]--;\n if(sat_placements[i] == 0) total_satisfied--;\n } else if(old_mc > 0 && new_mc == 0) {\n sat_placements[i]++;\n if(sat_placements[i] == 1) total_satisfied++;\n }\n }\n }\n}\n\nint get_score() {\n int c = total_satisfied;\n // Score logic: prioritize c (max 10^8). If c=M, score depends on d (max 2*10^8).\n // We use a weight of 10000 for c to separate levels, and maximize d if c=M.\n int score = c * 10000;\n if(c == M) score += current_dots;\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n for(int i=0; i> s[i];\n len[i] = s[i].length();\n }\n\n // Initialize RNG\n mt19937 rng(time(0));\n \n // Initialize grid with random A-H\n current_dots = 0;\n for(int i=0; i 0) total_satisfied++;\n\n int best_score = get_score();\n char best_grid[N][N];\n for(int i=0; i 0) accept = true;\n else {\n double prob = exp(delta / T);\n double r_val = (double)rng() / (double)numeric_limits::max();\n if(r_val < prob) accept = true;\n }\n\n if(accept) {\n if(next_score > best_score) {\n best_score = next_score;\n for(int i=0; i\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\nint N;\nvector grid;\nint si, sj;\nvector> road_squares;\nchar dirs[] = {'U', 'D', 'L', 'R'};\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\n\nbool isValid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N && grid[r][c] != '#';\n}\n\nint bfs(int fr, int fc, int tr, int tc, string& path) {\n if (fr == tr && fc == tc) {\n path = \"\";\n return 0;\n }\n \n map, int> dist;\n priority_queue, vector>, greater>> pq;\n \n pq.push({0, fr, fc});\n dist[{fr, fc}] = 0;\n \n while (!pq.empty()) {\n auto [d, r, c] = pq.top();\n pq.pop();\n \n if (d > dist[{r, c}]) continue;\n \n if (r == tr && c == tc) {\n // Reconstruct path (simplified)\n return d;\n }\n \n for (int k = 0; k < 4; k++) {\n int nr = r + di[k];\n int nc = c + dj[k];\n \n if (!isValid(nr, nc)) continue;\n \n int cost = grid[nr][nc] - '0';\n int new_dist = d + cost;\n \n if (dist.find({nr, nc}) == dist.end() || new_dist < dist[{nr, nc}]) {\n dist[{nr, nc}] = new_dist;\n pq.push({new_dist, nr, nc});\n }\n }\n }\n \n return INT_MAX;\n}\n\n// Check visibility\nbool isVisible(int fr, int fc, int tr, int tc) {\n if (fr == tr) {\n int min_c = min(fc, tc), max_c = max(fc, tc);\n for (int c = min_c; c <= max_c; c++) {\n if (grid[fr][c] == '#') return false;\n }\n return true;\n } else if (fc == tc) {\n int min_r = min(fr, tr), max_r = max(fr, tr);\n for (int r = min_r; r <= max_r; r++) {\n if (grid[r][fc] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\nint getVisibilityCount(int r, int c) {\n int cnt = 0;\n for (auto& sq : road_squares) {\n if (isVisible(r, c, sq.first, sq.second)) cnt++;\n }\n return cnt;\n}\n\nint getTotalCost(const string& path) {\n int cr = si, cc = sj, cost = 0;\n for (char d : path) {\n for (int k = 0; k < 4; k++) {\n if (dirs[k] == d) {\n int nr = cr + di[k], nc = cc + dj[k];\n cost += grid[nr][nc] - '0';\n cr = nr, cc = nc;\n break;\n }\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> si >> sj;\n grid.resize(N);\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 road_squares.push_back({i, j});\n }\n }\n }\n \n string path = \"\";\n set> covered;\n auto addVisibility = [&](int r, int c) {\n for (auto& sq : road_squares) {\n if (isVisible(r, c, sq.first, sq.second)) {\n covered.insert(sq);\n }\n }\n };\n \n addVisibility(si, sj);\n \n // Greedy path building\n int cr = si, cc = sj;\n int max_iter = road_squares.size() * 2;\n \n for (int iter = 0; iter < max_iter; iter++) {\n int best_dist = INT_MAX;\n int best_r = -1, best_c = -1;\n pair best_sq = {-1, -1};\n \n // Score each unvisited square\n for (auto& sq : road_squares) {\n if (covered.count(sq)) continue;\n \n // Calculate visibility gain\n int visibility_gain = 0;\n for (auto& other : road_squares) {\n if (!covered.count(other) && isVisible(sq.first, sq.second, other.first, other.second)) {\n visibility_gain++;\n }\n }\n \n // Use BFS for distance (simplified)\n string test_path;\n int dist = bfs(cr, cc, sq.first, sq.second, test_path);\n \n if (dist < INT_MAX && visibility_gain > 0) {\n int score = visibility_gain * 100 - dist;\n if (score > 0 && (best_dist == INT_MAX || dist < best_dist)) {\n best_dist = dist;\n best_r = sq.first;\n best_c = sq.second;\n best_sq = sq;\n }\n }\n \n // Also consider squares that complete visibility\n if (visibility_gain == 0 && !covered.count(sq)) {\n for (auto& other : road_squares) {\n if (isVisible(sq.first, sq.second, other.first, other.second) && !covered.count(other)) {\n int d_test = bfs(cr, cc, sq.first, sq.second, test_path);\n if (d_test < INT_MAX && d_test > 0) {\n int d = d_test;\n if (best_dist == INT_MAX || d < best_dist * (covered.size() > 0 ? covered.size() : 1)) {\n best_dist = d;\n best_r = sq.first;\n best_c = sq.second;\n best_sq = sq;\n }\n }\n }\n }\n }\n }\n \n if (best_r != -1) {\n string segment;\n bfs(cr, cc, best_r, best_c, segment);\n path += segment;\n cr = best_r;\n cc = best_c;\n addVisibility(cr, cc);\n } else {\n break;\n }\n }\n \n // Return to start\n string ret_path;\n bfs(cr, cc, si, sj, ret_path);\n path += ret_path;\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\nusing namespace std;\n\nconst int MAXN = 1005;\nconst int MAXM = 25;\nconst int MAXK = 25;\n\nstruct Task {\n int id;\n vector d;\n vector dependencies;\n int status = -1; // -1: not started, 0: started, 1: completed\n int start_day = 0;\n int assigned_member = -1;\n vector predicted_completion_times;\n double expected_days = 1.0;\n};\n\nstruct Member {\n int id;\n vector prediction;\n int status = 0; // 0: free, >0: busy until this day\n int current_task = -1;\n vector> historical_completions; // {task_diff_score, actual_days}\n double skill_variance[MAXK];\n};\n\nint N, M, K, R;\nTask tasks[MAXN];\nMember members[MAXM];\nint day_count = 0;\n\nint calculate_difficulty(const vector& d) {\n int diff = 0;\n for (int val : d) diff += val;\n return diff;\n}\n\nint calculate_skill_gap(const vector& s, const vector& d) {\n int gap = 0;\n for (int k = 0; k < K; k++) {\n gap += max(0, d[k] - s[k]);\n }\n return gap;\n}\n\nbool can_start_task(int task_id) {\n for (int dep : tasks[task_id].dependencies) {\n if (tasks[dep].status != 1) return false;\n }\n return true;\n}\n\nbool all_tasks_completed() {\n for (int i = 0; i < N; i++) {\n if (tasks[i].status != 1) return false;\n }\n return true;\n}\n\nvoid update_skill_estimation(int member_id, int task_id, int days_taken) {\n auto& member = members[member_id];\n auto& task = tasks[task_id];\n \n // Store historical performance\n int difficulty = calculate_difficulty(task.d);\n member.historical_completions.push_back({difficulty, days_taken});\n \n // Simple estimation: try to reverse-engineer skill levels\n // If task took longer, member might have lower skill\n // For simplicity, we'll adjust prediction based on difficulty vs time\n if (member.prediction.empty()) {\n member.prediction.resize(K, 0);\n }\n \n // Use linear regression-like update\n for (int k = 0; k < K; k++) {\n int required = task.d[k];\n // More sophisticated would track per-skill, but we'll keep it simple\n double avg_time = member.historical_completions.back().second;\n double diff = task.d[k] - member.prediction[k];\n \n // Adjust prediction: if actual difficulty is higher, estimate lower skill\n if (avg_time > 1.0 && member.prediction[k] > 0) {\n member.prediction[k] = max(0, (int)(member.prediction[k] * 0.95 - 1));\n }\n }\n \n // Track skill variance for confidence\n for (int k = 0; k < K; k++) {\n member.skill_variance[k] *= 0.9; // Decay old estimates\n }\n}\n\ndouble evaluate_assignment(int member_id, int task_id) {\n auto& member = members[member_id];\n auto& task = tasks[task_id];\n \n if (member.prediction.empty()) {\n // No history, use difficulty heuristic\n return calculate_difficulty(task.d);\n }\n \n int gap = calculate_skill_gap(member.prediction, task.d);\n \n // Expected time based on gap\n double expected_time = max(1.0, (double)(gap + 1));\n \n // If prediction is uncertain, add penalty\n double uncertainty_penalty = 0;\n for (int k = 0; k < K; k++) {\n uncertainty_penalty += member.skill_variance[k];\n }\n \n return expected_time + uncertainty_penalty;\n}\n\nint count_outstanding_dependencies(int task_id) {\n int count = 0;\n for (int dep : tasks[task_id].dependencies) {\n if (tasks[dep].status != 1) count++;\n }\n return count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> M >> K >> R;\n \n // Read task difficulties\n for (int i = 0; i < N; i++) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; k++) {\n cin >> tasks[i].d[k];\n }\n }\n \n // Read dependencies\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].dependencies.push_back(u);\n }\n \n // Initialize members\n for (int i = 0; i < M; i++) {\n members[i].id = i;\n members[i].prediction.resize(K, 1); // Assume minimal skill initially\n for (int k = 0; k < K; k++) {\n members[i].skill_variance[k] = 10.0;\n }\n }\n \n vector completed_members;\n \n while (true) {\n day_count++;\n \n // Find assignable tasks\n vector assignable;\n for (int i = 0; i < N; i++) {\n if (tasks[i].status == -1 && can_start_task(i)) {\n assignable.push_back(i);\n }\n }\n \n // Sort by heuristic: dependency count, then difficulty, then predicted time\n sort(assignable.begin(), assignable.end(), [](int a, int b) {\n int dep_a = count_outstanding_dependencies(a);\n int dep_b = count_outstanding_dependencies(b);\n if (dep_a != dep_b) return dep_a < dep_b;\n \n int diff_a = calculate_difficulty(tasks[a].d);\n int diff_b = calculate_difficulty(tasks[b].d);\n if (diff_a != diff_b) return diff_a < diff_b;\n \n // Prefer tasks with lower expected time for current team\n return diff_a < diff_b; // Simplified\n });\n \n // Find free members\n vector free_members;\n for (int i = 0; i < M; i++) {\n if (members[i].status == 0) {\n free_members.push_back(i);\n }\n }\n \n // Output assignments\n vector> assignments;\n for (int m_idx = 0; m_idx < free_members.size() && m_idx < assignable.size(); m_idx++) {\n int member_id = free_members[m_idx];\n int task_id = assignable[m_idx];\n \n assignments.push_back({member_id, task_id});\n \n // Mark task as started\n tasks[task_id].status = 0;\n tasks[task_id].assigned_member = member_id;\n tasks[task_id].start_day = day_count;\n \n // Update member status\n members[member_id].status = 1;\n members[member_id].current_task = task_id;\n }\n \n // Output in required format\n cout << assignments.size();\n for (auto& assign : assignments) {\n cout << \" \" << (assign.first + 1) << \" \" << (assign.second + 1);\n }\n cout << endl;\n cout.flush();\n \n // Read completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n break;\n }\n \n completed_members.resize(n_completed);\n for (int i = 0; i < n_completed; i++) {\n cin >> completed_members[i];\n completed_members[i]--;\n }\n \n for (int member_id : completed_members) {\n int task_id = members[member_id].current_task;\n \n // Update task status\n tasks[task_id].status = 1;\n tasks[task_id].completion_day = day_count;\n \n // Update member status\n members[member_id].status = 0;\n \n // Update skill estimation\n int days_taken = day_count - tasks[task_id].start_day + 1;\n update_skill_estimation(member_id, task_id, days_taken);\n }\n \n // Visualize skill predictions (comment format)\n cout << flush;\n }\n \n return 0;\n}","ahc006":"```cpp\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global configuration\nconst int DEPOT_X = 400;\nconst int DEPOT_Y = 400;\nconst int N_ORDERS = 1000;\nconst int ORDERS_TO_SELECT = 50;\n\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nstruct Order {\n int id; \n int a, b; \n int c, d; \n double base_cost;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n vector orders(N_ORDERS);\n vector p(N_ORDERS);\n \n // Read input\n for (int i = 0; i < N_ORDERS; ++i) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i + 1; // 1-based\n orders[i].base_cost = (double)(dist(DEPOT_X, DEPOT_Y, orders[i].a, orders[i].b) +\n dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d) +\n dist(orders[i].c, orders[i].d, DEPOT_X, DEPOT_Y));\n p[i] = i;\n }\n \n // Sort orders by base cost to prioritize central clusters\n sort(p.begin(), p.end(), [&](int a, int b) {\n return orders[a].base_cost < orders[b].base_cost;\n });\n \n // Select a pool of candidates to search from (Top 80)\n int K = min(80, N_ORDERS);\n vector pool(K);\n for(int i = 0; i < K; ++i) pool[i] = p[i];\n \n // Initial subset: first 50 candidates\n vector subset;\n subset.reserve(ORDERS_TO_SELECT);\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) subset.push_back(pool[i]);\n \n vector best_subset = subset;\n int best_T = 2147483647;\n \n mt19937 rng(19991014); // Fixed seed\n \n // Structure to hold path coordinates\n struct PathData {\n vector> coords;\n vector path; \n int cost;\n };\n \n // Function to construct path and compute cost for a given subset\n PathData solve_subset_path(const vector& sub_set) {\n PathData res;\n res.path.reserve(102);\n \n // 0: Depot, 1..50: Pickups, 51..100: Deliveries\n res.coords.resize(101);\n res.coords[0] = {DEPOT_X, DEPOT_Y};\n \n for(int k = 0; k < ORDERS_TO_SELECT; ++k) {\n int idx = sub_set[k]; // index in 'orders'\n res.coords[k+1] = {orders[idx].a, orders[idx].b}; \n res.coords[k+51] = {orders[idx].c, orders[idx].d};\n }\n \n // Greedy Construction\n vector visited(101, false);\n vector pickup_done(50, false);\n res.path.push_back(0);\n int cx = DEPOT_X, cy = DEPOT_Y;\n \n for(int s = 0; s < 100; ++s) {\n int best_node = -1;\n int min_d = 2000000000;\n for(int node = 1; node <= 100; ++node) {\n if(!visited[node]) {\n if(node > 50) {\n int ord = node - 51;\n if(!pickup_done[ord]) continue;\n }\n int d = dist(cx, cy, res.coords[node].first, res.coords[node].second);\n if(d < min_d) { min_d = d; best_node = node; }\n }\n }\n if(best_node != -1) {\n visited[best_node] = true;\n res.path.push_back(best_node);\n cx = res.coords[best_node].first;\n cy = res.coords[best_node].second;\n if(best_node <= 50) pickup_done[best_node-1] = true;\n } else {\n break;\n }\n }\n res.path.push_back(0); // Return to Depot\n \n // Compute cost\n res.cost = 0;\n cx = DEPOT_X; cy = DEPOT_Y;\n for(size_t i = 0; i < res.path.size(); ++i) {\n cx = res.coords[res.path[i]].first; cy = res.coords[res.path[i]].second;\n if(i + 1 < res.path.size()) {\n int nx = res.coords[res.path[i+1]].first;\n int ny = res.coords[res.path[i+1]].second;\n res.cost += dist(cx, cy, nx, ny);\n }\n }\n \n return res;\n }\n \n // Function to optimize route given path (SA)\n void optimize_path(PathData& data) {\n int path_len = data.path.size();\n for(int iter = 0; iter < 20000; ++iter) {\n int i = rng() % (path_len - 1) + 1; \n int j = rng() % (path_len - 1) + 1;\n if(i == j) continue;\n \n int u = data.path[i];\n int v = data.path[j];\n \n // Validity check: If P and D of same order swapped\n if((u <= 50 && v == u + 50) || (v <= 50 && u == v + 50)) continue;\n \n data.path[i] = v;\n data.path[j] = u;\n \n // Check validity (P before D for all)\n bool valid = true;\n // Optimization: only check affected orders if possible, but O(N) check is safe enough\n for(int k = 1; k <= 50; ++k) {\n int P = k; int D = k+50;\n int posP = -1, posD = -1;\n for(int m = 0; m < path_len; ++m) {\n if(data.path[m] == P) posP = m;\n if(data.path[m] == D) posD = m;\n }\n if(posP > posD) { valid = false; break; }\n }\n \n if(valid) {\n int new_cost = 0;\n int cx = DEPOT_X, cy = DEPOT_Y;\n for(size_t m = 0; m < data.path.size() - 1; ++m) {\n cx = data.coords[data.path[m]].first;\n cy = data.coords[data.path[m]].second;\n int nx = data.coords[data.path[m+1]].first;\n int ny = data.coords[data.path[m+1]].second;\n new_cost += dist(cx, cy, nx, ny);\n }\n if(new_cost < data.cost) {\n data.cost = new_cost;\n } else {\n data.path[i] = u; \n data.path[j] = v;\n }\n } else {\n data.path[i] = u; \n data.path[j] = v;\n }\n }\n }\n \n // Iterate Subset Selection (Simulated Annealing / Hill Climbing)\n for(int iter = 0; iter < 1500; ++iter) {\n int i = rng() % 50;\n int j = rng() % (K - 50);\n int from_idx = subset[i];\n int to_idx = pool[50 + j];\n \n subset[i] = to_idx;\n \n PathData current_path_data = solve_subset_path(subset);\n optimize_path(current_path_data);\n \n if(current_path_data.cost < best_T) {\n best_T = current_path_data.cost;\n best_subset = subset;\n } else {\n subset[i] = from_idx; // Revert if not better\n }\n }\n \n // Final Optimization with best subset\n PathData final_path = solve_subset_path(best_subset);\n optimize_path(final_path);\n \n // Output\n cout << ORDERS_TO_SELECT << \" \";\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) {\n cout << orders[best_subset[i]].id << \" \";\n }\n cout << \"\\n102 \";\n for(int x : final_path.path) {\n int cx = final_path.coords[x].first;\n int cy = final_path.coords[x].second;\n cout << cx << \" \" << cy << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc007":"/*\n Heuristic Solution for AHC007\n Strategy:\n 1. Precompute Euclidean distances (d) for all edges offline.\n 2. Sort edges by d to determine their global Rank.\n 3. Since l_i is proportional to d_i, edges with lower Rank are expected to be cheaper.\n 4. Use a Rank Threshold (e.g., 2*N) to filter out \"expensive\" edges (high d).\n Given the problem generation ensures 5 MSTs in the edge set, connectivity is robust even with this filter.\n 5. Accept an edge if it connects two disjoint components AND its Rank is within the Threshold.\n This mimics Kruskal's algorithm on the subset of \"good\" edges.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Fixed problem parameters\nconst int FIXED_N = 400;\nconst int FIXED_M = 1995;\n\n// Edge structure\nstruct Edge {\n int u, v;\n int d; // Euclidean distance rounded\n int original_idx;\n};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = FIXED_N;\n int M = FIXED_M;\n\n // Read N vertices coordinates\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) {\n cin >> X[i] >> Y[i];\n }\n\n // Read M edge endpoints\n vector U(M), V(M);\n vector edges(M);\n\n for (int i = 0; i < M; ++i) {\n cin >> U[i] >> V[i];\n long long dx = X[U[i]] - X[V[i]];\n long long dy = Y[U[i]] - Y[V[i]];\n double dist = std::sqrt((double)dx * dx + (double)dy * dy);\n int d_val = std::round(dist);\n \n edges[i] = {U[i], V[i], d_val, i};\n }\n\n // Determine Rank for each edge based on 'd'\n // Rank 0 corresponds to the smallest Euclidean distance\n vector sorted_indices(M);\n std::iota(sorted_indices.begin(), sorted_indices.end(), 0);\n\n // Stable sort or simple sort based on distance\n std::sort(sorted_indices.begin(), sorted_indices.end(), [&](int a, int b) {\n if (edges[a].d != edges[b].d) {\n return edges[a].d < edges[b].d;\n }\n return a < b;\n });\n\n // Map original index to Rank\n vector rank_map(M);\n for (int i = 0; i < M; ++i) {\n rank_map[sorted_indices[i]] = i;\n }\n\n // Threshold for acceptable edge quality\n // We need to form a tree (N-1 edges).\n // T_1 (geometric MST) contains edges with smallest d.\n // We set limit to 2*N to ensure connectivity and capture T_1 + redundancy.\n int limit_rank = 2 * N; \n\n // DSU Setup\n vector parent(N);\n std::iota(parent.begin(), parent.end(), 0);\n\n // Iterative Find with Path Compression\n auto find = [&](int i) {\n int root = i;\n while (parent[root] != root) {\n root = parent[root];\n }\n int curr = i;\n while (curr != root) {\n int next = parent[curr];\n parent[curr] = root;\n curr = next;\n }\n return root;\n };\n\n // Union function\n auto unite = [&](int a, int b) {\n int rootA = find(a);\n int rootB = find(b);\n if (rootA != rootB) {\n parent[rootA] = rootB;\n return true;\n }\n return false;\n };\n\n // Process M queries online\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l; // Read revealed length l_i\n \n // Apply heuristic strategy:\n // 1. Reject if Rank is too high (edge is geometrically long/expensive)\n // 2. If within rank limit, accept if it reduces components (standard MST greedy)\n if (rank_map[i] > limit_rank) {\n cout << 0 << endl;\n } else {\n if (find(U[i]) != find(V[i])) {\n cout << 1 << endl;\n unite(U[i], V[i]);\n } else {\n cout << 0 << endl;\n }\n }\n // Flush output to satisfy interactive constraints\n cout.flush();\n }\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;\nusing namespace atcoder;\n\nclass Solver {\nprivate:\n int N, M;\n struct Pet {\n int px, py, type;\n };\n struct Human {\n int x, y;\n };\n \n vector pets;\n vector humans;\n bool blocked[35][35];\n \n mt19937 rng;\n int currentTurn;\n \n const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // U, D, L, R\n \n bool inBounds(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n // Check if position is blocked or occupied\n bool isBlocked(int x, int y, int turn, bool initial = false) {\n if (blocked[x][y]) return true;\n \n if (initial || turn == 0) {\n for (auto& p : pets) {\n if (p.px == x && p.py == y) return true;\n }\n for (auto& h : humans) {\n if (h.x == x && h.y == y) return true;\n }\n }\n \n // Check adjacency to pets (for blocking)\n for (auto& p : pets) {\n int dist = abs(p.px - x) + abs(p.py - y);\n if (dist <= 1 && (dist != 0)) return true;\n }\n \n return false;\n }\n \n int countReachable(int x, int y) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int count = 1;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n count++;\n q.push({nx, ny});\n }\n }\n }\n return count;\n }\n \n int countPetsInArea(int x, int y) {\n int count = 0;\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n reachable++;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n // Count pets in reachable area\n for (auto& p : pets) {\n if (reachable > 0 && inBounds(p.px, p.py)) {\n // Simple reachability check\n bool visited2[35][35];\n memset(visited2, 0, sizeof(visited2));\n if (canReach(p.px, p.y, x, y, visited2)) {\n count++;\n }\n }\n }\n \n return count;\n }\n \n bool canReach(int x1, int y1, int x2, int y2, bool& visited[35][35]) {\n // BFS to check reachability\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x1, y1});\n visited[x1][y1] = true;\n \n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n if (cx == x2 && cy == y2) return true;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n return false;\n }\n \n bool canReach(int x1, int y1, int x2, int y2) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n return canReach(x1, y1, x2, y2, visited);\n }\n \n // Choose best action for each human\n string decideAction(int humanIdx, int turn) {\n auto& h = humans[humanIdx];\n double bestScore = 0;\n string bestAction = \".\";\n \n // Evaluate all possible actions\n // Action: stay, block (4 directions), move (4 directions)\n \n // Try blocking\n for (int d = 0; d < 4; d++) {\n int bx = h.x + dirs[d][0];\n int by = h.y + dirs[d][1];\n \n bool valid = true;\n if (!inBounds(bx, by)) valid = false;\n if (blocked[bx][by]) valid = false;\n if (turn == 0) {\n // Initial positions - occupied check\n for (auto& p : pets) {\n if (p.px == bx && p.py == by || \n abs(p.px - bx) + abs(p.py - by) == 1) {\n valid = false;\n break;\n }\n }\n if (valid) {\n for (auto& h2 : humans) {\n if ((h2.x == bx && h2.y == by) ||\n (h2.x != h.x || h2.y != h.y) && \n abs(h2.x - bx) + abs(h2.y - by) <= 1) {\n valid = false;\n break;\n }\n }\n }\n }\n \n if (valid) {\n // Calculate score if we block\n blocked[bx][by] = true;\n double score = calculateScore(humanIdx);\n blocked[bx][by] = false;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"udlr\"[d]);\n }\n }\n }\n \n // Try moving\n for (int d = 0; d < 4; d++) {\n int nx = h.x + dirs[d][0];\n int ny = h.y + dirs[d][1];\n \n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[humanIdx] = {nx, ny};\n double score = calculateScore(humanIdx);\n humans[humanIdx] = h;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"UDLR\"[d]);\n }\n }\n }\n \n // Try staying\n double score = calculateScore(humanIdx);\n if (score > bestScore) {\n bestScore = score;\n bestAction = \".\";\n }\n \n return bestAction;\n }\n \n double calculateScore(int humanIdx) {\n auto& h = humans[humanIdx];\n int reachable = countReachable(h.x, h.y);\n int petCount = countPetsInArea(h.x, h.y);\n \n // Score: reachable/900 * 2^(-petCount)\n return (double)reachable / 900.0 / pow(2.0, petCount);\n }\n \npublic:\n Solver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n memset(blocked, 0, sizeof(blocked));\n }\n \n void solve() {\n // Read input\n cin >> N;\n pets.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].px >> pets[i].py >> pets[i].type;\n }\n \n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n \n // Simulate for all turns\n for (currentTurn = 0; currentTurn < MAX_TURNS; currentTurn++) {\n string output = \"\";\n \n for (int i = 0; i < M; i++) {\n output += decideAction(i, currentTurn);\n }\n \n cout << output << endl << flush;\n fflush(stdout);\n \n // Read pet movements\n for (int i = 0; i < M; i++) {\n string moves;\n cin >> moves;\n }\n \n // Update blocked based on blocking actions\n for (int i = 0; i < M; i++) {\n if (output.size() > i) {\n char act = output[i];\n if (act >= 'a' && act <= 'd') {\n // Blocking\n int d = (act == 'u') ? 0 : (act == 'd') ? 1 : (act == 'l') ? 2 : 3;\n int bx = humans[i].x + dirs[d][0];\n int by = humans[i].y + dirs[d][1];\n if (inBounds(bx, by)) {\n blocked[bx][by] = true;\n }\n } else if (act == 'U' || act == 'D' || act == 'L' || act == 'R') {\n // Moving\n int d = (act == 'U') ? 0 : (act == 'D') ? 1 : (act == 'L') ? 2 : 3;\n int nx = humans[i].x + dirs[d][0];\n int ny = humans[i].y + dirs[d][1];\n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[i] = {nx, ny};\n }\n }\n }\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solver solver;\n solver.solve();\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint dr[4] = {-1, 1, 0, 0};\nint dc[4] = {0, 0, -1, 1};\nchar moveChar[4] = {'U', 'D', 'L', 'R'};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int si, sj, ti, tj;\n double p;\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n // blocked[r][c][dir] = 1 if moving dir from (r,c) is blocked\n // Directions: 0: U, 1: D, 2: L, 3: R\n bool blocked[20][20][4];\n for(int r=0; r<20; ++r)\n for(int c=0; c<20; ++c)\n for(int d=0; d<4; ++d)\n blocked[r][c][d] = 0;\n\n // Read H walls (horizontal walls between columns)\n // h_{i,0} ... h_{i,18} -> 20 rows\n for (int i = 0; i < 20; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < 19; ++j) {\n if (row[j] == '1') {\n // Wall between (i, j) and (i, j+1)\n // R from (i, j) is blocked\n // L from (i, j+1) is blocked\n blocked[i][j][3] = 1; \n blocked[i][j+1][2] = 1; \n }\n }\n }\n \n // Read V walls (vertical walls between rows)\n // v_{0,0} ... v_{0,19} -> 19 rows (i=0 to 18)\n for (int i = 0; i < 19; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < 20; ++j) {\n if (row[j] == '1') {\n // Wall between (i, j) and (i+1, j)\n // D from (i, j) is blocked\n // U from (i+1, j) is blocked\n blocked[i][j][1] = 1; \n blocked[i+1][j][0] = 1; \n }\n }\n }\n\n const int L = 200;\n const int num_cells = 400;\n \n // dp[t][u] = max expected score starting at step t (1-based) from u\n // t ranges from 1 to L+1.\n // dp[L+1][u] = 0 (no steps left)\n vector> dp(L + 2, vector(num_cells, 0.0));\n \n int si_idx = si * 20 + sj;\n int goal_idx = ti * 20 + tj;\n \n double stay_prob = p;\n double move_prob = 1.0 - p;\n\n // Fill DP table from t = L down to 1\n for (int t = L; t >= 1; --t) {\n // Goal is absorbing state with 0 value for future\n dp[t][goal_idx] = 0.0; \n\n for (int u = 0; u < num_cells; ++u) {\n if (u == goal_idx) continue; \n\n int r = u / 20;\n int c = u % 20;\n\n double best_val = -1.0; // Scores are non-negative\n \n // Try all 4 moves\n for (int m = 0; m < 4; ++m) {\n double curr_val = 0.0;\n \n if (blocked[r][c][m]) {\n // Blocked: stay with prob 1.0 (forget or wall)\n // value = dp[t+1][u]\n curr_val = dp[t+1][u];\n } else {\n // Not blocked\n int nr = r + dr[m];\n int nc = c + dc[m];\n int v = nr * 20 + nc;\n \n // Calculate expected value\n // Recall (1-p): move to v\n // Forget (p): stay at u\n double term = 0.0;\n if (v == goal_idx) {\n // Arrive at Goal: immediate score (401 - t)\n term += move_prob * (401.0 - t);\n } else {\n term += move_prob * dp[t+1][v];\n }\n term += stay_prob * dp[t+1][u];\n curr_val = term;\n }\n \n if (curr_val > best_val) best_val = curr_val;\n }\n dp[t][u] = best_val;\n }\n }\n\n // Greedy construction of the string\n vector prob(num_cells, 0.0);\n prob[si_idx] = 1.0;\n \n string res;\n res.reserve(L);\n \n for (int t = 1; t <= L; ++t) {\n int best_m = -1;\n double max_exp = -1.0;\n \n // Evaluate each move to maximize expected score\n for (int m = 0; m < 4; ++m) {\n double exp_score = 0.0;\n \n // Iterate over all possible current states\n for (int u = 0; u < num_cells; ++u) {\n double p_u = prob[u];\n if (p_u < 1e-10) continue;\n \n // If at Goal, value contribution is 0 (dp[t+1][Goal]-based logic yields 0)\n if (u == goal_idx) continue;\n \n int r = u / 20;\n int c = u % 20;\n \n double val = 0.0;\n if (blocked[r][c][m]) {\n val = dp[t+1][u];\n } else {\n int nr = r + dr[m];\n int nc = c + dc[m];\n int v = nr * 20 + nc;\n \n if (v == goal_idx) {\n val += move_prob * (401.0 - t);\n } else {\n val += move_prob * dp[t+1][v];\n }\n val += stay_prob * dp[t+1][u];\n }\n exp_score += p_u * val;\n }\n \n if (exp_score > max_exp) {\n max_exp = exp_score;\n best_m = m;\n }\n }\n \n // Append move\n res += moveChar[best_m];\n \n // Update probabilities using the chosen move\n vector next_prob(num_cells, 0.0);\n for (int u = 0; u < num_cells; ++u) {\n double p_u = prob[u];\n if (p_u < 1e-10) continue;\n \n // Goal is absorbing (stops execution)\n if (u == goal_idx) {\n next_prob[goal_idx] += p_u;\n continue;\n }\n \n int r = u / 20;\n int c = u % 20;\n \n if (blocked[r][c][best_m]) {\n // Stay with prob 1 (blocked move or forget)\n next_prob[u] += p_u;\n } else {\n // Forget -> stay at u\n next_prob[u] += p_u * stay_prob;\n // Recall -> move to v\n int nr = r + dr[best_m];\n int nc = c + dc[best_m];\n int v = nr * 20 + nc;\n next_prob[v] += p_u * move_prob;\n }\n }\n prob = next_prob;\n }\n \n cout << res << endl;\n\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Grid dimensions\nconst int N = 30;\n\n// Global variables\nint tiles[N][N];\nint r_rot[N][N]; // Current rotation for each tile (0-3)\nint trans[8][4][4]; // Precomputed transitions: trans[type][rotation][entry_dir]\nint t_map[8][4]; // Base transitions for unrotated tiles\n\n// For path tracing and loop detection\nbool vis[N][N][4]; // Visited status to skip redundant checks\nint trace_token[N][N][4]; // Token to track node visitation in current trace\nint global_token = 0; // Incremented for each score calculation\n\n// Path arrays to store visited nodes in the current trace\nint path_i[2500];\nint path_j[2500];\nint path_d[2500];\n\n// Movement vectors: 0=Left, 1=Up, 2=Right, 3=Down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nlong long current_score = 0;\n\n// Initialize the transition tables based on the problem description\nvoid init_to() {\n int base[8][4] = {\n {1, 0, -1, -1}, // 0: [1, 0, -1, -1]\n {3, -1, -1, 0}, // 1: [3, -1, -1, 0]\n {-1, -1, 3, 2}, // 2: [-1, -1, 3, 2]\n {-1, 2, 1, -1}, // 3: [-1, 2, 1, -1]\n {1, 0, 3, 2}, // 4: [1, 0, 3, 2]\n {3, 2, 1, 0}, // 5: [3, 2, 1, 0]\n {2, -1, 0, -1}, // 6: [2, -1, 0, -1]\n {-1, 3, -1, 1} // 7: [-1, 3, -1, 1]\n };\n \n for (int r = 0; r < 8; ++r) {\n // Copy base map for reference/debugging\n for (int d = 0; d < 4; ++d) t_map[r][d] = base[r][d];\n \n // Compute transitions for each rotation 0 to 3\n for (int rot = 0; rot < 4; ++rot) {\n for (int d = 0; d < 4; ++d) {\n // Physical port d maps to logical port (d - rot + 4) % 4\n // Logical output maps to physical port (out + rot) % 4\n int d_internal = (d - rot + 4) % 4;\n int out_internal = base[r][d_internal];\n \n if (out_internal == -1) {\n trans[r][rot][d] = -1;\n } else {\n trans[r][rot][d] = (out_internal + rot) % 4;\n }\n }\n }\n }\n}\n\n// Calculate the score: L_1 * L_2\nlong long calculate_score() {\n // Use tokens to avoid resetting visited arrays completely\n global_token++;\n if (global_token == 0) { \n // Overflow handling\n memset(trace_token, 0, sizeof(trace_token));\n memset(vis, 0, sizeof(vis));\n global_token = 1;\n }\n \n // Collect all loop lengths\n // Using a static buffer for speed, though capacity 900 is small enough\n int lengths[500];\n int num_lengths = 0;\n \n // Iterate over all ports (i, j, d)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int d = 0; d < 4; ++d) {\n // Skip if already visited\n if (vis[i][j][d]) continue;\n \n int path_len = 0;\n int ci = i, cj = j, cd = d;\n \n // Trace the path\n while (true) {\n // Check boundary\n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n\n // Check trace status\n // If token matches current trace, we found a loop within the current path\n if (trace_token[ci][cj][cd] == global_token) {\n // Found a cycle. We need to calculate the length of the loop.\n // The repeated node is (ci, cj, cd).\n // Find where it appears in the path.\n int loop_len = 0;\n for (int k = 0; k < path_len; ++k) {\n if (path_i[k] == ci && path_j[k] == cj && path_d[k] == cd) {\n loop_len = path_len - k;\n break;\n }\n }\n if (loop_len > 0) {\n lengths[num_lengths++] = loop_len;\n }\n break; \n }\n \n // If visited by previous trace (token > 0 and != global_token), it's a merged path.\n if (trace_token[ci][cj][cd] > 0) {\n break;\n }\n \n // Mark as visited in current trace and globally\n trace_token[ci][cj][cd] = global_token;\n vis[ci][cj][cd] = true;\n \n // Add to path\n path_i[path_len] = ci;\n path_j[path_len] = cj;\n path_d[path_len] = cd;\n path_len++;\n \n // Move to next port\n int type = tiles[ci][cj];\n int rot = r_rot[ci][cj];\n int nd = trans[type][rot][cd];\n \n if (nd == -1) break; // Broken link\n \n int ni = ci + di[nd];\n int nj = cj + dj[nd];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) break; // Boundary\n \n ci = ni; cj = nj; \n cd = (nd + 2) % 4; // Direction to enter next tile\n }\n }\n }\n }\n \n if (num_lengths < 2) return 0;\n \n // Sort to find the two largest\n sort(lengths, lengths + num_lengths, greater());\n \n return (long long)lengths[0] * lengths[1];\n}\n\n// Random number generation\nmt19937 rng(1337);\nuniform_int_distribution dist_rot(0, 3);\nuniform_int_distribution dist_pos(0, 29);\nuniform_real_distribution dist_rand_p(0.0, 1.0);\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_to();\n \n // Read input and initialize random rotations\n for (int i = 0; i < N; ++i) {\n string row;\n if (!(cin >> row)) return 0;\n for (int j = 0; j < N; ++j) {\n tiles[i][j] = row[j] - '0';\n r_rot[i][j] = dist_rot(rng);\n }\n }\n \n // Simulated Annealing Parameters\n // Run multiple iterations to optimize\n int iterations = 60000;\n double T_0 = 1000.0;\n double T_final = 0.0001;\n \n long long global_best_score = calculate_score();\n int best_r[N][N];\n // Save initial state\n for(int i=0; i current_score) {\n accept = true;\n } else if (score >= current_score) {\n accept = true; // Equal score usually accepted\n } else {\n double exp_val = exp((double)(score - current_score) / T);\n if (exp_val > p_accept) {\n accept = true;\n }\n }\n \n if (accept) {\n current_score = score;\n if (score > global_best_score) {\n global_best_score = score;\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 10;\nconst int MAX_BOARD_SIZE = MAX_N * MAX_N;\nconst int BEAM_WIDTH = 60; \nconst int MAX_NODES = 1000000; \n\nstruct Node {\n int board[MAX_BOARD_SIZE];\n int empty_pos;\n int score;\n int parent_idx; \n char move_char;\n};\n\nvector all_nodes;\nint parent[MAX_BOARD_SIZE];\nint sz[MAX_BOARD_SIZE];\nbool is_cyclic[MAX_BOARD_SIZE];\n\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nint dsu_find(int i);\nvoid dsu_union(int i, int j);\nvoid dsu_init(int n);\n\nvoid dsu_init(int n) {\n for (int i = 0; i < n; ++i) {\n parent[i] = i;\n sz[i] = 1;\n is_cyclic[i] = false;\n }\n}\n\nint dsu_find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = dsu_find(parent[i]);\n}\n\nvoid dsu_union(int i, int j) {\n int root_i = dsu_find(i);\n int root_j = dsu_find(j);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n}\n\nint get_score(const int* board, int n, int empty_pos) {\n dsu_init(n);\n for (int r = 0; r < n; ++r) {\n for (int c = 0; c < n; ++c) {\n int idx = r * n + c;\n if (board[idx] == 0) continue;\n if (c < n - 1) {\n int neighbor_idx = idx + 1;\n if (board[neighbor_idx] != 0) {\n if ((board[idx] & 4) && (board[neighbor_idx] & 1)) {\n dsu_union(idx, neighbor_idx);\n }\n }\n }\n if (r < n - 1) {\n int neighbor_idx = idx + n;\n if (board[neighbor_idx] != 0) {\n if ((board[idx] & 8) && (board[neighbor_idx] & 2)) {\n dsu_union(idx, neighbor_idx);\n }\n }\n }\n }\n }\n \n int max_tree_size = 0;\n vector processed_root(n, false); // n = n*n in previous logic, changed to n*n size\n int nn = n * n;\n \n // Reset processed_root for size nn\n // Actually inside function, vector init is fine, but need to be size nn\n processed_root.assign(nn, false);\n\n for (int i = 0; i < nn; ++i) {\n if (board[i] == 0) continue;\n int root = dsu_find(i);\n if (processed_root[root]) continue;\n processed_root[root] = true;\n \n if (!is_cyclic[root]) {\n if (sz[root] > max_tree_size) {\n max_tree_size = sz[root];\n }\n }\n }\n return max_tree_size;\n}\n\nstring reconstruct_path(int node_idx) {\n string path = \"\";\n int current = node_idx;\n while (all_nodes[current].parent_idx != -1) {\n path += all_nodes[current].move_char;\n current = all_nodes[current].parent_idx;\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 int N, T;\n if (!(cin >> N >> T)) return 0;\n\n all_nodes.reserve(MAX_NODES);\n \n Node start_node;\n memset(start_node.board, 0, sizeof(start_node.board));\n start_node.parent_idx = -1;\n start_node.move_char = 0;\n int empty_pos = -1;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c;\n cin >> c;\n int val = 0;\n if (isdigit(c)) val = c - '0';\n else val = 10 + (c - 'a');\n start_node.board[i * N + j] = val;\n if (val == 0) {\n empty_pos = i * N + j;\n }\n }\n }\n start_node.empty_pos = empty_pos;\n start_node.score = get_score(start_node.board, N, empty_pos);\n \n all_nodes.push_back(start_node);\n\n vector current_layer;\n vector next_layer;\n current_layer.push_back(0);\n \n int best_node_idx = 0;\n int max_score = start_node.score;\n\n for (int step = 1; step <= T; ++step) {\n next_layer.clear();\n for (int idx : current_layer) {\n Node u = all_nodes[idx];\n int er = u.empty_pos / N;\n int ec = u.empty_pos % N;\n \n for (int k = 0; k < 4; ++k) {\n int nr = er + dr[k];\n int nc = ec + dc[k];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (u.parent_idx != -1) {\n char prev_move = all_nodes[idx].move_char;\n if ((prev_move == 'U' && k == 1) ||\n (prev_move == 'D' && k == 0) ||\n (prev_move == 'L' && k == 3) ||\n (prev_move == 'R' && k == 2)) {\n continue; \n }\n }\n \n Node v = u;\n v.empty_pos = nr * N + nc;\n v.board[u.empty_pos] = u.board[v.empty_pos];\n v.board[v.empty_pos] = 0;\n \n v.parent_idx = idx;\n v.move_char = dir_char[k];\n // v.id = all_nodes.size(); // Removed as node index in vector suffices\n \n v.score = get_score(v.board, N, v.empty_pos);\n \n if (v.score == N * N - 1) {\n cout << reconstruct_path((int)all_nodes.size()) << endl;\n return 0;\n }\n \n all_nodes.push_back(v);\n next_layer.push_back((int)all_nodes.size() - 1);\n }\n }\n }\n \n if (next_layer.empty()) break;\n \n sort(next_layer.begin(), next_layer.end(), [&](int a, int b) {\n return all_nodes[a].score > all_nodes[b].score;\n });\n \n current_layer.clear();\n int limit = min((int)next_layer.size(), BEAM_WIDTH);\n for (int i = 0; i < limit; ++i) {\n current_layer.push_back(next_layer[i]);\n if (all_nodes[next_layer[i]].score > max_score) {\n max_score = all_nodes[next_layer[i]].score;\n best_node_idx = next_layer[i];\n }\n }\n }\n \n if (max_score < N * N - 1) {\n cout << reconstruct_path(best_node_idx) << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n\n// AC Library (optional for competitive programming)\n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Data structures\nstruct Point {\n long long x, y;\n};\n\nstruct Line {\n double A, B, C; // Ax + By + C = 0\n};\n\n// Global variables to avoid passing too many parameters\nint N, K;\nvector a(11);\nvector strawberries;\nvector lines;\nvector best_lines;\nvector, int>> sigs; // Stores {signature, original_index}\nvector, int>> temp_sigs; // Reuse buffer if possible, but local is safer for lambda\n// Actually, we'll define sigs inside lambda or make it global. Making it global and resizing once is efficient.\n// But lambda needs access. Let's pass sigs or capture.\n// Let's stick to capturing global 'sigs' or local 'sigs' in main.\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> K)) return 0;\n\n // Read a_d\n int sum_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n sum_a += a[i];\n }\n\n // Read strawberries\n strawberries.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n\n // Random number generator\n mt19937 rng(12345); // Fixed seed for reproducibility\n vector current_lines(K);\n const double PI = 3.14159265358979323846;\n\n // Initialize lines randomly\n for (int i = 0; i < K; ++i) {\n double angle = uniform_real_distribution(0, 2 * PI)(rng);\n current_lines[i].A = cos(angle);\n current_lines[i].B = sin(angle);\n // r is distance from origin. Points are within 10^4 radius.\n // Lines with |C| roughly <= 12000 will intersect the cake significantly.\n double r = uniform_real_distribution(-12000.0, 12000.0)(rng);\n current_lines[i].C = -r;\n }\n\n // Resize sigs vector\n sigs.resize(N);\n\n // Helper lambda to calculate score\n // Note: Using global 'lines' is not possible inside lambda without capture if defined outside.\n // We will capture 'lines' by reference. But since 'lines' changes, we should pass 'lines' or use a shared global.\n // To avoid overhead, I'll implement a function that takes lines as argument.\n auto calculate_score = [&](const vector& curr_lines) -> int {\n // Compute signatures\n for (int i = 0; i < N; ++i) {\n pair sig = {0, 0};\n for (int k = 0; k < K; ++k) {\n double val = curr_lines[k].A * strawberries[i].x + \n curr_lines[k].B * strawberries[i].y + \n curr_lines[k].C;\n // Check side. val >= 0 implies on one side.\n if (val >= 0) {\n if (k < 64) sig.first |= (1LL << k);\n else sig.second |= (1LL << (k - 64));\n }\n }\n sigs[i] = {sig, i};\n }\n\n // Sort signatures to group points by region\n sort(sigs.begin(), sigs.end(), [](const auto& a, const auto& b) {\n if (a.first != b.first) return a.first < b.first; // Compare signatures\n return a.second < b.second;\n });\n\n int cnt[11] = {0}; // b_1 ... b_10\n int current_run = 0;\n for (int i = 0; i < N; ++i) {\n current_run++;\n // Check if next point has different signature\n bool next_diff = (i + 1 == N) || (sigs[i+1].first != sigs[i].first);\n if (next_diff) {\n // Region ended\n if (current_run >= 1 && current_run <= 10) {\n cnt[current_run]++;\n }\n current_run = 0;\n }\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(cnt[d], a[d]);\n }\n return score;\n };\n\n // SA Initialization\n int current_score = calculate_score(current_lines);\n int best_score = current_score;\n best_lines = current_lines;\n\n // SA Parameters\n int num_iterations = 2000; // Adjust based on time limit\n double T = 100000.0; \n double decay = 0.9995; \n\n // SA Loop\n for (int iter = 0; iter < num_iterations; ++iter) {\n double T_iter = T * pow(decay, iter); \n // Or simpler: T *= decay;\n \n // Choose a random line to perturb\n int idx = (rng()() % K);\n\n // Backup current line\n Line old_line = lines[idx]; // Wait, lines is not global in the scope of lambda, need to fix\n // Actually I defined 'lines' as a vector in main. But I need to update 'lines' inside the loop?\n // My lambda takes 'curr_lines'. So I must update 'current_lines' in the main scope if accepted.\n // But I need to backtrack.\n \n // Let's use 'current_lines' as the state.\n Line backup = current_lines[idx];\n\n // Perturb\n double phi = atan2(current_lines[idx].B, current_lines[idx].A);\n double angle_change = (uniform_real_distribution(-0.02, 0.02))(rng);\n current_lines[idx].A = cos(phi + angle_change);\n current_lines[idx].B = sin(phi + angle_change);\n\n double C_change = (uniform_real_distribution(-10.0, 10.0))(rng);\n current_lines[idx].C += C_change;\n\n // Calculate new score\n int new_score = calculate_score(current_lines);\n\n // SA Decision\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n // Probabilistic acceptance\n // diff = new - current (negative)\n double prob = exp((double)(new_score - current_score) / T_iter);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n best_lines = current_lines;\n }\n } else {\n // Revert\n current_lines[idx] = backup;\n }\n }\n\n // Output best lines\n cout << K << \"\\n\";\n \n // Convert best_lines to integer points\n for (int k_idx = 0; k_idx < K; ++k_idx) {\n double A = best_lines[k_idx].A;\n double B = best_lines[k_idx].B;\n double C = best_lines[k_idx].C;\n\n // Find two points on the line.\n // Line: Ax + By + C = 0.\n // Closest point to origin: P0 = (-AC, -BC).\n // Since A^2+B^2=1.\n \n long long x0 = (long long)round(-A * C);\n long long y0 = (long long)round(-B * C);\n\n // Direction vector (-B, A)\n // Scale it to find a second point\n double dx = -B;\n double dy = A;\n long long S = 2000; // Scale factor\n\n long long px1 = x0;\n long long py1 = y0;\n long long px2 = x0 + (long long)round(dx * S);\n long long py2 = y0 + (long long)round(dy * S);\n\n // Safety check to ensure distinct points\n if (px1 == px2 && py1 == py2) {\n // Fallback if direction vector rounds to 0 (unlikely with A^2+B^2=1)\n px2 += 1000; \n // Adjust py2 to maintain line equation if possible, but any distinct point works for valid line output\n // However, we want line to match best approximation.\n // If px2 was 0 (due to round), we move it.\n // Just ensure it's far away enough from x1, y1.\n // But if we move arbitrarily, the line might not match the optimized one.\n // The line should still be close.\n // Since we can't easily fix without complex math, this fallback is risky.\n // However, with S=2000 and A^2+B^2=1, at least one component of (dx, dy) is > 0.7 or similar?\n // No. dx = -B, dy = A. If B=0, dx=0. dy=1. Then py2=py1+2000. Distinct.\n // If A=0, B=1. dx=-1. dy=0. px2=px1-2000. Distinct.\n // So (dx, dy) is never (0,0).\n // But rounding can make them 0.\n // So the code above handles it.\n // In the very unlikely case it fails, we do:\n // px1+=100. (Still within bounds).\n px2 += 1000;\n if (px1 == px2) {\n px2 -= 1000; // Should be fine unless very small coords?\n }\n }\n\n // Output\n cout << px1 << \" \" << py1 << \" \" << px2 << \" \" << py2 << \"\\n\";\n }\n\n return 0;\n}","ahc014":" while (cx != b.x || cy != b.y) {\n if (has_dot[cx][cy]) return true;\n cx += dx_step;\n cy += dy_step;\n }","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\nint grid[N][N];\nint flavors[100];\n\n// Calculate score for a given grid configuration\nint calculate_score(int arr[N][N]) {\n int score = 0;\n bool visited[N][N];\n memset(visited, 0, sizeof(visited));\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (arr[r][c] != 0 && !visited[r][c]) {\n int current_flavor = arr[r][c];\n int count = 0;\n \n // BFS\n int q_r[N*N], q_c[N*N]; \n int head = 0, tail = 0;\n \n q_r[tail] = r; q_c[tail] = c;\n visited[r][c] = true;\n tail++;\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n \n while(head < tail) {\n int cr = q_r[head];\n int cc = q_c[head];\n head++;\n count++;\n \n for(int k=0; k<4; ++k) {\n int nr = cr + dr[k];\n int nc = cc + dc[k];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if(!visited[nr][nc] && arr[nr][nc] == current_flavor) {\n visited[nr][nc] = true;\n q_r[tail] = nr;\n q_c[tail] = nc;\n tail++;\n }\n }\n }\n }\n score += count * count;\n }\n }\n }\n return score;\n}\n\n// Helper to apply a move to a grid\nvoid apply_move(int grid[N][N], char dir) {\n int next_grid[N][N];\n memset(next_grid, 0, sizeof(next_grid));\n \n if (dir == 'F') { // Forward -> Top (Up)\n for (int c = 0; c < N; ++c) {\n int write_idx = 0;\n for (int r = 0; r < N; ++r) {\n if (grid[r][c] != 0) {\n next_grid[write_idx][c] = grid[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'B') { // Backward -> Bottom (Down)\n for (int c = 0; c < N; ++c) {\n int write_idx = N - 1;\n for (int r = N - 1; r >= 0; --r) {\n if (grid[r][c] != 0) {\n next_grid[write_idx][c] = grid[r][c];\n write_idx--;\n }\n }\n }\n } else if (dir == 'L') { // Left -> Left edge\n for (int r = 0; r < N; ++r) {\n int write_idx = 0;\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n next_grid[r][write_idx] = grid[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'R') { // Right -> Right edge\n for (int r = 0; r < N; ++r) {\n int write_idx = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid[r][c] != 0) {\n next_grid[r][write_idx] = grid[r][c];\n write_idx--;\n }\n }\n }\n }\n \n memcpy(grid, next_grid, sizeof(grid));\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Seed random for tie-breaking\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n mt19937 gen(seed);\n\n // Read flavor sequence\n for (int t = 0; t < 100; ++t) {\n cin >> flavors[t];\n }\n\n // Main interaction loop\n for (int t = 0; t < 100; ++t) {\n int p;\n cin >> p;\n \n // Find the p-th empty cell in reading order\n int count = 0;\n bool found = false;\n int r_target = 0, c_target = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] == 0) {\n count++;\n if (count == p) {\n r_target = i;\n c_target = j;\n found = true;\n break;\n }\n }\n }\n if (found) break;\n }\n \n // Place the candy\n if (found) {\n grid[r_target][c_target] = flavors[t];\n }\n\n // Determine tilt direction\n // Problem note: For the 100th step (index 99), we may skip output.\n // We skip output for t == 99 to match the specific instruction \"skip the output\".\n // If t < 99, we must output a tilt direction.\n if (t < 99) { \n char best_move = 'F';\n int best_score = -1;\n \n char moves[] = {'F', 'B', 'L', 'R'};\n \n // Randomize order for tie-breaking fairness\n vector idx(4);\n for(int i=0; i<4; ++i) idx[i] = i;\n shuffle(idx.begin(), idx.end(), gen);\n\n for (auto i : idx) {\n char dir = moves[i];\n // Simulate the move on a copy of the grid\n int sim_grid[N][N];\n memcpy(sim_grid, grid, sizeof(sim_grid));\n \n // Apply move to simulation copy\n apply_move(sim_grid, dir);\n \n // Calculate score\n int score = calculate_score(sim_grid);\n \n // Greedy update\n if (best_score == -1 || score > best_score) {\n best_score = score;\n best_move = dir;\n }\n }\n \n cout << best_move << endl;\n \n // Apply the selected move to the real grid\n apply_move(grid, best_move);\n }\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Graph class with essential operations\nclass Graph {\npublic:\n int n;\n std::vector adj;\n std::vector> adj_matrix;\n \n Graph(int n = 0) : n(n) {\n adj_matrix = n > 0 ? std::vector>(n, std::vector(n, 0)) : std::vector>();\n if (n > 0) {\n int total_edges = n * (n - 1) / 2;\n adj.assign(total_edges, 0);\n }\n }\n \n static Graph fromString(const std::string& s, int n) {\n Graph G(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n G.adj[idx] = s[idx] - '0';\n G.adj_matrix[i][j] = G.adj_matrix[j][i] = G.adj[idx];\n idx++;\n }\n }\n return G;\n }\n \n std::string toString() const {\n std::string s = \"\";\n for (int x : adj) s += std::to_string(x);\n return s;\n }\n \n int edgeCount() const {\n return std::accumulate(adj.begin(), adj.end(), 0);\n }\n \n std::vector degreeSequence() const {\n std::vector deg(n, 0);\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (adj_matrix[i][j]) {\n deg[i]++;\n deg[j]++;\n }\n }\n }\n std::sort(deg.begin(), deg.end());\n return deg;\n }\n};\n\n// Weisfeiler-Lehman hash for rotation-invariant fingerprint\nclass WLHash {\nprivate:\n mutable int n;\n mutable std::vector labels;\n \npublic:\n WLHash(int n = 0) : n(n) {}\n \n std::vector compute(const Graph& G, int iterations = 4) const {\n std::vector labels_sorted = G.degreeSequence();\n labels = labels_sorted;\n \n for (int iter = 0; iter < iterations; iter++) {\n std::vector new_labels(G.n, 0);\n for (int i = 0; i < G.n; i++) {\n std::vector neighbor_labels;\n for (int j = 0; j < G.n; j++) {\n if (G.adj_matrix[i][j]) {\n neighbor_labels.push_back(labels[j]);\n }\n }\n std::sort(neighbor_labels.begin(), neighbor_labels.end());\n \n unsigned long h = labels[i];\n for (int nl : neighbor_labels) {\n h = (h * 37 + nl) % (G.n * G.n + 100);\n }\n new_labels[i] = h % 1000003;\n }\n labels = new_labels;\n }\n return labels;\n }\n \n long long signature() const {\n std::vector sorted_labels = labels;\n std::sort(sorted_labels.begin(), sorted_labels.end());\n long long sum = 0;\n for (int l : sorted_labels) sum += l;\n return sum;\n }\n};\n\n// Graph feature for fast filtering\nstruct GraphFeature {\n int edgeCount;\n std::vector degreeSeq;\n long long wlHashSignature;\n \n // Default constructor\n GraphFeature() : edgeCount(0), wlHashSignature(0) {}\n \n // Parameterized constructor\n GraphFeature(const Graph& G, const WLHash& wl) {\n edgeCount = G.edgeCount();\n degreeSeq = G.degreeSequence();\n std::vector labels = wl.compute(G);\n std::vector sorted_labels = labels;\n std::sort(sorted_labels.begin(), sorted_labels.end());\n wlHashSignature = std::accumulate(sorted_labels.begin(), sorted_labels.end(), 0LL);\n }\n \n int distance(const GraphFeature& other) const {\n int diff = std::abs(edgeCount - other.edgeCount);\n int degDiff = 0;\n for (size_t i = 0; i < degreeSeq.size(); i++) {\n degDiff += std::abs((int)degreeSeq[i] - (int)other.degreeSeq[i]);\n }\n int whDiff = std::abs((int)(wlHashSignature - other.wlHashSignature)) / 1000;\n return diff * 100 + degDiff + whDiff;\n }\n};\n\n// Compute log-likelihood score for matching\ndouble computeLikelihood(int matched, int total, double epsilon) {\n double logP = matched * std::log(1.0 - epsilon) + (total - matched) * std::log(epsilon);\n return logP;\n}\n\n// Approximate isomorphism check with scoring\ndouble scoreGraphMatch(const Graph& H, const Graph& G, double epsilon) {\n int n = H.n;\n if (n != G.n) return -1e18;\n \n // Greedy vertex matching based on degrees\n std::vector> h_deg, g_deg;\n for (int i = 0; i < n; i++) {\n int hd = 0, gd = 0;\n for (int j = 0; j < n; j++) {\n if (H.adj_matrix[i][j]) hd++;\n if (G.adj_matrix[i][j]) gd++;\n }\n h_deg.push_back({-hd, i}); // negative for descending sort\n g_deg.push_back({-gd, i});\n }\n std::sort(h_deg.begin(), h_deg.end());\n std::sort(g_deg.begin(), g_deg.end());\n \n // Count matching edges under degree-based mapping\n int matched = 0;\n int total_pairs = n * (n - 1) / 2;\n \n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n bool h_edge = H.adj_matrix[i][j];\n int mi = h_deg[i].second;\n int mj = h_deg[j].second;\n // Map H[i] -> G[sorted_g[rank_i]]\n // Actually we need the sorted rank\n int src_rank1 = -1, src_rank2 = -1;\n for (int r = 0; r < n; r++) {\n if (h_deg[r].second == i) src_rank1 = r;\n if (h_deg[r].second == j) src_rank2 = r;\n }\n int tar_i = g_deg[src_rank1].second;\n int tar_j = g_deg[src_rank2].second;\n \n bool g_edge = G.adj_matrix[tar_i][tar_j];\n if (h_edge == g_edge) matched++;\n }\n }\n \n // Return log-likelihood\n return computeLikelihood(matched, total_pairs, epsilon);\n}\n\nint main() {\n // Optimization for I/O\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int M;\n double epsilon;\n if (!(std::cin >> M >> epsilon)) return 0;\n \n // N selection: balance score vs distinguishability\n // Score = round(10^9 * 0.9^E / N), so smaller N is better\n // But need enough vertices for distinct graphs\n int N = 35;\n \n // Generate M graphs with different edge counts\n std::vector graphs(M, Graph(N));\n std::vector features;\n features.reserve(M);\n \n WLHash wl(N);\n \n // Use increasing edge counts for easy filtering\n int max_edges = N * (N - 1) / 2;\n for (int k = 0; k < M; k++) {\n // Distribute edge counts: [0, max_edges]\n int target_edges = k * max_edges / M;\n \n // Create graph with specific edge count\n int count = 0;\n for (int i = 0; i < N && count < target_edges; i++) {\n for (int j = i + 1; j < N && count < target_edges; j++) {\n graphs[k].adj_matrix[i][j] = graphs[k].adj_matrix[j][i] = 1;\n count++;\n }\n }\n \n // Convert to adj format\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n graphs[k].adj[idx++] = graphs[k].adj_matrix[i][j];\n }\n }\n \n features.emplace_back(graphs[k], wl);\n }\n \n // Output N and graphs\n std::cout << N << \"\\n\";\n std::cout.flush();\n \n for (int k = 0; k < M; k++) {\n std::cout << graphs[k].toString() << \"\\n\";\n }\n std::cout.flush();\n \n // Process queries\n for (int q = 0; q < 100; q++) {\n std::string H_str;\n std::cin >> H_str;\n Graph H = Graph::fromString(H_str, N);\n \n // First filter: edge count (most distinctive feature)\n int best_k = 0;\n double best_score = -1e18;\n \n // Score all graphs and pick best\n for (int k = 0; k < M; k++) {\n // Edge count filter - if too far off, skip expensive match\n int edge_diff = std::abs(graphs[k].edgeCount() - H.edgeCount());\n if (edge_diff > 5) continue; // threshold depends on noise\n \n // Full matching score\n double score = scoreGraphMatch(H, graphs[k], epsilon);\n \n // Bonus for edge count similarity\n score += (50 - edge_diff) * 0.1;\n \n if (score > best_score) {\n best_score = score;\n best_k = k;\n }\n }\n \n std::cout << best_k << \"\\n\";\n std::cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1000000000;\n\nstruct Edge {\n int u, v, w, id;\n};\n\nint main() {\n ios_base::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> adj[N + 1];\n vector edges(M);\n \n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n edges[i] = {u, v, w, i};\n adj[u].push_back(i);\n adj[v].push_back(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 // Precompute original distances\n vector> orig(N + 1, vector(N + 1, INF));\n uniform_int_distribution nodeDist(1, N);\n mt19937 rng(42);\n \n for (int i = 1; i <= N; i++) {\n priority_queue, vector>, greater>> pq;\n pq.push({0, i});\n orig[i][i] = 0;\n \n while (!pq.empty()) {\n int d = pq.top().first;\n int u = pq.top().second;\n pq.pop();\n \n if (d > orig[i][u]) continue;\n \n for (int edgeIdx : adj[u]) {\n int v = (edges[edgeIdx].u == u) ? edges[edgeIdx].v : edges[edgeIdx].u;\n int w = edges[edgeIdx].w;\n \n if (d + w < orig[i][v]) {\n orig[i][v] = d + w;\n pq.push({orig[i][v], v});\n }\n }\n }\n }\n \n // Initialize assignments evenly\n vector assignments(M);\n vector dayCounts(D + 1, 0);\n \n int basePerDay = M / D;\n int extra = M % D;\n for (int i = 0; i < M; i++) {\n int day = (i / basePerDay);\n dayCounts[day + 1] += (day < extra) ? (basePerDay + 1) : basePerDay;\n assignments[i] = day + 1;\n }\n \n // Hill climbing\n for (int iter = 0; iter < 80000; iter++) {\n int edgeIdx = rng() % M;\n int fromDay = assignments[edgeIdx];\n \n // Find edges in fromDay\n vector fromDayEdges;\n for (int i = 0; i < M; i++) {\n if (assignments[i] == fromDay) {\n fromDayEdges.push_back(i);\n }\n }\n \n if (fromDayEdges.empty()) continue;\n \n // Pick random to day\n uniform_int_distribution dayDist(1, D);\n int toDay = dayDist(rng);\n if (toDay == fromDay) continue;\n \n // Check capacity\n if (dayCounts[toDay] >= K) continue;\n if (fromDayEdges.size() == 1) continue;\n \n // Move edge\n assignments[edgeIdx] = toDay;\n dayCounts[fromDay]--;\n dayCounts[toDay]++;\n \n if (iter % 10000 == 0) {\n cout << \"iter \" << iter << \"\\n\";\n }\n }\n \n // Output\n for (int i = 0; i < M; i++) {\n cout << assignments[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold a point in 3D space\nstruct Point3D {\n int x, y, z;\n bool operator<(const Point3D& o) const {\n if (x != o.x) return x < o.x;\n if (y != o.y) return y < o.y;\n return z < o.z;\n }\n bool operator==(const Point3D& o) const {\n return x == o.x && y == o.y && z == o.z;\n }\n};\n\n// Structure to hold rotation matrices\nstruct RotMat {\n int p[3]; // permutation of axes\n int s[3]; // signs for each axis\n};\n\nint D;\nchar f1[15][15], r1[15][15], f2[15][15], r2[15][15];\nint g1[15][15][15], g2[15][15][15];\nint g_common[15][15][15];\nint b1[15][15][15], b2[15][15][15];\nvector common_ccs;\nvector> rem1_c;\nvector> rem2_c;\nvector rotations;\n\nint parity(const vector& p) {\n int c = 0;\n for(int i=0; i<3; ++i) \n for(int j=i+1; j<3; ++j) \n if(p[i] > p[j]) c++;\n return c;\n}\n\nvoid init_rotations() {\n int p[] = {0, 1, 2};\n do {\n vector v_p(p, p+3);\n if (parity(v_p) % 2 == 0) {\n int signs[4][3] = {{1,1,1}, {1,-1,-1}, {-1,1,-1}, {-1,-1,1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n } else {\n int signs[4][3] = {{1,1,-1}, {1,-1,1}, {-1,1,1}, {-1,-1,-1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n }\n } while (next_permutation(p, p+3));\n}\n\nPoint3D transform(const Point3D& src, const RotMat& r) {\n int vals[3] = {src.x, src.y, src.z};\n return {vals[r.p[0]] * r.s[0], vals[r.p[1]] * r.s[1], vals[r.p[2]] * r.s[2]};\n}\n\n// Generate the canonical representation of a shape by trying all rotations\nvector get_canonical_shape(const vector& pts) {\n if (pts.empty()) return {};\n \n vector best;\n bool first = true;\n \n for(const auto& r : rotations) {\n vector current;\n current.reserve(pts.size());\n for(const auto& p : pts) {\n current.push_back(transform(p, r));\n }\n \n int cminx=1000, cminy=1000, cminz=1000;\n for(const auto& p : current) {\n cminx = min(cminx, p.x);\n cminy = min(cminy, p.y);\n cminz = min(cminz, p.z);\n }\n \n sort(current.begin(), current.end());\n for(auto& p : current) {\n p.x -= cminx; p.y -= cminy; p.z -= cminz;\n }\n \n if (first || current < best) {\n best = current;\n first = false;\n }\n }\n return best;\n}\n\nvoid bfs(int grid[15][15][15], vector>& components) {\n for(int x=0; x pts;\n queue, int>> q;\n q.push({{x, y}, z});\n grid[x][y][z] = 0;\n pts.push_back({x,y,z});\n \n while(!q.empty()){\n auto curr = q.front(); q.pop();\n int cx = curr.first.first, cy = curr.first.second, cz = curr.second;\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 for(int i=0; i<6; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n int nz = cz + dz[i];\n if(nx >= 0 && nx < D && ny >= 0 && ny < D && nz >= 0 && nz < D && grid[nx][ny][nz] == 1) {\n grid[nx][ny][nz] = 0;\n q.push({{nx, ny}, nz});\n pts.push_back({nx, ny, nz});\n }\n }\n }\n components.push_back(pts);\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_rotations();\n \n if (!(cin >> D)) return 0;\n \n string s;\n // Read f1\n for(int z=0; z> s; for(int x=0;x> s; for(int y=0;y> s; for(int x=0;x> s; for(int y=0;y, vector> rem2_map;\n for(size_t i=0; i shape = rem2_c[i];\n vector key = get_canonical_shape(shape);\n rem2_map[key].push_back(i);\n }\n \n vector rem1_block_id(rem1_c.size(), 0);\n vector rem2_block_id(rem2_c.size(), 0);\n \n int common_count = common_ccs.size();\n int current_id = common_count + 1;\n \n // Fill Common Blocks with IDs 1 to common_count\n for(size_t i=0; i shape = rem1_c[i];\n vector key = get_canonical_shape(shape);\n \n if (rem2_map.count(key) && !rem2_map[key].empty()) {\n int j = rem2_map[key].back();\n rem2_map[key].pop_back();\n \n rem1_block_id[i] = current_id;\n rem2_block_id[j] = current_id;\n int bid = current_id;\n for(auto& p : rem1_c[i]) b1[p.x][p.y][p.z] = bid;\n for(auto& p : rem2_c[j]) b2[p.x][p.y][p.z] = bid;\n current_id++;\n } else {\n rem1_block_id[i] = current_id;\n current_id++;\n }\n }\n \n // Fill Unique Rem1 components\n for(size_t i=0; i\n","ahc021":"#include \n#include \n#include \n\nusing namespace std;\n\n// Define a structure for edges to connect nodes in adjacent rows\nstruct Edge {\n int x1, y1; // Top node coordinates (row x1, y1)\n int x2, y2; // Bottom node coordinates (row x2, y2)\n};\n\n// Define a structure to store operations\nstruct Op {\n int x1, y1, x2, y2;\n};\n\n// Global variables to store state\nint grid[30][30]; // Stores the value of balls\nint L[466]; // Stores the target level (row index) for each ball value\nvector edges;\n\nint main() {\n // Optimization for faster I/O\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Initialize edges representing valid vertical connections\n // The pyramid has rows 0 to 29.\n // Nodes in row x are (x, 0) to (x, x).\n // Vertical edges connect row x to row x+1.\n // Specifically, (x, y) connects to (x+1, y) and (x+1, y+1).\n for (int x = 0; x < 29; ++x) {\n for (int y = 0; y <= x; ++y) {\n edges.push_back({x, y, x + 1, y});\n edges.push_back({x, y, x + 1, y + 1});\n }\n }\n\n // Read input from Standard Input\n // The input gives the pyramid row by row.\n for (int x = 0; x < 30; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> grid[x][y];\n }\n }\n\n // Calculate the target level L[v] for each ball value v.\n // The problem implies we want to sort the pyramid such that it forms a valid heap.\n // A sufficient condition is \"Level Sorting\": balls with smaller values occupy higher rows.\n // Specifically, level r contains r+1 balls.\n // Balls values 0..0 (size 1) -> Level 0\n // Balls values 1..2 (size 2) -> Level 1\n // ...\n // Balls values S..E (size r+1) -> Level r\n int k = 0;\n for (int r = 0; r < 30; ++r) {\n int cnt = r + 1;\n for (int i = 0; i < cnt; ++i) {\n if (k < 465) {\n L[k] = r;\n k++;\n }\n }\n }\n\n // Perform swaps to sort balls by target level L[v].\n // This acts as a bubble sort on the graph where we sort keys L[v].\n // Since L[v] is monotonic with value v, sorting by L[v] ensures level sorting,\n // which guarantees E=0.\n \n vector ops;\n // Limit operations to 10000 as per problem statement\n while (ops.size() < 10000) {\n bool changed = false;\n // Iterate through all valid edges\n for (const auto& e : edges) {\n int val_top = grid[e.x1][e.y1];\n int val_bottom = grid[e.x2][e.y2];\n \n // e.x1 is always < e.x2 due to our construction (Top node is in upper row)\n // If the ball at the top (val_top) has a larger target level than the ball at bottom (val_bottom),\n // it means val_top should ideally be lower in the pyramid.\n // We swap them to correct the order.\n if (L[val_top] > L[val_bottom]) {\n swap(grid[e.x1][e.y1], grid[e.x2][e.y2]);\n ops.push_back({e.x1, e.y1, e.x2, e.y2});\n changed = true;\n }\n }\n // If no swaps were made in a full pass, the array is sorted by L[v]\n if (!changed) break;\n }\n\n // Output the results\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: up, down, left, right\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\n\nstruct Pos {\n int r, c;\n bool operator<(const Pos& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n bool operator==(const Pos& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nclass Warehouse {\nprivate:\n int D;\n int N;\n vector> grid; // true = obstacle or occupied\n vector container_positions;\n vector priority_at_pos; // priority of container at each position\n vector possible_positions;\n vector possible_distances;\n \n // BFS to find reachable positions and their distances from entrance\n vector> reachable_positions() {\n vector> reachable;\n queue> q;\n vector> visited(D, vector(D, false));\n \n Pos start = {0, (D-1)/2};\n if (grid[start.r][start.c]) return reachable;\n \n q.push({start, 0});\n visited[start.r][start.c] = true;\n \n while (!q.empty()) {\n auto [pos, dist] = q.front();\n q.pop();\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D &&\n !visited[pos.r][pos.c] && !grid[pos.r][pos.c]) {\n reachable.push_back({pos, dist});\n visited[pos.r][pos.c] = true;\n \n for (int i = 0; i < 4; i++) {\n int nr = pos.r + dr[i];\n int nc = pos.c + dc[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && \n !grid[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({{nr, nc}, dist + 1});\n }\n }\n }\n }\n return reachable;\n }\n \n // Calculate distance from entrance for a position\n int distance_from_entrance(Pos pos) {\n int r = pos.r;\n int c = pos.c;\n int entrance_r = 0;\n int entrance_c = (D-1)/2;\n return abs(r - entrance_r) + abs(c - entrance_c);\n }\n \npublic:\n Warehouse(int D, int N, const vector& obstacles) \n : D(D), N(N), grid(D, vector(D, false)), \n container_positions((D*D - N - 1), {-1, -1}),\n priority_at_pos(D*D, -1) {\n \n // Mark obstacle positions\n for (const auto& obs : obstacles) {\n grid[obs.r][obs.c] = true;\n }\n \n // Mark entrance as blocked for storage\n grid[0][(D-1)/2] = true;\n \n // Pre-compute all possible storage positions sorted by distance\n set all_possible;\n for (int r = 0; r < D; r++) {\n for (int c = 0; c < D; c++) {\n if (!grid[r][c]) {\n all_possible.insert({r, c});\n }\n }\n }\n \n vector> sorted_positions;\n for (const auto& pos : all_possible) {\n sorted_positions.push_back({distance_from_entrance(pos), pos});\n }\n sort(sorted_positions.begin(), sorted_positions.end());\n \n for (const auto& item : sorted_positions) {\n possible_positions.push_back(item.second);\n possible_distances.push_back(item.first);\n }\n }\n \n // Find the best position for a container with given priority\n Pos find_placement() {\n vector> reachable = reachable_positions();\n \n if (reachable.empty()) {\n return {-1, -1}; // No valid position\n }\n \n // Heuristic: balance between distance from entrance and priority\n // Lower priority numbers should be closer for easier retrieval\n // Sort reachable positions by distance\n sort(reachable.begin(), reachable.end(),\n [](const pair& a, const pair& b) {\n return a.second < b.second;\n });\n \n // Choose position that allows future flexibility\n // Prefer positions that are not too deep in the warehouse\n for (const auto& [pos, dist] : reachable) {\n // Verify this position can be uniquely reached (not blocked)\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n return pos;\n }\n }\n \n // Fallback: return the most accessible position\n return reachable[0].first;\n }\n \n bool mark_occupied(Pos pos, int priority) {\n if (pos.r < 0 || pos.r >= D || pos.c < 0 || pos.c >= D) {\n return false;\n }\n if (grid[pos.r][pos.c]) {\n return false;\n }\n grid[pos.r][pos.c] = true; // Mark as occupied\n return true;\n }\n \n void free_position(Pos pos) {\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n grid[pos.r][pos.c] = false; // Mark as empty\n }\n }\n \n int total_containers() const {\n return container_positions.size();\n }\n \n const Pos& get_container_pos(int priority) const {\n if (priority >= 0 && priority < total_containers()) {\n return container_positions[priority];\n }\n return container_positions[0];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D, N;\n cin >> D >> N;\n \n vector obstacles;\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n obstacles.push_back({r, c});\n }\n \n Warehouse warehouse(D, N, obstacles);\n int total_containers = warehouse.total_containers();\n \n vector> placements(total_containers);\n \n // Place each container as it arrives\n for (int d = 0; d < total_containers; d++) {\n int priority;\n cin >> priority;\n \n Pos pos = warehouse.find_placement();\n \n while (pos.r == -1) { // Retry if no valid position\n int d2 = warehouse.total_containers();\n // This shouldn't happen with proper logic\n break;\n }\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n warehouse.mark_occupied(pos, priority);\n placements[priority] = {priority, pos};\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n }\n }\n \n // Output transport order: in priority order (0, 1, 2, ...)\n // We simply output containers in their assigned priority order\n for (int p = 0; p < total_containers; p++) {\n if (placements[p].first == p) {\n Pos pos = placements[p].second;\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n // Free the position after transport\n warehouse.free_position(pos);\n }\n }\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, M;\nint grid[55][55];\nint adj[105][105];\nint adj_count[105][105];\nint total_pixels[105];\nint vis[55][55];\nint q_node[2500];\nint bfs_iter = 0;\n\n// Helper to find a starting pixel of a specific color\nint get_start(int color) {\n for(int i=0; i 1000000) { \n // Optimization to avoid int overflow or reset if needed\n // Just clearing vis is safer if needed, but iter is large enough.\n // Just resetting vis every 10^6 iters might be slow. \n // Iter is safe for 2 sec (limit ~2e9).\n }\n\n int head = 0, tail = 0;\n q_node[tail++] = start;\n vis[start / N][start % N] = bfs_iter;\n int reached = 1;\n \n // Count total pixels of this color\n int total_count = 0;\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N && grid[nr][nc] == color) {\n if(vis[nr][nc] != bfs_iter) {\n vis[nr][nc] = bfs_iter;\n q_node[tail++] = nr * N + nc;\n reached++;\n }\n }\n }\n }\n\n return (reached == total_count);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n // Read input\n for(int i=0; i> grid[i][j];\n if(grid[i][j] != 0) total_pixels[grid[i][j]]++;\n }\n }\n\n // Clear arrays\n memset(adj, 0, sizeof(adj));\n memset(adj_count, 0, sizeof(adj_count));\n\n // Compute adjacencies from input map\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n \n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj[u][v] = 1; // Mark adjacency exists in Input\n }\n \n // Count adjacencies\n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj_count[u][v]++;\n }\n }\n }\n }\n\n // Identify candidate pixels (all colored pixels)\n vector> pixels;\n pixels.reserve(N * N);\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n if(grid[nr][nc] == color) neighbors_of_color++;\n }\n }\n\n // If pixel has < 2 neighbors of same color, removing it won't disconnect component\n // This is a strong heuristic. \n // Note: A pixel with 1 neighbor is a leaf or bridge (if 1 edge connects 2 blocks via this pixel).\n // If 1 neighbor, it's not a bridge cutting into >=2 parts.\n // So check connectivity only if >= 2 neighbors.\n bool need_check_connected = (neighbors_of_color >= 2);\n\n // Check adjacency constraints BEFORE modifying grid\n bool valid = true;\n\n // Check if we would break a required adjacency\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If n is 0, we don't lose adjacency with 0 unless p was the ONLY contact between color and 0\n // But we check adj_count logic\n \n if(n != 0 && n != color && adj[color][n] == 1) {\n int u = min(color, n);\n int v = max(color, n);\n // adj_count[u][v] stores contacts. \n // For non-0 neighbors, each contact is counted twice (once from each side).\n // Limit is 2 (meaning count 1 contact -> count 2 total).\n int limit = (u == 0 || v == 0) ? 1 : 2;\n if(adj_count[u][v] <= limit) {\n valid = false;\n break;\n }\n }\n }\n \n // Check if we create forbidden 0 adjacency\n if(valid) {\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n // n is color of neighbor\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If neighbor is color d (!= 0), it will become adjacent to 0 after removal.\n // Check if (0, d) is allowed.\n if(n != 0 && n != color && adj[0][n] == 0) {\n valid = false;\n break;\n }\n }\n }\n\n if(valid) {\n // Check connectivity if needed\n if(need_check_connected) {\n // Temporarily remove\n grid[r][c] = 0;\n int cnt;\n if(!check_connected(color, cnt)) {\n valid = false;\n }\n grid[r][c] = color; // Restore\n }\n }\n \n if(valid) {\n // Perform update\n grid[r][c] = 0;\n total_pixels[color]--;\n \n // Update adjacency counts\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n if(n != 0 && n != color) { // n != 0 because if n=0 we treat 0 as color 0\n // Actually, if n=0, we update adj_count[0][color]\n }\n // We need to update for all neighbors.\n // n can be 0.\n int u = min(color, n);\n int v = max(color, n);\n // If n was a colored pixel (d>0), it contributed 2.\n // If n was 0, it contributed 1.\n // We remove 2 or 1.\n // Since adj_count[u][v] was incremented by 2 for d>0 (when processing u) \n // and by 2 for d>0 (when processing v).\n // Wait, I used `adj_count[u][v]++` in Init loop.\n // When u sees v, count++. When v sees u, count++.\n // So count is 2.\n // When removing u (p), we remove count contribution from u side.\n // So decrement by 1 (from u side).\n // Wait, if n is a pixel, it sees me.\n // In Init loop, if cell `x` sees neighbor `y`, `adj_count` increments.\n // So edge `x-y` contributes 2 to `adj_count`.\n // Removing `x` (which is `p`) removes `x` side of adjacency.\n // So decrement `adj_count` by 2?\n // Yes, because both x and y contribute.\n // Wait, if `y` also sees `x`. `x` is neighbor of `y`.\n // If I remove `p` (x).\n // `adj_count` counts edges.\n // Edge (x, y) contributes 2 to count.\n // Removing x means edge (x, y) is gone.\n // So decrement by 2?\n // Wait, my check `adj_count <= limit` assumes limit 2 means \"unique contact\".\n // If unique contact exists, count is 2. Removing p removes all 2?\n // No. If unique contact exists, p is the ONLY pixel of color touching d.\n // So p's side contributes 1. d's side contributes 1.\n // So total count 2.\n // If I remove p, I remove p's side.\n // Does it remove d's side?\n // d's side contact was with p.\n // So if p is gone, d has no neighbor p.\n // So d's side contribution is lost.\n // So total contribution lost is 2.\n // So decrement by 2.\n \n // Wait, what if `n` is 0.\n // Edge (p, 0).\n // p contributes 1. 0 (outside) not processed.\n // If `0` region exists in grid. p contributes 1. 0 (at neighbor) not processed.\n // So total 1.\n // So decrement by 1 for 0 neighbors?\n // Or is `n` 0 (outside) vs `n` 0 (pixel)?\n // Both treated as `n=0`.\n // But my `adj_count` loop didn't count 0 side.\n // So count is 1.\n // So decrement by 1 if `n==0`?\n \n // Wait, if `grid` has 0 pixel.\n // `p` is color c. Neighbor `q` is 0 pixel.\n // Loop `p`: sees `q` (0). count[0][c]++ (1).\n // Loop `q`: skipped.\n // So count is 1.\n // So decrement `adj_count[0][color]` by 1.\n \n // Wait, if `n` is 0 (outside boundary).\n // Loop `p`: sees boundary 0. count[0][c]++ (1).\n // So count is 1.\n // So decrement by 1.\n \n // So `if (n != 0)`?\n // Wait, `n` is the neighbor's color.\n // If `n != 0` (colored). Decrement 2.\n // If `n == 0`. Decrement 1.\n // Wait, `adj_count` logic in loop:\n // `adj_count[0][color]++`\n // `adj_count[color][d]++`\n // It always increments `adj_count[min][max]`.\n // The issue is `n` could be `color` (if `n` was colored `d`).\n // If `n` (neighbor) is colored `d`.\n // When processing `p` (color `c`), I see `d`. Increment `count[c][d]`.\n // When processing `d` (at neighbor location), I see `c` (which was `p`). Increment `count[d][c]`.\n // So total 2.\n // When `p` removed.\n // `p` side contribution lost: 1.\n // `d` side contribution lost: 1 (since `p` was neighbor).\n // Total 2.\n // So decrement 2.\n // If `n` is 0.\n // `p` sees 0. Increment `count[0][c]` (1).\n // `0` is skipped in loop.\n // So total 1.\n // When `p` removed.\n // `p` contribution lost: 1.\n // `0` contribution lost: 0.\n // Total 1.\n // So decrement 1.\n \n // So: `int dec = (n == 0) ? 1 : 2;` ?\n // Wait, `n` is neighbor color.\n // If `n` is 0 (pixel or boundary).\n // Yes.\n // Wait, `adj[u][v]` check uses `limit`.\n // `limit` logic: if `u==0 || v==0` then `limit=1`.\n // Else `limit=2`.\n // So `dec` should match `limit`.\n \n int dec = (u == 0 || v == 0) ? 1 : 2;\n adj_count[u][v] -= dec;\n }\n }\n }\n }\n\n // Output\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace atcoder;\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int N, D, Q;\n if (!(std::cin >> N >> D >> Q)) return 0;\n \n // Store comparison results for building weight estimates\n std::vector weight_estimate(N, 0);\n std::vector> weight_confidence(N, std::vector(N, 0.0));\n \n int used_queries = 0;\n std::mt19937 rng(42);\n \n // Phase 1: Learning weights through pairwise comparisons\n // Use tournament-style comparisons\n for (int i = 0; i < N - 1 && used_queries < Q; i++) {\n for (int j = i + 1; j < N && used_queries < Q; j++) {\n if (used_queries >= Q) break;\n \n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 1.0;\n weight_confidence[i][j] = 1.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 1.0;\n weight_confidence[j][i] = 1.0;\n } else {\n // Equal\n weight_estimate[i] += 0.5;\n weight_estimate[j] += 0.5;\n weight_confidence[i][j] = 0.5;\n weight_confidence[j][i] = 0.5;\n }\n }\n }\n \n // Phase 2: Query more comparisons for better ranking (if queries remain)\n // Use larger gaps for better ranking spread\n for (int gap = 1; gap <= 5 && used_queries < Q; gap++) {\n for (int i = 0; i < N - gap && used_queries < Q; i++) {\n int j = i + gap;\n if (weight_confidence[i][j] < 0.5) {\n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 2.0;\n weight_confidence[i][j] = 2.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 2.0;\n weight_confidence[j][i] = 2.0;\n } else {\n weight_estimate[i] += 1.0;\n weight_estimate[j] += 1.0;\n weight_confidence[i][j] = 1.0;\n weight_confidence[j][i] = 1.0;\n }\n }\n }\n }\n \n // Phase 3: Use remaining queries for verification/refinement\n // Compare items with known reference points\n if (used_queries < Q && N > 2) {\n std::vector item_order(N);\n std::iota(item_order.begin(), item_order.end(), 0);\n \n // Quick sort by weight estimate\n std::sort(item_order.begin(), item_order.end(), [&](int a, int b) {\n return weight_estimate[a] > weight_estimate[b];\n });\n \n // Verify middle items with extreme items\n int mid_idx = N / 2;\n int low_item = item_order[0];\n int high_item = item_order[N - 1];\n \n for (int k = 1; k < std::min(5, mid_idx + 1) && used_queries < Q; k++) {\n int mid_item = item_order[k];\n std::cout << 1 << \" \" << 1 << \" \" << mid_item << \" \" << high_item << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \"<\") {\n weight_estimate[high_item] += 3.0;\n } else if (result == \">\") {\n weight_estimate[mid_item] += 3.0;\n }\n }\n }\n \n // Phase 4: Sort items by estimated weight\n std::vector> items_by_weight(N);\n for (int i = 0; i < N; i++) {\n items_by_weight[i] = {weight_estimate[i], i};\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n \n // Handle edge case where all weights are the same\n if (used_queries >= Q) {\n // Add small random jitter to break ties\n std::uniform_real_distribution jitter_dist(-0.1, 0.1);\n for (auto& p : items_by_weight) {\n if (p.first == 0.0) {\n p.first = jitter_dist(rng);\n }\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n }\n \n // Phase 5: LPT Greedy Partitioning\n std::vector partition(N);\n std::vector set_weights(D, 0.0);\n std::vector> set_items(D);\n \n for (const auto& item_data : items_by_weight) {\n int item_idx = item_data.second;\n \n // Find set with minimum weight\n int best_set = 0;\n double min_weight = set_weights[0];\n for (int s = 1; s < D; s++) {\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n best_set = s;\n }\n }\n \n partition[item_idx] = best_set;\n set_items[best_set].push_back(item_idx);\n set_weights[best_set] += item_data.first;\n }\n \n // Phase 6: Simple local search refinement with proper bounds checking\n bool improved = true;\n int max_iterations = std::min(10, D);\n int iteration_count = 0;\n \n while (improved && iteration_count < max_iterations) {\n improved = false;\n iteration_count++;\n \n // Recalculate set weights\n std::fill(set_weights.begin(), set_weights.end(), 0.0);\n for (int i = 0; i < N; i++) {\n set_weights[partition[i]] += items_by_weight[i].first;\n }\n \n // Find max and min weighted sets\n int max_set = 0, min_set = 0;\n double max_weight = set_weights[0], min_weight = set_weights[0];\n \n for (int s = 1; s < D; s++) {\n if (set_weights[s] > max_weight) {\n max_weight = set_weights[s];\n max_set = s;\n }\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n min_set = s;\n }\n }\n \n // Try moving items from max weight set to min weight set\n std::vector& from_set = set_items[max_set];\n std::vector& to_set = set_items[min_set];\n \n if (from_set.empty()) {\n break;\n }\n \n for (const int& item_idx : from_set) {\n // Calculate weight change if we move this item\n double weight_of_item = items_by_weight[N - 1 - max_set].first;\n // Actually get correct weight\n for (int i = 0; i < N; i++) {\n if (items_by_weight[i].second == item_idx) {\n weight_of_item = items_by_weight[i].first;\n break;\n }\n }\n \n double old_max_weight = set_weights[max_set];\n double old_min_weight = set_weights[min_set];\n \n double new_max = old_max_weight - weight_of_item;\n double new_min = old_min_weight + weight_of_item;\n \n // Check if moving improves balance\n double old_range = std::max(old_max_weight, old_min_weight) - \n std::min(old_max_weight, old_min_weight);\n double new_range = std::max(new_max, new_min) - \n std::min(new_max, new_min);\n // Also check impact on intermediate sets\n bool all_within_range = true;\n for (int s = 0; s < D; s++) {\n if (s != max_set && s != min_set) {\n double ws = set_weights[s];\n if (std::abs(ws - new_min) > 1.1 * std::abs(old_max_weight - old_min_weight)) {\n all_within_range = false;\n break;\n }\n }\n }\n \n if (new_range < old_range * 0.95 && all_within_range) {\n // Make the move\n partition[item_idx] = min_set;\n set_items[max_set].erase(std::find(set_items[max_set].begin(), \n set_items[max_set].end(), item_idx));\n set_items[min_set].push_back(item_idx);\n set_weights[max_set] -= weight_of_item;\n set_weights[min_set] += weight_of_item;\n improved = true;\n break;\n }\n }\n }\n \n // Phase 7: Output final partition\n for (int i = 0; i < N; i++) {\n std::cout << partition[i] << (i == N - 1 ? \"\\n\" : \" \");\n }\n \n std::flush(std::cout);\n \n return 0;\n}","ahc026":"#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 n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> stacks(m);\n vector> pos(n + 1);\n\n // Read input and initialize stacks and position tracking\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int b;\n cin >> b;\n stacks[i].push_back(b);\n pos[b] = {i, j};\n }\n }\n\n vector> operations;\n vector carried_out(n + 1, false);\n\n for (int v = 1; v <= n; ++v) {\n if (carried_out[v]) continue;\n\n int src_idx = pos[v].first;\n int box_idx = pos[v].second;\n\n // Move boxes above v one by one\n while (stacks[src_idx].size() > box_idx + 1) {\n int top_box = stacks[src_idx].back();\n stacks[src_idx].pop_back();\n\n // Find the best destination stack\n int dest_idx = -1;\n int best_max_top = -1;\n int best_dest = -1;\n bool found_empty = false;\n\n // Check for any empty stack first\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n if (stacks[i].empty()) {\n dest_idx = i;\n found_empty = true;\n break;\n }\n }\n\n // If no empty stack, find the one with largest top\n if (!found_empty) {\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n int top = stacks[i].back();\n if (top > best_max_top) {\n best_max_top = top;\n best_dest = i;\n }\n }\n dest_idx = best_dest;\n }\n\n // Move the box to the destination stack\n stacks[dest_idx].push_back(top_box);\n pos[top_box] = {dest_idx, stacks[dest_idx].size() - 1};\n operations.push_back({top_box, dest_idx + 1});\n }\n\n // Carry out box v\n operations.push_back({v, 0});\n carried_out[v] = true;\n stacks[src_idx].pop_back();\n }\n\n // Output operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h_in;\nvector v_in;\nvector> d_grid;\nvector> children;\nvector parents;\nvector x_vec;\nvector cnt_vec;\nvector version;\nint V;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n h_in.resize(N - 1);\n for(int i = 0; i < N - 1; ++i) cin >> h_in[i];\n v_in.resize(N);\n for(int i = 0; i < N; ++i) cin >> v_in[i];\n d_grid.resize(N, vector(N));\n V = N * N;\n for(int i = 0; i < N; ++i) {\n for(int j = 0; j < N; ++j) cin >> d_grid[i][j];\n }\n\n parents.assign(V, -1);\n children.assign(V, vector());\n x_vec.assign(V, 1);\n x_vec[0] = 0;\n cnt_vec.assign(V, 0);\n version.assign(V, 0);\n\n // BFS spanning tree\n queue q;\n q.push(0);\n vector visited(V, false);\n visited[0] = true;\n\n while(!q.empty()){\n int u = q.front(); q.pop();\n int r = u / N, c = u % N;\n\n if(r + 1 < N && h_in[r][c] == '0') {\n int v = (r + 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(r - 1 >= 0 && h_in[r - 1][c] == '0') {\n int v = (r - 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c + 1 < N && v_in[r][c] == '0') {\n int v = r * N + (c + 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c - 1 >= 0 && v_in[r][c - 1] == '0') {\n int v = r * N + (c - 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n }\n\n // Initial cnt calculation\n for(int i = V - 1; i >= 0; --i) {\n cnt_vec[i] = x_vec[i];\n for(int c : children[i]) cnt_vec[i] += cnt_vec[c];\n }\n\n // Helper to calculate gain\n auto get_gain = [&](int u) {\n double g = 0.0;\n int curr = u;\n while(curr != -1) {\n if(cnt_vec[curr] > 0) {\n g += (double)d_grid[curr / N][curr % N] / ( (double)cnt_vec[curr] * ((double)cnt_vec[curr] + 1.0) );\n }\n if(curr == 0) break;\n curr = parents[curr];\n }\n return g;\n };\n\n // Priority Queue: {gain, u, version}\n priority_queue> pq;\n\n for(int i = 1; i < V; ++i) {\n version[i]++;\n double g = get_gain(i);\n pq.push({g, i, version[i]});\n }\n\n long long budget = 50000; // sum(x) <= 50000\n long long current_sum = 0;\n for(int i = 0; i < V; ++i) current_sum += x_vec[i];\n long long remaining = budget - current_sum;\n if(remaining < 0) remaining = 0;\n\n for(long long iter = 0; iter < remaining && !pq.empty(); ++iter) {\n tuple top = pq.top(); pq.pop();\n double gain = get<0>(top);\n int u = get<1>(top);\n int v = get<2>(top);\n\n // Check if this entry is outdated\n if(v != version[u]) continue;\n\n // Apply increment\n x_vec[u]++;\n\n // Update cnt for u and all ancestors\n int curr = u;\n while(curr != -1) {\n cnt_vec[curr]++;\n curr = parents[curr];\n if(curr == -1) break;\n }\n\n // Update PQ entries for affected nodes\n curr = u;\n while(curr != -1) {\n version[curr]++;\n double ng = get_gain(curr);\n pq.push({ng, curr, version[curr]});\n curr = parents[curr];\n if(curr == -1) break;\n }\n }\n\n // Generate path using DFS\n string ans;\n ans.reserve(100000);\n\n auto dfs = [&](auto&& self, int u) -> void {\n for(int v : children[u]) {\n int r_u = u / N, c_u = u % N;\n int r_v = v / N, c_v = v % N;\n char dir = ' ';\n char back = ' ';\n if(r_v == r_u + 1) { dir = 'D'; back = 'U'; }\n else if(r_v == r_u - 1) { dir = 'U'; back = 'D'; }\n else if(c_v == c_u + 1) { dir = 'R'; back = 'L'; }\n else if(c_v == c_u - 1) { dir = 'L'; back = 'R'; }\n\n for(long long k = 0; k < x_vec[v]; ++k) {\n ans += dir;\n self(self, v);\n ans += back;\n }\n }\n };\n\n dfs(dfs, 0);\n cout << ans << endl;\n\n return 0;\n}","ahc028":"```cpp\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 r, c;\n bool operator==(const Point& o) const { return r == o.r && c == o.c; }\n int dist(const Point& o) const { return abs(r - o.r) + abs(c - o.c); }\n};\n\nstruct Occurrence {\n Point start;\n Point end;\n vector path;\n int internal_cost; \n};\n\nint N, M;\nint s_r, s_c;\nvector A;\nvector words;\nvector> word_occurrences;\n\n// Function to get total cost of a permutation\nint get_total_cost(const vector& perm) {\n // We need a large enough array\n // N=15, M=200.\n static int dp[205][15][15];\n \n // Initialize\n for(int w=0; w= 2e9) continue;\n // Try to extend to every occurrence of current word\n for(const auto& occ : occs_curr) {\n int move_cost = ({r, c}).dist(occ.start);\n int total = dp[w-1][r][c] + move_cost + occ.internal_cost;\n if (total < dp[w][occ.end.r][occ.end.c]) {\n dp[w][occ.end.r][occ.end.c] = total;\n }\n }\n }\n }\n }\n \n // Find min in last word\n int pi = perm[M-1];\n int min_c = 2e9;\n for(int r=0; r dp[M-1][r][c]) {\n min_c = dp[M-1][r][c];\n }\n }\n }\n return min_c;\n}\n\n// Helper to reconstruct path for best permutation\nvoid reconstruct_and_output(const vector& perm) {\n static int dp[205][15][15];\n static int choice_r[205][15][15];\n static int choice_c[205][15][15];\n static int choice_idx[205][15][15]; // index in word_occurrences\n \n // Initialize\n for(int w=0; w= 2e9) continue;\n const auto& occs_curr = word_occurrences[pi];\n for(int i=0; i full_path;\n for(int w = M - 1; w >= 0; --w) {\n pi = perm[w];\n int r = choice_r[w][full_path.empty() ? min_r : 0][full_path.empty() ? min_c : 0]; // Logic fix\n // Wait, backtracking needs to go from end state back to state w-1.\n // But we need to know the state at w-1.\n // We need to store the chosen `r, c` of the CURRENT state at `w`.\n // Then look up `choice_r[w][r][c]` which gives `prev_r, prev_c`.\n // But we need to access the full path to know `full_path.back()`.\n // This is tricky because `full_path` is vector of ALL points.\n // Actually, we should backtrack the OCCURRENCE indices and the grid positions.\n \n // Let's just re-run and record chosen occ index at each step.\n // State at w: (chosen_occ_idx, end_r, end_c).\n }\n \n // Correct backtracking\n vector path_occ_indices;\n int curr_r = min_r;\n int curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n int idx = choice_idx[w][curr_r][curr_c];\n int prev_r = choice_r[w][curr_r][curr_c];\n int prev_c = choice_c[w][curr_r][curr_c]; // Wait, for w=0, prev is (s_r, s_c)\n \n path_occ_indices.push_back(idx);\n curr_r = prev_r;\n curr_c = prev_c;\n }\n reverse(path_occ_indices.begin(), path_occ_indices.end());\n \n // Wait, for w=0, choice_r/choice_c logic needs to return start state (s_r, s_c).\n // My logic above: `choice_r[0][...] = s_r`.\n // So when backtracking w=0, prev_r=s_r, prev_c=s_c.\n // Then we break.\n \n // Also we need to handle the path inside the occurrences.\n // But wait, path_occ_indices only tell us WHICH occurrence.\n // We need to verify the sequence of coordinates.\n // The sequence of coords is simply: occ[0].path + occ[1].path...?\n // NO. occ[1] starts at `occ[1].start`.\n // We move from `occ[0].end` to `occ[1].start`.\n // This move does not append any character!\n // So the sequence of coordinates to OUTPUT is:\n // occ[0].path, occ[1].path, ...\n // Just concatenation.\n \n // Wait, the transition `dist` is movement cost.\n // But we must ensure we output the coords.\n // Yes, we just output `occ[path].path` for each occ sequentially.\n \n // Wait, does the problem require us to output the MOVES?\n // \"Specify square (i, j), move the finger to this square, and then append A_{i,j}\".\n // \"output... (i_l, j_l)\".\n // The sequence of (i_l, j_l) constitutes the chars appended.\n // If we are at `occ[0].end` and want to start `occ[1]` at `occ[1].start` (where `occ[1].start != occ[0].end`),\n // We do NOT output the coords in between!\n // We just jump. The move happens \"inside\" the operation?\n // \"move the finger to this square, and then append\".\n // This implies one operation = one movement + one append.\n // So to go from `occ[0].end` to `occ[1].start`, we need 1 operation!\n // Wait, if we jump, we append `occ[1].start` char.\n // But we skipped `occ[0].end`? No, we already typed it in `occ[0].path`.\n // So we just type `occ[1].start`.\n // So we just output the sequence of points in `occ[1].path` directly?\n // Yes. The string S is formed by chars.\n // My disjoint model: S = char(t_k1) + char(t_k2) + ...\n // So S is formed by the characters of the occurrences' paths.\n // Is the `move cost` paid? Yes.\n // But do we output intermediate points?\n // No. We only output points `(i, j)` that are typed.\n // So if we jump from A to B, we type B.\n // The cost `|rA - rB| + |cA - cB| + 1` is paid.\n // So we don't need to output the path between A and B.\n // We just jump.\n // So my output logic: just concat all `occ.path` vectors.\n \n // BUT wait, my `occurrence` paths already spell the words.\n // If I just concat them, `occ[0]` spells `words[perm[0]]`.\n // `occ[1]` spells `words[perm[1]]`.\n // So S = `words[perm[0]] + words[perm[1]] + ...`\n // This is valid.\n \n for(int idx : path_occ_indices) {\n const auto& occ = word_occurrences[perm[idx]][idx]; // Wait, `idx` is index *in* word_occurrences?\n // `path_occ_indices` stores the index from `word_occurrences[perm[w]]`.\n // So I should access `word_occurrences[perm[w]][idx]`.\n // But I need to track `w`.\n // The loop `w` goes forward for output.\n }\n \n vector final_perm = perm; // need correct permutation\n vector> final_paths;\n curr_r = min_r; curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n final_perm.insert(final_perm.begin() + w, 0); // This is wrong, perm is fixed.\n // I need the `path_occ_indices` vector which is ordered by w.\n // Wait, `path_occ_indices` has size M.\n // It corresponds to w=0 at index 0?\n // The loop pushed from w=M-1 down to 0.\n // So `path_occ_indices` is [occ_idx(M-1), ..., occ_idx(0)].\n // Reversed it to [occ_idx(0), ..., occ_idx(M-1)].\n }\n}\n\nvoid precompute_occurrences() {\n word_occurrences.resize(M);\n for (int k = 0; k < M; ++k) {\n vector current_occs;\n set> seen_pairs;\n \n for (int sr = 0; sr < N; ++sr) {\n for (int sc = 0; sc < N; ++sc) {\n if (A[sr][sc] == words[k][0]) {\n int dist_map[15][15][5];\n Point parent_pos[15][15][5];\n for(int r=0; r> pq; // -cost, {p*r*51 + p*c + depth} ? \n // Let's use struct.\n struct Node {\n Point p;\n int d;\n int cost;\n };\n priority_queue, greater> pq2;\n \n dist_map[sr][sc][0] = 1;\n pq2.push({{sr, sc}, 0, 1});\n \n vector> targets; // r, c, cost\n \n while(!pq2.empty()) {\n Node top = pq2.top();\n pq2.pop();\n int r = top.p.r;\n int c = top.p.c;\n int d = top.d;\n int val = top.cost;\n \n if (dist_map[r][c][d] != -1 && val > dist_map[r][c][d]) continue;\n \n if (d == 4) {\n targets.push_back({r, c, val});\n }\n if (d < 4) {\n int nd = d + 1;\n char needed = words[k][nd];\n for (int dr = -1; dr <= 1; ++dr) {\n for (int dc = -1; dc <= 1; ++dc) {\n int nr = r + dr;\n int nc = c + dc;\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (A[nr][nc] == needed) {\n int move_cost = abs(dr) + abs(dc);\n int new_cost = val + move_cost + 1;\n if (dist_map[nr][nc][nd] == -1 || new_cost < dist_map[nr][nc][nd]) {\n dist_map[nr][nc][nd] = new_cost;\n parent_pos[nr][nc][nd] = {{r, c}};\n pq2.push({{nr, nc}, nd, new_cost});\n }\n }\n }\n }\n }\n }\n }\n \n for(auto& t : targets) {\n int er = get<0>(t);\n int ec = get<1>(t);\n int cost = get<2>(t);\n \n if (seen_pairs.count({sr, sc, er, ec})) continue;\n seen_pairs.insert({sr, sc, er, ec});\n \n // Reconstruct\n vector path;\n int r = er, c = ec;\n for(int d=4; d>=0; --d) {\n path.push_back({r, c});\n // Move to parent\n if (d > 0) {\n Point p_parent = parent_pos[r][c][d];\n r = p_parent.r;\n c = p_parent.c;\n }\n }\n reverse(path.begin(), path.end());\n \n Occurrence occ;\n occ.start = {sr, sc};\n occ.end = {er, ec};\n occ.path = path;\n occ.internal_cost = cost;\n current_occs.push_back(occ);\n }\n }\n }\n }\n \n sort(current_occs.begin(), current_occs.end(), [](const Occurrence& a, const Occurrence& b) {\n return a.internal_cost < b.internal_cost;\n });\n if (current_occs.size() > 50) current_occs.resize(50);\n word_occurrences[k] = current_occs;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (!(cin >> N >> M)) return 0;\n cin >> s_r >> s_c;\n A.resize(N);\n for(int i=0; i> A[i];\n words.resize(M);\n for(int i=0; i> words[i];\n \n precompute_occurrences();\n \n // Random permute\n vector perm(M);\n for(int i=0; i rand_idx(0, M-1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n \n int base_cost = get_total_cost(perm);\n int best_cost = base_cost;\n vector best_perm = perm;\n \n for(int iter=0; iter<200000; ++iter) {\n vector next_perm = perm;\n int i = rand_idx(mt);\n int j = rand_idx(mt);\n swap(next_perm[i], next_perm[j]);\n \n int next_cost = get_total_cost(next_perm);\n if (next_cost < best_cost) {\n best_cost = next_cost;\n best_perm = next_perm;\n }\n // Simulated Annealing logic (optional but good for local optima)\n // Since time is tight, just greedy descent or simple SA\n // Let's use standard SA\n if (next_cost < base_cost) {\n perm = next_perm;\n base_cost = next_cost;\n } else {\n if (rand_prob(mt) < exp((base_cost - next_cost) / 100.0)) {\n perm = next_perm;\n base_cost = next_cost;\n }\n }\n }\n \n // Reconstruct and output\n // Need to run DP again to get occ indices\n static int dp[205][15][15];\n // ... logic from reconstruction above ...\n // (I will incorporate into a helper function in final code)\n \n // Just to be safe, I'll re-implement reconstruction here\n for(int w=0; w= 2e9) continue;\n for(int i=0; i> output_path;\n curr_r = min_r; curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n int idx = choice_idx[w][curr_r][curr_c];\n output_path.push_back(word_occurrences[best_perm[w]][idx].path);\n // curr_r, curr_c updated? No, for w=0 we need previous state?\n // Wait, `choice_idx` only stores the index of occ.\n // We don't store prev_r, prev_c in this version.\n // But for output, we don't need prev_r, prev_c. We just need the path of occ.\n // But wait, for the next step (w-1), we need to know where we ended up from w?\n // Yes. The DP state is (w, r, c) -> min cost.\n // `curr_r, curr_c` is the end position of word `w` that led to optimal.\n // But to get to `w-1`, we need to know the START of `w`.\n // Because `dp[w]` depends on `dp[w-1][prev_r][prev_c]`.\n // So we need `choice_idx[w][r][c]` to retrieve the occ.\n // Does this tell us `prev_r`?\n // No. We need to know `prev_r, prev_c`.\n // We need `choice_prev_r[w][r][c]` and `choice_prev_c[w][r][c]`.\n \n // Let's add that.\n curr_r = ... // Need to find match.\n \n // Simple fix:\n // In DP step, store `best_prev_r` and `best_prev_c`.\n }\n \n // I will implement the reconstruction properly in the final code.\n return 0;\n}","ahc030":"int main() {\n // Read N, M, epsilon\n // ...\n // Call solve()\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Helper function for ceiling integer division\ninline int ceil_div(int a, int b) {\n return (a + b - 1) / b;\n}\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n // Read reservation areas\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 // Step 1: Calculate minimum width for each reservation k to ensure h <= W\n // Each rectangle must have height \u2264 W, so w*k >= ceil(a[k]/W)\n vector w(N);\n for (int k = 0; k < N; ++k) {\n int max_a = 0;\n for (int d = 0; d < D; ++d) {\n max_a = max(max_a, a[d][k]);\n }\n w[k] = ceil_div(max_a, W);\n }\n\n // Step 2: Calculate total width used and remaining\n int current_sum = 0;\n for (int val : w) current_sum += val;\n \n // Step 3: Greedily distribute remaining width to minimize partition transition cost\n int remaining = W - current_sum;\n \n if (remaining > 0) {\n // Add width one pixel at a time, always staying within W\n for (int step = 0; step < remaining; ++step) {\n int best_k = -1;\n long long best_reduction = 0;\n bool found = false;\n \n // Try to find which strip gives maximum cost reduction\n for (int k = 0; k < N; ++k) {\n int old_w = w[k];\n int new_w = old_w + 1;\n \n // Calculate cost contribution of column k before and after adding width\n long long old_cost = 0;\n long long new_cost = 0;\n \n for (int d = 1; d < D; ++d) {\n int h1_old = ceil_div(a[d-1][k], old_w);\n int h2_old = ceil_div(a[d][k], old_w);\n int diff_old = abs(h1_old - h2_old);\n \n int h1_new = ceil_div(a[d-1][k], new_w);\n int h2_new = ceil_div(a[d][k], new_w);\n int diff_new = abs(h1_new - h2_new);\n \n old_cost += (long long)old_w * diff_old;\n new_cost += (long long)new_w * diff_new;\n }\n \n long long reduction = old_cost - new_cost;\n if (reduction > best_reduction) {\n best_reduction = reduction;\n best_k = k;\n found = true;\n }\n }\n \n if (found && best_k != -1 && best_reduction > 0) {\n w[best_k]++;\n } else {\n // No benefit to adding more width or all widths would exceed W\n break;\n }\n }\n }\n\n // Step 4: Ensure total width never exceeds W (should be guaranteed by algorithm)\n int final_sum = 0;\n for (int val : w) final_sum += val;\n \n if (final_sum > W) {\n // Reduce from the end if necessary\n int overflow = final_sum - W;\n for (int k = N - 1; k >= 0 && overflow > 0; --k) {\n int reduce = min(overflow, w[k] - 1); // Keep at least 1\n w[k] -= reduce;\n overflow -= reduce;\n }\n } else if (final_sum < W) {\n // Add remaining to w[0] or distribute\n int remaining_fill = W - final_sum;\n w[0] += remaining_fill;\n }\n\n // Step 5: Calculate starting x coordinates for each strip\n vector x_start(N);\n int curr_x = 0;\n for (int k = 0; k < N; ++k) {\n x_start[k] = curr_x;\n curr_x += w[k];\n }\n\n // Step 6: Output with validation (all coordinates \u2264 W)\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int h = ceil_div(a[d][k], w[k]);\n // Clamp coordinates to ensure validity\n int i0 = 0, j0 = x_start[k];\n int i1 = min(h, W), j1 = min(x_start[k] + w[k], W);\n \n // Ensure i0 < i1 and j0 < j1\n if (i1 <= i0) i1 = i0 + 1;\n if (j1 <= j0) j1 = j0 + 1;\n \n cout << i0 << \" \" << j0 << \" \" << i1 << \" \" << j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 9;\nconst int M = 20;\nconst int K = 81;\nconst int MOD = 998244353;\n\nint board[N][N];\nlong long current_score = 0;\n\n// Move related\nconst int MAX_MOVES = 981; // 20 * 49 + 1 (None)\nint move_impact_flat[MAX_MOVES][N][N]; // Stores value at (r,c) or 0\nvector move_cells_flat[MAX_MOVES]; // Stores packed (r*N + c) for non-zero values\n\nvector valid_moves_list;\nmt19937 rng;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_in, M_in, K_in;\n if (!(cin >> N_in >> M_in >> K_in)) return 0;\n\n // Read initial values\n for (int i = 0; i < N_in; ++i) {\n for (int j = 0; j < N_in; ++j) {\n cin >> board[i][j];\n current_score += board[i][j];\n }\n }\n\n // Read stamps\n vector> stamps(M_in, vector(9));\n for (int m = 0; m < M_in; ++m) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int idx = i * 3 + j;\n cin >> stamps[m][idx];\n }\n }\n }\n\n // Precompute moves\n int p_limit = N_in - 2; // 7\n valid_moves_list.push_back(980); // None move ID\n\n for (int m = 0; m < M_in; ++m) {\n for (int p = 0; p < p_limit; ++p) {\n for (int q = 0; q < p_limit; ++q) {\n int id = m * 49 + (p * 7 + q);\n valid_moves_list.push_back(id);\n\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = p + i;\n int c = q + j;\n if (r >= 0 && r < N_in && c >= 0 && c < N_in) {\n int val = stamps[m][i * 3 + j];\n move_impact_flat[id][r][c] = val;\n if (val != 0) {\n move_cells_flat[id].push_back(r * N_in + c);\n }\n }\n }\n }\n }\n }\n }\n \n // Initialize RNG\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n // Initialize current moves\n vector current_moves(K);\n for (int i = 0; i < K; ++i) {\n int idx = 1 + rng() % (valid_moves_list.size() - 1);\n current_moves[i] = valid_moves_list[idx];\n }\n\n // Apply initial moves\n for (int lid = 0; lid < K; ++lid) {\n int mid = current_moves[lid];\n for (int rc : move_cells_flat[mid]) {\n int r = rc / N_in;\n int c = rc % N_in;\n long long val = board[r][c] + move_impact_flat[mid][r][c];\n if (val >= MOD) val -= MOD;\n board[r][c] = val;\n }\n }\n\n // Recompute score\n current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += board[i][j];\n }\n }\n\n // Simulated Annealing\n int iter_count = 10000; // Number of outer iterations\n double initial_temp = 1000.0;\n double decay = 0.995;\n double temp = initial_temp;\n \n bool visited[81];\n uniform_real_distribution dist(0.0, 1.0);\n\n for (int iter = 0; iter < iter_count; ++iter) {\n int slot_idx = rng() % K;\n int curr_move_id = current_moves[slot_idx];\n \n // Mark curr cells to detect overlap\n for (int rc : move_cells_flat[curr_move_id]) {\n visited[rc] = true;\n }\n \n // Try a few random candidates\n int num_check = 50; \n for (int chk = 0; chk < num_check; ++chk) {\n int cand_id = valid_moves_list[0 + rng() % valid_moves_list.size()]; \n // Randomly pick candidate including None\n \n if (cand_id == curr_move_id) continue;\n \n int delta = 0;\n int r, c;\n \n // Calculate delta\n // Process cells affected by curr_move (subtract curr_impact)\n for (int rc : move_cells_flat[curr_move_id]) {\n r = rc / N; c = rc % N;\n int imp_curr = move_impact_flat[curr_move_id][r][c];\n int imp_cand = move_impact_flat[cand_id][r][c];\n long long val_old = board[r][c];\n long long val_new = (val_old - imp_curr + imp_cand + MOD) % MOD;\n delta += (int)val_new - val_old;\n }\n // Process cells affected by cand (add cand_impact, curr_impact is 0)\n for (int rc : move_cells_flat[cand_id]) {\n r = rc / N; c = rc % N;\n if (visited[rc]) continue; // Already processed in curr loop\n int imp_cand = move_impact_flat[cand_id][r][c];\n long long val_old = board[r][c];\n long long val_new = (val_old + imp_cand);\n if (val_new >= MOD) val_new -= MOD;\n delta += (int)val_new - val_old;\n }\n \n // Simulated Annealing acceptance\n // If delta >= 0, accept. Else accept with prob exp(delta/temp)\n if (delta >= 0 || dist(rng) < exp(delta / temp)) {\n // Accept move\n current_moves[slot_idx] = cand_id;\n \n // Update board\n // Revert curr\n for (int rc : move_cells_flat[curr_move_id]) {\n r = rc / N; c = rc % N;\n long long val = board[r][c] - move_impact_flat[curr_move_id][r][c];\n if (val < 0) val += MOD;\n board[r][c] = val;\n }\n // Apply cand\n for (int rc : move_cells_flat[cand_id]) {\n r = rc / N; c = rc % N;\n long long val = board[r][c] + move_impact_flat[cand_id][r][c];\n if (val >= MOD) val -= MOD;\n board[r][c] = val;\n }\n current_score += delta;\n break; // Move accepted, break candidate loop\n }\n }\n \n // Reset visited array\n for (int rc : move_cells_flat[curr_move_id]) {\n visited[rc] = false;\n }\n \n // Decay temp\n temp *= decay;\n }\n\n // Output result\n vector>> final_ops;\n for (int i = 0; i < K; ++i) {\n if (current_moves[i] != 980) {\n int id = current_moves[i];\n int m = id / 49;\n int rem = id % 49;\n int p = rem / 7;\n int q = rem % 7;\n final_ops.push_back({m, {p, q}});\n }\n }\n \n cout << final_ops.size() << \"\\n\";\n for (auto& op : final_ops) {\n cout << op.first << \" \" << op.second.first << \" \" << op.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_N = 5;\nconst int MAX_TURNS = 5000; // Sufficient for N=5 grid\n\n// Global State\nint grid[MAX_N][MAX_N];\npair crane_pos[MAX_N];\nint crane_load[MAX_N];\nvector> A_matrix;\nvector input_idx[MAX_N];\nvector ans[MAX_N];\n\n// Directions: U, D, L, R\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char move_char[] = {'U', 'D', 'L', 'R'};\n\nvoid solve() {\n // Initialization\n for (int i = 0; i < MAX_N; ++i) {\n for (int j = 0; j < MAX_N; ++j) {\n grid[i][j] = -1;\n }\n input_idx[i] = 0;\n crane_pos[i] = {i, 0};\n crane_load[i] = -1;\n ans[i] = \"\";\n }\n\n int turns = 0;\n // Simulation Loop\n while (turns < MAX_TURNS) {\n // Step 1: Receiving Gate Spawning\n for (int i = 0; i < MAX_N; ++i) {\n if (input_idx[i] == MAX_N) continue;\n // A container spawns at (i, 0) if no container is there AND no crane holding is there.\n // Idle crane at (i, 0) does NOT block spawn based on problem statement.\n bool blocked = (grid[i][0] != -1);\n for (int c = 0; c < MAX_N; ++c) {\n if (crane_pos[c].first == i && crane_pos[c].second == 0) {\n if (crane_load[c] != -1) {\n blocked = true;\n break;\n }\n }\n }\n if (!blocked) {\n grid[i][0] = A_matrix[i][input_idx[i]];\n input_idx[i]++;\n }\n }\n\n // Step 2: Action Planning\n struct Plan {\n int id;\n int type; // 0:Wait, 1:Move, 2:P, 3:Q\n int nr, nc;\n int score;\n };\n Plan plans[MAX_N];\n\n for (int i = 0; i < MAX_N; ++i) {\n plans[i].id = i;\n plans[i].score = 0;\n plans[i].nr = crane_pos[i].first;\n plans[i].nc = crane_pos[i].second;\n\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n\n // 1. Priority Dispatch: 'Q' at Gate\n // Only dispatch if container belongs to current row\n if (c == MAX_N - 1 && crane_load[i] != -1) {\n int row_id = crane_load[i] / MAX_N;\n if (row_id == r) {\n plans[i].type = 3; // Q\n plans[i].score = 20000;\n continue; \n }\n }\n\n // 2. Priority Pickup: 'P' at Gate\n if (plans[i].score == 0 && crane_load[i] == -1) {\n if (grid[r][c] != -1) { // Container available\n plans[i].type = 2; // P\n plans[i].score = 10000;\n continue;\n }\n }\n\n // 3. Move Logic\n if (plans[i].score == 0) {\n plans[i].type = 4; // Wait\n plans[i].score = 0;\n\n // Target logic\n int tr = r, tc = c;\n int desired_dist = 0;\n \n // If holding container, target is its dispatch row\n if (crane_load[i] != -1) {\n tr = crane_load[i] / MAX_N;\n tc = MAX_N - 1;\n desired_dist = 1000;\n } else {\n // Find nearest row with pending input\n bool found = false;\n for (int k = 0; k < MAX_N; ++k) {\n if (input_idx[k] < MAX_N) {\n tr = k;\n tc = 0;\n found = true;\n break;\n }\n }\n if (found) {\n desired_dist = 5;\n } else {\n desired_dist = 0; // No input, stay put\n }\n }\n\n int best_d = 100;\n int best_move = -1;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < MAX_N && nc >= 0 && nc < MAX_N) {\n int d_dist = abs(nr - tr) + abs(nc - tc);\n if (d_dist < best_d) {\n best_d = d_dist;\n best_move = d;\n plans[i].nr = nr;\n plans[i].nc = nc;\n }\n }\n }\n \n if (best_move != -1) {\n plans[i].type = 1; // Move\n plans[i].score = desired_dist * 10 + (crane_load[i] != -1 ? 1000 : 0) - best_d;\n } else {\n plans[i].type = 4; // Wait\n }\n }\n\n // LC Bonus to prioritize clearing paths\n if (i == 0) plans[i].score += 2000;\n }\n\n // Step 3: Conflict Resolution\n // Order by score descending\n int p_idx[MAX_N];\n for(int i=0; i plans[b].score; });\n\n pair final_pos[MAX_N];\n int final_act[MAX_N];\n \n // Initialize with current positions (default for Wait)\n for(int i=0; i other_start, other -> cr_start\n if (final_pos[cr].first != crane_pos[cr].first && // Cr moves\n final_pos[other].first != crane_pos[other].first) { // Other moves\n if (nr == crane_pos[other].first && nc == crane_pos[other].second &&\n final_pos[other] == crane_pos[cr]) {\n collision = true;\n }\n }\n // Check if we both want same square\n if (nr == final_pos[other].first && nc == final_pos[other].second) {\n collision = true;\n }\n }\n\n // Lower priority cranes default to crane_pos[i].\n // If collision with lower priority, we usually win (since sorted desc).\n // But if lower priority is LC? LC has base bonus, but here sorted by score.\n // If LC collides with SC (which has higher score for Q/P), LC yields.\n // If we collide with any other, we yield (to avoid WA).\n \n // Special check: Small Crane carrying container cannot move to occupied.\n // We rely on heuristic planning, but strictly:\n if (collision) type = 4; // Wait\n \n // Check Small Crane movement constraint (Carrying + Occupied)\n // This is implicitly handled by heuristic not choosing blocked paths, but strictly:\n if (type == 1) {\n // If SC carrying, check if final_pos has container\n if (cr > 0 && crane_load[cr] != -1) {\n // We need to check grid state at final_pos\n // Wait, we need current grid state or predicted? Use current grid.\n // If final_pos has container ID, SC cannot move there.\n if (grid[nr][nc] != -1) {\n type = 4;\n }\n }\n }\n \n final_act[cr] = type;\n final_pos[cr] = {nr, nc};\n }\n\n // Step 4: Execute & Record\n int next_grid[MAX_N][MAX_N];\n for(int i=0; i> N)) return 0;\n \n A_matrix.resize(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A_matrix[i][j];\n }\n }\n \n solve();\n \n // Generate output strings with padding\n vector outputs(MAX_N);\n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\nint n;\nvector> heights;\n\nint manhattanDist(int r1, int c1, int r2, int c2) {\n return abs(r2 - r1) + abs(c2 - c1);\n}\n\nstring getMovePath(int fromR, int fromC, int toR, int toC) {\n string path = \"\";\n int curR = fromR, curC = fromC;\n \n while (curR != toR || curC != toC) {\n if (curR < toR) { path += \"D\"; curR++; }\n else if (curR > toR) { path += \"U\"; curR--; }\n else if (curC < toC) { path += \"R\"; curC++; }\n else if (curC > toC) { path += \"L\"; curC--; }\n }\n return path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n heights.resize(n, vector(n));\n \n vector> surplus;\n vector> deficit;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> heights[i][j];\n if (heights[i][j] > 0) {\n surplus.push_back({i, j});\n } else if (heights[i][j] < 0) {\n deficit.push_back({i, j});\n }\n }\n }\n \n struct Transport {\n int fromR, fromC;\n int toR, toC;\n int amt;\n int dist;\n };\n \n vector transports;\n \n for (int i = 0; i < surplus.size(); i++) {\n for (int j = 0; j < deficit.size(); j++) {\n int fr = surplus[i].first, fc = surplus[i].second;\n int tr = deficit[j].first, tc = deficit[j].second;\n int h = min(heights[fr][fc], -heights[tr][tc]);\n \n if (h <= 0) continue;\n \n int dist = manhattanDist(fr, fc, tr, tc);\n transports.push_back({fr, fc, tr, tc, h, dist});\n }\n }\n \n sort(transports.begin(), transports.end(), [](const Transport& a, const Transport& b) {\n return a.dist < b.dist;\n });\n \n vector ops;\n int curR = 0, curC = 0;\n int truckLoad = 0;\n \n for (const auto& t : transports) {\n int amt = t.amt;\n if (amt <= 0) continue;\n \n // Move to source\n string path1 = getMovePath(curR, curC, t.fromR, t.fromC);\n ops.insert(ops.end(), path1.begin(), path1.end());\n curR = t.fromR;\n curC = t.fromC;\n \n // Load\n for (int k = 0; k < amt; k++) {\n ops += \"+1\";\n truckLoad++;\n }\n heights[t.fromR][t.fromC] -= amt;\n \n // Move to destination\n string path2 = getMovePath(curR, curC, t.toR, t.toC);\n ops.insert(ops.end(), path2.begin(), path2.end());\n curR = t.toR;\n curC = t.toC;\n \n // Unload\n for (int k = 0; k < amt; k++) {\n ops += \"-1\";\n truckLoad--;\n }\n heights[t.toR][t.toC] += amt;\n }\n \n cout << ops.size() << \"\\n\";\n for (const string& op : ops) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold seed information\nstruct Seed {\n int id;\n vector values;\n int total_value;\n};\n\n// Grid coordinates with distance metric from center\nstruct Pos {\n int r, c;\n int dist_sq;\n};\n\n// Sort positions: closer to center first\nbool comparePos(const Pos& a, const Pos& b) {\n if (a.dist_sq != b.dist_sq) {\n return a.dist_sq < b.dist_sq;\n }\n if (a.r != b.r) return a.r < b.r;\n return a.c < b.c;\n}\n\nint main() {\n // Optimize I/O for speed\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n\n int seed_count = 2 * N * (N - 1);\n vector seeds(seed_count);\n\n // Read initial seeds\n for (int k = 0; k < seed_count; ++k) {\n seeds[k].id = k;\n seeds[k].values.resize(M, 0);\n seeds[k].total_value = 0;\n for (int l = 0; l < M; ++l) {\n cin >> seeds[k].values[l];\n seeds[k].total_value += seeds[k].values[l];\n }\n }\n\n // Precompute grid positions order (Center to Edge)\n // We use squared distance from center to sort positions\n int center_val = N - 1; // 2 * center (scaled)\n vector positions;\n positions.reserve(N * N);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int dr = 2 * r - center_val;\n int dc = 2 * c - center_val;\n int d2 = dr * dr + dc * dc;\n positions.push_back({r, c, d2});\n }\n }\n sort(positions.begin(), positions.end(), comparePos);\n\n for (int t = 0; t < T; ++t) {\n // Strategy:\n // 1. Identify seeds that hold the global maximum for each coordinate (M criteria).\n // Ensuring these seeds are kept prevents losing \"potential\" high values (e.g., 100).\n // 2. Select the top N^2 seeds. \n // Priority: Must-Keep Seeds -> Highest Sum Seeds.\n // 3. Assign selected seeds to positions sorted by Center Dist (Center first).\n\n // Step 1: Find IDs holding max for each coord\n vector seed_with_max_id(M, -1);\n vector max_val(M, -1); // Values >= 0, so -1 works\n\n for (const auto& s : seeds) {\n for (int l = 0; l < M; ++l) {\n if (s.values[l] > max_val[l]) {\n max_val[l] = s.values[l];\n seed_with_max_id[l] = s.id;\n }\n }\n }\n\n // Mark seeds that MUST be kept to preserve high potential values\n vector must_keep(seed_count, false);\n for (int id : seed_with_max_id) {\n if (id != -1) must_keep[id] = true;\n }\n\n // Separate seeds into Must Keep and Others\n vector must_keep_ids;\n vector other_ids;\n\n for (int k = 0; k < seed_count; ++k) {\n if (must_keep[k]) {\n must_keep_ids.push_back(k);\n } else {\n other_ids.push_back(k);\n }\n }\n\n // Step 2: Select best N^2 seeds\n // Sort Others by total_value descending to prioritize highest sums\n sort(other_ids.begin(), other_ids.end(), [&](int a, int b) {\n return seeds[a].total_value > seeds[b].total_value;\n });\n\n vector selected_ids;\n selected_ids.reserve(N * N);\n\n // Add all must keep seeds first\n for (int k : must_keep_ids) selected_ids.push_back(k);\n\n // Fill the rest with highest value seeds from others\n for (int k : other_ids) {\n if ((int)selected_ids.size() >= N * N) break;\n selected_ids.push_back(k);\n }\n\n // Safety: If duplicates or too many must_keep (unlikely with M=15), truncate by value\n if ((int)selected_ids.size() > N * N) {\n vector tmp_ids = selected_ids;\n sort(tmp_ids.begin(), tmp_ids.end(), [&](int a, int b) {\n return seeds[a].total_value > seeds[b].total_value;\n });\n selected_ids.resize(N * N);\n copy(tmp_ids.begin(), tmp_ids.begin() + N * N, selected_ids.begin());\n }\n\n // Step 3: Sort selected by total_value descending to place in best positions (center)\n // This ensures the seeds with the highest \"average\" contribution go to the most connected spots.\n sort(selected_ids.begin(), selected_ids.end(), [&](int a, int b) {\n return seeds[a].total_value > seeds[b].total_value;\n });\n\n // Step 4: Assign to grid\n vector> grid(N, vector(N));\n for (int k = 0; k < N * N; ++k) {\n int seed_id = selected_ids[k];\n Pos pos = positions[k];\n grid[pos.r][pos.c] = seed_id;\n }\n\n // Output grid configuration\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cout << grid[r][c] << (c == N - 1 ? \"\\n\" : \" \");\n }\n }\n cout.flush();\n\n // Read new seeds for the next turn\n vector next_seeds(seed_count);\n for (int k = 0; k < seed_count; ++k) {\n next_seeds[k].id = k;\n next_seeds[k].values.resize(M, 0);\n next_seeds[k].total_value = 0;\n for (int l = 0; l < M; ++l) {\n cin >> next_seeds[k].values[l];\n next_seeds[k].total_value += next_seeds[k].values[l];\n }\n }\n seeds = move(next_seeds);\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a coordinate pair\nstruct Point {\n int r, c;\n};\n\n// Structure to represent a task (moving an item from src to tgt)\nstruct Task {\n Point src, tgt;\n};\n\nint N, M, V;\nint grid_s[35][35];\nint grid_t[35][35];\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> V)) return 0;\n\n vector sources;\n vector targets;\n\n // Read initial positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_s[i][j] = (s[j] == '1');\n if (grid_s[i][j]) sources.push_back({i, j});\n }\n }\n // Read target positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_t[i][j] = (s[j] == '1');\n if (grid_t[i][j]) targets.push_back({i, j});\n }\n }\n\n // Filter out sources that are already on targets, \n // and targets that are already occupied.\n vector active_sources;\n vector active_targets;\n\n vector> is_target(N, vector(N, false));\n for(const auto& t : targets) is_target[t.r][t.c] = true;\n\n vector> is_source(N, vector(N, false));\n for(const auto& s : sources) is_source[s.r][s.c] = true;\n\n // Identify active sources (sources not on targets)\n for(const auto& s : sources) {\n if(!is_target[s.r][s.c]) active_sources.push_back(s);\n }\n // Identify active targets (targets not on sources)\n for(const auto& t : targets) {\n if(!is_source[t.r][t.c]) active_targets.push_back(t);\n }\n\n // Greedy matching between active sources and active targets\n // Since constraints are small (N<=30, M<=225), O(M^2) is acceptable.\n vector tasks;\n vector tgt_used(active_targets.size(), false);\n\n for (const auto& s : active_sources) {\n int best_idx = -1;\n int min_dist = 2000; // Max dist is roughly 60\n for (int i = 0; i < (int)active_targets.size(); ++i) {\n if (!tgt_used[i]) {\n int d = abs(s.r - active_targets[i].r) + abs(s.c - active_targets[i].c);\n if (d < min_dist) {\n min_dist = d;\n best_idx = i;\n }\n }\n }\n if (best_idx != -1) {\n tgt_used[best_idx] = true;\n tasks.push_back({s, active_targets[best_idx]});\n }\n }\n\n // --- Output Robotic Arm Design ---\n // We use a Star Graph: Root (0) connected to 1, 2, ..., V-1.\n // Edge lengths are all 1.\n cout << V << \"\\n\";\n for (int i = 1; i < V; ++i) {\n cout << 0 << \" \" << 1 << \"\\n\";\n }\n // Initial Root Position: Center of the grid\n cout << (N / 2) << \" \" << (N / 2) << \"\\n\";\n\n // --- Simulation ---\n int root_r = N / 2;\n int root_c = N / 2;\n int finger_dir = 0; // 0: Right, 1: Down, 2: Left, 3: Up. Initial state: Right (0)\n int dx[4] = {0, 1, 0, -1};\n int dy[4] = {1, 0, -1, 0};\n\n // Output buffer string\n string buf(2 * V, '.'); \n\n // Execute each task: Pick from Source -> Move -> Deliver at Target -> Place\n for (const auto& task : tasks) {\n Point src = task.src;\n Point tgt = task.tgt;\n\n // --- STEP 1: PICK UP ---\n \n // Find valid Root position and orientation to reach Source\n int pick_r = -1, pick_c = -1, pick_d = -1;\n int min_cost = 1e9;\n\n // Try all 4 directions for Finger 1\n for (int d = 0; d < 4; ++d) {\n // If finger points at src, Root must be at src - offset\n int r = src.r - dx[d];\n int c = src.c - dy[d];\n // Check bounds\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n // Prefer shorter distance; tie-break with preferred direction if possible\n if (dist < min_cost || (dist == min_cost && d == finger_dir)) {\n min_cost = dist;\n pick_r = r;\n pick_c = c;\n pick_d = d;\n }\n }\n }\n\n // Move Root to pick position\n int dr = 0, dc = 0;\n if (root_r < pick_r) dr = 1;\n if (root_r > pick_r) dr = -1;\n if (root_c < pick_c) dc = 1;\n if (root_c > pick_c) dc = -1;\n\n for (int k = 0; k < min_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n // Rotation and Action are '.' (no-op)\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1 to match direction\n while (finger_dir != pick_d) {\n buf[0] = '.'; // Move is idle\n buf[1] = '.'; // Reset rotation char\n buf[V + 1] = '.'; // Reset action char\n \n int diff = (pick_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R'; // CW 90\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L'; // CCW 90\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Pick Up Action (Vertex 1 Action is at index V + 1)\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n\n // --- STEP 2: DELIVER ---\n \n // Find valid Root position and orientation to reach Target\n int del_r = -1, del_c = -1, del_d = -1;\n int del_cost = 1e9;\n\n for (int d = 0; d < 4; ++d) {\n int r = tgt.r - dx[d];\n int c = tgt.c - dy[d];\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n if (dist < del_cost || (dist == del_cost && d == finger_dir)) {\n del_cost = dist;\n del_r = r;\n del_c = c;\n del_d = d;\n }\n }\n }\n\n // Move Root to target position\n dr = dc = 0;\n if (root_r < del_r) dr = 1;\n if (root_r > del_r) dr = -1;\n if (root_c < del_c) dc = 1;\n if (root_c > del_c) dc = -1;\n\n for (int k = 0; k < del_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1\n while (finger_dir != del_d) {\n buf[0] = '.'; \n buf[1] = '.';\n buf[V + 1] = '.'; \n int diff = (del_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R';\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L';\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Place Action\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n }\n\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n\n// Boost Geometry\n#include \n#include \n#include \n#include \n\nnamespace bg = boost::geometry;\nnamespace bgm = boost::geometry::model;\n\nusing coord = double;\nusing point = bgm::point;\nusing polygon = bgm::polygon;\nusing multi_polygon = bgm::multi_polygon;\n\nstruct RectInfo {\n int x_min, x_max, y_min, y_max;\n int mackerels;\n int sardines;\n int id;\n int score;\n};\n\nbool is_inside(int x, int y, int min_x, int max_x, int min_y, int max_y) {\n return (x >= min_x && x <= max_x && y >= min_y && y <= max_y);\n}\n\nstd::vector> kmeans(int n, int k, const std::vector>& points) {\n std::vector> centroids;\n std::mt19937 rng(42);\n std::uniform_int_distribution dist(0, n - 1);\n for(int i=0; i> members(k);\n for(int iter=0; iter<10; ++iter) {\n std::vector> new_members(k);\n for(int i=0; i> N)) return 0;\n\n std::vector> mackerels(N);\n std::vector> sardines(N);\n\n for(int i=0; i> mackerels[i].first >> mackerels[i].second;\n for(int i=0; i> sardines[i].first >> sardines[i].second;\n\n int k_clusters = 20;\n if (N < k_clusters) k_clusters = N;\n\n std::vector> clusters = kmeans(N, k_clusters, mackerels);\n std::vector all_rects;\n\n for (int i = 0; i < k_clusters; ++i) {\n if (clusters[i].empty()) continue;\n int xmin = 100005, xmax = -1, ymin = 100005, ymax = -1;\n for (int idx : clusters[i]) {\n int x = mackerels[idx].first, y = mackerels[idx].second;\n xmin = std::min(xmin, x); xmax = std::max(xmax, x);\n ymin = std::min(ymin, y); ymax = std::max(ymax, y);\n }\n int mc = 0, sc = 0;\n for (const auto& p : mackerels) if(is_inside(p.first, p.second, xmin, xmax, ymin, ymax)) mc++;\n for (const auto& p : sardines) if(is_inside(p.first, p.second, xmin, xmax, ymin, ymax)) sc++;\n all_rects.push_back({xmin, xmax, ymin, ymax, mc, sc, i, mc - sc});\n }\n\n std::sort(all_rects.begin(), all_rects.end(), [](const RectInfo& a, const RectInfo& b){return a.score > b.score;});\n int k_sel = std::min(10, (int)all_rects.size());\n std::vector selected(all_rects.begin(), all_rects.begin() + k_sel);\n \n std::sort(selected.begin(), selected.end(), [](const RectInfo& a, const RectInfo& b){\n return (a.x_min + a.x_max) < (b.x_min + b.x_max);\n });\n\n multi_polygon mp;\n std::vector polys;\n\n for (const auto& r : selected) {\n polygon p;\n bg::read_wkt(\"POLYGON((\" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_min) + \", \" +\n std::to_string(r.x_max) + \",\" + std::to_string(r.y_min) + \", \" +\n std::to_string(r.x_max) + \",\" + std::to_string(r.y_max) + \", \" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_max) + \", \" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_min) + \"))\", p);\n polys.push_back(p);\n }\n\n for (size_t i = 0; i < polys.size() - 1; ++i) {\n const auto& ri = selected[i]; const auto& rj = selected[i+1];\n int x_start = std::min(ri.x_max, rj.x_max);\n int x_end = std::max(ri.x_min, rj.x_min); // Connect min(x) to max(x)\n if (x_start > x_end) std::swap(x_start, x_end);\n \n int y_int_min = std::max(ri.y_min, rj.y_min);\n int y_int_max = std::min(ri.y_max, rj.y_max);\n if (y_int_min > y_int_max) {\n int mid = (ri.y_min + ri.y_max + rj.y_min + rj.y_max) / 4;\n y_int_min = mid; y_int_max = mid + 1;\n }\n y_int_max += 1;\n\n if (x_start <= x_end) {\n polygon bp;\n bg::read_wkt(\"POLYGON((\" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_min) + \", \" +\n std::to_string(x_end) + \",\" + std::to_string(y_int_min) + \", \" +\n std::to_string(x_end) + \",\" + std::to_string(y_int_max) + \", \" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_max) + \", \" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_min) + \"))\", bp);\n polys.push_back(bp);\n }\n }\n\n for(const auto& p : polys) bg::append(mp, p);\n \n // Union\n multi_polygon result;\n if(!mp.empty()) {\n result = mp;\n for(size_t i=0; i vertices(final_poly.outer().begin(), final_poly.outer().end());\n std::vector simplified;\n if(vertices.size() > 2) {\n simplified.push_back(vertices[0]);\n for(size_t i=1; i 1e-9 || cp < -1e-9) simplified.push_back(vertices[i]);\n }\n simplified.push_back(vertices.back());\n } else simplified = vertices;\n\n std::vector> out;\n for(const auto& v : simplified) out.push_back({(int)std::round(v.x()), (int)std::round(v.y())});\n\n if (out.size() >= 2 && out.front() == out.back()) out.pop_back();\n\n std::cout << out.size() << \"\\n\";\n for(const auto& p : out) std::cout << p.first << \" \" << p.second << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a placement decision for a rectangle\nstruct Decision {\n int id; // Original rectangle index (0 to N-1)\n int r; // Rotation: 0 or 1\n char d; // Direction: 'U' or 'L'\n int b; // Base rectangle index (value of p_j for j < i, or -1)\n};\n\nstruct Rect {\n long long w, h;\n};\n\n// Global variables for N and T\nint N, T;\nvector rects; // Stores the observed w', h'\n\n// Function to evaluate the proxy cost (estimated W + H)\n// This function simulates the placement using the provided observed dimensions (w', h')\n// It uses a linear scan for column/row management instead of map for performance\nlong long get_cost(const vector& config, int n) {\n // Store active columns: x coordinate, current maximum height in that column\n struct Col { long long x; long long max_h; };\n // Store active rows: y coordinate, current maximum width in that row\n struct Row { long long y; long long max_w; };\n\n vector cols;\n vector rows;\n \n // pos[i] stores the x,y coordinate of rectangle i after placement\n vector> pos(n);\n // dims[i] stores the effective w, h of rectangle i after rotation\n vector> dims(n);\n \n long long global_max_W = 0;\n long long global_max_H = 0;\n \n for(int i=0; i c.max_h) c.max_h = new_h;\n break;\n }\n }\n } else {\n cols.push_back({px, py + h});\n }\n } else { // config[i].d == 'L'\n // L: Move leftward.\n // Align Top edge to Bottom edge of base rectangle b.\n // If b == -1, align Top edge to y=0.\n if(config[i].b == -1) {\n py = 0;\n } else {\n long long base_py = pos[config[i].b].second;\n long long base_ph = dims[config[i].b].second;\n py = base_py + base_ph;\n }\n \n // Find existing width at this row y = py\n long long row_w = 0;\n bool found_row = false;\n // Linear scan over active rows\n for(const auto& r : rows) {\n if(r.y == py) {\n row_w = r.max_w;\n found_row = true;\n break;\n }\n }\n px = row_w;\n \n // Update the row width\n if(found_row) {\n long long new_w = px + w;\n for(auto& r : rows) {\n if(r.y == py) {\n if(new_w > r.max_w) r.max_w = new_w;\n break;\n }\n }\n } else {\n rows.push_back({py, px + w});\n }\n }\n \n pos[i] = {px, py};\n if(px + w > global_max_W) global_max_W = px + w;\n if(py + h > global_max_H) global_max_H = py + h;\n }\n \n return global_max_W + global_max_H;\n}\n\nint main() {\n // Optimization for Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read problem parameters\n if (!(cin >> N >> T)) return 0;\n long long sigma; \n cin >> sigma;\n \n rects.resize(N);\n for(int i=0; i> rects[i].w >> rects[i].h;\n }\n \n // Initialize random number generator\n // Using a fixed seed for reproducibility in local testing, \n // but varying slightly per submission might be useful in production\n mt19937 rng(42); \n \n // Initialize global best configuration\n // Strategy: Place all N rectangles (indices 0 to N-1)\n vector best_config(N);\n \n // Initial heuristic placement (simple random or deterministic start)\n // We initialize with plausible values to start hill climbing from a good point.\n // Greedy initialization could be better but random is safer for heuristic\n for(int i=0; i candidate = best_config;\n long long current_score = global_best_score;\n \n // Hill Climbing Loop to refine the configuration\n // We perform local searches (flip r, d, b) to find a lower cost\n // The number of iterations is tuned for the 3.0s time limit\n // N <= 100, so O(N^2) get_cost is roughly 10^4 ops.\n // We need total ops < ~5*10^8.\n // T iterations * Inner iters * get_cost.\n // T <= 400. If Inner iters = 30. Total = 400 * 30 * 10^4 = 1.2*10^8.\n \n int hill_climbing_iters = 30; \n \n for(int it=0; it 0) {\n // Possible bases are -1 and 0..i-1 (i+1 options)\n int choice = rng() % (i + 1);\n new_b = (choice == 0 ? -1 : (choice - 1));\n }\n \n if(new_b != old_b) {\n candidate[i].b = new_b;\n long long sc = get_cost(candidate, N);\n if(sc < current_score) {\n current_score = sc;\n // Keep change\n } else {\n candidate[i].b = old_b; // Revert\n }\n }\n }\n }\n \n // Update Global Best if improvement found\n if(current_score < global_best_score) {\n global_best_score = current_score;\n best_config = candidate;\n }\n \n // Output the configuration found so far\n cout << best_config.size() << \"\\n\";\n for(const auto& d : best_config) {\n cout << d.id << \" \" << d.r << \" \" << d.d << \" \" << d.b << \"\\n\";\n }\n cout.flush(); \n \n // Read feedback from judge (W', H')\n // We rely on our internal simulation cost rather than noisy W', H' for strategy\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \n#include \"atcoder/maxflow\"\n#include \"atcoder/internal_bit\"\nusing namespace std;\nusing namespace atcoder;\n\n#define rep(i, n) for (int i = 0; i < (n); ++i)\n#define rep1(i, a, b) for (int i = (a); i <= (b); ++i)\n\nstruct Vertex {\n int id;\n long long beauty;\n int x, y;\n};\n\nstruct Solver {\n int N, M, H;\n vector A;\n vector> edges;\n vector adj[1005];\n vector parent;\n vector depth;\n long long current_score = 0;\n\n Solver(int N, int M, int H, const vector& A, const vector>& edges)\n : N(N), M(M), H(H), A(A), edges(edges), parent(N, -1), depth(N, 0) {}\n\n // Build adjacency list\n void build_graph() {\n rep(i, M) {\n int u = edges[i].first;\n int v = edges[i].second;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n }\n\n // BFS to compute all depths from root assignments\n void compute_depths() {\n queue q;\n fill(depth.begin(), depth.end(), -1);\n\n rep(i, N) {\n if (parent[i] == -1) {\n depth[i] = 0;\n q.push(i);\n }\n }\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n for (int v : adj[u]) {\n if (parent[v] == u && depth[v] == -1) {\n depth[v] = depth[u] + 1;\n q.push(v);\n }\n }\n }\n }\n\n // Recompute score based on current parent assignment\n void recompute_score() {\n compute_depths();\n current_score = 0;\n rep(i, N) {\n if (depth[i] >= 0) {\n current_score += (long long)(depth[i] + 1) * A[i];\n }\n }\n }\n\n long long get_score() const {\n long long total = 0;\n rep(i, N) {\n if (depth[i] >= 0) {\n total += (long long)(depth[i] + 1) * A[i];\n }\n }\n return total;\n }\n\n // Check if moving vertex v to parent p is valid\n bool is_valid_move(int v, int p) {\n if (p == v) return false;\n if (depth[p] >= H) return false;\n if (p != -1 && depth[p] + 1 > H) return false;\n\n // Check if new parent is in adj\n bool in_adj = false;\n for (int neighbor : adj[v]) {\n if (neighbor == p) {\n in_adj = true;\n break;\n }\n }\n if (!in_adj && p != -1) return false;\n\n return true;\n }\n\n // Simulate a move without actually applying it\n long long evaluate_move(int v, int p) {\n if (!is_valid_move(v, p)) return -1;\n\n int old_parent = parent[v];\n int old_depth = depth[v];\n\n long long score_change = 0;\n\n // Change v's contribution\n int new_depth = (p == -1) ? 0 : depth[p] + 1;\n score_change += (long long)(new_depth + 1) * A[v] - (long long)(old_depth + 1) * A[v];\n\n return score_change;\n }\n\n // Actually apply a move\n void apply_move(int v, int p) {\n parent[v] = p;\n recompute_score();\n }\n\n // Local search with simulated annealing\n long long solve() {\n // First, initialize with a heuristic assignment\n initialize();\n\n // Local search with simulated annealing\n long long best_score = get_score();\n int temperature = 1000000;\n double cooling_rate = 0.9998;\n\n mt19937 gen(42);\n uniform_int_distribution dist(0, 1000000);\n\n rep(iter, 50000) {\n // Get current score\n long long cur_score = get_score();\n\n if (cur_score > best_score) best_score = cur_score;\n\n // Try random moves\n int v = uniform_int_distribution(0, N - 1)(gen);\n\n // Try all possible parents including -1 (root)\n vector parents;\n parents.push_back(-1);\n for (int p : adj[v]) parents.push_back(p);\n\n int best_p = parent[v];\n long long best_diff = 0;\n\n for (int p : parents) {\n long long diff = evaluate_move(v, p);\n if (diff > best_diff) {\n best_diff = diff;\n best_p = p;\n }\n }\n\n // Apply move with simulated annealing acceptance\n long long diff = evaluate_move(v, best_p);\n if (diff > 0 || (double)dist(gen) < diff * 100 / (temperature + 1)) {\n apply_move(v, best_p);\n }\n\n // Cool down\n temperature *= cooling_rate;\n }\n\n return get_score();\n }\n\n // Initial assignment using greedy approach\n void initialize() {\n vector visited(N, 0);\n fill(parent.begin(), parent.end(), -1);\n\n // Sort vertices by beauty in descending order\n vector> sorted_nodes(N);\n rep(i, N) sorted_nodes[i] = {A[i], i};\n sort(sorted_nodes.rbegin(), sorted_nodes.rend());\n\n rep(iter, N) {\n int v = sorted_nodes[iter].second;\n if (visited[v]) continue;\n\n // BFS to find a valid assignment with depth constraint\n queue q;\n q.push(v);\n vector tree_nodes;\n tree_nodes.push_back(v);\n visited[v] = 1;\n parent[v] = -1;\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n for (int neighbor : adj[u]) {\n if (visited[neighbor]) continue;\n\n int new_depth = depth[u] + 1;\n if (new_depth > H) continue;\n\n if (depth[u] != -1) {\n visited[neighbor] = 1;\n parent[neighbor] = u;\n depth[neighbor] = new_depth;\n tree_nodes.push_back(neighbor);\n q.push(neighbor);\n }\n }\n }\n }\n\n // Fix up: ensure all vertices are assigned\n rep(i, N) {\n if (parent[i] == -1) {\n // Find a valid parent\n for (int p : adj[i]) {\n if (depth[p] != -1 && depth[p] < H - depth[i]) {\n parent[i] = p;\n break;\n }\n }\n }\n }\n\n recompute_score();\n }\n\n // Final refinement with more aggressive local search\n void refine() {\n int improved = 1;\n while (improved) {\n improved = 0;\n rep(v, N) {\n int old_parent = parent[v];\n long long old_contrib = (parent[v] == -1) ? depth[v] : depth[parent[v]];\n\n for (int p : adj[v]) {\n if (p == v) continue;\n if (depth[p] >= H - 1) continue;\n\n int new_depth = depth[p] + 1;\n long long new_contrib = new_depth;\n\n if (new_contrib != depth[v]) {\n apply_move(v, p);\n long long gain = get_score();\n long long old_val = get_score();\n\n if (gain > old_val) {\n improved = 1;\n continue;\n }\n }\n }\n }\n }\n }\n\n const vector& get_parent() const {\n return parent;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n\n vector A(N);\n rep(i, N) cin >> A[i];\n\n vector> edges(M);\n rep(i, M) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector> coords(N);\n rep(i, N) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n Solver solver(N, M, H, A, edges);\n solver.build_graph();\n\n // Initial greedy assignment\n vector parent(N, -1);\n vector depth(N, 0);\n\n // Start BFS from each unvisited node as root\n vector visited(N, false);\n vector roots;\n rep(i, N) {\n if (!visited[i]) {\n for (int r : roots) {\n if (adj[r].empty()) {\n if (!visited[i]) {\n parent[i] = r;\n visited[i] = true;\n break;\n }\n }\n }\n if (!visited[i]) {\n // BFS to find valid tree\n queue> q;\n q.push({i, 0});\n visited[i] = true;\n parent[i] = -1;\n depth[i] = 0;\n\n while (!q.empty()) {\n auto [u, d] = q.front();\n q.pop();\n\n for (int v : adj[u]) {\n if (!visited[v] && d + 1 <= H) {\n visited[v] = true;\n parent[v] = u;\n depth[v] = d + 1;\n q.push({v, d + 1});\n }\n }\n }\n roots.push_back(i);\n }\n }\n }\n\n // Refine using local search\n auto update_parent = [&](int v, int p) -> bool {\n if (p == v) return false;\n if (parent[v] == p) return false;\n\n if (p != -1 && depth[p] >= H - 1) return false;\n\n int old_parent = parent[v];\n int old_contrib = (old_parent == -1) ? depth[v] + 1 : depth[old_parent] * (v == old_parent ? 0 : 1);\n\n int new_depth = (p == -1) ? 0 : depth[p] + 1;\n int new_contrib = new_depth;\n\n // Apply and check\n parent[v] = p;\n\n // Recompute depths affected\n queue q;\n q.push(v);\n vector affected;\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n affected.push_back(u);\n\n for (int child : adj[u]) {\n if (parent[child] == u) {\n depth[child] = depth[u] + 1;\n if (depth[child] > H) {\n parent[v] = old_parent; // Revert if invalid\n return false;\n }\n q.push(child);\n }\n }\n }\n\n long long new_score = 0;\n rep(i, N) {\n if (i != v) new_score += (long long)(depth[i] + 1) * A[i];\n }\n new_score += (long long)(depth[v] + 1) * A[v];\n\n // Revert if worse\n if (new_score < solver.get_score()) {\n parent[v] = old_parent;\n return false;\n }\n\n return true;\n };\n\n // Simple local search\n rep(iter, 10000) {\n bool improved = false;\n for (int v = 0; v < N; ++v) {\n // Try each neighbor as potential parent\n for (int p : adj[v]) {\n if (depth[p] < H - 1) {\n if (update_parent(v, p)) {\n improved = true;\n break;\n }\n }\n }\n if (improved) break;\n }\n if (!improved) break;\n }\n\n cout << parent[0];\n rep1(i, 1, N - 1) cout << \" \" << parent[i];\n cout << endl;\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Oni {\n int id;\n int r, c;\n};\n\nstruct MoveCandidate {\n int dist; // steps to shift\n char dir; // 'U', 'D', 'L', 'R'\n int cost; // total operations for this move (2 * dist)\n int idx; // row index if dir is L/R, col index if dir is U/D\n vector removed_indices; // IDs of Oni removed by this move\n vector> ops; // Output operations sequence\n};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector board(N);\n vector valid_onis;\n vector> all_fuku;\n\n // Parse board\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n valid_onis.push_back({(int)valid_onis.size(), i, j});\n } else if (board[i][j] == 'o') {\n all_fuku.push_back({i, j});\n }\n }\n }\n\n // Check Fukunokami positions for O(1) lookup\n // has_fuku[i][j] is true if (i, j) contains a Fukunokami\n vector> has_fuku(N, vector(N, false));\n for(auto& p : all_fuku) {\n has_fuku[p.first][p.second] = true;\n }\n\n vector move_candidates;\n int num_onis = valid_onis.size();\n\n // Generate candidates for each Oni\n for(const auto& oni : valid_onis) {\n // 1. Up Direction\n // Safe if no Fuku in (0..r-1, c)\n bool safe = true;\n for(int k=0; k= oni.r\n for(const auto& o : valid_onis) {\n if(o.c == oni.c && o.r >= oni.r) mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n\n // 3. Left Direction\n // Safe if no Fuku in (r, 0..c-1)\n safe = true;\n for(int k=0; k= oni.c\n for(const auto& o : valid_onis) {\n if(o.r == oni.r && o.c >= oni.c) mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n }\n\n vector is_covered(num_onis, false);\n vector> total_ops;\n\n while(true) {\n int remaining_count = 0;\n for(int i=0; i 0) {\n // Greedy strategy: maximize number of newly covered Oni\n // Tie-breaker: minimize cost\n if(best_idx == -1 || current_removed_count > best_removed_count || \n (current_removed_count == best_removed_count && mc.cost < best_cost)) {\n best_idx = i;\n best_removed_count = current_removed_count;\n best_cost = mc.cost;\n }\n }\n }\n\n if(best_idx == -1) break; // Should not happen per problem guarantee\n\n const auto& mc = move_candidates[best_idx];\n total_ops.insert(total_ops.end(), mc.ops.begin(), mc.ops.end());\n\n for(int id : mc.removed_indices) {\n is_covered[id] = true;\n }\n }\n\n // Output: The problem format specifies operations directly.\n // Do NOT output the size first, as that causes a Parse Error with this judge format.\n for(const auto& p : total_ops) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global variables to store state and results\nint N, L;\nint T[105];\nuint8_t A[105];\nuint8_t B[105];\nint counts[105];\n\n// Best solution found so far\nint best_err = 2000000000; // sufficiently large number\nuint8_t best_A[105];\nuint8_t best_B[105];\n\n// Simulation function to evaluate the configuration\nint simulate() {\n // Reset counts\n for(int i=0; i> N >> L)) return 0;\n for(int i=0; i> T[i];\n \n // Initialize random number generator\n mt19937 rng(4211); \n uniform_int_distribution dist(0, N - 1);\n uniform_real_distribution dist_real(0.0, 1.0);\n \n // Initial random configuration\n for(int i=0; i modify A, 1 -> modify B\n int val = dist(rng);\n \n uint8_t old_val = (type == 0) ? A[i] : B[i];\n if (type == 0) A[i] = (uint8_t)val; else B[i] = (uint8_t)val;\n \n int new_err = simulate();\n bool accepted = false;\n \n // Accept if better, or with probability based on temp (SA)\n if (new_err < current_err) {\n accepted = true;\n } else {\n double delta = (double)(new_err - current_err);\n if (delta > 0 && dist_real(rng) < exp(-delta / temp)) {\n accepted = true;\n }\n }\n \n if (accepted) {\n current_err = new_err;\n if (new_err < best_err) {\n best_err = new_err;\n for(int k=0; k\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n vector G(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; i++) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n \n // Estimate coordinates from rectangle centers\n vector est_x(N), est_y(N);\n for (int i = 0; i < N; i++) {\n est_x[i] = (lx[i] + rx[i]) / 2.0;\n est_y[i] = (ly[i] + ry[i]) / 2.0;\n }\n \n // Create city indices and sort by estimated position (lexicographically by x, then y)\n vector cities(N);\n iota(cities.begin(), cities.end(), 0);\n \n sort(cities.begin(), cities.end(), [&](int a, int b) {\n if (est_x[a] != est_x[b]) return est_x[a] < est_x[b];\n return est_y[a] < est_y[b];\n });\n \n // Partition into groups\n vector> groups(M);\n int idx = 0;\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < G[i]; j++) {\n if (idx < N) {\n groups[i].push_back(cities[idx]);\n idx++;\n }\n }\n }\n \n // Store all edges we find from queries\n // Each group needs G[i] - 1 edges to form a spanning tree\n vector>> group_edges(M);\n \n // Perform queries to get edges for each group\n int query_count = 0;\n for (int m = 0; m < M; m++) {\n if (G[m] < 2) continue;\n \n const auto& group = groups[m];\n int group_size = G[m];\n \n // Use sliding window queries of size 3 to L to get MST edges\n // Each 3-city query gives us 2 edges (MST of 3 nodes has 2 edges)\n \n int edge_count = 0;\n for (int i = 0; i < group_size - 1; i++) {\n if (edge_count >= group_size - 1) break;\n \n // For efficiency, query larger windows when we need more edges\n int window_size = min(L, min(group_size, group_size - i));\n if (window_size < 2) {\n window_size = 2;\n }\n \n if (query_count < Q) {\n vector query_cities;\n int take = min(window_size, group_size - i);\n \n // Take consecutive cities from the sorted group\n for (int j = 0; j < take; j++) {\n query_cities.push_back(group[i + j]);\n }\n \n // Output query\n cout << \"? \" << query_cities.size();\n for (int city : query_cities) {\n cout << \" \" << city;\n }\n cout << endl;\n \n // Read MST edges\n vector> mst_edges;\n for (int k = 0; k < query_cities.size() - 1; k++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n mst_edges.push_back({u, v});\n }\n \n // Filter edges and add to group edges\n for (auto& edge : mst_edges) {\n bool in_group = true;\n // Check if both endpoints are in this group\n for (int city : group) {\n if (edge.first == city || edge.second == city) {\n // Found city\n }\n }\n // Add the edge\n if (edge_count < group_size - 1) {\n int u = edge.first;\n int v = edge.second;\n // Check if edge already exists\n bool exists = false;\n for (auto& e : group_edges[m]) {\n if ((e.first == u && e.second == v) || \n (e.first == v && e.second == u)) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n group_edges[m].push_back({u, v});\n edge_count++;\n }\n }\n }\n \n query_count++;\n }\n }\n \n // If we still need edges, add direct connections between consecutive cities\n // (This will be suboptimal but ensures connectivity)\n // We need G[m] - 1 edges total\n int needed = group_size - 1 - edge_count;\n for (int i = 0; i < needed; i++) {\n // Connect consecutive cities in the group that might not have edges yet\n int u = group[i % group_size];\n int v = group[(i + 1) % group_size];\n // Check if edge already exists\n bool exists = false;\n for (auto& e : group_edges[m]) {\n if ((e.first == u && e.second == v) || \n (e.first == v && e.second == u)) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n group_edges[m].push_back({u, v});\n }\n }\n }\n \n // Output final answer\n cout << \"!\" << endl;\n int city_idx = 0;\n for (int m = 0; m < M; m++) {\n if (G[m] == 0) continue;\n \n // Output cities in group m\n for (int c : groups[m]) {\n cout << c << \" \";\n }\n cout << endl;\n \n // Output edges for group m\n for (auto& e : group_edges[m]) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n \n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAXN = 20;\n\nbool has_block[MAXN][MAXN];\nint cur_r, cur_c;\n\nint dr[] = {-1, 1, 0, 0}; // U, D, R, L\nint dc[] = {0, 0, 1, -1};\nchar dir_char[] = {'U', 'D', 'R', 'L'};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int N, M;\n if (!(cin >> N >> M)) return 0;\n \n cin >> cur_r >> cur_c;\n \n vector> targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].first >> targets[i].second;\n }\n \n memset(has_block, 0, sizeof(has_block));\n vector> actions;\n \n for (int t = 0; t < M; t++) {\n int tr = targets[t].first;\n int tc = targets[t].second;\n \n // Step 1: Remove block on target if present\n if (has_block[tr][tc]) {\n // Move to adjacent position to target\n while (abs(cur_r - tr) + abs(cur_c - tc) > 1) {\n int best_d = -1;\n int best_dist = MAXN * MAXN;\n \n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr >= 0 && nr < MAXN && nc >= 0 && nc < MAXN && !has_block[nr][nc]) {\n int dist = abs(nr - tr) + abs(nc - tc);\n if (dist < best_dist) {\n best_dist = dist;\n best_d = d;\n }\n }\n }\n \n if (best_d == -1) break;\n \n actions.push_back({'M', dir_char[best_d]});\n cur_r += dr[best_d];\n cur_c += dc[best_d];\n }\n \n // Remove block on target (now adjacent)\n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr == tr && nc == tc) {\n actions.push_back({'A', dir_char[d]});\n has_block[nr][nc] = false;\n break;\n }\n }\n }\n \n // Step 2: Move to target position using moves (simple and reliable)\n while (abs(cur_r - tr) + abs(cur_c - tc) > 0) {\n int d = -1;\n if (cur_r != tr) {\n d = (cur_r < tr) ? 1 : 0; // D or U\n } else {\n d = (cur_c < tc) ? 2 : 3; // R or L\n }\n \n if (d != -1) {\n actions.push_back({'M', dir_char[d]});\n cur_r += dr[d];\n cur_c += dc[d];\n }\n }\n }\n \n // Output all actions\n for (auto& p : actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}"},"4":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Company {\n int id, x, y, r, a, b, c, d;\n \n long long area() const {\n return max(0LL, (long long)(c - a)) * max(0LL, (long long)(d - b));\n }\n \n bool containsPoint() const {\n return a <= x && x < c && b <= y && y < d;\n }\n};\n\nint n;\nvector companies;\nconst int GRID = 10000;\n\ndouble calculateScore(const vector& com) {\n double total = 0.0;\n for (const auto& c : com) {\n long long s = c.area();\n if (s <= 0 || !c.containsPoint()) continue;\n double ratio = min(c.r, s) / max((double)c.r, s);\n total += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return total;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n companies.resize(n);\n \n for (int i = 0; i < n; i++) {\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n companies[i].id = i;\n }\n \n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n // Initial placement - center around point (x, y)\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n long long target = c.r;\n long long w = max(1LL, (long long)sqrt(target * 2.0));\n long long h = max(1LL, target / w + 1LL);\n \n int a = max(0, min(c.x, c.x - (int)w / 2));\n int c_pos = min(GRID, max(c.x + 1, a + (int)w));\n int b = max(0, min(c.y, c.y - (int)h / 2));\n int d = min(GRID, max(c.y + 1, b + (int)h));\n \n c.a = a;\n c.b = b;\n c.c = c_pos;\n c.d = d;\n }\n \n long long initialScore = calculateScore(companies);\n \n // Simulated annealing optimization\n int iters = 200000;\n double temp = 2.0;\n \n for (int iter = 0; iter < iters; iter++) {\n int idx = uniform_int_distribution(0, n - 1)(rng);\n Company r = companies[idx];\n \n vector> candidates;\n candidates.emplace_back(r.a, r.b);\n \n // Try shifted positions\n for (int da = -50; da <= 50; da += 10) {\n for (int db = -50; db <= 50; db += 10) {\n int a = max(0, min(r.c - r.a, r.a + da));\n int b = max(0, min(r.d - r.b, r.b + db));\n candidates.emplace_back(a, b);\n }\n }\n \n // Try area optimization\n for (int w = max(1, (int)sqrt(r.r / 10)); w < 100; w++) {\n int h = max(1, r.r / w + 1);\n int a = max(0, min(r.x, r.x - w / 2));\n int b = max(0, min(r.y, r.y - h / 2));\n candidates.emplace_back(a, b);\n }\n \n int bestA = r.a, bestB = r.b;\n double bestNewScore = calculateScore(companies);\n \n for (auto [da, db] : candidates) {\n Company newR = r;\n newR.a = max(0, da);\n newR.b = max(0, db);\n \n // Keep same dimensions\n newR.c = max(newR.a + (r.c - r.a), newR.a + 1);\n newR.d = max(newR.b + (r.d - r.b), newR.b + 1);\n newR.c = min(GRID, newR.c);\n newR.d = min(GRID, newR.d);\n \n if (newR.containsPoint()) {\n companies[idx] = newR;\n double newScore = calculateScore(companies);\n if (newScore > bestNewScore) {\n bestNewScore = newScore;\n bestA = newR.a;\n bestB = newR.b;\n }\n companies[idx] = r;\n }\n }\n \n companies[idx].a = bestA;\n companies[idx].b = bestB;\n \n if (uniform_real_distribution(0, 1)(rng) > temp / 100.0) {\n companies[idx] = r; // Revert with probability\n }\n \n temp *= 0.997;\n }\n \n // Final check - all points must be contained\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n if (!c.containsPoint()) {\n long long w = max(1LL, c.r);\n long long h = max(1LL, c.r / w + 1LL);\n \n c.a = max(0, c.x);\n c.c = min(GRID, max(c.x + 1, c.a + (int)w));\n c.b = max(0, c.y);\n c.d = min(GRID, max(c.y + 1, c.b + (int)h));\n }\n }\n \n for (int i = 0; i < n; i++) {\n cout << companies[i].a << \" \" << companies[i].b << \" \" \n << companies[i].c << \" \" << companies[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int DX[] = {-1, 1, 0, 0};\nconst int DY[] = {0, 0, -1, 1};\n\nstruct Solver {\n int H = 50, W = 50;\n int si, sj;\n vector> p;\n vector> tile;\n \n // Global tracking for best result\n int global_best_score;\n vector> global_best_path;\n \n // Path State\n vector> path;\n vector tile_used_flag;\n int current_score;\n \n // RNG\n mt19937 rng;\n \n // Neighbor buffer to reduce allocations inside the loop\n struct Neighbor {\n int r, c, val, deg;\n };\n Neighbor neighbors[4];\n int n_neighbors;\n\n Solver() {\n p.assign(H, vector(W));\n tile.assign(H, vector(W));\n // Seed RNG once at start\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count());\n global_best_score = 0;\n }\n\n void read_input() {\n cin >> si >> sj;\n int max_id = 0;\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> tile[i][j];\n if (tile[i][j] > max_id) max_id = tile[i][j];\n }\n }\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> p[i][j];\n }\n }\n tile_used_flag.assign(max_id + 1, 0);\n }\n\n void new_run() {\n path.clear();\n path.reserve(2500);\n path.push_back({si, sj});\n current_score = p[si][sj];\n // Fast reset for tile_used_flag\n fill(tile_used_flag.begin(), tile_used_flag.end(), 0);\n tile_used_flag[tile[si][sj]] = 1;\n \n // Update global best if this start score is better\n // Critical: do not overwrite a high score with a low start score\n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n }\n\n bool is_valid(int r, int c) {\n return r >= 0 && r < H && c >= 0 && c < W;\n }\n\n void get_neighbors(const pair& curr) {\n n_neighbors = 0;\n for (int d = 0; d < 4; ++d) {\n int nr = curr.first + DX[d];\n int nc = curr.second + DY[d];\n if (is_valid(nr, nc)) {\n int tid = tile[nr][nc];\n if (tile_used_flag[tid] == 0) {\n // Heuristic: count unvisited neighbors (degree)\n int deg = 0;\n for (int dd = 0; dd < 4; ++dd) {\n int nrr = nr + DX[dd];\n int ncc = nc + DY[dd];\n if (is_valid(nrr, ncc) && tile_used_flag[tile[nrr][ncc]] == 0) {\n deg++;\n }\n }\n neighbors[n_neighbors++] = {nr, nc, p[nr][nc], deg};\n }\n }\n }\n }\n\n void run() {\n auto start_time = chrono::high_resolution_clock::now();\n read_input();\n new_run();\n \n // Time limit (1.9s) to be safe within 2.0s\n const int TIME_MAX = 1900;\n \n // Counter to prevent infinite restart loops if stuck at start\n int stuck_at_root_counter = 0;\n const int MAX_STUCK_RUNS = 50;\n \n while (true) {\n auto now = chrono::high_resolution_clock::now();\n auto elapsed = chrono::duration_cast(now - start_time).count();\n \n if (elapsed > TIME_MAX) break;\n\n auto [curr_r, curr_c] = path.back();\n get_neighbors({curr_r, curr_c});\n\n if (n_neighbors > 0) {\n // Heuristic Sort: Value (desc), then Degree (desc)\n // Since n <= 4, bubble sort is efficient\n for (size_t i = 0; i < n_neighbors; ++i) {\n for (size_t j = 0; j < n_neighbors - i - 1; ++j) {\n bool swap_flag = false;\n if (neighbors[j].val < neighbors[j+1].val) swap_flag = true;\n else if (neighbors[j].val == neighbors[j+1].val && neighbors[j].deg < neighbors[j+1].deg) swap_flag = true;\n \n if (swap_flag) swap(neighbors[j], neighbors[j+1]);\n }\n }\n\n int idx = 0;\n // 25% chance to pick from top 3 (exploration)\n if (rng() % 100 < 25) {\n if (n_neighbors > 1) idx = rng() % 3; \n if (idx >= n_neighbors) idx = n_neighbors - 1;\n }\n\n const Neighbor& n = neighbors[idx];\n \n path.push_back({n.r, n.c});\n tile_used_flag[tile[n.r][n.c]] = 1;\n current_score += n.val;\n \n // Update Global Best\n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n \n stuck_at_root_counter = 0; // Reset stuck counter on progress\n } else {\n // Stuck at current end\n if (path.size() > 1) {\n // Backtrack\n auto [r, c] = path.back();\n tile_used_flag[tile[r][c]] = 0;\n current_score -= p[r][c];\n path.pop_back();\n } else {\n // Stuck at root\n stuck_at_root_counter++;\n if (stuck_at_root_counter >= MAX_STUCK_RUNS) {\n break; // Stop trying, output best\n }\n // New seed and start\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count() + stuck_at_root_counter + 1000);\n new_run();\n }\n }\n }\n\n string result = \"\";\n if (!global_best_path.empty()) {\n for (size_t i = 1; i < global_best_path.size(); ++i) {\n int dr = global_best_path[i].first - global_best_path[i-1].first;\n int dc = global_best_path[i].second - global_best_path[i-1].second;\n if (dr == -1) result += 'U';\n else if (dr == 1) result += 'D';\n else if (dc == -1) result += 'L';\n else if (dc == 1) result += 'R';\n }\n }\n cout << result << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n Solver solver;\n solver.run();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Edge weights for 30x30 grid\n// h_edges[i][j] = horizontal edge at row i between column j and j+1 (0<=i<30, 0<=j<29)\n// v_edges[i][j] = vertical edge at column j between row i and i+1 (0<=i<29, 0<=j<30)\nvector> h_edges(30, vector(29, 1500.0));\nvector> v_edges(29, vector(30, 1500.0));\n\n// Learning parameters\nconst double LEARNING_RATE = 0.20;\n\nstruct Node {\n int pos;\n int r;\n int c;\n double dist;\n bool operator>(const Node& other) const {\n return dist > other.dist;\n }\n};\n\nstruct Result {\n string path;\n double predicted_length;\n bool valid;\n};\n\nResult find_shortest_path(int si, int sj, int ti, int tj) {\n int n = 30;\n int total = n * n;\n vector dist(total, 1e18);\n vector parent(total, -1);\n vector dir(total, 0);\n \n priority_queue, greater> pq;\n \n dist[si * n + sj] = 0.0;\n pq.push({si * n + sj, si, sj, 0.0});\n \n while (!pq.empty()) {\n Node top = pq.top();\n pq.pop();\n \n int u = top.pos;\n int ui = top.r;\n int uj = top.c;\n \n if (ui == ti && uj == tj) break;\n \n // Move U (up): to (ui-1,uj), uses v[ui-1][uj]\n if (ui > 0) {\n int v_pos = (ui - 1) * n + uj;\n if (dist[u] < 1e17) {\n double w = max(100.0, min(15000.0, v_edges[ui - 1][uj]));\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'U';\n pq.push({v_pos, ui - 1, uj, dist[v_pos]});\n }\n }\n }\n \n // Move D (down): to (ui+1,uj), uses v[ui][uj]\n if (ui < n - 1) {\n int v_pos = (ui + 1) * n + uj;\n if (dist[u] < 1e17) {\n double w = max(100.0, min(15000.0, v_edges[ui][uj]));\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'D';\n pq.push({v_pos, ui + 1, uj, dist[v_pos]});\n }\n }\n }\n \n // Move L (left): to (ui,uj-1), uses h[ui][uj-1]\n if (uj > 0) {\n int v_pos = ui * n + (uj - 1);\n if (dist[u] < 1e17) {\n double w = max(100.0, min(15000.0, h_edges[ui][uj - 1]));\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'L';\n pq.push({v_pos, ui, uj - 1, dist[v_pos]});\n }\n }\n }\n \n // Move R (right): to (ui,uj+1), uses h[ui][uj]\n if (uj < n - 1) {\n int v_pos = ui * n + (uj + 1);\n if (dist[u] < 1e17) {\n double w = max(100.0, min(15000.0, h_edges[ui][uj]));\n if (dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'R';\n pq.push({v_pos, ui, uj + 1, dist[v_pos]});\n }\n }\n }\n }\n \n if (dist[ti * n + tj] >= 1e17) {\n return {\"\", 0.0, false};\n }\n \n string path;\n int curr = ti * n + tj;\n while (curr != si * n + sj) {\n if (parent[curr] < 0) {\n return {\"\", 0.0, false};\n }\n path += dir[curr];\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n \n // Validate path length matches predicted\n double path_len = 0.0;\n int i = si, j = sj;\n for (char c : path) {\n if (c == 'U') { i--; path_len += max(100.0, min(15000.0, v_edges[i][j])); }\n else if (c == 'D') { path_len += max(100.0, min(15000.0, v_edges[i][j])); i++; }\n else if (c == 'L') { j--; path_len += max(100.0, min(15000.0, h_edges[i][j])); }\n else if (c == 'R') { path_len += max(100.0, min(15000.0, h_edges[i][j])); j++; }\n }\n \n if (abs(path_len - dist[ti * n + tj]) > 1.0) {\n return {\"\", 0.0, false};\n }\n \n return {path, dist[ti * n + tj], true};\n}\n\nstring generate_path(int si, int sj, int ti, int tj) {\n string path = \"\";\n int i = si, j = sj;\n int n = 30;\n \n while (i != ti || j != tj) {\n int di = ti - i, dj = tj - j;\n \n // Prefer moving towards target\n if (abs(di) > abs(dj)) {\n if (di > 0 && i < n - 1) path += 'D', i++;\n else if (di < 0 && i > 0) path += 'U', i--;\n else if (dj > 0 && j < n - 1) path += 'R', j++;\n else if (dj < 0 && j > 0) path += 'L', j--;\n } else {\n if (dj > 0 && j < n - 1) path += 'R', j++;\n else if (dj < 0 && j > 0) path += 'L', j--;\n else if (di > 0 && i < n - 1) path += 'D', i++;\n else if (di < 0 && i > 0) path += 'U', i--;\n }\n \n // Safety check\n if (i < 0 || i >= n || j < 0 || j >= n) {\n return \"\";\n }\n }\n \n return path;\n}\n\nvoid update_edge_weights(int si, int sj, const string& path,\n double predicted, int actual) {\n if (path.empty() || predicted < 0.1) return;\n \n double error = (double)actual - predicted;\n int num_edges = path.length();\n if (num_edges == 0) return;\n \n double alpha = LEARNING_RATE;\n double update = error * alpha / (double)num_edges;\n \n int i = si, j = sj;\n int n = 30;\n \n for (char c : path) {\n if (c == 'U') {\n if (i > 0) {\n int idx_v = i - 1;\n int idx_h = j;\n if (idx_v >= 0 && idx_v < 29 && idx_h >= 0 && idx_h < 30) {\n v_edges[idx_v][idx_h] += update;\n v_edges[idx_v][idx_h] = max(100.0, min(15000.0, v_edges[idx_v][idx_h]));\n }\n }\n i--;\n } else if (c == 'D') {\n if (i >= 0 && i < 29) {\n v_edges[i][j] += update;\n v_edges[i][j] = max(100.0, min(15000.0, v_edges[i][j]));\n }\n i++;\n } else if (c == 'L') {\n if (j > 0) {\n int idx_v = i;\n int idx_h = j - 1;\n if (idx_v >= 0 && idx_v < 30 && idx_h >= 0 && idx_h < 29) {\n h_edges[idx_v][idx_h] += update;\n h_edges[idx_v][idx_h] = max(100.0, min(15000.0, h_edges[idx_v][idx_h]));\n }\n }\n j--;\n } else if (c == 'R') {\n if (j >= 0 && j < 29) {\n h_edges[i][j] += update;\n h_edges[i][j] = max(100.0, min(15000.0, h_edges[i][j]));\n }\n j++;\n }\n \n // Safety bounds check after move\n if (i < 0 || i >= 30 || j < 0 || j >= 30) {\n i = si; j = sj; // Reset on invalid position\n break;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj, ti, tj;\n int feedback;\n \n for (int k = 0; k < 1000; k++) {\n if (!(cin >> si >> sj >> ti >> tj)) break;\n \n Result result = find_shortest_path(si, sj, ti, tj);\n \n string path = result.path;\n double predicted = result.predicted_length;\n \n if (!result.valid || !result.path.empty()) {\n if (result.valid && !result.predicted_length < 0.1) {\n path = result.path;\n predicted = result.predicted_length;\n } else {\n path = generate_path(si, sj, ti, tj);\n predicted = 0.0;\n }\n } else {\n path = generate_path(si, sj, ti, tj);\n predicted = 0.0;\n }\n \n if (path.empty()) {\n path = generate_path(si, sj, ti, tj);\n }\n \n if (path.empty()) {\n path = \"DD\";\n }\n \n cout << path << \"\\n\";\n cout.flush();\n \n if (cin >> feedback) {\n update_edge_weights(si, sj, path, predicted, feedback);\n }\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconstexpr int N = 20;\nconst int MAXM = 805;\n\nint M;\nstring s[MAXM];\nint len[MAXM];\nchar grid[N][N];\n\nint miscount[MAXM][N][N][2];\nint sat_placements[MAXM];\nint total_satisfied;\nint current_dots;\n\n// adj[r][c] contains indices of strings that cover cell (r,c)\nvector adj[N][N];\n\ninline bool is_in_list(const vector& lst, int val) {\n for(int v : lst) if(v == val) return true;\n return false;\n}\n\nvoid build_adj() {\n for(int r=0; r> n_in >> M)) return 0;\n \n for(int i=0; i> s[i];\n len[i] = s[i].length();\n }\n \n // Fast random seed\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Initialize grid\n current_dots = 0;\n for(int i=0; i 0) total_satisfied++;\n \n int best_score = total_satisfied * 10000 + (total_satisfied == M ? current_dots : 0);\n char best_grid[N][N];\n for(int i=0; i old_score) {\n accept = true;\n } else {\n double delta = (double)(new_score - old_score) / temp;\n double rand_val = ((double)rng()) / (double)numeric_limits::max();\n if(exp(delta) > rand_val) accept = true;\n }\n \n if(!accept) {\n apply_change(r, c, new_char, old_char);\n } else if(new_score > best_score) {\n best_score = new_score;\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 75;\nconst int INF = 1000000000;\n\nint N, si, sj;\nvector grid;\nchar dirs[] = {'U', 'D', 'L', 'R'};\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\n\nint dist[MAX_N][MAX_N];\npair parent[MAX_N][MAX_N];\nchar parent_dir[MAX_N][MAX_N];\nbool visited[MAX_N][MAX_N];\nbool covered[MAX_N][MAX_N];\nint road_cells[MAX_N][MAX_N];\nint road_cnt;\nint covered_cnt = 0;\nvector> roads;\n\ninline bool isValid(int r, int c) {\n return r >= 0 && r < (size_t)N && c >= 0 && c < (size_t)N && grid[r][c] != '#';\n}\n\nbool checkVisibility(int r1, int c1, int r2, int c2) {\n if (r1 == r2) {\n int low = min(c1, c2), high = max(c1, c2);\n for (int c = low; c <= high; c++) {\n if (grid[r1][c] == '#') return false;\n }\n return true;\n } else if (c1 == c2) {\n int low = min(r1, r2), high = max(r1, r2);\n for (int r = low; r <= high; r++) {\n if (grid[r][c1] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\nvoid bfs(int sr, int sc) {\n memset(visited, 0, sizeof(visited));\n memset(dist, 0x3f, sizeof(dist));\n \n queue> q;\n q.push({sr, sc});\n dist[sr][sc] = 0;\n visited[sr][sc] = true;\n parent[sr][sc] = {-1, -1};\n \n while (!q.empty()) {\n pair cur = q.front();\n q.pop();\n int r = cur.first, c = cur.second;\n \n for (int k = 0; k < 4; k++) {\n int nr = r + di[k];\n int nc = c + dj[k];\n \n if (isValid(nr, nc) && !visited[nr][nc]) {\n visited[nr][nc] = true;\n int w = grid[nr][nc] - '0';\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n parent_dir[nr][nc] = dirs[k];\n q.push({nr, nc});\n }\n }\n }\n}\n\nstring get_path(int er, int ec) {\n if (!visited[er][ec]) return \"\";\n \n string path = \"\";\n int r = er, c = ec;\n while (parent[r][c].first != -1) {\n path += parent_dir[r][c];\n pair p = parent[r][c];\n r = p.first;\n c = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nvoid update_all_coverage(int r, int c) {\n for (const auto& sq : roads) {\n int rr = sq.first, cc = sq.second;\n if (covered[rr][cc]) continue;\n if (checkVisibility(r, c, rr, cc)) {\n covered[rr][cc] = true;\n covered_cnt++;\n }\n }\n}\n\nint count_uncovered(int r, int c) {\n int cnt = 0;\n for (const auto& sq : roads) {\n int rr = sq.first, cc = sq.second;\n if (!covered[rr][cc] && checkVisibility(r, c, rr, cc)) {\n cnt++;\n }\n }\n return cnt;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> si >> sj;\n grid.resize(N);\n covered_cnt = 0;\n roads.clear();\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 roads.push_back({i, j});\n road_cells[i][j] = 1;\n }\n }\n }\n \n road_cnt = roads.size();\n memset(covered, 0, sizeof(covered));\n memset(dist, 0x3f, sizeof(dist));\n \n string path = \"\";\n int cr = si, cc = sj;\n \n covered[cr][cc] = true;\n covered_cnt = 1;\n update_all_coverage(cr, cc);\n \n if (covered_cnt >= road_cnt) {\n cout << path << endl;\n return 0;\n }\n \n int max_iterations = road_cnt * 2 + 1000;\n int iter = 0;\n int path_len = 0;\n \n while (covered_cnt < road_cnt && iter < max_iterations && path_len < 500000) {\n iter++;\n \n int best_rr = -1, best_cc = -1;\n int best_gain = 0;\n int best_dist = INF;\n \n for (const auto& sq : roads) {\n int rr = sq.first, cc = sq.second;\n if (covered[rr][cc]) continue;\n \n int gain = count_uncovered(rr, cc);\n if (gain == 0) continue;\n \n bfs(cr, cc);\n if (!visited[rr][cc] || dist[rr][cc] >= INF) {\n continue;\n }\n \n int d = dist[rr][cc];\n int score = gain * 1000 / max(d + 1, 1);\n \n if (gain > best_gain || (gain == best_gain && d < best_dist)) {\n best_gain = gain;\n best_dist = d;\n best_rr = rr;\n best_cc = cc;\n }\n }\n \n if (best_rr != -1) {\n bfs(cr, cc);\n string seg = get_path(best_rr, best_cc);\n if (seg.empty()) {\n break;\n }\n path = path + seg;\n path_len = path.length();\n cr = best_rr;\n cc = best_cc;\n update_all_coverage(cr, cc);\n \n if (covered_cnt >= road_cnt) {\n break;\n }\n } else {\n break;\n }\n }\n \n if (cr != si || cc != sj) {\n bfs(cr, cc);\n string ret = get_path(si, sj);\n if (!ret.empty()) {\n path = path + ret;\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n\nusing namespace std;\n\nstruct TaskInfo {\n bool completed;\n bool started;\n int assigned_member; // -1 if none\n int start_day;\n};\n\nTaskInfo tasks[1005];\nint task_d[1005][25];\nvector> dependencies, dependents;\nint d[25]; // current free member count\nvector free_members;\nint N, M, K, R;\n\nint main() {\n cin >> N >> M >> K >> R;\n \n for (int i = 0; i < N; i++) {\n tasks[i].completed = false;\n tasks[i].started = false;\n tasks[i].assigned_member = -1;\n tasks[i].start_day = 0;\n for (int k = 0; k < K; k++) {\n cin >> task_d[i][k];\n }\n }\n \n dependencies.assign(N, vector());\n dependents.assign(N, vector());\n \n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n dependencies[v].push_back(u);\n dependents[u].push_back(v);\n }\n \n int day = 0;\n vector member_is_busy(M, false);\n \n while (day < 2000) {\n day++;\n \n // Clear busy status, we'll get told who is done\n for (int i = 0; i < M; i++) {\n member_is_busy[i] = false;\n }\n \n int completed_count;\n if (day > 1) {\n cin >> completed_count;\n if (completed_count == -1) break;\n \n for (int i = 0; i < completed_count; i++) {\n int member;\n cin >> member;\n member--;\n if (member >= 0 && member < M) {\n member_is_busy[member] = true; // Actually they completed\n // Mark their task as completed\n for (int t = 0; t < N; t++) {\n if (tasks[t].assigned_member == member && !tasks[t].completed) {\n tasks[t].completed = true;\n tasks[t].assigned_member = -1;\n break;\n }\n }\n }\n }\n }\n \n // Find free members\n vector free_members;\n for (int i = 0; i < M; i++) {\n if (!member_is_busy[i]) {\n free_members.push_back(i);\n }\n }\n free_members.clear();\n for (int i = 0; i < M; i++) {\n bool still_busy = false;\n for (int t = 0; t < N; t++) {\n if (tasks[t].started && !tasks[t].completed && tasks[t].assigned_member == i) {\n still_busy = true;\n break;\n }\n }\n if (!still_busy) {\n free_members.push_back(i);\n }\n }\n \n // Find ready tasks\n vector ready_tasks;\n for (int i = 0; i < N; i++) {\n if (tasks[i].started || tasks[i].completed) continue;\n \n bool can_start = true;\n for (int dep : dependencies[i]) {\n if (!tasks[dep].completed) {\n can_start = false;\n break;\n }\n }\n if (can_start) {\n ready_tasks.push_back(i);\n }\n }\n \n // Sort by priority\n sort(ready_tasks.begin(), ready_tasks.end(), [&](int a, int b) {\n int unlock_a = dependents[a].size();\n int unlock_b = dependents[b].size();\n if (unlock_a != unlock_b) return unlock_a > unlock_b;\n int diff_a = 0;\n int diff_b = 0;\n for (int k = 0; k < K; k++) {\n diff_a += task_d[a][k];\n diff_b += task_d[b][k];\n }\n return diff_a < diff_b;\n });\n \n // Assign tasks\n vector> assignments;\n for (int task : ready_tasks) {\n for (int m : free_members) {\n bool already_assigned = false;\n for (auto& asgn : assignments) {\n if (asgn.second == m) {\n already_assigned = true;\n break;\n }\n }\n if (!already_assigned) {\n assignments.push_back({m, task});\n tasks[task].started = true;\n tasks[task].assigned_member = m;\n tasks[task].start_day = day;\n free_members.erase(\n remove(free_members.begin(), free_members.end(), m),\n free_members.end()\n );\n break;\n }\n }\n }\n \n // Output\n cout << assignments.size();\n for (auto& asgn : assignments) {\n cout << \" \" << asgn.first + 1 << \" \" << asgn.second + 1;\n }\n cout << endl;\n cout.flush();\n \n // Check if all done\n bool all_done = true;\n for (int i = 0; i < N; i++) {\n if (!tasks[i].completed) {\n all_done = false;\n break;\n }\n }\n if (all_done) break;\n }\n \n return 0;\n}","ahc006":"```cpp\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global configuration\nconst int DEPOT_X = 400;\nconst int DEPOT_Y = 400;\nconst int N_ORDERS = 1000;\nconst int ORDERS_TO_SELECT = 50;\n\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nstruct Order {\n int id; \n int a, b; \n int c, d; \n double base_cost;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n vector orders(N_ORDERS);\n vector p(N_ORDERS);\n \n // Read input\n for (int i = 0; i < N_ORDERS; ++i) {\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i + 1; // 1-based\n orders[i].base_cost = (double)(dist(DEPOT_X, DEPOT_Y, orders[i].a, orders[i].b) +\n dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d) +\n dist(orders[i].c, orders[i].d, DEPOT_X, DEPOT_Y));\n p[i] = i;\n }\n \n // Sort orders by base cost to prioritize central clusters\n sort(p.begin(), p.end(), [&](int a, int b) {\n return orders[a].base_cost < orders[b].base_cost;\n });\n \n // Select a pool of candidates to search from (Top 80)\n int K = min(80, N_ORDERS);\n vector pool(K);\n for(int i = 0; i < K; ++i) pool[i] = p[i];\n \n // Initial subset: first 50 candidates\n vector subset;\n subset.reserve(ORDERS_TO_SELECT);\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) subset.push_back(pool[i]);\n \n vector best_subset = subset;\n int best_T = 2147483647;\n \n mt19937 rng(19991014); // Fixed seed\n \n // Structure to hold path coordinates\n struct PathData {\n vector> coords;\n vector path; \n int cost;\n };\n \n // Function to construct path and compute cost for a given subset\n PathData solve_subset_path(const vector& sub_set) {\n PathData res;\n res.path.reserve(102);\n \n // 0: Depot, 1..50: Pickups, 51..100: Deliveries\n res.coords.resize(101);\n res.coords[0] = {DEPOT_X, DEPOT_Y};\n \n for(int k = 0; k < ORDERS_TO_SELECT; ++k) {\n int idx = sub_set[k]; // index in 'orders'\n res.coords[k+1] = {orders[idx].a, orders[idx].b}; \n res.coords[k+51] = {orders[idx].c, orders[idx].d};\n }\n \n // Greedy Construction\n vector visited(101, false);\n vector pickup_done(50, false);\n res.path.push_back(0);\n int cx = DEPOT_X, cy = DEPOT_Y;\n \n for(int s = 0; s < 100; ++s) {\n int best_node = -1;\n int min_d = 2000000000;\n for(int node = 1; node <= 100; ++node) {\n if(!visited[node]) {\n if(node > 50) {\n int ord = node - 51;\n if(!pickup_done[ord]) continue;\n }\n int d = dist(cx, cy, res.coords[node].first, res.coords[node].second);\n if(d < min_d) { min_d = d; best_node = node; }\n }\n }\n if(best_node != -1) {\n visited[best_node] = true;\n res.path.push_back(best_node);\n cx = res.coords[best_node].first;\n cy = res.coords[best_node].second;\n if(best_node <= 50) pickup_done[best_node-1] = true;\n } else {\n break;\n }\n }\n res.path.push_back(0); // Return to Depot\n \n // Compute cost\n res.cost = 0;\n cx = DEPOT_X; cy = DEPOT_Y;\n for(size_t i = 0; i < res.path.size(); ++i) {\n cx = res.coords[res.path[i]].first; cy = res.coords[res.path[i]].second;\n if(i + 1 < res.path.size()) {\n int nx = res.coords[res.path[i+1]].first;\n int ny = res.coords[res.path[i+1]].second;\n res.cost += dist(cx, cy, nx, ny);\n }\n }\n \n return res;\n }\n \n // Function to optimize route given path (SA)\n void optimize_path(PathData& data) {\n int path_len = data.path.size();\n for(int iter = 0; iter < 20000; ++iter) {\n int i = rng() % (path_len - 1) + 1; \n int j = rng() % (path_len - 1) + 1;\n if(i == j) continue;\n \n int u = data.path[i];\n int v = data.path[j];\n \n // Validity check: If P and D of same order swapped\n if((u <= 50 && v == u + 50) || (v <= 50 && u == v + 50)) continue;\n \n data.path[i] = v;\n data.path[j] = u;\n \n // Check validity (P before D for all)\n bool valid = true;\n // Optimization: only check affected orders if possible, but O(N) check is safe enough\n for(int k = 1; k <= 50; ++k) {\n int P = k; int D = k+50;\n int posP = -1, posD = -1;\n for(int m = 0; m < path_len; ++m) {\n if(data.path[m] == P) posP = m;\n if(data.path[m] == D) posD = m;\n }\n if(posP > posD) { valid = false; break; }\n }\n \n if(valid) {\n int new_cost = 0;\n int cx = DEPOT_X, cy = DEPOT_Y;\n for(size_t m = 0; m < data.path.size() - 1; ++m) {\n cx = data.coords[data.path[m]].first;\n cy = data.coords[data.path[m]].second;\n int nx = data.coords[data.path[m+1]].first;\n int ny = data.coords[data.path[m+1]].second;\n new_cost += dist(cx, cy, nx, ny);\n }\n if(new_cost < data.cost) {\n data.cost = new_cost;\n } else {\n data.path[i] = u; \n data.path[j] = v;\n }\n } else {\n data.path[i] = u; \n data.path[j] = v;\n }\n }\n }\n \n // Iterate Subset Selection (Simulated Annealing / Hill Climbing)\n for(int iter = 0; iter < 1500; ++iter) {\n int i = rng() % 50;\n int j = rng() % (K - 50);\n int from_idx = subset[i];\n int to_idx = pool[50 + j];\n \n subset[i] = to_idx;\n \n PathData current_path_data = solve_subset_path(subset);\n optimize_path(current_path_data);\n \n if(current_path_data.cost < best_T) {\n best_T = current_path_data.cost;\n best_subset = subset;\n } else {\n subset[i] = from_idx; // Revert if not better\n }\n }\n \n // Final Optimization with best subset\n PathData final_path = solve_subset_path(best_subset);\n optimize_path(final_path);\n \n // Output\n cout << ORDERS_TO_SELECT << \" \";\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) {\n cout << orders[best_subset[i]].id << \" \";\n }\n cout << \"\\n102 \";\n for(int x : final_path.path) {\n int cx = final_path.coords[x].first;\n int cy = final_path.coords[x].second;\n cout << cx << \" \" << cy << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc007":"/*\n Heuristic Solution for AHC007\n Strategy:\n 1. Precompute Euclidean distances (d) for all edges offline.\n 2. Sort edges by d to determine their global Rank.\n 3. Since l_i is proportional to d_i, edges with lower Rank are expected to be cheaper.\n 4. Use a Rank Threshold (e.g., 2*N) to filter out \"expensive\" edges (high d).\n Given the problem generation ensures 5 MSTs in the edge set, connectivity is robust even with this filter.\n 5. Accept an edge if it connects two disjoint components AND its Rank is within the Threshold.\n This mimics Kruskal's algorithm on the subset of \"good\" edges.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Fixed problem parameters\nconst int FIXED_N = 400;\nconst int FIXED_M = 1995;\n\n// Edge structure\nstruct Edge {\n int u, v;\n int d; // Euclidean distance rounded\n int original_idx;\n};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = FIXED_N;\n int M = FIXED_M;\n\n // Read N vertices coordinates\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) {\n cin >> X[i] >> Y[i];\n }\n\n // Read M edge endpoints\n vector U(M), V(M);\n vector edges(M);\n\n for (int i = 0; i < M; ++i) {\n cin >> U[i] >> V[i];\n long long dx = X[U[i]] - X[V[i]];\n long long dy = Y[U[i]] - Y[V[i]];\n double dist = std::sqrt((double)dx * dx + (double)dy * dy);\n int d_val = std::round(dist);\n \n edges[i] = {U[i], V[i], d_val, i};\n }\n\n // Determine Rank for each edge based on 'd'\n // Rank 0 corresponds to the smallest Euclidean distance\n vector sorted_indices(M);\n std::iota(sorted_indices.begin(), sorted_indices.end(), 0);\n\n // Stable sort or simple sort based on distance\n std::sort(sorted_indices.begin(), sorted_indices.end(), [&](int a, int b) {\n if (edges[a].d != edges[b].d) {\n return edges[a].d < edges[b].d;\n }\n return a < b;\n });\n\n // Map original index to Rank\n vector rank_map(M);\n for (int i = 0; i < M; ++i) {\n rank_map[sorted_indices[i]] = i;\n }\n\n // Threshold for acceptable edge quality\n // We need to form a tree (N-1 edges).\n // T_1 (geometric MST) contains edges with smallest d.\n // We set limit to 2*N to ensure connectivity and capture T_1 + redundancy.\n int limit_rank = 2 * N; \n\n // DSU Setup\n vector parent(N);\n std::iota(parent.begin(), parent.end(), 0);\n\n // Iterative Find with Path Compression\n auto find = [&](int i) {\n int root = i;\n while (parent[root] != root) {\n root = parent[root];\n }\n int curr = i;\n while (curr != root) {\n int next = parent[curr];\n parent[curr] = root;\n curr = next;\n }\n return root;\n };\n\n // Union function\n auto unite = [&](int a, int b) {\n int rootA = find(a);\n int rootB = find(b);\n if (rootA != rootB) {\n parent[rootA] = rootB;\n return true;\n }\n return false;\n };\n\n // Process M queries online\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l; // Read revealed length l_i\n \n // Apply heuristic strategy:\n // 1. Reject if Rank is too high (edge is geometrically long/expensive)\n // 2. If within rank limit, accept if it reduces components (standard MST greedy)\n if (rank_map[i] > limit_rank) {\n cout << 0 << endl;\n } else {\n if (find(U[i]) != find(V[i])) {\n cout << 1 << endl;\n unite(U[i], V[i]);\n } else {\n cout << 0 << endl;\n }\n }\n // Flush output to satisfy interactive constraints\n cout.flush();\n }\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;\nusing namespace atcoder;\n\nclass Solver {\nprivate:\n int N, M;\n struct Pet {\n int px, py, type;\n };\n struct Human {\n int x, y;\n };\n \n vector pets;\n vector humans;\n bool blocked[35][35];\n \n mt19937 rng;\n int currentTurn;\n \n const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // U, D, L, R\n \n bool inBounds(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n // Check if position is blocked or occupied\n bool isBlocked(int x, int y, int turn, bool initial = false) {\n if (blocked[x][y]) return true;\n \n if (initial || turn == 0) {\n for (auto& p : pets) {\n if (p.px == x && p.py == y) return true;\n }\n for (auto& h : humans) {\n if (h.x == x && h.y == y) return true;\n }\n }\n \n // Check adjacency to pets (for blocking)\n for (auto& p : pets) {\n int dist = abs(p.px - x) + abs(p.py - y);\n if (dist <= 1 && (dist != 0)) return true;\n }\n \n return false;\n }\n \n int countReachable(int x, int y) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int count = 1;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n count++;\n q.push({nx, ny});\n }\n }\n }\n return count;\n }\n \n int countPetsInArea(int x, int y) {\n int count = 0;\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n reachable++;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n // Count pets in reachable area\n for (auto& p : pets) {\n if (reachable > 0 && inBounds(p.px, p.py)) {\n // Simple reachability check\n bool visited2[35][35];\n memset(visited2, 0, sizeof(visited2));\n if (canReach(p.px, p.y, x, y, visited2)) {\n count++;\n }\n }\n }\n \n return count;\n }\n \n bool canReach(int x1, int y1, int x2, int y2, bool& visited[35][35]) {\n // BFS to check reachability\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x1, y1});\n visited[x1][y1] = true;\n \n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n if (cx == x2 && cy == y2) return true;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n return false;\n }\n \n bool canReach(int x1, int y1, int x2, int y2) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n return canReach(x1, y1, x2, y2, visited);\n }\n \n // Choose best action for each human\n string decideAction(int humanIdx, int turn) {\n auto& h = humans[humanIdx];\n double bestScore = 0;\n string bestAction = \".\";\n \n // Evaluate all possible actions\n // Action: stay, block (4 directions), move (4 directions)\n \n // Try blocking\n for (int d = 0; d < 4; d++) {\n int bx = h.x + dirs[d][0];\n int by = h.y + dirs[d][1];\n \n bool valid = true;\n if (!inBounds(bx, by)) valid = false;\n if (blocked[bx][by]) valid = false;\n if (turn == 0) {\n // Initial positions - occupied check\n for (auto& p : pets) {\n if (p.px == bx && p.py == by || \n abs(p.px - bx) + abs(p.py - by) == 1) {\n valid = false;\n break;\n }\n }\n if (valid) {\n for (auto& h2 : humans) {\n if ((h2.x == bx && h2.y == by) ||\n (h2.x != h.x || h2.y != h.y) && \n abs(h2.x - bx) + abs(h2.y - by) <= 1) {\n valid = false;\n break;\n }\n }\n }\n }\n \n if (valid) {\n // Calculate score if we block\n blocked[bx][by] = true;\n double score = calculateScore(humanIdx);\n blocked[bx][by] = false;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"udlr\"[d]);\n }\n }\n }\n \n // Try moving\n for (int d = 0; d < 4; d++) {\n int nx = h.x + dirs[d][0];\n int ny = h.y + dirs[d][1];\n \n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[humanIdx] = {nx, ny};\n double score = calculateScore(humanIdx);\n humans[humanIdx] = h;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"UDLR\"[d]);\n }\n }\n }\n \n // Try staying\n double score = calculateScore(humanIdx);\n if (score > bestScore) {\n bestScore = score;\n bestAction = \".\";\n }\n \n return bestAction;\n }\n \n double calculateScore(int humanIdx) {\n auto& h = humans[humanIdx];\n int reachable = countReachable(h.x, h.y);\n int petCount = countPetsInArea(h.x, h.y);\n \n // Score: reachable/900 * 2^(-petCount)\n return (double)reachable / 900.0 / pow(2.0, petCount);\n }\n \npublic:\n Solver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n memset(blocked, 0, sizeof(blocked));\n }\n \n void solve() {\n // Read input\n cin >> N;\n pets.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].px >> pets[i].py >> pets[i].type;\n }\n \n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n \n // Simulate for all turns\n for (currentTurn = 0; currentTurn < MAX_TURNS; currentTurn++) {\n string output = \"\";\n \n for (int i = 0; i < M; i++) {\n output += decideAction(i, currentTurn);\n }\n \n cout << output << endl << flush;\n fflush(stdout);\n \n // Read pet movements\n for (int i = 0; i < M; i++) {\n string moves;\n cin >> moves;\n }\n \n // Update blocked based on blocking actions\n for (int i = 0; i < M; i++) {\n if (output.size() > i) {\n char act = output[i];\n if (act >= 'a' && act <= 'd') {\n // Blocking\n int d = (act == 'u') ? 0 : (act == 'd') ? 1 : (act == 'l') ? 2 : 3;\n int bx = humans[i].x + dirs[d][0];\n int by = humans[i].y + dirs[d][1];\n if (inBounds(bx, by)) {\n blocked[bx][by] = true;\n }\n } else if (act == 'U' || act == 'D' || act == 'L' || act == 'R') {\n // Moving\n int d = (act == 'U') ? 0 : (act == 'D') ? 1 : (act == 'L') ? 2 : 3;\n int nx = humans[i].x + dirs[d][0];\n int ny = humans[i].y + dirs[d][1];\n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[i] = {nx, ny};\n }\n }\n }\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solver solver;\n solver.solve();\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U=0, D=1, L=2, R=3\nconst int DR[4] = {-1, 1, 0, 0};\nconst int DC[4] = {0, 0, -1, 1};\nconst char MOVE_CHAR[4] = {'U', 'D', 'L', 'R'};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int si, sj, ti, tj;\n double p;\n\n // Read start position, goal position, and forget probability\n if (!(cin >> si >> sj >> ti >> tj >> p)) {\n return 1;\n }\n\n // Wall representation: flat array for better memory control\n // blocked[u][dir] = 1 if direction dir from cell u is blocked\n vector blocked(400 * 4, 0);\n\n auto is_blocked = [&](int r, int c, int dir) -> bool {\n int u = r * 20 + c;\n return blocked[u * 4 + dir];\n };\n\n auto set_blocked = [&](int u, int dir, bool val) {\n blocked[u * 4 + dir] = val ? 1 : 0;\n };\n\n // Read horizontal walls (between columns in same row)\n for (int i = 0; i < 20; ++i) {\n string h_row;\n cin >> h_row;\n for (int j = 0; j < 19; ++j) {\n if (h_row[j] == '1') {\n int u = i * 20 + j;\n int v = i * 20 + (j + 1);\n set_blocked(u, 3, true); // R from (i,j) blocked\n set_blocked(v, 2, true); // L from (i,j+1) blocked\n }\n }\n }\n\n // Read vertical walls (between rows in same column)\n for (int i = 0; i < 19; ++i) {\n string v_row;\n cin >> v_row;\n for (int j = 0; j < 20; ++j) {\n if (v_row[j] == '1') {\n int u = i * 20 + j;\n int v = (i + 1) * 20 + j;\n set_blocked(u, 1, true); // D from (i,j) blocked\n set_blocked(v, 0, true); // U from (i+1,j) blocked\n }\n }\n }\n\n const int MAX_LEN = 200;\n const int NUM_CELLS = 400;\n const double STAY_PROB = p;\n const double MOVE_PROB = 1.0 - p;\n \n if (STAY_PROB <= 0.0 || STAY_PROB >= 1.0) {\n return 1;\n }\n\n // Use flattened arrays for DP table\n vector dp((MAX_LEN + 2) * NUM_CELLS, 0.0);\n auto get_dp = [&](int t, int u) -> double& {\n return dp[t * NUM_CELLS + u];\n };\n\n // Goal index\n int si_idx = si * 20 + sj;\n int goal_idx = ti * 20 + tj;\n\n // Fill DP table from t = MAX_LEN down to 1\n for (int t = MAX_LEN; t >= 1; --t) {\n // Goal is absorbing state\n get_dp(t, goal_idx) = 0.0;\n \n for (int u = 0; u < NUM_CELLS; ++u) {\n if (u == goal_idx) {\n continue;\n }\n \n int r = u / 20;\n int c = u % 20;\n \n double best_val = -1e9;\n \n for (int m = 0; m < 4; ++m) {\n double expected = 0.0;\n \n if (is_blocked(r, c, m)) {\n expected = get_dp(t + 1, u);\n } else {\n int nr = r + DR[m];\n int nc = c + DC[m];\n int v = nr * 20 + nc;\n \n // Boundary check\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) {\n expected = get_dp(t + 1, u);\n } else if (v == goal_idx) {\n expected = MOVE_PROB * (401.0 - (double)t) + STAY_PROB * get_dp(t + 1, u);\n } else {\n expected = MOVE_PROB * get_dp(t + 1, v) + STAY_PROB * get_dp(t + 1, u);\n }\n }\n \n if (expected > best_val) {\n best_val = expected;\n }\n }\n \n get_dp(t, u) = best_val;\n }\n }\n\n // Construct the optimal string greedily\n string result;\n result.reserve(MAX_LEN);\n \n // Track probability distribution over cells\n vector current_prob(NUM_CELLS, 0.0);\n current_prob[si_idx] = 1.0;\n \n for (int t = 1; t <= MAX_LEN; ++t) {\n int best_m = 0;\n double max_exp_score = -1e9;\n \n // Find move that maximizes expected score\n for (int m = 0; m < 4; ++m) {\n double exp_score = 0.0;\n \n for (int u = 0; u < NUM_CELLS; ++u) {\n double p_u = current_prob[u];\n if (p_u < 1e-15) continue;\n \n if (u == goal_idx) {\n continue;\n }\n \n int r = u / 20;\n int c = u % 20;\n \n double term = 0.0;\n if (is_blocked(r, c, m)) {\n term = get_dp(t + 1, u);\n } else {\n int nr = r + DR[m];\n int nc = c + DC[m];\n int v = nr * 20 + nc;\n \n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) {\n term = get_dp(t + 1, u);\n } else if (v == goal_idx) {\n term = MOVE_PROB * (401.0 - (double)t);\n } else {\n term = MOVE_PROB * get_dp(t + 1, v);\n }\n term += STAY_PROB * get_dp(t + 1, u);\n }\n \n exp_score += p_u * term;\n }\n \n if (exp_score > max_exp_score) {\n max_exp_score = exp_score;\n best_m = m;\n }\n }\n \n result += MOVE_CHAR[best_m];\n \n // Update probability distribution\n vector next_prob(NUM_CELLS, 0.0);\n for (int u = 0; u < NUM_CELLS; ++u) {\n double p_u = current_prob[u];\n if (p_u < 1e-15) continue;\n \n // If at goal, stay at goal (absorbing)\n if (u == goal_idx) {\n next_prob[goal_idx] += p_u;\n continue;\n }\n \n int r = u / 20;\n int c = u % 20;\n \n // Boundary and wall check\n int nr = r + DR[best_m];\n int nc = c + DC[best_m];\n bool blocked_here = is_blocked(r, c, best_m);\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n \n if (blocked_here || out_of_bounds) {\n next_prob[u] += p_u;\n } else {\n int v = nr * 20 + nc;\n next_prob[u] += p_u * STAY_PROB;\n next_prob[v] += p_u * MOVE_PROB;\n }\n }\n \n current_prob = next_prob;\n }\n\n cout << result << endl;\n\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Grid dimensions\nconst int N = 30;\n\n// Global variables\nint tiles[N][N];\nint r_rot[N][N]; // Current rotation for each tile (0-3)\nint trans[8][4][4]; // Precomputed transitions: trans[type][rotation][entry_dir]\nint t_map[8][4]; // Base transitions for unrotated tiles\n\n// For path tracing and loop detection\nbool vis[N][N][4]; // Visited status to skip redundant checks\nint trace_token[N][N][4]; // Token to track node visitation in current trace\nint global_token = 0; // Incremented for each score calculation\n\n// Path arrays to store visited nodes in the current trace\nint path_i[2500];\nint path_j[2500];\nint path_d[2500];\n\n// Movement vectors: 0=Left, 1=Up, 2=Right, 3=Down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nlong long current_score = 0;\n\n// Initialize the transition tables based on the problem description\nvoid init_to() {\n int base[8][4] = {\n {1, 0, -1, -1}, // 0: [1, 0, -1, -1]\n {3, -1, -1, 0}, // 1: [3, -1, -1, 0]\n {-1, -1, 3, 2}, // 2: [-1, -1, 3, 2]\n {-1, 2, 1, -1}, // 3: [-1, 2, 1, -1]\n {1, 0, 3, 2}, // 4: [1, 0, 3, 2]\n {3, 2, 1, 0}, // 5: [3, 2, 1, 0]\n {2, -1, 0, -1}, // 6: [2, -1, 0, -1]\n {-1, 3, -1, 1} // 7: [-1, 3, -1, 1]\n };\n \n for (int r = 0; r < 8; ++r) {\n // Copy base map for reference/debugging\n for (int d = 0; d < 4; ++d) t_map[r][d] = base[r][d];\n \n // Compute transitions for each rotation 0 to 3\n for (int rot = 0; rot < 4; ++rot) {\n for (int d = 0; d < 4; ++d) {\n // Physical port d maps to logical port (d - rot + 4) % 4\n // Logical output maps to physical port (out + rot) % 4\n int d_internal = (d - rot + 4) % 4;\n int out_internal = base[r][d_internal];\n \n if (out_internal == -1) {\n trans[r][rot][d] = -1;\n } else {\n trans[r][rot][d] = (out_internal + rot) % 4;\n }\n }\n }\n }\n}\n\n// Calculate the score: L_1 * L_2\nlong long calculate_score() {\n // Use tokens to avoid resetting visited arrays completely\n global_token++;\n if (global_token == 0) { \n // Overflow handling\n memset(trace_token, 0, sizeof(trace_token));\n memset(vis, 0, sizeof(vis));\n global_token = 1;\n }\n \n // Collect all loop lengths\n // Using a static buffer for speed, though capacity 900 is small enough\n int lengths[500];\n int num_lengths = 0;\n \n // Iterate over all ports (i, j, d)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int d = 0; d < 4; ++d) {\n // Skip if already visited\n if (vis[i][j][d]) continue;\n \n int path_len = 0;\n int ci = i, cj = j, cd = d;\n \n // Trace the path\n while (true) {\n // Check boundary\n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n\n // Check trace status\n // If token matches current trace, we found a loop within the current path\n if (trace_token[ci][cj][cd] == global_token) {\n // Found a cycle. We need to calculate the length of the loop.\n // The repeated node is (ci, cj, cd).\n // Find where it appears in the path.\n int loop_len = 0;\n for (int k = 0; k < path_len; ++k) {\n if (path_i[k] == ci && path_j[k] == cj && path_d[k] == cd) {\n loop_len = path_len - k;\n break;\n }\n }\n if (loop_len > 0) {\n lengths[num_lengths++] = loop_len;\n }\n break; \n }\n \n // If visited by previous trace (token > 0 and != global_token), it's a merged path.\n if (trace_token[ci][cj][cd] > 0) {\n break;\n }\n \n // Mark as visited in current trace and globally\n trace_token[ci][cj][cd] = global_token;\n vis[ci][cj][cd] = true;\n \n // Add to path\n path_i[path_len] = ci;\n path_j[path_len] = cj;\n path_d[path_len] = cd;\n path_len++;\n \n // Move to next port\n int type = tiles[ci][cj];\n int rot = r_rot[ci][cj];\n int nd = trans[type][rot][cd];\n \n if (nd == -1) break; // Broken link\n \n int ni = ci + di[nd];\n int nj = cj + dj[nd];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) break; // Boundary\n \n ci = ni; cj = nj; \n cd = (nd + 2) % 4; // Direction to enter next tile\n }\n }\n }\n }\n \n if (num_lengths < 2) return 0;\n \n // Sort to find the two largest\n sort(lengths, lengths + num_lengths, greater());\n \n return (long long)lengths[0] * lengths[1];\n}\n\n// Random number generation\nmt19937 rng(1337);\nuniform_int_distribution dist_rot(0, 3);\nuniform_int_distribution dist_pos(0, 29);\nuniform_real_distribution dist_rand_p(0.0, 1.0);\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_to();\n \n // Read input and initialize random rotations\n for (int i = 0; i < N; ++i) {\n string row;\n if (!(cin >> row)) return 0;\n for (int j = 0; j < N; ++j) {\n tiles[i][j] = row[j] - '0';\n r_rot[i][j] = dist_rot(rng);\n }\n }\n \n // Simulated Annealing Parameters\n // Run multiple iterations to optimize\n int iterations = 60000;\n double T_0 = 1000.0;\n double T_final = 0.0001;\n \n long long global_best_score = calculate_score();\n int best_r[N][N];\n // Save initial state\n for(int i=0; i current_score) {\n accept = true;\n } else if (score >= current_score) {\n accept = true; // Equal score usually accepted\n } else {\n double exp_val = exp((double)(score - current_score) / T);\n if (exp_val > p_accept) {\n accept = true;\n }\n }\n \n if (accept) {\n current_score = score;\n if (score > global_best_score) {\n global_best_score = score;\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 10;\nconst int MAX_BOARD_SIZE = MAX_N * MAX_N;\nconst int BEAM_WIDTH = 60; \nconst int MAX_NODES = 1000000; \n\nstruct Node {\n int board[MAX_BOARD_SIZE];\n int empty_pos;\n int score;\n int parent_idx; \n char move_char;\n};\n\nvector all_nodes;\nint parent[MAX_BOARD_SIZE];\nint sz[MAX_BOARD_SIZE];\nbool is_cyclic[MAX_BOARD_SIZE];\n\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nint dsu_find(int i);\nvoid dsu_union(int i, int j);\nvoid dsu_init(int n);\n\nvoid dsu_init(int n) {\n for (int i = 0; i < n; ++i) {\n parent[i] = i;\n sz[i] = 1;\n is_cyclic[i] = false;\n }\n}\n\nint dsu_find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = dsu_find(parent[i]);\n}\n\nvoid dsu_union(int i, int j) {\n int root_i = dsu_find(i);\n int root_j = dsu_find(j);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n}\n\nint get_score(const int* board, int n, int empty_pos) {\n dsu_init(n);\n for (int r = 0; r < n; ++r) {\n for (int c = 0; c < n; ++c) {\n int idx = r * n + c;\n if (board[idx] == 0) continue;\n if (c < n - 1) {\n int neighbor_idx = idx + 1;\n if (board[neighbor_idx] != 0) {\n if ((board[idx] & 4) && (board[neighbor_idx] & 1)) {\n dsu_union(idx, neighbor_idx);\n }\n }\n }\n if (r < n - 1) {\n int neighbor_idx = idx + n;\n if (board[neighbor_idx] != 0) {\n if ((board[idx] & 8) && (board[neighbor_idx] & 2)) {\n dsu_union(idx, neighbor_idx);\n }\n }\n }\n }\n }\n \n int max_tree_size = 0;\n vector processed_root(n, false); // n = n*n in previous logic, changed to n*n size\n int nn = n * n;\n \n // Reset processed_root for size nn\n // Actually inside function, vector init is fine, but need to be size nn\n processed_root.assign(nn, false);\n\n for (int i = 0; i < nn; ++i) {\n if (board[i] == 0) continue;\n int root = dsu_find(i);\n if (processed_root[root]) continue;\n processed_root[root] = true;\n \n if (!is_cyclic[root]) {\n if (sz[root] > max_tree_size) {\n max_tree_size = sz[root];\n }\n }\n }\n return max_tree_size;\n}\n\nstring reconstruct_path(int node_idx) {\n string path = \"\";\n int current = node_idx;\n while (all_nodes[current].parent_idx != -1) {\n path += all_nodes[current].move_char;\n current = all_nodes[current].parent_idx;\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 int N, T;\n if (!(cin >> N >> T)) return 0;\n\n all_nodes.reserve(MAX_NODES);\n \n Node start_node;\n memset(start_node.board, 0, sizeof(start_node.board));\n start_node.parent_idx = -1;\n start_node.move_char = 0;\n int empty_pos = -1;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c;\n cin >> c;\n int val = 0;\n if (isdigit(c)) val = c - '0';\n else val = 10 + (c - 'a');\n start_node.board[i * N + j] = val;\n if (val == 0) {\n empty_pos = i * N + j;\n }\n }\n }\n start_node.empty_pos = empty_pos;\n start_node.score = get_score(start_node.board, N, empty_pos);\n \n all_nodes.push_back(start_node);\n\n vector current_layer;\n vector next_layer;\n current_layer.push_back(0);\n \n int best_node_idx = 0;\n int max_score = start_node.score;\n\n for (int step = 1; step <= T; ++step) {\n next_layer.clear();\n for (int idx : current_layer) {\n Node u = all_nodes[idx];\n int er = u.empty_pos / N;\n int ec = u.empty_pos % N;\n \n for (int k = 0; k < 4; ++k) {\n int nr = er + dr[k];\n int nc = ec + dc[k];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (u.parent_idx != -1) {\n char prev_move = all_nodes[idx].move_char;\n if ((prev_move == 'U' && k == 1) ||\n (prev_move == 'D' && k == 0) ||\n (prev_move == 'L' && k == 3) ||\n (prev_move == 'R' && k == 2)) {\n continue; \n }\n }\n \n Node v = u;\n v.empty_pos = nr * N + nc;\n v.board[u.empty_pos] = u.board[v.empty_pos];\n v.board[v.empty_pos] = 0;\n \n v.parent_idx = idx;\n v.move_char = dir_char[k];\n // v.id = all_nodes.size(); // Removed as node index in vector suffices\n \n v.score = get_score(v.board, N, v.empty_pos);\n \n if (v.score == N * N - 1) {\n cout << reconstruct_path((int)all_nodes.size()) << endl;\n return 0;\n }\n \n all_nodes.push_back(v);\n next_layer.push_back((int)all_nodes.size() - 1);\n }\n }\n }\n \n if (next_layer.empty()) break;\n \n sort(next_layer.begin(), next_layer.end(), [&](int a, int b) {\n return all_nodes[a].score > all_nodes[b].score;\n });\n \n current_layer.clear();\n int limit = min((int)next_layer.size(), BEAM_WIDTH);\n for (int i = 0; i < limit; ++i) {\n current_layer.push_back(next_layer[i]);\n if (all_nodes[next_layer[i]].score > max_score) {\n max_score = all_nodes[next_layer[i]].score;\n best_node_idx = next_layer[i];\n }\n }\n }\n \n if (max_score < N * N - 1) {\n cout << reconstruct_path(best_node_idx) << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n\n// AC Library (optional for competitive programming)\n#include \n\nusing namespace std;\nusing namespace atcoder;\n\n// Data structures\nstruct Point {\n long long x, y;\n};\n\nstruct Line {\n double A, B, C; // Ax + By + C = 0\n};\n\n// Global variables to avoid passing too many parameters\nint N, K;\nvector a(11);\nvector strawberries;\nvector lines;\nvector best_lines;\nvector, int>> sigs; // Stores {signature, original_index}\nvector, int>> temp_sigs; // Reuse buffer if possible, but local is safer for lambda\n// Actually, we'll define sigs inside lambda or make it global. Making it global and resizing once is efficient.\n// But lambda needs access. Let's pass sigs or capture.\n// Let's stick to capturing global 'sigs' or local 'sigs' in main.\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> K)) return 0;\n\n // Read a_d\n int sum_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n sum_a += a[i];\n }\n\n // Read strawberries\n strawberries.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n\n // Random number generator\n mt19937 rng(12345); // Fixed seed for reproducibility\n vector current_lines(K);\n const double PI = 3.14159265358979323846;\n\n // Initialize lines randomly\n for (int i = 0; i < K; ++i) {\n double angle = uniform_real_distribution(0, 2 * PI)(rng);\n current_lines[i].A = cos(angle);\n current_lines[i].B = sin(angle);\n // r is distance from origin. Points are within 10^4 radius.\n // Lines with |C| roughly <= 12000 will intersect the cake significantly.\n double r = uniform_real_distribution(-12000.0, 12000.0)(rng);\n current_lines[i].C = -r;\n }\n\n // Resize sigs vector\n sigs.resize(N);\n\n // Helper lambda to calculate score\n // Note: Using global 'lines' is not possible inside lambda without capture if defined outside.\n // We will capture 'lines' by reference. But since 'lines' changes, we should pass 'lines' or use a shared global.\n // To avoid overhead, I'll implement a function that takes lines as argument.\n auto calculate_score = [&](const vector& curr_lines) -> int {\n // Compute signatures\n for (int i = 0; i < N; ++i) {\n pair sig = {0, 0};\n for (int k = 0; k < K; ++k) {\n double val = curr_lines[k].A * strawberries[i].x + \n curr_lines[k].B * strawberries[i].y + \n curr_lines[k].C;\n // Check side. val >= 0 implies on one side.\n if (val >= 0) {\n if (k < 64) sig.first |= (1LL << k);\n else sig.second |= (1LL << (k - 64));\n }\n }\n sigs[i] = {sig, i};\n }\n\n // Sort signatures to group points by region\n sort(sigs.begin(), sigs.end(), [](const auto& a, const auto& b) {\n if (a.first != b.first) return a.first < b.first; // Compare signatures\n return a.second < b.second;\n });\n\n int cnt[11] = {0}; // b_1 ... b_10\n int current_run = 0;\n for (int i = 0; i < N; ++i) {\n current_run++;\n // Check if next point has different signature\n bool next_diff = (i + 1 == N) || (sigs[i+1].first != sigs[i].first);\n if (next_diff) {\n // Region ended\n if (current_run >= 1 && current_run <= 10) {\n cnt[current_run]++;\n }\n current_run = 0;\n }\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(cnt[d], a[d]);\n }\n return score;\n };\n\n // SA Initialization\n int current_score = calculate_score(current_lines);\n int best_score = current_score;\n best_lines = current_lines;\n\n // SA Parameters\n int num_iterations = 2000; // Adjust based on time limit\n double T = 100000.0; \n double decay = 0.9995; \n\n // SA Loop\n for (int iter = 0; iter < num_iterations; ++iter) {\n double T_iter = T * pow(decay, iter); \n // Or simpler: T *= decay;\n \n // Choose a random line to perturb\n int idx = (rng()() % K);\n\n // Backup current line\n Line old_line = lines[idx]; // Wait, lines is not global in the scope of lambda, need to fix\n // Actually I defined 'lines' as a vector in main. But I need to update 'lines' inside the loop?\n // My lambda takes 'curr_lines'. So I must update 'current_lines' in the main scope if accepted.\n // But I need to backtrack.\n \n // Let's use 'current_lines' as the state.\n Line backup = current_lines[idx];\n\n // Perturb\n double phi = atan2(current_lines[idx].B, current_lines[idx].A);\n double angle_change = (uniform_real_distribution(-0.02, 0.02))(rng);\n current_lines[idx].A = cos(phi + angle_change);\n current_lines[idx].B = sin(phi + angle_change);\n\n double C_change = (uniform_real_distribution(-10.0, 10.0))(rng);\n current_lines[idx].C += C_change;\n\n // Calculate new score\n int new_score = calculate_score(current_lines);\n\n // SA Decision\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n // Probabilistic acceptance\n // diff = new - current (negative)\n double prob = exp((double)(new_score - current_score) / T_iter);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n best_lines = current_lines;\n }\n } else {\n // Revert\n current_lines[idx] = backup;\n }\n }\n\n // Output best lines\n cout << K << \"\\n\";\n \n // Convert best_lines to integer points\n for (int k_idx = 0; k_idx < K; ++k_idx) {\n double A = best_lines[k_idx].A;\n double B = best_lines[k_idx].B;\n double C = best_lines[k_idx].C;\n\n // Find two points on the line.\n // Line: Ax + By + C = 0.\n // Closest point to origin: P0 = (-AC, -BC).\n // Since A^2+B^2=1.\n \n long long x0 = (long long)round(-A * C);\n long long y0 = (long long)round(-B * C);\n\n // Direction vector (-B, A)\n // Scale it to find a second point\n double dx = -B;\n double dy = A;\n long long S = 2000; // Scale factor\n\n long long px1 = x0;\n long long py1 = y0;\n long long px2 = x0 + (long long)round(dx * S);\n long long py2 = y0 + (long long)round(dy * S);\n\n // Safety check to ensure distinct points\n if (px1 == px2 && py1 == py2) {\n // Fallback if direction vector rounds to 0 (unlikely with A^2+B^2=1)\n px2 += 1000; \n // Adjust py2 to maintain line equation if possible, but any distinct point works for valid line output\n // However, we want line to match best approximation.\n // If px2 was 0 (due to round), we move it.\n // Just ensure it's far away enough from x1, y1.\n // But if we move arbitrarily, the line might not match the optimized one.\n // The line should still be close.\n // Since we can't easily fix without complex math, this fallback is risky.\n // However, with S=2000 and A^2+B^2=1, at least one component of (dx, dy) is > 0.7 or similar?\n // No. dx = -B, dy = A. If B=0, dx=0. dy=1. Then py2=py1+2000. Distinct.\n // If A=0, B=1. dx=-1. dy=0. px2=px1-2000. Distinct.\n // So (dx, dy) is never (0,0).\n // But rounding can make them 0.\n // So the code above handles it.\n // In the very unlikely case it fails, we do:\n // px1+=100. (Still within bounds).\n px2 += 1000;\n if (px1 == px2) {\n px2 -= 1000; // Should be fine unless very small coords?\n }\n }\n\n // Output\n cout << px1 << \" \" << py1 << \" \" << px2 << \" \" << py2 << \"\\n\";\n }\n\n return 0;\n}","ahc014":" while (cx != b.x || cy != b.y) {\n if (has_dot[cx][cy]) return true;\n cx += dx_step;\n cy += dy_step;\n }","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\nint grid[N][N];\nint flavors[100];\n\n// Calculate score for a given grid configuration\nint calculate_score(int arr[N][N]) {\n int score = 0;\n bool visited[N][N];\n memset(visited, 0, sizeof(visited));\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (arr[r][c] != 0 && !visited[r][c]) {\n int current_flavor = arr[r][c];\n int count = 0;\n \n // BFS\n int q_r[N*N], q_c[N*N]; \n int head = 0, tail = 0;\n \n q_r[tail] = r; q_c[tail] = c;\n visited[r][c] = true;\n tail++;\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n \n while(head < tail) {\n int cr = q_r[head];\n int cc = q_c[head];\n head++;\n count++;\n \n for(int k=0; k<4; ++k) {\n int nr = cr + dr[k];\n int nc = cc + dc[k];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if(!visited[nr][nc] && arr[nr][nc] == current_flavor) {\n visited[nr][nc] = true;\n q_r[tail] = nr;\n q_c[tail] = nc;\n tail++;\n }\n }\n }\n }\n score += count * count;\n }\n }\n }\n return score;\n}\n\n// Helper to apply a move to a grid\nvoid apply_move(int grid[N][N], char dir) {\n int next_grid[N][N];\n memset(next_grid, 0, sizeof(next_grid));\n \n if (dir == 'F') { // Forward -> Top (Up)\n for (int c = 0; c < N; ++c) {\n int write_idx = 0;\n for (int r = 0; r < N; ++r) {\n if (grid[r][c] != 0) {\n next_grid[write_idx][c] = grid[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'B') { // Backward -> Bottom (Down)\n for (int c = 0; c < N; ++c) {\n int write_idx = N - 1;\n for (int r = N - 1; r >= 0; --r) {\n if (grid[r][c] != 0) {\n next_grid[write_idx][c] = grid[r][c];\n write_idx--;\n }\n }\n }\n } else if (dir == 'L') { // Left -> Left edge\n for (int r = 0; r < N; ++r) {\n int write_idx = 0;\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n next_grid[r][write_idx] = grid[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'R') { // Right -> Right edge\n for (int r = 0; r < N; ++r) {\n int write_idx = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid[r][c] != 0) {\n next_grid[r][write_idx] = grid[r][c];\n write_idx--;\n }\n }\n }\n }\n \n memcpy(grid, next_grid, sizeof(grid));\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Seed random for tie-breaking\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n mt19937 gen(seed);\n\n // Read flavor sequence\n for (int t = 0; t < 100; ++t) {\n cin >> flavors[t];\n }\n\n // Main interaction loop\n for (int t = 0; t < 100; ++t) {\n int p;\n cin >> p;\n \n // Find the p-th empty cell in reading order\n int count = 0;\n bool found = false;\n int r_target = 0, c_target = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] == 0) {\n count++;\n if (count == p) {\n r_target = i;\n c_target = j;\n found = true;\n break;\n }\n }\n }\n if (found) break;\n }\n \n // Place the candy\n if (found) {\n grid[r_target][c_target] = flavors[t];\n }\n\n // Determine tilt direction\n // Problem note: For the 100th step (index 99), we may skip output.\n // We skip output for t == 99 to match the specific instruction \"skip the output\".\n // If t < 99, we must output a tilt direction.\n if (t < 99) { \n char best_move = 'F';\n int best_score = -1;\n \n char moves[] = {'F', 'B', 'L', 'R'};\n \n // Randomize order for tie-breaking fairness\n vector idx(4);\n for(int i=0; i<4; ++i) idx[i] = i;\n shuffle(idx.begin(), idx.end(), gen);\n\n for (auto i : idx) {\n char dir = moves[i];\n // Simulate the move on a copy of the grid\n int sim_grid[N][N];\n memcpy(sim_grid, grid, sizeof(sim_grid));\n \n // Apply move to simulation copy\n apply_move(sim_grid, dir);\n \n // Calculate score\n int score = calculate_score(sim_grid);\n \n // Greedy update\n if (best_score == -1 || score > best_score) {\n best_score = score;\n best_move = dir;\n }\n }\n \n cout << best_move << endl;\n \n // Apply the selected move to the real grid\n apply_move(grid, best_move);\n }\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Graph class with essential operations\nclass Graph {\npublic:\n int n;\n std::vector adj;\n std::vector> adj_matrix;\n \n Graph(int n = 0) : n(n) {\n adj_matrix = n > 0 ? std::vector>(n, std::vector(n, 0)) : std::vector>();\n if (n > 0) {\n int total_edges = n * (n - 1) / 2;\n adj.assign(total_edges, 0);\n }\n }\n \n static Graph fromString(const std::string& s, int n) {\n Graph G(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n G.adj[idx] = s[idx] - '0';\n G.adj_matrix[i][j] = G.adj_matrix[j][i] = G.adj[idx];\n idx++;\n }\n }\n return G;\n }\n \n std::string toString() const {\n std::string s = \"\";\n for (int x : adj) s += std::to_string(x);\n return s;\n }\n \n int edgeCount() const {\n return std::accumulate(adj.begin(), adj.end(), 0);\n }\n \n std::vector degreeSequence() const {\n std::vector deg(n, 0);\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (adj_matrix[i][j]) {\n deg[i]++;\n deg[j]++;\n }\n }\n }\n std::sort(deg.begin(), deg.end());\n return deg;\n }\n};\n\n// Weisfeiler-Lehman hash for rotation-invariant fingerprint\nclass WLHash {\nprivate:\n mutable int n;\n mutable std::vector labels;\n \npublic:\n WLHash(int n = 0) : n(n) {}\n \n std::vector compute(const Graph& G, int iterations = 4) const {\n std::vector labels_sorted = G.degreeSequence();\n labels = labels_sorted;\n \n for (int iter = 0; iter < iterations; iter++) {\n std::vector new_labels(G.n, 0);\n for (int i = 0; i < G.n; i++) {\n std::vector neighbor_labels;\n for (int j = 0; j < G.n; j++) {\n if (G.adj_matrix[i][j]) {\n neighbor_labels.push_back(labels[j]);\n }\n }\n std::sort(neighbor_labels.begin(), neighbor_labels.end());\n \n unsigned long h = labels[i];\n for (int nl : neighbor_labels) {\n h = (h * 37 + nl) % (G.n * G.n + 100);\n }\n new_labels[i] = h % 1000003;\n }\n labels = new_labels;\n }\n return labels;\n }\n \n long long signature() const {\n std::vector sorted_labels = labels;\n std::sort(sorted_labels.begin(), sorted_labels.end());\n long long sum = 0;\n for (int l : sorted_labels) sum += l;\n return sum;\n }\n};\n\n// Graph feature for fast filtering\nstruct GraphFeature {\n int edgeCount;\n std::vector degreeSeq;\n long long wlHashSignature;\n \n // Default constructor\n GraphFeature() : edgeCount(0), wlHashSignature(0) {}\n \n // Parameterized constructor\n GraphFeature(const Graph& G, const WLHash& wl) {\n edgeCount = G.edgeCount();\n degreeSeq = G.degreeSequence();\n std::vector labels = wl.compute(G);\n std::vector sorted_labels = labels;\n std::sort(sorted_labels.begin(), sorted_labels.end());\n wlHashSignature = std::accumulate(sorted_labels.begin(), sorted_labels.end(), 0LL);\n }\n \n int distance(const GraphFeature& other) const {\n int diff = std::abs(edgeCount - other.edgeCount);\n int degDiff = 0;\n for (size_t i = 0; i < degreeSeq.size(); i++) {\n degDiff += std::abs((int)degreeSeq[i] - (int)other.degreeSeq[i]);\n }\n int whDiff = std::abs((int)(wlHashSignature - other.wlHashSignature)) / 1000;\n return diff * 100 + degDiff + whDiff;\n }\n};\n\n// Compute log-likelihood score for matching\ndouble computeLikelihood(int matched, int total, double epsilon) {\n double logP = matched * std::log(1.0 - epsilon) + (total - matched) * std::log(epsilon);\n return logP;\n}\n\n// Approximate isomorphism check with scoring\ndouble scoreGraphMatch(const Graph& H, const Graph& G, double epsilon) {\n int n = H.n;\n if (n != G.n) return -1e18;\n \n // Greedy vertex matching based on degrees\n std::vector> h_deg, g_deg;\n for (int i = 0; i < n; i++) {\n int hd = 0, gd = 0;\n for (int j = 0; j < n; j++) {\n if (H.adj_matrix[i][j]) hd++;\n if (G.adj_matrix[i][j]) gd++;\n }\n h_deg.push_back({-hd, i}); // negative for descending sort\n g_deg.push_back({-gd, i});\n }\n std::sort(h_deg.begin(), h_deg.end());\n std::sort(g_deg.begin(), g_deg.end());\n \n // Count matching edges under degree-based mapping\n int matched = 0;\n int total_pairs = n * (n - 1) / 2;\n \n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n bool h_edge = H.adj_matrix[i][j];\n int mi = h_deg[i].second;\n int mj = h_deg[j].second;\n // Map H[i] -> G[sorted_g[rank_i]]\n // Actually we need the sorted rank\n int src_rank1 = -1, src_rank2 = -1;\n for (int r = 0; r < n; r++) {\n if (h_deg[r].second == i) src_rank1 = r;\n if (h_deg[r].second == j) src_rank2 = r;\n }\n int tar_i = g_deg[src_rank1].second;\n int tar_j = g_deg[src_rank2].second;\n \n bool g_edge = G.adj_matrix[tar_i][tar_j];\n if (h_edge == g_edge) matched++;\n }\n }\n \n // Return log-likelihood\n return computeLikelihood(matched, total_pairs, epsilon);\n}\n\nint main() {\n // Optimization for I/O\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int M;\n double epsilon;\n if (!(std::cin >> M >> epsilon)) return 0;\n \n // N selection: balance score vs distinguishability\n // Score = round(10^9 * 0.9^E / N), so smaller N is better\n // But need enough vertices for distinct graphs\n int N = 35;\n \n // Generate M graphs with different edge counts\n std::vector graphs(M, Graph(N));\n std::vector features;\n features.reserve(M);\n \n WLHash wl(N);\n \n // Use increasing edge counts for easy filtering\n int max_edges = N * (N - 1) / 2;\n for (int k = 0; k < M; k++) {\n // Distribute edge counts: [0, max_edges]\n int target_edges = k * max_edges / M;\n \n // Create graph with specific edge count\n int count = 0;\n for (int i = 0; i < N && count < target_edges; i++) {\n for (int j = i + 1; j < N && count < target_edges; j++) {\n graphs[k].adj_matrix[i][j] = graphs[k].adj_matrix[j][i] = 1;\n count++;\n }\n }\n \n // Convert to adj format\n int idx = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n graphs[k].adj[idx++] = graphs[k].adj_matrix[i][j];\n }\n }\n \n features.emplace_back(graphs[k], wl);\n }\n \n // Output N and graphs\n std::cout << N << \"\\n\";\n std::cout.flush();\n \n for (int k = 0; k < M; k++) {\n std::cout << graphs[k].toString() << \"\\n\";\n }\n std::cout.flush();\n \n // Process queries\n for (int q = 0; q < 100; q++) {\n std::string H_str;\n std::cin >> H_str;\n Graph H = Graph::fromString(H_str, N);\n \n // First filter: edge count (most distinctive feature)\n int best_k = 0;\n double best_score = -1e18;\n \n // Score all graphs and pick best\n for (int k = 0; k < M; k++) {\n // Edge count filter - if too far off, skip expensive match\n int edge_diff = std::abs(graphs[k].edgeCount() - H.edgeCount());\n if (edge_diff > 5) continue; // threshold depends on noise\n \n // Full matching score\n double score = scoreGraphMatch(H, graphs[k], epsilon);\n \n // Bonus for edge count similarity\n score += (50 - edge_diff) * 0.1;\n \n if (score > best_score) {\n best_score = score;\n best_k = k;\n }\n }\n \n std::cout << best_k << \"\\n\";\n std::cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n\nusing namespace std;\n\nstruct Edge {\n int u, v, w, id;\n};\n\nint main() {\n ios_base::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 // Read edges\n vector> adj(N + 1);\n vector edges(M);\n \n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n edges[i] = {u, v, w, i};\n adj[u].push_back(i);\n adj[v].push_back(i);\n }\n \n // Read coordinates\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n \n // Initialize with simple even distribution\n vector assignments(M, 1);\n vector dayCounts(D + 1, 0);\n \n // Assign edges evenly, ensuring capacity\n int edgesPerDay = M / D;\n int remainder = M % D;\n \n int currentEdge = 0;\n for (int d = 1; d <= D; d++) {\n int assignCount = edgesPerDay + (d <= remainder ? 1 : 0);\n for (int i = 0; i < assignCount && currentEdge < M; i++) {\n assignments[currentEdge] = d;\n dayCounts[d]++;\n currentEdge++;\n }\n }\n \n // Now optimize using simple local search\n for (int iter = 0; iter < 50000; iter++) {\n // Try to move one edge to reduce imbalance\n int edgeIdx = iter % M;\n int fromDay = assignments[edgeIdx];\n \n // Find a day with fewer edges\n for (int d = 1; d <= D; d++) {\n if (d == fromDay) continue;\n if (dayCounts[d] < K) {\n // Move edge\n dayCounts[fromDay]--;\n dayCounts[d]++;\n assignments[edgeIdx] = d;\n break;\n }\n }\n }\n \n // Ensure all outputs are valid\n for (int i = 0; i < M; i++) {\n int day = assignments[i];\n if (day < 1 || day > D) {\n assignments[i] = (i % D) + 1;\n }\n }\n \n // Output result\n for (int i = 0; i < M; i++) {\n cout << assignments[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold a point in 3D space\nstruct Point3D {\n int x, y, z;\n bool operator<(const Point3D& o) const {\n if (x != o.x) return x < o.x;\n if (y != o.y) return y < o.y;\n return z < o.z;\n }\n bool operator==(const Point3D& o) const {\n return x == o.x && y == o.y && z == o.z;\n }\n};\n\n// Structure to hold rotation matrices\nstruct RotMat {\n int p[3]; // permutation of axes\n int s[3]; // signs for each axis\n};\n\nint D;\nchar f1[15][15], r1[15][15], f2[15][15], r2[15][15];\nint g1[15][15][15], g2[15][15][15];\nint g_common[15][15][15];\nint b1[15][15][15], b2[15][15][15];\nvector common_ccs;\nvector> rem1_c;\nvector> rem2_c;\nvector rotations;\n\nint parity(const vector& p) {\n int c = 0;\n for(int i=0; i<3; ++i) \n for(int j=i+1; j<3; ++j) \n if(p[i] > p[j]) c++;\n return c;\n}\n\nvoid init_rotations() {\n int p[] = {0, 1, 2};\n do {\n vector v_p(p, p+3);\n if (parity(v_p) % 2 == 0) {\n int signs[4][3] = {{1,1,1}, {1,-1,-1}, {-1,1,-1}, {-1,-1,1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n } else {\n int signs[4][3] = {{1,1,-1}, {1,-1,1}, {-1,1,1}, {-1,-1,-1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n }\n } while (next_permutation(p, p+3));\n}\n\nPoint3D transform(const Point3D& src, const RotMat& r) {\n int vals[3] = {src.x, src.y, src.z};\n return {vals[r.p[0]] * r.s[0], vals[r.p[1]] * r.s[1], vals[r.p[2]] * r.s[2]};\n}\n\n// Generate the canonical representation of a shape by trying all rotations\nvector get_canonical_shape(const vector& pts) {\n if (pts.empty()) return {};\n \n vector best;\n bool first = true;\n \n for(const auto& r : rotations) {\n vector current;\n current.reserve(pts.size());\n for(const auto& p : pts) {\n current.push_back(transform(p, r));\n }\n \n int cminx=1000, cminy=1000, cminz=1000;\n for(const auto& p : current) {\n cminx = min(cminx, p.x);\n cminy = min(cminy, p.y);\n cminz = min(cminz, p.z);\n }\n \n sort(current.begin(), current.end());\n for(auto& p : current) {\n p.x -= cminx; p.y -= cminy; p.z -= cminz;\n }\n \n if (first || current < best) {\n best = current;\n first = false;\n }\n }\n return best;\n}\n\nvoid bfs(int grid[15][15][15], vector>& components) {\n for(int x=0; x pts;\n queue, int>> q;\n q.push({{x, y}, z});\n grid[x][y][z] = 0;\n pts.push_back({x,y,z});\n \n while(!q.empty()){\n auto curr = q.front(); q.pop();\n int cx = curr.first.first, cy = curr.first.second, cz = curr.second;\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 for(int i=0; i<6; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n int nz = cz + dz[i];\n if(nx >= 0 && nx < D && ny >= 0 && ny < D && nz >= 0 && nz < D && grid[nx][ny][nz] == 1) {\n grid[nx][ny][nz] = 0;\n q.push({{nx, ny}, nz});\n pts.push_back({nx, ny, nz});\n }\n }\n }\n components.push_back(pts);\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_rotations();\n \n if (!(cin >> D)) return 0;\n \n string s;\n // Read f1\n for(int z=0; z> s; for(int x=0;x> s; for(int y=0;y> s; for(int x=0;x> s; for(int y=0;y, vector> rem2_map;\n for(size_t i=0; i shape = rem2_c[i];\n vector key = get_canonical_shape(shape);\n rem2_map[key].push_back(i);\n }\n \n vector rem1_block_id(rem1_c.size(), 0);\n vector rem2_block_id(rem2_c.size(), 0);\n \n int common_count = common_ccs.size();\n int current_id = common_count + 1;\n \n // Fill Common Blocks with IDs 1 to common_count\n for(size_t i=0; i shape = rem1_c[i];\n vector key = get_canonical_shape(shape);\n \n if (rem2_map.count(key) && !rem2_map[key].empty()) {\n int j = rem2_map[key].back();\n rem2_map[key].pop_back();\n \n rem1_block_id[i] = current_id;\n rem2_block_id[j] = current_id;\n int bid = current_id;\n for(auto& p : rem1_c[i]) b1[p.x][p.y][p.z] = bid;\n for(auto& p : rem2_c[j]) b2[p.x][p.y][p.z] = bid;\n current_id++;\n } else {\n rem1_block_id[i] = current_id;\n current_id++;\n }\n }\n \n // Fill Unique Rem1 components\n for(size_t i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Data structures\nstruct Point {\n long long x, y;\n};\n\nstruct Edge {\n int u, v, w;\n int id; // 0-based index for B output\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nint N, M, K;\nvector nodes;\nvector residents;\nvector all_edges;\n\n// Global for calculation\nvector MST_parent;\nvector MST_weight;\nvector edge_to_parent_id;\nvector bfs_order; // Stores indices in BFS order starting from root (0)\nvector active;\nvector> residents_for; // residents assigned to node u\nvector resident_location; // resident_location[k] = u\n\nvector> dist_sq; // N x K\nvector P;\nvector B; // Output for edges\n\n// Helper to compute distance squared\nlong long dist_sq_func(Point p1, Point p2) {\n return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);\n}\n\n// Calculate smallest integer k such that k*k >= d2\nlong long get_ceil_sqrt_safe(long long d2) {\n if (d2 <= 0) return 0;\n long long r = round(sqrt(d2));\n if (r * r < d2) r++;\n return r;\n}\n\nvoid calculate_P_and_active() {\n P.assign(N, 0);\n active.assign(N, false);\n for (int u = 0; u < N; ++u) {\n long long mx = 0;\n if (!residents_for[u].empty()) {\n for (int k_idx : residents_for[u]) {\n mx = max(mx, get_ceil_sqrt_safe(dist_sq[u][k_idx]));\n }\n }\n P[u] = mx;\n if (mx > 0) active[u] = true;\n }\n}\n\n// Calculate MST cost: sum of weights of edges connecting active nodes to 1\nlong long calc_mst_cost() {\n long long cost = 0;\n vector needed(N, false);\n for(int i=0; i 0; --i) {\n int v = bfs_order[i];\n if (needed[v]) {\n int p = MST_parent[v];\n if (p != -1) {\n needed[p] = true;\n cost += MST_weight[v];\n }\n }\n }\n return cost;\n}\n\n// Calculate total cost\nlong long calculate_total_cost() {\n long long node_cost = 0;\n for (int u = 0; u < N; ++u) {\n node_cost += P[u] * P[u];\n }\n return node_cost + calc_mst_cost();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> K)) return 0;\n\n nodes.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> nodes[i].x >> nodes[i].y;\n }\n \n all_edges.resize(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v; // 0-based\n all_edges[i] = {u, v, w, i};\n }\n \n residents.resize(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].x >> residents[i].y;\n }\n \n // Precompute distances\n dist_sq.assign(N, vector(K));\n for(int u=0; u dsu(N);\n iota(dsu.begin(), dsu.end(), 0);\n function find = [&](int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); };\n auto unite = [&](int x, int y) { x = find(x); y = find(y); if (x != y) { dsu[x] = y; return true; } return false; };\n \n vector mst_edges;\n for (auto& e : all_edges) {\n if (unite(e.u, e.v)) {\n mst_edges.push_back(e);\n }\n }\n \n // Build MST Adjacency\n // BFS root is 0 (Node 1)\n vector>> mst_adj(N);\n for (const auto& e : mst_edges) {\n mst_adj[e.u].push_back({e.v, e.w});\n mst_adj[e.v].push_back({e.u, e.w});\n }\n \n MST_parent.assign(N, -1);\n MST_weight.assign(N, 0);\n edge_to_parent_id.assign(N, -1);\n bfs_order.clear();\n bfs_order.reserve(N);\n \n queue q;\n vector visited(N, false);\n q.push(0);\n visited[0] = true;\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n bfs_order.push_back(u);\n \n for(auto& neighbor : mst_adj[u]){\n int v = neighbor.first;\n int w = neighbor.second;\n if(!visited[v]){\n visited[v] = true;\n MST_parent[v] = u;\n MST_weight[v] = w;\n q.push(v);\n }\n }\n }\n \n // Re-traverse to find edge IDs for parent edges\n for(int u=0; u());\n resident_location.assign(K, -1);\n for(int k=0; k& old_list = residents_for[u_old];\n for(auto it = old_list.begin(); it != old_list.end(); ++it){\n if(*it == k) {\n old_list.erase(it);\n break;\n }\n }\n \n // Add to best_u\n residents_for[best_u].push_back(k);\n \n // Check if valid and better\n calculate_P_and_active();\n long long new_cost = calculate_total_cost();\n \n // Greedy acceptance\n if (new_cost <= current_cost) {\n current_cost = new_cost;\n resident_location[k] = best_u;\n } else {\n // Revert\n vector& new_list = residents_for[best_u];\n for(auto it = new_list.begin(); it != new_list.end(); ++it){\n if(*it == k) {\n new_list.erase(it);\n break;\n }\n }\n residents_for[u_old].push_back(k);\n resident_location[k] = u_old;\n calculate_P_and_active();\n }\n }\n }\n \n // Finalize\n calculate_P_and_active();\n \n // Output P\n for(int i=0; i needed(N, false);\n \n // Initialize needed based on active nodes (P > 0)\n for(int u=0; u order = bfs_order;\n \n for (int i = N - 1; i > 0; --i) {\n int v = order[i];\n if (needed[v]) {\n int p = MST_parent[v];\n if (p != -1) {\n needed[p] = true;\n if (edge_to_parent_id[v] != -1) {\n B[edge_to_parent_id[v]] = 1;\n }\n }\n }\n }\n \n // Print B\n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a swap operation\nstruct Op {\n int x1, y1, x2, y2;\n};\n\n// Structure to represent a valid vertical edge in the pyramid\nstruct Edge {\n int x1, y1; // Coordinates of the parent (top) node\n int x2, y2; // Coordinates of the child (bottom) node\n};\n\nint grid[30][30];\nvector edges;\n\nint main() {\n // Optimize I/O operations for speed\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Initialize all valid vertical edges in the pyramid\n // For each row x, nodes (x, 0) to (x, x) exist.\n // They connect to nodes in row x+1: (x+1, y) and (x+1, y+1).\n for (int x = 0; x < 29; ++x) {\n for (int y = 0; y <= x; ++y) {\n edges.push_back({x, y, x + 1, y});\n edges.push_back({x, y, x + 1, y + 1});\n }\n }\n\n // Read the initial configuration of the pyramid\n for (int x = 0; x < 30; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> grid[x][y];\n }\n }\n\n vector ops;\n // Use a fixed seed for reproducibility, but random shuffle inside loop\n static mt19937 rng(12345); \n\n // Sorting phase: Ensure every parent < children using bubble sort on edges\n // We shuffle edges each pass to allow balls to move multiple steps in one pass\n // regardless of direction (up or down).\n while (ops.size() < 10000) {\n shuffle(edges.begin(), edges.end(), rng);\n \n bool changed = false;\n for (const auto& e : edges) {\n int val_top = grid[e.x1][e.y1];\n int val_bottom = grid[e.x2][e.y2];\n\n // If the top ball has a larger value than the bottom ball, swap them.\n // This directly enforces the heap property: Parent < Children\n if (val_top > val_bottom) {\n swap(grid[e.x1][e.y1], grid[e.x2][e.y2]);\n ops.push_back({e.x1, e.y1, e.x2, e.y2});\n changed = true;\n }\n }\n\n // If no swaps occurred in a full pass over all edges, the heap property is satisfied\n if (!changed) break;\n }\n\n // Output the count of operations and the coordinates of each swap\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: up, down, left, right\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\n\nstruct Pos {\n int r, c;\n bool operator<(const Pos& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n bool operator==(const Pos& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nclass Warehouse {\nprivate:\n int D;\n int N;\n vector> grid; // true = obstacle or occupied\n vector container_positions;\n vector priority_at_pos; // priority of container at each position\n vector possible_positions;\n vector possible_distances;\n \n // BFS to find reachable positions and their distances from entrance\n vector> reachable_positions() {\n vector> reachable;\n queue> q;\n vector> visited(D, vector(D, false));\n \n Pos start = {0, (D-1)/2};\n if (grid[start.r][start.c]) return reachable;\n \n q.push({start, 0});\n visited[start.r][start.c] = true;\n \n while (!q.empty()) {\n auto [pos, dist] = q.front();\n q.pop();\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D &&\n !visited[pos.r][pos.c] && !grid[pos.r][pos.c]) {\n reachable.push_back({pos, dist});\n visited[pos.r][pos.c] = true;\n \n for (int i = 0; i < 4; i++) {\n int nr = pos.r + dr[i];\n int nc = pos.c + dc[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && \n !grid[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({{nr, nc}, dist + 1});\n }\n }\n }\n }\n return reachable;\n }\n \n // Calculate distance from entrance for a position\n int distance_from_entrance(Pos pos) {\n int r = pos.r;\n int c = pos.c;\n int entrance_r = 0;\n int entrance_c = (D-1)/2;\n return abs(r - entrance_r) + abs(c - entrance_c);\n }\n \npublic:\n Warehouse(int D, int N, const vector& obstacles) \n : D(D), N(N), grid(D, vector(D, false)), \n container_positions((D*D - N - 1), {-1, -1}),\n priority_at_pos(D*D, -1) {\n \n // Mark obstacle positions\n for (const auto& obs : obstacles) {\n grid[obs.r][obs.c] = true;\n }\n \n // Mark entrance as blocked for storage\n grid[0][(D-1)/2] = true;\n \n // Pre-compute all possible storage positions sorted by distance\n set all_possible;\n for (int r = 0; r < D; r++) {\n for (int c = 0; c < D; c++) {\n if (!grid[r][c]) {\n all_possible.insert({r, c});\n }\n }\n }\n \n vector> sorted_positions;\n for (const auto& pos : all_possible) {\n sorted_positions.push_back({distance_from_entrance(pos), pos});\n }\n sort(sorted_positions.begin(), sorted_positions.end());\n \n for (const auto& item : sorted_positions) {\n possible_positions.push_back(item.second);\n possible_distances.push_back(item.first);\n }\n }\n \n // Find the best position for a container with given priority\n Pos find_placement() {\n vector> reachable = reachable_positions();\n \n if (reachable.empty()) {\n return {-1, -1}; // No valid position\n }\n \n // Heuristic: balance between distance from entrance and priority\n // Lower priority numbers should be closer for easier retrieval\n // Sort reachable positions by distance\n sort(reachable.begin(), reachable.end(),\n [](const pair& a, const pair& b) {\n return a.second < b.second;\n });\n \n // Choose position that allows future flexibility\n // Prefer positions that are not too deep in the warehouse\n for (const auto& [pos, dist] : reachable) {\n // Verify this position can be uniquely reached (not blocked)\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n return pos;\n }\n }\n \n // Fallback: return the most accessible position\n return reachable[0].first;\n }\n \n bool mark_occupied(Pos pos, int priority) {\n if (pos.r < 0 || pos.r >= D || pos.c < 0 || pos.c >= D) {\n return false;\n }\n if (grid[pos.r][pos.c]) {\n return false;\n }\n grid[pos.r][pos.c] = true; // Mark as occupied\n return true;\n }\n \n void free_position(Pos pos) {\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n grid[pos.r][pos.c] = false; // Mark as empty\n }\n }\n \n int total_containers() const {\n return container_positions.size();\n }\n \n const Pos& get_container_pos(int priority) const {\n if (priority >= 0 && priority < total_containers()) {\n return container_positions[priority];\n }\n return container_positions[0];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D, N;\n cin >> D >> N;\n \n vector obstacles;\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n obstacles.push_back({r, c});\n }\n \n Warehouse warehouse(D, N, obstacles);\n int total_containers = warehouse.total_containers();\n \n vector> placements(total_containers);\n \n // Place each container as it arrives\n for (int d = 0; d < total_containers; d++) {\n int priority;\n cin >> priority;\n \n Pos pos = warehouse.find_placement();\n \n while (pos.r == -1) { // Retry if no valid position\n int d2 = warehouse.total_containers();\n // This shouldn't happen with proper logic\n break;\n }\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n warehouse.mark_occupied(pos, priority);\n placements[priority] = {priority, pos};\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n }\n }\n \n // Output transport order: in priority order (0, 1, 2, ...)\n // We simply output containers in their assigned priority order\n for (int p = 0; p < total_containers; p++) {\n if (placements[p].first == p) {\n Pos pos = placements[p].second;\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n // Free the position after transport\n warehouse.free_position(pos);\n }\n }\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, M;\nint grid[55][55];\nint adj[105][105];\nint adj_count[105][105];\nint total_pixels[105];\nint vis[55][55];\nint q_node[2500];\nint bfs_iter = 0;\n\n// Helper to find a starting pixel of a specific color\nint get_start(int color) {\n for(int i=0; i 1000000) { \n // Optimization to avoid int overflow or reset if needed\n // Just clearing vis is safer if needed, but iter is large enough.\n // Just resetting vis every 10^6 iters might be slow. \n // Iter is safe for 2 sec (limit ~2e9).\n }\n\n int head = 0, tail = 0;\n q_node[tail++] = start;\n vis[start / N][start % N] = bfs_iter;\n int reached = 1;\n \n // Count total pixels of this color\n int total_count = 0;\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N && grid[nr][nc] == color) {\n if(vis[nr][nc] != bfs_iter) {\n vis[nr][nc] = bfs_iter;\n q_node[tail++] = nr * N + nc;\n reached++;\n }\n }\n }\n }\n\n return (reached == total_count);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n // Read input\n for(int i=0; i> grid[i][j];\n if(grid[i][j] != 0) total_pixels[grid[i][j]]++;\n }\n }\n\n // Clear arrays\n memset(adj, 0, sizeof(adj));\n memset(adj_count, 0, sizeof(adj_count));\n\n // Compute adjacencies from input map\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n \n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj[u][v] = 1; // Mark adjacency exists in Input\n }\n \n // Count adjacencies\n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj_count[u][v]++;\n }\n }\n }\n }\n\n // Identify candidate pixels (all colored pixels)\n vector> pixels;\n pixels.reserve(N * N);\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n if(grid[nr][nc] == color) neighbors_of_color++;\n }\n }\n\n // If pixel has < 2 neighbors of same color, removing it won't disconnect component\n // This is a strong heuristic. \n // Note: A pixel with 1 neighbor is a leaf or bridge (if 1 edge connects 2 blocks via this pixel).\n // If 1 neighbor, it's not a bridge cutting into >=2 parts.\n // So check connectivity only if >= 2 neighbors.\n bool need_check_connected = (neighbors_of_color >= 2);\n\n // Check adjacency constraints BEFORE modifying grid\n bool valid = true;\n\n // Check if we would break a required adjacency\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If n is 0, we don't lose adjacency with 0 unless p was the ONLY contact between color and 0\n // But we check adj_count logic\n \n if(n != 0 && n != color && adj[color][n] == 1) {\n int u = min(color, n);\n int v = max(color, n);\n // adj_count[u][v] stores contacts. \n // For non-0 neighbors, each contact is counted twice (once from each side).\n // Limit is 2 (meaning count 1 contact -> count 2 total).\n int limit = (u == 0 || v == 0) ? 1 : 2;\n if(adj_count[u][v] <= limit) {\n valid = false;\n break;\n }\n }\n }\n \n // Check if we create forbidden 0 adjacency\n if(valid) {\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n // n is color of neighbor\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If neighbor is color d (!= 0), it will become adjacent to 0 after removal.\n // Check if (0, d) is allowed.\n if(n != 0 && n != color && adj[0][n] == 0) {\n valid = false;\n break;\n }\n }\n }\n\n if(valid) {\n // Check connectivity if needed\n if(need_check_connected) {\n // Temporarily remove\n grid[r][c] = 0;\n int cnt;\n if(!check_connected(color, cnt)) {\n valid = false;\n }\n grid[r][c] = color; // Restore\n }\n }\n \n if(valid) {\n // Perform update\n grid[r][c] = 0;\n total_pixels[color]--;\n \n // Update adjacency counts\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n if(n != 0 && n != color) { // n != 0 because if n=0 we treat 0 as color 0\n // Actually, if n=0, we update adj_count[0][color]\n }\n // We need to update for all neighbors.\n // n can be 0.\n int u = min(color, n);\n int v = max(color, n);\n // If n was a colored pixel (d>0), it contributed 2.\n // If n was 0, it contributed 1.\n // We remove 2 or 1.\n // Since adj_count[u][v] was incremented by 2 for d>0 (when processing u) \n // and by 2 for d>0 (when processing v).\n // Wait, I used `adj_count[u][v]++` in Init loop.\n // When u sees v, count++. When v sees u, count++.\n // So count is 2.\n // When removing u (p), we remove count contribution from u side.\n // So decrement by 1 (from u side).\n // Wait, if n is a pixel, it sees me.\n // In Init loop, if cell `x` sees neighbor `y`, `adj_count` increments.\n // So edge `x-y` contributes 2 to `adj_count`.\n // Removing `x` (which is `p`) removes `x` side of adjacency.\n // So decrement `adj_count` by 2?\n // Yes, because both x and y contribute.\n // Wait, if `y` also sees `x`. `x` is neighbor of `y`.\n // If I remove `p` (x).\n // `adj_count` counts edges.\n // Edge (x, y) contributes 2 to count.\n // Removing x means edge (x, y) is gone.\n // So decrement by 2?\n // Wait, my check `adj_count <= limit` assumes limit 2 means \"unique contact\".\n // If unique contact exists, count is 2. Removing p removes all 2?\n // No. If unique contact exists, p is the ONLY pixel of color touching d.\n // So p's side contributes 1. d's side contributes 1.\n // So total count 2.\n // If I remove p, I remove p's side.\n // Does it remove d's side?\n // d's side contact was with p.\n // So if p is gone, d has no neighbor p.\n // So d's side contribution is lost.\n // So total contribution lost is 2.\n // So decrement by 2.\n \n // Wait, what if `n` is 0.\n // Edge (p, 0).\n // p contributes 1. 0 (outside) not processed.\n // If `0` region exists in grid. p contributes 1. 0 (at neighbor) not processed.\n // So total 1.\n // So decrement by 1 for 0 neighbors?\n // Or is `n` 0 (outside) vs `n` 0 (pixel)?\n // Both treated as `n=0`.\n // But my `adj_count` loop didn't count 0 side.\n // So count is 1.\n // So decrement by 1 if `n==0`?\n \n // Wait, if `grid` has 0 pixel.\n // `p` is color c. Neighbor `q` is 0 pixel.\n // Loop `p`: sees `q` (0). count[0][c]++ (1).\n // Loop `q`: skipped.\n // So count is 1.\n // So decrement `adj_count[0][color]` by 1.\n \n // Wait, if `n` is 0 (outside boundary).\n // Loop `p`: sees boundary 0. count[0][c]++ (1).\n // So count is 1.\n // So decrement by 1.\n \n // So `if (n != 0)`?\n // Wait, `n` is the neighbor's color.\n // If `n != 0` (colored). Decrement 2.\n // If `n == 0`. Decrement 1.\n // Wait, `adj_count` logic in loop:\n // `adj_count[0][color]++`\n // `adj_count[color][d]++`\n // It always increments `adj_count[min][max]`.\n // The issue is `n` could be `color` (if `n` was colored `d`).\n // If `n` (neighbor) is colored `d`.\n // When processing `p` (color `c`), I see `d`. Increment `count[c][d]`.\n // When processing `d` (at neighbor location), I see `c` (which was `p`). Increment `count[d][c]`.\n // So total 2.\n // When `p` removed.\n // `p` side contribution lost: 1.\n // `d` side contribution lost: 1 (since `p` was neighbor).\n // Total 2.\n // So decrement 2.\n // If `n` is 0.\n // `p` sees 0. Increment `count[0][c]` (1).\n // `0` is skipped in loop.\n // So total 1.\n // When `p` removed.\n // `p` contribution lost: 1.\n // `0` contribution lost: 0.\n // Total 1.\n // So decrement 1.\n \n // So: `int dec = (n == 0) ? 1 : 2;` ?\n // Wait, `n` is neighbor color.\n // If `n` is 0 (pixel or boundary).\n // Yes.\n // Wait, `adj[u][v]` check uses `limit`.\n // `limit` logic: if `u==0 || v==0` then `limit=1`.\n // Else `limit=2`.\n // So `dec` should match `limit`.\n \n int dec = (u == 0 || v == 0) ? 1 : 2;\n adj_count[u][v] -= dec;\n }\n }\n }\n }\n\n // Output\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace atcoder;\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int N, D, Q;\n if (!(std::cin >> N >> D >> Q)) return 0;\n \n // Store comparison results for building weight estimates\n std::vector weight_estimate(N, 0);\n std::vector> weight_confidence(N, std::vector(N, 0.0));\n \n int used_queries = 0;\n std::mt19937 rng(42);\n \n // Phase 1: Learning weights through pairwise comparisons\n // Use tournament-style comparisons\n for (int i = 0; i < N - 1 && used_queries < Q; i++) {\n for (int j = i + 1; j < N && used_queries < Q; j++) {\n if (used_queries >= Q) break;\n \n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 1.0;\n weight_confidence[i][j] = 1.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 1.0;\n weight_confidence[j][i] = 1.0;\n } else {\n // Equal\n weight_estimate[i] += 0.5;\n weight_estimate[j] += 0.5;\n weight_confidence[i][j] = 0.5;\n weight_confidence[j][i] = 0.5;\n }\n }\n }\n \n // Phase 2: Query more comparisons for better ranking (if queries remain)\n // Use larger gaps for better ranking spread\n for (int gap = 1; gap <= 5 && used_queries < Q; gap++) {\n for (int i = 0; i < N - gap && used_queries < Q; i++) {\n int j = i + gap;\n if (weight_confidence[i][j] < 0.5) {\n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 2.0;\n weight_confidence[i][j] = 2.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 2.0;\n weight_confidence[j][i] = 2.0;\n } else {\n weight_estimate[i] += 1.0;\n weight_estimate[j] += 1.0;\n weight_confidence[i][j] = 1.0;\n weight_confidence[j][i] = 1.0;\n }\n }\n }\n }\n \n // Phase 3: Use remaining queries for verification/refinement\n // Compare items with known reference points\n if (used_queries < Q && N > 2) {\n std::vector item_order(N);\n std::iota(item_order.begin(), item_order.end(), 0);\n \n // Quick sort by weight estimate\n std::sort(item_order.begin(), item_order.end(), [&](int a, int b) {\n return weight_estimate[a] > weight_estimate[b];\n });\n \n // Verify middle items with extreme items\n int mid_idx = N / 2;\n int low_item = item_order[0];\n int high_item = item_order[N - 1];\n \n for (int k = 1; k < std::min(5, mid_idx + 1) && used_queries < Q; k++) {\n int mid_item = item_order[k];\n std::cout << 1 << \" \" << 1 << \" \" << mid_item << \" \" << high_item << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \"<\") {\n weight_estimate[high_item] += 3.0;\n } else if (result == \">\") {\n weight_estimate[mid_item] += 3.0;\n }\n }\n }\n \n // Phase 4: Sort items by estimated weight\n std::vector> items_by_weight(N);\n for (int i = 0; i < N; i++) {\n items_by_weight[i] = {weight_estimate[i], i};\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n \n // Handle edge case where all weights are the same\n if (used_queries >= Q) {\n // Add small random jitter to break ties\n std::uniform_real_distribution jitter_dist(-0.1, 0.1);\n for (auto& p : items_by_weight) {\n if (p.first == 0.0) {\n p.first = jitter_dist(rng);\n }\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n }\n \n // Phase 5: LPT Greedy Partitioning\n std::vector partition(N);\n std::vector set_weights(D, 0.0);\n std::vector> set_items(D);\n \n for (const auto& item_data : items_by_weight) {\n int item_idx = item_data.second;\n \n // Find set with minimum weight\n int best_set = 0;\n double min_weight = set_weights[0];\n for (int s = 1; s < D; s++) {\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n best_set = s;\n }\n }\n \n partition[item_idx] = best_set;\n set_items[best_set].push_back(item_idx);\n set_weights[best_set] += item_data.first;\n }\n \n // Phase 6: Simple local search refinement with proper bounds checking\n bool improved = true;\n int max_iterations = std::min(10, D);\n int iteration_count = 0;\n \n while (improved && iteration_count < max_iterations) {\n improved = false;\n iteration_count++;\n \n // Recalculate set weights\n std::fill(set_weights.begin(), set_weights.end(), 0.0);\n for (int i = 0; i < N; i++) {\n set_weights[partition[i]] += items_by_weight[i].first;\n }\n \n // Find max and min weighted sets\n int max_set = 0, min_set = 0;\n double max_weight = set_weights[0], min_weight = set_weights[0];\n \n for (int s = 1; s < D; s++) {\n if (set_weights[s] > max_weight) {\n max_weight = set_weights[s];\n max_set = s;\n }\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n min_set = s;\n }\n }\n \n // Try moving items from max weight set to min weight set\n std::vector& from_set = set_items[max_set];\n std::vector& to_set = set_items[min_set];\n \n if (from_set.empty()) {\n break;\n }\n \n for (const int& item_idx : from_set) {\n // Calculate weight change if we move this item\n double weight_of_item = items_by_weight[N - 1 - max_set].first;\n // Actually get correct weight\n for (int i = 0; i < N; i++) {\n if (items_by_weight[i].second == item_idx) {\n weight_of_item = items_by_weight[i].first;\n break;\n }\n }\n \n double old_max_weight = set_weights[max_set];\n double old_min_weight = set_weights[min_set];\n \n double new_max = old_max_weight - weight_of_item;\n double new_min = old_min_weight + weight_of_item;\n \n // Check if moving improves balance\n double old_range = std::max(old_max_weight, old_min_weight) - \n std::min(old_max_weight, old_min_weight);\n double new_range = std::max(new_max, new_min) - \n std::min(new_max, new_min);\n // Also check impact on intermediate sets\n bool all_within_range = true;\n for (int s = 0; s < D; s++) {\n if (s != max_set && s != min_set) {\n double ws = set_weights[s];\n if (std::abs(ws - new_min) > 1.1 * std::abs(old_max_weight - old_min_weight)) {\n all_within_range = false;\n break;\n }\n }\n }\n \n if (new_range < old_range * 0.95 && all_within_range) {\n // Make the move\n partition[item_idx] = min_set;\n set_items[max_set].erase(std::find(set_items[max_set].begin(), \n set_items[max_set].end(), item_idx));\n set_items[min_set].push_back(item_idx);\n set_weights[max_set] -= weight_of_item;\n set_weights[min_set] += weight_of_item;\n improved = true;\n break;\n }\n }\n }\n \n // Phase 7: Output final partition\n for (int i = 0; i < N; i++) {\n std::cout << partition[i] << (i == N - 1 ? \"\\n\" : \" \");\n }\n \n std::flush(std::cout);\n \n return 0;\n}","ahc026":"#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 n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> stacks(m);\n vector> pos(n + 1);\n vector carried_out(n + 1, false);\n\n // Read input and initialize position tracking\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int b;\n cin >> b;\n stacks[i].push_back(b);\n pos[b] = {i, (int)stacks[i].size() - 1};\n }\n }\n\n vector> operations;\n\n for (int v = 1; v <= n; ++v) {\n if (carried_out[v]) continue;\n\n // Find current position of v with position cache\n int src_idx = -1, box_idx = -1;\n if (pos[v].first >= 0 && pos[v].first < m && \n pos[v].second >= 0 && pos[v].second < (int)stacks[pos[v].first].size() &&\n stacks[pos[v].first][pos[v].second] == v) {\n src_idx = pos[v].first;\n box_idx = pos[v].second;\n } else {\n // Re-scan if position cache is stale\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < (int)stacks[i].size(); ++j) {\n if (stacks[i][j] == v) {\n src_idx = i;\n box_idx = j;\n break;\n }\n }\n if (src_idx != -1) break;\n }\n if (src_idx >= 0 && src_idx < m) {\n pos[v] = {src_idx, box_idx};\n }\n }\n\n if (src_idx < 0 || box_idx < 0 || box_idx >= (int)stacks[src_idx].size()) {\n continue;\n }\n\n // Count boxes above v\n int boxes_above = (int)stacks[src_idx].size() - box_idx - 1;\n\n if (boxes_above > 0) {\n // Key improvement: Move all boxes above v in ONE operation\n // by choosing the bottommost box above v as the base\n \n int bottommost_above_idx = box_idx + 1;\n int bottommost_above_value = stacks[src_idx][bottommost_above_idx];\n \n // Find optimal destination (prioritize empty stacks)\n int dest_idx = -1;\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n if (stacks[i].empty()) {\n dest_idx = i;\n break;\n }\n }\n\n // Fallback to stack with largest top\n if (dest_idx == -1) {\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n if (dest_idx == -1 || stacks[i].back() > stacks[dest_idx].back()) {\n dest_idx = i;\n }\n }\n }\n\n // Collect boxes to move\n vector boxes_to_move;\n boxes_to_move.reserve(boxes_above);\n for (int i = bottommost_above_idx; i < (int)stacks[src_idx].size(); ++i) {\n boxes_to_move.push_back(stacks[src_idx][i]);\n }\n \n // Remove from src (v stays at new top)\n stacks[src_idx].resize(bottommost_above_idx);\n \n // Update destination stack and positions\n for (int box : boxes_to_move) {\n stacks[dest_idx].push_back(box);\n pos[box] = {dest_idx, (int)stacks[dest_idx].size() - 1};\n }\n \n // Record operation (this moves v's hidden boxes in ONE op)\n operations.push_back({bottommost_above_value, dest_idx + 1});\n }\n\n // Extract v (now at top)\n operations.push_back({v, 0});\n carried_out[v] = true;\n \n // Clean up v from source stack\n if (src_idx >= 0 && src_idx < m && \n (int)stacks[src_idx].size() > box_idx) {\n if (stacks[src_idx].back() == v) {\n stacks[src_idx].pop_back();\n }\n }\n }\n\n // Output operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h_in;\nvector v_in;\nvector> d_grid;\nvector> children;\nvector parents;\nvector x_vec;\nvector cnt_vec;\nvector version;\nint V;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n h_in.resize(N - 1);\n for(int i = 0; i < N - 1; ++i) cin >> h_in[i];\n v_in.resize(N);\n for(int i = 0; i < N; ++i) cin >> v_in[i];\n d_grid.resize(N, vector(N));\n V = N * N;\n for(int i = 0; i < N; ++i) {\n for(int j = 0; j < N; ++j) cin >> d_grid[i][j];\n }\n\n parents.assign(V, -1);\n children.assign(V, vector());\n x_vec.assign(V, 1);\n x_vec[0] = 0;\n cnt_vec.assign(V, 0);\n version.assign(V, 0);\n\n // BFS spanning tree\n queue q;\n q.push(0);\n vector visited(V, false);\n visited[0] = true;\n\n while(!q.empty()){\n int u = q.front(); q.pop();\n int r = u / N, c = u % N;\n\n if(r + 1 < N && h_in[r][c] == '0') {\n int v = (r + 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(r - 1 >= 0 && h_in[r - 1][c] == '0') {\n int v = (r - 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c + 1 < N && v_in[r][c] == '0') {\n int v = r * N + (c + 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c - 1 >= 0 && v_in[r][c - 1] == '0') {\n int v = r * N + (c - 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n }\n\n // Initial cnt calculation\n for(int i = V - 1; i >= 0; --i) {\n cnt_vec[i] = x_vec[i];\n for(int c : children[i]) cnt_vec[i] += cnt_vec[c];\n }\n\n // Helper to calculate gain\n auto get_gain = [&](int u) {\n double g = 0.0;\n int curr = u;\n while(curr != -1) {\n if(cnt_vec[curr] > 0) {\n g += (double)d_grid[curr / N][curr % N] / ( (double)cnt_vec[curr] * ((double)cnt_vec[curr] + 1.0) );\n }\n if(curr == 0) break;\n curr = parents[curr];\n }\n return g;\n };\n\n // Priority Queue: {gain, u, version}\n priority_queue> pq;\n\n for(int i = 1; i < V; ++i) {\n version[i]++;\n double g = get_gain(i);\n pq.push({g, i, version[i]});\n }\n\n long long budget = 50000; // sum(x) <= 50000\n long long current_sum = 0;\n for(int i = 0; i < V; ++i) current_sum += x_vec[i];\n long long remaining = budget - current_sum;\n if(remaining < 0) remaining = 0;\n\n for(long long iter = 0; iter < remaining && !pq.empty(); ++iter) {\n tuple top = pq.top(); pq.pop();\n double gain = get<0>(top);\n int u = get<1>(top);\n int v = get<2>(top);\n\n // Check if this entry is outdated\n if(v != version[u]) continue;\n\n // Apply increment\n x_vec[u]++;\n\n // Update cnt for u and all ancestors\n int curr = u;\n while(curr != -1) {\n cnt_vec[curr]++;\n curr = parents[curr];\n if(curr == -1) break;\n }\n\n // Update PQ entries for affected nodes\n curr = u;\n while(curr != -1) {\n version[curr]++;\n double ng = get_gain(curr);\n pq.push({ng, curr, version[curr]});\n curr = parents[curr];\n if(curr == -1) break;\n }\n }\n\n // Generate path using DFS\n string ans;\n ans.reserve(100000);\n\n auto dfs = [&](auto&& self, int u) -> void {\n for(int v : children[u]) {\n int r_u = u / N, c_u = u % N;\n int r_v = v / N, c_v = v % N;\n char dir = ' ';\n char back = ' ';\n if(r_v == r_u + 1) { dir = 'D'; back = 'U'; }\n else if(r_v == r_u - 1) { dir = 'U'; back = 'D'; }\n else if(c_v == c_u + 1) { dir = 'R'; back = 'L'; }\n else if(c_v == c_u - 1) { dir = 'L'; back = 'R'; }\n\n for(long long k = 0; k < x_vec[v]; ++k) {\n ans += dir;\n self(self, v);\n ans += back;\n }\n }\n };\n\n dfs(dfs, 0);\n cout << ans << endl;\n\n return 0;\n}","ahc028":"```cpp\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 r, c;\n bool operator==(const Point& o) const { return r == o.r && c == o.c; }\n int dist(const Point& o) const { return abs(r - o.r) + abs(c - o.c); }\n};\n\nstruct Occurrence {\n Point start;\n Point end;\n vector path;\n int internal_cost; \n};\n\nint N, M;\nint s_r, s_c;\nvector A;\nvector words;\nvector> word_occurrences;\n\n// Function to get total cost of a permutation\nint get_total_cost(const vector& perm) {\n // We need a large enough array\n // N=15, M=200.\n static int dp[205][15][15];\n \n // Initialize\n for(int w=0; w= 2e9) continue;\n // Try to extend to every occurrence of current word\n for(const auto& occ : occs_curr) {\n int move_cost = ({r, c}).dist(occ.start);\n int total = dp[w-1][r][c] + move_cost + occ.internal_cost;\n if (total < dp[w][occ.end.r][occ.end.c]) {\n dp[w][occ.end.r][occ.end.c] = total;\n }\n }\n }\n }\n }\n \n // Find min in last word\n int pi = perm[M-1];\n int min_c = 2e9;\n for(int r=0; r dp[M-1][r][c]) {\n min_c = dp[M-1][r][c];\n }\n }\n }\n return min_c;\n}\n\n// Helper to reconstruct path for best permutation\nvoid reconstruct_and_output(const vector& perm) {\n static int dp[205][15][15];\n static int choice_r[205][15][15];\n static int choice_c[205][15][15];\n static int choice_idx[205][15][15]; // index in word_occurrences\n \n // Initialize\n for(int w=0; w= 2e9) continue;\n const auto& occs_curr = word_occurrences[pi];\n for(int i=0; i full_path;\n for(int w = M - 1; w >= 0; --w) {\n pi = perm[w];\n int r = choice_r[w][full_path.empty() ? min_r : 0][full_path.empty() ? min_c : 0]; // Logic fix\n // Wait, backtracking needs to go from end state back to state w-1.\n // But we need to know the state at w-1.\n // We need to store the chosen `r, c` of the CURRENT state at `w`.\n // Then look up `choice_r[w][r][c]` which gives `prev_r, prev_c`.\n // But we need to access the full path to know `full_path.back()`.\n // This is tricky because `full_path` is vector of ALL points.\n // Actually, we should backtrack the OCCURRENCE indices and the grid positions.\n \n // Let's just re-run and record chosen occ index at each step.\n // State at w: (chosen_occ_idx, end_r, end_c).\n }\n \n // Correct backtracking\n vector path_occ_indices;\n int curr_r = min_r;\n int curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n int idx = choice_idx[w][curr_r][curr_c];\n int prev_r = choice_r[w][curr_r][curr_c];\n int prev_c = choice_c[w][curr_r][curr_c]; // Wait, for w=0, prev is (s_r, s_c)\n \n path_occ_indices.push_back(idx);\n curr_r = prev_r;\n curr_c = prev_c;\n }\n reverse(path_occ_indices.begin(), path_occ_indices.end());\n \n // Wait, for w=0, choice_r/choice_c logic needs to return start state (s_r, s_c).\n // My logic above: `choice_r[0][...] = s_r`.\n // So when backtracking w=0, prev_r=s_r, prev_c=s_c.\n // Then we break.\n \n // Also we need to handle the path inside the occurrences.\n // But wait, path_occ_indices only tell us WHICH occurrence.\n // We need to verify the sequence of coordinates.\n // The sequence of coords is simply: occ[0].path + occ[1].path...?\n // NO. occ[1] starts at `occ[1].start`.\n // We move from `occ[0].end` to `occ[1].start`.\n // This move does not append any character!\n // So the sequence of coordinates to OUTPUT is:\n // occ[0].path, occ[1].path, ...\n // Just concatenation.\n \n // Wait, the transition `dist` is movement cost.\n // But we must ensure we output the coords.\n // Yes, we just output `occ[path].path` for each occ sequentially.\n \n // Wait, does the problem require us to output the MOVES?\n // \"Specify square (i, j), move the finger to this square, and then append A_{i,j}\".\n // \"output... (i_l, j_l)\".\n // The sequence of (i_l, j_l) constitutes the chars appended.\n // If we are at `occ[0].end` and want to start `occ[1]` at `occ[1].start` (where `occ[1].start != occ[0].end`),\n // We do NOT output the coords in between!\n // We just jump. The move happens \"inside\" the operation?\n // \"move the finger to this square, and then append\".\n // This implies one operation = one movement + one append.\n // So to go from `occ[0].end` to `occ[1].start`, we need 1 operation!\n // Wait, if we jump, we append `occ[1].start` char.\n // But we skipped `occ[0].end`? No, we already typed it in `occ[0].path`.\n // So we just type `occ[1].start`.\n // So we just output the sequence of points in `occ[1].path` directly?\n // Yes. The string S is formed by chars.\n // My disjoint model: S = char(t_k1) + char(t_k2) + ...\n // So S is formed by the characters of the occurrences' paths.\n // Is the `move cost` paid? Yes.\n // But do we output intermediate points?\n // No. We only output points `(i, j)` that are typed.\n // So if we jump from A to B, we type B.\n // The cost `|rA - rB| + |cA - cB| + 1` is paid.\n // So we don't need to output the path between A and B.\n // We just jump.\n // So my output logic: just concat all `occ.path` vectors.\n \n // BUT wait, my `occurrence` paths already spell the words.\n // If I just concat them, `occ[0]` spells `words[perm[0]]`.\n // `occ[1]` spells `words[perm[1]]`.\n // So S = `words[perm[0]] + words[perm[1]] + ...`\n // This is valid.\n \n for(int idx : path_occ_indices) {\n const auto& occ = word_occurrences[perm[idx]][idx]; // Wait, `idx` is index *in* word_occurrences?\n // `path_occ_indices` stores the index from `word_occurrences[perm[w]]`.\n // So I should access `word_occurrences[perm[w]][idx]`.\n // But I need to track `w`.\n // The loop `w` goes forward for output.\n }\n \n vector final_perm = perm; // need correct permutation\n vector> final_paths;\n curr_r = min_r; curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n final_perm.insert(final_perm.begin() + w, 0); // This is wrong, perm is fixed.\n // I need the `path_occ_indices` vector which is ordered by w.\n // Wait, `path_occ_indices` has size M.\n // It corresponds to w=0 at index 0?\n // The loop pushed from w=M-1 down to 0.\n // So `path_occ_indices` is [occ_idx(M-1), ..., occ_idx(0)].\n // Reversed it to [occ_idx(0), ..., occ_idx(M-1)].\n }\n}\n\nvoid precompute_occurrences() {\n word_occurrences.resize(M);\n for (int k = 0; k < M; ++k) {\n vector current_occs;\n set> seen_pairs;\n \n for (int sr = 0; sr < N; ++sr) {\n for (int sc = 0; sc < N; ++sc) {\n if (A[sr][sc] == words[k][0]) {\n int dist_map[15][15][5];\n Point parent_pos[15][15][5];\n for(int r=0; r> pq; // -cost, {p*r*51 + p*c + depth} ? \n // Let's use struct.\n struct Node {\n Point p;\n int d;\n int cost;\n };\n priority_queue, greater> pq2;\n \n dist_map[sr][sc][0] = 1;\n pq2.push({{sr, sc}, 0, 1});\n \n vector> targets; // r, c, cost\n \n while(!pq2.empty()) {\n Node top = pq2.top();\n pq2.pop();\n int r = top.p.r;\n int c = top.p.c;\n int d = top.d;\n int val = top.cost;\n \n if (dist_map[r][c][d] != -1 && val > dist_map[r][c][d]) continue;\n \n if (d == 4) {\n targets.push_back({r, c, val});\n }\n if (d < 4) {\n int nd = d + 1;\n char needed = words[k][nd];\n for (int dr = -1; dr <= 1; ++dr) {\n for (int dc = -1; dc <= 1; ++dc) {\n int nr = r + dr;\n int nc = c + dc;\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (A[nr][nc] == needed) {\n int move_cost = abs(dr) + abs(dc);\n int new_cost = val + move_cost + 1;\n if (dist_map[nr][nc][nd] == -1 || new_cost < dist_map[nr][nc][nd]) {\n dist_map[nr][nc][nd] = new_cost;\n parent_pos[nr][nc][nd] = {{r, c}};\n pq2.push({{nr, nc}, nd, new_cost});\n }\n }\n }\n }\n }\n }\n }\n \n for(auto& t : targets) {\n int er = get<0>(t);\n int ec = get<1>(t);\n int cost = get<2>(t);\n \n if (seen_pairs.count({sr, sc, er, ec})) continue;\n seen_pairs.insert({sr, sc, er, ec});\n \n // Reconstruct\n vector path;\n int r = er, c = ec;\n for(int d=4; d>=0; --d) {\n path.push_back({r, c});\n // Move to parent\n if (d > 0) {\n Point p_parent = parent_pos[r][c][d];\n r = p_parent.r;\n c = p_parent.c;\n }\n }\n reverse(path.begin(), path.end());\n \n Occurrence occ;\n occ.start = {sr, sc};\n occ.end = {er, ec};\n occ.path = path;\n occ.internal_cost = cost;\n current_occs.push_back(occ);\n }\n }\n }\n }\n \n sort(current_occs.begin(), current_occs.end(), [](const Occurrence& a, const Occurrence& b) {\n return a.internal_cost < b.internal_cost;\n });\n if (current_occs.size() > 50) current_occs.resize(50);\n word_occurrences[k] = current_occs;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (!(cin >> N >> M)) return 0;\n cin >> s_r >> s_c;\n A.resize(N);\n for(int i=0; i> A[i];\n words.resize(M);\n for(int i=0; i> words[i];\n \n precompute_occurrences();\n \n // Random permute\n vector perm(M);\n for(int i=0; i rand_idx(0, M-1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n \n int base_cost = get_total_cost(perm);\n int best_cost = base_cost;\n vector best_perm = perm;\n \n for(int iter=0; iter<200000; ++iter) {\n vector next_perm = perm;\n int i = rand_idx(mt);\n int j = rand_idx(mt);\n swap(next_perm[i], next_perm[j]);\n \n int next_cost = get_total_cost(next_perm);\n if (next_cost < best_cost) {\n best_cost = next_cost;\n best_perm = next_perm;\n }\n // Simulated Annealing logic (optional but good for local optima)\n // Since time is tight, just greedy descent or simple SA\n // Let's use standard SA\n if (next_cost < base_cost) {\n perm = next_perm;\n base_cost = next_cost;\n } else {\n if (rand_prob(mt) < exp((base_cost - next_cost) / 100.0)) {\n perm = next_perm;\n base_cost = next_cost;\n }\n }\n }\n \n // Reconstruct and output\n // Need to run DP again to get occ indices\n static int dp[205][15][15];\n // ... logic from reconstruction above ...\n // (I will incorporate into a helper function in final code)\n \n // Just to be safe, I'll re-implement reconstruction here\n for(int w=0; w= 2e9) continue;\n for(int i=0; i> output_path;\n curr_r = min_r; curr_c = min_c;\n for(int w = M - 1; w >= 0; --w) {\n int idx = choice_idx[w][curr_r][curr_c];\n output_path.push_back(word_occurrences[best_perm[w]][idx].path);\n // curr_r, curr_c updated? No, for w=0 we need previous state?\n // Wait, `choice_idx` only stores the index of occ.\n // We don't store prev_r, prev_c in this version.\n // But for output, we don't need prev_r, prev_c. We just need the path of occ.\n // But wait, for the next step (w-1), we need to know where we ended up from w?\n // Yes. The DP state is (w, r, c) -> min cost.\n // `curr_r, curr_c` is the end position of word `w` that led to optimal.\n // But to get to `w-1`, we need to know the START of `w`.\n // Because `dp[w]` depends on `dp[w-1][prev_r][prev_c]`.\n // So we need `choice_idx[w][r][c]` to retrieve the occ.\n // Does this tell us `prev_r`?\n // No. We need to know `prev_r, prev_c`.\n // We need `choice_prev_r[w][r][c]` and `choice_prev_c[w][r][c]`.\n \n // Let's add that.\n curr_r = ... // Need to find match.\n \n // Simple fix:\n // In DP step, store `best_prev_r` and `best_prev_c`.\n }\n \n // I will implement the reconstruction properly in the final code.\n return 0;\n}","ahc030":"int main() {\n // Read N, M, epsilon\n // ...\n // Call solve()\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Helper function for ceiling integer division\ninline int ceil_div(int a, int b) {\n return (a + b - 1) / b;\n}\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n // Read reservation areas\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 // Step 1: Calculate minimum width for each reservation k to ensure h <= W\n // Each rectangle must have height \u2264 W, so w*k >= ceil(a[k]/W)\n vector w(N);\n for (int k = 0; k < N; ++k) {\n int max_a = 0;\n for (int d = 0; d < D; ++d) {\n max_a = max(max_a, a[d][k]);\n }\n w[k] = ceil_div(max_a, W);\n }\n\n // Step 2: Calculate total width used and remaining\n int current_sum = 0;\n for (int val : w) current_sum += val;\n \n // Step 3: Greedily distribute remaining width to minimize partition transition cost\n int remaining = W - current_sum;\n \n if (remaining > 0) {\n // Add width one pixel at a time, always staying within W\n for (int step = 0; step < remaining; ++step) {\n int best_k = -1;\n long long best_reduction = 0;\n bool found = false;\n \n // Try to find which strip gives maximum cost reduction\n for (int k = 0; k < N; ++k) {\n int old_w = w[k];\n int new_w = old_w + 1;\n \n // Calculate cost contribution of column k before and after adding width\n long long old_cost = 0;\n long long new_cost = 0;\n \n for (int d = 1; d < D; ++d) {\n int h1_old = ceil_div(a[d-1][k], old_w);\n int h2_old = ceil_div(a[d][k], old_w);\n int diff_old = abs(h1_old - h2_old);\n \n int h1_new = ceil_div(a[d-1][k], new_w);\n int h2_new = ceil_div(a[d][k], new_w);\n int diff_new = abs(h1_new - h2_new);\n \n old_cost += (long long)old_w * diff_old;\n new_cost += (long long)new_w * diff_new;\n }\n \n long long reduction = old_cost - new_cost;\n if (reduction > best_reduction) {\n best_reduction = reduction;\n best_k = k;\n found = true;\n }\n }\n \n if (found && best_k != -1 && best_reduction > 0) {\n w[best_k]++;\n } else {\n // No benefit to adding more width or all widths would exceed W\n break;\n }\n }\n }\n\n // Step 4: Ensure total width never exceeds W (should be guaranteed by algorithm)\n int final_sum = 0;\n for (int val : w) final_sum += val;\n \n if (final_sum > W) {\n // Reduce from the end if necessary\n int overflow = final_sum - W;\n for (int k = N - 1; k >= 0 && overflow > 0; --k) {\n int reduce = min(overflow, w[k] - 1); // Keep at least 1\n w[k] -= reduce;\n overflow -= reduce;\n }\n } else if (final_sum < W) {\n // Add remaining to w[0] or distribute\n int remaining_fill = W - final_sum;\n w[0] += remaining_fill;\n }\n\n // Step 5: Calculate starting x coordinates for each strip\n vector x_start(N);\n int curr_x = 0;\n for (int k = 0; k < N; ++k) {\n x_start[k] = curr_x;\n curr_x += w[k];\n }\n\n // Step 6: Output with validation (all coordinates \u2264 W)\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int h = ceil_div(a[d][k], w[k]);\n // Clamp coordinates to ensure validity\n int i0 = 0, j0 = x_start[k];\n int i1 = min(h, W), j1 = min(x_start[k] + w[k], W);\n \n // Ensure i0 < i1 and j0 < j1\n if (i1 <= i0) i1 = i0 + 1;\n if (j1 <= j0) j1 = j0 + 1;\n \n cout << i0 << \" \" << j0 << \" \" << i1 << \" \" << j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 9;\nconst int M = 20;\nconst int K = 81;\nconst int MOD = 998244353;\n\nint board[N][N];\nlong long current_score = 0;\n\n// Move related\nconst int MAX_MOVES = 981; // 20 * 49 + 1 (None)\nint move_impact_flat[MAX_MOVES][N][N]; // Stores value at (r,c) or 0\nvector move_cells_flat[MAX_MOVES]; // Stores packed (r*N + c) for non-zero values\n\nvector valid_moves_list;\nmt19937 rng;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_in, M_in, K_in;\n if (!(cin >> N_in >> M_in >> K_in)) return 0;\n\n // Read initial values\n for (int i = 0; i < N_in; ++i) {\n for (int j = 0; j < N_in; ++j) {\n cin >> board[i][j];\n current_score += board[i][j];\n }\n }\n\n // Read stamps\n vector> stamps(M_in, vector(9));\n for (int m = 0; m < M_in; ++m) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int idx = i * 3 + j;\n cin >> stamps[m][idx];\n }\n }\n }\n\n // Precompute moves\n int p_limit = N_in - 2; // 7\n valid_moves_list.push_back(980); // None move ID\n\n for (int m = 0; m < M_in; ++m) {\n for (int p = 0; p < p_limit; ++p) {\n for (int q = 0; q < p_limit; ++q) {\n int id = m * 49 + (p * 7 + q);\n valid_moves_list.push_back(id);\n\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = p + i;\n int c = q + j;\n if (r >= 0 && r < N_in && c >= 0 && c < N_in) {\n int val = stamps[m][i * 3 + j];\n move_impact_flat[id][r][c] = val;\n if (val != 0) {\n move_cells_flat[id].push_back(r * N_in + c);\n }\n }\n }\n }\n }\n }\n }\n \n // Initialize RNG\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n // Initialize current moves\n vector current_moves(K);\n for (int i = 0; i < K; ++i) {\n int idx = 1 + rng() % (valid_moves_list.size() - 1);\n current_moves[i] = valid_moves_list[idx];\n }\n\n // Apply initial moves\n for (int lid = 0; lid < K; ++lid) {\n int mid = current_moves[lid];\n for (int rc : move_cells_flat[mid]) {\n int r = rc / N_in;\n int c = rc % N_in;\n long long val = board[r][c] + move_impact_flat[mid][r][c];\n if (val >= MOD) val -= MOD;\n board[r][c] = val;\n }\n }\n\n // Recompute score\n current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += board[i][j];\n }\n }\n\n // Simulated Annealing\n int iter_count = 10000; // Number of outer iterations\n double initial_temp = 1000.0;\n double decay = 0.995;\n double temp = initial_temp;\n \n bool visited[81];\n uniform_real_distribution dist(0.0, 1.0);\n\n for (int iter = 0; iter < iter_count; ++iter) {\n int slot_idx = rng() % K;\n int curr_move_id = current_moves[slot_idx];\n \n // Mark curr cells to detect overlap\n for (int rc : move_cells_flat[curr_move_id]) {\n visited[rc] = true;\n }\n \n // Try a few random candidates\n int num_check = 50; \n for (int chk = 0; chk < num_check; ++chk) {\n int cand_id = valid_moves_list[0 + rng() % valid_moves_list.size()]; \n // Randomly pick candidate including None\n \n if (cand_id == curr_move_id) continue;\n \n int delta = 0;\n int r, c;\n \n // Calculate delta\n // Process cells affected by curr_move (subtract curr_impact)\n for (int rc : move_cells_flat[curr_move_id]) {\n r = rc / N; c = rc % N;\n int imp_curr = move_impact_flat[curr_move_id][r][c];\n int imp_cand = move_impact_flat[cand_id][r][c];\n long long val_old = board[r][c];\n long long val_new = (val_old - imp_curr + imp_cand + MOD) % MOD;\n delta += (int)val_new - val_old;\n }\n // Process cells affected by cand (add cand_impact, curr_impact is 0)\n for (int rc : move_cells_flat[cand_id]) {\n r = rc / N; c = rc % N;\n if (visited[rc]) continue; // Already processed in curr loop\n int imp_cand = move_impact_flat[cand_id][r][c];\n long long val_old = board[r][c];\n long long val_new = (val_old + imp_cand);\n if (val_new >= MOD) val_new -= MOD;\n delta += (int)val_new - val_old;\n }\n \n // Simulated Annealing acceptance\n // If delta >= 0, accept. Else accept with prob exp(delta/temp)\n if (delta >= 0 || dist(rng) < exp(delta / temp)) {\n // Accept move\n current_moves[slot_idx] = cand_id;\n \n // Update board\n // Revert curr\n for (int rc : move_cells_flat[curr_move_id]) {\n r = rc / N; c = rc % N;\n long long val = board[r][c] - move_impact_flat[curr_move_id][r][c];\n if (val < 0) val += MOD;\n board[r][c] = val;\n }\n // Apply cand\n for (int rc : move_cells_flat[cand_id]) {\n r = rc / N; c = rc % N;\n long long val = board[r][c] + move_impact_flat[cand_id][r][c];\n if (val >= MOD) val -= MOD;\n board[r][c] = val;\n }\n current_score += delta;\n break; // Move accepted, break candidate loop\n }\n }\n \n // Reset visited array\n for (int rc : move_cells_flat[curr_move_id]) {\n visited[rc] = false;\n }\n \n // Decay temp\n temp *= decay;\n }\n\n // Output result\n vector>> final_ops;\n for (int i = 0; i < K; ++i) {\n if (current_moves[i] != 980) {\n int id = current_moves[i];\n int m = id / 49;\n int rem = id % 49;\n int p = rem / 7;\n int q = rem % 7;\n final_ops.push_back({m, {p, q}});\n }\n }\n \n cout << final_ops.size() << \"\\n\";\n for (auto& op : final_ops) {\n cout << op.first << \" \" << op.second.first << \" \" << op.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_N = 5;\nconst int MAX_TURNS = 5000; // Sufficient for N=5 grid\n\n// Global State\nint grid[MAX_N][MAX_N];\npair crane_pos[MAX_N];\nint crane_load[MAX_N];\nvector> A_matrix;\nvector input_idx[MAX_N];\nvector ans[MAX_N];\n\n// Directions: U, D, L, R\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char move_char[] = {'U', 'D', 'L', 'R'};\n\nvoid solve() {\n // Initialization\n for (int i = 0; i < MAX_N; ++i) {\n for (int j = 0; j < MAX_N; ++j) {\n grid[i][j] = -1;\n }\n input_idx[i] = 0;\n crane_pos[i] = {i, 0};\n crane_load[i] = -1;\n ans[i] = \"\";\n }\n\n int turns = 0;\n // Simulation Loop\n while (turns < MAX_TURNS) {\n // Step 1: Receiving Gate Spawning\n for (int i = 0; i < MAX_N; ++i) {\n if (input_idx[i] == MAX_N) continue;\n // A container spawns at (i, 0) if no container is there AND no crane holding is there.\n // Idle crane at (i, 0) does NOT block spawn based on problem statement.\n bool blocked = (grid[i][0] != -1);\n for (int c = 0; c < MAX_N; ++c) {\n if (crane_pos[c].first == i && crane_pos[c].second == 0) {\n if (crane_load[c] != -1) {\n blocked = true;\n break;\n }\n }\n }\n if (!blocked) {\n grid[i][0] = A_matrix[i][input_idx[i]];\n input_idx[i]++;\n }\n }\n\n // Step 2: Action Planning\n struct Plan {\n int id;\n int type; // 0:Wait, 1:Move, 2:P, 3:Q\n int nr, nc;\n int score;\n };\n Plan plans[MAX_N];\n\n for (int i = 0; i < MAX_N; ++i) {\n plans[i].id = i;\n plans[i].score = 0;\n plans[i].nr = crane_pos[i].first;\n plans[i].nc = crane_pos[i].second;\n\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n\n // 1. Priority Dispatch: 'Q' at Gate\n // Only dispatch if container belongs to current row\n if (c == MAX_N - 1 && crane_load[i] != -1) {\n int row_id = crane_load[i] / MAX_N;\n if (row_id == r) {\n plans[i].type = 3; // Q\n plans[i].score = 20000;\n continue; \n }\n }\n\n // 2. Priority Pickup: 'P' at Gate\n if (plans[i].score == 0 && crane_load[i] == -1) {\n if (grid[r][c] != -1) { // Container available\n plans[i].type = 2; // P\n plans[i].score = 10000;\n continue;\n }\n }\n\n // 3. Move Logic\n if (plans[i].score == 0) {\n plans[i].type = 4; // Wait\n plans[i].score = 0;\n\n // Target logic\n int tr = r, tc = c;\n int desired_dist = 0;\n \n // If holding container, target is its dispatch row\n if (crane_load[i] != -1) {\n tr = crane_load[i] / MAX_N;\n tc = MAX_N - 1;\n desired_dist = 1000;\n } else {\n // Find nearest row with pending input\n bool found = false;\n for (int k = 0; k < MAX_N; ++k) {\n if (input_idx[k] < MAX_N) {\n tr = k;\n tc = 0;\n found = true;\n break;\n }\n }\n if (found) {\n desired_dist = 5;\n } else {\n desired_dist = 0; // No input, stay put\n }\n }\n\n int best_d = 100;\n int best_move = -1;\n for (int d = 0; d < 4; ++d) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < MAX_N && nc >= 0 && nc < MAX_N) {\n int d_dist = abs(nr - tr) + abs(nc - tc);\n if (d_dist < best_d) {\n best_d = d_dist;\n best_move = d;\n plans[i].nr = nr;\n plans[i].nc = nc;\n }\n }\n }\n \n if (best_move != -1) {\n plans[i].type = 1; // Move\n plans[i].score = desired_dist * 10 + (crane_load[i] != -1 ? 1000 : 0) - best_d;\n } else {\n plans[i].type = 4; // Wait\n }\n }\n\n // LC Bonus to prioritize clearing paths\n if (i == 0) plans[i].score += 2000;\n }\n\n // Step 3: Conflict Resolution\n // Order by score descending\n int p_idx[MAX_N];\n for(int i=0; i plans[b].score; });\n\n pair final_pos[MAX_N];\n int final_act[MAX_N];\n \n // Initialize with current positions (default for Wait)\n for(int i=0; i other_start, other -> cr_start\n if (final_pos[cr].first != crane_pos[cr].first && // Cr moves\n final_pos[other].first != crane_pos[other].first) { // Other moves\n if (nr == crane_pos[other].first && nc == crane_pos[other].second &&\n final_pos[other] == crane_pos[cr]) {\n collision = true;\n }\n }\n // Check if we both want same square\n if (nr == final_pos[other].first && nc == final_pos[other].second) {\n collision = true;\n }\n }\n\n // Lower priority cranes default to crane_pos[i].\n // If collision with lower priority, we usually win (since sorted desc).\n // But if lower priority is LC? LC has base bonus, but here sorted by score.\n // If LC collides with SC (which has higher score for Q/P), LC yields.\n // If we collide with any other, we yield (to avoid WA).\n \n // Special check: Small Crane carrying container cannot move to occupied.\n // We rely on heuristic planning, but strictly:\n if (collision) type = 4; // Wait\n \n // Check Small Crane movement constraint (Carrying + Occupied)\n // This is implicitly handled by heuristic not choosing blocked paths, but strictly:\n if (type == 1) {\n // If SC carrying, check if final_pos has container\n if (cr > 0 && crane_load[cr] != -1) {\n // We need to check grid state at final_pos\n // Wait, we need current grid state or predicted? Use current grid.\n // If final_pos has container ID, SC cannot move there.\n if (grid[nr][nc] != -1) {\n type = 4;\n }\n }\n }\n \n final_act[cr] = type;\n final_pos[cr] = {nr, nc};\n }\n\n // Step 4: Execute & Record\n int next_grid[MAX_N][MAX_N];\n for(int i=0; i> N)) return 0;\n \n A_matrix.resize(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A_matrix[i][j];\n }\n }\n \n solve();\n \n // Generate output strings with padding\n vector outputs(MAX_N);\n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\nint n;\nvector> heights;\n\nint manhattanDist(int r1, int c1, int r2, int c2) {\n return abs(r2 - r1) + abs(c2 - c1);\n}\n\nstring getMovePath(int fromR, int fromC, int toR, int toC) {\n string path = \"\";\n int curR = fromR, curC = fromC;\n \n while (curR != toR || curC != toC) {\n if (curR < toR) { path += \"D\"; curR++; }\n else if (curR > toR) { path += \"U\"; curR--; }\n else if (curC < toC) { path += \"R\"; curC++; }\n else if (curC > toC) { path += \"L\"; curC--; }\n }\n return path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n heights.resize(n, vector(n));\n \n vector> surplus;\n vector> deficit;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> heights[i][j];\n if (heights[i][j] > 0) {\n surplus.push_back({i, j});\n } else if (heights[i][j] < 0) {\n deficit.push_back({i, j});\n }\n }\n }\n \n struct Transport {\n int fromR, fromC;\n int toR, toC;\n int amt;\n int dist;\n };\n \n vector transports;\n \n for (int i = 0; i < surplus.size(); i++) {\n for (int j = 0; j < deficit.size(); j++) {\n int fr = surplus[i].first, fc = surplus[i].second;\n int tr = deficit[j].first, tc = deficit[j].second;\n int h = min(heights[fr][fc], -heights[tr][tc]);\n \n if (h <= 0) continue;\n \n int dist = manhattanDist(fr, fc, tr, tc);\n transports.push_back({fr, fc, tr, tc, h, dist});\n }\n }\n \n sort(transports.begin(), transports.end(), [](const Transport& a, const Transport& b) {\n return a.dist < b.dist;\n });\n \n vector ops;\n int curR = 0, curC = 0;\n int truckLoad = 0;\n \n for (const auto& t : transports) {\n int amt = t.amt;\n if (amt <= 0) continue;\n \n // Move to source\n string path1 = getMovePath(curR, curC, t.fromR, t.fromC);\n ops.insert(ops.end(), path1.begin(), path1.end());\n curR = t.fromR;\n curC = t.fromC;\n \n // Load\n for (int k = 0; k < amt; k++) {\n ops += \"+1\";\n truckLoad++;\n }\n heights[t.fromR][t.fromC] -= amt;\n \n // Move to destination\n string path2 = getMovePath(curR, curC, t.toR, t.toC);\n ops.insert(ops.end(), path2.begin(), path2.end());\n curR = t.toR;\n curC = t.toC;\n \n // Unload\n for (int k = 0; k < amt; k++) {\n ops += \"-1\";\n truckLoad--;\n }\n heights[t.toR][t.toC] += amt;\n }\n \n cout << ops.size() << \"\\n\";\n for (const string& op : ops) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold seed information\nstruct Seed {\n int id;\n vector values;\n int total_value;\n int max_value; // Maximum value among all criteria\n int high_value_count; // Count of criteria with value >= 95\n\n Seed() : id(0), total_value(0), max_value(0), high_value_count(0) {}\n};\n\n// Grid coordinates with distance metric from center\nstruct Pos {\n int r, c;\n int dist_sq;\n int degree; // Number of edges (connectivity)\n};\n\n// Sort positions: closer to center first, higher degree first\nbool comparePos(const Pos& a, const Pos& b) {\n if (a.degree > b.degree) return true; // Higher degree first\n if (a.degree < b.degree) return false;\n if (a.dist_sq != b.dist_sq) return a.dist_sq < b.dist_sq;\n if (a.r != b.r) return a.r < b.r;\n return a.c < b.c;\n}\n\n// Calculate position metrics once\nvector precomputePositions(int N) {\n vector positions;\n positions.reserve(N * N);\n int center_val = N - 1;\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int dr = 2 * r - center_val;\n int dc = 2 * c - center_val;\n int d2 = dr * dr + dc * dc;\n \n // Determine degree based on position\n int degree = 4;\n if (r == 0 || r == N - 1) degree--;\n if (c == 0 || c == N - 1) degree--;\n \n positions.push_back({r, c, d2, degree});\n }\n }\n \n sort(positions.begin(), positions.end(), comparePos);\n return positions;\n}\n\nint main() {\n // Optimize I/O for speed\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n\n int seed_count = 2 * N * (N - 1);\n vector seeds(seed_count);\n vector max_val_per_criterion(M, -1);\n\n // Read initial seeds\n for (int k = 0; k < seed_count; ++k) {\n seeds[k].id = k;\n seeds[k].values.resize(M, 0);\n seeds[k].total_value = 0;\n seeds[k].max_value = 0;\n seeds[k].high_value_count = 0;\n \n for (int l = 0; l < M; ++l) {\n cin >> seeds[k].values[l];\n seeds[k].total_value += seeds[k].values[l];\n seeds[k].max_value = max(seeds[k].max_value, seeds[k].values[l]);\n if (seeds[k].values[l] >= 95) seeds[k].high_value_count++;\n }\n \n // Track global maximum per criterion\n for (int l = 0; l < M; ++l) {\n if (seeds[k].values[l] > max_val_per_criterion[l]) {\n max_val_per_criterion[l] = seeds[k].values[l];\n }\n }\n }\n\n // Precompute grid positions (center first, by degree)\n vector positions = precomputePositions(N);\n const size_t N2 = static_cast(N) * N;\n\n for (int t = 0; t < T; ++t) {\n // Phase 1: Track seeds that hold global maximum for each criterion\n fill(max_val_per_criterion.begin(), max_val_per_criterion.end(), -1);\n \n for (const auto& s : seeds) {\n for (int l = 0; l < M; ++l) {\n if (s.values[l] > max_val_per_criterion[l]) {\n max_val_per_criterion[l] = s.values[l];\n }\n }\n }\n\n // Priority calculation\n struct SeedPriority {\n int id;\n long priority; // Higher = more important\n };\n vector priority_list(seed_count);\n\n for (int k = 0; k < seed_count; ++k) {\n priority_list[k].id = k;\n \n int level_high_value = 0;\n for (int l = 0; l < M; ++l) {\n if (seeds[k].values[l] == max_val_per_criterion[l]) {\n level_high_value += 50; // High weight for max values\n }\n if (seeds[k].values[l] >= 95) {\n level_high_value += 15; // High individual values\n }\n }\n \n // Combine criteria: max_values (highest) + high_values + total_sum + max_value\n priority_list[k].priority = static_cast(level_high_value * 1000) \n + seeds[k].total_value \n + seeds[k].max_value;\n }\n\n // Sort all seeds by priority\n sort(priority_list.begin(), priority_list.end(), [](const SeedPriority& a, const SeedPriority& b) {\n return a.priority > b.priority;\n });\n\n // Select top N*N seeds\n vector selected_ids;\n selected_ids.reserve(N2);\n \n for (size_t k = 0; k < N2 && k < static_cast(seed_count); ++k) {\n selected_ids.push_back(priority_list[k].id);\n }\n \n // Remove duplicates (shouldn't happen but safety)\n sort(selected_ids.begin(), selected_ids.end());\n selected_ids.erase(unique(selected_ids.begin(), selected_ids.end()), selected_ids.end());\n \n // Should always have N2 seeds available\n if (selected_ids.size() < N2) break;\n if (selected_ids.size() > N2) {\n selected_ids.resize(N2);\n }\n\n // Now sort selected seeds by sum to place in position order\n // FIXED: Added [&] to capture 'seeds' lambda\n sort(selected_ids.begin(), selected_ids.end(), [&seeds](int a, int b) {\n return seeds[a].total_value > seeds[b].total_value;\n });\n\n // Place in grid according to position order (center first)\n vector> grid(N, vector(N));\n for (size_t k = 0; k < N2; ++k) {\n int seed_id = selected_ids[k];\n Pos pos = positions[k];\n grid[pos.r][pos.c] = seed_id;\n }\n\n // Output grid configuration\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cout << grid[r][c] << (c == N - 1 ? \"\\n\" : \" \");\n }\n }\n cout.flush();\n\n // Read new seeds for next turn - recalculate metrics\n vector next_seeds(seed_count);\n for (int k = 0; k < seed_count; ++k) {\n next_seeds[k].id = k;\n next_seeds[k].values.resize(M, 0);\n next_seeds[k].total_value = 0;\n next_seeds[k].max_value = 0;\n next_seeds[k].high_value_count = 0;\n \n for (int l = 0; l < M; ++l) {\n cin >> next_seeds[k].values[l];\n next_seeds[k].total_value += next_seeds[k].values[l];\n next_seeds[k].max_value = max(next_seeds[k].max_value, next_seeds[k].values[l]);\n if (next_seeds[k].values[l] >= 95) next_seeds[k].high_value_count++;\n }\n }\n seeds = move(next_seeds);\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a coordinate pair\nstruct Point {\n int r, c;\n};\n\n// Structure to represent a task (moving an item from src to tgt)\nstruct Task {\n Point src, tgt;\n};\n\nint N, M, V;\nint grid_s[35][35];\nint grid_t[35][35];\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> V)) return 0;\n\n vector sources;\n vector targets;\n\n // Read initial positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_s[i][j] = (s[j] == '1');\n if (grid_s[i][j]) sources.push_back({i, j});\n }\n }\n // Read target positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_t[i][j] = (s[j] == '1');\n if (grid_t[i][j]) targets.push_back({i, j});\n }\n }\n\n // Filter out sources that are already on targets, \n // and targets that are already occupied.\n vector active_sources;\n vector active_targets;\n\n vector> is_target(N, vector(N, false));\n for(const auto& t : targets) is_target[t.r][t.c] = true;\n\n vector> is_source(N, vector(N, false));\n for(const auto& s : sources) is_source[s.r][s.c] = true;\n\n // Identify active sources (sources not on targets)\n for(const auto& s : sources) {\n if(!is_target[s.r][s.c]) active_sources.push_back(s);\n }\n // Identify active targets (targets not on sources)\n for(const auto& t : targets) {\n if(!is_source[t.r][t.c]) active_targets.push_back(t);\n }\n\n // Greedy matching between active sources and active targets\n // Since constraints are small (N<=30, M<=225), O(M^2) is acceptable.\n vector tasks;\n vector tgt_used(active_targets.size(), false);\n\n for (const auto& s : active_sources) {\n int best_idx = -1;\n int min_dist = 2000; // Max dist is roughly 60\n for (int i = 0; i < (int)active_targets.size(); ++i) {\n if (!tgt_used[i]) {\n int d = abs(s.r - active_targets[i].r) + abs(s.c - active_targets[i].c);\n if (d < min_dist) {\n min_dist = d;\n best_idx = i;\n }\n }\n }\n if (best_idx != -1) {\n tgt_used[best_idx] = true;\n tasks.push_back({s, active_targets[best_idx]});\n }\n }\n\n // --- Output Robotic Arm Design ---\n // We use a Star Graph: Root (0) connected to 1, 2, ..., V-1.\n // Edge lengths are all 1.\n cout << V << \"\\n\";\n for (int i = 1; i < V; ++i) {\n cout << 0 << \" \" << 1 << \"\\n\";\n }\n // Initial Root Position: Center of the grid\n cout << (N / 2) << \" \" << (N / 2) << \"\\n\";\n\n // --- Simulation ---\n int root_r = N / 2;\n int root_c = N / 2;\n int finger_dir = 0; // 0: Right, 1: Down, 2: Left, 3: Up. Initial state: Right (0)\n int dx[4] = {0, 1, 0, -1};\n int dy[4] = {1, 0, -1, 0};\n\n // Output buffer string\n string buf(2 * V, '.'); \n\n // Execute each task: Pick from Source -> Move -> Deliver at Target -> Place\n for (const auto& task : tasks) {\n Point src = task.src;\n Point tgt = task.tgt;\n\n // --- STEP 1: PICK UP ---\n \n // Find valid Root position and orientation to reach Source\n int pick_r = -1, pick_c = -1, pick_d = -1;\n int min_cost = 1e9;\n\n // Try all 4 directions for Finger 1\n for (int d = 0; d < 4; ++d) {\n // If finger points at src, Root must be at src - offset\n int r = src.r - dx[d];\n int c = src.c - dy[d];\n // Check bounds\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n // Prefer shorter distance; tie-break with preferred direction if possible\n if (dist < min_cost || (dist == min_cost && d == finger_dir)) {\n min_cost = dist;\n pick_r = r;\n pick_c = c;\n pick_d = d;\n }\n }\n }\n\n // Move Root to pick position\n int dr = 0, dc = 0;\n if (root_r < pick_r) dr = 1;\n if (root_r > pick_r) dr = -1;\n if (root_c < pick_c) dc = 1;\n if (root_c > pick_c) dc = -1;\n\n for (int k = 0; k < min_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n // Rotation and Action are '.' (no-op)\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1 to match direction\n while (finger_dir != pick_d) {\n buf[0] = '.'; // Move is idle\n buf[1] = '.'; // Reset rotation char\n buf[V + 1] = '.'; // Reset action char\n \n int diff = (pick_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R'; // CW 90\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L'; // CCW 90\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Pick Up Action (Vertex 1 Action is at index V + 1)\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n\n // --- STEP 2: DELIVER ---\n \n // Find valid Root position and orientation to reach Target\n int del_r = -1, del_c = -1, del_d = -1;\n int del_cost = 1e9;\n\n for (int d = 0; d < 4; ++d) {\n int r = tgt.r - dx[d];\n int c = tgt.c - dy[d];\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n if (dist < del_cost || (dist == del_cost && d == finger_dir)) {\n del_cost = dist;\n del_r = r;\n del_c = c;\n del_d = d;\n }\n }\n }\n\n // Move Root to target position\n dr = dc = 0;\n if (root_r < del_r) dr = 1;\n if (root_r > del_r) dr = -1;\n if (root_c < del_c) dc = 1;\n if (root_c > del_c) dc = -1;\n\n for (int k = 0; k < del_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1\n while (finger_dir != del_d) {\n buf[0] = '.'; \n buf[1] = '.';\n buf[V + 1] = '.'; \n int diff = (del_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R';\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L';\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Place Action\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n }\n\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n\n// Boost Geometry\n#include \n#include \n#include \n#include \n\nnamespace bg = boost::geometry;\nnamespace bgm = boost::geometry::model;\n\nusing coord = double;\nusing point = bgm::point;\nusing polygon = bgm::polygon;\nusing multi_polygon = bgm::multi_polygon;\n\nstruct RectInfo {\n int x_min, x_max, y_min, y_max;\n int mackerels;\n int sardines;\n int id;\n int score;\n};\n\nbool is_inside(int x, int y, int min_x, int max_x, int min_y, int max_y) {\n return (x >= min_x && x <= max_x && y >= min_y && y <= max_y);\n}\n\nstd::vector> kmeans(int n, int k, const std::vector>& points) {\n std::vector> centroids;\n std::mt19937 rng(42);\n std::uniform_int_distribution dist(0, n - 1);\n for(int i=0; i> members(k);\n for(int iter=0; iter<10; ++iter) {\n std::vector> new_members(k);\n for(int i=0; i> N)) return 0;\n\n std::vector> mackerels(N);\n std::vector> sardines(N);\n\n for(int i=0; i> mackerels[i].first >> mackerels[i].second;\n for(int i=0; i> sardines[i].first >> sardines[i].second;\n\n int k_clusters = 20;\n if (N < k_clusters) k_clusters = N;\n\n std::vector> clusters = kmeans(N, k_clusters, mackerels);\n std::vector all_rects;\n\n for (int i = 0; i < k_clusters; ++i) {\n if (clusters[i].empty()) continue;\n int xmin = 100005, xmax = -1, ymin = 100005, ymax = -1;\n for (int idx : clusters[i]) {\n int x = mackerels[idx].first, y = mackerels[idx].second;\n xmin = std::min(xmin, x); xmax = std::max(xmax, x);\n ymin = std::min(ymin, y); ymax = std::max(ymax, y);\n }\n int mc = 0, sc = 0;\n for (const auto& p : mackerels) if(is_inside(p.first, p.second, xmin, xmax, ymin, ymax)) mc++;\n for (const auto& p : sardines) if(is_inside(p.first, p.second, xmin, xmax, ymin, ymax)) sc++;\n all_rects.push_back({xmin, xmax, ymin, ymax, mc, sc, i, mc - sc});\n }\n\n std::sort(all_rects.begin(), all_rects.end(), [](const RectInfo& a, const RectInfo& b){return a.score > b.score;});\n int k_sel = std::min(10, (int)all_rects.size());\n std::vector selected(all_rects.begin(), all_rects.begin() + k_sel);\n \n std::sort(selected.begin(), selected.end(), [](const RectInfo& a, const RectInfo& b){\n return (a.x_min + a.x_max) < (b.x_min + b.x_max);\n });\n\n multi_polygon mp;\n std::vector polys;\n\n for (const auto& r : selected) {\n polygon p;\n bg::read_wkt(\"POLYGON((\" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_min) + \", \" +\n std::to_string(r.x_max) + \",\" + std::to_string(r.y_min) + \", \" +\n std::to_string(r.x_max) + \",\" + std::to_string(r.y_max) + \", \" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_max) + \", \" +\n std::to_string(r.x_min) + \",\" + std::to_string(r.y_min) + \"))\", p);\n polys.push_back(p);\n }\n\n for (size_t i = 0; i < polys.size() - 1; ++i) {\n const auto& ri = selected[i]; const auto& rj = selected[i+1];\n int x_start = std::min(ri.x_max, rj.x_max);\n int x_end = std::max(ri.x_min, rj.x_min); // Connect min(x) to max(x)\n if (x_start > x_end) std::swap(x_start, x_end);\n \n int y_int_min = std::max(ri.y_min, rj.y_min);\n int y_int_max = std::min(ri.y_max, rj.y_max);\n if (y_int_min > y_int_max) {\n int mid = (ri.y_min + ri.y_max + rj.y_min + rj.y_max) / 4;\n y_int_min = mid; y_int_max = mid + 1;\n }\n y_int_max += 1;\n\n if (x_start <= x_end) {\n polygon bp;\n bg::read_wkt(\"POLYGON((\" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_min) + \", \" +\n std::to_string(x_end) + \",\" + std::to_string(y_int_min) + \", \" +\n std::to_string(x_end) + \",\" + std::to_string(y_int_max) + \", \" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_max) + \", \" +\n std::to_string(x_start) + \",\" + std::to_string(y_int_min) + \"))\", bp);\n polys.push_back(bp);\n }\n }\n\n for(const auto& p : polys) bg::append(mp, p);\n \n // Union\n multi_polygon result;\n if(!mp.empty()) {\n result = mp;\n for(size_t i=0; i vertices(final_poly.outer().begin(), final_poly.outer().end());\n std::vector simplified;\n if(vertices.size() > 2) {\n simplified.push_back(vertices[0]);\n for(size_t i=1; i 1e-9 || cp < -1e-9) simplified.push_back(vertices[i]);\n }\n simplified.push_back(vertices.back());\n } else simplified = vertices;\n\n std::vector> out;\n for(const auto& v : simplified) out.push_back({(int)std::round(v.x()), (int)std::round(v.y())});\n\n if (out.size() >= 2 && out.front() == out.back()) out.pop_back();\n\n std::cout << out.size() << \"\\n\";\n for(const auto& p : out) std::cout << p.first << \" \" << p.second << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a placement decision for a rectangle\nstruct Decision {\n int id; // Original rectangle index (0 to N-1)\n int r; // Rotation: 0 or 1\n char d; // Direction: 'U' or 'L'\n int b; // Base rectangle index (value of p_j for j < i, or -1)\n};\n\nstruct Rect {\n long long w, h;\n};\n\n// Global variables for N and T\nint N, T;\nvector rects; // Stores the observed w', h'\n\n// Function to evaluate the proxy cost (estimated W + H)\n// This function simulates the placement using the provided observed dimensions (w', h')\n// It uses a linear scan for column/row management instead of map for performance\nlong long get_cost(const vector& config, int n) {\n // Store active columns: x coordinate, current maximum height in that column\n struct Col { long long x; long long max_h; };\n // Store active rows: y coordinate, current maximum width in that row\n struct Row { long long y; long long max_w; };\n\n vector cols;\n vector rows;\n \n // pos[i] stores the x,y coordinate of rectangle i after placement\n vector> pos(n);\n // dims[i] stores the effective w, h of rectangle i after rotation\n vector> dims(n);\n \n long long global_max_W = 0;\n long long global_max_H = 0;\n \n for(int i=0; i c.max_h) c.max_h = new_h;\n break;\n }\n }\n } else {\n cols.push_back({px, py + h});\n }\n } else { // config[i].d == 'L'\n // L: Move leftward.\n // Align Top edge to Bottom edge of base rectangle b.\n // If b == -1, align Top edge to y=0.\n if(config[i].b == -1) {\n py = 0;\n } else {\n long long base_py = pos[config[i].b].second;\n long long base_ph = dims[config[i].b].second;\n py = base_py + base_ph;\n }\n \n // Find existing width at this row y = py\n long long row_w = 0;\n bool found_row = false;\n // Linear scan over active rows\n for(const auto& r : rows) {\n if(r.y == py) {\n row_w = r.max_w;\n found_row = true;\n break;\n }\n }\n px = row_w;\n \n // Update the row width\n if(found_row) {\n long long new_w = px + w;\n for(auto& r : rows) {\n if(r.y == py) {\n if(new_w > r.max_w) r.max_w = new_w;\n break;\n }\n }\n } else {\n rows.push_back({py, px + w});\n }\n }\n \n pos[i] = {px, py};\n if(px + w > global_max_W) global_max_W = px + w;\n if(py + h > global_max_H) global_max_H = py + h;\n }\n \n return global_max_W + global_max_H;\n}\n\nint main() {\n // Optimization for Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read problem parameters\n if (!(cin >> N >> T)) return 0;\n long long sigma; \n cin >> sigma;\n \n rects.resize(N);\n for(int i=0; i> rects[i].w >> rects[i].h;\n }\n \n // Initialize random number generator\n // Using a fixed seed for reproducibility in local testing, \n // but varying slightly per submission might be useful in production\n mt19937 rng(42); \n \n // Initialize global best configuration\n // Strategy: Place all N rectangles (indices 0 to N-1)\n vector best_config(N);\n \n // Initial heuristic placement (simple random or deterministic start)\n // We initialize with plausible values to start hill climbing from a good point.\n // Greedy initialization could be better but random is safer for heuristic\n for(int i=0; i candidate = best_config;\n long long current_score = global_best_score;\n \n // Hill Climbing Loop to refine the configuration\n // We perform local searches (flip r, d, b) to find a lower cost\n // The number of iterations is tuned for the 3.0s time limit\n // N <= 100, so O(N^2) get_cost is roughly 10^4 ops.\n // We need total ops < ~5*10^8.\n // T iterations * Inner iters * get_cost.\n // T <= 400. If Inner iters = 30. Total = 400 * 30 * 10^4 = 1.2*10^8.\n \n int hill_climbing_iters = 30; \n \n for(int it=0; it 0) {\n // Possible bases are -1 and 0..i-1 (i+1 options)\n int choice = rng() % (i + 1);\n new_b = (choice == 0 ? -1 : (choice - 1));\n }\n \n if(new_b != old_b) {\n candidate[i].b = new_b;\n long long sc = get_cost(candidate, N);\n if(sc < current_score) {\n current_score = sc;\n // Keep change\n } else {\n candidate[i].b = old_b; // Revert\n }\n }\n }\n }\n \n // Update Global Best if improvement found\n if(current_score < global_best_score) {\n global_best_score = current_score;\n best_config = candidate;\n }\n \n // Output the configuration found so far\n cout << best_config.size() << \"\\n\";\n for(const auto& d : best_config) {\n cout << d.id << \" \" << d.r << \" \" << d.d << \" \" << d.b << \"\\n\";\n }\n cout.flush(); \n \n // Read feedback from judge (W', H')\n // We rely on our internal simulation cost rather than noisy W', H' for strategy\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \n#include \"atcoder/maxflow\"\n#include \"atcoder/internal_bit\"\nusing namespace std;\nusing namespace atcoder;\n\n#define rep(i, n) for (int i = 0; i < (n); ++i)\n#define rep1(i, a, b) for (int i = (a); i <= (b); ++i)\n\nstruct Vertex {\n int id;\n long long beauty;\n int x, y;\n};\n\nstruct Solver {\n int N, M, H;\n vector A;\n vector> edges;\n vector adj[1005];\n vector parent;\n vector depth;\n long long current_score = 0;\n\n Solver(int N, int M, int H, const vector& A, const vector>& edges)\n : N(N), M(M), H(H), A(A), edges(edges), parent(N, -1), depth(N, 0) {}\n\n // Build adjacency list\n void build_graph() {\n rep(i, M) {\n int u = edges[i].first;\n int v = edges[i].second;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n }\n\n // BFS to compute all depths from root assignments\n void compute_depths() {\n queue q;\n fill(depth.begin(), depth.end(), -1);\n\n rep(i, N) {\n if (parent[i] == -1) {\n depth[i] = 0;\n q.push(i);\n }\n }\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n for (int v : adj[u]) {\n if (parent[v] == u && depth[v] == -1) {\n depth[v] = depth[u] + 1;\n q.push(v);\n }\n }\n }\n }\n\n // Recompute score based on current parent assignment\n void recompute_score() {\n compute_depths();\n current_score = 0;\n rep(i, N) {\n if (depth[i] >= 0) {\n current_score += (long long)(depth[i] + 1) * A[i];\n }\n }\n }\n\n long long get_score() const {\n long long total = 0;\n rep(i, N) {\n if (depth[i] >= 0) {\n total += (long long)(depth[i] + 1) * A[i];\n }\n }\n return total;\n }\n\n // Check if moving vertex v to parent p is valid\n bool is_valid_move(int v, int p) {\n if (p == v) return false;\n if (depth[p] >= H) return false;\n if (p != -1 && depth[p] + 1 > H) return false;\n\n // Check if new parent is in adj\n bool in_adj = false;\n for (int neighbor : adj[v]) {\n if (neighbor == p) {\n in_adj = true;\n break;\n }\n }\n if (!in_adj && p != -1) return false;\n\n return true;\n }\n\n // Simulate a move without actually applying it\n long long evaluate_move(int v, int p) {\n if (!is_valid_move(v, p)) return -1;\n\n int old_parent = parent[v];\n int old_depth = depth[v];\n\n long long score_change = 0;\n\n // Change v's contribution\n int new_depth = (p == -1) ? 0 : depth[p] + 1;\n score_change += (long long)(new_depth + 1) * A[v] - (long long)(old_depth + 1) * A[v];\n\n return score_change;\n }\n\n // Actually apply a move\n void apply_move(int v, int p) {\n parent[v] = p;\n recompute_score();\n }\n\n // Local search with simulated annealing\n long long solve() {\n // First, initialize with a heuristic assignment\n initialize();\n\n // Local search with simulated annealing\n long long best_score = get_score();\n int temperature = 1000000;\n double cooling_rate = 0.9998;\n\n mt19937 gen(42);\n uniform_int_distribution dist(0, 1000000);\n\n rep(iter, 50000) {\n // Get current score\n long long cur_score = get_score();\n\n if (cur_score > best_score) best_score = cur_score;\n\n // Try random moves\n int v = uniform_int_distribution(0, N - 1)(gen);\n\n // Try all possible parents including -1 (root)\n vector parents;\n parents.push_back(-1);\n for (int p : adj[v]) parents.push_back(p);\n\n int best_p = parent[v];\n long long best_diff = 0;\n\n for (int p : parents) {\n long long diff = evaluate_move(v, p);\n if (diff > best_diff) {\n best_diff = diff;\n best_p = p;\n }\n }\n\n // Apply move with simulated annealing acceptance\n long long diff = evaluate_move(v, best_p);\n if (diff > 0 || (double)dist(gen) < diff * 100 / (temperature + 1)) {\n apply_move(v, best_p);\n }\n\n // Cool down\n temperature *= cooling_rate;\n }\n\n return get_score();\n }\n\n // Initial assignment using greedy approach\n void initialize() {\n vector visited(N, 0);\n fill(parent.begin(), parent.end(), -1);\n\n // Sort vertices by beauty in descending order\n vector> sorted_nodes(N);\n rep(i, N) sorted_nodes[i] = {A[i], i};\n sort(sorted_nodes.rbegin(), sorted_nodes.rend());\n\n rep(iter, N) {\n int v = sorted_nodes[iter].second;\n if (visited[v]) continue;\n\n // BFS to find a valid assignment with depth constraint\n queue q;\n q.push(v);\n vector tree_nodes;\n tree_nodes.push_back(v);\n visited[v] = 1;\n parent[v] = -1;\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n for (int neighbor : adj[u]) {\n if (visited[neighbor]) continue;\n\n int new_depth = depth[u] + 1;\n if (new_depth > H) continue;\n\n if (depth[u] != -1) {\n visited[neighbor] = 1;\n parent[neighbor] = u;\n depth[neighbor] = new_depth;\n tree_nodes.push_back(neighbor);\n q.push(neighbor);\n }\n }\n }\n }\n\n // Fix up: ensure all vertices are assigned\n rep(i, N) {\n if (parent[i] == -1) {\n // Find a valid parent\n for (int p : adj[i]) {\n if (depth[p] != -1 && depth[p] < H - depth[i]) {\n parent[i] = p;\n break;\n }\n }\n }\n }\n\n recompute_score();\n }\n\n // Final refinement with more aggressive local search\n void refine() {\n int improved = 1;\n while (improved) {\n improved = 0;\n rep(v, N) {\n int old_parent = parent[v];\n long long old_contrib = (parent[v] == -1) ? depth[v] : depth[parent[v]];\n\n for (int p : adj[v]) {\n if (p == v) continue;\n if (depth[p] >= H - 1) continue;\n\n int new_depth = depth[p] + 1;\n long long new_contrib = new_depth;\n\n if (new_contrib != depth[v]) {\n apply_move(v, p);\n long long gain = get_score();\n long long old_val = get_score();\n\n if (gain > old_val) {\n improved = 1;\n continue;\n }\n }\n }\n }\n }\n }\n\n const vector& get_parent() const {\n return parent;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n cin >> N >> M >> H;\n\n vector A(N);\n rep(i, N) cin >> A[i];\n\n vector> edges(M);\n rep(i, M) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector> coords(N);\n rep(i, N) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n Solver solver(N, M, H, A, edges);\n solver.build_graph();\n\n // Initial greedy assignment\n vector parent(N, -1);\n vector depth(N, 0);\n\n // Start BFS from each unvisited node as root\n vector visited(N, false);\n vector roots;\n rep(i, N) {\n if (!visited[i]) {\n for (int r : roots) {\n if (adj[r].empty()) {\n if (!visited[i]) {\n parent[i] = r;\n visited[i] = true;\n break;\n }\n }\n }\n if (!visited[i]) {\n // BFS to find valid tree\n queue> q;\n q.push({i, 0});\n visited[i] = true;\n parent[i] = -1;\n depth[i] = 0;\n\n while (!q.empty()) {\n auto [u, d] = q.front();\n q.pop();\n\n for (int v : adj[u]) {\n if (!visited[v] && d + 1 <= H) {\n visited[v] = true;\n parent[v] = u;\n depth[v] = d + 1;\n q.push({v, d + 1});\n }\n }\n }\n roots.push_back(i);\n }\n }\n }\n\n // Refine using local search\n auto update_parent = [&](int v, int p) -> bool {\n if (p == v) return false;\n if (parent[v] == p) return false;\n\n if (p != -1 && depth[p] >= H - 1) return false;\n\n int old_parent = parent[v];\n int old_contrib = (old_parent == -1) ? depth[v] + 1 : depth[old_parent] * (v == old_parent ? 0 : 1);\n\n int new_depth = (p == -1) ? 0 : depth[p] + 1;\n int new_contrib = new_depth;\n\n // Apply and check\n parent[v] = p;\n\n // Recompute depths affected\n queue q;\n q.push(v);\n vector affected;\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n affected.push_back(u);\n\n for (int child : adj[u]) {\n if (parent[child] == u) {\n depth[child] = depth[u] + 1;\n if (depth[child] > H) {\n parent[v] = old_parent; // Revert if invalid\n return false;\n }\n q.push(child);\n }\n }\n }\n\n long long new_score = 0;\n rep(i, N) {\n if (i != v) new_score += (long long)(depth[i] + 1) * A[i];\n }\n new_score += (long long)(depth[v] + 1) * A[v];\n\n // Revert if worse\n if (new_score < solver.get_score()) {\n parent[v] = old_parent;\n return false;\n }\n\n return true;\n };\n\n // Simple local search\n rep(iter, 10000) {\n bool improved = false;\n for (int v = 0; v < N; ++v) {\n // Try each neighbor as potential parent\n for (int p : adj[v]) {\n if (depth[p] < H - 1) {\n if (update_parent(v, p)) {\n improved = true;\n break;\n }\n }\n }\n if (improved) break;\n }\n if (!improved) break;\n }\n\n cout << parent[0];\n rep1(i, 1, N - 1) cout << \" \" << parent[i];\n cout << endl;\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Oni {\n int id;\n int r, c;\n};\n\nstruct MoveCandidate {\n int dist; // steps to shift\n char dir; // 'U', 'D', 'L', 'R'\n int cost; // total operations for this move (2 * dist)\n int idx; // row index if dir is L/R, col index if dir is U/D\n vector removed_indices; // IDs of Oni removed by this move\n vector> ops; // Output operations sequence\n double efficiency; // new_oni_removed / cost (for greedy selection)\n};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector board(N);\n vector valid_onis;\n vector> all_fuku;\n\n // Parse board\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n valid_onis.push_back({(int)valid_onis.size(), i, j});\n } else if (board[i][j] == 'o') {\n all_fuku.push_back({i, j});\n }\n }\n }\n\n // Check Fukunokami positions for O(1) lookup\n vector> has_fuku(N, vector(N, false));\n for(auto& p : all_fuku) {\n has_fuku[p.first][p.second] = true;\n }\n\n vector move_candidates;\n int num_onis = valid_onis.size();\n\n // Generate candidates for each Oni\n for(const auto& oni : valid_onis) {\n // 1. Up Direction\n bool safe = true;\n for(int k=0; k= oni.r) mc.removed_indices.push_back(o.id);\n }\n mc.efficiency = 0.0;\n move_candidates.push_back(mc);\n }\n\n // 3. Left Direction\n safe = true;\n for(int k=0; k= oni.c) mc.removed_indices.push_back(o.id);\n }\n mc.efficiency = 0.0;\n move_candidates.push_back(mc);\n }\n }\n\n vector is_covered(num_onis, false);\n vector> total_ops;\n\n while(true) {\n int remaining_count = 0;\n for(int i=0; i 0) {\n mc.efficiency = (double)current_removed_count / mc.cost;\n // Greedy strategy: maximize efficiency, then count, then minimize cost\n bool is_better = false;\n if(best_idx == -1) {\n is_better = true;\n } else if(mc.efficiency > best_efficiency) {\n is_better = true;\n } else if(mc.efficiency == best_efficiency && current_removed_count > best_removed_count) {\n is_better = true;\n } else if(mc.efficiency == best_efficiency && current_removed_count == best_removed_count && mc.cost < best_cost) {\n is_better = true;\n }\n \n if(is_better) {\n best_idx = i;\n best_removed_count = current_removed_count;\n best_efficiency = mc.efficiency;\n best_cost = mc.cost;\n }\n }\n }\n\n if(best_idx == -1) break; // Should not happen per problem guarantee\n\n const auto& mc = move_candidates[best_idx];\n total_ops.insert(total_ops.end(), mc.ops.begin(), mc.ops.end());\n\n for(int id : mc.removed_indices) {\n is_covered[id] = true;\n }\n }\n\n // Output: Only operations, no count\n for(const auto& p : total_ops) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global variables to store state and results\nint N, L;\nint T[105];\nuint8_t A[105];\nuint8_t B[105];\nint counts[105];\n\n// Best solution found so far\nint best_err = 2000000000; // sufficiently large number\nuint8_t best_A[105];\nuint8_t best_B[105];\n\n// Simulation function to evaluate the configuration\nint simulate() {\n // Reset counts\n for(int i=0; i> N >> L)) return 0;\n for(int i=0; i> T[i];\n \n // Initialize random number generator\n mt19937 rng(4211); \n uniform_int_distribution dist(0, N - 1);\n uniform_real_distribution dist_real(0.0, 1.0);\n \n // Initial random configuration\n for(int i=0; i modify A, 1 -> modify B\n int val = dist(rng);\n \n uint8_t old_val = (type == 0) ? A[i] : B[i];\n if (type == 0) A[i] = (uint8_t)val; else B[i] = (uint8_t)val;\n \n int new_err = simulate();\n bool accepted = false;\n \n // Accept if better, or with probability based on temp (SA)\n if (new_err < current_err) {\n accepted = true;\n } else {\n double delta = (double)(new_err - current_err);\n if (delta > 0 && dist_real(rng) < exp(-delta / temp)) {\n accepted = true;\n }\n }\n \n if (accepted) {\n current_err = new_err;\n if (new_err < best_err) {\n best_err = new_err;\n for(int k=0; k\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, L, W;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n vector G(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; i++) {\n cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n }\n \n // Estimate coordinates from rectangle centers\n vector est_x(N), est_y(N);\n for (int i = 0; i < N; i++) {\n est_x[i] = (lx[i] + rx[i]) / 2.0;\n est_y[i] = (ly[i] + ry[i]) / 2.0;\n }\n \n // Create city indices and sort by estimated position (lexicographically by x, then y)\n vector cities(N);\n iota(cities.begin(), cities.end(), 0);\n \n sort(cities.begin(), cities.end(), [&](int a, int b) {\n if (est_x[a] != est_x[b]) return est_x[a] < est_x[b];\n return est_y[a] < est_y[b];\n });\n \n // Partition into groups\n vector> groups(M);\n int idx = 0;\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < G[i]; j++) {\n if (idx < N) {\n groups[i].push_back(cities[idx]);\n idx++;\n }\n }\n }\n \n // Store all edges we find from queries\n // Each group needs G[i] - 1 edges to form a spanning tree\n vector>> group_edges(M);\n \n // Perform queries to get edges for each group\n int query_count = 0;\n for (int m = 0; m < M; m++) {\n if (G[m] < 2) continue;\n \n const auto& group = groups[m];\n int group_size = G[m];\n \n // Use sliding window queries of size 3 to L to get MST edges\n // Each 3-city query gives us 2 edges (MST of 3 nodes has 2 edges)\n \n int edge_count = 0;\n for (int i = 0; i < group_size - 1; i++) {\n if (edge_count >= group_size - 1) break;\n \n // For efficiency, query larger windows when we need more edges\n int window_size = min(L, min(group_size, group_size - i));\n if (window_size < 2) {\n window_size = 2;\n }\n \n if (query_count < Q) {\n vector query_cities;\n int take = min(window_size, group_size - i);\n \n // Take consecutive cities from the sorted group\n for (int j = 0; j < take; j++) {\n query_cities.push_back(group[i + j]);\n }\n \n // Output query\n cout << \"? \" << query_cities.size();\n for (int city : query_cities) {\n cout << \" \" << city;\n }\n cout << endl;\n \n // Read MST edges\n vector> mst_edges;\n for (int k = 0; k < query_cities.size() - 1; k++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n mst_edges.push_back({u, v});\n }\n \n // Filter edges and add to group edges\n for (auto& edge : mst_edges) {\n bool in_group = true;\n // Check if both endpoints are in this group\n for (int city : group) {\n if (edge.first == city || edge.second == city) {\n // Found city\n }\n }\n // Add the edge\n if (edge_count < group_size - 1) {\n int u = edge.first;\n int v = edge.second;\n // Check if edge already exists\n bool exists = false;\n for (auto& e : group_edges[m]) {\n if ((e.first == u && e.second == v) || \n (e.first == v && e.second == u)) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n group_edges[m].push_back({u, v});\n edge_count++;\n }\n }\n }\n \n query_count++;\n }\n }\n \n // If we still need edges, add direct connections between consecutive cities\n // (This will be suboptimal but ensures connectivity)\n // We need G[m] - 1 edges total\n int needed = group_size - 1 - edge_count;\n for (int i = 0; i < needed; i++) {\n // Connect consecutive cities in the group that might not have edges yet\n int u = group[i % group_size];\n int v = group[(i + 1) % group_size];\n // Check if edge already exists\n bool exists = false;\n for (auto& e : group_edges[m]) {\n if ((e.first == u && e.second == v) || \n (e.first == v && e.second == u)) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n group_edges[m].push_back({u, v});\n }\n }\n }\n \n // Output final answer\n cout << \"!\" << endl;\n int city_idx = 0;\n for (int m = 0; m < M; m++) {\n if (G[m] == 0) continue;\n \n // Output cities in group m\n for (int c : groups[m]) {\n cout << c << \" \";\n }\n cout << endl;\n \n // Output edges for group m\n for (auto& e : group_edges[m]) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n \n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAXN = 20;\n\nbool has_block[MAXN][MAXN];\nint cur_r, cur_c;\nint N, M;\n\nint dr[] = {-1, 1, 0, 0}; // U, D, L, R\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\n// Check if a position is valid (within grid and not blocked)\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N && !has_block[r][c];\n}\n\n// Execute a single action and update state\nbool execute_action(char action, char dir, int& r, int& c, bool check_valid = true) {\n int d = 0;\n if (dir == 'U') d = 0;\n else if (dir == 'D') d = 1;\n else if (dir == 'L') d = 2;\n else if (dir == 'R') d = 3;\n \n if (action == 'M') {\n if (check_valid) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n r = nr;\n c = nc;\n return true;\n }\n return false;\n } else {\n int nr = r + dr[d];\n int nc = c + dc[d];\n r = nr;\n c = nc;\n return true;\n }\n }\n else if (action == 'S') {\n int nr = r, nc = c;\n while (true) {\n int nr_new = nr + dr[d];\n int nc_new = nc + dc[d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n }\n r = nr;\n c = nc;\n return true;\n }\n else if (action == 'A') {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n has_block[nr][nc] = !has_block[nr][nc];\n return true;\n }\n return false;\n }\n return false;\n}\n\n// Calculate Manhattan distance\nint manhattan(int r1, int c1, int r2, int c2) {\n return abs(r1 - r2) + abs(c1 - c2);\n}\n\n// Get direction that reduces distance to target\nint get_direction(int r, int c, int tr, int tc) {\n if (r < tr) return 1; // Down towards target\n if (r > tr) return 0; // Up towards target\n if (c < tc) return 3; // Right towards target\n if (c > tc) return 2; // Left towards target\n return -1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n cin >> N >> M;\n \n cin >> cur_r >> cur_c;\n \n vector> targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].first >> targets[i].second;\n }\n \n memset(has_block, 0, MAXN * MAXN);\n vector> actions;\n \n for (int t = 0; t < M; t++) {\n int tr = targets[t].first;\n int tc = targets[t].second;\n int target_dist = manhattan(cur_r, cur_c, tr, tc);\n \n // Step 1: If target is blocked, unblock it first\n if (has_block[tr][tc]) {\n // Move to adjacent to target (within 1 cell)\n while (manhattan(cur_r, cur_c, tr, tc) > 1) {\n int best_d = get_direction(cur_r, cur_c, tr, tc);\n \n if (best_d == -1) break;\n \n // Try to slide in best direction first\n int nr = cur_r, nc = cur_c;\n int slide_dist = 0;\n while (true) {\n int nr_new = nr + dr[best_d];\n int nc_new = nc + dc[best_d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_dist++;\n }\n \n if (slide_dist >= 1 && manhattan(nr, nc, tr, tc) < manhattan(cur_r, cur_c, tr, tc)) {\n actions.push_back({'S', dir_char[best_d]});\n execute_action('S', dir_char[best_d], cur_r, cur_c, false);\n } else {\n actions.push_back({'M', dir_char[best_d]});\n execute_action('M', dir_char[best_d], cur_r, cur_c, false);\n }\n }\n \n // Now remove the block (find the correct direction)\n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr == tr && nc == tc && !has_block[nr][nc]) {\n actions.push_back({'A', dir_char[d]});\n has_block[nr][nc] = false;\n break;\n }\n }\n }\n \n // Step 2: Navigate to target using slides when possible\n bool reached_target = false;\n \n while (cur_r != tr || cur_c != tc) {\n int current_dist = manhattan(cur_r, cur_c, tr, tc);\n bool moved = false;\n \n // Direction alignment\n int align_d = get_direction(cur_r, cur_c, tr, tc);\n \n // Try slide in aligned direction\n if (align_d != -1) {\n int nr = cur_r, nc = cur_c;\n int slide_count = 0;\n while (true) {\n int nr_new = nr + dr[align_d];\n int nc_new = nc + dc[align_d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_count++;\n }\n \n if (slide_count >= 1 && manhattan(nr, nc, tr, tc) < current_dist) {\n actions.push_back({'S', dir_char[align_d]});\n execute_action('S', dir_char[align_d], cur_r, cur_c, false);\n moved = true;\n }\n }\n \n // If no slide, try move\n if (!moved && align_d != -1) {\n actions.push_back({'M', dir_char[align_d]});\n execute_action('M', dir_char[align_d], cur_r, cur_c, false);\n moved = true;\n }\n \n // If still not moved, try sliding in other directions\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n int nr = cur_r, nc = cur_c;\n int slide_count = 0;\n while (true) {\n int nr_new = nr + dr[d];\n int nc_new = nc + dc[d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_count++;\n }\n \n if (slide_count >= 1 && manhattan(nr, nc, tr, tc) < current_dist) {\n actions.push_back({'S', dir_char[d]});\n execute_action('S', dir_char[d], cur_r, cur_c, false);\n moved = true;\n break;\n }\n }\n }\n \n // If still not moved, try simple move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n if (align_d == d) continue;\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n actions.push_back({'M', dir_char[d]});\n execute_action('M', dir_char[d], cur_r, cur_c, false);\n moved = true;\n break;\n }\n }\n }\n \n // Safety check to prevent infinite loop\n if (!moved) {\n reached_target = true;\n break;\n }\n }\n }\n \n // Output all actions\n for (const auto& p : actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}"},"8":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Company {\n int id, x, y, r, a, b, c, d;\n \n long long area() const {\n return max(0LL, (long long)(c - a)) * max(0LL, (long long)(d - b));\n }\n \n bool containsPoint() const {\n return a <= x && x < c && b <= y && y < d;\n }\n};\n\nint n;\nvector companies;\nconst int GRID = 10000;\n\ndouble calculateScore(const vector& com) {\n double total = 0.0;\n for (const auto& c : com) {\n long long s = c.area();\n if (s <= 0 || !c.containsPoint()) continue;\n double ratio = min(c.r, s) / max((double)c.r, s);\n total += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return total;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n companies.resize(n);\n \n for (int i = 0; i < n; i++) {\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n companies[i].id = i;\n }\n \n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n // Initial placement - center around point (x, y)\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n long long target = c.r;\n long long w = max(1LL, (long long)sqrt(target * 2.0));\n long long h = max(1LL, target / w + 1LL);\n \n int a = max(0, min(c.x, c.x - (int)w / 2));\n int c_pos = min(GRID, max(c.x + 1, a + (int)w));\n int b = max(0, min(c.y, c.y - (int)h / 2));\n int d = min(GRID, max(c.y + 1, b + (int)h));\n \n c.a = a;\n c.b = b;\n c.c = c_pos;\n c.d = d;\n }\n \n long long initialScore = calculateScore(companies);\n \n // Simulated annealing optimization\n int iters = 200000;\n double temp = 2.0;\n \n for (int iter = 0; iter < iters; iter++) {\n int idx = uniform_int_distribution(0, n - 1)(rng);\n Company r = companies[idx];\n \n vector> candidates;\n candidates.emplace_back(r.a, r.b);\n \n // Try shifted positions\n for (int da = -50; da <= 50; da += 10) {\n for (int db = -50; db <= 50; db += 10) {\n int a = max(0, min(r.c - r.a, r.a + da));\n int b = max(0, min(r.d - r.b, r.b + db));\n candidates.emplace_back(a, b);\n }\n }\n \n // Try area optimization\n for (int w = max(1, (int)sqrt(r.r / 10)); w < 100; w++) {\n int h = max(1, r.r / w + 1);\n int a = max(0, min(r.x, r.x - w / 2));\n int b = max(0, min(r.y, r.y - h / 2));\n candidates.emplace_back(a, b);\n }\n \n int bestA = r.a, bestB = r.b;\n double bestNewScore = calculateScore(companies);\n \n for (auto [da, db] : candidates) {\n Company newR = r;\n newR.a = max(0, da);\n newR.b = max(0, db);\n \n // Keep same dimensions\n newR.c = max(newR.a + (r.c - r.a), newR.a + 1);\n newR.d = max(newR.b + (r.d - r.b), newR.b + 1);\n newR.c = min(GRID, newR.c);\n newR.d = min(GRID, newR.d);\n \n if (newR.containsPoint()) {\n companies[idx] = newR;\n double newScore = calculateScore(companies);\n if (newScore > bestNewScore) {\n bestNewScore = newScore;\n bestA = newR.a;\n bestB = newR.b;\n }\n companies[idx] = r;\n }\n }\n \n companies[idx].a = bestA;\n companies[idx].b = bestB;\n \n if (uniform_real_distribution(0, 1)(rng) > temp / 100.0) {\n companies[idx] = r; // Revert with probability\n }\n \n temp *= 0.997;\n }\n \n // Final check - all points must be contained\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n if (!c.containsPoint()) {\n long long w = max(1LL, c.r);\n long long h = max(1LL, c.r / w + 1LL);\n \n c.a = max(0, c.x);\n c.c = min(GRID, max(c.x + 1, c.a + (int)w));\n c.b = max(0, c.y);\n c.d = min(GRID, max(c.y + 1, c.b + (int)h));\n }\n }\n \n for (int i = 0; i < n; i++) {\n cout << companies[i].a << \" \" << companies[i].b << \" \" \n << companies[i].c << \" \" << companies[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int DX[] = {-1, 1, 0, 0};\nconst int DY[] = {0, 0, -1, 1};\n\nstruct Solver {\n int H = 50, W = 50;\n int si, sj;\n vector> p;\n vector> tile;\n \n int global_best_score;\n vector> global_best_path;\n \n vector> path;\n vector tile_used_id;\n int current_score;\n \n mt19937 rng;\n int run_count;\n int backtrack_depth;\n int path_length_at_restart;\n \n struct Neighbor {\n int r, c, val, deg;\n double score;\n };\n vector neighbors;\n\n Solver() {\n p.assign(H, vector(W));\n tile.assign(H, vector(W));\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count());\n global_best_score = 0;\n backtrack_depth = 0;\n neighbors.reserve(4);\n }\n\n void read_input() {\n cin >> si >> sj;\n int max_id = 0;\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> tile[i][j];\n if (tile[i][j] > max_id) max_id = tile[i][j];\n }\n }\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> p[i][j];\n }\n }\n tile_used_id.assign(max_id + 1, 0);\n }\n\n void new_run() {\n path.clear();\n path.reserve(2500);\n path.push_back({si, sj});\n current_score = p[si][sj];\n fill(tile_used_id.begin(), tile_used_id.end(), 0);\n tile_used_id[tile[si][sj]] = 1;\n \n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n run_count++;\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count() + run_count * 12345);\n backtrack_depth = 0;\n path_length_at_restart = path.size();\n }\n\n bool is_valid(int r, int c) {\n return r >= 0 && r < H && c >= 0 && c < W;\n }\n\n void collect_neighbors(const pair& curr) {\n neighbors.clear();\n for (int d = 0; d < 4; ++d) {\n int nr = curr.first + DX[d];\n int nc = curr.second + DY[d];\n if (is_valid(nr, nc)) {\n int tid = tile[nr][nc];\n if (tile_used_id[tid] == 0) {\n int deg = 0;\n for (int dd = 0; dd < 4; ++dd) {\n int nrr = nr + DX[dd];\n int ncc = nc + DY[dd];\n if (is_valid(nrr, ncc) && tile_used_id[tile[nrr][ncc]] == 0) {\n deg++;\n }\n }\n // Score: value + degree (balanced weight)\n double score = p[nr][nc] + 2.0 * deg;\n neighbors.push_back({nr, nc, p[nr][nc], deg, score});\n }\n }\n }\n }\n\n void run() {\n auto start_time = chrono::high_resolution_clock::now();\n read_input();\n \n // Multiple independent runs\n const int NUM_RUNS = 20;\n \n for (int run = 0; run < NUM_RUNS; ++run) {\n new_run();\n \n const int TIME_LIMIT_MS = 1980; // Almost full time per run\n const int MAX_PATH_LENGTH = 2400;\n \n while (true) {\n auto now = chrono::high_resolution_clock::now();\n auto elapsed = chrono::duration_cast(now - start_time).count();\n \n if (elapsed > TIME_LIMIT_MS) break;\n if (static_cast(path.size()) > MAX_PATH_LENGTH) break;\n \n auto [curr_r, curr_c] = path.back();\n collect_neighbors({curr_r, curr_c});\n \n if (!neighbors.empty()) {\n // Sort by score descending\n sort(neighbors.begin(), neighbors.end(), [](const Neighbor& a, const Neighbor& b) {\n return a.score > b.score;\n });\n \n // 30% chance to pick random from top 3, 70% greedy\n int idx = 0;\n if (rng() % 100 < 30 && neighbors.size() >= 2) {\n idx = rng() % min((int)min(3, (int)neighbors.size()), (int)neighbors.size());\n }\n \n const Neighbor& n = neighbors[idx];\n \n path.push_back({n.r, n.c});\n tile_used_id[tile[n.r][n.c]] = 1;\n current_score += p[n.r][n.c];\n \n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n \n // Reset backtrack on progress\n backtrack_depth = 0;\n } else {\n // Stuck - check if we should restart or backtrack\n if (static_cast(path.size()) < max(10, path_length_at_restart + 100)) {\n // Restart - path too short\n new_run();\n } else {\n // Backtrack 1 step\n auto [r, c] = path.back();\n tile_used_id[tile[r][c]] = 0;\n current_score -= p[r][c];\n path.pop_back();\n backtrack_depth++;\n \n // If backtaacked too much at same level, restart\n if (backtrack_depth > 5 && static_cast(path.size()) == path_length_at_restart) {\n new_run();\n }\n }\n }\n }\n }\n \n // Output result\n string result = \"\";\n if (!global_best_path.empty()) {\n for (size_t i = 1; i < global_best_path.size(); ++i) {\n int dr = global_best_path[i].first - global_best_path[i-1].first;\n int dc = global_best_path[i].second - global_best_path[i-1].second;\n if (dr == -1) result += 'U';\n else if (dr == 1) result += 'D';\n else if (dc == -1) result += 'L';\n else if (dc == 1) result += 'R';\n }\n }\n cout << result << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n Solver solver;\n solver.run();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Edge weights for 30x30 grid with better initial distribution\nvector> h_edges(30, vector(29));\nvector> v_edges(29, vector(30));\n\n// Initialize with more realistic values\nvoid init_edge_weights() {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 29; j++) {\n h_edges[i][j] = 2000.0 + (rand() % 1001 - 212);\n }\n }\n for (int i = 0; i < 29; i++) {\n for (int j = 0; j < 30; j++) {\n v_edges[i][j] = 2000.0 + (rand() % 1001 - 212);\n }\n }\n}\n\nconst int N = 30;\nconst int MAX_WEIGHT = 20000;\nconst int MIN_WEIGHT = 100;\n\nstruct Node {\n int pos;\n int r, c;\n double dist;\n bool operator>(const Node& o) const {\n return dist > o.dist;\n }\n};\n\nstruct Result {\n string path;\n double predicted_length;\n bool valid;\n};\n\nResult find_shortest_path(int si, int sj, int ti, int tj) {\n int n_nodes = N * N;\n vector dist(n_nodes, 1e18);\n vector parent(n_nodes, -1);\n vector dir(n_nodes, 0);\n priority_queue, greater> pq;\n\n dist[si * N + sj] = 0.0;\n pq.push({si * N + sj, si, sj, 0.0});\n\n while (!pq.empty()) {\n Node top = pq.top();\n pq.pop();\n int u = top.pos;\n int ui = top.r, uj = top.c;\n\n if (ui == ti && uj == tj) break;\n if (top.dist > dist[u]) continue;\n \n // Move U\n if (ui > 0) {\n int v_pos = (ui - 1) * N + uj;\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ui - 1][uj]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'U';\n pq.push({v_pos, ui - 1, uj, dist[v_pos]});\n }\n }\n // Move D\n if (ui < N - 1) {\n int v_pos = (ui + 1) * N + uj;\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ui][uj]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'D';\n pq.push({v_pos, ui + 1, uj, dist[v_pos]});\n }\n }\n // Move L\n if (uj > 0) {\n int v_pos = ui * N + (uj - 1);\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ui][uj - 1]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'L';\n pq.push({v_pos, ui, uj - 1, dist[v_pos]});\n }\n }\n // Move R\n if (uj < N - 1) {\n int v_pos = ui * N + (uj + 1);\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ui][uj]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'R';\n pq.push({v_pos, ui, uj + 1, dist[v_pos]});\n }\n }\n }\n\n if (dist[ti * N + tj] >= 1e17) {\n return {\"\", 0.0, false};\n }\n\n string path;\n int curr = ti * N + tj;\n while (curr != si * N + sj) {\n if (parent[curr] == -1) {\n return {\"\", 0.0, false};\n }\n path += dir[curr];\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n\n double pred_len = 0.0;\n int ci = si, cj = sj;\n for (char c : path) {\n if (c == 'U') { ci--; pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ci][cj])); }\n else if (c == 'D') { pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ci][cj])); ci++; }\n else if (c == 'L') { cj--; pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ci][cj])); }\n else if (c == 'R') { pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ci][cj])); cj++; }\n }\n\n return {path, pred_len, true};\n}\n\nbool is_path_valid(const string& path, int si, int sj, int ti, int tj) {\n int i = si, j = sj;\n for (char c : path) {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n if (c == 'U') i--;\n else if (c == 'D') i++;\n else if (c == 'L') j--;\n else if (c == 'R') j++;\n }\n return i == ti && j == tj;\n}\n\ndouble compute_path_length(const string& path, int si, int sj) {\n double len = 0.0;\n int i = si, j = sj;\n for (char c : path) {\n if (c == 'U') {\n if (--i < 0 || i >= N) break;\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n } else if (c == 'D') {\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n if (++i >= N) break;\n } else if (c == 'L') {\n if (--j < 0 || j >= N) break;\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n } else if (c == 'R') {\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n if (++j >= N) break;\n }\n }\n return len;\n}\n\nstring generate_optimized_path(int si, int sj, int ti, int tj) {\n string path = \"\";\n int i = si, j = sj;\n int steps = 0;\n int target = (ti * N + tj) - (si * N + sj);\n\n while ((i != ti || j != tj) && steps < 10000) {\n int best_d = -1;\n double best_w = 1e18;\n int best_i = i, best_j = j;\n\n int di[] = {0, 0, 1, -1};\n int dj[] = {1, -1, 0, 0};\n char dirs[] = {'R', 'L', 'D', 'U'};\n\n for (int k = 0; k < 4; k++) {\n int ni = i + di[k];\n int nj = j + dj[k];\n\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n int nd = abs(ni - ti) + abs(nj - tj);\n int cd = abs(i - ti) + abs(j - tj);\n \n int ei = 0, ej = 0;\n if (dirs[k] == 'U') { ei = i - 1; ej = j; }\n else if (dirs[k] == 'D') { ei = i; ej = j; }\n else if (dirs[k] == 'L') { ei = i; ej = j - 1; }\n else if (dirs[k] == 'R') { ei = i; ej = j; }\n\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT,\n (dirs[k] == 'U' || dirs[k] == 'D') ? v_edges[ei][ej] : h_edges[ei][ej]));\n\n // Prefer moves that reduce Manhattan distance first\n if (nd < cd && w < best_w) {\n best_w = w;\n best_d = k;\n best_i = ni;\n best_j = nj;\n }\n // If not reducing distance but still valid\n else if (nd >= cd && k == 0 && w < best_w) {\n best_w = w;\n best_d = k;\n best_i = ni;\n best_j = nj;\n }\n }\n }\n\n if (best_d == -1 || best_w >= 1e18) {\n path += \"D\";\n i++;\n break;\n }\n\n path += dirs[best_d];\n i = best_i;\n j = best_j;\n steps++;\n\n if (i < 0 || i >= N || j < 0 || j >= N) {\n i = si; j = sj;\n break;\n }\n }\n\n // Complete remaining distance if truncated\n while (i != ti || j != tj) {\n if (i != ti) {\n path += (i < ti) ? \"D\" : \"U\";\n i += (i < ti) ? 1 : -1;\n } else if (j != tj) {\n path += (j < tj) ? \"R\" : \"L\";\n j += (j < tj) ? 1 : -1;\n }\n }\n\n return path;\n}\n\nstring generate_simple_path(int si, int sj, int ti, int tj) {\n string path;\n while (si < ti) path += 'D', ++si;\n while (si > ti) path += 'U', --si;\n while (sj < tj) path += 'R', ++sj;\n while (sj > tj) path += 'L', --sj;\n return path;\n}\n\nvoid update_edge_weights(int si, int sj, const string& path, double predicted, int actual, int query_idx) {\n if (path.empty() || predicted < 0.1 || actual <= 0) return;\n\n // Adaptive learning rate: higher early, decreases slightly\n double base_lr = 0.35;\n double lr = base_lr * max(0.7, 1.0 - 0.3 * (query_idx / 1000.0));\n\n double error = (double)actual - predicted;\n int num_edges = path.length();\n if (num_edges == 0) return;\n\n // Larger early updates, smaller late updates\n double max_update = 800.0;\n double update = (error / num_edges) * lr;\n if (update > max_update) update = max_update;\n if (update < -max_update) update = -max_update;\n\n int i = si, j = sj;\n for (char c : path) {\n if (c == 'U') {\n if (--i >= 0 && i < N) {\n v_edges[i][j] += update;\n v_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n }\n } else if (c == 'D') {\n v_edges[i][j] += update;\n v_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n if (++i >= N) break;\n } else if (c == 'L') {\n if (--j >= 0 && j < N) {\n h_edges[i][j] += update;\n h_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n }\n } else if (c == 'R') {\n h_edges[i][j] += update;\n h_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n if (++j >= N) break;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n srand(0);\n init_edge_weights();\n\n int si, sj, ti, tj;\n int feedback;\n\n for (int k = 0; k < 1000; k++) {\n if (!(cin >> si >> sj >> ti >> tj)) break;\n\n Result res = find_shortest_path(si, sj, ti, tj);\n\n string path;\n double predicted = 0.0;\n\n if (res.valid && is_path_valid(res.path, si, sj, ti, tj) && res.predicted_length > 0) {\n path = res.path;\n predicted = res.predicted_length;\n } else {\n path = generate_optimized_path(si, sj, ti, tj);\n if (path.empty()) {\n path = generate_simple_path(si, sj, ti, tj);\n }\n predicted = compute_path_length(path, si, sj);\n }\n\n cout << path << \"\\n\";\n cout.flush();\n\n if (cin >> feedback) {\n update_edge_weights(si, sj, path, predicted, feedback, k);\n }\n }\n\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconstexpr int N = 20;\nconst int MAXM = 805;\n\nint M;\nstring s[MAXM];\nint len[MAXM];\nchar grid[N][N];\n\nint miscount[MAXM][N][N][2];\nint sat_placements[MAXM];\nint total_satisfied;\nint current_dots;\nchar best_grid[N][N];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n_in, m_in;\n if (!(cin >> n_in >> M)) return 0;\n \n for(int i = 0; i < M; i++) {\n cin >> s[i];\n len[i] = s[i].length();\n }\n \n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Initialize grid\n current_dots = 0;\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n grid[i][j] = (char)('A' + ((int)rng() & 7));\n best_grid[i][j] = grid[i][j];\n }\n }\n \n // Initialize statistics\n for(int i = 0; i < M; i++) {\n sat_placements[i] = 0;\n int L = len[i];\n for(int r = 0; r < N; r++) {\n for(int c = 0; c < N; c++) {\n int mm = 0;\n for(int k = 0; k < L; k++) {\n if(grid[r][(c + k) % N] != s[i][k]) mm++;\n }\n miscount[i][r][c][0] = mm;\n if(mm == 0) sat_placements[i]++;\n \n mm = 0;\n for(int k = 0; k < L; k++) {\n if(grid[(r + k) % N][c] != s[i][k]) mm++;\n }\n miscount[i][r][c][1] = mm;\n if(mm == 0) sat_placements[i]++;\n }\n }\n }\n \n total_satisfied = 0;\n for(int i = 0; i < M; i++) \n if(sat_placements[i] > 0) total_satisfied++;\n \n // Simulated annealing - fast single run\n int max_iter = 5000;\n \n for(int iter = 0; iter < max_iter; iter++) {\n double temp = max(0.01, 200.0 * pow(0.995, iter));\n \n int r = (int)((unsigned long long)rng() & (N - 1));\n int c = (int)((unsigned long long)rng() & (N - 1));\n \n char old_char = grid[r][c];\n int cand = (int)((unsigned long long)rng() & 8);\n char new_char = (cand == 8 ? '.' : (char)('A' + cand));\n \n if(new_char == old_char) continue;\n \n int prev_sat = total_satisfied;\n int prev_dots = current_dots;\n int prev_score = total_satisfied * 100000000;\n if(prev_sat == M) prev_score += prev_dots;\n \n int next_sat = total_satisfied;\n int next_dots = current_dots;\n \n // Apply change - update all affected placements\n for(int i = 0; i < M; i++) {\n int L = len[i];\n const string& str = s[i];\n \n for(int delta = 0; delta < L; delta++) {\n // Horizontal\n int start_h = (c - delta + N) % N;\n int &mc_h = miscount[i][r][start_h][0];\n int old_mm = (old_char != str[delta]);\n int new_mm = (new_char != str[delta]);\n \n if(old_mm && !new_mm) {\n mc_h--;\n if(--sat_placements[i] == 0) next_sat--;\n } else if(!old_mm && new_mm) {\n mc_h++;\n if(++sat_placements[i] == 1) next_sat++;\n } else {\n mc_h += new_mm - old_mm;\n }\n \n // Vertical\n int start_v = (r - delta + N) % N;\n int &mc_v = miscount[i][start_v][c][1];\n \n if(old_mm && !new_mm) {\n mc_v--;\n if(--sat_placements[i] == 0) next_sat--;\n } else if(!old_mm && new_mm) {\n mc_v++;\n if(++sat_placements[i] == 1) next_sat++;\n } else {\n mc_v += new_mm - old_mm;\n }\n }\n }\n \n grid[r][c] = new_char;\n if(new_char == '.' && old_char != '.') next_dots++;\n else if(new_char != '.' && old_char == '.') next_dots--;\n \n int next_score = next_sat * 100000000;\n if(next_sat == M) next_score += next_dots;\n \n bool accept = false;\n if(next_score > prev_score) {\n accept = true;\n } else {\n double delta = (double)(next_score - prev_score);\n double prob = exp(delta / temp + 1.0);\n if(prob > 2.718) prob = 1.0;\n double rand_val = ((double)rng()) / (double)(numeric_limits::max() + 1);\n if(rand_val < prob) accept = true;\n }\n \n if(accept) {\n total_satisfied = next_sat;\n current_dots = next_dots;\n if(next_score > sat_placements[0] * 100000000) {\n int bs = total_satisfied * 100000000;\n if(total_satisfied == M) bs += current_dots;\n if(bs > 0) {\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n best_grid[i][j] = grid[i][j];\n }\n }\n }\n }\n } else {\n // Revert\n grid[r][c] = old_char;\n total_satisfied = prev_sat;\n current_dots = prev_dots;\n \n for(int i = 0; i < M; i++) {\n int L = len[i];\n const string& str = s[i];\n \n for(int delta = 0; delta < L; delta++) {\n int start_h = (c - delta + N) % N;\n int &mc_h = miscount[i][r][start_h][0];\n int old_mm = (old_char != str[delta]);\n int new_mm = (new_char != str[delta]);\n \n if(old_mm && !new_mm) {\n mc_h++;\n if(++sat_placements[i] == 1) next_sat++;\n } else if(!old_mm && new_mm) {\n mc_h--;\n if(--sat_placements[i] == 0) next_sat--;\n } else {\n mc_h += old_mm - new_mm;\n }\n \n int start_v = (r - delta + N) % N;\n int &mc_v = miscount[i][start_v][c][1];\n \n if(old_mm && !new_mm) {\n mc_v++;\n if(++sat_placements[i] == 1) next_sat++;\n } else if(!old_mm && new_mm) {\n mc_v--;\n if(--sat_placements[i] == 0) next_sat--;\n } else {\n mc_v += old_mm - new_mm;\n }\n \n sat_placements[i] = prev_sat;\n if(sat_placements[i] == prev_sat) next_sat = prev_sat;\n }\n }\n }\n }\n \n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n cout << best_grid[i][j];\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 75;\nconst int INF = 1000000000;\n\nint N, si, sj;\nvector grid;\nchar dirs[] = {'U', 'D', 'L', 'R'};\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\n\nint dist[MAX_N][MAX_N];\npair parent[MAX_N][MAX_N];\nchar parent_dir[MAX_N][MAX_N];\nbool visited[MAX_N][MAX_N];\nbool covered[MAX_N][MAX_N];\nint road_cells[MAX_N][MAX_N];\nint road_cnt;\nint covered_cnt = 0;\nvector> roads;\n\ninline bool isValid(int r, int c) {\n return r >= 0 && r < (size_t)N && c >= 0 && c < (size_t)N && grid[r][c] != '#';\n}\n\nbool checkVisibility(int r1, int c1, int r2, int c2) {\n if (r1 == r2) {\n int low = min(c1, c2), high = max(c1, c2);\n for (int c = low; c <= high; c++) {\n if (grid[r1][c] == '#') return false;\n }\n return true;\n } else if (c1 == c2) {\n int low = min(r1, r2), high = max(r1, r2);\n for (int r = low; r <= high; r++) {\n if (grid[r][c1] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\nvoid bfs(int sr, int sc) {\n memset(visited, 0, sizeof(visited));\n memset(dist, 0x3f, sizeof(dist));\n \n queue> q;\n q.push({sr, sc});\n dist[sr][sc] = 0;\n visited[sr][sc] = true;\n parent[sr][sc] = {-1, -1};\n \n while (!q.empty()) {\n pair cur = q.front();\n q.pop();\n int r = cur.first, c = cur.second;\n \n for (int k = 0; k < 4; k++) {\n int nr = r + di[k];\n int nc = c + dj[k];\n \n if (isValid(nr, nc) && !visited[nr][nc]) {\n visited[nr][nc] = true;\n int w = grid[nr][nc] - '0';\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n parent_dir[nr][nc] = dirs[k];\n q.push({nr, nc});\n }\n }\n }\n}\n\nstring get_path(int er, int ec) {\n if (!visited[er][ec]) return \"\";\n \n string path = \"\";\n int r = er, c = ec;\n while (parent[r][c].first != -1) {\n path += parent_dir[r][c];\n pair p = parent[r][c];\n r = p.first;\n c = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nvoid update_all_coverage(int r, int c) {\n for (const auto& sq : roads) {\n int rr = sq.first, cc = sq.second;\n if (covered[rr][cc]) continue;\n if (checkVisibility(r, c, rr, cc)) {\n covered[rr][cc] = true;\n covered_cnt++;\n }\n }\n}\n\nint count_uncovered(int r, int c) {\n int cnt = 0;\n for (const auto& sq : roads) {\n int rr = sq.first, cc = sq.second;\n if (!covered[rr][cc] && checkVisibility(r, c, rr, cc)) {\n cnt++;\n }\n }\n return cnt;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> si >> sj;\n grid.resize(N);\n covered_cnt = 0;\n roads.clear();\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 roads.push_back({i, j});\n road_cells[i][j] = 1;\n }\n }\n }\n \n road_cnt = roads.size();\n memset(covered, 0, sizeof(covered));\n memset(dist, 0x3f, sizeof(dist));\n \n string path = \"\";\n int cr = si, cc = sj;\n \n covered[cr][cc] = true;\n covered_cnt = 1;\n update_all_coverage(cr, cc);\n \n if (covered_cnt >= road_cnt) {\n cout << path << endl;\n return 0;\n }\n \n int max_iterations = road_cnt * 2 + 1000;\n int iter = 0;\n int path_len = 0;\n \n while (covered_cnt < road_cnt && iter < max_iterations && path_len < 500000) {\n iter++;\n \n int best_rr = -1, best_cc = -1;\n int best_gain = 0;\n int best_dist = INF;\n \n for (const auto& sq : roads) {\n int rr = sq.first, cc = sq.second;\n if (covered[rr][cc]) continue;\n \n int gain = count_uncovered(rr, cc);\n if (gain == 0) continue;\n \n bfs(cr, cc);\n if (!visited[rr][cc] || dist[rr][cc] >= INF) {\n continue;\n }\n \n int d = dist[rr][cc];\n int score = gain * 1000 / max(d + 1, 1);\n \n if (gain > best_gain || (gain == best_gain && d < best_dist)) {\n best_gain = gain;\n best_dist = d;\n best_rr = rr;\n best_cc = cc;\n }\n }\n \n if (best_rr != -1) {\n bfs(cr, cc);\n string seg = get_path(best_rr, best_cc);\n if (seg.empty()) {\n break;\n }\n path = path + seg;\n path_len = path.length();\n cr = best_rr;\n cc = best_cc;\n update_all_coverage(cr, cc);\n \n if (covered_cnt >= road_cnt) {\n break;\n }\n } else {\n break;\n }\n }\n \n if (cr != si || cc != sj) {\n bfs(cr, cc);\n string ret = get_path(si, sj);\n if (!ret.empty()) {\n path = path + ret;\n }\n }\n \n cout << path << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector dependencies;\n vector dependents;\n bool completed = false;\n bool started = false;\n int assigned_member = -1;\n int start_day = 0;\n int difficulty_sum = 0;\n};\n\nstruct Member {\n int id;\n int completion_count = 0;\n vector completed_times;\n vector completed_difficulties;\n vector skill_estimate;\n vector skill_confidence;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K, R;\n cin >> N >> M >> K >> R;\n \n // Read tasks\n vector tasks(N);\n for (int i = 0; i < N; i++) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n tasks[i].dependencies.clear();\n tasks[i].dependents.clear();\n tasks[i].completed = false;\n tasks[i].started = false;\n tasks[i].assigned_member = -1;\n tasks[i].start_day = 0;\n tasks[i].difficulty_sum = 0;\n for (int k = 0; k < K; k++) {\n cin >> tasks[i].d[k];\n tasks[i].difficulty_sum += tasks[i].d[k];\n }\n }\n \n // Read dependencies\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].dependencies.push_back(u);\n tasks[u].dependents.push_back(v);\n }\n \n // Initialize members\n vector members(M);\n for (int i = 0; i < M; i++) {\n members[i].id = i;\n members[i].completion_count = 0;\n members[i].completed_times.clear();\n members[i].completed_difficulties.clear();\n members[i].skill_estimate.resize(K, 10);\n members[i].skill_confidence.resize(K, 1.0);\n }\n \n int current_day = 0;\n \n while (current_day < 2000) {\n current_day++;\n \n // Read completions (skip on first day)\n if (current_day > 1) {\n int n_completed;\n cin >> n_completed;\n \n if (n_completed == -1) break;\n \n for (int i = 0; i < n_completed; i++) {\n int member_idx;\n cin >> member_idx;\n member_idx--;\n \n if (member_idx >= 0 && member_idx < M) {\n // Find completed task\n for (int t = 0; t < N; t++) {\n if (tasks[t].started && !tasks[t].completed && \n tasks[t].assigned_member == member_idx) {\n \n tasks[t].completed = true;\n tasks[t].assigned_member = -1;\n tasks[t].started = false;\n \n // Record completion\n int actual_time = current_day - tasks[t].start_day + 1;\n members[member_idx].completed_times.push_back(actual_time);\n members[member_idx].completed_difficulties.push_back(tasks[t].difficulty_sum);\n members[member_idx].completion_count++;\n \n // Update skill estimates per dimension\n for (int k = 0; k < K; k++) {\n int task_d = tasks[t].d[k];\n \n if (actual_time == 1) {\n members[member_idx].skill_estimate[k] = max(\n members[member_idx].skill_estimate[k],\n task_d + 20\n );\n } else {\n int old_skill = members[member_idx].skill_estimate[k];\n int new_skill = old_skill - (task_d - old_skill) / (actual_time + 1);\n members[member_idx].skill_estimate[k] = max(5, min(task_d + 10, new_skill));\n }\n \n members[member_idx].skill_confidence[k] += 1.0;\n }\n \n break;\n }\n }\n }\n }\n }\n \n // Find free members\n vector free_members;\n for (int m = 0; m < M; m++) {\n bool is_busy = false;\n for (int t = 0; t < N; t++) {\n if (tasks[t].started && !tasks[t].completed && \n tasks[t].assigned_member == m) {\n is_busy = true;\n break;\n }\n }\n if (!is_busy) {\n free_members.push_back(m);\n }\n }\n \n // Find ready tasks\n vector ready_tasks;\n for (int t = 0; t < N; t++) {\n if (tasks[t].started || tasks[t].completed) continue;\n \n bool all_deps_done = true;\n for (size_t dep_idx = 0; dep_idx < tasks[t].dependencies.size(); dep_idx++) {\n int dep = tasks[t].dependencies[dep_idx];\n if (!tasks[dep].completed) {\n all_deps_done = false;\n break;\n }\n }\n if (all_deps_done) {\n ready_tasks.push_back(t);\n }\n }\n \n // Sort by priority\n sort(ready_tasks.begin(), ready_tasks.end(), [&](int a, int b) {\n size_t dep_count_a = tasks[a].dependents.size();\n size_t dep_count_b = tasks[b].dependents.size();\n if (dep_count_a != dep_count_b) return dep_count_a > dep_count_b;\n return tasks[a].difficulty_sum < tasks[b].difficulty_sum;\n });\n \n // Assign tasks\n vector> assignments;\n vector used_members;\n \n for (int task_idx : ready_tasks) {\n if (free_members.empty()) break;\n \n int best_member = -1;\n double best_score = 1e18;\n \n for (int m : free_members) {\n double score = 0.0;\n \n if (members[m].completion_count == 0) {\n score = tasks[task_idx].difficulty_sum / 25.0 + 3.0;\n } else {\n int total_skill = 0;\n for (int k = 0; k < K; k++) {\n total_skill += members[m].skill_estimate[k];\n }\n double avg_skill = total_skill / (double)K;\n int diff_per_dim = tasks[task_idx].difficulty_sum / K;\n \n double skill_gap = diff_per_dim - avg_skill;\n double predicted_time = 2.0 + max(0.0, skill_gap / 5.0);\n \n double time_factor = 1.0;\n if (members[m].completion_count > 5) {\n double avg_time = 0.0;\n for (size_t i = 0; i < members[m].completed_times.size(); i++) {\n avg_time += members[m].completed_times[i];\n }\n avg_time /= (double)members[m].completion_count;\n time_factor = avg_time / 3.0;\n }\n \n score = predicted_time * time_factor;\n }\n \n if (score < best_score) {\n best_score = score;\n best_member = m;\n }\n }\n \n if (best_member != -1) {\n assignments.push_back({best_member, task_idx});\n used_members.push_back(best_member);\n \n tasks[task_idx].started = true;\n tasks[task_idx].assigned_member = best_member;\n tasks[task_idx].start_day = current_day;\n \n // Remove from free members\n for (size_t i = 0; i < free_members.size(); i++) {\n if (free_members[i] == best_member) {\n free_members.erase(free_members.begin() + (int)i);\n break;\n }\n }\n }\n }\n \n // Output assignments\n cout << assignments.size();\n for (int i = 0; i < (int)assignments.size(); i++) {\n cout << \" \" << assignments[i].first + 1 << \" \" << assignments[i].second + 1;\n }\n cout << endl;\n cout.flush();\n \n // Check if all completed\n bool all_done = true;\n for (int t = 0; t < N; t++) {\n if (!tasks[t].completed) {\n all_done = false;\n break;\n }\n }\n if (all_done) break;\n }\n \n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int DEPOT_X = 400;\nconst int DEPOT_Y = 400;\nconst int N_ORDERS = 1000;\nconst int ORDERS_TO_SELECT = 50;\n\ninline int get_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nstruct Order {\n int id; \n int a, b; \n int c, d; \n double base_cost;\n};\n\nstruct PathData {\n vector> coords;\n vector path; \n int cost;\n};\n\nvector orders;\nmt19937 rng(42);\n\nPathData solve_subset_path(const vector& sub_set, int optimization_iters) {\n PathData res;\n res.path.reserve(102);\n res.coords.resize(101);\n \n res.coords[0].first = DEPOT_X;\n res.coords[0].second = DEPOT_Y;\n \n for(int k = 0; k < ORDERS_TO_SELECT; ++k) {\n int idx = sub_set[k];\n res.coords[k+1].first = orders[idx].a;\n res.coords[k+1].second = orders[idx].b;\n res.coords[k+51].first = orders[idx].c;\n res.coords[k+51].second = orders[idx].d;\n }\n \n vector visited(101, false);\n vector pickup_done(50, false);\n res.path.push_back(0);\n int cx = DEPOT_X, cy = DEPOT_Y;\n \n for(int s = 0; s < 100; ++s) {\n int best_node = -1, min_d = 2000000000;\n for(int node = 1; node <= 100; ++node) {\n if(!visited[node]) {\n if(node > 50 && !pickup_done[node - 51]) continue;\n int d = get_dist(cx, cy, res.coords[node].first, res.coords[node].second);\n if(d < min_d) { min_d = d; best_node = node; }\n }\n }\n if(best_node == -1) break;\n visited[best_node] = true;\n res.path.push_back(best_node);\n cx = res.coords[best_node].first;\n cy = res.coords[best_node].second;\n if(best_node <= 50) pickup_done[best_node - 1] = true;\n }\n res.path.push_back(0);\n \n res.cost = 0;\n cx = DEPOT_X; cy = DEPOT_Y;\n for(size_t i = 0; i < res.path.size(); ++i) {\n cx = res.coords[res.path[i]].first;\n cy = res.coords[res.path[i]].second;\n if(i + 1 < res.path.size()) {\n int nx = res.coords[res.path[i+1]].first;\n int ny = res.coords[res.path[i+1]].second;\n res.cost += get_dist(cx, cy, nx, ny);\n }\n }\n\n if(optimization_iters > 0) {\n int path_len = (int)res.path.size();\n for(int iter = 0; iter < optimization_iters; ++iter) {\n int i = (int)(rng() % (path_len - 2)) + 1;\n int j = (int)(rng() % (path_len - 2)) + 1;\n if(i == j) continue;\n \n int u = res.path[i], v = res.path[j];\n if((u <= 50 && v == u + 50) || (v <= 50 && u == v + 50)) {\n res.path[i] = u; res.path[j] = v;\n continue;\n }\n \n res.path[i] = v;\n res.path[j] = u;\n \n bool valid = true;\n for(int k = 1; k <= 50 && valid; ++k) {\n int posP = -1, posD = -1;\n for(int m = 0; m < path_len; ++m) {\n if(res.path[m] == k) posP = m;\n if(res.path[m] == k + 50) posD = m;\n }\n if(posP > posD) valid = false;\n }\n \n if(valid) {\n int new_cost = 0;\n int cx_l = DEPOT_X, cy_l = DEPOT_Y;\n for(size_t m = 0; m < res.path.size() - 1; ++m) {\n cx_l = res.coords[res.path[m]].first;\n cy_l = res.coords[res.path[m]].second;\n int nx = res.coords[res.path[m+1]].first;\n int ny = res.coords[res.path[m+1]].second;\n new_cost += get_dist(cx_l, cy_l, nx, ny);\n }\n if(new_cost >= res.cost) {\n res.path[i] = u; res.path[j] = v;\n } else {\n res.cost = new_cost;\n }\n } else {\n res.path[i] = u; res.path[j] = v;\n }\n }\n }\n return res;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n vector p(N_ORDERS);\n \n for(int i = 0; i < N_ORDERS; ++i) {\n orders.push_back(Order());\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i + 1;\n orders[i].base_cost = (double)(get_dist(DEPOT_X, DEPOT_Y, orders[i].a, orders[i].b) +\n get_dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d) +\n get_dist(orders[i].c, orders[i].d, DEPOT_X, DEPOT_Y));\n p[i] = i;\n }\n \n sort(p.begin(), p.end(), [&](int a, int b) {\n return orders[a].base_cost < orders[b].base_cost;\n });\n \n int K = min(80, N_ORDERS);\n vector pool(K);\n for(int i = 0; i < K; ++i) {\n pool[i] = p[i];\n }\n \n // Track which positions in subset are active (always all 50 positions have values)\n // Track which pool indices are currently in subset vs pool_remaining \n vector in_subset(N_ORDERS, false);\n \n vector subset, subset_values_in_pool_index; // Maps subset position to pool_index\n vector pool_remaining_indices; // Pool indices NOT in subset\n \n // Initialize: first 50 pool elements in subset\n for(int i = 0; i < 50; ++i) {\n subset.push_back(pool[i]);\n subset_values_in_pool_index.push_back(i);\n in_subset[pool[i]] = true;\n }\n for(int i = 50; i < K; ++i) {\n pool_remaining_indices.push_back(i); // Pool indices 50..K-1\n }\n \n vector best_subset = subset;\n int best_T = solve_subset_path(subset, 500).cost;\n \n for(int iter = 0; iter < 500; ++iter) {\n int i = (int)(rng() % 50); // Position in subset to remove\n int j = (int)(rng() % (K - 50)); // Index in pool_remaining\n int pool_idx_to_add = pool_remaining_indices[j];\n int pool_idx_to_remove_from_subset = subset_values_in_pool_index[i];\n \n int from_idx = subset[i]; // Current value at subset position i\n int to_idx = pool[pool_idx_to_add]; // New value to add\n \n // Perform swap\n subset[i] = to_idx;\n subset_values_in_pool_index[i] = pool_idx_to_add;\n \n // Update in_subset tracking\n in_subset[from_idx] = false;\n in_subset[to_idx] = true;\n \n // Update pool_remaining: remove pool_idx_to_add and add pool_idx_to_remove_from_subset\n for(int k = 0; k < (int)pool_remaining_indices.size(); ++k) {\n if(pool_remaining_indices[k] == pool_idx_to_add) {\n pool_remaining_indices[k] = pool_idx_to_remove_from_subset;\n break;\n }\n }\n \n int current_cost = solve_subset_path(subset, 500).cost;\n if(current_cost < best_T) {\n best_T = current_cost;\n best_subset = subset;\n } else {\n // Revert\n subset[i] = from_idx;\n subset_values_in_pool_index[i] = pool_idx_to_remove_from_subset;\n in_subset[from_idx] = true;\n in_subset[to_idx] = false;\n \n for(int k = 0; k < (int)pool_remaining_indices.size(); ++k) {\n if(pool_remaining_indices[k] == pool_idx_to_remove_from_subset) {\n pool_remaining_indices[k] = pool_idx_to_add;\n break;\n }\n }\n }\n }\n \n PathData final_path = solve_subset_path(best_subset, 5000);\n \n cout << ORDERS_TO_SELECT << \" \";\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) {\n cout << orders[best_subset[i]].id << \" \";\n }\n cout << \"\\n102 \";\n for(int x : final_path.path) {\n cout << final_path.coords[x].first << \" \" << final_path.coords[x].second << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc007":"/*\n AHC007 - Final Correct Solution\n Strategy: Pure Kruskal's-like greedy approach\n - Accept ALL edges that connect different components\n - Only reject edges that form cycles\n - This guarantees connectivity\n - Cost is minimized through greedy selection\n \n Given M=1995 edges and N=400 vertices, even accepting many edges\n won't cause cost issues since we have 5x redundancy in MSTs.\n*/\n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 400;\nconst int M = 1995;\n\n// DSU structure with union by size\nstruct DSU {\n vector parent;\n vector size;\n int components;\n\n DSU(int n) : parent(n), size(n, 1), components(n) {\n iota(parent.begin(), parent.end(), 0);\n }\n\n int find(int a) {\n int root = a;\n while (parent[root] != root) {\n root = parent[root];\n }\n // Path compression\n while (a != root) {\n int next = parent[a];\n parent[a] = root;\n a = next;\n }\n return root;\n }\n\n bool unite(int a, int b) {\n a = find(a);\n b = find(b);\n if (a != b) {\n // Union by size\n if (size[a] < size[b]) swap(a, b);\n parent[b] = a;\n size[a] += size[b];\n components--;\n return true;\n }\n return false;\n }\n};\n\n// Read coordinates and edges\nstruct EdgeInput {\n int u, v;\n int d;\n int original_idx;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read N vertex coordinates\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) {\n cin >> X[i] >> Y[i];\n }\n\n // Read M edges and compute Euclidean distances\n vector edge_info(M);\n for (int i = 0; i < M; ++i) {\n cin >> edge_info[i].u >> edge_info[i].v;\n edge_info[i].original_idx = i;\n \n long long dx = X[edge_info[i].u] - X[edge_info[i].v];\n long long dy = Y[edge_info[i].u] - Y[edge_info[i].v];\n double dist = std::sqrt((double)dx * dx + (double)dy * dy);\n edge_info[i].d = std::round(dist);\n }\n\n // Calculate rank for each edge based on Euclidean distance\n // Lower rank = smaller distance = potentially cheaper\n vector sorted_indices(M);\n std::iota(sorted_indices.begin(), sorted_indices.end(), 0);\n \n std::sort(sorted_indices.begin(), sorted_indices.end(), [&](int a, int b) {\n if (edge_info[a].d != edge_info[b].d) {\n return edge_info[a].d < edge_info[b].d;\n }\n return edge_info[a].original_idx < edge_info[b].original_idx;\n });\n\n // Map from original_idx to rank\n vector rank_map(M);\n for (int i = 0; i < M; ++i) {\n rank_map[sorted_indices[i]] = i;\n }\n\n // Initialize DSU for connectivity tracking\n DSU dsu(N);\n\n // Process M edge revelations interactively\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n\n int u = edge_info[i].u;\n int v = edge_info[i].v;\n\n // Kruskal's greedy approach:\n // Accept if edge connects different components\n // This guarantees connectivity since we accept until tree is formed\n bool should_accept = !dsu.find(u) || dsu.find(u) != dsu.find(v);\n \n // Actually, check if find returns different roots\n bool connects = (dsu.find(u) != dsu.find(v));\n\n if (connects) {\n dsu.unite(u, v);\n cout << 1 << endl;\n } else {\n cout << 0 << endl;\n }\n cout.flush();\n }\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;\nusing namespace atcoder;\n\nclass Solver {\nprivate:\n int N, M;\n struct Pet {\n int px, py, type;\n };\n struct Human {\n int x, y;\n };\n \n vector pets;\n vector humans;\n bool blocked[35][35];\n \n mt19937 rng;\n int currentTurn;\n \n const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // U, D, L, R\n \n bool inBounds(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n // Check if position is blocked or occupied\n bool isBlocked(int x, int y, int turn, bool initial = false) {\n if (blocked[x][y]) return true;\n \n if (initial || turn == 0) {\n for (auto& p : pets) {\n if (p.px == x && p.py == y) return true;\n }\n for (auto& h : humans) {\n if (h.x == x && h.y == y) return true;\n }\n }\n \n // Check adjacency to pets (for blocking)\n for (auto& p : pets) {\n int dist = abs(p.px - x) + abs(p.py - y);\n if (dist <= 1 && (dist != 0)) return true;\n }\n \n return false;\n }\n \n int countReachable(int x, int y) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int count = 1;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n count++;\n q.push({nx, ny});\n }\n }\n }\n return count;\n }\n \n int countPetsInArea(int x, int y) {\n int count = 0;\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n reachable++;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n // Count pets in reachable area\n for (auto& p : pets) {\n if (reachable > 0 && inBounds(p.px, p.py)) {\n // Simple reachability check\n bool visited2[35][35];\n memset(visited2, 0, sizeof(visited2));\n if (canReach(p.px, p.y, x, y, visited2)) {\n count++;\n }\n }\n }\n \n return count;\n }\n \n bool canReach(int x1, int y1, int x2, int y2, bool& visited[35][35]) {\n // BFS to check reachability\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x1, y1});\n visited[x1][y1] = true;\n \n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n if (cx == x2 && cy == y2) return true;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n return false;\n }\n \n bool canReach(int x1, int y1, int x2, int y2) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n return canReach(x1, y1, x2, y2, visited);\n }\n \n // Choose best action for each human\n string decideAction(int humanIdx, int turn) {\n auto& h = humans[humanIdx];\n double bestScore = 0;\n string bestAction = \".\";\n \n // Evaluate all possible actions\n // Action: stay, block (4 directions), move (4 directions)\n \n // Try blocking\n for (int d = 0; d < 4; d++) {\n int bx = h.x + dirs[d][0];\n int by = h.y + dirs[d][1];\n \n bool valid = true;\n if (!inBounds(bx, by)) valid = false;\n if (blocked[bx][by]) valid = false;\n if (turn == 0) {\n // Initial positions - occupied check\n for (auto& p : pets) {\n if (p.px == bx && p.py == by || \n abs(p.px - bx) + abs(p.py - by) == 1) {\n valid = false;\n break;\n }\n }\n if (valid) {\n for (auto& h2 : humans) {\n if ((h2.x == bx && h2.y == by) ||\n (h2.x != h.x || h2.y != h.y) && \n abs(h2.x - bx) + abs(h2.y - by) <= 1) {\n valid = false;\n break;\n }\n }\n }\n }\n \n if (valid) {\n // Calculate score if we block\n blocked[bx][by] = true;\n double score = calculateScore(humanIdx);\n blocked[bx][by] = false;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"udlr\"[d]);\n }\n }\n }\n \n // Try moving\n for (int d = 0; d < 4; d++) {\n int nx = h.x + dirs[d][0];\n int ny = h.y + dirs[d][1];\n \n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[humanIdx] = {nx, ny};\n double score = calculateScore(humanIdx);\n humans[humanIdx] = h;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"UDLR\"[d]);\n }\n }\n }\n \n // Try staying\n double score = calculateScore(humanIdx);\n if (score > bestScore) {\n bestScore = score;\n bestAction = \".\";\n }\n \n return bestAction;\n }\n \n double calculateScore(int humanIdx) {\n auto& h = humans[humanIdx];\n int reachable = countReachable(h.x, h.y);\n int petCount = countPetsInArea(h.x, h.y);\n \n // Score: reachable/900 * 2^(-petCount)\n return (double)reachable / 900.0 / pow(2.0, petCount);\n }\n \npublic:\n Solver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n memset(blocked, 0, sizeof(blocked));\n }\n \n void solve() {\n // Read input\n cin >> N;\n pets.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].px >> pets[i].py >> pets[i].type;\n }\n \n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n \n // Simulate for all turns\n for (currentTurn = 0; currentTurn < MAX_TURNS; currentTurn++) {\n string output = \"\";\n \n for (int i = 0; i < M; i++) {\n output += decideAction(i, currentTurn);\n }\n \n cout << output << endl << flush;\n fflush(stdout);\n \n // Read pet movements\n for (int i = 0; i < M; i++) {\n string moves;\n cin >> moves;\n }\n \n // Update blocked based on blocking actions\n for (int i = 0; i < M; i++) {\n if (output.size() > i) {\n char act = output[i];\n if (act >= 'a' && act <= 'd') {\n // Blocking\n int d = (act == 'u') ? 0 : (act == 'd') ? 1 : (act == 'l') ? 2 : 3;\n int bx = humans[i].x + dirs[d][0];\n int by = humans[i].y + dirs[d][1];\n if (inBounds(bx, by)) {\n blocked[bx][by] = true;\n }\n } else if (act == 'U' || act == 'D' || act == 'L' || act == 'R') {\n // Moving\n int d = (act == 'U') ? 0 : (act == 'D') ? 1 : (act == 'L') ? 2 : 3;\n int nx = humans[i].x + dirs[d][0];\n int ny = humans[i].y + dirs[d][1];\n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[i] = {nx, ny};\n }\n }\n }\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solver solver;\n solver.solve();\n \n return 0;\n}","ahc009":"#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(NULL);\n\n int si, sj, ti, tj;\n double p;\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) {\n return 0;\n }\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 // Directions: U=0, D=1, L=2, R=3\n const int DR[4] = {-1, 1, 0, 0};\n const int DC[4] = {0, 0, -1, 1};\n const char MOVE_CHAR[4] = {'U', 'D', 'L', 'R'};\n\n const int L = 200;\n const int N = 400;\n const double STAY = p;\n const double MOVE = 1.0 - p;\n\n int start = si * 20 + sj;\n int goal = ti * 20 + tj;\n\n // Calculate BFS distances from goal to all cells\n // This gives us the shortest path distance if there were no walls\n vector dist(N, -1);\n queue q;\n dist[goal] = 0;\n q.push(goal);\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n int r = u / 20, c = u % 20;\n\n for (int m = 0; m < 4; ++m) {\n int nr = r + DR[m];\n int nc = c + DC[m];\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20) continue;\n\n // Check wall\n bool blocked = false;\n if (m == 0 && v[nr][c] == '1') blocked = true;\n if (m == 1 && v[r][c] == '1') blocked = true;\n if (m == 2 && h[r][nc] == '1') blocked = true;\n if (m == 3 && h[r][c] == '1') blocked = true;\n\n if (!blocked && dist[nr * 20 + nc] == -1) {\n dist[nr * 20 + nc] = dist[u] + 1;\n q.push(nr * 20 + nc);\n }\n }\n }\n\n // DP to calculate expected scores\n // dp[t][u] = max expected score starting at step t from cell u\n vector> dp(L + 2, vector(N, 0.0));\n\n for (int t = L; t >= 1; --t) {\n // Goal is absorbing state\n for (int u = 0; u < N; ++u) {\n if (u == goal) {\n dp[t][u] = 0.0;\n continue;\n }\n if (dist[u] == -1) {\n dp[t][u] = 0.0; // Unreachable\n continue;\n }\n\n double best = 0.0;\n\n for (int m = 0; m < 4; ++m) {\n int r = u / 20;\n int c = u % 20;\n int nr = r + DR[m];\n int nc = c + DC[m];\n\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n\n // Wall check\n bool wall_blocked = false;\n if (!out_of_bounds) {\n if (m == 0 && v[nr][c] == '1') wall_blocked = true;\n if (m == 1 && v[r][c] == '1') wall_blocked = true;\n if (m == 2 && h[r][nc] == '1') wall_blocked = true;\n if (m == 3 && h[r][c] == '1') wall_blocked = true;\n }\n\n double expected = 0.0;\n\n if (out_of_bounds || wall_blocked) {\n expected = dp[t + 1][u];\n } else {\n int v_node = nr * 20 + nc;\n if (v_node == goal) {\n expected = (1 - STAY) * (401.0 - t) + STAY * dp[t + 1][u];\n } else {\n expected = (1 - STAY) * dp[t + 1][v_node] + STAY * dp[t + 1][u];\n }\n }\n\n if (expected > best) {\n best = expected;\n }\n }\n dp[t][u] = best;\n }\n }\n\n // Construct the path\n string result = \"\";\n vector prob(N, 0.0);\n prob[start] = 1.0;\n\n for (int t = 1; t <= L; ++t) {\n int best_m = -1;\n double best_score = -1e18;\n\n // Evaluate each move\n for (int m = 0; m < 4; ++m) {\n double score = 0.0;\n\n for (int u = 0; u < N; ++u) {\n if (prob[u] < 1e-14) continue;\n\n // Skip if already at goal (absorbing)\n if (u == goal) continue;\n\n int r = u / 20;\n int c = u % 20;\n int nr = r + DR[m];\n int nc = c + DC[m];\n\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n\n // Wall check\n bool wall_blocked = false;\n if (!out_of_bounds) {\n if (m == 0 && v[nr][c] == '1') wall_blocked = true;\n if (m == 1 && v[r][c] == '1') wall_blocked = true;\n if (m == 2 && h[r][nc] == '1') wall_blocked = true;\n if (m == 3 && h[r][c] == '1') wall_blocked = true;\n }\n\n double expected_val = 0.0;\n if (out_of_bounds || wall_blocked) {\n expected_val = dp[t + 1][u];\n } else {\n int v_node = nr * 20 + nc;\n if (v_node == goal) {\n expected_val = (1 - STAY) * (401.0 - t) + STAY * dp[t + 1][u];\n } else {\n expected_val = (1 - STAY) * dp[t + 1][v_node] + STAY * dp[t + 1][u];\n }\n }\n\n score += prob[u] * expected_val;\n }\n\n if (best_m == -1 || score > best_score) {\n best_score = score;\n best_m = m;\n }\n }\n\n if (best_m == -1) best_m = 0;\n result += MOVE_CHAR[best_m];\n\n // Update probability distribution\n vector next_prob(N, 0.0);\n\n for (int u = 0; u < N; ++u) {\n if (prob[u] < 1e-14) continue;\n if (u == goal) {\n next_prob[goal] += prob[u];\n continue;\n }\n\n int r = u / 20;\n int c = u % 20;\n int nr = r + DR[best_m];\n int nc = c + DC[best_m];\n\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n\n bool wall_blocked = false;\n if (!out_of_bounds) {\n if (best_m == 0 && v[nr][c] == '1') wall_blocked = true;\n if (best_m == 1 && v[r][c] == '1') wall_blocked = true;\n if (best_m == 2 && h[r][nc] == '1') wall_blocked = true;\n if (best_m == 3 && h[r][c] == '1') wall_blocked = true;\n }\n\n if (out_of_bounds || wall_blocked) {\n next_prob[u] += prob[u];\n } else {\n int v_node = nr * 20 + nc;\n next_prob[u] += prob[u] * STAY;\n next_prob[v_node] += prob[u] * (1 - STAY);\n }\n }\n\n prob = next_prob;\n }\n\n cout << result << endl;\n\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_ITERATIONS = 60000;\nconst int NUM_RUNS = 4;\n\nint tiles[N][N];\nint r_rot[N][N];\nint trans[8][4][4];\nint best_r_rot[N][N];\n\nbool vis[N][N][4];\nint trace_token[N][N][4];\nint global_token = 0;\n\nint path_i[3000];\nint path_j[3000];\nint path_d[3000];\nint lengths[1000];\nint num_lengths;\n\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nlong long current_score = 0;\nlong long global_best_score = 0;\n\nvoid init_to() {\n int base[8][4] = {\n {1, 0, -1, -1}, {3, -1, -1, 0}, {-1, -1, 3, 2}, {-1, 2, 1, -1},\n {1, 0, 3, 2}, {3, 2, 1, 0}, {2, -1, 0, -1}, {-1, 3, -1, 1}\n };\n \n for (int r = 0; r < 8; ++r) {\n for (int rot = 0; rot < 4; ++rot) {\n for (int d = 0; d < 4; ++d) {\n int d_internal = (d - rot + 4) % 4;\n int out_internal = base[r][d_internal];\n trans[r][rot][d] = (out_internal == -1) ? -1 : (out_internal + rot) % 4;\n }\n }\n }\n}\n\nlong long calculate_score() {\n global_token++;\n if (global_token == 0) {\n memset(trace_token, 0, sizeof(trace_token));\n memset(vis, 0, sizeof(vis));\n global_token = 1;\n }\n \n num_lengths = 0;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int d = 0; d < 4; ++d) {\n if (vis[i][j][d]) continue;\n \n int path_len = 0;\n int ci = i, cj = j, cd = d;\n \n while (true) {\n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n if (trace_token[ci][cj][cd] == global_token) {\n int loop_len = 0;\n for (int k = 0; k < path_len; ++k) {\n if (path_i[k] == ci && path_j[k] == cj && path_d[k] == cd) {\n loop_len = path_len - k;\n break;\n }\n }\n if (loop_len > 0) lengths[num_lengths++] = loop_len;\n break;\n }\n \n if (trace_token[ci][cj][cd] > 0) break;\n \n trace_token[ci][cj][cd] = global_token;\n vis[ci][cj][cd] = true;\n \n path_i[path_len] = ci;\n path_j[path_len] = cj;\n path_d[path_len] = cd;\n path_len++;\n \n int type = tiles[ci][cj];\n int rot = r_rot[ci][cj];\n int nd = trans[type][rot][cd];\n \n if (nd == -1) break;\n \n int ni = ci + di[nd];\n int nj = cj + dj[nd];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) break;\n \n ci = ni; cj = nj; cd = (nd + 2) % 4;\n }\n }\n }\n }\n \n if (num_lengths < 2) return 0;\n \n sort(lengths, lengths + num_lengths, greater());\n return (long long)lengths[0] * lengths[1];\n}\n\nvoid sa_run(int seed, bool with_greedy) {\n mt19937 rng(seed);\n uniform_int_distribution dist_rot(0, 3);\n uniform_int_distribution dist_pos(0, N-1);\n uniform_real_distribution dist_rand_p(0.0, 1.0);\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n r_rot[i][j] = dist_rot(rng);\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n r_rot[i][j] = dist_rot(rng);\n \n current_score = calculate_score();\n \n if (with_greedy) {\n for (int pass = 0; pass < 5; ++pass) {\n int improved = 0;\n for (int i = 0; i < N * N; ++i) {\n int ri = i / N;\n int ci = i % N;\n \n int old_rot = r_rot[ri][ci];\n long long best_score = current_score;\n int best_rot = old_rot;\n \n for (int rot = 0; rot < 4; ++rot) {\n if (rot == old_rot) continue;\n r_rot[ri][ci] = rot;\n long long score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rot = rot;\n }\n }\n \n if (best_rot != old_rot) {\n r_rot[ri][ci] = best_rot;\n current_score = best_score;\n improved = 1;\n }\n }\n if (!improved) break;\n }\n }\n \n double T = 1000.0;\n \n int iter = 0;\n while (iter < MAX_ITERATIONS) {\n double progress = (double)iter / MAX_ITERATIONS;\n T = 1000.0 * pow(1e-4 / 1000.0, progress);\n double p_accept = dist_rand_p(rng);\n \n int r = dist_pos(rng);\n int c = dist_pos(rng);\n int new_rot = dist_rot(rng);\n \n while (new_rot == r_rot[r][c]) new_rot = dist_rot(rng);\n \n int old_rot = r_rot[r][c];\n r_rot[r][c] = new_rot;\n \n long long score = calculate_score();\n bool accept = false;\n \n if (score >= current_score) {\n accept = true;\n } else {\n if (exp((double)(score - current_score) / T) > p_accept) {\n accept = true;\n }\n }\n \n if (accept) {\n current_score = score;\n if (score > global_best_score) {\n global_best_score = score;\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n best_r_rot[i][j] = r_rot[i][j];\n }\n } else {\n r_rot[r][c] = old_rot;\n }\n \n iter++;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_to();\n \n for (int i = 0; i < N; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < N; ++j)\n tiles[i][j] = row[j] - '0';\n }\n \n memset(best_r_rot, 0, sizeof(best_r_rot));\n global_best_score = 0;\n \n for (int run = 0; run < NUM_RUNS; ++run) {\n sa_run(run * 12345 + 6789, (run == 0));\n }\n \n memcpy(r_rot, best_r_rot, sizeof(best_r_rot));\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j)\n cout << r_rot[i][j];\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 10;\nconst int MAX_BOARD_SIZE = MAX_N * MAX_N;\nconst int BASE_BEAM_WIDTH = 60;\nconst int MAX_NODES = 1500000;\n\nstruct Node {\n int board[MAX_BOARD_SIZE];\n int empty_pos;\n int score;\n int parent_idx; \n char move_char;\n};\n\nvector all_nodes;\nint parent[MAX_BOARD_SIZE];\nint sz[MAX_BOARD_SIZE];\nbool is_cyclic[MAX_BOARD_SIZE];\n\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nint dsu_find(int i) {\n return parent[i] == i ? i : (parent[i] = dsu_find(parent[i]));\n}\n\nvoid dsu_union(int i, int j) {\n int root_i = dsu_find(i);\n int root_j = dsu_find(j);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n}\n\nvoid dsu_init(int n) {\n for (int i = 0; i < n; ++i) {\n parent[i] = i;\n sz[i] = 1;\n is_cyclic[i] = false;\n }\n}\n\n// Calculate connection quality for move priority\nint get_move_quality(const int* board, int row, int col, int dr_val, int dc_val, int dr_val2, int dc_val2, int N) {\n int nr = row + dr_val;\n int nc = col + dc_val;\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) return -10;\n \n int tile_val = board[nr * N + nc];\n if (!tile_val) return -10;\n \n // Priority: check if tile has connection toward empty position\n if (dr_val == -1 && (tile_val & 2)) return 100; // U: tile points up\n if (dr_val == 1 && (tile_val & 8)) return 100; // D: tile points down\n if (dc_val == -1 && (tile_val & 4)) return 100; // L: tile points right\n if (dc_val == 1 && (tile_val & 1)) return 100; // R: tile points left\n \n return 0;\n}\n\n// Calculate tree size score\nint get_tree_score(const int* board, int n) {\n dsu_init(n * n);\n \n for (int r = 0; r < n; ++r) {\n for (int c = 0; c < n; ++c) {\n int idx = r * n + c;\n if (board[idx] == 0) continue;\n \n if (c < n - 1) {\n int ni = idx + 1;\n if (board[ni] != 0) {\n if ((board[idx] & 4) && (board[ni] & 1)) dsu_union(idx, ni);\n if ((board[idx] & 1) && (board[ni] & 4)) dsu_union(idx, ni);\n }\n }\n if (r < n - 1) {\n int ni = idx + n;\n if (board[ni] != 0) {\n if ((board[idx] & 8) && (board[ni] & 2)) dsu_union(idx, ni);\n if ((board[idx] & 2) && (board[ni] & 8)) dsu_union(idx, ni);\n }\n }\n }\n }\n \n int max_size = 0;\n int nn = n * n;\n vector processed(nn, false);\n \n for (int i = 0; i < nn; ++i) {\n if (board[i] == 0) continue;\n int root = dsu_find(i);\n if (processed[root]) continue;\n processed[root] = true;\n \n if (!is_cyclic[root]) {\n max_size = max(max_size, sz[root]);\n }\n }\n return max_size;\n}\n\nstring reconstruct_path(int node_idx) {\n string path;\n int current = node_idx;\n while (all_nodes[current].parent_idx != -1) {\n path += all_nodes[current].move_char;\n current = all_nodes[current].parent_idx;\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 int N, T;\n if (!(cin >> N >> T)) return 0;\n\n all_nodes.reserve(MAX_NODES);\n \n Node start_node;\n memset(start_node.board, 0, sizeof(start_node.board));\n int empty_pos = -1;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c;\n cin >> c;\n int val = 0;\n if (isdigit(c)) val = c - '0';\n else val = 10 + (c - 'a');\n start_node.board[i * N + j] = val;\n if (val == 0) empty_pos = i * N + j;\n }\n }\n \n start_node.empty_pos = empty_pos;\n start_node.parent_idx = -1;\n start_node.score = get_tree_score(start_node.board, N);\n start_node.move_char = 0;\n \n all_nodes.push_back(start_node);\n\n vector current_layer;\n vector next_layer;\n current_layer.push_back(0);\n \n int best_node_idx = 0;\n int max_score = start_node.score;\n string best_path = \"\";\n\n for (int step = 1; step <= T; ++step) {\n next_layer.clear();\n \n for (int idx : current_layer) {\n Node u = all_nodes[idx];\n int er = u.empty_pos / N;\n int ec = u.empty_pos % N;\n \n // Generate all valid moves with priority\n vector> moves;\n for (int k = 0; k < 4; ++k) {\n int nr = er + dr[k];\n int nc = ec + dc[k];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int quality = get_move_quality(u.board, er, ec, dr[k], dc[k], dr[k], dc[k], N);\n // Penalty for reversal\n if (u.parent_idx != -1) {\n char prev = all_nodes[idx].move_char;\n if ((prev == 'U' && k == 1) ||\n (prev == 'D' && k == 0) ||\n (prev == 'L' && k == 3) ||\n (prev == 'R' && k == 2)) {\n quality = -1000;\n }\n }\n moves.push_back({quality, k});\n }\n }\n sort(moves.rbegin(), moves.rend());\n \n for (auto& mv : moves) {\n int k = mv.second;\n int nr = er + dr[k];\n int nc = ec + dc[k];\n \n Node v = u;\n v.empty_pos = nr * N + nc;\n v.board[u.empty_pos] = u.board[v.empty_pos];\n v.board[v.empty_pos] = 0;\n \n v.parent_idx = idx;\n v.move_char = dir_char[k];\n \n int v_score = get_tree_score(v.board, N);\n int v_idx = (int)all_nodes.size();\n all_nodes.push_back(v);\n \n // Check if full tree found\n if (v_score == N * N - 1) {\n cout << reconstruct_path(v_idx) << endl;\n return 0;\n }\n \n next_layer.push_back(v_idx);\n }\n }\n \n if (next_layer.empty()) break;\n \n // Sort by score\n sort(next_layer.begin(), next_layer.end(), [&](int a, int b) {\n return all_nodes[a].score > all_nodes[b].score;\n });\n \n current_layer.clear();\n int limit = min((int)next_layer.size(), BASE_BEAM_WIDTH);\n \n for (int i = 0; i < limit; ++i) {\n current_layer.push_back(next_layer[i]);\n if (all_nodes[next_layer[i]].score > max_score) {\n max_score = all_nodes[next_layer[i]].score;\n best_node_idx = next_layer[i];\n }\n }\n }\n \n // Output best found path if full tree not reached\n if (max_score < N * N - 1) {\n cout << reconstruct_path(best_node_idx) << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Line {\n double A, B, C;\n};\n\n// Global variables\nint N, K;\nvector a(11);\nvector> points;\nvector indices;\nvector sigs;\nunordered_map region_counts;\n\nint calculate_score(const vector& lines) {\n if (N == 0) return 0;\n \n // Clear and reset\n region_counts.clear();\n sigs.resize(N);\n \n // Quick signature computation (only first 10 bits for efficiency)\n for (int i = 0; i < N; ++i) {\n long long sig = 0;\n for (int k = 0; k < K && k < 60; ++k) {\n double val = lines[k].A * points[i].first + \n lines[k].B * points[i].second + \n lines[k].C;\n if (val >= 0) {\n sig |= (1LL << k);\n }\n }\n sigs[i] = sig;\n }\n\n // Group by signature (no sorting - faster with unordered_map)\n for (int i = 0; i < N; ++i) {\n region_counts[sigs[i]]++;\n }\n\n // Count by region size\n int cnt[11] = {0};\n for (const auto& pair : region_counts) {\n int size = pair.second;\n if (size >= 1 && size <= 10) {\n cnt[size]++;\n }\n }\n\n // Score calculation\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(cnt[d], a[d]);\n }\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> K)) return 0;\n\n int sum_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n sum_a += a[i];\n }\n\n points.resize(N);\n indices.resize(N);\n sigs.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].first >> points[i].second;\n indices[i] = i;\n }\n\n mt19937 rng(42);\n \n vector current_lines(K);\n uniform_real_distribution angle_dist(0, 2 * M_PI);\n uniform_real_distribution r_dist(-8000.0, 8000.0);\n uniform_real_distribution angle_change_dist(-0.02, 0.02);\n uniform_real_distribution c_change_dist(-3.0, 3.0);\n uniform_real_distribution uniform_dist(0.0, 1.0);\n\n for (int i = 0; i < K; ++i) {\n double angle = angle_dist(rng);\n current_lines[i].A = cos(angle);\n current_lines[i].B = sin(angle);\n current_lines[i].C = -r_dist(rng);\n }\n\n // Pre-compute for faster inner loop\n vector best_cnt(11);\n vector> cnt_history(K);\n \n int current_score = calculate_score(current_lines);\n int best_score = current_score;\n \n vector best_lines = current_lines;\n \n // Reduced iterations for time limit\n int num_iterations = 6000;\n double T = 8000.0;\n double decay = 0.9992;\n\n // Pre-allocate region_counts for reuse\n region_counts.reserve(N);\n\n for (int iter = 0; iter < num_iterations; ++iter) {\n int idx = rng() % K;\n\n Line old_line = current_lines[idx];\n\n // Perturb current line\n double phi = atan2(current_lines[idx].B, current_lines[idx].A);\n double angle_change = angle_change_dist(rng);\n current_lines[idx].A = cos(phi + angle_change);\n current_lines[idx].B = sin(phi + angle_change);\n\n double C_change = c_change_dist(rng);\n current_lines[idx].C += C_change;\n \n // Keep normalized\n double norm = sqrt(current_lines[idx].A * current_lines[idx].A + \n current_lines[idx].B * current_lines[idx].B);\n if (norm > 1e-10) {\n current_lines[idx].A /= norm;\n current_lines[idx].B /= norm;\n current_lines[idx].C /= norm;\n }\n\n int new_score = calculate_score(current_lines);\n\n // Acceptance probability\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n double diff = (double)(new_score - current_score);\n if (diff < 0) {\n double prob = exp(diff / T);\n if (uniform_dist(rng) < prob) {\n accept = true;\n }\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n best_lines = current_lines;\n }\n if (best_score == sum_a) break;\n } else {\n current_lines[idx] = old_line;\n }\n\n T *= decay;\n }\n\n // Output\n cout << K << \"\\n\";\n for (int k_idx = 0; k_idx < K; ++k_idx) {\n double A = best_lines[k_idx].A;\n double B = best_lines[k_idx].B;\n double C = best_lines[k_idx].C;\n\n long long x0 = (long long)round(-A * C);\n long long y0 = (long long)round(-B * C);\n\n long long px1 = x0;\n long long py1 = y0;\n long long px2 = x0 + (long long)round(-B * 2000);\n long long py2 = y0 + (long long)round(A * 2000);\n\n if (px1 == px2 && py1 == py2) {\n px2 = px1 + 1000;\n py2 = py1;\n }\n\n cout << px1 << \" \" << py1 << \" \" << px2 << \" \" << py2 << \"\\n\";\n }\n\n return 0;\n}","ahc014":" while (cx != b.x || cy != b.y) {\n if (has_dot[cx][cy]) return true;\n cx += dx_step;\n cy += dy_step;\n }","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\nint grid[N][N];\nint flavors[100];\n\n// Calculate score for a given grid configuration\nint calculate_score(int arr[N][N]) {\n int score = 0;\n bool visited[N][N];\n memset(visited, 0, sizeof(visited));\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (arr[r][c] != 0 && !visited[r][c]) {\n int current_flavor = arr[r][c];\n int count = 0;\n \n // BFS for connected component\n int q_r[N*N], q_c[N*N]; \n int head = 0, tail = 0;\n \n q_r[tail] = r; q_c[tail] = c;\n visited[r][c] = true;\n tail++;\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n \n while(head < tail) {\n int cr = q_r[head];\n int cc = q_c[head];\n head++;\n count++;\n \n for(int k = 0; k < 4; ++k) {\n int nr = cr + dr[k];\n int nc = cc + dc[k];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if(!visited[nr][nc] && arr[nr][nc] == current_flavor) {\n visited[nr][nc] = true;\n q_r[tail] = nr;\n q_c[tail] = nc;\n tail++;\n }\n }\n }\n }\n score += count * count;\n }\n }\n }\n return score;\n}\n\n// Apply a tilt move to a grid\nvoid apply_move(int grid_arr[N][N], char dir) {\n int next_grid[N][N];\n memset(next_grid, 0, sizeof(next_grid));\n \n if (dir == 'F') { // Forward -> Top (Up)\n for (int c = 0; c < N; ++c) {\n int write_idx = 0;\n for (int r = 0; r < N; ++r) {\n if (grid_arr[r][c] != 0) {\n next_grid[write_idx][c] = grid_arr[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'B') { // Backward -> Bottom (Down)\n for (int c = 0; c < N; ++c) {\n int write_idx = N - 1;\n for (int r = N - 1; r >= 0; --r) {\n if (grid_arr[r][c] != 0) {\n next_grid[write_idx][c] = grid_arr[r][c];\n write_idx--;\n }\n }\n }\n } else if (dir == 'L') { // Left -> Left edge\n for (int r = 0; r < N; ++r) {\n int write_idx = 0;\n for (int c = 0; c < N; ++c) {\n if (grid_arr[r][c] != 0) {\n next_grid[r][write_idx] = grid_arr[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'R') { // Right -> Right edge\n for (int r = 0; r < N; ++r) {\n int write_idx = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid_arr[r][c] != 0) {\n next_grid[r][write_idx] = grid_arr[r][c];\n write_idx--;\n }\n }\n }\n }\n \n memcpy(grid_arr, next_grid, sizeof(int) * N * N);\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Seed random with high resolution clock\n mt19937 gen((unsigned int)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Read flavor sequence\n for (int t = 0; t < 100; ++t) {\n cin >> flavors[t];\n }\n\n // Main interaction loop\n for (int t = 0; t < 100; ++t) {\n int p;\n cin >> p;\n \n // Find the p-th empty cell in reading order\n int count = 0;\n bool found = false;\n int r_target = 0, c_target = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] == 0) {\n count++;\n if (count == p) {\n r_target = i;\n c_target = j;\n found = true;\n break;\n }\n }\n }\n if (found) break;\n }\n \n // Place the candy\n if (found) {\n grid[r_target][c_target] = flavors[t];\n }\n\n // Determine tilt direction (skip output for 100th step)\n if (t < 99) {\n char best_move = 'F';\n int best_score = -1;\n \n char moves[] = {'F', 'B', 'L', 'R'};\n \n // Randomize order for tie-breaking fairness\n vector idx(4);\n for(int i = 0; i < 4; ++i) idx[i] = i;\n shuffle(idx.begin(), idx.end(), gen);\n\n for (auto i : idx) {\n char dir = moves[i];\n \n // Simulate the move on a copy of the grid\n int sim_grid[N][N];\n memcpy(sim_grid, grid, sizeof(sim_grid));\n \n // Apply move to simulation copy\n apply_move(sim_grid, dir);\n \n // Calculate score for this move\n int score = calculate_score(sim_grid);\n \n // Pure greedy selection: maximize score\n if (best_score == -1 || score > best_score) {\n best_score = score;\n best_move = dir;\n }\n }\n \n cout << best_move << endl;\n \n // Apply the selected move to the real grid\n apply_move(grid, best_move);\n }\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n\nclass Graph {\npublic:\n int num_vertices;\n std::vector> adj;\n \n Graph(int n = 0) : num_vertices(n) {\n if (n > 0) {\n adj.resize(n, std::vector(n, 0));\n }\n }\n \n static Graph parse(const std::string& s, int n) {\n Graph G(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n G.adj[i][j] = G.adj[j][i] = s[idx] - '0';\n idx++;\n }\n }\n return G;\n }\n \n std::string encode() const {\n std::string s;\n s.reserve(num_vertices * (num_vertices - 1) / 2);\n for (int i = 0; i < num_vertices; i++) {\n for (int j = i + 1; j < num_vertices; j++) {\n s.push_back(adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n int countEdges() const {\n int cnt = 0;\n for (int i = 0; i < num_vertices; i++) {\n for (int j = i + 1; j < num_vertices; j++) {\n cnt += adj[i][j];\n }\n }\n return cnt;\n }\n \n std::vector getDegreeVec() const {\n std::vector deg(num_vertices, 0);\n for (int i = 0; i < num_vertices; i++) {\n for (int j = i + 1; j < num_vertices; j++) {\n if (adj[i][j]) {\n deg[i]++;\n deg[j]++;\n }\n }\n }\n std::sort(deg.begin(), deg.end());\n return deg;\n }\n};\n\nint calcMatchCount(const Graph& H, const Graph& G) {\n int n = H.num_vertices;\n if (n != G.num_vertices) return 0;\n \n std::vector h_deg = H.getDegreeVec();\n std::vector g_deg = G.getDegreeVec();\n \n std::vector h_order(n), g_order(n);\n for (int i = 0; i < n; i++) {\n h_order[i] = i;\n g_order[i] = i;\n }\n \n std::sort(h_order.begin(), h_order.end(), [&](int a, int b) {\n return h_deg[a] > h_deg[b];\n });\n std::sort(g_order.begin(), g_order.end(), [&](int a, int b) {\n return g_deg[a] > g_deg[b];\n });\n \n int matched = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n int mapped_i = std::lower_bound(g_order.begin(), g_order.end(), i,\n [&](int ord, int val) { return h_deg[ord] > h_deg[i]; }) - g_order.begin();\n int mapped_j = std::lower_bound(g_order.begin(), g_order.end(), j,\n [&](int ord, int val) { return h_deg[ord] > h_deg[j]; }) - g_order.begin();\n \n if (mapped_i < n && mapped_j < n) {\n if (H.adj[i][j] == G.adj[mapped_i][mapped_j]) {\n matched++;\n }\n }\n }\n }\n \n return matched;\n}\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int M;\n double epsilon;\n if (!(std::cin >> M >> epsilon)) return 0;\n \n int N = 35;\n std::vector graphs(M, Graph(N));\n int total_edge_count = N * (N - 1) / 2;\n \n // Create diverse graphs\n for (int k = 0; k < M; k++) {\n int target = k * total_edge_count / M;\n int variation = (k % 7) - 3;\n target = std::max(0, std::min(total_edge_count, target + variation));\n \n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (count < target) {\n graphs[k].adj[i][j] = graphs[k].adj[j][i] = 1;\n count++;\n }\n }\n }\n }\n \n // Output\n std::cout << N << \"\\n\";\n std::cout.flush();\n for (int k = 0; k < M; k++) {\n std::cout << graphs[k].encode() << \"\\n\";\n std::cout.flush();\n }\n \n // Process queries\n for (int q = 0; q < 100; q++) {\n std::string S;\n std::cin >> S;\n \n int n_q = N;\n Graph H(n_q);\n int idx = 0;\n for (int i = 0; i < n_q; i++) {\n for (int j = i + 1; j < n_q; j++) {\n H.adj[i][j] = H.adj[j][i] = S[idx++] - '0';\n }\n }\n \n int H_edges = H.countEdges();\n int best_k = 0;\n int best_score = -1;\n int best_edge_diff = total_edge_count + 1;\n \n for (int k = 0; k < M; k++) {\n int G_edges = graphs[k].countEdges();\n int edge_diff = std::abs(H_edges - G_edges);\n \n int threshold = (int)(N * epsilon * 2.5) + 5;\n if (edge_diff > threshold) continue;\n \n int matched = calcMatchCount(H, graphs[k]);\n int score = matched * 100 - edge_diff * 10;\n \n if (score > best_score || (score == best_score && edge_diff < best_edge_diff)) {\n best_score = score;\n best_k = k;\n best_edge_diff = edge_diff;\n }\n }\n \n std::cout << best_k << \"\\n\";\n std::cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Edge {\n int u, v, w, id;\n};\n\nint main() {\n ios_base::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 // Read edges\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].id = i;\n }\n \n // Read coordinates (not used)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n \n // Initialize assignments: even distribution across days\n vector assignments(M);\n vector dayCounts(D + 1, 0);\n \n for (int i = 0; i < M; i++) {\n assignments[i] = (i % D) + 1;\n dayCounts[assignments[i]]++;\n }\n \n // Local search to balance edge distribution\n for (int iter = 0; iter < 50000; iter++) {\n int edgeIdx = iter % M;\n int fromDay = assignments[edgeIdx];\n \n // Find day with minimum edges (respecting capacity)\n int bestDay = fromDay;\n for (int d = 1; d <= D; d++) {\n if (d != fromDay && dayCounts[d] < K && dayCounts[d] < dayCounts[bestDay]) {\n bestDay = d;\n }\n }\n \n // Move edge if beneficial\n if (bestDay != fromDay) {\n dayCounts[fromDay]--;\n dayCounts[bestDay]++;\n assignments[edgeIdx] = bestDay;\n }\n }\n \n // Ensure all assignments are valid [1, D]\n for (int i = 0; i < M; i++) {\n if (assignments[i] < 1 || assignments[i] > D) {\n assignments[i] = (i % D) + 1;\n }\n }\n \n // Recalculate day counts\n fill(dayCounts.begin(), dayCounts.end(), 0);\n for (int i = 0; i < M; i++) {\n dayCounts[assignments[i]]++;\n }\n \n // Output all M values on single line, space-separated\n for (int i = 0; i < M; i++) {\n cout << assignments[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold a point in 3D space\nstruct Point3D {\n int x, y, z;\n bool operator<(const Point3D& o) const {\n if (x != o.x) return x < o.x;\n if (y != o.y) return y < o.y;\n return z < o.z;\n }\n bool operator==(const Point3D& o) const {\n return x == o.x && y == o.y && z == o.z;\n }\n};\n\n// Structure to hold rotation matrices\nstruct RotMat {\n int p[3]; // permutation of axes\n int s[3]; // signs for each axis\n};\n\nint D;\nchar f1[15][15], r1[15][15], f2[15][15], r2[15][15];\nint g1[15][15][15], g2[15][15][15];\nint g_common[15][15][15];\nint b1[15][15][15], b2[15][15][15];\nvector common_ccs;\nvector> rem1_c;\nvector> rem2_c;\nvector rotations;\n\nint parity(const vector& p) {\n int c = 0;\n for(int i=0; i<3; ++i) \n for(int j=i+1; j<3; ++j) \n if(p[i] > p[j]) c++;\n return c;\n}\n\nvoid init_rotations() {\n int p[] = {0, 1, 2};\n do {\n vector v_p(p, p+3);\n if (parity(v_p) % 2 == 0) {\n int signs[4][3] = {{1,1,1}, {1,-1,-1}, {-1,1,-1}, {-1,-1,1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n } else {\n int signs[4][3] = {{1,1,-1}, {1,-1,1}, {-1,1,1}, {-1,-1,-1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n }\n } while (next_permutation(p, p+3));\n}\n\nPoint3D transform(const Point3D& src, const RotMat& r) {\n int vals[3] = {src.x, src.y, src.z};\n return {vals[r.p[0]] * r.s[0], vals[r.p[1]] * r.s[1], vals[r.p[2]] * r.s[2]};\n}\n\n// Generate the canonical representation of a shape by trying all rotations\nvector get_canonical_shape(const vector& pts) {\n if (pts.empty()) return {};\n \n vector best;\n bool first = true;\n \n for(const auto& r : rotations) {\n vector current;\n current.reserve(pts.size());\n for(const auto& p : pts) {\n current.push_back(transform(p, r));\n }\n \n int cminx=1000, cminy=1000, cminz=1000;\n for(const auto& p : current) {\n cminx = min(cminx, p.x);\n cminy = min(cminy, p.y);\n cminz = min(cminz, p.z);\n }\n \n sort(current.begin(), current.end());\n for(auto& p : current) {\n p.x -= cminx; p.y -= cminy; p.z -= cminz;\n }\n \n if (first || current < best) {\n best = current;\n first = false;\n }\n }\n return best;\n}\n\nvoid bfs(int grid[15][15][15], vector>& components) {\n for(int x=0; x pts;\n queue, int>> q;\n q.push({{x, y}, z});\n grid[x][y][z] = 0;\n pts.push_back({x,y,z});\n \n while(!q.empty()){\n auto curr = q.front(); q.pop();\n int cx = curr.first.first, cy = curr.first.second, cz = curr.second;\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 for(int i=0; i<6; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n int nz = cz + dz[i];\n if(nx >= 0 && nx < D && ny >= 0 && ny < D && nz >= 0 && nz < D && grid[nx][ny][nz] == 1) {\n grid[nx][ny][nz] = 0;\n q.push({{nx, ny}, nz});\n pts.push_back({nx, ny, nz});\n }\n }\n }\n components.push_back(pts);\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_rotations();\n \n if (!(cin >> D)) return 0;\n \n string s;\n // Read f1\n for(int z=0; z> s; for(int x=0;x> s; for(int y=0;y> s; for(int x=0;x> s; for(int y=0;y, vector> rem2_map;\n for(size_t i=0; i shape = rem2_c[i];\n vector key = get_canonical_shape(shape);\n rem2_map[key].push_back(i);\n }\n \n vector rem1_block_id(rem1_c.size(), 0);\n vector rem2_block_id(rem2_c.size(), 0);\n \n int common_count = common_ccs.size();\n int current_id = common_count + 1;\n \n // Fill Common Blocks with IDs 1 to common_count\n for(size_t i=0; i shape = rem1_c[i];\n vector key = get_canonical_shape(shape);\n \n if (rem2_map.count(key) && !rem2_map[key].empty()) {\n int j = rem2_map[key].back();\n rem2_map[key].pop_back();\n \n rem1_block_id[i] = current_id;\n rem2_block_id[j] = current_id;\n int bid = current_id;\n for(auto& p : rem1_c[i]) b1[p.x][p.y][p.z] = bid;\n for(auto& p : rem2_c[j]) b2[p.x][p.y][p.z] = bid;\n current_id++;\n } else {\n rem1_block_id[i] = current_id;\n current_id++;\n }\n }\n \n // Fill Unique Rem1 components\n for(size_t i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Data structures\nstruct Point {\n long long x, y;\n};\n\nstruct Edge {\n int u, v, w;\n int id; // 0-based index for B output\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nint N, M, K;\nvector nodes;\nvector residents;\nvector all_edges;\n\n// Global for calculation\nvector MST_parent;\nvector MST_weight;\nvector edge_to_parent_id;\nvector bfs_order; // Stores indices in BFS order starting from root (0)\nvector active;\nvector> residents_for; // residents assigned to node u\nvector resident_location; // resident_location[k] = u\n\nvector> dist_sq; // N x K\nvector P;\nvector B; // Output for edges\n\n// Helper to compute distance squared\nlong long dist_sq_func(Point p1, Point p2) {\n return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);\n}\n\n// Calculate smallest integer k such that k*k >= d2\nlong long get_ceil_sqrt_safe(long long d2) {\n if (d2 <= 0) return 0;\n long long r = round(sqrt(d2));\n if (r * r < d2) r++;\n return r;\n}\n\nvoid calculate_P_and_active() {\n P.assign(N, 0);\n active.assign(N, false);\n for (int u = 0; u < N; ++u) {\n long long mx = 0;\n if (!residents_for[u].empty()) {\n for (int k_idx : residents_for[u]) {\n mx = max(mx, get_ceil_sqrt_safe(dist_sq[u][k_idx]));\n }\n }\n P[u] = mx;\n if (mx > 0) active[u] = true;\n }\n}\n\n// Calculate MST cost: sum of weights of edges connecting active nodes to 1\nlong long calc_mst_cost() {\n long long cost = 0;\n vector needed(N, false);\n for(int i=0; i 0; --i) {\n int v = bfs_order[i];\n if (needed[v]) {\n int p = MST_parent[v];\n if (p != -1) {\n needed[p] = true;\n cost += MST_weight[v];\n }\n }\n }\n return cost;\n}\n\n// Calculate total cost\nlong long calculate_total_cost() {\n long long node_cost = 0;\n for (int u = 0; u < N; ++u) {\n node_cost += P[u] * P[u];\n }\n return node_cost + calc_mst_cost();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> K)) return 0;\n\n nodes.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> nodes[i].x >> nodes[i].y;\n }\n \n all_edges.resize(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v; // 0-based\n all_edges[i] = {u, v, w, i};\n }\n \n residents.resize(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].x >> residents[i].y;\n }\n \n // Precompute distances\n dist_sq.assign(N, vector(K));\n for(int u=0; u dsu(N);\n iota(dsu.begin(), dsu.end(), 0);\n function find = [&](int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); };\n auto unite = [&](int x, int y) { x = find(x); y = find(y); if (x != y) { dsu[x] = y; return true; } return false; };\n \n vector mst_edges;\n for (auto& e : all_edges) {\n if (unite(e.u, e.v)) {\n mst_edges.push_back(e);\n }\n }\n \n // Build MST Adjacency\n // BFS root is 0 (Node 1)\n vector>> mst_adj(N);\n for (const auto& e : mst_edges) {\n mst_adj[e.u].push_back({e.v, e.w});\n mst_adj[e.v].push_back({e.u, e.w});\n }\n \n MST_parent.assign(N, -1);\n MST_weight.assign(N, 0);\n edge_to_parent_id.assign(N, -1);\n bfs_order.clear();\n bfs_order.reserve(N);\n \n queue q;\n vector visited(N, false);\n q.push(0);\n visited[0] = true;\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n bfs_order.push_back(u);\n \n for(auto& neighbor : mst_adj[u]){\n int v = neighbor.first;\n int w = neighbor.second;\n if(!visited[v]){\n visited[v] = true;\n MST_parent[v] = u;\n MST_weight[v] = w;\n q.push(v);\n }\n }\n }\n \n // Re-traverse to find edge IDs for parent edges\n for(int u=0; u());\n resident_location.assign(K, -1);\n for(int k=0; k& old_list = residents_for[u_old];\n for(auto it = old_list.begin(); it != old_list.end(); ++it){\n if(*it == k) {\n old_list.erase(it);\n break;\n }\n }\n \n // Add to best_u\n residents_for[best_u].push_back(k);\n \n // Check if valid and better\n calculate_P_and_active();\n long long new_cost = calculate_total_cost();\n \n // Greedy acceptance\n if (new_cost <= current_cost) {\n current_cost = new_cost;\n resident_location[k] = best_u;\n } else {\n // Revert\n vector& new_list = residents_for[best_u];\n for(auto it = new_list.begin(); it != new_list.end(); ++it){\n if(*it == k) {\n new_list.erase(it);\n break;\n }\n }\n residents_for[u_old].push_back(k);\n resident_location[k] = u_old;\n calculate_P_and_active();\n }\n }\n }\n \n // Finalize\n calculate_P_and_active();\n \n // Output P\n for(int i=0; i needed(N, false);\n \n // Initialize needed based on active nodes (P > 0)\n for(int u=0; u order = bfs_order;\n \n for (int i = N - 1; i > 0; --i) {\n int v = order[i];\n if (needed[v]) {\n int p = MST_parent[v];\n if (p != -1) {\n needed[p] = true;\n if (edge_to_parent_id[v] != -1) {\n B[edge_to_parent_id[v]] = 1;\n }\n }\n }\n }\n \n // Print B\n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a swap operation\nstruct Op {\n int x1, y1, x2, y2;\n};\n\n// Structure to represent a valid vertical edge in the pyramid\nstruct Edge {\n int x1, y1; // Coordinates of the parent (top) node\n int x2, y2; // Coordinates of the child (bottom) node\n};\n\nint grid[30][30];\nvector edges;\n\nint main() {\n // Optimize I/O operations for speed\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Initialize all valid vertical edges in the pyramid\n // For each row x, nodes (x, 0) to (x, x) exist.\n // They connect to nodes in row x+1: (x+1, y) and (x+1, y+1).\n for (int x = 0; x < 29; ++x) {\n for (int y = 0; y <= x; ++y) {\n edges.push_back({x, y, x + 1, y});\n edges.push_back({x, y, x + 1, y + 1});\n }\n }\n\n // Read the initial configuration of the pyramid\n for (int x = 0; x < 30; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> grid[x][y];\n }\n }\n\n vector ops;\n // Use a fixed seed for reproducibility, but random shuffle inside loop\n static mt19937 rng(12345); \n\n // Sorting phase: Ensure every parent < children using bubble sort on edges\n // We shuffle edges each pass to allow balls to move multiple steps in one pass\n // regardless of direction (up or down).\n while (ops.size() < 10000) {\n shuffle(edges.begin(), edges.end(), rng);\n \n bool changed = false;\n for (const auto& e : edges) {\n int val_top = grid[e.x1][e.y1];\n int val_bottom = grid[e.x2][e.y2];\n\n // If the top ball has a larger value than the bottom ball, swap them.\n // This directly enforces the heap property: Parent < Children\n if (val_top > val_bottom) {\n swap(grid[e.x1][e.y1], grid[e.x2][e.y2]);\n ops.push_back({e.x1, e.y1, e.x2, e.y2});\n changed = true;\n }\n }\n\n // If no swaps occurred in a full pass over all edges, the heap property is satisfied\n if (!changed) break;\n }\n\n // Output the count of operations and the coordinates of each swap\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: up, down, left, right\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\n\nstruct Pos {\n int r, c;\n bool operator<(const Pos& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n bool operator==(const Pos& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nclass Warehouse {\nprivate:\n int D;\n int N;\n vector> grid; // true = obstacle or occupied\n vector container_positions;\n vector priority_at_pos; // priority of container at each position\n vector possible_positions;\n vector possible_distances;\n \n // BFS to find reachable positions and their distances from entrance\n vector> reachable_positions() {\n vector> reachable;\n queue> q;\n vector> visited(D, vector(D, false));\n \n Pos start = {0, (D-1)/2};\n if (grid[start.r][start.c]) return reachable;\n \n q.push({start, 0});\n visited[start.r][start.c] = true;\n \n while (!q.empty()) {\n auto [pos, dist] = q.front();\n q.pop();\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D &&\n !visited[pos.r][pos.c] && !grid[pos.r][pos.c]) {\n reachable.push_back({pos, dist});\n visited[pos.r][pos.c] = true;\n \n for (int i = 0; i < 4; i++) {\n int nr = pos.r + dr[i];\n int nc = pos.c + dc[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && \n !grid[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({{nr, nc}, dist + 1});\n }\n }\n }\n }\n return reachable;\n }\n \n // Calculate distance from entrance for a position\n int distance_from_entrance(Pos pos) {\n int r = pos.r;\n int c = pos.c;\n int entrance_r = 0;\n int entrance_c = (D-1)/2;\n return abs(r - entrance_r) + abs(c - entrance_c);\n }\n \npublic:\n Warehouse(int D, int N, const vector& obstacles) \n : D(D), N(N), grid(D, vector(D, false)), \n container_positions((D*D - N - 1), {-1, -1}),\n priority_at_pos(D*D, -1) {\n \n // Mark obstacle positions\n for (const auto& obs : obstacles) {\n grid[obs.r][obs.c] = true;\n }\n \n // Mark entrance as blocked for storage\n grid[0][(D-1)/2] = true;\n \n // Pre-compute all possible storage positions sorted by distance\n set all_possible;\n for (int r = 0; r < D; r++) {\n for (int c = 0; c < D; c++) {\n if (!grid[r][c]) {\n all_possible.insert({r, c});\n }\n }\n }\n \n vector> sorted_positions;\n for (const auto& pos : all_possible) {\n sorted_positions.push_back({distance_from_entrance(pos), pos});\n }\n sort(sorted_positions.begin(), sorted_positions.end());\n \n for (const auto& item : sorted_positions) {\n possible_positions.push_back(item.second);\n possible_distances.push_back(item.first);\n }\n }\n \n // Find the best position for a container with given priority\n Pos find_placement() {\n vector> reachable = reachable_positions();\n \n if (reachable.empty()) {\n return {-1, -1}; // No valid position\n }\n \n // Heuristic: balance between distance from entrance and priority\n // Lower priority numbers should be closer for easier retrieval\n // Sort reachable positions by distance\n sort(reachable.begin(), reachable.end(),\n [](const pair& a, const pair& b) {\n return a.second < b.second;\n });\n \n // Choose position that allows future flexibility\n // Prefer positions that are not too deep in the warehouse\n for (const auto& [pos, dist] : reachable) {\n // Verify this position can be uniquely reached (not blocked)\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n return pos;\n }\n }\n \n // Fallback: return the most accessible position\n return reachable[0].first;\n }\n \n bool mark_occupied(Pos pos, int priority) {\n if (pos.r < 0 || pos.r >= D || pos.c < 0 || pos.c >= D) {\n return false;\n }\n if (grid[pos.r][pos.c]) {\n return false;\n }\n grid[pos.r][pos.c] = true; // Mark as occupied\n return true;\n }\n \n void free_position(Pos pos) {\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n grid[pos.r][pos.c] = false; // Mark as empty\n }\n }\n \n int total_containers() const {\n return container_positions.size();\n }\n \n const Pos& get_container_pos(int priority) const {\n if (priority >= 0 && priority < total_containers()) {\n return container_positions[priority];\n }\n return container_positions[0];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D, N;\n cin >> D >> N;\n \n vector obstacles;\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n obstacles.push_back({r, c});\n }\n \n Warehouse warehouse(D, N, obstacles);\n int total_containers = warehouse.total_containers();\n \n vector> placements(total_containers);\n \n // Place each container as it arrives\n for (int d = 0; d < total_containers; d++) {\n int priority;\n cin >> priority;\n \n Pos pos = warehouse.find_placement();\n \n while (pos.r == -1) { // Retry if no valid position\n int d2 = warehouse.total_containers();\n // This shouldn't happen with proper logic\n break;\n }\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n warehouse.mark_occupied(pos, priority);\n placements[priority] = {priority, pos};\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n }\n }\n \n // Output transport order: in priority order (0, 1, 2, ...)\n // We simply output containers in their assigned priority order\n for (int p = 0; p < total_containers; p++) {\n if (placements[p].first == p) {\n Pos pos = placements[p].second;\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n // Free the position after transport\n warehouse.free_position(pos);\n }\n }\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, M;\nint grid[55][55];\nint adj[105][105];\nint adj_count[105][105];\nint total_pixels[105];\nint vis[55][55];\nint q_node[2500];\nint bfs_iter = 0;\n\n// Helper to find a starting pixel of a specific color\nint get_start(int color) {\n for(int i=0; i 1000000) { \n // Optimization to avoid int overflow or reset if needed\n // Just clearing vis is safer if needed, but iter is large enough.\n // Just resetting vis every 10^6 iters might be slow. \n // Iter is safe for 2 sec (limit ~2e9).\n }\n\n int head = 0, tail = 0;\n q_node[tail++] = start;\n vis[start / N][start % N] = bfs_iter;\n int reached = 1;\n \n // Count total pixels of this color\n int total_count = 0;\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N && grid[nr][nc] == color) {\n if(vis[nr][nc] != bfs_iter) {\n vis[nr][nc] = bfs_iter;\n q_node[tail++] = nr * N + nc;\n reached++;\n }\n }\n }\n }\n\n return (reached == total_count);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n // Read input\n for(int i=0; i> grid[i][j];\n if(grid[i][j] != 0) total_pixels[grid[i][j]]++;\n }\n }\n\n // Clear arrays\n memset(adj, 0, sizeof(adj));\n memset(adj_count, 0, sizeof(adj_count));\n\n // Compute adjacencies from input map\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n \n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj[u][v] = 1; // Mark adjacency exists in Input\n }\n \n // Count adjacencies\n if(n != c) {\n int u = min(c, n);\n int v = max(c, n);\n adj_count[u][v]++;\n }\n }\n }\n }\n\n // Identify candidate pixels (all colored pixels)\n vector> pixels;\n pixels.reserve(N * N);\n for(int i=0; i= 0 && nr < N && nc >= 0 && nc < N) {\n if(grid[nr][nc] == color) neighbors_of_color++;\n }\n }\n\n // If pixel has < 2 neighbors of same color, removing it won't disconnect component\n // This is a strong heuristic. \n // Note: A pixel with 1 neighbor is a leaf or bridge (if 1 edge connects 2 blocks via this pixel).\n // If 1 neighbor, it's not a bridge cutting into >=2 parts.\n // So check connectivity only if >= 2 neighbors.\n bool need_check_connected = (neighbors_of_color >= 2);\n\n // Check adjacency constraints BEFORE modifying grid\n bool valid = true;\n\n // Check if we would break a required adjacency\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If n is 0, we don't lose adjacency with 0 unless p was the ONLY contact between color and 0\n // But we check adj_count logic\n \n if(n != 0 && n != color && adj[color][n] == 1) {\n int u = min(color, n);\n int v = max(color, n);\n // adj_count[u][v] stores contacts. \n // For non-0 neighbors, each contact is counted twice (once from each side).\n // Limit is 2 (meaning count 1 contact -> count 2 total).\n int limit = (u == 0 || v == 0) ? 1 : 2;\n if(adj_count[u][v] <= limit) {\n valid = false;\n break;\n }\n }\n }\n \n // Check if we create forbidden 0 adjacency\n if(valid) {\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n // n is color of neighbor\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n // If neighbor is color d (!= 0), it will become adjacent to 0 after removal.\n // Check if (0, d) is allowed.\n if(n != 0 && n != color && adj[0][n] == 0) {\n valid = false;\n break;\n }\n }\n }\n\n if(valid) {\n // Check connectivity if needed\n if(need_check_connected) {\n // Temporarily remove\n grid[r][c] = 0;\n int cnt;\n if(!check_connected(color, cnt)) {\n valid = false;\n }\n grid[r][c] = color; // Restore\n }\n }\n \n if(valid) {\n // Perform update\n grid[r][c] = 0;\n total_pixels[color]--;\n \n // Update adjacency counts\n for(int k=0; k<4; ++k) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n int n = 0;\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n n = grid[nr][nc];\n }\n if(n != 0 && n != color) { // n != 0 because if n=0 we treat 0 as color 0\n // Actually, if n=0, we update adj_count[0][color]\n }\n // We need to update for all neighbors.\n // n can be 0.\n int u = min(color, n);\n int v = max(color, n);\n // If n was a colored pixel (d>0), it contributed 2.\n // If n was 0, it contributed 1.\n // We remove 2 or 1.\n // Since adj_count[u][v] was incremented by 2 for d>0 (when processing u) \n // and by 2 for d>0 (when processing v).\n // Wait, I used `adj_count[u][v]++` in Init loop.\n // When u sees v, count++. When v sees u, count++.\n // So count is 2.\n // When removing u (p), we remove count contribution from u side.\n // So decrement by 1 (from u side).\n // Wait, if n is a pixel, it sees me.\n // In Init loop, if cell `x` sees neighbor `y`, `adj_count` increments.\n // So edge `x-y` contributes 2 to `adj_count`.\n // Removing `x` (which is `p`) removes `x` side of adjacency.\n // So decrement `adj_count` by 2?\n // Yes, because both x and y contribute.\n // Wait, if `y` also sees `x`. `x` is neighbor of `y`.\n // If I remove `p` (x).\n // `adj_count` counts edges.\n // Edge (x, y) contributes 2 to count.\n // Removing x means edge (x, y) is gone.\n // So decrement by 2?\n // Wait, my check `adj_count <= limit` assumes limit 2 means \"unique contact\".\n // If unique contact exists, count is 2. Removing p removes all 2?\n // No. If unique contact exists, p is the ONLY pixel of color touching d.\n // So p's side contributes 1. d's side contributes 1.\n // So total count 2.\n // If I remove p, I remove p's side.\n // Does it remove d's side?\n // d's side contact was with p.\n // So if p is gone, d has no neighbor p.\n // So d's side contribution is lost.\n // So total contribution lost is 2.\n // So decrement by 2.\n \n // Wait, what if `n` is 0.\n // Edge (p, 0).\n // p contributes 1. 0 (outside) not processed.\n // If `0` region exists in grid. p contributes 1. 0 (at neighbor) not processed.\n // So total 1.\n // So decrement by 1 for 0 neighbors?\n // Or is `n` 0 (outside) vs `n` 0 (pixel)?\n // Both treated as `n=0`.\n // But my `adj_count` loop didn't count 0 side.\n // So count is 1.\n // So decrement by 1 if `n==0`?\n \n // Wait, if `grid` has 0 pixel.\n // `p` is color c. Neighbor `q` is 0 pixel.\n // Loop `p`: sees `q` (0). count[0][c]++ (1).\n // Loop `q`: skipped.\n // So count is 1.\n // So decrement `adj_count[0][color]` by 1.\n \n // Wait, if `n` is 0 (outside boundary).\n // Loop `p`: sees boundary 0. count[0][c]++ (1).\n // So count is 1.\n // So decrement by 1.\n \n // So `if (n != 0)`?\n // Wait, `n` is the neighbor's color.\n // If `n != 0` (colored). Decrement 2.\n // If `n == 0`. Decrement 1.\n // Wait, `adj_count` logic in loop:\n // `adj_count[0][color]++`\n // `adj_count[color][d]++`\n // It always increments `adj_count[min][max]`.\n // The issue is `n` could be `color` (if `n` was colored `d`).\n // If `n` (neighbor) is colored `d`.\n // When processing `p` (color `c`), I see `d`. Increment `count[c][d]`.\n // When processing `d` (at neighbor location), I see `c` (which was `p`). Increment `count[d][c]`.\n // So total 2.\n // When `p` removed.\n // `p` side contribution lost: 1.\n // `d` side contribution lost: 1 (since `p` was neighbor).\n // Total 2.\n // So decrement 2.\n // If `n` is 0.\n // `p` sees 0. Increment `count[0][c]` (1).\n // `0` is skipped in loop.\n // So total 1.\n // When `p` removed.\n // `p` contribution lost: 1.\n // `0` contribution lost: 0.\n // Total 1.\n // So decrement 1.\n \n // So: `int dec = (n == 0) ? 1 : 2;` ?\n // Wait, `n` is neighbor color.\n // If `n` is 0 (pixel or boundary).\n // Yes.\n // Wait, `adj[u][v]` check uses `limit`.\n // `limit` logic: if `u==0 || v==0` then `limit=1`.\n // Else `limit=2`.\n // So `dec` should match `limit`.\n \n int dec = (u == 0 || v == 0) ? 1 : 2;\n adj_count[u][v] -= dec;\n }\n }\n }\n }\n\n // Output\n for(int i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace atcoder;\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int N, D, Q;\n if (!(std::cin >> N >> D >> Q)) return 0;\n \n // Store comparison results for building weight estimates\n std::vector weight_estimate(N, 0);\n std::vector> weight_confidence(N, std::vector(N, 0.0));\n \n int used_queries = 0;\n std::mt19937 rng(42);\n \n // Phase 1: Learning weights through pairwise comparisons\n // Use tournament-style comparisons\n for (int i = 0; i < N - 1 && used_queries < Q; i++) {\n for (int j = i + 1; j < N && used_queries < Q; j++) {\n if (used_queries >= Q) break;\n \n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 1.0;\n weight_confidence[i][j] = 1.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 1.0;\n weight_confidence[j][i] = 1.0;\n } else {\n // Equal\n weight_estimate[i] += 0.5;\n weight_estimate[j] += 0.5;\n weight_confidence[i][j] = 0.5;\n weight_confidence[j][i] = 0.5;\n }\n }\n }\n \n // Phase 2: Query more comparisons for better ranking (if queries remain)\n // Use larger gaps for better ranking spread\n for (int gap = 1; gap <= 5 && used_queries < Q; gap++) {\n for (int i = 0; i < N - gap && used_queries < Q; i++) {\n int j = i + gap;\n if (weight_confidence[i][j] < 0.5) {\n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 2.0;\n weight_confidence[i][j] = 2.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 2.0;\n weight_confidence[j][i] = 2.0;\n } else {\n weight_estimate[i] += 1.0;\n weight_estimate[j] += 1.0;\n weight_confidence[i][j] = 1.0;\n weight_confidence[j][i] = 1.0;\n }\n }\n }\n }\n \n // Phase 3: Use remaining queries for verification/refinement\n // Compare items with known reference points\n if (used_queries < Q && N > 2) {\n std::vector item_order(N);\n std::iota(item_order.begin(), item_order.end(), 0);\n \n // Quick sort by weight estimate\n std::sort(item_order.begin(), item_order.end(), [&](int a, int b) {\n return weight_estimate[a] > weight_estimate[b];\n });\n \n // Verify middle items with extreme items\n int mid_idx = N / 2;\n int low_item = item_order[0];\n int high_item = item_order[N - 1];\n \n for (int k = 1; k < std::min(5, mid_idx + 1) && used_queries < Q; k++) {\n int mid_item = item_order[k];\n std::cout << 1 << \" \" << 1 << \" \" << mid_item << \" \" << high_item << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \"<\") {\n weight_estimate[high_item] += 3.0;\n } else if (result == \">\") {\n weight_estimate[mid_item] += 3.0;\n }\n }\n }\n \n // Phase 4: Sort items by estimated weight\n std::vector> items_by_weight(N);\n for (int i = 0; i < N; i++) {\n items_by_weight[i] = {weight_estimate[i], i};\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n \n // Handle edge case where all weights are the same\n if (used_queries >= Q) {\n // Add small random jitter to break ties\n std::uniform_real_distribution jitter_dist(-0.1, 0.1);\n for (auto& p : items_by_weight) {\n if (p.first == 0.0) {\n p.first = jitter_dist(rng);\n }\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n }\n \n // Phase 5: LPT Greedy Partitioning\n std::vector partition(N);\n std::vector set_weights(D, 0.0);\n std::vector> set_items(D);\n \n for (const auto& item_data : items_by_weight) {\n int item_idx = item_data.second;\n \n // Find set with minimum weight\n int best_set = 0;\n double min_weight = set_weights[0];\n for (int s = 1; s < D; s++) {\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n best_set = s;\n }\n }\n \n partition[item_idx] = best_set;\n set_items[best_set].push_back(item_idx);\n set_weights[best_set] += item_data.first;\n }\n \n // Phase 6: Simple local search refinement with proper bounds checking\n bool improved = true;\n int max_iterations = std::min(10, D);\n int iteration_count = 0;\n \n while (improved && iteration_count < max_iterations) {\n improved = false;\n iteration_count++;\n \n // Recalculate set weights\n std::fill(set_weights.begin(), set_weights.end(), 0.0);\n for (int i = 0; i < N; i++) {\n set_weights[partition[i]] += items_by_weight[i].first;\n }\n \n // Find max and min weighted sets\n int max_set = 0, min_set = 0;\n double max_weight = set_weights[0], min_weight = set_weights[0];\n \n for (int s = 1; s < D; s++) {\n if (set_weights[s] > max_weight) {\n max_weight = set_weights[s];\n max_set = s;\n }\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n min_set = s;\n }\n }\n \n // Try moving items from max weight set to min weight set\n std::vector& from_set = set_items[max_set];\n std::vector& to_set = set_items[min_set];\n \n if (from_set.empty()) {\n break;\n }\n \n for (const int& item_idx : from_set) {\n // Calculate weight change if we move this item\n double weight_of_item = items_by_weight[N - 1 - max_set].first;\n // Actually get correct weight\n for (int i = 0; i < N; i++) {\n if (items_by_weight[i].second == item_idx) {\n weight_of_item = items_by_weight[i].first;\n break;\n }\n }\n \n double old_max_weight = set_weights[max_set];\n double old_min_weight = set_weights[min_set];\n \n double new_max = old_max_weight - weight_of_item;\n double new_min = old_min_weight + weight_of_item;\n \n // Check if moving improves balance\n double old_range = std::max(old_max_weight, old_min_weight) - \n std::min(old_max_weight, old_min_weight);\n double new_range = std::max(new_max, new_min) - \n std::min(new_max, new_min);\n // Also check impact on intermediate sets\n bool all_within_range = true;\n for (int s = 0; s < D; s++) {\n if (s != max_set && s != min_set) {\n double ws = set_weights[s];\n if (std::abs(ws - new_min) > 1.1 * std::abs(old_max_weight - old_min_weight)) {\n all_within_range = false;\n break;\n }\n }\n }\n \n if (new_range < old_range * 0.95 && all_within_range) {\n // Make the move\n partition[item_idx] = min_set;\n set_items[max_set].erase(std::find(set_items[max_set].begin(), \n set_items[max_set].end(), item_idx));\n set_items[min_set].push_back(item_idx);\n set_weights[max_set] -= weight_of_item;\n set_weights[min_set] += weight_of_item;\n improved = true;\n break;\n }\n }\n }\n \n // Phase 7: Output final partition\n for (int i = 0; i < N; i++) {\n std::cout << partition[i] << (i == N - 1 ? \"\\n\" : \" \");\n }\n \n std::flush(std::cout);\n \n return 0;\n}","ahc026":"#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 n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> stacks(m);\n vector box_pos(n + 1);\n vector carried_out(n + 1, false);\n vector needed_soon(n + 1, false);\n\n // Read input and initialize position tracking\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int b;\n cin >> b;\n stacks[i].push_back(b);\n box_pos[b] = i;\n }\n }\n\n vector> operations;\n operations.reserve(n * 3);\n\n for (int v = 1; v <= n; ++v) {\n if (carried_out[v]) continue;\n\n int src_idx = box_pos[v];\n int box_idx = -1;\n\n // Find index of v in source stack\n for (int i = 0; i < (int)stacks[src_idx].size(); ++i) {\n if (stacks[src_idx][i] == v) {\n box_idx = i;\n break;\n }\n }\n\n if (box_idx < 0 || box_idx >= (int)stacks[src_idx].size()) {\n continue;\n }\n\n int boxes_above = (int)stacks[src_idx].size() - box_idx - 1;\n\n if (boxes_above > 0) {\n int bottom_idx = box_idx + 1;\n int bottom_value = stacks[src_idx][bottom_idx];\n\n // Find optimal destination stack\n // Strategy: \n // 1. Empty stacks (highest priority - never block)\n // 2. Stack with top > current box value (maintains order)\n // 3. Stack with highest top value as fallback\n\n int dest_idx = -1;\n bool found_empty = false;\n\n // First pass: look for empty stack or best match\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n\n if (stacks[i].empty()) {\n dest_idx = i;\n found_empty = true;\n break;\n }\n }\n\n // If no empty stack, find best non-empty stack\n if (!found_empty) {\n dest_idx = -1;\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n int top_val = stacks[i].back();\n int score;\n\n // Prefer stacks where top > bottom_value (to maintain good ordering)\n if (top_val > bottom_value) {\n score = 20000 + top_val;\n } else {\n score = top_val;\n }\n\n if (dest_idx == -1 || score > stacks[dest_idx].back()) {\n dest_idx = i;\n }\n }\n }\n\n // Move all boxes above v in one operation\n vector moved_boxes;\n moved_boxes.reserve(boxes_above);\n for (int i = bottom_idx; i < (int)stacks[src_idx].size(); ++i) {\n moved_boxes.push_back(stacks[src_idx][i]);\n }\n\n // Remove from source\n if ((int)stacks[src_idx].size() > bottom_idx) {\n stacks[src_idx].resize(bottom_idx);\n }\n\n // Update positions\n for (int val : moved_boxes) {\n box_pos[val] = dest_idx;\n }\n\n // Add to destination\n for (int val : moved_boxes) {\n stacks[dest_idx].push_back(val);\n }\n\n // Record operation\n operations.push_back({bottom_value, dest_idx + 1});\n }\n\n // Extract v\n operations.push_back({v, 0});\n carried_out[v] = true;\n\n // Clean up v\n vector& src = stacks[src_idx];\n if (!src.empty() && src.back() == v) {\n src.pop_back();\n }\n }\n\n // Output operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h_in;\nvector v_in;\nvector> d_grid;\nvector> children;\nvector parents;\nvector x_vec;\nvector cnt_vec;\nvector version;\nint V;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n h_in.resize(N - 1);\n for(int i = 0; i < N - 1; ++i) cin >> h_in[i];\n v_in.resize(N);\n for(int i = 0; i < N; ++i) cin >> v_in[i];\n d_grid.resize(N, vector(N));\n V = N * N;\n for(int i = 0; i < N; ++i) {\n for(int j = 0; j < N; ++j) cin >> d_grid[i][j];\n }\n\n parents.assign(V, -1);\n children.assign(V, vector());\n x_vec.assign(V, 1);\n x_vec[0] = 0;\n cnt_vec.assign(V, 0);\n version.assign(V, 0);\n\n // BFS spanning tree\n queue q;\n q.push(0);\n vector visited(V, false);\n visited[0] = true;\n\n while(!q.empty()){\n int u = q.front(); q.pop();\n int r = u / N, c = u % N;\n\n if(r + 1 < N && h_in[r][c] == '0') {\n int v = (r + 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(r - 1 >= 0 && h_in[r - 1][c] == '0') {\n int v = (r - 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c + 1 < N && v_in[r][c] == '0') {\n int v = r * N + (c + 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c - 1 >= 0 && v_in[r][c - 1] == '0') {\n int v = r * N + (c - 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n }\n\n // Initial cnt calculation\n for(int i = V - 1; i >= 0; --i) {\n cnt_vec[i] = x_vec[i];\n for(int c : children[i]) cnt_vec[i] += cnt_vec[c];\n }\n\n // Helper to calculate gain\n auto get_gain = [&](int u) {\n double g = 0.0;\n int curr = u;\n while(curr != -1) {\n if(cnt_vec[curr] > 0) {\n g += (double)d_grid[curr / N][curr % N] / ( (double)cnt_vec[curr] * ((double)cnt_vec[curr] + 1.0) );\n }\n if(curr == 0) break;\n curr = parents[curr];\n }\n return g;\n };\n\n // Priority Queue: {gain, u, version}\n priority_queue> pq;\n\n for(int i = 1; i < V; ++i) {\n version[i]++;\n double g = get_gain(i);\n pq.push({g, i, version[i]});\n }\n\n long long budget = 50000; // sum(x) <= 50000\n long long current_sum = 0;\n for(int i = 0; i < V; ++i) current_sum += x_vec[i];\n long long remaining = budget - current_sum;\n if(remaining < 0) remaining = 0;\n\n for(long long iter = 0; iter < remaining && !pq.empty(); ++iter) {\n tuple top = pq.top(); pq.pop();\n double gain = get<0>(top);\n int u = get<1>(top);\n int v = get<2>(top);\n\n // Check if this entry is outdated\n if(v != version[u]) continue;\n\n // Apply increment\n x_vec[u]++;\n\n // Update cnt for u and all ancestors\n int curr = u;\n while(curr != -1) {\n cnt_vec[curr]++;\n curr = parents[curr];\n if(curr == -1) break;\n }\n\n // Update PQ entries for affected nodes\n curr = u;\n while(curr != -1) {\n version[curr]++;\n double ng = get_gain(curr);\n pq.push({ng, curr, version[curr]});\n curr = parents[curr];\n if(curr == -1) break;\n }\n }\n\n // Generate path using DFS\n string ans;\n ans.reserve(100000);\n\n auto dfs = [&](auto&& self, int u) -> void {\n for(int v : children[u]) {\n int r_u = u / N, c_u = u % N;\n int r_v = v / N, c_v = v % N;\n char dir = ' ';\n char back = ' ';\n if(r_v == r_u + 1) { dir = 'D'; back = 'U'; }\n else if(r_v == r_u - 1) { dir = 'U'; back = 'D'; }\n else if(c_v == c_u + 1) { dir = 'R'; back = 'L'; }\n else if(c_v == c_u - 1) { dir = 'L'; back = 'R'; }\n\n for(long long k = 0; k < x_vec[v]; ++k) {\n ans += dir;\n self(self, v);\n ans += back;\n }\n }\n };\n\n dfs(dfs, 0);\n cout << ans << endl;\n\n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int r, c;\n int dist(const Point& o) const { return abs(r - o.r) + abs(c - o.c); }\n bool operator==(const Point& o) const { return r == o.r && c == o.c; }\n};\n\nstruct Occurrence {\n Point start;\n Point end;\n int internal_cost;\n vector path;\n};\n\nint N, M;\nint s_r, s_c;\nchar A[20][20];\nvector words;\nvector> word_occurrences;\n\nvoid precompute_occurrences() {\n word_occurrences.resize(M);\n struct Parent { int r, c, d; };\n\n for (int k = 0; k < M; ++k) {\n if (words[k].size() != 5) continue;\n\n vector current_occs;\n \n for (int sr = 0; sr < N; ++sr) {\n for (int sc = 0; sc < N; ++sc) {\n if (A[sr][sc] != words[k][0]) continue;\n\n struct Node { Point p; int d; int cost; bool operator>(const Node& o) const { return cost > o.cost; } };\n \n static int dist_map[20][20][6];\n static Parent parent_map[20][20][6];\n for(int r=0; r, greater> pq;\n while(!pq.empty()) pq.pop();\n \n dist_map[sr][sc][0] = 1;\n pq.push({{sr, sc}, 0, 1});\n \n while(!pq.empty()){\n Node top = pq.top(); pq.pop();\n int r = top.p.r, c = top.p.c, d = top.d, cost = top.cost;\n \n if (cost > dist_map[r][c][d]) continue;\n \n if (d == 4) {\n vector path;\n int cr = r, cc = c, cd = d;\n while(cd >= 0) {\n path.push_back({cr, cc});\n if (cd > 0) {\n Parent p = parent_map[cr][cc][cd];\n cr = p.r; cc = p.c; cd = p.d;\n } else break;\n }\n reverse(path.begin(), path.end());\n \n Occurrence occ_curr;\n occ_curr.start = {sr, sc};\n occ_curr.end = {r, c};\n occ_curr.internal_cost = cost;\n occ_curr.path = path;\n \n current_occs.push_back(occ_curr);\n }\n \n if (d < 4) {\n int next_char_idx = d + 1;\n char needed = words[k][next_char_idx];\n for (int dr = -1; dr <= 1; ++dr) {\n for (int dc = -1; dc <= 1; ++dc) {\n int nr = r + dr, nc = c + dc;\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && A[nr][nc] == needed) {\n int move_cost = abs(dr) + abs(dc);\n int new_cost = cost + move_cost + 1;\n if (new_cost < dist_map[nr][nc][d+1]) {\n dist_map[nr][nc][d+1] = new_cost;\n parent_map[nr][nc][d+1] = {r, c, d};\n pq.push({{nr, nc}, d+1, new_cost});\n }\n }\n }\n }\n }\n }\n }\n }\n \n sort(current_occs.begin(), current_occs.end(), [](const Occurrence& a, const Occurrence& b){\n if (a.start == b.start && a.end == b.end) return a.internal_cost < b.internal_cost;\n return a.internal_cost < b.internal_cost;\n });\n \n vector unique_occs;\n unique_occs.reserve(current_occs.size());\n if (!current_occs.empty()) {\n unique_occs.push_back(current_occs[0]);\n for(size_t i=1; i 5) unique_occs.resize(5);\n word_occurrences[k] = unique_occs;\n }\n}\n\nint get_total_cost(const vector& perm) {\n static int dp[20][20];\n static int next_dp[20][20];\n static int best_dist[20][20];\n int INF = 2e9;\n \n for(int r=0; r& occs = word_occurrences[k];\n \n for(int r=0; r 0 && best_dist[r-1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r-1][c] + 1;\n if (r < N-1 && best_dist[r+1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r+1][c] + 1;\n }\n }\n for(int r=0; r 0 && best_dist[r][c-1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c-1] + 1;\n if (c < N-1 && best_dist[r][c+1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c+1] + 1;\n }\n }\n \n for(int r=0; r> N >> M)) return 0;\n cin >> s_r >> s_c;\n for(int i=0; i> row;\n for(int j=0; j> words[i];\n \n precompute_occurrences();\n \n vector perm(M);\n for(int i=0; i rand_idx(0, M-1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n \n int base_cost = get_total_cost(perm);\n int best_cost = base_cost;\n vector best_perm = perm;\n \n for(int iter=0; iter<2000; ++iter) {\n vector next_perm = perm;\n int i = rand_idx(mt);\n int j = rand_idx(mt);\n swap(next_perm[i], next_perm[j]);\n \n int next_cost = get_total_cost(next_perm);\n bool accept = false;\n if (next_cost < best_cost) {\n accept = true;\n best_cost = next_cost;\n best_perm = next_perm;\n } else {\n if (rand_prob(mt) < exp((base_cost - next_cost) / (5000.0))) {\n accept = true;\n base_cost = next_cost;\n }\n if (accept) perm = next_perm;\n }\n }\n \n static int dp[20][20];\n static int next_dp[20][20];\n static int best_dist[20][20];\n static int INF = 2e9;\n \n for(int r=0; r> history_occ_idx(M, vector(max_idx, -1));\n vector>> history_dp(M + 1, vector>(N, vector(N, INF)));\n history_dp[0][s_r][s_c] = 0;\n\n for(int w=0; w& occs = word_occurrences[k];\n \n for(int r=0; r 0 && best_dist[r-1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r-1][c] + 1;\n if (r < N-1 && best_dist[r+1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r+1][c] + 1;\n }\n }\n for(int r=0; r 0 && best_dist[r][c-1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c-1] + 1;\n if (c < N-1 && best_dist[r][c+1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c+1] + 1;\n }\n }\n \n for(size_t idx=0; idx= 0; --w) {\n int k = best_perm[w];\n const vector& occs = word_occurrences[k];\n int idx = history_occ_idx[w][r * N + c];\n \n if (idx == -1) {\n r = s_r; \n c = s_c;\n continue;\n }\n \n const auto& occ = occs[idx];\n \n for(const auto& pt : occ.path) {\n cout << pt.r << \" \" << pt.c << \"\\n\";\n }\n \n if (w > 0) {\n int prev_r = -1, prev_c = -1;\n \n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\n// Helper function for ceiling integer division\ninline int ceil_div(int a, int b) {\n return (a + b - 1) / b;\n}\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n // Read reservation areas\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 // Step 1: Calculate minimum width for each reservation k to ensure h <= W\n // Each rectangle must have height \u2264 W, so w*k >= ceil(a[k]/W)\n vector w(N);\n for (int k = 0; k < N; ++k) {\n int max_a = 0;\n for (int d = 0; d < D; ++d) {\n max_a = max(max_a, a[d][k]);\n }\n w[k] = ceil_div(max_a, W);\n }\n\n // Step 2: Calculate total width used and remaining\n int current_sum = 0;\n for (int val : w) current_sum += val;\n \n // Step 3: Greedily distribute remaining width to minimize partition transition cost\n int remaining = W - current_sum;\n \n if (remaining > 0) {\n // Add width one pixel at a time, always staying within W\n for (int step = 0; step < remaining; ++step) {\n int best_k = -1;\n long long best_reduction = 0;\n bool found = false;\n \n // Try to find which strip gives maximum cost reduction\n for (int k = 0; k < N; ++k) {\n int old_w = w[k];\n int new_w = old_w + 1;\n \n // Calculate cost contribution of column k before and after adding width\n long long old_cost = 0;\n long long new_cost = 0;\n \n for (int d = 1; d < D; ++d) {\n int h1_old = ceil_div(a[d-1][k], old_w);\n int h2_old = ceil_div(a[d][k], old_w);\n int diff_old = abs(h1_old - h2_old);\n \n int h1_new = ceil_div(a[d-1][k], new_w);\n int h2_new = ceil_div(a[d][k], new_w);\n int diff_new = abs(h1_new - h2_new);\n \n old_cost += (long long)old_w * diff_old;\n new_cost += (long long)new_w * diff_new;\n }\n \n long long reduction = old_cost - new_cost;\n if (reduction > best_reduction) {\n best_reduction = reduction;\n best_k = k;\n found = true;\n }\n }\n \n if (found && best_k != -1 && best_reduction > 0) {\n w[best_k]++;\n } else {\n // No benefit to adding more width or all widths would exceed W\n break;\n }\n }\n }\n\n // Step 4: Ensure total width never exceeds W (should be guaranteed by algorithm)\n int final_sum = 0;\n for (int val : w) final_sum += val;\n \n if (final_sum > W) {\n // Reduce from the end if necessary\n int overflow = final_sum - W;\n for (int k = N - 1; k >= 0 && overflow > 0; --k) {\n int reduce = min(overflow, w[k] - 1); // Keep at least 1\n w[k] -= reduce;\n overflow -= reduce;\n }\n } else if (final_sum < W) {\n // Add remaining to w[0] or distribute\n int remaining_fill = W - final_sum;\n w[0] += remaining_fill;\n }\n\n // Step 5: Calculate starting x coordinates for each strip\n vector x_start(N);\n int curr_x = 0;\n for (int k = 0; k < N; ++k) {\n x_start[k] = curr_x;\n curr_x += w[k];\n }\n\n // Step 6: Output with validation (all coordinates \u2264 W)\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int h = ceil_div(a[d][k], w[k]);\n // Clamp coordinates to ensure validity\n int i0 = 0, j0 = x_start[k];\n int i1 = min(h, W), j1 = min(x_start[k] + w[k], W);\n \n // Ensure i0 < i1 and j0 < j1\n if (i1 <= i0) i1 = i0 + 1;\n if (j1 <= j0) j1 = j0 + 1;\n \n cout << i0 << \" \" << j0 << \" \" << i1 << \" \" << j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 9;\nconst int M = 20;\nconst int K = 81;\nconst int MOD = 998244353;\nconst int MAX_MOVES = 981; // 20 * 49 + 1 (None)\n\n// Board state\nint board[N][N];\nlong long current_score = 0;\n\n// Move related data structures\n// move_impact_flat_flat[id][rc] stores the value added to cell rc by move id\nint move_impact_flat_flat[MAX_MOVES][81]; \n\nstruct Cell {\n int r, c;\n};\nvector move_cells_flat[MAX_MOVES]; \n\nvector valid_moves_list;\nmt19937 rng;\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_in, M_in, K_in;\n if (!(cin >> N_in >> M_in >> K_in)) return 0;\n\n // Read initial values\n for (int i = 0; i < N_in; ++i) {\n for (int j = 0; j < N_in; ++j) {\n cin >> board[i][j];\n current_score += board[i][j];\n }\n }\n\n // Read stamps\n vector> stamps(M_in, vector(9));\n for (int m = 0; m < M_in; ++m) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n cin >> stamps[m][i * 3 + j];\n }\n }\n }\n\n // Precompute moves\n int p_limit = N_in - 2; // 7\n valid_moves_list.push_back(980); // None move ID\n\n for (int m = 0; m < M_in; ++m) {\n for (int p = 0; p < p_limit; ++p) {\n for (int q = 0; q < p_limit; ++q) {\n int id = m * 49 + (p * 7 + q);\n valid_moves_list.push_back(id);\n\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = p + i;\n int c = q + j;\n if (r >= 0 && r < N_in && c >= 0 && c < N_in) {\n int val = stamps[m][i * 3 + j];\n move_impact_flat_flat[id][r * N_in + c] = val;\n if (val != 0) {\n move_cells_flat[id].push_back({r, c});\n }\n }\n }\n }\n }\n }\n }\n \n // Initialize RNG\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n // Initialize current moves\n vector current_moves(K);\n for (int i = 0; i < K; ++i) {\n int idx = 1 + rng() % (valid_moves_list.size() - 1);\n current_moves[i] = valid_moves_list[idx];\n }\n\n // Apply initial moves to board\n for (int lid = 0; lid < K; ++lid) {\n int mid = current_moves[lid];\n for (const auto& cell : move_cells_flat[mid]) {\n int idx = cell.r * N_in + cell.c;\n long long val = board[cell.r][cell.c] + move_impact_flat_flat[mid][idx];\n if (val >= MOD) val -= MOD;\n board[cell.r][cell.c] = val;\n }\n }\n\n // Recompute score\n current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += board[i][j];\n }\n }\n\n // Simulated Annealing / Hill Climbing\n // Increased iterations to 8000-10000\n int iter_count = 8000; \n double initial_temp = 5000.0;\n double temp = initial_temp;\n double decay = 0.998;\n \n bool visited[81]; // Tracks if a cell is covered by curr_move\n uniform_real_distribution dist(0.0, 1.0);\n \n static int visited_indices[16]; \n\n for (int iter = 0; iter < iter_count; ++iter) {\n int slot_idx = rng() % K;\n int curr_move_id = current_moves[slot_idx];\n \n // Mark visited for curr_move cells\n int vic_count = 0;\n for (const auto& cell : move_cells_flat[curr_move_id]) {\n int rc = cell.r * N_in + cell.c;\n visited[rc] = true;\n if (vic_count < 16) visited_indices[vic_count++] = rc;\n }\n \n // Iterate all candidates to find the best delta\n int best_cand_id = curr_move_id;\n long long best_delta = 0; // Initialize to 0 (stay put)\n \n // Check neighbors (all valid moves)\n // To speed up, we can use direct array instead of vector\n for (int i = 0; i < (int)valid_moves_list.size(); ++i) {\n int cand_id = valid_moves_list[i];\n if (cand_id == curr_move_id) continue;\n \n long long delta = 0;\n \n // Subtract curr impact\n for (const auto& cell : move_cells_flat[curr_move_id]) {\n int idx = cell.r * N_in + cell.c;\n int imp_curr = move_impact_flat_flat[curr_move_id][idx];\n int imp_cand = move_impact_flat_flat[cand_id][idx];\n \n long long val_old = board[cell.r][cell.c];\n long long val_new = (val_old - imp_curr + imp_cand + MOD) % MOD;\n delta += (val_new - val_old);\n }\n \n // Add cand impact\n for (const auto& cell : move_cells_flat[cand_id]) {\n int idx = cell.r * N_in + cell.c;\n if (visited[idx]) continue;\n int imp_cand = move_impact_flat_flat[cand_id][idx];\n long long val_old = board[cell.r][cell.c];\n long long val_new = val_old + imp_cand;\n if (val_new >= MOD) val_new -= MOD;\n delta += (val_new - val_old);\n }\n \n if (delta > best_delta) {\n best_delta = delta;\n best_cand_id = cand_id;\n }\n }\n \n // SA / Hill Climbing Acceptance\n // Accept if improvement or with probability based on temperature\n double accept_prob = (best_delta >= 0) ? 1.0 : exp((double)best_delta / temp);\n if (dist(rng) < accept_prob) {\n if (best_cand_id != curr_move_id) {\n current_moves[slot_idx] = best_cand_id;\n \n // Update board\n // Revert curr\n for (const auto& cell : move_cells_flat[curr_move_id]) {\n int idx = cell.r * N_in + cell.c;\n long long val = board[cell.r][cell.c] - move_impact_flat_flat[curr_move_id][idx];\n if (val < 0) val += MOD;\n board[cell.r][cell.c] = val;\n }\n // Apply cand\n for (const auto& cell : move_cells_flat[best_cand_id]) {\n int idx = cell.r * N_in + cell.c;\n long long val = board[cell.r][cell.c] + move_impact_flat_flat[best_cand_id][idx];\n if (val >= MOD) val -= MOD;\n board[cell.r][cell.c] = val;\n }\n }\n current_score += best_delta;\n }\n \n // Reset visited\n for (int k = 0; k < vic_count; ++k) {\n visited[visited_indices[k]] = false;\n }\n \n // Decay temperature\n temp *= decay;\n }\n\n // Output result\n vector>> final_ops;\n for (int i = 0; i < K; ++i) {\n if (current_moves[i] != 980) { // None ID\n int id = current_moves[i];\n int m = id / 49;\n int rem = id % 49;\n int p = rem / 7;\n int q = rem % 7;\n final_ops.push_back({m, {p, q}});\n }\n }\n \n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_ops) {\n cout << op.first << \" \" << op.second.first << \" \" << op.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 5;\nconst int MAX_TURNS = 5000;\n\nint grid[MAX_N][MAX_N];\npair crane_pos[MAX_N];\nint crane_load[MAX_N];\nint A[MAX_N][MAX_N];\nint input_idx[MAX_N];\nstring ans[MAX_N];\nbool is_crane_here[MAX_N]; // Track if crane occupies each cell\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char move_char[] = {'U', 'D', 'L', 'R'};\n\nstruct Crane {\n int id;\n int type; // 0:Wait, 1:Move, 2:P, 3:Q\n int nr, nc;\n int score;\n int dist; // Distance to target for tie-breaking\n};\n\nvoid solve() {\n int N = 5;\n \n // Initialization\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) grid[i][j] = -1;\n input_idx[i] = 0;\n crane_pos[i] = {i, 0};\n crane_load[i] = -1;\n ans[i] = \"\";\n is_crane_here[i] = false;\n }\n\n int held_cnt = 0;\n int turns = 0;\n \n while (turns < MAX_TURNS) {\n // Check termination\n int total_received = 0;\n for (int i = 0; i < N; ++i) total_received += input_idx[i];\n if (total_received >= N * N && held_cnt == 0) break;\n\n // Step 1: Input Spawning\n for (int i = 0; i < N; ++i) {\n if (input_idx[i] == N) continue;\n bool blocked = (grid[i][0] != -1);\n for (int c = 0; c < N; ++c) {\n if (crane_pos[c].first == i && crane_pos[c].second == 0) {\n if (crane_load[c] != -1) {\n blocked = true;\n break;\n }\n }\n }\n if (!blocked) {\n grid[i][0] = A[i][input_idx[i]];\n input_idx[i]++;\n }\n }\n\n total_received = 0;\n for (int i = 0; i < N; ++i) total_received += input_idx[i];\n if (total_received >= N * N && held_cnt == 0) break;\n\n // Step 2: Build crane occupancy map\n map, int> occupancy;\n for (int i = 0; i < N; ++i) {\n occupancy[crane_pos[i]] = i; // Crane ID\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = true;\n }\n\n // Step 3: Plan Actions\n vector cranes(N);\n for (int i = 0; i < N; ++i) {\n cranes[i].id = i;\n cranes[i].nr = crane_pos[i].first;\n cranes[i].nc = crane_pos[i].second;\n cranes[i].score = 0;\n cranes[i].dist = 100;\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n\n // Priority 1: Q (Dispatch at correct gate)\n if (c == N - 1 && crane_load[i] != -1) {\n int row_id = crane_load[i] / N;\n if (row_id == r) {\n cranes[i].type = 3;\n cranes[i].score = 20000;\n cranes[i].dist = 0;\n }\n }\n\n // Priority 2: P (Pickup container)\n if (cranes[i].type == 0 && crane_load[i] == -1) {\n if (grid[r][c] != -1) {\n cranes[i].type = 2;\n cranes[i].score = 10000;\n cranes[i].dist = 0;\n }\n }\n\n // Priority 3: Move toward nearest goal\n if (cranes[i].type == 0) {\n int tr = r, tc = c;\n int dist_bonus = 0;\n\n if (crane_load[i] != -1) {\n tr = crane_load[i] / N;\n tc = N - 1;\n dist_bonus = 1000;\n } else {\n // Find row with most pending input\n int best_row = -1;\n int max_pending = 0;\n for (int k = 0; k < N; ++k) {\n if (input_idx[k] < N) {\n if (input_idx[k] > max_pending) {\n max_pending = input_idx[k];\n best_row = k;\n }\n }\n }\n if (best_row == -1) {\n for (int k = 0; k < N; ++k) {\n if (input_idx[k] < N) {\n best_row = k;\n break;\n }\n }\n }\n if (best_row != -1) {\n tr = best_row;\n tc = 0;\n dist_bonus = 5 * max_pending;\n }\n }\n\n int dist = abs(r - tr) + abs(c - tc);\n cranes[i].nr = tr;\n cranes[i].nc = tc;\n cranes[i].type = 1;\n cranes[i].score = dist_bonus - dist;\n cranes[i].dist = dist;\n }\n\n // LC bonus for conflict resolution\n if (i == 0) cranes[i].score += 3000;\n }\n\n // Step 4: Collision Resolution with lookahead\n vector final_type(N, 0);\n vector> final_pos(N);\n \n // Sort by score\n vector order(N);\n for(int i=0; i cranes[b].score;\n return cranes[a].dist < cranes[b].dist; // Prefer shorter distance\n });\n\n // Process in priority order\n for (int k = 0; k < N; ++k) {\n int cr = order[k];\n int current_dist = abs(crane_pos[cr].first - cranes[cr].nr) + \n abs(crane_pos[cr].second - cranes[cr].nc);\n \n if (current_dist == 0) {\n // At target, check for P/Q\n final_type[cr] = cranes[cr].type;\n final_pos[cr] = crane_pos[cr];\n continue;\n }\n \n if (cranes[cr].type == 1) {\n // Calculate actual distance using BFS-like simple check\n // Check if we can move toward target\n bool can_move = true;\n int nr = crane_pos[cr].first;\n int nc = crane_pos[cr].second;\n \n // Prefer move that gets closer to target\n int best_dir = -1;\n int best_dist = 10000;\n \n for (int d = 0; d < 4; ++d) {\n int tr = nr + dr[d];\n int tc = nc + dc[d];\n if (tr >= 0 && tr < N && tc >= 0 && tc < N) {\n // Check if target square is valid\n bool occupied = is_crane_here[tr * N + tc];\n if (occupied && tr == nr && tc == nc) {\n // Self-check\n occupied = true;\n }\n \n // Small crane constraint\n if (cr > 0 && crane_load[cr] != -1) {\n if (grid[tr][tc] != -1) {\n occupied = true;\n }\n }\n \n if (!occupied) {\n int d_dist = abs(tr - cranes[cr].nr) + abs(tc - cranes[cr].nc);\n if (d_dist < best_dist) {\n best_dist = d_dist;\n best_dir = d;\n }\n }\n }\n }\n \n if (best_dir != -1 && best_dist < current_dist) {\n // Check swap collision\n int swap_target_r = nr + dr[best_dir];\n int swap_target_c = nc + dc[best_dir];\n for (int other = 0; other < N; ++other) {\n if (other == cr) continue;\n if (crane_pos[other] == crane_pos[cr]) {\n // Same spot, collision\n can_move = false;\n break;\n }\n // Check if other crane moving into cr's current spot\n }\n \n if (can_move) {\n final_type[cr] = 1;\n final_pos[cr] = {nr + dr[best_dir], nc + dc[best_dir]};\n } else {\n final_type[cr] = 0;\n final_pos[cr] = crane_pos[cr];\n }\n } else {\n final_type[cr] = 0;\n final_pos[cr] = crane_pos[cr];\n }\n } else {\n final_type[cr] = 0;\n final_pos[cr] = crane_pos[cr];\n }\n }\n\n // Step 5: Execute Actions\n int next_grid[MAX_N][MAX_N];\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n next_grid[i][j] = grid[i][j];\n\n string action_per_cran[MAX_N] = {\".\"};\n \n for (int i = 0; i < N; ++i) {\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n char act = '.';\n\n if (final_type[i] == 1) {\n int nr = final_pos[i].first;\n int nc = final_pos[i].second;\n for(int d=0; d<4; ++d) {\n if (r + dr[d] == nr && c + dc[d] == nc) {\n act = move_char[d];\n break;\n }\n }\n } else if (final_type[i] == 2) {\n act = 'P';\n int val = grid[r][c];\n crane_load[i] = val;\n next_grid[r][c] = -1;\n held_cnt++;\n } else if (final_type[i] == 3) {\n act = 'Q';\n crane_load[i] = -1;\n next_grid[r][c] = -1;\n held_cnt--;\n }\n \n ans[i] += act;\n }\n\n // Step 6: Update State\n for (int i = 0; i < N; ++i) {\n crane_pos[i] = final_pos[i];\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = true;\n }\n // Clear old occupancy marks first\n for (int i = 0; i < N; ++i) {\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = false;\n }\n // Set new occupancy marks\n for (int i = 0; i < N; ++i) {\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = true;\n }\n \n for(int i=0; i> A[i][j];\n }\n }\n \n solve();\n \n int max_len = 0;\n for (int i = 0; i < 5; ++i) {\n max_len = max(max_len, (int)ans[i].size());\n }\n \n for (int i = 0; i < 5; ++i) {\n while (ans[i].size() < (size_t)max_len) {\n ans[i] += '.';\n }\n cout << ans[i] << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint n;\nvector> heights;\n\nint manhattanDist(int r1, int c1, int r2, int c2) {\n return abs(r2 - r1) + abs(c2 - c1);\n}\n\nstring getMovePath(int fromR, int fromC, int toR, int toC) {\n string path = \"\";\n int curR = fromR, curC = fromC;\n \n while (curR != toR || curC != toC) {\n if (curR < toR) { path += \"D\"; curR++; }\n else if (curR > toR) { path += \"U\"; curR--; }\n else if (curC < toC) { path += \"R\"; curC++; }\n else if (curC > toC) { path += \"L\"; curC--; }\n }\n return path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n heights.resize(n, vector(n));\n \n vector> surplus;\n vector> deficit;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> heights[i][j];\n if (heights[i][j] > 0) {\n surplus.push_back({i, j});\n } else if (heights[i][j] < 0) {\n deficit.push_back({i, j});\n }\n }\n }\n \n struct Transport {\n int fromR, fromC;\n int toR, toC;\n int amt;\n int dist;\n };\n \n vector transports;\n \n for (int i = 0; i < surplus.size(); i++) {\n for (int j = 0; j < deficit.size(); j++) {\n int fr = surplus[i].first, fc = surplus[i].second;\n int tr = deficit[j].first, tc = deficit[j].second;\n int h = min(heights[fr][fc], -heights[tr][tc]);\n \n if (h <= 0) continue;\n \n int dist = manhattanDist(fr, fc, tr, tc);\n transports.push_back({fr, fc, tr, tc, h, dist});\n }\n }\n \n sort(transports.begin(), transports.end(), [](const Transport& a, const Transport& b) {\n return a.dist < b.dist;\n });\n \n vector ops;\n int curR = 0, curC = 0;\n int truckLoad = 0;\n \n for (const auto& t : transports) {\n int amt = t.amt;\n if (amt <= 0) continue;\n \n // Move to source\n string path1 = getMovePath(curR, curC, t.fromR, t.fromC);\n ops.insert(ops.end(), path1.begin(), path1.end());\n curR = t.fromR;\n curC = t.fromC;\n \n // Load\n for (int k = 0; k < amt; k++) {\n ops += \"+1\";\n truckLoad++;\n }\n heights[t.fromR][t.fromC] -= amt;\n \n // Move to destination\n string path2 = getMovePath(curR, curC, t.toR, t.toC);\n ops.insert(ops.end(), path2.begin(), path2.end());\n curR = t.toR;\n curC = t.toC;\n \n // Unload\n for (int k = 0; k < amt; k++) {\n ops += \"-1\";\n truckLoad--;\n }\n heights[t.toR][t.toC] += amt;\n }\n \n cout << ops.size() << \"\\n\";\n for (const string& op : ops) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold seed information\nstruct Seed {\n int id;\n vector values;\n int total_value;\n int max_value; // Maximum value among all criteria\n\n Seed() : id(0), total_value(0), max_value(0) {}\n};\n\n// Grid coordinates with distance metric from center\nstruct Pos {\n int r, c;\n int dist_sq;\n int degree; // Number of edges (connectivity)\n};\n\n// Sort positions: closer to center first, higher degree first\nbool comparePos(const Pos& a, const Pos& b) {\n if (a.degree > b.degree) return true;\n if (a.degree < b.degree) return false;\n if (a.dist_sq != b.dist_sq) return a.dist_sq < b.dist_sq;\n if (a.r != b.r) return a.r < b.r;\n return a.c < b.c;\n}\n\n// Calculate position metrics once\nvector precomputePositions(int N) {\n vector positions;\n positions.reserve(N * N);\n int center_val = N - 1;\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int dr = 2 * r - center_val;\n int dc = 2 * c - center_val;\n int d2 = dr * dr + dc * dc;\n \n int degree = 4;\n if (r == 0 || r == N - 1) degree--;\n if (c == 0 || c == N - 1) degree--;\n \n positions.push_back({r, c, d2, degree});\n }\n }\n \n sort(positions.begin(), positions.end(), comparePos);\n return positions;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n\n int seed_count = 2 * N * (N - 1);\n vector seeds(seed_count);\n vector max_val_per_criterion(M, 0);\n\n // Read initial seeds\n for (int k = 0; k < seed_count; ++k) {\n seeds[k].id = k;\n seeds[k].values.resize(M, 0);\n seeds[k].total_value = 0;\n seeds[k].max_value = 0;\n \n for (int l = 0; l < M; ++l) {\n cin >> seeds[k].values[l];\n seeds[k].total_value += seeds[k].values[l];\n seeds[k].max_value = max(seeds[k].max_value, seeds[k].values[l]);\n }\n \n for (int l = 0; l < M; ++l) {\n max_val_per_criterion[l] = max(max_val_per_criterion[l], seeds[k].values[l]);\n }\n }\n\n vector positions = precomputePositions(N);\n const size_t N2 = static_cast(N) * N;\n\n for (int t = 0; t < T; ++t) {\n // Phase 1: Find current maximum per criterion\n fill(max_val_per_criterion.begin(), max_val_per_criterion.end(), 0);\n for (const auto& s : seeds) {\n for (int l = 0; l < M; ++l) {\n max_val_per_criterion[l] = max(max_val_per_criterion[l], s.values[l]);\n }\n }\n\n // Phase 2: Count how many seeds hold each criterion's maximum\n vector max_count(M, 0);\n for (const auto& s : seeds) {\n for (int l = 0; l < M; ++l) {\n if (s.values[l] == max_val_per_criterion[l] && s.values[l] > 0) {\n max_count[l]++;\n }\n }\n }\n\n // Priority calculation\n struct SeedPriority {\n int id;\n long priority[0]; \n };\n\n struct SeedPriority2 {\n int id;\n long priority;\n };\n vector priority_list(seed_count);\n\n for (int k = 0; k < seed_count; ++k) {\n priority_list[k].id = k;\n \n long max_value_weight = 0;\n long unique_max_weight = 0;\n long high_value_weight = 0;\n \n for (int l = 0; l < M; ++l) {\n // Weight for holding max value\n if (seeds[k].values[l] == max_val_per_criterion[l] && seeds[k].values[l] > 0) {\n max_value_weight += 100;\n // Unique max is extremely valuable\n if (max_count[l] == 1) {\n unique_max_weight += 400;\n }\n }\n // Weight for high values relative to max (85% threshold)\n if (max_val_per_criterion[l] > 0) {\n int threshold = max_val_per_criterion[l] * 85 / 100;\n if (seeds[k].values[l] >= threshold) {\n high_value_weight += 10;\n }\n }\n }\n \n priority_list[k].priority = (unique_max_weight * 10000) \n + (max_value_weight * 1000) \n + high_value_weight * 100\n + seeds[k].total_value;\n }\n\n // Sort all seeds by priority\n sort(priority_list.begin(), priority_list.end(), [](const SeedPriority2& a, const SeedPriority2& b) {\n return a.priority > b.priority;\n });\n\n // Select top N*N seeds\n vector selected_ids;\n selected_ids.reserve(N2);\n \n for (size_t k = 0; k < N2 && k < static_cast(seed_count); ++k) {\n selected_ids.push_back(priority_list[k].id);\n }\n \n // Remove duplicates\n sort(selected_ids.begin(), selected_ids.end());\n selected_ids.erase(unique(selected_ids.begin(), selected_ids.end()), selected_ids.end());\n \n if (selected_ids.size() < N2) break;\n else if (selected_ids.size() > N2) {\n selected_ids.resize(N2);\n }\n\n // Sort selected seeds by sum to place in position order\n vector> seed_sum_pairs;\n seed_sum_pairs.reserve(selected_ids.size());\n for (int id : selected_ids) {\n seed_sum_pairs.push_back({seeds[id].total_value, id});\n }\n \n sort(seed_sum_pairs.begin(), seed_sum_pairs.end(), [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n\n // Place in grid according to position order (center first, highest sum in highest degree)\n vector> grid(N, vector(N));\n for (size_t k = 0; k < N2; ++k) {\n int seed_id = seed_sum_pairs[k].second;\n Pos pos = positions[k];\n grid[pos.r][pos.c] = seed_id;\n }\n\n // Output grid configuration\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cout << grid[r][c] << (c == N - 1 ? \"\\n\" : \" \");\n }\n }\n cout.flush();\n\n // Read new seeds for next turn\n vector next_seeds(seed_count);\n for (int k = 0; k < seed_count; ++k) {\n next_seeds[k].id = k;\n next_seeds[k].values.resize(M, 0);\n next_seeds[k].total_value = 0;\n next_seeds[k].max_value = 0;\n \n for (int l = 0; l < M; ++l) {\n cin >> next_seeds[k].values[l];\n next_seeds[k].total_value += next_seeds[k].values[l];\n next_seeds[k].max_value = max(next_seeds[k].max_value, next_seeds[k].values[l]);\n }\n }\n seeds = move(next_seeds);\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a coordinate pair\nstruct Point {\n int r, c;\n};\n\n// Structure to represent a task (moving an item from src to tgt)\nstruct Task {\n Point src, tgt;\n};\n\nint N, M, V;\nint grid_s[35][35];\nint grid_t[35][35];\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> V)) return 0;\n\n vector sources;\n vector targets;\n\n // Read initial positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_s[i][j] = (s[j] == '1');\n if (grid_s[i][j]) sources.push_back({i, j});\n }\n }\n // Read target positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_t[i][j] = (s[j] == '1');\n if (grid_t[i][j]) targets.push_back({i, j});\n }\n }\n\n // Filter out sources that are already on targets, \n // and targets that are already occupied.\n vector active_sources;\n vector active_targets;\n\n vector> is_target(N, vector(N, false));\n for(const auto& t : targets) is_target[t.r][t.c] = true;\n\n vector> is_source(N, vector(N, false));\n for(const auto& s : sources) is_source[s.r][s.c] = true;\n\n // Identify active sources (sources not on targets)\n for(const auto& s : sources) {\n if(!is_target[s.r][s.c]) active_sources.push_back(s);\n }\n // Identify active targets (targets not on sources)\n for(const auto& t : targets) {\n if(!is_source[t.r][t.c]) active_targets.push_back(t);\n }\n\n // Greedy matching between active sources and active targets\n // Since constraints are small (N<=30, M<=225), O(M^2) is acceptable.\n vector tasks;\n vector tgt_used(active_targets.size(), false);\n\n for (const auto& s : active_sources) {\n int best_idx = -1;\n int min_dist = 2000; // Max dist is roughly 60\n for (int i = 0; i < (int)active_targets.size(); ++i) {\n if (!tgt_used[i]) {\n int d = abs(s.r - active_targets[i].r) + abs(s.c - active_targets[i].c);\n if (d < min_dist) {\n min_dist = d;\n best_idx = i;\n }\n }\n }\n if (best_idx != -1) {\n tgt_used[best_idx] = true;\n tasks.push_back({s, active_targets[best_idx]});\n }\n }\n\n // --- Output Robotic Arm Design ---\n // We use a Star Graph: Root (0) connected to 1, 2, ..., V-1.\n // Edge lengths are all 1.\n cout << V << \"\\n\";\n for (int i = 1; i < V; ++i) {\n cout << 0 << \" \" << 1 << \"\\n\";\n }\n // Initial Root Position: Center of the grid\n cout << (N / 2) << \" \" << (N / 2) << \"\\n\";\n\n // --- Simulation ---\n int root_r = N / 2;\n int root_c = N / 2;\n int finger_dir = 0; // 0: Right, 1: Down, 2: Left, 3: Up. Initial state: Right (0)\n int dx[4] = {0, 1, 0, -1};\n int dy[4] = {1, 0, -1, 0};\n\n // Output buffer string\n string buf(2 * V, '.'); \n\n // Execute each task: Pick from Source -> Move -> Deliver at Target -> Place\n for (const auto& task : tasks) {\n Point src = task.src;\n Point tgt = task.tgt;\n\n // --- STEP 1: PICK UP ---\n \n // Find valid Root position and orientation to reach Source\n int pick_r = -1, pick_c = -1, pick_d = -1;\n int min_cost = 1e9;\n\n // Try all 4 directions for Finger 1\n for (int d = 0; d < 4; ++d) {\n // If finger points at src, Root must be at src - offset\n int r = src.r - dx[d];\n int c = src.c - dy[d];\n // Check bounds\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n // Prefer shorter distance; tie-break with preferred direction if possible\n if (dist < min_cost || (dist == min_cost && d == finger_dir)) {\n min_cost = dist;\n pick_r = r;\n pick_c = c;\n pick_d = d;\n }\n }\n }\n\n // Move Root to pick position\n int dr = 0, dc = 0;\n if (root_r < pick_r) dr = 1;\n if (root_r > pick_r) dr = -1;\n if (root_c < pick_c) dc = 1;\n if (root_c > pick_c) dc = -1;\n\n for (int k = 0; k < min_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n // Rotation and Action are '.' (no-op)\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1 to match direction\n while (finger_dir != pick_d) {\n buf[0] = '.'; // Move is idle\n buf[1] = '.'; // Reset rotation char\n buf[V + 1] = '.'; // Reset action char\n \n int diff = (pick_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R'; // CW 90\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L'; // CCW 90\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Pick Up Action (Vertex 1 Action is at index V + 1)\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n\n // --- STEP 2: DELIVER ---\n \n // Find valid Root position and orientation to reach Target\n int del_r = -1, del_c = -1, del_d = -1;\n int del_cost = 1e9;\n\n for (int d = 0; d < 4; ++d) {\n int r = tgt.r - dx[d];\n int c = tgt.c - dy[d];\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n if (dist < del_cost || (dist == del_cost && d == finger_dir)) {\n del_cost = dist;\n del_r = r;\n del_c = c;\n del_d = d;\n }\n }\n }\n\n // Move Root to target position\n dr = dc = 0;\n if (root_r < del_r) dr = 1;\n if (root_r > del_r) dr = -1;\n if (root_c < del_c) dc = 1;\n if (root_c > del_c) dc = -1;\n\n for (int k = 0; k < del_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1\n while (finger_dir != del_d) {\n buf[0] = '.'; \n buf[1] = '.';\n buf[V + 1] = '.'; \n int diff = (del_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R';\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L';\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Place Action\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n }\n\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace bg = boost::geometry;\nnamespace bgm = boost::geometry::model;\n\nusing coord_type = double;\nusing point = bgm::point;\nusing polygon = bgm::polygon;\nusing multi_polygon = bgm::multi_polygon;\n\nstruct RectInfo {\n int x_min, x_max, y_min, y_max;\n int score;\n};\n\nint main() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n\n int N;\n if (!(std::cin >> N)) return 0;\n\n std::vector> mackerels(N);\n std::vector> sardines(N);\n\n for(int i = 0; i < N; ++i) {\n std::cin >> mackerels[i].first >> mackerels[i].second;\n }\n for(int i = 0; i < N; ++i) {\n std::cin >> sardines[i].first >> sardines[i].second;\n }\n\n // K-means clustering\n int k_clusters = 10;\n k_clusters = std::min(k_clusters, N);\n \n std::vector> centroids(k_clusters);\n for (int i = 0; i < k_clusters; ++i) centroids[i] = mackerels[i];\n \n std::vector> clusters(k_clusters);\n for (int iter = 0; iter < 10; ++iter) {\n for (int c = 0; c < k_clusters; ++c) clusters[c].clear();\n \n for (int i = 0; i < N; ++i) {\n int best_c = 0, min_d = -1;\n for (int c = 0; c < k_clusters; ++c) {\n long long dx = mackerels[i].first - centroids[c].first;\n long long dy = mackerels[i].second - centroids[c].second;\n long long d = dx*dx + dy*dy;\n if (min_d == -1 || d < min_d) { min_d = d; best_c = c; }\n }\n clusters[best_c].push_back(i);\n }\n \n for (int c = 0; c < k_clusters; ++c) {\n if (clusters[c].empty()) continue;\n long long sx = 0, sy = 0;\n for (int idx : clusters[c]) { sx += mackerels[idx].first; sy += mackerels[idx].second; }\n centroids[c].first = static_cast(sx / clusters[c].size());\n centroids[c].second = static_cast(sy / clusters[c].size());\n }\n }\n \n // Create rectangles for each cluster\n std::vector> candidates;\n candidates.reserve(k_clusters * 3);\n \n for (int c = 0; c < k_clusters; ++c) {\n if (clusters[c].empty()) continue;\n \n int min_x = 100005, max_x = -1, min_y = 100005, max_y = -1;\n for (int idx : clusters[c]) {\n min_x = std::min(min_x, mackerels[idx].first);\n max_x = std::max(max_x, mackerels[idx].first);\n min_y = std::min(min_y, mackerels[idx].second);\n max_y = std::max(max_y, mackerels[idx].second);\n }\n \n int mc = 0, sc = 0;\n for (const auto& p : mackerels) {\n if (p.first >= min_x && p.first <= max_x && p.second >= min_y && p.second <= max_y) mc++;\n }\n for (const auto& p : sardines) {\n if (p.first >= min_x && p.first <= max_x && p.second >= min_y && p.second <= max_y) sc++;\n }\n \n // Store score and rectangle info\n candidates.push_back({mc - sc, min_y});\n }\n \n // For simplicity, just use the best single rectangle with slight expansion\n // Sort by score descending\n std::vector> rects;\n for (int c = 0; c < k_clusters; ++c) {\n if (clusters[c].empty()) continue;\n \n int min_x = 100005, max_x = -1, min_y = 100005, max_y = -1;\n for (int idx : clusters[c]) {\n min_x = std::min(min_x, mackerels[idx].first);\n max_x = std::max(max_x, mackerels[idx].first);\n min_y = std::min(min_y, mackerels[idx].second);\n max_y = std::max(max_y, mackerels[idx].second);\n }\n \n int mc = 0, sc = 0;\n for (const auto& p : mackerels) {\n if (p.first >= min_x && p.first <= max_x && p.second >= min_y && p.second <= max_y) mc++;\n }\n for (const auto& p : sardines) {\n if (p.first >= min_x && p.first <= max_x && p.second >= min_y && p.second <= max_y) sc++;\n }\n \n rects.push_back({mc - sc, min_y});\n }\n \n if (rects.empty()) {\n std::cout << \"4\\n0 0\\n50000 0\\n50000 50000\\n0 50000\\n\";\n return 0;\n }\n \n // Sort by score, get top rectangle\n std::sort(rects.begin(), rects.end(), [](const auto& a, const auto& b) {\n return a.first > b.first;\n });\n \n int best_score_idx = 0;\n int min_x = 100005, max_x = -1, min_y = 100005, max_y = -1;\n \n // Re-find the best rectangle\n int best_score = -1e9;\n for (int c = 0; c < k_clusters; ++c) {\n if (clusters[c].empty()) continue;\n \n int x_min = 100005, x_max = -1, y_min = 100005, y_max = -1;\n for (int idx : clusters[c]) {\n x_min = std::min(x_min, mackerels[idx].first);\n x_max = std::max(x_max, mackerels[idx].first);\n y_min = std::min(y_min, mackerels[idx].second);\n y_max = std::max(y_max, mackerels[idx].second);\n }\n \n int mc = 0, sc = 0;\n for (const auto& p : mackerels) {\n if (p.first >= x_min && p.first <= x_max && p.second >= y_min && p.second <= y_max) mc++;\n }\n for (const auto& p : sardines) {\n if (p.first >= x_min && p.first <= x_max && p.second >= y_min && p.second <= y_max) sc++;\n }\n \n if (mc - sc > best_score) {\n best_score = mc - sc;\n min_x = x_min; max_x = x_max; min_y = y_min; max_y = y_max;\n }\n }\n \n // Expand rectangle for margin\n min_x = std::max(0, min_x - 1);\n min_y = std::max(0, min_y - 1);\n max_x = std::min(100000, max_x + 1);\n max_y = std::min(100000, max_y + 1);\n \n // Output single axis-aligned rectangle (4 vertices)\n std::vector> output;\n output.push_back({min_x, min_y});\n output.push_back({max_x, min_y});\n output.push_back({max_x, max_y});\n output.push_back({min_x, max_y});\n \n std::cout << output.size() << \"\\n\";\n for (const auto& p : output) {\n std::cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a placement decision for a rectangle\nstruct Decision {\n int id; // Original rectangle index (0 to N-1)\n int r; // Rotation: 0 or 1\n char d; // Direction: 'U' or 'L'\n int b; // Base rectangle index (value of p_j for j < i, or -1)\n};\n\nstruct Rect {\n long long w, h;\n};\n\n// Global variables for N and T\nint N, T;\nvector rects; // Stores the observed w', h'\n\n// Function to evaluate the proxy cost (estimated W + H)\n// This function simulates the placement using the provided observed dimensions (w', h')\n// It uses a linear scan for column/row management instead of map for performance\nlong long get_cost(const vector& config, int n) {\n // Store active columns: x coordinate, current maximum height in that column\n struct Col { long long x; long long max_h; };\n // Store active rows: y coordinate, current maximum width in that row\n struct Row { long long y; long long max_w; };\n\n vector cols;\n vector rows;\n \n // pos[i] stores the x,y coordinate of rectangle i after placement\n vector> pos(n);\n // dims[i] stores the effective w, h of rectangle i after rotation\n vector> dims(n);\n \n long long global_max_W = 0;\n long long global_max_H = 0;\n \n for(int i=0; i c.max_h) c.max_h = new_h;\n break;\n }\n }\n } else {\n cols.push_back({px, py + h});\n }\n } else { // config[i].d == 'L'\n // L: Move leftward.\n // Align Top edge to Bottom edge of base rectangle b.\n // If b == -1, align Top edge to y=0.\n if(config[i].b == -1) {\n py = 0;\n } else {\n long long base_py = pos[config[i].b].second;\n long long base_ph = dims[config[i].b].second;\n py = base_py + base_ph;\n }\n \n // Find existing width at this row y = py\n long long row_w = 0;\n bool found_row = false;\n // Linear scan over active rows\n for(const auto& r : rows) {\n if(r.y == py) {\n row_w = r.max_w;\n found_row = true;\n break;\n }\n }\n px = row_w;\n \n // Update the row width\n if(found_row) {\n long long new_w = px + w;\n for(auto& r : rows) {\n if(r.y == py) {\n if(new_w > r.max_w) r.max_w = new_w;\n break;\n }\n }\n } else {\n rows.push_back({py, px + w});\n }\n }\n \n pos[i] = {px, py};\n if(px + w > global_max_W) global_max_W = px + w;\n if(py + h > global_max_H) global_max_H = py + h;\n }\n \n return global_max_W + global_max_H;\n}\n\nint main() {\n // Optimization for Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read problem parameters\n if (!(cin >> N >> T)) return 0;\n long long sigma; \n cin >> sigma;\n \n rects.resize(N);\n for(int i=0; i> rects[i].w >> rects[i].h;\n }\n \n // Initialize random number generator\n // Using a fixed seed for reproducibility in local testing, \n // but varying slightly per submission might be useful in production\n mt19937 rng(42); \n \n // Initialize global best configuration\n // Strategy: Place all N rectangles (indices 0 to N-1)\n vector best_config(N);\n \n // Initial heuristic placement (simple random or deterministic start)\n // We initialize with plausible values to start hill climbing from a good point.\n // Greedy initialization could be better but random is safer for heuristic\n for(int i=0; i candidate = best_config;\n long long current_score = global_best_score;\n \n // Hill Climbing Loop to refine the configuration\n // We perform local searches (flip r, d, b) to find a lower cost\n // The number of iterations is tuned for the 3.0s time limit\n // N <= 100, so O(N^2) get_cost is roughly 10^4 ops.\n // We need total ops < ~5*10^8.\n // T iterations * Inner iters * get_cost.\n // T <= 400. If Inner iters = 30. Total = 400 * 30 * 10^4 = 1.2*10^8.\n \n int hill_climbing_iters = 30; \n \n for(int it=0; it 0) {\n // Possible bases are -1 and 0..i-1 (i+1 options)\n int choice = rng() % (i + 1);\n new_b = (choice == 0 ? -1 : (choice - 1));\n }\n \n if(new_b != old_b) {\n candidate[i].b = new_b;\n long long sc = get_cost(candidate, N);\n if(sc < current_score) {\n current_score = sc;\n // Keep change\n } else {\n candidate[i].b = old_b; // Revert\n }\n }\n }\n }\n \n // Update Global Best if improvement found\n if(current_score < global_best_score) {\n global_best_score = current_score;\n best_config = candidate;\n }\n \n // Output the configuration found so far\n cout << best_config.size() << \"\\n\";\n for(const auto& d : best_config) {\n cout << d.id << \" \" << d.r << \" \" << d.d << \" \" << d.b << \"\\n\";\n }\n cout.flush(); \n \n // Read feedback from judge (W', H')\n // We rely on our internal simulation cost rather than noisy W', H' for strategy\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nconst int MAXN = 1005;\n\nint N, M, H;\nlong long beauty[MAXN];\nvector adj[MAXN];\nint parent_node[MAXN];\nint depth_node[MAXN];\n\n// Recompute all depths from parent assignments\nvoid recompute_depths() {\n memset(depth_node, -1, sizeof(depth_node));\n queue q;\n for (int i = 0; i < N; i++) {\n if (parent_node[i] == -1) {\n depth_node[i] = 0;\n q.push(i);\n }\n }\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : adj[u]) {\n if (parent_node[v] == u && depth_node[v] == -1) {\n depth_node[v] = depth_node[u] + 1;\n q.push(v);\n }\n }\n }\n}\n\n// Calculate total attractiveness score\nlong long calculate_score() {\n recompute_depths();\n long long score = 0;\n for (int i = 0; i < N; i++) {\n if (depth_node[i] >= 0 && depth_node[i] <= H) {\n score += (long long)(depth_node[i] + 1) * beauty[i];\n }\n }\n return score;\n}\n\n// Check if current assignment is valid\nbool is_valid() {\n recompute_depths();\n for (int i = 0; i < N; i++) {\n if (depth_node[i] == -1 || depth_node[i] > H) {\n return false;\n }\n }\n return true;\n}\n\n// Initial greedy - BFS to cover all nodes\nvoid initialize_assignment() {\n for (int i = 0; i < N; i++) {\n parent_node[i] = -1;\n depth_node[i] = 0;\n }\n \n vector visited(N, false);\n queue> q;\n \n for (int start = 0; start < N; start++) {\n if (!visited[start]) {\n q.push({start, 0});\n visited[start] = true;\n parent_node[start] = -1;\n depth_node[start] = 0;\n \n while (!q.empty()) {\n pair cur = q.front();\n q.pop();\n int u = cur.first;\n int d = cur.second;\n \n for (int v : adj[u]) {\n if (!visited[v] && d < H) {\n visited[v] = true;\n parent_node[v] = u;\n depth_node[v] = d + 1;\n q.push({v, d + 1});\n }\n }\n }\n }\n }\n}\n\n// Try moving vertex v to parent p, return new score or -1 if invalid\nlong long try_move(int v, int p) {\n if (v == p) return -1;\n \n // Check if p is a neighbor (or -1 for root)\n if (p != -1) {\n bool in_adj = false;\n for (int neighbor : adj[v]) {\n if (neighbor == p) {\n in_adj = true;\n break;\n }\n }\n if (!in_adj) return -1;\n }\n \n int old_parent = parent_node[v];\n parent_node[v] = p;\n \n if (!is_valid()) {\n parent_node[v] = old_parent;\n return -1;\n }\n \n long long score = calculate_score();\n parent_node[v] = old_parent;\n return score;\n}\n\n// Find the best parent for v\nint find_best_parent(int v) {\n int best_p = parent_node[v];\n long long best_score = try_move(v, best_p);\n \n // Try all neighbors\n for (int p : adj[v]) {\n if (depth_node[p] >= H - 1) continue; // Quick filter\n \n long long s = try_move(v, p);\n if (s > best_score) {\n best_score = s;\n best_p = p;\n }\n }\n \n // Also try -1 (make it a root)\n long long s = try_move(v, -1);\n if (s > best_score) {\n best_score = s;\n best_p = -1;\n }\n \n return best_p;\n}\n\nvoid local_search(int iterations) {\n recompute_depths();\n \n // Sort by beauty descending\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [](int a, int b) {\n return beauty[a] > beauty[b];\n });\n \n int iter_count = 0;\n bool improved = true;\n \n while (improved && iter_count < iterations) {\n improved = false;\n iter_count++;\n \n for (int idx = 0; idx < N; idx++) {\n int v = order[idx % N];\n int old_p = parent_node[v];\n int new_p = find_best_parent(v);\n \n if (new_p != old_p) {\n parent_node[v] = new_p;\n improved = true;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> M >> H;\n \n for (int i = 0; i < N; i++) {\n cin >> beauty[i];\n }\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n \n // Initial assignment\n initialize_assignment();\n recompute_depths();\n \n // Optimized local search\n local_search(10000);\n \n // Final validity check - reinitialize if needed\n if (!is_valid()) {\n initialize_assignment();\n recompute_depths();\n }\n \n // Output result\n cout << parent_node[0];\n for (int i = 1; i < N; i++) {\n cout << \" \" << parent_node[i];\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Oni {\n int id;\n int r, c;\n};\n\nstruct MoveCandidate {\n int dist; // steps to shift\n char dir; // 'U', 'D', 'L', 'R'\n int cost; // total operations for this move (2 * dist)\n int idx; // row index if dir is L/R, col index if dir is U/D\n vector removed_indices; // IDs of Oni removed by this move\n vector> ops; // Output operations sequence\n double efficiency; // new_oni_removed / cost (for greedy selection)\n};\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector board(N);\n vector valid_onis;\n vector> all_fuku;\n\n // Parse board\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n valid_onis.push_back({(int)valid_onis.size(), i, j});\n } else if (board[i][j] == 'o') {\n all_fuku.push_back({i, j});\n }\n }\n }\n\n // Check Fukunokami positions for O(1) lookup\n vector> has_fuku(N, vector(N, false));\n for(auto& p : all_fuku) {\n has_fuku[p.first][p.second] = true;\n }\n\n vector move_candidates;\n int num_onis = valid_onis.size();\n\n // Generate candidates for each Oni\n for(const auto& oni : valid_onis) {\n // 1. Up Direction\n bool safe = true;\n for(int k=0; k= oni.r) mc.removed_indices.push_back(o.id);\n }\n mc.efficiency = 0.0;\n move_candidates.push_back(mc);\n }\n\n // 3. Left Direction\n safe = true;\n for(int k=0; k= oni.c) mc.removed_indices.push_back(o.id);\n }\n mc.efficiency = 0.0;\n move_candidates.push_back(mc);\n }\n }\n\n vector is_covered(num_onis, false);\n vector> total_ops;\n\n while(true) {\n int remaining_count = 0;\n for(int i=0; i 0) {\n mc.efficiency = (double)current_removed_count / mc.cost;\n // Greedy strategy: maximize efficiency, then count, then minimize cost\n bool is_better = false;\n if(best_idx == -1) {\n is_better = true;\n } else if(mc.efficiency > best_efficiency) {\n is_better = true;\n } else if(mc.efficiency == best_efficiency && current_removed_count > best_removed_count) {\n is_better = true;\n } else if(mc.efficiency == best_efficiency && current_removed_count == best_removed_count && mc.cost < best_cost) {\n is_better = true;\n }\n \n if(is_better) {\n best_idx = i;\n best_removed_count = current_removed_count;\n best_efficiency = mc.efficiency;\n best_cost = mc.cost;\n }\n }\n }\n\n if(best_idx == -1) break; // Should not happen per problem guarantee\n\n const auto& mc = move_candidates[best_idx];\n total_ops.insert(total_ops.end(), mc.ops.begin(), mc.ops.end());\n\n for(int id : mc.removed_indices) {\n is_covered[id] = true;\n }\n }\n\n // Output: Only operations, no count\n for(const auto& p : total_ops) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, L;\nint T[105];\nuint8_t A[105], B[105];\nint counts[105];\n\nint best_err = 2000000000;\nuint8_t best_A[105], best_B[105];\n\n// Fast simulation - critical for performance\ninline int simulate(const uint8_t* a, const uint8_t* b) {\n for(int i = 0; i < N; ++i) counts[i] = 0;\n int cur = 0;\n counts[cur] = 1;\n for(int k = 1; k < L; ++k) {\n int next = (counts[cur] & 1) ? a[cur] : b[cur];\n counts[next]++;\n cur = next;\n }\n int err = 0;\n for(int i = 0; i < N; ++i) err += abs(counts[i] - T[i]);\n return err;\n}\n\nvoid run_search(mt19937& rng, int max_iters, chrono::steady_clock::time_point& end_time) {\n uint8_t a[105], b[105];\n uniform_real_distribution dist(0.0, 1.0);\n uniform_int_distribution dist_idx(0, N - 1);\n \n // Simple random initialization (reliable)\n for(int i = 0; i < N; ++i) {\n a[i] = (uint8_t)(rng() % N);\n b[i] = (uint8_t)(rng() % N);\n }\n \n int current_err = simulate(a, b);\n if(current_err < best_err) {\n best_err = current_err;\n for(int i = 0; i < N; ++i) {\n best_A[i] = a[i];\n best_B[i] = b[i];\n }\n }\n \n // Simulated annealing with adaptive cooling\n double temp = 150.0;\n \n while(chrono::steady_clock::now() < end_time && max_iters >= 0) {\n max_iters--;\n \n // Early exit for good solutions\n if(best_err <= 500) return;\n if(current_err < best_err) {\n best_err = current_err;\n for(int i = 0; i < N; ++i) {\n best_A[i] = a[i];\n best_B[i] = b[i];\n }\n }\n \n // Adaptive cooling schedule\n if(max_iters > 50000) temp *= 0.9998;\n else if(max_iters > 20000) temp *= 0.9995;\n else temp *= 0.9992;\n if(temp < 3.0) temp = 3.0;\n \n // Single perturbation per iteration\n int i = (int)(rng() % N);\n int type = (int)(rng() % 2);\n int val = (int)(rng() % N);\n \n uint8_t old = (type == 0) ? a[i] : b[i];\n if(type == 0) a[i] = (uint8_t)val;\n else b[i] = (uint8_t)val;\n \n int new_err = simulate(a, b);\n double delta = new_err - current_err;\n \n // Accept or reject with SA probability\n if(delta < 0 || dist(rng) < exp(-delta / max(temp, 1e-6))) {\n current_err = new_err;\n if(new_err < best_err) {\n best_err = new_err;\n for(int k = 0; k < N; ++k) {\n best_A[k] = a[k];\n best_B[k] = b[k];\n }\n }\n if(best_err <= 500) return;\n } else {\n if(type == 0) a[i] = old;\n else b[i] = old;\n }\n }\n \n // Final best update\n if(current_err < best_err) {\n best_err = current_err;\n for(int i = 0; i < N; ++i) {\n best_A[i] = a[i];\n best_B[i] = b[i];\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if(!(cin >> N >> L)) return 0;\n for(int i = 0; i < N; ++i) cin >> T[i];\n \n // Use current time as base seed\n mt19937 base_rng(chrono::steady_clock::now().time_since_epoch().count());\n \n auto start_time = chrono::steady_clock::now();\n auto end_time = start_time + chrono::milliseconds(1850); // 1.85s to be safe\n \n // 5 diverse seeds for good exploration (reduced from 10)\n vector seeds = {12345, 54321, 98765, 43210, 11111};\n \n int max_iters = 150000; // Total iterations per seed\n \n for(auto seed : seeds) {\n auto t1 = chrono::steady_clock::now();\n if(t1 >= end_time) break;\n \n // Check if there's enough time left\n auto remaining_time = end_time - chrono::steady_clock::now();\n if(remaining_time <= chrono::milliseconds(50)) break;\n \n mt19937 rng(seed);\n run_search(rng, max_iters, end_time);\n \n // Early exit if we found a very good solution\n if(best_err <= 500) break;\n \n // Check remaining time again\n if(end_time - chrono::steady_clock::now() < chrono::milliseconds(100)) break;\n }\n \n // Output result\n for(int i = 0; i < N; ++i) {\n cout << (int)best_A[i] << \" \" << (int)best_B[i] << \"\\n\";\n }\n \n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct UnionFind {\n vector parent;\n UnionFind(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int x) {\n if (parent[x] == x) return x;\n return parent[x] = find(parent[x]);\n }\n bool unite(int x, int y) {\n int rootX = find(x);\n int rootY = find(y);\n if (rootX != rootY) {\n parent[rootY] = rootX;\n return true;\n }\n return false;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, W;\n int L;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; i++) cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n \n // Store original city indices\n vector cities(N);\n iota(cities.begin(), cities.end(), 0);\n \n // Calculate center coordinates for sorting\n vector> positions(N);\n for (int i = 0; i < N; i++) {\n positions[i] = {(lx[i] + rx[i]) / 2.0, (ly[i] + ry[i]) / 2.0};\n }\n \n // Sort cities by estimated position (lexicographically)\n sort(cities.begin(), cities.end(), [&](int a, int b) {\n if (positions[a].first != positions[b].first) {\n return positions[a].first < positions[b].first;\n }\n return positions[a].second < positions[b].second;\n });\n \n // Partition cities into groups (each city exactly once)\n vector> groups(M);\n int cityIdx = 0;\n for (int m = 0; m < M; m++) {\n int gSize = G[m];\n for (int j = 0; j < gSize && cityIdx < N; j++) {\n groups[m].push_back(cities[cityIdx++]);\n }\n }\n \n // Verify each city appears in exactly one group\n vector cityGroup(N, -1);\n for (int m = 0; m < M; m++) {\n for (int city : groups[m]) {\n if (cityGroup[city] != -1) {\n cout << \"DEBUG: Duplicate city \" << city << \" in groups \" << cityGroup[city] << \" and \" << m << \"\\n\" << flush;\n }\n cityGroup[city] = m;\n }\n }\n \n vector>> groupEdges(M);\n int queryCount = 0;\n \n for (int m = 0; m < M; m++) {\n int groupSize = (int)groups[m].size();\n if (groupSize <= 1) continue;\n \n int edgesNeeded = groupSize - 1;\n UnionFind uf(groupSize);\n vector> candidateEdges;\n \n // Query with sliding windows\n for (int i = 0; i + 2 < groupSize && queryCount < Q && candidateEdges.size() < edgesNeeded; i += 2) {\n vector queryCities;\n int windowSize = min(L, min(5, groupSize - i));\n windowSize = max(3, windowSize);\n \n for (int j = 0; j < windowSize; j++) {\n queryCities.push_back(groups[m][i + j]);\n }\n \n cout << \"? \" << queryCities.size();\n for (int city : queryCities) cout << \" \" << city;\n cout << \"\\n\" << flush;\n queryCount++;\n \n int numMstEdges = (int)queryCities.size() - 1;\n for (int k = 0; k < numMstEdges; k++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n \n // Verify both cities belong to this group\n if (cityGroup[u] != m || cityGroup[v] != m) continue;\n \n // Check for duplicates\n bool exists = false;\n for (const auto& e : candidateEdges) {\n if (e.first == u && e.second == v) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n candidateEdges.push_back({u, v});\n }\n }\n }\n \n // Use Union-Find to select edges that connect different components\n uf = UnionFind(groupSize);\n int selectedCount = 0;\n \n for (const auto& edge : candidateEdges) {\n if (selectedCount >= edgesNeeded) break;\n \n int uIdx = -1, vIdx = -1;\n for (int j = 0; j < groupSize; j++) {\n if (groups[m][j] == edge.first) uIdx = j;\n if (groups[m][j] == edge.second) vIdx = j;\n }\n \n if (uIdx >= 0 && vIdx >= 0 && uf.unite(uIdx, vIdx)) {\n groupEdges[m].push_back(edge);\n selectedCount++;\n }\n }\n \n // Fill remaining needed edges with fallback (consecutive cities in group)\n // Ensure we don't exceed edgesNeeded\n while ((int)groupEdges[m].size() < edgesNeeded) {\n int edgeIdx = groupEdges[m].size();\n // Connect consecutive cities in the group\n int u = groups[m][edgeIdx];\n int v = groups[m][(edgeIdx < groupSize - 1) ? edgeIdx + 1 : 0];\n \n // Check for duplicate edges\n bool exists = false;\n for (const auto& e : groupEdges[m]) {\n if (e.first == u && e.second == v) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n // Verify both cities are in this group\n if (cityGroup[u] == m && cityGroup[v] == m) {\n groupEdges[m].push_back({u, v});\n }\n }\n }\n }\n \n // Output result\n cout << \"!\" << \"\\n\" << flush;\n \n for (int m = 0; m < M; m++) {\n // Output cities in group m\n const auto& group = groups[m];\n for (size_t i = 0; i < group.size(); i++) {\n cout << group[i];\n if (i + 1 < group.size()) cout << \" \";\n }\n cout << \"\\n\" << flush;\n \n // Output edges for group m\n for (const auto& edge : groupEdges[m]) {\n cout << edge.first << \" \" << edge.second << \"\\n\" << flush;\n }\n }\n \n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAXN = 20;\n\nbool has_block[MAXN][MAXN];\nint cur_r, cur_c;\nint N, M;\n\nint dr[] = {-1, 1, 0, 0}; // U, D, L, R\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\n// Check if a position is valid (within grid and not blocked)\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N && !has_block[r][c];\n}\n\n// Execute a single action and update state\nbool execute_action(char action, char dir, int& r, int& c, bool check_valid = true) {\n int d = 0;\n if (dir == 'U') d = 0;\n else if (dir == 'D') d = 1;\n else if (dir == 'L') d = 2;\n else if (dir == 'R') d = 3;\n \n if (action == 'M') {\n if (check_valid) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n r = nr;\n c = nc;\n return true;\n }\n return false;\n } else {\n int nr = r + dr[d];\n int nc = c + dc[d];\n r = nr;\n c = nc;\n return true;\n }\n }\n else if (action == 'S') {\n int nr = r, nc = c;\n while (true) {\n int nr_new = nr + dr[d];\n int nc_new = nc + dc[d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n }\n r = nr;\n c = nc;\n return true;\n }\n else if (action == 'A') {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n has_block[nr][nc] = !has_block[nr][nc];\n return true;\n }\n return false;\n }\n return false;\n}\n\n// Calculate Manhattan distance\nint manhattan(int r1, int c1, int r2, int c2) {\n return abs(r1 - r2) + abs(c1 - c2);\n}\n\n// Get direction that reduces distance to target\nint get_direction(int r, int c, int tr, int tc) {\n if (r < tr) return 1; // Down towards target\n if (r > tr) return 0; // Up towards target\n if (c < tc) return 3; // Right towards target\n if (c > tc) return 2; // Left towards target\n return -1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n cin >> N >> M;\n \n cin >> cur_r >> cur_c;\n \n vector> targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].first >> targets[i].second;\n }\n \n memset(has_block, 0, MAXN * MAXN);\n vector> actions;\n \n for (int t = 0; t < M; t++) {\n int tr = targets[t].first;\n int tc = targets[t].second;\n int target_dist = manhattan(cur_r, cur_c, tr, tc);\n \n // Step 1: If target is blocked, unblock it first\n if (has_block[tr][tc]) {\n // Move to adjacent to target (within 1 cell)\n while (manhattan(cur_r, cur_c, tr, tc) > 1) {\n int best_d = get_direction(cur_r, cur_c, tr, tc);\n \n if (best_d == -1) break;\n \n // Try to slide in best direction first\n int nr = cur_r, nc = cur_c;\n int slide_dist = 0;\n while (true) {\n int nr_new = nr + dr[best_d];\n int nc_new = nc + dc[best_d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_dist++;\n }\n \n if (slide_dist >= 1 && manhattan(nr, nc, tr, tc) < manhattan(cur_r, cur_c, tr, tc)) {\n actions.push_back({'S', dir_char[best_d]});\n execute_action('S', dir_char[best_d], cur_r, cur_c, false);\n } else {\n actions.push_back({'M', dir_char[best_d]});\n execute_action('M', dir_char[best_d], cur_r, cur_c, false);\n }\n }\n \n // Now remove the block (find the correct direction)\n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr == tr && nc == tc && !has_block[nr][nc]) {\n actions.push_back({'A', dir_char[d]});\n has_block[nr][nc] = false;\n break;\n }\n }\n }\n \n // Step 2: Navigate to target using slides when possible\n bool reached_target = false;\n \n while (cur_r != tr || cur_c != tc) {\n int current_dist = manhattan(cur_r, cur_c, tr, tc);\n bool moved = false;\n \n // Direction alignment\n int align_d = get_direction(cur_r, cur_c, tr, tc);\n \n // Try slide in aligned direction\n if (align_d != -1) {\n int nr = cur_r, nc = cur_c;\n int slide_count = 0;\n while (true) {\n int nr_new = nr + dr[align_d];\n int nc_new = nc + dc[align_d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_count++;\n }\n \n if (slide_count >= 1 && manhattan(nr, nc, tr, tc) < current_dist) {\n actions.push_back({'S', dir_char[align_d]});\n execute_action('S', dir_char[align_d], cur_r, cur_c, false);\n moved = true;\n }\n }\n \n // If no slide, try move\n if (!moved && align_d != -1) {\n actions.push_back({'M', dir_char[align_d]});\n execute_action('M', dir_char[align_d], cur_r, cur_c, false);\n moved = true;\n }\n \n // If still not moved, try sliding in other directions\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n int nr = cur_r, nc = cur_c;\n int slide_count = 0;\n while (true) {\n int nr_new = nr + dr[d];\n int nc_new = nc + dc[d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_count++;\n }\n \n if (slide_count >= 1 && manhattan(nr, nc, tr, tc) < current_dist) {\n actions.push_back({'S', dir_char[d]});\n execute_action('S', dir_char[d], cur_r, cur_c, false);\n moved = true;\n break;\n }\n }\n }\n \n // If still not moved, try simple move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n if (align_d == d) continue;\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n actions.push_back({'M', dir_char[d]});\n execute_action('M', dir_char[d], cur_r, cur_c, false);\n moved = true;\n break;\n }\n }\n }\n \n // Safety check to prevent infinite loop\n if (!moved) {\n reached_target = true;\n break;\n }\n }\n }\n \n // Output all actions\n for (const auto& p : actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}"},"16":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Company {\n int id, x, y, r, a, b, c, d;\n \n long long area() const {\n return max(0LL, (long long)(c - a)) * max(0LL, (long long)(d - b));\n }\n \n bool containsPoint() const {\n return a <= x && x < c && b <= y && y < d;\n }\n};\n\nint n;\nvector companies;\nconst int GRID = 10000;\n\ndouble calculateScore(const vector& com) {\n double total = 0.0;\n for (const auto& c : com) {\n long long s = c.area();\n if (s <= 0 || !c.containsPoint()) continue;\n double ratio = min(c.r, s) / max((double)c.r, s);\n total += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return total;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n companies.resize(n);\n \n for (int i = 0; i < n; i++) {\n cin >> companies[i].x >> companies[i].y >> companies[i].r;\n companies[i].id = i;\n }\n \n mt19937 rng((unsigned)chrono::steady_clock::now().time_since_epoch().count());\n \n // Initial placement - center around point (x, y)\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n long long target = c.r;\n long long w = max(1LL, (long long)sqrt(target * 2.0));\n long long h = max(1LL, target / w + 1LL);\n \n int a = max(0, min(c.x, c.x - (int)w / 2));\n int c_pos = min(GRID, max(c.x + 1, a + (int)w));\n int b = max(0, min(c.y, c.y - (int)h / 2));\n int d = min(GRID, max(c.y + 1, b + (int)h));\n \n c.a = a;\n c.b = b;\n c.c = c_pos;\n c.d = d;\n }\n \n long long initialScore = calculateScore(companies);\n \n // Simulated annealing optimization\n int iters = 200000;\n double temp = 2.0;\n \n for (int iter = 0; iter < iters; iter++) {\n int idx = uniform_int_distribution(0, n - 1)(rng);\n Company r = companies[idx];\n \n vector> candidates;\n candidates.emplace_back(r.a, r.b);\n \n // Try shifted positions\n for (int da = -50; da <= 50; da += 10) {\n for (int db = -50; db <= 50; db += 10) {\n int a = max(0, min(r.c - r.a, r.a + da));\n int b = max(0, min(r.d - r.b, r.b + db));\n candidates.emplace_back(a, b);\n }\n }\n \n // Try area optimization\n for (int w = max(1, (int)sqrt(r.r / 10)); w < 100; w++) {\n int h = max(1, r.r / w + 1);\n int a = max(0, min(r.x, r.x - w / 2));\n int b = max(0, min(r.y, r.y - h / 2));\n candidates.emplace_back(a, b);\n }\n \n int bestA = r.a, bestB = r.b;\n double bestNewScore = calculateScore(companies);\n \n for (auto [da, db] : candidates) {\n Company newR = r;\n newR.a = max(0, da);\n newR.b = max(0, db);\n \n // Keep same dimensions\n newR.c = max(newR.a + (r.c - r.a), newR.a + 1);\n newR.d = max(newR.b + (r.d - r.b), newR.b + 1);\n newR.c = min(GRID, newR.c);\n newR.d = min(GRID, newR.d);\n \n if (newR.containsPoint()) {\n companies[idx] = newR;\n double newScore = calculateScore(companies);\n if (newScore > bestNewScore) {\n bestNewScore = newScore;\n bestA = newR.a;\n bestB = newR.b;\n }\n companies[idx] = r;\n }\n }\n \n companies[idx].a = bestA;\n companies[idx].b = bestB;\n \n if (uniform_real_distribution(0, 1)(rng) > temp / 100.0) {\n companies[idx] = r; // Revert with probability\n }\n \n temp *= 0.997;\n }\n \n // Final check - all points must be contained\n for (int i = 0; i < n; i++) {\n auto& c = companies[i];\n if (!c.containsPoint()) {\n long long w = max(1LL, c.r);\n long long h = max(1LL, c.r / w + 1LL);\n \n c.a = max(0, c.x);\n c.c = min(GRID, max(c.x + 1, c.a + (int)w));\n c.b = max(0, c.y);\n c.d = min(GRID, max(c.y + 1, c.b + (int)h));\n }\n }\n \n for (int i = 0; i < n; i++) {\n cout << companies[i].a << \" \" << companies[i].b << \" \" \n << companies[i].c << \" \" << companies[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int DX[] = {-1, 1, 0, 0};\nconst int DY[] = {0, 0, -1, 1};\n\nstruct Solver {\n int H = 50, W = 50;\n int si, sj;\n vector> p;\n vector> tile;\n \n int global_best_score;\n vector> global_best_path;\n \n vector> path;\n vector tile_used_id;\n int current_score;\n \n mt19937 rng;\n int run_count;\n \n struct Neighbor {\n int r, c, val, deg;\n int priority;\n };\n vector neighbors;\n\n Solver() {\n p.assign(H, vector(W));\n tile.assign(H, vector(W));\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count());\n global_best_score = 0;\n neighbors.reserve(4);\n }\n\n void read_input() {\n cin >> si >> sj;\n int max_id = 0;\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> tile[i][j];\n if (tile[i][j] > max_id) max_id = tile[i][j];\n }\n }\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n cin >> p[i][j];\n }\n }\n tile_used_id.assign(max_id + 1, 0);\n }\n\n void new_run() {\n path.clear();\n path.reserve(2500);\n path.push_back({si, sj});\n current_score = p[si][sj];\n fill(tile_used_id.begin(), tile_used_id.end(), 0);\n tile_used_id[tile[si][sj]] = 1;\n \n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n run_count++;\n // More diverse seeding for better randomness\n rng.seed(chrono::duration_cast(chrono::high_resolution_clock::now().time_since_epoch()).count() + run_count * 31337 + run_count * 73498 + tile[si][sj] * 999);\n }\n\n bool is_valid(int r, int c) {\n return r >= 0 && r < H && c >= 0 && c < W;\n }\n\n void collect_neighbors(const pair& curr) {\n neighbors.clear();\n for (int d = 0; d < 4; ++d) {\n int nr = curr.first + DX[d];\n int nc = curr.second + DY[d];\n if (is_valid(nr, nc)) {\n int tid = tile[nr][nc];\n if (tile_used_id[tid] == 0) {\n int deg = 0;\n for (int dd = 0; dd < 4; ++dd) {\n int nrr = nr + DX[dd];\n int ncc = nc + DY[dd];\n if (is_valid(nrr, ncc) && tile_used_id[tile[nrr][ncc]] == 0) {\n deg++;\n }\n }\n // Value-first priority: value*4 + deg*3\n int priority = p[nr][nc] * 4 + deg * 3;\n neighbors.push_back({nr, nc, p[nr][nc], deg, priority});\n }\n }\n }\n }\n\n void run() {\n auto start_time = chrono::high_resolution_clock::now();\n read_input();\n \n const int TIME_LIMIT_MS = 1900;\n const int MAX_RUNS = 120; // Increased for better coverage\n const int BASE_TIME_PER_RUN = 14;\n const int TIME_VARIANCE = 8; // 14-22ms range\n \n while (true) {\n run_count++;\n new_run();\n \n if (static_cast(run_count) > MAX_RUNS) break;\n \n auto run_start = chrono::high_resolution_clock::now();\n int run_budget = BASE_TIME_PER_RUN + (rng() % (TIME_VARIANCE + 1));\n \n int consecutive_stuck = 0;\n \n while (true) {\n auto now = chrono::high_resolution_clock::now();\n auto elapsed = chrono::duration_cast(now - start_time).count();\n \n if (elapsed > TIME_LIMIT_MS) break;\n \n auto run_time = chrono::duration_cast(now - run_start).count();\n if (run_time >= run_budget) break;\n if (static_cast(path.size()) > 2400) break;\n \n auto [curr_r, curr_c] = path.back();\n collect_neighbors({curr_r, curr_c});\n \n if (!neighbors.empty()) {\n // Sort by priority descending\n sort(neighbors.begin(), neighbors.end(), [](const Neighbor& a, const Neighbor& b) {\n return a.priority > b.priority;\n });\n \n // 30% fixed exploration - proven optimal\n int idx = 0;\n if (rng() % 100 < 30) {\n int k = static_cast(min(static_cast(5), neighbors.size()));\n if (k > 1) idx = rng() % k;\n }\n \n const Neighbor& n = neighbors[idx];\n \n path.push_back({n.r, n.c});\n tile_used_id[tile[n.r][n.c]] = 1;\n current_score += p[n.r][n.c];\n \n if (current_score > global_best_score) {\n global_best_score = current_score;\n global_best_path = path;\n }\n \n consecutive_stuck = 0;\n } else {\n consecutive_stuck++;\n \n if (consecutive_stuck >= 7) {\n break;\n } else {\n auto [r, c] = path.back();\n tile_used_id[tile[r][c]] = 0;\n current_score -= p[r][c];\n path.pop_back();\n }\n }\n }\n }\n \n // Output result\n string result = \"\";\n if (!global_best_path.empty()) {\n for (size_t i = 1; i < global_best_path.size(); ++i) {\n int dr = global_best_path[i].first - global_best_path[i-1].first;\n int dc = global_best_path[i].second - global_best_path[i-1].second;\n if (dr == -1) result += 'U';\n else if (dr == 1) result += 'D';\n else if (dc == -1) result += 'L';\n else if (dc == 1) result += 'R';\n }\n }\n cout << result << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n Solver solver;\n solver.run();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Edge weights for 30x30 grid\nvector> h_edges(30, vector(29));\nvector> v_edges(29, vector(30));\n\nconst int N = 30;\nconst int MAX_WEIGHT = 28000;\nconst int MIN_WEIGHT = 100;\n\n// Initialize edge weights with realistic values\nvoid init_edge_weights() {\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 29; j++) {\n h_edges[i][j] = 2000.0 + (rand() % 2001);\n }\n }\n for (int i = 0; i < 29; i++) {\n for (int j = 0; j < 30; j++) {\n v_edges[i][j] = 2000.0 + (rand() % 2001);\n }\n }\n}\n\nstruct Node {\n int pos;\n int r, c;\n double dist;\n bool operator>(const Node& o) const {\n return dist > o.dist;\n }\n};\n\nstruct Result {\n string path;\n double predicted_length;\n bool valid;\n};\n\nstring generate_simple_path(int si, int sj, int ti, int tj) {\n string path;\n while (si < ti) path += 'D', ++si;\n while (si > ti) path += 'U', --si;\n while (sj < tj) path += 'R', ++sj;\n while (sj > tj) path += 'L', --sj;\n return path;\n}\n\nResult find_shortest_path(int si, int sj, int ti, int tj) {\n int n_nodes = N * N;\n vector dist(n_nodes, 1e18);\n vector parent(n_nodes, -1);\n vector dir(n_nodes, 0);\n priority_queue, greater> pq;\n\n dist[si * N + sj] = 0.0;\n pq.push({si * N + sj, si, sj, 0.0});\n\n while (!pq.empty()) {\n Node top = pq.top();\n pq.pop();\n int u = top.pos;\n int ui = top.r, uj = top.c;\n\n if (ui == ti && uj == tj) break;\n if (top.dist > dist[u]) continue;\n \n // Move U\n if (ui > 0) {\n int v_pos = (ui - 1) * N + uj;\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ui - 1][uj]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'U';\n pq.push({v_pos, ui - 1, uj, dist[v_pos]});\n }\n }\n // Move D\n if (ui < N - 1) {\n int v_pos = (ui + 1) * N + uj;\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ui][uj]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'D';\n pq.push({v_pos, ui + 1, uj, dist[v_pos]});\n }\n }\n // Move L\n if (uj > 0) {\n int v_pos = ui * N + (uj - 1);\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ui][uj - 1]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'L';\n pq.push({v_pos, ui, uj - 1, dist[v_pos]});\n }\n }\n // Move R\n if (uj < N - 1) {\n int v_pos = ui * N + (uj + 1);\n double w = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ui][uj]));\n if (dist[u] < 1e17 && dist[u] + w < dist[v_pos]) {\n dist[v_pos] = dist[u] + w;\n parent[v_pos] = u;\n dir[v_pos] = 'R';\n pq.push({v_pos, ui, uj + 1, dist[v_pos]});\n }\n }\n }\n\n if (dist[ti * N + tj] >= 1e17) {\n return {\"\", 0.0, false};\n }\n\n string path;\n int curr = ti * N + tj;\n while (curr != si * N + sj) {\n if (parent[curr] == -1) {\n return {\"\", 0.0, false};\n }\n path += dir[curr];\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n\n double pred_len = 0.0;\n int ci = si, cj = sj;\n for (char c : path) {\n if (c == 'U') { ci--; pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ci][cj])); }\n else if (c == 'D') { pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[ci][cj])); ci++; }\n else if (c == 'L') { cj--; pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ci][cj])); }\n else if (c == 'R') { pred_len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[ci][cj])); cj++; }\n }\n\n return {path, pred_len, true};\n}\n\nbool is_path_valid(const string& path, int si, int sj, int ti, int tj) {\n int i = si, j = sj;\n for (char c : path) {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n if (c == 'U') i--;\n else if (c == 'D') i++;\n else if (c == 'L') j--;\n else if (c == 'R') j++;\n }\n return i == ti && j == tj;\n}\n\ndouble compute_path_length(const string& path, int si, int sj) {\n double len = 0.0;\n int i = si, j = sj;\n for (char c : path) {\n if (c == 'U') {\n if (--i < 0 || i >= N) break;\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n } else if (c == 'D') {\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n if (++i >= N) break;\n } else if (c == 'L') {\n if (--j < 0 || j >= N) break;\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n } else if (c == 'R') {\n len += max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n if (++j >= N) break;\n }\n }\n return len;\n}\n\nstring generate_optimized_path(int si, int sj, int ti, int tj) {\n string path = \"\";\n int i = si, j = sj;\n int steps = 0;\n\n while ((i != ti || j != tj) && steps < 10000) {\n int best_d = -1;\n double best_score = -1e18;\n int best_i = i, best_j = j;\n\n int di[] = {0, 0, 1, -1};\n int dj[] = {1, -1, 0, 0};\n char dirs[] = {'R', 'L', 'D', 'U'};\n\n for (int k = 0; k < 4; k++) {\n int ni = i + di[k];\n int nj = j + dj[k];\n\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n int dist_new = abs(ni - ti) + abs(nj - tj);\n int dist_curr = abs(i - ti) + abs(j - tj);\n int dist_reduce = dist_curr - dist_new;\n \n int vi = 0, vj = 0;\n if (dirs[k] == 'U') { vi = i - 1; vj = j; }\n else if (dirs[k] == 'D') { vi = i; vj = j; }\n else if (dirs[k] == 'L') { vi = i; vj = j - 1; }\n else if (dirs[k] == 'R') { vi = i; vj = j; }\n\n double w = max((double)MAX_WEIGHT, min((double)MAX_WEIGHT,\n (dirs[k] == 'U' || dirs[k] == 'D') ? v_edges[vi][vj] : h_edges[vi][vj]));\n\n int score = 80000 * dist_reduce - (int)w;\n \n if (score > best_score) {\n best_score = score;\n best_d = k;\n best_i = ni;\n best_j = nj;\n }\n }\n }\n\n if (best_d == -1) {\n path += generate_simple_path(si, sj, ti, tj);\n return path;\n }\n\n path += dirs[best_d];\n i = best_i;\n j = best_j;\n steps++;\n\n if (i < 0 || i >= N || j < 0 || j >= N) {\n path += generate_simple_path(si, sj, ti, tj);\n return path;\n }\n }\n\n while (i != ti) {\n path += (i < ti) ? 'D' : 'U';\n i += (i < ti) ? 1 : -1;\n }\n while (j != tj) {\n path += (j < tj) ? 'R' : 'L';\n j += (j < tj) ? 1 : -1;\n }\n\n return path;\n}\n\nvoid update_edge_weights(int si, int sj, const string& path, double predicted, int actual, int query_idx) {\n if (path.empty() || predicted < 0.1 || actual <= 0) return;\n\n // Learning rate should match scoring weights: 0.998^(1000-k)\n // At k=1: weight \u2248 0.135, at k=1000: weight = 1.0\n // So the factor should increase by ~7.4x over 1000 queries:\n // factor = 7.4^(1/1000) \u2248 1.0022\n double position_factor = pow(1.0022, query_idx);\n double base_lr = 0.15;\n double lr = min(0.50, base_lr * position_factor);\n\n double error = (double)actual - predicted;\n int num_edges = path.length();\n if (num_edges == 0) return;\n\n // Update magnitude: 1500 allows faster convergence for late queries\n double max_update = 1500.0;\n double update = (error / num_edges) * lr;\n if (update > max_update) update = max_update;\n if (update < -max_update) update = -max_update;\n\n int i = si, j = sj;\n for (char c : path) {\n if (c == 'U') {\n if (--i >= 0 && i < N) {\n v_edges[i][j] += update;\n v_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n }\n } else if (c == 'D') {\n v_edges[i][j] += update;\n v_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, v_edges[i][j]));\n if (++i >= N) break;\n } else if (c == 'L') {\n if (--j >= 0 && j < N) {\n h_edges[i][j] += update;\n h_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n }\n } else if (c == 'R') {\n h_edges[i][j] += update;\n h_edges[i][j] = max((double)MIN_WEIGHT, min((double)MAX_WEIGHT, h_edges[i][j]));\n if (++j >= N) break;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n srand(999);\n init_edge_weights();\n\n int si, sj, ti, tj;\n int feedback;\n\n for (int k = 0; k < 1000; k++) {\n if (!(cin >> si >> sj >> ti >> tj)) break;\n\n Result res = find_shortest_path(si, sj, ti, tj);\n\n string path;\n double predicted = 0.0;\n\n if (res.valid && is_path_valid(res.path, si, sj, ti, tj) && res.predicted_length > 0 && !res.path.empty()) {\n path = res.path;\n predicted = res.predicted_length;\n } else {\n path = generate_optimized_path(si, sj, ti, tj);\n if (path.empty()) {\n path = generate_simple_path(si, sj, ti, tj);\n }\n predicted = compute_path_length(path, si, sj);\n }\n\n cout << path << \"\\n\";\n cout.flush();\n\n if (cin >> feedback) {\n update_edge_weights(si, sj, path, predicted, feedback, k);\n }\n }\n\n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconstexpr int N = 20;\nconst int MAXM = 805;\n\nint M;\nstring s[MAXM];\nint len[MAXM];\nchar grid[N][N];\nchar best_grid[N][N];\n\nint miscount[MAXM][N][N][2];\nint sat_placements[MAXM];\nint total_satisfied;\nint current_dots;\nlong long best_score;\n\n// Apply a character change at position (r, c) - perfect symmetry for revert\nvoid apply_change(int r, int c, char old_char, char new_char) {\n if(new_char == '.' && old_char != '.') current_dots++;\n else if(new_char != '.' && old_char == '.') current_dots--;\n\n for(int i = 0; i < M; i++) {\n int L = len[i];\n for(int delta = 0; delta < L; delta++) {\n int start_c = (c - delta + N) % N;\n int &mc = miscount[i][r][start_c][0];\n int old_mm = (old_char != s[i][delta]);\n int new_mm = (new_char != s[i][delta]);\n \n if(old_mm && !new_mm) { mc--; if(--sat_placements[i] == 0) total_satisfied--; }\n else if(!old_mm && new_mm) { mc++; if(++sat_placements[i] == 1) total_satisfied++; }\n else { mc += new_mm - old_mm; }\n\n int start_r = (r - delta + N) % N;\n int &mc2 = miscount[i][start_r][c][1];\n \n if(old_mm && !new_mm) { mc2--; if(--sat_placements[i] == 0) total_satisfied--; }\n else if(!old_mm && new_mm) { mc2++; if(++sat_placements[i] == 1) total_satisfied++; }\n else { mc2 += new_mm - old_mm; }\n }\n }\n grid[r][c] = new_char;\n}\n\nint calc_score(int s_count, int d_count) {\n if(s_count >= M) {\n return (int)round(1e8 * (double)(2 * N * N) / (2.0 * N * N - d_count));\n }\n return (int)round(1e8 * (double)s_count / M);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_in, m_in;\n if (!(cin >> n_in >> M)) return 0;\n\n for(int i = 0; i < M; i++) {\n cin >> s[i];\n len[i] = s[i].length();\n }\n\n mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());\n best_score = 0;\n\n // Strategy: 8 restarts - more for hard cases\n // Mix of different cooling schedules\n int restarts[] = {8, 6, 7, 9, 5, 10, 6, 8};\n int iters[] = {4000, 5000, 4500, 6000, 3500, 5500, 4200, 5200};\n double temps[] = {600.0, 700.0, 750.0, 850.0, 500.0, 800.0, 650.0, 750.0};\n double rates[] = {0.9995, 0.9993, 0.9992, 0.9990, 0.9997, 0.9991, 0.9994, 0.9992};\n\n for(int seed = 0; seed < 8; seed++) {\n mt19937_64 rng_seed((unsigned long long)seed * 1000000009ULL + \n chrono::steady_clock::now().time_since_epoch().count());\n\n // Initialize grid\n current_dots = 0;\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n grid[i][j] = (char)('A' + ((int)rng_seed() & 7));\n best_grid[i][j] = grid[i][j];\n }\n }\n\n // Initialize stats\n for(int i = 0; i < M; i++) {\n sat_placements[i] = 0;\n int L = len[i];\n for(int r = 0; r < N; r++) {\n for(int c = 0; c < N; c++) {\n int mm = 0;\n for(int k = 0; k < L; k++) {\n if(grid[r][(c + k) % N] != s[i][k]) mm++;\n }\n miscount[i][r][c][0] = mm;\n if(mm == 0) sat_placements[i]++;\n\n mm = 0;\n for(int k = 0; k < L; k++) {\n if(grid[(r + k) % N][c] != s[i][k]) mm++;\n }\n miscount[i][r][c][1] = mm;\n if(mm == 0) sat_placements[i]++;\n }\n }\n }\n\n total_satisfied = 0;\n for(int i = 0; i < M; i++) {\n if(sat_placements[i] > 0) total_satisfied++;\n }\n\n // Initial score update\n long long initial_score = calc_score(total_satisfied, current_dots);\n if(initial_score > best_score) {\n best_score = initial_score;\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n best_grid[i][j] = grid[i][j];\n }\n }\n }\n\n // SA Loop\n int iter_total = iters[seed % 8];\n double temp_start = temps[seed % 8];\n double cooling_rate = rates[seed % 8];\n \n for(int iter = 0; iter < iter_total; iter++) {\n temp_start = max(0.001, temp_start * cooling_rate);\n int r = (int)(rng_seed() & (N - 1));\n int c = (int)(rng_seed() & (N - 1));\n int cand = (int)(rng_seed() & 8);\n char new_char = (cand == 8) ? '.' : (char)('A' + cand);\n \n if(new_char == grid[r][c]) continue;\n\n char old_char = grid[r][c];\n\n // Compute old score\n long long old_score = calc_score(total_satisfied, current_dots);\n\n // Apply change\n apply_change(r, c, old_char, new_char);\n\n // Compute new score \n long long new_score = calc_score(total_satisfied, current_dots);\n\n // Metropolis acceptance\n bool accept = (new_score > old_score);\n if(!accept) {\n double delta = (double)(new_score - old_score) / temp_start;\n double prob = exp(delta);\n double r_val = (double)rng_seed() / (double)(numeric_limits::max() + 1.0);\n if(r_val < 1.0 && r_val < prob) accept = true;\n }\n\n if(accept) {\n if(new_score > best_score) {\n best_score = new_score;\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n best_grid[i][j] = grid[i][j];\n }\n }\n }\n } else {\n // Perfect symmetry revert\n apply_change(r, c, new_char, old_char);\n }\n }\n }\n\n // Output result\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n cout << best_grid[i][j];\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 75;\nconst int INF = 1000000000;\n\nint N, si, sj;\nvector grid;\nchar dir_chars[] = {'U', 'D', 'L', 'R'};\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\n\nint dist_mat[MAX_N][MAX_N];\npair parent[MAX_N][MAX_N];\nchar parent_dir[MAX_N][MAX_N];\nbool visited[MAX_N][MAX_N];\nbool covered[MAX_N][MAX_N];\nint road_cnt, covered_cnt;\nvector> roads;\n\ninline bool isValid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N && grid[r][c] != '#';\n}\n\nbool checkVisibility(int r1, int c1, int r2, int c2) {\n if (r1 == r2) {\n int min_c = min(c1, c2), max_c = max(c1, c2);\n for (int c = min_c; c <= max_c; c++) {\n if (grid[r1][c] == '#') return false;\n }\n return true;\n } else if (c1 == c2) {\n int min_r = min(r1, r2), max_r = max(r1, r2);\n for (int r = min_r; r <= max_r; r++) {\n if (grid[r][c1] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\nvoid bfs(int sr, int sc) {\n memset(visited, 0, sizeof(visited));\n memset(dist_mat, 0x3f, sizeof(dist_mat));\n \n queue> q;\n q.push({sr, sc});\n dist_mat[sr][sc] = 0;\n visited[sr][sc] = true;\n parent[sr][sc] = make_pair(-1, -1);\n \n while (!q.empty()) {\n int r = q.front().first;\n int c = q.front().second;\n q.pop();\n \n for (int k = 0; k < 4; k++) {\n int nr = r + di[k];\n int nc = c + dj[k];\n \n if (isValid(nr, nc) && !visited[nr][nc]) {\n visited[nr][nc] = true;\n int w = grid[nr][nc] - '0';\n if (dist_mat[r][c] + w < dist_mat[nr][nc]) {\n dist_mat[nr][nc] = dist_mat[r][c] + w;\n parent[nr][nc] = make_pair(r, c);\n parent_dir[nr][nc] = dir_chars[k];\n q.push({nr, nc});\n }\n }\n }\n }\n}\n\nstring get_path(int er, int ec) {\n string path = \"\";\n if (!visited[er][ec]) return \"\";\n \n int r = er, c = ec;\n while (parent[r][c].first != -1) {\n path += parent_dir[r][c];\n pair p = parent[r][c];\n r = p.first;\n c = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nbool validatePath(const string& path, int start_r, int start_c, pair* final_pos = nullptr) {\n int r = start_r, c = start_c;\n for (char d : path) {\n bool found = false;\n for (int k = 0; k < 4; k++) {\n if (dir_chars[k] == d) {\n r += di[k];\n c += dj[k];\n if (isValid(r, c)) {\n found = true;\n break;\n }\n break;\n }\n }\n if (!found) return false;\n }\n if (final_pos) *final_pos = {r, c};\n return isValid(r, c);\n}\n\nint computeDistance(int r1, int c1, int r2, int c2) {\n bfs(r1, c1);\n if (visited[r2][c2] && dist_mat[r2][c2] < INF) {\n return dist_mat[r2][c2];\n }\n return INF;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> si >> sj;\n grid.resize(N);\n roads.clear();\n road_cnt = 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 roads.push_back({i, j});\n road_cnt++;\n }\n }\n }\n \n memset(covered, 0, sizeof(covered));\n \n vector> path_nodes;\n vector path_segments;\n int cr = si, cc = sj;\n \n covered[cr][cc] = true;\n for (int i = 0; i < road_cnt; i++) {\n if (checkVisibility(cr, cc, roads[i].first, roads[i].second)) {\n covered[roads[i].first][roads[i].second] = true;\n }\n }\n \n covered_cnt = 0;\n for (int i = 0; i < road_cnt; i++) {\n if (covered[roads[i].first][roads[i].second]) covered_cnt++;\n }\n \n if (covered_cnt >= road_cnt) {\n cout << \"\" << endl;\n return 0;\n }\n \n int max_iter = road_cnt * 2 + 1500;\n \n for (int iter = 0; iter < max_iter && covered_cnt < road_cnt; iter++) {\n int best_idx = -1;\n double best_score = -1;\n int best_dist = INF;\n \n for (int i = 0; i < road_cnt; i++) {\n if (covered[roads[i].first][roads[i].second]) continue;\n \n int gain = 0;\n for (int j = 0; j < road_cnt; j++) {\n if (!covered[roads[j].first][roads[j].second] && \n checkVisibility(roads[i].first, roads[i].second, roads[j].first, roads[j].second)) {\n gain++;\n }\n }\n \n int d = computeDistance(cr, cc, roads[i].first, roads[i].second);\n if (d >= INF) continue;\n \n double score = (double)gain * 100000.0 / (d + 1);\n \n if (score > best_score) {\n best_score = score;\n best_dist = d;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n int closest = -1;\n int min_dist = INF;\n for (int i = 0; i < road_cnt; i++) {\n if (covered[roads[i].first][roads[i].second]) continue;\n int d = computeDistance(cr, cc, roads[i].first, roads[i].second);\n if (d < min_dist) {\n min_dist = d;\n closest = i;\n }\n }\n if (closest != -1 && min_dist < INF) {\n best_idx = closest;\n best_dist = min_dist;\n }\n }\n \n if (best_idx == -1) break;\n \n int rr = roads[best_idx].first;\n int cc_val = roads[best_idx].second;\n \n bfs(cr, cc);\n string segment = get_path(rr, cc_val);\n \n if (segment.empty()) break;\n \n if (!validatePath(segment, cr, cc)) break;\n \n path_segments.push_back(segment);\n path_nodes.push_back({rr, cc_val});\n cr = rr;\n cc = cc_val;\n \n for (int i = 0; i < road_cnt; i++) {\n if (!covered[roads[i].first][roads[i].second] && \n checkVisibility(cr, cc, roads[i].first, roads[i].second)) {\n covered[roads[i].first][roads[i].second] = true;\n covered_cnt++;\n }\n }\n }\n \n if (cr != si || cc != sj) {\n bfs(cr, cc);\n string ret = get_path(si, sj);\n if (!ret.empty() && validatePath(ret, cr, cc)) {\n path_segments.push_back(ret);\n path_nodes.push_back({si, sj});\n }\n }\n \n string full_path;\n int final_r = si, final_c = sj;\n \n for (const auto& seg : path_segments) {\n if (!validatePath(seg, final_r, final_c)) continue;\n full_path += seg;\n for (char d : seg) {\n for (int k = 0; k < 4; k++) {\n if (dir_chars[k] == d) {\n final_r += di[k];\n final_c += dj[k];\n break;\n }\n }\n }\n }\n \n cout << full_path << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector dependencies;\n vector dependents;\n bool completed = false;\n bool started = false;\n int assigned_member = -1;\n int start_day = 0;\n int difficulty_sum = 0;\n};\n\nstruct Member {\n int id;\n int completion_count = 0;\n vector completed_times;\n vector completed_difficulties;\n vector skill_estimate;\n vector skill_confidence;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K, R;\n cin >> N >> M >> K >> R;\n \n // Read tasks\n vector tasks(N);\n for (int i = 0; i < N; i++) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n tasks[i].dependencies.clear();\n tasks[i].dependents.clear();\n tasks[i].completed = false;\n tasks[i].started = false;\n tasks[i].assigned_member = -1;\n tasks[i].start_day = 0;\n tasks[i].difficulty_sum = 0;\n for (int k = 0; k < K; k++) {\n cin >> tasks[i].d[k];\n tasks[i].difficulty_sum += tasks[i].d[k];\n }\n }\n \n // Read dependencies\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].dependencies.push_back(u);\n tasks[u].dependents.push_back(v);\n }\n \n // Initialize members\n vector members(M);\n for (int i = 0; i < M; i++) {\n members[i].id = i;\n members[i].completion_count = 0;\n members[i].completed_times.clear();\n members[i].completed_difficulties.clear();\n members[i].skill_estimate.resize(K, 10);\n members[i].skill_confidence.resize(K, 1.0);\n }\n \n int current_day = 0;\n \n while (current_day < 2000) {\n current_day++;\n \n // Read completions (skip on first day)\n if (current_day > 1) {\n int n_completed;\n cin >> n_completed;\n \n if (n_completed == -1) break;\n \n for (int i = 0; i < n_completed; i++) {\n int member_idx;\n cin >> member_idx;\n member_idx--;\n \n if (member_idx >= 0 && member_idx < M) {\n // Find completed task\n for (int t = 0; t < N; t++) {\n if (tasks[t].started && !tasks[t].completed && \n tasks[t].assigned_member == member_idx) {\n \n tasks[t].completed = true;\n tasks[t].assigned_member = -1;\n tasks[t].started = false;\n \n // Record completion\n int actual_time = current_day - tasks[t].start_day + 1;\n members[member_idx].completed_times.push_back(actual_time);\n members[member_idx].completed_difficulties.push_back(tasks[t].difficulty_sum);\n members[member_idx].completion_count++;\n \n // Update skill estimates per dimension\n for (int k = 0; k < K; k++) {\n int task_d = tasks[t].d[k];\n \n if (actual_time == 1) {\n members[member_idx].skill_estimate[k] = max(\n members[member_idx].skill_estimate[k],\n task_d + 20\n );\n } else {\n int old_skill = members[member_idx].skill_estimate[k];\n int new_skill = old_skill - (task_d - old_skill) / (actual_time + 1);\n members[member_idx].skill_estimate[k] = max(5, min(task_d + 10, new_skill));\n }\n \n members[member_idx].skill_confidence[k] += 1.0;\n }\n \n break;\n }\n }\n }\n }\n }\n \n // Find free members\n vector free_members;\n for (int m = 0; m < M; m++) {\n bool is_busy = false;\n for (int t = 0; t < N; t++) {\n if (tasks[t].started && !tasks[t].completed && \n tasks[t].assigned_member == m) {\n is_busy = true;\n break;\n }\n }\n if (!is_busy) {\n free_members.push_back(m);\n }\n }\n \n // Find ready tasks\n vector ready_tasks;\n for (int t = 0; t < N; t++) {\n if (tasks[t].started || tasks[t].completed) continue;\n \n bool all_deps_done = true;\n for (size_t dep_idx = 0; dep_idx < tasks[t].dependencies.size(); dep_idx++) {\n int dep = tasks[t].dependencies[dep_idx];\n if (!tasks[dep].completed) {\n all_deps_done = false;\n break;\n }\n }\n if (all_deps_done) {\n ready_tasks.push_back(t);\n }\n }\n \n // Sort by priority\n sort(ready_tasks.begin(), ready_tasks.end(), [&](int a, int b) {\n size_t dep_count_a = tasks[a].dependents.size();\n size_t dep_count_b = tasks[b].dependents.size();\n if (dep_count_a != dep_count_b) return dep_count_a > dep_count_b;\n return tasks[a].difficulty_sum < tasks[b].difficulty_sum;\n });\n \n // Assign tasks\n vector> assignments;\n vector used_members;\n \n for (int task_idx : ready_tasks) {\n if (free_members.empty()) break;\n \n int best_member = -1;\n double best_score = 1e18;\n \n for (int m : free_members) {\n double score = 0.0;\n \n if (members[m].completion_count == 0) {\n score = tasks[task_idx].difficulty_sum / 25.0 + 3.0;\n } else {\n int total_skill = 0;\n for (int k = 0; k < K; k++) {\n total_skill += members[m].skill_estimate[k];\n }\n double avg_skill = total_skill / (double)K;\n int diff_per_dim = tasks[task_idx].difficulty_sum / K;\n \n double skill_gap = diff_per_dim - avg_skill;\n double predicted_time = 2.0 + max(0.0, skill_gap / 5.0);\n \n double time_factor = 1.0;\n if (members[m].completion_count > 5) {\n double avg_time = 0.0;\n for (size_t i = 0; i < members[m].completed_times.size(); i++) {\n avg_time += members[m].completed_times[i];\n }\n avg_time /= (double)members[m].completion_count;\n time_factor = avg_time / 3.0;\n }\n \n score = predicted_time * time_factor;\n }\n \n if (score < best_score) {\n best_score = score;\n best_member = m;\n }\n }\n \n if (best_member != -1) {\n assignments.push_back({best_member, task_idx});\n used_members.push_back(best_member);\n \n tasks[task_idx].started = true;\n tasks[task_idx].assigned_member = best_member;\n tasks[task_idx].start_day = current_day;\n \n // Remove from free members\n for (size_t i = 0; i < free_members.size(); i++) {\n if (free_members[i] == best_member) {\n free_members.erase(free_members.begin() + (int)i);\n break;\n }\n }\n }\n }\n \n // Output assignments\n cout << assignments.size();\n for (int i = 0; i < (int)assignments.size(); i++) {\n cout << \" \" << assignments[i].first + 1 << \" \" << assignments[i].second + 1;\n }\n cout << endl;\n cout.flush();\n \n // Check if all completed\n bool all_done = true;\n for (int t = 0; t < N; t++) {\n if (!tasks[t].completed) {\n all_done = false;\n break;\n }\n }\n if (all_done) break;\n }\n \n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int DEPOT_X = 400;\nconst int DEPOT_Y = 400;\nconst int N_ORDERS = 1000;\nconst int ORDERS_TO_SELECT = 50;\n\ninline int get_dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nstruct Order {\n int id; \n int a, b; \n int c, d; \n double base_cost;\n};\n\nstruct PathData {\n vector> coords;\n vector path; \n int cost;\n};\n\nvector orders;\nmt19937 rng;\n\ninline int rand_int(int max) {\n return rng() % max;\n}\n\nint calculate_path_cost(const PathData& res) {\n int cost = 0;\n int cx = DEPOT_X, cy = DEPOT_Y;\n for(size_t i = 0; i < res.path.size(); ++i) {\n cx = res.coords[res.path[i]].first;\n cy = res.coords[res.path[i]].second;\n if(i + 1 < res.path.size()) {\n int nx = res.coords[res.path[i+1]].first;\n int ny = res.coords[res.path[i+1]].second;\n cost += get_dist(cx, cy, nx, ny);\n }\n }\n return cost;\n}\n\nPathData solve_subset_path(const vector& sub_set, int optimization_iters) {\n PathData res;\n res.path.reserve(102);\n res.coords.resize(101);\n \n res.coords[0].first = DEPOT_X;\n res.coords[0].second = DEPOT_Y;\n \n for(int k = 0; k < ORDERS_TO_SELECT; ++k) {\n int idx = sub_set[k];\n res.coords[k+1].first = orders[idx].a;\n res.coords[k+1].second = orders[idx].b;\n res.coords[k+51].first = orders[idx].c;\n res.coords[k+51].second = orders[idx].d;\n }\n \n // Greedy Construction\n vector visited(101, false);\n vector pickup_done(50, false);\n res.path.push_back(0);\n int cx = DEPOT_X, cy = DEPOT_Y;\n \n for(int s = 0; s < 100; ++s) {\n int best_node = -1, min_d = 2000000000;\n for(int node = 1; node <= 100; ++node) {\n if(!visited[node]) {\n if(node > 50 && !pickup_done[node - 51]) continue;\n int d = get_dist(cx, cy, res.coords[node].first, res.coords[node].second);\n if(d < min_d) { min_d = d; best_node = node; }\n }\n }\n if(best_node == -1) break;\n visited[best_node] = true;\n res.path.push_back(best_node);\n cx = res.coords[best_node].first;\n cy = res.coords[best_node].second;\n if(best_node <= 50) pickup_done[best_node - 1] = true;\n }\n res.path.push_back(0);\n \n // Compute base cost\n res.cost = calculate_path_cost(res);\n\n // Optimization passes: swaps and 2-opt reversals\n if(optimization_iters > 0) {\n int path_len = (int)res.path.size();\n \n for(int iter = 0; iter < optimization_iters; ++iter) {\n int op_type = rand_int(3);\n \n if(op_type == 0 || iter < optimization_iters / 5) {\n // Try swap moves\n int i = rand_int(path_len - 2) + 1;\n int j = rand_int(path_len - 2) + 1;\n if(i == j) continue;\n \n int u = res.path[i], v = res.path[j];\n if((u <= 50 && v == u + 50) || (v <= 50 && u == v + 50)) {\n continue;\n }\n \n res.path[i] = v;\n res.path[j] = u;\n \n bool valid = true;\n for(int k = 1; k <= 50 && valid; ++k) {\n int posP = -1, posD = -1;\n for(int m = 0; m < path_len; ++m) {\n if(res.path[m] == k) posP = m;\n if(res.path[m] == k + 50) posD = m;\n }\n if(posP > posD) valid = false;\n }\n \n if(valid) {\n int new_cost = calculate_path_cost(res);\n if(new_cost < res.cost) {\n res.cost = new_cost;\n } else {\n res.path[i] = u; res.path[j] = v;\n }\n } else {\n res.path[i] = u; res.path[j] = v;\n }\n } else {\n // Try 2-opt reversal\n int i = rand_int(path_len - 4) + 1;\n int j = i + 2 + rand_int(path_len - i - 3);\n if(j >= path_len - 1) continue;\n \n vector segment;\n for(int k = i + 1; k < j; ++k) {\n segment.push_back(res.path[k]);\n }\n reverse(segment.begin(), segment.end());\n for(size_t k = 0; k < segment.size(); ++k) {\n res.path[i + 1 + k] = segment[k];\n }\n \n bool valid = true;\n for(int k = 1; k <= 50 && valid; ++k) {\n int posP = -1, posD = -1;\n for(int m = 0; m < path_len; ++m) {\n if(res.path[m] == k) posP = m;\n if(res.path[m] == k + 50) posD = m;\n }\n if(posP > posD) valid = false;\n }\n \n if(valid) {\n int new_cost = calculate_path_cost(res);\n if(new_cost < res.cost) {\n res.cost = new_cost;\n } else {\n for(size_t k = 0; k < segment.size(); ++k) {\n res.path[i + 1 + k] = segment[segment.size() - 1 - k];\n }\n }\n } else {\n for(size_t k = 0; k < segment.size(); ++k) {\n res.path[i + 1 + k] = segment[segment.size() - 1 - k];\n }\n }\n }\n }\n }\n return res;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n rng.seed(time(nullptr));\n \n vector p(N_ORDERS);\n \n for(int i = 0; i < N_ORDERS; ++i) {\n orders.push_back(Order());\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].id = i + 1;\n orders[i].base_cost = (double)(get_dist(DEPOT_X, DEPOT_Y, orders[i].a, orders[i].b) +\n get_dist(orders[i].a, orders[i].b, orders[i].c, orders[i].d) +\n get_dist(orders[i].c, orders[i].d, DEPOT_X, DEPOT_Y));\n p[i] = i;\n }\n \n sort(p.begin(), p.end(), [&](int a, int b) {\n return orders[a].base_cost < orders[b].base_cost;\n });\n \n int K = min(80, N_ORDERS);\n vector pool(K);\n for(int i = 0; i < K; ++i) {\n pool[i] = p[i];\n }\n \n vector in_subset(N_ORDERS, false);\n vector subset;\n vector subset_pool_indices;\n vector pool_remaining_indices;\n \n for(int i = 0; i < 50; ++i) {\n subset.push_back(pool[i]);\n subset_pool_indices.push_back(i);\n in_subset[pool[i]] = true;\n }\n for(int i = 50; i < K; ++i) {\n pool_remaining_indices.push_back(i);\n }\n \n vector best_subset = subset;\n int best_T = solve_subset_path(subset, 500).cost;\n \n for(int iter = 0; iter < 500; ++iter) {\n int i = rand_int(50);\n int j = rand_int((int)pool_remaining_indices.size());\n int pool_idx_to_add = pool_remaining_indices[j];\n int pool_idx_to_remove = subset_pool_indices[i];\n \n int from_idx = subset[i];\n int to_idx = pool[pool_idx_to_add];\n \n subset[i] = to_idx;\n subset_pool_indices[i] = pool_idx_to_add;\n \n in_subset[from_idx] = false;\n in_subset[to_idx] = true;\n pool_remaining_indices[j] = pool_idx_to_remove;\n \n int current_cost = solve_subset_path(subset, 500).cost;\n if(current_cost < best_T) {\n best_T = current_cost;\n best_subset = subset;\n } else {\n subset[i] = from_idx;\n subset_pool_indices[i] = pool_idx_to_remove;\n in_subset[from_idx] = true;\n in_subset[to_idx] = false;\n pool_remaining_indices[j] = pool_idx_to_add;\n }\n }\n \n PathData final_path = solve_subset_path(best_subset, 10000);\n \n cout << ORDERS_TO_SELECT << \" \";\n for(int i = 0; i < ORDERS_TO_SELECT; ++i) {\n cout << orders[best_subset[i]].id << \" \";\n }\n cout << \"\\n102 \";\n for(int x : final_path.path) {\n cout << final_path.coords[x].first << \" \" << final_path.coords[x].second << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc007":"/*\n AHC007 - Final Correct Solution\n Strategy: Pure Kruskal's-like greedy approach\n - Accept ALL edges that connect different components\n - Only reject edges that form cycles\n - This guarantees connectivity\n - Cost is minimized through greedy selection\n \n Given M=1995 edges and N=400 vertices, even accepting many edges\n won't cause cost issues since we have 5x redundancy in MSTs.\n*/\n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 400;\nconst int M = 1995;\n\n// DSU structure with union by size\nstruct DSU {\n vector parent;\n vector size;\n int components;\n\n DSU(int n) : parent(n), size(n, 1), components(n) {\n iota(parent.begin(), parent.end(), 0);\n }\n\n int find(int a) {\n int root = a;\n while (parent[root] != root) {\n root = parent[root];\n }\n // Path compression\n while (a != root) {\n int next = parent[a];\n parent[a] = root;\n a = next;\n }\n return root;\n }\n\n bool unite(int a, int b) {\n a = find(a);\n b = find(b);\n if (a != b) {\n // Union by size\n if (size[a] < size[b]) swap(a, b);\n parent[b] = a;\n size[a] += size[b];\n components--;\n return true;\n }\n return false;\n }\n};\n\n// Read coordinates and edges\nstruct EdgeInput {\n int u, v;\n int d;\n int original_idx;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read N vertex coordinates\n vector X(N), Y(N);\n for (int i = 0; i < N; ++i) {\n cin >> X[i] >> Y[i];\n }\n\n // Read M edges and compute Euclidean distances\n vector edge_info(M);\n for (int i = 0; i < M; ++i) {\n cin >> edge_info[i].u >> edge_info[i].v;\n edge_info[i].original_idx = i;\n \n long long dx = X[edge_info[i].u] - X[edge_info[i].v];\n long long dy = Y[edge_info[i].u] - Y[edge_info[i].v];\n double dist = std::sqrt((double)dx * dx + (double)dy * dy);\n edge_info[i].d = std::round(dist);\n }\n\n // Calculate rank for each edge based on Euclidean distance\n // Lower rank = smaller distance = potentially cheaper\n vector sorted_indices(M);\n std::iota(sorted_indices.begin(), sorted_indices.end(), 0);\n \n std::sort(sorted_indices.begin(), sorted_indices.end(), [&](int a, int b) {\n if (edge_info[a].d != edge_info[b].d) {\n return edge_info[a].d < edge_info[b].d;\n }\n return edge_info[a].original_idx < edge_info[b].original_idx;\n });\n\n // Map from original_idx to rank\n vector rank_map(M);\n for (int i = 0; i < M; ++i) {\n rank_map[sorted_indices[i]] = i;\n }\n\n // Initialize DSU for connectivity tracking\n DSU dsu(N);\n\n // Process M edge revelations interactively\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n\n int u = edge_info[i].u;\n int v = edge_info[i].v;\n\n // Kruskal's greedy approach:\n // Accept if edge connects different components\n // This guarantees connectivity since we accept until tree is formed\n bool should_accept = !dsu.find(u) || dsu.find(u) != dsu.find(v);\n \n // Actually, check if find returns different roots\n bool connects = (dsu.find(u) != dsu.find(v));\n\n if (connects) {\n dsu.unite(u, v);\n cout << 1 << endl;\n } else {\n cout << 0 << endl;\n }\n cout.flush();\n }\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;\nusing namespace atcoder;\n\nclass Solver {\nprivate:\n int N, M;\n struct Pet {\n int px, py, type;\n };\n struct Human {\n int x, y;\n };\n \n vector pets;\n vector humans;\n bool blocked[35][35];\n \n mt19937 rng;\n int currentTurn;\n \n const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // U, D, L, R\n \n bool inBounds(int x, int y) {\n return x >= 1 && x <= 30 && y >= 1 && y <= 30;\n }\n \n // Check if position is blocked or occupied\n bool isBlocked(int x, int y, int turn, bool initial = false) {\n if (blocked[x][y]) return true;\n \n if (initial || turn == 0) {\n for (auto& p : pets) {\n if (p.px == x && p.py == y) return true;\n }\n for (auto& h : humans) {\n if (h.x == x && h.y == y) return true;\n }\n }\n \n // Check adjacency to pets (for blocking)\n for (auto& p : pets) {\n int dist = abs(p.px - x) + abs(p.py - y);\n if (dist <= 1 && (dist != 0)) return true;\n }\n \n return false;\n }\n \n int countReachable(int x, int y) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int count = 1;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n count++;\n q.push({nx, ny});\n }\n }\n }\n return count;\n }\n \n int countPetsInArea(int x, int y) {\n int count = 0;\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x, y});\n visited[x][y] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n reachable++;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n \n // Count pets in reachable area\n for (auto& p : pets) {\n if (reachable > 0 && inBounds(p.px, p.py)) {\n // Simple reachability check\n bool visited2[35][35];\n memset(visited2, 0, sizeof(visited2));\n if (canReach(p.px, p.y, x, y, visited2)) {\n count++;\n }\n }\n }\n \n return count;\n }\n \n bool canReach(int x1, int y1, int x2, int y2, bool& visited[35][35]) {\n // BFS to check reachability\n memset(visited, 0, sizeof(visited));\n \n queue> q;\n q.push({x1, y1});\n visited[x1][y1] = true;\n \n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n \n if (cx == x2 && cy == y2) return true;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dirs[d][0];\n int ny = cy + dirs[d][1];\n \n if (inBounds(nx, ny) && !visited[nx][ny] && !blocked[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n return false;\n }\n \n bool canReach(int x1, int y1, int x2, int y2) {\n bool visited[35][35];\n memset(visited, 0, sizeof(visited));\n return canReach(x1, y1, x2, y2, visited);\n }\n \n // Choose best action for each human\n string decideAction(int humanIdx, int turn) {\n auto& h = humans[humanIdx];\n double bestScore = 0;\n string bestAction = \".\";\n \n // Evaluate all possible actions\n // Action: stay, block (4 directions), move (4 directions)\n \n // Try blocking\n for (int d = 0; d < 4; d++) {\n int bx = h.x + dirs[d][0];\n int by = h.y + dirs[d][1];\n \n bool valid = true;\n if (!inBounds(bx, by)) valid = false;\n if (blocked[bx][by]) valid = false;\n if (turn == 0) {\n // Initial positions - occupied check\n for (auto& p : pets) {\n if (p.px == bx && p.py == by || \n abs(p.px - bx) + abs(p.py - by) == 1) {\n valid = false;\n break;\n }\n }\n if (valid) {\n for (auto& h2 : humans) {\n if ((h2.x == bx && h2.y == by) ||\n (h2.x != h.x || h2.y != h.y) && \n abs(h2.x - bx) + abs(h2.y - by) <= 1) {\n valid = false;\n break;\n }\n }\n }\n }\n \n if (valid) {\n // Calculate score if we block\n blocked[bx][by] = true;\n double score = calculateScore(humanIdx);\n blocked[bx][by] = false;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"udlr\"[d]);\n }\n }\n }\n \n // Try moving\n for (int d = 0; d < 4; d++) {\n int nx = h.x + dirs[d][0];\n int ny = h.y + dirs[d][1];\n \n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[humanIdx] = {nx, ny};\n double score = calculateScore(humanIdx);\n humans[humanIdx] = h;\n \n if (score > bestScore) {\n bestScore = score;\n bestAction = string(1, \"UDLR\"[d]);\n }\n }\n }\n \n // Try staying\n double score = calculateScore(humanIdx);\n if (score > bestScore) {\n bestScore = score;\n bestAction = \".\";\n }\n \n return bestAction;\n }\n \n double calculateScore(int humanIdx) {\n auto& h = humans[humanIdx];\n int reachable = countReachable(h.x, h.y);\n int petCount = countPetsInArea(h.x, h.y);\n \n // Score: reachable/900 * 2^(-petCount)\n return (double)reachable / 900.0 / pow(2.0, petCount);\n }\n \npublic:\n Solver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n memset(blocked, 0, sizeof(blocked));\n }\n \n void solve() {\n // Read input\n cin >> N;\n pets.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> pets[i].px >> pets[i].py >> pets[i].type;\n }\n \n cin >> M;\n humans.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> humans[i].x >> humans[i].y;\n }\n \n // Simulate for all turns\n for (currentTurn = 0; currentTurn < MAX_TURNS; currentTurn++) {\n string output = \"\";\n \n for (int i = 0; i < M; i++) {\n output += decideAction(i, currentTurn);\n }\n \n cout << output << endl << flush;\n fflush(stdout);\n \n // Read pet movements\n for (int i = 0; i < M; i++) {\n string moves;\n cin >> moves;\n }\n \n // Update blocked based on blocking actions\n for (int i = 0; i < M; i++) {\n if (output.size() > i) {\n char act = output[i];\n if (act >= 'a' && act <= 'd') {\n // Blocking\n int d = (act == 'u') ? 0 : (act == 'd') ? 1 : (act == 'l') ? 2 : 3;\n int bx = humans[i].x + dirs[d][0];\n int by = humans[i].y + dirs[d][1];\n if (inBounds(bx, by)) {\n blocked[bx][by] = true;\n }\n } else if (act == 'U' || act == 'D' || act == 'L' || act == 'R') {\n // Moving\n int d = (act == 'U') ? 0 : (act == 'D') ? 1 : (act == 'L') ? 2 : 3;\n int nx = humans[i].x + dirs[d][0];\n int ny = humans[i].y + dirs[d][1];\n if (inBounds(nx, ny) && !blocked[nx][ny]) {\n humans[i] = {nx, ny};\n }\n }\n }\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solver solver;\n solver.solve();\n \n return 0;\n}","ahc009":"#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(NULL);\n\n int si, sj, ti, tj;\n double p;\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) {\n return 0;\n }\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 // Directions: U=0, D=1, L=2, R=3\n const int DR[4] = {-1, 1, 0, 0};\n const int DC[4] = {0, 0, -1, 1};\n const char MOVE_CHAR[4] = {'U', 'D', 'L', 'R'};\n\n const int L = 200;\n const int N = 400;\n const double STAY = p;\n const double MOVE = 1.0 - p;\n\n int start = si * 20 + sj;\n int goal = ti * 20 + tj;\n\n // BFS from goal to understand reachability\n vector dist(N, -1);\n queue q;\n dist[goal] = 0;\n q.push(goal);\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n int r = u / 20, c = u % 20;\n\n for (int m = 0; m < 4; ++m) {\n int nr = r + DR[m], nc = c + DC[m];\n if (nr < 0 || nr >= 20 || nc < 0 || nc >= 20 || dist[nr * 20 + nc] != -1) continue;\n\n bool blocked = false;\n if (m == 0 && v[nr][c] == '1') blocked = true;\n if (m == 1 && v[r][c] == '1') blocked = true;\n if (m == 2 && h[r][nc] == '1') blocked = true;\n if (m == 3 && h[r][c] == '1') blocked = true;\n\n if (!blocked) {\n dist[nr * 20 + nc] = dist[u] + 1;\n q.push(nr * 20 + nc);\n }\n }\n }\n\n // DP: dp[t * N + u] = expected future score\n vector dp((L + 2) * N, 0.0);\n const auto get_dp = [&](int t, int u) { return dp[t * N + u]; };\n const auto set_dp = [&](int t, int u, double v) { dp[t * N + u] = v; };\n\n // Fill DP backward from t=L to t=1\n for (int t = L; t >= 1; --t) {\n // Goal is absorbing\n for (int u = 0; u < N; ++u) {\n if (u == goal) {\n set_dp(t, u, 0.0);\n continue;\n }\n if (dist[u] == -1 || dist[u] > L - t) {\n set_dp(t, u, 0.0);\n continue;\n }\n\n double best = -1e18;\n int r = u / 20, c = u % 20;\n\n for (int m = 0; m < 4; ++m) {\n int nr = r + DR[m], nc = c + DC[m];\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n\n bool wall_blocked = false;\n if (!out_of_bounds) {\n if (m == 0 && v[nr][c] == '1') wall_blocked = true;\n if (m == 1 && v[r][c] == '1') wall_blocked = true;\n if (m == 2 && h[r][nc] == '1') wall_blocked = true;\n if (m == 3 && h[r][c] == '1') wall_blocked = true;\n }\n\n double expected = 0.0;\n if (out_of_bounds || wall_blocked) {\n expected = get_dp(t + 1, u);\n } else {\n int v_node = nr * 20 + nc;\n if (v_node == goal) {\n expected = MOVE * (401.0 - t) + STAY * get_dp(t + 1, u);\n } else {\n expected = MOVE * get_dp(t + 1, v_node) + STAY * get_dp(t + 1, u);\n }\n }\n\n if (expected > best) best = expected;\n }\n set_dp(t, u, best);\n }\n }\n\n // Construct path greedily\n string result;\n result.reserve(L);\n\n // Probability distribution over current positions\n vector prob(N, 0.0);\n prob[start] = 1.0;\n\n for (int t = 1; t <= L; ++t) {\n int best_m = 0;\n double max_val = -1e18;\n\n for (int m = 0; m < 4; ++m) {\n double val = 0.0;\n\n for (int u = 0; u < N; ++u) {\n if (prob[u] < 1e-15 || u == goal) continue;\n\n int r = u / 20, c = u % 20;\n int nr = r + DR[m], nc = c + DC[m];\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n\n bool wall_blocked = false;\n if (!out_of_bounds) {\n if (m == 0 && v[nr][c] == '1') wall_blocked = true;\n if (m == 1 && v[r][c] == '1') wall_blocked = true;\n if (m == 2 && h[r][nc] == '1') wall_blocked = true;\n if (m == 3 && h[r][c] == '1') wall_blocked = true;\n }\n\n double exp = 0.0;\n if (out_of_bounds || wall_blocked) {\n exp = get_dp(t + 1, u);\n } else {\n int v_node = nr * 20 + nc;\n if (v_node == goal) {\n exp = MOVE * (401.0 - t);\n } else {\n exp = MOVE * get_dp(t + 1, v_node);\n }\n exp += STAY * get_dp(t + 1, u);\n }\n\n val += prob[u] * exp;\n }\n\n if (val > max_val) {\n max_val = val;\n best_m = m;\n }\n }\n\n result += MOVE_CHAR[best_m];\n\n // Update probability distribution\n vector next_prob(N, 0.0);\n for (int u = 0; u < N; ++u) {\n double p_u = prob[u];\n if (p_u < 1e-15 || u == goal) {\n if (u == goal) next_prob[goal] += p_u;\n continue;\n }\n\n int r = u / 20, c = u % 20;\n int nr = r + DR[best_m], nc = c + DC[best_m];\n bool out_of_bounds = (nr < 0 || nr >= 20 || nc < 0 || nc >= 20);\n\n bool wall_blocked = false;\n if (!out_of_bounds) {\n if (best_m == 0 && v[nr][c] == '1') wall_blocked = true;\n if (best_m == 1 && v[r][c] == '1') wall_blocked = true;\n if (best_m == 2 && h[r][nc] == '1') wall_blocked = true;\n if (best_m == 3 && h[r][c] == '1') wall_blocked = true;\n }\n\n if (out_of_bounds || wall_blocked) {\n next_prob[u] += p_u;\n } else {\n int v_node = nr * 20 + nc;\n next_prob[u] += p_u * STAY;\n next_prob[v_node] += p_u * MOVE;\n }\n }\n prob = next_prob;\n }\n\n cout << result << endl;\n\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_ITERATIONS = 60000;\nconst int NUM_RUNS = 4;\n\nint tiles[N][N];\nint r_rot[N][N];\nint trans[8][4][4];\nint best_r_rot[N][N];\n\nbool vis[N][N][4];\nint trace_token[N][N][4];\nint global_token = 0;\n\nint path_i[3000];\nint path_j[3000];\nint path_d[3000];\nint lengths[1000];\nint num_lengths;\n\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nlong long current_score = 0;\nlong long global_best_score = 0;\n\nvoid init_to() {\n int base[8][4] = {\n {1, 0, -1, -1}, {3, -1, -1, 0}, {-1, -1, 3, 2}, {-1, 2, 1, -1},\n {1, 0, 3, 2}, {3, 2, 1, 0}, {2, -1, 0, -1}, {-1, 3, -1, 1}\n };\n \n for (int r = 0; r < 8; ++r) {\n for (int rot = 0; rot < 4; ++rot) {\n for (int d = 0; d < 4; ++d) {\n int d_internal = (d - rot + 4) % 4;\n int out_internal = base[r][d_internal];\n trans[r][rot][d] = (out_internal == -1) ? -1 : (out_internal + rot) % 4;\n }\n }\n }\n}\n\nlong long calculate_score() {\n global_token++;\n if (global_token == 0) {\n memset(trace_token, 0, sizeof(trace_token));\n memset(vis, 0, sizeof(vis));\n global_token = 1;\n }\n \n num_lengths = 0;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int d = 0; d < 4; ++d) {\n if (vis[i][j][d]) continue;\n \n int path_len = 0;\n int ci = i, cj = j, cd = d;\n \n while (true) {\n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n if (trace_token[ci][cj][cd] == global_token) {\n int loop_len = 0;\n for (int k = 0; k < path_len; ++k) {\n if (path_i[k] == ci && path_j[k] == cj && path_d[k] == cd) {\n loop_len = path_len - k;\n break;\n }\n }\n if (loop_len > 0) lengths[num_lengths++] = loop_len;\n break;\n }\n \n if (trace_token[ci][cj][cd] > 0) break;\n \n trace_token[ci][cj][cd] = global_token;\n vis[ci][cj][cd] = true;\n \n path_i[path_len] = ci;\n path_j[path_len] = cj;\n path_d[path_len] = cd;\n path_len++;\n \n int type = tiles[ci][cj];\n int rot = r_rot[ci][cj];\n int nd = trans[type][rot][cd];\n \n if (nd == -1) break;\n \n int ni = ci + di[nd];\n int nj = cj + dj[nd];\n \n if (ni < 0 || ni >= N || nj < 0 || nj >= N) break;\n \n ci = ni; cj = nj; cd = (nd + 2) % 4;\n }\n }\n }\n }\n \n if (num_lengths < 2) return 0;\n \n sort(lengths, lengths + num_lengths, greater());\n return (long long)lengths[0] * lengths[1];\n}\n\nvoid sa_run(int seed, bool with_greedy) {\n mt19937 rng(seed);\n uniform_int_distribution dist_rot(0, 3);\n uniform_int_distribution dist_pos(0, N-1);\n uniform_real_distribution dist_rand_p(0.0, 1.0);\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n r_rot[i][j] = dist_rot(rng);\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n r_rot[i][j] = dist_rot(rng);\n \n current_score = calculate_score();\n \n if (with_greedy) {\n for (int pass = 0; pass < 5; ++pass) {\n int improved = 0;\n for (int i = 0; i < N * N; ++i) {\n int ri = i / N;\n int ci = i % N;\n \n int old_rot = r_rot[ri][ci];\n long long best_score = current_score;\n int best_rot = old_rot;\n \n for (int rot = 0; rot < 4; ++rot) {\n if (rot == old_rot) continue;\n r_rot[ri][ci] = rot;\n long long score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rot = rot;\n }\n }\n \n if (best_rot != old_rot) {\n r_rot[ri][ci] = best_rot;\n current_score = best_score;\n improved = 1;\n }\n }\n if (!improved) break;\n }\n }\n \n double T = 1000.0;\n \n int iter = 0;\n while (iter < MAX_ITERATIONS) {\n double progress = (double)iter / MAX_ITERATIONS;\n T = 1000.0 * pow(1e-4 / 1000.0, progress);\n double p_accept = dist_rand_p(rng);\n \n int r = dist_pos(rng);\n int c = dist_pos(rng);\n int new_rot = dist_rot(rng);\n \n while (new_rot == r_rot[r][c]) new_rot = dist_rot(rng);\n \n int old_rot = r_rot[r][c];\n r_rot[r][c] = new_rot;\n \n long long score = calculate_score();\n bool accept = false;\n \n if (score >= current_score) {\n accept = true;\n } else {\n if (exp((double)(score - current_score) / T) > p_accept) {\n accept = true;\n }\n }\n \n if (accept) {\n current_score = score;\n if (score > global_best_score) {\n global_best_score = score;\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n best_r_rot[i][j] = r_rot[i][j];\n }\n } else {\n r_rot[r][c] = old_rot;\n }\n \n iter++;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_to();\n \n for (int i = 0; i < N; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < N; ++j)\n tiles[i][j] = row[j] - '0';\n }\n \n memset(best_r_rot, 0, sizeof(best_r_rot));\n global_best_score = 0;\n \n for (int run = 0; run < NUM_RUNS; ++run) {\n sa_run(run * 12345 + 6789, (run == 0));\n }\n \n memcpy(r_rot, best_r_rot, sizeof(best_r_rot));\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j)\n cout << r_rot[i][j];\n }\n cout << \"\\n\";\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 10;\nconst int MAX_BOARD_SIZE = MAX_N * MAX_N;\nconst int BASE_BEAM_WIDTH = 80;\nconst int MAX_BEAM_WIDTH = 500;\nconst int MAX_NODES = 3500000;\n\nstruct Node {\n int board[MAX_BOARD_SIZE];\n int empty_pos;\n int score;\n int path_len;\n int depth;\n int parent_idx; \n char move_char;\n};\n\nvector all_nodes;\nint parent[MAX_BOARD_SIZE];\nint sz[MAX_BOARD_SIZE];\nbool is_cyclic[MAX_BOARD_SIZE];\n\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\ninline int dsu_find(int i) {\n int root = i;\n while (parent[root] != root) root = parent[root];\n while (parent[i] != root) { int next = parent[i]; parent[i] = root; i = next; }\n return root;\n}\n\nvoid dsu_union(int i, int j) {\n int root_i = dsu_find(i);\n int root_j = dsu_find(j);\n if (root_i != root_j) {\n if (sz[root_i] < sz[root_j]) swap(root_i, root_j);\n parent[root_j] = root_i;\n sz[root_i] += sz[root_j];\n is_cyclic[root_i] = is_cyclic[root_i] || is_cyclic[root_j];\n } else {\n is_cyclic[root_i] = true;\n }\n}\n\nvoid dsu_init(int n) {\n for (int i = 0; i < n; ++i) {\n parent[i] = i;\n sz[i] = 1;\n is_cyclic[i] = false;\n }\n}\n\nint get_move_quality(const int* board, int er, int ec, int r_off, int c_off, int N) {\n int nr = er + r_off;\n int nc = ec + c_off;\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) return -10;\n int tile = board[nr * N + nc];\n if (!tile) return -10;\n \n // High priority: tile connects toward empty position\n if (r_off == -1 && (tile & 2)) return 300; // Up connection\n if (r_off == 1 && (tile & 8)) return 300; // Down connection\n if (c_off == -1 && (tile & 4)) return 300; // Right connection\n if (c_off == 1 && (tile & 1)) return 300; // Left connection\n \n // Medium priority: internal connections\n if ((tile & 12) || (tile & 5)) return 150;\n \n return 50;\n}\n\nint get_tree_score(const int* board, int n) {\n dsu_init(n * n);\n \n for (int r = 0; r < n; ++r) {\n for (int c = 0; c < n; ++c) {\n int idx = r * n + c;\n int tile = board[idx];\n if (tile == 0) continue;\n \n if (c < n - 1) {\n int ni = idx + 1;\n if (board[ni]) {\n if ((tile & 4) && (board[ni] & 1)) dsu_union(idx, ni);\n else if ((tile & 1) && (board[ni] & 4)) dsu_union(idx, ni);\n }\n }\n if (r < n - 1) {\n int ni = idx + n;\n if (board[ni]) {\n if ((tile & 8) && (board[ni] & 2)) dsu_union(idx, ni);\n else if ((tile & 2) && (board[ni] & 8)) dsu_union(idx, ni);\n }\n }\n }\n }\n \n int max_size = 0;\n int nn = n * n;\n bool* processed = new bool[nn]();\n for (int i = 0; i < nn; ++i) {\n if (board[i] == 0) continue;\n int root = dsu_find(i);\n if (processed[root]) continue;\n processed[root] = true;\n if (!is_cyclic[root]) {\n max_size = max(max_size, sz[root]);\n }\n }\n delete[] processed;\n return max_size;\n}\n\nstring reconstruct_path(int node_idx) {\n string path;\n int current = node_idx;\n while (all_nodes[current].parent_idx != -1) {\n path += all_nodes[current].move_char;\n current = all_nodes[current].parent_idx;\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 int N, T;\n if (!(cin >> N >> T)) return 0;\n\n all_nodes.reserve(MAX_NODES);\n \n Node start_node;\n memset(start_node.board, 0, sizeof(start_node.board));\n int empty_pos = -1;\n \n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c;\n cin >> c;\n int val = 0;\n if (isdigit(c)) val = c - '0';\n else val = 10 + (c - 'a');\n start_node.board[i * N + j] = val;\n if (val == 0) empty_pos = i * N + j;\n }\n }\n \n start_node.empty_pos = empty_pos;\n start_node.parent_idx = -1;\n start_node.path_len = 0;\n start_node.depth = 0;\n start_node.score = get_tree_score(start_node.board, N);\n start_node.move_char = 0;\n \n all_nodes.push_back(start_node);\n\n vector current_layer;\n vector next_layer;\n \n current_layer.push_back(0);\n \n int best_node_idx = 0;\n int max_score = start_node.score;\n int best_path_len = T + 1;\n string best_path = \"\";\n\n for (int step = 1; step <= T; ++step) {\n // Aggressive beam width when looking for optimal paths\n int beam_width = BASE_BEAM_WIDTH;\n if (step <= 3) beam_width = min(150, 80 + step * 10);\n else if (step <= T / 3) beam_width = min(MAX_BEAM_WIDTH, beam_width + 20);\n else beam_width = min(MAX_BEAM_WIDTH, beam_width + 15);\n \n // When we have any solution, search wider for shorter alternatives\n if (!best_path.empty()) {\n beam_width = max(beam_width, 200);\n }\n \n next_layer.clear();\n \n for (int idx : current_layer) {\n Node u = all_nodes[idx];\n int er = u.empty_pos / N;\n int ec = u.empty_pos % N;\n \n // Collect all legal moves with priority\n pair moves[4];\n int move_count = 0;\n for (int k = 0; k < 4; ++k) {\n int nr = er + dr[k];\n int nc = ec + dc[k];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int quality = get_move_quality(u.board, er, ec, dr[k], dc[k], N);\n if (u.parent_idx != -1) {\n char prev = all_nodes[idx].move_char;\n if ((prev == 'U' && k == 1) ||\n (prev == 'D' && k == 0) ||\n (prev == 'L' && k == 3) ||\n (prev == 'R' && k == 2)) {\n quality = -1000;\n }\n }\n moves[move_count++] = make_pair(quality, k);\n }\n }\n // Sort moves manually (only 4 max)\n for (int i = 0; i < move_count - 1; i++) {\n for (int j = i + 1; j < move_count; j++) {\n if (moves[i] < moves[j]) swap(moves[i], moves[j]);\n }\n }\n \n for (int mi = 0; mi < move_count; mi++) {\n int k = moves[mi].second;\n int nr = er + dr[k];\n int nc = ec + dc[k];\n \n // Create new node\n int v_idx = (int)all_nodes.size();\n if (v_idx >= MAX_NODES) break;\n \n Node v;\n memcpy(v.board, u.board, sizeof(u.board));\n v.empty_pos = nr * N + nc;\n v.board[u.empty_pos] = u.board[v.empty_pos];\n v.board[v.empty_pos] = 0;\n v.parent_idx = idx;\n v.move_char = dir_char[k];\n v.path_len = u.path_len + 1;\n v.depth = u.depth + 1;\n v.score = get_tree_score(v.board, N);\n \n all_nodes.push_back(v);\n \n // Check if full tree found and track best path length\n if (v.score >= N * N - 1) {\n if (v.path_len < best_path_len) {\n best_path_len = v.path_len;\n best_path = reconstruct_path(v_idx);\n }\n // Continue searching for even shorter paths\n }\n next_layer.push_back(v_idx);\n }\n }\n \n if (next_layer.empty()) break;\n \n // Sort by: score (desc), path length (asc), depth (asc)\n sort(next_layer.begin(), next_layer.end(), [&](int a, int b) {\n if (all_nodes[a].score != all_nodes[b].score)\n return all_nodes[a].score > all_nodes[b].score;\n if (all_nodes[a].path_len != all_nodes[b].path_len)\n return all_nodes[a].path_len < all_nodes[b].path_len;\n return all_nodes[a].depth < all_nodes[b].depth;\n });\n \n current_layer.clear();\n int limit = min((int)next_layer.size(), beam_width);\n \n for (int i = 0; i < limit; ++i) {\n int node_idx = next_layer[i];\n current_layer.push_back(node_idx);\n \n if (all_nodes[node_idx].score > max_score) {\n max_score = all_nodes[node_idx].score;\n best_node_idx = node_idx;\n }\n }\n }\n \n // Output best result\n if (!best_path.empty()) {\n cout << best_path << endl;\n } else {\n cout << reconstruct_path(best_node_idx) << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Line structure\nstruct Line {\n double A, B, C;\n};\n\n// Global variables\nint N, K;\nvector a(11);\nvector> points;\nvector indices;\nvector sigs;\n\n// Fast signature computation\nint calculate_score(const Line* lines) {\n if (N == 0) return 0;\n \n // Compute signatures (using 11 bits for speed)\n for (int i = 0; i < N; ++i) {\n long long sig = 0;\n for (int k = 0; k < K && k < 11; ++k) {\n double val = lines[k].A * points[i].first + \n lines[k].B * points[i].second + \n lines[k].C;\n if (val >= 0.0) {\n sig |= (1LL << k);\n }\n }\n sigs[i] = sig;\n }\n\n // Initialize indices\n iota(indices.begin(), indices.end(), 0);\n \n // Fast sorting based on N\n if (N < 1000) {\n // Insertion sort for small arrays\n for (int i = 1; i < N; i++) {\n int key = indices[i];\n int j = i - 1;\n while (j >= 0 && sigs[indices[j]] > sigs[key]) {\n indices[j + 1] = indices[j];\n j--;\n }\n indices[j + 1] = key;\n }\n } else {\n // STL sort for large arrays\n sort(indices.begin(), indices.end(), [&](int a, int b) {\n return sigs[a] < sigs[b];\n });\n }\n\n // Count region sizes (no map, direct iteration)\n int cnt[11] = {0};\n int i = 0;\n while (i < N) {\n int j = i;\n long long cur_sig = sigs[indices[i]];\n while (j < N && sigs[indices[j]] == cur_sig) {\n j++;\n }\n int size = j - i;\n if (size >= 1 && size <= 10) {\n cnt[size]++;\n }\n i = j;\n }\n\n // Score calculation\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(cnt[d], a[d]);\n }\n return score;\n}\n\n// SA function with optimization\nint run_sa(int seed, const vector& init_lines, vector& best_lines, \n int& best_score, int sum_a) {\n mt19937 rng(seed);\n \n vector current_lines = init_lines;\n uniform_real_distribution angle_change_dist(-0.008, 0.008);\n uniform_real_distribution c_change_dist(-1.0, 1.0);\n uniform_real_distribution uniform_dist(0.0, 1.0);\n \n // Better temperature schedule - start higher, cool slower\n double T = 3000.0;\n double decay = 0.9994;\n \n // Variable iterations based on seed\n int num_iterations = 7500 + (seed & 1) * 500;\n int current_score = calculate_score(current_lines.data());\n int local_best_score = current_score;\n vector local_best = current_lines;\n \n // Early termination threshold\n int early_stop_threshold = (int)(sum_a * 0.95);\n \n for (int iter = 0; iter < num_iterations; ++iter) {\n int idx = rng() % K;\n\n Line old_line = current_lines[idx];\n\n // Perturb\n double phi = atan2(current_lines[idx].B, current_lines[idx].A);\n double angle_change = angle_change_dist(rng);\n current_lines[idx].A = cos(phi + angle_change);\n current_lines[idx].B = sin(phi + angle_change);\n\n double C_change = c_change_dist(rng);\n current_lines[idx].C += C_change;\n \n // Normalize for numerical stability\n double norm = sqrt(current_lines[idx].A * current_lines[idx].A + \n current_lines[idx].B * current_lines[idx].B);\n if (norm > 1e-10) {\n current_lines[idx].A /= norm;\n current_lines[idx].B /= norm;\n current_lines[idx].C /= norm;\n }\n\n int new_score = calculate_score(current_lines.data());\n\n // SA acceptance\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n double diff = (double)(new_score - current_score);\n if (diff < 0) {\n double prob = exp(diff / T);\n if (uniform_dist(rng) < prob) {\n accept = true;\n }\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > local_best_score) {\n local_best_score = current_score;\n local_best = current_lines;\n }\n // Update global best\n if (local_best_score > best_score) {\n best_score = local_best_score;\n best_lines = local_best;\n }\n // Early termination\n if (local_best_score >= early_stop_threshold) {\n break;\n }\n } else {\n current_lines[idx] = old_line;\n }\n\n // Adaptive temperature decay\n T *= decay;\n }\n \n return local_best_score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> K)) return 0;\n\n int sum_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n sum_a += a[i];\n }\n\n points.resize(N);\n indices.resize(N);\n sigs.resize(N);\n \n for (int i = 0; i < N; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n\n // Best lines storage\n vector best_lines(K);\n int best_score = 0;\n \n // RNG for base lines\n mt19937 rng(12345);\n uniform_real_distribution angle_dist(0, 2 * M_PI);\n uniform_real_distribution r_dist(-8000.0, 8000.0);\n \n // Initialize base lines\n vector init_lines(K);\n for (int i = 0; i < K; ++i) {\n double angle = angle_dist(rng);\n init_lines[i].A = cos(angle);\n init_lines[i].B = sin(angle);\n init_lines[i].C = -r_dist(rng);\n }\n\n // Run SA from different seeds (3 runs for exploration)\n int seeds[] = {10000, 20000, 30000};\n for (int run = 0; run < 3; ++run) {\n vector temp_lines = init_lines;\n \n // Small perturbation for each seed\n mt19937 run_rng(42 + seeds[run]);\n vector perturbed(K);\n for (int i = 0; i < K; ++i) {\n perturbed[i] = temp_lines[i];\n double angle = atan2(perturbed[i].B, perturbed[i].A);\n perturbed[i].A = cos(angle + uniform_real_distribution(-0.005, 0.005)(run_rng));\n perturbed[i].B = sin(perturbed[i].A == 0 ? M_PI/2 : atan2(perturbed[i].B, perturbed[i].A));\n perturbed[i].C += uniform_real_distribution(-2.0, 2.0)(run_rng);\n }\n\n run_sa(seeds[run], perturbed, best_lines, best_score, sum_a);\n \n // Early exit if perfect score\n if (best_score == sum_a) break;\n }\n\n // Output\n cout << K << \"\\n\";\n for (int k_idx = 0; k_idx < K; ++k_idx) {\n double A = best_lines[k_idx].A;\n double B = best_lines[k_idx].B;\n double C = best_lines[k_idx].C;\n\n long long x0 = (long long)round(-A * C);\n long long y0 = (long long)round(-B * C);\n\n long long px1 = x0;\n long long py1 = y0;\n long long px2 = x0 + (long long)round(-B * 2000);\n long long py2 = y0 + (long long)round(A * 2000);\n\n if (px1 == px2 && py1 == py2) {\n px2 = px1 + 1000;\n py2 = py1;\n }\n\n cout << px1 << \" \" << py1 << \" \" << px2 << \" \" << py2 << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAXN = 65;\nconst int INF = 1e9;\n\nint N, M;\nint c;\nlong long weight[MAXN][MAXN];\nbool has_dot[MAXN][MAXN];\n\nstruct DotCoord {\n int x, y;\n};\n\n// Nearest dot info\nDotCoord nearest_dot[MAXN][MAXN][8];\nint dist_dot[MAXN][MAXN][8];\n\n// Drawn edges stored at canonical position (minx, miny) of the segment\nbool drawn_edge_H[MAXN][MAXN]; // (x,y) to (x+1,y) - horizontal\nbool drawn_edge_V[MAXN][MAXN]; // (x,y) to (x,y+1) - vertical\nbool drawn_edge_D1[MAXN][MAXN]; // (x,y) to (x+1,y+1) - slope 1\nbool drawn_edge_D2[MAXN][MAXN]; // (x,y) to (x+1,y-1) - slope -1\n\n// Direction vectors: 0=R, 1=U, 2=L, 3=D, 4=UR, 5=UL, 6=DL, 7=DR\nconst int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};\nconst int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};\n\n// Check if segment has any dots strictly inside\nbool has_dots_on_segment(const DotCoord& a, const DotCoord& b) {\n int dx_step = (b.x != a.x) ? (b.x > a.x ? 1 : -1) : 0;\n int dy_step = (b.y != a.y) ? (b.y > a.y ? 1 : -1) : 0;\n \n for (int cx = a.x + dx_step, cy = a.y + dy_step; \n cx != b.x || cy != b.y; \n cx += dx_step, cy += dy_step) {\n if (cx >= 0 && cx < N && cy >= 0 && cy < N && has_dot[cx][cy]) return true;\n }\n return false;\n}\n\n// Check if segment overlaps with any drawn edge\n// FIXED: Start loop from a, consistent with mark_edge\nbool overlaps_with_edge(const DotCoord& a, const DotCoord& b) {\n if (a.x == b.x) { // Vertical edge\n int x = a.x;\n int y_min = min(a.y, b.y);\n int y_max = max(a.y, b.y);\n if (x < 0 || x >= N) return false;\n for (int y = y_min; y < y_max && y >= 0 && y < N; ++y) {\n if (drawn_edge_V[x][y]) return true;\n }\n } else if (a.y == b.y) { // Horizontal edge\n int y = a.y;\n int x_min = min(a.x, b.x);\n int x_max = max(a.x, b.x);\n if (y < 0 || y >= N) return false;\n for (int x = x_min; x < x_max && x >= 0 && x < N; ++x) {\n if (drawn_edge_H[x][y]) return true;\n }\n } else { // Diagonal edge - FIXED to start from a\n int dx_sign = (b.x > a.x) ? 1 : -1;\n int dy_sign = (b.y > a.y) ? 1 : -1;\n int steps = abs(b.x - a.x);\n \n int cx = a.x;\n int cy = a.y;\n \n for (int s = 0; s < steps; ++s) {\n // Segment from (cx, cy) to (cx+dx_sign, cy+dy_sign)\n int minsx = min(cx, cx + dx_sign);\n int minsy = min(cy, cy + dy_sign);\n \n if (minsx < 0 || minsx + 1 >= N || minsy < 0 || minsy + 1 >= N) {\n cx += dx_sign;\n cy += dy_sign;\n continue;\n }\n \n if (dx_sign == dy_sign) { // Slope 1\n if (drawn_edge_D1[minsx][minsy]) return true;\n } else { // Slope -1\n if (drawn_edge_D2[minsx][minsy]) return true;\n }\n cx += dx_sign;\n cy += dy_sign;\n }\n }\n return false;\n}\n\n// Mark edges as drawn - MUST match overlaps_with_edge exactly\nvoid mark_edge(const DotCoord& a, const DotCoord& b) {\n if (a.x == b.x) { // Vertical\n int x = a.x;\n int y_min = min(a.y, b.y);\n if (x < 0 || x >= N) return;\n for (int y = y_min; y < max(a.y, b.y) && y >= 0 && y < N; ++y) {\n drawn_edge_V[x][y] = true;\n }\n } else if (a.y == b.y) { // Horizontal\n int y = a.y;\n int x_min = min(a.x, b.x);\n if (y < 0 || y >= N) return;\n for (int x = x_min; x < max(a.x, b.x) && x >= 0 && x < N; ++x) {\n drawn_edge_H[x][y] = true;\n }\n } else { // Diagonal - FIXED to start from a\n int dx_sign = (b.x > a.x) ? 1 : -1;\n int dy_sign = (b.y > a.y) ? 1 : -1;\n int steps = abs(b.x - a.x);\n \n int cx = a.x;\n int cy = a.y;\n \n for (int s = 0; s < steps; ++s) {\n // Segment from (cx, cy) to (cx+dx_sign, cy+dy_sign)\n int minsx = min(cx, cx + dx_sign);\n int minsy = min(cy, cy + dy_sign);\n \n if (minsx >= 0 && minsx + 1 < N && minsy >= 0 && minsy + 1 < N) {\n if (dx_sign == dy_sign) { // Slope 1\n drawn_edge_D1[minsx][minsy] = true;\n } else { // Slope -1\n drawn_edge_D2[minsx][minsy] = true;\n }\n }\n cx += dx_sign;\n cy += dy_sign;\n }\n }\n}\n\n// Check visibility: can P be seen from Q in direction d?\nbool can_see(int qx, int qy, int px, int py, int dir) {\n int cx = qx + dx[dir];\n int cy = qy + dy[dir];\n while (cx != px || cy != py) {\n if (cx < 0 || cx >= N || cy < 0 || cy >= N) return false;\n if (has_dot[cx][cy]) return false;\n cx += dx[dir];\n cy += dy[dir];\n }\n return true;\n}\n\nstruct Operation {\n int x1, y1, x2, y2, x3, y3, x4, y4;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (!(cin >> N >> M)) return 0;\n c = (N - 1) / 2;\n\n // Initialize\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n weight[i][j] = ((long long)i - c) * ((long long)i - c) + \n ((long long)j - c) * ((long long)j - c) + 1;\n has_dot[i][j] = false;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n has_dot[x][y] = true;\n }\n\n // Clear edge arrays\n memset(drawn_edge_H, 0, sizeof(drawn_edge_H));\n memset(drawn_edge_V, 0, sizeof(drawn_edge_V));\n memset(drawn_edge_D1, 0, sizeof(drawn_edge_D1));\n memset(drawn_edge_D2, 0, sizeof(drawn_edge_D2));\n\n // Initialize nearest_dot with INF\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n for (int d = 0; d < 8; ++d) {\n nearest_dot[x][y][d] = {-1, -1};\n dist_dot[x][y][d] = INF;\n }\n }\n }\n\n // Fill nearest_dot for initial dots\n for (int d = 0; d < 8; ++d) {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int k = 1; k <= N; ++k) {\n int nx = i + k * dx[d];\n int ny = j + k * dy[d];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) break;\n if (has_dot[nx][ny]) {\n nearest_dot[i][j][d] = {nx, ny};\n dist_dot[i][j][d] = k;\n break;\n }\n }\n }\n }\n }\n\n // Get empty points sorted by weight (descending)\n vector> candidates;\n candidates.reserve(N * N);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (!has_dot[i][j]) {\n candidates.push_back({weight[i][j], i * N + j});\n }\n }\n }\n sort(candidates.rbegin(), candidates.rend());\n\n vector ops;\n bool found_op = true;\n\n while (found_op) {\n found_op = false;\n int best_idx = -1;\n int best_d1 = -1, best_d2 = -1;\n long long best_w = -1;\n\n for (const auto& cand : candidates) {\n int idx = cand.second;\n int x = idx / N;\n int y = idx % N;\n if (has_dot[x][y]) continue;\n\n // Try all 8 orthogonal direction pairs\n int pairs[8][2] = {\n {0, 1}, {1, 2}, {2, 3}, {3, 0}, // Axis-parallel\n {4, 5}, {5, 6}, {6, 7}, {7, 4} // 45-degree\n };\n\n for (auto& p : pairs) {\n int d1 = p[0], d2 = p[1];\n\n DotCoord p2 = nearest_dot[x][y][d1];\n DotCoord p4 = nearest_dot[x][y][d2];\n\n if (p2.x == -1 || p4.x == -1) continue;\n\n // Calculate rectangle corner p3\n DotCoord p3 = {p2.x + p4.x - x, p2.y + p4.y - y};\n\n // Check p3 validity\n if (p3.x < 0 || p3.x >= N || p3.y < 0 || p3.y >= N) continue;\n if (!has_dot[p3.x][p3.y]) continue;\n\n // Check all 4 perimeter segments for dots (strictly inside)\n if (has_dots_on_segment({x, y}, p2)) continue;\n if (has_dots_on_segment(p2, p3)) continue;\n if (has_dots_on_segment(p3, p4)) continue;\n if (has_dots_on_segment(p4, {x, y})) continue;\n\n // Check all 4 perimeter segments for edge overlaps\n if (overlaps_with_edge({x, y}, p2)) continue;\n if (overlaps_with_edge(p2, p3)) continue;\n if (overlaps_with_edge(p3, p4)) continue;\n if (overlaps_with_edge(p4, {x, y})) continue;\n\n // Found valid operation\n if (weight[x][y] > best_w) {\n best_w = weight[x][y];\n best_idx = x * N + y;\n best_d1 = d1;\n best_d2 = d2;\n }\n }\n }\n\n if (best_idx != -1) {\n found_op = true;\n int x = best_idx / N;\n int y = best_idx % N;\n int d1 = best_d1;\n int d2 = best_d2;\n\n DotCoord p1 = {x, y};\n DotCoord p2 = nearest_dot[x][y][d1];\n DotCoord p4 = nearest_dot[x][y][d2];\n DotCoord p3 = {p2.x + p4.x - x, p2.y + p4.y - y};\n\n has_dot[x][y] = true;\n ops.push_back({x, y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y});\n\n // Mark edges\n mark_edge(p1, p2);\n mark_edge(p2, p3);\n mark_edge(p3, p4);\n mark_edge(p4, p1);\n\n // Update nearest_dot for all points\n for (int d = 0; d < 8; ++d) {\n int opp = d ^ 4; // Opposite direction\n \n int k = 1;\n while (true) {\n int qx = x + k * dx[opp];\n int qy = y + k * dy[opp];\n if (qx < 0 || qx >= N || qy < 0 || qy >= N) break;\n\n if (can_see(qx, qy, x, y, d)) {\n if (dist_dot[qx][qy][d] == INF || k < dist_dot[qx][qy][d]) {\n nearest_dot[qx][qy][d] = {x, y};\n dist_dot[qx][qy][d] = k;\n }\n }\n k++;\n }\n }\n }\n }\n\n // Output results\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \"\n << op.x2 << \" \" << op.y2 << \" \"\n << op.x3 << \" \" << op.y3 << \" \"\n << op.x4 << \" \" << op.y4 << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\nint grid[N][N];\nint flavors[100];\n\n// Calculate score for a given grid configuration\nint calculate_score(int arr[N][N]) {\n int score = 0;\n bool visited[N][N];\n memset(visited, 0, sizeof(visited));\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (arr[r][c] != 0 && !visited[r][c]) {\n int current_flavor = arr[r][c];\n int count = 0;\n \n // BFS for connected component\n int q_r[N*N], q_c[N*N]; \n int head = 0, tail = 0;\n \n q_r[tail] = r; q_c[tail] = c;\n visited[r][c] = true;\n tail++;\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n \n while(head < tail) {\n int cr = q_r[head];\n int cc = q_c[head];\n head++;\n count++;\n \n for(int k = 0; k < 4; ++k) {\n int nr = cr + dr[k];\n int nc = cc + dc[k];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if(!visited[nr][nc] && arr[nr][nc] == current_flavor) {\n visited[nr][nc] = true;\n q_r[tail] = nr;\n q_c[tail] = nc;\n tail++;\n }\n }\n }\n }\n score += count * count;\n }\n }\n }\n return score;\n}\n\n// Apply a tilt move to a grid\nvoid apply_move(int grid_arr[N][N], char dir) {\n int next_grid[N][N];\n memset(next_grid, 0, sizeof(next_grid));\n \n if (dir == 'F') { // Forward -> Top (Up)\n for (int c = 0; c < N; ++c) {\n int write_idx = 0;\n for (int r = 0; r < N; ++r) {\n if (grid_arr[r][c] != 0) {\n next_grid[write_idx][c] = grid_arr[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'B') { // Backward -> Bottom (Down)\n for (int c = 0; c < N; ++c) {\n int write_idx = N - 1;\n for (int r = N - 1; r >= 0; --r) {\n if (grid_arr[r][c] != 0) {\n next_grid[write_idx][c] = grid_arr[r][c];\n write_idx--;\n }\n }\n }\n } else if (dir == 'L') { // Left -> Left edge\n for (int r = 0; r < N; ++r) {\n int write_idx = 0;\n for (int c = 0; c < N; ++c) {\n if (grid_arr[r][c] != 0) {\n next_grid[r][write_idx] = grid_arr[r][c];\n write_idx++;\n }\n }\n }\n } else if (dir == 'R') { // Right -> Right edge\n for (int r = 0; r < N; ++r) {\n int write_idx = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid_arr[r][c] != 0) {\n next_grid[r][write_idx] = grid_arr[r][c];\n write_idx--;\n }\n }\n }\n }\n \n memcpy(grid_arr, next_grid, sizeof(int) * N * N);\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Seed random with high resolution clock\n mt19937 gen((unsigned int)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n // Read flavor sequence\n for (int t = 0; t < 100; ++t) {\n cin >> flavors[t];\n }\n\n // Main interaction loop\n for (int t = 0; t < 100; ++t) {\n int p;\n cin >> p;\n \n // Find the p-th empty cell in reading order\n int count = 0;\n bool found = false;\n int r_target = 0, c_target = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] == 0) {\n count++;\n if (count == p) {\n r_target = i;\n c_target = j;\n found = true;\n break;\n }\n }\n }\n if (found) break;\n }\n \n // Place the candy\n if (found) {\n grid[r_target][c_target] = flavors[t];\n }\n\n // Determine tilt direction (skip output for 100th step)\n if (t < 99) {\n char best_move = 'F';\n int best_score = -1;\n \n char moves[] = {'F', 'B', 'L', 'R'};\n \n // Randomize order for tie-breaking fairness\n vector idx(4);\n for(int i = 0; i < 4; ++i) idx[i] = i;\n shuffle(idx.begin(), idx.end(), gen);\n\n for (auto i : idx) {\n char dir = moves[i];\n \n // Simulate the move on a copy of the grid\n int sim_grid[N][N];\n memcpy(sim_grid, grid, sizeof(sim_grid));\n \n // Apply move to simulation copy\n apply_move(sim_grid, dir);\n \n // Calculate score for this move\n int score = calculate_score(sim_grid);\n \n // Pure greedy selection: maximize score\n if (best_score == -1 || score > best_score) {\n best_score = score;\n best_move = dir;\n }\n }\n \n cout << best_move << endl;\n \n // Apply the selected move to the real grid\n apply_move(grid, best_move);\n }\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n\nclass Graph {\npublic:\n int n;\n std::vector> adj;\n \n Graph(int n = 0) : n(n) {\n if (n > 0) adj.resize(n, std::vector(n, 0));\n }\n \n static Graph parse(const std::string& s, int n) {\n Graph G(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n G.adj[i][j] = G.adj[j][i] = s[idx] - '0';\n idx++;\n }\n }\n return G;\n }\n \n std::string encode() const {\n std::string s;\n s.reserve(n * (n - 1) / 2);\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n s.push_back(adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n int countEdges() const {\n int cnt = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n cnt += adj[i][j];\n }\n }\n return cnt;\n }\n \n int getDegree(int i) const {\n int d = 0;\n for (int j = 0; j < n; j++) {\n if (i != j && adj[i][j]) d++;\n }\n return d;\n }\n};\n\nint computeMatchScore(const Graph& H, const Graph& G) {\n int n = H.n;\n std::vector h_order(n), g_order(n);\n \n // Sort by degree descending\n std::vector> h_deg, g_deg;\n for (int i = 0; i < n; i++) {\n h_deg.emplace_back(-H.getDegree(i), i);\n g_deg.emplace_back(-G.getDegree(i), i);\n }\n std::sort(h_deg.begin(), h_deg.end());\n std::sort(g_deg.begin(), g_deg.end());\n \n // Create order arrays\n for (int i = 0; i < n; i++) {\n h_order[i] = h_deg[i].second;\n g_order[i] = g_deg[i].second;\n }\n \n // Count matching edges using this mapping\n int matched = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (H.adj[i][j] == G.adj[h_order[i]][h_order[j]]) {\n matched++;\n }\n }\n }\n \n return matched;\n}\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int M;\n double epsilon;\n if (!(std::cin >> M >> epsilon)) return 0;\n \n // N = 35 is optimal for most cases\n int N = 35;\n std::vector graphs(M, Graph(N));\n int total_edges = N * (N - 1) / 2;\n \n // Create graphs with different edge counts for easy filtering\n for (int k = 0; k < M; k++) {\n int target = k * total_edges / M + (k % 5) - 2;\n target = std::max(0, std::min(total_edges, target));\n \n int added = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (added < target) {\n graphs[k].adj[i][j] = graphs[k].adj[j][i] = 1;\n added++;\n }\n }\n }\n }\n \n // Output graphs\n std::cout << N << \"\\n\";\n std::cout.flush();\n for (int k = 0; k < M; k++) {\n std::cout << graphs[k].encode() << \"\\n\";\n std::cout.flush();\n }\n \n // Process 100 queries\n for (int q = 0; q < 100; q++) {\n std::string S;\n std::cin >> S;\n \n Graph H = Graph::parse(S, N);\n int H_edges = H.countEdges();\n \n int best_k = 0;\n int best_score = -1000000000;\n \n for (int k = 0; k < M; k++) {\n int G_edges = graphs[k].countEdges();\n int edge_diff = std::abs(H_edges - G_edges);\n \n // Simple threshold based on noise level\n int threshold = (int)(N * epsilon * 3.0) + 4;\n if (edge_diff > threshold) continue;\n \n int matched = computeMatchScore(H, graphs[k]);\n int score = matched;\n \n if (score > best_score) {\n best_score = score;\n best_k = k;\n }\n }\n \n std::cout << best_k << \"\\n\";\n std::cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1000000000;\n\nstruct Edge {\n int u, v, w, id;\n};\n\nint main() {\n ios_base::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 vector> adj(N + 1);\n \n for (int i = 0; i < M; i++) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].id = i;\n adj[edges[i].u].push_back(i);\n adj[edges[i].v].push_back(i);\n }\n \n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n \n // All-pairs shortest paths computation\n vector> allPairsDist(N + 1, vector(N + 1, INF));\n \n for (int i = 1; i <= N; i++) {\n priority_queue, vector>, greater>> pq;\n pq.push({0, i});\n allPairsDist[i][i] = 0;\n \n while (!pq.empty()) {\n int d = pq.top().first;\n int u = pq.top().second;\n pq.pop();\n \n if (d > allPairsDist[i][u]) continue;\n \n for (int edgeIdx : adj[u]) {\n int v = (edges[edgeIdx].u == u) ? edges[edgeIdx].v : edges[edgeIdx].u;\n int w = edges[edgeIdx].w;\n \n if (d + w < allPairsDist[i][v]) {\n allPairsDist[i][v] = d + w;\n pq.push({allPairsDist[i][v], v});\n }\n }\n }\n }\n \n // Calculate edge contribution score\n vector edgeScore(M, 0);\n for (int i = 0; i < M; i++) {\n double weightScore = (double)edges[i].w / 1e6;\n double degreeScore = (double)(adj[edges[i].u].size() + adj[edges[i].v].size() - 2) / 10;\n edgeScore[i] = weightScore - degreeScore;\n }\n \n // Sort edges by score (ascending: lower score = more critical, should be preserved longer)\n vector edgeOrder(M);\n for (int i = 0; i < M; i++) edgeOrder[i] = i;\n \n sort(edgeOrder.begin(), edgeOrder.end(), [&](int a, int b) {\n return edgeScore[a] < edgeScore[b];\n });\n \n // Initialize assignments\n vector assignments(M, 1);\n vector dayCounts(D + 1, 0);\n \n // Assign edges to days based on sorted order\n for (int i = 0; i < M; i++) {\n int edgeIdx = edgeOrder[i];\n int day = (i % D) + 1;\n assignments[edgeIdx] = day;\n dayCounts[day]++;\n }\n \n // Multi-phase optimization\n auto start = chrono::steady_clock::now();\n vector rngState = {42, 123, 456};\n \n for (int phase = 0; phase < 3; phase++) {\n for (int iter = 0; iter < 100000; iter++) {\n int ms = chrono::duration_cast(\n chrono::steady_clock::now() - start).count();\n if (ms > 17000) break;\n \n int edgeIdx = (rngState[iter % 3] + iter) % M;\n int fromDay = assignments[edgeIdx];\n \n vector candidates;\n for (int d = 1; d <= D; d++) {\n if (d != fromDay && dayCounts[d] < K) {\n candidates.push_back(d);\n }\n }\n \n if (candidates.empty()) continue;\n \n // Choose best improvement\n int bestDay = candidates[0];\n for (int d : candidates) {\n if (dayCounts[d] < dayCounts[bestDay]) {\n bestDay = d;\n }\n }\n \n if (bestDay != fromDay) {\n dayCounts[fromDay]--;\n dayCounts[bestDay]++;\n assignments[edgeIdx] = bestDay;\n }\n }\n }\n \n // Final validation\n for (int i = 0; i < M; i++) {\n if (assignments[i] < 1 || assignments[i] > D) {\n assignments[i] = (i % D) + 1;\n }\n }\n \n // Output results\n for (int i = 0; i < M; i++) {\n cout << assignments[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to hold a point in 3D space\nstruct Point3D {\n int x, y, z;\n bool operator<(const Point3D& o) const {\n if (x != o.x) return x < o.x;\n if (y != o.y) return y < o.y;\n return z < o.z;\n }\n bool operator==(const Point3D& o) const {\n return x == o.x && y == o.y && z == o.z;\n }\n};\n\n// Structure to hold rotation matrices\nstruct RotMat {\n int p[3]; // permutation of axes\n int s[3]; // signs for each axis\n};\n\nint D;\nchar f1[15][15], r1[15][15], f2[15][15], r2[15][15];\nint g1[15][15][15], g2[15][15][15];\nint g_common[15][15][15];\nint b1[15][15][15], b2[15][15][15];\nvector common_ccs;\nvector> rem1_c;\nvector> rem2_c;\nvector rotations;\n\nint parity(const vector& p) {\n int c = 0;\n for(int i=0; i<3; ++i) \n for(int j=i+1; j<3; ++j) \n if(p[i] > p[j]) c++;\n return c;\n}\n\nvoid init_rotations() {\n int p[] = {0, 1, 2};\n do {\n vector v_p(p, p+3);\n if (parity(v_p) % 2 == 0) {\n int signs[4][3] = {{1,1,1}, {1,-1,-1}, {-1,1,-1}, {-1,-1,1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n } else {\n int signs[4][3] = {{1,1,-1}, {1,-1,1}, {-1,1,1}, {-1,-1,-1}};\n for(int k=0; k<4; ++k) {\n RotMat r;\n for(int i=0; i<3; ++i) r.p[i] = p[i];\n for(int i=0; i<3; ++i) r.s[i] = signs[k][i];\n rotations.push_back(r);\n }\n }\n } while (next_permutation(p, p+3));\n}\n\nPoint3D transform(const Point3D& src, const RotMat& r) {\n int vals[3] = {src.x, src.y, src.z};\n return {vals[r.p[0]] * r.s[0], vals[r.p[1]] * r.s[1], vals[r.p[2]] * r.s[2]};\n}\n\n// Generate the canonical representation of a shape by trying all rotations\nvector get_canonical_shape(const vector& pts) {\n if (pts.empty()) return {};\n \n vector best;\n bool first = true;\n \n for(const auto& r : rotations) {\n vector current;\n current.reserve(pts.size());\n for(const auto& p : pts) {\n current.push_back(transform(p, r));\n }\n \n int cminx=1000, cminy=1000, cminz=1000;\n for(const auto& p : current) {\n cminx = min(cminx, p.x);\n cminy = min(cminy, p.y);\n cminz = min(cminz, p.z);\n }\n \n sort(current.begin(), current.end());\n for(auto& p : current) {\n p.x -= cminx; p.y -= cminy; p.z -= cminz;\n }\n \n if (first || current < best) {\n best = current;\n first = false;\n }\n }\n return best;\n}\n\nvoid bfs(int grid[15][15][15], vector>& components) {\n for(int x=0; x pts;\n queue, int>> q;\n q.push({{x, y}, z});\n grid[x][y][z] = 0;\n pts.push_back({x,y,z});\n \n while(!q.empty()){\n auto curr = q.front(); q.pop();\n int cx = curr.first.first, cy = curr.first.second, cz = curr.second;\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 for(int i=0; i<6; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n int nz = cz + dz[i];\n if(nx >= 0 && nx < D && ny >= 0 && ny < D && nz >= 0 && nz < D && grid[nx][ny][nz] == 1) {\n grid[nx][ny][nz] = 0;\n q.push({{nx, ny}, nz});\n pts.push_back({nx, ny, nz});\n }\n }\n }\n components.push_back(pts);\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_rotations();\n \n if (!(cin >> D)) return 0;\n \n string s;\n // Read f1\n for(int z=0; z> s; for(int x=0;x> s; for(int y=0;y> s; for(int x=0;x> s; for(int y=0;y, vector> rem2_map;\n for(size_t i=0; i shape = rem2_c[i];\n vector key = get_canonical_shape(shape);\n rem2_map[key].push_back(i);\n }\n \n vector rem1_block_id(rem1_c.size(), 0);\n vector rem2_block_id(rem2_c.size(), 0);\n \n int common_count = common_ccs.size();\n int current_id = common_count + 1;\n \n // Fill Common Blocks with IDs 1 to common_count\n for(size_t i=0; i shape = rem1_c[i];\n vector key = get_canonical_shape(shape);\n \n if (rem2_map.count(key) && !rem2_map[key].empty()) {\n int j = rem2_map[key].back();\n rem2_map[key].pop_back();\n \n rem1_block_id[i] = current_id;\n rem2_block_id[j] = current_id;\n int bid = current_id;\n for(auto& p : rem1_c[i]) b1[p.x][p.y][p.z] = bid;\n for(auto& p : rem2_c[j]) b2[p.x][p.y][p.z] = bid;\n current_id++;\n } else {\n rem1_block_id[i] = current_id;\n current_id++;\n }\n }\n \n // Fill Unique Rem1 components\n for(size_t i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Data structures\nstruct Point {\n long long x, y;\n};\n\nstruct Edge {\n int u, v, w;\n int id; // 0-based index for B output\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nint N, M, K;\nvector nodes;\nvector residents;\nvector all_edges;\n\n// Global for calculation\nvector MST_parent;\nvector MST_weight;\nvector edge_to_parent_id;\nvector bfs_order; // Stores indices in BFS order starting from root (0)\nvector active;\nvector> residents_for; // residents assigned to node u\nvector resident_location; // resident_location[k] = u\n\nvector> dist_sq; // N x K\nvector P;\nvector B; // Output for edges\n\n// Helper to compute distance squared\nlong long dist_sq_func(Point p1, Point p2) {\n return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);\n}\n\n// Calculate smallest integer k such that k*k >= d2\nlong long get_ceil_sqrt_safe(long long d2) {\n if (d2 <= 0) return 0;\n long long r = round(sqrt(d2));\n if (r * r < d2) r++;\n return r;\n}\n\nvoid calculate_P_and_active() {\n P.assign(N, 0);\n active.assign(N, false);\n for (int u = 0; u < N; ++u) {\n long long mx = 0;\n if (!residents_for[u].empty()) {\n for (int k_idx : residents_for[u]) {\n mx = max(mx, get_ceil_sqrt_safe(dist_sq[u][k_idx]));\n }\n }\n P[u] = mx;\n if (mx > 0) active[u] = true;\n }\n}\n\n// Calculate MST cost: sum of weights of edges connecting active nodes to 1\nlong long calc_mst_cost() {\n long long cost = 0;\n vector needed(N, false);\n for(int i=0; i 0; --i) {\n int v = bfs_order[i];\n if (needed[v]) {\n int p = MST_parent[v];\n if (p != -1) {\n needed[p] = true;\n cost += MST_weight[v];\n }\n }\n }\n return cost;\n}\n\n// Calculate total cost\nlong long calculate_total_cost() {\n long long node_cost = 0;\n for (int u = 0; u < N; ++u) {\n node_cost += P[u] * P[u];\n }\n return node_cost + calc_mst_cost();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> K)) return 0;\n\n nodes.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> nodes[i].x >> nodes[i].y;\n }\n \n all_edges.resize(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n --u; --v; // 0-based\n all_edges[i] = {u, v, w, i};\n }\n \n residents.resize(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].x >> residents[i].y;\n }\n \n // Precompute distances\n dist_sq.assign(N, vector(K));\n for(int u=0; u dsu(N);\n iota(dsu.begin(), dsu.end(), 0);\n function find = [&](int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); };\n auto unite = [&](int x, int y) { x = find(x); y = find(y); if (x != y) { dsu[x] = y; return true; } return false; };\n \n vector mst_edges;\n for (auto& e : all_edges) {\n if (unite(e.u, e.v)) {\n mst_edges.push_back(e);\n }\n }\n \n // Build MST Adjacency\n // BFS root is 0 (Node 1)\n vector>> mst_adj(N);\n for (const auto& e : mst_edges) {\n mst_adj[e.u].push_back({e.v, e.w});\n mst_adj[e.v].push_back({e.u, e.w});\n }\n \n MST_parent.assign(N, -1);\n MST_weight.assign(N, 0);\n edge_to_parent_id.assign(N, -1);\n bfs_order.clear();\n bfs_order.reserve(N);\n \n queue q;\n vector visited(N, false);\n q.push(0);\n visited[0] = true;\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n bfs_order.push_back(u);\n \n for(auto& neighbor : mst_adj[u]){\n int v = neighbor.first;\n int w = neighbor.second;\n if(!visited[v]){\n visited[v] = true;\n MST_parent[v] = u;\n MST_weight[v] = w;\n q.push(v);\n }\n }\n }\n \n // Re-traverse to find edge IDs for parent edges\n for(int u=0; u());\n resident_location.assign(K, -1);\n for(int k=0; k& old_list = residents_for[u_old];\n for(auto it = old_list.begin(); it != old_list.end(); ++it){\n if(*it == k) {\n old_list.erase(it);\n break;\n }\n }\n \n // Add to best_u\n residents_for[best_u].push_back(k);\n \n // Check if valid and better\n calculate_P_and_active();\n long long new_cost = calculate_total_cost();\n \n // Greedy acceptance\n if (new_cost <= current_cost) {\n current_cost = new_cost;\n resident_location[k] = best_u;\n } else {\n // Revert\n vector& new_list = residents_for[best_u];\n for(auto it = new_list.begin(); it != new_list.end(); ++it){\n if(*it == k) {\n new_list.erase(it);\n break;\n }\n }\n residents_for[u_old].push_back(k);\n resident_location[k] = u_old;\n calculate_P_and_active();\n }\n }\n }\n \n // Finalize\n calculate_P_and_active();\n \n // Output P\n for(int i=0; i needed(N, false);\n \n // Initialize needed based on active nodes (P > 0)\n for(int u=0; u order = bfs_order;\n \n for (int i = N - 1; i > 0; --i) {\n int v = order[i];\n if (needed[v]) {\n int p = MST_parent[v];\n if (p != -1) {\n needed[p] = true;\n if (edge_to_parent_id[v] != -1) {\n B[edge_to_parent_id[v]] = 1;\n }\n }\n }\n }\n \n // Print B\n for(int i=0; i\n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Edge {\n int x1, y1, x2, y2;\n};\n\nstruct Op {\n int x1, y1, x2, y2;\n};\n\nint grid[30][30];\nvector all_edges;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Precompute all valid vertical edges\n for (int x = 0; x < 29; ++x) {\n for (int y = 0; y <= x; ++y) {\n all_edges.push_back({x, y, x + 1, y});\n all_edges.push_back({x, y, x + 1, y + 1});\n }\n }\n\n // Read input pyramid\n for (int x = 0; x < 30; ++x) {\n for (int y = 0; y <= x; ++y) {\n cin >> grid[x][y];\n }\n }\n\n vector ops;\n static mt19937 rng(42); // Consistent seed\n\n // Initial shuffle and sort pass\n while (ops.size() < 10000) {\n // Shuffle edges to enable bidirectional bubble movement\n shuffle(all_edges.begin(), all_edges.end(), rng);\n \n bool fixed = false;\n int inversions = 0;\n \n // Process all edges\n for (const auto& e : all_edges) {\n const int& top = grid[e.x1][e.y1];\n const int& bottom = grid[e.x2][e.y2];\n \n // Count inversions and fix them\n if (top > bottom) {\n swap(grid[e.x1][e.y1], grid[e.x2][e.y2]);\n ops.push_back({e.x1, e.y1, e.x2, e.y2});\n fixed = true;\n }\n if (top > bottom) {\n inversions++;\n }\n }\n \n // Early termination if no changes\n if (!fixed) break;\n }\n\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: up, down, left, right\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\n\nstruct Pos {\n int r, c;\n bool operator<(const Pos& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n bool operator==(const Pos& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nclass Warehouse {\nprivate:\n int D;\n int N;\n vector> grid; // true = obstacle or occupied\n vector container_positions;\n vector priority_at_pos; // priority of container at each position\n vector possible_positions;\n vector possible_distances;\n \n // BFS to find reachable positions and their distances from entrance\n vector> reachable_positions() {\n vector> reachable;\n queue> q;\n vector> visited(D, vector(D, false));\n \n Pos start = {0, (D-1)/2};\n if (grid[start.r][start.c]) return reachable;\n \n q.push({start, 0});\n visited[start.r][start.c] = true;\n \n while (!q.empty()) {\n auto [pos, dist] = q.front();\n q.pop();\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D &&\n !visited[pos.r][pos.c] && !grid[pos.r][pos.c]) {\n reachable.push_back({pos, dist});\n visited[pos.r][pos.c] = true;\n \n for (int i = 0; i < 4; i++) {\n int nr = pos.r + dr[i];\n int nc = pos.c + dc[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && \n !grid[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({{nr, nc}, dist + 1});\n }\n }\n }\n }\n return reachable;\n }\n \n // Calculate distance from entrance for a position\n int distance_from_entrance(Pos pos) {\n int r = pos.r;\n int c = pos.c;\n int entrance_r = 0;\n int entrance_c = (D-1)/2;\n return abs(r - entrance_r) + abs(c - entrance_c);\n }\n \npublic:\n Warehouse(int D, int N, const vector& obstacles) \n : D(D), N(N), grid(D, vector(D, false)), \n container_positions((D*D - N - 1), {-1, -1}),\n priority_at_pos(D*D, -1) {\n \n // Mark obstacle positions\n for (const auto& obs : obstacles) {\n grid[obs.r][obs.c] = true;\n }\n \n // Mark entrance as blocked for storage\n grid[0][(D-1)/2] = true;\n \n // Pre-compute all possible storage positions sorted by distance\n set all_possible;\n for (int r = 0; r < D; r++) {\n for (int c = 0; c < D; c++) {\n if (!grid[r][c]) {\n all_possible.insert({r, c});\n }\n }\n }\n \n vector> sorted_positions;\n for (const auto& pos : all_possible) {\n sorted_positions.push_back({distance_from_entrance(pos), pos});\n }\n sort(sorted_positions.begin(), sorted_positions.end());\n \n for (const auto& item : sorted_positions) {\n possible_positions.push_back(item.second);\n possible_distances.push_back(item.first);\n }\n }\n \n // Find the best position for a container with given priority\n Pos find_placement() {\n vector> reachable = reachable_positions();\n \n if (reachable.empty()) {\n return {-1, -1}; // No valid position\n }\n \n // Heuristic: balance between distance from entrance and priority\n // Lower priority numbers should be closer for easier retrieval\n // Sort reachable positions by distance\n sort(reachable.begin(), reachable.end(),\n [](const pair& a, const pair& b) {\n return a.second < b.second;\n });\n \n // Choose position that allows future flexibility\n // Prefer positions that are not too deep in the warehouse\n for (const auto& [pos, dist] : reachable) {\n // Verify this position can be uniquely reached (not blocked)\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n return pos;\n }\n }\n \n // Fallback: return the most accessible position\n return reachable[0].first;\n }\n \n bool mark_occupied(Pos pos, int priority) {\n if (pos.r < 0 || pos.r >= D || pos.c < 0 || pos.c >= D) {\n return false;\n }\n if (grid[pos.r][pos.c]) {\n return false;\n }\n grid[pos.r][pos.c] = true; // Mark as occupied\n return true;\n }\n \n void free_position(Pos pos) {\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n grid[pos.r][pos.c] = false; // Mark as empty\n }\n }\n \n int total_containers() const {\n return container_positions.size();\n }\n \n const Pos& get_container_pos(int priority) const {\n if (priority >= 0 && priority < total_containers()) {\n return container_positions[priority];\n }\n return container_positions[0];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D, N;\n cin >> D >> N;\n \n vector obstacles;\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n obstacles.push_back({r, c});\n }\n \n Warehouse warehouse(D, N, obstacles);\n int total_containers = warehouse.total_containers();\n \n vector> placements(total_containers);\n \n // Place each container as it arrives\n for (int d = 0; d < total_containers; d++) {\n int priority;\n cin >> priority;\n \n Pos pos = warehouse.find_placement();\n \n while (pos.r == -1) { // Retry if no valid position\n int d2 = warehouse.total_containers();\n // This shouldn't happen with proper logic\n break;\n }\n \n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n warehouse.mark_occupied(pos, priority);\n placements[priority] = {priority, pos};\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n }\n }\n \n // Output transport order: in priority order (0, 1, 2, ...)\n // We simply output containers in their assigned priority order\n for (int p = 0; p < total_containers; p++) {\n if (placements[p].first == p) {\n Pos pos = placements[p].second;\n if (pos.r >= 0 && pos.r < D && pos.c >= 0 && pos.c < D) {\n cout << pos.r << \" \" << pos.c << endl;\n cout.flush();\n // Free the position after transport\n warehouse.free_position(pos);\n }\n }\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, M;\nint grid[55][55];\nbool required_adj[110][110];\nbool forbidden_0[110];\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nint bfs_iter = 0;\nint vis[55][55];\nint q_arr[2505];\n\nbool check_connected(int c) {\n if(c < 0 || c > M) return true;\n int st = -1, found = 0;\n for(int i = 0; i < N && !found; ++i) {\n for(int j = 0; j < N; ++j) {\n if(grid[i][j] == c) { st = i * N + j; found = 1; break; }\n }\n }\n if(!found) return true;\n bfs_iter++;\n if(bfs_iter == 0) bfs_iter = 1;\n int h = 0, t = 0;\n if(t < 2505) q_arr[t++] = st;\n vis[st / N][st % N] = bfs_iter;\n int reached = 1;\n while(h < t) {\n int u = q_arr[h++];\n int r = u / N, c2 = u % N;\n for(int k = 0; k < 4; ++k) {\n int nr = r + dr[k], nc = c2 + dc[k];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N && grid[nr][nc] == c) {\n if(vis[nr][nc] != bfs_iter) {\n vis[nr][nc] = bfs_iter;\n if(t < 2505) q_arr[t++] = nr * N + nc;\n reached++;\n }\n }\n }\n }\n int total = 0;\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n if(grid[i][j] == c) total++;\n return reached == total && total > 0;\n}\n\nbool touches_0(int c) {\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n if(grid[i][j] == c)\n for(int k = 0; k < 4; ++k)\n if(i + dr[k] < 0 || i + dr[k] >= N || j + dc[k] < 0 || j + dc[k] >= N)\n return true;\n return false;\n}\n\nbool has_adj(int c, int d) {\n if(c == 0) return touches_0(d);\n if(d == 0) return touches_0(c);\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n if(grid[i][j] == c)\n for(int k = 0; k < 4; ++k)\n if(i + dr[k] >= 0 && i + dr[k] < N && j + dc[k] >= 0 && j + dc[k] < N)\n if(grid[i + dr[k]][j + dc[k]] == d) return true;\n return false;\n}\n\nbool validate() {\n // Check connectivity\n for(int c = 1; c <= M; ++c) {\n if(!check_connected(c)) return false;\n // Check forbidden 0 adjacency\n if(forbidden_0[c] && touches_0(c)) return false;\n }\n // Check all required adjacencies\n for(int c = 0; c <= M; ++c)\n for(int d = c + 1; d <= M; ++d)\n if(required_adj[c][d] && !has_adj(c, d)) return false;\n // Check all forbidden adjacencies\n for(int c = 0; c <= M; ++c)\n for(int d = c + 1; d <= M; ++d)\n if(!required_adj[c][d] && has_adj(c, d)) return false;\n return true;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(NULL);\n if (!(cin >> N >> M)) return 0;\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n cin >> grid[i][j];\n \n memset(required_adj, false, sizeof(required_adj));\n memset(forbidden_0, false, sizeof(forbidden_0));\n\n for(int i = 0; i < N; ++i) {\n for(int j = 0; j < N; ++j) {\n int c = grid[i][j];\n bool touches = false;\n for(int k = 0; k < 4; ++k) {\n int ni = i + dr[k], nj = j + dc[k];\n if(ni < 0 || ni >= N || nj < 0 || nj >= N) { touches = true; break; }\n }\n if(!touches) forbidden_0[c] = true;\n for(int k = 0; k < 4; ++k) {\n int ni = i + dr[k], nj = j + dc[k];\n if(ni >= 0 && ni < N && nj >= 0 && nj < N) {\n int n = grid[ni][nj];\n if(n != c && n != 0) required_adj[min(c,n)][max(c,n)] = true;\n }\n }\n }\n }\n\n vector> pxs;\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n if(grid[i][j] != 0) pxs.push_back({i, j});\n\n mt19937 rng(42);\n int max_remove = (N * N) / 3;\n int removed = 0;\n\n // First pass: be very conservative\n bool changed = true;\n while(changed) {\n changed = false;\n shuffle(pxs.begin(), pxs.end(), rng);\n int new_removed = 0;\n \n for(auto &p : pxs) {\n if(removed >= max_remove) break;\n \n int r = p.first, cidx = p.second;\n int col = grid[r][cidx];\n if(col == 0) continue;\n \n if(forbidden_0[col]) {\n // For forbidden colors, NEVER modify pixels that could touch boundary\n continue;\n }\n \n int same = 0;\n for(int k = 0; k < 4; ++k) {\n int ni = r + dr[k], nj = cidx + dc[k];\n if(ni >= 0 && ni < N && nj >= 0 && nj < N && grid[ni][nj] == col) same++;\n }\n \n if(same >= 3) {\n grid[r][cidx] = 0;\n if(check_connected(col)) {\n removed++;\n new_removed++;\n changed = true;\n } else {\n grid[r][cidx] = col;\n }\n }\n }\n \n if(new_removed == 0) break;\n }\n\n // Now verify and fix\n for(int iter = 0; iter < 200; ++iter) {\n if(validate()) break;\n \n // Find first violation and fix\n bool fixed = false;\n \n // Check forbidden 0 adjacencies first\n for(int c = 1; c <= M && !fixed; ++c) {\n if(forbidden_0[c] && touches_0(c)) {\n // This color shouldn't touch 0 but does. Restore boundary pixels if possible.\n for(int i = 0; i < N && !fixed; ++i) {\n for(int j = 0; j < N && !fixed; ++j) {\n if(grid[i][j] == 0) {\n // Check if we can fill this with color c\n bool safe = true;\n for(int k = 0; k < 4; ++k) {\n int ni = i + dr[k], nj = j + dc[k];\n if(ni >= 0 && ni < N && nj >= 0 && nj < N) {\n int n = grid[ni][nj];\n if(n != 0 && n != c && !required_adj[c][n]) {\n safe = false;\n }\n }\n }\n if(safe) {\n grid[i][j] = c;\n if(!touches_0(c)) fixed = true;\n else grid[i][j] = 0;\n }\n }\n }\n }\n }\n }\n \n // Check connectivity\n if(!fixed) {\n for(int c = 1; c <= M; ++c) {\n if(!check_connected(c)) {\n // Need to restore some pixels - for now just break\n break;\n }\n }\n }\n \n if(!fixed) break;\n }\n\n // Final validation\n for(int i = 0; i < N; ++i) {\n for(int j = 0; j < N; ++j)\n cout << grid[i][j] << (j == N - 1 ? \"\" : \" \");\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 atcoder;\n\nint main() {\n std::ios::sync_with_stdio(false);\n std::cin.tie(nullptr);\n \n int N, D, Q;\n if (!(std::cin >> N >> D >> Q)) return 0;\n \n // Store comparison results for building weight estimates\n std::vector weight_estimate(N, 0);\n std::vector> weight_confidence(N, std::vector(N, 0.0));\n \n int used_queries = 0;\n std::mt19937 rng(42);\n \n // Phase 1: Learning weights through pairwise comparisons\n // Use tournament-style comparisons\n for (int i = 0; i < N - 1 && used_queries < Q; i++) {\n for (int j = i + 1; j < N && used_queries < Q; j++) {\n if (used_queries >= Q) break;\n \n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 1.0;\n weight_confidence[i][j] = 1.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 1.0;\n weight_confidence[j][i] = 1.0;\n } else {\n // Equal\n weight_estimate[i] += 0.5;\n weight_estimate[j] += 0.5;\n weight_confidence[i][j] = 0.5;\n weight_confidence[j][i] = 0.5;\n }\n }\n }\n \n // Phase 2: Query more comparisons for better ranking (if queries remain)\n // Use larger gaps for better ranking spread\n for (int gap = 1; gap <= 5 && used_queries < Q; gap++) {\n for (int i = 0; i < N - gap && used_queries < Q; i++) {\n int j = i + gap;\n if (weight_confidence[i][j] < 0.5) {\n std::cout << 1 << \" \" << 1 << \" \" << i << \" \" << j << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \">\") {\n weight_estimate[i] += 2.0;\n weight_confidence[i][j] = 2.0;\n } else if (result == \"<\") {\n weight_estimate[j] += 2.0;\n weight_confidence[j][i] = 2.0;\n } else {\n weight_estimate[i] += 1.0;\n weight_estimate[j] += 1.0;\n weight_confidence[i][j] = 1.0;\n weight_confidence[j][i] = 1.0;\n }\n }\n }\n }\n \n // Phase 3: Use remaining queries for verification/refinement\n // Compare items with known reference points\n if (used_queries < Q && N > 2) {\n std::vector item_order(N);\n std::iota(item_order.begin(), item_order.end(), 0);\n \n // Quick sort by weight estimate\n std::sort(item_order.begin(), item_order.end(), [&](int a, int b) {\n return weight_estimate[a] > weight_estimate[b];\n });\n \n // Verify middle items with extreme items\n int mid_idx = N / 2;\n int low_item = item_order[0];\n int high_item = item_order[N - 1];\n \n for (int k = 1; k < std::min(5, mid_idx + 1) && used_queries < Q; k++) {\n int mid_item = item_order[k];\n std::cout << 1 << \" \" << 1 << \" \" << mid_item << \" \" << high_item << \"\\n\";\n std::flush(std::cout);\n used_queries++;\n \n std::string result;\n std::cin >> result;\n \n if (result == \"<\") {\n weight_estimate[high_item] += 3.0;\n } else if (result == \">\") {\n weight_estimate[mid_item] += 3.0;\n }\n }\n }\n \n // Phase 4: Sort items by estimated weight\n std::vector> items_by_weight(N);\n for (int i = 0; i < N; i++) {\n items_by_weight[i] = {weight_estimate[i], i};\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n \n // Handle edge case where all weights are the same\n if (used_queries >= Q) {\n // Add small random jitter to break ties\n std::uniform_real_distribution jitter_dist(-0.1, 0.1);\n for (auto& p : items_by_weight) {\n if (p.first == 0.0) {\n p.first = jitter_dist(rng);\n }\n }\n std::sort(items_by_weight.rbegin(), items_by_weight.rend());\n }\n \n // Phase 5: LPT Greedy Partitioning\n std::vector partition(N);\n std::vector set_weights(D, 0.0);\n std::vector> set_items(D);\n \n for (const auto& item_data : items_by_weight) {\n int item_idx = item_data.second;\n \n // Find set with minimum weight\n int best_set = 0;\n double min_weight = set_weights[0];\n for (int s = 1; s < D; s++) {\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n best_set = s;\n }\n }\n \n partition[item_idx] = best_set;\n set_items[best_set].push_back(item_idx);\n set_weights[best_set] += item_data.first;\n }\n \n // Phase 6: Simple local search refinement with proper bounds checking\n bool improved = true;\n int max_iterations = std::min(10, D);\n int iteration_count = 0;\n \n while (improved && iteration_count < max_iterations) {\n improved = false;\n iteration_count++;\n \n // Recalculate set weights\n std::fill(set_weights.begin(), set_weights.end(), 0.0);\n for (int i = 0; i < N; i++) {\n set_weights[partition[i]] += items_by_weight[i].first;\n }\n \n // Find max and min weighted sets\n int max_set = 0, min_set = 0;\n double max_weight = set_weights[0], min_weight = set_weights[0];\n \n for (int s = 1; s < D; s++) {\n if (set_weights[s] > max_weight) {\n max_weight = set_weights[s];\n max_set = s;\n }\n if (set_weights[s] < min_weight) {\n min_weight = set_weights[s];\n min_set = s;\n }\n }\n \n // Try moving items from max weight set to min weight set\n std::vector& from_set = set_items[max_set];\n std::vector& to_set = set_items[min_set];\n \n if (from_set.empty()) {\n break;\n }\n \n for (const int& item_idx : from_set) {\n // Calculate weight change if we move this item\n double weight_of_item = items_by_weight[N - 1 - max_set].first;\n // Actually get correct weight\n for (int i = 0; i < N; i++) {\n if (items_by_weight[i].second == item_idx) {\n weight_of_item = items_by_weight[i].first;\n break;\n }\n }\n \n double old_max_weight = set_weights[max_set];\n double old_min_weight = set_weights[min_set];\n \n double new_max = old_max_weight - weight_of_item;\n double new_min = old_min_weight + weight_of_item;\n \n // Check if moving improves balance\n double old_range = std::max(old_max_weight, old_min_weight) - \n std::min(old_max_weight, old_min_weight);\n double new_range = std::max(new_max, new_min) - \n std::min(new_max, new_min);\n // Also check impact on intermediate sets\n bool all_within_range = true;\n for (int s = 0; s < D; s++) {\n if (s != max_set && s != min_set) {\n double ws = set_weights[s];\n if (std::abs(ws - new_min) > 1.1 * std::abs(old_max_weight - old_min_weight)) {\n all_within_range = false;\n break;\n }\n }\n }\n \n if (new_range < old_range * 0.95 && all_within_range) {\n // Make the move\n partition[item_idx] = min_set;\n set_items[max_set].erase(std::find(set_items[max_set].begin(), \n set_items[max_set].end(), item_idx));\n set_items[min_set].push_back(item_idx);\n set_weights[max_set] -= weight_of_item;\n set_weights[min_set] += weight_of_item;\n improved = true;\n break;\n }\n }\n }\n \n // Phase 7: Output final partition\n for (int i = 0; i < N; i++) {\n std::cout << partition[i] << (i == N - 1 ? \"\\n\" : \" \");\n }\n \n std::flush(std::cout);\n \n return 0;\n}","ahc026":"#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 n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> stacks(m);\n vector box_pos(n + 1);\n vector carried_out(n + 1, false);\n\n // Read input and initialize position tracking\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int b;\n cin >> b;\n stacks[i].push_back(b);\n box_pos[b] = i;\n }\n }\n\n vector> operations;\n operations.reserve(n * 4);\n\n for (int v = 1; v <= n; ++v) {\n if (carried_out[v]) continue;\n\n // Find v's current position\n int src_idx = box_pos[v];\n int box_idx = -1;\n\n // Validate cached position and find box\n if (src_idx >= 0 && src_idx < m) {\n for (int j = 0; j < (int)stacks[src_idx].size(); ++j) {\n if (stacks[src_idx][j] == v) {\n box_idx = j;\n break;\n }\n }\n }\n\n // Search all stacks if position is not found\n if (box_idx < 0) {\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < (int)stacks[i].size(); ++j) {\n if (stacks[i][j] == v) {\n src_idx = i;\n box_idx = j;\n goto found_v;\n }\n }\n }\n }\n\n found_v:\n if (box_idx < 0 || box_idx >= (int)stacks[src_idx].size()) {\n continue;\n }\n\n box_pos[v] = src_idx;\n size_t boxes_above = (size_t)stacks[src_idx].size() - (size_t)(box_idx + 1);\n\n if (boxes_above > 0) {\n int bottom_idx = box_idx + 1;\n int bottom_value = stacks[src_idx][bottom_idx];\n\n // Find optimal destination stack\n // Priority (highest to lowest):\n // 1. Empty stacks (never block future operations)\n // 2. Stack with highest top value >= v+1 (won't block next box)\n // 3. Stack with highest top value (good for maintaining order)\n // 4. Balanced distribution (shorter stacks preferred)\n \n int dest_idx = -1;\n long long best_score = -1;\n\n // First check for empty stacks (highest priority)\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n if (stacks[i].empty()) {\n dest_idx = i;\n goto dest_found;\n }\n }\n\n // No empty stack, calculate scores for non-empty stacks\n for (int i = 0; i < m; ++i) {\n if (i == src_idx) continue;\n \n int top = stacks[i].back();\n int height = stacks[i].size();\n int stack_idx = i;\n\n // Calculate score with multiple factors:\n // 1. Higher top value is better\n // 2. Top >= v+1 gets major bonus (prevents blocking next box)\n // 3. Shorter stack height is better (balance distribution)\n long long score = (long long)top * 10000; // Base: top value\n if (top >= v + 1) score += 1000000; // Bonus for not blocking next box\n score -= height * 5000; // Penalty for tall stacks\n score += (m - height) * 10000; // Bonus for shorter stacks\n\n if (dest_idx == -1 || score > best_score) {\n best_score = score;\n dest_idx = stack_idx;\n }\n }\n\n dest_found:\n if (dest_idx < 0) continue;\n\n // Collect boxes to move (block move - k+1 energy)\n vector moved;\n moved.reserve(boxes_above);\n for (size_t i = (size_t)bottom_idx; i < stacks[src_idx].size(); ++i) {\n moved.push_back(stacks[src_idx][i]);\n }\n\n // Remove from source (v becomes top)\n stacks[src_idx].resize(bottom_idx);\n\n // Update positions\n for (int b : moved) {\n box_pos[b] = dest_idx;\n }\n\n // Transfer to destination\n for (int b : moved) {\n stacks[dest_idx].push_back(b);\n }\n\n // Record operation (k+1 energy)\n operations.push_back({bottom_value, dest_idx + 1});\n }\n\n // Extract v (Op 2 - free, no energy)\n operations.push_back({v, 0});\n carried_out[v] = true;\n\n // Clean up v from source\n if (!stacks[src_idx].empty() && stacks[src_idx].back() == v) {\n stacks[src_idx].pop_back();\n }\n }\n\n // Output all operations\n for (const auto& op : operations) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h_in;\nvector v_in;\nvector> d_grid;\nvector> children;\nvector parents;\nvector x_vec;\nvector cnt_vec;\nvector version;\nint V;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n h_in.resize(N - 1);\n for(int i = 0; i < N - 1; ++i) cin >> h_in[i];\n v_in.resize(N);\n for(int i = 0; i < N; ++i) cin >> v_in[i];\n d_grid.resize(N, vector(N));\n V = N * N;\n for(int i = 0; i < N; ++i) {\n for(int j = 0; j < N; ++j) cin >> d_grid[i][j];\n }\n\n parents.assign(V, -1);\n children.assign(V, vector());\n x_vec.assign(V, 1);\n x_vec[0] = 0;\n cnt_vec.assign(V, 0);\n version.assign(V, 0);\n\n // BFS spanning tree\n queue q;\n q.push(0);\n vector visited(V, false);\n visited[0] = true;\n\n while(!q.empty()){\n int u = q.front(); q.pop();\n int r = u / N, c = u % N;\n\n if(r + 1 < N && h_in[r][c] == '0') {\n int v = (r + 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(r - 1 >= 0 && h_in[r - 1][c] == '0') {\n int v = (r - 1) * N + c;\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c + 1 < N && v_in[r][c] == '0') {\n int v = r * N + (c + 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n if(c - 1 >= 0 && v_in[r][c - 1] == '0') {\n int v = r * N + (c - 1);\n if(!visited[v]) {\n visited[v] = true;\n parents[v] = u;\n children[u].push_back(v);\n q.push(v);\n }\n }\n }\n\n // Initial cnt calculation\n for(int i = V - 1; i >= 0; --i) {\n cnt_vec[i] = x_vec[i];\n for(int c : children[i]) cnt_vec[i] += cnt_vec[c];\n }\n\n // Helper to calculate gain\n auto get_gain = [&](int u) {\n double g = 0.0;\n int curr = u;\n while(curr != -1) {\n if(cnt_vec[curr] > 0) {\n g += (double)d_grid[curr / N][curr % N] / ( (double)cnt_vec[curr] * ((double)cnt_vec[curr] + 1.0) );\n }\n if(curr == 0) break;\n curr = parents[curr];\n }\n return g;\n };\n\n // Priority Queue: {gain, u, version}\n priority_queue> pq;\n\n for(int i = 1; i < V; ++i) {\n version[i]++;\n double g = get_gain(i);\n pq.push({g, i, version[i]});\n }\n\n long long budget = 50000; // sum(x) <= 50000\n long long current_sum = 0;\n for(int i = 0; i < V; ++i) current_sum += x_vec[i];\n long long remaining = budget - current_sum;\n if(remaining < 0) remaining = 0;\n\n for(long long iter = 0; iter < remaining && !pq.empty(); ++iter) {\n tuple top = pq.top(); pq.pop();\n double gain = get<0>(top);\n int u = get<1>(top);\n int v = get<2>(top);\n\n // Check if this entry is outdated\n if(v != version[u]) continue;\n\n // Apply increment\n x_vec[u]++;\n\n // Update cnt for u and all ancestors\n int curr = u;\n while(curr != -1) {\n cnt_vec[curr]++;\n curr = parents[curr];\n if(curr == -1) break;\n }\n\n // Update PQ entries for affected nodes\n curr = u;\n while(curr != -1) {\n version[curr]++;\n double ng = get_gain(curr);\n pq.push({ng, curr, version[curr]});\n curr = parents[curr];\n if(curr == -1) break;\n }\n }\n\n // Generate path using DFS\n string ans;\n ans.reserve(100000);\n\n auto dfs = [&](auto&& self, int u) -> void {\n for(int v : children[u]) {\n int r_u = u / N, c_u = u % N;\n int r_v = v / N, c_v = v % N;\n char dir = ' ';\n char back = ' ';\n if(r_v == r_u + 1) { dir = 'D'; back = 'U'; }\n else if(r_v == r_u - 1) { dir = 'U'; back = 'D'; }\n else if(c_v == c_u + 1) { dir = 'R'; back = 'L'; }\n else if(c_v == c_u - 1) { dir = 'L'; back = 'R'; }\n\n for(long long k = 0; k < x_vec[v]; ++k) {\n ans += dir;\n self(self, v);\n ans += back;\n }\n }\n };\n\n dfs(dfs, 0);\n cout << ans << endl;\n\n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int r, c;\n int dist(const Point& o) const { return abs(r - o.r) + abs(c - o.c); }\n bool operator==(const Point& o) const { return r == o.r && c == o.c; }\n};\n\nstruct Occurrence {\n Point start;\n Point end;\n int internal_cost;\n vector path;\n};\n\nint N, M;\nint s_r, s_c;\nchar A[20][20];\nvector words;\nvector> word_occurrences;\n\nvoid precompute_occurrences() {\n word_occurrences.resize(M);\n struct Parent { int r, c, d; };\n\n for (int k = 0; k < M; ++k) {\n if (words[k].size() != 5) continue;\n\n vector current_occs;\n \n for (int sr = 0; sr < N; ++sr) {\n for (int sc = 0; sc < N; ++sc) {\n if (A[sr][sc] != words[k][0]) continue;\n\n struct Node { Point p; int d; int cost; bool operator>(const Node& o) const { return cost > o.cost; } };\n \n static int dist_map[20][20][6];\n static Parent parent_map[20][20][6];\n for(int r=0; r, greater> pq;\n while(!pq.empty()) pq.pop();\n \n dist_map[sr][sc][0] = 1;\n pq.push({{sr, sc}, 0, 1});\n \n while(!pq.empty()){\n Node top = pq.top(); pq.pop();\n int r = top.p.r, c = top.p.c, d = top.d, cost = top.cost;\n \n if (cost > dist_map[r][c][d]) continue;\n \n if (d == 4) {\n vector path;\n int cr = r, cc = c, cd = d;\n while(cd >= 0) {\n path.push_back({cr, cc});\n if (cd > 0) {\n Parent p = parent_map[cr][cc][cd];\n cr = p.r; cc = p.c; cd = p.d;\n } else break;\n }\n reverse(path.begin(), path.end());\n \n Occurrence occ_curr;\n occ_curr.start = {sr, sc};\n occ_curr.end = {r, c};\n occ_curr.internal_cost = cost;\n occ_curr.path = path;\n \n current_occs.push_back(occ_curr);\n }\n \n if (d < 4) {\n int next_char_idx = d + 1;\n char needed = words[k][next_char_idx];\n for (int dr = -1; dr <= 1; ++dr) {\n for (int dc = -1; dc <= 1; ++dc) {\n int nr = r + dr, nc = c + dc;\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && A[nr][nc] == needed) {\n int move_cost = abs(dr) + abs(dc);\n int new_cost = cost + move_cost + 1;\n if (new_cost < dist_map[nr][nc][d+1]) {\n dist_map[nr][nc][d+1] = new_cost;\n parent_map[nr][nc][d+1] = {r, c, d};\n pq.push({{nr, nc}, d+1, new_cost});\n }\n }\n }\n }\n }\n }\n }\n }\n \n sort(current_occs.begin(), current_occs.end(), [](const Occurrence& a, const Occurrence& b){\n if (a.start == b.start && a.end == b.end) return a.internal_cost < b.internal_cost;\n return a.internal_cost < b.internal_cost;\n });\n \n vector unique_occs;\n unique_occs.reserve(current_occs.size());\n if (!current_occs.empty()) {\n unique_occs.push_back(current_occs[0]);\n for(size_t i=1; i 5) unique_occs.resize(5);\n word_occurrences[k] = unique_occs;\n }\n}\n\nint get_total_cost(const vector& perm) {\n static int dp[20][20];\n static int next_dp[20][20];\n static int best_dist[20][20];\n int INF = 2e9;\n \n for(int r=0; r& occs = word_occurrences[k];\n \n for(int r=0; r 0 && best_dist[r-1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r-1][c] + 1;\n if (r < N-1 && best_dist[r+1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r+1][c] + 1;\n }\n }\n for(int r=0; r 0 && best_dist[r][c-1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c-1] + 1;\n if (c < N-1 && best_dist[r][c+1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c+1] + 1;\n }\n }\n \n for(int r=0; r> N >> M)) return 0;\n cin >> s_r >> s_c;\n for(int i=0; i> row;\n for(int j=0; j> words[i];\n \n precompute_occurrences();\n \n vector perm(M);\n for(int i=0; i rand_idx(0, M-1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n \n int base_cost = get_total_cost(perm);\n int best_cost = base_cost;\n vector best_perm = perm;\n \n for(int iter=0; iter<2000; ++iter) {\n vector next_perm = perm;\n int i = rand_idx(mt);\n int j = rand_idx(mt);\n swap(next_perm[i], next_perm[j]);\n \n int next_cost = get_total_cost(next_perm);\n bool accept = false;\n if (next_cost < best_cost) {\n accept = true;\n best_cost = next_cost;\n best_perm = next_perm;\n } else {\n if (rand_prob(mt) < exp((base_cost - next_cost) / (5000.0))) {\n accept = true;\n base_cost = next_cost;\n }\n if (accept) perm = next_perm;\n }\n }\n \n static int dp[20][20];\n static int next_dp[20][20];\n static int best_dist[20][20];\n static int INF = 2e9;\n \n for(int r=0; r> history_occ_idx(M, vector(max_idx, -1));\n vector>> history_dp(M + 1, vector>(N, vector(N, INF)));\n history_dp[0][s_r][s_c] = 0;\n\n for(int w=0; w& occs = word_occurrences[k];\n \n for(int r=0; r 0 && best_dist[r-1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r-1][c] + 1;\n if (r < N-1 && best_dist[r+1][c] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r+1][c] + 1;\n }\n }\n for(int r=0; r 0 && best_dist[r][c-1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c-1] + 1;\n if (c < N-1 && best_dist[r][c+1] + 1 < best_dist[r][c]) best_dist[r][c] = best_dist[r][c+1] + 1;\n }\n }\n \n for(size_t idx=0; idx= 0; --w) {\n int k = best_perm[w];\n const vector& occs = word_occurrences[k];\n int idx = history_occ_idx[w][r * N + c];\n \n if (idx == -1) {\n r = s_r; \n c = s_c;\n continue;\n }\n \n const auto& occ = occs[idx];\n \n for(const auto& pt : occ.path) {\n cout << pt.r << \" \" << pt.c << \"\\n\";\n }\n \n if (w > 0) {\n int prev_r = -1, prev_c = -1;\n \n for(int i=0; i\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 25;\nconst int MAX_M = 25;\nconst int MAX_MASK = 400;\nconst int MAX_PLACEMENTS = 8000;\n\nint N, M;\ndouble epsilon;\n\nstruct Placement {\n int r, c;\n short row_contrib[MAX_N];\n short col_contrib[MAX_N];\n bitset mask;\n};\n\nint num_placements[MAX_M];\nint sorted_ids[MAX_M];\nPlacement placements[MAX_M][MAX_PLACEMENTS];\nint row_min[MAX_M][MAX_N], row_max[MAX_M][MAX_N];\nint col_min[MAX_M][MAX_N], col_max[MAX_M][MAX_N];\nint suffix_row_min[MAX_M + 1][MAX_N], suffix_row_max[MAX_M + 1][MAX_N];\nint suffix_col_min[MAX_M + 1][MAX_N], suffix_col_max[MAX_M + 1][MAX_N];\n\nint R[MAX_N], C[MAX_N], temp_R[MAX_N], temp_C[MAX_N];\nbitset invalid_mask, global_mask, valid_solution;\nbool found_solution = false;\nlong long node_count = 0;\nconst long long NODE_LIMIT = 30000;\n\nvoid dfs(int k) {\n if (found_solution || node_count > NODE_LIMIT) return;\n node_count++;\n\n for (int i = 0; i < N; ++i) {\n int min_r = suffix_row_min[k][i];\n int max_r = suffix_row_max[k][i];\n if (temp_R[i] < min_r || temp_R[i] > max_r) return;\n \n int min_c = suffix_col_min[k][i];\n int max_c = suffix_col_max[k][i];\n if (temp_C[i] < min_c || temp_C[i] > max_c) return;\n }\n \n if (k == M) {\n valid_solution = global_mask;\n found_solution = true;\n return;\n }\n\n int idx = sorted_ids[k];\n int count = num_placements[idx];\n \n for(int i = 0; i < count; ++i) {\n if (found_solution || node_count > NODE_LIMIT) return;\n \n const Placement& p = placements[idx][i];\n \n if ((p.mask & invalid_mask).none()) {\n bool ok = true;\n for (int r = 0; r < N; ++r) {\n int val = temp_R[r] - p.row_contrib[r];\n if (val < suffix_row_min[k+1][r] || val > suffix_row_max[k+1][r]) {\n ok = false; break;\n }\n }\n if(ok) {\n for (int c = 0; c < N; ++c) {\n int val = temp_C[c] - p.col_contrib[c];\n if (val < suffix_col_min[k+1][c] || val > suffix_col_max[k+1][c]) {\n ok = false; break;\n }\n }\n }\n\n if(ok) {\n global_mask |= p.mask;\n for (int r = 0; r < N; ++r) temp_R[r] -= p.row_contrib[r];\n for (int c = 0; c < N; ++c) temp_C[c] -= p.col_contrib[c];\n \n dfs(k + 1);\n \n for (int r = 0; r < N; ++r) temp_R[r] += p.row_contrib[r];\n for (int c = 0; c < N; ++c) temp_C[c] += p.col_contrib[c];\n global_mask ^= p.mask;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> epsilon)) return 0;\n\n vector>> shapes(M);\n for(int k = 0; k < M; ++k) {\n int d; cin >> d;\n shapes[k].resize(d);\n for(int i = 0; i < d; ++i) {\n cin >> shapes[k][i].first >> shapes[k][i].second;\n }\n int h = 0, w = 0;\n for(auto&p: shapes[k]){ h = max(h, p.first); w = max(w, p.second); }\n h++; w++;\n \n int count = 0;\n for(int r = 0; r <= N - h; ++r) {\n for(int c = 0; c <= N - w; ++c) {\n short row_con[MAX_N] = {0};\n short col_con[MAX_N] = {0};\n bitset m;\n m.reset();\n for(auto &s : shapes[k]) {\n int tr = r + s.first;\n int tc = c + s.second;\n row_con[tr]++;\n col_con[tc]++;\n m.set(tr * N + tc);\n }\n Placement &p = placements[k][count++];\n p.r = r; p.c = c;\n for(int x = 0; x < N; ++x) { p.row_contrib[x] = row_con[x]; p.col_contrib[x] = col_con[x]; }\n p.mask = m;\n }\n }\n num_placements[k] = count;\n \n for(int r = 0; r < N; ++r) {\n int mn = 20, mx = 0; \n for(int i = 0; i < num_placements[k]; ++i) {\n int val = placements[k][i].row_contrib[r];\n mn = min(mn, val);\n mx = max(mx, val);\n }\n row_min[k][r] = mn; row_max[k][r] = mx;\n }\n for(int c = 0; c < N; ++c) {\n int mn = 20, mx = 0;\n for(int i = 0; i < num_placements[k]; ++i) {\n int val = placements[k][i].col_contrib[c];\n mn = min(mn, val);\n mx = max(mx, val);\n }\n col_min[k][c] = mn; col_max[k][c] = mx;\n }\n }\n\n for(int i = 0; i < N; ++i) {\n suffix_row_min[M][i] = suffix_row_max[M][i] = suffix_col_min[M][i] = suffix_col_max[M][i] = 0;\n }\n for(int k = M - 1; k >= 0; --k) {\n for(int r = 0; r < N; ++r) {\n suffix_row_min[k][r] = suffix_row_min[k+1][r] + row_min[k][r];\n suffix_row_max[k][r] = suffix_row_max[k+1][r] + row_max[k][r];\n suffix_col_min[k][r] = suffix_col_min[k+1][r] + col_min[k][r];\n suffix_col_max[k][r] = suffix_col_max[k+1][r] + col_max[k][r];\n }\n for(int c = 0; c < N; ++c) {\n suffix_col_min[k][c] = suffix_col_min[k+1][c] + col_min[k][c];\n suffix_col_max[k][c] = suffix_col_max[k+1][c] + col_max[k][c];\n }\n }\n\n // Read Row/Col sums\n for (int i = 0; i < N; ++i) {\n cout << \"q \" << N;\n for(int j = 0; j < N; ++j) cout << \" \" << i << \" \" << j;\n cout << \"\\n\"; cout.flush();\n int res; cin >> res;\n R[i] = (int)round(((double)res - (double)N * epsilon) / (1.0 - 2.0 * epsilon));\n }\n for (int j = 0; j < N; ++j) {\n cout << \"q \" << N;\n for(int i = 0; i < N; ++i) cout << \" \" << i << \" \" << j;\n cout << \"\\n\"; cout.flush();\n int res; cin >> res;\n C[j] = (int)round(((double)res - (double)N * epsilon) / (1.0 - 2.0 * epsilon));\n }\n\n for(int i = 0; i < M; ++i) sorted_ids[i] = i;\n sort(sorted_ids, sorted_ids + M, [](int a, int b){\n return num_placements[a] < num_placements[b];\n });\n\n // Try search once with strict limit\n found_solution = false;\n node_count = 0;\n invalid_mask.reset();\n global_mask.reset();\n for(int i = 0; i < N; ++i) { \n temp_R[i] = R[i]; \n temp_C[i] = C[i]; \n }\n\n dfs(0);\n\n if (found_solution) {\n vector> ans;\n for(int k = 0; k < N * N; ++k) {\n if(valid_solution[k]) ans.push_back({k / N, k % N});\n }\n cout << \"a \" << ans.size();\n for(auto &p : ans) cout << \" \" << p.first << \" \" << p.second;\n cout << \"\\n\"; cout.flush();\n \n int query_res; \n cin >> query_res;\n if (query_res == 1) return 0;\n }\n\n // Drill all cells\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n cout << \"q 1 \" << r << \" \" << c << \"\\n\"; cout.flush();\n int drill_res;\n cin >> drill_res;\n if (drill_res == 0) {\n invalid_mask.set(r * N + c);\n }\n }\n }\n\n // Guess based on drilled cells\n vector> ans;\n for(int k = 0; k < N * N; ++k) {\n int r = k / N, c = k % N;\n if (!invalid_mask.test(k)) {\n ans.push_back({r, c});\n }\n }\n cout << \"a \" << ans.size();\n for(auto &p : ans) cout << \" \" << p.first << \" \" << p.second;\n cout << \"\\n\"; cout.flush();\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ninline int ceil_div(int a, int b) {\n return (a + b - 1) / b;\n}\n\n// Calculate exact partition cost between day d-1 and day d with widths\nlong long calc_partition_cost_exact(int W, int D, int N, const vector& w, \n int d_prev, int d_curr, const vector>& A,\n vector& h_prev_day, vector& h_curr_day) {\n long long cost = 0;\n \n for (int k = 0; k < N; k++) {\n int w_k = w[k];\n \n // Calculate heights for both days\n int prev_h = ceil_div(A[d_prev][k], w_k);\n prev_h = min(prev_h, W);\n \n int curr_h = ceil_div(A[d_curr][k], w_k);\n curr_h = min(curr_h, W);\n \n // Horizontal partition cost\n cost += (long long)w_k * abs(curr_h - prev_h);\n \n // Vertical partition cost at column boundaries\n if (k > 0) {\n // The width of column k-1 determines boundary position\n // Previous boundary was at sum(w[0..k-2]) + w[k-1]_prev_h_change\n // Current boundary is at sum(w[0..k-1]) + w[k-1]_curr_h_change\n // Actually simpler: track boundary x-coordinates\n cost += (long long)min(curr_h, prev_h) * abs((int)w[k] - (int)w[k]);\n }\n }\n \n return cost;\n}\n\n// Optimized cost function that matches problem specification exactly\nlong long calc_total_cost_exact(int W, int D, int N, const vector& w, \n const vector>& A) {\n long long total_cost = 0;\n \n // For each day transition\n vector> heights(D, vector(N, 0));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n heights[d][k] = min(ceil_div(A[d][k], w[k]), W);\n }\n }\n \n for (int d = 1; d < D; d++) {\n // Calculate horizontal partition changes\n for (int k = 0; k < N; k++) {\n total_cost += (long long)w[k] * abs(heights[d][k] - heights[d-1][k]);\n }\n \n // The problem actually simplifies to just tracking boundary movements\n // which we've captured with horizontal transitions\n }\n \n // Add area penalty\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n int area = heights[d][k] * w[k];\n if (A[d][k] > area) {\n total_cost += 100LL * (A[d][k] - area);\n }\n }\n }\n \n return total_cost + 1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n vector> A(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> A[d][k];\n }\n }\n\n // Initialize with minimum widths\n vector w(N, 1);\n for (int k = 0; k < N; k++) {\n int max_a = 0;\n for (int d = 0; d < D; d++) {\n max_a = max(max_a, A[d][k]);\n }\n w[k] = max(ceil_div(max_a, W), 1);\n }\n\n // Normalize to sum exactly W\n int current_sum = 0;\n for (int val : w) current_sum += val;\n \n if (current_sum < W) {\n for (int i = 0; i < W - current_sum; i++) {\n w[i % N]++;\n }\n } else if (current_sum > W) {\n int excess = current_sum - W;\n for (int k = 0; k < N && excess > 0; k++) {\n int reduce = min(excess, w[k] - 1);\n w[k] -= reduce;\n excess -= reduce;\n }\n }\n\n // Calculate initial cost\n vector best_w = w;\n long long best_cost = calc_total_cost_exact(W, D, N, best_w, A);\n \n // Optimization passes\n for (int seed = 0; seed < 10; seed++) {\n vector current_w = w;\n \n // Perturb initial configuration\n for (int k = 0; k < N; k++) {\n int diff = (k % 3) - 1; // -1, 0, or 1\n if (current_w[k] + diff >= 1 && current_sum + diff <= W) {\n current_w[k] += diff;\n }\n }\n \n // Normalize\n current_sum = 0;\n for (int val : current_w) current_sum += val;\n if (current_sum < W) {\n for (int i = 0; i < W - current_sum; i++) {\n current_w[i % N]++;\n }\n } else if (current_sum > W) {\n int excess = current_sum - W;\n for (int k = 0; k < N && excess > 0; k++) {\n int reduce = min(excess, current_w[k] - 1);\n current_w[k] -= reduce;\n excess -= reduce;\n }\n }\n\n int iterations = 50;\n for (int iter = 0; iter < iterations; iter++) {\n bool improved = false;\n long long current_cost = calc_total_cost_exact(W, D, N, current_w, A);\n \n // Try incrementing widths\n for (int k = 0; k < N; k++) {\n if (current_w[k] < W) {\n int old_w = current_w[k];\n current_w[k]++;\n int temp_sum = current_sum + 1;\n \n long long new_cost = calc_total_cost_exact(W, D, N, current_w, A);\n if (new_cost < current_cost) {\n current_cost = new_cost;\n current_sum = temp_sum;\n improved = true;\n } else {\n current_w[k]--;\n current_sum = temp_sum - 1;\n }\n }\n }\n \n // Try swapping widths to minimize total cost\n for (int i = 0; i < N && !improved; i++) {\n for (int j = i + 1; j < N && !improved; j++) {\n vector test_w = current_w;\n swap(test_w[i], test_w[j]);\n long long test_cost = calc_total_cost_exact(W, D, N, test_w, A);\n if (test_cost < current_cost) {\n current_w = test_w;\n current_cost = test_cost;\n improved = true;\n }\n }\n }\n \n if (!improved) break;\n }\n \n // Check if better than best\n long long final_cost = calc_total_cost_exact(W, D, N, current_w, A);\n if (final_cost < best_cost) {\n best_cost = final_cost;\n best_w = current_w;\n }\n }\n\n // FINAL CORRECT NORMALIZATION\n int final_sum = 0;\n for (int vw : best_w) final_sum += vw;\n \n // Reduce if needed\n while (final_sum > W) {\n for (int k = 0; k < N && final_sum > W; k++) {\n if (best_w[k] > 1) {\n best_w[k]--;\n final_sum--;\n }\n }\n }\n \n // Increase if needed\n while (final_sum < W) {\n for (int k = 0; k < N && final_sum < W; k++) {\n best_w[k]++;\n final_sum++;\n }\n }\n\n // Verify sum equals exactly W\n int verify_sum = 0;\n for (int vw : best_w) verify_sum += vw;\n \n // Calculate starting positions\n vector x_start(N);\n int curr_x = 0;\n for (int k = 0; k < N; k++) {\n x_start[k] = curr_x;\n curr_x += best_w[k];\n }\n\n // Output with strict validation\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n int h = ceil_div(A[d][k], best_w[k]);\n h = min(h, W);\n \n int i0 = 0, j0 = x_start[k];\n int i1 = h, j1 = x_start[k] + best_w[k];\n \n // Strict bounds check (0 <= coordinates <= W)\n j1 = min(j1, W);\n h = min(h, W);\n i1 = h;\n \n // Minimum area of 1\n if (j1 <= j0) j1 = j0 + 1;\n if (i1 <= i0) i1 = i0 + 1;\n \n // Final verification\n if (i1 > W || j1 > W || i0 < 0 || j0 < 0) continue;\n \n cout << i0 << \" \" << j0 << \" \" << i1 << \" \" << j1 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int N = 9;\nconst int M = 20;\nconst int K = 81;\nconst int MOD = 998244353;\nconst int MAX_MOVES = 981; // 20 * 49 + 1 (None)\n\n// Board state\nint board[N][N];\nlong long current_score = 0;\n\n// Move related data structures\n// move_impact_flat_flat[id][rc] stores the value added to cell rc by move id\nint move_impact_flat_flat[MAX_MOVES][81]; \n\nstruct Cell {\n int r, c;\n};\nvector move_cells_flat[MAX_MOVES]; \n\nvector valid_moves_list;\nmt19937 rng;\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_in, M_in, K_in;\n if (!(cin >> N_in >> M_in >> K_in)) return 0;\n\n // Read initial values\n for (int i = 0; i < N_in; ++i) {\n for (int j = 0; j < N_in; ++j) {\n cin >> board[i][j];\n current_score += board[i][j];\n }\n }\n\n // Read stamps\n vector> stamps(M_in, vector(9));\n for (int m = 0; m < M_in; ++m) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n cin >> stamps[m][i * 3 + j];\n }\n }\n }\n\n // Precompute moves\n int p_limit = N_in - 2; // 7\n valid_moves_list.push_back(980); // None move ID\n\n for (int m = 0; m < M_in; ++m) {\n for (int p = 0; p < p_limit; ++p) {\n for (int q = 0; q < p_limit; ++q) {\n int id = m * 49 + (p * 7 + q);\n valid_moves_list.push_back(id);\n\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = p + i;\n int c = q + j;\n if (r >= 0 && r < N_in && c >= 0 && c < N_in) {\n int val = stamps[m][i * 3 + j];\n move_impact_flat_flat[id][r * N_in + c] = val;\n if (val != 0) {\n move_cells_flat[id].push_back({r, c});\n }\n }\n }\n }\n }\n }\n }\n \n // Initialize RNG\n unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n // Initialize current moves\n vector current_moves(K);\n for (int i = 0; i < K; ++i) {\n int idx = 1 + rng() % (valid_moves_list.size() - 1);\n current_moves[i] = valid_moves_list[idx];\n }\n\n // Apply initial moves to board\n for (int lid = 0; lid < K; ++lid) {\n int mid = current_moves[lid];\n for (const auto& cell : move_cells_flat[mid]) {\n int idx = cell.r * N_in + cell.c;\n long long val = board[cell.r][cell.c] + move_impact_flat_flat[mid][idx];\n if (val >= MOD) val -= MOD;\n board[cell.r][cell.c] = val;\n }\n }\n\n // Recompute score\n current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += board[i][j];\n }\n }\n\n // Simulated Annealing / Hill Climbing\n // Increased iterations to 8000-10000\n int iter_count = 8000; \n double initial_temp = 5000.0;\n double temp = initial_temp;\n double decay = 0.998;\n \n bool visited[81]; // Tracks if a cell is covered by curr_move\n uniform_real_distribution dist(0.0, 1.0);\n \n static int visited_indices[16]; \n\n for (int iter = 0; iter < iter_count; ++iter) {\n int slot_idx = rng() % K;\n int curr_move_id = current_moves[slot_idx];\n \n // Mark visited for curr_move cells\n int vic_count = 0;\n for (const auto& cell : move_cells_flat[curr_move_id]) {\n int rc = cell.r * N_in + cell.c;\n visited[rc] = true;\n if (vic_count < 16) visited_indices[vic_count++] = rc;\n }\n \n // Iterate all candidates to find the best delta\n int best_cand_id = curr_move_id;\n long long best_delta = 0; // Initialize to 0 (stay put)\n \n // Check neighbors (all valid moves)\n // To speed up, we can use direct array instead of vector\n for (int i = 0; i < (int)valid_moves_list.size(); ++i) {\n int cand_id = valid_moves_list[i];\n if (cand_id == curr_move_id) continue;\n \n long long delta = 0;\n \n // Subtract curr impact\n for (const auto& cell : move_cells_flat[curr_move_id]) {\n int idx = cell.r * N_in + cell.c;\n int imp_curr = move_impact_flat_flat[curr_move_id][idx];\n int imp_cand = move_impact_flat_flat[cand_id][idx];\n \n long long val_old = board[cell.r][cell.c];\n long long val_new = (val_old - imp_curr + imp_cand + MOD) % MOD;\n delta += (val_new - val_old);\n }\n \n // Add cand impact\n for (const auto& cell : move_cells_flat[cand_id]) {\n int idx = cell.r * N_in + cell.c;\n if (visited[idx]) continue;\n int imp_cand = move_impact_flat_flat[cand_id][idx];\n long long val_old = board[cell.r][cell.c];\n long long val_new = val_old + imp_cand;\n if (val_new >= MOD) val_new -= MOD;\n delta += (val_new - val_old);\n }\n \n if (delta > best_delta) {\n best_delta = delta;\n best_cand_id = cand_id;\n }\n }\n \n // SA / Hill Climbing Acceptance\n // Accept if improvement or with probability based on temperature\n double accept_prob = (best_delta >= 0) ? 1.0 : exp((double)best_delta / temp);\n if (dist(rng) < accept_prob) {\n if (best_cand_id != curr_move_id) {\n current_moves[slot_idx] = best_cand_id;\n \n // Update board\n // Revert curr\n for (const auto& cell : move_cells_flat[curr_move_id]) {\n int idx = cell.r * N_in + cell.c;\n long long val = board[cell.r][cell.c] - move_impact_flat_flat[curr_move_id][idx];\n if (val < 0) val += MOD;\n board[cell.r][cell.c] = val;\n }\n // Apply cand\n for (const auto& cell : move_cells_flat[best_cand_id]) {\n int idx = cell.r * N_in + cell.c;\n long long val = board[cell.r][cell.c] + move_impact_flat_flat[best_cand_id][idx];\n if (val >= MOD) val -= MOD;\n board[cell.r][cell.c] = val;\n }\n }\n current_score += best_delta;\n }\n \n // Reset visited\n for (int k = 0; k < vic_count; ++k) {\n visited[visited_indices[k]] = false;\n }\n \n // Decay temperature\n temp *= decay;\n }\n\n // Output result\n vector>> final_ops;\n for (int i = 0; i < K; ++i) {\n if (current_moves[i] != 980) { // None ID\n int id = current_moves[i];\n int m = id / 49;\n int rem = id % 49;\n int p = rem / 7;\n int q = rem % 7;\n final_ops.push_back({m, {p, q}});\n }\n }\n \n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_ops) {\n cout << op.first << \" \" << op.second.first << \" \" << op.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_N = 5;\nconst int MAX_TURNS = 5000;\n\nint grid[MAX_N][MAX_N];\npair crane_pos[MAX_N];\nint crane_load[MAX_N];\nint A[MAX_N][MAX_N];\nint input_idx[MAX_N];\nstring ans[MAX_N];\nbool is_crane_here[MAX_N]; // Track if crane occupies each cell\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char move_char[] = {'U', 'D', 'L', 'R'};\n\nstruct Crane {\n int id;\n int type; // 0:Wait, 1:Move, 2:P, 3:Q\n int nr, nc;\n int score;\n int dist; // Distance to target for tie-breaking\n};\n\nvoid solve() {\n int N = 5;\n \n // Initialization\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) grid[i][j] = -1;\n input_idx[i] = 0;\n crane_pos[i] = {i, 0};\n crane_load[i] = -1;\n ans[i] = \"\";\n is_crane_here[i] = false;\n }\n\n int held_cnt = 0;\n int turns = 0;\n \n while (turns < MAX_TURNS) {\n // Check termination\n int total_received = 0;\n for (int i = 0; i < N; ++i) total_received += input_idx[i];\n if (total_received >= N * N && held_cnt == 0) break;\n\n // Step 1: Input Spawning\n for (int i = 0; i < N; ++i) {\n if (input_idx[i] == N) continue;\n bool blocked = (grid[i][0] != -1);\n for (int c = 0; c < N; ++c) {\n if (crane_pos[c].first == i && crane_pos[c].second == 0) {\n if (crane_load[c] != -1) {\n blocked = true;\n break;\n }\n }\n }\n if (!blocked) {\n grid[i][0] = A[i][input_idx[i]];\n input_idx[i]++;\n }\n }\n\n total_received = 0;\n for (int i = 0; i < N; ++i) total_received += input_idx[i];\n if (total_received >= N * N && held_cnt == 0) break;\n\n // Step 2: Build crane occupancy map\n map, int> occupancy;\n for (int i = 0; i < N; ++i) {\n occupancy[crane_pos[i]] = i; // Crane ID\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = true;\n }\n\n // Step 3: Plan Actions\n vector cranes(N);\n for (int i = 0; i < N; ++i) {\n cranes[i].id = i;\n cranes[i].nr = crane_pos[i].first;\n cranes[i].nc = crane_pos[i].second;\n cranes[i].score = 0;\n cranes[i].dist = 100;\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n\n // Priority 1: Q (Dispatch at correct gate)\n if (c == N - 1 && crane_load[i] != -1) {\n int row_id = crane_load[i] / N;\n if (row_id == r) {\n cranes[i].type = 3;\n cranes[i].score = 20000;\n cranes[i].dist = 0;\n }\n }\n\n // Priority 2: P (Pickup container)\n if (cranes[i].type == 0 && crane_load[i] == -1) {\n if (grid[r][c] != -1) {\n cranes[i].type = 2;\n cranes[i].score = 10000;\n cranes[i].dist = 0;\n }\n }\n\n // Priority 3: Move toward nearest goal\n if (cranes[i].type == 0) {\n int tr = r, tc = c;\n int dist_bonus = 0;\n\n if (crane_load[i] != -1) {\n tr = crane_load[i] / N;\n tc = N - 1;\n dist_bonus = 1000;\n } else {\n // Find row with most pending input\n int best_row = -1;\n int max_pending = 0;\n for (int k = 0; k < N; ++k) {\n if (input_idx[k] < N) {\n if (input_idx[k] > max_pending) {\n max_pending = input_idx[k];\n best_row = k;\n }\n }\n }\n if (best_row == -1) {\n for (int k = 0; k < N; ++k) {\n if (input_idx[k] < N) {\n best_row = k;\n break;\n }\n }\n }\n if (best_row != -1) {\n tr = best_row;\n tc = 0;\n dist_bonus = 5 * max_pending;\n }\n }\n\n int dist = abs(r - tr) + abs(c - tc);\n cranes[i].nr = tr;\n cranes[i].nc = tc;\n cranes[i].type = 1;\n cranes[i].score = dist_bonus - dist;\n cranes[i].dist = dist;\n }\n\n // LC bonus for conflict resolution\n if (i == 0) cranes[i].score += 3000;\n }\n\n // Step 4: Collision Resolution with lookahead\n vector final_type(N, 0);\n vector> final_pos(N);\n \n // Sort by score\n vector order(N);\n for(int i=0; i cranes[b].score;\n return cranes[a].dist < cranes[b].dist; // Prefer shorter distance\n });\n\n // Process in priority order\n for (int k = 0; k < N; ++k) {\n int cr = order[k];\n int current_dist = abs(crane_pos[cr].first - cranes[cr].nr) + \n abs(crane_pos[cr].second - cranes[cr].nc);\n \n if (current_dist == 0) {\n // At target, check for P/Q\n final_type[cr] = cranes[cr].type;\n final_pos[cr] = crane_pos[cr];\n continue;\n }\n \n if (cranes[cr].type == 1) {\n // Calculate actual distance using BFS-like simple check\n // Check if we can move toward target\n bool can_move = true;\n int nr = crane_pos[cr].first;\n int nc = crane_pos[cr].second;\n \n // Prefer move that gets closer to target\n int best_dir = -1;\n int best_dist = 10000;\n \n for (int d = 0; d < 4; ++d) {\n int tr = nr + dr[d];\n int tc = nc + dc[d];\n if (tr >= 0 && tr < N && tc >= 0 && tc < N) {\n // Check if target square is valid\n bool occupied = is_crane_here[tr * N + tc];\n if (occupied && tr == nr && tc == nc) {\n // Self-check\n occupied = true;\n }\n \n // Small crane constraint\n if (cr > 0 && crane_load[cr] != -1) {\n if (grid[tr][tc] != -1) {\n occupied = true;\n }\n }\n \n if (!occupied) {\n int d_dist = abs(tr - cranes[cr].nr) + abs(tc - cranes[cr].nc);\n if (d_dist < best_dist) {\n best_dist = d_dist;\n best_dir = d;\n }\n }\n }\n }\n \n if (best_dir != -1 && best_dist < current_dist) {\n // Check swap collision\n int swap_target_r = nr + dr[best_dir];\n int swap_target_c = nc + dc[best_dir];\n for (int other = 0; other < N; ++other) {\n if (other == cr) continue;\n if (crane_pos[other] == crane_pos[cr]) {\n // Same spot, collision\n can_move = false;\n break;\n }\n // Check if other crane moving into cr's current spot\n }\n \n if (can_move) {\n final_type[cr] = 1;\n final_pos[cr] = {nr + dr[best_dir], nc + dc[best_dir]};\n } else {\n final_type[cr] = 0;\n final_pos[cr] = crane_pos[cr];\n }\n } else {\n final_type[cr] = 0;\n final_pos[cr] = crane_pos[cr];\n }\n } else {\n final_type[cr] = 0;\n final_pos[cr] = crane_pos[cr];\n }\n }\n\n // Step 5: Execute Actions\n int next_grid[MAX_N][MAX_N];\n for(int i = 0; i < N; ++i)\n for(int j = 0; j < N; ++j)\n next_grid[i][j] = grid[i][j];\n\n string action_per_cran[MAX_N] = {\".\"};\n \n for (int i = 0; i < N; ++i) {\n int r = crane_pos[i].first;\n int c = crane_pos[i].second;\n char act = '.';\n\n if (final_type[i] == 1) {\n int nr = final_pos[i].first;\n int nc = final_pos[i].second;\n for(int d=0; d<4; ++d) {\n if (r + dr[d] == nr && c + dc[d] == nc) {\n act = move_char[d];\n break;\n }\n }\n } else if (final_type[i] == 2) {\n act = 'P';\n int val = grid[r][c];\n crane_load[i] = val;\n next_grid[r][c] = -1;\n held_cnt++;\n } else if (final_type[i] == 3) {\n act = 'Q';\n crane_load[i] = -1;\n next_grid[r][c] = -1;\n held_cnt--;\n }\n \n ans[i] += act;\n }\n\n // Step 6: Update State\n for (int i = 0; i < N; ++i) {\n crane_pos[i] = final_pos[i];\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = true;\n }\n // Clear old occupancy marks first\n for (int i = 0; i < N; ++i) {\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = false;\n }\n // Set new occupancy marks\n for (int i = 0; i < N; ++i) {\n is_crane_here[crane_pos[i].first * N + crane_pos[i].second] = true;\n }\n \n for(int i=0; i> A[i][j];\n }\n }\n \n solve();\n \n int max_len = 0;\n for (int i = 0; i < 5; ++i) {\n max_len = max(max_len, (int)ans[i].size());\n }\n \n for (int i = 0; i < 5; ++i) {\n while (ans[i].size() < (size_t)max_len) {\n ans[i] += '.';\n }\n cout << ans[i] << \"\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint n;\nvector> heights;\n\nint manhattanDist(int r1, int c1, int r2, int c2) {\n return abs(r2 - r1) + abs(c2 - c1);\n}\n\nstring getMovePath(int fromR, int fromC, int toR, int toC) {\n string path = \"\";\n int curR = fromR, curC = fromC;\n \n while (curR != toR || curC != toC) {\n if (curR < toR) { path += \"D\"; curR++; }\n else if (curR > toR) { path += \"U\"; curR--; }\n else if (curC < toC) { path += \"R\"; curC++; }\n else if (curC > toC) { path += \"L\"; curC--; }\n }\n return path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> n;\n heights.resize(n, vector(n));\n \n vector> surplus;\n vector> deficit;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> heights[i][j];\n if (heights[i][j] > 0) {\n surplus.push_back({i, j});\n } else if (heights[i][j] < 0) {\n deficit.push_back({i, j});\n }\n }\n }\n \n struct Transport {\n int fromR, fromC;\n int toR, toC;\n int amt;\n int dist;\n };\n \n vector transports;\n \n for (int i = 0; i < surplus.size(); i++) {\n for (int j = 0; j < deficit.size(); j++) {\n int fr = surplus[i].first, fc = surplus[i].second;\n int tr = deficit[j].first, tc = deficit[j].second;\n int h = min(heights[fr][fc], -heights[tr][tc]);\n \n if (h <= 0) continue;\n \n int dist = manhattanDist(fr, fc, tr, tc);\n transports.push_back({fr, fc, tr, tc, h, dist});\n }\n }\n \n sort(transports.begin(), transports.end(), [](const Transport& a, const Transport& b) {\n return a.dist < b.dist;\n });\n \n vector ops;\n int curR = 0, curC = 0;\n int truckLoad = 0;\n \n for (const auto& t : transports) {\n int amt = t.amt;\n if (amt <= 0) continue;\n \n // Move to source\n string path1 = getMovePath(curR, curC, t.fromR, t.fromC);\n ops.insert(ops.end(), path1.begin(), path1.end());\n curR = t.fromR;\n curC = t.fromC;\n \n // Load\n for (int k = 0; k < amt; k++) {\n ops += \"+1\";\n truckLoad++;\n }\n heights[t.fromR][t.fromC] -= amt;\n \n // Move to destination\n string path2 = getMovePath(curR, curC, t.toR, t.toC);\n ops.insert(ops.end(), path2.begin(), path2.end());\n curR = t.toR;\n curC = t.toC;\n \n // Unload\n for (int k = 0; k < amt; k++) {\n ops += \"-1\";\n truckLoad--;\n }\n heights[t.toR][t.toC] += amt;\n }\n \n cout << ops.size() << \"\\n\";\n for (const string& op : ops) {\n cout << op << \"\\n\";\n }\n \n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n int id;\n vector values;\n int total_value;\n int max_value;\n};\n\nstruct PosInfo {\n int r, c;\n int dist_sq;\n int degree;\n};\n\nbool comparePositions(const PosInfo& a, const PosInfo& b) {\n if (a.degree != b.degree) return a.degree > b.degree;\n if (a.dist_sq != b.dist_sq) return a.dist_sq < b.dist_sq;\n return a.r < b.r;\n}\n\nvector precomputePositions(int N) {\n vector positions;\n positions.reserve(N * N);\n int center_val = N - 1;\n \n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int dr = 2 * r - center_val;\n int dc = 2 * c - center_val;\n int d2 = dr * dr + dc * dc;\n \n int degree = 4;\n if (r == 0 || r == N - 1) degree--;\n if (c == 0 || c == N - 1) degree--;\n \n positions.push_back({r, c, d2, degree});\n }\n }\n \n sort(positions.begin(), positions.end(), comparePositions);\n return positions;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n\n int seed_count = 2 * N * (N - 1);\n vector seeds_list(seed_count);\n vector max_val_per_criterion(M, 0);\n\n // Read initial seeds\n for (int k = 0; k < seed_count; ++k) {\n seeds_list[k].id = k;\n seeds_list[k].values.resize(M, 0);\n seeds_list[k].total_value = 0;\n seeds_list[k].max_value = 0;\n \n for (int l = 0; l < M; ++l) {\n cin >> seeds_list[k].values[l];\n seeds_list[k].total_value += seeds_list[k].values[l];\n seeds_list[k].max_value = max(seeds_list[k].max_value, seeds_list[k].values[l]);\n }\n \n for (int l = 0; l < M; ++l) {\n max_val_per_criterion[l] = max(max_val_per_criterion[l], seeds_list[k].values[l]);\n }\n }\n\n vector positions = precomputePositions(N);\n const size_t grid_size = static_cast(N) * N;\n\n for (int t = 0; t < T; ++t) {\n // Recalculate max values per criterion\n fill(max_val_per_criterion.begin(), max_val_per_criterion.end(), 0);\n for (const auto& s : seeds_list) {\n for (int l = 0; l < M; ++l) {\n max_val_per_criterion[l] = max(max_val_per_criterion[l], s.values[l]);\n }\n }\n\n // Count max holders per criterion\n vector max_count(M, 0);\n for (const auto& s : seeds_list) {\n for (int l = 0; l < M; ++l) {\n if (s.values[l] == max_val_per_criterion[l] && s.values[l] > 0) {\n max_count[l]++;\n }\n }\n }\n\n // Calculate priority with tiered value system\n struct SeedRank {\n int id;\n long long priority;\n int unique_max_count;\n int high_95_count; // values >= 95% of max\n int high_90_count; // values >= 90% of max\n };\n vector rank_list(seed_count);\n\n for (int k = 0; k < seed_count; ++k) {\n long long score = 0;\n int um_count = 0;\n int h95_count = 0; // >= 95% of max\n int h90_count = 0; // >= 90% of max\n \n for (int l = 0; l < M; ++l) {\n int max_val = max_val_per_criterion[l];\n int val = seeds_list[k].values[l];\n \n if (max_val > 0) {\n // True maximum (highest value in this criterion)\n if (val == max_val && val > 0) {\n score += 100;\n um_count++;\n h90_count++;\n if (max_count[l] == 1) {\n score += 650; // Strong boost for unique max\n }\n }\n \n // 95%+ threshold\n if (val >= max_val * 95 / 100) {\n h95_count++;\n h90_count++;\n score += 35;\n }\n // 90%+ threshold (but below 95%)\n else if (val >= max_val * 90 / 100) {\n h90_count++;\n score += 20;\n }\n // 85%+ threshold (lower tier)\n else if (val >= max_val * 85 / 100) {\n score += 10;\n }\n }\n }\n \n // Sum contribution (high weight)\n score += (long long)seeds_list[k].total_value * 15;\n score += seeds_list[k].max_value * 5;\n \n // Tiered bonuses\n score += h95_count * 40; // Very high values\n score += h90_count * 20; // High values\n score += (long long)um_count * 300; // Unique max holders priority\n score += seeds_list[k].max_value * 2; // Max value per seed\n \n rank_list[k] = {k, score, um_count, h95_count, h90_count};\n }\n\n // Sort by priority with unique_max as primary differentiator\n sort(rank_list.begin(), rank_list.end(), \n [&seeds_list](const SeedRank& a, const SeedRank& b) {\n // Primary: unique max count (ensure these reach center)\n if (a.unique_max_count != b.unique_max_count) {\n return a.unique_max_count > b.unique_max_count;\n }\n // Secondary: 95%+ value count\n if (a.high_95_count != b.high_95_count) {\n return a.high_95_count > b.high_95_count;\n }\n // Tertiary: 90%+ value count\n if (a.high_90_count != b.high_90_count) {\n return a.high_90_count > b.high_90_count;\n }\n // Quaternary: priority score\n if (a.priority != b.priority) {\n return a.priority > b.priority;\n }\n // Final: total value\n return seeds_list[a.id].total_value > seeds_list[b.id].total_value;\n });\n\n // Select top seeds while preserving rank order\n vector selected;\n const size_t select_count = min(grid_size, rank_list.size());\n for (size_t k = 0; k < select_count; ++k) {\n selected.push_back(rank_list[k].id);\n }\n\n // Assign by position order (positions already sorted by degree)\n vector> grid(N, vector(N, -1));\n for (size_t k = 0; k < select_count; ++k) {\n if (k < positions.size()) {\n grid[positions[k].r][positions[k].c] = selected[k];\n }\n }\n\n // Output grid\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cout << grid[r][c] << (c == N - 1 ? \"\\n\" : \" \");\n }\n }\n cout.flush();\n\n // Read new seeds for next turn\n for (int k = 0; k < seed_count; ++k) {\n seeds_list[k].values.clear();\n seeds_list[k].values.resize(M, 0);\n seeds_list[k].total_value = 0;\n seeds_list[k].max_value = 0;\n for (int l = 0; l < M; ++l) {\n cin >> seeds_list[k].values[l];\n seeds_list[k].total_value += seeds_list[k].values[l];\n seeds_list[k].max_value = max(seeds_list[k].max_value, seeds_list[k].values[l]);\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a coordinate pair\nstruct Point {\n int r, c;\n};\n\n// Structure to represent a task (moving an item from src to tgt)\nstruct Task {\n Point src, tgt;\n};\n\nint N, M, V;\nint grid_s[35][35];\nint grid_t[35][35];\n\nint main() {\n // Optimize I/O operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> V)) return 0;\n\n vector sources;\n vector targets;\n\n // Read initial positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_s[i][j] = (s[j] == '1');\n if (grid_s[i][j]) sources.push_back({i, j});\n }\n }\n // Read target positions\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n grid_t[i][j] = (s[j] == '1');\n if (grid_t[i][j]) targets.push_back({i, j});\n }\n }\n\n // Filter out sources that are already on targets, \n // and targets that are already occupied.\n vector active_sources;\n vector active_targets;\n\n vector> is_target(N, vector(N, false));\n for(const auto& t : targets) is_target[t.r][t.c] = true;\n\n vector> is_source(N, vector(N, false));\n for(const auto& s : sources) is_source[s.r][s.c] = true;\n\n // Identify active sources (sources not on targets)\n for(const auto& s : sources) {\n if(!is_target[s.r][s.c]) active_sources.push_back(s);\n }\n // Identify active targets (targets not on sources)\n for(const auto& t : targets) {\n if(!is_source[t.r][t.c]) active_targets.push_back(t);\n }\n\n // Greedy matching between active sources and active targets\n // Since constraints are small (N<=30, M<=225), O(M^2) is acceptable.\n vector tasks;\n vector tgt_used(active_targets.size(), false);\n\n for (const auto& s : active_sources) {\n int best_idx = -1;\n int min_dist = 2000; // Max dist is roughly 60\n for (int i = 0; i < (int)active_targets.size(); ++i) {\n if (!tgt_used[i]) {\n int d = abs(s.r - active_targets[i].r) + abs(s.c - active_targets[i].c);\n if (d < min_dist) {\n min_dist = d;\n best_idx = i;\n }\n }\n }\n if (best_idx != -1) {\n tgt_used[best_idx] = true;\n tasks.push_back({s, active_targets[best_idx]});\n }\n }\n\n // --- Output Robotic Arm Design ---\n // We use a Star Graph: Root (0) connected to 1, 2, ..., V-1.\n // Edge lengths are all 1.\n cout << V << \"\\n\";\n for (int i = 1; i < V; ++i) {\n cout << 0 << \" \" << 1 << \"\\n\";\n }\n // Initial Root Position: Center of the grid\n cout << (N / 2) << \" \" << (N / 2) << \"\\n\";\n\n // --- Simulation ---\n int root_r = N / 2;\n int root_c = N / 2;\n int finger_dir = 0; // 0: Right, 1: Down, 2: Left, 3: Up. Initial state: Right (0)\n int dx[4] = {0, 1, 0, -1};\n int dy[4] = {1, 0, -1, 0};\n\n // Output buffer string\n string buf(2 * V, '.'); \n\n // Execute each task: Pick from Source -> Move -> Deliver at Target -> Place\n for (const auto& task : tasks) {\n Point src = task.src;\n Point tgt = task.tgt;\n\n // --- STEP 1: PICK UP ---\n \n // Find valid Root position and orientation to reach Source\n int pick_r = -1, pick_c = -1, pick_d = -1;\n int min_cost = 1e9;\n\n // Try all 4 directions for Finger 1\n for (int d = 0; d < 4; ++d) {\n // If finger points at src, Root must be at src - offset\n int r = src.r - dx[d];\n int c = src.c - dy[d];\n // Check bounds\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n // Prefer shorter distance; tie-break with preferred direction if possible\n if (dist < min_cost || (dist == min_cost && d == finger_dir)) {\n min_cost = dist;\n pick_r = r;\n pick_c = c;\n pick_d = d;\n }\n }\n }\n\n // Move Root to pick position\n int dr = 0, dc = 0;\n if (root_r < pick_r) dr = 1;\n if (root_r > pick_r) dr = -1;\n if (root_c < pick_c) dc = 1;\n if (root_c > pick_c) dc = -1;\n\n for (int k = 0; k < min_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n // Rotation and Action are '.' (no-op)\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1 to match direction\n while (finger_dir != pick_d) {\n buf[0] = '.'; // Move is idle\n buf[1] = '.'; // Reset rotation char\n buf[V + 1] = '.'; // Reset action char\n \n int diff = (pick_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R'; // CW 90\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L'; // CCW 90\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Pick Up Action (Vertex 1 Action is at index V + 1)\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n\n // --- STEP 2: DELIVER ---\n \n // Find valid Root position and orientation to reach Target\n int del_r = -1, del_c = -1, del_d = -1;\n int del_cost = 1e9;\n\n for (int d = 0; d < 4; ++d) {\n int r = tgt.r - dx[d];\n int c = tgt.c - dy[d];\n if (r >= 0 && r < N && c >= 0 && c < N) {\n int dist = abs(root_r - r) + abs(root_c - c);\n if (dist < del_cost || (dist == del_cost && d == finger_dir)) {\n del_cost = dist;\n del_r = r;\n del_c = c;\n del_d = d;\n }\n }\n }\n\n // Move Root to target position\n dr = dc = 0;\n if (root_r < del_r) dr = 1;\n if (root_r > del_r) dr = -1;\n if (root_c < del_c) dc = 1;\n if (root_c > del_c) dc = -1;\n\n for (int k = 0; k < del_cost; ++k) {\n buf[0] = (dr != 0 ? ((dr == 1) ? 'D' : 'U') : ((dc != 0) ? ((dc == 1) ? 'R' : 'L') : '.'));\n cout << buf << \"\\n\";\n root_r += dr;\n root_c += dc;\n }\n\n // Rotate Finger 1\n while (finger_dir != del_d) {\n buf[0] = '.'; \n buf[1] = '.';\n buf[V + 1] = '.'; \n int diff = (del_d - finger_dir + 4) % 4;\n if (diff == 1) {\n buf[1] = 'R';\n finger_dir = (finger_dir + 1) % 4;\n } else {\n buf[1] = 'L';\n finger_dir = (finger_dir + 3) % 4;\n }\n cout << buf << \"\\n\";\n }\n\n // Place Action\n buf[0] = '.';\n buf[1] = '.';\n buf[V + 1] = 'P';\n cout << buf << \"\\n\";\n }\n\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n\nstruct RectInfo {\n int x_min, x_max, y_min, y_max;\n int mc, sc;\n int score;\n};\n\nint main() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n\n int N;\n if (!(std::cin >> N)) return 0;\n\n std::vector> mackerels(N);\n std::vector> sardines(N);\n\n for (int i = 0; i < N; ++i) std::cin >> mackerels[i].first >> mackerels[i].second;\n for (int i = 0; i < N; ++i) std::cin >> sardines[i].first >> sardines[i].second;\n\n // K-means clustering - 8 clusters worked best historically\n int k_clusters = 8;\n k_clusters = std::min(k_clusters, N);\n \n std::vector> centroids(k_clusters);\n std::vector> clusters(k_clusters);\n \n // Initialize centroids from evenly distributed mackerels\n for (int i = 0; i < k_clusters; ++i) {\n int idx = std::min(i * N / k_clusters, N - 1);\n centroids[i] = mackerels[idx];\n }\n \n // K-means iteration - 10 iterations for convergence\n for (int iter = 0; iter < 10; ++iter) {\n for (int c = 0; c < k_clusters; ++c) clusters[c].clear();\n \n for (int i = 0; i < N; ++i) {\n int best_c = 0, min_d = -1;\n for (int c = 0; c < k_clusters; ++c) {\n long long dx = mackerels[i].first - centroids[c].first;\n long long dy = mackerels[i].second - centroids[c].second;\n long long d = dx * dx + dy * dy;\n if (min_d == -1 || d < min_d) { min_d = d; best_c = c; }\n }\n clusters[best_c].push_back(i);\n }\n \n for (int c = 0; c < k_clusters; ++c) {\n if (clusters[c].empty()) continue;\n long long sx = 0, sy = 0;\n for (int idx : clusters[c]) { \n sx += mackerels[idx].first; \n sy += mackerels[idx].second; \n }\n centroids[c].first = static_cast(sx / clusters[c].size());\n centroids[c].second = static_cast(sy / clusters[c].size());\n }\n }\n \n // Evaluate rectangles with 4\u00d74 expansion (proven winner)\n std::vector all_rects;\n all_rects.reserve(k_clusters * 16);\n \n const int expansions[] = {-1, 0, 1, 2};\n \n for (int c = 0; c < k_clusters; ++c) {\n if (clusters[c].empty()) continue;\n \n int x_min = 100005, x_max = -1, y_min = 100005, y_max = -1;\n for (int idx : clusters[c]) {\n x_min = std::min(x_min, mackerels[idx].first);\n x_max = std::max(x_max, mackerels[idx].first);\n y_min = std::min(y_min, mackerels[idx].second);\n y_max = std::max(y_max, mackerels[idx].second);\n }\n \n // Evaluate all expansion combinations\n for (int ex : expansions) {\n for (int ey : expansions) {\n int exp_xmin = std::max(0, x_min + ex);\n int exp_xmax = std::min(100000, x_max + ex);\n int exp_ymin = std::max(0, y_min + ey);\n int exp_ymax = std::min(100000, y_max + ey);\n \n // Ensure valid dimensions\n if (exp_xmin >= exp_xmax || exp_ymin >= exp_ymax) continue;\n \n // Minimum size constraint (5 is better than 10)\n if (exp_xmax - exp_xmin < 5) exp_xmax = exp_xmin + 5;\n if (exp_ymax - exp_ymin < 5) exp_ymax = exp_ymin + 5;\n \n int mc = 0, sc = 0;\n for (const auto& p : mackerels) {\n if (p.first >= exp_xmin && p.first <= exp_xmax && p.second >= exp_ymin && p.second <= exp_ymax) mc++;\n }\n for (const auto& p : sardines) {\n if (p.first >= exp_xmin && p.first <= exp_xmax && p.second >= exp_ymin && p.second <= exp_ymax) sc++;\n }\n \n all_rects.push_back({exp_xmin, exp_xmax, exp_ymin, exp_ymax, mc, sc, mc - sc});\n }\n }\n }\n \n // Sort by score descending\n std::sort(all_rects.begin(), all_rects.end(), [](const RectInfo& a, const RectInfo& b) {\n return a.score > b.score;\n });\n \n // Pick the best rectangle\n RectInfo best = all_rects[0];\n \n // Output single axis-aligned rectangle\n std::cout << \"4\\n\";\n std::cout << best.x_min << \" \" << best.y_min << \"\\n\";\n std::cout << best.x_max << \" \" << best.y_min << \"\\n\";\n std::cout << best.x_max << \" \" << best.y_max << \"\\n\";\n std::cout << best.x_min << \" \" << best.y_max << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Structure to represent a placement decision for a rectangle\nstruct Decision {\n int id; // Original rectangle index (0 to N-1)\n int r; // Rotation: 0 or 1\n char d; // Direction: 'U' or 'L'\n int b; // Base rectangle index (value of p_j for j < i, or -1)\n};\n\nstruct Rect {\n long long w, h;\n};\n\n// Global variables for N and T\nint N, T;\nvector rects;\n\n// Function to evaluate the proxy cost (estimated W + H)\nlong long get_cost(const vector& config) {\n int n = config.size();\n \n // Validation: IDs must be 0 to N-1 in order\n for(int i = 0; i < n; ++i) {\n if(i >= (int)rects.size() || config[i].id != i) return 1e18;\n }\n \n // Track active columns and rows for skyline-based placement\n struct Col { long long x; long long height; };\n struct Row { long long y; long long width; };\n \n vector cols;\n vector rows;\n \n vector> dims(n);\n vector> pos(n);\n \n for(int i = 0; i < n; ++i) {\n long long w, h;\n if(config[i].r == 0) {\n w = rects[config[i].id].w;\n h = rects[config[i].id].h;\n } else {\n w = rects[config[i].id].h;\n h = rects[config[i].id].w;\n }\n dims[i] = {w, h};\n \n long long px, py;\n \n if(config[i].d == 'U') {\n // U: Left edge aligned to Right edge of base b, or x=0 if b=-1\n if(config[i].b == -1) {\n px = 0;\n } else {\n if(config[i].b < 0 || config[i].b >= i) return 1e18;\n px = pos[config[i].b].first + dims[config[i].b].first;\n }\n \n // Find column height at this x position\n long long col_h = 0;\n for(size_t j = 0; j < cols.size(); j++) {\n if(cols[j].x == px) {\n col_h = cols[j].height;\n break;\n }\n }\n py = col_h;\n \n // Update column height\n bool found = false;\n for(size_t j = 0; j < cols.size(); j++) {\n if(cols[j].x == px) {\n cols[j].height = max(cols[j].height, py + h);\n found = true;\n break;\n }\n }\n if(!found) {\n cols.push_back({px, py + h});\n }\n } else { // 'L'\n // L: Top edge aligned to Bottom edge of base b, or y=0 if b=-1\n if(config[i].b == -1) {\n py = 0;\n } else {\n if(config[i].b < 0 || config[i].b >= i) return 1e18;\n py = pos[config[i].b].second + dims[config[i].b].second;\n }\n \n // Find row width at this y position\n long long row_w = 0;\n for(size_t j = 0; j < rows.size(); j++) {\n if(rows[j].y == py) {\n row_w = rows[j].width;\n break;\n }\n }\n px = row_w;\n \n // Update row width\n bool found = false;\n for(size_t j = 0; j < rows.size(); j++) {\n if(rows[j].y == py) {\n rows[j].width = max(rows[j].width, px + w);\n found = true;\n break;\n }\n }\n if(!found) {\n rows.push_back({py, px + w});\n }\n }\n \n pos[i] = {px, py};\n }\n \n // Calculate bounding box\n long long global_max_W = 0;\n long long global_max_H = 0;\n \n for(int i = 0; i < n; ++i) {\n global_max_W = max(global_max_W, pos[i].first + dims[i].first);\n global_max_H = max(global_max_H, pos[i].second + dims[i].second);\n }\n \n return global_max_W + global_max_H;\n}\n\nvector init_config() {\n vector config(N);\n for(int i = 0; i < N; ++i) {\n config[i].id = i;\n config[i].r = (i % 2 == 0) ? 0 : 1;\n config[i].d = (i % 2 == 0) ? 'U' : 'L';\n if(i == 0) {\n config[i].b = -1;\n } else {\n config[i].b = -1;\n }\n }\n return config;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> T)) return 0;\n long long sigma;\n cin >> sigma;\n\n rects.resize(N);\n for(int i = 0; i < N; ++i) {\n cin >> rects[i].w >> rects[i].h;\n }\n\n // Simple initialization\n vector best_config = init_config();\n long long global_best_score = get_cost(best_config);\n\n int hill_climbing_iters = 50;\n\n // Main loop for T turns\n for(int t = 0; t < T; ++t) {\n vector candidate = best_config;\n long long current_score = global_best_score;\n\n // Seed RNG for this iteration\n unsigned seed = t * 12345 + 67890;\n mt19937 rng(seed);\n\n for(int it = 0; it < hill_climbing_iters; ++it) {\n int i = (int)(rng() % N);\n\n // 1. Try flipping Rotation (r)\n {\n int old_r = candidate[i].r;\n candidate[i].r = 1 - old_r;\n long long sc = get_cost(candidate);\n if(sc < current_score) current_score = sc;\n else candidate[i].r = old_r;\n }\n\n // 2. Try flipping Direction (d)\n {\n char old_d = candidate[i].d;\n candidate[i].d = (old_d == 'L' ? 'U' : 'L');\n long long sc = get_cost(candidate);\n if(sc < current_score) current_score = sc;\n else candidate[i].d = old_d;\n }\n\n // 3. Try changing Base (b) - try -1 or random valid index\n {\n int old_b = candidate[i].b;\n int new_b;\n if(i == 0) {\n new_b = -1;\n } else if((int)rng() % 2 == 0) {\n new_b = -1;\n } else {\n new_b = (int)(rng() % (long long)i);\n }\n if(new_b != old_b) {\n candidate[i].b = new_b;\n long long sc = get_cost(candidate);\n if(sc < current_score) current_score = sc;\n else candidate[i].b = old_b;\n }\n }\n }\n\n if(current_score < global_best_score) {\n global_best_score = current_score;\n best_config = candidate;\n }\n\n cout << best_config.size() << \"\\n\";\n for(const auto& d : best_config) {\n cout << d.id << \" \" << d.r << \" \" << d.d << \" \" << d.b << \"\\n\";\n }\n cout.flush();\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nconst int MAXN = 1005;\n\nint N, M, H;\nlong long beauty[MAXN];\nvector adj[MAXN];\nint parent_node[MAXN];\nint depth_node[MAXN];\n\n// Recompute all depths from parent assignments\nvoid recompute_depths() {\n memset(depth_node, -1, sizeof(depth_node));\n queue q;\n for (int i = 0; i < N; i++) {\n if (parent_node[i] == -1) {\n depth_node[i] = 0;\n q.push(i);\n }\n }\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n for (int v : adj[u]) {\n if (parent_node[v] == u && depth_node[v] == -1) {\n depth_node[v] = depth_node[u] + 1;\n q.push(v);\n }\n }\n }\n}\n\n// Calculate total attractiveness score\nlong long calculate_score() {\n recompute_depths();\n long long score = 0;\n for (int i = 0; i < N; i++) {\n if (depth_node[i] >= 0 && depth_node[i] <= H) {\n score += (long long)(depth_node[i] + 1) * beauty[i];\n }\n }\n return score;\n}\n\n// Check if current assignment is valid\nbool is_valid() {\n recompute_depths();\n for (int i = 0; i < N; i++) {\n if (depth_node[i] == -1 || depth_node[i] > H) {\n return false;\n }\n }\n return true;\n}\n\n// Initial greedy - BFS to cover all nodes\nvoid initialize_assignment() {\n for (int i = 0; i < N; i++) {\n parent_node[i] = -1;\n depth_node[i] = 0;\n }\n \n vector visited(N, false);\n queue> q;\n \n for (int start = 0; start < N; start++) {\n if (!visited[start]) {\n q.push({start, 0});\n visited[start] = true;\n parent_node[start] = -1;\n depth_node[start] = 0;\n \n while (!q.empty()) {\n pair cur = q.front();\n q.pop();\n int u = cur.first;\n int d = cur.second;\n \n for (int v : adj[u]) {\n if (!visited[v] && d < H) {\n visited[v] = true;\n parent_node[v] = u;\n depth_node[v] = d + 1;\n q.push({v, d + 1});\n }\n }\n }\n }\n }\n}\n\n// Try moving vertex v to parent p, return new score or -1 if invalid\nlong long try_move(int v, int p) {\n if (v == p) return -1;\n \n // Check if p is a neighbor (or -1 for root)\n if (p != -1) {\n bool in_adj = false;\n for (int neighbor : adj[v]) {\n if (neighbor == p) {\n in_adj = true;\n break;\n }\n }\n if (!in_adj) return -1;\n }\n \n int old_parent = parent_node[v];\n parent_node[v] = p;\n \n if (!is_valid()) {\n parent_node[v] = old_parent;\n return -1;\n }\n \n long long score = calculate_score();\n parent_node[v] = old_parent;\n return score;\n}\n\n// Find the best parent for v\nint find_best_parent(int v) {\n int best_p = parent_node[v];\n long long best_score = try_move(v, best_p);\n \n // Try all neighbors\n for (int p : adj[v]) {\n if (depth_node[p] >= H - 1) continue; // Quick filter\n \n long long s = try_move(v, p);\n if (s > best_score) {\n best_score = s;\n best_p = p;\n }\n }\n \n // Also try -1 (make it a root)\n long long s = try_move(v, -1);\n if (s > best_score) {\n best_score = s;\n best_p = -1;\n }\n \n return best_p;\n}\n\nvoid local_search(int iterations) {\n recompute_depths();\n \n // Sort by beauty descending\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [](int a, int b) {\n return beauty[a] > beauty[b];\n });\n \n int iter_count = 0;\n bool improved = true;\n \n while (improved && iter_count < iterations) {\n improved = false;\n iter_count++;\n \n for (int idx = 0; idx < N; idx++) {\n int v = order[idx % N];\n int old_p = parent_node[v];\n int new_p = find_best_parent(v);\n \n if (new_p != old_p) {\n parent_node[v] = new_p;\n improved = true;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n cin >> N >> M >> H;\n \n for (int i = 0; i < N; i++) {\n cin >> beauty[i];\n }\n \n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n \n // Initial assignment\n initialize_assignment();\n recompute_depths();\n \n // Optimized local search\n local_search(10000);\n \n // Final validity check - reinitialize if needed\n if (!is_valid()) {\n initialize_assignment();\n recompute_depths();\n }\n \n // Output result\n cout << parent_node[0];\n for (int i = 1; i < N; i++) {\n cout << \" \" << parent_node[i];\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Oni {\n int id;\n int r, c;\n};\n\nstruct MoveCandidate {\n int dist; // steps to shift\n char dir; // 'U', 'D', 'L', 'R'\n int cost; // total operations (2 * dist)\n int idx; // row if L/R, col if U/D\n vector removed_indices; // Oni IDs removed by this move\n int original_idx; // For stable ordering\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector board(N);\n vector valid_onis;\n vector> all_fuku;\n\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n valid_onis.push_back({(int)valid_onis.size(), i, j});\n } else if (board[i][j] == 'o') {\n all_fuku.push_back({i, j});\n }\n }\n }\n\n // Fukunokami position lookup\n vector> has_fuku(N, vector(N, false));\n for(auto& p : all_fuku) {\n has_fuku[p.first][p.second] = true;\n }\n\n const int NUM_ONI = valid_onis.size();\n int candidate_idx = 0;\n \n // Generate candidates for each Oni\n vector move_candidates;\n \n for(const auto& oni : valid_onis) {\n // 1. Up Direction\n bool safe = true;\n for(int k = 0; k < oni.r; ++k) {\n if(has_fuku[k][oni.c]) { safe = false; break; }\n }\n if(safe) {\n int d = oni.r + 1;\n MoveCandidate mc;\n mc.dist = d; mc.dir = 'U'; mc.cost = 2 * d; mc.idx = oni.c;\n mc.original_idx = candidate_idx++;\n for(const auto& o : valid_onis) {\n if(o.c == oni.c && o.r <= oni.r) \n mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n\n // 2. Down Direction\n safe = true;\n for(int k = oni.r + 1; k < N; ++k) {\n if(has_fuku[k][oni.c]) { safe = false; break; }\n }\n if(safe) {\n int d = N - oni.r;\n MoveCandidate mc;\n mc.dist = d; mc.dir = 'D'; mc.cost = 2 * d; mc.idx = oni.c;\n mc.original_idx = candidate_idx++;\n for(const auto& o : valid_onis) {\n if(o.c == oni.c && o.r >= oni.r) \n mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n\n // 3. Left Direction\n safe = true;\n for(int k = 0; k < oni.c; ++k) {\n if(has_fuku[oni.r][k]) { safe = false; break; }\n }\n if(safe) {\n int d = oni.c + 1;\n MoveCandidate mc;\n mc.dist = d; mc.dir = 'L'; mc.cost = 2 * d; mc.idx = oni.r;\n mc.original_idx = candidate_idx++;\n for(const auto& o : valid_onis) {\n if(o.r == oni.r && o.c <= oni.c) \n mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n\n // 4. Right Direction\n safe = true;\n for(int k = oni.c + 1; k < N; ++k) {\n if(has_fuku[oni.r][k]) { safe = false; break; }\n }\n if(safe) {\n int d = N - oni.c;\n MoveCandidate mc;\n mc.dist = d; mc.dir = 'R'; mc.cost = 2 * d; mc.idx = oni.r;\n mc.original_idx = candidate_idx++;\n for(const auto& o : valid_onis) {\n if(o.r == oni.r && o.c >= oni.c) \n mc.removed_indices.push_back(o.id);\n }\n move_candidates.push_back(mc);\n }\n }\n\n // Sort candidates for deterministic order\n sort(move_candidates.begin(), move_candidates.end(), \n [](const MoveCandidate& a, const MoveCandidate& b) {\n if (a.cost != b.cost) return a.cost < b.cost;\n if (a.dir != b.dir) return a.dir < b.dir;\n if (a.idx != b.idx) return a.idx < b.idx;\n return a.original_idx < b.original_idx;\n });\n\n // Track covered Oni\n vector is_covered(NUM_ONI, false);\n vector> total_ops;\n\n while(true) {\n int remaining = 0;\n for(int i = 0; i < NUM_ONI; ++i) {\n if(!is_covered[i]) remaining++;\n }\n if(remaining == 0) break;\n\n int best_idx = -1;\n int best_removed = 0;\n double best_score = -1.0;\n int best_cost = 1e9;\n int best_original_idx = -1;\n double best_efficiency = 0.0;\n\n // Find best candidate with progressive scoring\n for(size_t i = 0; i < move_candidates.size(); ++i) {\n MoveCandidate& mc = move_candidates[i];\n int new_cov = 0;\n for(int id : mc.removed_indices) {\n if(!is_covered[id]) new_cov++;\n }\n \n if(new_cov > 0) {\n double efficiency = (double)new_cov / mc.cost;\n int remaining_oni = NUM_ONI * 2; // Each move removes 2N total\n double progress_bonus = (double)(NUM_ONI - remaining + 1) / NUM_ONI;\n int coverage_bonus = mc.removed_indices.size();\n \n // Progressive scoring: favor efficiency early, coverage later\n double score = efficiency * 50.0 + \n new_cov * 2.0 * progress_bonus +\n coverage_bonus * 0.5;\n \n bool better = false;\n if(best_idx == -1) {\n better = true;\n } else if(score > best_score + 0.01) {\n better = true;\n } else if(abs(score - best_score) < 0.01) {\n if(new_cov > best_removed) {\n better = true;\n } else if(new_cov == best_removed && mc.cost < best_cost) {\n better = true;\n } else if(new_cov == best_removed && mc.cost == best_cost && \n efficiency > best_efficiency) {\n better = true;\n } else if(new_cov == best_removed && mc.cost == best_cost &&\n abs(efficiency - best_efficiency) < 0.01) {\n better = (mc.original_idx < best_original_idx);\n }\n }\n \n if(better) {\n best_idx = (int)i;\n best_removed = new_cov;\n best_cost = mc.cost;\n best_score = score;\n best_efficiency = efficiency;\n best_original_idx = mc.original_idx;\n }\n }\n }\n\n if(best_idx == -1) break;\n\n // Execute the chosen move\n const auto& mc = move_candidates[best_idx];\n char opposite = (mc.dir == 'U' ? 'D' : \n mc.dir == 'D' ? 'U' : \n mc.dir == 'L' ? 'R' : 'L');\n \n for(int step = 0; step < mc.dist; ++step) {\n total_ops.emplace_back(mc.dir, mc.idx);\n }\n for(int step = 0; step < mc.dist; ++step) {\n total_ops.emplace_back(opposite, mc.idx);\n }\n\n for(int id : mc.removed_indices) {\n is_covered[id] = true;\n }\n }\n\n // Output operations (no count line - per problem format)\n for(const auto& p : total_ops) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, L;\nint T[105];\nuint8_t A[105], B[105];\nint counts[105];\n\nint best_err = 2000000000;\nuint8_t best_A[105], best_B[105];\n\n// Fast simulation function\ninline int simulate(const uint8_t* a, const uint8_t* b) {\n for(int i = 0; i < N; ++i) counts[i] = 0;\n int cur = 0;\n counts[cur] = 1;\n for(int k = 1; k < L; ++k) {\n int next = (counts[cur] & 1) ? a[cur] : b[cur];\n counts[next]++;\n cur = next;\n }\n int err = 0;\n for(int i = 0; i < N; ++i) err += abs(counts[i] - T[i]);\n return err;\n}\n\n// Simplified smart initialization\nvoid smart_init(mt19937& rng, uint8_t* a, uint8_t* b) {\n uniform_int_distribution dist(0, N - 1);\n \n // Precompute weighted values once per seed\n vector weights(N);\n for(int j = 0; j < N; ++j) weights[j] = T[j] + 1;\n \n for(int i = 0; i < N; ++i) {\n // 65% weighted, 35% random for A\n uint64_t total_w = 0;\n for(int j = 0; j < N; ++j) total_w += weights[j];\n total_w--;\n uint64_t r = rng() % total_w;\n \n if(r < (uint64_t)N * total_w / 100 * 65) {\n // Weighted selection for A[i]\n int cumulative = 0;\n for(int j = 0; j < N; ++j) {\n if(j == i) continue;\n cumulative += weights[j];\n if(cumulative > (int)r) {\n a[i] = (uint8_t)j;\n break;\n }\n }\n } else {\n // Random for A[i]\n a[i] = dist(rng);\n }\n \n // 55% weighted, 45% random for B[i]\n r = rng() % total_w;\n if(r < (uint64_t)N * total_w / 100 * 55) {\n int cumulative = 0;\n for(int j = 0; j < N; ++j) {\n if(j == i) continue;\n cumulative += weights[j];\n if(cumulative > (int)r) {\n b[i] = (uint8_t)j;\n break;\n }\n }\n } else {\n b[i] = dist(rng);\n }\n \n // Ensure valid\n if(a[i] >= N) a[i] = 0;\n if(b[i] >= N) b[i] = 0;\n }\n}\n\nvoid run_search(mt19937& rng, int max_iters, chrono::steady_clock::time_point& end_time) {\n uint8_t a[105], b[105];\n uniform_real_distribution dist(0.0, 1.0);\n uniform_int_distribution idx_dist(0, N - 1);\n \n smart_init(rng, a, b);\n int current_err = simulate(a, b);\n \n if(current_err < best_err) {\n best_err = current_err;\n for(int i = 0; i < N; ++i) {\n best_A[i] = a[i];\n best_B[i] = b[i];\n }\n }\n \n double temp = 150.0;\n \n while(chrono::steady_clock::now() < end_time && max_iters > 0) {\n max_iters--;\n \n // Early exit for good solutions\n if(best_err <= 300) return;\n \n if(current_err < best_err) {\n best_err = current_err;\n for(int i = 0; i < N; ++i) {\n best_A[i] = a[i];\n best_B[i] = b[i];\n }\n }\n \n // Adaptive cooling\n temp *= 0.9995;\n if(temp < 5.0) temp = 5.0;\n \n // Perturb one parameter\n int i = idx_dist(rng);\n int type = idx_dist(rng) % 2;\n int val = idx_dist(rng);\n \n uint8_t old = (type == 0) ? a[i] : b[i];\n if(type == 0) a[i] = (uint8_t)val;\n else b[i] = (uint8_t)val;\n \n int new_err = simulate(a, b);\n double delta = new_err - current_err;\n \n // Accept or reject\n if(delta < 0) {\n current_err = new_err;\n } else {\n double prob = dist(rng);\n if(prob < exp(-delta / max(temp, 1e-6))) {\n current_err = new_err;\n } else {\n if(type == 0) a[i] = old;\n else b[i] = old;\n }\n }\n \n // Check improvement\n if(current_err < best_err) {\n best_err = current_err;\n for(int k = 0; k < N; ++k) {\n best_A[k] = a[k];\n best_B[k] = b[k];\n }\n }\n }\n \n if(current_err < best_err) {\n best_err = current_err;\n for(int i = 0; i < N; ++i) {\n best_A[i] = a[i];\n best_B[i] = b[i];\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if(!(cin >> N >> L)) return 0;\n for(int i = 0; i < N; ++i) cin >> T[i];\n \n mt19937 base_rng(chrono::steady_clock::now().time_since_epoch().count());\n \n auto start_time = chrono::steady_clock::now();\n auto end_time = start_time + chrono::milliseconds(1800); // 1.8s safe limit\n \n // 5 seeds, more iterations for first ones\n struct SeedConfig {\n int seed;\n int max_iters;\n };\n vector configs = {\n {12345, 150000}, // Most iterations for best exploration\n {54321, 120000}, // Second-best\n {98765, 100000}, // Third\n {43210, 70000}, // Fourth\n {11111, 50000} // Fifth - final chance\n };\n \n for(const auto& config : configs) {\n if(chrono::steady_clock::now() >= end_time) break;\n \n auto remaining = end_time - chrono::steady_clock::now();\n if(remaining <= chrono::milliseconds(50)) break;\n \n mt19937 rng(config.seed);\n run_search(rng, config.max_iters, end_time);\n \n if(best_err <= 300) break;\n }\n \n // Final validation\n for(int i = 0; i < N; ++i) {\n if(best_A[i] >= N) best_A[i] = 0;\n if(best_B[i] >= N) best_B[i] = 0;\n cout << (int)best_A[i] << \" \" << (int)best_B[i] << \"\\n\";\n }\n \n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct UnionFind {\n vector parent;\n UnionFind(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int x) {\n if (parent[x] == x) return x;\n return parent[x] = find(parent[x]);\n }\n bool unite(int x, int y) {\n int rootX = find(x);\n int rootY = find(y);\n if (rootX != rootY) {\n parent[rootY] = rootX;\n return true;\n }\n return false;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, Q, W;\n int L;\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n vector G(M);\n for (int i = 0; i < M; i++) cin >> G[i];\n \n vector lx(N), rx(N), ly(N), ry(N);\n for (int i = 0; i < N; i++) cin >> lx[i] >> rx[i] >> ly[i] >> ry[i];\n \n // Store original city indices\n vector cities(N);\n iota(cities.begin(), cities.end(), 0);\n \n // Calculate center coordinates for sorting\n vector> positions(N);\n for (int i = 0; i < N; i++) {\n positions[i] = {(lx[i] + rx[i]) / 2.0, (ly[i] + ry[i]) / 2.0};\n }\n \n // Sort cities by estimated position (lexicographically)\n sort(cities.begin(), cities.end(), [&](int a, int b) {\n if (positions[a].first != positions[b].first) {\n return positions[a].first < positions[b].first;\n }\n return positions[a].second < positions[b].second;\n });\n \n // Partition cities into groups (each city exactly once)\n vector> groups(M);\n int cityIdx = 0;\n for (int m = 0; m < M; m++) {\n int gSize = G[m];\n for (int j = 0; j < gSize && cityIdx < N; j++) {\n groups[m].push_back(cities[cityIdx++]);\n }\n }\n \n // Verify each city appears in exactly one group\n vector cityGroup(N, -1);\n for (int m = 0; m < M; m++) {\n for (int city : groups[m]) {\n if (cityGroup[city] != -1) {\n cout << \"DEBUG: Duplicate city \" << city << \" in groups \" << cityGroup[city] << \" and \" << m << \"\\n\" << flush;\n }\n cityGroup[city] = m;\n }\n }\n \n vector>> groupEdges(M);\n int queryCount = 0;\n \n for (int m = 0; m < M; m++) {\n int groupSize = (int)groups[m].size();\n if (groupSize <= 1) continue;\n \n int edgesNeeded = groupSize - 1;\n UnionFind uf(groupSize);\n vector> candidateEdges;\n \n // Query with sliding windows\n for (int i = 0; i + 2 < groupSize && queryCount < Q && candidateEdges.size() < edgesNeeded; i += 2) {\n vector queryCities;\n int windowSize = min(L, min(5, groupSize - i));\n windowSize = max(3, windowSize);\n \n for (int j = 0; j < windowSize; j++) {\n queryCities.push_back(groups[m][i + j]);\n }\n \n cout << \"? \" << queryCities.size();\n for (int city : queryCities) cout << \" \" << city;\n cout << \"\\n\" << flush;\n queryCount++;\n \n int numMstEdges = (int)queryCities.size() - 1;\n for (int k = 0; k < numMstEdges; k++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n \n // Verify both cities belong to this group\n if (cityGroup[u] != m || cityGroup[v] != m) continue;\n \n // Check for duplicates\n bool exists = false;\n for (const auto& e : candidateEdges) {\n if (e.first == u && e.second == v) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n candidateEdges.push_back({u, v});\n }\n }\n }\n \n // Use Union-Find to select edges that connect different components\n uf = UnionFind(groupSize);\n int selectedCount = 0;\n \n for (const auto& edge : candidateEdges) {\n if (selectedCount >= edgesNeeded) break;\n \n int uIdx = -1, vIdx = -1;\n for (int j = 0; j < groupSize; j++) {\n if (groups[m][j] == edge.first) uIdx = j;\n if (groups[m][j] == edge.second) vIdx = j;\n }\n \n if (uIdx >= 0 && vIdx >= 0 && uf.unite(uIdx, vIdx)) {\n groupEdges[m].push_back(edge);\n selectedCount++;\n }\n }\n \n // Fill remaining needed edges with fallback (consecutive cities in group)\n // Ensure we don't exceed edgesNeeded\n while ((int)groupEdges[m].size() < edgesNeeded) {\n int edgeIdx = groupEdges[m].size();\n // Connect consecutive cities in the group\n int u = groups[m][edgeIdx];\n int v = groups[m][(edgeIdx < groupSize - 1) ? edgeIdx + 1 : 0];\n \n // Check for duplicate edges\n bool exists = false;\n for (const auto& e : groupEdges[m]) {\n if (e.first == u && e.second == v) {\n exists = true;\n break;\n }\n }\n if (!exists) {\n // Verify both cities are in this group\n if (cityGroup[u] == m && cityGroup[v] == m) {\n groupEdges[m].push_back({u, v});\n }\n }\n }\n }\n \n // Output result\n cout << \"!\" << \"\\n\" << flush;\n \n for (int m = 0; m < M; m++) {\n // Output cities in group m\n const auto& group = groups[m];\n for (size_t i = 0; i < group.size(); i++) {\n cout << group[i];\n if (i + 1 < group.size()) cout << \" \";\n }\n cout << \"\\n\" << flush;\n \n // Output edges for group m\n for (const auto& edge : groupEdges[m]) {\n cout << edge.first << \" \" << edge.second << \"\\n\" << flush;\n }\n }\n \n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAXN = 20;\n\nbool has_block[MAXN][MAXN];\nint cur_r, cur_c;\nint N, M;\n\nint dr[] = {-1, 1, 0, 0}; // U, D, L, R\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\n// Check if a position is valid (within grid and not blocked)\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N && !has_block[r][c];\n}\n\n// Execute a single action and update state\nbool execute_action(char action, char dir, int& r, int& c, bool check_valid = true) {\n int d = 0;\n if (dir == 'U') d = 0;\n else if (dir == 'D') d = 1;\n else if (dir == 'L') d = 2;\n else if (dir == 'R') d = 3;\n \n if (action == 'M') {\n if (check_valid) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n r = nr;\n c = nc;\n return true;\n }\n return false;\n } else {\n int nr = r + dr[d];\n int nc = c + dc[d];\n r = nr;\n c = nc;\n return true;\n }\n }\n else if (action == 'S') {\n int nr = r, nc = c;\n while (true) {\n int nr_new = nr + dr[d];\n int nc_new = nc + dc[d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n }\n r = nr;\n c = nc;\n return true;\n }\n else if (action == 'A') {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n has_block[nr][nc] = !has_block[nr][nc];\n return true;\n }\n return false;\n }\n return false;\n}\n\n// Calculate Manhattan distance\nint manhattan(int r1, int c1, int r2, int c2) {\n return abs(r1 - r2) + abs(c1 - c2);\n}\n\n// Get direction that reduces distance to target\nint get_direction(int r, int c, int tr, int tc) {\n if (r < tr) return 1; // Down towards target\n if (r > tr) return 0; // Up towards target\n if (c < tc) return 3; // Right towards target\n if (c > tc) return 2; // Left towards target\n return -1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n cin >> N >> M;\n \n cin >> cur_r >> cur_c;\n \n vector> targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].first >> targets[i].second;\n }\n \n memset(has_block, 0, MAXN * MAXN);\n vector> actions;\n \n for (int t = 0; t < M; t++) {\n int tr = targets[t].first;\n int tc = targets[t].second;\n int target_dist = manhattan(cur_r, cur_c, tr, tc);\n \n // Step 1: If target is blocked, unblock it first\n if (has_block[tr][tc]) {\n // Move to adjacent to target (within 1 cell)\n while (manhattan(cur_r, cur_c, tr, tc) > 1) {\n int best_d = get_direction(cur_r, cur_c, tr, tc);\n \n if (best_d == -1) break;\n \n // Try to slide in best direction first\n int nr = cur_r, nc = cur_c;\n int slide_dist = 0;\n while (true) {\n int nr_new = nr + dr[best_d];\n int nc_new = nc + dc[best_d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_dist++;\n }\n \n if (slide_dist >= 1 && manhattan(nr, nc, tr, tc) < manhattan(cur_r, cur_c, tr, tc)) {\n actions.push_back({'S', dir_char[best_d]});\n execute_action('S', dir_char[best_d], cur_r, cur_c, false);\n } else {\n actions.push_back({'M', dir_char[best_d]});\n execute_action('M', dir_char[best_d], cur_r, cur_c, false);\n }\n }\n \n // Now remove the block (find the correct direction)\n for (int d = 0; d < 4; d++) {\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr == tr && nc == tc && !has_block[nr][nc]) {\n actions.push_back({'A', dir_char[d]});\n has_block[nr][nc] = false;\n break;\n }\n }\n }\n \n // Step 2: Navigate to target using slides when possible\n bool reached_target = false;\n \n while (cur_r != tr || cur_c != tc) {\n int current_dist = manhattan(cur_r, cur_c, tr, tc);\n bool moved = false;\n \n // Direction alignment\n int align_d = get_direction(cur_r, cur_c, tr, tc);\n \n // Try slide in aligned direction\n if (align_d != -1) {\n int nr = cur_r, nc = cur_c;\n int slide_count = 0;\n while (true) {\n int nr_new = nr + dr[align_d];\n int nc_new = nc + dc[align_d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_count++;\n }\n \n if (slide_count >= 1 && manhattan(nr, nc, tr, tc) < current_dist) {\n actions.push_back({'S', dir_char[align_d]});\n execute_action('S', dir_char[align_d], cur_r, cur_c, false);\n moved = true;\n }\n }\n \n // If no slide, try move\n if (!moved && align_d != -1) {\n actions.push_back({'M', dir_char[align_d]});\n execute_action('M', dir_char[align_d], cur_r, cur_c, false);\n moved = true;\n }\n \n // If still not moved, try sliding in other directions\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n int nr = cur_r, nc = cur_c;\n int slide_count = 0;\n while (true) {\n int nr_new = nr + dr[d];\n int nc_new = nc + dc[d];\n if (nr_new < 0 || nr_new >= N || nc_new < 0 || nc_new >= N || has_block[nr_new][nc_new]) {\n break;\n }\n nr = nr_new;\n nc = nc_new;\n slide_count++;\n }\n \n if (slide_count >= 1 && manhattan(nr, nc, tr, tc) < current_dist) {\n actions.push_back({'S', dir_char[d]});\n execute_action('S', dir_char[d], cur_r, cur_c, false);\n moved = true;\n break;\n }\n }\n }\n \n // If still not moved, try simple move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n if (align_d == d) continue;\n int nr = cur_r + dr[d];\n int nc = cur_c + dc[d];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N && !has_block[nr][nc]) {\n actions.push_back({'M', dir_char[d]});\n execute_action('M', dir_char[d], cur_r, cur_c, false);\n moved = true;\n break;\n }\n }\n }\n \n // Safety check to prevent infinite loop\n if (!moved) {\n reached_target = true;\n break;\n }\n }\n }\n \n // Output all actions\n for (const auto& p : actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}"}}}