{"model_name":"gemini-3-pro-preview-low","codes":{"1":{"ahc001":"/**\n * AtCoder Heuristic Contest 001\n * Problem: AtCoder Ad\n * Author: Algorithm Engineer\n * Method: Hill Climbing with Local Geometric Moves\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int W = 10000;\nconst int H = 10000;\nconst double TIME_LIMIT = 4.85; // seconds\n\nstruct Rect {\n int id;\n int x1, y1, x2, y2; // [x1, x2) x [y1, y2)\n int area() const { return (x2 - x1) * (y2 - y1); }\n int width() const { return x2 - x1; }\n int height() const { return y2 - y1; }\n};\n\nstruct Request {\n int id;\n int x, y, r;\n};\n\nint N;\nvector requests;\nvector ans;\n\n// Scoring function for a single request\ndouble calc_score(int r_target, int r_actual) {\n if (r_actual == 0) return 0.0;\n double val = 1.0 - (double)min(r_target, r_actual) / max(r_target, r_actual);\n return 1.0 - val * val;\n}\n\n// Check if two rectangles overlap\nbool intersect(const Rect& a, const Rect& b) {\n return max(a.x1, b.x1) < min(a.x2, b.x2) && max(a.y1, b.y1) < min(a.y2, b.y2);\n}\n\n// Utility to get time\ndouble get_time() {\n static auto start_time = chrono::steady_clock::now();\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N;\n requests.resize(N);\n for (int i = 0; i < N; ++i) {\n requests[i].id = i;\n cin >> requests[i].x >> requests[i].y >> requests[i].r;\n }\n\n // Initial solution: 1x1 rectangles at the requested points\n ans.resize(N);\n for (int i = 0; i < N; ++i) {\n ans[i].id = i;\n ans[i].x1 = requests[i].x;\n ans[i].y1 = requests[i].y;\n ans[i].x2 = requests[i].x + 1;\n ans[i].y2 = requests[i].y + 1;\n }\n\n // Current individual scores\n vector scores(N);\n double current_total_score = 0;\n for(int i=0; i dist_idx(0, N - 1);\n uniform_int_distribution dist_dir(0, 3); // 0: Left, 1: Right, 2: Bottom, 3: Top\n uniform_int_distribution dist_move(0, 1); // 0: shrink, 1: expand (simplified logic below)\n\n int iter_count = 0;\n \n // Optimization Loop\n while (true) {\n iter_count++;\n if ((iter_count & 0xFFFF) == 0) {\n if (get_time() > TIME_LIMIT) break;\n }\n\n // Pick a random rectangle\n int i = dist_idx(rng);\n Rect current = ans[i];\n int dir = dist_dir(rng);\n \n // Determine move type: Expand or Shrink\n // We can try both with simple step size 1\n // But to make it symmetric, let's just define a delta = +1 or -1\n // However, shrinking is always valid if size > 1 and contains point.\n // Expanding requires collision check.\n \n // Let's randomly choose a delta\n // To encourage filling space, we might bias towards expansion if area < target\n // But simple random walk works well too.\n \n // Heuristic: if area < target, probability to expand is higher\n // if area > target, probability to shrink is higher.\n // Though standard HC just tries random neighbors. Let's stick to random neighbors.\n // We select a delta: -1 or +1\n // Actually, let's just try one random modification.\n \n // int delta = (dist_move(rng) == 0) ? -1 : 1; \n // A purely random delta might get stuck. Let's try to be smarter?\n // No, for these problems, extremely high iteration count usually beats \"smart\" moves.\n // Let's try a random delta from {-1, 1}.\n \n // Actually, let's pick delta based on current area vs target area for faster convergence\n int current_area = current.area();\n int target_area = requests[i].r;\n int delta = 0;\n \n // Probabilistic guidance\n // If too small, expand (delta=1) with higher prob. If too big, shrink (delta=-1).\n // If roughly equal, random.\n // However, sometimes we need to shrink even if small to make room for others, \n // so we shouldn't forbid \"bad\" directions, just bias them.\n // Simpler: Just pick random delta. The acceptance criterion (score improvement) handles the logic.\n \n if (rng() % 2 == 0) delta = 1; else delta = -1;\n\n // Temporary new coordinates\n Rect next = current;\n if (dir == 0) { // Left (x1)\n next.x1 -= delta; // Expand left means x1 decreases\n } else if (dir == 1) { // Right (x2)\n next.x2 += delta; // Expand right means x2 increases\n } else if (dir == 2) { // Bottom (y1)\n next.y1 -= delta; // Expand bottom means y1 decreases\n } else if (dir == 3) { // Top (y2)\n next.y2 += delta; // Expand top means y2 increases\n }\n\n // 1. Boundary Check\n if (next.x1 < 0 || next.y1 < 0 || next.x2 > W || next.y2 > H) continue;\n \n // 2. Point Containment Check\n // The request point (x, y) is effectively (x+0.5, y+0.5).\n // Since integer coords, we need x in [x1, x2) and y in [y1, y2).\n // Actually, the problem says point is (x+0.5, y+0.5).\n // So x1 <= x < x2 and y1 <= y < y2 must hold.\n if (!(next.x1 <= requests[i].x && requests[i].x < next.x2 &&\n next.y1 <= requests[i].y && requests[i].y < next.y2)) {\n continue;\n }\n\n // 3. Width/Height Check (must be positive)\n if (next.width() <= 0 || next.height() <= 0) continue;\n\n // 4. Intersection Check\n // Only need to check if we expanded. If we shrunk, no new overlaps can be created.\n bool possible_collision = false;\n // Expanding direction logic:\n // Left: x1 decreases (delta=1, dir=0 -> x1 -= 1) -> Check overlap\n // Right: x2 increases (delta=1, dir=1 -> x2 += 1) -> Check overlap\n // ...\n // Actually, we defined delta=1 as \"expansion of boundary outwards\" in the logic?\n // Wait, let's trace carefully:\n // dir=0 (Left, x1): next.x1 = current.x1 - delta.\n // If delta=1, x1 becomes smaller (expands left). Collision risk.\n // If delta=-1, x1 becomes larger (shrinks left). No collision risk.\n // dir=1 (Right, x2): next.x2 = current.x2 + delta.\n // If delta=1, x2 larger (expands right). Collision risk.\n // If delta=-1, x2 smaller (shrinks right). No collision risk.\n // Same for Y.\n // So collision risk only if delta == 1.\n \n if (delta == 1) {\n for (int j = 0; j < N; ++j) {\n if (i == j) continue;\n if (intersect(next, ans[j])) {\n possible_collision = true;\n break;\n }\n }\n }\n if (possible_collision) continue;\n\n // 5. Score Evaluation\n double new_score = calc_score(requests[i].r, next.area());\n double old_score = scores[i];\n \n // Acceptance criteria\n // Hill Climbing: Accept if score improves or stays same.\n // Note: We accept equal moves to allow traversing plateaus (reshaping).\n if (new_score >= old_score) {\n ans[i] = next;\n current_total_score += (new_score - old_score);\n scores[i] = new_score;\n } \n else {\n // Simulated Annealing component could go here.\n // Given the dense packing nature, simple HC works well to fill space.\n // Sometimes shrinking a rectangle slightly hurts its score but might help others later.\n // With a strict HC, we might get stuck.\n // Let's add a tiny probability to accept bad moves, or just rely on \n // the fact that there are many \"neutral\" moves (reshaping) that allow escape.\n \n // Let's try a simple SA probability.\n // Temperature schedule\n double progress = get_time() / TIME_LIMIT;\n double T = 0.5 * (1.0 - progress); // Start at 0.5, end at 0\n \n // For very small degradation, we might accept.\n if (T > 0) {\n double diff = new_score - old_score;\n if (exp(diff / T) > (double)(rng() % 10000) / 10000.0) {\n ans[i] = next;\n current_total_score += (new_score - old_score);\n scores[i] = new_score;\n }\n }\n }\n }\n\n // Output results\n for (int i = 0; i < N; ++i) {\n cout << ans[i].x1 << \" \" << ans[i].y1 << \" \" << ans[i].x2 << \" \" << ans[i].y2 << \"\\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// --------------------------------------------------------\n// Constants & Globals\n// --------------------------------------------------------\nconst int N = 50;\nconst int TIME_LIMIT_MS = 1950;\n\nint SI, SJ;\nint T[N][N];\nint P[N][N];\nint M_tiles = 0;\n\n// Direction mapping\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\nconst char DCHAR[] = {'U', 'D', 'L', 'R'};\n\n// Optimization: Global visited array using tokens\nint visited_token[2505];\nint current_token = 0;\n\n// RNG\nmt19937 rng;\n\n// Best solution storage\nint max_score = -1;\nstring best_path_str = \"\";\n\n// --------------------------------------------------------\n// Helper Functions\n// --------------------------------------------------------\ninline bool isValid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\n// --------------------------------------------------------\n// Main Search Logic\n// --------------------------------------------------------\nvoid solve_run() {\n current_token++;\n \n int curr_r = SI;\n int curr_c = SJ;\n int curr_score = P[SI][SJ];\n \n // Using a static buffer for path to avoid reallocation might be slightly faster,\n // but string with reserve is clean enough for C++20.\n string curr_path;\n curr_path.reserve(2500);\n \n // Mark start tile as visited\n visited_token[T[SI][SJ]] = current_token;\n \n while (true) {\n struct MoveCand {\n int dir;\n int r, c;\n int score;\n };\n \n MoveCand candidates[4];\n int cand_count = 0;\n \n // 1. Evaluate all neighbors\n for (int d = 0; d < 4; ++d) {\n int nr = curr_r + DR[d];\n int nc = curr_c + DC[d];\n \n if (!isValid(nr, nc)) continue;\n \n int n_tile = T[nr][nc];\n \n // Check if tile is already visited (or is the current tile)\n if (visited_token[n_tile] == current_token) continue;\n \n // Calculate Heuristic Score\n // Base: Points on the tile\n int val = P[nr][nc];\n \n // Connectivity: How many valid moves exist from the target?\n int exits = 0;\n for (int dd = 0; dd < 4; ++dd) {\n int nnr = nr + DR[dd];\n int nnc = nc + DC[dd];\n if (isValid(nnr, nnc)) {\n int nn_tile = T[nnr][nnc];\n // Valid exit: inside bounds, not visited, not the tile itself\n if (visited_token[nn_tile] != current_token && nn_tile != n_tile) {\n exits++;\n }\n }\n }\n \n // Weighted sum + Random noise\n // Weights: Points (10), Exits (15), Noise (0-20)\n int w = val * 10 + exits * 15 + (int)(rng() % 20);\n \n candidates[cand_count++] = {d, nr, nc, w};\n }\n \n if (cand_count == 0) break; // Stuck\n \n // 2. Sort candidates descending\n for(int i=0; i 1) {\n // 5% chance to take the second best option to escape local optima\n if ((rng() % 100) < 5) {\n selected = 1;\n }\n }\n \n const auto& m = candidates[selected];\n \n // 4. Apply move\n curr_r = m.r;\n curr_c = m.c;\n curr_score += P[m.r][m.c];\n visited_token[T[m.r][m.c]] = current_token;\n curr_path += DCHAR[m.dir];\n }\n \n if (curr_score > max_score) {\n max_score = curr_score;\n best_path_str = curr_path;\n }\n}\n\nint main() {\n // Speed up\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_clock = chrono::steady_clock::now();\n \n // Input\n if (!(cin >> SI >> SJ)) return 0;\n \n for(int i=0; i> T[i][j];\n if (T[i][j] > M_tiles) M_tiles = T[i][j];\n }\n }\n for(int i=0; i> P[i][j];\n }\n }\n \n // Seed RNG\n rng.seed(chrono::steady_clock::now().time_since_epoch().count());\n \n // Reset visited array (safe init)\n for(int i=0; i<=M_tiles; ++i) visited_token[i] = 0;\n \n // Iterative Search\n int iterations = 0;\n while (true) {\n iterations++;\n // Check time periodically\n if ((iterations & 127) == 0) {\n auto now = chrono::steady_clock::now();\n auto dur = chrono::duration_cast(now - start_clock).count();\n if (dur > TIME_LIMIT_MS) break;\n }\n \n solve_run();\n }\n \n // Output\n cout << best_path_str << endl;\n \n return 0;\n}","ahc003":"/**\n * AtCoder Heuristic Contest 003\n * Problem: Shortest Path\n * Author: Algorithm Engineer\n */\n\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\n// --------------------------------------------------------------------------\n// Constants & Globals\n// --------------------------------------------------------------------------\n\nconst int N = 30;\nconst int M_QUERY = 1000;\nconst double INITIAL_ESTIMATE = 5000.0;\nconst double MIN_EDGE_COST = 1000.0; // From problem gen: 1000+D (D>=100) => min ~1100\nconst double MAX_EDGE_COST = 9000.0; // From problem gen: 9000-D => max ~8900\n\n// We have a grid. \n// Vertices: (r, c) for r in 0..29, c in 0..29.\n// Edges:\n// Horizontal: (r, c) -- (r, c+1) for r in 0..29, c in 0..28\n// Vertical: (r, c) -- (r+1, c) for r in 0..28, c in 0..29\n\n// Data structures to hold edge weights\n// h_edges[r][c] is edge between (r, c) and (r, c+1)\n// v_edges[r][c] is edge between (r, c) and (r+1, c)\nstruct EdgeInfo {\n double estimated_weight;\n int visit_count;\n \n // We keep a \"base\" estimate derived from row/col stats and a \"local\" modification\n // But for simplicity in this heuristic, we just store one floating point value\n // and update it.\n};\n\nvector> h_edges(N, vector(N - 1));\nvector> v_edges(N - 1, vector(N));\n\n// Stats for rows and columns to exploit structural correlation\n// M=1 or M=2 means rows/cols are piecewise constant-ish.\n// We maintain an average weight for each row and col.\nstruct LineStats {\n double sum_weights = 0;\n double count = 0;\n double current_avg = INITIAL_ESTIMATE;\n};\n\nvector row_stats(N);\nvector col_stats(N);\n\n// Random engine\nmt19937 rng(12345);\n\n// --------------------------------------------------------------------------\n// Helper Functions\n// --------------------------------------------------------------------------\n\n// Clamp value to valid range\ndouble clamp_weight(double w) {\n return std::max(100.0, std::min(9000.0 + 2000.0, w)); // Allow slightly wider range for updates\n}\n\n// Directions for Dijkstra\nconst int DR[] = {-1, 1, 0, 0}; // U, D, L, R\nconst int DC[] = {0, 0, -1, 1};\nconst char DIR_CHAR[] = {'U', 'D', 'L', 'R'};\n\nstruct State {\n double cost;\n int r, c;\n bool operator>(const State& other) const {\n return cost > other.cost;\n }\n};\n\n// Predecessor map for path reconstruction: [r][c] -> index in DR/DC/DIR_CHAR\nint parent_dir[N][N]; \n\n// Get current weight of an edge\ndouble get_edge_weight(int r, int c, int dir) {\n // dir: 0=U, 1=D, 2=L, 3=R\n if (dir == 0) { // Up: edge is v_edges[r-1][c]\n return v_edges[r - 1][c].estimated_weight;\n } else if (dir == 1) { // Down: edge is v_edges[r][c]\n return v_edges[r][c].estimated_weight;\n } else if (dir == 2) { // Left: edge is h_edges[r][c-1]\n return h_edges[r][c - 1].estimated_weight;\n } else if (dir == 3) { // Right: edge is h_edges[r][c]\n return h_edges[r][c].estimated_weight;\n }\n return 1e9;\n}\n\n// Function to find shortest path\nstring find_shortest_path(int sr, int sc, int tr, int tc) {\n // Reset DP table\n for(int i=0; i> dist(N, vector(N, 1e18));\n priority_queue, greater> pq;\n\n dist[sr][sc] = 0;\n pq.push({0, sr, sc});\n\n while (!pq.empty()) {\n State top = pq.top();\n pq.pop();\n \n if (top.cost > dist[top.r][top.c]) continue;\n if (top.r == tr && top.c == tc) break; // Found target\n\n for (int i = 0; i < 4; ++i) {\n int nr = top.r + DR[i];\n int nc = top.c + DC[i];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n double w = get_edge_weight(top.r, top.c, i);\n \n // Exploration heuristic: slightly prefer unvisited edges early on?\n // Actually, given the scoring (ratio), accuracy is paramount.\n // The structural updates handle exploration implicitly by filling in neighbors.\n // We can add a tiny noise to break ties or encourage diversity if needed.\n \n if (dist[top.r][top.c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[top.r][top.c] + w;\n parent_dir[nr][nc] = i; // direction taken to reach (nr, nc)\n pq.push({dist[nr][nc], nr, nc});\n }\n }\n }\n }\n\n // Reconstruct path\n string path = \"\";\n int cr = tr, cc = tc;\n while (cr != sr || cc != sc) {\n int dir = parent_dir[cr][cc];\n // To backtrack, we need to know which direction we CAME from.\n // parent_dir stores the direction TO (cr, cc) from previous.\n // So if dir is 0 (Up, meaning prev->curr was Up), previous was (cr+1, cc)\n // Wait, my dir defs: 0=U (r-1), 1=D (r+1).\n // If we moved U to get here, we came from (cr+1, cc).\n \n path += DIR_CHAR[dir];\n \n // Backtrack coordinates\n cr -= DR[dir];\n cc -= DC[dir];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// --------------------------------------------------------------------------\n// Learning / Update Logic\n// --------------------------------------------------------------------------\n\nvoid update_weights(int sr, int sc, const string& path, int measured_result) {\n int curr_r = sr;\n int curr_c = sc;\n \n // Identify edges in the path\n struct PathEdge {\n bool is_horizontal; // true if h_edges, false if v_edges\n int r, c; // coordinates in the respective array\n double current_val;\n };\n \n vector edges_in_path;\n double predicted_total = 0;\n \n for (char c : path) {\n PathEdge pe;\n if (c == 'U') {\n // Moving up: (curr_r, curr_c) -> (curr_r-1, curr_c)\n // Edge is v_edges[curr_r-1][curr_c]\n pe.is_horizontal = false;\n pe.r = curr_r - 1; pe.c = curr_c;\n pe.current_val = v_edges[pe.r][pe.c].estimated_weight;\n curr_r--;\n } else if (c == 'D') {\n // Moving down: (curr_r, curr_c) -> (curr_r+1, curr_c)\n // Edge is v_edges[curr_r][curr_c]\n pe.is_horizontal = false;\n pe.r = curr_r; pe.c = curr_c;\n pe.current_val = v_edges[pe.r][pe.c].estimated_weight;\n curr_r++;\n } else if (c == 'L') {\n // Moving left: (curr_r, curr_c) -> (curr_r, curr_c-1)\n // Edge is h_edges[curr_r][curr_c-1]\n pe.is_horizontal = true;\n pe.r = curr_r; pe.c = curr_c - 1;\n pe.current_val = h_edges[pe.r][pe.c].estimated_weight;\n curr_c--;\n } else if (c == 'R') {\n // Moving right: (curr_r, curr_c) -> (curr_r, curr_c+1)\n // Edge is h_edges[curr_r][curr_c]\n pe.is_horizontal = true;\n pe.r = curr_r; pe.c = curr_c;\n pe.current_val = h_edges[pe.r][pe.c].estimated_weight;\n curr_c++;\n }\n edges_in_path.push_back(pe);\n predicted_total += pe.current_val;\n }\n\n // The observed result is roughly sum(weights) * random(0.9, 1.1)\n // We treat result as unbiased estimate of sum(weights) because E[random] = 1.0\n // However, we must be careful with outliers.\n // Let's compute the ratio:\n double ratio = (double)measured_result / predicted_total;\n \n // If ratio is large, our estimates are too small. If ratio is small, estimates are too big.\n // We want to shift edges towards the measured reality.\n // We use a learning rate.\n double learning_rate = 0.6; \n \n // Calculate diff to distribute\n double diff = measured_result - predicted_total;\n \n // We distribute the difference proportional to the variance? Or uniformly?\n // Or proportional to current weight?\n // Proportional to current weight implies multiplicative scaling, which fits the \"ratio\" idea.\n // Update rule: w_new = w_old * (1 + alpha * (ratio - 1))\n \n // However, we also want to exploit the ROW/COLUMN structure.\n // If we found that a row is heavier than expected, ALL edges in that row likely need an update.\n \n // 1. Local update for edges on the path\n for (auto& pe : edges_in_path) {\n double old_w = pe.current_val;\n // Simple delta rule\n double new_w = old_w + (diff / edges_in_path.size()) * learning_rate;\n \n // Update storage\n if (pe.is_horizontal) {\n h_edges[pe.r][pe.c].estimated_weight = clamp_weight(new_w);\n h_edges[pe.r][pe.c].visit_count++;\n \n // Update row stats\n // Using an Exponential Moving Average for the row\n double row_lr = 0.15;\n row_stats[pe.r].current_avg = row_stats[pe.r].current_avg * (1.0 - row_lr) + new_w * row_lr;\n } else {\n v_edges[pe.r][pe.c].estimated_weight = clamp_weight(new_w);\n v_edges[pe.r][pe.c].visit_count++;\n \n // Update col stats\n double col_lr = 0.15;\n col_stats[pe.c].current_avg = col_stats[pe.c].current_avg * (1.0 - col_lr) + new_w * col_lr;\n }\n }\n \n // 2. Global smoothing (Structure Exploitation)\n // The edges NOT on the path but in the same rows/cols should also be nudged towards the new average.\n // This is crucial because M=1 or M=2 means long segments of similar weights.\n \n // We iterate over all edges. If an edge hasn't been visited much, pull it strongly towards the row/col average.\n // If it has been visited, trust its local value more.\n \n for (int r = 0; r < N; ++r) {\n // Horizontal edges in row r\n double target = row_stats[r].current_avg;\n for (int c = 0; c < N - 1; ++c) {\n double& w = h_edges[r][c].estimated_weight;\n int vc = h_edges[r][c].visit_count;\n \n // Influence factor: if vc is high, we trust w. If vc is low, we trust target.\n // We apply a small \"diffusion\" update every turn\n double alpha = 0.01 / (1.0 + 0.5 * vc); \n w = w * (1.0 - alpha) + target * alpha;\n w = clamp_weight(w);\n }\n }\n \n for (int c = 0; c < N; ++c) {\n // Vertical edges in col c\n double target = col_stats[c].current_avg;\n for (int r = 0; r < N - 1; ++r) {\n double& w = v_edges[r][c].estimated_weight;\n int vc = v_edges[r][c].visit_count;\n \n double alpha = 0.01 / (1.0 + 0.5 * vc);\n w = w * (1.0 - alpha) + target * alpha;\n w = clamp_weight(w);\n }\n }\n}\n\n// --------------------------------------------------------------------------\n// Main\n// --------------------------------------------------------------------------\n\nint main() {\n // Optimization for I/O\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n\n // Initialize weights\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N - 1; ++c) {\n h_edges[r][c] = {INITIAL_ESTIMATE, 0};\n }\n }\n for (int r = 0; r < N - 1; ++r) {\n for (int c = 0; c < N; ++c) {\n v_edges[r][c] = {INITIAL_ESTIMATE, 0};\n }\n }\n \n for(int i=0; i> si >> sj >> ti >> tj;\n \n // 1. Plan Path\n string path = find_shortest_path(si, sj, ti, tj);\n \n // 2. Output Path\n cout << path << endl;\n \n // 3. Get Result\n int result;\n cin >> result;\n \n // 4. Update Knowledge\n update_weights(si, sj, path, result);\n }\n\n return 0;\n}","ahc004":"/**\n * Alien's Genetic Information - Heuristic Solution\n *\n * Strategy:\n * 1. Initialization:\n * - Since we want to maximize the number of covered strings (c) and then minimize dots (d),\n * our primary goal is finding a valid placement for as many strings as possible.\n * - Start with a random grid or a grid constructed by greedily placing some long strings.\n * - However, a pure random grid is a good baseline for hill climbing / simulated annealing\n * because the strings are generated from a random grid initially.\n *\n * 2. State Representation:\n * - An N x N grid of characters.\n * - Auxiliary data structures to quickly check which strings are currently satisfied.\n * - `covered[k]` : boolean, is string s_k currently a subsequence?\n * - `count_c` : current number of satisfied strings.\n * - `count_dot` : current number of dots (we aim for 0 dots generally, as filling\n * with random characters usually helps cover more strings by chance).\n *\n * 3. Optimization (Simulated Annealing):\n * - Score Function:\n * - Base score: count_c * (some large constant).\n * - Tie-breaker: If count_c == M, maximize 1/(number of dots).\n * - Since getting count_c == M is hard and the primary scoring metric is linear in c for c < M,\n * we focus heavily on maximizing c.\n * - To make the landscape smoother, we can count \"partial matches\" or the number of\n * occurrences of each string. But strictly, the problem asks for binary coverage.\n * Let's stick to maximizing binary coverage first.\n *\n * - Neighborhood Operations (Transitions):\n * a. Mutate Single Cell: Change grid[i][j] to a random char ('A'-'H') or '.'.\n * - Usually changing to '.' is bad unless we specifically optimize for d, but\n * in the early stage, we just want valid characters. Let's stick to 'A'-'H'.\n * b. Shift Row/Column: Cyclically shift a row or a column.\n * c. Swap Cells: Swap two cells.\n * d. \"Force\" a string: Pick an unsatisfied string s_k, pick a random position and direction,\n * and overwrite the grid cells to make s_k match. This is a destructive move but\n * can jump out of local optima.\n *\n * 4. Efficient Updates:\n * - Recomputing the full score is expensive (O(M * N * L)).\n * - We need delta updates.\n * - Since N is small (20), rows and cols are short.\n * - Checking if a specific string s_k matches at (r, c, dir) is fast.\n * - We can maintain `match_count[k]`: how many times string k appears in the grid.\n * - score c = count(match_count[k] > 0).\n * - When a cell (r, c) changes, we only need to re-check strings that could possibly pass through (r, c).\n * - Horizontal strings passing through (r, c) start at (r, (c - p) % N).\n * - Vertical strings passing through (r, c) start at ((r - p) % N, c).\n * - However, M is up to 800. Even localized updates might be heavy if we iterate all M.\n * - Inverted index: Map each string to \"potential locations\" isn't quite right because strings are the queries.\n * - Aho-Corasick could work for matching all strings in a row/col, but strings can wrap around.\n * - Given N=20 is very small, we can optimize the checking.\n * - Precompute for each string: length.\n * - When (r, c) changes, we scan row r and col c.\n * - Actually, checking all strings against the changed row r and col c is roughly O(M * N).\n * - With N=20, M=800, this is ~16000 ops. Maybe acceptable for SA?\n * - Let's optimize: We only need to update the match counts for strings that *were* matching the old row/col or *now* match the new row/col.\n * - Actually, brute force re-check of row r and col c for *all* strings is too slow.\n * - Optimization: We maintain a bitmask or list of strings that appear in each row/col? No, strings can be anywhere.\n *\n * - Let's refine the delta update.\n * - `matches[k]`: integer, number of times string k appears in the entire grid.\n * - When `grid[r][c]` changes:\n * 1. Identify \"affected\" paths.\n * - The row `r` (with wrap-around).\n * - The col `c` (with wrap-around).\n * 2. For the row `r`:\n * - Decrement `matches[k]` for all matches that existed in row `r` with the OLD char.\n * - Increment `matches[k]` for all matches that exist in row `r` with the NEW char.\n * - Same for col `c`.\n * - Wait, to decrement, we need to know *which* strings matched.\n * - Re-scanning the whole row `r` takes O(N). We can check all M strings against this row.\n * - O(M * N) is high.\n * - BUT, many strings won't match.\n * - We can use bitsets or simpler heuristics?\n * - Or maybe just re-evaluating the whole grid periodically is too slow, but re-evaluating one row/col against all strings is the bottleneck.\n *\n * - Alternative State Representation for Fast Updates:\n * - The strings are short (2-12).\n * - N=20.\n * - A string matches row `r` at offset `j` if `row_str[j...j+len] == s_k`.\n * - With `grid[r][c]` changing, we only need to check substrings of row `r` that overlap index `c`.\n * - For a string of length `L`, there are `L` such start positions in the row.\n * - Max L=12.\n * - So for each string $s_k$, if it was matching row $r$ at a position overlapping $c$, we check if it still matches. If it wasn't, we check if it now matches.\n * - This still feels like iterating M.\n *\n * - Optimization via Precomputed Hash / Aho-Corasick?\n * - Since N is small, we can just keep `matches[k]` up to date.\n * - To avoid O(M) per move:\n * - Map `substring of length 2-3` -> `list of string IDs`.\n * - Only check strings that share a k-mer with the updated region?\n * - Maybe too complex.\n * - Let's look at constants. 3.0 seconds.\n * - Simple SA with O(M*L) update might get ~100k-500k iterations.\n * - Let's try a raw update first.\n * - Update logic:\n * - `old_val = grid[r][c]`\n * - `row_matches_before` = scan_row(r)\n * - `col_matches_before` = scan_col(c)\n * - `grid[r][c] = new_val`\n * - `row_matches_after` = scan_row(r)\n * - `col_matches_after` = scan_col(c)\n * - Update global counts based on differences.\n * - `scan_row(r)` involves iterating all M strings?\n * - Yes. 800 * 20 = 16000 ops. Too slow for a tight inner loop.\n *\n * - Optimized `scan_row(r)`:\n * - We can maintain `matches[k]` decomposed: `count_row[k][r]` and `count_col[k][c]`.\n * - Total `matches[k] = sum(count_row[k]) + sum(count_col[k])`.\n * - When `grid[r][c]` changes, we strictly recompute row `r` and col `c`.\n * - To make `scan_row(r)` fast:\n * - Pre-calculate all strings as integers? No, alphabet size 8.\n * - Use bitsets? A bitset of length N=20 is a single integer.\n * - Represent each string $s_k$ as a set of (pattern, mask).\n * - Actually, since N=20, wrap around is easy.\n * - Can we match all M strings against a row of length 20 quickly?\n * - Aho-Corasick automaton built on {s_1...s_M}.\n * - The text is the row (doubled to handle wrap). Length 40.\n * - Traversing the AC automaton takes O(N).\n * - Finding matches takes O(N + #matches).\n * - This is extremely fast compared to O(M*N).\n * - AC construction is done once.\n * - We need one AC for the set of strings.\n * - But wait, we need to know *which* string matched to update counts.\n * - AC output nodes store lists of string indices.\n * - This is perfect.\n *\n * 5. Algorithm Details:\n * - Build Aho-Corasick Automaton on s_1...s_M.\n * - Initial Grid: Random.\n * - Initial Score Calculation:\n * - `row_counts[r][k]`: how many times s_k appears in row r.\n * - `col_counts[c][k]`: how many times s_k appears in col c.\n * - `total_matches[k]` = sum over r, c.\n * - `satisfied` = count(total_matches[k] > 0).\n * - SA Loop:\n * - Pick random (r, c), pick new char `v`.\n * - Delta:\n * - Old row string -> run AC -> list of (string_id, count_in_row).\n * - Decrement `total_matches` for these.\n * - New row string -> run AC -> list of (string_id, count_in_row).\n * - Increment `total_matches`.\n * - Same for col `c`.\n * - Calculate new score.\n * - Accept/Reject.\n * - Since N is fixed at 20, AC run is very fast (~40 steps).\n * - Maximize `satisfied`.\n * - If `satisfied == M`, switch to minimizing dots. But problem says fill with A-H.\n * - The score formula uses `d` (dots). `c=M` gives huge bonus.\n * - If we can satisfy all with '.' allowed, great. But usually random chars saturate better.\n * - Strategy: Use A-H only. `d` will be 0. Score is `10^8 * c/M`.\n * - If we somehow get perfect coverage, score jumps.\n * - The generated inputs don't use dots.\n * - It is safer to stick to A-H. The penalty for d > 0 when c=M is subtle, but getting c=M is the main hurdle.\n * - If we stick to A-H, `d=0`, if `c=M`, score = `10^8`.\n * - The problem statement implies we can use dots to reduce the denominator if c=M.\n * - `2N^2 / (2N^2 - d)`. Since `2N^2 = 800`. If d=0, ratio is 1. If d=400, ratio is 2.\n * - So using dots is beneficial ONLY IF c=M is maintained.\n * - This suggests a two-phase approach:\n * 1. Maximize c using A-H.\n * 2. If c=M, try to turn cells into '.' without decreasing c.\n *\n * 6. AC Automaton details:\n * - Alphabet: A-H (0-7).\n * - Nodes, failure links.\n * - Output: `std::vector` indices of strings ending here.\n * - Optimization: Since strings are short, many strings might be identical. Handle duplicates by merging IDs or list of IDs.\n * - Since max length is 12 and strings are generated randomly, duplicates are rare but possible.\n *\n * 7. Parallelism / Multiple Starts:\n * - 3 seconds is plenty.\n * - Can run multiple restarts if the SA gets stuck.\n * - N=20 is very small, convergence should be fast.\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants and Types\nconstexpr int N = 20;\nconstexpr int MAX_M = 1000; // problem says 400-800\nconstexpr int ALPHABET_SIZE = 8;\nconstexpr int EMPTY_CHAR = 8; // Internal representation for '.'\n// Map 'A'-'H' to 0-7, '.' to 8.\n\n// Aho-Corasick Trie Node\nstruct Node {\n int children[ALPHABET_SIZE]; // We only match A-H. '.' never matches a string char.\n int failure;\n vector matched_indices; // indices of strings ending at this node\n\n Node() {\n memset(children, -1, sizeof(children));\n failure = 0;\n }\n};\n\nvector trie;\n\nvoid build_ac(const vector& patterns) {\n trie.clear();\n trie.emplace_back(); // Root\n\n for (int i = 0; i < patterns.size(); ++i) {\n int curr = 0;\n for (char c : patterns[i]) {\n int val = c - 'A';\n if (trie[curr].children[val] == -1) {\n trie[curr].children[val] = trie.size();\n trie.emplace_back();\n }\n curr = trie[curr].children[val];\n }\n trie[curr].matched_indices.push_back(i);\n }\n\n queue q;\n for (int i = 0; i < ALPHABET_SIZE; ++i) {\n if (trie[0].children[i] != -1) {\n trie[trie[0].children[i]].failure = 0;\n q.push(trie[0].children[i]);\n } else {\n trie[0].children[i] = 0;\n }\n }\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n // Merge matches from failure link\n // This ensures that if we match a longer string, we also count substrings\n // that end at the same position.\n // Note: This might duplicate indices if not careful, but std::vector append is fine\n // because patterns are unique IDs.\n // Actually, patterns are distinct indices i=0..M-1.\n const auto& fail_matches = trie[trie[u].failure].matched_indices;\n trie[u].matched_indices.insert(trie[u].matched_indices.end(), fail_matches.begin(), fail_matches.end());\n\n for (int i = 0; i < ALPHABET_SIZE; ++i) {\n if (trie[u].children[i] != -1) {\n int v = trie[u].children[i];\n trie[v].failure = trie[trie[u].failure].children[i];\n q.push(v);\n } else {\n trie[u].children[i] = trie[trie[u].failure].children[i];\n }\n }\n }\n}\n\n// Global Data\nint M;\nvector S;\nint grid[N][N]; // 0-7 or 8\nint best_grid[N][N];\n\n// Score tracking\n// matches[k] = total occurrences of S[k]\nint string_occurrences[MAX_M];\n// To make updates fast, we might need to know how many times S[k] appears in row r specifically\n// But actually, we can just recompute the row contribution.\n// Let row_contrib[r][k] be count of S[k] in row r.\n// Updating row r:\n// foreach k: string_occurrences[k] -= row_contrib[r][k]\n// recompute row r -> new_contribs\n// foreach k: string_occurrences[k] += new_contribs[k]\n// update row_contrib[r][k]\n// This requires O(M) storage per row, and O(M) update?\n// No, the AC automaton gives us a list of found strings. Most are 0.\n// We can use a sparse representation or just iterate the found ones.\n// Since we need to subtract the old ones, we need to remember what was found.\n// Storing `vector row_found_strings[N]` (list of string indices found in row r, with multiplicity) is better.\n\nvector row_found_strings[N]; // flattened list of string indices found in row i\nvector col_found_strings[N];\n\nint current_c = 0;\nint current_d = 0;\n\n// Random engine\nmt19937 rng(2023);\n\n// Helper to scan a sequence (row or col) with wrap-around\n// seq has length N. We need to scan it as if it wraps.\n// The simplest way is to feed seq + seq[0..max_len-2] into AC.\n// Since max len is 12, we can feed a sequence of length N + 11 approx.\n// Or just N + N to be safe and simpler.\n// Returns a list of string indices found (with multiplicity).\nvector scan_sequence(const vector& seq) {\n vector found;\n found.reserve(N * 2); // heuristic reserve\n int u = 0;\n // We need to handle wrap around.\n // Effective length to scan: N + (longest_string_len - 1).\n // Max string len is 12. So N+11.\n // Let's just do length 2*N - 1 to cover all wrap-around cases fully without\n // double counting the same start position.\n // Actually, valid start positions are 0 to N-1.\n // A match starting at i ends at i + len - 1.\n // We iterate `start` from 0 to N-1?\n // No, AC is character by character.\n // We feed characters. When we are at step `p`, we check matches ending at `p`.\n // A match of length L ending at `p` starts at `p - L + 1`.\n // We want to count matches starting at 0..N-1.\n // So we feed characters 0..N-1, then 0..MaxLen-2.\n // And collect matches.\n // Wait, if we feed 0..N-1, we find matches ending at 0..N-1.\n // A match starting at N-1 of length 2 ends at 0 (wrapped).\n // We need to continue feeding to find wrapped matches.\n // We should feed 2*N - 1 characters?\n // If we feed characters for indices 0, 1, ..., N-1, 0, 1, ..., N-2.\n // Total 2N-1 chars.\n // Matches ending at index `k` (in the fed sequence) correspond to strings.\n // We only care about matches that *start* within [0, N-1].\n // If a match of length L ends at index `p` (0-based in fed seq),\n // its start index is `p - L + 1`.\n // We accept if `0 <= (p - L + 1) < N`.\n\n int len_seq = seq.size(); // N\n // We iterate up to N + 11. Let's be safe with N + N.\n // Optimization: limit based on max string length (12).\n int limit = N + 12; \n\n for (int i = 0; i < limit; ++i) {\n int c = seq[i % len_seq];\n if (c == EMPTY_CHAR) {\n u = 0; // Reset to root if '.' (assuming '.' breaks all matches)\n // Note: problem says '.' is empty. A-H strings cannot match '.'\n continue;\n }\n u = trie[u].children[c];\n \n // Collect matches\n for (int s_idx : trie[u].matched_indices) {\n // Check start position validity\n int len = S[s_idx].length();\n int end_pos = i;\n int start_pos = end_pos - len + 1;\n if (start_pos >= 0 && start_pos < N) {\n found.push_back(s_idx);\n }\n }\n }\n return found;\n}\n\nvoid full_evaluate() {\n fill(string_occurrences, string_occurrences + M, 0);\n current_d = 0;\n \n // Rows\n for (int r = 0; r < N; ++r) {\n vector seq(N);\n for (int c = 0; c < N; ++c) {\n seq[c] = grid[r][c];\n if (grid[r][c] == EMPTY_CHAR) current_d++; // Double counting d here, fix later\n }\n row_found_strings[r] = scan_sequence(seq);\n for (int idx : row_found_strings[r]) {\n string_occurrences[idx]++;\n }\n }\n\n // Cols\n for (int c = 0; c < N; ++c) {\n vector seq(N);\n for (int r = 0; r < N; ++r) seq[r] = grid[r][c];\n col_found_strings[c] = scan_sequence(seq);\n for (int idx : col_found_strings[c]) {\n string_occurrences[idx]++;\n }\n }\n \n // Fix d count (it was counted 2N times)\n current_d = 0;\n for(int i=0; i 0) current_c++;\n }\n}\n\n// Update a single cell and re-evaluate incrementally\n// Returns the change in 'c' (and updates 'd', 'occurrences', found lists internally)\n// We pass the old value to revert if needed?\n// Better: function `try_update(r, c, new_val)` returns score diff. \n// If accepted, we commit. If not, we revert.\n// But committing is complex (updating lists).\n// SA structure:\n// make move\n// calculate delta score\n// if accept: keep\n// else: revert\n// To make \"revert\" fast, we probably want to perform the calculation on temp vars first.\n\n// Since N=20 and M=800, full row scan is fast enough.\n// scan_sequence takes approx 32 steps * tree depth. Very fast.\n// The overhead is vector allocations. We can reuse buffers.\n\nvoid commit_update(int r, int c, int new_val) {\n int old_val = grid[r][c];\n if (old_val == new_val) return;\n\n // Update d\n if (old_val == EMPTY_CHAR) current_d--;\n if (new_val == EMPTY_CHAR) current_d++;\n\n grid[r][c] = new_val;\n\n // Update Row r\n // Remove old counts\n for (int idx : row_found_strings[r]) {\n string_occurrences[idx]--;\n if (string_occurrences[idx] == 0) current_c--;\n }\n // Rescan\n vector seq(N);\n for (int j = 0; j < N; ++j) seq[j] = grid[r][j];\n row_found_strings[r] = scan_sequence(seq);\n // Add new counts\n for (int idx : row_found_strings[r]) {\n if (string_occurrences[idx] == 0) current_c++;\n string_occurrences[idx]++;\n }\n\n // Update Col c\n // Remove old counts\n for (int idx : col_found_strings[c]) {\n string_occurrences[idx]--;\n if (string_occurrences[idx] == 0) current_c--;\n }\n // Rescan\n for (int i = 0; i < N; ++i) seq[i] = grid[i][c];\n col_found_strings[c] = scan_sequence(seq);\n // Add new counts\n for (int idx : col_found_strings[c]) {\n if (string_occurrences[idx] == 0) current_c++;\n string_occurrences[idx]++;\n }\n}\n\n// Try update: returns pair {new_c, new_d}. Does NOT modify state (except temp buffers maybe, but not logical state)\n// Actually, modifying and reverting is easier to implement.\n// Let's assume we modify. If rejected, we modify back.\n// Since we have randomness, we can just swap back.\n// The only cost is the vector re-allocations which is small for N=20.\n\ndouble get_score(int c, int d) {\n if (c < M) {\n return 1e8 * (double)c / M;\n } else {\n // c == M\n double num = 2.0 * N * N;\n double den = 2.0 * N * N - d;\n if (den <= 0) den = 1e-9; // should not happen\n return 1e8 * (num / den);\n }\n}\n\n// Optimization: Force a string into the grid\n// This is a \"large step\" mutation.\n// Pick a string S[k] that is not currently satisfied.\n// Pick a random pos (r, c) and direction (H/V).\n// Overwrite grid cells.\nvoid force_string(int k) {\n if (string_occurrences[k] > 0) return; // already satisfied\n \n int len = S[k].length();\n int dir = rng() % 2;\n int r = rng() % N;\n int c = rng() % N;\n\n // We will just overwrite. This changes multiple cells.\n // To do this correctly with incremental updates, we do it cell by cell.\n for (int i = 0; i < len; ++i) {\n int tr = r, tc = c;\n if (dir == 0) { // Horizontal\n tc = (c + i) % N;\n } else { // Vertical\n tr = (r + i) % N;\n }\n int char_code = S[k][i] - 'A';\n commit_update(tr, tc, char_code);\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> M; // N is fixed 20, but first input is N? No, input is N M.\n // Wait, problem says input is \"N M\". N is fixed 20.\n int n_in; cin >> n_in >> M; // Consume N\n // Note: The variable N is constexpr 20. n_in should be 20.\n\n S.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> S[i];\n }\n\n build_ac(S);\n\n // Initialize Grid\n // Random initialization\n uniform_int_distribution dist_char(0, 7);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n grid[i][j] = dist_char(rng);\n }\n }\n\n full_evaluate();\n\n // Save best\n int best_c = current_c;\n int best_d = current_d;\n double best_score = get_score(current_c, current_d);\n memcpy(best_grid, grid, sizeof(grid));\n\n // SA parameters\n auto start_time = chrono::steady_clock::now();\n double time_limit = 2.90; // seconds\n double temp_start = 2.0;\n double temp_end = 0.0;\n\n // For the second phase (minimizing dots), we might want different params.\n // But let's handle it via the score function.\n \n long long iterations = 0;\n\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n double temp = temp_start + (temp_end - temp_start) * progress;\n\n // Move Strategy\n // 1. Single cell mutation (common)\n // 2. Force unsatisfied string (occasional)\n \n int move_type = 0;\n if (current_c < M && (rng() % 100 < 5)) {\n move_type = 1;\n }\n\n if (move_type == 1) {\n // Find unsatisfied strings\n vector unsat;\n unsat.reserve(M);\n for(int i=0; i 0 || exp(delta / temp) > (double)(rng()%10000)/10000.0) {\n // Accept\n if (new_score > best_score) {\n best_score = new_score;\n best_c = current_c;\n best_d = current_d;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n // Reject - revert\n memcpy(grid, backup_grid, sizeof(grid));\n full_evaluate(); // Rebuild aux structures\n }\n }\n } else {\n // Single Cell Mutation\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val;\n \n // If we have satisfied all strings, we can try to put '.' to improve score.\n // Otherwise, stick to A-H.\n if (current_c == M) {\n // Try '.' or other chars\n // Bias towards '.' if not already '.'\n if (old_val != EMPTY_CHAR && (rng() % 2 == 0)) {\n new_val = EMPTY_CHAR;\n } else {\n new_val = dist_char(rng);\n if (new_val == old_val) new_val = (new_val + 1) % 8;\n }\n } else {\n // Only A-H\n new_val = dist_char(rng);\n if (new_val == old_val) new_val = (new_val + 1) % 8;\n }\n\n // Apply update\n commit_update(r, c, new_val);\n \n double new_score = get_score(current_c, current_d);\n double prev_score = best_score; // Approximation for SA acceptance, actually need prev state score\n // We need the score BEFORE the move.\n // Let's keep track of current_score variable to avoid recalc.\n // But get_score is cheap.\n // We need `current_score_before_move`.\n // Let's rollback manually if rejected.\n \n // Re-calculate prev_score correctly\n // To avoid re-evaluating score function, we can assume we accepted the move if it passes\n // check against 'current_score' stored outside.\n // But here I didn't store it. Let's reconstruct prev_score from logic?\n // Too messy. Let's simplify:\n // We need `prev_c`, `prev_d`.\n // We updated `current_c`, `current_d`.\n // Revert logic is simple: `commit_update(r, c, old_val)`.\n \n // Wait, to check delta, we need prev_c.\n // We don't have it easily because commit_update changed it.\n // We can calculate delta based on new score and... wait.\n // A standard pattern:\n // prev_score = get_score(c, d)\n // change()\n // new_score = get_score(new_c, new_d)\n // if accept: continue\n // else: revert()\n \n // But here I changed first.\n // Let's just assume we don't know prev_score.\n // We can't do SA properly without prev_score.\n // Refactor loop slightly.\n }\n iterations++;\n }\n \n // Correct loop structure with Score tracking\n // Reset for clean logic\n memcpy(grid, best_grid, sizeof(grid));\n full_evaluate();\n double current_score = get_score(current_c, current_d);\n \n // Tune params\n temp_start = 1000000.0; // High temp for score ~ 1e8\n temp_end = 1000.0;\n\n // Restart timer just for the loop structure logic, but respect total time\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n double temp = temp_start * pow(temp_end/temp_start, progress);\n\n int move_type = 0;\n // Occasional kick if stuck?\n if (current_c < M && (rng() % 1000 < 5)) move_type = 1; // Force string\n\n if (move_type == 1) {\n vector unsat;\n for(int i=0; i= 0 || (temp > 0 && exp(delta / temp) > uniform_real_distribution<>(0,1)(rng))) {\n current_score = new_score;\n if (new_score > best_score) {\n best_score = new_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n memcpy(grid, backup_grid, sizeof(grid));\n full_evaluate();\n }\n } else {\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val;\n \n if (current_c == M) {\n if (old_val != EMPTY_CHAR && (rng() % 5 == 0)) { // Try dot with 20% prob\n new_val = EMPTY_CHAR;\n } else {\n new_val = dist_char(rng);\n if (new_val == old_val) new_val = (new_val + 1) % 8;\n }\n } else {\n new_val = dist_char(rng);\n if (new_val == old_val) new_val = (new_val + 1) % 8;\n // Very rarely try dot if c < M? No, dots are bad for c < M.\n }\n \n double prev_score_val = current_score;\n \n // We need to be able to undo commit_update efficiently?\n // commit_update modifies state.\n // Undo is just commit_update(r, c, old_val).\n \n commit_update(r, c, new_val);\n double new_score = get_score(current_c, current_d);\n \n double delta = new_score - prev_score_val;\n\n if (delta >= 0 || (temp > 0 && exp(delta / temp) > uniform_real_distribution<>(0,1)(rng))) {\n current_score = new_score;\n if (new_score > best_score) {\n best_score = new_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n commit_update(r, c, old_val); // Revert\n }\n }\n iterations++;\n }\n\n // Output\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (best_grid[i][j] == EMPTY_CHAR) cout << '.';\n else cout << (char)('A' + best_grid[i][j]);\n }\n cout << \"\\n\";\n }\n \n // Cerr logging\n // cerr << \"Score: \" << (long long)best_score << \" Iterations: \" << iterations << endl;\n\n return 0;\n}","ahc005":"/**\n * heuristic_solution.cpp\n *\n * Problem Analysis:\n * The problem asks for a minimal cost cycle starting and ending at (si, sj) such that every road cell \n * is \"seen\" at least once. \"Seeing\" a cell means having a direct line of sight (same row/col, no obstacles).\n * This is a variation of the Watchman Route Problem or Traveling Salesman Problem (TSP) with neighborhoods, \n * specifically on a grid with line-of-sight visibility.\n *\n * Key Concepts:\n * 1. Visibility: Standing at an intersection allows seeing all roads connected to it in 4 directions.\n * 2. Cost: Movement cost varies (5-9). We want to minimize total travel time.\n * 3. Coverage: All road cells must be covered.\n *\n * Algorithm Strategy:\n * Since this is an NP-hard problem and we have limited time (3.0 sec), we need a heuristic approach.\n * The problem can be modeled as selecting a set of \"viewpoints\" that cover the entire map and then finding \n * a TSP tour through these viewpoints.\n *\n * Step 1: Preprocessing\n * - Identify all road cells.\n * - Calculate All-Pairs Shortest Paths (APSP) between key locations (intersections) is too expensive (N~69, huge state space).\n * Instead, we can compute APSP only between selected viewpoints or use BFS on demand.\n * Since N is small (up to 69), BFS is fast.\n *\n * Step 2: Viewpoint Selection (Set Cover approximation)\n * - We need to select a set of cells V such that every road cell is visible from at least one v in V.\n * - We prefer viewpoints that are close to each other (to minimize travel time) and cover many 'hard-to-see' cells.\n * - A greedy approach with backtracking or a randomized greedy can work well. \n * - Intersections are prime candidates for viewpoints.\n *\n * Step 3: Route Construction (TSP)\n * - Once we have a set of viewpoints, we need to order them to form a tour.\n * - This is a standard TSP. We can use heuristics like Nearest Neighbor, 2-opt, 3-opt, or Simulated Annealing.\n *\n * Advanced Strategy: Iterative Improvement / Simulated Annealing (SA)\n * Instead of separating Step 2 and 3 strictly, we can combine them.\n * State: An ordered list of waypoints.\n * Objective: Minimize (Cost of Tour + Penalty * Uncovered Cells).\n * Operations:\n * - Add a waypoint (improves coverage, increases cost).\n * - Remove a waypoint (decreases cost, might reduce coverage).\n * - Move a waypoint to a neighbor.\n * - Swap order of waypoints (TSP optimization).\n *\n * Since finding the *absolute* minimum set of points is hard, and the *order* matters greatly for cost, \n * an SA approach that modifies the tour directly is promising. However, the constraint \"must cover ALL\" is hard.\n * Usually, it's better to ensure coverage first or heavily penalize non-coverage.\n *\n * Refined Algorithm for Contest:\n * 1. Analyze graph structure. Roads form lines. An intersection is where lines meet.\n * We can simplify the graph into nodes (intersections) and edges (road segments).\n * Actually, just standing at intersections is often enough to see most things.\n * Dead-ends must be visited (or seen from the nearest intersection).\n * 2. Decomposition into \"Segments\":\n * The map consists of horizontal and vertical road segments.\n * To cover a segment, we must visit at least one cell within that segment.\n * Wait, visibility is \"entire line of sight\". So to cover a specific cell C, \n * we must be on the row of C (with clear path) or col of C (with clear path).\n * Let's define \"Lines\" as maximal contiguous straight road segments.\n * To cover the whole map, every cell must be covered.\n * Notice that if we visit a specific cell in a Line, we see the whole Line? \n * YES, because \"visible\" means unblocked path. If we are at (r, c) inside a horizontal line segments from (r, c1) to (r, c2),\n * we see all (r, k) for c1 <= k <= c2.\n * So, the problem reduces to: Pick a set of visitation points such that every maximal contiguous segment is \"pierced\" by at least one point.\n * Then TSP these points.\n *\n * Wait, a single Line (e.g., horizontal) is covered if we visit *any* cell in it.\n * So for each maximal horizontal segment H_i and vertical segment V_j, we need to pick a set of points P\n * such that for all i, (P intersect H_i) is not empty, AND for all j, (P intersect V_j) is not empty?\n * Actually, if we visit a point p=(r,c), we cover the horizontal segment containing p AND the vertical segment containing p.\n * So this is exactly the \"Set Cover\" problem where elements are Segments and we pick Points (intersections of segments).\n * \n * Let S_H be the set of horizontal segments, S_V be the set of vertical segments.\n * We want to pick points {p_k} to cover all S_H and S_V.\n * A point p covers H_i if p is in H_i. It covers V_j if p is in V_j.\n * Often, intersections cover both an H and a V. Points inside a segment but not at an intersection cover only 1.\n * So we should prioritize intersections.\n *\n * Algorithm:\n * 1. Extract all maximal Horizontal segments and Vertical segments.\n * 2. Identify all candidate points:\n * - Intersections between an H-seg and a V-seg.\n * - For segments that have no intersections (isolated lines?), pick any point (ideally closest to others).\n * 3. Solve Set Cover to pick a minimal set of points (or minimal cost set).\n * Since we want to minimize travel time, points should be clustered. This is a \"Connected Set Cover\" or \"TSP with Neighborhoods\".\n * 4. Construct TSP tour on selected points.\n * 5. Optimize TSP with 2-opt/3-opt.\n * 6. Optimize local paths (All-Pairs shortest paths is grid-based BFS).\n *\n * Optimization:\n * The cost function is total travel time. The \"Set Cover\" logic ignores the cost of travel between points.\n * We can use a greedy construction + randomized restarts.\n * \n * Greedy Construction:\n * - Start at (si, sj).\n * - While there are uncovered segments:\n * - Find a reachable point 'p' that covers \"many\" or \"difficult\" uncovered segments and is \"close\".\n * - Move to 'p'.\n * - Mark segments covered.\n * - Return to start.\n *\n * This looks like the \"Nearest Neighbor\" heuristic adapted for coverage.\n * Let's refine: \"Next Best View\" planner.\n * Score(p) = (New Segments Covered by p) / (Cost to reach p)^alpha\n * This often works well for exploration.\n *\n * After getting a full route, we can try to optimize it.\n * Route representation: Sequence of \"Target Points\".\n * Actual path: BFS path between targets.\n * Optimization:\n * 1. Remove redundant targets (if coverage is maintained).\n * 2. Reorder targets (TSP 2-opt).\n * 3. Replace a target p with p' nearby if p' maintains coverage but reduces distance.\n *\n * Given N <= 69, BFS is fast enough to be called many times.\n * We have 3 seconds.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst int INF = 1e9;\nint N;\nint SI, SJ;\nvector GRID;\nint cost_grid[70][70]; // Numeric cost\n\n// Directions: 0:U, 1:D, 2:L, 3:R\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\nconst char DCHAR[] = {'U', 'D', 'L', 'R'};\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n};\n\n// Segment representing a maximal straight line of road\nstruct Segment {\n int id;\n int r1, c1, r2, c2; // Inclusive range. For horizontal r1=r2, for vertical c1=c2\n bool is_vertical;\n int length;\n \n bool contains(const Point& p) const {\n if (is_vertical) return p.c == c1 && p.r >= r1 && p.r <= r2;\n else return p.r == r1 && p.c >= c1 && p.c <= c2;\n }\n};\n\nvector segments;\nint seg_owner[70][70][2]; // [r][c][0] -> H-seg ID, [r][c][1] -> V-seg ID. -1 if none.\n\n// Intersection: a point belonging to two segments (usually one H and one V)\nstruct Intersection {\n Point p;\n int h_seg_id;\n int v_seg_id;\n};\nvector intersections;\n\n// --- Utilities ---\n\n// BFS to find shortest path distance and reconstruction\nstruct PathResult {\n int dist;\n string path_str;\n Point end_pos;\n};\n\n// Simple Dijkstra/BFS for weighted grid\n// Returns dist[N][N], and parent pointers\nvoid get_dist_map(Point start, vector>& dists, vector>& parent_dir) {\n dists.assign(N, vector(N, INF));\n parent_dir.assign(N, vector(N, -1));\n \n priority_queue>, vector>>, greater>>> pq;\n \n dists[start.r][start.c] = 0;\n pq.push({0, {start.r, start.c}});\n \n while(!pq.empty()) {\n auto [d, pos] = pq.top();\n pq.pop();\n int r = pos.first;\n int c = pos.second;\n \n if (d > dists[r][c]) continue;\n \n for(int i=0; i<4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N && GRID[nr][nc] != '#') {\n int new_cost = d + cost_grid[nr][nc];\n if (new_cost < dists[nr][nc]) {\n dists[nr][nc] = new_cost;\n parent_dir[nr][nc] = i;\n pq.push({new_cost, {nr, nc}});\n }\n }\n }\n }\n}\n\nstring reconstruct_path(Point start, Point end, const vector>& parent_dir) {\n string path = \"\";\n int cur_r = end.r;\n int cur_c = end.c;\n while (cur_r != start.r || cur_c != start.c) {\n int dir = parent_dir[cur_r][cur_c];\n if (dir == -1) return \"\"; // Should not happen if reachable\n path += DCHAR[dir];\n // parent is reverse move\n // if dir was U (-1, 0), we came from r+1\n // actually parent_dir stores the direction TO (cur_r, cur_c) from parent\n // so parent is (cur_r - dr, cur_c - dc)\n cur_r -= DR[dir];\n cur_c -= DC[dir];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\nint get_path_cost(const string& s, Point start) {\n int t = 0;\n int r = start.r, c = start.c;\n for (char m : s) {\n if (m == 'U') r--;\n else if (m == 'D') r++;\n else if (m == 'L') c--;\n else if (m == 'R') c++;\n t += cost_grid[r][c];\n }\n return t;\n}\n\n// --- Preprocessing ---\n\nvoid find_segments() {\n segments.clear();\n for(int i=0; i= 3 usually, or just structural crossing).\n // However, for set cover purposes, any cell covered by H and V is a candidate.\n // But strictly, any road cell belongs to exactly one H-seg and one V-seg in our definition.\n // Wait, a road cell (r,c) is part of row r (H-seg) and col c (V-seg). \n // If H-seg has length 1 and V-seg has length 1, it's an isolated cell.\n \n // We collect \"Important Points\":\n // 1. True crossings (where we can switch direction).\n // 2. If a segment has no crossings, we must pick at least one point in it.\n \n // Let's just consider ALL road cells as potential viewpoints? Too many (N*N).\n // Reduce to: \n // - Vertices of the underlying graph (degree != 2).\n // - One representative for each segment if it has no vertices.\n \n // Let's just use the greedy strategy on the grid, maybe restricting search to \"Vertices\".\n // Vertices: \n // - Ends of segments?\n // - Crossings (degree >= 3)?\n // - Corners (degree == 2 but turn)?\n \n // Let's define \"Crossings\" as cells where we can move in at least 3 directions OR turn (corner).\n // Actually, for the Set Cover, any point in a segment covers it.\n // The best points are those that cover BOTH their H and V segments.\n // Every road cell covers its H and V. \n // So we want to pick a minimum number of cells to cover all segments.\n // Since every cell covers exactly 2 segments (one H, one V), this is Edge Cover on a bipartite graph?\n // Bipartite graph: Left nodes = H-segments, Right nodes = V-segments.\n // Edge between H_i and V_j if they intersect (share a cell).\n // We want to pick edges (cells) to cover all nodes (segments).\n // This is exactly Minimum Edge Cover.\n // Min Edge Cover size = |V| - Max Matching size? No, that's for vertex cover.\n // For Edge Cover: Size = Max Matching + (Vertices - 2 * Max Matching) = |V| - Max Matching.\n // Yes. We can find the Minimum Edge Cover in polynomial time!\n // The edges in the Min Edge Cover correspond to a set of cells {P} that cover all segments.\n // We can then just visit these cells {P} + start point.\n \n // Refined Algorithm:\n // 1. Build Bipartite Graph: U = {H-segs}, V = {V-segs}. Edge (u, v) if they share a cell.\n // The cell corresponding to edge (u, v) is the intersection point.\n // 2. Find Maximum Matching M.\n // 3. For every matched edge in M, select the corresponding cell. Both H and V segs are covered.\n // 4. For every unmatched H-seg, pick any cell in it (ideally one close to other selected points).\n // 5. For every unmatched V-seg, pick any cell in it.\n // 6. This gives a set of points. Solve TSP on these points.\n \n // NOTE: Unmatched segments might be covered by points selected for other segments?\n // No, because an edge (cell) covers exactly its endpoints (H and V segments).\n // If an H-seg is unmatched in max matching, it means it's not covered by the chosen matching edges.\n // But we need to cover it. We must pick an edge incident to it.\n // In Edge Cover construction:\n // - Take edges from Max Matching.\n // - For every uncovered vertex, pick an arbitrary incident edge.\n // This guarantees coverage with minimum number of edges (cells).\n \n // Does minimizing number of cells minimize travel time? Not necessarily, but it's a strong proxy.\n // Let's try this.\n}\n\nstruct BipartiteMatching {\n int n_left, n_right;\n vector> adj;\n vector match_left, match_right;\n vector vis;\n\n BipartiteMatching(int nl, int nr) : n_left(nl), n_right(nr), adj(nl), match_left(nl, -1), match_right(nr, -1) {}\n\n void add_edge(int u, int v) {\n adj[u].push_back(v);\n }\n\n bool dfs(int u) {\n vis[u] = true;\n for (int v : adj[u]) {\n if (match_right[v] == -1 || (!vis[match_right[v]] && dfs(match_right[v]))) {\n match_left[u] = v;\n match_right[v] = u;\n return true;\n }\n }\n return false;\n }\n\n int solve() {\n int matches = 0;\n for (int i = 0; i < n_left; ++i) {\n vis.assign(n_left, false);\n if (dfs(i)) matches++;\n }\n return matches;\n }\n};\n\n// --- TSP Solver ---\n// Using simulated annealing or simple 2-opt on the tour\nvector optimize_tour(vector targets) {\n // Start point must be first and last?\n // Actually, targets is just a set of points to visit.\n // We need to add start point, then order them.\n // Start point covers segments too, so maybe it's already in the set?\n // If not, add it.\n \n bool start_included = false;\n Point start_pt = {SI, SJ};\n for (auto& p : targets) if (p == start_pt) start_included = true;\n if (!start_included) targets.push_back(start_pt);\n \n // Simple Nearest Neighbor to init\n vector tour;\n vector used(targets.size(), false);\n \n Point current = start_pt;\n tour.push_back(current);\n \n // Find index of start in targets and mark used\n for(int i=0; i<(int)targets.size(); ++i) {\n if (targets[i] == start_pt && !used[i]) {\n used[i] = true;\n break;\n }\n }\n \n int count = 1;\n while(count < (int)targets.size()) {\n int best_idx = -1;\n int best_dist = INF;\n \n // Just Manhattan dist as heuristic for speed\n for(int i=0; i<(int)targets.size(); ++i) {\n if (!used[i]) {\n int d = abs(targets[i].r - current.r) + abs(targets[i].c - current.c);\n if (d < best_dist) {\n best_dist = d;\n best_idx = i;\n }\n }\n }\n \n used[best_idx] = true;\n current = targets[best_idx];\n tour.push_back(current);\n count++;\n }\n // Don't add start at the end yet, we handle return loop in cost calc\n \n // 2-opt Optimization\n // We want to minimize cycle cost: sum dist(p[i], p[i+1]) + dist(p[end], p[0])\n // Real distance is BFS distance. Precomputing all-pairs is expensive.\n // Heuristic: Use Manhattan initially, then refine?\n // Actually N=69, All-Pairs BFS on ~500 points is too slow (500 BFS calls).\n // But we only need distances between adjacent in tour.\n // Let's run 2-opt with Manhattan distance first.\n \n auto dist_approx = [&](Point a, Point b) {\n return abs(a.r - b.r) + abs(a.c - b.c);\n };\n \n int sz = tour.size();\n bool improved = true;\n int iter = 0;\n while(improved && iter < 1000) { // Limit iterations\n improved = false;\n iter++;\n for (int i = 0; i < sz - 1; ++i) {\n for (int j = i + 2; j < sz; ++j) {\n if (i == 0 && j == sz - 1) continue; // Don't break the loop wraparound in a weird way here\n \n // Current edges: (i, i+1) and (j, j+1) [wrapping handled if j=sz-1, j+1=0]\n int next_i = i + 1;\n int next_j = (j + 1) % sz;\n \n Point p_i = tour[i];\n Point p_next_i = tour[next_i];\n Point p_j = tour[j];\n Point p_next_j = tour[next_j];\n \n long long cur_cost = dist_approx(p_i, p_next_i) + dist_approx(p_j, p_next_j);\n long long new_cost = dist_approx(p_i, p_j) + dist_approx(p_next_i, p_next_j);\n \n if (new_cost < cur_cost) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n \n // Rotate tour so start is at 0\n vector final_tour;\n int start_idx = -1;\n for(int i=0; i h_ids, v_ids;\n for(auto& s : segments) {\n if (!s.is_vertical) h_ids.push_back(s.id);\n else v_ids.push_back(s.id);\n }\n \n // Map segment ID to index 0..K\n map h_map, v_map;\n for(int i=0; i<(int)h_ids.size(); ++i) h_map[h_ids[i]] = i;\n for(int i=0; i<(int)v_ids.size(); ++i) v_map[v_ids[i]] = i;\n \n BipartiteMatching bm(h_ids.size(), v_ids.size());\n \n // Fill edges\n // Iterate over grid to find intersections\n // intersection_pts[h_idx][v_idx] = Point\n map, Point> intersection_points;\n \n for(int r=0; r targets;\n vector h_covered(h_ids.size(), false);\n vector v_covered(v_ids.size(), false);\n \n // 1. Add points from Matching\n for (int i = 0; i < (int)h_ids.size(); ++i) {\n int match = bm.match_left[i];\n if (match != -1) {\n // This edge (i, match) is in the matching\n // But BM just gives a matching. The edge cover logic is:\n // Take edges from Max Matching.\n // Any vertex NOT in Matching must be covered by adding an edge.\n // Wait, edge cover size = |V| - |Matching|. \n // We construct it by taking the matching edges, then greedy for the rest.\n // Actually, the standard construction is:\n // Start with M (Max Matching).\n // For every unmatched vertex u in U (Left), pick an edge (u, v).\n // For every unmatched vertex v in V (Right), pick an edge (u, v).\n // Note: if we pick (u, v) where v was already matched in M (say with u'), v is now covered twice.\n // That's fine.\n \n // Let's collect the points for the matching first.\n Point p = intersection_points[{i, match}];\n targets.push_back(p);\n h_covered[i] = true;\n v_covered[match] = true;\n }\n }\n \n // 2. Cover remaining H segments\n for (int i = 0; i < (int)h_ids.size(); ++i) {\n if (!h_covered[i]) {\n // Pick a point on this H-segment.\n // Prefer intersection with an ALREADY COVERED V-segment if possible (redundancy but keeps points clustered?)\n // Or intersection with ANY V-segment.\n // Or just any point.\n // Strategy: Check if this H-segment intersects with any V-segment.\n // If yes, pick the intersection closest to center or something.\n // If no (isolated horizontal line), pick midpoint.\n \n bool found = false;\n for (int v_adj : bm.adj[i]) {\n // This H-segment intersects with V-segment v_adj\n Point p = intersection_points[{i, v_adj}];\n targets.push_back(p);\n // Note: v_adj might already be covered. That's okay.\n found = true;\n break; // Just need one\n }\n \n if (!found) {\n // Isolated H-segment? Should not happen if graph is connected component\n // But maybe it intersects no V-segment? (Length 1 H-seg intersects Length 1 V-seg at same cell)\n // So adj list shouldn't be empty unless bug or weird geometry.\n // Just in case:\n Segment& seg = segments[h_ids[i]];\n targets.push_back({seg.r1, (seg.c1 + seg.c2)/2});\n }\n h_covered[i] = true;\n }\n }\n \n // 3. Cover remaining V segments\n for (int j = 0; j < (int)v_ids.size(); ++j) {\n if (!v_covered[j]) {\n bool found = false;\n // We need to find an H-segment that intersects this V-segment (reverse lookup or iterate)\n // Since we didn't build reverse adj in BM explicitly (though it has match_right),\n // let's just scan intersection points or build reverse adj.\n // Actually, we can iterate all h that connect to j.\n // But BM only stores Left->Right.\n // Let's scan H's.\n // Optimization: Just look at the segment definition.\n \n Segment& vseg = segments[v_ids[j]];\n // Iterate cells in V-seg\n for (int r = vseg.r1; r <= vseg.r2; ++r) {\n int c = vseg.c1;\n // (r, c) is the point. Check its H-segment.\n int hid = seg_owner[r][c][0];\n if (hid != -1) {\n targets.push_back({r, c});\n found = true;\n break;\n }\n }\n \n if (!found) {\n targets.push_back({(vseg.r1 + vseg.r2)/2, vseg.c1});\n }\n v_covered[j] = true;\n }\n }\n \n // Optimize targets: remove duplicates\n sort(targets.begin(), targets.end());\n targets.erase(unique(targets.begin(), targets.end()), targets.end());\n \n // --- Refinement Step ---\n // We have a set of points covering all segments.\n // Now solve TSP.\n vector tour = optimize_tour(targets);\n \n // Construct full path\n string full_path = \"\";\n Point curr = tour[0];\n \n // Re-use memory for BFS\n vector> dists(N, vector(N));\n vector> parent_dir(N, vector(N));\n \n for(size_t i = 1; i < tour.size(); ++i) {\n Point next = tour[i];\n if (curr == next) continue;\n \n get_dist_map(curr, dists, parent_dir);\n string segment_path = reconstruct_path(curr, next, parent_dir);\n full_path += segment_path;\n curr = next;\n }\n \n return full_path;\n}\n\n\n// --- Advanced refinement: Reduce Viewpoints ---\n// The set cover from Edge Cover is minimal in # of points, but not necessarily minimal TSP cost.\n// Sometimes covering 2 segments with 2 points is better than 1 point if the 1 point is far.\n// But given the dense city structure and \"cost 5-9\", detours are expensive.\n// \"Minimal number of stops\" is a very strong heuristic for \"minimal total distance\" here.\n// Because stopping usually means traveling to a specific intersection.\n// The biggest inefficiency is the TSP order and the backtracking.\n\n// --- Post-processing: Shortcuts ---\n// The path goes A -> B -> C. Maybe we can go A -> C directly if B was redundant?\n// But B was selected to cover something.\n// We can verify coverage.\n// Given the full path, simulate coverage.\n// Then try to shorten parts of the path.\n// This is complicated to implement efficiently in C++.\n// Instead, let's trust the TSP on minimal set.\n\n// Another optimization:\n// When moving from A to B, we traverse cells. These cells might cover segments that were supposed to be covered by C.\n// If so, C might become redundant.\n// Algorithm:\n// 1. Generate Tour (A -> B -> C -> ...).\n// 2. Calculate exact path.\n// 3. Check remaining necessary viewpoints.\n// If a viewpoint is already \"seen\" (covered) by the path segments generated so far, skip it?\n// Wait, the order is fixed.\n// Dynamic adjustment:\n// Start at Tour[0].\n// Look at next target Tour[1]. Compute path.\n// Along this path, we cover segments.\n// Mark segments covered.\n// Check if Tour[2] is still needed. If all segments Tour[2] was responsible for are covered, skip Tour[2].\n// Problem: We don't know exactly which segments Tour[2] was *solely* responsible for.\n// Better: Maintain set of uncovered segments.\n// Filter future tour points: if a future point p only covers segments that are now covered, remove p.\n// Is 'p' needed?\n// Check if (Segments covered by p) intersect (Uncovered Segments).\n// If intersection is empty, p is redundant *for coverage*.\n// (It might be useful for connectivity, but BFS handles connectivity).\n// So yes, remove p.\n\n// Let's implement this dynamic filtering.\n\nbool is_needed(Point p, const vector& h_cov, const vector& v_cov, \n const map& h_map, const map& v_map) {\n // Check H segment at p\n int hid = seg_owner[p.r][p.c][0];\n if (hid != -1) {\n if (!h_cov[h_map.at(hid)]) return true;\n }\n // Check V segment at p\n int vid = seg_owner[p.r][p.c][1];\n if (vid != -1) {\n if (!v_cov[v_map.at(vid)]) return true;\n }\n return false;\n}\n\nvoid mark_covered(Point p, vector& h_cov, vector& v_cov, \n const map& h_map, const map& v_map) {\n int hid = seg_owner[p.r][p.c][0];\n if (hid != -1) h_cov[h_map.at(hid)] = true;\n int vid = seg_owner[p.r][p.c][1];\n if (vid != -1) v_cov[v_map.at(vid)] = true;\n}\n\nstring refined_solve() {\n find_segments();\n \n vector h_ids, v_ids;\n for(auto& s : segments) {\n if (!s.is_vertical) h_ids.push_back(s.id);\n else v_ids.push_back(s.id);\n }\n \n map h_map, v_map;\n for(int i=0; i<(int)h_ids.size(); ++i) h_map[h_ids[i]] = i;\n for(int i=0; i<(int)v_ids.size(); ++i) v_map[v_ids[i]] = i;\n \n BipartiteMatching bm(h_ids.size(), v_ids.size());\n map, Point> intersection_points;\n \n for(int r=0; r targets;\n vector h_claimed(h_ids.size(), false);\n vector v_claimed(v_ids.size(), false);\n \n // Collect points same as before\n for (int i = 0; i < (int)h_ids.size(); ++i) {\n int match = bm.match_left[i];\n if (match != -1) {\n targets.push_back(intersection_points[{i, match}]);\n h_claimed[i] = true; v_claimed[match] = true;\n }\n }\n for (int i = 0; i < (int)h_ids.size(); ++i) {\n if (!h_claimed[i]) {\n bool found = false;\n for (int v_adj : bm.adj[i]) {\n targets.push_back(intersection_points[{i, v_adj}]);\n found = true; break; \n }\n if (!found) {\n Segment& seg = segments[h_ids[i]];\n targets.push_back({seg.r1, (seg.c1 + seg.c2)/2});\n }\n }\n }\n for (int j = 0; j < (int)v_ids.size(); ++j) {\n if (!v_claimed[j]) {\n bool found = false;\n Segment& vseg = segments[v_ids[j]];\n for (int r = vseg.r1; r <= vseg.r2; ++r) {\n int c = vseg.c1;\n int hid = seg_owner[r][c][0];\n if (hid != -1) {\n targets.push_back({r, c});\n found = true; break;\n }\n }\n if (!found) targets.push_back({(vseg.r1 + vseg.r2)/2, vseg.c1});\n }\n }\n \n sort(targets.begin(), targets.end());\n targets.erase(unique(targets.begin(), targets.end()), targets.end());\n \n // Build TSP\n vector tour = optimize_tour(targets);\n \n // Dynamic construction\n string full_path = \"\";\n Point curr = tour[0]; // Start point\n \n // Real coverage tracking\n vector h_real_cov(h_ids.size(), false);\n vector v_real_cov(v_ids.size(), false);\n \n // Helper to update coverage along a path string\n auto update_coverage_path = [&](Point start_p, const string& path) {\n Point p = start_p;\n mark_covered(p, h_real_cov, v_real_cov, h_map, v_map);\n for (char c : path) {\n if (c=='U') p.r--;\n else if (c=='D') p.r++;\n else if (c=='L') p.c--;\n else if (c=='R') p.c++;\n mark_covered(p, h_real_cov, v_real_cov, h_map, v_map);\n }\n };\n \n update_coverage_path(curr, \"\"); // Cover start point\n \n vector> dists(N, vector(N));\n vector> parent_dir(N, vector(N));\n \n for(size_t i = 1; i < tour.size(); ++i) {\n Point next_target = tour[i];\n \n // Check if next_target is still needed for coverage\n if (!is_needed(next_target, h_real_cov, v_real_cov, h_map, v_map)) {\n // If it's the last point (start point return), we might still need to go there to finish loop?\n // The problem requires returning to (si, sj).\n // tour.back() is (si, sj).\n if (i != tour.size() - 1) {\n continue; // Skip redundant point\n }\n }\n \n if (curr == next_target) continue;\n\n get_dist_map(curr, dists, parent_dir);\n string sub_path = reconstruct_path(curr, next_target, parent_dir);\n \n update_coverage_path(curr, sub_path);\n full_path += sub_path;\n curr = next_target;\n }\n \n return full_path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (!(cin >> N >> SI >> SJ)) return 0;\n GRID.resize(N);\n for(int i=0; i> GRID[i];\n for(int j=0; j1, T = w + noise. So w_approx = T.\n * - Error E = w_approx - w.\n * - We want to change s_k to reduce E.\n * - The gradient of w w.r.t s_k is -1 if d_k > s_k, else 0.\n * - We update s_k += learning_rate * E * (1 if d_k > s_k else 0).\n * - Since we handle integer vectors, we apply probabilistic or deterministic increments.\n * \n * Implementation details:\n * - Use `long long` for safety, though inputs are small.\n * - Use fast I/O.\n */\n\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\n// Global Constants\nconstexpr int MAX_DAYS = 2000;\n\n// Random number generator\nmt19937 rng(12345);\n\nstruct Task {\n int id;\n vector d; // required skills\n vector children;\n vector parents;\n int parent_count; // dynamic incomplete parents count\n int original_parent_count;\n \n // Static analysis features\n int depth_rank; // Longest path to end\n int descendants_count; \n};\n\nstruct Member {\n int id;\n vector s; // estimated skills\n int working_on_task_id; // -1 if free\n int task_start_day;\n \n // History for better estimation (optional, simple greedy update used here)\n // We can store past tasks to replay training if we want to be fancy, \n // but online updates are usually sufficient for this constraint.\n};\n\nint N, M, K, R;\nvector tasks;\nvector members;\nvector task_status; // 0: not started, 1: working, 2: completed\n\n// Helper to generate random int\nint randint(int l, int r) {\n return uniform_int_distribution(l, r)(rng);\n}\n\n// Calculate predicted steps\n// w = sum(max(0, d - s))\n// t = w == 0 ? 1 : w + noise\n// expected t ~ w (ignoring the w=0 case discontinuity and noise average 0)\nint predict_ticks(const vector& d, const vector& s) {\n int w = 0;\n for (int k = 0; k < K; ++k) {\n w += max(0, d[k] - s[k]);\n }\n if (w == 0) return 1;\n return max(1, w); \n}\n\n// Calculate topological features for prioritization\nvoid analyze_graph() {\n // Calculate depth (longest path from task to any leaf)\n // Since N is up to 1000, O(N+R) with memoization is fine.\n vector depth(N + 1, -1);\n vector descendants(N + 1, -1);\n \n // Tasks are topologically sorted? No guarantee in input, but u < v implies acyclic.\n // We can compute in reverse order of ID since u < v.\n for (int i = N; i >= 1; --i) {\n int max_child_depth = 0;\n int total_descendants = 0;\n for (int child_id : tasks[i].children) {\n max_child_depth = max(max_child_depth, tasks[child_id].depth_rank);\n total_descendants += 1 + tasks[child_id].descendants_count;\n }\n tasks[i].depth_rank = 1 + max_child_depth;\n tasks[i].descendants_count = total_descendants;\n }\n}\n\n// Skill Estimation Update\nvoid update_skills(int member_id, int task_id, int actual_duration) {\n Member& m = members[member_id];\n const Task& t = tasks[task_id];\n \n // Current prediction\n int w_est = 0;\n vector relevant_dims;\n for (int k = 0; k < K; ++k) {\n if (t.d[k] > m.s[k]) {\n w_est += (t.d[k] - m.s[k]);\n relevant_dims.push_back(k);\n }\n }\n \n // Inverse logic:\n // We observed actual_duration.\n // If actual_duration == 1, then w was likely 0 (or very small and noise made it 1).\n // If actual_duration > 1, actual_duration = w_true + noise.\n // So w_true is roughly actual_duration.\n \n int w_target = actual_duration;\n // There's noise uniform(-3, 3). We don't know the noise, but over time it averages out.\n // If we assume noise is 0 for the update, we oscillate around the truth.\n \n // Simple Gradient Descent step\n // Error = w_est - w_target\n // We want to minimize (w_est - w_target)^2\n // w_est = sum_{k in relevant} (d_k - s_k)\n // partial derivative w.r.t s_k is -1 for k in relevant.\n // s_k_new = s_k - learning_rate * (d(Error)/d(s_k))\n // = s_k - learning_rate * 2 * (w_est - w_target) * (-1)\n // = s_k + 2 * lr * (w_est - w_target)\n \n // If w_est < w_target (took longer than expected), Error < 0. update should decrease s_k?\n // Wait.\n // w_est small means we think we are good. w_target large means we are bad.\n // So s_k should decrease (be further from d_k) to increase w_est.\n // Formula check: w_est - w_target < 0. s_k += neg * neg -> s_k += pos.\n // This increases s_k, which reduces w_est. This is wrong.\n \n // Let's reason simply:\n // If w_est < w_target (Underestimated difficulty / Overestimated skill):\n // We need to increase w_est => decrease s_k.\n // If w_est > w_target (Overestimated difficulty / Underestimated skill):\n // We need to decrease w_est => increase s_k.\n \n int diff = w_est - w_target; // Positive if we are too pessimistic (s too low), Negative if too optimistic (s too high)\n \n if (diff == 0) return; // Perfect prediction (or lucky noise)\n \n // To distribute the correction across dimensions\n // If we need to increase s (diff > 0), we pick dimensions where d_k > s_k mainly?\n // Actually, any s_k can affect w if d_k > s_k.\n // If d_k <= s_k, increasing s_k doesn't change max(0, d-s)=0 (remains 0).\n // But decreasing s_k might make it positive.\n \n // We use a randomized update strategy to avoid getting stuck\n // The \"learning rate\" effectively is how many points we distribute\n int correction = abs(diff); \n \n // Damping factor to account for noise. If |diff| <= 3, it might just be noise.\n // However, consistently correcting small amounts is fine.\n // We reduce the correction magnitude slightly to be conservative.\n correction = max(1, correction / 2);\n\n if (diff > 0) {\n // Estimated time too high -> Skills are actually better -> Increase s\n // We can increase s_k where d_k > s_k to reduce the term (d_k - s_k).\n // Or we can increase s_k where d_k <= s_k (doesn't help immediately for this task, but generally good).\n // Focusing on relevant dims is most effective for reducing the specific error.\n if (!relevant_dims.empty()) {\n for (int iter = 0; iter < correction; ++iter) {\n int k = relevant_dims[randint(0, relevant_dims.size() - 1)];\n m.s[k]++;\n }\n } else {\n // w_est was 0, but w_target can't be smaller than 1 unless logic error.\n // If diff > 0, w_est > w_target. Since w_target >= 1, w_est >= 2.\n // So relevant_dims cannot be empty.\n }\n } else {\n // Estimated time too low -> Skills are actually worse -> Decrease s\n // We need to increase w_est. Decrease s_k.\n // We should decrease s_k where it contributes to w (relevant_dims) or where it *should* contribute.\n // If we simply decrease random s_k, it increases max(0, d-s).\n \n // We prioritize dimensions where s_k is currently high or close to d_k?\n // Random dimension selection works reasonably well.\n for (int iter = 0; iter < correction; ++iter) {\n int k = randint(0, K - 1);\n if (m.s[k] > 0) {\n m.s[k]--;\n }\n }\n }\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // 1. Read Input\n cin >> N >> M >> K >> R;\n \n tasks.resize(N + 1);\n members.resize(M + 1);\n task_status.assign(N + 1, 0);\n \n for (int i = 1; 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 tasks[i].parent_count = 0;\n tasks[i].original_parent_count = 0;\n }\n \n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n tasks[u].children.push_back(v);\n tasks[v].parents.push_back(u);\n tasks[v].parent_count++;\n tasks[v].original_parent_count++;\n }\n \n // Initialize members\n for (int j = 1; j <= M; ++j) {\n members[j].id = j;\n members[j].s.assign(K, 0); // Start with 0 skill estimate\n // Alternative initialization: random normal around 0?\n // Given \"non-negative integer vector\", 0 is a safe lower bound.\n members[j].working_on_task_id = -1;\n }\n \n analyze_graph();\n\n vector ready_tasks;\n for (int i = 1; i <= N; ++i) {\n if (tasks[i].parent_count == 0) {\n ready_tasks.push_back(i);\n }\n }\n \n int completed_count = 0;\n \n // 2. Simulation Loop\n for (int day = 1; day <= MAX_DAYS; ++day) {\n // Output container\n vector> assignments;\n \n // Identify free members\n vector free_members;\n for (int j = 1; j <= M; ++j) {\n if (members[j].working_on_task_id == -1) {\n free_members.push_back(j);\n }\n }\n \n // Sort tasks by importance\n // Important tasks: High depth (critical path), High descendants\n // We can also consider difficulty vs skill match, but first filter by graph topology.\n sort(ready_tasks.begin(), ready_tasks.end(), [&](int a, int b) {\n // Lexicographical comparison of importance features\n if (tasks[a].depth_rank != tasks[b].depth_rank) \n return tasks[a].depth_rank > tasks[b].depth_rank;\n if (tasks[a].descendants_count != tasks[b].descendants_count)\n return tasks[a].descendants_count > tasks[b].descendants_count;\n return a < b; // Tie-break\n });\n\n // Match free members to ready tasks\n // Since M is small (20), we can afford O(M * |Ready|) or something slightly heavier.\n // We want to assign the \"best\" task to the \"best\" member for it.\n // However, \"best task\" is global (graph structure). \"Best member\" is local (skill match).\n // Strategy: Iterate tasks in order of importance. Assign to the member who can finish it fastest.\n \n vector task_taken(ready_tasks.size(), false);\n vector member_taken(M + 1, false);\n \n // We use a simple greedy approach: \n // Take the most important tasks and assign them to the member who does them fastest.\n // Note: Sometimes it's better to give a hard task to a strong member and an easy task to a weak member.\n // But minimizing completion time of the critical path is usually key.\n \n // To improve matching, let's iterate through available tasks (limit to some lookahead)\n // and find the (task, member) pair that minimizes duration, prioritizing important tasks implicitly.\n \n // Simple 2-pass Greedy:\n // Pass 1: For high priority tasks, find best member.\n \n // Let's make a list of assignments to perform this turn\n // We will simply loop until we run out of free members or ready tasks\n \n int assigned_count = 0;\n int max_assignments = min((int)free_members.size(), (int)ready_tasks.size());\n \n // We will construct a cost matrix for matching if we want to be precise,\n // but given the uncertainty, a heuristic loop is fine.\n \n // Let's try to assign tasks to members.\n // We iterate through free members and assign the best task for them?\n // Or iterate through tasks and assign best member?\n // Iterating through tasks (ordered by priority) and picking the best available member \n // ensures critical path moves fast.\n \n for (int i = 0; i < ready_tasks.size(); ++i) {\n if (assignments.size() >= free_members.size()) break;\n \n int t_id = ready_tasks[i];\n if (task_taken[i]) continue;\n \n // Find best member for this task among those not yet taken\n int best_m_id = -1;\n int min_pred_time = 1e9;\n \n // Heuristic: We want to minimize time.\n // Also, maybe reserve super-skilled members for super-hard tasks? \n // (Not modeled here, standard greedy is strong enough).\n \n for (int m_id : free_members) {\n if (member_taken[m_id]) continue;\n \n int pred = predict_ticks(tasks[t_id].d, members[m_id].s);\n if (pred < min_pred_time) {\n min_pred_time = pred;\n best_m_id = m_id;\n }\n }\n \n if (best_m_id != -1) {\n // Assign\n assignments.push_back({best_m_id, t_id});\n member_taken[best_m_id] = true;\n task_taken[i] = true;\n \n // Update internal state immediately\n members[best_m_id].working_on_task_id = t_id;\n members[best_m_id].task_start_day = day;\n task_status[t_id] = 1;\n }\n }\n \n // Remove taken tasks from ready_tasks\n vector next_ready_tasks;\n for (int i = 0; i < ready_tasks.size(); ++i) {\n if (!task_taken[i]) {\n next_ready_tasks.push_back(ready_tasks[i]);\n }\n }\n ready_tasks = next_ready_tasks;\n\n // Output assignments\n cout << assignments.size();\n for (auto& p : assignments) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << endl; // flush\n \n // 3. Read Response (Finished tasks)\n int n_finished;\n cin >> n_finished;\n \n if (n_finished == -1) {\n // End of simulation\n break;\n }\n \n for (int i = 0; i < n_finished; ++i) {\n int f_member;\n cin >> f_member;\n \n int finished_task = members[f_member].working_on_task_id;\n int duration = day - members[f_member].task_start_day + 1;\n \n // Update skills based on observation\n update_skills(f_member, finished_task, duration);\n \n members[f_member].working_on_task_id = -1;\n task_status[finished_task] = 2; // Completed\n completed_count++;\n \n // Unlock dependencies\n for (int child : tasks[finished_task].children) {\n tasks[child].parent_count--;\n if (tasks[child].parent_count == 0) {\n ready_tasks.push_back(child);\n }\n }\n }\n }\n \n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Hyperparameters ---\nconst int NUM_ORDERS = 1000;\nconst int TARGET_ORDERS = 50;\nconst int CENTER = 400;\nconst double TIME_LIMIT = 1.95; // seconds\n\n// --- Structures ---\nstruct Point {\n int x, y;\n};\n\nstruct Order {\n int id;\n Point pickup;\n Point delivery;\n int dist_pd; // dist(pickup, delivery)\n int dist_center_p; // dist(center, pickup)\n int dist_d_center; // dist(delivery, center)\n};\n\n// --- Global Data ---\nOrder orders[NUM_ORDERS];\nint dist_matrix[NUM_ORDERS * 2 + 2][NUM_ORDERS * 2 + 2]; \n// Mapping: 0..999 are Pickups, 1000..1999 are Deliveries. \n// But since we only select 50, we will map dynamically or just calculate on fly.\n// Given N=1000 is large for full matrix, we calculate distances on the fly.\n// But for the current subset of 50 orders (100 points), we can cache.\n\n// --- Helper Functions ---\ninline int dist(const Point& p1, const Point& p2) {\n return abs(p1.x - p2.x) + abs(p1.y - p2.y);\n}\n\n// --- Random Number Generator ---\nuint64_t xorshift64() {\n static uint64_t x = 88172645463325252ULL;\n x ^= x << 13;\n x ^= x >> 7;\n x ^= x << 17;\n return x;\n}\n\nint rand_int(int n) {\n return xorshift64() % n;\n}\n\ndouble rand_double() {\n return (double)xorshift64() / (double)0xFFFFFFFFFFFFFFFFULL;\n}\n\n// --- Solution State ---\nstruct State {\n vector selected_order_indices; // size 50. Indices into global 'orders'\n vector route; // size 100. values are 0..49 (pickup i), 50..99 (delivery i-50)\n // relative to the selected_order_indices vector.\n int total_dist;\n\n // To quickly check validity and constraints\n // route[k] is the type of node visited at step k.\n // if route[k] < 50, it's pickup for selected_order_indices[route[k]]\n // if route[k] >= 50, it's delivery for selected_order_indices[route[k]-50]\n};\n\n// Calculate total distance of a route including start/end at (400,400)\nint calculate_total_dist(const vector& route, const vector& selection) {\n int d = 0;\n Point curr = {CENTER, CENTER};\n \n for (int node_code : route) {\n Point next_p;\n if (node_code < TARGET_ORDERS) {\n next_p = orders[selection[node_code]].pickup;\n } else {\n next_p = orders[selection[node_code - TARGET_ORDERS]].delivery;\n }\n d += dist(curr, next_p);\n curr = next_p;\n }\n d += dist(curr, {CENTER, CENTER});\n return d;\n}\n\n// Check if a route is valid (Pickup before Delivery)\nbool is_valid_route(const vector& route) {\n int pos_pickup[TARGET_ORDERS];\n int pos_delivery[TARGET_ORDERS];\n for(int i=0; i pos_delivery[i]) return false;\n }\n return true;\n}\n\n// --- Main Solver ---\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n for (int i = 0; i < NUM_ORDERS; ++i) {\n orders[i].id = i + 1; // 1-based ID for output\n cin >> orders[i].pickup.x >> orders[i].pickup.y >> orders[i].delivery.x >> orders[i].delivery.y;\n orders[i].dist_pd = dist(orders[i].pickup, orders[i].delivery);\n orders[i].dist_center_p = dist({CENTER, CENTER}, orders[i].pickup);\n orders[i].dist_d_center = dist(orders[i].delivery, {CENTER, CENTER});\n }\n\n // Initial Selection Strategy\n // We want to pick 50 orders that are somewhat clustered or centrally located.\n // Let's sort all 1000 orders by a heuristic cost:\n // cost = dist(Center -> P) + dist(P -> D) + dist(D -> Center)\n // This is the cost if we did just this one order. Orders with lower individual cost are good candidates.\n vector order_indices(NUM_ORDERS);\n iota(order_indices.begin(), order_indices.end(), 0);\n\n // Slightly randomized sort to allow restarts or diversity if needed, \n // though here we rely on SA.\n // Actually, strict sorting is a good baseline.\n sort(order_indices.begin(), order_indices.end(), [&](int a, int b) {\n int cost_a = orders[a].dist_center_p + orders[a].dist_pd + orders[a].dist_d_center;\n int cost_b = orders[b].dist_center_p + orders[b].dist_pd + orders[b].dist_d_center;\n return cost_a < cost_b;\n });\n\n // Initial State\n State current_state;\n current_state.selected_order_indices.resize(TARGET_ORDERS);\n \n // Take top 50\n for(int i=0; i unselected_indices;\n unselected_indices.reserve(NUM_ORDERS - TARGET_ORDERS);\n for(int i=TARGET_ORDERS; i(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n }\n\n // Current progress for temperature\n auto now_check = chrono::steady_clock::now();\n double elapsed_check = chrono::duration(now_check - start_time).count();\n double progress = elapsed_check / TIME_LIMIT;\n double temp = start_temp + (end_temp - start_temp) * progress;\n\n // Determine move type\n // 0: Swap two nodes in route (TSP move)\n // 1: Shift a node in route (TSP move)\n // 2: Swap an order (Subset move) - More expensive, do less often?\n // Actually, subset modification is crucial.\n \n int move_type = rand_int(100);\n \n if (move_type < 50) { \n // --- Move Type 0: Swap two nodes in route ---\n // We pick two indices u, v in [0, 2*N-1].\n int u = rand_int(TARGET_ORDERS * 2);\n int v = rand_int(TARGET_ORDERS * 2);\n if (u == v) continue;\n if (u > v) swap(u, v);\n\n // Try swapping\n // Check validity efficiently\n // We are swapping route[u] and route[v].\n int node_u = current_state.route[u];\n int node_v = current_state.route[v];\n \n // Validity check:\n // We need to ensure that for the orders involving node_u and node_v, P is before D.\n // Other orders are unaffected.\n \n int p_u_idx = (node_u < TARGET_ORDERS) ? node_u : node_u - TARGET_ORDERS;\n int p_v_idx = (node_v < TARGET_ORDERS) ? node_v : node_v - TARGET_ORDERS;\n \n bool possible = true;\n \n // If we move node_u to v:\n // If node_u is Pickup, its Delivery must be > v (or be node_v which is at u, which is impossible since u < v)\n // If node_u is Delivery, its Pickup must be < v (already true since it was < u) - wait.\n // Let's do a full specific check.\n \n // Find the partner positions currently\n // Since scanning takes O(N), and N=100, it's fast enough.\n // Optimization: maintain positions array? Given N=100, linear scan is very fast in cache.\n \n // Let's perform the swap tentatively\n swap(current_state.route[u], current_state.route[v]);\n \n // Check validity only for affected orders?\n // Actually, checking just p_u_idx and p_v_idx is sufficient.\n auto check_order = [&](int order_idx) {\n int p_pos = -1, d_pos = -1;\n for(int k=0; k<2*TARGET_ORDERS; ++k) {\n if (current_state.route[k] == order_idx) p_pos = k;\n if (current_state.route[k] == order_idx + TARGET_ORDERS) d_pos = k;\n }\n return p_pos < d_pos;\n };\n \n if (!check_order(p_u_idx) || (p_u_idx != p_v_idx && !check_order(p_v_idx))) {\n possible = false;\n }\n\n if (possible) {\n int new_dist = calculate_total_dist(current_state.route, current_state.selected_order_indices);\n int delta = new_dist - current_state.total_dist;\n if (delta < 0 || exp(-delta / temp) > rand_double()) {\n current_state.total_dist = new_dist;\n if (new_dist < best_state.total_dist) {\n best_state = current_state;\n }\n } else {\n // Revert\n swap(current_state.route[u], current_state.route[v]);\n }\n } else {\n // Revert\n swap(current_state.route[u], current_state.route[v]);\n }\n\n } else if (move_type < 80) {\n // --- Move Type 1: Shift (Reinsert) node ---\n // Pick a node at index u, remove it, insert at index v\n int u = rand_int(TARGET_ORDERS * 2);\n int v = rand_int(TARGET_ORDERS * 2); // Insert before v (if v=2N, append? range is 0..2N-1 usually)\n if (u == v) continue;\n \n // Create temp route\n int node = current_state.route[u];\n vector next_route = current_state.route;\n next_route.erase(next_route.begin() + u);\n next_route.insert(next_route.begin() + v, node);\n \n // Check validity for the specific order of 'node'\n int order_idx = (node < TARGET_ORDERS) ? node : node - TARGET_ORDERS;\n \n // Find P and D positions in next_route\n int p_pos = -1, d_pos = -1;\n for(int k=0; k<2*TARGET_ORDERS; ++k) {\n if (next_route[k] == order_idx) p_pos = k;\n if (next_route[k] == order_idx + TARGET_ORDERS) d_pos = k;\n }\n \n if (p_pos < d_pos) {\n int new_dist = calculate_total_dist(next_route, current_state.selected_order_indices);\n int delta = new_dist - current_state.total_dist;\n if (delta < 0 || exp(-delta / temp) > rand_double()) {\n current_state.route = next_route;\n current_state.total_dist = new_dist;\n if (new_dist < best_state.total_dist) {\n best_state = current_state;\n }\n }\n }\n } else {\n // --- Move Type 2: Swap Order (Subset Modification) ---\n // Remove one order from current selection, add one from unselected.\n // To do this efficiently, we remove P and D of victim from route,\n // and insert P and D of new order into best positions (Greedy Insertion).\n \n int remove_idx_in_sel = rand_int(TARGET_ORDERS); // 0..49\n int add_idx_in_unsel = rand_int(unselected_indices.size());\n \n int old_global_idx = current_state.selected_order_indices[remove_idx_in_sel];\n int new_global_idx = unselected_indices[add_idx_in_unsel];\n \n // 1. Remove nodes from route\n vector reduced_route;\n reduced_route.reserve(2 * TARGET_ORDERS - 2);\n \n // We need to be careful about indices in route.\n // Route contains values 0..49 (P) and 50..99 (D).\n // The node to remove corresponds to `remove_idx_in_sel`.\n // Also, other indices > remove_idx_in_sel need to be adjusted? \n // Or we can just replace the meaning of `remove_idx_in_sel` with the new order.\n // Let's just reuse the index `remove_idx_in_sel` for the new order.\n \n // So, in the route, wherever we see `remove_idx_in_sel` (pickup) or `remove_idx_in_sel + 50` (delivery),\n // these are the positions currently occupied by the old order.\n // If we simply swap the global ID in `selected_order_indices`, the route becomes valid for the new order\n // topologically (P before D), but spatially it might be terrible.\n // So we should pull them out and re-insert them optimally.\n \n int p_code = remove_idx_in_sel;\n int d_code = remove_idx_in_sel + TARGET_ORDERS;\n \n for(int x : current_state.route) {\n if (x != p_code && x != d_code) {\n reduced_route.push_back(x);\n }\n }\n \n // Now reduced_route has 98 elements.\n // We temporarily update the selection to calculate distances for insertion\n int original_global_id = current_state.selected_order_indices[remove_idx_in_sel];\n current_state.selected_order_indices[remove_idx_in_sel] = new_global_idx;\n \n // Find best insertion for P (at i) and D (at j) with i <= j\n // This is O(N^2). N=100 -> 10000 ops. Feasible? Yes, simple enough.\n // But we can approximate or just try a few random positions to save time.\n // Let's try Best Insertion.\n \n int best_insertion_dist = 1e9;\n int best_i = -1, best_j = -1;\n \n // To optimize, precalculate partial distances of reduced_route?\n // Let's just do brute force for now, strict time limit check.\n // Or maybe just try random 10 positions if time is tight.\n // Given 2.0s and N=1000, O(N^2) inside SA loop might be too slow.\n // Reduced: Try all i for P, and for D just try picking best immediate placement or best few.\n \n // Fast Insertion Logic:\n // 1. Find best pos for Pickup.\n // 2. Given P pos, find best pos for Delivery.\n // This is O(N).\n \n // Even faster: Random insertion points.\n // Or: The previous P/D positions might be decent hints? No, spatial locality changes.\n \n // Let's implement O(N) heuristic insertion:\n // Iterate all i for P. For each i, find best j for D? No that's O(N^2).\n // Let's iterate all k positions in reduced route (0..98).\n // Calculate cost increase to insert P at k. Pick best 3 candidates.\n // For each candidate P_pos, try all valid D_pos > P_pos.\n \n // Coordinates of new order\n Point P = orders[new_global_idx].pickup;\n Point D = orders[new_global_idx].delivery;\n \n // Precompute cumulative dist of reduced route?\n // Too complex for 256 tokens context? No, simple loop.\n \n // Let's stick to \"Try random positions\" to keep iteration count high.\n // Try 20 random pairs (i, j) with i <= j.\n \n int best_rnd_dist = 1e9;\n int best_rnd_i = -1, best_rnd_j = -1;\n \n // Always try picking i, j closely related to spatial location?\n // Let's just do simple randomized insertion.\n for(int try_k=0; try_k<40; ++try_k) {\n int i = rand_int(reduced_route.size() + 1);\n int j = rand_int(reduced_route.size() + 1);\n if (i > j) swap(i, j);\n // Insert P at i, D at j+1 (since P takes a slot)\n \n // Calculate cost from scratch is O(N). 40 * 100 = 4000 ops. OK.\n vector temp_route = reduced_route;\n temp_route.insert(temp_route.begin() + i, p_code);\n temp_route.insert(temp_route.begin() + j + 1, d_code);\n \n int d = calculate_total_dist(temp_route, current_state.selected_order_indices);\n if (d < best_rnd_dist) {\n best_rnd_dist = d;\n best_rnd_i = i;\n best_rnd_j = j + 1; // index in temp_route effectively\n }\n }\n \n // Accept criteria\n int delta = best_rnd_dist - current_state.total_dist;\n \n if (delta < 0 || exp(-delta / temp) > rand_double()) {\n // Accept\n current_state.total_dist = best_rnd_dist;\n // Reconstruct route\n vector final_route = reduced_route;\n final_route.insert(final_route.begin() + best_rnd_i, p_code);\n // Note: best_rnd_j was calculated based on temp_route logic.\n // In reduced_route logic:\n // If we insert at `i`, indices >= `i` shift by 1.\n // If the second insertion was at `j_temp` (which is > `i`), in reduced_route terms it's `j_temp - 1`.\n // But `best_rnd_j` we stored was the index in the *resulting* vector.\n // So we can just insert into `final_route` which now has P inserted.\n final_route.insert(final_route.begin() + best_rnd_j, d_code);\n \n current_state.route = final_route;\n \n // Swap in unselected list\n unselected_indices[add_idx_in_unsel] = old_global_idx;\n \n if (current_state.total_dist < best_state.total_dist) {\n best_state = current_state;\n }\n } else {\n // Revert selection change\n current_state.selected_order_indices[remove_idx_in_sel] = original_global_id;\n }\n }\n }\n\n // Output Result\n // Format:\n // m r_1 ... r_m\n // n x_1 y_1 ... x_n y_n\n \n cout << TARGET_ORDERS;\n for (int idx : best_state.selected_order_indices) {\n cout << \" \" << orders[idx].id;\n }\n cout << endl;\n\n // Construct path points\n vector path;\n path.push_back({CENTER, CENTER}); // Start\n \n for (int node_code : best_state.route) {\n if (node_code < TARGET_ORDERS) {\n path.push_back(orders[best_state.selected_order_indices[node_code]].pickup);\n } else {\n path.push_back(orders[best_state.selected_order_indices[node_code - TARGET_ORDERS]].delivery);\n }\n }\n path.push_back({CENTER, CENTER}); // End\n\n cout << path.size();\n for (const auto& p : path) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << endl;\n\n return 0;\n}","ahc007":"/**\n * Solution for AtCoder Heuristic Contest 007\n * Author: Algorithm Engineer\n * Strategy: Monte Carlo Simulation with Online MST Decision\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Fast IO\nvoid fast_io() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n}\n\n// Disjoint Set Union (DSU) / Union-Find\nstruct DSU {\n std::vector parent;\n int components;\n\n DSU(int n) : parent(n), components(n) {\n std::iota(parent.begin(), parent.end(), 0);\n }\n\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n components--;\n return true;\n }\n return false;\n }\n\n bool same(int i, int j) {\n return find(i) == find(j);\n }\n \n // Reset to initial state (0..N-1)\n void reset() {\n std::iota(parent.begin(), parent.end(), 0);\n components = parent.size();\n }\n};\n\nstruct Point {\n int x, y;\n};\n\nstruct Edge {\n int id;\n int u, v;\n int d; // Euclidean distance rounded\n};\n\nint N, M;\nstd::vector points;\nstd::vector edges;\nstd::mt19937 rng(12345); // Fixed seed for reproducibility/debugging within context, or random for submission\n\nint get_dist(int i, int j) {\n double dx = points[i].x - points[j].x;\n double dy = points[i].y - points[j].y;\n return std::round(std::sqrt(dx*dx + dy*dy));\n}\n\nint main() {\n fast_io();\n\n // Read inputs\n std::cin >> N >> M;\n points.resize(N);\n for (int i = 0; i < N; ++i) {\n std::cin >> points[i].x >> points[i].y;\n }\n \n edges.resize(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n std::cin >> edges[i].u >> edges[i].v;\n edges[i].d = get_dist(edges[i].u, edges[i].v);\n }\n\n // DSU to keep track of edges we have firmly accepted\n DSU fixed_dsu(N);\n \n // DSU for checking global connectivity (bridges)\n DSU bridge_check_dsu(N);\n\n // DSU for simulation\n DSU sim_dsu(N);\n \n // Keep track of which edges are still available in the future\n // We just iterate indices > current_i\n\n // Tuning parameters\n // With 2.0 seconds and M=2000, we have 1ms per query.\n // A simple DSU op is near constant. Iterating ~2000 edges is fast.\n // We can afford about 300-500 simulations depending on implementation.\n const int NUM_SIMS = 400; \n\n for (int i = 0; i < M; ++i) {\n int l_i;\n std::cin >> l_i;\n \n int u = edges[i].u;\n int v = edges[i].v;\n\n // 1. If already connected by accepted edges, discard immediately.\n if (fixed_dsu.same(u, v)) {\n std::cout << 0 << std::endl;\n continue;\n }\n\n // 2. Check if this edge is a bridge given the remaining available edges.\n // If we don't take this edge, can we EVER connect u and v?\n // Construct graph with fixed edges + all future edges.\n bridge_check_dsu.reset();\n // Copy state from fixed_dsu? No, reset is O(N). Rebuilding is safer/cleaner.\n // Actually, better to maintain a \"base\" structure or just rebuild. \n // Rebuilding 2000 times with 2000 edges is 4*10^6 ops total, very fast.\n \n // Optimization: DSU copy is fast.\n bridge_check_dsu = fixed_dsu; \n \n for (int j = i + 1; j < M; ++j) {\n bridge_check_dsu.unite(edges[j].u, edges[j].v);\n }\n \n if (!bridge_check_dsu.same(u, v)) {\n // Must take it to maintain connectivity\n fixed_dsu.unite(u, v);\n std::cout << 1 << std::endl;\n continue;\n }\n\n // 3. Monte Carlo Simulation\n // We want to estimate P(edge i is in MST | edge i weight = l_i)\n // An edge (u, v) with weight w is in MST iff there is NO path between u and v\n // consisting entirely of edges with weight < w.\n \n int wins = 0;\n \n // We can pre-filter edges that could possibly be lighter than l_i.\n // Future edge j can be lighter than l_i only if min_possible_weight(j) < l_i.\n // i.e., d_j < l_i.\n std::vector candidates;\n candidates.reserve(M - i);\n for (int j = i + 1; j < M; ++j) {\n if (edges[j].d < l_i) {\n candidates.push_back(j);\n }\n }\n \n for (int t = 0; t < NUM_SIMS; ++t) {\n // Reset simulation DSU to current fixed state\n sim_dsu = fixed_dsu;\n \n // We check if u and v become connected using only future edges lighter than l_i.\n bool connected_via_lighter = false;\n \n // Optimization: We don't need to sort all candidates every time.\n // We just iterate candidates, sample their weight w_j.\n // If w_j < l_i, we unite.\n // If sim_dsu connects u, v, then edge i is NOT needed.\n \n // To optimize further: shuffling candidates allows early exit? \n // No, we need to add ALL edges < l_i. Order doesn't matter for connectivity.\n \n for (int idx : candidates) {\n // Sample weight for edge idx\n // Uniform integer in [d, 3d]\n int d = edges[idx].d;\n int w_j = d + (rng() % (2 * d + 1));\n \n if (w_j < l_i) {\n sim_dsu.unite(edges[idx].u, edges[idx].v);\n if (sim_dsu.same(u, v)) {\n connected_via_lighter = true;\n break;\n }\n }\n }\n \n if (!connected_via_lighter) {\n wins++;\n }\n }\n\n // Decision Rule\n // If the probability that this edge is required in the MST is high, take it.\n // A simple threshold is 0.5.\n if (wins * 2 > NUM_SIMS) {\n fixed_dsu.unite(u, v);\n std::cout << 1 << std::endl;\n } else {\n std::cout << 0 << std::endl;\n }\n }\n\n return 0;\n}","ahc008":"/**\n * AHC008 - Territory\n * Strategy: Grid Partitioning and Room Merging\n * \n * 1. Define a target grid layout (e.g., splitting the 30x30 area into smaller rectangular cells).\n * 2. Assign humans to build these walls efficiently.\n * 3. Use a task-based system where humans bid for the closest unbuilt wall segment.\n * 4. Safety First: Only build if no pets are adjacent to the target block square.\n * If a pet is close, wait or move away.\n * 5. Once walls are built, identify cells containing pets.\n * 6. Open walls between empty cells to maximize the connected territory size.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int H = 30;\nconst int W = 30;\nconst int TURNS = 300;\n\n// Directions: 0:Up, 1:Down, 2:Left, 3:Right, 4:Stay\nconst int DX[5] = {-1, 1, 0, 0, 0};\nconst int DY[5] = {0, 0, -1, 1, 0};\nconst char MOVE_CHAR[5] = {'U', 'D', 'L', 'R', '.'};\nconst char BLOCK_CHAR[5] = {'u', 'd', 'l', 'r', '.'};\n\nstruct Point {\n int x, y;\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { return x != other.x ? x < other.x : y < other.y; }\n int dist(const Point& other) const { return abs(x - other.x) + abs(y - other.y); }\n};\n\nstruct Pet {\n int id;\n int x, y;\n int type;\n};\n\nstruct Human {\n int id;\n int x, y;\n int target_task_id = -1;\n};\n\n// Grid state\n// 0: Empty, 1: Blocked\nint grid_state[H + 1][W + 1]; \n\n// To manage tasks\nstruct Task {\n int id;\n int bx, by; // Block coordinate\n bool completed = false;\n // The position a human must stand at to perform the block\n // There are multiple candidates, we pick one dynamically\n};\n\nvector pets;\nvector humans;\nvector tasks;\nint N_PETS, M_HUMANS;\n\n// Utility to check bounds\nbool is_valid(int x, int y) {\n return x >= 1 && x <= H && y >= 1 && y <= W;\n}\n\n// Check if a square can be blocked (Game Rule: No pets in neighbors)\nbool can_block(int bx, int by, const vector& current_pets) {\n if (!is_valid(bx, by)) return false;\n if (grid_state[bx][by] == 1) return false; // Already blocked\n\n // Rule: You cannot choose a square whose adjacent square contains a pet\n // Neighbors of (bx, by)\n for (int d = 0; d < 4; ++d) {\n int nx = bx + DX[d];\n int ny = by + DY[d];\n if (is_valid(nx, ny)) {\n for (const auto& p : current_pets) {\n if (p.x == nx && p.y == ny) return false;\n }\n }\n }\n \n // Also, the square itself cannot contain a pet or human (checked by caller usually, but pets check here)\n for(const auto& p : current_pets) {\n if(p.x == bx && p.y == by) return false;\n }\n \n return true;\n}\n\n// BFS for pathfinding on the grid considering current walls\nint get_dist(Point start, Point end) {\n if (start == end) return 0;\n queue> q;\n q.push({start, 0});\n vector> dist(H + 1, vector(W + 1, -1));\n dist[start.x][start.y] = 0;\n\n while (!q.empty()) {\n auto [curr, d] = q.front();\n q.pop();\n\n if (curr == end) return d;\n\n for (int i = 0; i < 4; ++i) {\n int nx = curr.x + DX[i];\n int ny = curr.y + DY[i];\n if (is_valid(nx, ny) && grid_state[nx][ny] == 0 && dist[nx][ny] == -1) {\n dist[nx][ny] = d + 1;\n q.push({{nx, ny}, d + 1});\n }\n }\n }\n return 1000; // Unreachable\n}\n\n// Function to generate the initial plan: A grid of walls\nvoid generate_tasks() {\n int id_counter = 0;\n \n // We want to create rooms. \n // Vertical lines every ~5-6 cells, Horizontal every ~10 cells?\n // 30x30.\n // Let's make horizontal cuts at row 10 and 20.\n // Let's make vertical cuts at col 6, 12, 18, 24.\n // This creates 3 * 5 = 15 rooms.\n \n // Horizontal walls\n vector h_cuts = {10, 20};\n for (int r : h_cuts) {\n for (int c = 1; c <= W; ++c) {\n // Don't block if it's an intersection that keeps connectivity initially? \n // Actually, we want to block everything to isolate, then open later.\n tasks.push_back({id_counter++, r, c});\n }\n }\n\n // Vertical walls\n vector v_cuts = {6, 12, 18, 24};\n for (int c : v_cuts) {\n for (int r = 1; r <= H; ++r) {\n // If this overlaps with horizontal cut, it's already added, but set check handles duplicates if we used set.\n // Here we just add. Duplicates in tasks might be bad, check grid_state before adding?\n // Simple check:\n bool exists = false;\n for(const auto& t : tasks) if(t.bx == r && t.by == c) exists = true;\n if(!exists) tasks.push_back({id_counter++, r, c});\n }\n }\n \n // Prioritize tasks? \n // Maybe shuffle to reduce congestion or sort by coordinates.\n // Spreading humans out is good.\n}\n\n// Find next move for a human\n// Returns: Action char ('U','D','L','R','u','d','l','r','.')\nchar plan_human_action(int h_idx, const vector& current_pets, const vector& current_humans) {\n Human& h = humans[h_idx];\n \n // 1. Check if current assigned task is still valid/needed\n if (h.target_task_id != -1) {\n if (tasks[h.target_task_id].completed || grid_state[tasks[h.target_task_id].bx][tasks[h.target_task_id].by] == 1) {\n tasks[h.target_task_id].completed = true;\n h.target_task_id = -1;\n }\n }\n\n // 2. Assign new task if needed\n if (h.target_task_id == -1) {\n int best_task = -1;\n int min_dist = 10000;\n\n for (int i = 0; i < tasks.size(); ++i) {\n if (tasks[i].completed) continue;\n if (grid_state[tasks[i].bx][tasks[i].by] == 1) {\n tasks[i].completed = true;\n continue;\n }\n\n // Check if another human is targeting this\n bool taken = false;\n for (int j = 0; j < M_HUMANS; ++j) {\n if (j != h_idx && humans[j].target_task_id == i) {\n taken = true;\n break;\n }\n }\n if (taken) continue;\n\n // Calculate distance\n // To block (bx, by), human needs to be at a neighbor\n int dist_to_task = 10000;\n for(int d=0; d<4; ++d) {\n int sx = tasks[i].bx + DX[d];\n int sy = tasks[i].by + DY[d];\n if(is_valid(sx, sy) && grid_state[sx][sy] == 0) {\n int d_val = get_dist({h.x, h.y}, {sx, sy});\n dist_to_task = min(dist_to_task, d_val);\n }\n }\n \n if (dist_to_task < min_dist) {\n min_dist = dist_to_task;\n best_task = i;\n }\n }\n\n if (best_task != -1) {\n h.target_task_id = best_task;\n }\n }\n\n // 3. Execute Task\n if (h.target_task_id != -1) {\n Task& t = tasks[h.target_task_id];\n \n // If already blocked (race condition), drop task\n if (grid_state[t.bx][t.by] == 1) {\n t.completed = true;\n h.target_task_id = -1;\n return '.';\n }\n\n // Determine desired standing position\n // We want a neighbor of (t.bx, t.by) that is closest to current pos\n Point best_stand = {-1, -1};\n int best_dist = 10000;\n int best_dir = -1; // direction from stand to block\n\n for(int d=0; d<4; ++d) {\n int sx = t.bx - DX[d]; // if block is at bx, and we apply direction d, we must be at bx-DX\n // Wait, logic:\n // Action 'u' means block (x-1, y). So if we are at (x, y), we block x-1.\n // So if target is (bx, by), and we want to use action d (blocking offset DX[d]),\n // we must be at (bx - DX[d], by - DY[d]).\n \n int sx_pos = t.bx - DX[d];\n int sy_pos = t.by - DY[d];\n \n if(is_valid(sx_pos, sy_pos) && grid_state[sx_pos][sy_pos] == 0) {\n // Path finding distance\n int d_val = get_dist({h.x, h.y}, {sx_pos, sy_pos});\n if (d_val < best_dist) {\n best_dist = d_val;\n best_stand = {sx_pos, sy_pos};\n best_dir = d;\n }\n }\n }\n\n if (best_stand.x == -1) {\n // Cannot reach any standing spot (maybe trapped), drop task\n h.target_task_id = -1;\n return '.';\n }\n\n // If we are at the standing spot\n if (h.x == best_stand.x && h.y == best_stand.y) {\n // Try to block\n if (can_block(t.bx, t.by, current_pets)) {\n // Also ensure we are not blocking a square that another human is currently in?\n // The rules say: \"You cannot choose a square that contains pets or humans\".\n bool human_collision = false;\n for(const auto& other_h : current_humans) {\n if(other_h.x == t.bx && other_h.y == t.by) human_collision = true;\n }\n if(!human_collision) {\n return BLOCK_CHAR[best_dir];\n } else {\n return '.'; // Wait for human to move\n }\n } else {\n // Cannot block due to pets. \n // If pets are near, wait. Or if it's impossible for a long time, maybe abandon?\n // For now, just wait.\n return '.';\n }\n } else {\n // Move towards standing spot\n // Simple BFS for next step\n queue> q;\n q.push({best_stand, 0});\n vector> dist_map(H+1, vector(W+1, 1000));\n dist_map[best_stand.x][best_stand.y] = 0;\n \n while(!q.empty()){\n auto [c, d_val] = q.front(); q.pop();\n if(c.x == h.x && c.y == h.y) break;\n \n for(int i=0; i<4; ++i){\n int nx = c.x + DX[i];\n int ny = c.y + DY[i];\n if(is_valid(nx, ny) && grid_state[nx][ny] == 0 && dist_map[nx][ny] > d_val + 1){\n dist_map[nx][ny] = d_val + 1;\n q.push({{nx, ny}, d_val + 1});\n }\n }\n }\n \n int best_move_dir = -1;\n int min_next_dist = 1000;\n for(int i=0; i<4; ++i){\n int nx = h.x + DX[i];\n int ny = h.y + DY[i];\n if(is_valid(nx, ny) && grid_state[nx][ny] == 0){\n // Don't move into a square that will be blocked by someone else? \n // Or containing another human?\n // Collision avoidance is tricky. \n // Simple check: avoid squares with humans currently.\n bool occupied = false;\n for(const auto& oh : current_humans) if(oh.x == nx && oh.y == ny) occupied = true;\n \n // Also avoid squares that WILL be blocked this turn? Hard to know.\n // We ignore advanced prediction for now.\n \n if(!occupied && dist_map[nx][ny] < min_next_dist){\n min_next_dist = dist_map[nx][ny];\n best_move_dir = i;\n }\n }\n }\n \n if(best_move_dir != -1) return MOVE_CHAR[best_move_dir];\n else return '.'; // Stuck\n }\n }\n\n // No tasks available? (Tasks done or unreachable)\n // Move to a central open area or away from walls\n return '.'; \n}\n\n// Phase 2: Removing walls logic\n// If we are in late game and have sealed pets, we can remove walls.\n// Wait, the problem allows ONLY \"Make impassable\". \n// \"Choose a square adjacent ... and make it impassable.\"\n// WE CANNOT REMOVE WALLS.\n// Mistake in thought process corrected: We can only ADD walls.\n// So the strategy must be:\n// 1. Enclose pets in small areas.\n// 2. Leave the rest open.\n// This implies we shouldn't build the FULL grid immediately. \n// We should build a grid that is *capable* of partitioning, but leave \"doors\" open until necessary?\n// Or, build the grid, but selectively NOT build segments if the sub-area is pet-free?\n// NO, pets move. If we leave a door open, they might enter.\n// Better strategy:\n// Build the full grid. Isolate everyone.\n// BUT we can't remove walls.\n// So if we isolate an empty 5x5 room, it's useless?\n// The score is based on Reachable Area.\n// If we build a full grid, the reachable area for a human is just one small room (e.g., 20-30 squares).\n// This is BAD. Max score requires huge area.\n//\n// REVISED STRATEGY:\n// 1. Identify \"Pet Zones\" and \"Human Zones\".\n// 2. Build walls to separate Pet Zones from everything else.\n// 3. Do NOT build walls between Human Zones.\n// \n// How to do this dynamically?\n// The \"Grid\" idea is still good as a scaffold.\n// We define the grid lines.\n// A wall segment (part of a grid line) should be built IF:\n// It separates a region with pets from a region without pets (or helps to do so).\n// OR it separates two regions both with pets (to keep them small).\n// It should NOT be built if it separates two regions BOTH WITHOUT pets.\n//\n// Refined Logic:\n// 1. Virtual Grid: 30x30 divided into cells (e.g. 15 rooms).\n// 2. At each turn (or periodically), count pets in each virtual room.\n// 3. If a room contains pets, we want to seal it. Add tasks to build walls bordering this room.\n// 4. If a room is empty, we try NOT to wall it off from other empty rooms.\n// 5. Humans prioritize building walls that border \"Pet Rooms\".\n\n// Virtual Room definitions\nstruct Room {\n int r1, c1, r2, c2; // inclusive range\n int id;\n vector neighbor_rooms;\n};\nvector rooms;\nint room_grid[H+1][W+1]; // Map x,y to room id\n\nvoid init_rooms() {\n vector rows = {1, 11, 21, 31}; // boundaries\n vector cols = {1, 7, 13, 19, 25, 31};\n \n int id = 0;\n for(size_t i=0; i& current_pets) {\n // Find which rooms are adjacent to this wall square\n // Since (bx, by) will become a wall, it effectively stops being part of a room\n // But logically, it separates neighbors.\n // Check 4 neighbors of the wall block.\n set adj_rooms;\n for(int d=0; d<4; ++d) {\n int nx = bx + DX[d];\n int ny = by + DY[d];\n if(is_valid(nx, ny)) {\n adj_rooms.insert(room_grid[nx][ny]);\n }\n }\n \n // Count pets in these adjacent rooms\n // Actually, the simple heuristic is: \n // If ANY adjacent room has a pet, we should probably build this wall to prevent that pet from leaving.\n // EXCEPTION: If the pet is already in a room, and we are building the wall between that room and another Pet room?\n // Yes, still good to fragment pets.\n // The only case to NOT build is if ALL adjacent rooms are EMPTY.\n \n for(int rid : adj_rooms) {\n for(const auto& p : current_pets) {\n // Check if pet is in room rid\n if(p.x >= rooms[rid].r1 && p.x <= rooms[rid].r2 && \n p.y >= rooms[rid].c1 && p.y <= rooms[rid].c2) {\n return true; // Found a pet in a neighbor room\n }\n }\n }\n return false;\n}\n\nvoid update_tasks_dynamic(const vector& current_pets) {\n // Clear unstarted tasks? No, just add new ones or re-prioritize.\n // We iterate over all potential grid lines.\n \n // Horizontal cuts: rows 10, 20\n vector h_cuts = {10, 20};\n for (int r : h_cuts) {\n for (int c = 1; c <= W; ++c) {\n if (grid_state[r][c] == 0) {\n bool needed = is_useful_wall(r, c, current_pets);\n \n // Check if task already exists\n bool exists = false;\n for(auto& t : tasks) if(t.bx == r && t.by == c && !t.completed) {\n exists = true;\n if(!needed) {\n // Ideally remove it, but vector erase is slow? \n // Just mark it as low priority or skip in assignment?\n // For simplicity, we just leave it. Humans check validity.\n // Actually, if it's not useful, we should mark it 'completed' or invalid to save effort.\n t.completed = true; \n } else {\n t.completed = false; // Reactivate if needed?\n }\n break;\n }\n \n if(!exists && needed) {\n tasks.push_back({(int)tasks.size(), r, c});\n }\n }\n }\n }\n\n // Vertical cuts\n vector v_cuts = {6, 12, 18, 24};\n for (int c : v_cuts) {\n for (int r = 1; r <= H; ++r) {\n if (grid_state[r][c] == 0) {\n bool needed = is_useful_wall(r, c, current_pets);\n bool exists = false;\n for(auto& t : tasks) if(t.bx == r && t.by == c && !t.completed) {\n exists = true;\n if(!needed) t.completed = true;\n else t.completed = false;\n break;\n }\n if(!exists && needed) {\n tasks.push_back({(int)tasks.size(), r, c});\n }\n }\n }\n }\n}\n\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N_PETS;\n pets.resize(N_PETS);\n for (int i = 0; i < N_PETS; ++i) {\n cin >> pets[i].x >> pets[i].y >> pets[i].type;\n pets[i].id = i;\n }\n\n cin >> M_HUMANS;\n humans.resize(M_HUMANS);\n for (int i = 0; i < M_HUMANS; ++i) {\n cin >> humans[i].x >> humans[i].y;\n humans[i].id = i;\n }\n\n // Init\n for(int i=0; i<=H; ++i) for(int j=0; j<=W; ++j) grid_state[i][j] = 0;\n init_rooms();\n\n // Main Loop\n for (int turn = 0; turn < TURNS; ++turn) {\n \n // 1. Update Tasks based on pet positions\n update_tasks_dynamic(pets);\n \n // 2. Plan and Output Human Actions\n string actions = \"\";\n \n // We need to track where humans WILL be to avoid collisions\n vector next_humans = humans; \n vector human_acts(M_HUMANS);\n\n // Simple greedy assignment per human\n // To avoid collision issues, we could process humans one by one and mark occupied 'next' squares.\n // But for now, simple logic.\n \n // Reset tracking of occupied next positions for collision avoidance in plan_human_action?\n // The function `plan_human_action` does a basic check against current positions.\n // Doing it sequentially helps a bit.\n \n for(int i=0; i> move_str;\n for(char c : move_str) {\n if(c == 'U') pets[i].x--;\n else if(c == 'D') pets[i].x++;\n else if(c == 'L') pets[i].y--;\n else if(c == 'R') pets[i].y++;\n }\n }\n\n // 4. Update World State based on own actions (assume success)\n // Note: The problem says \"If you choose a square that is already impassable, nothing happens.\"\n // \"You cannot choose a square ... [rules]\". The judge ignores invalid moves.\n // We should only update grid_state if the move was likely valid.\n // To be precise, we need to replicate the judge's validation logic exactly, \n // but since we pre-checked validity in plan_human_action, we assume success.\n \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#include \n\n// Fast IO\nvoid fast_io() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n}\n\n// Global constants\nconstexpr int H = 20;\nconstexpr int W = 20;\nconstexpr int MAX_STEPS = 200;\nconstexpr double EPS = 1e-9;\n\n// Direction mappings\n// 0: U, 1: D, 2: L, 3: R\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dc_char[] = {'U', 'D', 'L', 'R'};\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n};\n\n// Global inputs\nPoint start_pos, target_pos;\ndouble p_fail;\nint h_walls[H][W - 1]; // h_walls[i][j] = 1 means wall between (i,j) and (i,j+1)\nint v_walls[H - 1][W]; // v_walls[i][j] = 1 means wall between (i,j) and (i+1,j)\n\n// Check if a move is valid (not hitting a wall or boundary)\n// Returns the destination coordinates. If blocked, returns current coordinates.\nPoint get_next_pos(int r, int c, int dir) {\n int nr = r + dr[dir];\n int nc = c + dc[dir];\n\n // Check boundaries\n if (nr < 0 || nr >= H || nc < 0 || nc >= W) return {r, c};\n\n // Check walls\n if (dir == 0) { // Up\n if (v_walls[nr][c]) return {r, c};\n } else if (dir == 1) { // Down\n if (v_walls[r][c]) return {r, c};\n } else if (dir == 2) { // Left\n if (h_walls[r][nc]) return {r, c};\n } else if (dir == 3) { // Right\n if (h_walls[r][c]) return {r, c};\n }\n\n return {nr, nc};\n}\n\n// Precompute shortest path distances (BFS) from every cell to the target.\n// This serves as a heuristic for how \"good\" a position is.\nint dist_to_target[H][W];\n\nvoid bfs_distances() {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dist_to_target[i][j] = 1e9;\n\n std::queue q;\n dist_to_target[target_pos.r][target_pos.c] = 0;\n q.push(target_pos);\n\n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n\n for (int d = 0; d < 4; ++d) {\n // Reverse move logic to find neighbors that can reach curr\n // If we are at 'prev' and move 'd' to get to 'curr'.\n // We check all 4 neighbors of curr.\n int pr = curr.r - dr[d];\n int pc = curr.c - dc[d];\n \n // Bounds check for potential previous cell\n if (pr >= 0 && pr < H && pc >= 0 && pc < W) {\n // Check if a move from (pr, pc) in direction d leads to (curr.r, curr.c)\n Point next_of_prev = get_next_pos(pr, pc, d);\n if (next_of_prev == curr) {\n if (dist_to_target[pr][pc] > dist_to_target[curr.r][curr.c] + 1) {\n dist_to_target[pr][pc] = dist_to_target[curr.r][curr.c] + 1;\n q.push({pr, pc});\n }\n }\n }\n }\n }\n}\n\n// State for Beam Search\nstruct State {\n double probs[H][W]; // Probability distribution of agent's location\n std::string moves;\n double expected_score;\n double prob_reached_goal; // Cumulative probability of having reached the goal\n \n // Heuristic value for beam search sorting\n // We want to maximize expected score AND minimize expected remaining distance\n double heuristic_val; \n\n State() {\n std::memset(probs, 0, sizeof(probs));\n probs[start_pos.r][start_pos.c] = 1.0;\n moves = \"\";\n expected_score = 0.0;\n prob_reached_goal = 0.0;\n heuristic_val = 0.0;\n }\n\n // Copy constructor\n State(const State& other) {\n std::memcpy(probs, other.probs, sizeof(probs));\n moves = other.moves;\n expected_score = other.expected_score;\n prob_reached_goal = other.prob_reached_goal;\n heuristic_val = other.heuristic_val;\n }\n \n // Calculate heuristic: - (Expected Distance to Target)\n void calc_heuristic() {\n double expected_dist = 0.0;\n double total_prob = 0.0;\n for(int r=0; r 1e-6) {\n expected_dist += probs[r][c] * dist_to_target[r][c];\n total_prob += probs[r][c];\n }\n }\n }\n // Normalize? Not strictly necessary if we consider probability mass loss as reaching goal\n // But effectively, probability mass at target has dist 0.\n // We want to penalize distance.\n // Also, higher expected score is better.\n // Heuristic: Higher is better.\n // We add a large weight to expected_score to prioritize it, \n // and subtract expected distance to guide the cloud.\n // The expected score is roughly 400 * prob_reach.\n // The distance is roughly 0-40.\n \n // Simple heuristic: Minimize expected remaining distance\n heuristic_val = -expected_dist;\n }\n\n bool operator<(const State& other) const {\n return heuristic_val < other.heuristic_val;\n }\n};\n\n\n// Advance the probability distribution by one step in direction 'dir'\nvoid advance(State& s, int dir) {\n double next_probs[H][W];\n std::memset(next_probs, 0, sizeof(next_probs));\n \n double newly_reached = 0.0;\n int current_step = (int)s.moves.length() + 1;\n\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (s.probs[r][c] < 1e-9) continue;\n\n double p_curr = s.probs[r][c];\n \n // 1. Fail to move (stay) with prob p_fail\n // Stay at (r, c)\n // If (r,c) is target, we already handled it (probability mass is removed from grid upon reaching)\n // Wait, the problem says: \"When he gets to the office, he immediately terminate the move.\"\n // This means probability mass at target should be absorbed into score and removed from grid for future steps.\n // However, usually DP keeps it or handles it specifically. \n // Let's assume `probs` only stores probability of being active (not reached yet).\n \n // Stay logic:\n if (r == target_pos.r && c == target_pos.c) {\n // Should be 0 ideally if we clear it, but just in case\n continue; \n }\n\n // Stay:\n double p_stay = p_curr * p_fail;\n next_probs[r][c] += p_stay;\n\n // Move:\n double p_move = p_curr * (1.0 - p_fail);\n Point next_pt = get_next_pos(r, c, dir);\n \n if (next_pt.r == target_pos.r && next_pt.c == target_pos.c) {\n newly_reached += p_move;\n } else {\n next_probs[next_pt.r][next_pt.c] += p_move;\n }\n }\n }\n\n // Update state\n std::memcpy(s.probs, next_probs, sizeof(next_probs));\n s.moves += dc_char[dir];\n \n // Update score\n // Score logic: 401 - t\n // Add expected gain from reaching at this step\n if (newly_reached > 0) {\n s.expected_score += newly_reached * (401 - current_step);\n s.prob_reached_goal += newly_reached;\n }\n}\n\n\nint main() {\n fast_io();\n\n // 1. Read Input\n if (!(std::cin >> start_pos.r >> start_pos.c >> target_pos.r >> target_pos.c >> p_fail)) return 0;\n\n for (int i = 0; i < H; ++i) {\n std::string row;\n std::cin >> row;\n for (int j = 0; j < W - 1; ++j) {\n h_walls[i][j] = (row[j] == '1');\n }\n }\n for (int i = 0; i < H - 1; ++i) {\n std::string row;\n std::cin >> row;\n for (int j = 0; j < W; ++j) {\n v_walls[i][j] = (row[j] == '1');\n }\n }\n\n // 2. Precompute BFS distances (target to all)\n bfs_distances();\n\n // 3. Beam Search\n // Parameters\n int beam_width = 15; \n // For deeper steps, we can reduce width if needed, but 15 is small enough for 200 steps.\n // The state size is 20*20 doubles = 3.2KB.\n // 200 steps * 15 width * 4 branches = 12000 operations of matrix update.\n // Matrix update is 400 ops. Total ~ 4.8e6 ops. Very fast.\n \n std::vector beam;\n State initial_state;\n initial_state.calc_heuristic();\n beam.push_back(initial_state);\n\n for (int t = 0; t < MAX_STEPS; ++t) {\n std::vector next_candidates;\n // Optimization: Reserve memory\n next_candidates.reserve(beam.size() * 4);\n\n for (const auto& s : beam) {\n // If almost all probability mass reached target, we can stop extending this branch?\n // Or just continue to gather remaining small probability.\n if (s.prob_reached_goal > 0.9999) {\n next_candidates.push_back(s); \n continue; \n }\n\n // Try all 4 directions\n for (int d = 0; d < 4; ++d) {\n State next_s = s;\n advance(next_s, d);\n next_s.calc_heuristic();\n next_candidates.push_back(next_s);\n }\n }\n\n // Sort and select top K\n // We want top elements, so sort descending\n // However, heuristic might need tuning. \n // If we only use -dist, it might not account for accumulated score well enough.\n // Let's define sorting logic inside the loop carefully.\n // We mix expected score and potential.\n auto comparator = [](const State& a, const State& b) {\n // Primary: Expected Score + Potential\n // Potential is roughly proportional to (1 - prob_reached) * (some factor related to dist)\n // Actually, simply heuristic_val defined in struct is often enough if defined well.\n \n // Let's refine heuristic value here.\n // We prefer states that have ALREADY scored high, plus have potential to score more.\n // Potential max remaining score: (1 - p_reached) * (401 - t - avg_dist).\n // heuristic_val in struct is -E[dist].\n // So (1 - p_reached) is implicit in the magnitude of probabilities in the grid.\n // Sum of probs in grid = 1 - p_reached.\n // So heuristic_val is roughly -(1 - p_reached) * avg_dist_of_remainder.\n \n // Score = s.expected_score + weight * heuristic_val\n // heuristic_val is negative distance.\n // We need to balance \"points already secured\" vs \"closeness of remainder\".\n // Since time is limited, closeness is very important.\n \n // Let's prioritize simply based on s.expected_score + s.heuristic_val * decay?\n // No, just treating expected_score as base is good.\n // But early on, expected_score is 0. \n // So heuristic_val dominates early game (which is good, it guides to target).\n // Late game, expected_score dominates.\n // One catch: If we just reached the goal with 0.1 prob, score jumps.\n // If we moved closer with 0.9 prob, score is 0 but heuristic is high.\n // We need to normalize.\n \n // Let's try: current_score + estimated_future_score\n // estimated_future_score approx (Sum of p_grid) * (Max_Remaining_Turns - Avg_Dist)\n // This might overestimate but works for ranking.\n \n double score_a = a.expected_score + a.heuristic_val * 0.5; // Heuristic is negative dist\n double score_b = b.expected_score + b.heuristic_val * 0.5; \n // Note: heuristic_val = - sum(p * dist). \n // This sum scales with remaining probability mass.\n // So it naturally fades out as mass reaches goal.\n \n return score_a > score_b;\n };\n \n // Optimization: If too many candidates, use partial_sort or nth_element\n if (next_candidates.size() > beam_width) {\n std::nth_element(next_candidates.begin(), next_candidates.begin() + beam_width, next_candidates.end(), comparator);\n next_candidates.resize(beam_width);\n }\n \n beam = std::move(next_candidates);\n }\n\n // 4. Select best result from final beam\n // The best result is simply the one with highest expected_score\n // (We don't care about potential anymore at the end)\n double best_score = -1.0;\n std::string best_moves = \"\";\n\n for (const auto& s : beam) {\n if (s.expected_score > best_score) {\n best_score = s.expected_score;\n best_moves = s.moves;\n }\n }\n \n std::cout << best_moves << std::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\n// -----------------------------------------------------------------------------\n// Constants and Globals\n// -----------------------------------------------------------------------------\n\n// Grid size\nconst int N = 30;\n\n// Directions: 0:Left, 1:Up, 2:Right, 3:Down\nconst int DL[] = {0, -1, 0, 1}; // di\nconst int DC[] = {-1, 0, 1, 0}; // dj\nconst int OPP[] = {2, 3, 0, 1}; // Opposite directions (entry from neighbor)\n\n// Tables to store tile connectivity\n// BASE_TO[tile_type][entry_local_dir] = exit_local_dir\n// -1 indicates no connection.\nint BASE_TO[8][4];\n\n// Input Grid (Fixed tile types)\nint T[N][N];\n\n// State: Rotations (Variable)\nint R[N][N];\n\n// Visited array for path tracing to avoid allocations\n// Dimensions: [row][col][entry_dir]\n// 30 * 30 * 4 = 3600 bytes\nunsigned char visited[N][N][4];\n\n// -----------------------------------------------------------------------------\n// Initialization\n// -----------------------------------------------------------------------------\n\nvoid init_tables() {\n // Initialize with -1 (broken)\n for(int i=0; i<8; ++i) \n for(int j=0; j<4; ++j) \n BASE_TO[i][j] = -1;\n \n // Type 0: Left-Up\n BASE_TO[0][0] = 1; BASE_TO[0][1] = 0;\n // Type 1: Up-Right\n BASE_TO[1][1] = 2; BASE_TO[1][2] = 1;\n // Type 2: Right-Down\n BASE_TO[2][2] = 3; BASE_TO[2][3] = 2;\n // Type 3: Down-Left\n BASE_TO[3][3] = 0; BASE_TO[3][0] = 3;\n \n // Type 4: Left-Up & Right-Down\n BASE_TO[4][0] = 1; BASE_TO[4][1] = 0; \n BASE_TO[4][2] = 3; BASE_TO[4][3] = 2;\n \n // Type 5: Left-Down & Up-Right\n BASE_TO[5][0] = 3; BASE_TO[5][3] = 0; \n BASE_TO[5][1] = 2; BASE_TO[5][2] = 1;\n \n // Type 6: Left-Right\n BASE_TO[6][0] = 2; BASE_TO[6][2] = 0;\n \n // Type 7: Up-Down\n BASE_TO[7][1] = 3; BASE_TO[7][3] = 1;\n}\n\n// -----------------------------------------------------------------------------\n// Helpers\n// -----------------------------------------------------------------------------\n\n// Get the exit direction from tile (r,c) given we enter from `enter_dir` (Global 0-3).\n// Takes current rotation R[r][c] into account.\n// Returns -1 if the track doesn't connect.\ninline int get_exit(int r, int c, int enter_dir) {\n int type = T[r][c];\n int rot = R[r][c];\n \n // Convert global entry direction to local tile coordinates\n // A CCW rotation of grid means 'Up' in global maps to 'Right' in local if rot=1?\n // Let's verify: \n // Rot 0: Global Up(1) -> Local Up(1).\n // Rot 1 (90 CCW): Tile rotated left. Top of tile is now facing Left(0).\n // So Global Left(0) enters Local Up(1).\n // Formula: local = (global - rot + 4) % 4.\n int local_in = (enter_dir - rot + 4) & 3; \n \n int local_out = BASE_TO[type][local_in];\n if (local_out == -1) return -1;\n \n // Convert local exit direction back to global\n // Formula: global = (local + rot) % 4.\n return (local_out + rot) & 3;\n}\n\nstruct EvalResult {\n long long weighted_score; // For optimization\n long long real_score; // L1 * L2\n};\n\n// -----------------------------------------------------------------------------\n// Evaluation Function\n// -----------------------------------------------------------------------------\n\n// scratchpad for loops to avoid realloc\nvector loops; \n\nEvalResult evaluate() {\n loops.clear();\n memset(visited, 0, sizeof(visited));\n int total_links = 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 (visited[i][j][d]) continue;\n\n // Check if there is a path starting here\n // (Must enter from d to go somewhere)\n int exit_d = get_exit(i, j, d);\n if (exit_d == -1) continue;\n\n // Start tracing\n int curr_r = i, curr_c = j, curr_in = d;\n \n // To check for cycles\n int start_r = i, start_c = j, start_in = d;\n \n int len = 0;\n bool closed = false;\n \n while (true) {\n // Mark this direction on current tile as visited\n visited[curr_r][curr_c][curr_in] = 1;\n \n int out = get_exit(curr_r, curr_c, curr_in);\n // Also mark the reverse direction (leaving is entering from opposite)\n // This prevents traversing the same segment backwards\n visited[curr_r][curr_c][out] = 1;\n \n // Move to neighbor\n int next_r = curr_r + DL[out];\n int next_c = curr_c + DC[out];\n int next_in = OPP[out]; // Entering neighbor\n \n // Check bounds\n if (next_r < 0 || next_r >= N || next_c < 0 || next_c >= N) break;\n \n // Check if neighbor connects back\n if (get_exit(next_r, next_c, next_in) == -1) break;\n \n // Valid connection\n total_links++;\n len++;\n \n curr_r = next_r;\n curr_c = next_c;\n curr_in = next_in;\n \n // Check cycle closure\n if (curr_r == start_r && curr_c == start_c && curr_in == start_in) {\n closed = true;\n break;\n }\n \n // If we hit a visited path that isn't start, merge occurred (should be caught by visited check at start)\n if (visited[curr_r][curr_c][curr_in]) break;\n }\n \n if (closed) loops.push_back(len);\n }\n }\n }\n \n long long L1 = 0, L2 = 0;\n long long sum_L = 0;\n if (!loops.empty()) {\n // Partial sort or full sort\n if (loops.size() > 1) {\n partial_sort(loops.begin(), loops.begin() + 2, loops.end(), greater());\n L1 = loops[0];\n L2 = loops[1];\n } else {\n L1 = loops[0];\n }\n for (int l : loops) sum_L += l;\n }\n \n // Scoring Heuristic:\n // Priority 1: Maximize L1 * L2 (The actual goal)\n // Priority 2: Maximize Sum of Loop Lengths (Encourage forming loops)\n // Priority 3: Maximize Total Links (Encourage forming long paths)\n \n // Weights\n long long val = (L1 * L2) * 10000 + sum_L * 100 + total_links;\n return {val, L1 * L2};\n}\n\n// -----------------------------------------------------------------------------\n// Main (Simulated Annealing)\n// -----------------------------------------------------------------------------\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n init_tables();\n \n // Reading input\n // Input format is a grid of integers, potentially packed or space separated.\n // Safer to read char by char skipping whitespace.\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c; cin >> c;\n T[i][j] = c - '0';\n // Initialize rotation randomly? Or all 0.\n // Random is better for SA start.\n R[i][j] = 0; \n }\n }\n\n // Random Engine\n mt19937 rng(1337);\n uniform_int_distribution dist_coord(0, N - 1);\n uniform_int_distribution dist_rot(0, 3);\n \n // Initialize random rotations\n for(int i=0; i(now - start_time).count();\n if (elapsed > time_limit) break;\n }\n iterations++;\n \n // Pick random tile and random new rotation\n int r = dist_coord(rng);\n int c = dist_coord(rng);\n int old_rot = R[r][c];\n int new_rot = (old_rot + 1 + (rng() % 3)) % 4; // Ensure change\n \n // Update\n R[r][c] = new_rot;\n \n // Evaluate\n EvalResult next = evaluate();\n long long next_score = next.weighted_score;\n \n // Delta\n long long delta = next_score - current_score;\n \n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n // Calculate temperature\n // Simple linear decay schedule approximation based on iterations\n // Assuming around 200k - 300k iterations\n // Just use elapsed time for schedule\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n double temp = start_temp + (end_temp - start_temp) * (elapsed / time_limit);\n \n if (temp > 0.0) {\n double prob = exp(delta / temp);\n if (generate_canonical(rng) < prob) {\n accept = true;\n }\n }\n }\n \n if (accept) {\n current_score = next_score;\n // Update best\n if (next.real_score > best_real_score) {\n best_real_score = next.real_score;\n memcpy(best_R, R, sizeof(R));\n }\n // Also keep best structural configuration even if real score (L1*L2) is 0\n // to prevent getting stuck in complete chaos\n else if (next.real_score == best_real_score && next_score > best_weighted_score) {\n best_weighted_score = next_score;\n memcpy(best_R, R, sizeof(R));\n }\n } else {\n // Revert\n R[r][c] = old_rot;\n }\n }\n \n // Use the best found configuration\n // (Usually the last accepted in SA is not the global best, so we must revert)\n // However, we want the one with max real score.\n // If real score is 0, we fallback to the one with max weighted score.\n if (best_real_score > 0) {\n // We stored it in best_R\n } else {\n // Fallback\n }\n // Actually just use best_R\n \n // Output\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << best_R[i][j];\n }\n }\n cout << endl;\n\n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nint N, T_MAX;\nint start_board[10][10];\nint target_board[10][10];\nint tile_counts[16];\nint tile_counts_backup[16];\nmt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());\n\nconst int DR[] = {0, -1, 0, 1}; // L, U, R, D\nconst int DC[] = {-1, 0, 1, 0};\nconst char DCHAR[] = {'L', 'U', 'R', 'D'};\nconst int OPP[] = {2, 3, 0, 1};\n\nstruct Point { \n int r, c; \n bool operator==(const Point& p) const { return r==p.r && c==p.c; } \n bool operator!=(const Point& p) const { return !(*this==p); }\n bool operator<(const Point& p) const { if(r!=p.r) return r 0) && (cur_target[r-1][c] & 8);\n bool need_left = (c > 0) && (cur_target[r][c-1] & 4);\n\n vector candidates;\n candidates.reserve(16);\n for(int t=0; t<16; ++t) {\n if (cur_counts[t] > 0 && t != 0) candidates.push_back(t);\n }\n shuffle(candidates.begin(), candidates.end(), rng);\n\n UndoDSU saved_dsu = dsu_state;\n\n for (int t : candidates) {\n bool has_up = (t & 2);\n bool has_left = (t & 1);\n bool has_right = (t & 4);\n bool has_down = (t & 8);\n\n if (need_up != has_up) continue;\n if (need_left != has_left) continue;\n\n if (r == 0 && has_up) continue;\n if (c == 0 && has_left) continue;\n if (r == N - 1 && has_down) continue;\n if (c == N - 1 && has_right) continue;\n\n bool cycle = false;\n dsu_state = saved_dsu; \n \n if (has_up) {\n if (!dsu_state.unite(idx, idx - N)) cycle = true;\n }\n if (!cycle && has_left) {\n if (!dsu_state.unite(idx, idx - 1)) cycle = true;\n }\n\n if (cycle) continue;\n\n cur_target[r][c] = t;\n cur_counts[t]--;\n\n if (generate_target(idx + 1)) return true;\n\n cur_counts[t]++;\n }\n \n dsu_state = saved_dsu;\n return false;\n}\n\n// --- Solver ---\nstring solution_moves = \"\";\nint board_ids[10][10]; // Tracks ID of tile at (r,c)\nint board_types[10][10]; // Tracks type\nPoint empty_pos;\n\nvoid apply_move_internal(char m) {\n solution_moves += m;\n int d = -1;\n if (m=='L') d=0; else if(m=='U') d=1; else if(m=='R') d=2; else if(m=='D') d=3;\n \n int nr = empty_pos.r + DR[d];\n int nc = empty_pos.c + DC[d];\n swap(board_ids[empty_pos.r][empty_pos.c], board_ids[nr][nc]);\n swap(board_types[empty_pos.r][empty_pos.c], board_types[nr][nc]);\n empty_pos = {nr, nc};\n}\n\nPoint find_id(int id) {\n for(int r=0; r> fixed(N, vector(N, false));\n \n // Assignment logic\n struct Assign { int r, c; };\n vector assignment[16];\n for(int r=0; r target_to_source;\n vector used_source(N*N, false);\n \n // Initial Greedy Assignment\n for(int t=0; t<16; ++t) {\n vector sources;\n for(int r=0; r target_ids(N*N);\n int start_empty_id = -1;\n for(int r=0; r target_ids[j]) inversions++;\n }\n }\n \n // Empty dist\n // Current empty is at (r,c) for id start_empty_id\n // Target empty is at (N-1, N-1)\n int sr=-1, sc=-1;\n for(int r=0; r= 2) {\n Point p1 = {assignment[t][0].r, assignment[t][0].c};\n Point p2 = {assignment[t][1].r, assignment[t][1].c};\n Point s1 = target_to_source[p1];\n Point s2 = target_to_source[p2];\n target_to_source[p1] = s2;\n target_to_source[p2] = s1;\n swapped = true;\n break;\n }\n }\n if (!swapped) {\n // Should not happen for N >= 6\n }\n }\n\n // Helper to bring tile\n auto bring_id = [&](int id, int tr, int tc, vector>& fixed_ref) {\n while(true) {\n Point p = find_id(id);\n if (p.r == tr && p.c == tc) break;\n \n // BFS for tile\n queue q; q.push(p);\n vector> pdir(N, vector(N, -1));\n vector> vis(N, vector(N, false));\n vis[p.r][p.c] = true;\n bool found = false;\n while(!q.empty()){\n Point curr = q.front(); q.pop();\n if(curr.r == tr && curr.c == tc) { found=true; break; }\n for(int d=0; d<4; ++d){\n int nr = curr.r + DR[d], nc = curr.c + DC[d];\n if(nr>=0 && nr=0 && nc qe; qe.push(empty_pos);\n vector> edir(N, vector(N, -1));\n vector> evis(N, vector(N, false));\n evis[empty_pos.r][empty_pos.c] = true;\n bool efound = false;\n while(!qe.empty()){\n Point curr = qe.front(); qe.pop();\n if(curr.r == target_empty_r && curr.c == target_empty_c) { efound = true; break; }\n for(int d=0; d<4; ++d){\n int nr = curr.r + DR[d], nc = curr.c + DC[d];\n if(nr>=0 && nr=0 && nc>& fixed_ref) {\n while(empty_pos.r != tr || empty_pos.c != tc) {\n queue qe; qe.push(empty_pos);\n vector> edir(N, vector(N, -1));\n vector> evis(N, vector(N, false));\n evis[empty_pos.r][empty_pos.c] = true;\n bool efound = false;\n while(!qe.empty()){\n Point curr = qe.front(); qe.pop();\n if(curr.r == tr && curr.c == tc) { efound=true; break; }\n for(int d=0; d<4; ++d){\n int nr = curr.r + DR[d], nc = curr.c + DC[d];\n if(nr>=0 && nr=0 && nc= N-2 && nr < N && nc >= N-2 && nc < N) {\n apply_move_internal(DCHAR[d]);\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N >> T_MAX;\n for(int i=0; i> row;\n for(int j=0; j= '0' && row[j] <= '9') val = row[j] - '0';\n else val = row[j] - 'a' + 10;\n start_board[i][j] = val;\n board_types[i][j] = val;\n board_ids[i][j] = i*N+j;\n if (val == 0) empty_pos = {i, j};\n tile_counts[val]++;\n }\n }\n \n // Must use specific tile count for target gen. 0 is special.\n tile_counts[0] = 1; \n for(int i=0; i<16; ++i) tile_counts_backup[i] = tile_counts[i];\n\n // Generate valid target\n // Retry loop\n while(true) {\n for(int i=0; i<16; ++i) cur_counts[i] = tile_counts_backup[i];\n dsu_state = UndoDSU();\n // Force empty to be at (N-1, N-1) for target\n cur_counts[0]--; // Reserve\n \n if (generate_target(0)) {\n cur_target[N-1][N-1] = 0;\n break;\n }\n }\n\n solve_sliding();\n \n if (solution_moves.length() > T_MAX) {\n cout << solution_moves.substr(0, T_MAX) << endl;\n } else {\n cout << solution_moves << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_COORD = 10000;\nconst int MIN_COORD = -10000;\nconst int BIG_COORD = 1000000000;\nconst int NUM_CUTS_X = 50;\nconst int NUM_CUTS_Y = 50;\n\nstruct Point {\n int x, y;\n};\n\n// Global variables\nint N, K;\nint a[11];\nvector berries;\nint counts_grid[105][105];\n\n// Timer\nclass Timer {\n chrono::high_resolution_clock::time_point start;\npublic:\n Timer() { reset(); }\n void reset() { start = chrono::high_resolution_clock::now(); }\n double elapsed() {\n auto end = chrono::high_resolution_clock::now();\n return chrono::duration(end - start).count();\n }\n} timer;\n\n// Random Number Generator\nmt19937 rng(12345);\n\nint rand_int(int l, int r) {\n return uniform_int_distribution(l, r)(rng);\n}\n\ndouble rand_double() {\n return uniform_real_distribution(0.0, 1.0)(rng);\n}\n\n// Evaluation Function\n// Returns the raw score: sum of min(a_d, b_d)\nint evaluate(const vector& cx, const vector& cy) {\n int nx = cx.size();\n int ny = cy.size();\n \n // Reset grid counts\n // The grid size is at most (NUM_CUTS_X + 1) x (NUM_CUTS_Y + 1)\n for(int i = 0; i <= nx; ++i) {\n memset(counts_grid[i], 0, sizeof(int) * (ny + 1));\n }\n\n // Count berries in each cell\n for(const auto& p : berries) {\n // Identify column\n int ix = upper_bound(cx.begin(), cx.end(), p.x) - cx.begin();\n // Identify row\n int iy = upper_bound(cy.begin(), cy.end(), p.y) - cy.begin();\n counts_grid[ix][iy]++;\n }\n\n // Compute b_d (histogram of piece sizes)\n int b[11] = {0};\n for(int i = 0; i <= nx; ++i) {\n for(int j = 0; j <= ny; ++j) {\n int c = counts_grid[i][j];\n if(c >= 1 && c <= 10) {\n b[c]++;\n }\n }\n }\n\n // Compute Objective\n int score = 0;\n for(int d = 1; d <= 10; ++d) {\n score += min(a[d], b[d]);\n }\n return score;\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input Reading\n cin >> N >> K;\n for(int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n berries.resize(N);\n vector x_coords, y_coords;\n for(int i = 0; i < N; ++i) {\n cin >> berries[i].x >> berries[i].y;\n x_coords.push_back(berries[i].x);\n y_coords.push_back(berries[i].y);\n }\n\n // Sort coordinates for quantile initialization\n sort(x_coords.begin(), x_coords.end());\n sort(y_coords.begin(), y_coords.end());\n\n // Initialize cuts\n // Strategy: Use K/2 lines for X and K/2 lines for Y.\n // Initialize them based on quantiles to spread berries somewhat evenly.\n vector cx(NUM_CUTS_X), cy(NUM_CUTS_Y);\n \n for(int i = 0; i < NUM_CUTS_X; ++i) {\n int idx = (i + 1) * (int)x_coords.size() / (NUM_CUTS_X + 1);\n cx[i] = x_coords[min((int)x_coords.size() - 1, idx)];\n // Add slight noise to break symmetries\n cx[i] = max(MIN_COORD, min(MAX_COORD, cx[i] + rand_int(-50, 50)));\n }\n \n for(int i = 0; i < NUM_CUTS_Y; ++i) {\n int idx = (i + 1) * (int)y_coords.size() / (NUM_CUTS_Y + 1);\n cy[i] = y_coords[min((int)y_coords.size() - 1, idx)];\n cy[i] = max(MIN_COORD, min(MAX_COORD, cy[i] + rand_int(-50, 50)));\n }\n\n sort(cx.begin(), cx.end());\n sort(cy.begin(), cy.end());\n\n // Optimization Loop\n int current_score = evaluate(cx, cy);\n int best_score = current_score;\n vector best_cx = cx;\n vector best_cy = cy;\n\n // Simulated Annealing Parameters\n double time_limit = 2.85;\n double start_temp = 3.0;\n double end_temp = 0.0;\n\n int iter_count = 0;\n\n while(true) {\n iter_count++;\n // Check time every 256 iterations to reduce overhead\n if ((iter_count & 255) == 0) {\n if (timer.elapsed() > time_limit) break;\n }\n\n double progress = timer.elapsed() / time_limit;\n double temp = start_temp + (end_temp - start_temp) * progress;\n\n // Select a move\n // 1. Choose axis (X or Y)\n bool axis_x = (rand_int(0, 1) == 0);\n vector& current_vec = axis_x ? cx : cy;\n\n // 2. Choose a line index\n int idx = rand_int(0, (int)current_vec.size() - 1);\n int old_val = current_vec[idx];\n int new_val = old_val;\n\n // 3. Determine modification type\n // Type 0: Small shift (fine tuning)\n // Type 1: Snap to berry (structural change)\n // Type 2: Large jump (exploration)\n // Type 3: Disable line (move out of range)\n \n int r = rand_int(0, 100);\n if (r < 40) { \n // Shift\n new_val += rand_int(-150, 150);\n } else if (r < 80) {\n // Snap to berry coordinate\n int b_idx = rand_int(0, N - 1);\n int berry_coord = axis_x ? berries[b_idx].x : berries[b_idx].y;\n // Snap to berry_coord or berry_coord - 1\n // This places the cut exactly on one side of the berry line\n new_val = berry_coord + rand_int(-1, 0);\n } else if (r < 95) {\n // Random jump\n new_val = rand_int(MIN_COORD, MAX_COORD);\n } else {\n // Disable (move to infinity)\n // 11000 is effectively outside the cake range (10000)\n new_val = MAX_COORD + 1000 + rand_int(0, 100);\n }\n\n // Clamp to safe range (including disabled range)\n new_val = max(MIN_COORD - 2000, min(MAX_COORD + 2000, new_val));\n\n // Apply move\n // Since vector is sorted, we need to keep it sorted.\n // Instead of full sort, we can update efficiently, but size=50 is small enough for sort.\n current_vec[idx] = new_val;\n sort(current_vec.begin(), current_vec.end());\n\n int new_score = evaluate(cx, cy);\n\n // Accept or Reject\n if (new_score >= current_score) {\n current_score = new_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_cx = cx;\n best_cy = cy;\n }\n } else {\n // SA Probability\n double delta = new_score - current_score; // negative\n double prob = exp(delta / (temp + 1e-9));\n \n if (rand_double() < prob) {\n current_score = new_score;\n } else {\n // Revert\n // Find one instance of new_val and change it back to old_val\n auto it = lower_bound(current_vec.begin(), current_vec.end(), new_val);\n *it = old_val;\n sort(current_vec.begin(), current_vec.end());\n }\n }\n }\n\n // Output Solution\n // Format: k lines. Each line: px py qx qy\n // Vertical cut at x=C: (C, -10^9) -> (C+1, 10^9)\n // Horizontal cut at y=D: (-10^9, D) -> (10^9, D+1)\n\n cout << best_cx.size() + best_cy.size() << \"\\n\";\n for (int v : best_cx) {\n cout << v << \" \" << -BIG_COORD << \" \" << v + 1 << \" \" << BIG_COORD << \"\\n\";\n }\n for (int v : best_cy) {\n cout << -BIG_COORD << \" \" << v << \" \" << BIG_COORD << \" \" << v + 1 << \"\\n\";\n }\n\n return 0;\n}","ahc014":"/**\n * AHC014 - RectJoin Solver\n * \n * Strategy:\n * 1. This is a heuristic search problem. We want to connect dots to form rectangles \n * (axis-aligned or 45-degree tilted) to place new dots.\n * 2. The objective is to maximize the sum of weights of all dots, where weight increases \n * with distance from the center.\n * 3. Since we want dots far from the center, we should try to \"grow\" the set of dots \n * outwards from the initial central cluster.\n * 4. We can view this as a search problem. From the current state, what are the valid moves?\n * A move is defined by choosing an empty spot p1 and 3 existing dots p2, p3, p4 forming a valid rectangle.\n * Equivalently, we can look for pairs of existing dots that can form a side or a diagonal of a rectangle\n * and check if the other required vertices exist.\n * 5. Since the number of steps can be large and the branching factor is high, a pure BFS/DFS is impossible.\n * We will use a randomized greedy approach with lookahead (Beam Search or Chokudai Search).\n * Given the time limit (5.0s) and the nature of the problem (\"constructive\"), a beam search is suitable.\n * 6. Key constraints:\n * - Rectangle lines must not have other dots on them.\n * - Rectangle lines must not overlap with existing rectangle lines.\n * \n * Algorithm Details:\n * - State representation:\n * - Bitsets or 2D arrays to mark existing dots.\n * - Mark used edges (horizontal, vertical, diagonal+45, diagonal-45). Since coordinates are small (<=61),\n * we can use efficient data structures.\n * - Move generation:\n * - Iterate through all pairs of existing points.\n * - Check if they can form a valid rectangle with a potential new point.\n * - There are different configurations:\n * a) The new point completes a rectangle with 3 existing points.\n * This implies we look for \"L\" shapes of existing dots.\n * - Evaluation Function:\n * - Primary: Sum of weights of current dots.\n * - Secondary heuristic: Potential for future moves. A dot is valuable if it is far from center \n * but also if it helps creating more dots further out.\n * \n * Implementation specifics:\n * - To manage the complexity, we focus on a specific direction or try to fill the board layer by layer? \n * Actually, just greedy with beam search is standard for this type.\n * - Because finding *all* valid moves is expensive ($O(|Dots|^3)$ or $O(N^2)$ scan), we need optimization.\n * Instead of iterating all triples, iterate all empty points $p_1$? Too many.\n * Iterate all existing pairs $(p_2, p_4)$ that could be diagonals?\n * - If $p_2, p_4$ are diagonal vertices, then $p_1, p_3$ are the other two.\n * - We need $p_3$ to exist and $p_1$ to be empty.\n * - Center of rectangle is midpoint of $p_2, p_4$.\n * - This covers both axis-aligned and 45-degree rectangles.\n * - Check validity (no intermediate dots, no overlapping edges).\n * \n * - Directions:\n * Let's use 8 directions. For a point p, we can look for neighbors in 8 directions to form lines.\n * Actually, the constraint is strictly about the geometry.\n * \n * Types of rectangles:\n * 1. Axis-parallel: Vertices $(x, y), (x+w, y), (x+w, y+h), (x, y+h)$.\n * Diagonals intersect at $((2x+w)/2, (2y+h)/2)$.\n * 2. 45-degree: Vertices are $(x, y), (x+u, y+u), (x, y+2u), (x-u, y+u)$? No, generic.\n * Square vectors: $v, v_{\\perp}$.\n * Rectangles: $v_1 \\perp v_2$.\n * In grid, 45-degree means sides are along diagonals $(1,1)$ and $(1,-1)$.\n * \n * Let's simplify:\n * We search for a valid move by picking an existing dot $p_2$, a direction $d$, and a distance $l$.\n * This finds a potential $p_3$. Then turn 90 degrees, find $p_4$. Then $p_1$ is determined.\n * This is much faster.\n * Directions: \n * 0: (1, 0) -- Horizontal\n * 1: (0, 1) -- Vertical\n * 2: (1, 1) -- Diagonal Main\n * 3: (1, -1) -- Diagonal Anti\n * \n * For a rectangle, we need 3 existing points $p_2, p_3, p_4$ and 1 new $p_1$.\n * Structure: $p_2 \\to p_3$ (edge 1), $p_3 \\to p_4$ (edge 2), $p_4 \\to p_1$ (edge 3), $p_1 \\to p_2$ (edge 4).\n * $p_1$ is the new point.\n * We can iterate over $p_2$ (existing), direction $d1$, len $l1$ to find existing $p_3$.\n * Then from $p_3$, direction $d2$ ($d1 \\perp d2$), len $l2$ to find existing $p_4$.\n * Then calculate $p_1$. Check if $p_1$ is inside grid and empty.\n * Then check line constraints.\n * \n * Beam Search Flow:\n * - Keep top K states.\n * - For each state, generate many valid moves.\n * - Score moves.\n * - Select top K successors.\n * \n * Because M is small initially (~N^2/12) and we want to fill up to N^2, the game is long.\n * Beam search might be too slow if depth is huge.\n * However, the number of dots increases by 1 each step.\n * We likely won't fill the whole board.\n * Greedy with random restarts or simplified Monte Carlo might be robust.\n * Given 5 seconds, a decent width Beam Search or Chokudai Search is best.\n * \n * Optimization: Bitsets for \"has_dot\" grid.\n * Line checks: \n * - \"No dots on perimeter\": check points between vertices.\n * - \"No overlapping edges\": Keep a set of used segments?\n * Horizontal segments can be indexed by $(y, x_{start}, x_{end})$.\n * Or simply a boolean array for grid edges?\n * Grid edges: \n * Horizontal: (x, y) -- (x+1, y)\n * Vertical: (x, y) -- (x, y+1)\n * Diag1: (x, y) -- (x+1, y+1)\n * Diag2: (x+1, y) -- (x, y+1)\n * We can use arrays `H[64][64], V[64][64], D1[64][64], D2[64][64]` to store boolean \"used\".\n * Wait, \"share a common segment of positive length\".\n * This means we cannot reuse an edge segment.\n * Yes, simply marking unit intervals on the grid is sufficient.\n * \n * Coordinates: $0 \\le x, y < N$.\n * Center $c = (N-1)/2$.\n * \n * Weight $W(x,y) = (x-c)^2 + (y-c)^2 + 1$.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Configuration\nconst int MAX_N = 65;\nint N, M;\nint CENTER;\n\n// Directions: Right, Up, Up-Right, Down-Right\nconst int DX[] = {1, 0, 1, 1, -1, 0, -1, -1}; // 8 neighbors for iteration, but we define axes\n// Axes for rectangles:\n// Pair 0: (1, 0) and (0, 1) [Axis Aligned]\n// Pair 1: (1, 1) and (1, -1) [45 Degree]\n\nstruct Point {\n int x, y;\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { return x != other.x ? x < other.x : y < other.y; }\n};\n\nint dist_sq(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// Global precomputed weights\nint WEIGHTS[MAX_N][MAX_N];\n\nstruct Move {\n Point p1, p2, p3, p4; // p1 is the NEW dot\n // For output, we need to print p1, p2, p3, p4. \n // Order in struct: p1 is new. p2, p3, p4 are existing.\n // The rectangle is p1-p2-p3-p4 in order.\n};\n\n// Helper to managing edges\n// We identify a unit segment by its type, and the coordinate of its \"smaller\" end (lexicographically or just x then y).\n// Horizontal: (x, y) -> (x+1, y). Identify by (x, y).\n// Vertical: (x, y) -> (x, y+1). Identify by (x, y).\n// Diag1 (Main): (x, y) -> (x+1, y+1). Identify by (x, y).\n// Diag2 (Anti): (x, y+1) -> (x+1, y). Identify by (x, y). NOTE: This maps segment between (x, y+1) and (x+1, y).\n// \n// Size needed: \n// H: [0..N-2][0..N-1] -> 64*64\n// V: [0..N-1][0..N-2]\n// D1: [0..N-2][0..N-2]\n// D2: [0..N-2][0..N-2]\nstruct GridState {\n bool has_dot[MAX_N][MAX_N]; // 4KB\n // Use bitsets for edges to save space and copy time?\n // 64*64 = 4096 bits = 512 bytes. Very small.\n // We use raw bool arrays for simplicity unless memory is tight.\n // Actually, std::bitset or flattening is better for copying.\n // Let's use flat arrays of uint64_t for bitmasks.\n // 64 columns fit in one uint64_t.\n uint64_t used_H[MAX_N]; \n uint64_t used_V[MAX_N];\n uint64_t used_D1[MAX_N];\n uint64_t used_D2[MAX_N];\n\n int score;\n vector history;\n vector dots; // Keep track of dot coordinates for fast iteration\n\n GridState() {\n memset(has_dot, 0, sizeof(has_dot));\n memset(used_H, 0, sizeof(used_H));\n memset(used_V, 0, sizeof(used_V));\n memset(used_D1, 0, sizeof(used_D1));\n memset(used_D2, 0, sizeof(used_D2));\n score = 0;\n }\n\n // Check if a unit segment is used\n // type: 0=H, 1=V, 2=D1, 3=D2\n // For H: p is (x, y) of left point\n // For V: p is (x, y) of bottom point\n // For D1: p is (x, y) of bottom-left point\n // For D2: p is (x, y) of top-left point. (x, y+1) is the start, (x+1, y) is end.\n // Wait, let's standardize D2 indexing.\n // D2 connects (x, y+1) and (x+1, y). Let's index this segment by (x, y).\n bool is_used(int type, int x, int y) const {\n if (type == 0) return (used_H[y] >> x) & 1;\n if (type == 1) return (used_V[y] >> x) & 1;\n if (type == 2) return (used_D1[y] >> x) & 1;\n if (type == 3) return (used_D2[y] >> x) & 1;\n return false;\n }\n\n void set_used(int type, int x, int y) {\n if (type == 0) used_H[y] |= (1ULL << x);\n else if (type == 1) used_V[y] |= (1ULL << x);\n else if (type == 2) used_D1[y] |= (1ULL << x);\n else if (type == 3) used_D2[y] |= (1ULL << x);\n }\n\n void add_dot(int x, int y) {\n if (!has_dot[x][y]) {\n has_dot[x][y] = true;\n dots.push_back({x, y});\n score += WEIGHTS[x][y];\n }\n }\n};\n\n// Random number generator\nmt19937 rng(12345);\n\n// Time management\nauto start_time = chrono::high_resolution_clock::now();\ndouble time_limit = 4.9; // seconds\n\ndouble get_elapsed_time() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// Logic to check and apply lines\n// Returns false if invalid\nbool check_and_mark_line(GridState& state, Point p1, Point p2, bool mark) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int steps = max(abs(dx), abs(dy));\n if (steps == 0) return false; // Same point\n\n int sx = dx / steps;\n int sy = dy / steps;\n\n // Validate direction type\n int type = -1;\n if (sy == 0) type = 0; // H\n else if (sx == 0) type = 1; // V\n else if (sx == sy) type = 2; // D1\n else if (sx == -sy) type = 3; // D2\n else return false; // Should not happen for valid rects\n\n int cx = p1.x;\n int cy = p1.y;\n\n // Check intermediate dots and edge usage\n for (int i = 0; i < steps; ++i) {\n // Check edge usage\n // Segment from (cx, cy) to (cx+sx, cy+sy)\n int ux = cx, uy = cy;\n if (type == 3) { \n // For D2, our indexing is based on (x, y) for segment (x, y+1)-(x+1, y)\n // If moving down-right: (x, y+1) -> (x+1, y). Index at (x, y).\n // If moving up-left: (x+1, y) -> (x, y+1). Index at (x, y).\n // So we need min x and min y\n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy); \n } else {\n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy);\n }\n \n if (state.is_used(type, ux, uy)) return false;\n\n // Move to next point\n cx += sx;\n cy += sy;\n\n // Check dot existence (strictly between p1 and p2)\n if (i < steps - 1) {\n if (state.has_dot[cx][cy]) return false;\n }\n }\n\n if (mark) {\n cx = p1.x;\n cy = p1.y;\n for (int i = 0; i < steps; ++i) {\n int ux = cx, uy = cy;\n if (type == 3) { \n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy); \n } else {\n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy);\n }\n state.set_used(type, ux, uy);\n cx += sx;\n cy += sy;\n }\n }\n return true;\n}\n\n// Check if a move is valid and return the score gain (or -1 if invalid)\n// Move defines rectangle p1-p2-p3-p4. p1 is new.\n// However, p1 is just a coordinate. We need to check edges:\n// p1-p2, p2-p3, p3-p4, p4-p1.\n// Note: p2, p3, p4 must be existing dots. p1 must be empty.\n// Also no dots on edges (excluding endpoints).\n// Edges must not overlap existing.\nbool is_valid_move(GridState& state, const Move& m, bool apply = false) {\n if (state.has_dot[m.p1.x][m.p1.y]) return false;\n // Check bounds (implied by iteration usually, but safety first)\n if (m.p1.x < 0 || m.p1.x >= N || m.p1.y < 0 || m.p1.y >= N) return false;\n\n // Check 4 edges\n // Order: p1 -> p2 -> p3 -> p4 -> p1\n // We need to check without marking first, then mark if all good.\n // But to avoid code duplication, we can use the 'mark' flag carefully or just check then mark.\n // Since checking is fast, let's check all then mark all.\n \n if (!check_and_mark_line(state, m.p1, m.p2, false)) return false;\n if (!check_and_mark_line(state, m.p2, m.p3, false)) return false;\n if (!check_and_mark_line(state, m.p3, m.p4, false)) return false;\n if (!check_and_mark_line(state, m.p4, m.p1, false)) return false;\n\n if (apply) {\n check_and_mark_line(state, m.p1, m.p2, true);\n check_and_mark_line(state, m.p2, m.p3, true);\n check_and_mark_line(state, m.p3, m.p4, true);\n check_and_mark_line(state, m.p4, m.p1, true);\n state.add_dot(m.p1.x, m.p1.y);\n state.history.push_back(m);\n }\n\n return true;\n}\n\n// Evaluate a state to help beam search\n// Simple evaluation: current score\n// Heuristic: penalize if dots are cluttered? Reward dots near edges?\n// The problem objective is purely weighted sum.\n// However, having dots in \"useful\" positions (L-shapes) is good.\n// Calculating \"potential\" is expensive.\n// Let's stick to score + small centrality penalty (prefer outwards) if ties?\n// Actually, the weight function already rewards outward dots.\ndouble evaluate(const GridState& s) {\n return (double)s.score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N >> M;\n CENTER = (N - 1) / 2;\n GridState initial_state;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int dx = i - CENTER;\n int dy = j - CENTER;\n WEIGHTS[i][j] = dx*dx + dy*dy + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_state.add_dot(x, y);\n }\n\n // Beam Search Parameters\n // Since state copy is somewhat heavy (a few arrays), we can't have huge width.\n // But we want depth.\n // We can filter moves.\n // Prioritize moves that give high immediate score (large weight p1).\n int BEAM_WIDTH = 200; // Tunable\n if (N > 50) BEAM_WIDTH = 100;\n \n vector beam;\n beam.reserve(BEAM_WIDTH * 4);\n beam.push_back(initial_state);\n\n // The game can have many turns.\n // We stop when time is up or no moves.\n \n int turn = 0;\n int best_overall_score = 0;\n GridState best_state = initial_state;\n\n // Directions for searching p3 from p2\n // 0: right, 1: up, 2: left, 3: down\n // 4: ur, 5: ul, 6: dl, 7: dr\n int DX_LIST[] = {1, 0, -1, 0, 1, -1, -1, 1};\n int DY_LIST[] = {0, 1, 0, -1, 1, 1, -1, -1};\n\n while (get_elapsed_time() < time_limit) {\n vector next_beam;\n next_beam.reserve(BEAM_WIDTH * 4);\n \n bool any_move_found = false;\n \n // We will collect candidates from all states in beam\n struct Candidate {\n int state_idx;\n Move move;\n int gain;\n bool operator>(const Candidate& other) const {\n return gain > other.gain;\n }\n };\n \n // Use a priority queue or partial sort to keep top candidates across all beam states?\n // Or just top K per state?\n // Merging is better.\n \n // Since generating *all* moves is slow, we might need to sample or limit generation.\n // For each state, iterate all dots p2.\n // Try to find p3 such that p2->p3 is valid edge.\n // Then try to find p4 such that p3->p4 is valid edge (perp to p2->p3).\n // Then check p1.\n // This is O(Dots * 8 * N * 2 * N) ~ O(M * N^2). With M~100, N~30 -> 100*900 ~ 90000 ops per state.\n // With beam width 100, that's 9e6 ops per turn. 5 sec / 9e6 ~ 500 turns. Maybe okay.\n // Optimization: Precompute valid edges? No, edges change (get blocked).\n \n // Global candidates collection\n // To avoid too many copies, we store indices.\n vector candidates;\n \n int state_idx = 0;\n for (auto& state : beam) {\n // Limit the number of dots we check to save time if we have many dots?\n // We can shuffle dots or prioritize dots near edges (unlikely to be blocked).\n // Or just iterate all.\n \n // Optimization: Iterate dots in random order to avoid bias if we cut off early?\n // No, deterministic is better for debug, but random helps exploration.\n // Let's just iterate all for now.\n \n int moves_found_for_state = 0;\n \n for (const auto& p2 : state.dots) {\n // Try 8 directions for p3\n for (int dir = 0; dir < 8; ++dir) {\n int dx1 = DX_LIST[dir];\n int dy1 = DY_LIST[dir];\n \n // Scan for p3\n for (int l1 = 1; ; ++l1) {\n int x3 = p2.x + dx1 * l1;\n int y3 = p2.y + dy1 * l1;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) break;\n \n // If there is a dot at p3\n if (state.has_dot[x3][y3]) {\n Point p3 = {x3, y3};\n \n // Check if p2->p3 is valid (no intermediate dots, no edge overlap)\n if (check_and_mark_line(state, p2, p3, false)) {\n // Now look for p4 perpendicular\n // Perpendicular directions\n // If dir < 4 (axis): (dx, dy) -> (-dy, dx) and (dy, -dx)\n // If dir >= 4 (diag): similarly\n int p_dirs[2];\n if (dir < 4) { // Axis aligned\n // if (1,0) -> (0,1), (0,-1)\n // generic rot90: (x,y)->(-y, x), (x,y)->(y, -x)\n // But we need to map back to indices in DX_LIST/DY_LIST to be clean, \n // or just compute manual. Manual is easier.\n // But we only iterate to find dots.\n // Actually, we can just scan the two perp lines from p3.\n } \n \n int perp_dx[2], perp_dy[2];\n perp_dx[0] = -dy1; perp_dy[0] = dx1;\n perp_dx[1] = dy1; perp_dy[1] = -dx1;\n \n for (int k = 0; k < 2; ++k) {\n int dx2 = perp_dx[k];\n int dy2 = perp_dy[k];\n \n for (int l2 = 1; ; ++l2) {\n int x4 = x3 + dx2 * l2;\n int y4 = y3 + dy2 * l2;\n \n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) break;\n \n if (state.has_dot[x4][y4]) {\n Point p4 = {x4, y4};\n // Check p3->p4\n if (check_and_mark_line(state, p3, p4, false)) {\n // Calculate p1\n // p1 = p2 + (p4 - p3)\n int x1 = p2.x + (x4 - x3);\n int y1 = p2.y + (y4 - y3);\n Point p1 = {x1, y1};\n \n // Check p1 in bounds, empty\n if (x1 >= 0 && x1 < N && y1 >= 0 && y1 < N && !state.has_dot[x1][y1]) {\n // Check p4->p1 and p1->p2\n // Optimization: check validity function\n Move m = {p1, p2, p3, p4};\n // We already checked p2->p3 and p3->p4.\n // Need to check p4->p1 and p1->p2.\n // Reuse is_valid_move but optimized?\n // is_valid_move checks all 4. It's safer.\n if (is_valid_move(state, m, false)) {\n candidates.push_back({state_idx, m, WEIGHTS[x1][y1]});\n moves_found_for_state++;\n }\n }\n }\n // If found a dot, we can't go further in this direction usually?\n // The rule says \"no dots ... on the perimeter\".\n // So if we found p4, we cannot skip it to find another p4' behind it.\n // Because p4 would be on the segment p3->p4'.\n break; \n }\n }\n }\n }\n // Cannot skip p3\n break;\n }\n }\n }\n }\n state_idx++;\n }\n\n if (candidates.empty()) {\n break; // Game over\n }\n any_move_found = true;\n\n // Sort candidates.\n // We want diversity, so maybe not just strict score?\n // Just score is fine for this problem structure.\n // Maybe weight by distance from center heavily.\n // Or just random shuffle equal scores.\n sort(candidates.begin(), candidates.end(), [](const Candidate& a, const Candidate& b) {\n return a.gain > b.gain;\n });\n\n // Select top BEAM_WIDTH distinct successors\n int picked = 0;\n // To avoid picking too many from same parent and reducing diversity?\n // Simple approach: just pick best.\n // Limit candidates per parent? e.g. max 5 per parent.\n vector picked_count(beam.size(), 0);\n \n for (const auto& cand : candidates) {\n if (picked >= BEAM_WIDTH) break;\n // Pruning heuristics\n if (picked_count[cand.state_idx] >= 3) continue; // Diversity enforcement\n\n GridState next_s = beam[cand.state_idx];\n is_valid_move(next_s, cand.move, true); // Apply\n next_beam.push_back(next_s);\n \n if (next_s.score > best_overall_score) {\n best_overall_score = next_s.score;\n best_state = next_s;\n }\n \n picked++;\n picked_count[cand.state_idx]++;\n }\n \n // If we couldn't fill beam, relax diversity constraint\n if (picked < BEAM_WIDTH && candidates.size() > picked) {\n for (const auto& cand : candidates) {\n if (picked >= BEAM_WIDTH) break;\n if (picked_count[cand.state_idx] >= 3) { // Only pick those skipped before\n // Check if we really want to copy again? \n // Beam search usually takes unique states.\n // Here uniqueness is guaranteed by move.\n GridState next_s = beam[cand.state_idx];\n is_valid_move(next_s, cand.move, true);\n next_beam.push_back(next_s);\n if (next_s.score > best_overall_score) {\n best_overall_score = next_s.score;\n best_state = next_s;\n }\n picked++;\n }\n }\n }\n\n beam = move(next_beam);\n turn++;\n \n // Time check inside loop to be safe\n if (get_elapsed_time() > time_limit) break;\n }\n\n // Output\n cout << best_state.history.size() << \"\\n\";\n for (const auto& m : best_state.history) {\n cout << m.p1.x << \" \" << m.p1.y << \" \"\n << m.p2.x << \" \" << m.p2.y << \" \"\n << m.p3.x << \" \" << m.p3.y << \" \"\n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n cout << flush;\n\n return 0;\n}","ahc015":"/**\n * AtCoder Heuristic Contest 015 (AHC015) Solution\n * Problem: Halloween Candy\n * Author: Algorithm Engineer\n * Language: C++20 (gcc 12.2.0)\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Types ---\nconstexpr int N = 10;\nconstexpr int TOTAL_TURNS = 100;\nconstexpr int EMPTY = 0;\n\n// Directions: F, B, L, R\n// F: move up (row decreases)\n// B: move down (row increases)\n// L: move left (col decreases)\n// R: move right (col increases)\nenum Direction { F = 0, B = 1, L = 2, R = 3 };\nconst char DIR_CHARS[4] = {'F', 'B', 'L', 'R'};\nconst int DR[4] = {-1, 1, 0, 0}; // Delta Row\nconst int DC[4] = {0, 0, -1, 1}; // Delta Col\n\nstruct State {\n int grid[N][N];\n \n // Initialize grid\n void init() {\n memset(grid, 0, sizeof(grid));\n }\n\n // Count empty cells\n int count_empty() const {\n int cnt = 0;\n for(int r=0; r place(int p, int flavor) {\n int current_empty = 0;\n for(int r=0; r= 0; --r) {\n if (grid[r][c] != EMPTY) {\n if (r != write_pos) {\n grid[write_pos][c] = grid[r][c];\n grid[r][c] = EMPTY;\n }\n write_pos--;\n }\n }\n }\n } else if (d == L) { // Left\n for (int r = 0; r < N; ++r) {\n int write_pos = 0;\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != EMPTY) {\n if (c != write_pos) {\n grid[r][write_pos] = grid[r][c];\n grid[r][c] = EMPTY;\n }\n write_pos++;\n }\n }\n }\n } else if (d == R) { // Right\n for (int r = 0; r < N; ++r) {\n int write_pos = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid[r][c] != EMPTY) {\n if (c != write_pos) {\n grid[r][write_pos] = grid[r][c];\n grid[r][c] = EMPTY;\n }\n write_pos--;\n }\n }\n }\n }\n }\n\n // Calculate Score: Sum of squares of connected component sizes\n long long calc_score() const {\n bool visited[N][N] = {false};\n long long score = 0;\n \n // Stack for DFS to avoid recursion overhead\n static pair st[N*N]; \n\n for(int r=0; r 0) {\n auto [cr, cc] = st[--top];\n size++;\n \n // Check neighbors\n // Up\n if(cr > 0 && !visited[cr-1][cc] && grid[cr-1][cc] == flavor) {\n visited[cr-1][cc] = true;\n st[top++] = {cr-1, cc};\n }\n // Down\n if(cr < N-1 && !visited[cr+1][cc] && grid[cr+1][cc] == flavor) {\n visited[cr+1][cc] = true;\n st[top++] = {cr+1, cc};\n }\n // Left\n if(cc > 0 && !visited[cr][cc-1] && grid[cr][cc-1] == flavor) {\n visited[cr][cc-1] = true;\n st[top++] = {cr, cc-1};\n }\n // Right\n if(cc < N-1 && !visited[cr][cc+1] && grid[cr][cc+1] == flavor) {\n visited[cr][cc+1] = true;\n st[top++] = {cr, cc+1};\n }\n }\n score += (long long)size * size;\n }\n }\n }\n return score;\n }\n};\n\n// --- Global Variables ---\nint flavors[TOTAL_TURNS];\nState global_state;\n\n// --- Random Engine ---\n// Use a fast PRNG\nstruct Xorshift {\n uint32_t x = 123456789;\n uint32_t y = 362436069;\n uint32_t z = 521288629;\n uint32_t w = 88675123;\n \n uint32_t next() {\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n }\n \n // Returns [0, n-1]\n int next_int(int n) {\n return next() % n;\n }\n} rng;\n\n\n// --- Simulation Logic ---\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read flavors\n for(int i=0; i> flavors[i];\n }\n\n global_state.init();\n\n // Time management\n auto start_clock = chrono::high_resolution_clock::now();\n double time_limit = 1.95; // seconds\n\n for(int t=0; t> p;\n\n // 1. Place the current candy\n global_state.place(p, flavors[t]);\n\n // 2. Determine the best move\n int best_move = -1;\n\n // If it's the last turn, the move doesn't matter visually for placement,\n // but the problem asks for 100 outputs. \n // At t=99 (100th candy), any move consolidates the final state.\n // We should still optimize it to get the best final clustering.\n \n // Strategy: Monte Carlo with Greedy Playouts\n // We have limited time. We allocate time per turn proportional to remaining complexity?\n // Actually, early moves have huge impact. But late moves are easier to simulate deeply.\n // Given 2.0s total, ~20ms per move.\n \n // Determine how much time we can spend on this turn\n auto now = chrono::high_resolution_clock::now();\n chrono::duration elapsed = now - start_clock;\n double remaining_time = time_limit - elapsed.count();\n double time_for_this_move = remaining_time / (TOTAL_TURNS - t + 5); // Add buffer denominator\n \n // Cap time per move to ensure we don't timeout early but use time effectively\n // Minimum iterations\n int iterations = 0;\n \n // Score accumulators for the 4 directions\n // We track sum of scores to take average\n long long score_sum[4] = {0};\n int count_sims[4] = {0};\n\n // Temporary state objects to avoid reallocation\n State initial_sim_state = global_state;\n \n auto turn_start = chrono::high_resolution_clock::now();\n \n while (true) {\n // Check time every batch of iterations\n if ((iterations & 0x3F) == 0) { // check every 64 iters\n auto curr = chrono::high_resolution_clock::now();\n chrono::duration turn_elapsed = curr - turn_start;\n if (turn_elapsed.count() > time_for_this_move) break;\n }\n\n // Pick a candidate first move (round robin or random)\n // We want to evaluate all 4 candidates roughly equally\n int first_move = iterations % 4; \n\n // Copy state\n State sim_state = initial_sim_state;\n \n // Apply first move\n sim_state.tilt(first_move);\n \n // Playout\n // Simulate subsequent turns until end or depth limit\n // Full depth 100 is feasible since N=10 is small.\n \n for (int sim_t = t + 1; sim_t < TOTAL_TURNS; ++sim_t) {\n // Randomly place next candy\n // Empty cells count: 100 - sim_t\n int empty_cnt = 100 - sim_t; // before placement\n // Logic: At start of turn sim_t, grid has sim_t candies.\n // Wait, t is 0-indexed (0 to 99). \n // At start of loop t, we placed candy t. Grid has t+1 candies.\n // Then we tilt. Grid still has t+1 candies.\n // Next turn is t+1. We place candy t+1.\n // In this loop, sim_t goes from t+1 to 99.\n // At step sim_t, we place candy flavors[sim_t].\n // Number of filled cells before placing is sim_t.\n // Empty cells = 100 - sim_t.\n \n int rnd_p = rng.next_int(100 - sim_t) + 1;\n sim_state.place(rnd_p, flavors[sim_t]);\n \n // Greedy choice for the simulated step\n // Try all 4 tilts, pick best immediate score\n int best_local_move = 0;\n long long max_local_score = -1;\n \n // To make greedy fast, maybe we don't copy full state 4 times?\n // But state is small (100 ints). Copy is fast.\n \n // Heuristic: Sometimes pure greedy gets stuck. \n // But for this problem, clustering same colors is the goal.\n // Simple greedy is often a strong baseline for playout policy.\n \n for(int d=0; d<4; ++d) {\n State temp = sim_state;\n temp.tilt(d);\n long long s = temp.calc_score();\n if (s > max_local_score) {\n max_local_score = s;\n best_local_move = d;\n }\n }\n sim_state.tilt(best_local_move);\n }\n\n // End of simulation, evaluate\n score_sum[first_move] += sim_state.calc_score();\n count_sims[first_move]++;\n iterations++;\n }\n\n // Select best move based on average score\n double best_avg = -1.0;\n // Default to a valid move if time was super tight\n best_move = 0; \n \n // Tie-breaking: if scores are equal, prefer directions that keep candies closer to center? \n // Or just random. Here we use simple max.\n for(int d=0; d<4; ++d) {\n if (count_sims[d] > 0) {\n double avg = (double)score_sum[d] / count_sims[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_move = d;\n }\n }\n }\n \n // If we had 0 iterations (shouldn't happen with time buffer), pick greedy\n if (iterations == 0) {\n long long max_s = -1;\n for(int d=0; d<4; ++d) {\n State temp = global_state;\n temp.tilt(d);\n long long s = temp.calc_score();\n if (s > max_s) {\n max_s = s;\n best_move = d;\n }\n }\n }\n\n // Output\n cout << DIR_CHARS[best_move] << endl; // endl flushes\n \n // Apply to real state\n global_state.tilt(best_move);\n }\n\n return 0;\n}","ahc016":"/**\n * Solution for AHC016 - Graphorean\n * \n * Strategy:\n * The core problem is to design M graphs (G_0 ... G_{M-1}) such that they are distinguishable\n * even after:\n * 1. Edge flipping noise (probability epsilon).\n * 2. Vertex permutation (graph isomorphism).\n * \n * Since vertex labels are lost due to shuffling, we must rely on graph invariants.\n * Simple invariants like edge count or degree distribution are robust but might not carry\n * enough information for large M or high epsilon.\n * \n * Approach:\n * 1. We partition the N vertices into smaller \"cliques\" or clusters. The sizes of these clusters\n * act as the signature of the graph.\n * For example, if N=10, a graph could be formed by a clique of size 3 and a clique of size 7.\n * The edges inside a clique are dense (probability p_high), and edges between cliques are sparse (probability p_low).\n * Usually, to maximize distinguishability, we just use \"volume of edges\" in specific sub-blocks if we knew the permutation.\n * But since we don't know the permutation, we rely on the sorted degree sequence or just the total number of edges\n * if epsilon is very high.\n * \n * 2. Actually, for small epsilon, the degree sequence is preserved well. For large epsilon, only the total number of edges is reliable.\n * \n * Let's refine the strategy based on epsilon:\n * \n * Case A: Small Epsilon (e.g., < 0.10)\n * We can use the sorted degree sequence as a \"feature vector\".\n * Or even simpler: Just vary the total number of edges. But with M=100, just edge count might overlap due to variance.\n * The variance of edge count is V = N_edges * eps * (1-eps). Std dev is sqrt(V).\n * With N=100, max edges ~5000. If we use density 0.5, edges=2500. V = 2500 * 0.1 * 0.9 = 225. Sigma = 15.\n * We need to separate M=100 states. 6*sigma separation is ideal. 100 * 6 * 15 is way larger than 5000.\n * So just edge count is NOT enough for N=100, eps=0.1.\n * \n * We need more robust local structures.\n * We divide the N vertices into K groups. Let the sizes be s_1, s_2, ..., s_K.\n * Within group k, we fill edges with probability 1 (or close to 1). Between groups, probability 0.\n * When we receive H, we try to recover the cluster sizes.\n * However, recovering clusters is hard with noise.\n * \n * Better approach for this contest:\n * We construct graphs $G_k$ such that their adjacency matrices look like block diagonal matrices,\n * or specifically, we just define the \"ideal\" number of edges for each vertex.\n * Let's assign a \"target degree\" $d_i$ to vertex $i$.\n * Since vertices are shuffled, the signature is the sorted list of degrees $D = \\text{sort}(d_0, \\dots, d_{N-1})$.\n * \n * Algorithm:\n * 1. Determine N. High N reduces error but increases penalty.\n * Score = 10^9 * (0.9^E) / N.\n * If we can get E=0 with N=40, score is ~2.5e7.\n * If we get E=0 with N=100, score is ~1.0e7.\n * Minimizing N is crucial, but E > 0 is very costly (factor 0.9).\n * With E=5, 0.9^5 = 0.59. So N=40 with E=5 is better than N=100 with E=0?\n * Actually 0.59/40 = 0.014, 1.0/100 = 0.01. Yes.\n * So we want minimal N that keeps E low.\n * \n * Method used here:\n * We construct a set of prototype graphs. Each prototype is defined by a partition of vertices $N = n_1 + n_2 + \\dots + n_k$.\n * To encode message $s$, we pick a specific partition.\n * The simplest partition is just 1 group of size $N$. The parameter we vary is the edge density or specific structure.\n * \n * Given the constraints and the nature of \"shuffled vertices + noise\", the most robust invariant is the distribution of degrees,\n * or more simply, the counts of edges in the graph, perhaps augmented by the count of triangles, etc.\n * \n * But \"count of edges\" is a single scalar. We can store M values in a scalar if the variance is low enough.\n * If epsilon is large, variance is high. We need high N.\n * If epsilon is small, we can distinguish more states.\n * \n * Let's try a hybrid approach:\n * 1. Divide vertices into two sets A and B of size $n_A, n_B$.\n * 2. Edges inside A are dense (prob 1). Edges inside B are sparse (prob 0). Edges between A and B are sparse (prob 0).\n * Basically, $G_s$ consists of a clique of size $k$ and isolated vertices.\n * The number of edges is $k(k-1)/2$.\n * The max number of edges is limited.\n * \n * Let's generalize:\n * Each graph $G_s$ is generated by partitioning $N$ vertices into groups $c_1, c_2, \\dots$.\n * Edges within group $c_i$ are 1. Edges between groups are 0.\n * This creates a graph which is a disjoint union of cliques.\n * When noise is added, we get a graph. We calculate the \"likelihood\" of this graph coming from each $G_s$.\n * \n * Likelihood calculation:\n * Given $H$ (adjacency matrix $A_H$) and candidate $G_k$ (adjacency matrix $A_G$ but we don't know the permutation).\n * Since we don't know the permutation, exact likelihood is hard (requires summing over N! permutations).\n * \n * Approximation:\n * Just sort the degrees of $H$. Sort the expected degrees of $G_k$. Compare them?\n * Degrees change with noise.\n * \n * Alternative:\n * Just use the total number of edges?\n * Let $m$ be number of edges in $G_s$.\n * Observed edges in $H$: $m' \\sim m(1-\\epsilon) + (\\binom{N}{2}-m)\\epsilon$.\n * Expected value $\\mu(m) = m(1-2\\epsilon) + \\binom{N}{2}\\epsilon$.\n * We can choose $G_0, \\dots, G_{M-1}$ to have different $m$ such that $\\mu(m)$ are well-spaced.\n * Max edges $E_{max} = N(N-1)/2$.\n * We need to pick $M$ integers $x_0, \\dots, x_{M-1} \\in [0, E_{max}]$ to maximize spacing.\n * This is only effective if the spacing is larger than the noise std dev.\n * \n * If $\\epsilon$ is large (e.g. 0.40), the \"signal\" is $m(1-0.8) = 0.2m$.\n * Noise variance is large. N needs to be large (likely 100).\n * Even with N=100, simple edge counting might fail for M=100.\n * \n * Let's try a standard approach for this problem type:\n * Divide the N vertices into chunks.\n * Example: For each graph ID $k$, we define a binary vector $v_k$ of length $L$.\n * We assign subsets of vertices to represent bits of $v_k$.\n * However, because of shuffling, we can't identify which vertex is which bit.\n * \n * So, the code is effectively a multiset of features.\n * The best feature for graph isomorphism under noise is often the degree sequence.\n * But we can explicitly construct $G_k$ to maximize the difference in \"local density\".\n * \n * Proposed Solution:\n * We partition $N$ vertices into $D$ groups of equal size (e.g., $N=100$, 20 groups of 5).\n * Let the groups be $g_0, g_1, \\dots, g_{D-1}$.\n * For each pair of groups $(g_i, g_j)$ (including $i=j$), we decide whether to fill it with 1s or 0s based on the ID $k$.\n * Wait, shuffling destroys group identity.\n * \n * So we must rely on the counts.\n * Let's go back to \"Disjoint Union of Cliques\" or \"Graph defined by degree sequence\".\n * Actually, the \"Number of edges\" method is the most robust against shuffling because it is permutation invariant.\n * Is there a second invariant? Number of triangles?\n * \n * Let's stick to \"Number of edges\" as the primary differentiator, but optimize N.\n * If \"Number of edges\" is insufficient to separate M states with acceptable error, we increase N.\n * If N=100 is not enough, we are in trouble. But wait, we can use the whole range $0 \\dots \\binom{N}{2}$.\n * \n * Wait, if we output $N$, we must output $N$ for all graphs.\n * We can choose $N$ dynamically based on $M$ and $\\epsilon$.\n * \n * Algorithm:\n * 1. Estimate necessary N to separate M values using simple edge counts.\n * Let $L = N(N-1)/2$.\n * Signal range is roughly $L(1-2\\epsilon)$.\n * We have M points. Distance $d = L(1-2\\epsilon) / (M-1)$.\n * Noise std dev $\\sigma \\approx \\sqrt{L \\epsilon (1-\\epsilon)}$.\n * We want $d > k \\sigma$. (e.g., $k=2$ or $3$).\n * Solve for N.\n * \n * 2. If the required N > 100, we cap at 100 and try to add a second dimension.\n * The second dimension can be \"variance of degrees\".\n * We can construct graphs with same edge count but different degree variance.\n * E.g., Graph A: Regular graph (variance 0). Graph B: Star graph or Clique + Isolated (high variance).\n * \n * Refined Plan:\n * 1. Determine $N$. We iterate $N$ from 4 to 100.\n * We check if we can pack $M$ Gaussian distributions into the range of expected edge counts $[0, N(N-1)/2]$\n * such that the overlap probability is low.\n * If yes, pick that N and generate graphs with specific edge counts (randomly distributed to be \"generic\" or just first k edges?\n * To minimize variance of \"measured edges\", the generated graph structure doesn't matter much, only the count.\n * Actually, for a fixed edge count, different graphs might have slightly different noise characteristics for structural invariants,\n * but for raw edge count, it depends only on the count).\n * \n * Wait, if edge count is the only feature, we just output `11...100...0`.\n * Is there a way to improve?\n * Yes, if N is capped at 100 and edge count separation is insufficient, we use structure.\n * \n * Structure Idea:\n * Split vertices into 2 sets of size $N/2$.\n * We have 3 blocks of edges: (0,0), (0,1), (1,1).\n * This gives us a 3D feature space (density in block 00, 01, 11).\n * But we can't distinguish block 0 from block 1 easily after shuffling if their sizes are same.\n * If sizes are different (e.g. 1 vs N-1), we can.\n * \n * Actually, let's look at the \"Degree Sequence\" approach.\n * For a graph $G_k$, we set the edge probability $P_{ij}$ for edge $(i,j)$.\n * Since we output deterministic graphs, $P_{ij} \\in \\{0, 1\\}$.\n * \n * For large $\\epsilon$ (e.g. 0.4), information capacity is low.\n * Simple edge count is likely the best we can do because degree variance gets washed out by noise.\n * \n * Let's implement a simulator to pick the best N and the best strategy.\n * Strategy 0: Just modify total number of edges.\n * $G_k$ has $x_k$ edges.\n * Decoder: Count edges $e$, map to nearest expected $E[x_k]$.\n * \n * Strategy 1: Two clusters of different sizes $n_1, n_2$.\n * Densities $d_1, d_{12}, d_2$.\n * This is complex to decode.\n * \n * Let's evaluate Strategy 0.\n * Max edges $L = N(N-1)/2$.\n * Transform: $y = (x - L\\epsilon) / (1-2\\epsilon)$.\n * We want to place $M$ points in $[0, L]$.\n * Spacing $S = L / (M-1)$.\n * Sigma $\\sigma = \\sqrt{L \\epsilon (1-\\epsilon)}$.\n * Z-score $Z = (S/2) / \\sigma$.\n * Error prob $\\approx \\text{erfc}(Z)$.\n * \n * For $N=100, L=4950, M=100, \\epsilon=0.2$.\n * $S = 4950 / 99 = 50$.\n * Effective range scales by $(1-2\\epsilon) = 0.6$.\n * So effective spacing for raw edge count is $50 * 0.6 = 30$.\n * $\\sigma = \\sqrt{4950 * 0.2 * 0.8} = \\sqrt{792} \\approx 28$.\n * $Z = 30/2 / 28 = 0.5$. Error rate is huge.\n * \n * Conclusion: For high $M$ and $\\epsilon$, simple edge count is insufficient.\n * We need to use the individual degrees.\n * \n * Improved Encoding:\n * Assign a \"target degree\" $t_i \\in \\{0, \\dots, N-1\\}$ to each vertex $i$.\n * Construct a graph that matches these degrees as closely as possible.\n * Ideally, we partition vertices into \"bins\".\n * Vertices in bin $b$ are connected to all vertices in bins $0 \\dots b$ (or something similar).\n * This creates a staircase adjacency matrix.\n * \n * Let's simplify:\n * We can vary the \"clique size\".\n * $G_k$ = Clique of size $k$.\n * Degree sequence: $k$ vertices have degree $k-1$, $N-k$ vertices have degree $0$.\n * This is very distinct.\n * With $N=100$, we can vary clique size from 0 to 100 (101 states).\n * Is this better than edge count?\n * Clique size $k$ has $k(k-1)/2$ edges.\n * The edge counts are quadratic. They are sparse for low $k$ and dense for high $k$.\n * We want uniform spacing in \"distinguishability space\".\n * \n * Let's assume we use the full vector of sorted degrees $\\mathbf{d} = (d_1, \\dots, d_N)$ as the feature.\n * Decoder:\n * Receive $H$. Calculate sorted degrees $\\mathbf{d}_H$.\n * Find $k$ that minimizes distance $|\\mathbf{d}_H - E[\\mathbf{d}_{G_k}]|$.\n * \n * How to generate $G_k$?\n * We can define a continuous parameter $p \\in [0, 1]$.\n * We want to map $p$ to a graph $G(p)$.\n * A good trajectory of graphs $G(p)$ should change degrees smoothly and maximize variance.\n * \n * Simple \"staircase\" construction:\n * Order vertices $0 \\dots N-1$.\n * Fill edge $(i, j)$ if $i + j < K$.\n * As we increase $K$ from $0$ to $2N-3$, we fill the matrix.\n * This creates varying degrees.\n * \n * Construction \"Diagonal\":\n * Fill $(i, j)$ if $j \\le i + K$ ? No, undirected.\n * \n * Let's use the simple \"Linear Fill\":\n * Sort all possible edges $(i, j)$ by some criterion, then take first $X$ edges.\n * Criterion: $i + j$.\n * Edges with small $i+j$ connect low-index vertices.\n * This creates vertices with very high degree (low indices) and very low degree (high indices).\n * This maximizes the spread of degrees.\n * Low index vertices act as \"hubs\".\n * \n * Let's compare \"Linear Fill by $i+j$\" vs \"Random Fill\".\n * Random fill: degrees are all roughly $2X/N$. Very tight concentration.\n * $i+j$ fill: degrees vary from near $N$ to near $0$.\n * This high variance in degrees helps because noise affects each degree independently (mostly).\n * \n * So, the plan:\n * 1. Fix N (search for optimal).\n * 2. Generate $M$ graphs.\n * Each graph is defined by taking the first $X_k$ edges from a master list of edges.\n * The master list is sorted by $i+j$ (primary) and $i$ (secondary).\n * This ensures we fill the \"corner\" of the adjacency matrix first.\n * Let's call this \"Corner Fill\".\n * 3. The values $X_0, \\dots, X_{M-1}$ are chosen to be equidistant in terms of \"Distance metric\".\n * Distance between $G_a$ and $G_b$ is defined by the Euclidean distance of their expected sorted degree sequences.\n * Or simpler: just select $X_k$ such that the expected edge counts are spaced.\n * Actually, if we use \"Corner Fill\", the edge count correlates perfectly with the degree distribution shift.\n * We just need to select $X_k$ to maximize separation.\n * \n * Since the error is roughly proportional to $\\sqrt{Edges}$ (actually dependent on density),\n * uniform spacing of Edges is a reasonable starting point.\n * \n * Wait, for high $\\epsilon$, simply counting edges is often statistically stronger than looking at degrees \n * because individual degrees have variance $\\approx N \\epsilon (1-\\epsilon)$ and are correlated.\n * Sum of degrees = 2 * edges.\n * So utilizing the degree distribution is basically a refinement.\n * \n * Optimization of N:\n * We can simulate the \"Success Rate\" for a given N and M, epsilon.\n * For the contest, we can just run a local search or simple heuristic to pick N.\n * Since M <= 100, N=100 is safe but might be penalized.\n * If M is small (10) and eps small (0.01), N=4 is enough?\n * $N=4, M=10$. Edges $0..6$. Not enough for 10 graphs.\n * Need enough capacity.\n * \n * Let's implement a \"Solver\" class.\n * It will try $N \\in \\{4, \\dots, 100\\}$.\n * For a fixed N, we generate M candidate edge counts $e_0, \\dots, e_{M-1}$.\n * To make them robust, we space them out.\n * Ideally $e_k \\approx \\frac{L}{M-1} k$.\n * But we must account for the \"contraction\" due to $\\epsilon$.\n * Actually, we just output graphs with $e_k$ edges. The decoder handles the $\\epsilon$.\n * \n * We will use the \"Corner Fill\" strategy because it produces distinct degree sequences, which *might* help \n * if we use a sophisticated decoder, and certainly doesn't hurt (it's better than random).\n * \n * Decoder:\n * Given H.\n * Compute feature vector $F(H)$.\n * Compare with expected feature vectors $E[F(G_k)]$.\n * Pick closest.\n * \n * Feature vector:\n * 1. Total edges.\n * 2. Sorted degrees?\n * Let's check if sorted degrees help.\n * With Corner Fill, graph $k$ and graph $k+1$ differ by few edges.\n * Degrees change slightly.\n * The \"Total Edges\" is the strongest signal.\n * The \"Sorted Degrees\" adds detail.\n * We can use a Maximum Likelihood Estimator (MLE) approximation.\n * \n * Prob of observing adjacency $A'$ given $A$:\n * $P(A'|A) = \\prod \\dots$\n * This requires summing over permutations. Too slow.\n * \n * Simple Decoder:\n * Just use total edges.\n * $cnt = \\text{popcount}(H)$.\n * Estimate $\\hat{e} = (cnt - L \\epsilon) / (1 - 2\\epsilon)$.\n * Find $k$ such that number of edges in $G_k$ is closest to $\\hat{e}$.\n * \n * Is this enough?\n * Let's run a quick simulation logic inside the `solve` function to pick N.\n * \n * Simulation:\n * For a candidate N:\n * Define $L = N(N-1)/2$.\n * Select $M$ integers $E_0, \\dots, E_{M-1}$ evenly spaced in $[0, L]$.\n * Simulate noise:\n * For each $k$, sample $obs \\sim Binomial(E_k, 1-\\epsilon) + Binomial(L-E_k, \\epsilon)$.\n * Decode $obs$: $\\hat{E} = (obs - L\\epsilon) / (1-2\\epsilon)$.\n * Check if nearest $E_j$ is $E_k$.\n * Count errors.\n * Calculate score.\n * Pick N that maximizes score.\n * \n * Corner case: $\\epsilon$ close to 0.5 (e.g. 0.4). The denominator $1-2\\epsilon$ becomes 0.2.\n * The noise is huge. We definitely need N=100 for large $\\epsilon$.\n * For small $\\epsilon$, we can reduce N.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global parameters\nint M;\ndouble epsilon_val;\n\nstruct Solution {\n int N;\n vector G_str;\n vector edge_counts;\n\n // For decoding, we might just use edge counts. \n // But let's prepare for the actual graph generation.\n};\n\n// Function to count '1's in a string\nint count_ones(const string& s) {\n int c = 0;\n for(char ch : s) if(ch == '1') c++;\n return c;\n}\n\n// Generate the graph string for a given N and number of edges, using \"Corner Fill\"\n// Vertices 0..N-1. We fill edges (u, v) with smallest u+v, then smallest u.\nstring generate_graph(int n, int target_edges) {\n int max_edges = n * (n - 1) / 2;\n target_edges = max(0, min(max_edges, target_edges));\n \n // List all edges\n vector> edges;\n edges.reserve(max_edges);\n for(int i=0; i& a, const pair& b){\n int sum_a = a.first + a.second;\n int sum_b = b.first + b.second;\n if (sum_a != sum_b) return sum_a < sum_b;\n return a.first < b.first;\n });\n \n // Create adjacency matrix/string\n // The output format requires lexicographical order of (i, j).\n // So we first determine which edges are present, then build the string.\n vector> adj(n, vector(n, false));\n for(int k=0; k 100) return 0.0;\n \n int L = n * (n - 1) / 2;\n \n // We choose m edge counts evenly spaced.\n vector targets(m);\n if (m == 1) {\n targets[0] = 0;\n } else {\n for(int i=0; i G/2).\n // P(Z > k) where k = (G/2)/sigma.\n \n if (denom < 1e-9) denom = 0; // Handling eps=0.5, though limit is 0.4\n \n double separation = (m > 1) ? (double)L / (m - 1) * denom : 1e9;\n double z = 0;\n if (sigma > 1e-9) {\n z = (separation / 2.0) / sigma;\n } else {\n z = 1e9; // Infinite separation if no noise\n }\n \n // Error probability approximation using complementary error function\n // P(error) approx erfc(z/sqrt(2)) (one-sided is 0.5*erfc, two-sided is erfc roughly)\n // Actually, for internal points it's 2-sided, for boundaries 1-sided.\n // Average error prob:\n double p_fail_single = 0.5 * erfc(z / sqrt(2.0)); \n // Most points have two neighbors, so 2 * p_fail_single.\n // Endpoints have one neighbor.\n // Approx total error rate E_rate:\n double E_rate = 0.0;\n if (m > 1) {\n double two_sided = 2.0 * p_fail_single;\n double one_sided = p_fail_single;\n // (M-2) points have 2 neighbors, 2 points have 1 neighbor\n E_rate = ((m - 2) * two_sided + 2 * one_sided) / m;\n }\n \n // Simulation requires Expected Failures out of 100 queries.\n double expected_failures = 100.0 * E_rate;\n \n // Score formula\n double score = pow(0.9, expected_failures) / n;\n return score;\n}\n\nint main() {\n // Optimize I/O\n cin.tie(NULL);\n ios_base::sync_with_stdio(false);\n\n if (!(cin >> M >> epsilon_val)) return 0;\n\n // 1. Select optimal N\n // We search N in [4, 100].\n // We prefer smaller N if score is similar, but the formula heavily penalizes failures.\n // 0.9^1 = 0.9. 0.9^5 = 0.59.\n // Changing N from 50 to 100 halves the score factor 1/N, but if it saves 5 errors, 0.59 vs 1.0 is big.\n // However, if errors are already 0, increasing N just hurts.\n \n int best_N = 4;\n double best_score = -1.0;\n \n // Since the function is not monotonic (due to integer rounding of gaps), we scan all.\n for(int n=4; n<=100; ++n) {\n double s = estimate_score(n, M, epsilon_val);\n if (s > best_score) {\n best_score = s;\n best_N = n;\n }\n }\n \n // Generate the M graphs\n int N = best_N;\n cout << N << \"\\n\";\n \n vector target_edges(M);\n int L = N * (N - 1) / 2;\n \n // Generate targets\n if (M == 1) {\n target_edges[0] = 0;\n } else {\n for(int i=0; i expected_edges(M);\n for(int i=0; i> H;\n \n int obs_edges = count_ones(H);\n \n // Find closest expected value\n int best_k = 0;\n double min_dist = 1e18;\n \n for(int k=0; k\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// ---------------------------------------------------------\n// Configuration\n// ---------------------------------------------------------\nconst double TIME_LIMIT = 5.8; // Total execution time limit buffer\nconst double PHASE1_LIMIT = 4.0; // Time allocation for geometric optimization\n\n// ---------------------------------------------------------\n// Structures\n// ---------------------------------------------------------\nstruct Point {\n int x, y;\n};\n\nstruct Edge {\n int id; // 1-based ID\n int u, v, w; // u, v are 1-based vertex indices\n double mx, my;// Midpoint coordinates\n};\n\n// ---------------------------------------------------------\n// Globals\n// ---------------------------------------------------------\nint N, M, D, K;\nvector edges;\nvector coords;\nvector>> adj; // adj[u] contains {v, edge_index_in_edges_vec} (Wait, let's store edge ID)\n // Let's store {v, edge_id} for easier lookup\nvector solution; // solution[edge_id] = day (1-based)\nvector> edges_on_day; // day (0-based) -> list of edge ids\nvector inv_dist_sq; // Precomputed inverse squared distances between edges\n\nmt19937 rng(12345);\n\n// ---------------------------------------------------------\n// Utility Functions\n// ---------------------------------------------------------\ndouble get_time() {\n static auto start_time = chrono::steady_clock::now();\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// Get precomputed interaction potential between two edges (by 0-based index in edges vector)\n// We map edge_id to index by (id - 1)\ninline float get_inv_dist(int idx1, int idx2) {\n if (idx1 > idx2) swap(idx1, idx2);\n return inv_dist_sq[idx1 * M + idx2];\n}\n\n// ---------------------------------------------------------\n// Core Logic\n// ---------------------------------------------------------\n\n// Precompute O(M^2) distance table for fast energy updates\nvoid precompute_distances() {\n inv_dist_sq.resize(M * M);\n for (int i = 0; i < M; ++i) {\n for (int j = i + 1; j < M; ++j) {\n double dx = edges[i].mx - edges[j].mx;\n double dy = edges[i].my - edges[j].my;\n // Add epsilon to avoid division by zero (though overlapping edges rare)\n // Using Euclidean squared distance + constant\n double d2 = dx*dx + dy*dy;\n float val = 1.0f / (float)(d2 + 100.0); \n inv_dist_sq[i * M + j] = val;\n }\n }\n}\n\n// Dijkstra's algorithm to compute sum of shortest paths from source s\n// considering edges in `removed_edge_ids` are blocked.\n// Returns a large penalty if the graph becomes disconnected.\nlong long run_dijkstra(int s, const vector& removed_edge_ids) {\n static vector is_removed(M + 1, false);\n static vector dist(N + 1);\n static const long long INF_DIST = 1e15; // Sufficiently large penalty\n\n // Mark removed edges\n for (int e : removed_edge_ids) is_removed[e] = true;\n\n // Reset dist\n fill(dist.begin(), dist.end(), -1);\n\n // Priority Queue: {distance, vertex}\n // Use std::greater for min-heap\n priority_queue, vector>, greater>> pq;\n\n dist[s] = 0;\n pq.push({0, s});\n\n int visited_count = 0; // To check connectivity if needed, but sum checks it implicitly\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (dist[u] != -1 && d > dist[u]) continue;\n\n for (auto& edge : adj[u]) {\n int v = edge.first;\n int id = edge.second;\n \n if (is_removed[id]) continue;\n\n int w = edges[id-1].w;\n if (dist[v] == -1 || dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.push({dist[v], v});\n }\n }\n }\n\n // Unmark removed edges for next run\n for (int e : removed_edge_ids) is_removed[e] = false;\n\n long long total_dist = 0;\n for (int i = 1; i <= N; ++i) {\n if (dist[i] == -1) return INF_DIST; // Disconnected\n total_dist += dist[i];\n }\n return total_dist;\n}\n\n// Initial Construction: BFS-based spatial dispersion\nvoid initial_solution() {\n // Find a central node to start BFS\n int center = 1;\n double min_d_center = 1e18;\n for(int i=1; i<=N; ++i) {\n double d = pow(coords[i-1].x - 500, 2) + pow(coords[i-1].y - 500, 2);\n if (d < min_d_center) {\n min_d_center = d;\n center = i;\n }\n }\n\n // BFS to calculate node ranks (distance from center in unweighted hops)\n vector node_rank(N + 1, -1);\n queue q;\n \n node_rank[center] = 0;\n q.push(center);\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n for(auto& pair : adj[u]){\n int v = pair.first;\n if(node_rank[v] == -1){\n node_rank[v] = node_rank[u] + 1;\n q.push(v);\n }\n }\n }\n \n // Sort edges based on the rank of their endpoints (creating concentric layers)\n // Within the same layer, sort by angle to disperse around the ring\n vector sorted_edges(M);\n iota(sorted_edges.begin(), sorted_edges.end(), 1);\n \n sort(sorted_edges.begin(), sorted_edges.end(), [&](int a, int b){\n int u1 = edges[a-1].u, v1 = edges[a-1].v;\n int u2 = edges[b-1].u, v2 = edges[b-1].v;\n \n int r1 = min(node_rank[u1], node_rank[v1]);\n int r2 = min(node_rank[u2], node_rank[v2]);\n \n if(r1 != r2) return r1 < r2;\n \n // Angle check relative to center (500, 500)\n double ang1 = atan2(edges[a-1].my - 500, edges[a-1].mx - 500);\n double ang2 = atan2(edges[b-1].my - 500, edges[b-1].mx - 500);\n return ang1 < ang2;\n });\n\n // Assign edges to days in round-robin fashion based on this sorted order\n edges_on_day.assign(D, {});\n for (int i = 0; i < M; ++i) {\n int eid = sorted_edges[i];\n int day = i % D; \n solution[eid] = day + 1;\n edges_on_day[day].push_back(eid);\n }\n}\n\n// Calculate geometric potential (sum of inverse squared distances) for a day\ndouble calc_day_potential(int day) {\n const auto& es = edges_on_day[day];\n double pot = 0;\n for (size_t i = 0; i < es.size(); ++i) {\n for (size_t j = i + 1; j < es.size(); ++j) {\n pot += get_inv_dist(es[i]-1, es[j]-1);\n }\n }\n return pot;\n}\n\n// Phase 1: Simulated Annealing optimizing Geometric Dispersion\n// Objective: Ensure edges removed on the same day are far apart.\nvoid optimize_geometric() {\n vector day_potentials(D);\n double total_potential = 0;\n for(int d=0; d end_time) break;\n }\n \n // Candidate Move: Move edge e from d1 to d2\n int e_idx = rng() % M; // 0-based index\n int eid = edges[e_idx].id;\n int d1 = solution[eid] - 1;\n int d2 = rng() % D;\n\n if (d1 == d2) continue;\n if (edges_on_day[d2].size() >= K) continue; // Capacity constraint\n\n // Calculate change in potential\n // 1. Remove e from d1\n double pot_d1_new = day_potentials[d1];\n for (int other : edges_on_day[d1]) {\n if (other == eid) continue;\n pot_d1_new -= get_inv_dist(eid-1, other-1);\n }\n \n // 2. Add e to d2\n double pot_d2_new = day_potentials[d2];\n for (int other : edges_on_day[d2]) {\n pot_d2_new += get_inv_dist(eid-1, other-1);\n }\n\n double delta = (pot_d1_new + pot_d2_new) - (day_potentials[d1] + day_potentials[d2]);\n \n // Acceptance Probability\n double time_progress = (get_time() - start_time) / (end_time - start_time);\n double temp = T0 + (T1 - T0) * time_progress; // Linear cooling\n \n // Metropolis criterion (minimizing potential)\n if (delta < 0 || exp(-delta / temp) > generate_canonical(rng)) {\n // Apply Move\n // Remove from d1\n auto& v1 = edges_on_day[d1];\n for(size_t i=0; i samples;\n \n // Uniform random sampling\n vector p(N);\n iota(p.begin(), p.end(), 1);\n shuffle(p.begin(), p.end(), rng);\n for(int i=0; i& day_edges) -> long long {\n long long sum = 0;\n for(int s : samples) {\n sum += run_dijkstra(s, day_edges);\n }\n return sum;\n };\n\n // Calculate initial scores for all days\n vector day_scores(D);\n for(int d=0; d end_time) break;\n }\n\n // Move type: Move edge e from d1 to d2\n int e_idx = rng() % M;\n int eid = edges[e_idx].id;\n int d1 = solution[eid] - 1;\n int d2 = rng() % D;\n\n if (d1 == d2) continue;\n if (edges_on_day[d2].size() >= K) continue;\n\n // Construct tentative edge sets\n // Note: Copying vectors is cheap since size ~ M/D ~ 100\n vector d1_edges = edges_on_day[d1];\n // Remove eid from copy\n for(auto it = d1_edges.begin(); it != d1_edges.end(); ++it){\n if(*it == eid){\n d1_edges.erase(it);\n break;\n }\n }\n \n vector d2_edges = edges_on_day[d2];\n d2_edges.push_back(eid);\n\n // Evaluate only the changed days\n long long current_total = day_scores[d1] + day_scores[d2];\n long long new_s1 = calc_day_score(d1_edges);\n long long new_s2 = calc_day_score(d2_edges);\n \n // Greedy acceptance (Hill Climbing)\n if (new_s1 + new_s2 < current_total) {\n // Apply changes\n auto& v1 = edges_on_day[d1];\n for(size_t i=0; i> N >> M >> D >> K)) return 0;\n \n adj.resize(N + 1);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n Edge e;\n e.id = i + 1;\n e.u = u; e.v = v; e.w = w;\n edges.push_back(e);\n adj[u].push_back({v, e.id});\n adj[v].push_back({u, e.id});\n }\n \n coords.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].x >> coords[i].y;\n }\n\n // Initialization\n for (auto& e : edges) {\n e.mx = (coords[e.u-1].x + coords[e.v-1].x) / 2.0;\n e.my = (coords[e.u-1].y + coords[e.v-1].y) / 2.0;\n }\n solution.resize(M + 1);\n\n // Precompute geometric data\n precompute_distances();\n\n // Step 1: Construct a spatially dispersed initial solution\n initial_solution();\n\n // Step 2: Improve using geometric potential (Fast SA)\n optimize_geometric();\n\n // Step 3: Refine using actual path lengths (Dijkstra Hill Climbing)\n optimize_graph();\n\n // Output\n for (int i = 1; i <= M; ++i) {\n cout << solution[i] << (i == M ? \"\" : \" \");\n }\n cout << endl;\n\n return 0;\n}","ahc019":"/**\n * AtCoder Heuristic Contest 019 - Silhouettes\n * \n * Strategy Overview:\n * 1. Initial Representation: \n * For each silhouette pair (f_i, r_i), the maximum possible volume is the intersection of the extrusions\n * of the silhouettes. Let's call this the \"maximal object\" M_i.\n * M_i(x, y, z) = 1 if f_i(z, x) == 1 and r_i(z, y) == 1, else 0.\n * Any valid object O_i must be a subset of M_i.\n * \n * 2. Decomposition into Blocks:\n * The core task is to find a set of blocks {B_1, ..., B_k} that can assemble into O_1 and O_2.\n * This is essentially finding a common decomposition of two voxel sets, or rather, finding large\n * blocks that can fit into both M_1 (transformed T1) and M_2 (transformed T2), then filling the\n * residuals with smaller blocks.\n * \n * 3. Optimization Objective:\n * Minimize: r1 + r2 + sum_{b in S} (1/vol(b))\n * - r1, r2 are wasted volumes (blocks unused in one configuration).\n * - The sum term encourages using *large* blocks shared between both configurations.\n * - Ideally, r1 = r2 = 0 (all blocks used in both) and blocks are huge.\n * \n * 4. Algorithm:\n * a. Valid Region constraints:\n * We must satisfy the silhouettes. This means for every '1' pixel in f_i or r_i, there must be at\n * least one voxel in O_i that projects to it.\n * Let's verify valid/essential voxels.\n * \n * b. Block Generation (Greedy / Randomized Search):\n * We want to find a rigid transformation (rotation + translation) of a chunk of voxels in M_1\n * such that it fits inside M_2.\n * \n * Method:\n * - Identify \"essential\" voxels in M_1 and M_2 that are needed to satisfy the silhouette constraints.\n * - Ideally, we carve out the same shape from M_1 and M_2.\n * - Try to find the largest common sub-shape between M_1 and M_2 considering rotations.\n * - This is computationally heavy (matching 3D shapes).\n * \n * c. Simplified Approach for Constraints:\n * Since D is small (up to 14), we can iterate.\n * We can try to correlate M_1 and M_2.\n * Let's pick a random rotation for M_2 relative to M_1.\n * Try to match voxels.\n * \n * d. Construction Algorithm:\n * - Maintain a state of \"remaining volume\" for O_1 and O_2. Initially M_1 and M_2.\n * - Repeat:\n * 1. Pick a seed voxel in remaining M_1.\n * 2. Grow a large connected component (block) P from this seed inside M_1.\n * 3. Check if P (or a rotation of P) fits into remaining M_2.\n * 4. If yes, place P in both, record it as a shared block. Remove P from M_1 and M_2.\n * 5. If no, try shrinking P or picking a different seed.\n * - After sharing as much as possible, decompose the remaining parts of M_1 into blocks (used only in O_1).\n * - Decompose the remaining parts of M_2 into blocks (used only in O_2).\n * - Validate silhouette constraints. If constraints are violated by removal, we might need to keep some voxels or ensure the decomposition covers the requirements.\n * - Actually, the problem allows M_i to be a subset of the maximal shape. We just need to cover the silhouette.\n * Wait, the scoring penalty r_i is \"volume of blocks NOT used in output i\".\n * The blocks are a global set.\n * If we define a block B, and we use it in O_1 but not O_2, its volume contributes to r_2.\n * So we want every block to be used in both.\n * \n * e. Refined Algorithm:\n * 1. Calculate Maximal Volumes V1_max and V2_max based on silhouettes.\n * 2. Identify \"Pivot\" voxels. A voxel is pivotal if it is the ONLY voxel covering a specific silhouette pixel.\n * However, we can just work with the maximal volume. The maximal volume by definition satisfies the silhouettes\n * (problem statement guarantees a solution exists).\n * Using subsets is risky unless we carefully check constraints.\n * Strategy: Just decompose V1_max and V2_max directly. This ensures valid silhouettes (since V_max is valid).\n * We might try to \"shave\" non-essential voxels later to increase matching probability, but maximizing overlap is key.\n * \n * 3. Matching Phase:\n * We want to decompose V1_max into {A_i} and V2_max into {B_j} such that we can map sets of A_i to B_j.\n * Actually, it's finding common sub-objects.\n * \n * Try multiple relative orientations (24 rotations * shifts) between V1 and V2 to maximize overlap?\n * D is small, but shifts are D*D*D. O(24 * D^3) is small enough.\n * \n * Let's fix V1. Rotate V2 to V2'. Shift V2' to maximize intersection with V1.\n * Let Intersection I = V1 AND V2'.\n * The connected components of I can be candidate shared blocks.\n * However, a connected component in I might be disconnected in V2's original frame? No, connectivity is preserved by rigid transform.\n * \n * Steps:\n * - Iterate through all 24 rotations of V2.\n * - For each rotation, try all reasonable shifts (offsets) to overlay V2 onto V1.\n * - Compute Intersection volume. Pick the transform that maximizes Intersection volume.\n * - Let best intersection be I_best.\n * - Decompose I_best into connected components. These are the shared blocks.\n * - Residual R1 = V1 \\ I_best. Residual R2 = V2 \\ (InverseTransform(I_best)).\n * - Decompose R1 into chunks (these contribute to penalty r_2).\n * - Decompose R2 into chunks (these contribute to penalty r_1).\n * \n * Optimization:\n * Usually, one global transform isn't enough. We might need multiple blocks with *different* relative transforms.\n * \n * Iterative Greedy:\n * 1. Current volumes current_V1, current_V2.\n * 2. Search for a block shape B that fits in current_V1 and (rotated/shifted) current_V2.\n * Maximize volume(B).\n * To make this fast: \n * - Pick a random rotation `rot` and shift `d`.\n * - Intersect current_V1 and T(current_V2).\n * - Find connected components.\n * - Pick the largest one.\n * 3. Commit this block. Remove from current_V1 and current_V2.\n * 4. Repeat until no good shared blocks found.\n * 5. Dump remaining as individual 1x1x1 blocks (or greedily merged 1x1x1s) specific to V1 or V2.\n * \n * 5. Data Structures:\n * - Voxel grids: bitset or 3D bool array. D=14 -> 2744. Fast.\n * - Rotations: Precompute 24 rotation matrices.\n * \n * 6. Refinement on \"Remaining\":\n * Simply decomposing the remainder into 1x1x1 is bad for the score term sum(1/v).\n * We should merge adjacent residuals into larger blocks even if they are not shared.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_D = 14;\nconst double TIME_LIMIT = 5.8; // seconds\n\n// Types\nstruct Point {\n int x, y, z;\n bool operator==(const Point& other) const { return x == x && y == other.y && z == other.z; }\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n if (y != other.y) return y < other.y;\n return z < other.z;\n }\n Point operator+(const Point& other) const { return {x + other.x, y + other.y, z + other.z}; }\n Point operator-(const Point& other) const { return {x - other.x, y - other.y, z - other.z}; }\n};\n\nstruct Block {\n int id;\n vector cells; // Coordinates relative to the block's local origin (usually first cell)\n int volume() const { return cells.size(); }\n};\n\nstruct Placement {\n int block_id;\n int cells_idx; // Index into block list\n // The position in the global grid is derived. \n // We store the actual occupied cells in the global grid for convenience during construction.\n vector global_cells; \n};\n\n// Global Input\nint D;\nvector f1_in, r1_in, f2_in, r2_in;\n\n// 3D Grid Helper\nbool in_bounds(int x, int y, int z) {\n return x >= 0 && x < D && y >= 0 && y < D && z >= 0 && z < D;\n}\n\nbool in_bounds(Point p) {\n return in_bounds(p.x, p.y, p.z);\n}\n\n// Rotation Logic\n// 24 rotations. A rotation maps (x, y, z) -> (x', y', z')\n// We can represent rotation as a matrix or a permutation + sign change.\n// Standard axis permutations: \n// x maps to +/- x, +/- y, +/- z\n// y maps to ...\n// z maps to ...\n// Determinant must be 1 (no reflection).\nstruct Trans {\n int mx[3][3]; // Matrix\n Point apply(Point p) const {\n return {\n mx[0][0]*p.x + mx[0][1]*p.y + mx[0][2]*p.z,\n mx[1][0]*p.x + mx[1][1]*p.y + mx[1][2]*p.z,\n mx[2][0]*p.x + mx[2][1]*p.y + mx[2][2]*p.z\n };\n }\n};\n\nvector rotations;\n\nvoid init_rotations() {\n // Generate all 24 rotations\n // Basis vectors: (1,0,0), (0,1,0), (0,0,1)\n // Map them to signed basis vectors.\n int basis[3][3] = {{1,0,0}, {0,1,0}, {0,0,1}};\n \n // Try mapping x-axis to one of 6 directions\n // Try mapping y-axis to one of 4 remaining orthogonal directions\n // z-axis is fixed by cross product\n \n vector dirs = {\n {1,0,0}, {-1,0,0}, {0,1,0}, {0,-1,0}, {0,0,1}, {0,0,-1}\n };\n\n for(auto& dx : dirs) {\n for(auto& dy : dirs) {\n if (dx.x == dy.x && dx.y == dy.y && dx.z == dy.z) continue;\n if (dx.x == -dy.x && dx.y == -dy.y && dx.z == -dy.z) continue;\n if (dx.x*dy.x + dx.y*dy.y + dx.z*dy.z != 0) continue; // Must be orthogonal\n\n // Cross product for dz\n Point dz = {\n dx.y*dy.z - dx.z*dy.y,\n dx.z*dy.x - dx.x*dy.z,\n dx.x*dy.y - dx.y*dy.x\n };\n\n Trans t;\n t.mx[0][0] = dx.x; t.mx[0][1] = dy.x; t.mx[0][2] = dz.x;\n t.mx[1][0] = dx.y; t.mx[1][1] = dy.y; t.mx[1][2] = dz.y;\n t.mx[2][0] = dx.z; t.mx[2][1] = dy.z; t.mx[2][2] = dz.z;\n rotations.push_back(t);\n }\n }\n}\n\n// Grid state\nstruct Grid {\n int data[MAX_D][MAX_D][MAX_D]; // 0: empty, 1: occupied (initially), 2: used\n int count;\n \n Grid() { \n memset(data, 0, sizeof(data)); \n count = 0;\n }\n\n void set(int x, int y, int z, int val) {\n data[x][y][z] = val;\n }\n \n int get(int x, int y, int z) const {\n return data[x][y][z];\n }\n};\n\n// Initialize maximal grids\nGrid init_grid(const vector& f, const vector& r) {\n Grid g;\n for(int z=0; z> find_components(const vector& points) {\n if (points.empty()) return {};\n \n set pset(points.begin(), points.end());\n vector> components;\n \n while(!pset.empty()) {\n vector comp;\n Point start = *pset.begin();\n pset.erase(pset.begin());\n comp.push_back(start);\n \n vector q;\n q.push_back(start);\n \n int head = 0;\n while(head < q.size()){\n Point curr = q[head++];\n \n // Neighbors\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n \n for(int k=0; k<6; ++k) {\n Point nxt = {curr.x + dx[k], curr.y + dy[k], curr.z + dz[k]};\n if (pset.count(nxt)) {\n pset.erase(nxt);\n comp.push_back(nxt);\n q.push_back(nxt);\n }\n }\n }\n components.push_back(comp);\n }\n return components;\n}\n\n// Final Result Structures\nstruct ResultBlock {\n int id;\n vector shape_cells; // normalized shape\n vector cells1; // position in grid 1 (if used)\n vector cells2; // position in grid 2 (if used)\n bool used1 = false;\n bool used2 = false;\n};\n\nvector final_blocks;\nint grid1_map[MAX_D][MAX_D][MAX_D];\nint grid2_map[MAX_D][MAX_D][MAX_D];\n\n// Timer\nauto start_time = chrono::high_resolution_clock::now();\ndouble get_time() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n init_rotations();\n\n cin >> D;\n f1_in.resize(D); r1_in.resize(D);\n f2_in.resize(D); r2_in.resize(D);\n\n for(int i=0; i> f1_in[i];\n for(int i=0; i> r1_in[i];\n for(int i=0; i> f2_in[i];\n for(int i=0; i> r2_in[i];\n\n // 1. Construct maximal grids\n Grid G1 = init_grid(f1_in, r1_in);\n Grid G2 = init_grid(f2_in, r2_in);\n\n // We will mark used cells in G1/G2 with 0. Initially they are 1.\n // Let's keep a copy or just modify directly?\n // We need to output n, then grid1 IDs, then grid2 IDs.\n \n // Strategy: Randomized Greedy Common Substructure Mining\n // While time permits or grids not empty:\n // Pick a random rotation R and offset S.\n // Compute intersection of G1 and (G2 transformed by R, S).\n // Find largest connected component in intersection.\n // If size > threshold (maybe adaptive):\n // Create block B.\n // Mark cells covered in G1 as used.\n // Mark cells covered in G2 as used.\n // Add B to list.\n \n // After time limit or no big blocks:\n // Decompose remaining G1 into blocks.\n // Decompose remaining G2 into blocks.\n // Note: These residuals are ideally large connected chunks too.\n \n // To optimize score: round(10^9 * (r1 + r2 + sum(1/v)))\n // We want r1=0, r2=0 (all blocks shared).\n // If we have residuals, they increase r1/r2.\n // Specifically:\n // Used in both: adds 1/v to score cost.\n // Used in 1 only: adds v (to r2) + 1/v.\n // Used in 2 only: adds v (to r1) + 1/v.\n // Since v >= 1, v is much larger than 1/v. \n // Priority: SHARE EVERYTHING.\n \n // State\n // Current available cells in G1: V1\n // Current available cells in G2: V2\n // We want to decompose V1 into {b1_i} and V2 into {b2_j} such that they are isomorphic.\n \n // Since we can't match perfectly, we greedily find large matches.\n \n vector v1_points, v2_points;\n for(int x=0; x current_p1, current_p2;\n for(int x=0; x best_shape; // In G1 coordinates\n vector best_shape_in_g2; \n \n // Number of trials depends on remaining time and size\n int trials = 50; \n if (current_p1.size() < 20 || current_p2.size() < 20) trials = 200; // try harder when small\n \n // Optimization: Instead of full grid check, pick a random point in G1 and a random point in G2, \n // pick a random rotation, align these points, and check overlap growth.\n \n for(int t=0; t TIME_LIMIT * 0.9) break;\n\n // Pick random seed points\n int idx1 = rand() % current_p1.size();\n int idx2 = rand() % current_p2.size();\n Point p1 = current_p1[idx1];\n Point p2 = current_p2[idx2];\n\n // Pick random rotation\n int r_idx = rand() % 24;\n const Trans& R = rotations[r_idx];\n\n // Calculate shift\n // We want R(p_local) + shift = p2\n // Assume p1 is the origin of the shape in frame 1.\n // So shape_1 point q maps to R(q - p1) + p2 in frame 2.\n // Wait, simpler: \n // G1 coords: X. G2 coords: Y.\n // We map X -> Y via Y = R(X) + S.\n // If we align p1 to p2: p2 = R(p1) + S => S = p2 - R(p1).\n \n Point rp1 = R.apply(p1);\n Point S = p2 - rp1;\n\n // Now compute intersection size\n // We can iterate over all G1 points, transform, check if in G2\n // Optimization: BFS from p1 to find connected component in intersection\n vector component;\n vector q_bfs;\n set visited;\n \n // We check connectivity in G1.\n // For a point to be in component, it must be in G1, unvisited, and its map must be in G2.\n \n if (!is_used1(p1) && in_bounds(p1)) { // Should be true\n // Check p2 logic again? p2 is in G2.\n // Y = R(p1) + S = R(p1) + p2 - R(p1) = p2. Correct.\n q_bfs.push_back(p1);\n visited.insert(p1);\n }\n \n int head = 0;\n vector current_candidate;\n \n while(head < q_bfs.size()) {\n Point curr = q_bfs[head++];\n current_candidate.push_back(curr);\n \n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n \n for(int k=0; k<6; ++k) {\n Point nxt = {curr.x + dx[k], curr.y + dy[k], curr.z + dz[k]};\n if (in_bounds(nxt) && !is_used1(nxt) && visited.find(nxt) == visited.end()) {\n Point mapped = R.apply(nxt) + S;\n if (in_bounds(mapped) && !is_used2(mapped)) {\n visited.insert(nxt);\n q_bfs.push_back(nxt);\n }\n }\n }\n }\n\n if (current_candidate.size() > best_vol) {\n best_vol = current_candidate.size();\n best_shape = current_candidate;\n \n best_shape_in_g2.clear();\n for(auto& p : best_shape) {\n best_shape_in_g2.push_back(R.apply(p) + S);\n }\n }\n }\n\n // If we found a block, commit it\n if (best_vol > 0) {\n ResultBlock rb;\n rb.id = block_counter++;\n rb.cells1 = best_shape;\n rb.cells2 = best_shape_in_g2;\n rb.used1 = true;\n rb.used2 = true;\n \n // Normalize shape (relative to 0,0,0)\n // This is just for internal consistency if needed, but we store absolute positions.\n // Output format doesn't need shape definition, just IDs in grid.\n \n for(auto& p : best_shape) set_used1(p);\n for(auto& p : best_shape_in_g2) set_used2(p);\n \n final_blocks.push_back(rb);\n } else {\n // Can't match anything? Break to clean up.\n break;\n }\n }\n\n // Phase 2: Clean up residuals\n // Remaining cells in G1 must be formed into blocks (used only in G1).\n // Ideally connected.\n vector rem1;\n for(int x=0; x> comps1 = find_components(rem1);\n for(auto& comp : comps1) {\n ResultBlock rb;\n rb.id = block_counter++;\n rb.cells1 = comp;\n rb.used1 = true;\n rb.used2 = false; // Not used in 2\n final_blocks.push_back(rb);\n }\n }\n\n vector rem2;\n for(int x=0; x> comps2 = find_components(rem2);\n for(auto& comp : comps2) {\n ResultBlock rb;\n rb.id = block_counter++;\n rb.cells2 = comp;\n rb.used1 = false; // Not used in 1\n rb.used2 = true;\n final_blocks.push_back(rb);\n }\n }\n \n // Generate Output\n // Fill maps\n memset(grid1_map, 0, sizeof(grid1_map));\n memset(grid2_map, 0, sizeof(grid2_map));\n \n for(const auto& b : final_blocks) {\n if(b.used1) {\n for(auto& p : b.cells1) grid1_map[p.x][p.y][p.z] = b.id;\n }\n if(b.used2) {\n for(auto& p : b.cells2) grid2_map[p.x][p.y][p.z] = b.id;\n }\n }\n\n // Output\n cout << final_blocks.size() << \"\\n\";\n \n // Grid 1\n for(int x=0; x 0$ to the root. This is a Steiner Tree problem.\n * Since N is small (100), we can approximate the Steiner Tree cost using a Minimum Spanning Tree on the subset\n * of active nodes, or simply by the union of shortest paths from root to each active node (Dijkstra).\n *\n * Phase B: Local Search / Optimization\n * - Start with a solution where all residents are assigned to their nearest station.\n * - Try to \"move\" residents from one station to another.\n * - Moving a resident might increase the $P$ of the new station but decrease the $P$ of the old one.\n * - It might also change the set of active stations, affecting edge costs.\n * - Try to \"deactivate\" a station by moving all its residents to other nearby stations. This saves the edge connection cost\n * but likely increases coverage costs ($\\sum P^2$).\n *\n * Phase C: Edge Pruning\n * - Once the set of required stations (with $P_i > 0$) is fixed, we need the minimum cost subgraph connecting them to root.\n * - We can use a heuristic Steiner Tree algorithm:\n * 1. Start with all edges in the shortest path tree from root to all required nodes.\n * 2. Greedily remove redundant edges if connectivity is maintained.\n * 3. Or, construct a Metric Closure on required nodes and run MST, then map back to original graph edges (Standard Steiner Tree approx).\n * Given N=100, a simpler approach is: Compute Dijkstra from root. For every required node, trace back parents. Union these edges.\n * Then try to run a Randomized Kruskal's or Prim's restricted to the nodes involved to see if we can find cheaper paths.\n *\n * 4. Refined Approach for Contest:\n * - The coordinate range is [-10000, 10000]. N=100, K=2000-5000.\n * - $P_i \\le 5000$.\n * - Since we must cover ALL residents (to get a non-trivial score), we focus on minimizing cost for full coverage.\n * \n * Algorithm:\n * 1. Calculate distance matrix `dist_mat[k][i]` (resident k to station i).\n * 2. Initial State:\n * - For each resident, find the station with minimal `dist_mat[k][i]`. Let's call this `nearest[k]`.\n * - Initially, active stations are those that are `nearest` for at least one resident.\n * - $P_i = \\max ( \\text{dist}(k, i) )$ for all $k$ assigned to $i$.\n * - Calculate edge cost to connect these stations.\n *\n * 3. Optimization (Hill Climbing / Simulated Annealing):\n * - State: Assignment of each resident to a station.\n * - Neighbor Move 1: Change assignment of resident $k$ from station $u$ to station $v$ (where $v$ is close to $k$).\n * - Neighbor Move 2: Turn off a leaf station in the current tree if its residents can be cheaply covered by neighbors.\n * \n * Evaluating the cost of a state is expensive (Steiner Tree). We need a proxy or fast update.\n * Fast Steiner Tree approximation:\n * - Maintain the set of \"active\" stations (those with assigned residents).\n * - Cost = MST of (Active Stations + Root + Steiner Points?). Actually, just taking the union of Shortest Paths from Root is a good upper bound.\n * - Better: Precompute all-pairs shortest paths (Floyd-Warshall or N Dijkstra). The cost to add a node $u$ to an existing tree $T$ is $\\min_{v \\in T} \\text{dist}_{graph}(u, v)$.\n * - Let's stick to: Cost = $\\sum P_i^2 + \\text{SteinerTreeCost}(\\text{ActiveNodes})$.\n *\n * 4. Specific heuristic for \"Broadcasting\":\n * - Often it's better to have a few powerful stations than many weak ones, because edge costs are high?\n * - Or maybe edge costs are low? $100 D \\le w \\le 2500 D$. $P^2$ grows fast.\n * - Let's check magnitudes. Max distance ~20000. $P \\le 5000$. $P^2$ can be $25 \\times 10^6$.\n * - Edge weights: Distance 1000 -> $w \\approx 10^5 \\dots 2.5 \\times 10^6$.\n * - So turning on an edge costs roughly $(300 \\dots 500)^2$ in terms of power.\n * - It suggests we should aggregate residents to stations to avoid long cable runs, but $P^2$ penalty discourages huge radii.\n * - Balance is key.\n *\n * 5. Implementation Details:\n * - Precompute APSP (All-Pairs Shortest Paths) on the graph (only 100 nodes).\n * - State Representation: `P[i]` array.\n * - We don't need to store resident assignment explicitly in the state for local search if we define state by \"active stations and their powers\".\n * - Actually, let's define state by the boolean vector of \"Used Edges\" and integer vector \"P\".\n * - But the search space is too big.\n * - Back to: State = { active_stations }.\n * - Residents are assigned to the active station that covers them with minimal $P_i$ increase? No, residents are simply covered if dist <= P.\n * - Let's iterate on P.\n * \n * Let's try a \"Power Optimization\" approach.\n * 1. Start with all P=0.\n * 2. Identify uncovered residents.\n * 3. Pick a resident. Find cheapest way to cover it:\n * - Increase P of an already connected station. Cost: $(P_{new}^2 - P_{old}^2)$.\n * - Connect a new station and set its P. Cost: Path_to_root + $P_{new}^2$.\n * \n * This looks like a greedy construction. Let's do a randomized greedy or beam search.\n * \n * Refined Algorithm:\n * 1. Compute APSP between all nodes $u, v$. Store path reconstruction info.\n * 2. K-Means like clustering? No, the graph structure is fixed.\n * 3. Attempt: Randomized Greedy with Decay.\n * - Initially, tree contains only root (Station 1).\n * - While uncovered residents exist:\n * - Select a subset of uncovered residents (or one).\n * - Try to cover them by:\n * a) Increasing P of a node in current tree.\n * b) Extending the tree to a new node $v$ and setting $P_v$ to cover.\n * - Pick the option with best (Cost Increase / Residents Covered) ratio.\n * 4. Post-process: Prune edges. Prune powers.\n * - Iterate nodes $u$: try reducing $P_u$. If some residents become uncovered, can they be covered by neighbors cheaply?\n * - Re-calculate MST/Steiner Tree for the set of nodes with $P > 0$.\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Types ---\nusing ll = long long;\nconst ll INF_LL = 1e18;\nconst int MAX_P = 5000;\n\nstruct Point {\n int x, y;\n};\n\nstruct Edge {\n int u, v, w, id;\n};\n\nstruct Resident {\n int x, y, id;\n};\n\n// --- Global Inputs ---\nint N, M, K;\nvector stations;\nvector edges;\nvector residents;\nvector>> adj; // u -> {v, weight}\n\n// --- Precomputed Data ---\n// dist_residents[k][i] = squared euclidean distance from resident k to station i\n// We store squared distance to avoid sqrt until necessary, but P is linear radius.\n// Problem says P_i >= dist. So P_i^2 >= dist^2.\n// Wait, problem says \"circular region of radius P_i\". So coverage: dist_eucl(k, i) <= P_i.\n// Which is dist_sq(k, i) <= P_i^2.\nvector> dist_sq_residents; \n\n// Graph shortest paths (weights)\nvector> graph_dist; \n// Next hop for reconstruction\nvector> graph_next_hop; \n\n// --- Utility Functions ---\n\nint dist_sq(const Point& p1, const Point& p2) {\n return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);\n}\n\nint dist_sq(const Resident& r, const Point& p) {\n return (r.x - p.x) * (r.x - p.x) + (r.y - p.y) * (r.y - p.y);\n}\n\n// Standard Dijkstras for APSP on small N=100\nvoid precompute_apsp() {\n graph_dist.assign(N + 1, vector(N + 1, INF_LL));\n graph_next_hop.assign(N + 1, vector(N + 1, -1));\n\n for (int i = 1; i <= N; ++i) {\n graph_dist[i][i] = 0;\n priority_queue, vector>, greater>> pq;\n pq.push({0, i});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d > graph_dist[i][u]) continue;\n\n for (auto& edge : adj[u]) {\n int v = edge.first;\n int w = edge.second;\n if (graph_dist[i][u] + w < graph_dist[i][v]) {\n graph_dist[i][v] = graph_dist[i][u] + w;\n // To reconstruct path i -> ... -> v, we want the predecessor of v?\n // Or simply storing distances is enough for Steiner approximation, \n // and we reconstruct tree explicitly later.\n // Let's store nothing for next_hop for now, simple Dijkstra is enough.\n pq.push({graph_dist[i][v], v});\n }\n }\n }\n }\n}\n\n// --- Solution Representation ---\nstruct Solution {\n vector P;\n vector edge_on;\n ll score;\n\n Solution() : P(N + 1, 0), edge_on(M, false), score(INF_LL) {}\n};\n\n// --- Logic to build edge set from Active Nodes ---\n// Given a set of nodes with P > 0, construct a low-cost tree connecting them to root (1).\n// We use a simple heuristic: Steiner Tree approx using MST on metric closure or just union of shortest paths.\n// Since N is small, we can be greedy:\n// Start with component {1}.\n// Iteratively add the closest required node to the current component.\npair> build_connectivity(const vector& P_vals) {\n vector is_active(N + 1, false);\n vector active_nodes;\n active_nodes.push_back(1);\n for (int i = 2; i <= N; ++i) {\n if (P_vals[i] > 0) {\n is_active[i] = true;\n active_nodes.push_back(i);\n }\n }\n\n // Prim-like algorithm to connect all active_nodes\n // But we are operating on the original graph.\n // We want to connect all `active_nodes` to the component containing `1`.\n // Actually, this is exactly the Steiner Tree problem.\n // Heuristic:\n // Set C = {1}. Set R = {active_nodes} \\ {1}.\n // While R is not empty:\n // Find u in C, v in R minimizing dist(u, v).\n // Add path u-v to the tree edges.\n // Add all nodes on path u-v to C. Remove v from R.\n \n // This works well.\n vector in_component(N + 1, false);\n in_component[1] = true;\n \n // We need to keep track of which edges are used\n vector used_edges(M, false);\n ll edges_cost = 0;\n\n // To efficiently find closest, we can just iterate. N is small.\n int num_connected = 1;\n int target_count = active_nodes.size(); \n \n // Since active_nodes includes 1, size is correct.\n // If only 1 is active, we are done.\n if (target_count <= 1) return {0, used_edges};\n\n // Optimization: track min dist from component to each node\n vector min_dist_to_comp(N + 1, INF_LL);\n vector parent_in_comp(N + 1, -1); // which node in comp is closest\n \n // Initialize with node 1\n for(int i=1; i<=N; ++i) {\n min_dist_to_comp[i] = graph_dist[1][i];\n parent_in_comp[i] = 1;\n }\n\n int remain = target_count - 1;\n \n // Which nodes from R are still not in C?\n vector covered(N + 1, false); // covered means in component\n covered[1] = true;\n\n // Keep adding until all required nodes are covered\n while(remain > 0) {\n int best_node = -1;\n ll best_val = INF_LL;\n\n // Find closest required node not yet covered\n for (int i : active_nodes) {\n if (!covered[i]) {\n if (min_dist_to_comp[i] < best_val) {\n best_val = min_dist_to_comp[i];\n best_node = i;\n }\n }\n }\n\n if (best_node == -1) break; // Should not happen if connected\n\n // Add path from best_node to parent_in_comp[best_node]\n int curr = best_node;\n int target = parent_in_comp[best_node];\n \n // Reconstruct path using a simple BFS/Dijkstra or just run Dijkstra again restricted to search?\n // We precomputed distances but not predecessors.\n // Let's run a quick search to find the actual path from `target` to `curr` (or vice versa)\n // and mark edges.\n // Since we need to mark edges on the path and add nodes to component.\n \n // Find path from `target` (in comp) to `curr` (outside) with length `best_val`.\n // Wait, graph_dist stores shortest path length. We need the actual path.\n // We can recover it step by step.\n \n int u = target;\n int v = curr;\n // Reconstruct path from u to v\n // Backward reconstruction from v to u using distances\n int temp_curr = v;\n while (temp_curr != u) {\n covered[temp_curr] = true;\n \n // Find neighbor w that satisfies dist(u, w) + weight(w, temp_curr) == dist(u, temp_curr)\n // AND dist(u, temp_curr) should match the optimal distance segment?\n // Actually, simply: dist(u, temp_curr) == dist(u, w) + weight.\n // Be careful: min_dist_to_comp[i] is dist from some node in comp.\n // `best_val` is exactly graph_dist[target][curr].\n \n bool found = false;\n for (auto& edge : adj[temp_curr]) {\n int neighbor = edge.first;\n int w_idx = edge.second; // weight\n // Identify edge index\n // We need edge index from input.\n // Let's store edge index in adj.\n // Done: struct Edge has id. adj needs to store id too? \n // Let's scan edges or update adj.\n // Updating adj to store {v, weight, id} is better.\n }\n \n // Let's update ADJ structure first to support this efficiently\n break; // Placeholder\n }\n \n // Since reconstructing path is annoying without predecessors, let's do a slightly different greedy:\n // Prim's algorithm on the graph of *all* nodes, but we only care about connecting `active_nodes`.\n // Actually, standard \"Union of Shortest Paths\" is a decent heuristic.\n // Let's refine the \"Add closest required node\" strategy.\n // When we add `best_node`, we trace the shortest path from `best_node` to `parent_in_comp[best_node]`.\n // All edges on this path are added. All nodes on this path are added to the component.\n // We update min_dist_to_comp for all remaining nodes using the newly added nodes.\n \n // RE-IMPLEMENTATION INSIDE LOOP:\n // 1. Reconstruct path from `target` to `curr`.\n // Since we know dist[target][curr], we pick neighbor `next` of `curr` such that \n // dist[target][next] + weight(next, curr) == dist[target][curr].\n // Add edge (next, curr).\n // Move curr to next. Repeat until curr == target.\n // 2. For each node `x` on this path (including original `curr`):\n // If `x` was required and not covered, decrement remain.\n // Mark `x` as covered.\n // Update `min_dist_to_comp` for all other nodes using `x` as source.\n \n vector path_nodes;\n temp_curr = v;\n while (temp_curr != u) {\n path_nodes.push_back(temp_curr);\n int best_next = -1;\n int best_edge_id = -1;\n \n for (const auto& e : edges) {\n int neighbor = -1;\n if (e.u == temp_curr) neighbor = e.v;\n else if (e.v == temp_curr) neighbor = e.u;\n \n if (neighbor != -1) {\n if (abs(graph_dist[u][neighbor] + e.w - graph_dist[u][temp_curr]) < 1e-9) { // integer arithmetic though\n if (graph_dist[u][neighbor] + e.w == graph_dist[u][temp_curr]) {\n best_next = neighbor;\n best_edge_id = e.id;\n break; \n }\n }\n }\n }\n \n // Add edge\n if (!used_edges[best_edge_id]) {\n used_edges[best_edge_id] = true;\n edges_cost += edges[best_edge_id].w;\n }\n temp_curr = best_next;\n }\n path_nodes.push_back(u); // Add target (already covered but useful for updates)\n \n // Process new nodes in component\n for (int newly_added : path_nodes) {\n // If this node was a required node and not counted yet\n // (Check logic: `covered` tracks if it's in component. \n // `is_active` tracks if it's required.\n // We need to decrement remain if `is_active[newly_added]` was true and `covered` was false BEFORE this loop?\n // No, let's just track strictly.)\n \n if (!covered[newly_added]) {\n covered[newly_added] = true;\n if (is_active[newly_added]) {\n remain--;\n }\n \n // Update distances\n for (int i = 1; i <= N; ++i) {\n if (!covered[i]) {\n ll d = graph_dist[newly_added][i]; // Precomputed APSP\n if (d < min_dist_to_comp[i]) {\n min_dist_to_comp[i] = d;\n parent_in_comp[i] = newly_added;\n }\n }\n }\n } else {\n // Even if covered, if we just 'reached' it via path reconstruction, \n // we don't need to do anything because it's already a source for distances.\n // However, strictly speaking, path reconstruction goes backwards from `curr` (outside) to `target` (inside).\n // `curr` is new. `target` is old. Intermediate nodes are new.\n // We should iterate path nodes in any order to update.\n }\n }\n // Since we iterate path_nodes, we might process `u` again. `covered[u]` is true, so no update triggered. Correct.\n // But wait, path_nodes includes `v` (curr) which was NOT covered.\n // Correct.\n }\n \n return {edges_cost, used_edges};\n}\n\n// --- Main Solver Class ---\n\nclass Solver {\npublic:\n void solve() {\n // 1. Read Input\n cin >> N >> M >> K;\n stations.resize(N + 1);\n for (int i = 1; i <= N; ++i) cin >> stations[i].x >> stations[i].y;\n \n adj.resize(N + 1);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n edges.push_back({u, v, w, i});\n adj[u].push_back({v, w}); // ID needed?\n adj[v].push_back({u, w});\n }\n \n residents.resize(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].x >> residents[i].y;\n residents[i].id = i;\n }\n\n // 2. Precompute\n precompute_apsp();\n dist_sq_residents.assign(K, vector(N + 1));\n for (int k = 0; k < K; ++k) {\n for (int i = 1; i <= N; ++i) {\n dist_sq_residents[k][i] = dist_sq(residents[k], stations[i]);\n }\n }\n\n // 3. Initial Solution: Closest Station\n // Assign each resident to the closest station.\n vector assignment(K);\n vector P(N + 1, 0);\n \n for (int k = 0; k < K; ++k) {\n int best_i = -1;\n int best_d = 2e9; // large enough\n for (int i = 1; i <= N; ++i) {\n if (dist_sq_residents[k][i] < best_d) {\n best_d = dist_sq_residents[k][i];\n best_i = i;\n }\n }\n assignment[k] = best_i;\n int needed_P = (int)ceil(sqrt(best_d));\n if (needed_P > P[best_i]) P[best_i] = needed_P;\n }\n \n // Build connectivity for initial solution\n auto [edge_cost, edge_mask] = build_connectivity(P);\n \n ll current_p_cost = 0;\n for(int p : P) current_p_cost += (ll)p * p;\n \n ll best_score = current_p_cost + edge_cost;\n vector best_P = P;\n vector best_edge_mask = edge_mask;\n\n // 4. Optimization Loop\n // We will use Hill Climbing / Simulated Annealing\n // Moves:\n // 1. Move a resident to a different station (one of the K-nearest stations).\n // 2. Pick a station, set P=0 (force drop), reassign its residents to nearest active stations.\n \n // Since evaluating full cost is expensive (Steiner Tree), we do it carefully.\n // Randomized Local Search\n \n auto start_time = chrono::steady_clock::now();\n double time_limit = 1.85; \n \n mt19937 rng(12345);\n\n while (true) {\n auto curr_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(curr_time - start_time).count();\n if (elapsed > time_limit) break;\n\n // Strategy:\n // Randomly pick a station `u` that is active.\n // Try to reduce its power or turn it off completely.\n // Or pick a resident and move it.\n \n // Let's implement \"Move Resident\"\n int k = uniform_int_distribution(0, K - 1)(rng);\n int old_station = assignment[k];\n \n // Pick a new station for this resident\n // Prefer stations that are already active or close\n int new_station = uniform_int_distribution(1, N)(rng);\n \n if (new_station == old_station) continue;\n \n // Backup state\n int old_P_u = P[old_station];\n int old_P_v = P[new_station];\n \n // Apply change\n assignment[k] = new_station;\n \n // Recompute P for old_station and new_station\n // This is O(K) effectively if we scan all residents, can be optimized by maintaining lists\n // Since K is up to 5000 and we have 1.8s, O(K) per iteration is okay if iteration count is not huge.\n // Better: maintain `vector> station_residents`.\n \n // Let's optimize `P` update\n // We need to find max dist for old_station after removal\n // and max dist for new_station after addition.\n \n // Lazy check: just recompute P for these two stations\n // (To do this fast, we need to know which residents are assigned to them)\n // Let's keep assignment vector.\n \n // Actually, recomputing P for old_station requires scanning all its residents.\n // Let's do the scan. It's not too slow.\n \n auto recalc_P = [&](int station_idx) {\n int max_d_sq = 0;\n // We iterate all K? Slow.\n // We should maintain reverse mapping.\n // But for a simple contest submission, let's try full K scan first, if TLE, optimize.\n // With K=5000, 10^5 ops/sec => 10^5 * K = 5*10^8 ops. Too slow for 2 sec.\n // We MUST maintain reverse lists.\n return 0; \n };\n \n // We can't afford O(K) per move inside the loop.\n // Let's change strategy:\n // Perturb the *Power Vector P* directly?\n // No, P depends on assignment.\n // Let's maintain `vector> residents_of_station(N+1)`.\n }\n \n // RESTARTING OPTIMIZATION WITH BETTER DATA STRUCTURES\n vector> residents_of(N + 1);\n for(int k=0; k(curr_time - start_time).count();\n if (elapsed > time_limit) break;\n }\n \n // MOVES\n // 1. Transfer resident k from u to v.\n // 2. Merge: Move all residents from u to v (if v is close).\n \n int type = uniform_int_distribution(0, 10)(rng);\n \n if (type < 6) { // Single resident move\n int k = uniform_int_distribution(0, K - 1)(rng);\n int u = assignment[k];\n // Pick v: prioritize active nodes or close nodes\n int v;\n if (uniform_int_distribution(0, 1)(rng)) {\n // Pick completely random\n v = uniform_int_distribution(1, N)(rng);\n } else {\n // Pick one of the active nodes (P > 0)\n vector actives;\n for(int i=1; i<=N; ++i) if(P[i] > 0) actives.push_back(i);\n if (actives.empty()) v = 1; // Should not happen\n else v = actives[uniform_int_distribution(0, actives.size()-1)(rng)];\n }\n \n if (u == v) continue;\n \n // Check if new P is within bounds\n int dist_k_v = dist_sq_residents[k][v];\n if (dist_k_v > 5000 * 5000) continue; // Too far\n \n // Calculate cost delta\n // Change in P_u^2 + P_v^2\n // P_v will be max(current_P_v, dist_k_v_sqrt)\n // P_u might decrease.\n \n int old_Pu = P[u];\n int old_Pv = P[v];\n \n // Tentative new P_v\n int new_Pv = max(old_Pv, (int)ceil(sqrt(dist_k_v)));\n \n // Tentative new P_u\n // We need to find max dist in residents_of[u] excluding k\n int new_Pu = 0;\n // Optimization: if k was not defining the max radius, P_u doesn't change.\n // If k was defining it, we need to scan.\n // Scan residents_of[u] is O(|Res_u|). On average K/N ~ 50. Fast enough.\n bool u_needs_recalc = false;\n if ((int)ceil(sqrt(dist_sq_residents[k][u])) == old_Pu) {\n u_needs_recalc = true;\n }\n \n if (!u_needs_recalc) {\n new_Pu = old_Pu;\n } else {\n int max_d = 0;\n for (int r : residents_of[u]) {\n if (r == k) continue;\n max_d = max(max_d, dist_sq_residents[r][u]);\n }\n new_Pu = (int)ceil(sqrt(max_d));\n }\n \n ll p_cost_delta = ((ll)new_Pu * new_Pu + (ll)new_Pv * new_Pv) - ((ll)old_Pu * old_Pu + (ll)old_Pv * old_Pv);\n \n // Edge cost delta?\n // This is expensive. We estimate.\n // If P_u becomes 0, we might save edge costs.\n // If P_v was 0 and becomes > 0, we might pay edge costs.\n // If both stay active/inactive state same, edge cost = 0 delta.\n \n bool u_was_active = (old_Pu > 0);\n bool u_is_active = (new_Pu > 0);\n bool v_was_active = (old_Pv > 0);\n bool v_is_active = (new_Pv > 0);\n \n // If activity status doesn't change, accept based on P cost.\n // If it changes, we need to run Steiner check.\n bool status_change = (u_was_active != u_is_active) || (v_was_active != v_is_active);\n \n // Heuristic acceptance\n if (!status_change) {\n if (p_cost_delta <= 0) {\n // Accept\n assignment[k] = v;\n P[u] = new_Pu;\n P[v] = new_Pv;\n \n // Update residents lists\n // Remove k from u\n for(size_t idx=0; idx actives;\n for(int i=1; i<=N; ++i) if(P[i] > 0 && i!=1) actives.push_back(i); // keep 1? maybe not\n if (actives.empty()) continue;\n int u = actives[uniform_int_distribution(0, actives.size()-1)(rng)];\n \n // Pick `v` close to `u`\n // Use precomputed graph dist to find nearby stations\n int v = -1;\n ll min_dist = INF_LL;\n \n // Try a few random nodes or iterate all\n for (int cand=1; cand<=N; ++cand) {\n if (cand == u) continue;\n if (graph_dist[u][cand] < min_dist) {\n min_dist = graph_dist[u][cand];\n v = cand;\n }\n }\n // Or randomly pick one nearby\n // Let's refine: pick v that is already active to encourage consolidation\n vector targets;\n for(int i=1; i<=N; ++i) if (i!=u) targets.push_back(i);\n if(targets.empty()) continue;\n v = targets[uniform_int_distribution(0, targets.size()-1)(rng)];\n\n // Try moving ALL residents of u to v\n if (residents_of[u].empty()) continue;\n \n bool feasible = true;\n int max_req_v = 0;\n for (int r : residents_of[v]) max_req_v = max(max_req_v, dist_sq_residents[r][v]);\n \n for (int r : residents_of[u]) {\n if (dist_sq_residents[r][v] > 5000*5000) {\n feasible = false; \n break;\n }\n max_req_v = max(max_req_v, dist_sq_residents[r][v]);\n }\n \n if (!feasible) continue;\n \n // Calculate costs\n int new_Pv = (int)ceil(sqrt(max_req_v));\n int new_Pu = 0;\n int old_Pv = P[v];\n int old_Pu = P[u];\n \n // Apply temp\n P[v] = new_Pv;\n P[u] = new_Pu;\n \n auto [new_edge_cost, new_mask] = build_connectivity(P);\n \n ll new_p_cost = 0;\n for(int i=1; i<=N; ++i) new_p_cost += (ll)P[i] * P[i];\n ll new_total_score = new_p_cost + new_edge_cost;\n \n if (new_total_score < best_score) {\n best_score = new_total_score;\n best_P = P;\n best_edge_mask = new_mask;\n \n // Update assignment and lists\n for(int r : residents_of[u]) {\n assignment[r] = v;\n residents_of[v].push_back(r);\n }\n residents_of[u].clear();\n } else {\n // Revert\n P[u] = old_Pu;\n P[v] = old_Pv;\n }\n }\n }\n\n // Final Check: Ensure Validity\n // We used `best_P` and `best_edge_mask` which correspond to `best_score`.\n // However, because we accepted some moves without checking edge costs (when status didn't change),\n // `best_score` might be slightly off or `best_edge_mask` might be stale relative to `best_P` if we didn't call build_connectivity.\n // Actually, in the code above:\n // 1. Single resident move, no status change: We updated `P` and `assignment`, but `best_edge_mask` is NOT updated.\n // The edge cost doesn't change, so `best_score` estimate is correct, but `best_edge_mask` is old.\n // This is fine because the SET of active nodes didn't change, so the MST is valid.\n // 2. Status change / Merge: We called build_connectivity and updated `best_edge_mask`.\n // So, `best_edge_mask` is valid for the SET of active nodes in `best_P`.\n \n // Output\n for (int i = 1; i <= N; ++i) cout << best_P[i] << (i == N ? \"\" : \" \");\n cout << endl;\n for (int i = 0; i < M; ++i) cout << (best_edge_mask[i] ? 1 : 0) << (i == M - 1 ? \"\" : \" \");\n cout << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n Solver solver;\n solver.solve();\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Standard library includes for IO and containers\nusing namespace std;\n\n// Constants\nconst int N = 30;\nconst int MAX_OPS = 10000;\n\n// Coordinate struct\nstruct Coord {\n int x, y;\n bool operator==(const Coord& other) const {\n return x == other.x && y == other.y;\n }\n bool operator!=(const Coord& other) const {\n return !(*this == other);\n }\n bool operator<(const Coord& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n};\n\n// Operation struct\nstruct Op {\n Coord p1;\n Coord p2;\n};\n\n// Global state\nint grid[N][N];\nvector operations;\n\n// Helper to get current location of a value might be slow, so we keep the grid updated.\n// But since we are picking specific values, we might need to search.\n// Given N=30, a full scan is 465 ops, which is fine.\n\n// Function to find the coordinates of a specific value\nCoord find_value(int val) {\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (grid[x][y] == val) return {x, y};\n }\n }\n return {-1, -1};\n}\n\n// Perform a swap and record it\nvoid do_swap(Coord c1, Coord c2) {\n if (c1 == c2) return;\n swap(grid[c1.x][c1.y], grid[c2.x][c2.y]);\n operations.push_back({c1, c2});\n}\n\n// Function to check if a coordinate is within bounds\nbool is_valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\n// Heuristic Solution\n// Strategy:\n// We want to satisfy the condition: ball(x, y) < ball(x+1, y) and ball(x, y) < ball(x+1, y+1).\n// This is essentially a heap property.\n// To minimize operations, we fill the pyramid from top (0,0) down.\n// For each position (x, y), we want to bring the smallest available value \n// from the sub-pyramid rooted at (x, y) to (x, y).\n// Why the sub-pyramid? Because any node in the sub-pyramid below (x,y) can act as a source \n// for (x,y) without disrupting the already established upper layers.\n// If we pick a value from outside the sub-pyramid, we might have to swap horizontally or \n// upwards into already sorted regions, which is bad.\n\nvoid solve() {\n // We iterate through the pyramid positions in a specific order.\n // Top to bottom, left to right is a natural choice.\n for (int x = 0; x < N - 1; ++x) { // The last row (x=29) doesn't have constraints below it\n for (int y = 0; y <= x; ++y) {\n \n // We need to find the best candidate to place at (x, y).\n // The condition is strictly local: grid[x][y] < grid[x+1][y] and grid[x][y] < grid[x+1][y+1].\n // However, to ensure we don't get stuck later, generally smaller numbers should be higher up.\n // The \"safest\" greedy choice is to pick the minimum value present in the \n // \"reachable cone\" below (x, y).\n // The reachable cone for (x,y) consists of all (r, c) such that\n // r >= x and we can reach (x,y) by only moving up-left or up-right.\n // Actually, any node (r, c) where r >= x and y <= c <= y + (r-x) is in the \"shadow\" of (x,y).\n // Moving a value from this shadow to (x,y) only involves swapping with parents,\n // which perfectly aligns with bubbling up.\n\n int best_val = 1000000;\n Coord best_pos = {-1, -1};\n\n // Search in the shadow cone\n for (int r = x; r < N; ++r) {\n for (int c = y; c <= y + (r - x); ++c) {\n if (grid[r][c] < best_val) {\n best_val = grid[r][c];\n best_pos = {r, c};\n }\n }\n }\n\n // If the current spot already has the best value, do nothing\n if (best_pos.x == x && best_pos.y == y) continue;\n\n // Move the best_val from best_pos to (x, y)\n // We move it upwards step by step.\n // At each step, we swap it with the parent that leads towards (x, y).\n // If we are at (cx, cy), we want to go to (x, y).\n // The parents are (cx-1, cy-1) and (cx-1, cy).\n // We need to choose the one that keeps us in the valid path to (x, y).\n \n Coord curr = best_pos;\n while (curr.x > x) {\n // We want to decrease curr.x\n // We need to decide whether to decrement y or not.\n // Target is y.\n // If curr.y > y, we can go to (curr.x-1, curr.y-1) (left parent)\n // If curr.y == y, we must go to (curr.x-1, curr.y) (right parent) \n // actually, wait. \n // Parent L: (r-1, c-1), Parent R: (r-1, c).\n // If we take Parent L, c decreases.\n // If we take Parent R, c stays same.\n \n Coord next_step;\n if (curr.y > y) {\n // We are to the right of the target column, move left-up\n next_step = {curr.x - 1, curr.y - 1};\n } else {\n // We are on the correct column (since we search in cone y <= c ...), move straight-up\n next_step = {curr.x - 1, curr.y};\n }\n \n do_swap(curr, next_step);\n curr = next_step;\n }\n }\n }\n}\n\nint main() {\n // Fast IO\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n\n // Input reading\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> grid[i][j];\n }\n }\n\n // Solve\n solve();\n\n // Output results\n cout << operations.size() << \"\\n\";\n for (const auto& op : operations) {\n cout << op.p1.x << \" \" << op.p1.y << \" \" << op.p2.x << \" \" << op.p2.y << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"/**\n * @brief Transit Warehouse Solution\n * \n * Strategy:\n * 1. Build a spanning tree that balances depth and branching factor.\n * A purely random DFS or BFS is suboptimal. We want a \"comb-like\" structure \n * or a \"long snake with small offshoots\" to allow differentiation between\n * very large values (deep in snake) and medium values (offshoots).\n * \n * 2. Assign a \"target rank\" to every cell.\n * We simulate a filling process where we always fill the deepest available node.\n * The order in which nodes are filled gives them a score from 0 to M-1.\n * Higher score = filled earlier = should hold larger values.\n * Lower score = filled later = closer to root = should hold smaller values.\n * \n * 3. Online placement:\n * For a container with value T:\n * - Calculate its percentile P among remaining unseen values.\n * - Identify currently \"placeable\" cells (leaves of the empty tree).\n * - Pick the leaf whose score is closest to the expected score for percentile P.\n * \n * 4. Retrieval:\n * Maintain a priority queue of accessible filled cells (initially just the ones adjacent to entrance).\n * Always pick the smallest value available to remove.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global configuration\nconst int D = 9;\nconst int MAX_VAL = D * D; \n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { if (r != other.r) return r < other.r; return c < other.c; }\n};\n\nint dist(Point a, Point b) {\n return abs(a.r - b.r) + abs(a.c - b.c);\n}\n\n// Directions: Up, Left, Down, Right\nconst int dr[] = {-1, 0, 1, 0};\nconst int dc[] = {0, -1, 0, 1};\n\nstruct Node {\n Point p;\n vector children_idx;\n int parent_idx = -1;\n int id; // index in the nodes array\n \n // Heuristic score: intended relative order (0 = last to be filled/root, High = first to be filled/deep)\n int fill_order_rank = -1; \n};\n\nint N_obstacles;\nvector obstacles;\nbool is_obstacle[D][D];\nbool has_container[D][D];\nint container_val[D][D]; // Value stored at r,c\n\nPoint entrance = {0, (D - 1) / 2};\nvector entrance_adj;\n\n// The tree structure\nvector nodes;\nint root_node_idx = -1;\n// Map coordinates to node index\nint grid_node_map[D][D];\n\n// Available numbers management\nbool seen_number[MAX_VAL];\n\n// Check valid coordinate\nbool in_bounds(int r, int c) {\n return r >= 0 && r < D && c >= 0 && c < D;\n}\n\n// Initialize basic grid info\nvoid init_grid() {\n for(int r=0; r usable_cells;\n for(int r=0; r q;\n vector visited(D*D, false);\n \n // Root is effectively the entrance.\n // But the entrance cannot hold items. Its neighbors can.\n // We connect entrance to its neighbors.\n \n // Let's just treat the grid as a graph.\n // We want a parent pointer for every valid storage cell towards the entrance.\n \n // Priority for DFS: prefer neighbors that have fewer free neighbors (heuristic to avoid isolating cells).\n // Or simply prefer neighbors that are \"far\" from entrance to drive the path deep? No.\n \n // Let's stick to a BFS for tree shape stability, but modify the queue to be a Deque or PriorityQueue\n // to create \"long\" branches.\n // Actually, a pure \"Snake\" (Hamiltonian path) is ideal if N=0. \n // With obstacles, it's a tree.\n \n // Let's try to build the tree by traversing \"away\" from entrance.\n // Cells: Storage cells.\n // Root: We can imagine a super-root connected to entrance neighbors.\n // Let's just pick one entrance neighbor as the primary start if possible, or all of them.\n \n // Actually, to define \"leaves\" for placement, we need the parent-child relationship.\n // Parent = Closer to entrance (in the path sense).\n // Child = Further.\n \n // BFS usually gives \"bushy\" trees (bad for sorting, good for access).\n // DFS gives \"long\" trees (good for sorting).\n // We want DFS.\n \n auto get_idx = [&](int r, int c) { return r*D + c; };\n \n // We'll build the tree explicitly.\n // Start DFS from all entrance neighbors.\n \n vector dfs_stack;\n // We shuffle entrance neighbors to add randomness\n vector seeds;\n for(auto p : entrance_adj) {\n if(!is_obstacle[p.r][p.c]) seeds.push_back(p);\n }\n // Sort seeds? No, random is fine or fixed.\n // Let's sort by distance to center to break symmetry deterministically?\n \n // Mark entrance and obstacles as visited\n visited[get_idx(entrance.r, entrance.c)] = true;\n for(int r=0; r p_map(D*D, -1); // Parent mapping for reconstruction\n\n vector S;\n // Add seeds.\n // Note: We must connect seeds to entrance.\n for(auto p : seeds) {\n // Don't mark visited yet, let the loop handle\n // But we need to know they come from entrance\n p_map[get_idx(p.r, p.c)] = get_idx(entrance.r, entrance.c);\n S.push_back(p);\n // Mark seeds visited in stack to avoid duplication?\n // Standard DFS logic:\n }\n \n // Actually, strictly, let's just run DFS from entrance.\n // The neighbors are naturally pushed.\n \n // We want to visit all reachable nodes.\n // To avoid \"trapping\" pockets, we might need `visited` check on push?\n // Standard DFS: Mark on pop? No, mark on push (or strictly on discovery).\n \n // Reset\n fill(visited.begin(), visited.end(), false);\n visited[get_idx(entrance.r, entrance.c)] = true;\n for(int r=0; r> nbs;\n for(int i=0; i<4; ++i) {\n int nr = u.r + dr[i];\n int nc = u.c + dc[i];\n if(in_bounds(nr, nc) && !visited[get_idx(nr, nc)]) {\n // Heuristic: number of free neighbors\n int free_n = 0;\n for(int k=0; k<4; ++k) {\n int nnr = nr + dr[k];\n int nnc = nc + dc[k];\n if(in_bounds(nnr, nnc) && !visited[get_idx(nnr, nnc)]) free_n++;\n }\n // Heuristic 2: Distance to entrance (further is better)\n // Heuristic 3: Prefer moving towards the \"back\" (larger r) or \"sides\"\n int dist_ent = abs(nr - entrance.r) + abs(nc - entrance.c);\n \n // Combine: prefer low free_n (hugging walls/obstacles), high dist\n int score = -free_n * 100 + dist_ent;\n \n nbs.push_back({score, {nr, nc}});\n }\n }\n sort(nbs.rbegin(), nbs.rend()); // Descending score\n vector res;\n for(auto& kv : nbs) res.push_back(kv.second);\n return res;\n };\n\n // Re-implement DFS using explicit stack and parent tracking\n // The stack will store (u, p)\n struct State { Point u; Point p; };\n vector stack;\n \n // Initial neighbors\n auto initial_nbs = get_sorted_neighbors(entrance);\n // Push in reverse so best is popped first\n reverse(initial_nbs.begin(), initial_nbs.end());\n for(auto p : initial_nbs) stack.push_back({p, entrance});\n \n while(!stack.empty()) {\n State top = stack.back();\n stack.pop_back();\n \n int u_idx = get_idx(top.u.r, top.u.c);\n if(visited[u_idx]) continue;\n visited[u_idx] = true;\n \n // Add to tree\n int p_idx_in_nodes = grid_node_map[top.p.r][top.p.c];\n \n Node new_node;\n new_node.p = top.u;\n new_node.id = nodes.size();\n new_node.parent_idx = p_idx_in_nodes;\n nodes[p_idx_in_nodes].children_idx.push_back(new_node.id);\n grid_node_map[top.u.r][top.u.c] = new_node.id;\n nodes.push_back(new_node);\n \n // Add neighbors\n auto nbs = get_sorted_neighbors(top.u);\n reverse(nbs.begin(), nbs.end());\n for(auto next_p : nbs) {\n stack.push_back({next_p, top.u});\n }\n }\n}\n\n// Assign priorities to nodes based on a simulation of filling\n// Logic: \"Deepest available\" node gets the highest rank (reserved for large numbers).\nvoid assign_priorities() {\n // We simulate the filling process.\n // At each step, we identify all \"available\" nodes (leaves of the current empty tree).\n // We greedily pick the one that is \"deepest\" or \"most desirable\" for a large number.\n // The one we pick gets rank M. The next M-1, etc.\n \n // What is \"deepest\"?\n // Distance from root in the tree? Yes.\n // Tie-breaker? Subtree size?\n // Let's use (Depth, -SubtreeSize) as priority.\n // Actually, since we are filling leaves, the \"depth\" is static.\n \n int num_nodes = nodes.size(); // Includes dummy root\n // Actual storage nodes\n vector storage_nodes;\n for(int i=1; i depth(num_nodes, 0);\n vector degree(num_nodes, 0); // Number of children\n vector parent(num_nodes, -1);\n \n for(auto& node : nodes) {\n degree[node.id] = node.children_idx.size();\n for(int child : node.children_idx) {\n depth[child] = depth[node.id] + 1;\n parent[child] = node.id;\n }\n }\n \n // \"Available\" means degree is 0 (leaf in the dependency tree)\n // Note: In the actual problem, we fill a spot if it's empty and reachable.\n // In our tree model, we only fill leaves of the tree to preserve reachability of the rest of the tree.\n // This is a subset of valid moves, but a safe one.\n \n // Priority Queue for simulation: Stores node indices.\n // Ordered by Depth desc.\n auto comp = [&](int a, int b) {\n if (depth[a] != depth[b]) return depth[a] < depth[b]; // Max depth first\n return a < b;\n };\n priority_queue, decltype(comp)> pq(comp);\n \n vector current_degree = degree;\n \n for(int i=1; i> N_obstacles;\n if (cin.fail()) return; // Local test end or error\n\n init_grid();\n \n for(int i=0; i> r >> c;\n is_obstacle[r][c] = true;\n obstacles.push_back({r, c});\n }\n \n build_tree();\n assign_priorities();\n \n int total_containers = (D * D) - 1 - N_obstacles;\n \n // Used for tracking which numbers have appeared\n for(int i=0; i current_degree(nodes.size(), 0);\n for(auto& n : nodes) current_degree[n.id] = n.children_idx.size();\n \n // Active leaves (available spots)\n // We can just scan or maintain a set. Since D is small, scanning is fast.\n // But a set ordered by fill_order_rank is better.\n auto leaf_comp = [&](int a, int b) {\n return nodes[a].fill_order_rank < nodes[b].fill_order_rank;\n };\n // We want to quickly find a node with rank close to Target.\n // Sorted vector is fine.\n \n // Track available spots\n vector available_spots;\n for(int i=1; i<(int)nodes.size(); ++i) {\n if(current_degree[i] == 0) available_spots.push_back(i);\n }\n \n // Main Placement Loop\n for(int d=0; d> t;\n seen_number[t] = true;\n \n // 1. Estimate Rank of t among remaining numbers\n int smaller_unseen = 0;\n int total_unseen = 0;\n \n // This loop is O(M), M~80. Fast enough.\n // Optim: precalculate total unseen count.\n for(int v=0; v 0) {\n percentile = (double)smaller_unseen / (double)total_unseen;\n } else {\n percentile = 1.0; // Last item, doesn't matter\n }\n \n // 2. Map percentile to available spots\n // We have 'available_spots'. \n // But wait, we shouldn't just look at available spots.\n // We should look at the 'ideal' global rank we want to fill.\n // The set of ALL remaining empty spots has a distribution of 'fill_order_rank'.\n // We want to fill a spot that corresponds to 'percentile'.\n // BUT we are constrained to 'available_spots'.\n \n // Let's list all remaining empty spots and sort them by 'fill_order_rank'.\n vector all_empty_spots; \n for(int i=1; i<(int)nodes.size(); ++i) {\n if(container_val[nodes[i].p.r][nodes[i].p.c] == -1) {\n all_empty_spots.push_back(i);\n }\n }\n sort(all_empty_spots.begin(), all_empty_spots.end(), [&](int a, int b){\n return nodes[a].fill_order_rank < nodes[b].fill_order_rank;\n });\n \n // Target index in the sorted list of all empty spots\n int target_idx = (int)round(percentile * (all_empty_spots.size() - 1));\n int target_node = all_empty_spots[target_idx];\n int target_rank = nodes[target_node].fill_order_rank;\n \n // Now find the BEST MATCH from 'available_spots'\n int best_node = -1;\n int min_diff = 999999;\n \n // Tie-breaking: If multiple spots have same rank diff?\n // Not possible since ranks are unique.\n \n for(int cand : available_spots) {\n int diff = abs(nodes[cand].fill_order_rank - target_rank);\n if(diff < min_diff) {\n min_diff = diff;\n best_node = cand;\n }\n }\n \n // Place\n Point p = nodes[best_node].p;\n cout << p.r << \" \" << p.c << endl;\n \n has_container[p.r][p.c] = true;\n container_val[p.r][p.c] = t;\n \n // Update tree state\n // Remove best_node from available\n // Update parent's degree\n // If parent becomes available, add to list\n \n // Inefficient remove from vector, but N is small.\n for(auto it = available_spots.begin(); it != available_spots.end(); ++it) {\n if(*it == best_node) {\n available_spots.erase(it);\n break;\n }\n }\n \n int parent_id = nodes[best_node].parent_idx;\n if(parent_id != -1 && parent_id != 0) {\n current_degree[parent_id]--;\n if(current_degree[parent_id] == 0) {\n available_spots.push_back(parent_id);\n }\n }\n }\n \n // Retrieval Phase\n // We need to output the sequence of retrieval.\n // We must respect reachability.\n // In our tree logic, a node is reachable if its parent is removed (or it's adjacent to entrance).\n // Actually, reachability is geometric. But since we filled a tree, geometric reachability is guaranteed if we remove in Parent->Child order?\n // Wait.\n // Placement: Child filled before Parent. (Leaves first).\n // Retrieval: Parent removed before Child. (Root first).\n // Yes, removing the root of a subtree makes the children accessible.\n // So we can maintain a \"frontier\" of removable nodes.\n // Initially, this is the children of the dummy root (entrance).\n // We greedily pick the node with the SMALLEST value from the frontier.\n \n priority_queue, vector>, greater>> pq_retrieve;\n \n // Initial accessible nodes: children of dummy root\n for(int child : nodes[0].children_idx) {\n // The child is a valid container spot.\n // Value is in container_val\n int val = container_val[nodes[child].p.r][nodes[child].p.c];\n pq_retrieve.push({val, child});\n }\n \n while(!pq_retrieve.empty()) {\n pair top = pq_retrieve.top();\n pq_retrieve.pop();\n \n int u = top.second;\n Point p = nodes[u].p;\n \n cout << p.r << \" \" << p.c << endl;\n \n // Add children to PQ\n for(int child : nodes[u].children_idx) {\n int val = container_val[nodes[child].p.r][nodes[child].p.c];\n pq_retrieve.push({val, child});\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc024":"#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 = 50;\nconst int M = 100;\nconst int EMPTY = 0;\n\n// Directions\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n};\n\n// Global State\nint grid[N][N];\nint original_grid[N][N];\nbool target_adj[M + 1][M + 1];\nint current_adj_count[M + 1][M + 1];\n\n// RNG\nmt19937 rng(12345);\n\n// Helper to get neighbors (valid coordinates only)\nvector get_neighbors(int r, int c) {\n vector nb;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n nb.push_back({nr, nc});\n }\n }\n return nb;\n}\n\n// Check connectivity for a specific color using BFS\nbool check_connectivity(int color, const vector& members) {\n if (members.empty()) return true;\n \n // Map coordinates to index in members for quick lookup, or use a visited grid\n // Since N is small, a static visited array is fine\n static int visited[N][N];\n static int visit_token = 0;\n visit_token++;\n \n int start_r = members[0].r;\n int start_c = members[0].c;\n \n queue q;\n q.push({start_r, start_c});\n visited[start_r][start_c] = visit_token;\n \n int count = 0;\n while (!q.empty()) {\n Point p = q.front();\n q.pop();\n count++;\n \n for (int i = 0; i < 4; ++i) {\n int nr = p.r + DR[i];\n int nc = p.c + DC[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (grid[nr][nc] == color && visited[nr][nc] != visit_token) {\n visited[nr][nc] = visit_token;\n q.push({nr, nc});\n }\n }\n }\n }\n \n return count == members.size();\n}\n\n// Check if a color was originally adjacent to boundary (0)\n// This is captured in target_adj[0][c]\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n_in, m_in;\n cin >> n_in >> m_in; // n=50, m=100 fixed\n \n // 1. Read Input\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cin >> original_grid[r][c];\n grid[r][c] = original_grid[r][c];\n }\n }\n \n // 2. Analyze Target Adjacency\n // Initialize\n for (int i = 0; i <= M; ++i) {\n for (int j = 0; j <= M; ++j) {\n target_adj[i][j] = false;\n }\n }\n \n // Check grid adjacencies\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = original_grid[r][c];\n \n // Check 4 neighbors\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v;\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n v = original_grid[nr][nc];\n } else {\n v = 0; // Outside is color 0\n }\n \n if (u != v) {\n target_adj[u][v] = true;\n target_adj[v][u] = true;\n }\n }\n }\n }\n \n // 3. Initialize Current Adjacency Counts\n // We need to maintain counts to know if removing a cell breaks the LAST connection\n // or creates a FORBIDDEN connection.\n for (int i = 0; i <= M; ++i) {\n for (int j = 0; j <= M; ++j) current_adj_count[i][j] = 0;\n }\n\n // Count current adjacencies in the working grid\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = grid[r][c];\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n \n if (u < v) { // Count each edge once\n current_adj_count[u][v]++;\n current_adj_count[v][u]++;\n }\n }\n }\n }\n\n // Track member cells for each color for fast connectivity checking\n vector> color_cells(M + 1);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n color_cells[grid[r][c]].push_back({r, c});\n }\n }\n \n // 4. Iterative Shrinking\n // Candidates are non-zero cells adjacent to 0\n // Since checking candidates is fast, we can just iterate or keep a set.\n // A set of (r,c) is good.\n \n vector candidates;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n bool adj_zero = false;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n if (v == 0) {\n adj_zero = true;\n break;\n }\n }\n if (adj_zero) candidates.push_back({r, c});\n }\n }\n }\n \n // Shuffle candidates to avoid bias\n shuffle(candidates.begin(), candidates.end(), rng);\n \n // We can loop multiple times. In each pass, we try to remove cells.\n // If we remove a cell, its neighbors become new candidates.\n \n // Using a set for unique candidates in queue\n // But simple iteration over the grid or shuffling is often robust enough given the time limit.\n // Let's try a queue-based approach with a 'in_queue' check to propagate erosions.\n // Actually, since we want to maximize deletions, we can just loop until no progress is made.\n // With N=50, checking all cells is fast.\n \n bool changed = true;\n auto start_time = chrono::high_resolution_clock::now();\n \n while (changed) {\n changed = false;\n \n // Collect boundary cells\n vector boundary_cells;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n bool is_boundary = false;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n if (v == 0) {\n is_boundary = true;\n break;\n }\n }\n if (is_boundary) boundary_cells.push_back({r, c});\n }\n }\n }\n \n shuffle(boundary_cells.begin(), boundary_cells.end(), rng);\n \n for (const auto& p : boundary_cells) {\n int r = p.r;\n int c = p.c;\n int color = grid[r][c];\n \n if (color == 0) continue; // Already removed\n \n // --- CHECKS ---\n \n // 1. Check Adjacency Constraints\n bool possible = true;\n \n // Check neighbors of (r,c)\n vector neighbor_colors;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n neighbor_colors.push_back(v);\n }\n \n // A. Check if removing breaks a required adjacency (color <-> neighbor)\n // B. Check if removing creates a forbidden adjacency (neighbor <-> 0)\n \n // A. Breakage\n // The edges being removed are between 'color' and each 'v' in neighbor_colors.\n // Note: multiple neighbors might have same color v. We need to count carefully.\n map edges_to_remove;\n for (int v : neighbor_colors) {\n if (v != color) { // Internal edges (color-color) don't count for adjacency between distinct sets\n edges_to_remove[v]++;\n }\n }\n \n for (auto const& [v, count] : edges_to_remove) {\n if (target_adj[color][v]) {\n if (current_adj_count[color][v] - count <= 0) {\n possible = false;\n break;\n }\n }\n }\n if (!possible) continue;\n \n // B. Forbidden exposure\n // If (r,c) becomes 0, then every neighbor v becomes adjacent to 0.\n // If target_adj[v][0] is false, this is forbidden.\n // Note: if v is already adjacent to 0 elsewhere, this is fine? \n // Actually, the condition \"if and only if there exist adjacent squares...\".\n // If v and 0 are adjacent in created map (which they will be if we turn (r,c) to 0),\n // then they MUST be adjacent in original map.\n // So we just check target_adj[v][0].\n for (int v : neighbor_colors) {\n if (v != 0 && v != color) { // If v is 0, it's fine. If v is color, it will be checked recursively later or it's fine (self).\n if (!target_adj[v][0]) {\n possible = false;\n break;\n }\n }\n }\n if (!possible) continue;\n\n // 2. Check Connectivity of 'color'\n // Optimization: Only check if local connectivity is broken\n // If the 3x3 area neighbors of 'color' are connected within 3x3 excluding center,\n // then global connectivity is preserved (assuming simply connected initially).\n // But general case: removing a node can disconnect a graph.\n // We construct the new list of cells temporarily.\n vector& cells = color_cells[color];\n vector next_cells;\n next_cells.reserve(cells.size());\n for(auto& cp : cells) {\n if(cp.r != r || cp.c != c) next_cells.push_back(cp);\n }\n \n if (!check_connectivity(color, next_cells)) {\n continue;\n }\n \n // 3. Check Connectivity of 0?\n // Problem says \"squares of color 0 can be connected through the outside\".\n // Since we only erode from boundary (adjacent to 0), the new 0 cell connects to existing 0.\n // We ensure the \"outside\" is a single component.\n // However, could we create an \"island\" of colors inside a ring of 0s?\n // No, because we only turn a cell to 0 if it touches an existing 0. \n // So the set of 0s stays connected.\n \n // --- COMMIT ---\n \n // Update Counts\n // Remove edges (color, v)\n for (int v : neighbor_colors) {\n if (v != color) {\n current_adj_count[color][v]--;\n current_adj_count[v][color]--;\n }\n }\n \n // Add edges (0, v)\n // But wait, if we change (r,c) to 0, it might merge with neighbor 0s.\n // The edges between the new 0 and neighbor 0s are 0-0 edges (internal), not counted in adj map usually?\n // Adjacency map counts edges between distinct sets.\n // Edges between new 0 and neighbor v (where v != 0):\n for (int v : neighbor_colors) {\n if (v != 0) { \n // Note: neighbor v was adjacent to 'color', now adjacent to '0'.\n // Wait, if v was 'color' (same component), now it is adjacent to '0'.\n // Correct logic:\n // The cell at (r,c) changes from 'color' to 0.\n // Neighbors that were v != 0 are now adjacent to this new 0.\n // Neighbors that were 0 are now adjacent to this new 0 (internal 0-0 edge).\n if (v != 0) {\n current_adj_count[0][v]++;\n current_adj_count[v][0]++;\n }\n }\n }\n\n // Update Grid\n grid[r][c] = 0;\n color_cells[color] = next_cells;\n changed = true;\n \n // Time check\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1800) {\n goto end_loops;\n }\n }\n }\n \n end_loops:;\n \n // 5. Output\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 cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"/**\n * AHC025 - Unweighable\n * \n * Strategy:\n * 1. Initial Sorting:\n * Since we want to partition items into equal-weight sets, knowing the relative order of weights is crucial.\n * We perform a merge sort to get a rough ordering of items by weight. Since comparisons are expensive and limited,\n * we need to be careful. However, with N up to 100 and Q up to 32N (min 2N), a full sort (N log N approx 665 for N=100)\n * might be feasible if Q is large, but risky if Q is small.\n * \n * Actually, N=100, N log2 N approx 664. Minimum Q is 2N = 200.\n * So we cannot always afford a full sort. We should prioritize sorting larger items or use a partial sort / approximate sort.\n * Let's try to maintain a sorted list. If Q is small, we might just sort into groups or do random comparisons to estimate.\n * \n * Strategy A (Small Q): Approximate sort or group-based sort.\n * Strategy B (Large Q): Full Merge Sort.\n * \n * Let's use a hybrid approach. We'll implement a standard `std::sort` with a custom comparator that uses the query.\n * To save queries, we can cache comparison results, but since we only compare once usually in sort, caching isn't huge.\n * \n * 2. Initial Distribution:\n * Once items are sorted (heaviest to lightest), we distribute them using a \"greedy snake\" approach (serpentine distribution).\n * Set 0 gets item 0, Set 1 gets item 1... Set D-1 gets item D-1.\n * Then Set D-1 gets item D, Set D-2 gets item D+1...\n * This balances the weights roughly.\n * \n * 3. Refinement (Hill Climbing / Simulated Annealing):\n * After the initial distribution, the sums won't be perfectly equal.\n * We have remaining queries. We use them to improve the balance.\n * \n * We want to compare the total weights of two sets, say Set A and Set B.\n * If weight(Set A) > weight(Set B), we should move an item from A to B, or swap a heavy item from A with a light item from B.\n * \n * However, the query allows comparing arbitrary subsets.\n * The most direct check for \"Is Set A heavier than Set B?\" is to put all items of A on Left and all items of B on Right.\n * Since items are distinct (partitioned), L and R are disjoint.\n * \n * Algorithm loop until Q runs out:\n * a. Pick two sets, say $S_i$ and $S_j$.\n * Heuristic to pick: Pick based on history? Or random?\n * Let's maintain a rough estimate of set weights? No, we can't know absolute values.\n * But we can maintain an ordering of sets.\n * Let's keep the sets sorted by their approximate total weight.\n * To do this, we can compare two sets $S_i$ and $S_j$ using 1 query.\n * b. If $S_i > S_j$, we try to swap items to reduce the gap.\n * If we just swap random items, we don't know if it improves.\n * We need to know individual item weights relative to the gap.\n * \n * Refined Strategy for Phase 2:\n * - Measure the relative order of the D sets. Sort the sets $S_{p_0}, S_{p_1}, \\dots, S_{p_{D-1}}$ such that $Weight(S_{p_0}) < Weight(S_{p_1}) < \\dots$.\n * This takes some queries. Since D is small (up to N/4 = 25), sorting D sets takes $D \\log D$ comparisons.\n * - Once we know the heaviest set $H$ and the lightest set $L$, we want to move weight from $H$ to $L$.\n * - Operations:\n * 1. Move an item $x \\in H$ to $L$.\n * 2. Swap $x \\in H$ and $y \\in L$ such that $w_x > w_y$.\n * - To do this effectively without exact weights, we rely on the sorted order of items from Phase 1.\n * If we swap a heavy item from $H$ with a light item from $L$, the gap decreases.\n * We need to check if we \"overshot\" (i.e., $H$ becomes lighter than $L$ significantly).\n * \n * Wait, the distribution of weights is exponential. There are a few very heavy items and many light ones.\n * The heavy items dominate the variance.\n * \n * Revised Complete Algorithm:\n * Phase 1: Sort all items.\n * Use `std::sort` with the query.\n * Constraint check: If we run out of queries during sort, we abort the sort and use the partially sorted array.\n * Since exponential distribution, sorting the heaviest items is most important.\n * Maybe sort only top K items fully if Q is tight?\n * Actually, standard sort is quite adaptive. Let's try full sort.\n * \n * Phase 2: Initial Greedy Assignment.\n * Sort indices $0..N-1$ based on the result of Phase 1.\n * Distribute items $0..N-1$ (heaviest to lightest) into buckets $0..D-1$ using serpentine method.\n * \n * Phase 3: Balancing.\n * While queries remain:\n * 1. Identify the current Heavy bucket and Light bucket.\n * We don't know absolute weights. We can maintain the current total weight relative to each other? No.\n * We can assume our greedy distribution made them roughly equal.\n * Let's pick two buckets at random (or cyclically). Compare them.\n * Actually, let's try to keep a \"Leaderboard\" of buckets.\n * But comparing sum of sets is expensive if sets change often.\n * \n * Alternative for Phase 3:\n * Since we sorted items, we have a strong prior $w_0 < w_1 < \\dots < w_{N-1}$.\n * Let's estimate weights!\n * Since weights are drawn from Exp(1e-5) and rounded, expected value is roughly const * (-ln(uniform)).\n * Or simpler: The sorted ranks give us expected weights.\n * $E[w_{(i)}] \\approx F^{-1}(i/N)$ roughly.\n * Let's assign \"virtual weights\" to items based on their sorted rank and the expected distribution of order statistics of Exponential distribution.\n * Virtual Weight $v_i$.\n * \n * Then, we can simulate the balancing process locally using $v_i$.\n * This gives a target configuration.\n * However, real weights deviate.\n * \n * Let's use the query to correct the virtual weights or the set sums.\n * Idea: The \"virtual weight\" approach is good for initialization, but we have the balance scale.\n * \n * Algorithm:\n * 1. Sort items $i_0, i_1, \\dots, i_{N-1}$ by weight (Light -> Heavy).\n * 2. Assign tentative weights $w^*_{k}$ to the item at rank $k$.\n * For exponential distribution, the expected value of the $k$-th smallest of $N$ items is $\\sum_{j=1}^{k+1} \\frac{1}{N-j+1}$ (scaled).\n * Let's use these expected values as proxies.\n * 3. Optimization Loop:\n * Current partition is based on minimizing variance of proxy sums.\n * Repeat while query budget > threshold:\n * a. Calculate proxy sums of all sets.\n * b. Pick the set $S_{max}$ with max proxy sum and $S_{min}$ with min proxy sum.\n * c. We suspect $Weight(S_{max}) > Weight(S_{min})$. Verify this with 1 query.\n * Result:\n * - If $S_{max} > S_{min}$: Our proxy is likely correct direction-wise.\n * We want to reduce gap.\n * Try to find a swap $(u \\in S_{max}, v \\in S_{min})$ or move $u \\in S_{max} \\to S_{min}$\n * that minimizes the proxy variance difference, but be careful not to overshoot.\n * Since we confirmed the gap exists, we perform the move/swap if the proxy model suggests it's an improvement.\n * *Crucial*: After the move, we should update our \"belief\" about the total weights? \n * Actually, if the scale says $S_{max} > S_{min}$, and we move a small amount, it's likely safe.\n * If we swap items with large rank difference, we might flip the inequality.\n * \n * - If $S_{max} < S_{min}$: Our proxy model is wrong!\n * The set we thought was heavy is actually lighter than the set we thought was light.\n * This means the specific items in $S_{min}$ are heavier than expected relative to items in $S_{max}$.\n * We can update the proxy weights?\n * Simple update: Multiply all weights in $S_{min}$ by $(1+\\alpha)$ and in $S_{max}$ by $(1-\\alpha)$.\n * Then re-calculate proxy sums and repeat.\n * \n * - If $S_{max} == S_{min}$: Perfect balance between these two.\n * Maybe pick the next max/min pair.\n * \n * This \"Proxy Weight Adjustment\" seems robust. It combines the statistical expectation with ground truth feedback.\n *\n * Refined Update Logic:\n * - Initialize $v_i$ = Expected value of $i$-th smallest item in Exp dist.\n * - Loop:\n * - Identify candidate sets $L, R$ (e.g. max and min proxy weight sums).\n * - Query: Compare $L$ vs $R$.\n * - If $L > R$:\n * - If proxy says $Sum(L) < Sum(R)$, we have a contradiction. Increase weights of items in $L$, decrease in $R$.\n * - If proxy says $Sum(L) > Sum(R)$, consistent. We can try to improve balance by swapping/moving items based on proxy weights.\n * Find a move that reduces $|Sum(L) - Sum(R)|$ according to proxy.\n * Perform the move virtually.\n * - If $L < R$:\n * - Symmetric to above.\n * - If $L = R$:\n * - If proxy says different, adjust weights to bring sums closer.\n * \n * Termination:\n * - When Q is exhausted.\n *\n * Initial Sort Implementation details:\n * - Since Q can be small (2N), we might not finish full sort.\n * - Check Q before every comparison. If Q=0, treat as equal (or stop sorting).\n * - If sorting stops early, we rely on the partial order.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --------------------------------------------------------------\n// Global Variables & Constants\n// --------------------------------------------------------------\nint N, D, Q;\nint query_count = 0;\n\n// Random engine\nmt19937 rng(12345);\n\n// --------------------------------------------------------------\n// Query Handling\n// --------------------------------------------------------------\n\n// Returns:\n// 1 if Left > Right\n// -1 if Left < Right\n// 0 if Left == Right\n// -2 if query limit exceeded (should handle gracefully)\nint query(const vector& L, const vector& R) {\n if (query_count >= Q) return -2;\n \n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << endl;\n \n query_count++;\n \n string res;\n cin >> res;\n if (res == \">\") return 1;\n if (res == \"<\") return -1;\n return 0;\n}\n\n// Helper for single item comparison\n// Returns true if i < j (weight)\n// Caches results? No, memory is cheap but logic is complex. \n// Simple direct comparison for sorting.\nbool compare_items(int i, int j) {\n if (i == j) return false;\n // Query: Left={i}, Right={j}\n // If i < j (weight), result is '<' (-1).\n int res = query({i}, {j});\n if (res == -2) return false; // Fallback\n return res == -1; \n}\n\n// --------------------------------------------------------------\n// Data Structures\n// --------------------------------------------------------------\n\nstruct Item {\n int id;\n int rank; // rank after sorting (0 = lightest)\n double est_weight; // Estimated weight\n};\n\n// --------------------------------------------------------------\n// Utilities\n// --------------------------------------------------------------\n\n// Generate expected values for order statistics of Exponential Distribution\n// E[X_(k)] for sample size n from Exp(lambda) is sum(1/(n-i+1)) for i=1..k * (1/lambda)\n// Since we care about relative weights, 1/lambda cancels out.\nvector get_expected_order_stats(int n) {\n vector stats(n);\n double current = 0.0;\n for (int i = 0; i < n; ++i) {\n // The smallest item (rank 0) corresponds to the first term\n // The i-th smallest (0-indexed)\n current += 1.0 / (n - i);\n stats[i] = current;\n }\n return stats;\n}\n\n// --------------------------------------------------------------\n// Main Solver\n// --------------------------------------------------------------\n\nvoid solve() {\n cin >> N >> D >> Q;\n \n vector p(N);\n iota(p.begin(), p.end(), 0);\n\n // --- Phase 1: Sort Items ---\n // We want to sort items by weight.\n // If Q is very limited, we might not finish. \n // Check budget. \n // Comparison sort requires roughly N log N.\n // With N=100, ~700 queries. Q >= 200.\n // If Q is small, we might want to save queries for balancing.\n // Let's reserve some queries for Phase 3.\n // Phase 3 needs at least ~N queries to be effective? Or just D log D?\n // Let's reserve roughly N queries for balancing if possible, but prioritize sorting.\n \n int sort_budget = Q - min(Q / 2, N * 2); \n if (sort_budget < 0) sort_budget = Q; // Use all if Q is tiny\n\n // Custom sort with budget check inside comparator\n // We use std::stable_sort to minimize comparisons if already partially ordered?\n // Actually, merge sort is good.\n // Let's try to use a lambda with capture.\n \n bool stopped_sorting = false;\n \n // Using a custom merge sort or std::sort might be tricky with early exit.\n // But std::sort compares A and B. If we run out of queries, we must return something consistent.\n // If budget out, we can stop querying and just use indices to break ties (random order).\n \n auto comp = [&](int i, int j) {\n if (query_count >= sort_budget) {\n stopped_sorting = true;\n return i < j; // Fallback deterministic\n }\n return compare_items(i, j);\n };\n\n // Try to sort.\n // Note: std::sort might not handle inconsistent comparison well if we switch logic mid-way,\n // but here we switch to deterministic index comparison which is a valid total ordering.\n stable_sort(p.begin(), p.end(), comp);\n \n // --- Phase 2: Assign Initial Estimates ---\n vector items(N);\n vector exp_stats = get_expected_order_stats(N);\n \n for (int i = 0; i < N; ++i) {\n items[p[i]].id = p[i];\n items[p[i]].rank = i;\n // Assign weight based on rank.\n // Scale it up slightly to avoid tiny number issues, though double is fine.\n // The distribution is exponential.\n // The sorted array p has p[0] as lightest, p[N-1] as heaviest.\n items[p[i]].est_weight = exp_stats[i] * 10000.0; \n }\n\n // Initial Assignment: Serpentine (greedy snake)\n // Sort sets by current total estimated weight (initially 0)\n // To do serpentine properly:\n // 1. Assign heaviest item to set 0, 2nd heaviest to set 1, ..., D-1 to set D-1\n // 2. Reverse direction: D-th heaviest to set D-1, ...\n // But actually, a min-heap approach is often better for partitioning (Number Partitioning - greedy).\n // \"Put the next heaviest item into the currently lightest set.\"\n \n vector> sets(D);\n vector set_weights(D, 0.0);\n \n // Iterate items from heaviest to lightest\n for (int i = N - 1; i >= 0; --i) {\n int item_idx = p[i];\n // Find set with min weight\n int best_set = 0;\n double min_w = 1e18;\n for (int s = 0; s < D; ++s) {\n if (set_weights[s] < min_w) {\n min_w = set_weights[s];\n best_set = s;\n }\n }\n sets[best_set].push_back(item_idx);\n set_weights[best_set] += items[item_idx].est_weight;\n }\n\n // --- Phase 3: Balancing Loop ---\n // Strategy: Compare \"heaviest\" and \"lightest\" set according to *estimates*.\n // Verify with query. Update estimates based on result. Repeat.\n \n // Parameters for update\n // When Scale says L > R but Model says L < R, we have a strong violation.\n // We need to increase weights in L and decrease in R.\n // How much? Multiplicative factor.\n double update_factor = 0.1; \n // Anneal the update factor?\n \n // Keep track of last interaction to avoid cycles?\n // Randomness helps.\n \n while (query_count < Q) {\n // 1. Identify candidates\n int s_max = -1, s_min = -1;\n double max_w = -1.0, min_w = 1e18;\n \n for (int s = 0; s < D; ++s) {\n double w = 0;\n for (int id : sets[s]) w += items[id].est_weight;\n set_weights[s] = w; // update cached sum\n \n if (w > max_w) { max_w = w; s_max = s; }\n if (w < min_w) { min_w = w; s_min = s; }\n }\n \n if (s_max == s_min) {\n // All equal in model? Unlikely with doubles.\n // Pick random distinct\n s_max = 0; s_min = 1; \n }\n\n // Sometimes pick 2nd max or 2nd min to avoid stuck in local optima\n // Or pick random pair with probability?\n // Let's stick to max/min for greedy convergence, but add randomness if stuck.\n // Simple epsilon-greedy\n if (rng() % 100 < 10) { // 10% chance\n s_max = rng() % D;\n s_min = rng() % D;\n while(s_max == s_min) s_min = rng() % D;\n }\n\n // 2. Query\n // We compare Set s_max vs Set s_min\n int res = query(sets[s_max], sets[s_min]);\n if (res == -2) break; // Done\n \n // 3. Handle Result\n // res = 1 => s_max > s_min (Model correct direction)\n // res = -1 => s_max < s_min (Model wrong direction)\n // res = 0 => Equal\n \n if (res == 1) {\n // s_max is indeed heavier.\n // Logic: Try to move weight from s_max to s_min to balance them.\n // We rely on item estimates to pick the move.\n // Possible moves:\n // a. Move item u from s_max to s_min.\n // b. Swap u in s_max with v in s_min (where u > v).\n \n // Find best move that reduces gap (in model) without flipping too much?\n // Actually, since s_max > s_min physically, we WANT to reduce the physical gap.\n // We assume model weights are correlated to physical weights.\n // We pick a move that reduces ModelGap.\n \n double current_diff = set_weights[s_max] - set_weights[s_min]; \n // Note: current_diff might be negative if model was wrong (res=-1 case), \n // but here res=1, so usually current_diff > 0. \n // If current_diff < 0 but res=1, the model is VERY wrong.\n \n if (current_diff < 0) {\n // Model says Min > Max, but Reality says Max > Min.\n // Serious discrepancy. Update weights first.\n // Increase s_max items, decrease s_min items.\n for (int id : sets[s_max]) items[id].est_weight *= (1.0 + update_factor);\n for (int id : sets[s_min]) items[id].est_weight *= (1.0 - update_factor);\n // normalize to prevent explosion?\n // maybe not strictly necessary for short runs.\n } else {\n // Model agrees with Reality.\n // Try to perform a swap/move.\n // We want new_diff to be closer to 0.\n // Ideally slightly positive or slightly negative (overshoot is risky but maybe okay).\n \n // Candidate moves\n int best_type = -1; // 0: move s_max->s_min, 1: swap\n int best_u = -1, best_v = -1; // u index in sets[s_max], v index in sets[s_min]\n double best_new_diff_abs = current_diff;\n \n // Try moving u from Max to Min\n if (sets[s_max].size() > 1) { // Can't empty a set? Problem says non-empty L/R for queries. Output doesn't say sets can't be empty but usually partitions are non-empty. Constraint D <= N/4 implies sets size >= 1 roughly.\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n int u = sets[s_max][i];\n double w_u = items[u].est_weight;\n // New diff would be: (W_max - w_u) - (W_min + w_u) = W_max - W_min - 2*w_u\n double new_diff = current_diff - 2 * w_u;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 0;\n best_u = i;\n }\n }\n }\n \n // Try swapping u from Max with v from Min\n // We want to swap heavy u with light v -> net flow from Max to Min.\n // Change = (W_max - w_u + w_v) - (W_min - w_v + w_u) = Diff - 2(w_u - w_v)\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n for (int j = 0; j < (int)sets[s_min].size(); ++j) {\n int u = sets[s_max][i];\n int v = sets[s_min][j];\n if (items[u].est_weight > items[v].est_weight) {\n double delta = items[u].est_weight - items[v].est_weight;\n double new_diff = current_diff - 2 * delta;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 1;\n best_u = i;\n best_v = j;\n }\n }\n }\n }\n \n if (best_type != -1) {\n // Execute Move\n if (best_type == 0) {\n int u = sets[s_max][best_u];\n sets[s_max].erase(sets[s_max].begin() + best_u);\n sets[s_min].push_back(u);\n } else {\n int u = sets[s_max][best_u];\n int v = sets[s_min][best_v];\n sets[s_max][best_u] = v;\n sets[s_min][best_v] = u;\n }\n } else {\n // No good move found (maybe step size too coarse).\n // We could try to adjust weights slightly to force a change next time?\n // Or just pick random swap?\n }\n }\n } \n else if (res == -1) {\n // s_max < s_min\n // Reality contradicts (or surpasses) Model expectation.\n // s_min is actually heavier.\n \n double current_diff = set_weights[s_max] - set_weights[s_min];\n // If current_diff > 0 (Model thought Max > Min), but Reality Max < Min.\n // Big Error.\n if (current_diff > 0) {\n for (int id : sets[s_max]) items[id].est_weight *= (1.0 - update_factor);\n for (int id : sets[s_min]) items[id].est_weight *= (1.0 + update_factor);\n } else {\n // Model thought Max < Min (and we queried anyway?).\n // Then Model agrees with Reality.\n // Same logic as res=1 but swapped roles.\n // Try to move from Min to Max.\n \n // Swap roles for calculation\n int temp = s_max; s_max = s_min; s_min = temp;\n current_diff = set_weights[s_max] - set_weights[s_min]; // Now positive in theory\n \n // Copy paste logic from above? Or refactor.\n // Let's do a quick inline logic for simplicity\n int best_type = -1; \n int best_u = -1, best_v = -1;\n double best_new_diff_abs = current_diff;\n \n // Move u from heavy (now s_max) to light\n if (sets[s_max].size() > 1) {\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n int u = sets[s_max][i];\n double new_diff = current_diff - 2 * items[u].est_weight;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 0;\n best_u = i;\n }\n }\n }\n // Swap\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n for (int j = 0; j < (int)sets[s_min].size(); ++j) {\n int u = sets[s_max][i];\n int v = sets[s_min][j];\n if (items[u].est_weight > items[v].est_weight) {\n double delta = items[u].est_weight - items[v].est_weight;\n double new_diff = current_diff - 2 * delta;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 1;\n best_u = i;\n best_v = j;\n }\n }\n }\n }\n \n if (best_type == 0) {\n int u = sets[s_max][best_u];\n sets[s_max].erase(sets[s_max].begin() + best_u);\n sets[s_min].push_back(u);\n } else if (best_type == 1) {\n int u = sets[s_max][best_u];\n int v = sets[s_min][best_v];\n sets[s_max][best_u] = v;\n sets[s_min][best_v] = u;\n }\n }\n }\n else {\n // Equal. Good!\n // Maybe try to equalize other sets?\n // Nothing to do for this pair.\n }\n }\n \n // --- Final Output ---\n // Format: d_0 d_1 ... d_{N-1}\n vector assignment(N);\n for (int s = 0; s < D; ++s) {\n for (int id : sets[s]) {\n assignment[id] = s;\n }\n }\n \n // Output result\n for (int i = 0; i < N; ++i) {\n cout << assignment[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << endl;\n}\n\nint main() {\n solve();\n return 0;\n}","ahc026":"/**\n * AHC026 - Stacking of Boxes\n * Heuristic Solution\n * \n * Strategy:\n * 1. Always retrieve boxes 1, 2, ..., n in order.\n * 2. When box 'v' is buried, we need to move the boxes above it.\n * 3. We move these covering boxes to other stacks. The decision of \"which stack\"\n * is the core of the heuristic.\n * 4. We employ a greedy scoring function to pick the destination stack.\n * - Prefer putting box X on top of box Y if X < Y (maintains sorted order).\n * - If forced to put X on top of Y where X > Y (blocking Y), choose Y such that\n * Y is large (needed late) or the gap is minimized.\n * - Avoid placing boxes on the stack containing the next immediate targets (v+1, v+2...)\n * to prevent burying them deeper.\n * 5. We check if we can move multiple boxes at once (chunks) to save energy,\n * but usually moving them individually or in small sorted groups to correct stacks is better\n * for long-term sorting. Given the cost K+1, moving K boxes is cheaper than K moves of 1 box.\n * However, sorting is crucial. We implement a hybrid: try to move chunks if they roughly belong\n * to the same destination category.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global constants\nconst int N = 200;\nconst int M = 10;\n\n// State representation\nstruct State {\n vector> stacks;\n // Box positions: pos[v] = {stack_index, height_index}\n // height_index 0 is bottom.\n vector> pos; \n\n State() {\n stacks.resize(M);\n pos.resize(N + 1);\n }\n};\n\n// Operation representation\nstruct Op {\n int v, i;\n};\n\nState state;\nvector history;\n\n// Function to execute operation 2: carry out box v\nvoid do_op2(int v) {\n int s_idx = state.pos[v].first;\n state.stacks[s_idx].pop_back();\n state.pos[v] = {-1, -1}; // Removed\n history.push_back({v, 0});\n}\n\n// Function to execute operation 1: move box v and above to stack i\nvoid do_op1(int v, int to_stack_idx) {\n int from_stack_idx = state.pos[v].first;\n int from_h_idx = state.pos[v].second;\n \n vector& from_s = state.stacks[from_stack_idx];\n vector& to_s = state.stacks[to_stack_idx];\n \n // Identify the chunk to move\n vector chunk;\n for (size_t k = from_h_idx; k < from_s.size(); ++k) {\n chunk.push_back(from_s[k]);\n }\n \n // Remove from old stack\n from_s.resize(from_h_idx);\n \n // Add to new stack and update positions\n int start_h = to_s.size();\n for (int i = 0; i < (int)chunk.size(); ++i) {\n int box_val = chunk[i];\n to_s.push_back(box_val);\n state.pos[box_val] = {to_stack_idx, start_h + i};\n }\n \n history.push_back({v, to_stack_idx + 1}); // Output is 1-based\n}\n\n// Evaluate the cost of putting a generic box `val` onto stack `s_idx`\n// Lower score is better.\nlong long evaluate_move(int val, int s_idx, int current_target) {\n const vector& st = state.stacks[s_idx];\n \n // Heuristic 1: Avoid empty stacks if possible? \n // Actually, empty stacks are great buffers, but maybe we save them for really messy blocks.\n // Let's treat empty stack as having a virtual base of value N + 1 (infinite).\n int top_val = st.empty() ? 201 : st.back();\n \n long long score = 0;\n \n // Principle: We want val < top_val. (Smaller on top of larger)\n // This means we can access 'val' (needed sooner) without lifting it to get 'top_val'.\n \n if (val < top_val) {\n // Good case. Reward this.\n // The closer they are, the better? Or just generally good.\n // If we put 10 on 100, it's good. If we put 10 on 11, it's also good.\n // Maybe we prefer 10 on 11 to keep sorted segments tight?\n // Or maybe 10 on 100 is safer.\n // Let's prefer putting on a value that is just larger than val to keep stacks sorted.\n score -= 100000; \n score += (top_val - val); // Prefer smaller gap -> tighter sort\n } else {\n // Bad case: val > top_val. (Larger on top of smaller)\n // We are burying 'top_val' (needed sooner) under 'val' (needed later).\n // This will incur future energy.\n score += 100000;\n // If we must bury, bury a top_val that is as large as possible (closest to val),\n // or bury one that is needed very late?\n // Actually, if top_val is small (needed soon), this is DISASTROUS.\n // So the penalty should be proportional to how soon top_val is needed.\n // Since we iterate v from 1 to N, (top_val - current_target) is a proxy for \"how soon\".\n // Smaller (top_val - current_target) -> needed sooner -> Higher Penalty.\n \n // We also want to minimize the inversion magnitude.\n score += (val - top_val) * 100;\n \n // Critical penalty: If top_val is the VERY NEXT target or close to it.\n if (top_val <= current_target + 10) {\n score += 10000000;\n }\n }\n \n return score;\n}\n\n// Solve function\nvoid solve() {\n int n, m;\n if (!(cin >> n >> m)) return;\n\n // Initialize\n state.stacks.clear();\n state.stacks.resize(m);\n state.pos.assign(n + 1, {-1, -1});\n \n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int val;\n cin >> val;\n state.stacks[i].push_back(val);\n state.pos[val] = {i, j};\n }\n }\n \n // Main loop: retrieve 1 to N\n for (int target = 1; target <= n; ++target) {\n // 1. Locate target\n int s_idx = state.pos[target].first;\n int h_idx = state.pos[target].second;\n \n // 2. If target is at top, remove it\n if (h_idx == (int)state.stacks[s_idx].size() - 1) {\n do_op2(target);\n continue;\n }\n \n // 3. Target is buried. We must move boxes above it.\n // Strategy: Identify the boxes above. Move them smartly.\n // To minimize energy K+1, we prefer moving many boxes at once IF they go to the same place.\n // However, sorting is paramount.\n // Let's try to find the largest chunk from the top that can go to a \"good\" stack together.\n // Simplification: Just look at the top box (or top few) and move it to the best place.\n // Repeat until target is exposed.\n \n while (true) {\n int current_h_idx = state.pos[target].second; // Target might shift if we messed up logic, but here it stays.\n int stack_size = state.stacks[s_idx].size();\n \n if (current_h_idx == stack_size - 1) break; // Exposed\n \n // We need to move boxes from [current_h_idx + 1] to [stack_size - 1].\n // Let's look at the box directly above target, and the one above that, etc.\n // We want to move a chunk [split_idx ... stack_size-1] to some best_stack.\n \n // Simple robust strategy: Move them one by one (or chunk by one logical unit) from the top.\n // Moving the top-most chunk is Operation 1 on the top-most box? No, Op 1 is \"pick v, move v and above\".\n // So to move just the top box, we pick v = top_box.\n // To move top 3 boxes, we pick v = 3rd_from_top.\n \n // We try all possible split points (move 1 box, move 2 boxes... up to all covering boxes)\n // and all possible destination stacks.\n // We pick the (split_point, dest_stack) pair that minimizes a local cost function.\n \n int boxes_above_count = stack_size - 1 - current_h_idx;\n \n long long best_move_score = 4e18; // Infinity\n int best_split_v = -1;\n int best_dest_idx = -1;\n \n // We can try moving k boxes from the top (k=1..boxes_above_count)\n // The 'v' for this operation is the box at index (stack_size - k).\n for (int k = 1; k <= boxes_above_count; ++k) {\n int split_idx = stack_size - k;\n int v_to_move = state.stacks[s_idx][split_idx];\n \n // Check all destination stacks\n for (int dest = 0; dest < m; ++dest) {\n if (dest == s_idx) continue;\n \n // Scoring the move of chunk starting at v_to_move to 'dest'\n // Factors:\n // 1. Energy cost: k + 1\n // 2. Strategic cost: How well does the BOTTOM of the chunk fit onto 'dest'?\n // (Since the chunk preserves order, only the interface between dest-top and chunk-bottom matters mostly)\n // 3. Future cost: Are we burying something important in 'dest'?\n \n long long current_energy = k + 1;\n \n // Analyze the interface\n int bottom_val_of_chunk = v_to_move;\n long long strategic_score = evaluate_move(bottom_val_of_chunk, dest, target);\n \n // Heuristic: penalty for scattering?\n // Actually, we might want to check if the chunk itself is \"good\".\n // If the chunk is reverse-sorted (bad), moving it as a whole preserves the badness.\n // But we can't reorder inside a move. We just move.\n \n // Weighting\n // Energy is important, but bad placement is fatal for future energy.\n // Multiplier for strategic score needs to be tuned.\n long long total_score = current_energy * 200 + strategic_score;\n \n if (total_score < best_move_score) {\n best_move_score = total_score;\n best_split_v = v_to_move;\n best_dest_idx = dest;\n }\n }\n \n // Optimization: If we just want to clear the way, usually moving larger chunks is better energy-wise\n // BUT only if the destination is valid.\n // Don't search too many splits if time is tight (not an issue here with N=200).\n // However, often moving the WHOLE covering set is best if there is a safe spot.\n // Or moving 1 by 1 is best to sort them.\n // Let's restrict k to be 1, and maybe the whole block.\n // It turns out allowing all k allows \"greedy chunking\".\n }\n \n // Execute best move\n do_op1(best_split_v, best_dest_idx);\n }\n \n // Now target is exposed\n do_op2(target);\n }\n \n // Output history\n for (auto& op : history) {\n cout << op.v << \" \" << op.i << \"\\n\";\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc027":"/**\n * Solution for AtCoder Heuristic Contest 027 (AHC027)\n * Problem: Takahashi-kun cleaner No.2\n *\n * Strategy Overview:\n * 1. The problem asks us to find a cyclic route visiting all reachable cells starting from (0,0)\n * to minimize the average total accumulated dirt.\n * 2. The cost function is roughly proportional to sum(d[i][j] * (time_since_last_visit[i][j])).\n * To minimize this, cells with high 'd' (dirtiness susceptibility) should be visited more frequently.\n * 3. This is modeled as finding a route on a graph. Since L <= 10^5 is quite large compared to N^2 (~1600),\n * we can visit nodes multiple times.\n * 4. Main Approach:\n * - Construct a base Hamiltonian-like path or a spanning tree traversal (DFS) to ensure connectivity.\n * - Use Hill Climbing / Simulated Annealing to optimize the route.\n * - Represent the route as a sequence of nodes. Since we need a valid path, operations must preserve\n * connectivity.\n * - Instead of a simple path, we can think of this as traversing edges on a graph.\n * - A very effective strategy for this specific \"frequency based TSP\" is to construct a primary cycle\n * that visits everyone, and then \"shortcut\" or \"sub-cycle\" high value nodes.\n *\n * Algorithm Details:\n * 1. **Graph Representation**: Parse the grid into an adjacency list graph. Store 'd' values.\n * 2. **Initial Solution**:\n * - Generate a standard DFS traversal route (visiting every node at least once, retracing steps).\n * This guarantees coverage but is inefficient (length ~ 2*N*N).\n * - Or, construct a TSP tour using heuristics (e.g., nearest neighbor with preference for high d,\n * or MST-based). Let's start with a simple DFS tour as a robust baseline.\n * 3. **Optimization (Local Search)**:\n * - We represent the solution as a long string of directions. However, manipulating a string is hard\n * because changing one move breaks the path validity.\n * - Better representation: A list of \"target waypoints\". The robot goes from waypoints[k] to waypoints[k+1]\n * using shortest path (BFS). The full route is the concatenation of these paths.\n * - Even better for this dense grid: Modify the edge traversal sequence directly.\n * - **Selected Approach**: Coordinate Descent / Local Search on a simplified edge-visiting model or\n * explicit route manipulation.\n * - Given the constraints and problem type, a \"iterative route improvement\" works well.\n * Let the route be a sequence of coordinates $v_0, v_1, \\dots, v_{L-1}, v_L=v_0$.\n * Valid mutations:\n * a. **2-opt**: Swap sub-routes if endpoints are adjacent.\n * b. **Insert/Delete**: If we visit $u \\to v \\to w$, and $u$ is adjacent to $w$, we can skip $v$ (if $v$ is visited elsewhere).\n * c. **Expansion**: If $u \\to w$ are adjacent, we can insert $u \\to v \\to w$ to visit $v$ more often.\n *\n * 4. **Score Calculation**:\n * - Calculating the exact score $\\bar{S}$ takes $O(L \\cdot N^2)$ naively, which is too slow inside a loop.\n * - Optimization: The score is the sum of accumulated dirt. For a cyclic schedule of length $L$,\n * if cell $u$ is visited at indices $t_1, t_2, \\dots, t_k$ (modulo L), the contribution of $u$ to the\n * total sum over one period is based on the gaps between visits.\n * Specifically, for a gap $g$, the sum of arithmetic progression $d_u \\cdot (1 + 2 + \\dots + g-1)$ is added?\n * Wait, let's clarify the objective function.\n * Let $a_{t, i, j}$ be dirt at time $t$. After move, visited becomes 0. Others += d.\n * In steady state (period L), total dirt sum over period is $\\sum_{t=0}^{L-1} S_t$.\n * Actually, it's easier to calculate the contribution of each cell.\n * If a cell $(i, j)$ with rate $d$ is visited every $k$ steps (regularly), the average dirt on it is roughly $d \\cdot k/2$.\n * More precisely, if visited at times $0=T_0 < T_1 < \\dots < T_k = L$, the contribution to the sum of total dirtiness\n * over the cycle of length $L$ is $\\sum_{m=0}^{k-1} d \\cdot \\frac{(T_{m+1} - T_m)(T_{m+1} - T_m - 1)}{2}$.\n * The constant offset depends on problem details, but minimizing sum of squares of gaps is the core.\n * Formula: Cost = $\\sum_{cells\\ u} \\frac{d_u}{2} \\sum_{gaps\\ g} g^2$ (approx).\n * Exact formula for sum of dirt over L steps for one cell:\n * Let gaps be $l_1, l_2, \\dots, l_k$ such that $\\sum l_i = L$.\n * Between visits, dirt grows: $1d, 2d, \\dots, (l-1)d$. Sum is $d \\frac{(l-1)l}{2}$.\n * Also need to account for the 'steady state' average. The problem defines average dirtiness.\n * Let $f(l) = l(l-1)/2$. Total score $\\approx \\sum_{u} d_u \\sum_{intervals} f(len)$.\n * We want to minimize this.\n *\n * 5. **Refined Strategy**:\n * - Start with a valid TSP cycle (visiting every node once).\n * - Greedily insert visits to high-$d$ nodes. If we are at $u$ and neighbor $v$ has high $d$,\n * going $u \\to v \\to u$ adds length 2 but reduces the gap for $v$.\n * - Since $L$ is limited to $10^5$ and $N \\le 40$, we have plenty of moves (min required $N^2 \\approx 1600$).\n * - We can afford a route much longer than minimal TSP.\n * - **Algorithm**:\n * 1. Generate a base TSP tour (DFS tree walk + pruning leaf returns is a good approximation).\n * 2. Try to \"insert\" detours to high $d$ nodes where beneficial.\n * 3. Local search: Try to change order, short-cut parts, or extend parts.\n * 4. Because evaluating the delta is fast (only affects gaps of involved nodes), we can do many iterations.\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst int MAX_N = 40;\nconst int MAX_L = 100000;\nconst double TIME_LIMIT = 1.90; // seconds\n\nint N;\nint D[MAX_N][MAX_N];\n// Adjacency: adj[u] = {v, direction_char}\n// Encoding node (i, j) as i*N + j\nstruct Edge {\n int to;\n char move; // 'U', 'D', 'L', 'R'\n};\nvector adj[MAX_N * MAX_N];\n\n// Directions helpers\nconst int di[] = {-1, 1, 0, 0};\nconst int dj[] = {0, 0, -1, 1};\nconst char dchar[] = {'U', 'D', 'L', 'R'};\nconst int rev_dir[] = {1, 0, 3, 2}; // Index of reverse direction\n\n// Random number generator\nmt19937 rng(12345);\n\n// --- Timer ---\nstruct Timer {\n chrono::high_resolution_clock::time_point start;\n Timer() { start = chrono::high_resolution_clock::now(); }\n double elapsed() {\n chrono::duration diff = chrono::high_resolution_clock::now() - start;\n return diff.count();\n }\n} timer;\n\n// --- Input Parsing ---\nvoid read_input() {\n cin >> N;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> D[i][j];\n }\n }\n\n // Build Graph\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = i * N + j;\n // Check 4 directions\n for (int k = 0; k < 4; ++k) {\n int ni = i + di[k];\n int nj = j + dj[k];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n bool blocked = false;\n if (k == 0) { // Up\n if (h[ni][j] == '1') blocked = true;\n } else if (k == 1) { // Down\n if (h[i][j] == '1') blocked = true;\n } else if (k == 2) { // Left\n if (v[i][nj] == '1') blocked = true;\n } else if (k == 3) { // Right\n if (v[i][j] == '1') blocked = true;\n }\n\n if (!blocked) {\n adj[u].push_back({ni * N + nj, dchar[k]});\n }\n }\n }\n }\n }\n}\n\n// --- Logic ---\n\n// Helper to get move char between adjacent u and v\nchar get_move_char(int u, int v) {\n for (auto& e : adj[u]) {\n if (e.to == v) return e.move;\n }\n return '?';\n}\n\n// Score Calculation\n// To optimize speed, we compute the sum of d * gap*(gap-1)/2.\n// Wait, let's re-verify the formula.\n// If a cell has dirt d, and gaps are l1, l2...\n// The dirt accumulated just before visit is d*l.\n// The sum of dirt on that cell over the cycle:\n// For a gap of length L, the dirt values are d, 2d, ..., (L-1)d just before reset?\n// No, the problem says \"dirtiness... increases by d\". Reset to 0.\n// Time t=0: 0. Move 1. t=1: dirt d (if not visited).\n// If visited at t_a and next at t_b (gap L = t_b - t_a).\n// Values at t_a+1...t_b are: 1d, 2d, ..., Ld? No, at step t, we move THEN update.\n// Visited at t means at end of t, dirt is 0.\n// t+1: dirt becomes d.\n// t+2: dirt becomes 2d.\n// ...\n// t+L: dirt becomes L*d. Then we visit at t+L, it becomes 0.\n// The sequence of dirtiness values contributing to S (sum over all cells) is:\n// For the period, we sum S_t.\n// Contribution of one interval of length L (between resets) to the total sum \\sum S_t:\n// It contributes d + 2d + ... + (L-1)d = d * L(L-1)/2.\n// Wait, does it include the moment of visit?\n// \"dirtiness of the square you moved to becomes 0, and ... all other squares increases\".\n// If we move to u at time T, a_T,u = 0.\n// If we come back at T+L, a_{T+L},u = 0.\n// In between, at T+k (0 < k < L), a_{T+k},u = k*d.\n// At T+L, before move, it was (L-1)d + d?? No, sequence is:\n// T: 0\n// T+1: d\n// ...\n// T+L-1: (L-1)d\n// T+L: 0 (reset).\n// Sum over one cycle period [T, T+L-1] (length L)?\n// Actually, usually we sum over [0, L_route-1].\n// If the route repeats, the gaps are fixed.\n// Contribution of a gap of size g to the sum over one full cycle of length L_route:\n// sum_{k=1 to g-1} k*d = d * g*(g-1)/2.\n// Note: The sum of gaps for a cell equals L_route.\n// Total Score = Sum_{all cells} [ d_cell * Sum_{all gaps g} g(g-1)/2 ] / L_route.\n// We want to minimize this.\n// Actually, we can ignore the denominator for comparisons if L is fixed, but L changes.\n// Minimizing (Sum cost) / L.\n\nlong long calculate_score_numerator(const vector& path) {\n int L = path.size() - 1;\n if (L == 0) return 1e18;\n \n // last visited time for each cell\n vector last_visit(N * N, -1);\n // sum of gap costs\n long long total_cost = 0;\n \n // We simulate two passes to handle the wraparound correctly\n // Or just treat it as cyclic.\n // First pass to establish last_visit relative to end\n // Actually easier: store all visit indices for each cell\n vector> visits(N * N);\n for (int t = 0; t < L; ++t) {\n visits[path[t]].push_back(t);\n }\n \n for (int u = 0; u < N * N; ++u) {\n if (visits[u].empty()) return 2e18; // Invalid: must visit all\n \n long long cell_term = 0;\n int k = visits[u].size();\n for (int i = 0; i < k; ++i) {\n int t_curr = visits[u][i];\n int t_next = visits[u][(i + 1) % k];\n long long gap;\n if (t_next > t_curr) {\n gap = t_next - t_curr;\n } else {\n gap = (L - t_curr) + t_next;\n }\n cell_term += gap * (gap - 1) / 2;\n }\n total_cost += (long long)D[u / N][u % N] * cell_term;\n }\n \n return total_cost;\n}\n\ndouble evaluate(const vector& path) {\n long long num = calculate_score_numerator(path);\n return (double)num / (path.size() - 1);\n}\n\n// Generate initial solution: DFS traversal\n// To make it a cycle, we return to 0.\n// Simple DFS creates a tree. We traverse the tree: down edge, recurse, up edge.\n// This visits every node and returns to root. Length 2*(N*N-1).\n// This is a valid starting point.\nvoid dfs_build(int u, vector& visited, vector& route) {\n visited[u] = true;\n // Prioritize neighbors? \n // Random shuffle or sort by something might help, but simple DFS is fine for base.\n // Maybe visit high D neighbors first? No, doesn't matter for coverage.\n \n // Let's sort neighbors by some heuristic? Maybe proximity to other unvisited nodes?\n // Just shuffle for randomness in restarts.\n vector neighbors;\n for(auto& e : adj[u]) neighbors.push_back(e.to);\n shuffle(neighbors.begin(), neighbors.end(), rng);\n\n for (int v : neighbors) {\n if (!visited[v]) {\n route.push_back(v);\n dfs_build(v, visited, route);\n route.push_back(u);\n }\n }\n}\n\nvector get_initial_solution() {\n vector route;\n route.reserve(2 * N * N);\n route.push_back(0);\n vector visited(N * N, false);\n dfs_build(0, visited, route);\n return route;\n}\n\n// --- Optimization ---\n// We want to optimize the sequence of nodes.\n// Operations:\n// 1. Shortcut: A -> B -> C. If A and C adjacent, A -> C. (Remove B).\n// Only valid if B is visited elsewhere.\n// 2. Detour: A -> C. If A adjacent to B, B adjacent to C, A -> B -> C. (Insert B).\n// Always valid. Good if B has high D and large gap.\n// 3. Swap: A path segment ... u -> ... -> v ...\n// Hard to do general swaps while maintaining connectivity without BFS.\n// But we can swap branches in the DFS tree structure? Too complex.\n// Let's stick to local mutations on the flat path.\n\n// Since the path is a sequence of adjacent nodes, any modification must preserve adjacency.\n// Valid mutation: Replace a sub-path u -> ... -> v with another sub-path u -> ... -> v.\n// Common specific cases:\n// - Remove loop: u -> v -> ... -> u. Can remove the cycle v...u if all nodes in it are visited elsewhere.\n// - Insert loop: at u, insert u -> ... -> u. (e.g. visit high value neighbor v: u->v->u).\n\n// Data structures for fast updates:\n// Global count of visits per node to quickly check if removal is allowed.\nvector visit_counts;\n\nvoid update_counts(const vector& path) {\n fill(visit_counts.begin(), visit_counts.end(), 0);\n // path includes start and end (which are same), so count 0 to L-1\n for (size_t i = 0; i < path.size() - 1; ++i) {\n visit_counts[path[i]]++;\n }\n}\n\n// We will use Simulated Annealing / Hill Climbing.\n// State is `vector path`.\n// Moves:\n// 1. Remove u -> v -> u (Leaf pruning-ish). \n// Pattern in path: ... A, B, A ...\n// Condition: B visited count > 1.\n// Action: remove B, A. Path becomes ... A ...\n// 2. Insert u -> v -> u\n// At u, pick neighbor v.\n// Action: ... u, v, u ...\n// 3. Shortcut triangle: u -> v -> w -> u. (cycle of 3). Remove?\n// Generally: u -> v1 -> v2 -> ... -> vk -> u.\n// If we find such pattern and all v_i have count > 1, we can remove.\n// 4. Bridge shortcut: ... u, v, w ... \n// If u and w are connected, replace v with nothing? -> ... u, w ...\n// Condition: u-w adjacent, v visited elsewhere.\n// 5. Swap segments?\n// If path visits u twice: ... u (path1) u (path2) u ...\n// We can reverse path1? u (rev_path1) u ...\n// Since graph is undirected, reversing a valid cycle u->...->u keeps it valid.\n// This corresponds to 2-opt on the TSP formulation if we view it as a tour of edges.\n\n// Because N is small (40), path length ~2000-3000 initially.\n// Max length 100,000 allows us to repeat the cleaning many times.\n// Strategy:\n// Instead of finding ONE minimal cycle, we want to fill the 10^5 budget with a route that\n// minimizes the cost.\n// However, the problem asks for A route of length L repeated infinitely.\n// The score is average dirtiness.\n// Minimizing Average Dirtiness is equivalent to minimizing (Cost(Path) / Length(Path)).\n// It is often better to have a SHORTER path if it covers everything frequently enough.\n// But we can also have a longer path that visits high D nodes multiple times.\n\n// Let's stick to finding a good cycle of arbitrary length (up to limit).\n// The \"Average Dirtiness\" is the metric.\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n read_input();\n visit_counts.resize(N * N);\n \n vector current_path = get_initial_solution();\n update_counts(current_path);\n \n double current_score = evaluate(current_path);\n vector best_path = current_path;\n double best_score = current_score;\n \n // Prepare adjacency matrix for O(1) checks\n // adj_mat[u][v] = true if connected\n vector> adj_mat(N*N, vector(N*N, false));\n for(int u=0; u TL) break;\n // Update Temp\n // T = T0 * pow(T1/T0, t/TL);\n }\n \n double time_ratio = timer.elapsed() / TL;\n double T = T0 + (T1 - T0) * time_ratio;\n \n // Select Move\n int move_type = rng() % 3;\n // 0: Remove ... u, v, u ... (backtrack removal)\n // 1: Insert ... u, v, u ... (visit neighbor)\n // 2: Shortcut ... u, v, w ... -> ... u, w ... (if connected)\n // 3: 2-opt on cycles? ... u ... u ... (reverse segment) - lets add this later if needed\n // 4: Splice ... u ... v ... and ... v ... u ... (complex)\n\n // For efficiency, try to be smart about picking indices.\n // Random index\n int idx = rng() % (current_path.size() - 1);\n \n if (move_type == 0) {\n // Try remove u, v, u\n // Pattern check: path[idx] == path[idx+2] ?\n // Need idx+2 <= size-1.\n if (idx + 2 < current_path.size()) {\n if (current_path[idx] == current_path[idx+2]) {\n int u = current_path[idx];\n int v = current_path[idx+1];\n // Check if v is visited elsewhere\n if (visit_counts[v] > 1) {\n // Proposed change: remove idx+1, idx+2.\n // New path length -2.\n \n // Delta evaluation is expensive to do fully, but we can try partial update or just re-eval.\n // Since L ~ 3000, O(L) is okay. N^2 is 1600. \n // Cost calc is O(N^2 * avg_visits). Avg visits ~ 2.\n // So eval is O(N^2). ~2000 ops.\n // We can do ~10^5 iters.\n \n // Temporarily apply\n visit_counts[v]--;\n int saved_v = current_path[idx+1];\n int saved_u = current_path[idx+2];\n \n // Actually removing from vector is O(L).\n // Let's construct candidate virtually? No, copy is okay for now.\n vector next_path = current_path;\n next_path.erase(next_path.begin() + idx + 1, next_path.begin() + idx + 3);\n \n double next_score = evaluate(next_path);\n \n // Metropolis\n double diff = next_score - current_score; // we minimize\n if (diff < 0 || exp(-diff * current_path.size() / T) > (double)rng()/rng.max()) { // Scaling diff\n current_path = next_path;\n current_score = next_score;\n if (current_score < best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n } else {\n visit_counts[v]++; // Revert count\n }\n }\n }\n }\n } \n else if (move_type == 1) {\n // Insert u, v, u\n // path[idx] is u.\n // Pick neighbor v.\n int u = current_path[idx];\n if (adj[u].empty()) continue;\n int rand_edge = rng() % adj[u].size();\n int v = adj[u][rand_edge].to;\n \n // Heuristic: prefer high D?\n // Not necessarily, SA will filter.\n \n // Only insert if length permits\n if (current_path.size() + 2 > MAX_L) continue;\n \n vector next_path = current_path;\n next_path.insert(next_path.begin() + idx + 1, v);\n next_path.insert(next_path.begin() + idx + 2, u);\n \n double next_score = evaluate(next_path);\n double diff = next_score - current_score;\n \n // Accept logic\n if (diff < 0 || exp(-diff * current_path.size() / T) > (double)rng()/rng.max()) {\n current_path = next_path;\n current_score = next_score;\n visit_counts[v]++;\n // u count increases? \n // In the path ... u, v, u, w ...\n // u is visited at idx, then v at idx+1, u at idx+2.\n // Yes, u is visited one more time.\n visit_counts[u]++; \n \n if (current_score < best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n }\n }\n else if (move_type == 2) {\n // Shortcut ... u, v, w ... -> ... u, w ...\n // Condition: u and w are adjacent.\n // And v visited elsewhere.\n if (idx + 2 < current_path.size()) {\n int u = current_path[idx];\n int v = current_path[idx+1];\n int w = current_path[idx+2];\n \n if (adj_mat[u][w] && visit_counts[v] > 1) {\n vector next_path = current_path;\n next_path.erase(next_path.begin() + idx + 1);\n \n double next_score = evaluate(next_path);\n double diff = next_score - current_score;\n \n if (diff < 0 || exp(-diff * current_path.size() / T) > (double)rng()/rng.max()) {\n current_path = next_path;\n current_score = next_score;\n visit_counts[v]--;\n if (current_score < best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n }\n }\n }\n }\n }\n \n // Post-Processing: Output\n string ans = \"\";\n for (size_t i = 0; i < best_path.size() - 1; ++i) {\n ans += get_move_char(best_path[i], best_path[i+1]);\n }\n cout << ans << endl;\n\n return 0;\n}","ahc028":"/**\n * Problem Analysis:\n *\n * This is a heuristic optimization problem similar to the Traveling Salesperson Problem (TSP) or Shortest Common Superstring (SCS) problem, \n * but with an additional layer of complexity: the cost of typing characters depends on the physical layout of the keyboard.\n *\n * Key Elements:\n * 1. Superstring Construction: We need to find a string S that contains all M target strings t_k. To minimize length/cost, we want these strings to overlap as much as possible.\n * - Since M=200 and len(t_k)=5, simply concatenating them is too long. Overlaps are crucial.\n * 2. Keyboard Traversal: Moving from one character to the next has a cost calculated by Manhattan distance + 1.\n * - The same character appears in multiple locations. We must choose the optimal location for each character in our sequence to minimize movement cost.\n *\n * Strategy:\n *\n * Step 1: Preprocessing Overlaps\n * Calculate the overlap between every pair of strings t_i and t_j. Specifically, calculate `overlap[i][j]`, which is the length of the suffix of t_i that matches a prefix of t_j.\n *\n * Step 2: Constructing the String Order (High-Level TSP)\n * We need to decide the order in which to type the strings t_k. Since \"lucky string\" just means they appear as substrings, if t_i contains t_j completely, we don't need to type t_j separately.\n * However, the problem generation says t_k are random length 5 strings. It's unlikely one is a substring of another unless they are identical (which is disallowed). \n * So we mostly deal with overlaps.\n * We can model this as a TSP where nodes are the strings t_k, and the edge weight from i to j is roughly `cost(typing non-overlapping part of t_j starting from end of t_i)`.\n *\n * Step 3: Refining Costs with Keyboard Layout\n * The \"cost\" in the TSP isn't just string length; it's movement cost.\n * Let `dist(char a, char b)` be the minimum Manhattan distance between any instance of 'a' and any instance of 'b'. This is a lower bound.\n * A better estimate requires knowing the specific coordinates.\n *\n * Approach:\n * 1. Graph Construction: Create a graph where nodes are the target strings.\n * 2. Greedy / Randomized TSP:\n * - Start with the \"current\" string being empty (or just the starting position).\n * - Repeatedly pick the \"best\" next string to append.\n * - \"Best\" is defined by a combination of:\n * a) Maximum overlap (reduces number of characters to type).\n * b) Minimum physical movement cost.\n *\n * 3. Dynamic Programming / Beam Search for Typing:\n * - Once we have a candidate merged string (or while building it), we need to find the specific coordinates for each character.\n * - Since N=15, N*N = 225. For a string of length L, a simple DP `dp[index_in_S][coord_index]` works.\n * State: `dp[k][(r, c)]` = min cost to type `S[0...k]` ending at `(r, c)`.\n * Since only `S[k]` matters, we only need to track costs for coordinates where `grid[r][c] == S[k]`.\n * Transition: `dp[k][u] = min(dp[k-1][v] + dist(v, u) + 1)` for all v where `grid[v] == S[k-1]`.\n *\n * 4. Iterative Improvement:\n * - Initial solution: Greedy selection of next string based on overlap and approximate distance.\n * - Optimization: 2-opt or 3-opt on the sequence of strings.\n * - Temperature-based Simulated Annealing is likely the best approach given the constraints and scoring function.\n *\n * Detailed Algorithm Implementation Plan:\n *\n * A. Data Structures:\n * - `pos[char]`: List of coordinates for each character 'A'-'Z'.\n * - `adj[M][M]`: Overlap length between t_i and t_j.\n * - `dist_cache[u_idx][v_idx]`: Manhattan distances between specific grid cells (computed on fly or precomputed if memory allows, N^4 is small enough ~50k).\n *\n * B. Initial Solution:\n * - Start at the given finger position.\n * - Maintain a set of unvisited strings.\n * - At each step, evaluate all unvisited strings.\n * - Score for picking `next_str` given `curr_str` (and specific finger pos):\n * - Calculate overlap `ov = overlap(curr_str, next_str)`.\n * - Calculate physical cost to type the `len(next_str) - ov` new characters.\n * - We need a quick heuristic for physical cost. We can use a greedy physical movement for estimation.\n *\n * C. Search / Optimization (Simulated Annealing):\n * - State: A permutation of indices `0` to `M-1`.\n * - Energy Function: The total cost to type the constructed superstring.\n * - To evaluate energy efficiently: \n * 1. Construct the superstring from the permutation.\n * 2. Run the DP to find the optimal path on the keyboard for this superstring.\n * - Move: Swap two indices in the permutation, reverse a subsegment, or move a block.\n * - Time Limit: 2.0s is generous enough for many iterations.\n *\n * D. Refined Energy Calculation (The DP part):\n * - The superstring can be up to M * 5 = 1000 chars (worst case), but with overlaps much shorter.\n * - DP state size: For each char in S, there are roughly N*N/26 \u2248 9 positions.\n * - DP complexity: L * (AvgPos)^2. With AvgPos \u2248 9, this is very fast.\n * - So we can afford to run the full DP inside the SA loop or at least frequently.\n *\n */\n\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\n// --- Constants & Globals ---\nconst int N_MAX = 15;\nconst int M_MAX = 200;\nconst int T_LEN = 5;\nconst int INF = 1e9;\n\nint N, M;\nint start_r, start_c;\nchar grid[N_MAX][N_MAX];\nvector T;\n\n// Positions of each character on the keyboard\nvector> char_positions[26];\n\n// Overlap precomputation: overlap[i][j] = length of suffix of T[i] matching prefix of T[j]\nint overlaps[M_MAX][M_MAX];\n\n// Random number generator\nmt19937 rng(12345);\n\n// --- Helper Functions ---\n\n// Calculate Manhattan distance\ninline int dist(int r1, int c1, int r2, int c2) {\n return abs(r1 - r2) + abs(c1 - c2);\n}\n\n// Calculate overlap between suffix of s1 and prefix of s2\nint calc_overlap(const string& s1, const string& s2) {\n int max_ov = 0;\n for (int k = 1; k < min((int)s1.length(), (int)s2.length()); ++k) {\n if (s1.substr(s1.length() - k) == s2.substr(0, k)) {\n max_ov = k;\n }\n }\n // Check if s1 ends with s2 (overlap = s2.length()) - handled by loop limit?\n // Actually, max overlap can be min(len1, len2).\n // Special check for full containment or full suffix match limited by length\n for (int k = min((int)s1.length(), (int)s2.length()); k >= 1; --k) {\n if (s1.substr(s1.length() - k) == s2.substr(0, k)) return k;\n }\n return 0;\n}\n\n// --- Core Logic ---\n\n// DP to find minimum cost to type a string S starting from (start_r, start_c)\n// Returns pair\n// path is a list of (r, c) coordinates.\npair>> solve_typing(const string& S) {\n if (S.empty()) return {0, {}};\n\n int L = S.length();\n \n // dp[i][pos_idx] = min cost to type S[0...i], ending at char_positions[S[i]][pos_idx]\n // We also need to reconstruct path, so store parent pointer: parent[i][pos_idx] = prev_pos_idx\n \n vector> dp(L);\n vector> parent(L);\n \n // Initialize for first character\n int char_idx_0 = S[0] - 'A';\n int num_pos_0 = char_positions[char_idx_0].size();\n dp[0].resize(num_pos_0);\n parent[0].resize(num_pos_0, -1);\n\n for (int j = 0; j < num_pos_0; ++j) {\n auto p = char_positions[char_idx_0][j];\n dp[0][j] = dist(start_r, start_c, p.first, p.second) + 1;\n }\n\n // DP transitions\n for (int i = 1; i < L; ++i) {\n int char_idx = S[i] - 'A';\n int prev_char_idx = S[i-1] - 'A';\n int num_pos = char_positions[char_idx].size();\n int num_prev_pos = char_positions[prev_char_idx].size();\n \n dp[i].assign(num_pos, INF);\n parent[i].resize(num_pos);\n\n for (int j = 0; j < num_pos; ++j) {\n auto curr_p = char_positions[char_idx][j];\n for (int k = 0; k < num_prev_pos; ++k) {\n if (dp[i-1][k] == INF) continue;\n \n auto prev_p = char_positions[prev_char_idx][k];\n int cost = dp[i-1][k] + dist(prev_p.first, prev_p.second, curr_p.first, curr_p.second) + 1;\n \n if (cost < dp[i][j]) {\n dp[i][j] = cost;\n parent[i][j] = k;\n }\n }\n }\n }\n\n // Find minimum cost at the end\n int last_char_idx = S.back() - 'A';\n int num_last_pos = char_positions[last_char_idx].size();\n int min_total_cost = INF;\n int best_end_idx = -1;\n\n for (int j = 0; j < num_last_pos; ++j) {\n if (dp[L-1][j] < min_total_cost) {\n min_total_cost = dp[L-1][j];\n best_end_idx = j;\n }\n }\n\n // Reconstruct path\n vector> path(L);\n int curr_idx = best_end_idx;\n for (int i = L - 1; i >= 0; --i) {\n path[i] = char_positions[S[i] - 'A'][curr_idx];\n curr_idx = parent[i][curr_idx];\n }\n\n return {min_total_cost, path};\n}\n\n// Fast cost estimation (without full path reconstruction)\n// Only returns the cost.\nint estimate_typing_cost(const string& S) {\n if (S.empty()) return 0;\n int L = S.length();\n \n // Use two rows for DP to save memory/allocations if called frequently\n // dp_curr[j] stores cost to reach j-th instance of current char\n vector dp_prev, dp_curr;\n \n int char_idx_0 = S[0] - 'A';\n int num_pos_0 = char_positions[char_idx_0].size();\n dp_prev.resize(num_pos_0);\n\n for (int j = 0; j < num_pos_0; ++j) {\n auto p = char_positions[char_idx_0][j];\n dp_prev[j] = dist(start_r, start_c, p.first, p.second) + 1;\n }\n\n for (int i = 1; i < L; ++i) {\n int char_idx = S[i] - 'A';\n int prev_char_idx = S[i-1] - 'A';\n int num_pos = char_positions[char_idx].size();\n int num_prev_pos = char_positions[prev_char_idx].size();\n \n dp_curr.assign(num_pos, INF);\n\n // Optimization: This inner loop is small (avg 9x9=81 iters), but called many times.\n for (int k = 0; k < num_prev_pos; ++k) {\n if (dp_prev[k] >= INF) continue; // Should not happen usually\n auto prev_p = char_positions[prev_char_idx][k];\n int base_cost = dp_prev[k] + 1;\n \n for (int j = 0; j < num_pos; ++j) {\n auto curr_p = char_positions[char_idx][j];\n int move = abs(prev_p.first - curr_p.first) + abs(prev_p.second - curr_p.second);\n int cost = base_cost + move;\n if (cost < dp_curr[j]) {\n dp_curr[j] = cost;\n }\n }\n }\n dp_prev = move(dp_curr);\n }\n\n int min_total_cost = INF;\n for (int c : dp_prev) min_total_cost = min(min_total_cost, c);\n return min_total_cost;\n}\n\n// Convert permutation of indices to superstring\nstring indices_to_string(const vector& p) {\n if (p.empty()) return \"\";\n string s = T[p[0]];\n for (size_t i = 1; i < p.size(); ++i) {\n int u = p[i-1];\n int v = p[i];\n int ov = overlaps[u][v];\n s += T[v].substr(ov);\n }\n return s;\n}\n\n// --- Main Solver ---\n\nstruct Solution {\n vector order;\n string s;\n int cost;\n};\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n cin >> N >> M;\n cin >> start_r >> start_c;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> grid[i][j];\n char_positions[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n T.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> T[i];\n }\n\n // Precompute overlaps\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) {\n if (i == j) overlaps[i][j] = 0;\n else overlaps[i][j] = calc_overlap(T[i], T[j]);\n }\n }\n\n // Initial Solution Construction: Greedy\n // We want to visit all nodes (strings).\n // Heuristic: Pick next string that maximizes overlap, breaking ties with estimated cost.\n \n vector current_order;\n vector visited(M, false);\n \n // Try different starting strings to find a good seed\n // Since M=200, we can't try all as start for full greedy, but we can do a quick check.\n // Actually, let's just do one greedy pass starting from the \"closest\" string to (start_r, start_c).\n \n int best_start_idx = -1;\n int min_start_dist = INF;\n \n // Find a string whose first char is close to start pos\n for(int i=0; i candidates;\n for (int i = 0; i < M; ++i) {\n if (!visited[i]) {\n int ov = overlaps[last][i];\n if (ov > max_ov) {\n max_ov = ov;\n candidates.clear();\n candidates.push_back(i);\n } else if (ov == max_ov) {\n candidates.push_back(i);\n }\n }\n }\n \n // From candidates, pick one that *roughly* aligns well? \n // Actually, checking physical cost is expensive inside loop if we construct partial string.\n // Let's just pick random from best candidates or first.\n // To improve diversity, maybe pick closest first char?\n \n // Refined Greedy: From candidates, check distance from last char of T[last] to first char of T[candidate] (taking overlap into account)\n // The last char of current string is T[last].back().\n // If overlap is ov, the first NEW char of T[candidate] is T[candidate][ov].\n // We want min distance between any instance of T[last].back() and T[candidate][ov].\n \n // BUT: We don't know which instance of T[last].back() we used.\n // Approximation: Use average position or just standard greedy.\n // Let's stick to simple max overlap + random tie break for now, relying on SA later.\n \n if (!candidates.empty()) {\n // Simple heuristic for tie-breaking:\n // Pick the one that has the \"best\" connectivity to remaining nodes? Too slow.\n // Let's just pick the one where the transition character is physically close?\n // Let's use a simplified distance check.\n \n int best_cand = candidates[0];\n int min_trans_cost = INF;\n \n // Approximate last char position? No, just use index 0 for determinism or rand\n // Let's just take the first one.\n best_next = candidates[0]; \n }\n \n visited[best_next] = true;\n current_order.push_back(best_next);\n }\n \n // Initial evaluation\n string current_s = indices_to_string(current_order);\n int current_cost = estimate_typing_cost(current_s);\n \n vector best_order = current_order;\n int best_cost = current_cost;\n\n // --- Simulated Annealing ---\n \n auto start_time = chrono::steady_clock::now();\n double time_limit = 1.85; // seconds\n \n double temp_start = 2000.0;\n double temp_end = 10.0;\n double temp = temp_start;\n \n int iter = 0;\n \n while (true) {\n iter++;\n if ((iter & 255) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n // Linear cooling\n double ratio = elapsed / time_limit;\n temp = temp_start * (1.0 - ratio) + temp_end * ratio;\n }\n\n // Generate Neighbor\n // Types of moves:\n // 1. Swap two indices\n // 2. Reverse a subsegment (2-opt)\n // 3. Move a block (insert a subsegment elsewhere)\n \n int move_type = rng() % 3;\n int i = rng() % M;\n int j = rng() % M;\n if (i == j) continue;\n if (i > j) swap(i, j); // Ensure i < j for range ops\n \n vector next_order = current_order;\n \n if (move_type == 0) { // Swap\n swap(next_order[i], next_order[j]);\n } else if (move_type == 1) { // Reverse\n reverse(next_order.begin() + i, next_order.begin() + j + 1);\n } else { // Insert block\n // Move block [i, j] to position k\n // If we define block size and dest, it's clearer.\n // Let's define: pick block starting at i with length l, move to k\n int l = (rng() % 5) + 1; // Small blocks\n if (i + l > M) l = M - i;\n int end_block = i + l; // exclusive\n \n // Extract block\n vector block;\n vector remaining;\n for(int x=0; x= i && x < end_block) block.push_back(current_order[x]);\n else remaining.push_back(current_order[x]);\n }\n \n int k = rng() % (remaining.size() + 1);\n next_order = remaining;\n next_order.insert(next_order.begin() + k, block.begin(), block.end());\n }\n \n // Evaluate\n string next_s = indices_to_string(next_order);\n // Optimization: Is it possible to incrementally update cost?\n // The cost function is highly non-linear due to keyboard layout.\n // Recalculating full DP is roughly 1000 * 80 ops ~ 80k ops. \n // We can do ~2 * 10^8 ops per sec, so ~2500 evals per sec. \n // With 2 sec, we get ~5000 evals. This is a bit low for SA.\n // But string length is often < 1000. M=200, avg overlap ~2 -> len ~ 600.\n // Let's try full eval.\n \n int next_cost = estimate_typing_cost(next_s);\n \n int delta = next_cost - current_cost;\n bool accept = false;\n if (delta < 0) {\n accept = true;\n } else {\n double prob = exp(-delta / temp);\n if (generate_canonical(rng) < prob) {\n accept = true;\n }\n }\n \n if (accept) {\n current_order = next_order;\n current_cost = next_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_order = current_order;\n }\n }\n }\n\n // Final Output Generation\n string final_s = indices_to_string(best_order);\n auto result = solve_typing(final_s);\n \n for (auto p : result.second) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"/**\n * AHC030 - Polyomino Oil Field Search\n * \n * Strategy:\n * 1. Representation: We represent the state as a set of possible positions for each of the M polyominoes.\n * Since N and M are small (N<=20, M<=20), we can manage the possibilities.\n * \n * 2. Bayesian Inference / MCMC Approach:\n * The problem asks us to find the true configuration of M polyominoes placed on the NxN grid.\n * Let a configuration C be defined by the top-left coordinates (r_k, c_k) for each polyomino k=1..M.\n * We want to find C_true.\n * \n * We maintain a probability distribution over possible positions for each piece. However, the joint\n * distribution is too large ((N^2)^M).\n * Instead, we can keep a pool of \"valid candidates\" or perform a restricted search.\n * Since we need to query to gain information, we need to calculate the expected information gain or \n * simply reduce the entropy of the grid.\n * \n * Phase 1: Initial Scanning\n * - Perform \"divination\" queries (type 2) on large blocks (e.g., 2x2, 3x3, or larger depending on N).\n * A query on a set S returns a noisy sum of overlaps.\n * Cost is 1/sqrt(k). Larger k is cheaper but noisier.\n * We want to identify regions with high probability of containing oil.\n * \n * Phase 2: Refinement & Drill\n * - Based on the divination results, we update the probabilities of each polyomino being at each location.\n * - We calculate the \"marginal probability\" P(v(i,j) > 0) for each cell.\n * - If P(v(i,j) > 0) is very high (near 1) or very low (near 0), we are confident.\n * - If we are uncertain, we can drill (type 1, cost 1, exact result) or divine more.\n * - Drilling is expensive but gives ground truth. Divining is cheap but noisy.\n * \n * Since the total cost is summed up, and we want to minimize it, type 2 queries are very powerful \n * if used effectively.\n * \n * Algorithm Details:\n * 1. Generate all possible translations for each polyomino. Let L_k be the list of valid top-lefts for piece k.\n * 2. Maintain a set of \"plausible configurations\". Initially, this is too large.\n * Instead, we can use a greedy + local search or simple constraint satisfaction approach.\n * \n * High-level flow:\n * - Step 1: Divide the grid into disjoint small blocks (e.g., 4x4 or 3x3). Query them with type 2.\n * This gives us a rough heatmap.\n * - Step 2: Solve a CSP / Optimization problem: Find a configuration of (r_k, c_k) that best explains\n * the observed query results.\n * Let the observed value for query q be O_q. The expected value for a config C is E_q(C).\n * We want to minimize sum |O_q - E_q(C)| (weighted by variance).\n * Since observations are noisy, we can't strictly prune, but we can compute likelihoods.\n * \n * - Step 3: Calculate entropy of each cell based on the top K likely configurations.\n * Select the cell with highest entropy (closest to p=0.5 for v(i,j)>0) to drill.\n * Or select a set of cells to divine to differentiate between top configurations.\n * \n * - Step 4: Once we drill, we have hard constraints. Prune the search space of (r_k, c_k).\n * If a config is inconsistent with a drill result v(i,j), it is invalid (or we update the logic to handle overlaps).\n * Actually, v(i,j) is the count of overlaps. So v(i,j) from drill is a hard constraint on sum of overlaps.\n * \n * - Step 5: Repeat until the solution is unique or we are confident enough to guess.\n * The 'guess' operation allows retrying, but costs 1 if wrong.\n * \n * Heuristic for \"Likely Configurations\":\n * - Since M is up to 20, we can't iterate all combinations.\n * - We can use Hill Climbing / Simulated Annealing to find a configuration that fits current history.\n * - We keep a collection of distinct high-likelihood configurations.\n * - From this collection, we compute p(i,j) = fraction of configs having oil at (i,j).\n * - If p(i,j) > threshold, assume oil. If < 1-threshold, assume empty.\n * - If ambiguous, drill.\n * \n * Specifics for N <= 20:\n * - The grid is very small. N^2 = 400 max.\n * - Operations limit 2*N^2 = 800.\n * - We can drill quite a bit if needed, but cost is the score. We want to minimize drills.\n * - Divination is cost 1/sqrt(k). For k=16 (4x4), cost is 0.25. Much cheaper than drill.\n * \n * Modified Flow:\n * 1. Initial broad queries: Cover the grid with type 2 queries (e.g. partition into 3x3 or 4x4).\n * 2. Solver Loop:\n * a. Run SA/HC to find a set of valid configurations that match all history (drills + divinations).\n * - Cost function for SA: Log-likelihood of divination results + Hard penalty for drill violations.\n * b. Analyze the pool of solutions.\n * - If all solutions agree on the set of positive cells { (i,j) | v(i,j)>0 }, make a guess.\n * - Identify the cell (i,j) where the solutions disagree most (variance of v(i,j) is high).\n * - Drill that cell.\n * c. Add the new info to history and repeat.\n * \n * Handling \"v(i,j)\" vs \"v(i,j)>0\":\n * - The final answer requires the set of cells where v(i,j) > 0.\n * - Drill returns exact v(i,j).\n * - Divination returns noisy sum.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconstexpr int MAX_N = 20;\nconstexpr int MAX_M = 20;\n\n// Globals from input\nint N, M;\ndouble EPSILON;\n\nstruct Point {\n int r, c;\n bool operator<(const Point& other) const {\n return r < other.r || (r == other.r && c < other.c);\n }\n bool operator==(const Point& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nstruct Polyomino {\n int id;\n int size;\n vector shape; // relative to (0,0) being top-left of bounding box\n};\nvector polys;\n\n// Precomputed valid positions for each polyomino\n// valid_positions[k] = list of (r, c) top-left coordinates such that poly k fits in NxN\nstruct Position {\n int r, c; // top-left\n};\nvector> possible_placements;\n// Maps poly_idx -> placement_idx -> list of cells occupied (absolute coords)\nvector>> precomputed_cells;\n\n// History\nstruct DrillResult {\n int r, c;\n int val;\n};\nvector drill_history;\n\nstruct DivinationResult {\n vector query_cells;\n int result_val;\n};\nvector div_history;\n\n// Grid state\n// -1: unknown, >=0: known exact value\nint known_grid[MAX_N][MAX_N]; \n\n// Random number generation\nmt19937 rng(12345);\n\n// Time management\nchrono::steady_clock::time_point start_time;\ndouble time_limit = 2.8;\n\ndouble get_time() {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// I/O Helpers\nint query_drill(int r, int c) {\n cout << \"q 1 \" << r << \" \" << c << endl;\n int resp;\n cin >> resp;\n return resp;\n}\n\nint query_divine(const vector& pts) {\n cout << \"q \" << pts.size();\n for (const auto& p : pts) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int resp;\n cin >> resp;\n return resp;\n}\n\nbool guess_answer(const vector& pts) {\n cout << \"a \" << pts.size();\n for (const auto& p : pts) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int resp;\n cin >> resp;\n return resp == 1;\n}\n\nvoid debug_color(int r, int c, string color) {\n cout << \"#c \" << r << \" \" << c << \" \" << color << endl;\n}\n\n// Precomputation\nvoid precompute() {\n possible_placements.resize(M);\n precomputed_cells.resize(M);\n for (int k = 0; k < M; ++k) {\n // find bounding box\n int max_r = 0, max_c = 0;\n for(auto& p : polys[k].shape) {\n max_r = max(max_r, p.r);\n max_c = max(max_c, p.c);\n }\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (r + max_r < N && c + max_c < N) {\n possible_placements[k].push_back({r, c});\n vector occupied;\n for(auto& p : polys[k].shape) {\n occupied.push_back({r + p.r, c + p.c});\n }\n precomputed_cells[k].push_back(occupied);\n }\n }\n }\n }\n}\n\n// Solver State\nstruct State {\n vector placement_indices; // index into possible_placements[k]\n \n // Derived grid sum\n // This is expensive to recompute from scratch, so we might want incremental updates in SA\n // But N is small, maybe recomputing is fine for now.\n};\n\n// Probability helper\n// Returns log probability of observing 'obs' given true value 'v' and size 'k'\ndouble log_prob_divine(int k_cells, int v_sum, int obs) {\n double mean = (k_cells - v_sum) * EPSILON + v_sum * (1.0 - EPSILON);\n double var = k_cells * EPSILON * (1.0 - EPSILON);\n double sigma = sqrt(var);\n \n // Normal distribution PDF: P(x) = (1 / (sigma * sqrt(2pi))) * exp( -0.5 * ((x - mu)/sigma)^2 )\n // We observed 'obs', which is round(sample). So we integrate the PDF over [obs-0.5, obs+0.5].\n // However, for optimization, comparing densities at 'obs' is usually sufficient for \"score\".\n // Or simply use squared error term if we assume Gaussian.\n // (obs - mean)^2 / (2 * var)\n \n return -0.5 * pow(obs - mean, 2) / var;\n}\n\n// Cost function for SA\n// Lower is better\ndouble calculate_energy(const State& s) {\n // 1. Check Drill Consistency (Hard Constraints)\n // We can actually enforce this during neighbor generation, but let's check here\n static int grid_counts[MAX_N][MAX_N];\n for(int r=0; r minimize negative log likelihood\n for(const auto& div : div_history) {\n int current_sum = 0;\n for(auto& p : div.query_cells) {\n current_sum += grid_counts[p.r][p.c];\n }\n double lp = log_prob_divine(div.query_cells.size(), current_sum, div.result_val);\n energy -= lp; // Subtract log prob\n }\n\n return energy;\n}\n\n// Check if a state is consistent with hard constraints (drills)\nbool is_consistent(const State& s) {\n static int grid_counts[MAX_N][MAX_N];\n for(int r=0; r> N >> M >> EPSILON;\n polys.resize(M);\n for (int i = 0; i < M; ++i) {\n int d;\n cin >> d;\n polys[i].id = i;\n polys[i].size = d;\n for (int j = 0; j < d; ++j) {\n int r, c;\n cin >> r >> c;\n polys[i].shape.push_back({r, c});\n }\n }\n\n precompute();\n\n for(int r=0; r 15) block_size = 3; // 3x3 for larger maps to save queries\n \n // To avoid TLE in logic part and maximize info, we might do a checkered pattern or full tiling.\n // Full tiling is safest.\n for (int r = 0; r < N; r += block_size) {\n for (int c = 0; c < N; c += block_size) {\n vector pts;\n for (int dr = 0; dr < block_size; ++dr) {\n for (int dc = 0; dc < block_size; ++dc) {\n if (r + dr < N && c + dc < N) {\n pts.push_back({r + dr, c + dc});\n }\n }\n }\n if (pts.size() >= 2) { // Requirement: set size >= 2\n int res = query_divine(pts);\n div_history.push_back({pts, res});\n }\n }\n }\n\n // ------------------------------------------------\n // Main Loop: Drill and Refine\n // ------------------------------------------------\n // We maintain a set of \"good\" samples found by SA.\n // From these samples, we compute marginals and decide where to drill.\n\n while (get_time() < time_limit) {\n // Run Simulated Annealing to find a pool of consistent configurations\n vector pool;\n const int POOL_SIZE = 25; // Small pool due to time constraints\n \n // Generate pool\n // We run SA multiple times or one long run keeping best states?\n // Multiple short runs is better to escape local optima.\n \n for (int run = 0; run < POOL_SIZE; ++run) {\n if (get_time() > time_limit) break;\n\n State current;\n current.placement_indices.resize(M);\n // Random initialization\n for(int k=0; k dist(0, possible_placements[k].size() - 1);\n current.placement_indices[k] = dist(rng);\n }\n \n double current_energy = calculate_energy(current);\n \n // SA params\n double temp = 10.0;\n double cooling = 0.95;\n int steps = 200; // Increase if grid is large\n if (N > 15) steps = 300;\n\n for (int step = 0; step < steps; ++step) {\n // Neighbor: pick a piece and move it\n int k = uniform_int_distribution(0, M - 1)(rng);\n int old_idx = current.placement_indices[k];\n int new_idx = uniform_int_distribution(0, possible_placements[k].size() - 1)(rng);\n \n if(old_idx == new_idx) continue;\n\n current.placement_indices[k] = new_idx;\n double new_energy = calculate_energy(current);\n \n if (new_energy < current_energy) {\n current_energy = new_energy;\n } else {\n double prob = exp((current_energy - new_energy) / temp);\n if (generate_canonical(rng) < prob) {\n current_energy = new_energy;\n } else {\n // Revert\n current.placement_indices[k] = old_idx;\n }\n }\n temp *= cooling;\n }\n \n // Store if reasonable quality\n // \"Reasonable\" means hard constraints are satisfied (energy < 1e8)\n if (current_energy < 1e8) {\n pool.push_back(current);\n }\n }\n \n if (pool.empty()) {\n // This shouldn't happen unless hard constraints are contradictory or SA failed bad.\n // Fallback: Drill a random unknown cell\n vector unknown_cells;\n for(int r=0; r(0, unknown_cells.size()-1)(rng);\n int val = query_drill(unknown_cells[idx].r, unknown_cells[idx].c);\n known_grid[unknown_cells[idx].r][unknown_cells[idx].c] = val;\n drill_history.push_back({unknown_cells[idx].r, unknown_cells[idx].c, val});\n continue;\n }\n\n // Analyze pool\n // Calculate p(cell > 0)\n vector> positive_counts(N, vector(N, 0));\n for(const auto& s : pool) {\n // Reconstruct grid\n static int g[MAX_N][MAX_N];\n for(int r=0;r 0) positive_counts[r][c]++;\n }\n\n // Determine most uncertain cell\n // We want a cell where the pool disagrees most (closest to 50% positive)\n // But we also prioritize cells that haven't been drilled.\n double best_uncertainty = -1.0;\n Point best_p = {-1, -1};\n \n // Also check if all consistent solutions agree on the output set\n bool all_agree = true;\n vector first_sol_set;\n {\n // Build set for first sol\n set s1;\n static int g[MAX_N][MAX_N];\n for(int r=0;r0) first_sol_set.push_back({r,c});\n }\n\n for(size_t i=1; i s_curr;\n static int g[MAX_N][MAX_N];\n for(int r=0;r curr_set;\n for(int r=0;r0) curr_set.push_back({r,c});\n \n if(curr_set.size() != first_sol_set.size()) { all_agree = false; break; }\n for(size_t j=0; j= 5) {\n // Construct the answer from first_sol_set\n // Need to ensure drilled 0s are not in set, drilled >0 are in set (already handled by consistency)\n if (guess_answer(first_sol_set)) {\n return 0;\n } else {\n // Wrong guess. The pool was biased.\n // We need more info. Drill something not in history but maybe in the set?\n // Or just continue loop, the cost 1 penalty is applied.\n // To diversify, let's drill a random cell from the guessed set to confirm values?\n // Or better, drill a random uncertain cell if any exist, or just random.\n }\n }\n\n // Find best drill target\n for(int r=0; r best_uncertainty) {\n best_uncertainty = uncertainty;\n best_p = {r, c};\n }\n }\n }\n \n if (best_p.r != -1) {\n int val = query_drill(best_p.r, best_p.c);\n known_grid[best_p.r][best_p.c] = val;\n drill_history.push_back({best_p.r, best_p.c, val});\n } else {\n // All cells in pool are agreed upon (all 0 or all >0), but maybe we failed a guess?\n // Drill a random undrilled cell to increase constraints\n vector unknown_cells;\n for(int r=0; r ans;\n for(int r=0; r 0) ans.push_back({r, c});\n if(guess_answer(ans)) return 0;\n else break; // Should not happen if grid is fully drilled\n }\n \n int idx = uniform_int_distribution(0, unknown_cells.size()-1)(rng);\n int val = query_drill(unknown_cells[idx].r, unknown_cells[idx].c);\n known_grid[unknown_cells[idx].r][unknown_cells[idx].c] = val;\n drill_history.push_back({unknown_cells[idx].r, unknown_cells[idx].c, val});\n }\n }\n\n // Final fallback if time runs out\n // Collect all known > 0 and whatever the last pool suggests\n // This is just a desperate guess.\n return 0;\n}","ahc031":"/**\n * AHC031 - Event Hall Management\n *\n * Strategy:\n * 1. Vertical Stripe Decomposition:\n * We divide the 1000x1000 grid into several vertical columns (stripes).\n * This simplifies the 2D packing problem into a series of 1D problems.\n * This structure is maintained across all days to minimize partition movement costs.\n *\n * 2. Initial Partitioning:\n * We determine the width of these vertical columns. Since the total area demand\n * fluctuates, we aim for a robust partitioning that can handle the peak demands\n * of groups of reservations. A simple approach is to divide the width (1000)\n * into N parts or fewer, but fixed width columns are easier to manage.\n * However, demands vary greatly. A better approach is to group the N reservations\n * into K groups, and assign a column to each group. The width of the column is\n * proportional to the average/max demand of that group.\n *\n * 3. Cost Function:\n * Total Cost = (Area Penalty) + (Partition Cost).\n * Area Penalty = 100 * max(0, target_area - actual_area).\n * Partition Cost = Length of added/removed walls.\n * \n * Since Area Penalty weight (100) is significantly higher than Partition Cost (1),\n * satisfying area requirements is the primary goal. Partition stability is secondary\n * but crucial for high scores.\n *\n * 4. Algorithm Overview:\n * a. Grouping: For every day, we sort requests $a_{d,k}$. However, the input is already sorted.\n * We want to map reservation $k$ to a specific physical area (slot) consistently across days\n * to minimize wall movement. Since $a_{d,k}$ is sorted by size, simply mapping index $k$\n * to the same spatial region is a good heuristic.\n * \n * b. Grid Division Strategy:\n * Instead of arbitrary rectangles, we enforce a strict grid-like structure.\n * We slice the $W=1000$ width into $K$ vertical strips.\n * Let's try to map the $N$ requests into these strips.\n * Since $N$ is up to 50, one strip per request might be too thin or rigid.\n * However, the problem states $N$ is constant for all days.\n * \n * We can use a \"stable layout\" approach.\n * We try to fix the vertical partitions (x-coordinates) for all days.\n * Let's say we divide the width $W$ into a set of widths $w_0, w_1, \\dots, w_{N-1}$.\n * Then, for each day $d$, reservation $k$ gets the rectangle in column $k$\n * with width $w_k$ and necessary height $h_{d,k} = \\lceil a_{d,k} / w_k \\rceil$.\n * The horizontal line moves day by day.\n * \n * Wait, we can put multiple reservations in one column or spread one reservation across.\n * But 1-to-1 mapping (reservation $k$ -> fixed column $k$) is simplest for stability.\n * \n * Optimization: The widths $w_k$ should be chosen such that they accommodate the \"average\"\n * or \"maximum\" need of reservation $k$ efficiently across all days.\n * Since we pay for changing partitions, keeping $w_k$ constant is essentially free for\n * vertical lines. We only pay for horizontal lines changes.\n * \n * The total width is 1000. We need to distribute 1000 among $N$ columns.\n * Maximize $\\sum_d \\sum_k \\min(a_{d,k}, w_k \\times W)$. Actually we want to minimize penalty.\n * Constraint: $\\sum w_k = 1000$.\n * We can model the height required for reservation $k$ on day $d$ as $h_{d,k} = a_{d,k}/w_k$.\n * If $h_{d,k} > 1000$, we are capped and pay penalty.\n * Since $\\sum a_{d,k} \\le W^2$, usually we can fit everything.\n * \n * Refinement: Maybe columns are too restrictive?\n * What if we simply fill row by row? \n * The partition cost is $L_d$. If we completely change layout, $L_d \\approx$ total perimeter.\n * Total perimeter for $N=50$ rects is roughly $50 \\times 4 \\times \\sqrt{1000^2/50} \\approx 200 \\times 140 \\approx 28000$.\n * Area penalty is $100 \\times$ deficit.\n * If we miss area by 1 unit, cost is 100.\n * So 1 unit of area is worth 100 units of wall length.\n * Wall length is cheap. We should aggressively satisfy area.\n * \n * Let's stick to the \"Fixed Vertical Columns\" strategy as a baseline, then optimize.\n * Why? Because vertical lines at fixed $x$ coordinates cost 0 after day 0.\n * We only pay for moving horizontal dividers.\n * \n * Algorithm Step 1: Determine widths $w_0, \\dots, w_{N-1}$ s.t. $\\sum w_k = 1000$.\n * Objective: Minimize potential overflow.\n * Heuristic: $w_k \\propto \\max_d(a_{d,k})$.\n * \n * Algorithm Step 2: Inside each column $k$ (width $w_k$), on day $d$, \n * we need a rectangle of area $a_{d,k}$.\n * We place it at the top? Or try to align with previous day?\n * Actually, the problem says \"rectangles for different reservations must not overlap\".\n * It does NOT say they must cover the whole grid.\n * The space not used is \"vacant\".\n * So for column $k$, we just allocate a rectangle of size $w_k \\times h_{d,k}$ from the top $(0, y_{start})$.\n * Wait, if we just use $N$ columns, each column contains exactly 1 reservation per day.\n * This is valid and simple.\n * Rectangle $k$: $x \\in [X_k, X_{k+1}]$, $y \\in [0, h_{d,k}]$.\n * Here $h_{d,k} = \\min(1000, \\lceil a_{d,k} / w_k \\rceil)$.\n * Since partitions must be on grid points, $w_k$ must be integer.\n * \n * Is one column per reservation optimal?\n * If $N=50$, average width is 20.\n * If some $a_{d,k}$ is huge, it needs width much larger than 20.\n * Since $a_{d,k}$ are sorted, $k=0$ is small, $k=N-1$ is large.\n * The proportional width allocation handles this.\n *\n * Algorithm Step 3 (Simulated Annealing):\n * Variables: The set of partition x-coordinates $\\{x_1, \\dots, x_{N-1}\\}$. $x_0=0, x_N=1000$.\n * State: A vector of integers representing widths.\n * Score: Total Area Penalty + Partition Cost.\n * Transitions: Move a boundary $x_k$ left or right.\n * \n * Calculation of Score for a set of widths $W = \\{w_0, \\dots, w_{N-1}\\}$:\n * For each day $d$:\n * Current day cost = 0.\n * For each $k$:\n * req = $a_{d,k}$\n * alloc_h = min(1000, (req + w_k - 1) / w_k) -- ceiling div, clamped\n * alloc_area = alloc_h * w_k\n * diff = max(0, req - alloc_area)\n * cost += 100 * diff\n * \n * Transition cost from $d-1$ to $d$:\n * Vertical lines are fixed (cost 0).\n * Horizontal lines:\n * On day $d-1$, rect $k$ had bottom at $y = H_{d-1, k}$.\n * On day $d$, rect $k$ has bottom at $y = H_{d, k}$.\n * Cost += $|H_{d, k} - H_{d-1, k}| \\times (\\text{active segment length})$.\n * Actually, the cost definition is simpler:\n * Horizontal segments on perimeter.\n * Bottom edge of rect $k$ is from $X_k$ to $X_{k+1}$ at height $H_{d,k}$.\n * Top edge is at 0 (always there? No, grid boundary doesn't count for cost).\n * The top edge at $y=0$ is on grid perimeter -> Cost 0.\n * The bottom edge at $y=H_{d,k}$ is internal (unless $H=1000$).\n * If $H_{d,k} < 1000$, we have a horizontal segment.\n * We compare presence of segment at $(x, H)$ on day $d$ vs $d-1$.\n * Since columns are disjoint, we can compute partition cost for each column independently!\n * Cost for column $k$:\n * Horizontal line at $y=H_{d,k}$ exists if $H_{d,k} < 1000$.\n * Horizontal line at $y=H_{d-1,k}$ existed if $H_{d-1,k} < 1000$.\n * If $H_{d,k} == H_{d-1,k}$, no change -> cost 0.\n * If different:\n * Remove old: cost $w_k$ (if old < 1000).\n * Add new: cost $w_k$ (if new < 1000).\n * Vertical lines:\n * The vertical lines at $X_k$ are always there for all days (except if $h=0$?).\n * Actually, we define the rect as $[X_k, X_{k+1}] \\times [0, H_{d,k}]$.\n * Vertical segment at $x=X_k$ exists for $y \\in [0, H_{d,k}]$.\n * Length of vertical wall at $X_k$: $\\max(H_{d,k-1}, H_{d,k})$. (Shared boundary).\n * Wait, boundary between col $k-1$ and $k$:\n * Exists from $y=0$ to $\\max(H_{d, k-1}, H_{d, k})$.\n * Change cost is sum of abs diff of these lengths.\n * This couples columns.\n * \n * Refined Cost Calculation:\n * Let $H_{d,k}$ be height of rect $k$ on day $d$.\n * Area Penalty: $\\sum_{d,k} 100 \\times \\max(0, a_{d,k} - w_k H_{d,k})$.\n * Partition Cost:\n * 1. Horizontal changes:\n * For each $k$, day $d$ vs $d-1$:\n * If $H_{d,k} \\neq H_{d-1,k}$:\n * if $H_{d-1,k} < 1000$ cost += $w_k$ (remove old)\n * if $H_{d,k} < 1000$ cost += $w_k$ (add new)\n * 2. Vertical changes:\n * Boundary between $k$ and $k+1$ is at $X_{k+1}$.\n * Length on day $d$: $L_{d, k} = \\max(H_{d, k}, H_{d, k+1})$.\n * Change cost += $|L_{d, k} - L_{d-1, k}|$.\n * (Boundary 0 and N are grid borders, ignore).\n * \n * We can run Hill Climbing / SA on the widths $w_k$.\n * Since N is small (up to 50), we can optimize this efficiently.\n * \n * Constraint Handling:\n * $\\sum w_k = 1000$.\n * We can pick two indices $i, j$, increase $w_i$ by $\\delta$, decrease $w_j$ by $\\delta$.\n *\n * Initialization:\n * $w_k = \\lfloor 1000 \\times \\frac{\\sum_d a_{d,k}}{\\sum_{d,k} a_{d,k}} \\rfloor$.\n * Distribute remainder.\n * \n * Refinement on Area allocation:\n * If $a_{d,k}$ fits in $w_k \\times 1000$, we set $H_{d,k} = \\lceil a_{d,k}/w_k \\rceil$.\n * If not, $H_{d,k} = 1000$, and we take penalty.\n * Can we do better? Maybe on days where $a_{d,k}$ is small, we have slack.\n * Actually, strict 1-to-1 column mapping is rigid.\n * What if we allow $H_{d,k}$ to be larger than needed?\n * Sometimes keeping $H_{d,k} = H_{d-1,k}$ saves partition cost even if it wastes area (vacant).\n * Yes! For each column $k$, we have a sequence of requirements $R_{0}, \\dots, R_{D-1}$ where $R_d = \\lceil a_{d,k}/w_k \\rceil$.\n * We want to choose actual heights $h_0, \\dots, h_{D-1}$ ($h_d \\ge R_d$) to minimize partition changes.\n * This is a 1D DP problem per column!\n * Cost function for column $k$ sequence $h$:\n * $\\sum_d (\\text{horizontal change cost}) + \\text{vertical coupling?}$\n * Vertical coupling depends on neighbors. This breaks independence.\n * \n * Approximation:\n * Optimize widths $w_k$ assuming minimal required height $h_{d,k} = \\lceil a_{d,k}/w_k \\rceil$.\n * Then, after fixing widths, try to smooth heights to reduce horizontal costs.\n * Then, maybe try to smooth vertical costs? (Harder).\n * \n * Smoothing Heights:\n * For a fixed width $w_k$, we have required heights $req_d$.\n * We want to find $h_d \\ge req_d$ to minimize $\\sum cost(h_d, h_{d-1})$.\n * Horizontal change cost: if $h_d \\neq h_{d-1}$, cost += (h_{d-1}<1000?w:0) + (h_d<1000?w:0).\n * Basically, keeping $h_d = h_{d-1}$ saves $2w$.\n * Vertical coupling makes this complex. But since horizontal walls (width $w$) are usually more expensive than vertical segments (height diffs),\n * smoothing horizontal usage is priority.\n * Actually, vertical change cost is $| \\max(h_{d,k}, h_{d,k+1}) - \\max(h_{d-1,k}, h_{d-1,k+1}) |$.\n * This is often small compared to $2w_k \\approx 40$.\n * So we can smooth heights per column independently as a post-processing or inside the loop if fast enough.\n * \n * Let's refine the \"Smoothing\" DP for column $k$:\n * $DP[d][current\\_h]$? State space too large (1000).\n * Observations: $h_d$ will likely be one of $\\{req_0, \\dots, req_{D-1}\\}$.\n * Restricting $h_d$ to be chosen from the set of required heights reduces state space to $D$.\n * $DP[d][idx]$ = min cost up to day $d$ ending with height $v_{idx}$.\n * This is $O(D^3)$. $D=50 \\implies 125,000$ ops. Very fast.\n * We can do this DP inside the width optimization score function?\n * Maybe too slow to do inside every SA step.\n * Do it greedily inside SA: $h_d = req_d$.\n * Then run the DP after SA finishes.\n * Then maybe run SA again with smoothed values? No, widths change requirements.\n * \n * Final Algorithm Structure:\n * 1. Initialize widths $w_k$ proportional to max demands.\n * 2. SA Optimization of widths:\n * - Move unit width from column $i$ to $j$.\n * - Evaluator: strict height $h_{d,k} = \\lceil a_{d,k}/w_k \\rceil$.\n * Cost = AreaPenalty + HorizontalChange + VerticalChange.\n * 3. Post-process Smoothing:\n * - For each column, run DP to stabilize $h_{d,k}$ (allow $h_{d,k} > req_{d,k}$ to match $h_{d-1,k}$).\n * - Since vertical costs couple columns, we can iterate:\n * Optimize col 0, then 1, ..., N-1, then repeat.\n * 4. Output.\n * \n * Time limit 3.0s is generous for N=50, D=50.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Constants & Inputs ---\nconst int W_SIZE = 1000;\nint D, N;\nvector> A; // A[d][k]\n\n// --- Random Number Generator ---\nmt19937 rng(12345);\n\n// --- Structures ---\nstruct Rect {\n int r1, c1, r2, c2;\n};\n\nstruct Solution {\n vector widths; // size N, sum = 1000\n vector x_coords; // size N+1, x_coords[0]=0\n // For evaluation\n long long score;\n};\n\n// --- Helper Functions ---\n\n// Calculate cost given widths and heights strategy\n// mode 0: Strict heights (h = ceil(req))\nlong long evaluate(const vector& widths, bool precise = false) {\n // Precompute x coordinates\n vector X(N + 1, 0);\n for (int k = 0; k < N; ++k) X[k + 1] = X[k] + widths[k];\n\n long long area_penalty = 0;\n long long partition_cost = 0;\n\n // To compute partition cost, we need the configuration of day d-1.\n // We store the \"effective\" height of the bottom wall of each column.\n // And the vertical wall length at each boundary X[k].\n \n // Day -1 state (initial state is empty hall? Problem says L_0 = 0, so transition to day 0 is free?\n // \"we assume L_0=0 on the first day.\" -> This means the cost of setting up day 0 is 0.\n // The cost is calculated for d=0..D-1. But L_0 is 0. \n // So we only pay for transitions 0->1, 1->2, ..., D-2->D-1.\n // Wait, \"L_d is incurred... L_0=0\".\n // So we calculate transitions d from 1 to D-1.\n \n // We need to store heights for all days to compute transition costs.\n // Let's compute heights first.\n vector> H(D, vector(N));\n \n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int w = widths[k];\n int req = A[d][k];\n int h = 0;\n if (w > 0) {\n h = (req + w - 1) / w;\n if (h > W_SIZE) h = W_SIZE; \n } else {\n h = W_SIZE; // Width 0 implies infinite height needed -> penalty\n }\n H[d][k] = h;\n \n // Area penalty\n long long actual_area = (long long)w * h;\n if (actual_area < req) {\n area_penalty += 100LL * (req - actual_area);\n }\n }\n }\n\n // Partition costs (d=1 to D-1)\n for (int d = 1; d < D; ++d) {\n // Horizontal lines\n for (int k = 0; k < N; ++k) {\n int h_prev = H[d-1][k];\n int h_curr = H[d][k];\n if (h_prev != h_curr) {\n if (h_prev < W_SIZE) partition_cost += widths[k];\n if (h_curr < W_SIZE) partition_cost += widths[k];\n }\n }\n // Vertical lines\n // Vertical line at X[k] (for k=1 to N-1)\n // Length is max(H[d][k-1], H[d][k])\n for (int k = 1; k < N; ++k) {\n int len_prev = max(H[d-1][k-1], H[d-1][k]);\n int len_curr = max(H[d][k-1], H[d][k]);\n if (len_prev != len_curr) {\n partition_cost += abs(len_prev - len_curr);\n }\n }\n }\n \n return area_penalty + partition_cost;\n}\n\n// Function to compute heights with DP smoothing\nvector> smooth_heights(const vector& widths) {\n vector> H(D, vector(N));\n \n // 1. Initial strict requirements\n vector> reqH(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n if (widths[k] == 0) reqH[d][k] = W_SIZE;\n else {\n int val = (A[d][k] + widths[k] - 1) / widths[k];\n reqH[d][k] = min(W_SIZE, val);\n }\n }\n }\n \n // 2. Independent Column Smoothing (DP)\n // For each column, select h[d] >= reqH[d] to minimize horizontal changes.\n // This ignores vertical coupling costs, but horizontal costs (width) >> vertical costs (diff).\n for (int k = 0; k < N; ++k) {\n if (widths[k] == 0) {\n for(int d=0; d candidates;\n candidates.reserve(D + 1);\n for(int d=0; d dp(C, 0); \n \n // Initialize day 0: valid if cand >= reqH[0]\n for (int i = 0; i < C; ++i) {\n if (candidates[i] < reqH[0][k]) dp[i] = 1e18; // Invalid\n else dp[i] = 0; \n }\n\n for (int d = 1; d < D; ++d) {\n vector next_dp(C, 1e18);\n int req = reqH[d][k];\n \n // Optimization: The cost function is:\n // transition(prev_h, curr_h) = (prev_h != curr_h) ? ((prev_h= 1e17) continue;\n int h_prev = candidates[j];\n long long cost = 0;\n if (h_prev != h_curr) {\n if (h_prev < W_SIZE) cost += widths[k];\n if (h_curr < W_SIZE) cost += widths[k];\n }\n if (dp[j] + cost < next_dp[i]) {\n next_dp[i] = dp[j] + cost;\n }\n }\n }\n dp = next_dp;\n }\n \n // Backtrack to find optimal path\n // Need to store parent pointers? Or recompute? C is small, store parent.\n // Let's rewrite with parent pointers.\n }\n\n // Re-implementation of DP with backtracking\n for (int k = 0; k < N; ++k) {\n if (widths[k] == 0) {\n for(int d=0; d candidates;\n for(int d=0; d> dp(D, vector(C, 1e18));\n vector> parent(D, vector(C, -1));\n\n for (int i = 0; i < C; ++i) {\n if (candidates[i] >= reqH[0][k]) dp[0][i] = 0;\n }\n\n for (int d = 1; d < D; ++d) {\n int req = reqH[d][k];\n for (int i = 0; i < C; ++i) {\n int h_curr = candidates[i];\n if (h_curr < req) continue;\n \n for (int j = 0; j < C; ++j) {\n if (dp[d-1][j] > 1e17) continue;\n int h_prev = candidates[j];\n long long cost = 0;\n if (h_prev != h_curr) {\n if (h_prev < W_SIZE) cost += widths[k];\n if (h_curr < W_SIZE) cost += widths[k];\n }\n \n if (dp[d-1][j] + cost < dp[d][i]) {\n dp[d][i] = dp[d-1][j] + cost;\n parent[d][i] = j;\n }\n }\n }\n }\n\n // Find best end\n long long best_cost = 1e18;\n int best_idx = -1;\n for (int i = 0; i < C; ++i) {\n if (dp[D-1][i] < best_cost) {\n best_cost = dp[D-1][i];\n best_idx = i;\n }\n }\n \n // Reconstruct\n for (int d = D - 1; d >= 0; --d) {\n H[d][k] = candidates[best_idx];\n if (d > 0) best_idx = parent[d][best_idx];\n }\n }\n \n return H;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n if (!(cin >> W_SIZE >> D >> N)) return 0;\n A.resize(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 auto start_time = chrono::high_resolution_clock::now();\n\n // 1. Initial Solution: Widths proportional to max demands\n vector widths(N);\n vector max_demands(N, 0);\n long long sum_max_demands = 0;\n \n for (int k = 0; k < N; ++k) {\n for (int d = 0; d < D; ++d) {\n max_demands[k] = max(max_demands[k], (long long)A[d][k]);\n }\n sum_max_demands += max_demands[k];\n }\n \n int current_width_sum = 0;\n for (int k = 0; k < N; ++k) {\n widths[k] = (int)(max_demands[k] * W_SIZE / sum_max_demands);\n // Ensure minimum width 1 if max_demand > 0 (usually true)\n if (widths[k] == 0 && max_demands[k] > 0) widths[k] = 1;\n current_width_sum += widths[k];\n }\n \n // Adjust sum to 1000\n while (current_width_sum < W_SIZE) {\n int k = rng() % N;\n widths[k]++;\n current_width_sum++;\n }\n while (current_width_sum > W_SIZE) {\n int k = rng() % N;\n if (widths[k] > 1) {\n widths[k]--;\n current_width_sum--;\n }\n }\n \n long long current_score = evaluate(widths);\n vector best_widths = widths;\n long long best_score = current_score;\n\n // 2. Simulated Annealing\n // We have about 2.8 seconds.\n double TIME_LIMIT = 2.8;\n \n // Constants for SA\n double temp_start = 2000.0;\n double temp_end = 10.0;\n \n int iter = 0;\n while (true) {\n iter++;\n if ((iter & 255) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n \n // Update temp\n double ratio = elapsed / TIME_LIMIT;\n double temp = temp_start * pow(temp_end / temp_start, ratio);\n \n // Mutation: Pick i, j. Give width from i to j.\n int i = rng() % N;\n int j = rng() % N;\n if (i == j) continue;\n if (widths[i] <= 1) continue; // Don't make width 0 unless necessary? (Actually width 0 is valid but bad)\n \n // Try move\n widths[i]--;\n widths[j]++;\n \n long long new_score = evaluate(widths);\n long long delta = new_score - current_score;\n \n bool accept = false;\n if (delta < 0) accept = true;\n else if (exp(-delta / temp) > (double)(rng() % 10000) / 10000.0) accept = true;\n \n if (accept) {\n current_score = new_score;\n if (current_score < best_score) {\n best_score = current_score;\n best_widths = widths;\n }\n } else {\n // Revert\n widths[i]++;\n widths[j]--;\n }\n } else {\n // Duplicated logic inside loop for performance (skipping time check)\n // Simplified logic for inner iterations\n int i = rng() % N;\n int j = rng() % N;\n if (i == j) continue;\n if (widths[i] <= 1) continue;\n \n widths[i]--;\n widths[j]++;\n long long new_score = evaluate(widths);\n \n // Fixed temp for inner loop? No, just use current approx temp logic or just greedy for a bit?\n // Actually, calculating temp every time is slow? No, pow is slow.\n // Just do greedy hill climbing in inner loops? No, SA needs temp.\n // Let's just stick to the batched time check structure.\n // The above \"if ((iter & 255) == 0)\" block handles one iteration.\n // I should move the logic out.\n }\n // Correct loop structure:\n // 1. Check time every 256 iters.\n // 2. Perform mutation.\n }\n\n // Correct Loop implementation\n iter = 0;\n double temp = temp_start;\n while(true) {\n iter++;\n if ((iter & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n double ratio = elapsed / TIME_LIMIT;\n temp = temp_start * pow(temp_end / temp_start, ratio);\n }\n\n int i = rng() % N;\n int j = rng() % N;\n if (i == j) continue;\n if (widths[i] <= 1) continue; \n \n int diff = 1; \n // larger moves?\n if (widths[i] > 10 && (rng()%5 == 0)) diff = 1 + rng() % (widths[i]/5);\n\n widths[i] -= diff;\n widths[j] += diff;\n \n long long new_score = evaluate(widths);\n long long delta = new_score - current_score;\n \n if (delta <= 0 || exp(-delta / temp) > (double)(rng() % 10000) / 10000.0) {\n current_score = new_score;\n if (current_score < best_score) {\n best_score = current_score;\n best_widths = widths;\n }\n } else {\n widths[i] += diff;\n widths[j] -= diff;\n }\n }\n \n // 3. Post-processing: Smoothing Heights with fixed best widths\n widths = best_widths;\n vector> final_H = smooth_heights(widths);\n \n // Compute X coords\n vector X(N + 1, 0);\n for (int k = 0; k < N; ++k) X[k + 1] = X[k] + widths[k];\n \n // Output\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int r1 = 0;\n int c1 = X[k];\n int r2 = final_H[d][k];\n int c2 = X[k+1];\n \n // If width is 0, output a valid empty rectangle (e.g., same coords)\n // Spec: 0 <= i < i' <= W. Area > 0?\n // \"rent a rectangular section of at least area a_{d,k}\"\n // \"rectangles ... must not have a positive area in common.\"\n // \"0 <= i < i' <= W\" implies i' > i, so area > 0.\n // If our width is 0, we cannot output a valid rectangle.\n // But our logic ensures widths[k] >= 1 (in initialization and SA).\n // Exception: if N is very large, maybe? But N <= 50, W=1000. Min width 1 is always possible.\n \n cout << r1 << \" \" << c1 << \" \" << r2 << \" \" << c2 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"/**\n * Heuristic Solution for Stamp Problem (AHC032)\n *\n * Problem Analysis:\n * 1. The board size is extremely small (9x9).\n * 2. The number of stamps is small (20).\n * 3. The max operations K is small (81). This corresponds exactly to the number of 1x1 cells on the board,\n * but significantly, it's also more than enough to cover the board with 3x3 stamps (since 9x9 / 3x3 = 9 stamps could cover it).\n * However, stamps overlap. The max top-left positions for a 3x3 stamp on a 9x9 board is (N-3+1) x (N-3+1) = 7x7 = 49 positions.\n * So we can theoretically stamp every possible top-left position at least once, or some twice.\n *\n * Objective:\n * Maximize sum( b[i][j] % MOD ) where MOD = 998244353.\n *\n * Key Insight:\n * Since we want to maximize the sum modulo P, this is a non-linear optimization problem due to the modulo operator.\n * A simple greedy approach (always adding the largest value) might get stuck in local optima because adding a value might\n * wrap around the modulo, decreasing the score significantly.\n *\n * State Space:\n * - Total cells: 81.\n * - Possible actions: 20 stamps * 49 positions = 980 actions.\n * - Max depth: 81.\n *\n * This suggests a local search or simulated annealing approach.\n *\n * Algorithm Strategy:\n *\n * 1. **Initial Solution**: Start with an empty set of operations.\n *\n * 2. **State Representation**:\n * - Current board values `current_b[9][9]`.\n * - Current score.\n * - List of operations `ops`.\n *\n * 3. **Neighbor Generation (Hill Climbing / Simulated Annealing)**:\n * We can modify the current solution by:\n * a) ADD: Add a random stamp at a random position (if |ops| < K).\n * b) REMOVE: Remove a random existing operation.\n * c) SWAP_STAMP: Change the stamp type of an existing operation.\n * d) SWAP_POS: Change the position of an existing operation.\n * e) REPLACE: Remove one op and add another (effectively a combination of b and a).\n *\n * Given the constraints and the nature of modulo arithmetic, a simple hill climbing might get stuck easily.\n * Simulated Annealing (SA) is ideal here.\n *\n * 4. **Score Calculation**:\n * We need to efficiently update the score.\n * - Calculating the full score takes O(N^2) = O(81).\n * - Incremental update: When adding/removing a stamp at (p, q), only 3x3 = 9 cells change.\n * Complexity O(9). This is very fast.\n *\n * 5. **Evaluation Function**:\n * Simply the sum of remainders.\n *\n * 6. **Specific Strategy (Beam Search vs SA)**:\n * - **Beam Search**: We could build the sequence of operations one by one.\n * State: (Board, Score). Transitions: Try all 980 possible moves. Keep top B states.\n * Since K is fixed and large (81), and we can stop early, this is essentially filling slots.\n * However, since the order of operations doesn't matter (addition is commutative), treating this as a sequence building problem\n * might be less effective than treating it as a \"set of operations\" problem optimization.\n * Also, \"removing\" isn't natural in Beam Search.\n *\n * - **Simulated Annealing**: Treat the solution as a multiset of operations (size 0 to K).\n * Transitions modify this multiset. The commutative property simplifies things immensely; we don't need to maintain order.\n * We just keep a count of how many times stamp m is applied at (p,q).\n * Let `count[m][p][q]` be the number of times stamp `m` is used at `p, q`.\n * Wait, K is global total count.\n * Since K=81 is relatively small, we can just keep a vector of operations.\n *\n * Let's stick to **Simulated Annealing**. It's robust for this kind of modulo maximization.\n *\n * 7. **Optimizations**:\n * - Fast incremental score update.\n * - Precompute the 3x3 updates.\n * - Time management: run as many iterations as possible within 1.95s.\n *\n * 8. **Refinement**:\n * The \"State\" is simply the current board `B`.\n * The \"Move\" is applying a stamp `(m, p, q)` or removing its inverse.\n * Wait, we can't \"remove\" simply by subtracting if we only store `B % MOD`. We need to handle the modulo logic correctly.\n * Actually, since `B` is just the sum, `(Original + Sum_Ops) % MOD`, subtraction is fine: `(Current - s + MOD) % MOD`.\n *\n * Let's refine the SA moves:\n * - Currently, we have a list of ops.\n * - Neighbor:\n * 1. Add a random op (if size < K).\n * 2. Remove a random op (if size > 0).\n * 3. Modify an op (change m or p or q).\n *\n * Since order doesn't matter, we can just pick an index in our `vector` to modify or remove.\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants and Globals ---\nconstexpr long long MOD = 998244353;\nconstexpr int N = 9;\nconstexpr int M_MAX = 20;\nconstexpr int K_MAX = 81;\nconstexpr int STAMP_SIZE = 3;\nconstexpr double TIME_LIMIT = 1.95; // Seconds\n\nstruct Operation {\n int m;\n int p;\n int q;\n};\n\n// Global inputs\nlong long A[N][N];\nlong long S[M_MAX][STAMP_SIZE][STAMP_SIZE];\nint N_in, M_in, K_in;\n\n// --- Random Number Generator ---\nstruct Xorshift {\n uint64_t x = 88172645463325252ull;\n inline uint64_t next() {\n x ^= x << 13;\n x ^= x >> 7;\n x ^= x << 17;\n return x;\n }\n inline int next_int(int n) {\n return next() % n;\n }\n inline double next_double() {\n return (double)next() / (double)(~0ull);\n }\n} rng;\n\n// --- State Management ---\n\nstruct State {\n long long b[N][N]; // Current board values\n long long score; // Current total score (sum of b[i][j] % MOD)\n vector ops;\n\n State() {\n score = 0;\n for(int i=0; i Decide -> (Update or Rollback).\n// Here, to be fastest:\n// 1. Calculate delta.\n// 2. If accepted, update b and score.\n// 3. If rejected, do nothing.\n\n// But we need to support both Add and Remove.\n\ninline long long calc_add_delta(const State& state, int m, int p, int q) {\n long long delta = 0;\n for(int i=0; i= MOD) new_val -= MOD;\n \n delta += (new_val - old_val);\n }\n }\n return delta;\n}\n\ninline void apply_add(State& state, int m, int p, int q) {\n for(int i=0; i= MOD) val -= MOD;\n }\n }\n state.ops.push_back({m, p, q});\n}\n\ninline long long calc_remove_delta(const State& state, int op_index) {\n const auto& op = state.ops[op_index];\n int m = op.m;\n int p = op.p;\n int q = op.q;\n \n long long delta = 0;\n for(int i=0; i Add new)\n// Returns pair\n// Note: Doing this in one step might be slightly more accurate for gradients, \n// but calculating delta is tricky because the \"Add\" depends on the state *after* \"Remove\".\n// Simple approach: Remove, then Add.\n// To do it purely for delta calculation without modifying state:\ninline long long calc_modify_delta(const State& state, int op_idx, int new_m, int new_p, int new_q) {\n const auto& old_op = state.ops[op_idx];\n int old_m = old_op.m;\n int old_p = old_op.p;\n int old_q = old_op.q;\n\n long long delta = 0;\n\n // Iterate over the union of affected cells (bounding box of old and new)\n // But simpler: just iterate over old 3x3 and new 3x3.\n // Be careful with overlaps if we update a temp board.\n // Since we can't easily clone the board, we do this cell by cell logic.\n \n // Map to store temporary changes for delta calculation\n // Key: (row << 8) | col, Value: current_value\n // Since N is small (9), we can use a small flat array or iterate carefully.\n // 3x3 is small enough. Let's just do it:\n // 1. Calculate effect of removal.\n // 2. Calculate effect of addition on top of removal.\n \n // To avoid allocating memory, we iterate through all 9x9 cells? No, just the affected ones.\n // Affected: (old_p, old_q) 3x3 AND (new_p, new_q) 3x3.\n \n // Let's use a small static buffer for the 9x9 board diffs, but that's overkill.\n // We can iterate the union of the two 3x3 areas.\n \n int min_r = min(old_p, new_p);\n int max_r = max(old_p, new_p) + 2;\n int min_c = min(old_q, new_q);\n int max_c = max(old_q, new_q) + 2;\n \n for(int r = min_r; r <= max_r; ++r) {\n for(int c = min_c; c <= max_c; ++c) {\n long long val = state.b[r][c];\n long long original_val = val;\n \n // Apply removal if inside old stamp\n if (r >= old_p && r < old_p + 3 && c >= old_q && c < old_q + 3) {\n val -= S[old_m][r - old_p][c - old_q];\n if (val < 0) val += MOD;\n }\n \n // Apply addition if inside new stamp\n if (r >= new_p && r < new_p + 3 && c >= new_q && c < new_q + 3) {\n val += S[new_m][r - new_p][c - new_q];\n if (val >= MOD) val -= MOD;\n }\n \n delta += (val - original_val);\n }\n }\n \n return delta;\n}\n\ninline void apply_modify(State& state, int op_idx, int new_m, int new_p, int new_q) {\n const auto& old_op = state.ops[op_idx];\n int old_m = old_op.m;\n int old_p = old_op.p;\n int old_q = old_op.q;\n\n // Remove old\n for(int i=0; i= MOD) val -= MOD;\n }\n }\n \n state.ops[op_idx] = {new_m, new_p, new_q};\n}\n\n\n// --- Main Solver ---\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n cin >> N_in >> M_in >> K_in;\n for(int i=0; i> A[i][j];\n }\n }\n for(int m=0; m> S[m][i][j];\n }\n }\n }\n\n auto start_time = chrono::high_resolution_clock::now();\n\n State current_state;\n \n // Better Initial Solution?\n // Maybe fill randomly up to K? Or just start empty.\n // Starting empty allows SA to grow the solution naturally.\n // Given K is small, we can try to fill it.\n // Let's start with K/2 random operations.\n for(int k=0; k 0) { // Greedy initialization\n apply_add(current_state, m, p, q);\n current_state.score += delta;\n }\n }\n\n State best_state = current_state;\n \n // SA Parameters\n double t0 = 2e8; // Initial temperature (tuned)\n double t1 = 1e0; // Final temperature\n double temp = t0;\n int iter = 0;\n \n while (true) {\n iter++;\n if ((iter & 0xFF) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n \n // Temperature update (linear decay or exponential)\n double progress = elapsed / TIME_LIMIT;\n temp = t0 * pow(t1/t0, progress);\n }\n\n int type = rng.next_int(3); \n // 0: ADD\n // 1: REMOVE\n // 2: MODIFY\n \n // Bias towards MODIFY once we are full\n if (current_state.ops.size() == K_in && type == 0) type = 2;\n if (current_state.ops.empty() && (type == 1 || type == 2)) type = 0;\n\n if (type == 0) { // ADD\n if (current_state.ops.size() >= K_in) continue;\n \n int m = rng.next_int(M_in);\n int p = rng.next_int(N - 2);\n int q = rng.next_int(N - 2);\n \n long long delta = calc_add_delta(current_state, m, p, q);\n \n if (delta > 0 || rng.next_double() < exp(delta / temp)) {\n apply_add(current_state, m, p, q);\n current_state.score += delta;\n if (current_state.score > best_state.score) {\n best_state = current_state;\n }\n }\n }\n else if (type == 1) { // REMOVE\n if (current_state.ops.empty()) continue;\n \n int idx = rng.next_int(current_state.ops.size());\n \n long long delta = calc_remove_delta(current_state, idx);\n \n if (delta > 0 || rng.next_double() < exp(delta / temp)) {\n apply_remove(current_state, idx);\n current_state.score += delta;\n // Usually removing lowers score, but it might escape local optima\n if (current_state.score > best_state.score) {\n best_state = current_state;\n }\n }\n }\n else if (type == 2) { // MODIFY\n if (current_state.ops.empty()) continue;\n \n int idx = rng.next_int(current_state.ops.size());\n \n // Small perturbation: change position slightly OR change stamp\n int subtype = rng.next_int(2);\n int new_m = current_state.ops[idx].m;\n int new_p = current_state.ops[idx].p;\n int new_q = current_state.ops[idx].q;\n \n if (subtype == 0) { // Change Stamp\n new_m = rng.next_int(M_in);\n } else { // Change Pos\n // Try moving nearby first\n int d = rng.next_int(5); // 0..4\n if (d==0) new_p = max(0, new_p - 1);\n else if (d==1) new_p = min(N - 3, new_p + 1);\n else if (d==2) new_q = max(0, new_q - 1);\n else if (d==3) new_q = min(N - 3, new_q + 1);\n else {\n // Random jump\n new_p = rng.next_int(N - 2);\n new_q = rng.next_int(N - 2);\n }\n }\n \n if (new_m == current_state.ops[idx].m && new_p == current_state.ops[idx].p && new_q == current_state.ops[idx].q) continue;\n\n long long delta = calc_modify_delta(current_state, idx, new_m, new_p, new_q);\n \n if (delta > 0 || rng.next_double() < exp(delta / temp)) {\n apply_modify(current_state, idx, new_m, new_p, new_q);\n current_state.score += delta;\n if (current_state.score > best_state.score) {\n best_state = current_state;\n }\n }\n }\n }\n\n // Output\n cout << best_state.ops.size() << \"\\n\";\n for (const auto& op : best_state.ops) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"/**\n * AHC033 - Container Terminal\n * Heuristic Solution\n * \n * Strategy Overview:\n * 1. Task Assignment: \n * - We treat the grid as a flow system.\n * - Crane 0 (Big Crane) is special because it can fly over obstacles. It is best suited for fixing deadlocks or moving high-priority containers that are blocked.\n * - Cranes 1-4 (Small Cranes) operate mostly in their respective rows or adjacent rows.\n * \n * 2. Buffer Management:\n * - The grid is small (5x5). We need to use the middle columns (1, 2, 3) as buffers.\n * - Column 0 is for input, Column 4 is for output.\n * \n * 3. Priority based Greedy with Lookahead:\n * - We simulate the state turn by turn.\n * - At each turn, we decide the move for all cranes.\n * - Since N=5 is very small, we can perform a search (Beam Search or sophisticated Greedy).\n * - The state space includes:\n * - Grid configuration (containers at each cell).\n * - Crane positions and status (holding container?).\n * - Input queue status for each row.\n * - Output requirement status for each row.\n * \n * 4. Simplified Logic for this implementation:\n * - We will implement a strong rule-based controller with basic search.\n * - Each crane tries to pick up a container from (row, 0) if it's available.\n * - If holding a container:\n * - Determine its target row based on container ID. (Container C goes to row floor(C/N)).\n * - If the target output slot is ready for this container, move to (target_row, N-1).\n * - If not ready, move to a \"temporary\" storage location. Good storage spots are cells in columns 1-3 that are not blocking immediate paths.\n * - Ideally, we want to move containers directly from (r1, 0) to (r2, 4).\n * - Since small cranes cannot pass over containers, pathfinding is essentially a cooperative pathfinding problem (MAPF).\n * - We use the large crane (Crane 0) to clear bottlenecks or perform \"impossible\" moves for small cranes.\n * \n * 5. Algorithm structure:\n * - A central `Solver` class manages the state.\n * - `solve()` function iterates up to 10000 turns or until done.\n * - At each step, we identify high-level tasks: \"Move container C from A to B\".\n * - We use A* or BFS for low-level pathfinding for cranes, taking into account dynamic obstacles (other cranes and containers).\n * - To avoid collisions, we plan moves sequentially or use a reservation table.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst int N = 5;\nconst int MAX_TURNS = 10000;\nconst int INVALID = -1;\n\n// Directions: 0:U, 1:D, 2:L, 3:R, 4:., 5:P, 6:Q, 7:B\nconst int DR[] = {-1, 1, 0, 0, 0, 0, 0, 0};\nconst int DC[] = {0, 0, -1, 1, 0, 0, 0, 0};\nconst char OP_CHARS[] = \"UDLR.PQB\";\n\n// --- Structures ---\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { return tie(r, c) < tie(other.r, other.c); }\n int dist(const Point& other) const { return abs(r - other.r) + abs(c - other.c); }\n};\n\nstruct Container {\n int id;\n // Target row for output is id / N\n // Target order index is id % N\n int targetRow() const { return id / N; }\n int targetOrder() const { return id % N; }\n};\n\nstruct Crane {\n int id; // 0 is large, 1-4 are small\n Point pos;\n int holding_container_id = INVALID; // INVALID if empty\n bool bombed = false;\n\n bool isLarge() const { return id == 0; }\n bool hasContainer() const { return holding_container_id != INVALID; }\n};\n\nstruct State {\n int turn = 0;\n int grid_container[N][N]; // Container ID at (r, c), or INVALID\n vector input_queues[N]; // Remaining containers to arrive at row i\n int input_idx[N]; // Index of next container to arrive for row i\n \n int next_output_val[N]; // The next expected container ID for output row i (starts at row*N)\n int dispatched_count = 0;\n\n vector cranes;\n\n State() {\n for(int i=0; i Move -> Output.\n \n // 3. Dispatch Gates\n for(int i=0; i command_history;\n\n Solver(const vector>& inputs) {\n state = State();\n for(int i=0; i= 0 && r < N && c >= 0 && c < N;\n }\n\n // Check if a crane moving from u to v is valid regarding small crane height constraint\n bool canMove(const Crane& crane, Point from, Point to, const State& s) {\n if (!isValidPos(to.r, to.c)) return false;\n if (crane.bombed) return false; // Bombed cranes can't move\n \n // Small crane with container cannot enter a cell with a container\n if (!crane.isLarge() && crane.hasContainer()) {\n if (s.grid_container[to.r][to.c] != INVALID) return false;\n }\n return true;\n }\n\n // Main solve loop\n void solve() {\n // Initial Environment Update (Turn 0 setup)\n state.updateEnv();\n\n for (int t = 0; t < MAX_TURNS; ++t) {\n if (state.isDone()) break;\n\n // Decision making for this turn\n vector moves(N, 4); // Default '.'\n \n // Simple reservation table for next positions to avoid collision\n // Maps pos -> crane_id\n map next_positions; \n \n // Strategy:\n // 1. Assign tasks. \n // Task: Move container C to correct output row buffer or final slot.\n // Priority: Output ready > Input blocking > Storage management.\n \n // We iterate cranes. For each crane, we try to find a meaningful move.\n // To prevent collisions, we process cranes in a specific order (e.g., 0 to 4 or dynamic).\n // Since Crane 0 is powerful, maybe process it last to jump over others? \n // Or process it first to secure important path? \n // Let's process 0 first as it's most flexible, but actually, it's better to let constrained cranes plan first?\n // Let's stick to 0->4 for simplicity, but check validity against previous plans.\n\n vector p_order(N);\n iota(p_order.begin(), p_order.end(), 0);\n // Random shuffle order sometimes helps break deadlocks in greedy\n // shuffle(p_order.begin(), p_order.end(), mt19937(t)); \n\n for(int i : p_order) {\n Crane& c = state.cranes[i];\n if(c.bombed) {\n moves[i] = 4; // '.'\n continue;\n }\n\n // Current pos is occupied by this crane currently.\n // We need to determine next pos.\n // Note: logic is complex because \"swapping\" is banned.\n \n moves[i] = decideMove(i, next_positions);\n \n // Record next position\n Point next_p = c.pos;\n if(moves[i] < 4) {\n next_p.r += DR[moves[i]];\n next_p.c += DC[moves[i]];\n }\n // If stay/pick/drop/bomb, pos is same\n next_positions[next_p] = i;\n }\n\n // Apply moves\n string turn_ops[N];\n \n // Before applying, double check swap collisions\n // (A moves to B, B moves to A)\n // Our greedy reservation logic should prevent multiple cranes going to SAME spot.\n // But swapping is: c1 at p1->p2, c2 at p2->p1.\n for(int i=0; i& reserved_next_pos) {\n const Crane& c = state.cranes[crane_idx];\n \n // Candidate moves: U, D, L, R, ., P, Q\n // Prioritize:\n // 1. If holding: \n // - If at correct destination -> Q\n // - Else -> Move towards destination\n // 2. If empty:\n // - If current cell has container needed elsewhere -> P\n // - Else -> Move towards a container that needs moving\n \n // Helper to check if point is safe to be in next turn\n auto is_safe = [&](Point p, int current_crane_idx) {\n if(!isValidPos(p.r, p.c)) return false;\n // Check reservation\n if(reserved_next_pos.count(p)) return false; \n // Also check if any OTHER crane is currently at p and hasn't decided yet?\n // The `reserved_next_pos` only contains decided cranes.\n // We need to avoid p if an undecidad crane is there? No, if they haven't moved, we assume they *might* stay.\n // But simpler: Check current positions of all cranes. If a crane is at p, and we move to p, \n // we must ensure they move away. Since we determine order sequentially, \n // if crane K is at p and hasn't moved (K > current_idx in processing order), we assume collision risk.\n // So let's conservatively treat current positions of undecidad cranes as obstacles.\n for(int k=0; k candidates;\n for(int cc=N-2; cc>=1; --cc) candidates.push_back({target_row, cc}); // Same row\n for(int rr=0; rr best_score) {\n // Check if another crane is already targeting this or holding it?\n // We only check grid so holding is handled.\n // Targeting: hard to coordinate without central planner.\n // Just check if another crane is ON TOP of it?\n bool blocked = false;\n for(const auto& other : state.cranes) {\n if(other.id != c.id && !other.bombed && other.pos.r == r && other.pos.c == c_idx) blocked = true;\n }\n if(!blocked) {\n best_score = score;\n best_p = {r, c_idx};\n }\n }\n };\n\n // Scan grid\n for(int r=0; r& reserved) {\n Crane& c = state.cranes[idx];\n if(c.pos == target) return 4;\n\n // 4 dirs\n // We want to find the first step towards target.\n // Since N is small, we can do full BFS.\n \n queue> q;\n q.push({c.pos, -1}); // Point, first_move_dir\n \n vector> dist(N, vector(N, 1000));\n dist[c.pos.r][c.pos.c] = 0;\n \n // Randomize direction order to reduce repetitive oscillation\n vector dirs = {0, 1, 2, 3};\n // shuffle(dirs.begin(), dirs.end(), mt19937(idx));\n\n int best_first_move = 4; // Stay\n int min_dist_to_target = 1000;\n\n while(!q.empty()) {\n auto [curr, first_dir] = q.front();\n q.pop();\n\n if(curr == target) {\n return first_dir; // Found path\n }\n\n for(int d : dirs) {\n Point next_p = {curr.r + DR[d], curr.c + DC[d]};\n \n // Validity check\n if(!canMove(c, curr, next_p, state)) continue;\n\n // Collision check for the IMMEDIATE next step only\n // For subsequent steps in BFS, we assume cranes move away, \n // but we treat STATIC obstacles (containers for small cranes) as permanent for this turn.\n // HOWEVER, for the very first step (from c.pos), we must ensure the target cell is free in `reserved`.\n \n bool collision = false;\n if(curr == c.pos) { // Only check reservation for the immediate move\n // We use the is_safe logic from before\n if(reserved.count(next_p)) collision = true;\n \n // Also check against current positions of UNMOVED cranes\n for(int k=0; k dist[curr.r][curr.c] + 1) {\n dist[next_p.r][next_p.c] = dist[curr.r][curr.c] + 1;\n int new_first_dir = (curr == c.pos) ? d : first_dir;\n q.push({next_p, new_first_dir});\n }\n }\n }\n\n // If no path found, stay\n return 4;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_dummy;\n if (!(cin >> n_dummy)) return 0;\n\n vector> A(N, vector(N));\n for(int i=0; i> A[i][j];\n }\n }\n\n Solver solver(A);\n \n // Optimization: Bomb cranes that are not needed to reduce congestion?\n // With N=5 and 5 cranes, congestion is high.\n // Crane 0 (Big) is super valuable.\n // Cranes 1-4 (Small) are restricted.\n // Strategy: Maybe bomb crane 1, 3 to clear rows? \n // For now, keep all.\n \n solver.solve();\n\n for(int i=0; i 0 and we can load: effectively reduces work left.\n * - If h[tr][tc] < 0 and we have load: effectively reduces work left.\n * \n * We can simply perform a greedy search with a heuristic scoring function, potentially \n * iterating multiple times with randomized parameters or orderings.\n * \n * One crucial observation: It's almost always optimal to fully process a square when we decide \n * to interact with it (load all positive soil or fill as much negative as possible), \n * because revisiting costs movement.\n * \n * Let's try a \"basin hopping\" or simple randomized greedy approach.\n * We divide the grid into regions or just use global search.\n * \n * Let's implement a Randomized Greedy approach.\n * In each step, we look at all \"interesting\" squares (non-zero height).\n * We evaluate the cost to go there and the potential change in state.\n * \n * Metric to minimize: (Movement Cost) + (Future Heuristic Cost)\n * Future Heuristic Cost ~ (Remaining Soil to Move) * (Average Distance)\n * \n * Better yet, let's optimize the *path*.\n * We have a set of demands. We can view this as a path planning problem.\n * Since time limit is 2.0s, we can try many greedy paths.\n * \n * Specific Greedy Logic:\n * While (grid not flat):\n * Candidates: All (r, c) where h[r][c] != 0.\n * For each candidate:\n * Calculate cost to reach = dist * (100 + current_load).\n * Calculate 'value':\n * If h > 0: We can pick up `amt = min(cap - load, h)`. \n * If h < 0: We can drop `amt = min(load, -h)`.\n * Value ~= amt * (some_constant) - cost_to_reach.\n * Pick best candidate, go there, interact.\n * \n * To avoid getting stuck or oscillating, we can add randomness or a decay factor for far squares.\n * Also, we must return to (0,0) or end anywhere? Problem doesn't say we must return.\n * \n * Is it better to carry a lot?\n * Cost to move 1 step with load L: 100 + L.\n * Marginal cost of carrying unit soil: 1 per step.\n * Base cost: 100 per step.\n * Since 100 is relatively large, we want to minimize total steps (path length).\n * This looks very much like TSP. We want to visit non-zero nodes.\n * BUT, we have capacity constraints (technically unbounded capacity in problem, but practically limited by cost).\n * Actually, there is NO hard capacity limit on the truck (load can be anything).\n * However, cost increases linearly with load.\n * \n * So, carrying 100 units for 10 steps costs 10 * (100 + 100) = 2000.\n * Carrying 10 units for 10 steps costs 10 * (100 + 10) = 1100.\n * Carrying 0 units for 10 steps costs 10 * 100 = 1000.\n * The \"tax\" for carrying soil is distance * amount.\n * The \"tax\" for moving the truck is distance * 100.\n * \n * Optimization goal: Minimize (Total Distance * 100) + (Soil Transport Moment).\n * Soil Transport Moment = sum of (soil_chunk * distance_moved).\n * This is the Earth Mover's Distance (EMD) plus a TSP cost.\n * \n * High-level Plan:\n * 1. Calculate a matching between +soil and -soil to minimize transport distance?\n * This gives a lower bound on \"soil transport cost\".\n * However, we have the fixed truck cost.\n * If we just minimize EMD, we might make many small trips, exploding the truck cost.\n * If we just minimize truck moves (TSP), we might carry soil back and forth, exploding soil cost.\n * \n * 2. Combined Greedy Strategy:\n * Current state: (cur_r, cur_c, current_load).\n * We want to choose a target (next_r, next_c).\n * If we have a lot of load, we are desperate to find a sink (h < 0).\n * If we have little load, we prefer a source (h > 0).\n * \n * Score(target) = Cost_to_move + Predicted_Future_Cost\n * Cost_to_move = dist(cur, target) * (100 + current_load)\n * \n * Value of action at target:\n * If dropping soil (h < 0, load > 0):\n * We reduce load. This makes future moves cheaper.\n * Value ~ (amount_dropped) * (Value_Coefficient).\n * If picking soil (h > 0):\n * We increase load. Future moves more expensive.\n * But we reduce the \"debt\" of soil on the map.\n * Value ~ (amount_picked) * (Value_Coefficient).\n * \n * This heuristic is hard to tune.\n * \n * Alternative: Local Search on Operation Sequence? Too complex.\n * \n * Let's stick to a multi-start randomized greedy.\n * We can try to divide the grid into zones to improve locality.\n * \n * \"Gravitational\" Greedy:\n * Evaluate all non-zero cells.\n * Score = (Distance Cost) - (Attractiveness).\n * Attractiveness depends on:\n * - Amount of soil |h|.\n * - Synergy with current load (if load > 0, negatives are attractive; if load low, positives attractive).\n * \n * Let `w` be a parameter controlling the balance between distance and soil urgency.\n * For a candidate (r, c):\n * dist = |r - cr| + |c - cc|\n * move_cost = dist * (100 + current_load)\n * \n * potential_interaction:\n * if h > 0: transfer = h (load all)\n * if h < 0: transfer = min(current_load, -h) (unload as much as possible)\n * \n * heuristic_score:\n * if h > 0:\n * score = move_cost - ALPHA * transfer + BETA * dist * current_load\n * (Penalize picking up far away if we are already loaded? No, we can't pick up if loaded... wait\n * we CAN pick up even if loaded. But increasing load makes path expensive.)\n * if h < 0:\n * score = move_cost - GAMMA * transfer\n * (Highly incentivize unloading to reduce weight).\n * \n * Let's refine this.\n * We simply iterate until done.\n * In each step, we consider all reachable non-zero squares.\n * We pick the one with best score.\n * \n * To optimize further within 2 seconds:\n * Run this greedy simulation multiple times with slightly different ALPHA, GAMMA parameters \n * or with random perturbations in the score. Keep the best result.\n */\n\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\n// Problem Constants\nconst int N = 20;\nconst long long BASE_MOVE_COST = 100;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const {\n return r == other.r && c == other.c;\n }\n bool operator!=(const Point& other) const {\n return !(*this == other);\n }\n};\n\nint dist(Point p1, Point p2) {\n return abs(p1.r - p2.r) + abs(p1.c - p2.c);\n}\n\nenum OpType { MOVE, LOAD, UNLOAD };\n\nstruct Operation {\n OpType type;\n int val; // direction (0:U, 1:D, 2:L, 3:R) or amount\n char getChar() const {\n if (type == LOAD) return '+';\n if (type == UNLOAD) return '-';\n if (type == MOVE) {\n if (val == 0) return 'U';\n if (val == 1) return 'D';\n if (val == 2) return 'L';\n if (val == 3) return 'R';\n }\n return '?';\n }\n};\n\nstruct Result {\n vector ops;\n long long cost;\n long long diff_score;\n long long final_score;\n};\n\n// Global input\nint initial_grid[N][N];\n\n// Random engine\nmt19937 rng(12345);\n\n// Timer\nauto start_time = chrono::high_resolution_clock::now();\ndouble get_time() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\nstruct State {\n int grid[N][N];\n Point truck_pos;\n int current_load;\n vector history;\n long long current_cost;\n \n State() {\n for(int i=0; i target.r) apply_move(0); // U\n else apply_move(1); // D\n }\n while (truck_pos.c != target.c) {\n if (truck_pos.c > target.c) apply_move(2); // L\n else apply_move(3); // R\n }\n }\n \n void load_soil(int amount) {\n if (amount <= 0) return;\n grid[truck_pos.r][truck_pos.c] -= amount;\n current_load += amount;\n current_cost += amount;\n history.push_back({LOAD, amount});\n }\n \n void unload_soil(int amount) {\n if (amount <= 0) return;\n grid[truck_pos.r][truck_pos.c] += amount;\n current_load -= amount;\n current_cost += amount;\n history.push_back({UNLOAD, amount});\n }\n\n bool is_solved() const {\n for(int i=0; i targets;\n for(int i=0; i 100) sample_size = 100; // Heuristic limit\n \n // We might want to shuffle check order or pick random subset\n // But systematic scan is better for greedy.\n // Let's just check all, N*N is small (400).\n \n for (int k = 0; k < targets.size(); ++k) {\n Point p = targets[k];\n int d = dist(s.truck_pos, p);\n int h = s.grid[p.r][p.c];\n \n if (h == 0) continue; // Should be removed, but check just in case\n\n double score = 0;\n double move_penalty = d * (BASE_MOVE_COST + s.current_load);\n \n // Heuristic components\n if (h > 0) {\n // Source\n // Value of picking up soil\n // We prefer picking up if we are not carrying too much\n // But if we are near, we should pick it up.\n // Also prefer larger amounts.\n double pickup_amt = h; // Assume we take all\n score = -move_penalty + alpha * pickup_amt - beta * s.current_load * d;\n } else {\n // Sink (h < 0)\n // Value of dropping soil\n // We can only drop if we have load.\n int can_drop = min(s.current_load, -h);\n if (can_drop == 0) {\n score = -1e15; // Useless to go here now\n } else {\n score = -move_penalty + gamma * can_drop;\n }\n }\n \n // Add some noise to break ties and loops\n score += std::uniform_real_distribution<>(0, 10.0)(rng);\n\n if (score > best_score) {\n best_score = score;\n best_idx = k;\n }\n }\n \n if (best_idx == -1) break; // Should not happen unless solved\n \n Point target = targets[best_idx];\n \n // Execute move\n s.move_to(target);\n \n // Interact\n int h = s.grid[target.r][target.c];\n if (h > 0) {\n // Load all\n s.load_soil(h);\n } else if (h < 0) {\n // Unload as much as possible\n int can_drop = min(s.current_load, -h);\n s.unload_soil(can_drop);\n }\n \n // Update targets list\n if (s.grid[target.r][target.c] == 0) {\n targets.erase(targets.begin() + best_idx);\n }\n \n turns = s.history.size();\n }\n \n return {s.history, s.current_cost, 0, calculate_score(s)};\n}\n\n// A slightly smarter greedy that considers clusters\n// Or just iterate parameters of the simple greedy.\n// Given the constraints and problem type, parameter tuning on greedy is effective.\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n_in;\n cin >> n_in; // Always 20\n \n for(int i=0; i> initial_grid[i][j];\n \n // Parameter search\n // Alpha: Incentive to pick up soil\n // Beta: Penalty for distance when loaded (discourages picking up far away if loaded)\n // Gamma: Incentive to drop soil\n \n // Base strategy:\n // High Gamma: dropping load is very good (reduces movement cost quickly).\n // Alpha vs Beta: Picking up is good, but not if it makes the truck heavy for a long trip.\n \n Result best_res;\n best_res.final_score = -1;\n \n // Parameters ranges\n // alpha: [10, 500]\n // beta: [0.1, 10]\n // gamma: [100, 2000]\n \n // We prioritize dropping off heavily because carrying cost is high.\n \n int iterations = 0;\n while (get_time() < 1.85) {\n iterations++;\n double alpha = std::uniform_real_distribution<>(50.0, 300.0)(rng);\n double beta = std::uniform_real_distribution<>(0.0, 5.0)(rng);\n double gamma = std::uniform_real_distribution<>(200.0, 1500.0)(rng);\n \n // Sometimes try extreme strategies\n if (iterations % 5 == 0) {\n alpha = 500; beta = 0; gamma = 2000; // Greedy pickup/drop\n }\n \n Result res = solve_greedy(alpha, beta, gamma);\n \n if (res.final_score > best_res.final_score) {\n best_res = res;\n }\n }\n \n // Output\n for (const auto& op : best_res.ops) {\n if (op.type == MOVE) {\n cout << op.getChar() << \"\\n\";\n } else {\n cout << op.getChar() << op.val << \"\\n\";\n }\n }\n \n return 0;\n}","ahc035":"/**\n * AHC035 Solution\n *\n * Strategy:\n * This problem asks us to maximize the sum of evaluation criteria of the best seed after T turns.\n * This is essentially a breeding or genetic algorithm problem embedded in a grid layout.\n *\n * Key Observations:\n * 1. Grid Structure: Seeds are planted in an N x N grid. New seeds are generated from adjacent pairs.\n * The number of edges in an N x N grid is 2N(N-1), which exactly matches the number of seeds we carry over.\n * This means every adjacent pair produces exactly one offspring.\n *\n * 2. Constraints: N=6, M=15, T=10.\n * The grid is very small (36 cells). The number of turns is small.\n * The total population size is 2*6*5 = 60.\n * We discard 60 - 36 = 24 seeds every turn.\n *\n * 3. Objective: Maximize the maximum value of a single seed.\n * The value is the sum of vector components.\n * When two seeds mix, each component is chosen uniformly at random from the parents.\n * Therefore, the expected value of the offspring's component is the average of the parents'.\n * However, we are interested in the *maximum*, not the average. Variance is good.\n * We want to combine seeds that have high values in certain components to create a \"super seed\"\n * that has high values in all components.\n *\n * Algorithm:\n *\n * Step 1: Seed Selection (Survival of the Fittest + Diversity)\n * We have 60 seeds but only 36 spots. We need to pick the best 36.\n * - Simply picking the 36 with the highest current sum (V_k) is a strong baseline.\n * - However, we might want to keep seeds that are \"specialists\" (high in one specific dimension) even if their total sum isn't top-tier,\n * because they can contribute that high dimension to a future super-seed.\n * - Given T is small (10), simple elitism (highest sum) usually works well, but a slight bias towards\n * potential (max possible value) or maintaining diversity in max values per dimension helps.\n *\n * Step 2: Placement (Breeding Arrangement)\n * We need to place the 36 selected seeds into the grid to maximize the quality of the 60 offspring.\n * The 60 offspring come from horizontal edges (N*(N-1) = 30) and vertical edges (N*(N-1) = 30). Wait, N=6.\n * Horizontal edges: 6 rows * 5 edges = 30.\n * Vertical edges: 5 rows * 6 edges = 30.\n * Total = 60. Perfect.\n *\n * We want to place \"compatible\" or \"strong\" seeds adjacent to each other.\n * Since we want to converge all high component values into one seed, we should place the best seeds in the center\n * and have them breed with each other.\n *\n * Specific Placement Strategy:\n * - Sort the selected 36 seeds by their total value.\n * - Place the very best seed in the center (e.g., (2,2) or (2,3)).\n * - Place the next best seeds around it.\n * - This creates a \"gradient\" of quality, where the best genes flow towards the high-quality cluster.\n *\n * Refined Placement (Maximum Weight Perfect Matching approximation):\n * We want to maximize the expected value of the next generation.\n * Actually, we want to maximize the *potential* of the next generation.\n * Let's define a \"compatibility score\" between two seeds A and B.\n * A good metric is `Sum(max(A_i, B_i))` for all dimensions i. This represents the best possible offspring.\n * Or simply `Sum(A_i + B_i)`.\n * Since we want the *best* single result, we want to pair our best seeds with our other best seeds.\n *\n * A concentric layout works well:\n * 0 1 2 3 4 5\n * 6 7 8 9 10 11 ...\n *\n * Let's try a spiral or simply filling the grid such that the highest value seeds are neighbors.\n * A sorted order filling row-by-row usually puts indices (i) and (i+1) next to each other,\n * but (i) and (i+N) are also neighbors.\n * With N=6, row-by-row is:\n * 0 1 2 3 4 5\n * 6 7 8 9 10 11\n * ...\n * Here 0 is next to 1 and 6. If 0 is the best, 1 and 6 are the next best. This is good.\n *\n * Advanced Sorting:\n * Instead of just Total Value, let's try to evaluate seeds based on how much they contribute to the \"ideal\" seed.\n * The \"ideal\" seed has X_l = max over all seeds of component l.\n * Score(seed) = Sum(seed_l / max_l) could normalize, but raw sum is essentially the objective.\n *\n * Final Algorithm Implemented:\n * 1. Calculate stats (max value per dimension) to understand the potential.\n * 2. Sort all current seeds based on their total value.\n * 3. Pick the top N*N seeds.\n * 4. Place them in the grid.\n * To maximize mixing of top seeds, a simple row-major fill after sorting works surprisingly well\n * because adjacent indices in a sorted list are similar in quality, and high-quality ones clump at the start (top-left).\n * However, the edges wrap around in quality slightly.\n * Let's improve placement: Put the best seed at (2,2). Place others in a BFS/spiral manner around it.\n * This ensures the best seed has 4 high-quality neighbors.\n *\n * 5. Output, read response, repeat.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_VAL = 100;\n\nstruct Seed {\n int id;\n vector features;\n int total_value;\n\n // Calculate total value sum\n void compute_value() {\n total_value = 0;\n for (int x : features) total_value += x;\n }\n};\n\nint N, M, T;\nint SEED_COUNT; // 2 * N * (N - 1)\nint GRID_SIZE; // N * N\n\n// Helper to read seeds from input\nvector read_seeds(int count, int m, bool with_index_reset = false) {\n vector seeds(count);\n for (int i = 0; i < count; ++i) {\n seeds[i].id = i;\n seeds[i].features.resize(m);\n int sum = 0;\n for (int j = 0; j < m; ++j) {\n cin >> seeds[i].features[j];\n sum += seeds[i].features[j];\n }\n seeds[i].total_value = sum;\n }\n return seeds;\n}\n\n// Calculate the maximum possible value for each dimension across a set of seeds\nvector get_max_dims(const vector& seeds) {\n vector max_d(M, 0);\n for (const auto& s : seeds) {\n for (int j = 0; j < M; ++j) {\n max_d[j] = max(max_d[j], s.features[j]);\n }\n }\n return max_d;\n}\n\n// Solve a single turn\nvoid solve_turn(int turn, vector& current_seeds) {\n // 1. Selection Strategy\n // We have SEED_COUNT (60) seeds, need to pick GRID_SIZE (36).\n // We want to maximize the probability of getting a better seed.\n // Primary metric: Sum of features.\n // Secondary metric: \"Uniqueness\" or value in dimensions where we are lacking?\n // Given T is small, sticking to high sums is robust.\n\n // Let's stick to sorting by total value descending for the \"elite\" group.\n // However, we might want to preserve some diversity.\n // With N=6, M=15, diversity is implicitly handled by the randomness of inheritance\n // as long as we don't throw away high-potential \"specialists\" (seeds with low sum but one very high attribute).\n // Let's slightly adjust the score: sum + bonus for being close to the global max in a dimension.\n\n vector global_max_dims = get_max_dims(current_seeds);\n \n // Score calculation\n vector> scored_indices;\n scored_indices.reserve(current_seeds.size());\n\n for (int i = 0; i < (int)current_seeds.size(); ++i) {\n double score = 0;\n // Base score: sum of attributes\n score += current_seeds[i].total_value;\n \n // Bonus: if an attribute is the global maximum (or very close), boost it.\n // This ensures we don't lose the gene that is currently the best for a specific criteria.\n // We weight this bonus to be significant enough to save a \"specialist\".\n double max_potential_bonus = 0;\n for(int j=0; j selected_indices;\n vector is_selected(current_seeds.size(), false);\n for(int i=0; i> grid(N, vector(N, -1));\n vector> visited(N, vector(N, false));\n \n // BFS / Spiral fill order\n // Start at (N/2, N/2) or slightly offset. (2,2) is good.\n int start_r = N / 2 - 1;\n int start_c = N / 2 - 1;\n \n queue> q;\n q.push({start_r, start_c});\n visited[start_r][start_c] = true;\n \n int placed_count = 0;\n \n // Directions for BFS expansion (Up, Left, Down, Right)\n int dr[] = {-1, 0, 1, 0};\n int dc[] = {0, -1, 0, 1};\n\n // Map selection index 0 (best) -> center, 1 -> neighbor, etc.\n while(!q.empty() && placed_count < GRID_SIZE) {\n auto [r, c] = q.front();\n q.pop();\n \n grid[r][c] = selected_indices[placed_count++];\n \n // Add neighbors to queue\n // To make it more \"spiral-like\" and compact, order of checking neighbors matters less\n // in standard BFS, but we want to prioritize immediate neighbors of the best seed.\n for(int i=0; i<4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if(nr >= 0 && nr < N && nc >= 0 && nc < N && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n \n // Just in case BFS logic had gaps (it shouldn't on a grid), fill rest linearly (safety fallback)\n // Though with N*N and queue, it will visit exactly N*N nodes.\n\n // 3. Output\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 }\n cout << endl;\n }\n cout.flush();\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> T)) return 0;\n\n SEED_COUNT = 2 * N * (N - 1);\n GRID_SIZE = N * N;\n\n // Initial Read\n vector current_seeds = read_seeds(SEED_COUNT, M);\n\n for (int t = 0; t < T; ++t) {\n solve_turn(t, current_seeds);\n // Read next generation\n current_seeds = read_seeds(SEED_COUNT, M, true);\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Types ---\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { return tie(r, c) < tie(other.r, other.c); }\n int dist_manhattan(const Point& other) const { return abs(r - other.r) + abs(c - other.c); }\n};\n\nstruct ArmDesign {\n int V_prime;\n vector> edges; // (parent, length)\n int root_x, root_y;\n};\n\nstruct Operation {\n char move_root;\n string rotations;\n string leaf_actions;\n};\n\n// --- Globals ---\nint N, M, V;\nvector> grid_s; // 1 if takoyaki present\nvector> grid_t; // 1 if target\nvector sources;\nvector targets;\n\n// For checking if a square is a valid target destination that is currently empty of takoyaki\n// We track the current state of the board.\nvector> current_board; // 1 if takoyaki is currently here\n\n// Arm state\nstruct ArmState {\n Point root;\n // relative position of each leaf to root (simplified tracking)\n // Actually, we track the direction index of each edge.\n // Since we use a star graph (Root -> Leaves), each leaf i is defined by direction d_i.\n // Directions: 0: Right (0,1), 1: Down (1,0), 2: Left (0,-1), 3: Up (-1,0)\n vector leaf_dirs; \n vector leaf_lengths; // lengths of edges to leaves\n vector holding; // -1 if empty, else index of target in `targets` vector (or some ID)\n // For the simple strategy, holding[i] = 1 if holding any takoyaki, 0 otherwise.\n // We need to know *which* takoyaki? \n // The problem says \"target squares\". Any takoyaki can go to any target square.\n // So we just need to know if we are holding a takoyaki.\n};\n\n// Directions helpers\nconst int DR[] = {0, 1, 0, -1};\nconst int DC[] = {1, 0, -1, 0};\nconst char MOVE_CHARS[] = {'R', 'D', 'L', 'U'};\nconst char ROT_CHARS[] = {'R', 'R', 'L', 'L'}; // Mapping to output format requires care. \n// Output L: counter-clockwise, R: clockwise.\n// Logic dirs: 0->1 is Clockwise (R), 0->3 is Counter (L).\n// 0(R) -> 1(D) : +1 mod 4 (Clockwise 'R')\n// 0(R) -> 3(U) : -1 mod 4 (Counter 'L')\n\n// --- Helper Functions ---\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\n// Solve\nvoid solve() {\n // 1. Design the Arm\n // Strategy: Star graph. Root at center. \n // Leaves at distance 1.\n // We use min(V, 5) vertices total. 1 Root + up to 4 leaves.\n // Why 4? To cover Up, Down, Left, Right simultaneously if needed.\n // If V is large, maybe longer arms? No, control complexity is high.\n // Let's stick to a star graph with edges of length 1.\n int num_leaves = min(V - 1, 4); \n \n // Print Arm Design\n cout << (num_leaves + 1) << endl;\n for (int i = 0; i < num_leaves; ++i) {\n cout << \"0 1\" << endl; // Parent 0, Length 1\n }\n \n // Initial Root Position\n int curr_r = 0;\n int curr_c = 0;\n cout << curr_r << \" \" << curr_c << endl;\n\n // Initialize State\n ArmState state;\n state.root = {curr_r, curr_c};\n state.leaf_dirs.assign(num_leaves, 0); // All initially Right\n state.leaf_lengths.assign(num_leaves, 1);\n state.holding.assign(num_leaves, 0);\n\n // Current board state tracking\n current_board = grid_s;\n // Target tracking: we need to fill '1's in grid_t.\n // We can decrement a count or mark grid_t as we fill them.\n auto remaining_targets = grid_t; \n int items_remaining = M;\n\n // Operations record\n // We print operations immediately to avoid memory issues if T is large? \n // No, better to buffer or print turn by turn. We print turn by turn.\n \n // Main Loop\n // Simple Greedy:\n // 1. Identify reachable tasks (Pick up from S, Drop off at T).\n // 2. If carrying nothing -> Go pick up nearest available takoyaki.\n // 3. If carrying something -> Go drop off at nearest empty target.\n // 4. Optimize: Can we pick up more? Can we drop off more?\n \n // With multiple leaves, we can hold multiple items.\n // Heuristic:\n // Score = Distance to nearest objective.\n // If (holding count < num_leaves) and (exists nearby takoyaki): consider picking.\n // If (holding count > 0) and (exists nearby target): consider dropping.\n \n while (items_remaining > 0) {\n // BFS for pathfinding to the \"Best Next State\"\n // State in BFS: (root_r, root_c). \n // We assume leaf rotations are instant/free compared to movement, \n // or we include rotation in cost. \n // Actually, we can rotate while moving.\n // Target of BFS: A state where a leaf is over a valid objective.\n \n // Objective Types:\n // 1. PICK: Leaf i is over (r, c) where current_board[r][c] == 1 and remaining_targets[r][c] == 0 (usually).\n // Actually, we can pick up from a target square if it's not \"settled\" (but usually if it's on target, we leave it).\n // Constraint: \"s[x][y] == 1\" is the only condition to pick.\n // Optimization: Don't pick if s[x][y]==1 AND t[x][y]==1 (it's already home).\n // 2. DROP: Leaf i is over (r, c) where current_board[r][c] == 0 AND remaining_targets[r][c] == 1.\n \n // We define a target location for the ROOT.\n // If we want to pick item at P with leaf i (dist 1), Root must be at neighbors of P.\n \n // Strategy:\n // Find the closest pair (Leaf_idx, Objective_Pos)\n // Cost = Manhattan Dist from Root to (Objective_Pos - Leaf_Offset)\n \n int best_dist = 1e9;\n int target_r = -1, target_c = -1; // Desired Root Pos\n int action_leaf_idx = -1;\n bool is_pickup = true;\n \n // Analyze picking up\n int holding_count = 0;\n for(int x : state.holding) holding_count += x;\n \n // Candidates\n vector> candidates; // dist, r, c, is_pickup(true)/drop(false)\n \n // 1. Look for Pickups\n if (holding_count < num_leaves) {\n for(int r=0; r 0) {\n for(int r=0; r(a);\n int db = get<0>(b);\n // Bias: If distance is similar, prefer Drop if almost full.\n if (abs(da - db) < 3) {\n bool type_a = get<3>(a);\n bool type_b = get<3>(b);\n if (type_a != type_b) {\n if (holding_count > num_leaves / 2) return !type_a; // Prefer Drop (false)\n else return type_a; // Prefer Pick (true)\n }\n }\n return da < db;\n });\n \n auto best = candidates[0];\n target_r = get<1>(best);\n target_c = get<2>(best);\n is_pickup = get<3>(best);\n \n // Execute Movement\n // Move root towards target one step at a time\n while (state.root.r != target_r || state.root.c != target_c) {\n Operation op;\n op.rotations = string(num_leaves, '.');\n op.leaf_actions = string(num_leaves, '.');\n \n int dr = 0, dc = 0;\n if (state.root.r < target_r) { dr = 1; op.move_root = 'D'; }\n else if (state.root.r > target_r) { dr = -1; op.move_root = 'U'; }\n else if (state.root.c < target_c) { dc = 1; op.move_root = 'R'; }\n else if (state.root.c > target_c) { dc = -1; op.move_root = 'L'; }\n \n state.root.r += dr;\n state.root.c += dc;\n \n // While moving, can we perform any useful actions?\n // Opportunistic Pick/Drop\n // Check all leaves.\n // For each leaf, check if it is over a useful square.\n // We need to control orientation.\n // To maximize opportunism, we should rotate leaves to face valid targets if possible.\n // But simple logic: Just keep moving.\n \n cout << op.move_root << op.rotations << op.leaf_actions << \"\\n\";\n }\n \n // Reached target root pos.\n // Now perform the action.\n // We need to rotate a leaf to the correct square.\n // The target square is (Tr, Tc). Root is (Rr, Rc). Dist is 1.\n // Determine required direction.\n // Find which square we wanted to interact with.\n // Re-scan neighbors to find the objective that brought us here.\n int obj_r = -1, obj_c = -1;\n \n // Search neighbors for the matching condition\n for(int i=0; i<4; ++i) {\n int nr = state.root.r + DR[i];\n int nc = state.root.c + DC[i];\n if(!is_valid(nr, nc)) continue;\n \n if (is_pickup) {\n if (current_board[nr][nc] == 1 && remaining_targets[nr][nc] == 0) {\n obj_r = nr; obj_c = nc; break;\n }\n } else {\n if (current_board[nr][nc] == 0 && remaining_targets[nr][nc] == 1) {\n obj_r = nr; obj_c = nc; break;\n }\n }\n }\n \n if (obj_r != -1) {\n // Calculate required direction for a leaf\n // diff_r = obj_r - root.r\n // diff_c = obj_c - root.c\n // (0,1)->0, (1,0)->1, (0,-1)->2, (-1,0)->3\n int req_dir = -1;\n if (obj_r == state.root.r + 1) req_dir = 1; // D\n else if (obj_r == state.root.r - 1) req_dir = 3; // U\n else if (obj_c == state.root.c + 1) req_dir = 0; // R\n else if (obj_c == state.root.c - 1) req_dir = 2; // L\n \n // Find a leaf to use.\n // If Pickup: Need an empty leaf.\n // If Drop: Need a full leaf.\n int chosen_leaf = -1;\n for(int i=0; i> N >> M >> V)) return 0;\n \n grid_s.assign(N, vector(N));\n grid_t.assign(N, vector(N));\n \n char c;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> c;\n grid_s[i][j] = c - '0';\n if (grid_s[i][j]) sources.push_back({i, j});\n }\n }\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> c;\n grid_t[i][j] = c - '0';\n if (grid_t[i][j]) targets.push_back({i, j});\n }\n }\n\n // Quick check: items already on targets?\n // The problem says \"move M takoyaki... to M specified squares\".\n // It doesn't explicitly say we must move specific ones, but usually \"takoyaki are placed... move them\".\n // However, if s[i][j]==1 and t[i][j]==1, do we need to move it?\n // The score depends on M' (number of takoyaki at target positions).\n // If a takoyaki is already at a target position, we should leave it there unless it blocks something.\n // Our logic handles this: we only PICK from (s==1 && t==0) and DROP at (s==0 && t==1).\n // What if s==1 and t==1? It stays 1. M' counts it.\n // However, M is the total count. If s==1 and t==1, it counts towards M'.\n // We need to reduce items_remaining by the number of already satisfied spots.\n \n int already_done = 0;\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\n// -----------------------------------------------------------------------------\n// Constants and Globals\n// -----------------------------------------------------------------------------\nconst int GRID_SIZE = 100000;\nconst int MAX_COORD = 100000;\nconst int N_POINTS = 5000;\nconst int MAX_VERTICES = 1000;\nconst int MAX_LENGTH = 400000;\n\n// Use a coarse grid for the constructive heuristic\nconst int K = 40; // 40x40 grid. Each cell is 2500x2500.\nconst int CELL_SIZE = MAX_COORD / K;\n\nstruct Point {\n int x, y;\n int id;\n};\n\nstruct GridCell {\n vector mackerel_indices;\n vector sardine_indices;\n int base_score; // mackerels - sardines inside this exact square\n};\n\n// Global data\nvector mackerels;\nvector sardines;\nGridCell grid[K][K];\n\n// Utility for time keeping\nauto start_time = chrono::high_resolution_clock::now();\ndouble get_time_sec() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// Random number generator\nmt19937 rng(12345);\n\n// -----------------------------------------------------------------------------\n// Geometry Helpers\n// -----------------------------------------------------------------------------\n\n// Represents a polygon as a sequence of points\nusing Polygon = vector>;\n\n// Calculate score of a polygon exactly\nlong long calculate_score(const Polygon& poly) {\n // A point is inside if winding number is non-zero.\n // Since we have simple rectilinear polygons, we can use a simpler scan-line or just standard PIP.\n // However, for the contest, calculating exact score frequently is slow.\n // We trust our heuristic construction.\n // This function is mainly for debugging or final verification if needed.\n return 0; \n}\n\n// Trace boundary of the boolean grid\n// Returns a list of vertices (x, y) in order.\n// The grid coordinates are scaled by CELL_SIZE later.\n// Returns empty if invalid (e.g. empty grid).\nPolygon trace_boundary(const vector>& active, int& perimeter_blocks, int& vertices_count) {\n int start_x = -1, start_y = -1;\n for (int i = 0; i < K; ++i) {\n for (int j = 0; j < K; ++j) {\n if (active[i][j]) {\n start_x = i;\n start_y = j;\n goto found;\n }\n }\n }\n found:;\n \n if (start_x == -1) return {};\n\n // Directions: 0: Right, 1: Down, 2: Left, 3: Up\n // dx, dy corresponding to moving along the grid lines\n int dx[] = {1, 0, -1, 0};\n int dy[] = {0, -1, 0, 1};\n \n // We trace the \"edges\" of the active cells.\n // An edge is defined by the coordinate of the grid line.\n // We start at the top-left corner of the first found block (start_x, start_y).\n // Since we scan row by row, (start_x, start_y) is the top-left-most block.\n // Its top edge is definitely a boundary.\n // Let's define our position as the intersection of grid lines.\n // (x, y) corresponds to the corner x*CELL_SIZE, y*CELL_SIZE.\n // Top-left of block (i, j) is grid node (i, j+1) in cartesian if y goes up?\n // Problem coords: x right, y up.\n // Grid indices: let's map active[x][y] to the spatial box [x*S, (x+1)*S] x [y*S, (y+1)*S].\n // Then the top-left corner of block (start_x, start_y) is (start_x, start_y+1).\n // Wait, let's trace standard \"marching squares\" style or wall following.\n \n // Current position in grid node coords (0..K, 0..K)\n int cx = start_x;\n int cy = start_y + 1;\n int dir = 0; // Initial facing direction: Right (along the top edge of the block)\n\n Polygon poly;\n poly.push_back({cx, cy});\n\n // Determine initial direction validity? \n // We are at (start_x, start_y+1). The block (start_x, start_y) is to our Bottom-Right (if we face Right).\n // Wall following rule (Right hand on wall):\n // The \"wall\" is the active cells. We walk along the boundary such that active cells are on the right.\n \n // Helper to check if a cell is active\n auto is_active = [&](int x, int y) {\n if (x < 0 || x >= K || y < 0 || y >= K) return false;\n return active[x][y];\n };\n\n int initial_cx = cx;\n int initial_cy = cy;\n int initial_dir = dir;\n bool first_move = true;\n\n perimeter_blocks = 0;\n vertices_count = 0;\n\n while (true) {\n if (!first_move && cx == initial_cx && cy == initial_cy && dir == initial_dir) break;\n first_move = false;\n\n // Try to turn right first (relative to current dir)\n int right_dir = (dir + 1) % 4;\n // Check the cell that would be to our \"right\" after turning right and moving.\n // Actually, let's just check the 4 cells around current node (cx, cy).\n // Depending on dir, we are moving along an edge.\n // Let's use a simpler logic:\n // We are at a vertex. We came from 'dir'.\n // We want to keep the active region to our RIGHT.\n // Cells around vertex (cx, cy):\n // Top-Right (cx, cy), Top-Left (cx-1, cy), Bottom-Left (cx-1, cy-1), Bottom-Right (cx, cy-1)\n // Indices are relative to the grid cell indices.\n \n // Let's re-evaluate based on \"look ahead\".\n // Current edge is between (cx, cy) and (cx+dx[dir], cy+dy[dir]).\n // Is the cell to the right of this edge active?\n // Edge directions: 0: +x (Right), 1: -y (Down), 2: -x (Left), 3: +y (Up)\n \n // Relative cell coords to the edge starting at (cx, cy) heading 'dir':\n // Dir 0 (Right): Cell (cx, cy-1) is to the Right (Bottom-Right). Cell (cx, cy) is Left (Top-Right).\n // Dir 1 (Down): Cell (cx-1, cy-1) is Right. Cell (cx, cy-1) is Left.\n // Dir 2 (Left): Cell (cx-1, cy) is Right. Cell (cx-1, cy-1) is Left.\n // Dir 3 (Up): Cell (cx, cy) is Right. Cell (cx-1, cy) is Left.\n \n // We want to find the new direction such that the active region remains on the right.\n // We check relative turn directions: Right, Straight, Left, U-turn (impossible in simple poly).\n \n // Candidate directions in preference order for Right-Hand rule:\n // Turn Right (dir+1), Straight (dir), Turn Left (dir-1), U-Turn (dir+2)\n // Wait, standard contour tracing:\n // Look at the 2x2 cells around current node (cx, cy).\n // Identify which are active.\n // Determine outgoing edge.\n // But we are maintaining state (cx, cy, dir).\n \n // Check \"front-right\" cell relative to current dir.\n // If it is active -> We must turn right to keep it on right side? No, if front-right is active, \n // we might need to go straight or turn right depending on front-left.\n // Let's use a robust state machine.\n // Cell to the Right of current edge (hypothetically if we moved `dir`):\n // Dir 0: (cx, cy-1)\n // Dir 1: (cx-1, cy-1)\n // Dir 2: (cx-1, cy)\n // Dir 3: (cx, cy)\n \n // Helper to get \"Right\" cell coords given current pos and dir\n auto get_right_cell = [&](int x, int y, int d) -> pair {\n if (d == 0) return {x, y - 1};\n if (d == 1) return {x - 1, y - 1};\n if (d == 2) return {x - 1, y};\n return {x, y};\n };\n\n // Helper to get \"Left\" cell coords\n auto get_left_cell = [&](int x, int y, int d) -> pair {\n if (d == 0) return {x, y};\n if (d == 1) return {x, y - 1};\n if (d == 2) return {x - 1, y - 1};\n return {x - 1, y};\n };\n\n // Logic:\n // Ideally we move in `dir`. The cell to our right MUST be active. The cell to our left MUST be inactive.\n // But at a corner, this changes.\n // At vertex (cx, cy):\n // We arrived here. Now we choose new `dir`.\n // We check all 4 outgoing directions from (cx, cy).\n // Valid outgoing edge must have Active on Right, Inactive on Left.\n \n int next_dir = -1;\n // We search for the valid outgoing direction.\n // Since we follow the boundary, there is exactly one valid continuation unless self-intersecting (touching corners).\n // Touching corners case (checkerboard):\n // I A\n // A I\n // This creates ambiguity. We should prefer staying connected to current component logic.\n // For simple boundary tracing of a set of 4-connected cells, if the set is valid (no holes, single component),\n // we should just pick the \"sharpest left turn\" (CCW) or \"sharpest right turn\" (CW) that is valid?\n // Let's try checking directions starting from (dir + 3) % 4 (Left turn) -> (dir) -> (dir + 1).\n // i.e. try to turn left, then straight, then right. (This traces CCW or something? We want CW?)\n // We defined \"Active on Right\". This is CW tracing.\n // Preference for CW tracing: Try turning Right first? No, if we trace CW, inside is on Right.\n // At a convex corner, we turn Right. At a concave corner, we turn Left.\n // So we should check: Turn Right, then Straight, then Turn Left.\n // If we check \"Turn Right\" ((dir + 1)%4): check if valid edge.\n // Valid edge means: Get_Right_Cell is Active, Get_Left_Cell is Inactive.\n \n for (int k = 1; k >= -2; --k) { // k=1 (Right), 0 (Straight), -1 (Left), -2 (Back - should not happen)\n int nd = (dir + k + 4) % 4;\n auto rc = get_right_cell(cx, cy, nd);\n auto lc = get_left_cell(cx, cy, nd);\n if (is_active(rc.first, rc.second) && !is_active(lc.first, lc.second)) {\n next_dir = nd;\n break;\n }\n }\n \n assert(next_dir != -1);\n\n // Add vertex if direction changed\n if (next_dir != dir && !poly.empty()) {\n // The last point added was (cx, cy).\n // Actually, we add points when we *complete* a segment or change direction.\n // Better: just accumulate all moves, then simplify.\n // Let's simplify on the fly:\n // if (next_dir == dir), we just extend.\n // if (next_dir != dir), (cx, cy) is a corner.\n // Wait, poly already has starting point.\n }\n \n if (next_dir != dir) {\n // We turn at (cx, cy). So (cx, cy) is a vertex.\n // Check if (cx, cy) is same as last vertex?\n if (poly.empty() || poly.back().first != cx || poly.back().second != cy) {\n poly.push_back({cx, cy});\n }\n }\n\n cx += dx[next_dir];\n cy += dy[next_dir];\n dir = next_dir;\n perimeter_blocks++;\n }\n\n vertices_count = poly.size();\n // Close the loop explicitly if needed, but format usually implies it.\n // The problem asks for vertices.\n return poly;\n}\n\n// -----------------------------------------------------------------------------\n// Core Logic\n// -----------------------------------------------------------------------------\n\n// Refine the boundary of the polygon by shifting edges perpendicular to their direction\n// to optimize the objective function locally.\nPolygon optimize_polygon(const Polygon& coarse_poly) {\n // coarse_poly coords are in grid units (0..K).\n // We need to convert to real coords.\n // Initially, map v -> v * CELL_SIZE.\n \n int m = coarse_poly.size();\n if (m == 0) return {};\n\n vector> current_poly(m);\n for(int i=0; i i) is horizontal at y=curr_y. It goes from v[prev].x to v[i].x.\n // If we move v[i].x, we are shortening/lengthening this edge.\n // We must not move v[i].x past v[prev].x (or beyond).\n // Actually, we can move past, but that changes topology (self-intersection).\n // To stay safe and simple: constrain x between v[prev].x and v[next2].x?\n // Be careful about direction.\n // Also we must check if we collide with *other* parts of the polygon. \n // Global intersection check is expensive. \n // Heuristic: constrain shift to a small window (e.g. +/- CELL_SIZE) or checking the grid.\n // Since we started from a grid, the \"safe\" range is roughly the grid cell width around the edge, \n // unless the shape is one cell wide.\n \n // Let's simplify: Limit shift to range [min(prev_x, next2_x), max(prev_x, next2_x)]. \n // This prevents the \"U\" shape from inverting.\n \n int low, high;\n int fixed_start, fixed_end; // The range of the perpendicular coordinate\n \n if (is_vertical) {\n // Shifting X.\n // Connected horizontal segments are at y = curr_y and y = next_y.\n // Range of y for this vertical edge:\n fixed_start = min((int)curr_y, (int)next_y);\n fixed_end = max((int)curr_y, (int)next_y);\n \n // Constraints on X\n int limit1 = current_poly[prev].first;\n int limit2 = current_poly[next2].first;\n low = min(limit1, limit2) + 1; // +1 to avoid collapse/overlap for now\n high = max(limit1, limit2) - 1;\n \n // Also bound by global limits\n low = max(low, 0);\n high = min(high, MAX_COORD);\n \n if (low > high) continue; // Cannot move\n\n // We want to find optimal x in [low, high].\n // The vertical edge \"sweeps\" area.\n // If we move x to x', the area change involves points in rectangle defined by x, x', fixed_start, fixed_end.\n // We need to know orientation to know if moving Right adds or removes area.\n // Boundary trace: Active on Right.\n // If moving from (x, y1) to (x, y2).\n // If y2 < y1 (Down), Interior is Right (Larger X). Moving X right shrinks polygon.\n // If y2 > y1 (Up), Interior is Right (Larger X). Moving X right expands polygon.\n // Wait, standard:\n // Up (y increasing): Right side is inside. So increasing X (moving edge right) reduces 'outside', increases 'inside'.\n // Down (y decreasing): Right side is inside. Increasing X increases 'outside', reduces 'inside'.\n \n int direction = (next_y > curr_y) ? 1 : -1; \n // If direction 1 (Up), Inside is Right. Increasing X => Add Mackerels, Add Sardines.\n // We want to Maximize (M - S).\n // Actually:\n // If we move edge to the Right (increase X):\n // If Up: We are sweeping \"into\" the interior? No.\n // Up vector: (0, 1). Right normal (1, 0). Inside is +X.\n // So the edge is the LEFT boundary of the shape.\n // Moving Left Boundary to the Right SHRINKs the shape.\n // So increasing X removes points.\n // Delta Score = - (Points in swept area).\n // We want to minimize points in swept area?\n // No, we want to find X that maximizes the Total Score.\n // Points between X_old and X_new are either added or removed.\n \n // Let's just compute the contribution of points in the strip y \\in [fixed_start, fixed_end].\n // For a point (px, py) in this y-range:\n // If py is in range:\n // If we place the edge at X.\n // If Up (Left Boundary): Point is inside if px > X.\n // If Down (Right Boundary): Point is inside if px < X.\n \n // So we want to choose X.\n // Collect all relevant points (mackerels and sardines) in y-range.\n // Sort them by X.\n // Iterate X through the sorted points and update score.\n \n vector> strip_points; // {x, weight}. Weight: +1 Mackerel, -1 Sardine\n for (const auto& p : mackerels) {\n if (p.y >= fixed_start && p.y <= fixed_end) strip_points.push_back({p.x, 1});\n }\n for (const auto& p : sardines) {\n if (p.y >= fixed_start && p.y <= fixed_end) strip_points.push_back({p.x, -1});\n }\n sort(strip_points.begin(), strip_points.end());\n\n // Base score? We only care about relative change.\n // Case Up (Left Boundary): inside if px > X.\n // Score contribution of this strip = Sum(weight for px > X).\n // As X increases, points drop out.\n // We start with X = low-1 (all points in range [low, high] are > X, so inside).\n // Then sweep X.\n \n // Case Down (Right Boundary): inside if px < X.\n // Score contribution = Sum(weight for px < X).\n // As X increases, points enter.\n\n // We only care about points within [low, high]. Points outside this X-range are unaffected by our choice \n // (they are permanently in or out regarding this edge's movement).\n \n // Filter points in [low, high]\n vector> active_points;\n for(auto& p : strip_points) {\n if (p.first >= low && p.first <= high) active_points.push_back(p);\n }\n \n int best_x = current_poly[i].first;\n long long best_val = -1e18; // Relative score\n \n if (direction == 1) { \n // Up: Inside is > X.\n // Total weight of all active points.\n // If we pick X, score is sum of weights with p.x > X.\n // Sweep: Start X < min(active). Score = Total Sum.\n // Move X past point p: Score -= p.weight.\n long long current_val = 0;\n for(auto& p : active_points) current_val += p.second;\n \n // Try X = low. (Points at X=low are > low? No. Boundary inclusion rule:\n // Problem says points ON edge are inside.\n // If Left Boundary is at X, points at X are inside.\n // So inside condition: p.x >= X.\n // Moving X past p (from p.x to p.x+1) removes p.\n \n // Initial candidate: X = low. All active points (>= low) are inside.\n if (current_val > best_val) { best_val = current_val; best_x = low; }\n \n // Sweep\n int p_idx = 0;\n for (int x = low + 1; x <= high; ++x) {\n // Remove points strictly less than x?\n // Points at x-1 are no longer >= x.\n while(p_idx < active_points.size() && active_points[p_idx].first < x) {\n current_val -= active_points[p_idx].second;\n p_idx++;\n }\n // If points are exactly at x? They are still inside.\n // We check this x as candidate.\n if (current_val >= best_val) { // Prefer larger X to break ties? Doesn't matter.\n best_val = current_val;\n best_x = x;\n }\n }\n } else {\n // Down: Inside is <= X (Points on edge included).\n // Sweep: Start X = low. Points <= low are inside.\n long long current_val = 0;\n int p_idx = 0;\n // Initial points at exactly low\n while(p_idx < active_points.size() && active_points[p_idx].first <= low) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n \n if (current_val > best_val) { best_val = current_val; best_x = low; }\n \n for (int x = low + 1; x <= high; ++x) {\n // Add points at x\n while(p_idx < active_points.size() && active_points[p_idx].first <= x) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n if (current_val >= best_val) {\n best_val = current_val;\n best_x = x;\n }\n }\n }\n \n if (best_x != current_poly[i].first) {\n current_poly[i].first = best_x;\n current_poly[next].first = best_x;\n changed = true;\n }\n } else {\n // Horizontal Edge. Shifting Y.\n // Logic is symmetric.\n fixed_start = min((int)curr_x, (int)next_x);\n fixed_end = max((int)curr_x, (int)next_x);\n\n int limit1 = current_poly[prev].second;\n int limit2 = current_poly[next2].second;\n low = min(limit1, limit2) + 1;\n high = max(limit1, limit2) - 1;\n \n low = max(low, 0);\n high = min(high, MAX_COORD);\n\n if (low > high) continue;\n\n vector> strip_points; \n for (const auto& p : mackerels) {\n if (p.x >= fixed_start && p.x <= fixed_end) strip_points.push_back({p.y, 1});\n }\n for (const auto& p : sardines) {\n if (p.x >= fixed_start && p.x <= fixed_end) strip_points.push_back({p.y, -1});\n }\n sort(strip_points.begin(), strip_points.end());\n\n vector> active_points;\n for(auto& p : strip_points) {\n if (p.first >= low && p.first <= high) active_points.push_back(p);\n }\n \n int direction = (next_x < curr_x) ? 1 : -1; \n // next_x < curr_x => Moving Left (-X). \n // Normal to right (0, -1) or something?\n // Let's trace:\n // Edge (curr_x, curr_y) -> (next_x, next_y). Y is constant.\n // Left (-X): (0, -1) is \"Right\" side (since vector is (-1, 0)).\n // Inside is Down (-Y) direction. Top Boundary.\n // Top Boundary: Inside is y <= Y.\n // Right (+X): Vector (1, 0). Right side is (0, -1) -> Down. Inside is Down?\n // Wait.\n // Vector (dx, 0). Right normal is (0, -dx).\n // If dx > 0 (Right): Normal (0, -1) (Down). Inside is y <= Y. (Top edge).\n // If dx < 0 (Left): Normal (0, 1) (Up). Inside is y >= Y. (Bottom edge).\n \n int best_y = current_poly[i].second;\n long long best_val = -1e18;\n\n if (direction == 1) { // dx < 0, Left. Bottom Edge. Inside y >= Y.\n long long current_val = 0;\n for(auto& p : active_points) current_val += p.second;\n \n if (current_val > best_val) { best_val = current_val; best_y = low; }\n \n int p_idx = 0;\n for (int y = low + 1; y <= high; ++y) {\n while(p_idx < active_points.size() && active_points[p_idx].first < y) {\n current_val -= active_points[p_idx].second;\n p_idx++;\n }\n if (current_val >= best_val) {\n best_val = current_val;\n best_y = y;\n }\n }\n } else { // dx > 0, Right. Top Edge. Inside y <= Y.\n long long current_val = 0;\n int p_idx = 0;\n while(p_idx < active_points.size() && active_points[p_idx].first <= low) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n \n if (current_val > best_val) { best_val = current_val; best_y = low; }\n \n for (int y = low + 1; y <= high; ++y) {\n while(p_idx < active_points.size() && active_points[p_idx].first <= y) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n if (current_val >= best_val) {\n best_val = current_val;\n best_y = y;\n }\n }\n }\n\n if (best_y != current_poly[i].second) {\n current_poly[i].second = best_y;\n current_poly[next].second = best_y;\n changed = true;\n }\n }\n }\n if (!changed) break;\n }\n \n return current_poly;\n}\n\n// -----------------------------------------------------------------------------\n// Solver\n// -----------------------------------------------------------------------------\n\nvoid solve() {\n // Read input\n int N_dummy;\n if (!(cin >> N_dummy)) return;\n \n mackerels.resize(N_POINTS);\n for (int i = 0; i < N_POINTS; ++i) {\n cin >> mackerels[i].x >> mackerels[i].y;\n mackerels[i].id = i;\n }\n sardines.resize(N_POINTS);\n for (int i = 0; i < N_POINTS; ++i) {\n cin >> sardines[i].x >> sardines[i].y;\n sardines[i].id = i;\n }\n\n // Precompute Grid Weights\n for (int i = 0; i < K; ++i) {\n for (int j = 0; j < K; ++j) {\n grid[i][j].base_score = 0;\n }\n }\n\n auto get_grid_coords = [&](int x, int y) {\n return make_pair(min(x / CELL_SIZE, K - 1), min(y / CELL_SIZE, K - 1));\n };\n\n for (int i = 0; i < N_POINTS; ++i) {\n auto p = get_grid_coords(mackerels[i].x, mackerels[i].y);\n grid[p.first][p.second].mackerel_indices.push_back(i);\n grid[p.first][p.second].base_score++;\n }\n for (int i = 0; i < N_POINTS; ++i) {\n auto p = get_grid_coords(sardines[i].x, sardines[i].y);\n grid[p.first][p.second].sardine_indices.push_back(i);\n grid[p.first][p.second].base_score--;\n }\n\n // Initial State: Find best single cell\n int best_i = -1, best_j = -1;\n int max_cell_score = -1e9;\n for(int i=0; i max_cell_score) {\n max_cell_score = grid[i][j].base_score;\n best_i = i;\n best_j = j;\n }\n }\n }\n\n vector> active(K, vector(K, false));\n active[best_i][best_j] = true;\n\n // Simulated Annealing / Hill Climbing\n int current_score = max_cell_score;\n \n // To check connectivity efficiently, we can maintain counts or just run BFS.\n // Since K is small (40x40 = 1600), BFS is very fast (~10us).\n // We can afford full check.\n \n auto check_connectivity = [&](const vector>& state) {\n // Check if active cells are connected\n // Check if inactive cells are connected (no holes)\n int active_cnt = 0;\n int start_x = -1, start_y = -1;\n for(int i=0; i> visited(K, vector(K, false));\n deque> q;\n q.push_back({start_x, start_y});\n visited[start_x][start_y] = true;\n found_active++;\n \n int dx[] = {0, 0, 1, -1};\n int dy[] = {1, -1, 0, 0};\n\n while(!q.empty()) {\n auto [cx, cy] = q.front(); q.pop_front();\n for(int k=0; k<4; ++k) {\n int nx = cx + dx[k], ny = cy + dy[k];\n if (nx >= 0 && nx < K && ny >= 0 && ny < K && state[nx][ny] && !visited[nx][ny]) {\n visited[nx][ny] = true;\n found_active++;\n q.push_back({nx, ny});\n }\n }\n }\n if (found_active != active_cnt) return false;\n\n // Check for holes (Inactive connectivity to boundary)\n // We assume \"outside\" is connected to boundary of the grid.\n // BFS from all border inactive cells.\n int inactive_cnt = (K*K) - active_cnt;\n if (inactive_cnt == 0) return true; // Full grid\n\n // Reset visited\n for(int i=0; i= 0 && nx < K && ny >= 0 && ny < K && !state[nx][ny] && !visited[nx][ny]) {\n visited[nx][ny] = true;\n found_inactive++;\n q.push_back({nx, ny});\n }\n }\n }\n \n return found_inactive == inactive_cnt;\n };\n\n double T0 = 2000.0;\n double T1 = 10.0;\n double TL = 1.5; // Time limit for grid search\n int iter = 0;\n \n vector> boundary_candidates; // Neighbors of current shape\n // Initialize boundary candidates\n auto update_candidates = [&](const vector>& s) {\n boundary_candidates.clear();\n for(int i=0; i= 0 && nx < K && ny >= 0 && ny < K && !s[nx][ny]) {\n boundary_candidates.push_back({nx, ny});\n }\n }\n }\n }\n }\n // Unique\n sort(boundary_candidates.begin(), boundary_candidates.end());\n boundary_candidates.erase(unique(boundary_candidates.begin(), boundary_candidates.end()), boundary_candidates.end());\n };\n update_candidates(active);\n \n vector> active_list;\n active_list.push_back({best_i, best_j});\n\n while (true) {\n iter++;\n if ((iter & 127) == 0) {\n double t = get_time_sec();\n if (t > TL) break;\n }\n \n double time_ratio = get_time_sec() / TL;\n double temp = T0 + (T1 - T0) * time_ratio;\n\n // Two moves: Add a cell or Remove a cell\n int move_type = rng() % 2;\n \n if (move_type == 0) { // Add\n if (boundary_candidates.empty()) continue;\n int idx = rng() % boundary_candidates.size();\n auto p = boundary_candidates[idx];\n \n // Tentative add\n active[p.first][p.second] = true;\n \n if (check_connectivity(active)) {\n int delta = grid[p.first][p.second].base_score;\n if (delta >= 0 || exp(delta / temp) > (double)rng() / mt19937::max()) {\n current_score += delta;\n active_list.push_back(p);\n update_candidates(active); // Slow full update, optimize later if needed\n } else {\n active[p.first][p.second] = false; // Revert\n }\n } else {\n active[p.first][p.second] = false; // Revert\n }\n } else { // Remove\n if (active_list.size() <= 1) continue;\n int idx = rng() % active_list.size();\n auto p = active_list[idx];\n \n active[p.first][p.second] = false;\n \n if (check_connectivity(active)) {\n int delta = -grid[p.first][p.second].base_score;\n // Removing decreases score by base_score (so delta is negative of base_score)\n if (delta >= 0 || exp(delta / temp) > (double)rng() / mt19937::max()) {\n current_score += delta;\n active_list.erase(active_list.begin() + idx);\n update_candidates(active);\n } else {\n active[p.first][p.second] = true;\n }\n } else {\n active[p.first][p.second] = true;\n }\n }\n }\n\n // Final Construction\n int p_len, v_cnt;\n Polygon coarse_poly = trace_boundary(active, p_len, v_cnt);\n \n // Optimize coordinates\n Polygon final_poly = optimize_polygon(coarse_poly);\n\n // Ensure distinct vertices by minor perturbation if needed\n // But coordinate shift logic usually keeps them distinct if topology is preserved.\n // Check for duplicate sequential vertices (length 0 edges) and remove them.\n Polygon cleaned;\n for (size_t i = 0; i < final_poly.size(); ++i) {\n if (i > 0 && final_poly[i] == final_poly[i-1]) continue;\n cleaned.push_back(final_poly[i]);\n }\n if (!cleaned.empty() && cleaned.back() == cleaned.front()) cleaned.pop_back();\n \n // Also merge collinear edges\n Polygon merged;\n if (!cleaned.empty()) {\n merged.push_back(cleaned[0]);\n for (size_t i = 1; i < cleaned.size(); ++i) {\n // Check if segment (merged.back() -> cleaned[i]) is collinear with previous segment\n // Since it's rectilinear, check if both are horizontal or both vertical.\n if (merged.size() >= 2) {\n auto p1 = merged[merged.size()-2];\n auto p2 = merged.back();\n auto p3 = cleaned[i];\n bool seg1_vert = (p1.first == p2.first);\n bool seg2_vert = (p2.first == p3.first);\n if (seg1_vert == seg2_vert) {\n // Collinear, just update the last point\n merged.back() = p3;\n continue;\n }\n }\n merged.push_back(cleaned[i]);\n }\n // Check wrap-around collinearity\n if (merged.size() >= 3) {\n auto p1 = merged[merged.size()-2];\n auto p2 = merged.back();\n auto p3 = merged[0];\n bool seg1_vert = (p1.first == p2.first);\n bool seg2_vert = (p2.first == p3.first);\n if (seg1_vert == seg2_vert) {\n merged.pop_back();\n merged[0] = p2; // Effectively p2 replaces p3(start), cycle shifts\n }\n }\n }\n \n final_poly = merged;\n\n // Check constraints\n if (final_poly.size() > MAX_VERTICES) {\n // Naive fallback: bounding box of all mackerels\n // Or just the bounding box of active cells\n // Simplest valid output\n final_poly = {{0,0}, {100000, 0}, {100000, 100000}, {0, 100000}};\n }\n\n // Output\n cout << final_poly.size() << endl;\n for (const auto& p : final_poly) {\n cout << p.first << \" \" << p.second << endl;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc040":"/**\n * @file solution.cpp\n * @brief Heuristic solution for the rectangle packing problem.\n * \n * Strategy:\n * 1. **Uncertainty Management**: The true dimensions of the rectangles are unknown, and the input\n * is noisy. We maintain estimated dimensions (mean values) for each rectangle. Initially, these\n * are the input values. As we perform placements (queries) and get feedback (measured W, H),\n * we could potentially update these estimates, but given the problem structure and scoring,\n * simply trusting the initial noisy measurements or refining them slightly is less critical \n * than the geometric packing itself. The error sigma is relative to 10^5 sized rectangles, \n * so it's significant but the relative order of sizes is likely preserved.\n * \n * 2. **Geometric Packing Heuristic**: This is a 2D bin packing variant.\n * We model the placement logic locally to simulate the \"slide until hit\" mechanism.\n * The core heuristic uses a shelf-based or level-based approach, which is robust for minimizing W+H.\n * Specifically, we maintain a \"skyline\" or a set of available placement points.\n * However, the problem enforces a specific constructive placement order: \n * (p_i, r_i, d_i, b_i). This constructive method allows us to build structures relative to\n * previous ones.\n * \n * The (d, b) operation allows:\n * - 'U' (Up): Slide up until it hits something or y=0. Horizontal position is determined by \n * aligning left edge with b's right edge.\n * - 'L' (Left): Slide left until it hits something or x=0. Vertical position is determined by\n * aligning top edge with b's bottom edge.\n * \n * This structure strongly suggests we can build \"shelves\".\n * - A 'U' move with b=-1 starts a new column at x=0.\n * - A 'U' move with b=prev places a rectangle to the right of 'prev' (same row/shelf).\n * - A 'L' move with b=-1 starts a new row at y=0.\n * - A 'L' move with b=prev places a rectangle below 'prev' (same column).\n * \n * Let's define two primary packing strategies to try:\n * A. **Row-based Packing (Shelves)**:\n * We decide a max width W_limit. We place rectangles left-to-right. When a rectangle \n * doesn't fit in the current row width, we start a new row above the previous maximum height.\n * Wait, the \"slide\" mechanic is strictly local.\n * \n * Let's look at `d='U'` (slide Up).\n * It aligns left edge with `b`'s right edge.\n * If we chain `(U, -1), (U, 0), (U, 1)...`, we are placing rectangles in a row along the x-axis\n * at the bottom (because they slide up until y=0).\n * Wait, they slide UP. So they stop at y=0 (the bottom line? No, \"positive y-axis extends downward\").\n * Coordinate system:\n * x >= 0 (right), y >= 0 (down).\n * 'U': Moves upward (negative y direction) until it hits bottom edge of another or y=0.\n * So 'U' pushes items to the *top* of the container (y=0).\n * \n * Let's re-read carefully: \n * \"d='U', the rectangle is moved upward (decreasing y) until it stops at the bottom edge of another... or y=0.\"\n * So 'U' packs against the top edge of the box (y=0).\n * \n * \"b specifies which rectangle's right edge should align with the left edge of the new rectangle.\"\n * So if b=-1, x_new = 0.\n * If b=0, x_new = x_0 + w_0.\n * \n * Therefore, a sequence `(U, -1), (U, 0), (U, 1)` creates a horizontal row at y=0.\n * Rect 0 is at (0,0). Rect 1 is at (w0, 0). Rect 2 is at (w0+w1, 0).\n * \n * How do we start a second row?\n * We need something to stop the 'U' movement at a lower y (higher value).\n * The 'U' movement stops when it hits a *bottom edge*.\n * So if we have a row at y=0, and we place a new rect, we want it to stop at the bottom of the first row.\n * However, the x-alignment is determined by `b`.\n * If we do `(U, -1)` again, it aligns with x=0. It moves up. It will hit the bottom of the first rect in the first row.\n * So `(U, -1)` effectively starts a new row below the first one (assuming the first one covers x=0).\n * \n * So, a **Shelf Packing** strategy works naturally with the 'U' operation:\n * - Sort rectangles by height (or some heuristic).\n * - Fill a shelf from left to right using `(U, prev_in_shelf)`.\n * - When width limit is reached, start new shelf with `(U, -1)`.\n * \n * Wait, what if the new shelf's first item is narrower than the item above it?\n * The subsequent items in the second row will slide up.\n * If item 2 in row 2 is placed with `(U, item 1 of row 2)`, its x is correct. Its y will decrease until it hits something.\n * It might slide past the first row's bottom if there's a gap!\n * This is the \"guillotine\" or \"shelf\" constraint issue.\n * To ensure clean shelves, we usually want the items in a row to have similar heights, or we treat the row height as the max height of items in it.\n * But the physics here allows interlocking.\n * \n * 3. **Algorithm**:\n * Since T is relatively small (N/2 to 4N) but allows for iterations, and N is small (up to 100),\n * we can run a local search or simulated annealing.\n * \n * **State**: A permutation of rectangles and a rotation configuration.\n * **Evaluation**: Simulate the placement using a max-width heuristic.\n * \n * We will focus on the `max_width` parameter. We want to minimize W+H.\n * Usually, a square-ish shape (W ~ H) minimizes W+H for a fixed Area.\n * So we target W ~ sqrt(Total Area).\n * \n * **Heuristic Logic**:\n * 1. Determine a target width `W_target`.\n * 2. Sort rectangles (e.g., by height descending) or use the current permutation.\n * 3. Place rectangles one by one.\n * - Try to add to current shelf (using `b = last_in_shelf`).\n * - If `current_x + w > W_target`, start new shelf (using `b = -1` and `d = 'U'`).\n * - We only use `d='U'`. This simplifies the logic to standard shelf packing.\n * (Using `L` is symmetric but mixing them is complex).\n * \n * **Refining the State**:\n * We can shuffle the order of rectangles.\n * We can flip rotations.\n * We can adjust `W_target`.\n * \n * Since we have `T` turns, we can simply try $T$ different configurations generated by a local search\n * that runs within the time limit, output the best one found so far for the actual query, \n * get the result, and if it's good, maybe tweak it, or just keep exploring.\n * \n * Actually, the problem asks us to output a placement $T$ times.\n * The score is the min over all turns.\n * This means we should output diversity. We should try to find the global minimum.\n * We can perform a hill-climbing or SA in memory, and output the best solution found in that batch\n * at each step.\n * \n * Wait, the feedback (W', H') gives us information about the *actual* sizes.\n * Can we use this?\n * Yes. After we place, we get W' and H'.\n * The discrepancy between expected W and observed W' might tell us if our specific rectangles were larger/smaller.\n * However, with N=100 and sigma=1000~10000, the noise is high.\n * Simple accumulation: `est_w[i]` could be updated. But simply averaging the input `w'_i` is the baseline.\n * Given we only have N measurements initially and get 1 global measurement per turn,\n * inferring individual dimensions is hard.\n * Better to rely on the initial `w'_i` and `h'_i` but add a margin or robust packing.\n * \n * **Key Strategy**:\n * We will run a Simulated Annealing (SA) / Hill Climbing loop locally.\n * In each turn $t=0 \\dots T-1$:\n * - Run SA for a short duration (e.g., 50ms) to find a good packing layout based on *current estimated sizes*.\n * - The layout is defined by: \n * 1. An order of rectangles.\n * 2. Rotation for each rectangle.\n * 3. A maximum width parameter for the shelf algorithm.\n * - We generate a candidate layout.\n * - Output it.\n * - Receive (W', H').\n * - Although we can't easily update individual sizes, we record this result.\n * - To maximize the chance of hitting the minimum, we should diversify the `max_width` \n * and the permutation.\n * - We will maintain the \"best found configuration\" and try to mutate it.\n * \n * **Packing Implementation Details**:\n * We simulate the `U` operations.\n * We need a fast simulator.\n * Positions: `x[i]`, `y[i]`.\n * Sequence: `i = 0..N-1` (in the permutation).\n * Operation for `p_k`: `U`, `b`.\n * If `b = -1`:\n * `x_k = 0`\n * `y_k` = max y such that it overlaps with any existing rect at `x_k` range.\n * Since we slide U (decreasing y) until hit, `y_k` will be `max( (y_j + h_j) for all j intersecting x-range )`.\n * Initial `y` is effectively infinity, slides down to `0` or `bottom of other`.\n * Wait, positive y is downward. 'U' is upward (decreasing y).\n * So we slide from +inf y towards 0.\n * It stops at `max(y_bottom_edge)` of obstacles below it? No.\n * \"moved upward ... stops at bottom edge of another ... or line y=0\".\n * This means it comes from below.\n * So `y` coordinate becomes `max(y_j + h_j)` for any `j` such that x-intervals overlap.\n * (Assuming j is \"above\" k, i.e., j has smaller y).\n * Yes.\n * \n * Simulator Complexity:\n * For each rect, we check intersections with all placed rects? O(N^2).\n * With N=100, O(N^2) is trivial (10,000 ops). We can run thousands of simulations.\n * \n * 4. **Handling Input/Output format**:\n * - Read N, T, sigma.\n * - Read initial w', h'.\n * - Loop T times.\n * - Flush output.\n * \n * 5. **Time Management**:\n * Total time 3.0s.\n * We distribute time across T turns.\n * However, usually finding a good packing is fast. The bottleneck is T outputs.\n * We can front-load the search.\n * \n * Actually, since the score is `min(s_t)`, we treat each turn as an independent attempt to get a low score.\n * BUT, we can carry over the best permutation found so far.\n * \n * We will iterate `W_limit` from `TotalArea / 1.0` to `TotalArea / 20.0`?\n * A dynamic `W_limit` search is good.\n * Also, vary the sort order.\n * Typical good heuristics for 2D packing:\n * - Sort by Height Descending (Level High)\n * - Sort by Width Descending\n * - Sort by Area Descending\n * \n * We will implement a \"Permutation + Rotation + MaxWidth\" state SA.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst double TIME_LIMIT = 2.95;\n\n// Utility for random numbers\nstruct Random {\n mt19937 rng;\n Random() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n int randint(int a, int b) { return uniform_int_distribution(a, b)(rng); }\n double randdouble(double a, double b) { return uniform_real_distribution(a, b)(rng); }\n} rnd;\n\n// Problem Inputs\nint N, T;\nlong long sigma;\nstruct Rect {\n int id;\n long long w, h; // Estimated dimensions\n};\nvector rects;\n\n// Solution representation\nstruct Operation {\n int p;\n int r;\n char d;\n int b;\n};\n\nstruct Placement {\n long long x, y, w, h;\n};\n\n// Scoring / Simulation\n// Returns pair\npair simulate(const vector& p, const vector& r, long long max_w, vector& ops) {\n ops.clear();\n ops.reserve(N);\n \n vector placed;\n placed.reserve(N);\n \n // We will use the strategy:\n // Place rectangles in the order of 'p'.\n // Use 'U' direction.\n // Try to pack into shelves constrained by 'max_w'.\n \n // Current shelf tracking\n int current_shelf_first_idx = -1;\n int last_in_shelf_idx = -1;\n long long current_shelf_width = 0;\n \n long long total_W = 0;\n long long total_H = 0;\n\n for (int i = 0; i < N; ++i) {\n int original_idx = p[i];\n bool rotate = (r[original_idx] == 1);\n long long w_curr = rotate ? rects[original_idx].h : rects[original_idx].w;\n long long h_curr = rotate ? rects[original_idx].w : rects[original_idx].h;\n \n // Check if we can add to current shelf\n // Conditions:\n // 1. It fits within max_w\n // 2. If it's the first item, it always fits (defines a new shelf)\n \n bool new_shelf = false;\n if (current_shelf_first_idx == -1) {\n new_shelf = true;\n } else {\n if (current_shelf_width + w_curr > max_w) {\n new_shelf = true;\n }\n }\n \n Operation op;\n op.p = original_idx;\n op.r = rotate ? 1 : 0;\n op.d = 'U';\n \n long long x_pos = 0;\n long long y_pos = 0;\n \n if (new_shelf) {\n op.b = -1;\n x_pos = 0;\n current_shelf_first_idx = original_idx; // store the ID of the rect\n // reset shelf width\n current_shelf_width = w_curr;\n } else {\n op.b = last_in_shelf_idx; // ID of previous rect in shelf\n // Find the x coordinate of the previous rect\n // We need to look up in 'placed' array. \n // Since 'placed' is appended in order i=0..N-1, placed[i-1] corresponds to last placed.\n // But let's be safe. The 'b' refers to the rect ID.\n // The previous rect in the loop was at index i-1.\n x_pos = placed.back().x + placed.back().w;\n current_shelf_width += w_curr;\n }\n \n last_in_shelf_idx = original_idx;\n \n // Calculate Y position\n // 'U' moves rect upward (decreasing y) until it hits y=0 or bottom of another.\n // It rests on the lowest obstacle that is above it in geometric space (max y of obstacles).\n // Since y-axis is down, \"upward\" means decreasing y.\n // \"Stops at bottom edge of another\".\n // Rects are placed at y >= 0.\n // The movement is from +infinity y to 0.\n // It hits the \"bottom edge\" of an existing rect.\n // Bottom edge y coordinate is (y_existing + h_existing).\n // So the new rect's top edge (y_new) will be max(y_existing + h_existing) for all existing intersecting x.\n \n long long max_y_obstacle = 0;\n for (const auto& pl : placed) {\n // Check horizontal overlap\n // [pl.x, pl.x + pl.w] vs [x_pos, x_pos + w_curr]\n if (max(pl.x, x_pos) < min(pl.x + pl.w, x_pos + w_curr)) {\n max_y_obstacle = max(max_y_obstacle, pl.y + pl.h);\n }\n }\n \n y_pos = max_y_obstacle;\n \n placed.push_back({x_pos, y_pos, w_curr, h_curr});\n ops.push_back(op);\n \n total_W = max(total_W, x_pos + w_curr);\n total_H = max(total_H, y_pos + h_curr);\n }\n \n return {total_W, total_H};\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n \n cin >> N >> T >> sigma;\n rects.resize(N);\n long long total_area = 0;\n for (int i = 0; i < N; ++i) {\n rects[i].id = i;\n cin >> rects[i].w >> rects[i].h;\n total_area += rects[i].w * rects[i].h;\n }\n \n // Precompute sorted indices by different criteria to seed the search\n vector p_area_desc(N), p_h_desc(N), p_w_desc(N), p_max_dim_desc(N);\n iota(p_area_desc.begin(), p_area_desc.end(), 0);\n iota(p_h_desc.begin(), p_h_desc.end(), 0);\n iota(p_w_desc.begin(), p_w_desc.end(), 0);\n iota(p_max_dim_desc.begin(), p_max_dim_desc.end(), 0);\n \n sort(p_area_desc.begin(), p_area_desc.end(), [&](int a, int b){\n return rects[a].w * rects[a].h > rects[b].w * rects[b].h;\n });\n sort(p_h_desc.begin(), p_h_desc.end(), [&](int a, int b){\n return max(rects[a].w, rects[a].h) > max(rects[b].w, rects[b].h); // approximation\n });\n \n // State for SA\n // 1. Permutation\n // 2. Rotations (bitmap)\n // 3. Max Width Ratio (from 0.1 to 2.0 of sqrt(Area) or just pure width)\n \n // Initial Best\n vector best_p = p_area_desc;\n vector best_r(N, 0);\n // Initialize rotations to align longer side vertically (usually helps packing)\n for(int i=0; i rects[i].h) best_r[i] = 1;\n }\n \n // Reasonable width range: sqrt(total_area).\n // We want W ~ H ~ sqrt(Area).\n double side = sqrt(total_area);\n long long best_max_w = (long long)(side); \n \n long long best_score = -1;\n vector best_ops;\n \n // Current state\n vector curr_p = best_p;\n vector curr_r = best_r;\n long long curr_max_w = best_max_w;\n \n auto calc_score = [&](long long W, long long H) {\n return W + H;\n };\n \n // Initial Evaluate\n {\n vector ops;\n auto [W, H] = simulate(curr_p, curr_r, curr_max_w, ops);\n best_score = calc_score(W, H);\n best_ops = ops;\n }\n\n // Time control\n auto start_time = chrono::steady_clock::now();\n \n for (int t = 0; t < T; ++t) {\n // We continue searching from the best known or current state\n // But we can re-seed occasionally to escape local optima\n \n // Strategy for Turn t:\n // Run SA/HillClimbing for a slice of time.\n // The available time per turn is (Total - Elapsed) / (T - t).\n // We should use almost all of it, but leave safety margin.\n \n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n double remaining = TIME_LIMIT - elapsed;\n double time_slot = remaining / (T - t);\n \n // If time is very tight, just output best immediately\n if (time_slot < 0.001) time_slot = 0.0;\n \n auto turn_start = now;\n \n // Re-initialize current to best found so far to exploit\n // But maybe perturb significantly if we are stuck?\n // For the first few turns, explore diversity.\n \n // Exploration phase: if t is small, try different width seeds\n if (t < 10) {\n curr_p = p_area_desc;\n // Shuffle a bit\n for(int k=0; k turn_ops;\n pair turn_res;\n long long turn_min_score = -1;\n \n int iter_count = 0;\n \n while (true) {\n iter_count++;\n if ((iter_count & 127) == 0) {\n auto curr_time = chrono::steady_clock::now();\n if (chrono::duration(curr_time - turn_start).count() > time_slot) break;\n }\n \n // Neighbor generation\n // 1. Swap two indices in P\n // 2. Move an index in P\n // 3. Flip rotation\n // 4. Change max_w\n \n vector next_p = curr_p;\n vector next_r = curr_r;\n long long next_max_w = curr_max_w;\n \n int type = rnd.randint(0, 10);\n if (type <= 3) { // Swap\n int i = rnd.randint(0, N - 1);\n int j = rnd.randint(0, N - 1);\n swap(next_p[i], next_p[j]);\n } else if (type <= 5) { // Flip R\n int i = rnd.randint(0, N - 1);\n // In P, find original index\n next_r[next_p[i]] = 1 - next_r[next_p[i]];\n } else if (type <= 8) { // Change Width\n // Small perturbation\n double factor = rnd.randdouble(0.9, 1.1);\n next_max_w = (long long)(next_max_w * factor);\n if (next_max_w < 1) next_max_w = 1;\n } else { // Large change Width\n double factor = rnd.randdouble(0.5, 2.0);\n next_max_w = (long long)(side * factor);\n if (next_max_w < 1) next_max_w = 1;\n }\n \n // Evaluate\n vector temp_ops;\n auto [W, H] = simulate(next_p, next_r, next_max_w, temp_ops);\n long long score = calc_score(W, H);\n \n // Acceptance (Simple Hill Climbing / Late Acceptance prefered for speed, \n // but let's just keep track of global best and local current)\n \n // If we are in the first iteration of this turn, initialize\n if (turn_min_score == -1 || score < turn_min_score) {\n turn_min_score = score;\n turn_ops = temp_ops;\n turn_res = {W, H};\n \n curr_p = next_p;\n curr_r = next_r;\n curr_max_w = next_max_w;\n } else {\n // Maybe accept with probability? \n // Given the noise and nature, greedy on local neighborhood is okay-ish\n // But we need escape.\n // Simple simulated annealing probability\n // T_temp decreases.\n // But let's stick to random restarts + greedy logic within time slice.\n // If slightly worse, accept occasionally?\n if (rnd.randdouble(0, 1) < 0.05) {\n curr_p = next_p;\n curr_r = next_r;\n curr_max_w = next_max_w;\n }\n }\n \n // Update Global Best\n if (score < best_score) {\n best_score = score;\n best_ops = temp_ops;\n best_p = next_p;\n best_r = next_r;\n best_max_w = next_max_w;\n }\n }\n \n // Output the best operations found for this turn\n // Note: We should probably output the 'turn_ops' which is the result of local search in this turn.\n // However, if global 'best_ops' is better than what we found in this random restart, should we use it?\n // If we use the exact same configuration, we get another measurement of the same layout.\n // Given the measurement noise, re-measuring a good layout is not very useful unless we are uncertain.\n // But we are uncertain! The sigma is high.\n // However, finding *another* layout that might be better is more valuable.\n // So we prioritize diversity: output 'turn_ops' (result of this search).\n // UNLESS 'turn_ops' is garbage compared to 'best_ops'.\n // Let's output the best of current search.\n \n // Use the best found in this turn's search\n if (turn_ops.empty()) { \n // Fallback\n turn_ops = best_ops;\n }\n \n // Check if current turn result is significantly worse than global best\n // If so, maybe revert to global best with a small tweak for next turn?\n // For output, we just output turn_ops.\n \n cout << turn_ops.size() << endl;\n for (const auto& op : turn_ops) {\n cout << op.p << \" \" << op.r << \" \" << op.d << \" \" << op.b << endl;\n }\n \n // Get feedback\n long long obs_W, obs_H;\n cin >> obs_W >> obs_H;\n \n // We could use obs_W, obs_H to calibrate, but ignoring for this solution\n }\n \n return 0;\n}","ahc041":"/**\n * AtCoder Heuristic Contest 041\n * Problem: Christmas Trees\n * Author: Algorithm Engineer\n * \n * Strategy:\n * 1. Construct an initial valid solution by picking roots and growing BFS/DFS trees\n * while respecting height limit H.\n * 2. Use Simulated Annealing to improve the solution.\n * - State: Parent array P.\n * - Moves:\n * a. Change Parent: v changes parent to neighbor u (if valid).\n * b. Cut: v becomes a root.\n * c. Graft: Move a subtree to a different parent.\n * - Energy: Total attractiveness.\n * 3. Maintain depth and subtree height constraints incrementally.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst int MAX_N = 1005;\nconst int MAX_H = 10;\nint N, M, H;\nint A[MAX_N];\nvector adj[MAX_N]; // Graph G\nstruct Point { int x, y; } coords[MAX_N];\n\n// --- Random Engine ---\nmt19937 rng(12345);\n\n// --- Time Management ---\nauto start_time = chrono::high_resolution_clock::now();\ndouble get_elapsed() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// --- Solution State ---\nstruct State {\n int parent[MAX_N];\n vector children[MAX_N]; // Maintain explicit tree structure for fast updates\n int depth[MAX_N];\n long long score;\n\n State() {\n fill(parent, parent + MAX_N, -2); // -2: unassigned\n score = 0;\n }\n\n // Initialize with a greedy strategy\n void init_greedy() {\n fill(parent, parent + N, -2);\n for(int i=0; i p(N);\n iota(p.begin(), p.end(), 0);\n shuffle(p.begin(), p.end(), rng);\n\n fill(depth, depth + N, 0);\n \n // Start with some random roots. \n // Number of roots is tricky. Let's pick approx N/10 roots.\n int num_roots = max(1, N / 15);\n vector q;\n vector visited(N, false);\n\n for(int i=0; i= H) continue;\n\n // Shuffle neighbors for randomness\n vector neighbors = adj[u];\n shuffle(neighbors.begin(), neighbors.end(), rng);\n\n for(int v : neighbors) {\n if (!visited[v]) {\n visited[v] = true;\n parent[v] = u;\n children[u].push_back(v);\n depth[v] = depth[u] + 1;\n q.push_back(v);\n }\n }\n }\n\n bool all_visited = true;\n for(int i=0; i q_bfs;\n q_bfs.clear();\n q_bfs.push_back(u);\n int ptr = 0;\n \n while(ptr < q_bfs.size()){\n int curr = q_bfs[ptr++];\n max_d = max(max_d, depth[curr]);\n for(int v : children[curr]) {\n depth[v] = depth[curr] + 1;\n q_bfs.push_back(v);\n }\n }\n return max_d;\n }\n\n // Get max depth of subtree relative to u (i.e., height of subtree)\n int get_subtree_height(int u) {\n int h = 0;\n static vector> s_dfs; \n s_dfs.clear();\n s_dfs.push_back({u, 0});\n \n // Iterative DFS\n while(!s_dfs.empty()) {\n auto [curr, d] = s_dfs.back();\n s_dfs.pop_back();\n h = max(h, d);\n for(int v : children[curr]) {\n s_dfs.push_back({v, d+1});\n }\n }\n return h;\n }\n\n // Check if u is an ancestor of v\n bool is_ancestor(int u, int v) {\n int curr = v;\n while(curr != -1) {\n if(curr == u) return true;\n curr = parent[curr];\n }\n return false;\n }\n \n // Returns the change in score\n long long try_move_parent(int v, int new_p) {\n if (parent[v] == new_p) return 0;\n \n // Check cycle: new_p cannot be a descendant of v\n if (is_ancestor(v, new_p)) return -1e18; // Invalid\n\n // Check height constraint\n // We need the height of the subtree at v\n int v_subtree_h = get_subtree_height(v);\n int new_p_depth = (new_p == -1) ? -1 : depth[new_p]; // if new_p is root, its depth is 0. Wait, logic check.\n // If v becomes root (new_p == -1), depth[v] becomes 0.\n // If v attaches to new_p, depth[v] becomes depth[new_p] + 1.\n \n int new_v_depth = new_p_depth + 1;\n if (new_v_depth + v_subtree_h > H) return -1e18; // Invalid\n\n // Move is valid. Calculate score delta.\n // All nodes in subtree of v shift depth by (new_v_depth - current_depth[v])\n int depth_diff = new_v_depth - depth[v];\n if (depth_diff == 0) return 0; // No score change (e.g. attaching to sibling)\n\n long long score_delta = 0;\n \n // BFS to sum up A[x] * depth_diff\n static vector q_bfs;\n q_bfs.clear();\n q_bfs.push_back(v);\n int ptr = 0;\n while(ptr < q_bfs.size()){\n int curr = q_bfs[ptr++];\n score_delta += (long long)A[curr] * depth_diff;\n for(int child : children[curr]) {\n q_bfs.push_back(child);\n }\n }\n\n return score_delta;\n }\n\n void apply_move_parent(int v, int new_p) {\n int old_p = parent[v];\n \n // Remove from old parent's children list\n if (old_p != -1) {\n auto& siblings = children[old_p];\n // Find and swap-remove is faster than erase\n for(size_t i=0; i> N >> M >> H)) return;\n for(int i=0; i> A[i];\n for(int i=0; i> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n for(int i=0; i> coords[i].x >> coords[i].y;\n\n // Initial Solution\n State current_state;\n current_state.init_greedy();\n \n State best_state = current_state;\n \n // SA Parameters\n double T_start = 100.0;\n double T_end = 0.1;\n double time_limit = 1.95;\n \n int iter = 0;\n \n while (true) {\n iter++;\n if ((iter & 255) == 0) {\n double t = get_elapsed();\n if (t > time_limit) break;\n // Temperature schedule\n double progress = t / time_limit;\n double T = T_start * pow(T_end / T_start, progress);\n \n // Small optimization: occasionally try to deepen leaves greedily\n // Not implemented in main loop to keep it fast\n }\n\n // --- Neighbor Selection ---\n // Pick a random node v\n int v = rng() % N;\n \n // Operations:\n // 1. Move v to be a child of one of its neighbors u (u != current_parent)\n // 2. Make v a root (if not already)\n \n // Determine possible moves\n vector candidates;\n candidates.reserve(adj[v].size() + 1);\n \n // Option: Make root\n if (current_state.parent[v] != -1) {\n candidates.push_back(-1);\n }\n \n for (int u : adj[v]) {\n if (u == current_state.parent[v]) continue;\n candidates.push_back(u);\n }\n \n if (candidates.empty()) continue;\n \n int new_p = candidates[rng() % candidates.size()];\n \n // Evaluate Move\n long long delta = current_state.try_move_parent(v, new_p);\n \n if (delta <= -1e17) continue; // Invalid move\n\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double t = get_elapsed();\n double progress = t / time_limit;\n double T = T_start * pow(T_end / T_start, progress);\n if (rng() / (double)rng.max() < fast_exp(delta / T)) {\n accept = true;\n }\n }\n\n if (accept) {\n current_state.apply_move_parent(v, new_p);\n current_state.score += delta;\n \n if (current_state.score > best_state.score) {\n best_state = current_state;\n // best_state.recalc_score(); // sanity check\n }\n }\n }\n \n // Final optimization: Try to attach roots to neighbors if possible to gain score\n // Often roots are \"wasted\" depth 0.\n for(int i=0; i max_delta) {\n max_delta = delta;\n best_neighbor = u;\n }\n }\n \n if (best_neighbor != -1) {\n best_state.apply_move_parent(i, best_neighbor);\n best_state.score += max_delta;\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#include \n\nusing namespace std;\n\n// Constants\nconst int N = 20;\nconst int MAX_MOVES = 4 * N * N;\n\n// Enum for directions\nenum Direction { L = 0, R = 1, U = 2, D = 3 };\n\nstruct Move {\n Direction dir;\n int idx; // row or col index\n};\n\n// Board state representation\nstruct State {\n char grid[N][N];\n int score; // Heuristic score (lower is better)\n int moves_count;\n // We store the sequence of moves to reconstruct the path. \n // To save memory, in a real contest with huge beam, we might use parent pointers.\n // Given N=20 and beam width ~1000, copying vectors of moves might be heavy.\n // Let's use a parent pointer approach with a pool of nodes.\n int parent_index; \n Move last_move;\n int oni_count;\n \n // For cycle detection / deduplication\n size_t hash;\n\n bool operator>(const State& other) const {\n return score > other.score;\n }\n};\n\n// Node pool to manage states and reconstruction\nstruct Node {\n char grid[N][N];\n int parent;\n Move last_move;\n int g; // cost so far (number of moves)\n int h; // heuristic\n int f; // g + h\n size_t hash;\n \n bool operator<(const Node& other) const {\n // Priority queue orders by max, so we want min f.\n // However, we usually iterate and select top K.\n return f < other.f; \n }\n};\n\n// Global pool\nvector node_pool;\n\n// Zobrist hashing (simplified)\nunsigned long long zobrist[N][N][3]; // 0: ., 1: x, 2: o\n\nvoid init_zobrist() {\n mt19937_64 rng(1337);\n for(int i=0; i 0; --c) grid[r][c] = grid[r][c-1];\n grid[r][0] = '.';\n } else if (m.dir == U) {\n int c = m.idx;\n if (grid[0][c] == 'o') return false;\n for (int r = 0; r < N - 1; ++r) grid[r][c] = grid[r+1][c];\n grid[N-1][c] = '.';\n } else if (m.dir == D) {\n int c = m.idx;\n if (grid[N-1][c] == 'o') return false;\n for (int r = N - 1; r > 0; --r) grid[r][c] = grid[r-1][c];\n grid[0][c] = '.';\n }\n return true;\n}\n\nint count_oni(const char grid[N][N]) {\n int cnt = 0;\n for(int i=0; i> dummyN)) return; \n // N is always 20\n \n Node start_node;\n start_node.parent = -1;\n start_node.g = 0;\n \n for (int i = 0; i < N; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < N; ++j) {\n start_node.grid[i][j] = row[j];\n }\n }\n\n init_zobrist();\n start_node.hash = compute_hash(start_node.grid);\n start_node.h = calculate_heuristic(start_node.grid);\n start_node.f = start_node.g + start_node.h;\n \n node_pool.reserve(200000); // Preallocate\n node_pool.push_back(start_node);\n \n // Beam Search\n // Current beam is a list of indices into node_pool\n vector beam;\n beam.push_back(0);\n \n int best_solution_idx = -1;\n int min_solution_moves = 999999;\n \n // Timer\n auto start_time = chrono::high_resolution_clock::now();\n \n // Visited set for the current depth or globally?\n // Globally is better to detect reconvergence.\n // Using a map or set with hash.\n // Since we want minimal steps, if we reach same hash with more steps, ignore.\n // If same hash with fewer steps, update.\n // But in beam search, we process layer by layer usually.\n // Let's use a simple set seen_hashes;\n // But since g increases, we might revisit a state with higher g later? No, BFS-like structure.\n // Actually, simply checking if hash exists in 'current' or 'next' beam is often enough for contest heuristics.\n // Let's use a global visited set storing min_g for that hash.\n // Using a large hash table (vector + masking) for speed could work, but std::map is safer.\n // Let's use Unordered Map.\n // Actually, just dedup within the beam generation is usually sufficient and faster.\n \n int max_beam_width = 200; \n int depth = 0;\n \n while (!beam.empty() && depth < MAX_MOVES) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.85) break;\n\n vector> next_candidates; // (score, node_index)\n // We can't store all candidates then sort, might be too big.\n // 80 moves * 1000 beam = 80000 candidates. Sorting is fine.\n\n // Deduplication for the next step\n vector next_hashes;\n next_hashes.reserve(beam.size() * 80);\n\n for (int p_idx : beam) {\n const auto& parent = node_pool[p_idx];\n \n // If solved\n if (parent.h == 0 && count_oni(parent.grid) == 0) {\n if (parent.g < min_solution_moves) {\n min_solution_moves = parent.g;\n best_solution_idx = p_idx;\n }\n // We can continue to find potentially better paths if we haven't timed out,\n // but usually the first one found in BFS-like search is optimal in moves.\n // However, our heuristic is not admissible for A*, so it's greedy.\n // Let's just keep searching.\n continue; \n }\n \n // Try all 4 directions * N indices\n for (int d = 0; d < 4; ++d) {\n for (int k = 0; k < N; ++k) {\n // Optimization: Don't move empty rows/cols outwards endlessly\n // Or don't move rows that have no Oni and no Fukunokami?\n // Actually, simply trying all valid moves is safest.\n \n // Minor Optimization:\n // If row k has no Oni and no Fukunokami, moving it is useless?\n // Not necessarily, it changes nothing. So skip.\n // If row k has Fukunokami but no Oni, moving it is risky/useless unless it helps columns.\n // Let's skip strict pruning to avoid bugs, relying on heuristic.\n \n Node child;\n // Copy grid\n for(int r=0; r 1 makes it greedier.\n child.f = child.g + child.h; \n }\n\n child.parent = p_idx;\n child.last_move = m;\n \n // Store temporarily\n node_pool.push_back(child);\n next_candidates.push_back({child.f, (int)node_pool.size() - 1});\n }\n }\n }\n }\n \n if (next_candidates.empty()) break;\n\n // Sort and pick top K\n // Use partial sort or nth_element\n if (next_candidates.size() > max_beam_width) {\n // We want smallest f\n nth_element(next_candidates.begin(), next_candidates.begin() + max_beam_width, next_candidates.end());\n next_candidates.resize(max_beam_width);\n }\n \n // Prepare beam for next iteration\n // Handle deduplication here to keep beam diverse\n beam.clear();\n sort(next_candidates.begin(), next_candidates.end());\n \n set seen_in_beam;\n for (auto& p : next_candidates) {\n int idx = p.second;\n size_t h = node_pool[idx].hash;\n if (seen_in_beam.find(h) == seen_in_beam.end()) {\n seen_in_beam.insert(h);\n beam.push_back(idx);\n }\n }\n \n // If we found a solution and current best candidate f is much worse than solution, maybe stop?\n // But 'f' includes heuristic.\n if (best_solution_idx != -1) {\n // If the best node in beam has g >= best_solution_moves, we can't improve.\n // Because g only grows.\n if (node_pool[beam[0]].g >= min_solution_moves) break;\n }\n \n depth++;\n }\n \n // Reconstruct path\n if (best_solution_idx == -1) {\n // Should not happen given the problem guarantees and time limit, \n // but if it does, output nothing or partial?\n // Problem says \"If X>0 ... score is low\". Outputting valid moves is better than TLE.\n // Pick best from beam.\n if (!beam.empty()) best_solution_idx = beam[0];\n else best_solution_idx = 0; // Initial state\n }\n \n vector result;\n int curr = best_solution_idx;\n while (node_pool[curr].parent != -1) {\n result.push_back(node_pool[curr].last_move);\n curr = node_pool[curr].parent;\n }\n reverse(result.begin(), result.end());\n \n // Output\n // string conversion\n char dirs[] = {'L', 'R', 'U', 'D'};\n for (const auto& m : result) {\n cout << dirs[m.dir] << \" \" << m.idx << \"\\n\";\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc044":"#include \n#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 = 100;\nconst int L = 500000;\n\n// Global variables for problem input\nint T[N];\n\n// Struct to represent a solution\nstruct Solution {\n int a[N];\n int b[N];\n long long score; // Error, lower is better\n};\n\n// Simulation function to calculate error\nlong long calculate_error(const Solution& sol) {\n vector counts(N, 0);\n vector visit_state(N, 0); // Number of times visited so far\n \n int current = 0;\n // Counts for current are updated *before* moving\n // Wait, problem says:\n // Week 1: Employee 0 cleans.\n // Week k: Let x be cleaner of week k-1. Let t be visits of x by end of week k-1.\n // If t odd -> a_x, even -> b_x.\n \n // Let's trace carefully.\n // Week 1: current = 0. \n // End of Week 1: visit_state[0] becomes 1. counts[0] becomes 1.\n // Week 2: x = 0. t = 1 (odd). Next is a[0].\n \n // Initialization\n current = 0;\n \n for (int week = 0; week < L; ++week) {\n counts[current]++;\n visit_state[current]++;\n \n // Determine next\n // t is visit_state[current]\n int t = visit_state[current];\n if (t % 2 != 0) {\n current = sol.a[current];\n } else {\n current = sol.b[current];\n }\n }\n \n long long error = 0;\n for (int i = 0; i < N; ++i) {\n error += abs(counts[i] - T[i]);\n }\n return error;\n}\n\n// Random number generator\nmt19937 rng(12345);\n\n// Function to generate an initial solution based on flow matching\nSolution generate_initial_solution() {\n Solution sol;\n \n // Available capacity for \"odd\" (a) and \"even\" (b) edges\n vector supply_a(N), supply_b(N);\n vector demand(N);\n \n vector nodes_with_demand;\n \n for (int i = 0; i < N; ++i) {\n supply_a[i] = (T[i] + 1) / 2; // Ceil(T_i / 2)\n supply_b[i] = T[i] / 2; // Floor(T_i / 2)\n demand[i] = T[i];\n if (T[i] > 0) nodes_with_demand.push_back(i);\n }\n \n // Adjust demand for node 0 (gets 1st visit for free)\n if (demand[0] > 0) demand[0]--; \n // Note: if T[0] is 0, the problem constraints are violated or logic is weird, \n // but T_sum = L so usually T[0] > 0 or someone is reachable. \n // Actually, if T[0]=0, node 0 is visited once then leaves. \n // But the problem says T_0 is target. If target is 0, error increases by 1.\n // Let's assume standard case.\n \n // 1. Ensure Connectivity: Create a backbone cycle/path covering all nodes with T[i] > 0.\n // We shuffle the nodes to make random cycles.\n shuffle(nodes_with_demand.begin(), nodes_with_demand.end(), rng);\n \n // Temporary storage for assignments\n fill(sol.a, sol.a + N, 0); // Default to 0\n fill(sol.b, sol.b + N, 0);\n \n // Track which slot was used for the backbone\n vector a_used(N, false);\n vector b_used(N, false);\n \n if (!nodes_with_demand.empty()) {\n for (size_t k = 0; k < nodes_with_demand.size(); ++k) {\n int u = nodes_with_demand[k];\n int v = nodes_with_demand[(k + 1) % nodes_with_demand.size()];\n \n // We prefer to use 'a' (odd) for backbone as it's always available if T > 0\n if (supply_a[u] > 0) {\n sol.a[u] = v;\n supply_a[u]--;\n a_used[u] = true;\n demand[v]--;\n } else if (supply_b[u] > 0) {\n // Should ideally not happen if T >= 1, but for safety\n sol.b[u] = v;\n supply_b[u]--;\n b_used[u] = true;\n demand[v]--;\n }\n }\n }\n \n // 2. Fill remaining demands with remaining supplies\n // Create lists of available ports\n vector> ports; // {u, type}: type 0 for a, 1 for b\n for (int i = 0; i < N; ++i) {\n while (supply_a[i] > 0) {\n ports.push_back({i, 0});\n supply_a[i]--;\n }\n while (supply_b[i] > 0) {\n ports.push_back({i, 1});\n supply_b[i]--;\n }\n }\n \n vector receivers;\n for (int i = 0; i < N; ++i) {\n while (demand[i] > 0) {\n receivers.push_back(i);\n demand[i]--;\n }\n }\n \n // Shuffle to distribute randomly\n shuffle(ports.begin(), ports.end(), rng);\n shuffle(receivers.begin(), receivers.end(), rng);\n \n // Match\n size_t limit = min(ports.size(), receivers.size());\n for (size_t k = 0; k < limit; ++k) {\n int u = ports[k].first;\n int type = ports[k].second;\n int v = receivers[k];\n \n if (type == 0) {\n // If 'a' was already used by backbone, we can't overwrite it directly\n // Actually, the backbone logic above consumed the supply count.\n // But we need to check if we are assigning to the variable a[u] that was already set?\n // Wait, supply_a count is decremented. 'a' slot is single.\n // Ah, if T[i] >= 3, we have multiple supplies for 'a'? \n // No! The problem defines only ONE a_i and ONE b_i.\n // But the \"capacity\" notion in flow was abstract.\n // Real constraint: \n // Node i sends roughly T[i]/2 flow to a_i and T[i]/2 to b_i.\n // This means ALL \"odd\" flow goes to a_i, ALL \"even\" flow goes to b_i.\n // We cannot split odd flow to multiple destinations.\n // So my flow logic was slightly flawed: capacity is not integral packets to different dests.\n // Capacity is total flow, but destination is UNIQUE per type.\n \n // Correction:\n // We determine a_i and b_i. \n // a_i receives ceil(T[i]/2) flow.\n // b_i receives floor(T[i]/2) flow.\n // We need to assign a_i = v such that v needs flow.\n // But wait, if we set a_i = v, v gets ALL the odd flow from i.\n // So we are matching (Source i, type ODD) -> Target j with weight Ceil(T[i]/2).\n // This is a \"Weighted Matching\" problem or \"Generalized Assignment\".\n // Since we can split demand of j into pieces coming from various sources, this is fine.\n // But the source (i, odd) is atomic.\n }\n }\n \n // Let's restart the strategy with the Atomic constraint in mind.\n // Objects to assign:\n // 1. Output 'a' from node i: carries weight W_a[i] = ceil(T[i]/2)\n // 2. Output 'b' from node i: carries weight W_b[i] = floor(T[i]/2)\n // Targets: Node j with capacity C[j] = T[j]. (Node 0 capacity T[0]-1 effectively)\n // Constraint: Sum of weights assigned to j should be approx T[j].\n // Since we want to minimize sum of absolute diffs, this is exactly the Multiprocessor Scheduling problem \n // or Bin Packing variant where we want to fill bins j to level T[j].\n \n // New Construction Algorithm:\n // 1. Create items: (i, 'a', weight), (i, 'b', weight). Filter out weight 0.\n // 2. Create bins: j with capacity T[j].\n // 3. Assign items to bins to minimize overflow/underflow. \n // Greedy approach: Sort items by weight descending. Put into bin with most remaining space.\n // 4. Ensure connectivity! The graph formed by these edges must be connected (specifically reachable from 0).\n \n return sol; // Placeholder, actual logic below\n}\n\nstruct Item {\n int u;\n int type; // 0 for a, 1 for b\n int weight;\n};\n\nstruct Bin {\n int id;\n int capacity;\n int current_load;\n};\n\nSolution generate_solution_greedy_bin_packing() {\n Solution sol;\n // Initialize with random valid nodes to avoid 0-0 loops if unused\n for(int i=0; i items;\n for(int i=0; i 0) items.push_back({i, 0, w_a});\n if (w_b > 0) items.push_back({i, 1, w_b});\n }\n\n // Sort items descending by weight\n sort(items.begin(), items.end(), [](const Item& a, const Item& b){\n return a.weight > b.weight;\n });\n\n // Prepare bins\n // Use a priority queue for bins with most remaining space?\n // Or just vector and linear scan for best fit / worst fit?\n // Since N is small, linear scan is fine.\n vector current_load(N, 0);\n vector target_load(N);\n for(int i=0; i 0) target_load[0]--; // Account for initial visit\n\n // Connectivity enforcement:\n // Build a backbone.\n // Select a set of items that form a cycle (or path) covering all nodes with T > 0.\n // We can just pick one item (preferred 'a') from each significant node u and assign to next node v.\n // But we need to be careful about weights.\n \n vector nodes_with_t;\n for(int i=0; i 0) nodes_with_t.push_back(i);\n shuffle(nodes_with_t.begin(), nodes_with_t.end(), rng);\n\n vector item_used(items.size(), false);\n\n // Pre-assign backbone\n if (!nodes_with_t.empty()) {\n for(size_t k=0; k= weight\n int rem = target_load[bin_idx] - current_load[bin_idx];\n int diff = abs(rem - items[i].weight);\n \n // Heuristic: prefer filling underfilled bins\n // If rem < 0, bin is overloaded.\n \n if (diff < min_diff) {\n min_diff = diff;\n best_bin = bin_idx;\n }\n }\n \n // Update\n if (items[i].type == 0) sol.a[items[i].u] = best_bin;\n else sol.b[items[i].u] = best_bin;\n current_load[best_bin] += items[i].weight;\n }\n \n sol.score = 0; // Will be calculated externally\n return sol;\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N_in, L_in;\n if (!(cin >> N_in >> L_in)) return 0;\n \n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n // Time management\n auto start_time = chrono::high_resolution_clock::now();\n double time_limit = 1.90; // seconds\n\n Solution best_sol;\n best_sol.score = 1e18; // Initialize with large error\n\n // Initial generation attempts\n // Since the bin packing is heuristic and randomized, run it multiple times\n int iterations = 0;\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n chrono::duration elapsed = now - start_time;\n if (elapsed.count() > time_limit) break;\n\n Solution current_sol = generate_solution_greedy_bin_packing();\n \n // Refine phase: Hill Climbing / Simulated Annealing\n // Small local changes: \n // 1. Change destination of one edge\n // 2. Swap destinations of two edges\n \n current_sol.score = calculate_error(current_sol);\n \n if (current_sol.score < best_sol.score) {\n best_sol = current_sol;\n }\n \n // Local search on current_sol\n int ls_steps = 250; // Small number of steps per restart\n for(int step=0; step(t - start_time).count() > time_limit) break;\n }\n\n Solution neighbor = current_sol;\n int type = rng() % 2;\n \n if (type == 0) {\n // Change one destination\n int u = rng() % N;\n int v = rng() % N;\n // Don't create self loop if not necessary? No, self loops are fine.\n if (rng() % 2 == 0) neighbor.a[u] = v;\n else neighbor.b[u] = v;\n } else {\n // Swap\n int u1 = rng() % N;\n int u2 = rng() % N;\n int edge1 = rng() % 2; // 0 for a, 1 for b\n int edge2 = rng() % 2;\n \n int& dest1 = (edge1 == 0 ? neighbor.a[u1] : neighbor.b[u1]);\n int& dest2 = (edge2 == 0 ? neighbor.a[u2] : neighbor.b[u2]);\n \n swap(dest1, dest2);\n }\n \n long long new_score = calculate_error(neighbor);\n if (new_score <= current_sol.score) {\n current_sol = neighbor;\n current_sol.score = new_score;\n if (new_score < best_sol.score) {\n best_sol = current_sol;\n }\n }\n }\n \n iterations++;\n }\n\n // Output\n for (int i = 0; i < N; ++i) {\n cout << best_sol.a[i] << \" \" << best_sol.b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// AC Library / External Tools placeholders (not strictly needed for this logic but good practice)\n// Using standard library for portability in this heuristic context.\n\nusing namespace std;\n\n// --- Constants and Globals ---\nint N, M, Q, L, W;\nvector G_req; // Group sizes\nstruct Rect {\n int lx, rx, ly, ry;\n long long cx, cy; // Center coordinates\n};\nvector cities;\nvector> true_edges_cache; // Stores edges returned by queries\n\n// --- Geometry & Utils ---\nstruct Point {\n long long x, y;\n};\n\nlong long dist_sq(int i, int j) {\n long long dx = cities[i].cx - cities[j].cx;\n long long dy = cities[i].cy - cities[j].cy;\n return dx * dx + dy * dy;\n}\n\ndouble dist_euclid(int i, int j) {\n return std::sqrt(dist_sq(i, j));\n}\n\nstruct Edge {\n int u, v;\n long long w_sq; // Squared distance (estimated)\n bool is_true; // Is this edge confirmed by oracle?\n \n bool operator<(const Edge& other) const {\n if (is_true != other.is_true) {\n return is_true > other.is_true; // True edges first (treated as length 0)\n }\n return w_sq < other.w_sq;\n }\n};\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\n// --- Logic ---\n\n// 1. Clustering / Group Assignment\n// We need to assign cities to groups 0..M-1 with sizes G_req[0]..G_req[M-1].\n// We try to minimize the sum of intra-group MST costs (approximated by bounding box distance).\n// Since exact MST cost is hard to optimize directly, we use spatial clustering.\nvector> assign_groups() {\n vector p(N);\n iota(p.begin(), p.end(), 0);\n \n // Sort groups by size (largest first might be better to secure space, or just process in order)\n // Actually, K-Means like approach with size constraints.\n \n // Initial assignment: Sort cities by x-coordinate (or Hilbert curve) and chunk them.\n // This is a good baseline.\n sort(p.begin(), p.end(), [&](int i, int j) {\n if (cities[i].cx != cities[j].cx) return cities[i].cx < cities[j].cx;\n return cities[i].cy < cities[j].cy;\n });\n\n // Try a few different sorting strategies and pick the one with best estimated MST cost?\n // Time limit is generous (2.0s) for N=800.\n // Let's implement a simple swap-based hill climbing after initial assignment.\n \n vector> groups(M);\n vector current_assignment(N); // city -> group index\n \n int current_idx = 0;\n for(int i=0; i centroids(M);\n auto update_centroids = [&]() {\n for(int i=0; i(now - start_time).count();\n if(elapsed > time_limit) break;\n\n // Randomly pick two cities from different groups\n int u = rng() % N;\n int v = rng() % N;\n int gu = current_assignment[u];\n int gv = current_assignment[v];\n\n if(gu == gv) continue;\n\n // Evaluate swap\n // Old contribution\n double dx_u = cities[u].cx - centroids[gu].x;\n double dy_u = cities[u].cy - centroids[gu].y;\n double dx_v = cities[v].cx - centroids[gv].x;\n double dy_v = cities[v].cy - centroids[gv].y;\n double old_local = (dx_u*dx_u + dy_u*dy_u) + (dx_v*dx_v + dy_v*dy_v);\n\n // New contribution approx (assuming centroids don't move much)\n double dx_u_new = cities[u].cx - centroids[gv].x;\n double dy_u_new = cities[u].cy - centroids[gv].y;\n double dx_v_new = cities[v].cx - centroids[gu].x;\n double dy_v_new = cities[v].cy - centroids[gu].y;\n double new_local = (dx_u_new*dx_u_new + dy_u_new*dy_u_new) + (dx_v_new*dx_v_new + dy_v_new*dy_v_new);\n \n double diff = new_local - old_local;\n\n if(diff < 0 || exp(-diff / temp) > (double)rng()/rng.max()) {\n // Accept\n // Update groups vector (slow, linear scan)\n // To make this fast, we need to know index in groups[g].\n // For now, just update assignment array and lazy update groups vector later.\n // But centroids depend on group content.\n // Given N is small, we can update centroids incrementally.\n \n // Update Centroids\n centroids[gu].x = (centroids[gu].x * groups[gu].size() - cities[u].cx + cities[v].cx) / groups[gu].size();\n centroids[gu].y = (centroids[gu].y * groups[gu].size() - cities[u].cy + cities[v].cy) / groups[gu].size();\n \n centroids[gv].x = (centroids[gv].x * groups[gv].size() - cities[v].cx + cities[u].cx) / groups[gv].size();\n centroids[gv].y = (centroids[gv].y * groups[gv].size() - cities[v].cy + cities[u].cy) / groups[gv].size();\n \n current_assignment[u] = gv;\n current_assignment[v] = gu;\n \n // Update groups structure logic needs to match.\n // Since we only have current_assignment, we rebuild groups at the end?\n // But we need groups size for centroid calculation.\n // Actually sizes are fixed G_req.\n // We just need to swap u and v in the groups lists?\n // Keeping groups vector consistent is painful. Let's just maintain current_assignment and counts.\n // Counts are fixed.\n \n current_score += diff;\n }\n \n temp *= cooling;\n }\n \n // Rebuild groups from current_assignment\n vector> final_groups(M);\n for(int i=0; i L:\n// We can use a \"rolling window\" along the estimated MST or estimated spatial ordering.\n// Sort cities in group spatially (e.g., by X or projected on PC1).\n// Query windows [0, L-1], [L-2, 2L-3], etc. (overlap by 1 or 2 to connect components).\n// Since L <= 15 and Q=400, and M up to 400, we have roughly 1 query per group on average.\n// \n// Priority:\n// 1. Groups where G_i <= L. These are cheap to solve perfectly.\n// 2. Larger groups. We might run out of queries.\n// \n// If Q is tight, we prioritize groups that look \"dense\" or \"messy\" (large bounding boxes relative to separation),\n// or just round robin.\n// Since scoring is sum of lengths, verifying edges in dense clusters is less valuable than long edges, \n// BUT incorrect long edges hurt more? Actually, MST minimizes sum of lengths.\n// The \"True\" MST is likely similar to Estimated MST unless bounding boxes are large/overlapping.\n//\n// Given constraints: M <= 400, Q = 400.\n// Almost 1 query per group.\n// Small groups (G <= L) should be queried immediately.\n// Large groups: We can't fully query. Maybe 1 query to connect the \"core\" or just skip?\n// Actually, if G > L, 1 query only covers a subset. It doesn't connect the whole group.\n// We must rely on estimated edges for the rest.\n//\n// Maybe we sort groups by \"ambiguity\"?\n// Or just prioritize small groups to get perfect scores there, and rely on estimation for large ones.\n\nstruct QueryResult {\n int u, v;\n};\n\nvector> query_oracle(const vector& subset) {\n if (subset.size() < 2) return {};\n cout << \"? \" << subset.size();\n for (int x : subset) cout << \" \" << x;\n cout << endl;\n\n vector> res;\n for (size_t i = 0; i < subset.size() - 1; ++i) {\n int u, v;\n cin >> u >> v;\n res.push_back({u, v});\n }\n return res;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n G_req.resize(M);\n for(int i=0; i> G_req[i];\n \n cities.resize(N);\n for(int i=0; i> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2;\n }\n\n // 1. Assign Groups\n vector> groups = assign_groups();\n\n // 2. Queries\n // We categorize groups.\n // Type A: Size <= L. One query solves it.\n // Type B: Size > L.\n // We prioritize Type A.\n // For Type B, we try to use remaining queries to verify edges along the estimated MST structure.\n // Specifically, we can traverse the estimated MST, and whenever we have a cluster of nodes, query it.\n // Due to Q limit, we likely only process Type A and maybe a few Type B.\n\n vector>> group_edges(M); // Confirmed edges\n int queries_left = Q;\n \n vector type_a_indices;\n vector type_b_indices;\n for(int i=0; i 0 && groups[idx].size() >= 2) {\n auto res = query_oracle(groups[idx]);\n group_edges[idx] = res;\n queries_left--;\n }\n }\n\n // Process Type B\n // Strategy for large groups with limited queries:\n // We construct an Estimated MST first.\n // We identify \"chains\" or \"clusters\" in the Estimated MST.\n // We can use queries to solidify parts of the MST.\n // A simple effective strategy:\n // Sort cities in group spatially. Slide a window of size L (overlap 1).\n // Query [0..L-1], [L-1..2L-2], ...\n // This ensures connectivity along the chain.\n // Since queries are scarce, we might stop early.\n \n for(int idx : type_b_indices) {\n if (queries_left <= 0) break;\n \n // Heuristic: Sort by X+Y or just X to linearize\n // A better linearization is traversing the estimated MST or TSP path.\n // Let's do a simple coordinate sort.\n vector sorted_g = groups[idx];\n sort(sorted_g.begin(), sorted_g.end(), [&](int a, int b){\n return cities[a].cx < cities[b].cx; // Simple X sort\n });\n\n int n_g = sorted_g.size();\n int step = L - 1; // Overlap by 1\n for (int i = 0; i < n_g - 1; i += step) {\n if (queries_left <= 0) break;\n \n int end = min(i + L, n_g);\n if (end - i < 2) break; // Should not happen if loop condition is right\n\n vector subset;\n for(int k=i; k all_candidates;\n \n // Add confirmed edges with priority\n for(auto& e : group_edges[i]) {\n all_candidates.push_back({e.first, e.second, 0, true});\n }\n\n // Add all pairs (or Delaunay/KNN if G is huge, but N<=800 so G^2 is max 640000, fine)\n // To save time, for large groups, we might not add ALL pairs.\n // But G^2 for sum G_i = N is actually sum(G_i^2). Worst case one group size 800.\n // 800^2 = 640,000. Sorting is fast enough.\n // Optimization: Only add edges from estimated MST?\n // No, estimated MST might be wrong. Better to add all edges and let Kruskal decide based on estimated dist.\n \n int g_sz = groups[i].size();\n if (g_sz < 2) {\n // Output format for group size 1? Problem says G_i >= 1.\n // If G_i = 1, output city, no edges.\n cout << groups[i][0] << endl;\n continue; \n }\n\n // Optimization: If group is large, computing all pairs distances is heavy if done naively for many groups.\n // But sum of G_i = 800. sum G_i^2 <= 800^2. It's fine.\n for(int j=0; j> final_tree_edges;\n int edges_needed = g_sz - 1;\n \n for(auto& e : all_candidates) {\n if (dsu.unite(e.u, e.v)) {\n final_tree_edges.push_back({e.u, e.v});\n if ((int)final_tree_edges.size() == edges_needed) break;\n }\n }\n \n // Output\n // Line 1: cities in group\n for(int j=0; j next_target):\n * We perform a search (like A* or Dijkstra) to find the cheapest sequence of operations.\n * To make the search tractable, we restrict the \"state\" of blocks. We assume we start with the current set of blocks.\n * Actions in the search:\n * - Move (cost 1)\n * - Slide (cost 1, requires stop). If stop doesn't exist, we might need to `Alter` first.\n * So we can consider composite actions: \"Create stop then Slide\" (cost 1+1=2), etc.\n * Actually, `Alter` takes a turn. So:\n * State = (r, c).\n * Transitions:\n * 1. Move neighbor: cost 1.\n * 2. Slide direction D: cost 1. Valid if there is a block to stop us at some (r', c').\n * Crucially, if there is NO block at the target square's boundary to stop us, can we create one?\n * Yes, by moving to the adjacent square, `Alter`, then moving back to start and sliding?\n * That's too expensive.\n * Usually, `Alter` is useful if we are *already* near the place where we need a block, OR if we are at the start\n * and can place a block adjacent to us to stop a *future* slide, or place a block far away? No, Alter is only adjacent.\n *\n * Therefore, `Alter` is effectively a local move. We can treat block placement as a cost.\n * If we want to stop at (r_dest, c_dest) using a slide from (r_src, c_src), we need a block at (r_dest + dir, c_dest + dir).\n * To place that block, we must walk there, `Alter`, and walk back (or to a sliding start).\n * This suggests `Alter` is generally too expensive for a single slide unless the block is already there or we are very close to the stop point.\n * EXCEPTION: We can use existing blocks.\n * EXCEPTION 2: We can place a block to stop ourselves, then remove it?\n *\n * Actually, looking at the constraint 2NM (1600) and N=20. Average distance is ~13. 40 targets -> ~520 steps using only moves.\n * The max budget is quite loose. The score is M + 2NM - T. Minimizing T is the goal.\n * Basic Manhattan movement is a baseline. Can we beat Manhattan?\n * Yes, if dist > 1. A slide costs 1.\n * If we slide, we must stop exactly at the target. This requires a block immediately after the target.\n * Or we slide and stop *past* the target? No, \"Slide over ... not considered visited\". We must stop ON it.\n * So to use Slide to reach Target, we need a block at `Target + dv`.\n * To place that block, we have to walk to `Target`, `Alter`, then go to `Start`, then `Slide`.\n * Cost: Dist(Start, Target) + 1 (Alter) + Dist(Target, Start) + 1 (Slide).\n * Total: 2*D + 2. This is much worse than just walking (D).\n * So we can't \"set up\" a slide for the *current* leg easily unless the block exists.\n *\n * However, we can use Slide to get *closer* or to a strategic position, not necessarily the target immediately.\n * Also, blocks placed for target k might be useful for target k+1.\n *\n * Let's look at the inputs. N=20 is small.\n * Maybe we can do a BFS state search where state includes (robot_pos).\n * Since block configuration is persistent, simple BFS isn't enough.\n * But we can treat the grid as a graph where edges are:\n * - Move: weight 1.\n * - Slide: weight 1 (if valid stop exists).\n * - Alter: weight 1 (changes grid).\n *\n * Since we can't explore the space of all block configs, we stick to the current config.\n * We simply find the shortest path from Current to Next using (Move, Slide) on the *current* grid.\n * We can also allow \"Alter\" operations in the path?\n * If we include \"Alter\" in the path finding, the graph changes.\n * Heuristic:\n * At any step, we want to reach Target[k].\n * We compute a \"distance\" map from every square to Target[k] assuming *only* Moves. This is just Manhattan distance (if no obstacles).\n * Since we can add/remove blocks, obstacles are temporary.\n * Actually, blocks are obstacles for Move but targets for Slide.\n *\n * Let's implement a \"Semi-Greedy BFS with Limited Depth / Beam Search\".\n * Beam Search State:\n * - Current Position (r, c)\n * - Current Grid (bitmask or set of blocks)\n * - Index of next target to visit\n * - History of moves\n *\n * Since M=40 is long, we can't beam search the whole sequence.\n * We solve for Target[i] -> Target[i+1].\n * Function SolveLeg(Start, Goal, CurrentGrid):\n * PriorityQueue\n * State: (cost, r, c, grid_changes_list)\n * We can't store the full grid in the state, but we can store a list of changes relative to the start of the leg.\n * Since we want to minimize T, we use Dijkstra/A*.\n *\n * Actions from (r, c):\n * 1. Move (U/D/L/R):\n * - If target square is empty: New pos (r', c'), Cost + 1.\n * - If target square has block: Invalid.\n * 2. Slide (U/D/L/R):\n * - Simulate slide on current grid.\n * - If stops at (r', c'), Cost + 1.\n * 3. Alter (U/D/L/R):\n * - Toggle block at (r', c'). Cost + 1.\n * - This updates the grid for future moves in this leg.\n * - HEURISTIC: Only allow Alter if it enables a better move immediately or very soon?\n * Allowing arbitrary Alters explodes the search space.\n * Let's restrict Alter:\n * - Only Alter if we are adjacent to a potential \"Slide Stop\" for the Goal?\n * - Or simply allow Alter as a valid move in the graph, but heavily penalize it or prune states where we Alter uselessly.\n * - Actually, Alter is effectively moving to a neighbor in the \"configuration space\".\n * - Limiting Alters: Only allow Alter if the block being placed/removed is \"relevant\".\n * Relevant = on the same row/col as the Goal or Start?\n *\n * Heuristic for A*: H(u) = ManhattanDist(u, Goal).\n * Since Slide can reduce distance drastically, H(u) is not admissible if we strictly use Manhattan.\n * But H(u) = ManhattanDist(u, Goal) / N might be admissible (since slide covers at most N).\n * Or simply H(u) = 0 (Dijkstra). N=20 is small enough for Dijkstra on (r, c) *if grid is static*.\n * With dynamic grid, it's harder.\n *\n * Proposed Lightweight Algorithm:\n * 1. Keep track of current global grid `G`.\n * 2. For each target `tgt` in sequence:\n * Run a Dijkstra search to find shortest path from `curr` to `tgt`.\n * The state in Dijkstra: `(r, c)`.\n * But this assumes `G` is static.\n * What if we can perform `Alter` to improve the path?\n * Let's define a \"Macro Move\":\n * - Slide-to-Stop: If we slide and hit an existing block. Cost 1.\n * - Create-Stop-And-Slide:\n * If we want to slide U/D/L/R and stop at `(r', c')` (which means block at `next(r', c')`),\n * and that block doesn't exist.\n * We can try to \"go place that block\".\n * Cost estimation: `Dist((r,c), block_pos) + 1 (Alter) + Dist(block_pos, (r,c)) + 1 (Slide)`.\n * This is `2 * Dist + 2`. If this is < `Dist((r,c), (r', c'))`, it's worth it.\n * Usually not worth it for a single leg.\n *\n * However, `Alter` can also REMOVE blocks that are in the way of a Move.\n * If a block is at (r+1, c) and we want to go there, we must Alter to remove it.\n *\n * Let's refine the graph for Dijkstra:\n * Nodes: `(r, c)`.\n * Edges:\n * 1. `Move`: Cost 1. (If blocked, cost = 1 (Alter remove) + 1 (Move) + 1 (Alter put back? No, just leave removed) = 2 or more).\n * Actually, if blocked, we can't Move. We must Alter first.\n * So edge `(r,c) -> (r',c')` where `(r',c')` has block:\n * Action: `Alter (remove) at (r',c')`, then `Move to (r',c')`. Cost 2.\n * We update our local copy of grid to reflect removal?\n * This suggests we stick to one path.\n *\n * 2. `Slide`: Check all 4 directions.\n * Calculate stop point `(r_stop, c_stop)` based on current grid.\n * Edge `(r,c) -> (r_stop, c_stop)` cost 1.\n *\n * 3. `Alter` to create a stop for *future* slide?\n * Hard to plan. Let's ignore complex planning.\n * Focus on: Move, Slide (existing blocks), and \"Move through block\" (Alter+Move).\n *\n * Wait, we can place a block to stop *ourselves* at the target?\n * If we are at `(r, c)`, target is `(r_t, c_t)`.\n * If `r == r_t` and we slide towards `c_t`. We need block at `c_t + 1`.\n * If block exists, great. Cost 1.\n * If not, we can't slide and stop there.\n *\n * Maybe we can iterate through *all possible block placements* that would help us stop at the target?\n * Candidates for useful blocks: Neighbors of the current Target.\n * If we place a block at `(r_t, c_t+1)`, we can slide from left to `(r_t, c_t)`.\n * Cost to achieve this:\n * 1. Go to `(r_t, c_t+1)` (or neighbor).\n * 2. Alter.\n * 3. Go to somewhere left of `(r_t, c_t)`.\n * 4. Slide Right.\n * This looks like a detour.\n * We can calculate the cost of this detour using BFS distance.\n * `Cost = BFS(Start, PlacementPos) + 1 + BFS(PlacementPos, LaunchPos) + 1`.\n * LaunchPos is any cell in the same row/col that allows sliding to target.\n *\n * Algorithm V2 (Greedy per leg with \"Strategic Options\"):\n * For leg Start -> Goal:\n * Base option: BFS on (Move, Slide_on_current_grid, Move_through_block).\n * - Move_through_block logic: If block at neighbor, cost is 1(Alter) + 1(Move). (And we permanently remove the block for this leg).\n *\n * Strategic option (Create Stop):\n * For each of 4 neighbors of Goal `(nr, nc)`:\n * If `(nr, nc)` is empty:\n * Consider placing a block there.\n * Cost = BFS_Move_Only(Start, neighbor_of_(nr,nc)) + 1(Alter) + BFS_With_New_Block(neighbor_of_(nr,nc), Goal).\n * Actually, the second part is \"reach a launching spot then slide\".\n * The launching spot must be on the line segment towards Goal stopped by `(nr, nc)`.\n * We can estimate this.\n *\n * This seems complicated to get right.\n * Given N=20, purely exploring the grid with a slightly enriched state might work.\n * State: `(r, c)`.\n * What if we just run A* where we allow `Alter` at current position's neighbors?\n * If we `Alter`, the grid changes. This breaks the \"visited\" array of simple A* because the state is (pos, grid).\n * But we can't visit many grid states.\n * Maybe we only allow `Alter` if it's \"Move through block\" or \"Place block at target boundary\"?\n *\n * Let's try a simpler approach first which is robust.\n * BFS with state `(r, c)`.\n * Transitions:\n * - `Move` to adj (if empty). Cost 1.\n * - `Alter` adj (if block) -> `Move`. Cost 2. (Effectively remove block and move).\n * - `Slide` (if empty path). Cost 1. Destination determined by current grid.\n * This ignores the possibility of ADDING blocks to help slide.\n * Is ADDING blocks essential?\n * If we are far, sliding is good. To slide, we need a stop.\n * The grid starts empty. There are no blocks initially.\n * So initially, `Slide` is useless (goes to wall).\n * Unless the target is at the wall, we cannot stop at target with Slide initially.\n * Wait, \"All squares outside the NxN area are covered with blocks\".\n * So we can slide to the wall.\n * If a target is at `(5, 5)`, we can't slide to it unless there is a block at `(5, 6)` etc.\n * So we MUST add blocks to utilize sliding for non-edge targets.\n *\n * Since we have plenty of time (2.0s) and N is small, but M is somewhat large.\n * We can run a bounded-depth search or a more complex Dijkstra per leg.\n * Let's implement a Dijkstra that considers \"Go to X, Place Block, Proceed\".\n * Actually, simply checking \"Can I place a block near Target to help?\" is a good heuristic.\n * \n * Let's formalize the \"Target Stop Strategy\".\n * For a leg Start -> Goal:\n * 1. Compute `DistMap` from Start using only Moves (considering blocks as obstacles).\n * 2. Identify \"Stop Candidates\": The 4 neighbors of Goal.\n * 3. For each Stop Candidate `S`:\n * - Cost to place block at `S`: `PlaceCost = DistMap[neighbor of S] + 1`. (If block already there, cost 0).\n * - Once block is at `S`, we can slide to Goal from direction opposite to `S`.\n * Valid launch points `L` are cells in that direction.\n * Cost to reach `L` *after* placing block?\n * This is getting path-dependent.\n *\n * Maybe we use a simpler randomized/greedy approach?\n * We have 2NM = 1600 budget.\n * Simple Move path is roughly M * (N/2) ~ 400-600 ops.\n * We are well within budget.\n * We want to MINIMIZE turns.\n * So we should use Slide if `Slide Cost < Move Cost`.\n * \n * Let's refine the graph search.\n * We use Dijkstra.\n * State: `(r, c)`.\n * Dynamic Edge generation:\n * From `u=(r, c)`:\n * 1. `Move` to `v`:\n * - If `v` empty: Cost 1.\n * - If `v` block: Cost 2 (Alter v + Move v). We record that `v` is cleared.\n * 2. `Slide` dir `D`:\n * - Check stop pos `v` on CURRENT grid (plus modifications from path?).\n * Simplification: Use CURRENT global grid.\n * Cost 1.\n * 3. `Create Stop` (Heuristic transition):\n * - If we are at `u`, and `u` is \"aligned\" with Goal, and we can slide to Goal if there was a block behind Goal.\n * - If we are adjacent to the \"block spot\", we can Alter(cost 1) then move to launch?\n * - This is too specific.\n *\n * Let's implement a layered Dijkstra.\n * Layer 0: Current Grid.\n * Layer 1: Grid with 1 extra block placed \"optimally\" for this leg?\n * Too complex.\n *\n * Backtracking to the most effective simple strategy:\n * Just standard BFS/Dijkstra on (r,c) with:\n * - Move (1)\n * - Slide (1)\n * - Remove Block + Move (2)\n * \n * AND, at the beginning of each leg, we check if it's beneficial to place a block near the GOAL.\n * Strategy \"Place-Block-At-Target\":\n * For each of 4 neighbors of Goal:\n * Simulate:\n * 1. Path to neighbor.\n * 2. Alter (Place block).\n * 3. Find path from neighbor to a \"Launch point\".\n * 4. Slide to Goal.\n * Compare total cost with standard BFS.\n * If better, execute this plan.\n * \n * This handles the \"setup slide\" case.\n * What about \"remove block\" strategy?\n * The \"Remove Block + Move\" edge in standard BFS handles obstacles.\n *\n * What if we need to place a block in the middle of nowhere to stop?\n * Unlikely to be optimal given the setup cost vs just moving.\n * Only blocks adjacent to Goal are critical for stopping ON the Goal.\n *\n * So, the Algorithm:\n * Current Pos = Start.\n * Loop for each target T:\n * BestPath = StandardBFS(Pos, T, CurrentGrid)\n * \n * For each dir D in {0,1,2,3}:\n * BlockPos = T + delta[D]\n * If BlockPos inside grid and No Block:\n * // Try plan: Go place block there, then slide.\n * // 1. Go to a neighbor of BlockPos (to place it). \n * // Target for this sub-path is any neighbor of BlockPos.\n * // Let's pick best neighbor `np`.\n * Path1 = StandardBFS(Pos, np, CurrentGrid)\n * \n * // 2. Alter\n * TempGrid = CurrentGrid + BlockPos\n * \n * // 3. Find launch point. \n * // Launch point must be in direction D_opp from T.\n * // And reachable from np.\n * // Actually, we can just run BFS from np to T on TempGrid using Moves and Slides.\n * // But we force the LAST move to be a Slide that hits BlockPos? \n * // Or just trust StandardBFS on TempGrid to find the slide usage.\n * Path2 = StandardBFS(np, T, TempGrid)\n * \n * TotalCost = Path1.len + 1 + Path2.len\n * If TotalCost < BestPath.cost:\n * BestPlan = (Path1, Alter, Path2)\n * \n * Execute BestPlan. Update Pos, CurrentGrid.\n *\n * Wait, \"StandardBFS\" uses \"Remove Block + Move\" (cost 2).\n * We need to output the actual actions.\n * If BFS says \"Move to blocked cell\", we generate \"Alter, Move\".\n * \n * One detail: When checking \"Place-Block-At-Target\", we might have multiple choices of `np` (neighbors of BlockPos).\n * We should calculate distance to ALL neighbors of BlockPos and pick min.\n * Actually, StandardBFS can target a SET of squares (distance is min to any).\n *\n * Optimization:\n * StandardBFS can be A*. Heuristic = Manhattan / N (since slide is fast).\n * Or just 0 (Dijkstra). 20x20 is small (400 nodes). Dijkstra is instant.\n * \n * Corner Case:\n * Start == Target? (Input says coords distinct, but we visit sequentially. i0!=i1?\n * Problem says \"start at i0,j0, visit i1,j1...\".\n * If i0==i1, distance is 0.\n *\n * Implementation details:\n * - Coordinate struct.\n * - Grid representation (2D array bool).\n * - Action struct.\n * - BFS return type: vector of Actions.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\nconst char DCHAR[] = {'U', 'D', 'L', 'R'};\n\nint N, M;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { return tie(r, c) < tie(other.r, other.c); }\n};\n\nbool isValid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint distManhattan(Point p1, Point p2) {\n return abs(p1.r - p2.r) + abs(p1.c - p2.c);\n}\n\nstruct Action {\n char type; // 'M', 'S', 'A'\n int dir; // 0..3\n};\n\n// Global Grid State\n// false: empty, true: block\nvector> grid;\n\n// Reconstruct path helper\nstruct Node {\n int r, c;\n int cost;\n int parent_dir; // Incoming action direction\n int parent_action_type; // 0: None, 1: Move, 2: Slide, 3: Alter+Move(blocked)\n Point parent_pos;\n};\n\n// Dijkstra to find path from Start to Target\n// Returns list of actions.\n// cost_limit is used for pruning if we already have a better plan.\npair> solveLegDijkstra(Point start, Point target, const vector>& currentGrid, int cost_limit = 1e9) {\n if (start == target) return {0, {}};\n\n // dist[r][c]\n vector> dist(N, vector(N, 1e9));\n // To reconstruct path\n vector>> parent(N, vector>(N)); // {prev_pt, type, dir}\n\n using PQItem = tuple; // cost, r, c\n priority_queue, greater> pq;\n\n dist[start.r][start.c] = 0;\n pq.push({0, start.r, start.c});\n\n int best_cost_to_target = 1e9;\n\n while (!pq.empty()) {\n auto [c, r, col] = pq.top();\n pq.pop();\n\n if (c > dist[r][col]) continue;\n if (c >= cost_limit) continue;\n if (c >= best_cost_to_target) continue; \n \n Point curr = {r, col};\n if (curr == target) {\n best_cost_to_target = c;\n continue; // Continue to potentially find other paths? Dijkstra guarantees first visit is optimal.\n // Actually with uniform edge weights BFS is fine, but here we have weight 2 edges.\n // Dijkstra guarantees first pop is optimal.\n // So we can break? Yes.\n break;\n }\n\n // Try Moves\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = col + DC[i];\n\n if (isValid(nr, nc)) {\n // Check if blocked\n int weight = 1;\n bool is_blocked = currentGrid[nr][nc];\n if (is_blocked) weight = 2; // Alter(remove) + Move\n\n if (dist[r][col] + weight < dist[nr][nc]) {\n dist[nr][nc] = dist[r][col] + weight;\n pq.push({dist[nr][nc], nr, nc});\n char action_type = is_blocked ? 'B' : 'M'; // B for Blocked Move (Alter+Move)\n parent[nr][nc] = {curr, action_type, i};\n }\n }\n }\n\n // Try Slides\n for (int i = 0; i < 4; ++i) {\n // Simulate slide\n int nr = r, nc = col;\n while (true) {\n int next_r = nr + DR[i];\n int next_c = nc + DC[i];\n if (!isValid(next_r, next_c) || currentGrid[next_r][next_c]) {\n // Hit wall or block, stop at (nr, nc)\n break;\n }\n nr = next_r;\n nc = next_c;\n \n // Important: \"If you slide over a target square without stopping on it, it is not considered visited.\"\n // So we only care about the final resting position.\n }\n \n // If we actually moved\n if (nr != r || nc != col) {\n if (dist[r][col] + 1 < dist[nr][nc]) {\n dist[nr][nc] = dist[r][col] + 1;\n pq.push({dist[nr][nc], nr, nc});\n parent[nr][nc] = {curr, 'S', i};\n }\n }\n }\n }\n\n if (dist[target.r][target.c] == 1e9) return {1e9, {}};\n\n // Reconstruct\n vector actions;\n Point curr = target;\n while (curr != start) {\n auto [prev, type, dir] = parent[curr.r][curr.c];\n if (type == 'M') {\n actions.push_back({'M', dir});\n } else if (type == 'S') {\n actions.push_back({'S', dir});\n } else if (type == 'B') {\n // 'B' means Alter(remove) + Move\n actions.push_back({'M', dir});\n actions.push_back({'A', dir});\n }\n curr = prev;\n }\n reverse(actions.begin(), actions.end());\n return {dist[target.r][target.c], actions};\n}\n\n// Helper to find distance to any of a set of points\n// Returns min distance and the specific target point reached\npair distToSet(Point start, const vector& targets, const vector>& currentGrid) {\n // BFS\n vector> d(N, vector(N, 1e9));\n queue q;\n \n q.push(start);\n d[start.r][start.c] = 0;\n \n int min_dist = 1e9;\n Point best_p = {-1, -1};\n \n // Check if start is target\n for(auto& t : targets) if(start == t) return {0, start};\n\n while(!q.empty()){\n Point u = q.front();\n q.pop();\n \n if(d[u.r][u.c] >= min_dist) continue; // optimization\n\n for(int i=0; i<4; ++i){\n int nr = u.r + DR[i];\n int nc = u.c + DC[i];\n if(isValid(nr, nc)){\n int weight = currentGrid[nr][nc] ? 2 : 1;\n if(d[u.r][u.c] + weight < d[nr][nc]){\n d[nr][nc] = d[u.r][u.c] + weight;\n q.push({nr, nc});\n \n // Check if this is a target\n for(auto& t : targets){\n if(nr == t.r && nc == t.c){\n if(d[nr][nc] < min_dist){\n min_dist = d[nr][nc];\n best_p = {nr, nc};\n }\n }\n }\n }\n }\n }\n }\n return {min_dist, best_p};\n}\n\nint main() {\n // Speed up IO\n cin.tie(nullptr);\n ios::sync_with_stdio(false);\n\n cin >> N >> M;\n int r0, c0;\n cin >> r0 >> c0;\n vector targets(M);\n targets[0] = {r0, c0};\n for (int i = 0; i < M; ++i) { // Wait, input is i0, j0... then targets. \n // Problem: \"You start at the initial position (i0, j0) and must visit... (i1, j1)...\"\n // The input format says:\n // i0 j0\n // ...\n // i_{M-1} j_{M-1}\n // This lists M coordinates.\n // The first one is start. The subsequent ones are targets.\n // Wait, M coordinates total? \"Take the first M coordinates ... assign them as (i0,j0)...(iM-1,jM-1)\"\n // \"Start at (i0, j0) and visit (i1, j1) ... (iM-1, jM-1)\"\n // So there are M-1 targets to visit.\n }\n \n // Re-reading input format carefully:\n // N M\n // i0 j0\n // ...\n // i_{M-1} j_{M-1}\n // So we read M lines of coordinates.\n \n vector path_points(M);\n path_points[0] = {r0, c0}; // Actually read loop handles this\n \n // Correct read loop\n // We already read r0, c0. That is i0, j0.\n // We need to read M-1 more.\n // Actually let's just put them in a vector.\n // The input gives M lines of coords?\n // \"Input ... i0 j0 ... i_{M-1} j_{M-1}\"\n // Yes, M lines total.\n \n // Wait, I already read r0, c0. That is index 0.\n path_points[0] = {r0, c0};\n for(int i=1; i> path_points[i].r >> path_points[i].c;\n }\n\n grid.assign(N, vector(N, false));\n Point curr = path_points[0];\n\n // Total actions accumulator\n struct Output {\n char a, d;\n };\n vector full_ops;\n\n auto add_ops = [&](const vector& ops) {\n for (auto& op : ops) {\n full_ops.push_back({op.type, DCHAR[op.dir]});\n \n // Update state\n if (op.type == 'M') {\n curr.r += DR[op.dir];\n curr.c += DC[op.dir];\n } else if (op.type == 'S') {\n while (true) {\n int nr = curr.r + DR[op.dir];\n int nc = curr.c + DC[op.dir];\n if (!isValid(nr, nc) || grid[nr][nc]) break;\n curr.r = nr;\n curr.c = nc;\n }\n } else if (op.type == 'A') {\n int nr = curr.r + DR[op.dir];\n int nc = curr.c + DC[op.dir];\n if (isValid(nr, nc)) {\n grid[nr][nc] = !grid[nr][nc];\n }\n }\n }\n };\n\n for (int k = 0; k < M - 1; ++k) {\n Point start = curr;\n Point target = path_points[k+1];\n\n // 1. Basic Plan: Dijkstra on current grid\n auto [cost_basic, ops_basic] = solveLegDijkstra(start, target, grid);\n\n // 2. Strategy: Place block near target to help Slide\n int best_cost = cost_basic;\n vector best_ops = ops_basic;\n bool use_alt_strategy = false;\n \n // Stores details for the best alternative strategy\n // {PlaceBlockPos, NeighborOfBlockToVisit, DirToAlter, OpsToReachNeighbor}\n Point alt_block_pos;\n int alt_alter_dir;\n vector alt_ops_prefix; // Path to neighbor + Alter\n\n for (int d = 0; d < 4; ++d) {\n Point blockPos = {target.r + DR[d], target.c + DC[d]};\n \n // Must be valid, empty, and not the target itself (impossible by def of neighbor)\n // Also not the current start pos (can't place block on self)\n if (isValid(blockPos.r, blockPos.c) && !grid[blockPos.r][blockPos.c] && blockPos != start) {\n \n // We want to place a block here.\n // Step A: Go to a neighbor of blockPos to place it.\n vector neighbors;\n for(int nd=0; nd<4; ++nd) {\n Point np = {blockPos.r + DR[nd], blockPos.c + DC[nd]};\n if(isValid(np.r, np.c) && (!grid[np.r][np.c] || np == start)) {\n // np must not be blocked (or must be cleared). \n // If np is blocked, solveLegDijkstra handles removal cost.\n // But if np == blockPos, impossible.\n // Valid neighbor to stand on.\n if(np != blockPos) neighbors.push_back(np);\n }\n }\n\n if (neighbors.empty()) continue;\n\n // Find path to closest neighbor\n // To avoid running Dijkstra multiple times, we can run 1-to-set logic or just loop.\n // Since neighbors <= 4, looping is fine.\n \n int cost_prefix = 1e9;\n vector ops_prefix;\n Point chosen_neighbor;\n int chosen_alter_dir; // Direction from neighbor to blockPos\n\n for(auto np : neighbors) {\n // Path from Start to np\n // We limit cost to best_cost - 1 (heuristic for pruning)\n // Actually, we need to account for the Alter cost (+1) and the slide path cost (+1 min).\n // So limit = best_cost - 2.\n auto [c_p, ops_p] = solveLegDijkstra(start, np, grid, best_cost - 2);\n \n if (c_p + 1 < best_cost) { // +1 for Alter\n // Find direction for Alter\n int adir = -1;\n for(int x=0; x<4; ++x) if(np.r + DR[x] == blockPos.r && np.c + DC[x] == blockPos.c) adir = x;\n \n // Now we have a temporary grid with the block\n // Simulating strictly:\n // ops_p -> Arrive at np\n // Alter(adir) -> Grid changes\n // Find path from np to target using new grid\n \n // Let's evaluate full cost\n // Construct temp grid\n // But we can't easily modify global grid for simulation.\n // We can pass modified grid to solveLegDijkstra.\n \n // Only proceed if this prefix is promising\n if (c_p < cost_prefix) {\n // Check 2nd leg\n vector> tempGrid = grid;\n // Apply removals if any in ops_p (handled by logic, but solveLegDijkstra returns actions not grid state)\n // This is tricky. solveLegDijkstra assumes grid doesn't change except for temporary obstacle removals?\n // Actually my solveLegDijkstra handles \"Move through block\" by generating \"Alter, Move\".\n // This modifies the grid permanently for the leg?\n // My implementation of `solveLegDijkstra` DOES NOT modify the passed `currentGrid`.\n // It just assumes cost penalty.\n // So if `ops_p` contains \"Alter\", we must reflect that in `tempGrid`.\n \n // Re-simulate grid changes for ops_p\n Point simP = start;\n for(auto& op : ops_p){\n if(op.type == 'A'){\n int rr = simP.r + DR[op.dir];\n int cc = simP.c + DC[op.dir];\n tempGrid[rr][cc] = !tempGrid[rr][cc];\n } else if (op.type == 'M') {\n simP.r += DR[op.dir]; simP.c += DC[op.dir];\n } else if (op.type == 'S') {\n // update simP...\n while(true){\n int rr = simP.r + DR[op.dir];\n int cc = simP.c + DC[op.dir];\n if(!isValid(rr,cc) || tempGrid[rr][cc]) break;\n simP.r = rr; simP.c = cc;\n }\n }\n }\n \n // Perform Alter\n tempGrid[blockPos.r][blockPos.c] = true; // We place the block\n \n // Path 2: np to target\n // Pruning: limit = best_cost - (c_p + 1)\n auto [c_suff, ops_suff] = solveLegDijkstra(np, target, tempGrid, best_cost - c_p - 1);\n \n int total = c_p + 1 + c_suff;\n if(total < best_cost){\n best_cost = total;\n // Construct full ops\n best_ops = ops_p;\n best_ops.push_back({'A', adir});\n best_ops.insert(best_ops.end(), ops_suff.begin(), ops_suff.end());\n }\n }\n }\n }\n }\n }\n\n add_ops(best_ops);\n }\n\n for (auto& p : full_ops) {\n cout << p.a << \" \" << p.d << \"\\n\";\n }\n\n return 0;\n}"},"2":{"ahc001":"/**\n * AtCoder Heuristic Contest 001\n * Problem: AtCoder Ad\n * Approach: Hill Climbing / Simulated Annealing with \"Push\" moves.\n * \n * Improvement Strategy:\n * 1. **Smart \"Push\" Moves**: Instead of just resizing one rectangle and rejecting \n * collisions, if a rectangle expands into a neighbor, we attempt to shrink the \n * neighbor to accommodate the expansion. This allows boundaries between rectangles \n * to shift dynamically, simulating a \"sliding edge\" operation. This is crucial \n * for dense packing problems where simple expansion is often blocked.\n * 2. **Weighted Selection**: We bias the random selection towards rectangles that \n * have not met their area target yet, focusing computational resources where \n * gains are most likely.\n * 3. **Optimization Loop**: We use Simulated Annealing to escape local optima, \n * especially those created by the non-convex nature of the packing (geometric blocking).\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants ---\nconst int W = 10000;\nconst int H = 10000;\nconst double TIME_LIMIT = 4.90; // Seconds\n\n// --- Structures ---\nstruct Rect {\n int x1, y1, x2, y2; // [x1, x2) x [y1, y2)\n \n int area() const { \n return (x2 - x1) * (y2 - y1); \n }\n \n int width() const { return x2 - x1; }\n int height() const { return y2 - y1; }\n \n // Check if point (rx+0.5, ry+0.5) is within rectangle\n bool contains_pt(int rx, int ry) const {\n return (x1 <= rx && rx < x2 && y1 <= ry && ry < y2);\n }\n};\n\nstruct Request {\n int id;\n int x, y, r;\n};\n\n// --- Globals ---\nint N;\nvector requests;\nvector rects;\n\n// --- Helper Functions ---\n\n// Score calculation: 1 - (1 - min(r,s)/max(r,s))^2\ndouble get_score(int target, int area) {\n if (area == 0) return 0.0;\n double ratio = (double)min(target, area) / max(target, area);\n double val = 1.0 - ratio;\n return 1.0 - val * val;\n}\n\n// Check if two rectangles intersect\nbool intersect(const Rect& a, const Rect& b) {\n return max(a.x1, b.x1) < min(a.x2, b.x2) && max(a.y1, b.y1) < min(a.y2, b.y2);\n}\n\n// Timer\ndouble get_time() {\n static auto start_time = chrono::steady_clock::now();\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// --- Main Solver ---\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n if (!(cin >> N)) return 0;\n requests.resize(N);\n for (int i = 0; i < N; ++i) {\n requests[i].id = i;\n cin >> requests[i].x >> requests[i].y >> requests[i].r;\n }\n\n // 1. Initialization: Start with minimal valid 1x1 rectangles\n rects.resize(N);\n for (int i = 0; i < N; ++i) {\n rects[i] = {requests[i].x, requests[i].y, requests[i].x + 1, requests[i].y + 1};\n }\n\n // Initial Score calculation\n double current_total_score = 0;\n for(int i=0; i changed_ids;\n changed_ids.reserve(N);\n vector old_rects_buf;\n old_rects_buf.reserve(N);\n\n int iter_count = 0;\n \n // Temperature settings\n // T0 controls the probability of accepting bad moves initially.\n // A move degrading score by 0.01 with T=0.005 is accepted with p ~ 13%.\n double T0 = 0.005; \n double T = T0;\n\n while (true) {\n iter_count++;\n \n // Time Check & Temperature Update\n if ((iter_count & 255) == 0) {\n double t = get_time();\n if (t > TIME_LIMIT) break;\n double progress = t / TIME_LIMIT;\n T = T0 * (1.0 - progress);\n }\n\n // --- Move Generation ---\n \n // Selection Heuristic: Prioritize rectangles that are too small\n int i = rng() % N;\n \n // Decide whether to Expand or Shrink\n // If area < target, we bias heavily towards Expansion.\n bool want_expand = false;\n if (rects[i].area() < requests[i].r) {\n if (rng() % 100 < 70) want_expand = true;\n } else {\n if (rng() % 100 < 30) want_expand = true;\n }\n\n int dir = rng() % 4; // 0:Left, 1:Right, 2:Bottom, 3:Top\n int delta = want_expand ? 1 : -1;\n\n // Clear transaction logs\n changed_ids.clear();\n old_rects_buf.clear();\n \n auto stage_change = [&](int idx, Rect new_r) {\n changed_ids.push_back(idx);\n old_rects_buf.push_back(rects[idx]);\n rects[idx] = new_r; // Apply tentatively\n };\n\n // 1. Modify the primary rectangle 'i'\n Rect ri_new = rects[i];\n if (dir == 0) ri_new.x1 -= delta;\n else if (dir == 1) ri_new.x2 += delta;\n else if (dir == 2) ri_new.y1 -= delta;\n else if (dir == 3) ri_new.y2 += delta;\n\n // Basic Validity Checks for 'i'\n if (ri_new.width() <= 0 || ri_new.height() <= 0 ||\n ri_new.x1 < 0 || ri_new.y1 < 0 || ri_new.x2 > W || ri_new.y2 > H ||\n !ri_new.contains_pt(requests[i].x, requests[i].y)) {\n continue; // Invalid move\n }\n\n stage_change(i, ri_new);\n\n bool valid_move = true;\n\n if (want_expand) {\n // If expanding, we check for collisions.\n // Instead of rejecting, we try to PUSH (shrink) the neighbors.\n for (int j = 0; j < N; ++j) {\n if (i == j) continue;\n // Check intersection with the NEW i and OLD j\n // Note: rects[j] is current state (unless j < i and j was modified? \n // No, we just started modification. 'rects' array is being updated in place,\n // but changed_ids tracks what happened in this step.)\n // Actually, if multiple neighbors collide, we modify them sequentially.\n \n if (intersect(rects[i], rects[j])) {\n Rect rj_new = rects[j];\n \n // Shrink j based on direction of i's expansion\n // i expanding Left (0) hits j's Right side -> j.x2 must decrease\n // i expanding Right (1) hits j's Left side -> j.x1 must increase\n if (dir == 0) rj_new.x2 = rects[i].x1;\n else if (dir == 1) rj_new.x1 = rects[i].x2;\n else if (dir == 2) rj_new.y2 = rects[i].y1;\n else if (dir == 3) rj_new.y1 = rects[i].y2;\n \n // Validate j's new shape\n if (rj_new.width() <= 0 || rj_new.height() <= 0 || \n !rj_new.contains_pt(requests[j].x, requests[j].y)) {\n valid_move = false;\n break;\n }\n \n stage_change(j, rj_new);\n }\n }\n } \n // If shrinking (want_expand == false), no new collisions are created.\n\n if (valid_move) {\n // Calculate Score Delta\n double diff = 0;\n for (size_t k = 0; k < changed_ids.size(); ++k) {\n int idx = changed_ids[k];\n double old_s = get_score(requests[idx].r, old_rects_buf[k].area());\n double new_s = get_score(requests[idx].r, rects[idx].area());\n diff += (new_s - old_s);\n }\n\n // Acceptance Criteria (SA)\n bool accept = false;\n if (diff >= 0) {\n accept = true;\n } else if (T > 0) {\n double prob = exp(diff / T);\n if (prob > (double)(rng() % 100000) / 100000.0) {\n accept = true;\n }\n }\n\n if (accept) {\n current_total_score += diff;\n } else {\n // Rollback\n for (size_t k = 0; k < changed_ids.size(); ++k) {\n rects[changed_ids[k]] = old_rects_buf[k];\n }\n }\n } else {\n // Rollback (Invalid geometric configuration encountered)\n for (size_t k = 0; k < changed_ids.size(); ++k) {\n rects[changed_ids[k]] = old_rects_buf[k];\n }\n }\n }\n\n // Output Results\n for (int i = 0; i < N; ++i) {\n cout << rects[i].x1 << \" \" << rects[i].y1 << \" \" << rects[i].x2 << \" \" << rects[i].y2 << \"\\n\";\n }\n\n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --------------------------------------------------------\n// Constants\n// --------------------------------------------------------\nconst int N = 50;\nconst int MAX_LEN = 2505;\nconst int TIME_LIMIT_MS = 1950;\n\n// --------------------------------------------------------\n// Global Inputs\n// --------------------------------------------------------\nint SI, SJ;\nint T[N][N];\nint P[N][N];\nint M_tiles = 0;\n\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\nconst char DCHAR[] = {'U', 'D', 'L', 'R'};\n\n// --------------------------------------------------------\n// Random\n// --------------------------------------------------------\nmt19937 rng;\n\n// --------------------------------------------------------\n// State Definition\n// --------------------------------------------------------\n// Using a bitset for visited tiles. Size 2505 is small enough.\nstruct State {\n short r, c;\n int score;\n int heuristic_score;\n string path;\n bitset visited;\n};\n\n// --------------------------------------------------------\n// Globals for Result\n// --------------------------------------------------------\nint best_score = -1;\nstring best_path = \"\";\n\n// --------------------------------------------------------\n// Helper\n// --------------------------------------------------------\ninline bool isValid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\n// --------------------------------------------------------\n// Beam Search Logic\n// --------------------------------------------------------\n// We perform a beam search. \n// To maximize performance, we reuse memory where possible, \n// but std::vector reallocation is inevitable.\n// We tune BEAM_WIDTH dynamically or statically. \n// Static 50-100 is usually safe for N=50.\nconst int BEAM_WIDTH = 40; \n\nvoid solve_beam_search() {\n // Current depth beams\n // We only need current depth and next depth.\n vector current_beam;\n vector next_beam;\n \n current_beam.reserve(BEAM_WIDTH);\n next_beam.reserve(BEAM_WIDTH * 4);\n \n // Initial State\n State start;\n start.r = (short)SI;\n start.c = (short)SJ;\n start.score = P[SI][SJ];\n start.path = \"\";\n start.visited.reset();\n start.visited[T[SI][SJ]] = 1;\n \n // Heuristic for start? Just score.\n start.heuristic_score = start.score;\n \n current_beam.push_back(start);\n \n // Update global best\n if (start.score > best_score) {\n best_score = start.score;\n best_path = \"\";\n }\n \n // Loop until no states left\n // Max depth is implicitly bounded by grid size/visited\n for (int step = 0; step < MAX_LEN; ++step) {\n if (current_beam.empty()) break;\n \n next_beam.clear();\n \n // Expand\n for (const auto& s : current_beam) {\n // Try 4 directions\n for (int d = 0; d < 4; ++d) {\n int nr = s.r + DR[d];\n int nc = s.c + DC[d];\n \n if (!isValid(nr, nc)) continue;\n \n int t_next = T[nr][nc];\n if (s.visited[t_next]) continue;\n \n // Create candidate\n State nextS = s; // Copy (bitset and string copy happen here)\n nextS.r = (short)nr;\n nextS.c = (short)nc;\n nextS.score += P[nr][nc];\n nextS.visited[t_next] = 1;\n nextS.path += DCHAR[d];\n \n // Heuristic Calculation\n // 1. Immediate Score\n // 2. Future Connectivity (lookahead)\n // 3. Randomness (for restart diversity)\n \n int connectivity = 0;\n for (int dd = 0; dd < 4; ++dd) {\n int nnr = nr + DR[dd];\n int nnc = nc + DC[dd];\n if (isValid(nnr, nnc)) {\n int tt = T[nnr][nnc];\n if (!nextS.visited[tt]) connectivity++;\n }\n }\n \n // Weighted Heuristic\n // Noise is generated per expansion to differentiate paths\n nextS.heuristic_score = nextS.score + (connectivity * 10) + (int)(rng() % 20);\n \n if (nextS.score > best_score) {\n best_score = nextS.score;\n best_path = nextS.path;\n }\n \n next_beam.push_back(nextS);\n }\n }\n \n if (next_beam.empty()) break;\n \n // Prune Next Beam\n if (next_beam.size() > BEAM_WIDTH) {\n // Use nth_element to find top BEAM_WIDTH\n nth_element(next_beam.begin(), next_beam.begin() + BEAM_WIDTH, next_beam.end(), \n [](const State& a, const State& b) {\n return a.heuristic_score > b.heuristic_score;\n });\n next_beam.resize(BEAM_WIDTH);\n }\n \n // Swap for next iteration\n current_beam = next_beam;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::steady_clock::now();\n \n if (!(cin >> SI >> SJ)) return 0;\n \n for(int i=0; i> T[i][j];\n if (T[i][j] > M_tiles) M_tiles = T[i][j];\n }\n }\n for(int i=0; i> P[i][j];\n }\n }\n \n rng.seed(chrono::steady_clock::now().time_since_epoch().count());\n \n // Initial check\n best_score = P[SI][SJ];\n \n // Run multiple beam search restarts until time limit\n int runs = 0;\n while (true) {\n runs++;\n solve_beam_search();\n \n // Check time every few runs\n // A run takes some ms depending on length.\n // With width 40, length 1000, we do 40,000 expansions.\n // Bitset copy is fast. \n // Let's check every 1 run.\n auto now = chrono::steady_clock::now();\n auto ms = chrono::duration_cast(now - start_time).count();\n if (ms > TIME_LIMIT_MS) break;\n }\n \n cout << best_path << endl;\n \n return 0;\n}","ahc003":"/**\n * AtCoder Heuristic Contest 003\n * Problem: Shortest Path\n * Author: Algorithm Engineer\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --------------------------------------------------------------------------\n// Constants\n// --------------------------------------------------------------------------\nconst int N = 30;\nconst int Q_COUNT = 1000;\nconst double INIT_VAL = 5000.0;\n\n// Directions: U, D, L, R\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\nconst string DIRS = \"UDLR\";\nconst int OP_DIR[] = {1, 0, 3, 2}; // Opposite direction indices\n\n// --------------------------------------------------------------------------\n// Global State\n// --------------------------------------------------------------------------\n\n// Edge weights\n// h_edges[r][c] connects (r, c) - (r, c+1)\n// v_edges[r][c] connects (r, c) - (r+1, c)\ndouble h_edges[N][N - 1];\ndouble v_edges[N - 1][N];\n\n// Visit counts (reliability measure)\nint h_count[N][N - 1];\nint v_count[N - 1][N];\n\n// --------------------------------------------------------------------------\n// Helper Functions\n// --------------------------------------------------------------------------\n\n// Clamp weights to feasible range slightly wider than generation parameters\ndouble clamp_weight(double w) {\n return std::max(1000.0, std::min(9000.0, w));\n}\n\nstruct State {\n double cost;\n int r, c;\n bool operator>(const State& other) const {\n return cost > other.cost;\n }\n};\n\n// Get current edge cost estimate\n// dir: 0=U, 1=D, 2=L, 3=R\ndouble get_weight(int r, int c, int dir) {\n if (dir == 0) return v_edges[r - 1][c]; // Up\n if (dir == 1) return v_edges[r][c]; // Down\n if (dir == 2) return h_edges[r][c - 1]; // Left\n if (dir == 3) return h_edges[r][c]; // Right\n return 1e9;\n}\n\n// Get visit count (uncertainty metric)\nint get_count(int r, int c, int dir) {\n if (dir == 0) return v_count[r - 1][c];\n if (dir == 1) return v_count[r][c];\n if (dir == 2) return h_count[r][c - 1];\n if (dir == 3) return h_count[r][c];\n return 0;\n}\n\n// Dijkstra Search\n// Returns the path string\nstring solve_path(int si, int sj, int ti, int tj, bool exploration_phase) {\n // dist table\n static double dist[N][N];\n // parent pointer to reconstruct path: stores direction index FROM parent\n static int parent[N][N]; \n \n for(int i=0; i, greater> pq;\n\n dist[si][sj] = 0;\n pq.push({0, si, sj});\n\n while(!pq.empty()) {\n State top = pq.top();\n pq.pop();\n\n if (top.cost > dist[top.r][top.c]) continue;\n if (top.r == ti && top.c == tj) break;\n\n for(int d=0; d<4; ++d) {\n int nr = top.r + DR[d];\n int nc = top.c + DC[d];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n double w = get_weight(top.r, top.c, d);\n \n // Heuristic Adjustment:\n // If we are in exploration phase (early queries), reduce cost of unvisited edges\n // to encourage visiting them.\n if (exploration_phase) {\n int cnt = get_count(top.r, top.c, d);\n // A simple bonus. If cnt is 0, reduce cost effectively.\n // Be careful not to make it negative or break Dijkstra logic too much.\n // Just a small bias is enough.\n if (cnt < 2) w *= 0.65; \n else if (cnt < 5) w *= 0.85;\n }\n\n if (dist[top.r][top.c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[top.r][top.c] + w;\n parent[nr][nc] = d;\n pq.push({dist[nr][nc], nr, nc});\n }\n }\n }\n }\n\n // Reconstruct\n string path = \"\";\n int curr_r = ti, curr_c = tj;\n while(curr_r != si || curr_c != sj) {\n int d = parent[curr_r][curr_c]; // direction used to enter (curr_r, curr_c)\n path += DIRS[d];\n // Backtrack\n curr_r -= DR[d];\n curr_c -= DC[d];\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// --------------------------------------------------------------------------\n// Learning Logic\n// --------------------------------------------------------------------------\n\nvoid update_model(int si, int sj, const string& path, int result) {\n // 1. Identify all edges in the path\n struct EdgeRef {\n bool is_h; // true if horizontal\n int r, c; // coordinates in h_edges/v_edges\n double* w_ptr;\n int* c_ptr;\n };\n\n vector edges;\n double estimated_sum = 0;\n int curr_r = si;\n int curr_c = sj;\n\n // Track which rows/cols were visited to apply structural updates\n // map: index -> sum of weight differences observed in this row/col\n // We also need count of edges visited in that row/col\n struct LineData {\n double total_diff = 0;\n int count = 0;\n };\n map row_updates; // key: row index\n map col_updates; // key: col index\n\n for (char c : path) {\n EdgeRef e;\n if (c == 'U') {\n e.is_h = false; e.r = curr_r - 1; e.c = curr_c;\n e.w_ptr = &v_edges[e.r][e.c];\n e.c_ptr = &v_count[e.r][e.c];\n curr_r--;\n } else if (c == 'D') {\n e.is_h = false; e.r = curr_r; e.c = curr_c;\n e.w_ptr = &v_edges[e.r][e.c];\n e.c_ptr = &v_count[e.r][e.c];\n curr_r++;\n } else if (c == 'L') {\n e.is_h = true; e.r = curr_r; e.c = curr_c - 1;\n e.w_ptr = &h_edges[e.r][e.c];\n e.c_ptr = &h_count[e.r][e.c];\n curr_c--;\n } else if (c == 'R') {\n e.is_h = true; e.r = curr_r; e.c = curr_c;\n e.w_ptr = &h_edges[e.r][e.c];\n e.c_ptr = &h_count[e.r][e.c];\n curr_c++;\n }\n edges.push_back(e);\n estimated_sum += *e.w_ptr;\n (*e.c_ptr)++; // Increment visit count\n }\n\n // 2. Calculate Error\n double total_diff = result - estimated_sum;\n // If path length is L, average error per edge is total_diff / L\n double avg_diff = total_diff / edges.size();\n\n // 3. Apply direct updates AND accumulate structural info\n // We use a learning rate. Since result has noise, we shouldn't correct 100%.\n // However, if edges are visited often, they are \"stiff\" (we know them well),\n // while unvisited edges are \"loose\".\n \n // Actually, Kaczmarz method suggests distributing error proportional to uncertainty.\n // Let uncertainty u_i = 1 / (visit_count + K).\n // Correction for edge i: delta_i = error * (u_i / sum(u))\n \n double sum_uncertainty = 0;\n vector uncertainties;\n for (auto& e : edges) {\n // +1 because we just incremented count. \n // Use a base confidence.\n double u = 1.0 / sqrt(*e.c_ptr); \n uncertainties.push_back(u);\n sum_uncertainty += u;\n }\n\n for (size_t i = 0; i < edges.size(); ++i) {\n double share = uncertainties[i] / sum_uncertainty;\n double correction = total_diff * share;\n \n // Apply damped correction\n *edges[i].w_ptr += correction * 0.8; \n *edges[i].w_ptr = clamp_weight(*edges[i].w_ptr);\n \n // Accumulate for structural update\n // We want to know: \"On average, how much did we correct edges in row r?\"\n // correction is the amount added to the edge.\n if (edges[i].is_h) {\n row_updates[edges[i].r].total_diff += correction;\n row_updates[edges[i].r].count++;\n } else {\n col_updates[edges[i].c].total_diff += correction;\n col_updates[edges[i].c].count++;\n }\n }\n\n // 4. Structural Update (Global Smoothing)\n // If we increased edges in row 5 by average of +200, likely the whole row is +200.\n // But we only apply this to edges that were NOT in the path (or all edges slightly).\n // To prevent runaway feedback, we apply this cautiously.\n \n double struct_lr = 0.25; // Structural learning rate\n\n for (auto const& [r, data] : row_updates) {\n if (data.count == 0) continue;\n double avg_correction = data.total_diff / data.count;\n \n // Apply to all horizontal edges in this row\n for (int c = 0; c < N - 1; ++c) {\n // Don't double count edges in path too much? \n // Actually, it's fine. The path edges got a specific update, \n // now they get a general update.\n // We scale by inverse visit count so we don't mess up well-known edges.\n double u = 1.0 / (1.0 + h_count[r][c]);\n h_edges[r][c] += avg_correction * struct_lr * u;\n h_edges[r][c] = clamp_weight(h_edges[r][c]);\n }\n }\n\n for (auto const& [c, data] : col_updates) {\n if (data.count == 0) continue;\n double avg_correction = data.total_diff / data.count;\n \n for (int r = 0; r < N - 1; ++r) {\n double u = 1.0 / (1.0 + v_count[r][c]);\n v_edges[r][c] += avg_correction * struct_lr * u;\n v_edges[r][c] = clamp_weight(v_edges[r][c]);\n }\n }\n}\n\n// --------------------------------------------------------------------------\n// Main\n// --------------------------------------------------------------------------\n\nint main() {\n // Fast IO\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n\n // Initialization\n for(int i=0; i> si >> sj >> ti >> tj;\n\n // Exploration phase logic\n // We want to explore early.\n bool explore = (k < 150); // First 150 queries, prefer unvisited\n\n string path = solve_path(si, sj, ti, tj, explore);\n\n cout << path << endl;\n\n int result;\n cin >> result;\n\n update_model(si, sj, path, result);\n }\n\n return 0;\n}","ahc004":"/**\n * Alien's Genetic Information - Heuristic Solution (Optimized)\n *\n * Key Improvements from Feedback:\n * 1. Initialization robustness: A pure random grid might result in 0 matches for long strings,\n * leading to a score of 0 and a flat gradient for the optimizer. We implemented a \"Kickstart\"\n * phase that forces strings onto the grid until a minimum coverage is reached.\n * 2. Memory Management: Reduced dynamic allocations in the inner loop by using static buffers\n * for row/column extraction.\n * 3. Update Logic: Used a Greedy/Hill-Climbing approach with destructive \"Force\" moves to\n * escape local optima. Since the penalty for losing a match is huge, standard SA is tricky;\n * structured jumps (forcing an unsatisfied string) work better.\n * 4. Aho-Corasick Optimization: Optimized the `scan_sequence` function to handle the torus \n * wrapping correctly and efficiently.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem Constants\nconstexpr int N = 20;\nconstexpr int MAX_M = 805; \nconstexpr int ALPHABET_SIZE = 8;\nconstexpr int EMPTY_CHAR = 8; // Internal representation for '.'\n\n// Aho-Corasick Node\nstruct Node {\n int children[ALPHABET_SIZE];\n int failure;\n vector matched_indices; // Indices of strings ending here\n\n Node() {\n memset(children, -1, sizeof(children));\n failure = 0;\n }\n};\n\n// Global Data\nvector trie;\nint M;\nvector S;\nint grid[N][N];\nint best_grid[N][N];\n\n// Score Tracking\nint string_occurrences[MAX_M]; // How many times string S[k] appears in grid\nvector row_found_strings[N]; // Cache: which strings are found in row i\nvector col_found_strings[N]; // Cache: which strings are found in col j\nint current_c = 0; // Number of satisfied strings\nint current_d = 0; // Number of dots\nint best_c = 0;\nint best_d = 0;\ndouble best_score = 0.0;\n\n// Static buffers to reduce allocation in tight loops\nint row_buf[N];\nint col_buf[N];\n\nmt19937 rng(2023);\n\n// Build Aho-Corasick Automaton\nvoid build_ac(const vector& patterns) {\n trie.clear();\n trie.reserve(20000); // Pre-allocate to avoid frequent reallocations\n trie.emplace_back(); // Root\n\n for (int i = 0; i < patterns.size(); ++i) {\n int curr = 0;\n for (char c : patterns[i]) {\n int val = c - 'A';\n if (trie[curr].children[val] == -1) {\n trie[curr].children[val] = trie.size();\n trie.emplace_back();\n }\n curr = trie[curr].children[val];\n }\n trie[curr].matched_indices.push_back(i);\n }\n\n queue q;\n for (int i = 0; i < ALPHABET_SIZE; ++i) {\n if (trie[0].children[i] != -1) {\n trie[trie[0].children[i]].failure = 0;\n q.push(trie[0].children[i]);\n } else {\n trie[0].children[i] = 0;\n }\n }\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n\n const auto& fail_matches = trie[trie[u].failure].matched_indices;\n trie[u].matched_indices.insert(trie[u].matched_indices.end(), fail_matches.begin(), fail_matches.end());\n\n for (int i = 0; i < ALPHABET_SIZE; ++i) {\n if (trie[u].children[i] != -1) {\n int v = trie[u].children[i];\n trie[v].failure = trie[trie[u].failure].children[i];\n q.push(v);\n } else {\n trie[u].children[i] = trie[trie[u].failure].children[i];\n }\n }\n }\n}\n\n// Scan a sequence (row or col) for matches, handling wrap-around\nvoid scan_sequence(int const* seq, vector& out_found) {\n out_found.clear();\n int u = 0;\n // Max string length is 12 (L).\n // A match can wrap around. A match of length L starting at N-1 ends at N-1 + L - 1.\n // We simulate wrap-around by iterating past N.\n // Limit = N + 12 ensures we catch all wrap-around matches.\n int limit = N + 12; \n\n for (int i = 0; i < limit; ++i) {\n int c = seq[i % N];\n if (c == EMPTY_CHAR) {\n u = 0; \n continue;\n }\n \n u = trie[u].children[c];\n \n if (!trie[u].matched_indices.empty()) {\n for (int s_idx : trie[u].matched_indices) {\n int len = S[s_idx].length();\n // end position is i\n // start position is i - len + 1\n // We only record the match if its start position falls within the \n // canonical domain [0, N-1]. This avoids double counting.\n int start_pos = i - len + 1;\n if (start_pos >= 0 && start_pos < N) {\n out_found.push_back(s_idx);\n }\n }\n }\n }\n}\n\n// Update the grid at (r, c) and incrementally update scores\nvoid commit_update(int r, int c, int new_val) {\n int old_val = grid[r][c];\n if (old_val == new_val) return;\n\n if (old_val == EMPTY_CHAR) current_d--;\n if (new_val == EMPTY_CHAR) current_d++;\n\n grid[r][c] = new_val;\n\n // Update Row r\n // 1. Remove old matches\n for (int idx : row_found_strings[r]) {\n string_occurrences[idx]--;\n if (string_occurrences[idx] == 0) current_c--;\n }\n // 2. Rescan\n for(int j=0; j 0) current_c++;\n }\n}\n\n// Force a string to be present in the grid at a random location\nvoid force_string(int k) {\n int len = S[k].length();\n int dir = rng() % 2;\n int r = rng() % N;\n int c = rng() % N;\n \n for (int i = 0; i < len; ++i) {\n int char_code = S[k][i] - 'A';\n if (dir == 0) commit_update(r, (c + i) % N, char_code);\n else commit_update((r + i) % N, c, char_code);\n }\n}\n\ndouble get_score(int c, int d) {\n if (c < M) return 1e8 * (double)c / M;\n double den = 2.0 * N * N - d;\n if (den < 0.5) den = 0.5;\n return 1e8 * (2.0 * N * N / den);\n}\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int dummy_N; \n if (!(cin >> dummy_N >> M)) return 0;\n \n S.resize(M);\n for (int i = 0; i < M; ++i) cin >> S[i];\n\n build_ac(S);\n\n // Initial Random Grid\n uniform_int_distribution dist_char(0, 7);\n for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) grid[i][j] = dist_char(rng);\n\n full_evaluate();\n \n // KICKSTART PHASE\n // If random grid has very poor coverage (common with long strings), forces strings aggressively.\n // This prevents getting stuck at 0 score.\n int attempts = 0;\n while (current_c < M / 10 && attempts < 3000) {\n int k = rng() % M;\n force_string(k);\n attempts++;\n }\n\n best_c = current_c;\n best_d = current_d;\n best_score = get_score(best_c, best_d);\n memcpy(best_grid, grid, sizeof(grid));\n\n // Optimization Loop\n auto start_time = chrono::steady_clock::now();\n double time_limit = 2.95; \n double current_score = get_score(current_c, current_d);\n\n int backup_grid[N][N];\n long long iter = 0;\n\n while (true) {\n // Time check every 256 iterations to minimize overhead\n if ((iter & 255) == 0) {\n auto now = chrono::steady_clock::now();\n if (chrono::duration(now - start_time).count() > time_limit) break;\n }\n\n bool do_force = false;\n // If we haven't found all strings, occasionally force an unsatisfied one.\n // Increase probability if we have very few matches.\n if (current_c < M) {\n if (rng() % 100 < 2) do_force = true; \n if (current_c < M/5 && rng() % 10 < 3) do_force = true;\n }\n\n if (do_force) {\n // Strategy 1: Force an unsatisfied string (Large Step)\n vector unsat; \n for(int i=0; i= prev_score) {\n current_score = new_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_c = current_c;\n best_d = current_d;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n // Revert using backup and full re-eval (safe for multi-cell changes)\n memcpy(grid, backup_grid, sizeof(grid));\n full_evaluate();\n current_score = prev_score;\n }\n }\n } else {\n // Strategy 2: Single Cell Mutation (Small Step)\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val;\n \n // Only try dots if we have full coverage to maximize the secondary score\n if (current_c == M) {\n if (old_val != EMPTY_CHAR && (rng() % 4 == 0)) new_val = EMPTY_CHAR;\n else {\n new_val = dist_char(rng);\n if (new_val == old_val) new_val = (new_val + 1) % 8;\n }\n } else {\n new_val = dist_char(rng);\n if (new_val == old_val) new_val = (new_val + 1) % 8;\n }\n\n double prev_score = current_score;\n commit_update(r, c, new_val);\n double new_score = get_score(current_c, current_d);\n \n // Greedy acceptance\n if (new_score >= prev_score) {\n current_score = new_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_c = current_c;\n best_d = current_d;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n // Revert immediately\n commit_update(r, c, old_val);\n }\n }\n iter++;\n }\n\n // Output Result\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (best_grid[i][j] == EMPTY_CHAR) cout << '.';\n else cout << (char)('A' + best_grid[i][j]);\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc005":"/**\n * heuristic_solution_v2.cpp\n *\n * Improvement Strategy:\n * 1. Precompute All-Pairs Shortest Paths (APSP):\n * - N is small (up to 69), but the graph is sparse grid.\n * - Number of road cells is at most ~2500.\n * - APSP using BFS from each node takes ~2500 BFS runs.\n * - With N=69, BFS is fast. Precomputing fits within time limits (approx 0.5s).\n * - This allows O(1) distance queries for TSP and optimization steps.\n *\n * 2. Optimization Pipeline (Interleaved):\n * - Start with the Set Cover (Matching) based tour.\n * - Iteratively apply:\n * a. Prune: Remove viewpoints that become redundant (their segments are covered by others).\n * b. Slide: Move a viewpoint along a segment if it covers a unique segment, to minimize local path distance.\n * c. 2-Opt: Reorder viewpoints to minimize total tour length using exact BFS distances.\n * - This \"TSP with Neighborhoods\" approach directly addresses the geometry of the problem.\n *\n * 3. Data Structures:\n * - `dist_matrix[id1][id2]` for O(1) path costs.\n * - `seg_owner[r][c]` to quickly identify which segments a cell covers.\n * - `cover_count` array to track redundancy dynamically.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst int INF = 1e9;\nint N;\nint SI, SJ;\nvector GRID;\nint cost_grid[70][70];\n\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\nconst char DCHAR[] = {'U', 'D', 'L', 'R'};\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const {\n if (r != other.r) return r < other.r;\n return c < other.c;\n }\n};\n\nstruct Segment {\n int id;\n int r1, c1, r2, c2; // range\n bool is_vertical;\n};\n\nvector segments;\nint seg_owner[70][70][2]; // [r][c][0]->H, [1]->V\n\n// --- Time Management ---\nauto start_time = chrono::high_resolution_clock::now();\ndouble time_limit = 2.85;\n\ndouble elapsed_seconds() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// --- BFS & Path ---\n\n// Max road cells approx 70*70 = 4900.\n// Matrix 5000*5000 ints = 100MB.\nint dist_matrix[5000][5000];\nint point_to_id[70][70];\nPoint id_to_point[5000];\nint num_road_cells = 0;\n\n// Precompute APSP using BFS from every road cell\nvoid precompute_apsp() {\n int id_counter = 0;\n for(int r=0; r, vector>, greater>> pq;\n pq.push({0, i});\n \n while(!pq.empty()) {\n auto [d, u_id] = pq.top();\n pq.pop();\n \n if (d > dist_matrix[i][u_id]) continue;\n \n Point u = id_to_point[u_id];\n \n for(int k=0; k<4; ++k) {\n int nr = u.r + DR[k];\n int nc = u.c + DC[k];\n if(nr>=0 && nr=0 && nc=0 && pr=0 && pc>& adj, vector& match_right, vector& vis, vector& match_left) {\n vis[u] = true;\n for (int v : adj[u]) {\n if (match_right[v] == -1 || (!vis[match_right[v]] && bm_dfs(match_right[v], adj, match_right, vis, match_left))) {\n match_left[u] = v;\n match_right[v] = u;\n return true;\n }\n }\n return false;\n}\n\n// --- Optimization Logic ---\n\nlong long calc_tour_cost(const vector& tour) {\n if (tour.empty()) return 0;\n long long cost = 0;\n for(size_t i=0; i h_ids, v_ids;\n for(auto& s : segments) {\n if (!s.is_vertical) h_ids.push_back(s.id);\n else v_ids.push_back(s.id);\n }\n \n map h_map, v_map; \n for(int i=0; i<(int)h_ids.size(); ++i) h_map[h_ids[i]] = i;\n for(int i=0; i<(int)v_ids.size(); ++i) v_map[v_ids[i]] = i;\n \n vector> adj(h_ids.size());\n map, Point> intersection_points;\n \n for(int r=0; r match_left(h_ids.size(), -1);\n vector match_right(v_ids.size(), -1);\n vector vis;\n for(int i=0; i<(int)h_ids.size(); ++i) {\n vis.assign(h_ids.size(), false);\n bm_dfs(i, adj, match_right, vis, match_left);\n }\n\n vector targets;\n vector seg_covered(segments.size(), false);\n \n auto add_target = [&](Point p) {\n targets.push_back(p);\n int h = seg_owner[p.r][p.c][0];\n int v = seg_owner[p.r][p.c][1];\n if(h != -1) seg_covered[h] = true;\n if(v != -1) seg_covered[v] = true;\n };\n\n // 1. Matching Edges\n for(int i=0; i<(int)h_ids.size(); ++i) {\n if(match_left[i] != -1) {\n add_target(intersection_points[{i, match_left[i]}]);\n }\n }\n // 2. Uncovered H\n for(int i=0; i<(int)h_ids.size(); ++i) {\n if(!seg_covered[h_ids[i]]) {\n bool found = false;\n for(int v : adj[i]) {\n add_target(intersection_points[{i, v}]); \n found = true; break;\n }\n if(!found) {\n Segment& s = segments[h_ids[i]];\n add_target({s.r1, (s.c1+s.c2)/2});\n }\n }\n }\n // 3. Uncovered V\n for(int j=0; j<(int)v_ids.size(); ++j) {\n if(!seg_covered[v_ids[j]]) {\n bool found = false;\n Segment& s = segments[v_ids[j]];\n for(int r=s.r1; r<=s.r2; ++r) {\n int c = s.c1;\n int hid = seg_owner[r][c][0];\n if(hid != -1) { \n add_target({r, c});\n found = true; break;\n }\n }\n if(!found) add_target({(s.r1+s.r2)/2, s.c1});\n }\n }\n\n sort(targets.begin(), targets.end());\n targets.erase(unique(targets.begin(), targets.end()), targets.end());\n \n Point start_pt = {SI, SJ};\n bool has_start = false;\n for(auto p : targets) if(p==start_pt) has_start = true;\n if(!has_start) targets.push_back(start_pt);\n\n // Initial TSP (Nearest Neighbor)\n vector tour;\n {\n vector used(targets.size(), false);\n int curr_idx = -1;\n for(int i=0; i<(int)targets.size(); ++i) if(targets[i] == start_pt) curr_idx = i;\n \n tour.push_back(targets[curr_idx]);\n used[curr_idx] = true;\n \n for(int step=1; step<(int)targets.size(); ++step) {\n int best = -1; \n int best_d = INF;\n Point curr_p = tour.back();\n for(int i=0; i<(int)targets.size(); ++i) {\n if(!used[i]) {\n int d = get_dist(curr_p, targets[i]);\n if(d < best_d) { best_d = d; best = i; }\n }\n }\n used[best] = true;\n tour.push_back(targets[best]);\n }\n }\n \n // --- Optimization Loop ---\n vector cover_count(segments.size(), 0);\n auto refresh_counts = [&]() {\n fill(cover_count.begin(), cover_count.end(), 0);\n for(auto p : tour) {\n int h = seg_owner[p.r][p.c][0];\n int v = seg_owner[p.r][p.c][1];\n if(h!=-1) cover_count[h]++;\n if(v!=-1) cover_count[v]++;\n }\n };\n \n refresh_counts();\n long long current_cost = calc_tour_cost(tour);\n \n while(elapsed_seconds() < time_limit) {\n bool improved = false;\n\n // 1. Prune: Remove point if all its segments are covered by >1 points\n for(int i=0; i<(int)tour.size(); ++i) {\n if (tour.size() <= 1) break;\n if (tour[i] == start_pt) continue; \n \n int h = seg_owner[tour[i].r][tour[i].c][0];\n int v = seg_owner[tour[i].r][tour[i].c][1];\n \n bool needed = false;\n if (h != -1 && cover_count[h] <= 1) needed = true;\n if (v != -1 && cover_count[v] <= 1) needed = true;\n \n if (!needed) {\n if (h != -1) cover_count[h]--;\n if (v != -1) cover_count[v]--;\n tour.erase(tour.begin() + i);\n improved = true;\n i--; \n }\n }\n if (improved) { current_cost = calc_tour_cost(tour); continue; }\n\n // 2. Slide: Optimization for TSP with Neighborhoods\n for(int i=0; i<(int)tour.size(); ++i) {\n Point p = tour[i];\n if (p == start_pt) continue; // Keep start fixed\n\n int h = seg_owner[p.r][p.c][0];\n int v = seg_owner[p.r][p.c][1];\n \n bool h_unique = (h != -1 && cover_count[h] == 1);\n bool v_unique = (v != -1 && cover_count[v] == 1);\n \n // Determine which segment constrains this point\n int slide_seg_id = -1;\n if (h_unique && !v_unique) slide_seg_id = h;\n else if (!h_unique && v_unique) slide_seg_id = v;\n // If both unique, it's a critical intersection, can't move easily.\n \n if (slide_seg_id != -1) {\n Segment& s = segments[slide_seg_id];\n Point prev = tour[(i - 1 + tour.size()) % tour.size()];\n Point next = tour[(i + 1) % tour.size()];\n \n int best_local_cost = get_dist(prev, p) + get_dist(p, next);\n Point best_p = p;\n \n // Try all cells in the constraining segment\n if (!s.is_vertical) {\n for (int c = s.c1; c <= s.c2; ++c) {\n Point cand = {s.r1, c};\n int cand_cost = get_dist(prev, cand) + get_dist(cand, next);\n if (cand_cost < best_local_cost) {\n best_local_cost = cand_cost;\n best_p = cand;\n }\n }\n } else {\n for (int r = s.r1; r <= s.r2; ++r) {\n Point cand = {r, s.c1};\n int cand_cost = get_dist(prev, cand) + get_dist(cand, next);\n if (cand_cost < best_local_cost) {\n best_local_cost = cand_cost;\n best_p = cand;\n }\n }\n }\n \n if (best_p != p) {\n // Update counts\n int old_h = seg_owner[p.r][p.c][0];\n int old_v = seg_owner[p.r][p.c][1];\n if (old_h != -1) cover_count[old_h]--;\n if (old_v != -1) cover_count[old_v]--;\n \n tour[i] = best_p;\n \n int new_h = seg_owner[best_p.r][best_p.c][0];\n int new_v = seg_owner[best_p.r][best_p.c][1];\n if (new_h != -1) cover_count[new_h]++;\n if (new_v != -1) cover_count[new_v]++;\n \n improved = true;\n }\n }\n }\n if (improved) { current_cost = calc_tour_cost(tour); continue; }\n\n // 3. 2-Opt\n for (int i = 0; i < (int)tour.size() - 1; ++i) {\n for (int j = i + 2; j < (int)tour.size(); ++j) {\n if ((j+1)%tour.size() == i) continue; // Adjacency wrap\n \n Point A = tour[i];\n Point B = tour[i+1];\n Point C = tour[j];\n Point D = tour[(j+1)%tour.size()]; \n \n int d_old = get_dist(A, B) + get_dist(C, D);\n int d_new = get_dist(A, C) + get_dist(B, D);\n \n if (d_new < d_old) {\n reverse(tour.begin() + i + 1, tour.begin() + j + 1);\n improved = true;\n }\n }\n }\n if (improved) { current_cost = calc_tour_cost(tour); continue; }\n \n if (!improved) break; \n }\n \n // Final output construction\n int start_idx = -1;\n for(int i=0; i<(int)tour.size(); ++i) if(tour[i] == start_pt) { start_idx = i; break; }\n \n string final_path = \"\";\n Point curr = tour[start_idx];\n for(int i=0; i<(int)tour.size(); ++i) {\n Point next = tour[(start_idx + i + 1) % tour.size()];\n if (curr != next) {\n final_path += get_path_string(curr, next);\n }\n curr = next;\n }\n \n return final_path;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n if (!(cin >> N >> SI >> SJ)) return 0;\n GRID.resize(N);\n for(int i=0; i> GRID[i];\n for(int j=0; j1, T = w + noise. So w_approx = T.\n * - Error E = w_approx - w.\n * - We want to change s_k to reduce E.\n * - The gradient of w w.r.t s_k is -1 if d_k > s_k, else 0.\n * - We update s_k += learning_rate * E * (1 if d_k > s_k else 0).\n * - Since we handle integer vectors, we apply probabilistic or deterministic increments.\n * \n * Implementation details:\n * - Use `long long` for safety, though inputs are small.\n * - Use fast I/O.\n */\n\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\n// Global Constants\nconstexpr int MAX_DAYS = 2000;\n\n// Random number generator\nmt19937 rng(12345);\n\nstruct Task {\n int id;\n vector d; // required skills\n vector children;\n vector parents;\n int parent_count; // dynamic incomplete parents count\n int original_parent_count;\n \n // Static analysis features\n int depth_rank; // Longest path to end\n int descendants_count; \n};\n\nstruct Member {\n int id;\n vector s; // estimated skills\n int working_on_task_id; // -1 if free\n int task_start_day;\n \n // History for better estimation (optional, simple greedy update used here)\n // We can store past tasks to replay training if we want to be fancy, \n // but online updates are usually sufficient for this constraint.\n};\n\nint N, M, K, R;\nvector tasks;\nvector members;\nvector task_status; // 0: not started, 1: working, 2: completed\n\n// Helper to generate random int\nint randint(int l, int r) {\n return uniform_int_distribution(l, r)(rng);\n}\n\n// Calculate predicted steps\n// w = sum(max(0, d - s))\n// t = w == 0 ? 1 : w + noise\n// expected t ~ w (ignoring the w=0 case discontinuity and noise average 0)\nint predict_ticks(const vector& d, const vector& s) {\n int w = 0;\n for (int k = 0; k < K; ++k) {\n w += max(0, d[k] - s[k]);\n }\n if (w == 0) return 1;\n return max(1, w); \n}\n\n// Calculate topological features for prioritization\nvoid analyze_graph() {\n // Calculate depth (longest path from task to any leaf)\n // Since N is up to 1000, O(N+R) with memoization is fine.\n vector depth(N + 1, -1);\n vector descendants(N + 1, -1);\n \n // Tasks are topologically sorted? No guarantee in input, but u < v implies acyclic.\n // We can compute in reverse order of ID since u < v.\n for (int i = N; i >= 1; --i) {\n int max_child_depth = 0;\n int total_descendants = 0;\n for (int child_id : tasks[i].children) {\n max_child_depth = max(max_child_depth, tasks[child_id].depth_rank);\n total_descendants += 1 + tasks[child_id].descendants_count;\n }\n tasks[i].depth_rank = 1 + max_child_depth;\n tasks[i].descendants_count = total_descendants;\n }\n}\n\n// Skill Estimation Update\nvoid update_skills(int member_id, int task_id, int actual_duration) {\n Member& m = members[member_id];\n const Task& t = tasks[task_id];\n \n // Current prediction\n int w_est = 0;\n vector relevant_dims;\n for (int k = 0; k < K; ++k) {\n if (t.d[k] > m.s[k]) {\n w_est += (t.d[k] - m.s[k]);\n relevant_dims.push_back(k);\n }\n }\n \n // Inverse logic:\n // We observed actual_duration.\n // If actual_duration == 1, then w was likely 0 (or very small and noise made it 1).\n // If actual_duration > 1, actual_duration = w_true + noise.\n // So w_true is roughly actual_duration.\n \n int w_target = actual_duration;\n // There's noise uniform(-3, 3). We don't know the noise, but over time it averages out.\n // If we assume noise is 0 for the update, we oscillate around the truth.\n \n // Simple Gradient Descent step\n // Error = w_est - w_target\n // We want to minimize (w_est - w_target)^2\n // w_est = sum_{k in relevant} (d_k - s_k)\n // partial derivative w.r.t s_k is -1 for k in relevant.\n // s_k_new = s_k - learning_rate * (d(Error)/d(s_k))\n // = s_k - learning_rate * 2 * (w_est - w_target) * (-1)\n // = s_k + 2 * lr * (w_est - w_target)\n \n // If w_est < w_target (took longer than expected), Error < 0. update should decrease s_k?\n // Wait.\n // w_est small means we think we are good. w_target large means we are bad.\n // So s_k should decrease (be further from d_k) to increase w_est.\n // Formula check: w_est - w_target < 0. s_k += neg * neg -> s_k += pos.\n // This increases s_k, which reduces w_est. This is wrong.\n \n // Let's reason simply:\n // If w_est < w_target (Underestimated difficulty / Overestimated skill):\n // We need to increase w_est => decrease s_k.\n // If w_est > w_target (Overestimated difficulty / Underestimated skill):\n // We need to decrease w_est => increase s_k.\n \n int diff = w_est - w_target; // Positive if we are too pessimistic (s too low), Negative if too optimistic (s too high)\n \n if (diff == 0) return; // Perfect prediction (or lucky noise)\n \n // To distribute the correction across dimensions\n // If we need to increase s (diff > 0), we pick dimensions where d_k > s_k mainly?\n // Actually, any s_k can affect w if d_k > s_k.\n // If d_k <= s_k, increasing s_k doesn't change max(0, d-s)=0 (remains 0).\n // But decreasing s_k might make it positive.\n \n // We use a randomized update strategy to avoid getting stuck\n // The \"learning rate\" effectively is how many points we distribute\n int correction = abs(diff); \n \n // Damping factor to account for noise. If |diff| <= 3, it might just be noise.\n // However, consistently correcting small amounts is fine.\n // We reduce the correction magnitude slightly to be conservative.\n correction = max(1, correction / 2);\n\n if (diff > 0) {\n // Estimated time too high -> Skills are actually better -> Increase s\n // We can increase s_k where d_k > s_k to reduce the term (d_k - s_k).\n // Or we can increase s_k where d_k <= s_k (doesn't help immediately for this task, but generally good).\n // Focusing on relevant dims is most effective for reducing the specific error.\n if (!relevant_dims.empty()) {\n for (int iter = 0; iter < correction; ++iter) {\n int k = relevant_dims[randint(0, relevant_dims.size() - 1)];\n m.s[k]++;\n }\n } else {\n // w_est was 0, but w_target can't be smaller than 1 unless logic error.\n // If diff > 0, w_est > w_target. Since w_target >= 1, w_est >= 2.\n // So relevant_dims cannot be empty.\n }\n } else {\n // Estimated time too low -> Skills are actually worse -> Decrease s\n // We need to increase w_est. Decrease s_k.\n // We should decrease s_k where it contributes to w (relevant_dims) or where it *should* contribute.\n // If we simply decrease random s_k, it increases max(0, d-s).\n \n // We prioritize dimensions where s_k is currently high or close to d_k?\n // Random dimension selection works reasonably well.\n for (int iter = 0; iter < correction; ++iter) {\n int k = randint(0, K - 1);\n if (m.s[k] > 0) {\n m.s[k]--;\n }\n }\n }\n}\n\nint main() {\n // Optimize I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // 1. Read Input\n cin >> N >> M >> K >> R;\n \n tasks.resize(N + 1);\n members.resize(M + 1);\n task_status.assign(N + 1, 0);\n \n for (int i = 1; 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 tasks[i].parent_count = 0;\n tasks[i].original_parent_count = 0;\n }\n \n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n tasks[u].children.push_back(v);\n tasks[v].parents.push_back(u);\n tasks[v].parent_count++;\n tasks[v].original_parent_count++;\n }\n \n // Initialize members\n for (int j = 1; j <= M; ++j) {\n members[j].id = j;\n members[j].s.assign(K, 0); // Start with 0 skill estimate\n // Alternative initialization: random normal around 0?\n // Given \"non-negative integer vector\", 0 is a safe lower bound.\n members[j].working_on_task_id = -1;\n }\n \n analyze_graph();\n\n vector ready_tasks;\n for (int i = 1; i <= N; ++i) {\n if (tasks[i].parent_count == 0) {\n ready_tasks.push_back(i);\n }\n }\n \n int completed_count = 0;\n \n // 2. Simulation Loop\n for (int day = 1; day <= MAX_DAYS; ++day) {\n // Output container\n vector> assignments;\n \n // Identify free members\n vector free_members;\n for (int j = 1; j <= M; ++j) {\n if (members[j].working_on_task_id == -1) {\n free_members.push_back(j);\n }\n }\n \n // Sort tasks by importance\n // Important tasks: High depth (critical path), High descendants\n // We can also consider difficulty vs skill match, but first filter by graph topology.\n sort(ready_tasks.begin(), ready_tasks.end(), [&](int a, int b) {\n // Lexicographical comparison of importance features\n if (tasks[a].depth_rank != tasks[b].depth_rank) \n return tasks[a].depth_rank > tasks[b].depth_rank;\n if (tasks[a].descendants_count != tasks[b].descendants_count)\n return tasks[a].descendants_count > tasks[b].descendants_count;\n return a < b; // Tie-break\n });\n\n // Match free members to ready tasks\n // Since M is small (20), we can afford O(M * |Ready|) or something slightly heavier.\n // We want to assign the \"best\" task to the \"best\" member for it.\n // However, \"best task\" is global (graph structure). \"Best member\" is local (skill match).\n // Strategy: Iterate tasks in order of importance. Assign to the member who can finish it fastest.\n \n vector task_taken(ready_tasks.size(), false);\n vector member_taken(M + 1, false);\n \n // We use a simple greedy approach: \n // Take the most important tasks and assign them to the member who does them fastest.\n // Note: Sometimes it's better to give a hard task to a strong member and an easy task to a weak member.\n // But minimizing completion time of the critical path is usually key.\n \n // To improve matching, let's iterate through available tasks (limit to some lookahead)\n // and find the (task, member) pair that minimizes duration, prioritizing important tasks implicitly.\n \n // Simple 2-pass Greedy:\n // Pass 1: For high priority tasks, find best member.\n \n // Let's make a list of assignments to perform this turn\n // We will simply loop until we run out of free members or ready tasks\n \n int assigned_count = 0;\n int max_assignments = min((int)free_members.size(), (int)ready_tasks.size());\n \n // We will construct a cost matrix for matching if we want to be precise,\n // but given the uncertainty, a heuristic loop is fine.\n \n // Let's try to assign tasks to members.\n // We iterate through free members and assign the best task for them?\n // Or iterate through tasks and assign best member?\n // Iterating through tasks (ordered by priority) and picking the best available member \n // ensures critical path moves fast.\n \n for (int i = 0; i < ready_tasks.size(); ++i) {\n if (assignments.size() >= free_members.size()) break;\n \n int t_id = ready_tasks[i];\n if (task_taken[i]) continue;\n \n // Find best member for this task among those not yet taken\n int best_m_id = -1;\n int min_pred_time = 1e9;\n \n // Heuristic: We want to minimize time.\n // Also, maybe reserve super-skilled members for super-hard tasks? \n // (Not modeled here, standard greedy is strong enough).\n \n for (int m_id : free_members) {\n if (member_taken[m_id]) continue;\n \n int pred = predict_ticks(tasks[t_id].d, members[m_id].s);\n if (pred < min_pred_time) {\n min_pred_time = pred;\n best_m_id = m_id;\n }\n }\n \n if (best_m_id != -1) {\n // Assign\n assignments.push_back({best_m_id, t_id});\n member_taken[best_m_id] = true;\n task_taken[i] = true;\n \n // Update internal state immediately\n members[best_m_id].working_on_task_id = t_id;\n members[best_m_id].task_start_day = day;\n task_status[t_id] = 1;\n }\n }\n \n // Remove taken tasks from ready_tasks\n vector next_ready_tasks;\n for (int i = 0; i < ready_tasks.size(); ++i) {\n if (!task_taken[i]) {\n next_ready_tasks.push_back(ready_tasks[i]);\n }\n }\n ready_tasks = next_ready_tasks;\n\n // Output assignments\n cout << assignments.size();\n for (auto& p : assignments) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << endl; // flush\n \n // 3. Read Response (Finished tasks)\n int n_finished;\n cin >> n_finished;\n \n if (n_finished == -1) {\n // End of simulation\n break;\n }\n \n for (int i = 0; i < n_finished; ++i) {\n int f_member;\n cin >> f_member;\n \n int finished_task = members[f_member].working_on_task_id;\n int duration = day - members[f_member].task_start_day + 1;\n \n // Update skills based on observation\n update_skills(f_member, finished_task, duration);\n \n members[f_member].working_on_task_id = -1;\n task_status[finished_task] = 2; // Completed\n completed_count++;\n \n // Unlock dependencies\n for (int child : tasks[finished_task].children) {\n tasks[child].parent_count--;\n if (tasks[child].parent_count == 0) {\n ready_tasks.push_back(child);\n }\n }\n }\n }\n \n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants ---\nconst int NUM_ORDERS = 1000;\nconst int TARGET_ORDERS = 50;\nconst int CENTER_COORD = 400;\nconst double TIME_LIMIT = 1.95;\n\n// --- Structures ---\nstruct Point {\n int x, y;\n};\n\nstruct Order {\n int id; // 0-based index in input\n Point p, d;\n};\n\n// --- Global Data ---\nOrder orders[NUM_ORDERS];\n// Distance table: 0..999: Pickups, 1000..1999: Deliveries, 2000: Depot\n// Used for O(1) distance lookups.\nint dist_table[2005][2005];\n\ninline int get_dist(int u, int v) {\n return dist_table[u][v];\n}\n\ninline int calc_manhattan(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\n// Map order index to point indices in dist_table\ninline int P_IDX(int order_idx) { return order_idx; }\ninline int D_IDX(int order_idx) { return order_idx + 1000; }\nconst int DEPOT_IDX = 2000;\n\n// --- Random ---\nuint64_t rng_state = 88172645463325252ULL;\ninline uint64_t xorshift64() {\n rng_state ^= rng_state << 13;\n rng_state ^= rng_state >> 7;\n rng_state ^= rng_state << 17;\n return rng_state;\n}\ninline int rand_int(int n) { return xorshift64() % n; }\ninline double rand_double() { return (double)xorshift64() / 18446744073709551615.0; }\n\n// --- State ---\n// Route stores node indices: 0..99 (relative to current selection).\n// val < 50 => Pickup for selection[val]\n// val >= 50 => Delivery for selection[val-50]\nstruct State {\n vector selection; // size 50, stores global order IDs\n vector route; // size 100, stores values 0..99\n int total_dist;\n};\n\n// Helper to get global point index from route value\ninline int get_global_point_idx(int val, const vector& selection) {\n if (val < TARGET_ORDERS) return P_IDX(selection[val]);\n else return D_IDX(selection[val - TARGET_ORDERS]);\n}\n\nint calculate_full_dist(const vector& route, const vector& selection) {\n int d = 0;\n int curr = DEPOT_IDX;\n for (int val : route) {\n int next = get_global_point_idx(val, selection);\n d += get_dist(curr, next);\n curr = next;\n }\n d += get_dist(curr, DEPOT_IDX);\n return d;\n}\n\n// --- Greedy Construction ---\n// Used for initialization\nint solve_greedy_route(const vector& selection, vector& route_out) {\n route_out.clear();\n route_out.reserve(TARGET_ORDERS * 2);\n \n bool picked[TARGET_ORDERS] = {false};\n bool delivered[TARGET_ORDERS] = {false};\n int current_loc = DEPOT_IDX;\n int nodes_left = TARGET_ORDERS * 2;\n\n while (nodes_left > 0) {\n int best_node = -1;\n int best_dist = 1e9;\n \n // Optimization: Only check valid next moves\n // This loop is small (50 iters)\n for (int i = 0; i < TARGET_ORDERS; ++i) {\n if (!picked[i]) {\n int d = get_dist(current_loc, P_IDX(selection[i]));\n if (d < best_dist) {\n best_dist = d;\n best_node = i; \n }\n } else if (!delivered[i]) {\n int d = get_dist(current_loc, D_IDX(selection[i]));\n if (d < best_dist) {\n best_dist = d;\n best_node = i + TARGET_ORDERS; \n }\n }\n }\n \n route_out.push_back(best_node);\n if (best_node < TARGET_ORDERS) picked[best_node] = true;\n else delivered[best_node - TARGET_ORDERS] = true;\n \n current_loc = (best_node < TARGET_ORDERS) ? P_IDX(selection[best_node]) : D_IDX(selection[best_node - TARGET_ORDERS]);\n nodes_left--;\n }\n \n return calculate_full_dist(route_out, selection);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n auto start_time = chrono::steady_clock::now();\n\n // Input\n for (int i = 0; i < NUM_ORDERS; ++i) {\n orders[i].id = i;\n cin >> orders[i].p.x >> orders[i].p.y >> orders[i].d.x >> orders[i].d.y;\n }\n\n // Precompute Distances\n vector points(2001);\n for(int i=0; i> candidates; \n candidates.reserve(NUM_ORDERS);\n for(int i=0; i is_selected(NUM_ORDERS, false);\n for(int x : current_state.selection) is_selected[x] = true;\n vector unselected;\n unselected.reserve(NUM_ORDERS);\n for(int i=0; i(chrono::steady_clock::now() - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n }\n \n // Approximate temp calc inside loop for speed\n // Only update accurate temp occasionally if needed, but here we do it every step is fine?\n // Let's use linear approx\n // double temp = start_temp + (end_temp - start_temp) * (iter / MAX_ITER); \n // Since we don't know MAX_ITER, we use time.\n // Doing time check every iter is slow. Do coarse.\n \n // Just use current time from check block? \n // No, assume max iters ~ 300,000?\n // Let's stick to time check in block.\n \n // Simpler temp: \n // We update `temp` in the check block for efficiency? \n // Or just keep it simple. \n double elapsed = chrono::duration(chrono::steady_clock::now() - start_time).count();\n double temp = start_temp + (end_temp - start_temp) * (elapsed / TIME_LIMIT);\n\n int move_type = rand_int(100);\n \n if (move_type < 60) {\n // --- Move 1: TSP Swap Node ---\n int u = rand_int(2 * TARGET_ORDERS);\n int v = rand_int(2 * TARGET_ORDERS);\n if (u == v) continue;\n if (u > v) swap(u, v);\n \n int val_u = current_state.route[u];\n int val_v = current_state.route[v];\n int ord_u = (val_u < TARGET_ORDERS) ? val_u : val_u - TARGET_ORDERS;\n int ord_v = (val_v < TARGET_ORDERS) ? val_v : val_v - TARGET_ORDERS;\n \n if (ord_u == ord_v) continue; \n \n bool possible = true;\n \n if (val_u < TARGET_ORDERS) { // P at u -> v. D must be > v.\n // Check D pos\n for(int k=0; k<2*TARGET_ORDERS; ++k) {\n if (current_state.route[k] == ord_u + TARGET_ORDERS) { \n if (v > k) possible = false; \n break; \n }\n }\n }\n if (!possible) continue;\n\n if (val_v >= TARGET_ORDERS) { // D at v -> u. P must be < u.\n for(int k=0; k<2*TARGET_ORDERS; ++k) {\n if (current_state.route[k] == ord_v) { \n if (k > u) possible = false; \n break; \n }\n }\n }\n if (!possible) continue;\n \n // Calculate Delta\n int prev_u = (u == 0) ? DEPOT_IDX : get_global_point_idx(current_state.route[u-1], current_state.selection);\n int next_u = (u == 2*TARGET_ORDERS - 1) ? DEPOT_IDX : get_global_point_idx(current_state.route[u+1], current_state.selection);\n int prev_v = (v == 0) ? DEPOT_IDX : get_global_point_idx(current_state.route[v-1], current_state.selection);\n int next_v = (v == 2*TARGET_ORDERS - 1) ? DEPOT_IDX : get_global_point_idx(current_state.route[v+1], current_state.selection);\n \n int point_u = get_global_point_idx(val_u, current_state.selection);\n int point_v = get_global_point_idx(val_v, current_state.selection);\n \n int old_cost, new_cost;\n \n if (u + 1 == v) {\n old_cost = get_dist(prev_u, point_u) + get_dist(point_u, point_v) + get_dist(point_v, next_v);\n new_cost = get_dist(prev_u, point_v) + get_dist(point_v, point_u) + get_dist(point_u, next_v);\n } else {\n old_cost = get_dist(prev_u, point_u) + get_dist(point_u, next_u) + \n get_dist(prev_v, point_v) + get_dist(point_v, next_v);\n new_cost = get_dist(prev_u, point_v) + get_dist(point_v, next_u) +\n get_dist(prev_v, point_u) + get_dist(point_u, next_v);\n }\n \n int delta = new_cost - old_cost;\n if (delta < 0 || exp(-delta/temp) > rand_double()) {\n current_state.route[u] = val_v;\n current_state.route[v] = val_u;\n current_state.total_dist += delta;\n if (current_state.total_dist < best_state.total_dist) best_state = current_state;\n }\n \n } else if (move_type < 80) {\n // --- Move 2: TSP Shift Node ---\n int u = rand_int(2 * TARGET_ORDERS);\n int v = rand_int(2 * TARGET_ORDERS); \n if (u == v) continue;\n \n int val = current_state.route[u];\n \n // Check validity\n int partner_val = (val < TARGET_ORDERS) ? (val + TARGET_ORDERS) : (val - TARGET_ORDERS);\n int partner_pos = -1;\n for(int k=0; k<2*TARGET_ORDERS; ++k) if(current_state.route[k] == partner_val) { partner_pos = k; break; }\n \n int partner_pos_reduced = (partner_pos > u) ? partner_pos - 1 : partner_pos;\n \n if (val < TARGET_ORDERS) { // P, must insert before D\n if (v > partner_pos_reduced) continue;\n } else { // D, must insert after P\n if (v <= partner_pos_reduced) continue;\n }\n \n // Do full dist calc for shift\n vector next_route = current_state.route;\n next_route.erase(next_route.begin() + u);\n next_route.insert(next_route.begin() + v, val);\n \n int new_dist = calculate_full_dist(next_route, current_state.selection);\n int delta = new_dist - current_state.total_dist;\n \n if (delta < 0 || exp(-delta/temp) > rand_double()) {\n current_state.route = next_route;\n current_state.total_dist = new_dist;\n if (current_state.total_dist < best_state.total_dist) best_state = current_state;\n }\n \n } else {\n // --- Move 3: Swap Order ---\n int sel_idx = rand_int(TARGET_ORDERS);\n int old_global = current_state.selection[sel_idx];\n \n if (unselected.empty()) continue;\n int unsel_idx_ptr = rand_int(unselected.size());\n int new_global = unselected[unsel_idx_ptr];\n \n vector reduced_route;\n reduced_route.reserve(2 * TARGET_ORDERS - 2);\n int p_code = sel_idx;\n int d_code = sel_idx + TARGET_ORDERS;\n \n for (int x : current_state.route) {\n if (x != p_code && x != d_code) reduced_route.push_back(x);\n }\n \n current_state.selection[sel_idx] = new_global; // tentative\n \n // Insert Optimization\n int best_ins_dist = 1e9;\n int best_i = -1, best_j = -1;\n \n int P_g = P_IDX(new_global);\n int D_g = D_IDX(new_global);\n \n vector r_pts; \n r_pts.reserve(102);\n r_pts.push_back(DEPOT_IDX);\n for(int val : reduced_route) r_pts.push_back(get_global_point_idx(val, current_state.selection));\n r_pts.push_back(DEPOT_IDX);\n \n // base_dist is dist of reduced_route. \n // But since r_pts is built from scratch, we can sum it.\n // Cost optimization:\n // We need cost of reduced route to add deltas.\n // Can calculate once.\n int reduced_cost = 0;\n for(size_t k=0; k=i)\n // Just scan to find best D pos for this P pos\n int current_best_delta = 1e9;\n int current_best_k = -1;\n \n for(int k = i; k < (int)r_pts.size()-1; ++k) {\n int delta_d = 0;\n if (k == i) {\n // Insert D right after P. Edge P -> i+1 becomes P -> D -> i+1\n delta_d = get_dist(P_g, D_g) + get_dist(D_g, r_pts[i+1]) - get_dist(P_g, r_pts[i+1]);\n } else {\n // Insert D between k and k+1\n delta_d = get_dist(r_pts[k], D_g) + get_dist(D_g, r_pts[k+1]) - get_dist(r_pts[k], r_pts[k+1]);\n }\n if (delta_d < current_best_delta) {\n current_best_delta = delta_d;\n current_best_k = k;\n }\n }\n \n if (reduced_cost + cost_p + current_best_delta < best_ins_dist) {\n best_ins_dist = reduced_cost + cost_p + current_best_delta;\n best_i = i;\n best_j = current_best_k;\n }\n }\n \n int delta = best_ins_dist - current_state.total_dist;\n if (delta < 0 || exp(-delta/temp) > rand_double()) {\n current_state.total_dist = best_ins_dist;\n reduced_route.insert(reduced_route.begin() + best_i, p_code);\n reduced_route.insert(reduced_route.begin() + best_j + 1, d_code);\n current_state.route = reduced_route;\n \n unselected[unsel_idx_ptr] = old_global;\n if (current_state.total_dist < best_state.total_dist) best_state = current_state;\n } else {\n current_state.selection[sel_idx] = old_global;\n }\n }\n }\n \n cout << TARGET_ORDERS;\n for (int idx : best_state.selection) cout << \" \" << orders[idx].id + 1; \n cout << endl;\n \n vector path;\n path.push_back({CENTER_COORD, CENTER_COORD});\n for (int val : best_state.route) {\n if (val < TARGET_ORDERS) path.push_back(orders[best_state.selection[val]].p);\n else path.push_back(orders[best_state.selection[val - TARGET_ORDERS]].d);\n }\n path.push_back({CENTER_COORD, CENTER_COORD});\n \n cout << path.size();\n for (const auto& p : path) cout << \" \" << p.x << \" \" << p.y;\n cout << endl;\n\n return 0;\n}","ahc007":"/**\n * Solution for AtCoder Heuristic Contest 007\n * Author: Algorithm Engineer\n * Strategy: Monte Carlo Simulation with Online MST Decision\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Fast IO\nvoid fast_io() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n}\n\n// Disjoint Set Union (DSU) / Union-Find\nstruct DSU {\n std::vector parent;\n int components;\n\n DSU(int n) : parent(n), components(n) {\n std::iota(parent.begin(), parent.end(), 0);\n }\n\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n components--;\n return true;\n }\n return false;\n }\n\n bool same(int i, int j) {\n return find(i) == find(j);\n }\n \n // Reset to initial state (0..N-1)\n void reset() {\n std::iota(parent.begin(), parent.end(), 0);\n components = parent.size();\n }\n};\n\nstruct Point {\n int x, y;\n};\n\nstruct Edge {\n int id;\n int u, v;\n int d; // Euclidean distance rounded\n};\n\nint N, M;\nstd::vector points;\nstd::vector edges;\nstd::mt19937 rng(12345); // Fixed seed for reproducibility/debugging within context, or random for submission\n\nint get_dist(int i, int j) {\n double dx = points[i].x - points[j].x;\n double dy = points[i].y - points[j].y;\n return std::round(std::sqrt(dx*dx + dy*dy));\n}\n\nint main() {\n fast_io();\n\n // Read inputs\n std::cin >> N >> M;\n points.resize(N);\n for (int i = 0; i < N; ++i) {\n std::cin >> points[i].x >> points[i].y;\n }\n \n edges.resize(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n std::cin >> edges[i].u >> edges[i].v;\n edges[i].d = get_dist(edges[i].u, edges[i].v);\n }\n\n // DSU to keep track of edges we have firmly accepted\n DSU fixed_dsu(N);\n \n // DSU for checking global connectivity (bridges)\n DSU bridge_check_dsu(N);\n\n // DSU for simulation\n DSU sim_dsu(N);\n \n // Keep track of which edges are still available in the future\n // We just iterate indices > current_i\n\n // Tuning parameters\n // With 2.0 seconds and M=2000, we have 1ms per query.\n // A simple DSU op is near constant. Iterating ~2000 edges is fast.\n // We can afford about 300-500 simulations depending on implementation.\n const int NUM_SIMS = 400; \n\n for (int i = 0; i < M; ++i) {\n int l_i;\n std::cin >> l_i;\n \n int u = edges[i].u;\n int v = edges[i].v;\n\n // 1. If already connected by accepted edges, discard immediately.\n if (fixed_dsu.same(u, v)) {\n std::cout << 0 << std::endl;\n continue;\n }\n\n // 2. Check if this edge is a bridge given the remaining available edges.\n // If we don't take this edge, can we EVER connect u and v?\n // Construct graph with fixed edges + all future edges.\n bridge_check_dsu.reset();\n // Copy state from fixed_dsu? No, reset is O(N). Rebuilding is safer/cleaner.\n // Actually, better to maintain a \"base\" structure or just rebuild. \n // Rebuilding 2000 times with 2000 edges is 4*10^6 ops total, very fast.\n \n // Optimization: DSU copy is fast.\n bridge_check_dsu = fixed_dsu; \n \n for (int j = i + 1; j < M; ++j) {\n bridge_check_dsu.unite(edges[j].u, edges[j].v);\n }\n \n if (!bridge_check_dsu.same(u, v)) {\n // Must take it to maintain connectivity\n fixed_dsu.unite(u, v);\n std::cout << 1 << std::endl;\n continue;\n }\n\n // 3. Monte Carlo Simulation\n // We want to estimate P(edge i is in MST | edge i weight = l_i)\n // An edge (u, v) with weight w is in MST iff there is NO path between u and v\n // consisting entirely of edges with weight < w.\n \n int wins = 0;\n \n // We can pre-filter edges that could possibly be lighter than l_i.\n // Future edge j can be lighter than l_i only if min_possible_weight(j) < l_i.\n // i.e., d_j < l_i.\n std::vector candidates;\n candidates.reserve(M - i);\n for (int j = i + 1; j < M; ++j) {\n if (edges[j].d < l_i) {\n candidates.push_back(j);\n }\n }\n \n for (int t = 0; t < NUM_SIMS; ++t) {\n // Reset simulation DSU to current fixed state\n sim_dsu = fixed_dsu;\n \n // We check if u and v become connected using only future edges lighter than l_i.\n bool connected_via_lighter = false;\n \n // Optimization: We don't need to sort all candidates every time.\n // We just iterate candidates, sample their weight w_j.\n // If w_j < l_i, we unite.\n // If sim_dsu connects u, v, then edge i is NOT needed.\n \n // To optimize further: shuffling candidates allows early exit? \n // No, we need to add ALL edges < l_i. Order doesn't matter for connectivity.\n \n for (int idx : candidates) {\n // Sample weight for edge idx\n // Uniform integer in [d, 3d]\n int d = edges[idx].d;\n int w_j = d + (rng() % (2 * d + 1));\n \n if (w_j < l_i) {\n sim_dsu.unite(edges[idx].u, edges[idx].v);\n if (sim_dsu.same(u, v)) {\n connected_via_lighter = true;\n break;\n }\n }\n }\n \n if (!connected_via_lighter) {\n wins++;\n }\n }\n\n // Decision Rule\n // If the probability that this edge is required in the MST is high, take it.\n // A simple threshold is 0.5.\n if (wins * 2 > NUM_SIMS) {\n fixed_dsu.unite(u, v);\n std::cout << 1 << std::endl;\n } else {\n std::cout << 0 << std::endl;\n }\n }\n\n return 0;\n}","ahc008":"/**\n * AHC008 - Territory\n * Improved Solution\n * \n * Key Fixes:\n * 1. Conflict Resolution: Prevent humans from moving into squares that are being blocked in the same turn.\n * 2. State Tracking: Ensure internal coordinates stay synchronized with the judge.\n * 3. Dynamic Partitioning: Isolate pets efficiently.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants ---\nconst int H = 30;\nconst int W = 30;\nconst int TURNS = 300;\n\n// Directions: 0:Up, 1:Down, 2:Left, 3:Right\nconst int DX[4] = {-1, 1, 0, 0};\nconst int DY[4] = {0, 0, -1, 1};\nconst char MOVE_CHAR[5] = {'U', 'D', 'L', 'R', '.'};\nconst char BLOCK_CHAR[5] = {'u', 'd', 'l', 'r', '.'};\n\n// --- Structs ---\nstruct Point {\n int x, y;\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n int dist(const Point& other) const { return abs(x - other.x) + abs(y - other.y); }\n};\n\nstruct Pet {\n int id;\n int x, y;\n int type;\n};\n\nstruct Human {\n int id;\n int x, y;\n int target_task_id = -1;\n};\n\nstruct Task {\n int id;\n int bx, by; // Block coordinate\n bool completed = false;\n};\n\n// --- Globals ---\nint grid_state[H + 1][W + 1]; // 0: Empty, 1: Blocked\nvector pets;\nvector humans;\nvector tasks;\nint N_PETS, M_HUMANS;\n\n// --- Helpers ---\nbool is_valid(int x, int y) {\n return x >= 1 && x <= H && y >= 1 && y <= W;\n}\n\n// Check if a square can be blocked (Game Rule: No pets in neighbors)\n// Also checks if the square is already blocked.\nbool can_block(int bx, int by, const vector& current_pets) {\n if (!is_valid(bx, by)) return false;\n if (grid_state[bx][by] == 1) return false;\n\n // Rule: Cannot block if adjacent square has a pet\n for (int d = 0; d < 4; ++d) {\n int nx = bx + DX[d];\n int ny = by + DY[d];\n if (is_valid(nx, ny)) {\n for (const auto& p : current_pets) {\n if (p.x == nx && p.y == ny) return false;\n }\n }\n }\n // Rule: Cannot block if square itself has a pet\n for(const auto& p : current_pets) {\n if(p.x == bx && p.y == by) return false;\n }\n return true;\n}\n\n// BFS Pathfinding\n// Returns distance, or 1000 if unreachable\nint get_dist(Point start, Point end, const vector& temp_obstacles = {}) {\n if (start == end) return 0;\n \n // Simple BFS\n // Optimization: Static array for visited/dist to avoid allocation overhead\n // Since H, W is small (30), this is fast.\n static int dist[H+1][W+1];\n for(int i=0; i<=H; ++i) for(int j=0; j<=W; ++j) dist[i][j] = 1000;\n \n queue> q;\n q.push({start.x, start.y});\n dist[start.x][start.y] = 0;\n\n // Mark temp obstacles\n for(auto& p : temp_obstacles) {\n if(is_valid(p.x, p.y)) dist[p.x][p.y] = 9999; // effectively blocked\n }\n\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n int d = dist[cx][cy];\n\n if (cx == end.x && cy == end.y) return d;\n if (d >= 1000) continue; // Should not happen if logic is correct\n\n for (int i = 0; i < 4; ++i) {\n int nx = cx + DX[i];\n int ny = cy + DY[i];\n if (is_valid(nx, ny) && grid_state[nx][ny] == 0) {\n if (dist[nx][ny] == 1000) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n }\n }\n return 1000;\n}\n\n// --- Strategy & Tasks ---\n\n// Simple honeycomb-like structure\n// We will divide the map into small rectangles.\n// Vertical lines every 6, horizontal every 10.\n// Room ID mapping\nint get_room_id(int r, int c) {\n // Rows: 1-10, 11-20, 21-30 (3 sections)\n // Cols: 1-6, 7-12, 13-18, 19-24, 25-30 (5 sections)\n int r_idx = (r - 1) / 10;\n int c_idx = (c - 1) / 6;\n return r_idx * 5 + c_idx;\n}\n\n// Initialize fixed tasks for grid\nvoid generate_tasks_grid() {\n int id_counter = 0;\n \n // Horizontal walls at 10, 20\n vector h_cuts = {10, 20};\n for (int r : h_cuts) {\n for (int c = 1; c <= W; ++c) {\n tasks.push_back({id_counter++, r, c});\n }\n }\n // Vertical walls at 6, 12, 18, 24\n vector v_cuts = {6, 12, 18, 24};\n for (int c : v_cuts) {\n for (int r = 1; r <= H; ++r) {\n // Avoid duplicates if intersection is already added (though simple add is fine, duplicates handled by state check)\n bool exists = false;\n for(const auto& t : tasks) if(t.bx == r && t.by == c) exists = true;\n if(!exists) tasks.push_back({id_counter++, r, c});\n }\n }\n}\n\n// Logic to decide next action for a human\n// Returns a pair: {ActionChar, TargetPoint}\n// ActionChar: 'U'...'R', 'u'...'r', '.'\n// TargetPoint: If move, destination. If block, block coord. If stay, current.\nstruct ActionPlan {\n char c;\n int tx, ty; // Target coordinate (move dest or block dest)\n};\n\nActionPlan plan_human(int h_idx, const vector& current_pets, const vector& current_humans, const vector& planned_blocks) {\n Human& h = humans[h_idx];\n \n // 1. Check current task\n if (h.target_task_id != -1) {\n Task& t = tasks[h.target_task_id];\n // If completed or impossible (already blocked), drop\n if (t.completed || grid_state[t.bx][t.by] == 1) {\n t.completed = true;\n h.target_task_id = -1;\n }\n // Note: We might want to check if \"can_block\" is permanently impossible? \n // Dynamic check happens later.\n }\n\n // 2. Assign new task if needed\n if (h.target_task_id == -1) {\n int best_task = -1;\n int min_dist = 10000;\n\n // We want to prioritize tasks that seal pets.\n // Simple heuristic: Tasks closest to human, but strictly part of the \"Grid\".\n // Also, filter tasks that are definitely safe? No, greedy is okay.\n \n for (int i = 0; i < tasks.size(); ++i) {\n if (tasks[i].completed) continue;\n if (grid_state[tasks[i].bx][tasks[i].by] == 1) {\n tasks[i].completed = true;\n continue;\n }\n \n // Is another human targeting this?\n bool taken = false;\n for (int j = 0; j < M_HUMANS; ++j) {\n if (j != h_idx && humans[j].target_task_id == i) {\n taken = true; \n break;\n }\n }\n if (taken) continue;\n\n // Check distance to valid standing spots\n // Optimization: Just checking dist to block + 1 is a decent heuristic\n int d_val = get_dist({h.x, h.y}, {tasks[i].bx, tasks[i].by});\n // Filter only if reachable\n if (d_val < min_dist) {\n // Check if actually performable (no pets blocking neighbor)\n // This is a \"soft\" check. We might walk there and wait.\n // But if pets are crowding the wall, maybe skip?\n // Let's just pick closest for now.\n min_dist = d_val;\n best_task = i;\n }\n }\n\n if (best_task != -1) {\n h.target_task_id = best_task;\n }\n }\n\n // 3. Execute Task\n if (h.target_task_id != -1) {\n Task& t = tasks[h.target_task_id];\n \n // Are we adjacent to block target?\n int dx = t.bx - h.x;\n int dy = t.by - h.y;\n \n if (abs(dx) + abs(dy) == 1) {\n // Adjacent. Try to block.\n if (can_block(t.bx, t.by, current_pets)) {\n // Ensure we don't block a square containing a human\n bool human_inside = false;\n for(const auto& other : current_humans) if(other.x == t.bx && other.y == t.by) human_inside = true;\n \n if (!human_inside) {\n char act = '.';\n if(dx == -1) act = 'u';\n if(dx == 1) act = 'd';\n if(dy == -1) act = 'l';\n if(dy == 1) act = 'r';\n return {act, t.bx, t.by};\n }\n }\n // If we are adjacent but cannot block (due to pets or human), we should Wait or Re-position?\n // Staying is safer than moving randomly.\n return {'.', h.x, h.y};\n } \n else {\n // Not adjacent, move closer.\n // Target is a neighbor of (t.bx, t.by).\n // Find best neighbor to stand on.\n Point best_spot = {-1, -1};\n int best_spot_dist = 10000;\n \n for(int d=0; d<4; ++d) {\n int nx = t.bx + DX[d];\n int ny = t.by + DY[d];\n if(is_valid(nx, ny) && grid_state[nx][ny] == 0) {\n int d2 = get_dist({h.x, h.y}, {nx, ny}, planned_blocks);\n if(d2 < best_spot_dist) {\n best_spot_dist = d2;\n best_spot = {nx, ny};\n }\n }\n }\n \n if(best_spot.x != -1 && best_spot_dist < 1000) {\n // Move one step towards best_spot\n // Re-run BFS to find first step\n static int dist_map[H+1][W+1];\n for(int r=0;r<=H;++r) for(int c=0;c<=W;++c) dist_map[r][c] = 1000;\n \n queue> q;\n q.push({best_spot.x, best_spot.y});\n dist_map[best_spot.x][best_spot.y] = 0;\n \n // Mark planned blocks as obstacles for pathfinding too\n for(auto& p : planned_blocks) if(is_valid(p.x,p.y)) dist_map[p.x][p.y] = 9999;\n\n while(!q.empty()){\n auto [cx, cy] = q.front(); q.pop();\n if(cx == h.x && cy == h.y) break; // Reached start\n \n for(int i=0; i<4; ++i){\n int nx = cx + DX[i];\n int ny = cy + DY[i];\n if(is_valid(nx, ny) && grid_state[nx][ny] == 0 && dist_map[nx][ny] == 1000){\n dist_map[nx][ny] = dist_map[cx][cy] + 1;\n q.push({nx, ny});\n }\n }\n }\n \n // Find neighbor with distance = dist_map[h]-1\n int current_d = dist_map[h.x][h.y];\n if (current_d >= 1000) return {'.', h.x, h.y}; // Path blocked by temp walls\n\n for(int i=0; i<4; ++i){\n int nx = h.x + DX[i];\n int ny = h.y + DY[i];\n if(is_valid(nx, ny) && dist_map[nx][ny] == current_d - 1) {\n return {MOVE_CHAR[i], nx, ny};\n }\n }\n }\n // No reachable spot\n return {'.', h.x, h.y};\n }\n }\n\n return {'.', h.x, h.y};\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N_PETS;\n pets.resize(N_PETS);\n for (int i = 0; i < N_PETS; ++i) {\n cin >> pets[i].x >> pets[i].y >> pets[i].type;\n pets[i].id = i;\n }\n\n cin >> M_HUMANS;\n humans.resize(M_HUMANS);\n for (int i = 0; i < M_HUMANS; ++i) {\n cin >> humans[i].x >> humans[i].y;\n humans[i].id = i;\n }\n\n // Init Grid\n for(int i=0; i<=H; ++i) for(int j=0; j<=W; ++j) grid_state[i][j] = 0;\n generate_tasks_grid();\n\n for (int turn = 0; turn < TURNS; ++turn) {\n // Identify which tasks are useful.\n // Only prioritize tasks that help seal rooms with pets.\n // (Omitted complex dynamic logic for safety, focusing on correctness first)\n // Simple heuristic: if a task borders a room with pets, keep it.\n // Otherwise, maybe deprioritize? For now, just build the grid. It's robust.\n\n vector plans(M_HUMANS);\n vector planned_blocks;\n\n // 1. Gather intentions\n for(int i=0; i= 'a' && c <= 'z') { // blocking\n planned_blocks.push_back({plans[i].tx, plans[i].ty});\n }\n }\n\n // 2. Conflict Resolution\n // Ensure no human moves into a square that is being blocked this turn.\n for(int i=0; i= 'A' && plans[i].c <= 'Z') { // Moving\n bool conflict = false;\n for(const auto& pb : planned_blocks) {\n if (pb.x == plans[i].tx && pb.y == plans[i].ty) {\n conflict = true;\n break;\n }\n }\n if (conflict) {\n plans[i].c = '.';\n plans[i].tx = humans[i].x;\n plans[i].ty = humans[i].y;\n }\n }\n }\n\n // 3. Output and Internal Update\n string out_str = \"\";\n for(int i=0; i= 'a' && c <= 'z') {\n // Double check validity just in case\n if (can_block(plans[i].tx, plans[i].ty, pets)) {\n grid_state[plans[i].tx][plans[i].ty] = 1;\n // Mark task complete\n for(auto& t : tasks) if(t.bx == plans[i].tx && t.by == plans[i].ty) t.completed = true;\n }\n }\n }\n\n // Apply Moves\n for(int i=0; i= 'A' && c <= 'Z') {\n // Check if destination is valid (not blocked)\n if (grid_state[plans[i].tx][plans[i].ty] == 0) {\n humans[i].x = plans[i].tx;\n humans[i].y = plans[i].ty;\n }\n }\n }\n\n // 4. Read Pets\n for(int i=0; i> move_str;\n for(char c : move_str) {\n if(c == 'U') pets[i].x--;\n else if(c == 'D') pets[i].x++;\n else if(c == 'L') pets[i].y--;\n else if(c == 'R') pets[i].y++;\n }\n }\n }\n\n return 0;\n}","ahc009":"/**\n * AtCoder Heuristic Contest 009\n * Problem: Robust Commuting Route\n * Author: Algorithm Engineer\n * Language: C++20 (gcc 12.2.0)\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// --- Fast IO ---\nvoid fast_io() {\n std::ios_base::sync_with_stdio(false);\n std::cin.tie(NULL);\n}\n\n// --- Constants ---\nconstexpr int H = 20;\nconstexpr int W = 20;\nconstexpr int MAX_STEPS = 200;\nconstexpr int MAX_BEAM_WIDTH = 100; // Increased from 15\nconstexpr double TIME_LIMIT = 1.95; // Seconds\n\n// Direction mappings: 0:U, 1:D, 2:L, 3:R\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dc_char[] = {'U', 'D', 'L', 'R'};\n\n// --- Globals ---\nstruct Point { int r, c; };\nPoint start_pos, target_pos;\ndouble p_fail;\n// Walls: 1 if wall exists, 0 otherwise\nint h_walls[H][W]; // h_walls[i][j] between (i,j) and (i,j+1)\nint v_walls[H][W]; // v_walls[i][j] between (i,j) and (i+1,j)\nint dist_to_target[H][W]; // BFS distance\n\n// --- Timer ---\nstruct Timer {\n std::chrono::high_resolution_clock::time_point start_time;\n Timer() { reset(); }\n void reset() { start_time = std::chrono::high_resolution_clock::now(); }\n double elapsed() {\n auto now = std::chrono::high_resolution_clock::now();\n return std::chrono::duration(now - start_time).count();\n }\n} timer;\n\n// --- Random ---\nstd::mt19937 rng(12345);\ndouble rand_double() {\n return std::uniform_real_distribution(0.0, 1.0)(rng);\n}\nint rand_int(int l, int r) {\n return std::uniform_int_distribution(l, r)(rng);\n}\n\n// --- Helper Functions ---\n\n// Returns next position given current pos and direction. Handles walls/bounds.\ninline Point get_next_pos(int r, int c, int dir) {\n int nr = r + dr[dir];\n int nc = c + dc[dir];\n if (nr < 0 || nr >= H || nc < 0 || nc >= W) return {r, c}; // Boundary\n if (dir == 0) { // U\n if (v_walls[nr][c]) return {r, c};\n } else if (dir == 1) { // D\n if (v_walls[r][c]) return {r, c};\n } else if (dir == 2) { // L\n if (h_walls[r][nc]) return {r, c};\n } else if (dir == 3) { // R\n if (h_walls[r][c]) return {r, c};\n }\n return {nr, nc};\n}\n\nvoid bfs_distances() {\n for (int i = 0; i < H; ++i)\n for (int j = 0; j < W; ++j)\n dist_to_target[i][j] = 1e9;\n\n std::queue q;\n dist_to_target[target_pos.r][target_pos.c] = 0;\n q.push(target_pos);\n\n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n for (int d = 0; d < 4; ++d) {\n // Reverse logic: check neighbors that can reach curr\n int pr = curr.r - dr[d];\n int pc = curr.c - dc[d];\n if (pr >= 0 && pr < H && pc >= 0 && pc < W) {\n Point next_of_prev = get_next_pos(pr, pc, d);\n if (next_of_prev.r == curr.r && next_of_prev.c == curr.c) {\n if (dist_to_target[pr][pc] > dist_to_target[curr.r][curr.c] + 1) {\n dist_to_target[pr][pc] = dist_to_target[curr.r][curr.c] + 1;\n q.push({pr, pc});\n }\n }\n }\n }\n }\n}\n\n// --- Beam Search Structures ---\n\nstruct State {\n double probs[H][W];\n std::string moves;\n double expected_score;\n \n // Auxiliary for heuristic\n double prob_sum; // Sum of probabilities remaining on grid\n double weighted_dist; // Sum of prob * dist\n\n State() {\n std::memset(probs, 0, sizeof(probs));\n probs[start_pos.r][start_pos.c] = 1.0;\n moves = \"\";\n expected_score = 0.0;\n prob_sum = 1.0;\n weighted_dist = dist_to_target[start_pos.r][start_pos.c];\n }\n\n // Heuristic for sorting: \n // We want high expected score and low remaining distance.\n double eval() const {\n // weighted_dist is sum(p * dist).\n // expected_score is accumulating.\n // If we just use expected_score, the agent might not move towards goal if it's far.\n // If we just use weighted_dist, it ignores probability of failure accumulating.\n // A simple combo is: expected_score - coeff * weighted_dist\n return expected_score - 0.5 * weighted_dist;\n }\n \n bool operator<(const State& other) const {\n return eval() < other.eval();\n }\n};\n\nvoid advance_state(const State& prev, State& next, int dir) {\n // Initialize next from prev basics\n next.moves = prev.moves + dc_char[dir];\n next.expected_score = prev.expected_score;\n std::memset(next.probs, 0, sizeof(next.probs));\n \n double newly_reached = 0.0;\n int current_step = (int)next.moves.length(); // 1-based step index for scoring?\n // Problem: \"S = 401 - t if he gets to office after t turns\"\n // So if we reach at step K, score adds prob * (401 - K).\n \n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n double p = prev.probs[r][c];\n if (p < 1e-8) continue;\n\n // Stay probability\n double p_stay = p * p_fail;\n // Move probability\n double p_move = p * (1.0 - p_fail);\n\n // 1. Stay\n // If current cell is target, mass is already gone (handled in previous steps),\n // but our representation keeps probs active until they reach target.\n // If we are at target? No, mass is removed upon reaching.\n // So we only process r,c != target.\n \n // Stay at r,c\n next.probs[r][c] += p_stay;\n\n // 2. Move\n Point nxt = get_next_pos(r, c, dir);\n if (nxt.r == target_pos.r && nxt.c == target_pos.c) {\n newly_reached += p_move;\n } else {\n next.probs[nxt.r][nxt.c] += p_move;\n }\n }\n }\n \n // Update score\n if (newly_reached > 0) {\n next.expected_score += newly_reached * (401 - current_step);\n }\n \n // Recalculate heuristic info\n next.prob_sum = 0.0;\n next.weighted_dist = 0.0;\n for (int r = 0; r < H; ++r) {\n for (int c = 0; c < W; ++c) {\n if (next.probs[r][c] > 1e-8) {\n next.prob_sum += next.probs[r][c];\n next.weighted_dist += next.probs[r][c] * dist_to_target[r][c];\n }\n }\n }\n}\n\n// --- Simulation / DP for Optimization ---\n// We need a fast way to evaluate a full string.\n// We can keep the DP state (probability distribution) at each step.\n// When we change the string at index i, we only recompute from i.\n\nstruct DPSolver {\n // Stores probability distributions for each step [0...L]\n // step_probs[t][r][c]\n // To save memory and time, we can use a flat vector of (r, c, p) for sparse cells,\n // but dense grid is small (400 doubles). 200 steps * 400 doubles = 80000 doubles = 640KB. Cheap.\n \n double dp[MAX_STEPS + 1][H][W];\n std::string commands;\n double current_score;\n int length;\n\n void init(const std::string& s) {\n commands = s;\n length = s.length();\n // Init step 0\n std::memset(dp, 0, sizeof(dp));\n dp[0][start_pos.r][start_pos.c] = 1.0;\n \n // Compute all\n current_score = 0;\n recompute(0);\n }\n\n // Recompute DP from step `start_step` to end\n void recompute(int start_step) {\n // Reset score accumulator for parts we are about to recompute?\n // Actually, score is global. It's easier to recompute score from scratch \n // or track partial sums. Let's recompute score entirely for simplicity \n // but reuse DP states before start_step.\n \n // Recover score from steps 0 to start_step\n // The score contribution at step t (1-based) happens during transition (t-1) -> t.\n // So we need to sum contributions.\n \n double score = 0;\n // Add pre-calculated score? No, let's just recalculate full score for safety,\n // but only run DP updates from start_step.\n // To do this efficiently, we need stored partial scores or just run the loop.\n // Given L=200, linear scan for score is tiny.\n \n // However, we must re-run DP transitions.\n for (int t = start_step; t < length; ++t) {\n // Transition from t -> t+1\n int dir = -1;\n char c = commands[t];\n if (c == 'U') dir = 0;\n else if (c == 'D') dir = 1;\n else if (c == 'L') dir = 2;\n else if (c == 'R') dir = 3;\n\n // Clear next step\n // Use memset for speed?\n // std::memset(dp[t+1], 0, sizeof(dp[t+1])); \n // Memset is byte-wise. 0.0 double is all 0 bytes. Safe.\n // But only clearing used area is faster? H*W is small.\n std::memset(dp[t+1], 0, sizeof(double) * H * W);\n\n double newly_reached = 0;\n \n for (int r = 0; r < H; ++r) {\n for (int c_idx = 0; c_idx < W; ++c_idx) { // c is taken by char c\n double val = dp[t][r][c_idx];\n if (val < 1e-9) continue;\n\n // Stay\n double p_stay = val * p_fail;\n dp[t+1][r][c_idx] += p_stay;\n\n // Move\n double p_move = val * (1.0 - p_fail);\n Point nxt = get_next_pos(r, c_idx, dir);\n \n if (nxt.r == target_pos.r && nxt.c == target_pos.c) {\n newly_reached += p_move;\n } else {\n dp[t+1][nxt.r][nxt.c] += p_move;\n }\n }\n }\n // Add score for this step (t+1)\n // score += newly_reached * (401 - (t + 1)); \n // We can't sum it here easily if we want to support partial recompute.\n // Let's store step_score[t+1] in an array?\n }\n \n // Calculate total score\n // We need to re-run transitions to get `newly_reached`.\n // The above loop does exactly that.\n // So we can sum score inside.\n \n // BUT: If we only recompute from start_step, we need the score from before.\n // Let's store cumulative score or step-wise score.\n // Or simply: The loop runs from start_step.\n // But we need the score from 0 to start_step.\n // Optimization: keep step_rewards array.\n }\n \n // Full re-evaluation with optimized return\n double evaluate() {\n std::memset(dp, 0, sizeof(dp));\n dp[0][start_pos.r][start_pos.c] = 1.0;\n \n double total_score = 0;\n \n for (int t = 0; t < length; ++t) {\n int dir = 0;\n char c = commands[t];\n if (c == 'U') dir = 0;\n else if (c == 'D') dir = 1;\n else if (c == 'L') dir = 2;\n else if (c == 'R') dir = 3;\n \n double newly_reached = 0;\n \n // Manual loop unrolling or optimization? Compiler does well.\n // To speed up: track active bounding box? Maybe overkill.\n \n for (int r = 0; r < H; ++r) {\n for (int col = 0; col < W; ++col) {\n double val = dp[t][r][col];\n if (val < 1e-9) continue;\n\n // Stay\n dp[t+1][r][col] += val * p_fail;\n\n // Move\n Point nxt = get_next_pos(r, col, dir);\n if (nxt.r == target_pos.r && nxt.c == target_pos.c) {\n newly_reached += val * (1.0 - p_fail);\n } else {\n dp[t+1][nxt.r][nxt.c] += val * (1.0 - p_fail);\n }\n }\n }\n total_score += newly_reached * (401 - (t + 1));\n }\n return total_score;\n }\n \n // Evaluate with partial update support\n // We keep a persistent DP table.\n // This is risky if we reject a move and need to rollback.\n // Strategy:\n // 1. Make a copy of current best commands.\n // 2. Apply mutation.\n // 3. Run full evaluate (it's fast enough: 200*400 = 80k ops, 20k iters possible).\n // Partial update logic is complex to implement bug-free in contest time.\n // Full update is safer.\n};\n\n\nint main() {\n fast_io();\n\n // Input\n if (!(std::cin >> start_pos.r >> start_pos.c >> target_pos.r >> target_pos.c >> p_fail)) return 0;\n \n for (int i = 0; i < H; ++i) {\n std::string row; std::cin >> row;\n for (int j = 0; j < W - 1; ++j) h_walls[i][j] = (row[j] == '1');\n }\n for (int i = 0; i < H - 1; ++i) {\n std::string row; std::cin >> row;\n for (int j = 0; j < W; ++j) v_walls[i][j] = (row[j] == '1');\n }\n\n bfs_distances();\n\n // --- Phase 1: Beam Search ---\n // Generate a good initial solution\n std::vector beam;\n beam.push_back(State());\n\n for (int t = 0; t < MAX_STEPS; ++t) {\n // Check time\n if (timer.elapsed() > TIME_LIMIT * 0.6) break; // Reserve time for SA\n\n std::vector next_candidates;\n // Simple heuristic to avoid huge vector resizing\n next_candidates.reserve(beam.size() * 4);\n\n for (const auto& s : beam) {\n // Pruning: if prob sum is very low, stop expanding?\n if (s.prob_sum < 1e-4) {\n next_candidates.push_back(s);\n continue;\n }\n\n for (int d = 0; d < 4; ++d) {\n State next_s = s; // Copy\n advance_state(s, next_s, d);\n next_candidates.push_back(next_s);\n }\n }\n\n // Sort and prune\n if (next_candidates.empty()) break;\n \n // Partial sort to keep top K\n int k = std::min((int)next_candidates.size(), MAX_BEAM_WIDTH);\n // Use nth_element to get top K in O(N)\n std::nth_element(next_candidates.begin(), next_candidates.begin() + k, next_candidates.end(), \n [](const State& a, const State& b) {\n return a.eval() > b.eval(); // Descending\n });\n \n next_candidates.resize(k);\n beam = std::move(next_candidates);\n }\n\n // Pick best from beam\n std::string best_str = \"\";\n double best_score = -1.0;\n for (const auto& s : beam) {\n if (s.expected_score > best_score) {\n best_score = s.expected_score;\n best_str = s.moves;\n }\n }\n\n // If beam search finished early (due to probability mass depletion), fill with random or stay?\n // Usually we just output what we have.\n\n // --- Phase 2: Hill Climbing / Simulated Annealing ---\n // We have `best_str` of length `L`. We can extend it up to 200.\n // Or shrink it.\n \n DPSolver solver;\n // Initial padding if short\n while (best_str.length() < MAX_STEPS) {\n // Pad with random moves or just last direction?\n // Pad with random legal moves towards target roughly?\n // For now, just don't pad blindly, SA can insert.\n // Actually SA works better with fixed length or mutations.\n // Let's just append 'D' or similar dummy. Or keep it short.\n // Problem says output string <= 200.\n break;\n }\n \n solver.init(best_str);\n best_score = solver.evaluate(); // Re-verify score\n \n std::string curr_str = best_str;\n double curr_score = best_score;\n\n // Annealing parameters\n double T0 = 2.0;\n double T1 = 0.0;\n int iter = 0;\n \n while (true) {\n iter++;\n if ((iter & 255) == 0) {\n if (timer.elapsed() > TIME_LIMIT) break;\n }\n\n // Mutation\n // 1. Change char\n // 2. Insert char (if len < 200) -> Shift right? Expensive to shift? String handles it.\n // 3. Delete char (if len > 1)\n // 4. Swap adjacent?\n \n int type = rand_int(0, 2); // 0: Change, 1: Delete, 2: Insert\n if (curr_str.length() >= MAX_STEPS) type = rand_int(0, 1); // No insert\n if (curr_str.length() <= 1) type = rand_int(0, 0); // Only change? Or insert.\n if (curr_str.length() <= 1 && type == 1) type = 2; // Force insert\n\n std::string next_str = curr_str;\n \n if (type == 0) { // Change\n int idx = rand_int(0, (int)next_str.length() - 1);\n next_str[idx] = dc_char[rand_int(0, 3)];\n } else if (type == 1) { // Delete\n int idx = rand_int(0, (int)next_str.length() - 1);\n next_str.erase(next_str.begin() + idx);\n } else { // Insert\n int idx = rand_int(0, (int)next_str.length()); // Can insert at end\n char c = dc_char[rand_int(0, 3)];\n next_str.insert(next_str.begin() + idx, c);\n }\n \n // Evaluate\n solver.commands = next_str;\n solver.length = next_str.length();\n double new_score = solver.evaluate();\n \n // Accept logic\n // We are maximizing score.\n double delta = new_score - curr_score;\n double temp = T0 + (T1 - T0) * (timer.elapsed() / TIME_LIMIT);\n \n // Standard SA probability: exp(delta / T)\n // Since scores are large (e.g. 50e6), we need to scale delta or T.\n // Expected score is sum of PROBABILITIES * Score.\n // One small change changes prob by e.g. 0.01. Score change ~ 0.01 * 200 = 2.0.\n // So T should be around 1.0 to 10.0.\n \n bool accept = false;\n if (delta > 0) accept = true;\n else {\n // Only accept bad moves if T > 0\n if (temp > 1e-4 && std::exp(delta / temp) > rand_double()) {\n accept = true;\n }\n }\n \n if (accept) {\n curr_str = next_str;\n curr_score = new_score;\n if (curr_score > best_score) {\n best_score = curr_score;\n best_str = curr_str;\n }\n }\n }\n\n std::cout << best_str << std::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// -----------------------------------------------------------------------------\n// Constants\n// -----------------------------------------------------------------------------\nconst int N = 30;\n\n// Directions: 0:Left, 1:Up, 2:Right, 3:Down\nconst int DL[] = {0, -1, 0, 1}; // di (changes in row)\nconst int DC[] = {-1, 0, 1, 0}; // dj (changes in col)\nconst int OPP[] = {2, 3, 0, 1}; // Opposite directions\n\n// Connection Tables\n// BASE_TO[tile_type][entry_local_dir] = exit_local_dir (-1 if none)\nint BASE_TO[8][4];\n\n// -----------------------------------------------------------------------------\n// Globals for State\n// -----------------------------------------------------------------------------\nint T[N][N]; // Tile Types (Fixed)\nint R[N][N]; // Rotations (0..3)\n\n// Optimization: Use a visitation token instead of memset\nint visited_token[N][N][4];\nint current_token = 0;\n\n// -----------------------------------------------------------------------------\n// Setup\n// -----------------------------------------------------------------------------\nvoid init_tables() {\n memset(BASE_TO, -1, sizeof(BASE_TO));\n // Type 0: Left-Up (in local coords: Left=0, Up=1, Right=2, Down=3)\n // Note: Problem definition of local dirs might differ, let's stick to standard:\n // 0:Left, 1:Up, 2:Right, 3:Down\n \n // 0: Corner (Left <> Up)\n BASE_TO[0][0] = 1; BASE_TO[0][1] = 0;\n // 1: Corner (Up <> Right)\n BASE_TO[1][1] = 2; BASE_TO[1][2] = 1;\n // 2: Corner (Right <> Down)\n BASE_TO[2][2] = 3; BASE_TO[2][3] = 2;\n // 3: Corner (Down <> Left)\n BASE_TO[3][3] = 0; BASE_TO[3][0] = 3;\n \n // 4: Left <> Up, Right <> Down\n BASE_TO[4][0] = 1; BASE_TO[4][1] = 0; BASE_TO[4][2] = 3; BASE_TO[4][3] = 2;\n \n // 5: Left <> Down, Up <> Right\n BASE_TO[5][0] = 3; BASE_TO[5][3] = 0; BASE_TO[5][1] = 2; BASE_TO[5][2] = 1;\n \n // 6: Straight (Left <> Right)\n BASE_TO[6][0] = 2; BASE_TO[6][2] = 0;\n \n // 7: Straight (Up <> Down)\n BASE_TO[7][1] = 3; BASE_TO[7][3] = 1;\n}\n\n// -----------------------------------------------------------------------------\n// Logic\n// -----------------------------------------------------------------------------\n\n// Get exit direction.\n// entry_dir is GLOBAL direction (0:Left, 1:Up, 2:Right, 3:Down) entering (r,c).\n// Returns GLOBAL exit direction or -1.\ninline int get_exit(int type, int rot, int enter_dir) {\n // Transform global entry to local entry based on rotation.\n // CCW Rotation logic:\n // Rot 0: Local matches Global.\n // Rot 1 (90 CCW): Local 0 (Left) is now pointing Global Down (3).\n // No, let's visualize:\n // Tile 0 (Left-Up). Rot 0.\n // If we enter from Left (Global 0), we are entering Local Left?\n // Actually, usually \"Rotation\" transforms the tile features.\n // If we rotate the tile 90 CCW, the feature at \"Local Left\" moves to \"Global Down\".\n // So, \"Global Up\" corresponds to \"Local Right\" (since Right rotated 90 CCW is Up).\n // Relation: Global = (Local + Rot) % 4\n // Inverse: Local = (Global - Rot + 4) % 4\n \n int local_in = (enter_dir - rot + 4) & 3;\n int local_out = BASE_TO[type][local_in];\n \n if (local_out == -1) return -1;\n \n return (local_out + rot) & 3;\n}\n\n// Check if two adjacent tiles are connected.\n// (r1,c1) --dir--> (r2,c2)\n// Returns true if the line leaving (r1,c1) in direction `dir` \n// successfully enters (r2,c2) and finds a valid path inside (r2,c2).\ninline bool is_connected(int r1, int c1, int dir) {\n // 1. Check outgoing from r1,c1\n // We need to find WHICH port on (r1,c1) connects to `dir`.\n // Actually, we usually trace paths.\n // But for local connection score:\n // Does (r1,c1) have a line segment pointing to `dir`?\n // We can check this by seeing if entering from `dir`'s opposite is valid.\n // Wait, if we leave (r1,c1) towards `dir`, we are entering `dir`'s opposite port of (r1,c1).\n // No, \"leaving towards dir\".\n // Let's simplify: does (r1,c1) connect to (r2,c2)?\n // This means the boundary is consistent.\n // (r1,c1) has a port at `dir`.\n // (r2,c2) has a port at `OPP[dir]`.\n \n // Check (r1,c1) port at `dir`:\n // This is equivalent to saying: if we entered from OPP[dir], is there a valid exit?\n // Or simply check the tile definition manually.\n // Let's use get_exit trick: if we enter from OPP[dir], do we get non -1?\n // Or simpler: does the tile shape have a connection at local direction corresponding to `dir`?\n \n int local_port_1 = (dir - R[r1][c1] + 4) & 3;\n // In our BASE_TO definition, if BASE_TO[type][p] != -1, then port p exists.\n bool has_port_1 = (BASE_TO[T[r1][c1]][local_port_1] != -1);\n \n int r2 = r1 + DL[dir];\n int c2 = c1 + DC[dir];\n if (r2 < 0 || r2 >= N || c2 < 0 || c2 >= N) return false; // Boundary\n \n int dir_2 = OPP[dir]; // The side of (r2,c2) facing (r1,c1)\n int local_port_2 = (dir_2 - R[r2][c2] + 4) & 3;\n bool has_port_2 = (BASE_TO[T[r2][c2]][local_port_2] != -1);\n \n return has_port_1 && has_port_2;\n}\n\nstruct ScoreInfo {\n double objective;\n long long real_score;\n};\n\nvector loop_lengths;\n// Scratchpad for evaluate\n// We need to track start positions to distinguish loops\n// Max possible path length is 30*30*2 approx 1800.\n\nScoreInfo evaluate(bool fast_mode = false) {\n loop_lengths.clear();\n current_token++; \n // If wrapped around (very rare), reset array\n if (current_token == 0) {\n memset(visited_token, 0, sizeof(visited_token));\n current_token = 1;\n }\n\n int total_connections = 0; // Number of matching interfaces between tiles\n // Calculate local connectivity score (heuristic for \"potential\")\n // This is O(N^2)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n // Check Right\n if (j + 1 < N) {\n if (is_connected(i, j, 2)) total_connections++;\n }\n // Check Down\n if (i + 1 < N) {\n if (is_connected(i, j, 3)) total_connections++;\n }\n }\n }\n \n // Path tracing to find loops\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n for (int d = 0; d < 4; ++d) {\n if (visited_token[i][j][d] == current_token) continue;\n \n // Check if this port even exists on this tile\n // To do this, we simulate entering from the opposite side? \n // No, we want to start a path leaving (i,j) in direction d.\n // This implies we \"entered\" (i,j) from OPP[d].\n // If get_exit returns -1, this path segment doesn't exist inside the tile.\n // Wait, if we iterate all (i,j,d), we cover all segments.\n // The standard loop logic:\n // Pick a \"start\" of a line. A line is defined by a connection between tiles.\n // If (i,j) connects to (i',j') via d, start tracing.\n // But we must ensure we don't double count.\n \n // Better approach: Iterate all possible \"entries\" to a tile.\n // Let's consider \"entering (i,j) from d\".\n // If already visited, skip.\n // If valid internal path, trace it.\n \n int out_dir = get_exit(T[i][j], R[i][j], d);\n if (out_dir == -1) {\n visited_token[i][j][d] = current_token; // Mark as visited/invalid\n continue;\n }\n \n // Valid path exists inside tile (i,j) from d to out_dir.\n // Start tracing.\n int curr_r = i, curr_c = j, curr_in = d;\n int start_r = i, start_c = j, start_in = d;\n \n int len = 0;\n bool is_cycle = false;\n \n while (true) {\n visited_token[curr_r][curr_c][curr_in] = current_token;\n \n int exit_d = get_exit(T[curr_r][curr_c], R[curr_r][curr_c], curr_in);\n // exit_d shouldn't be -1 here because we check before entering loop or continued\n \n // Mark the reverse direction (entering from exit_d's neighbor is equivalent to leaving towards it)\n // Actually, marking (r,c,in) is enough to block re-entry from same side.\n // But for cycle detection, we just follow.\n \n // Move to next tile\n int next_r = curr_r + DL[exit_d];\n int next_c = curr_c + DC[exit_d];\n int next_in = OPP[exit_d]; // Enter neighbor from opposite of exit\n \n // 1. Check Bounds\n if (next_r < 0 || next_r >= N || next_c < 0 || next_c >= N) {\n // Hit wall\n break;\n }\n \n // 2. Check if neighbor accepts connection\n // We are trying to enter (next_r, next_c) from next_in.\n // Does it have an exit?\n int next_out = get_exit(T[next_r][next_c], R[next_r][next_c], next_in);\n if (next_out == -1) {\n // Dead end (broken line)\n break;\n }\n \n len++;\n \n // 3. Check Cycle\n if (next_r == start_r && next_c == start_c && next_in == start_in) {\n is_cycle = true;\n break;\n }\n \n // 4. Check Collision (Merge with already visited path)\n if (visited_token[next_r][next_c][next_in] == current_token) {\n // Merged into a previously processed path (which wasn't this one, or we would have hit start check)\n // Not a new cycle for us.\n break;\n }\n \n curr_r = next_r;\n curr_c = next_c;\n curr_in = next_in;\n }\n \n // Note: The problem definition of length is \"number of times to move to adjacent tile\".\n // Our len increments on move. If cycle closes, we moved from last tile back to start.\n // That last move is the one that triggers `next_r == start_r`.\n // So we must increment len one last time?\n // Let's trace:\n // Start inside (0,0). Move to (0,1) -> len=1.\n // ... Move to (0,0) from correct dir -> len=K.\n // The check `if (next == start)` happens *before* we increment len?\n // No, in the code above:\n // ... move logic ...\n // len++;\n // if (next == start) break;\n // So yes, the closing move is counted.\n \n if (is_cycle) {\n loop_lengths.push_back(len);\n }\n \n // Optimization: If we are looking for only very long loops, we could abort short ones.\n // But accurate scoring needs all.\n }\n }\n }\n \n long long L1 = 0, L2 = 0;\n double sq_sum = 0;\n if (!loop_lengths.empty()) {\n sort(loop_lengths.rbegin(), loop_lengths.rend());\n L1 = loop_lengths[0];\n if (loop_lengths.size() > 1) L2 = loop_lengths[1];\n \n for(int l : loop_lengths) sq_sum += (double)l * l;\n }\n \n long long real_score = L1 * L2;\n \n // Construction of Heuristic Objective\n // Weights\n double W_MAIN = 10000.0;\n double W_SQ = 1.0; // Prefer few large loops\n double W_CONN = 5.0; // Local connectivity density\n \n // If real score > 0, we focus heavily on it.\n // If real score == 0, we rely on heuristics to guide us there.\n \n double obj = 0;\n obj += real_score * W_MAIN;\n obj += sq_sum * W_SQ;\n obj += total_connections * W_CONN;\n \n return {obj, real_score};\n}\n\n// -----------------------------------------------------------------------------\n// Simulated Annealing\n// -----------------------------------------------------------------------------\n\nint main() {\n // Setup\n init_tables();\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Input\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c; cin >> c;\n T[i][j] = c - '0';\n }\n }\n \n // RNG\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist_N(0, N - 1);\n uniform_int_distribution dist_rot(0, 3);\n uniform_real_distribution dist_01(0.0, 1.0);\n \n // Initial State: Random\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n R[i][j] = dist_rot(rng);\n }\n }\n \n ScoreInfo current = evaluate();\n \n // Best Tracking\n int best_R[N][N];\n memcpy(best_R, R, sizeof(R));\n long long best_real = current.real_score;\n double best_obj = current.objective;\n \n // Time Control\n auto start_time = chrono::steady_clock::now();\n double time_limit = 1.980; // slightly safer margin\n \n // SA Params\n double T0 = 200.0;\n double T1 = 0.01;\n double temp = T0;\n \n int iterations = 0;\n \n // Optimization: Track \"stagnation\" to kickstart if needed?\n // For short contests, simple SA is usually better than complex restart logic unless trapped often.\n \n while (true) {\n iterations++;\n if ((iterations & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n // Temperature Update\n double progress = elapsed / time_limit;\n temp = T0 * pow(T1 / T0, progress);\n }\n \n // Move: Rotate one tile\n int r = dist_N(rng);\n int c = dist_N(rng);\n int old_rot = R[r][c];\n \n // Try a different rotation\n // Instead of random jump, maybe try just +1/-1? \n // Random jump is fine since domain is size 4.\n int new_rot = (old_rot + 1 + (rng() % 3)) % 4;\n \n R[r][c] = new_rot;\n \n ScoreInfo next = evaluate();\n \n double delta = next.objective - current.objective;\n \n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n if (dist_01(rng) < exp(delta / temp)) {\n accept = true;\n }\n }\n \n if (accept) {\n current = next;\n \n // Update Global Best\n // Priority: Real Score > Objective Score\n if (current.real_score > best_real) {\n best_real = current.real_score;\n best_obj = current.objective;\n memcpy(best_R, R, sizeof(R));\n } else if (current.real_score == best_real) {\n if (current.objective > best_obj) {\n best_obj = current.objective;\n memcpy(best_R, R, sizeof(R));\n }\n }\n } else {\n // Revert\n R[r][c] = old_rot;\n }\n }\n \n // Output Best\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << best_R[i][j];\n }\n }\n cout << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nint N, T_MAX;\nint start_board[10][10];\nint target_board[10][10];\nint tile_counts[16];\nint tile_counts_backup[16];\nmt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());\n\nconst int DR[] = {0, -1, 0, 1}; // L, U, R, D\nconst int DC[] = {-1, 0, 1, 0};\nconst char DCHAR[] = {'L', 'U', 'R', 'D'};\nconst int OPP[] = {2, 3, 0, 1};\n\nstruct Point { \n int r, c; \n bool operator==(const Point& p) const { return r==p.r && c==p.c; } \n bool operator!=(const Point& p) const { return !(*this==p); }\n bool operator<(const Point& p) const { if(r!=p.r) return r 0) && (cur_target[r-1][c] & 8);\n bool need_left = (c > 0) && (cur_target[r][c-1] & 4);\n\n vector candidates;\n candidates.reserve(16);\n for(int t=0; t<16; ++t) {\n if (cur_counts[t] > 0 && t != 0) candidates.push_back(t);\n }\n shuffle(candidates.begin(), candidates.end(), rng);\n\n UndoDSU saved_dsu = dsu_state;\n\n for (int t : candidates) {\n bool has_up = (t & 2);\n bool has_left = (t & 1);\n bool has_right = (t & 4);\n bool has_down = (t & 8);\n\n if (need_up != has_up) continue;\n if (need_left != has_left) continue;\n\n if (r == 0 && has_up) continue;\n if (c == 0 && has_left) continue;\n if (r == N - 1 && has_down) continue;\n if (c == N - 1 && has_right) continue;\n\n bool cycle = false;\n dsu_state = saved_dsu; \n \n if (has_up) {\n if (!dsu_state.unite(idx, idx - N)) cycle = true;\n }\n if (!cycle && has_left) {\n if (!dsu_state.unite(idx, idx - 1)) cycle = true;\n }\n\n if (cycle) continue;\n\n cur_target[r][c] = t;\n cur_counts[t]--;\n\n if (generate_target(idx + 1)) return true;\n\n cur_counts[t]++;\n }\n \n dsu_state = saved_dsu;\n return false;\n}\n\n// --- Solver ---\nstring solution_moves = \"\";\nint board_ids[10][10]; // Tracks ID of tile at (r,c)\nint board_types[10][10]; // Tracks type\nPoint empty_pos;\n\nvoid apply_move_internal(char m) {\n solution_moves += m;\n int d = -1;\n if (m=='L') d=0; else if(m=='U') d=1; else if(m=='R') d=2; else if(m=='D') d=3;\n \n int nr = empty_pos.r + DR[d];\n int nc = empty_pos.c + DC[d];\n swap(board_ids[empty_pos.r][empty_pos.c], board_ids[nr][nc]);\n swap(board_types[empty_pos.r][empty_pos.c], board_types[nr][nc]);\n empty_pos = {nr, nc};\n}\n\nPoint find_id(int id) {\n for(int r=0; r> fixed(N, vector(N, false));\n \n // Assignment logic\n struct Assign { int r, c; };\n vector assignment[16];\n for(int r=0; r target_to_source;\n vector used_source(N*N, false);\n \n // Initial Greedy Assignment\n for(int t=0; t<16; ++t) {\n vector sources;\n for(int r=0; r target_ids(N*N);\n int start_empty_id = -1;\n for(int r=0; r target_ids[j]) inversions++;\n }\n }\n \n // Empty dist\n // Current empty is at (r,c) for id start_empty_id\n // Target empty is at (N-1, N-1)\n int sr=-1, sc=-1;\n for(int r=0; r= 2) {\n Point p1 = {assignment[t][0].r, assignment[t][0].c};\n Point p2 = {assignment[t][1].r, assignment[t][1].c};\n Point s1 = target_to_source[p1];\n Point s2 = target_to_source[p2];\n target_to_source[p1] = s2;\n target_to_source[p2] = s1;\n swapped = true;\n break;\n }\n }\n if (!swapped) {\n // Should not happen for N >= 6\n }\n }\n\n // Helper to bring tile\n auto bring_id = [&](int id, int tr, int tc, vector>& fixed_ref) {\n while(true) {\n Point p = find_id(id);\n if (p.r == tr && p.c == tc) break;\n \n // BFS for tile\n queue q; q.push(p);\n vector> pdir(N, vector(N, -1));\n vector> vis(N, vector(N, false));\n vis[p.r][p.c] = true;\n bool found = false;\n while(!q.empty()){\n Point curr = q.front(); q.pop();\n if(curr.r == tr && curr.c == tc) { found=true; break; }\n for(int d=0; d<4; ++d){\n int nr = curr.r + DR[d], nc = curr.c + DC[d];\n if(nr>=0 && nr=0 && nc qe; qe.push(empty_pos);\n vector> edir(N, vector(N, -1));\n vector> evis(N, vector(N, false));\n evis[empty_pos.r][empty_pos.c] = true;\n bool efound = false;\n while(!qe.empty()){\n Point curr = qe.front(); qe.pop();\n if(curr.r == target_empty_r && curr.c == target_empty_c) { efound = true; break; }\n for(int d=0; d<4; ++d){\n int nr = curr.r + DR[d], nc = curr.c + DC[d];\n if(nr>=0 && nr=0 && nc>& fixed_ref) {\n while(empty_pos.r != tr || empty_pos.c != tc) {\n queue qe; qe.push(empty_pos);\n vector> edir(N, vector(N, -1));\n vector> evis(N, vector(N, false));\n evis[empty_pos.r][empty_pos.c] = true;\n bool efound = false;\n while(!qe.empty()){\n Point curr = qe.front(); qe.pop();\n if(curr.r == tr && curr.c == tc) { efound=true; break; }\n for(int d=0; d<4; ++d){\n int nr = curr.r + DR[d], nc = curr.c + DC[d];\n if(nr>=0 && nr=0 && nc= N-2 && nr < N && nc >= N-2 && nc < N) {\n apply_move_internal(DCHAR[d]);\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N >> T_MAX;\n for(int i=0; i> row;\n for(int j=0; j= '0' && row[j] <= '9') val = row[j] - '0';\n else val = row[j] - 'a' + 10;\n start_board[i][j] = val;\n board_types[i][j] = val;\n board_ids[i][j] = i*N+j;\n if (val == 0) empty_pos = {i, j};\n tile_counts[val]++;\n }\n }\n \n // Must use specific tile count for target gen. 0 is special.\n tile_counts[0] = 1; \n for(int i=0; i<16; ++i) tile_counts_backup[i] = tile_counts[i];\n\n // Generate valid target\n // Retry loop\n while(true) {\n for(int i=0; i<16; ++i) cur_counts[i] = tile_counts_backup[i];\n dsu_state = UndoDSU();\n // Force empty to be at (N-1, N-1) for target\n cur_counts[0]--; // Reserve\n \n if (generate_target(0)) {\n cur_target[N-1][N-1] = 0;\n break;\n }\n }\n\n solve_sliding();\n \n if (solution_moves.length() > T_MAX) {\n cout << solution_moves.substr(0, T_MAX) << endl;\n } else {\n cout << solution_moves << endl;\n }\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_COORD = 10000;\nconst int MIN_COORD = -10000;\nconst int BIG_COORD = 1000000000;\nconst int NUM_CUTS_X = 50;\nconst int NUM_CUTS_Y = 50;\n\nstruct Point {\n int x, y;\n};\n\n// Global variables\nint N, K;\nint a[11];\nvector berries;\nint counts_grid[105][105];\n\n// Timer\nclass Timer {\n chrono::high_resolution_clock::time_point start;\npublic:\n Timer() { reset(); }\n void reset() { start = chrono::high_resolution_clock::now(); }\n double elapsed() {\n auto end = chrono::high_resolution_clock::now();\n return chrono::duration(end - start).count();\n }\n} timer;\n\n// Random Number Generator\nmt19937 rng(12345);\n\nint rand_int(int l, int r) {\n return uniform_int_distribution(l, r)(rng);\n}\n\ndouble rand_double() {\n return uniform_real_distribution(0.0, 1.0)(rng);\n}\n\n// Evaluation Function\n// Returns the raw score: sum of min(a_d, b_d)\nint evaluate(const vector& cx, const vector& cy) {\n int nx = cx.size();\n int ny = cy.size();\n \n // Reset grid counts\n // The grid size is at most (NUM_CUTS_X + 1) x (NUM_CUTS_Y + 1)\n for(int i = 0; i <= nx; ++i) {\n memset(counts_grid[i], 0, sizeof(int) * (ny + 1));\n }\n\n // Count berries in each cell\n for(const auto& p : berries) {\n // Identify column\n int ix = upper_bound(cx.begin(), cx.end(), p.x) - cx.begin();\n // Identify row\n int iy = upper_bound(cy.begin(), cy.end(), p.y) - cy.begin();\n counts_grid[ix][iy]++;\n }\n\n // Compute b_d (histogram of piece sizes)\n int b[11] = {0};\n for(int i = 0; i <= nx; ++i) {\n for(int j = 0; j <= ny; ++j) {\n int c = counts_grid[i][j];\n if(c >= 1 && c <= 10) {\n b[c]++;\n }\n }\n }\n\n // Compute Objective\n int score = 0;\n for(int d = 1; d <= 10; ++d) {\n score += min(a[d], b[d]);\n }\n return score;\n}\n\nint main() {\n // Fast IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input Reading\n cin >> N >> K;\n for(int i = 1; i <= 10; ++i) {\n cin >> a[i];\n }\n berries.resize(N);\n vector x_coords, y_coords;\n for(int i = 0; i < N; ++i) {\n cin >> berries[i].x >> berries[i].y;\n x_coords.push_back(berries[i].x);\n y_coords.push_back(berries[i].y);\n }\n\n // Sort coordinates for quantile initialization\n sort(x_coords.begin(), x_coords.end());\n sort(y_coords.begin(), y_coords.end());\n\n // Initialize cuts\n // Strategy: Use K/2 lines for X and K/2 lines for Y.\n // Initialize them based on quantiles to spread berries somewhat evenly.\n vector cx(NUM_CUTS_X), cy(NUM_CUTS_Y);\n \n for(int i = 0; i < NUM_CUTS_X; ++i) {\n int idx = (i + 1) * (int)x_coords.size() / (NUM_CUTS_X + 1);\n cx[i] = x_coords[min((int)x_coords.size() - 1, idx)];\n // Add slight noise to break symmetries\n cx[i] = max(MIN_COORD, min(MAX_COORD, cx[i] + rand_int(-50, 50)));\n }\n \n for(int i = 0; i < NUM_CUTS_Y; ++i) {\n int idx = (i + 1) * (int)y_coords.size() / (NUM_CUTS_Y + 1);\n cy[i] = y_coords[min((int)y_coords.size() - 1, idx)];\n cy[i] = max(MIN_COORD, min(MAX_COORD, cy[i] + rand_int(-50, 50)));\n }\n\n sort(cx.begin(), cx.end());\n sort(cy.begin(), cy.end());\n\n // Optimization Loop\n int current_score = evaluate(cx, cy);\n int best_score = current_score;\n vector best_cx = cx;\n vector best_cy = cy;\n\n // Simulated Annealing Parameters\n double time_limit = 2.85;\n double start_temp = 3.0;\n double end_temp = 0.0;\n\n int iter_count = 0;\n\n while(true) {\n iter_count++;\n // Check time every 256 iterations to reduce overhead\n if ((iter_count & 255) == 0) {\n if (timer.elapsed() > time_limit) break;\n }\n\n double progress = timer.elapsed() / time_limit;\n double temp = start_temp + (end_temp - start_temp) * progress;\n\n // Select a move\n // 1. Choose axis (X or Y)\n bool axis_x = (rand_int(0, 1) == 0);\n vector& current_vec = axis_x ? cx : cy;\n\n // 2. Choose a line index\n int idx = rand_int(0, (int)current_vec.size() - 1);\n int old_val = current_vec[idx];\n int new_val = old_val;\n\n // 3. Determine modification type\n // Type 0: Small shift (fine tuning)\n // Type 1: Snap to berry (structural change)\n // Type 2: Large jump (exploration)\n // Type 3: Disable line (move out of range)\n \n int r = rand_int(0, 100);\n if (r < 40) { \n // Shift\n new_val += rand_int(-150, 150);\n } else if (r < 80) {\n // Snap to berry coordinate\n int b_idx = rand_int(0, N - 1);\n int berry_coord = axis_x ? berries[b_idx].x : berries[b_idx].y;\n // Snap to berry_coord or berry_coord - 1\n // This places the cut exactly on one side of the berry line\n new_val = berry_coord + rand_int(-1, 0);\n } else if (r < 95) {\n // Random jump\n new_val = rand_int(MIN_COORD, MAX_COORD);\n } else {\n // Disable (move to infinity)\n // 11000 is effectively outside the cake range (10000)\n new_val = MAX_COORD + 1000 + rand_int(0, 100);\n }\n\n // Clamp to safe range (including disabled range)\n new_val = max(MIN_COORD - 2000, min(MAX_COORD + 2000, new_val));\n\n // Apply move\n // Since vector is sorted, we need to keep it sorted.\n // Instead of full sort, we can update efficiently, but size=50 is small enough for sort.\n current_vec[idx] = new_val;\n sort(current_vec.begin(), current_vec.end());\n\n int new_score = evaluate(cx, cy);\n\n // Accept or Reject\n if (new_score >= current_score) {\n current_score = new_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_cx = cx;\n best_cy = cy;\n }\n } else {\n // SA Probability\n double delta = new_score - current_score; // negative\n double prob = exp(delta / (temp + 1e-9));\n \n if (rand_double() < prob) {\n current_score = new_score;\n } else {\n // Revert\n // Find one instance of new_val and change it back to old_val\n auto it = lower_bound(current_vec.begin(), current_vec.end(), new_val);\n *it = old_val;\n sort(current_vec.begin(), current_vec.end());\n }\n }\n }\n\n // Output Solution\n // Format: k lines. Each line: px py qx qy\n // Vertical cut at x=C: (C, -10^9) -> (C+1, 10^9)\n // Horizontal cut at y=D: (-10^9, D) -> (10^9, D+1)\n\n cout << best_cx.size() + best_cy.size() << \"\\n\";\n for (int v : best_cx) {\n cout << v << \" \" << -BIG_COORD << \" \" << v + 1 << \" \" << BIG_COORD << \"\\n\";\n }\n for (int v : best_cy) {\n cout << -BIG_COORD << \" \" << v << \" \" << BIG_COORD << \" \" << v + 1 << \"\\n\";\n }\n\n return 0;\n}","ahc014":"/**\n * AHC014 - RectJoin Solver\n * \n * Strategy:\n * 1. This is a heuristic search problem. We want to connect dots to form rectangles \n * (axis-aligned or 45-degree tilted) to place new dots.\n * 2. The objective is to maximize the sum of weights of all dots, where weight increases \n * with distance from the center.\n * 3. Since we want dots far from the center, we should try to \"grow\" the set of dots \n * outwards from the initial central cluster.\n * 4. We can view this as a search problem. From the current state, what are the valid moves?\n * A move is defined by choosing an empty spot p1 and 3 existing dots p2, p3, p4 forming a valid rectangle.\n * Equivalently, we can look for pairs of existing dots that can form a side or a diagonal of a rectangle\n * and check if the other required vertices exist.\n * 5. Since the number of steps can be large and the branching factor is high, a pure BFS/DFS is impossible.\n * We will use a randomized greedy approach with lookahead (Beam Search or Chokudai Search).\n * Given the time limit (5.0s) and the nature of the problem (\"constructive\"), a beam search is suitable.\n * 6. Key constraints:\n * - Rectangle lines must not have other dots on them.\n * - Rectangle lines must not overlap with existing rectangle lines.\n * \n * Algorithm Details:\n * - State representation:\n * - Bitsets or 2D arrays to mark existing dots.\n * - Mark used edges (horizontal, vertical, diagonal+45, diagonal-45). Since coordinates are small (<=61),\n * we can use efficient data structures.\n * - Move generation:\n * - Iterate through all pairs of existing points.\n * - Check if they can form a valid rectangle with a potential new point.\n * - There are different configurations:\n * a) The new point completes a rectangle with 3 existing points.\n * This implies we look for \"L\" shapes of existing dots.\n * - Evaluation Function:\n * - Primary: Sum of weights of current dots.\n * - Secondary heuristic: Potential for future moves. A dot is valuable if it is far from center \n * but also if it helps creating more dots further out.\n * \n * Implementation specifics:\n * - To manage the complexity, we focus on a specific direction or try to fill the board layer by layer? \n * Actually, just greedy with beam search is standard for this type.\n * - Because finding *all* valid moves is expensive ($O(|Dots|^3)$ or $O(N^2)$ scan), we need optimization.\n * Instead of iterating all triples, iterate all empty points $p_1$? Too many.\n * Iterate all existing pairs $(p_2, p_4)$ that could be diagonals?\n * - If $p_2, p_4$ are diagonal vertices, then $p_1, p_3$ are the other two.\n * - We need $p_3$ to exist and $p_1$ to be empty.\n * - Center of rectangle is midpoint of $p_2, p_4$.\n * - This covers both axis-aligned and 45-degree rectangles.\n * - Check validity (no intermediate dots, no overlapping edges).\n * \n * - Directions:\n * Let's use 8 directions. For a point p, we can look for neighbors in 8 directions to form lines.\n * Actually, the constraint is strictly about the geometry.\n * \n * Types of rectangles:\n * 1. Axis-parallel: Vertices $(x, y), (x+w, y), (x+w, y+h), (x, y+h)$.\n * Diagonals intersect at $((2x+w)/2, (2y+h)/2)$.\n * 2. 45-degree: Vertices are $(x, y), (x+u, y+u), (x, y+2u), (x-u, y+u)$? No, generic.\n * Square vectors: $v, v_{\\perp}$.\n * Rectangles: $v_1 \\perp v_2$.\n * In grid, 45-degree means sides are along diagonals $(1,1)$ and $(1,-1)$.\n * \n * Let's simplify:\n * We search for a valid move by picking an existing dot $p_2$, a direction $d$, and a distance $l$.\n * This finds a potential $p_3$. Then turn 90 degrees, find $p_4$. Then $p_1$ is determined.\n * This is much faster.\n * Directions: \n * 0: (1, 0) -- Horizontal\n * 1: (0, 1) -- Vertical\n * 2: (1, 1) -- Diagonal Main\n * 3: (1, -1) -- Diagonal Anti\n * \n * For a rectangle, we need 3 existing points $p_2, p_3, p_4$ and 1 new $p_1$.\n * Structure: $p_2 \\to p_3$ (edge 1), $p_3 \\to p_4$ (edge 2), $p_4 \\to p_1$ (edge 3), $p_1 \\to p_2$ (edge 4).\n * $p_1$ is the new point.\n * We can iterate over $p_2$ (existing), direction $d1$, len $l1$ to find existing $p_3$.\n * Then from $p_3$, direction $d2$ ($d1 \\perp d2$), len $l2$ to find existing $p_4$.\n * Then calculate $p_1$. Check if $p_1$ is inside grid and empty.\n * Then check line constraints.\n * \n * Beam Search Flow:\n * - Keep top K states.\n * - For each state, generate many valid moves.\n * - Score moves.\n * - Select top K successors.\n * \n * Because M is small initially (~N^2/12) and we want to fill up to N^2, the game is long.\n * Beam search might be too slow if depth is huge.\n * However, the number of dots increases by 1 each step.\n * We likely won't fill the whole board.\n * Greedy with random restarts or simplified Monte Carlo might be robust.\n * Given 5 seconds, a decent width Beam Search or Chokudai Search is best.\n * \n * Optimization: Bitsets for \"has_dot\" grid.\n * Line checks: \n * - \"No dots on perimeter\": check points between vertices.\n * - \"No overlapping edges\": Keep a set of used segments?\n * Horizontal segments can be indexed by $(y, x_{start}, x_{end})$.\n * Or simply a boolean array for grid edges?\n * Grid edges: \n * Horizontal: (x, y) -- (x+1, y)\n * Vertical: (x, y) -- (x, y+1)\n * Diag1: (x, y) -- (x+1, y+1)\n * Diag2: (x+1, y) -- (x, y+1)\n * We can use arrays `H[64][64], V[64][64], D1[64][64], D2[64][64]` to store boolean \"used\".\n * Wait, \"share a common segment of positive length\".\n * This means we cannot reuse an edge segment.\n * Yes, simply marking unit intervals on the grid is sufficient.\n * \n * Coordinates: $0 \\le x, y < N$.\n * Center $c = (N-1)/2$.\n * \n * Weight $W(x,y) = (x-c)^2 + (y-c)^2 + 1$.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Configuration\nconst int MAX_N = 65;\nint N, M;\nint CENTER;\n\n// Directions: Right, Up, Up-Right, Down-Right\nconst int DX[] = {1, 0, 1, 1, -1, 0, -1, -1}; // 8 neighbors for iteration, but we define axes\n// Axes for rectangles:\n// Pair 0: (1, 0) and (0, 1) [Axis Aligned]\n// Pair 1: (1, 1) and (1, -1) [45 Degree]\n\nstruct Point {\n int x, y;\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { return x != other.x ? x < other.x : y < other.y; }\n};\n\nint dist_sq(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// Global precomputed weights\nint WEIGHTS[MAX_N][MAX_N];\n\nstruct Move {\n Point p1, p2, p3, p4; // p1 is the NEW dot\n // For output, we need to print p1, p2, p3, p4. \n // Order in struct: p1 is new. p2, p3, p4 are existing.\n // The rectangle is p1-p2-p3-p4 in order.\n};\n\n// Helper to managing edges\n// We identify a unit segment by its type, and the coordinate of its \"smaller\" end (lexicographically or just x then y).\n// Horizontal: (x, y) -> (x+1, y). Identify by (x, y).\n// Vertical: (x, y) -> (x, y+1). Identify by (x, y).\n// Diag1 (Main): (x, y) -> (x+1, y+1). Identify by (x, y).\n// Diag2 (Anti): (x, y+1) -> (x+1, y). Identify by (x, y). NOTE: This maps segment between (x, y+1) and (x+1, y).\n// \n// Size needed: \n// H: [0..N-2][0..N-1] -> 64*64\n// V: [0..N-1][0..N-2]\n// D1: [0..N-2][0..N-2]\n// D2: [0..N-2][0..N-2]\nstruct GridState {\n bool has_dot[MAX_N][MAX_N]; // 4KB\n // Use bitsets for edges to save space and copy time?\n // 64*64 = 4096 bits = 512 bytes. Very small.\n // We use raw bool arrays for simplicity unless memory is tight.\n // Actually, std::bitset or flattening is better for copying.\n // Let's use flat arrays of uint64_t for bitmasks.\n // 64 columns fit in one uint64_t.\n uint64_t used_H[MAX_N]; \n uint64_t used_V[MAX_N];\n uint64_t used_D1[MAX_N];\n uint64_t used_D2[MAX_N];\n\n int score;\n vector history;\n vector dots; // Keep track of dot coordinates for fast iteration\n\n GridState() {\n memset(has_dot, 0, sizeof(has_dot));\n memset(used_H, 0, sizeof(used_H));\n memset(used_V, 0, sizeof(used_V));\n memset(used_D1, 0, sizeof(used_D1));\n memset(used_D2, 0, sizeof(used_D2));\n score = 0;\n }\n\n // Check if a unit segment is used\n // type: 0=H, 1=V, 2=D1, 3=D2\n // For H: p is (x, y) of left point\n // For V: p is (x, y) of bottom point\n // For D1: p is (x, y) of bottom-left point\n // For D2: p is (x, y) of top-left point. (x, y+1) is the start, (x+1, y) is end.\n // Wait, let's standardize D2 indexing.\n // D2 connects (x, y+1) and (x+1, y). Let's index this segment by (x, y).\n bool is_used(int type, int x, int y) const {\n if (type == 0) return (used_H[y] >> x) & 1;\n if (type == 1) return (used_V[y] >> x) & 1;\n if (type == 2) return (used_D1[y] >> x) & 1;\n if (type == 3) return (used_D2[y] >> x) & 1;\n return false;\n }\n\n void set_used(int type, int x, int y) {\n if (type == 0) used_H[y] |= (1ULL << x);\n else if (type == 1) used_V[y] |= (1ULL << x);\n else if (type == 2) used_D1[y] |= (1ULL << x);\n else if (type == 3) used_D2[y] |= (1ULL << x);\n }\n\n void add_dot(int x, int y) {\n if (!has_dot[x][y]) {\n has_dot[x][y] = true;\n dots.push_back({x, y});\n score += WEIGHTS[x][y];\n }\n }\n};\n\n// Random number generator\nmt19937 rng(12345);\n\n// Time management\nauto start_time = chrono::high_resolution_clock::now();\ndouble time_limit = 4.9; // seconds\n\ndouble get_elapsed_time() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// Logic to check and apply lines\n// Returns false if invalid\nbool check_and_mark_line(GridState& state, Point p1, Point p2, bool mark) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int steps = max(abs(dx), abs(dy));\n if (steps == 0) return false; // Same point\n\n int sx = dx / steps;\n int sy = dy / steps;\n\n // Validate direction type\n int type = -1;\n if (sy == 0) type = 0; // H\n else if (sx == 0) type = 1; // V\n else if (sx == sy) type = 2; // D1\n else if (sx == -sy) type = 3; // D2\n else return false; // Should not happen for valid rects\n\n int cx = p1.x;\n int cy = p1.y;\n\n // Check intermediate dots and edge usage\n for (int i = 0; i < steps; ++i) {\n // Check edge usage\n // Segment from (cx, cy) to (cx+sx, cy+sy)\n int ux = cx, uy = cy;\n if (type == 3) { \n // For D2, our indexing is based on (x, y) for segment (x, y+1)-(x+1, y)\n // If moving down-right: (x, y+1) -> (x+1, y). Index at (x, y).\n // If moving up-left: (x+1, y) -> (x, y+1). Index at (x, y).\n // So we need min x and min y\n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy); \n } else {\n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy);\n }\n \n if (state.is_used(type, ux, uy)) return false;\n\n // Move to next point\n cx += sx;\n cy += sy;\n\n // Check dot existence (strictly between p1 and p2)\n if (i < steps - 1) {\n if (state.has_dot[cx][cy]) return false;\n }\n }\n\n if (mark) {\n cx = p1.x;\n cy = p1.y;\n for (int i = 0; i < steps; ++i) {\n int ux = cx, uy = cy;\n if (type == 3) { \n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy); \n } else {\n ux = min(cx, cx + sx);\n uy = min(cy, cy + sy);\n }\n state.set_used(type, ux, uy);\n cx += sx;\n cy += sy;\n }\n }\n return true;\n}\n\n// Check if a move is valid and return the score gain (or -1 if invalid)\n// Move defines rectangle p1-p2-p3-p4. p1 is new.\n// However, p1 is just a coordinate. We need to check edges:\n// p1-p2, p2-p3, p3-p4, p4-p1.\n// Note: p2, p3, p4 must be existing dots. p1 must be empty.\n// Also no dots on edges (excluding endpoints).\n// Edges must not overlap existing.\nbool is_valid_move(GridState& state, const Move& m, bool apply = false) {\n if (state.has_dot[m.p1.x][m.p1.y]) return false;\n // Check bounds (implied by iteration usually, but safety first)\n if (m.p1.x < 0 || m.p1.x >= N || m.p1.y < 0 || m.p1.y >= N) return false;\n\n // Check 4 edges\n // Order: p1 -> p2 -> p3 -> p4 -> p1\n // We need to check without marking first, then mark if all good.\n // But to avoid code duplication, we can use the 'mark' flag carefully or just check then mark.\n // Since checking is fast, let's check all then mark all.\n \n if (!check_and_mark_line(state, m.p1, m.p2, false)) return false;\n if (!check_and_mark_line(state, m.p2, m.p3, false)) return false;\n if (!check_and_mark_line(state, m.p3, m.p4, false)) return false;\n if (!check_and_mark_line(state, m.p4, m.p1, false)) return false;\n\n if (apply) {\n check_and_mark_line(state, m.p1, m.p2, true);\n check_and_mark_line(state, m.p2, m.p3, true);\n check_and_mark_line(state, m.p3, m.p4, true);\n check_and_mark_line(state, m.p4, m.p1, true);\n state.add_dot(m.p1.x, m.p1.y);\n state.history.push_back(m);\n }\n\n return true;\n}\n\n// Evaluate a state to help beam search\n// Simple evaluation: current score\n// Heuristic: penalize if dots are cluttered? Reward dots near edges?\n// The problem objective is purely weighted sum.\n// However, having dots in \"useful\" positions (L-shapes) is good.\n// Calculating \"potential\" is expensive.\n// Let's stick to score + small centrality penalty (prefer outwards) if ties?\n// Actually, the weight function already rewards outward dots.\ndouble evaluate(const GridState& s) {\n return (double)s.score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n cin >> N >> M;\n CENTER = (N - 1) / 2;\n GridState initial_state;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int dx = i - CENTER;\n int dy = j - CENTER;\n WEIGHTS[i][j] = dx*dx + dy*dy + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_state.add_dot(x, y);\n }\n\n // Beam Search Parameters\n // Since state copy is somewhat heavy (a few arrays), we can't have huge width.\n // But we want depth.\n // We can filter moves.\n // Prioritize moves that give high immediate score (large weight p1).\n int BEAM_WIDTH = 200; // Tunable\n if (N > 50) BEAM_WIDTH = 100;\n \n vector beam;\n beam.reserve(BEAM_WIDTH * 4);\n beam.push_back(initial_state);\n\n // The game can have many turns.\n // We stop when time is up or no moves.\n \n int turn = 0;\n int best_overall_score = 0;\n GridState best_state = initial_state;\n\n // Directions for searching p3 from p2\n // 0: right, 1: up, 2: left, 3: down\n // 4: ur, 5: ul, 6: dl, 7: dr\n int DX_LIST[] = {1, 0, -1, 0, 1, -1, -1, 1};\n int DY_LIST[] = {0, 1, 0, -1, 1, 1, -1, -1};\n\n while (get_elapsed_time() < time_limit) {\n vector next_beam;\n next_beam.reserve(BEAM_WIDTH * 4);\n \n bool any_move_found = false;\n \n // We will collect candidates from all states in beam\n struct Candidate {\n int state_idx;\n Move move;\n int gain;\n bool operator>(const Candidate& other) const {\n return gain > other.gain;\n }\n };\n \n // Use a priority queue or partial sort to keep top candidates across all beam states?\n // Or just top K per state?\n // Merging is better.\n \n // Since generating *all* moves is slow, we might need to sample or limit generation.\n // For each state, iterate all dots p2.\n // Try to find p3 such that p2->p3 is valid edge.\n // Then try to find p4 such that p3->p4 is valid edge (perp to p2->p3).\n // Then check p1.\n // This is O(Dots * 8 * N * 2 * N) ~ O(M * N^2). With M~100, N~30 -> 100*900 ~ 90000 ops per state.\n // With beam width 100, that's 9e6 ops per turn. 5 sec / 9e6 ~ 500 turns. Maybe okay.\n // Optimization: Precompute valid edges? No, edges change (get blocked).\n \n // Global candidates collection\n // To avoid too many copies, we store indices.\n vector candidates;\n \n int state_idx = 0;\n for (auto& state : beam) {\n // Limit the number of dots we check to save time if we have many dots?\n // We can shuffle dots or prioritize dots near edges (unlikely to be blocked).\n // Or just iterate all.\n \n // Optimization: Iterate dots in random order to avoid bias if we cut off early?\n // No, deterministic is better for debug, but random helps exploration.\n // Let's just iterate all for now.\n \n int moves_found_for_state = 0;\n \n for (const auto& p2 : state.dots) {\n // Try 8 directions for p3\n for (int dir = 0; dir < 8; ++dir) {\n int dx1 = DX_LIST[dir];\n int dy1 = DY_LIST[dir];\n \n // Scan for p3\n for (int l1 = 1; ; ++l1) {\n int x3 = p2.x + dx1 * l1;\n int y3 = p2.y + dy1 * l1;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) break;\n \n // If there is a dot at p3\n if (state.has_dot[x3][y3]) {\n Point p3 = {x3, y3};\n \n // Check if p2->p3 is valid (no intermediate dots, no edge overlap)\n if (check_and_mark_line(state, p2, p3, false)) {\n // Now look for p4 perpendicular\n // Perpendicular directions\n // If dir < 4 (axis): (dx, dy) -> (-dy, dx) and (dy, -dx)\n // If dir >= 4 (diag): similarly\n int p_dirs[2];\n if (dir < 4) { // Axis aligned\n // if (1,0) -> (0,1), (0,-1)\n // generic rot90: (x,y)->(-y, x), (x,y)->(y, -x)\n // But we need to map back to indices in DX_LIST/DY_LIST to be clean, \n // or just compute manual. Manual is easier.\n // But we only iterate to find dots.\n // Actually, we can just scan the two perp lines from p3.\n } \n \n int perp_dx[2], perp_dy[2];\n perp_dx[0] = -dy1; perp_dy[0] = dx1;\n perp_dx[1] = dy1; perp_dy[1] = -dx1;\n \n for (int k = 0; k < 2; ++k) {\n int dx2 = perp_dx[k];\n int dy2 = perp_dy[k];\n \n for (int l2 = 1; ; ++l2) {\n int x4 = x3 + dx2 * l2;\n int y4 = y3 + dy2 * l2;\n \n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) break;\n \n if (state.has_dot[x4][y4]) {\n Point p4 = {x4, y4};\n // Check p3->p4\n if (check_and_mark_line(state, p3, p4, false)) {\n // Calculate p1\n // p1 = p2 + (p4 - p3)\n int x1 = p2.x + (x4 - x3);\n int y1 = p2.y + (y4 - y3);\n Point p1 = {x1, y1};\n \n // Check p1 in bounds, empty\n if (x1 >= 0 && x1 < N && y1 >= 0 && y1 < N && !state.has_dot[x1][y1]) {\n // Check p4->p1 and p1->p2\n // Optimization: check validity function\n Move m = {p1, p2, p3, p4};\n // We already checked p2->p3 and p3->p4.\n // Need to check p4->p1 and p1->p2.\n // Reuse is_valid_move but optimized?\n // is_valid_move checks all 4. It's safer.\n if (is_valid_move(state, m, false)) {\n candidates.push_back({state_idx, m, WEIGHTS[x1][y1]});\n moves_found_for_state++;\n }\n }\n }\n // If found a dot, we can't go further in this direction usually?\n // The rule says \"no dots ... on the perimeter\".\n // So if we found p4, we cannot skip it to find another p4' behind it.\n // Because p4 would be on the segment p3->p4'.\n break; \n }\n }\n }\n }\n // Cannot skip p3\n break;\n }\n }\n }\n }\n state_idx++;\n }\n\n if (candidates.empty()) {\n break; // Game over\n }\n any_move_found = true;\n\n // Sort candidates.\n // We want diversity, so maybe not just strict score?\n // Just score is fine for this problem structure.\n // Maybe weight by distance from center heavily.\n // Or just random shuffle equal scores.\n sort(candidates.begin(), candidates.end(), [](const Candidate& a, const Candidate& b) {\n return a.gain > b.gain;\n });\n\n // Select top BEAM_WIDTH distinct successors\n int picked = 0;\n // To avoid picking too many from same parent and reducing diversity?\n // Simple approach: just pick best.\n // Limit candidates per parent? e.g. max 5 per parent.\n vector picked_count(beam.size(), 0);\n \n for (const auto& cand : candidates) {\n if (picked >= BEAM_WIDTH) break;\n // Pruning heuristics\n if (picked_count[cand.state_idx] >= 3) continue; // Diversity enforcement\n\n GridState next_s = beam[cand.state_idx];\n is_valid_move(next_s, cand.move, true); // Apply\n next_beam.push_back(next_s);\n \n if (next_s.score > best_overall_score) {\n best_overall_score = next_s.score;\n best_state = next_s;\n }\n \n picked++;\n picked_count[cand.state_idx]++;\n }\n \n // If we couldn't fill beam, relax diversity constraint\n if (picked < BEAM_WIDTH && candidates.size() > picked) {\n for (const auto& cand : candidates) {\n if (picked >= BEAM_WIDTH) break;\n if (picked_count[cand.state_idx] >= 3) { // Only pick those skipped before\n // Check if we really want to copy again? \n // Beam search usually takes unique states.\n // Here uniqueness is guaranteed by move.\n GridState next_s = beam[cand.state_idx];\n is_valid_move(next_s, cand.move, true);\n next_beam.push_back(next_s);\n if (next_s.score > best_overall_score) {\n best_overall_score = next_s.score;\n best_state = next_s;\n }\n picked++;\n }\n }\n }\n\n beam = move(next_beam);\n turn++;\n \n // Time check inside loop to be safe\n if (get_elapsed_time() > time_limit) break;\n }\n\n // Output\n cout << best_state.history.size() << \"\\n\";\n for (const auto& m : best_state.history) {\n cout << m.p1.x << \" \" << m.p1.y << \" \"\n << m.p2.x << \" \" << m.p2.y << \" \"\n << m.p3.x << \" \" << m.p3.y << \" \"\n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n cout << flush;\n\n return 0;\n}","ahc015":"/**\n * AtCoder Heuristic Contest 015 (AHC015) Solution\n * Problem: Halloween Candy\n * Author: Algorithm Engineer\n * Language: C++20 (gcc 12.2.0)\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Types ---\nconstexpr int N = 10;\nconstexpr int TOTAL_TURNS = 100;\nconstexpr int EMPTY = 0;\n\n// Directions: F, B, L, R\n// F: move up (row decreases)\n// B: move down (row increases)\n// L: move left (col decreases)\n// R: move right (col increases)\nenum Direction { F = 0, B = 1, L = 2, R = 3 };\nconst char DIR_CHARS[4] = {'F', 'B', 'L', 'R'};\nconst int DR[4] = {-1, 1, 0, 0}; // Delta Row\nconst int DC[4] = {0, 0, -1, 1}; // Delta Col\n\nstruct State {\n int grid[N][N];\n \n // Initialize grid\n void init() {\n memset(grid, 0, sizeof(grid));\n }\n\n // Count empty cells\n int count_empty() const {\n int cnt = 0;\n for(int r=0; r place(int p, int flavor) {\n int current_empty = 0;\n for(int r=0; r= 0; --r) {\n if (grid[r][c] != EMPTY) {\n if (r != write_pos) {\n grid[write_pos][c] = grid[r][c];\n grid[r][c] = EMPTY;\n }\n write_pos--;\n }\n }\n }\n } else if (d == L) { // Left\n for (int r = 0; r < N; ++r) {\n int write_pos = 0;\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != EMPTY) {\n if (c != write_pos) {\n grid[r][write_pos] = grid[r][c];\n grid[r][c] = EMPTY;\n }\n write_pos++;\n }\n }\n }\n } else if (d == R) { // Right\n for (int r = 0; r < N; ++r) {\n int write_pos = N - 1;\n for (int c = N - 1; c >= 0; --c) {\n if (grid[r][c] != EMPTY) {\n if (c != write_pos) {\n grid[r][write_pos] = grid[r][c];\n grid[r][c] = EMPTY;\n }\n write_pos--;\n }\n }\n }\n }\n }\n\n // Calculate Score: Sum of squares of connected component sizes\n long long calc_score() const {\n bool visited[N][N] = {false};\n long long score = 0;\n \n // Stack for DFS to avoid recursion overhead\n static pair st[N*N]; \n\n for(int r=0; r 0) {\n auto [cr, cc] = st[--top];\n size++;\n \n // Check neighbors\n // Up\n if(cr > 0 && !visited[cr-1][cc] && grid[cr-1][cc] == flavor) {\n visited[cr-1][cc] = true;\n st[top++] = {cr-1, cc};\n }\n // Down\n if(cr < N-1 && !visited[cr+1][cc] && grid[cr+1][cc] == flavor) {\n visited[cr+1][cc] = true;\n st[top++] = {cr+1, cc};\n }\n // Left\n if(cc > 0 && !visited[cr][cc-1] && grid[cr][cc-1] == flavor) {\n visited[cr][cc-1] = true;\n st[top++] = {cr, cc-1};\n }\n // Right\n if(cc < N-1 && !visited[cr][cc+1] && grid[cr][cc+1] == flavor) {\n visited[cr][cc+1] = true;\n st[top++] = {cr, cc+1};\n }\n }\n score += (long long)size * size;\n }\n }\n }\n return score;\n }\n};\n\n// --- Global Variables ---\nint flavors[TOTAL_TURNS];\nState global_state;\n\n// --- Random Engine ---\n// Use a fast PRNG\nstruct Xorshift {\n uint32_t x = 123456789;\n uint32_t y = 362436069;\n uint32_t z = 521288629;\n uint32_t w = 88675123;\n \n uint32_t next() {\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n }\n \n // Returns [0, n-1]\n int next_int(int n) {\n return next() % n;\n }\n} rng;\n\n\n// --- Simulation Logic ---\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Read flavors\n for(int i=0; i> flavors[i];\n }\n\n global_state.init();\n\n // Time management\n auto start_clock = chrono::high_resolution_clock::now();\n double time_limit = 1.95; // seconds\n\n for(int t=0; t> p;\n\n // 1. Place the current candy\n global_state.place(p, flavors[t]);\n\n // 2. Determine the best move\n int best_move = -1;\n\n // If it's the last turn, the move doesn't matter visually for placement,\n // but the problem asks for 100 outputs. \n // At t=99 (100th candy), any move consolidates the final state.\n // We should still optimize it to get the best final clustering.\n \n // Strategy: Monte Carlo with Greedy Playouts\n // We have limited time. We allocate time per turn proportional to remaining complexity?\n // Actually, early moves have huge impact. But late moves are easier to simulate deeply.\n // Given 2.0s total, ~20ms per move.\n \n // Determine how much time we can spend on this turn\n auto now = chrono::high_resolution_clock::now();\n chrono::duration elapsed = now - start_clock;\n double remaining_time = time_limit - elapsed.count();\n double time_for_this_move = remaining_time / (TOTAL_TURNS - t + 5); // Add buffer denominator\n \n // Cap time per move to ensure we don't timeout early but use time effectively\n // Minimum iterations\n int iterations = 0;\n \n // Score accumulators for the 4 directions\n // We track sum of scores to take average\n long long score_sum[4] = {0};\n int count_sims[4] = {0};\n\n // Temporary state objects to avoid reallocation\n State initial_sim_state = global_state;\n \n auto turn_start = chrono::high_resolution_clock::now();\n \n while (true) {\n // Check time every batch of iterations\n if ((iterations & 0x3F) == 0) { // check every 64 iters\n auto curr = chrono::high_resolution_clock::now();\n chrono::duration turn_elapsed = curr - turn_start;\n if (turn_elapsed.count() > time_for_this_move) break;\n }\n\n // Pick a candidate first move (round robin or random)\n // We want to evaluate all 4 candidates roughly equally\n int first_move = iterations % 4; \n\n // Copy state\n State sim_state = initial_sim_state;\n \n // Apply first move\n sim_state.tilt(first_move);\n \n // Playout\n // Simulate subsequent turns until end or depth limit\n // Full depth 100 is feasible since N=10 is small.\n \n for (int sim_t = t + 1; sim_t < TOTAL_TURNS; ++sim_t) {\n // Randomly place next candy\n // Empty cells count: 100 - sim_t\n int empty_cnt = 100 - sim_t; // before placement\n // Logic: At start of turn sim_t, grid has sim_t candies.\n // Wait, t is 0-indexed (0 to 99). \n // At start of loop t, we placed candy t. Grid has t+1 candies.\n // Then we tilt. Grid still has t+1 candies.\n // Next turn is t+1. We place candy t+1.\n // In this loop, sim_t goes from t+1 to 99.\n // At step sim_t, we place candy flavors[sim_t].\n // Number of filled cells before placing is sim_t.\n // Empty cells = 100 - sim_t.\n \n int rnd_p = rng.next_int(100 - sim_t) + 1;\n sim_state.place(rnd_p, flavors[sim_t]);\n \n // Greedy choice for the simulated step\n // Try all 4 tilts, pick best immediate score\n int best_local_move = 0;\n long long max_local_score = -1;\n \n // To make greedy fast, maybe we don't copy full state 4 times?\n // But state is small (100 ints). Copy is fast.\n \n // Heuristic: Sometimes pure greedy gets stuck. \n // But for this problem, clustering same colors is the goal.\n // Simple greedy is often a strong baseline for playout policy.\n \n for(int d=0; d<4; ++d) {\n State temp = sim_state;\n temp.tilt(d);\n long long s = temp.calc_score();\n if (s > max_local_score) {\n max_local_score = s;\n best_local_move = d;\n }\n }\n sim_state.tilt(best_local_move);\n }\n\n // End of simulation, evaluate\n score_sum[first_move] += sim_state.calc_score();\n count_sims[first_move]++;\n iterations++;\n }\n\n // Select best move based on average score\n double best_avg = -1.0;\n // Default to a valid move if time was super tight\n best_move = 0; \n \n // Tie-breaking: if scores are equal, prefer directions that keep candies closer to center? \n // Or just random. Here we use simple max.\n for(int d=0; d<4; ++d) {\n if (count_sims[d] > 0) {\n double avg = (double)score_sum[d] / count_sims[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_move = d;\n }\n }\n }\n \n // If we had 0 iterations (shouldn't happen with time buffer), pick greedy\n if (iterations == 0) {\n long long max_s = -1;\n for(int d=0; d<4; ++d) {\n State temp = global_state;\n temp.tilt(d);\n long long s = temp.calc_score();\n if (s > max_s) {\n max_s = s;\n best_move = d;\n }\n }\n }\n\n // Output\n cout << DIR_CHARS[best_move] << endl; // endl flushes\n \n // Apply to real state\n global_state.tilt(best_move);\n }\n\n return 0;\n}","ahc016":"/**\n * Solution for AHC016 - Graphorean\n * \n * Strategy:\n * The core problem is to design M graphs (G_0 ... G_{M-1}) such that they are distinguishable\n * even after:\n * 1. Edge flipping noise (probability epsilon).\n * 2. Vertex permutation (graph isomorphism).\n * \n * Since vertex labels are lost due to shuffling, we must rely on graph invariants.\n * Simple invariants like edge count or degree distribution are robust but might not carry\n * enough information for large M or high epsilon.\n * \n * Approach:\n * 1. We partition the N vertices into smaller \"cliques\" or clusters. The sizes of these clusters\n * act as the signature of the graph.\n * For example, if N=10, a graph could be formed by a clique of size 3 and a clique of size 7.\n * The edges inside a clique are dense (probability p_high), and edges between cliques are sparse (probability p_low).\n * Usually, to maximize distinguishability, we just use \"volume of edges\" in specific sub-blocks if we knew the permutation.\n * But since we don't know the permutation, we rely on the sorted degree sequence or just the total number of edges\n * if epsilon is very high.\n * \n * 2. Actually, for small epsilon, the degree sequence is preserved well. For large epsilon, only the total number of edges is reliable.\n * \n * Let's refine the strategy based on epsilon:\n * \n * Case A: Small Epsilon (e.g., < 0.10)\n * We can use the sorted degree sequence as a \"feature vector\".\n * Or even simpler: Just vary the total number of edges. But with M=100, just edge count might overlap due to variance.\n * The variance of edge count is V = N_edges * eps * (1-eps). Std dev is sqrt(V).\n * With N=100, max edges ~5000. If we use density 0.5, edges=2500. V = 2500 * 0.1 * 0.9 = 225. Sigma = 15.\n * We need to separate M=100 states. 6*sigma separation is ideal. 100 * 6 * 15 is way larger than 5000.\n * So just edge count is NOT enough for N=100, eps=0.1.\n * \n * We need more robust local structures.\n * We divide the N vertices into K groups. Let the sizes be s_1, s_2, ..., s_K.\n * Within group k, we fill edges with probability 1 (or close to 1). Between groups, probability 0.\n * When we receive H, we try to recover the cluster sizes.\n * However, recovering clusters is hard with noise.\n * \n * Better approach for this contest:\n * We construct graphs $G_k$ such that their adjacency matrices look like block diagonal matrices,\n * or specifically, we just define the \"ideal\" number of edges for each vertex.\n * Let's assign a \"target degree\" $d_i$ to vertex $i$.\n * Since vertices are shuffled, the signature is the sorted list of degrees $D = \\text{sort}(d_0, \\dots, d_{N-1})$.\n * \n * Algorithm:\n * 1. Determine N. High N reduces error but increases penalty.\n * Score = 10^9 * (0.9^E) / N.\n * If we can get E=0 with N=40, score is ~2.5e7.\n * If we get E=0 with N=100, score is ~1.0e7.\n * Minimizing N is crucial, but E > 0 is very costly (factor 0.9).\n * With E=5, 0.9^5 = 0.59. So N=40 with E=5 is better than N=100 with E=0?\n * Actually 0.59/40 = 0.014, 1.0/100 = 0.01. Yes.\n * So we want minimal N that keeps E low.\n * \n * Method used here:\n * We construct a set of prototype graphs. Each prototype is defined by a partition of vertices $N = n_1 + n_2 + \\dots + n_k$.\n * To encode message $s$, we pick a specific partition.\n * The simplest partition is just 1 group of size $N$. The parameter we vary is the edge density or specific structure.\n * \n * Given the constraints and the nature of \"shuffled vertices + noise\", the most robust invariant is the distribution of degrees,\n * or more simply, the counts of edges in the graph, perhaps augmented by the count of triangles, etc.\n * \n * But \"count of edges\" is a single scalar. We can store M values in a scalar if the variance is low enough.\n * If epsilon is large, variance is high. We need high N.\n * If epsilon is small, we can distinguish more states.\n * \n * Let's try a hybrid approach:\n * 1. Divide vertices into two sets A and B of size $n_A, n_B$.\n * 2. Edges inside A are dense (prob 1). Edges inside B are sparse (prob 0). Edges between A and B are sparse (prob 0).\n * Basically, $G_s$ consists of a clique of size $k$ and isolated vertices.\n * The number of edges is $k(k-1)/2$.\n * The max number of edges is limited.\n * \n * Let's generalize:\n * Each graph $G_s$ is generated by partitioning $N$ vertices into groups $c_1, c_2, \\dots$.\n * Edges within group $c_i$ are 1. Edges between groups are 0.\n * This creates a graph which is a disjoint union of cliques.\n * When noise is added, we get a graph. We calculate the \"likelihood\" of this graph coming from each $G_s$.\n * \n * Likelihood calculation:\n * Given $H$ (adjacency matrix $A_H$) and candidate $G_k$ (adjacency matrix $A_G$ but we don't know the permutation).\n * Since we don't know the permutation, exact likelihood is hard (requires summing over N! permutations).\n * \n * Approximation:\n * Just sort the degrees of $H$. Sort the expected degrees of $G_k$. Compare them?\n * Degrees change with noise.\n * \n * Alternative:\n * Just use the total number of edges?\n * Let $m$ be number of edges in $G_s$.\n * Observed edges in $H$: $m' \\sim m(1-\\epsilon) + (\\binom{N}{2}-m)\\epsilon$.\n * Expected value $\\mu(m) = m(1-2\\epsilon) + \\binom{N}{2}\\epsilon$.\n * We can choose $G_0, \\dots, G_{M-1}$ to have different $m$ such that $\\mu(m)$ are well-spaced.\n * Max edges $E_{max} = N(N-1)/2$.\n * We need to pick $M$ integers $x_0, \\dots, x_{M-1} \\in [0, E_{max}]$ to maximize spacing.\n * This is only effective if the spacing is larger than the noise std dev.\n * \n * If $\\epsilon$ is large (e.g. 0.40), the \"signal\" is $m(1-0.8) = 0.2m$.\n * Noise variance is large. N needs to be large (likely 100).\n * Even with N=100, simple edge counting might fail for M=100.\n * \n * Let's try a standard approach for this problem type:\n * Divide the N vertices into chunks.\n * Example: For each graph ID $k$, we define a binary vector $v_k$ of length $L$.\n * We assign subsets of vertices to represent bits of $v_k$.\n * However, because of shuffling, we can't identify which vertex is which bit.\n * \n * So, the code is effectively a multiset of features.\n * The best feature for graph isomorphism under noise is often the degree sequence.\n * But we can explicitly construct $G_k$ to maximize the difference in \"local density\".\n * \n * Proposed Solution:\n * We partition $N$ vertices into $D$ groups of equal size (e.g., $N=100$, 20 groups of 5).\n * Let the groups be $g_0, g_1, \\dots, g_{D-1}$.\n * For each pair of groups $(g_i, g_j)$ (including $i=j$), we decide whether to fill it with 1s or 0s based on the ID $k$.\n * Wait, shuffling destroys group identity.\n * \n * So we must rely on the counts.\n * Let's go back to \"Disjoint Union of Cliques\" or \"Graph defined by degree sequence\".\n * Actually, the \"Number of edges\" method is the most robust against shuffling because it is permutation invariant.\n * Is there a second invariant? Number of triangles?\n * \n * Let's stick to \"Number of edges\" as the primary differentiator, but optimize N.\n * If \"Number of edges\" is insufficient to separate M states with acceptable error, we increase N.\n * If N=100 is not enough, we are in trouble. But wait, we can use the whole range $0 \\dots \\binom{N}{2}$.\n * \n * Wait, if we output $N$, we must output $N$ for all graphs.\n * We can choose $N$ dynamically based on $M$ and $\\epsilon$.\n * \n * Algorithm:\n * 1. Estimate necessary N to separate M values using simple edge counts.\n * Let $L = N(N-1)/2$.\n * Signal range is roughly $L(1-2\\epsilon)$.\n * We have M points. Distance $d = L(1-2\\epsilon) / (M-1)$.\n * Noise std dev $\\sigma \\approx \\sqrt{L \\epsilon (1-\\epsilon)}$.\n * We want $d > k \\sigma$. (e.g., $k=2$ or $3$).\n * Solve for N.\n * \n * 2. If the required N > 100, we cap at 100 and try to add a second dimension.\n * The second dimension can be \"variance of degrees\".\n * We can construct graphs with same edge count but different degree variance.\n * E.g., Graph A: Regular graph (variance 0). Graph B: Star graph or Clique + Isolated (high variance).\n * \n * Refined Plan:\n * 1. Determine $N$. We iterate $N$ from 4 to 100.\n * We check if we can pack $M$ Gaussian distributions into the range of expected edge counts $[0, N(N-1)/2]$\n * such that the overlap probability is low.\n * If yes, pick that N and generate graphs with specific edge counts (randomly distributed to be \"generic\" or just first k edges?\n * To minimize variance of \"measured edges\", the generated graph structure doesn't matter much, only the count.\n * Actually, for a fixed edge count, different graphs might have slightly different noise characteristics for structural invariants,\n * but for raw edge count, it depends only on the count).\n * \n * Wait, if edge count is the only feature, we just output `11...100...0`.\n * Is there a way to improve?\n * Yes, if N is capped at 100 and edge count separation is insufficient, we use structure.\n * \n * Structure Idea:\n * Split vertices into 2 sets of size $N/2$.\n * We have 3 blocks of edges: (0,0), (0,1), (1,1).\n * This gives us a 3D feature space (density in block 00, 01, 11).\n * But we can't distinguish block 0 from block 1 easily after shuffling if their sizes are same.\n * If sizes are different (e.g. 1 vs N-1), we can.\n * \n * Actually, let's look at the \"Degree Sequence\" approach.\n * For a graph $G_k$, we set the edge probability $P_{ij}$ for edge $(i,j)$.\n * Since we output deterministic graphs, $P_{ij} \\in \\{0, 1\\}$.\n * \n * For large $\\epsilon$ (e.g. 0.4), information capacity is low.\n * Simple edge count is likely the best we can do because degree variance gets washed out by noise.\n * \n * Let's implement a simulator to pick the best N and the best strategy.\n * Strategy 0: Just modify total number of edges.\n * $G_k$ has $x_k$ edges.\n * Decoder: Count edges $e$, map to nearest expected $E[x_k]$.\n * \n * Strategy 1: Two clusters of different sizes $n_1, n_2$.\n * Densities $d_1, d_{12}, d_2$.\n * This is complex to decode.\n * \n * Let's evaluate Strategy 0.\n * Max edges $L = N(N-1)/2$.\n * Transform: $y = (x - L\\epsilon) / (1-2\\epsilon)$.\n * We want to place $M$ points in $[0, L]$.\n * Spacing $S = L / (M-1)$.\n * Sigma $\\sigma = \\sqrt{L \\epsilon (1-\\epsilon)}$.\n * Z-score $Z = (S/2) / \\sigma$.\n * Error prob $\\approx \\text{erfc}(Z)$.\n * \n * For $N=100, L=4950, M=100, \\epsilon=0.2$.\n * $S = 4950 / 99 = 50$.\n * Effective range scales by $(1-2\\epsilon) = 0.6$.\n * So effective spacing for raw edge count is $50 * 0.6 = 30$.\n * $\\sigma = \\sqrt{4950 * 0.2 * 0.8} = \\sqrt{792} \\approx 28$.\n * $Z = 30/2 / 28 = 0.5$. Error rate is huge.\n * \n * Conclusion: For high $M$ and $\\epsilon$, simple edge count is insufficient.\n * We need to use the individual degrees.\n * \n * Improved Encoding:\n * Assign a \"target degree\" $t_i \\in \\{0, \\dots, N-1\\}$ to each vertex $i$.\n * Construct a graph that matches these degrees as closely as possible.\n * Ideally, we partition vertices into \"bins\".\n * Vertices in bin $b$ are connected to all vertices in bins $0 \\dots b$ (or something similar).\n * This creates a staircase adjacency matrix.\n * \n * Let's simplify:\n * We can vary the \"clique size\".\n * $G_k$ = Clique of size $k$.\n * Degree sequence: $k$ vertices have degree $k-1$, $N-k$ vertices have degree $0$.\n * This is very distinct.\n * With $N=100$, we can vary clique size from 0 to 100 (101 states).\n * Is this better than edge count?\n * Clique size $k$ has $k(k-1)/2$ edges.\n * The edge counts are quadratic. They are sparse for low $k$ and dense for high $k$.\n * We want uniform spacing in \"distinguishability space\".\n * \n * Let's assume we use the full vector of sorted degrees $\\mathbf{d} = (d_1, \\dots, d_N)$ as the feature.\n * Decoder:\n * Receive $H$. Calculate sorted degrees $\\mathbf{d}_H$.\n * Find $k$ that minimizes distance $|\\mathbf{d}_H - E[\\mathbf{d}_{G_k}]|$.\n * \n * How to generate $G_k$?\n * We can define a continuous parameter $p \\in [0, 1]$.\n * We want to map $p$ to a graph $G(p)$.\n * A good trajectory of graphs $G(p)$ should change degrees smoothly and maximize variance.\n * \n * Simple \"staircase\" construction:\n * Order vertices $0 \\dots N-1$.\n * Fill edge $(i, j)$ if $i + j < K$.\n * As we increase $K$ from $0$ to $2N-3$, we fill the matrix.\n * This creates varying degrees.\n * \n * Construction \"Diagonal\":\n * Fill $(i, j)$ if $j \\le i + K$ ? No, undirected.\n * \n * Let's use the simple \"Linear Fill\":\n * Sort all possible edges $(i, j)$ by some criterion, then take first $X$ edges.\n * Criterion: $i + j$.\n * Edges with small $i+j$ connect low-index vertices.\n * This creates vertices with very high degree (low indices) and very low degree (high indices).\n * This maximizes the spread of degrees.\n * Low index vertices act as \"hubs\".\n * \n * Let's compare \"Linear Fill by $i+j$\" vs \"Random Fill\".\n * Random fill: degrees are all roughly $2X/N$. Very tight concentration.\n * $i+j$ fill: degrees vary from near $N$ to near $0$.\n * This high variance in degrees helps because noise affects each degree independently (mostly).\n * \n * So, the plan:\n * 1. Fix N (search for optimal).\n * 2. Generate $M$ graphs.\n * Each graph is defined by taking the first $X_k$ edges from a master list of edges.\n * The master list is sorted by $i+j$ (primary) and $i$ (secondary).\n * This ensures we fill the \"corner\" of the adjacency matrix first.\n * Let's call this \"Corner Fill\".\n * 3. The values $X_0, \\dots, X_{M-1}$ are chosen to be equidistant in terms of \"Distance metric\".\n * Distance between $G_a$ and $G_b$ is defined by the Euclidean distance of their expected sorted degree sequences.\n * Or simpler: just select $X_k$ such that the expected edge counts are spaced.\n * Actually, if we use \"Corner Fill\", the edge count correlates perfectly with the degree distribution shift.\n * We just need to select $X_k$ to maximize separation.\n * \n * Since the error is roughly proportional to $\\sqrt{Edges}$ (actually dependent on density),\n * uniform spacing of Edges is a reasonable starting point.\n * \n * Wait, for high $\\epsilon$, simply counting edges is often statistically stronger than looking at degrees \n * because individual degrees have variance $\\approx N \\epsilon (1-\\epsilon)$ and are correlated.\n * Sum of degrees = 2 * edges.\n * So utilizing the degree distribution is basically a refinement.\n * \n * Optimization of N:\n * We can simulate the \"Success Rate\" for a given N and M, epsilon.\n * For the contest, we can just run a local search or simple heuristic to pick N.\n * Since M <= 100, N=100 is safe but might be penalized.\n * If M is small (10) and eps small (0.01), N=4 is enough?\n * $N=4, M=10$. Edges $0..6$. Not enough for 10 graphs.\n * Need enough capacity.\n * \n * Let's implement a \"Solver\" class.\n * It will try $N \\in \\{4, \\dots, 100\\}$.\n * For a fixed N, we generate M candidate edge counts $e_0, \\dots, e_{M-1}$.\n * To make them robust, we space them out.\n * Ideally $e_k \\approx \\frac{L}{M-1} k$.\n * But we must account for the \"contraction\" due to $\\epsilon$.\n * Actually, we just output graphs with $e_k$ edges. The decoder handles the $\\epsilon$.\n * \n * We will use the \"Corner Fill\" strategy because it produces distinct degree sequences, which *might* help \n * if we use a sophisticated decoder, and certainly doesn't hurt (it's better than random).\n * \n * Decoder:\n * Given H.\n * Compute feature vector $F(H)$.\n * Compare with expected feature vectors $E[F(G_k)]$.\n * Pick closest.\n * \n * Feature vector:\n * 1. Total edges.\n * 2. Sorted degrees?\n * Let's check if sorted degrees help.\n * With Corner Fill, graph $k$ and graph $k+1$ differ by few edges.\n * Degrees change slightly.\n * The \"Total Edges\" is the strongest signal.\n * The \"Sorted Degrees\" adds detail.\n * We can use a Maximum Likelihood Estimator (MLE) approximation.\n * \n * Prob of observing adjacency $A'$ given $A$:\n * $P(A'|A) = \\prod \\dots$\n * This requires summing over permutations. Too slow.\n * \n * Simple Decoder:\n * Just use total edges.\n * $cnt = \\text{popcount}(H)$.\n * Estimate $\\hat{e} = (cnt - L \\epsilon) / (1 - 2\\epsilon)$.\n * Find $k$ such that number of edges in $G_k$ is closest to $\\hat{e}$.\n * \n * Is this enough?\n * Let's run a quick simulation logic inside the `solve` function to pick N.\n * \n * Simulation:\n * For a candidate N:\n * Define $L = N(N-1)/2$.\n * Select $M$ integers $E_0, \\dots, E_{M-1}$ evenly spaced in $[0, L]$.\n * Simulate noise:\n * For each $k$, sample $obs \\sim Binomial(E_k, 1-\\epsilon) + Binomial(L-E_k, \\epsilon)$.\n * Decode $obs$: $\\hat{E} = (obs - L\\epsilon) / (1-2\\epsilon)$.\n * Check if nearest $E_j$ is $E_k$.\n * Count errors.\n * Calculate score.\n * Pick N that maximizes score.\n * \n * Corner case: $\\epsilon$ close to 0.5 (e.g. 0.4). The denominator $1-2\\epsilon$ becomes 0.2.\n * The noise is huge. We definitely need N=100 for large $\\epsilon$.\n * For small $\\epsilon$, we can reduce N.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global parameters\nint M;\ndouble epsilon_val;\n\nstruct Solution {\n int N;\n vector G_str;\n vector edge_counts;\n\n // For decoding, we might just use edge counts. \n // But let's prepare for the actual graph generation.\n};\n\n// Function to count '1's in a string\nint count_ones(const string& s) {\n int c = 0;\n for(char ch : s) if(ch == '1') c++;\n return c;\n}\n\n// Generate the graph string for a given N and number of edges, using \"Corner Fill\"\n// Vertices 0..N-1. We fill edges (u, v) with smallest u+v, then smallest u.\nstring generate_graph(int n, int target_edges) {\n int max_edges = n * (n - 1) / 2;\n target_edges = max(0, min(max_edges, target_edges));\n \n // List all edges\n vector> edges;\n edges.reserve(max_edges);\n for(int i=0; i& a, const pair& b){\n int sum_a = a.first + a.second;\n int sum_b = b.first + b.second;\n if (sum_a != sum_b) return sum_a < sum_b;\n return a.first < b.first;\n });\n \n // Create adjacency matrix/string\n // The output format requires lexicographical order of (i, j).\n // So we first determine which edges are present, then build the string.\n vector> adj(n, vector(n, false));\n for(int k=0; k 100) return 0.0;\n \n int L = n * (n - 1) / 2;\n \n // We choose m edge counts evenly spaced.\n vector targets(m);\n if (m == 1) {\n targets[0] = 0;\n } else {\n for(int i=0; i G/2).\n // P(Z > k) where k = (G/2)/sigma.\n \n if (denom < 1e-9) denom = 0; // Handling eps=0.5, though limit is 0.4\n \n double separation = (m > 1) ? (double)L / (m - 1) * denom : 1e9;\n double z = 0;\n if (sigma > 1e-9) {\n z = (separation / 2.0) / sigma;\n } else {\n z = 1e9; // Infinite separation if no noise\n }\n \n // Error probability approximation using complementary error function\n // P(error) approx erfc(z/sqrt(2)) (one-sided is 0.5*erfc, two-sided is erfc roughly)\n // Actually, for internal points it's 2-sided, for boundaries 1-sided.\n // Average error prob:\n double p_fail_single = 0.5 * erfc(z / sqrt(2.0)); \n // Most points have two neighbors, so 2 * p_fail_single.\n // Endpoints have one neighbor.\n // Approx total error rate E_rate:\n double E_rate = 0.0;\n if (m > 1) {\n double two_sided = 2.0 * p_fail_single;\n double one_sided = p_fail_single;\n // (M-2) points have 2 neighbors, 2 points have 1 neighbor\n E_rate = ((m - 2) * two_sided + 2 * one_sided) / m;\n }\n \n // Simulation requires Expected Failures out of 100 queries.\n double expected_failures = 100.0 * E_rate;\n \n // Score formula\n double score = pow(0.9, expected_failures) / n;\n return score;\n}\n\nint main() {\n // Optimize I/O\n cin.tie(NULL);\n ios_base::sync_with_stdio(false);\n\n if (!(cin >> M >> epsilon_val)) return 0;\n\n // 1. Select optimal N\n // We search N in [4, 100].\n // We prefer smaller N if score is similar, but the formula heavily penalizes failures.\n // 0.9^1 = 0.9. 0.9^5 = 0.59.\n // Changing N from 50 to 100 halves the score factor 1/N, but if it saves 5 errors, 0.59 vs 1.0 is big.\n // However, if errors are already 0, increasing N just hurts.\n \n int best_N = 4;\n double best_score = -1.0;\n \n // Since the function is not monotonic (due to integer rounding of gaps), we scan all.\n for(int n=4; n<=100; ++n) {\n double s = estimate_score(n, M, epsilon_val);\n if (s > best_score) {\n best_score = s;\n best_N = n;\n }\n }\n \n // Generate the M graphs\n int N = best_N;\n cout << N << \"\\n\";\n \n vector target_edges(M);\n int L = N * (N - 1) / 2;\n \n // Generate targets\n if (M == 1) {\n target_edges[0] = 0;\n } else {\n for(int i=0; i expected_edges(M);\n for(int i=0; i> H;\n \n int obs_edges = count_ones(H);\n \n // Find closest expected value\n int best_k = 0;\n double min_dist = 1e18;\n \n for(int k=0; k\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// ---------------------------------------------------------\n// Configuration\n// ---------------------------------------------------------\nconst double TIME_LIMIT = 5.8; \nconst double PHASE1_LIMIT = 1.5; // Focus on finding a valid, dispersed structure quickly\n// Phase 2 takes the rest\n\n// ---------------------------------------------------------\n// Structures\n// ---------------------------------------------------------\nstruct Point {\n int x, y;\n};\n\nstruct Edge {\n int id; // 1-based ID\n int u, v, w; // 1-based vertex indices\n double mx, my;// Midpoint\n};\n\n// ---------------------------------------------------------\n// Globals\n// ---------------------------------------------------------\nint N, M, D, K;\nvector edges;\nvector coords;\n// Adjacency list: adj[u] = {v, edge_index_in_edges_vector}\n// edge_index_in_edges_vector is 0-based\nvector>> adj; \n\nvector solution; // solution[edge_id_1based] = day_1based\nvector> edges_on_day; // day (0-based) -> list of edge indices (0-based)\nvector inv_dist_sq; // Precomputed inverse squared distances\n\nmt19937 rng(12345);\n\n// For connectivity checks\nvector visited_token;\nint token_counter = 0;\n// Static queue for BFS to avoid allocation\nint q_bfs[1005];\n\n// For Dijkstra\nconst long long INF_DIST = 1e15;\n\n// ---------------------------------------------------------\n// Utility\n// ---------------------------------------------------------\ndouble get_time() {\n static auto start_time = chrono::steady_clock::now();\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\ninline float get_inv_dist(int idx1, int idx2) {\n if (idx1 > idx2) swap(idx1, idx2);\n return inv_dist_sq[idx1 * M + idx2];\n}\n\n// ---------------------------------------------------------\n// Connectivity Logic\n// ---------------------------------------------------------\n\n// Checks if the graph is connected when 'edges_to_exclude' are removed.\n// 'edges_to_exclude' is a list of 0-based edge indices.\n// Also optionally excludes one additional edge 'extra_exclude_idx' if >= 0.\nbool is_connected(const vector& edges_to_exclude, int extra_exclude_idx = -1) {\n // Increase token for this run\n token_counter++;\n \n // We need a fast lookup for excluded edges. \n // Marking global array is faster than set/vector search for M=3000.\n static vector edge_excluded_token(M, 0);\n \n // Mark edges\n // Note: We use a separate token counter for edge exclusion to avoid clearing array\n static int edge_token_counter = 0;\n edge_token_counter++;\n if (edge_token_counter == 0) { // overflow handling\n fill(edge_excluded_token.begin(), edge_excluded_token.end(), 0);\n edge_token_counter = 1;\n }\n\n for (int e_idx : edges_to_exclude) {\n edge_excluded_token[e_idx] = edge_token_counter;\n }\n if (extra_exclude_idx != -1) {\n edge_excluded_token[extra_exclude_idx] = edge_token_counter;\n }\n\n int nodes_visited = 0;\n int head = 0, tail = 0;\n \n // Start BFS from node 1\n q_bfs[tail++] = 1;\n visited_token[1] = token_counter;\n nodes_visited++;\n\n while(head < tail) {\n int u = q_bfs[head++];\n \n for (auto& edge : adj[u]) {\n int v = edge.first;\n int e_idx = edge.second;\n \n if (edge_excluded_token[e_idx] == edge_token_counter) continue;\n \n if (visited_token[v] != token_counter) {\n visited_token[v] = token_counter;\n nodes_visited++;\n q_bfs[tail++] = v;\n }\n }\n }\n \n return nodes_visited == N;\n}\n\n// ---------------------------------------------------------\n// Core Logic\n// ---------------------------------------------------------\n\nvoid precompute_distances() {\n inv_dist_sq.resize(M * M);\n for (int i = 0; i < M; ++i) {\n for (int j = i + 1; j < M; ++j) {\n double dx = edges[i].mx - edges[j].mx;\n double dy = edges[i].my - edges[j].my;\n double d2 = dx*dx + dy*dy;\n float val = 1.0f / (float)(d2 + 10.0); // Reduced epsilon for sharper gradients\n inv_dist_sq[i * M + j] = val;\n }\n }\n}\n\n// Standard Dijkstra\nlong long run_dijkstra(int s, const vector& blocked_edge_indices) {\n static vector dist(N + 1);\n static vector dijkstra_blocked_token(M, 0);\n static int d_token = 0;\n\n d_token++;\n if(d_token == 0) { fill(dijkstra_blocked_token.begin(), dijkstra_blocked_token.end(), 0); d_token = 1; }\n\n for(int e : blocked_edge_indices) dijkstra_blocked_token[e] = d_token;\n\n fill(dist.begin(), dist.end(), -1);\n \n // {distance, vertex}\n priority_queue, vector>, greater>> pq;\n\n dist[s] = 0;\n pq.push({0, s});\n\n int visited_cnt = 0;\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (dist[u] != -1 && d > dist[u]) continue;\n visited_cnt++;\n\n for (auto& edge : adj[u]) {\n int v = edge.first;\n int e_idx = edge.second;\n \n if (dijkstra_blocked_token[e_idx] == d_token) continue;\n\n int w = edges[e_idx].w;\n if (dist[v] == -1 || dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.push({dist[v], v});\n }\n }\n }\n\n long long total = 0;\n for (int i = 1; i <= N; ++i) {\n if (dist[i] == -1) return INF_DIST; \n total += dist[i];\n }\n return total;\n}\n\n// ---------------------------------------------------------\n// Initialization\n// ---------------------------------------------------------\n\nvoid initial_solution() {\n visited_token.assign(N + 1, 0);\n\n // Try to generate a valid initial solution\n // We use the radial sort method, but if it fails connectivity, we randomize and retry.\n // The problem guarantees 2-edge connectivity, so valid partitions exist.\n \n while(true) {\n if (get_time() > 1.0) break; // Fallback if taking too long\n\n int center = (rng() % N) + 1;\n \n // BFS Rank\n vector node_rank(N + 1, -1);\n queue q;\n node_rank[center] = 0;\n q.push(center);\n while(!q.empty()){\n int u = q.front(); q.pop();\n for(auto& pair : adj[u]){\n int v = pair.first;\n if(node_rank[v] == -1){\n node_rank[v] = node_rank[u] + 1;\n q.push(v);\n }\n }\n }\n \n // Sort edges\n vector sorted_indices(M);\n iota(sorted_indices.begin(), sorted_indices.end(), 0);\n \n double cx = coords[center-1].x;\n double cy = coords[center-1].y;\n\n sort(sorted_indices.begin(), sorted_indices.end(), [&](int a, int b){\n // Layer logic\n int r1 = min(node_rank[edges[a].u], node_rank[edges[a].v]);\n int r2 = min(node_rank[edges[b].u], node_rank[edges[b].v]);\n if(r1 != r2) return r1 < r2;\n \n // Angle logic\n double ang1 = atan2(edges[a].my - cy, edges[a].mx - cx);\n double ang2 = atan2(edges[b].my - cy, edges[b].mx - cx);\n return ang1 < ang2;\n });\n\n // Assign\n bool possible = true;\n vector> attempt_days(D);\n \n // Fill days\n for (int i = 0; i < M; ++i) {\n attempt_days[i % D].push_back(sorted_indices[i]);\n }\n\n // Check all days\n for(int d=0; d p(M);\n iota(p.begin(), p.end(), 0);\n shuffle(p.begin(), p.end(), rng);\n\n for (int i = 0; i < M; ++i) {\n edges_on_day[i % D].push_back(p[i]);\n solution[p[i]+1] = (i % D) + 1;\n }\n}\n\n// ---------------------------------------------------------\n// Optimization\n// ---------------------------------------------------------\n\ndouble calc_day_potential(int day) {\n const auto& es = edges_on_day[day];\n double pot = 0;\n // Small optimization: if size is huge, maybe sample? No, K is small (avg ~100).\n for (size_t i = 0; i < es.size(); ++i) {\n for (size_t j = i + 1; j < es.size(); ++j) {\n pot += get_inv_dist(es[i], es[j]);\n }\n }\n return pot;\n}\n\nvoid optimize_geometric() {\n vector day_potentials(D);\n double total_potential = 0;\n for(int d=0; d PHASE1_LIMIT) break;\n }\n \n int e_idx = rng() % M; \n int d1 = solution[e_idx+1] - 1;\n int d2 = rng() % D;\n\n if (d1 == d2) continue;\n if (edges_on_day[d2].size() >= K) continue;\n\n // Check connectivity for d2 if we add e_idx? \n // NO. We move e_idx TO d2. So d2 LOSES e_idx from graph. \n // d1 GAINS e_idx back.\n // We need to ensure graph WITHOUT (edges_on_day[d2] + e_idx) is connected.\n \n if (!is_connected(edges_on_day[d2], e_idx)) {\n continue; // Invalid move\n }\n\n // Calc potential change\n double pot_d1_new = day_potentials[d1];\n for (int other : edges_on_day[d1]) {\n if (other == e_idx) continue;\n pot_d1_new -= get_inv_dist(e_idx, other);\n }\n \n double pot_d2_new = day_potentials[d2];\n for (int other : edges_on_day[d2]) {\n pot_d2_new += get_inv_dist(e_idx, other);\n }\n\n double delta = (pot_d1_new + pot_d2_new) - (day_potentials[d1] + day_potentials[d2]);\n \n double time_progress = (get_time() - start_time) / (PHASE1_LIMIT - start_time);\n double temp = T0 * (1.0 - time_progress);\n \n if (delta < 0 || exp(-delta / temp) > generate_canonical(rng)) {\n // Update d1\n auto& v1 = edges_on_day[d1];\n for(size_t i=0; i samples(sample_size);\n \n auto refresh_samples = [&]() {\n vector p(N);\n iota(p.begin(), p.end(), 1);\n shuffle(p.begin(), p.end(), rng);\n for(int i=0; i& blocked, const vector& my_samples) -> long long {\n long long sum = 0;\n for(int s : my_samples) {\n long long val = run_dijkstra(s, blocked);\n if(val >= INF_DIST) return INF_DIST; \n sum += val;\n }\n return sum;\n };\n\n // Initial scores\n vector day_scores(D);\n for(int d=0; d TIME_LIMIT) break;\n // Refresh samples periodically to prevent overfitting\n if (iter % 500 == 0) {\n refresh_samples();\n // Recalculate all scores with new samples\n for(int d=0; d= K) continue;\n\n // Strict Connectivity Check\n if (!is_connected(edges_on_day[d2], e_idx)) continue;\n\n // Proposed sets\n // d1 removes e_idx\n // d2 adds e_idx\n // We need to evaluate change in score.\n // Note: constructing full vector copy is small overhead compared to Dijkstra\n \n // Evaluate d1_new (e_idx removed from blocked list, i.e., added back to graph)\n vector d1_blocked = edges_on_day[d1];\n for(size_t i=0; i d2_blocked = edges_on_day[d2];\n d2_blocked.push_back(e_idx);\n\n long long new_s1 = get_day_score(d1_blocked, samples);\n long long new_s2 = get_day_score(d2_blocked, samples);\n \n long long current_total = day_scores[d1] + day_scores[d2];\n long long new_total = new_s1 + new_s2;\n\n // Simple Greedy / Hill Climbing\n if (new_total <= current_total) {\n // Apply\n edges_on_day[d1] = d1_blocked; // d1_blocked is already correct vector\n edges_on_day[d2] = d2_blocked;\n solution[e_idx+1] = d2 + 1;\n \n day_scores[d1] = new_s1;\n day_scores[d2] = new_s2;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> D >> K)) return 0;\n \n adj.resize(N + 1);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n Edge e;\n e.id = i + 1;\n e.u = u; e.v = v; e.w = w;\n edges.push_back(e);\n adj[u].push_back({v, i});\n adj[v].push_back({u, i});\n }\n \n coords.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].x >> coords[i].y;\n }\n\n for (auto& e : edges) {\n e.mx = (coords[e.u-1].x + coords[e.v-1].x) / 2.0;\n e.my = (coords[e.u-1].y + coords[e.v-1].y) / 2.0;\n }\n solution.resize(M + 1);\n\n precompute_distances();\n\n initial_solution();\n \n // Double check initialization validity for safety\n for(int d=0; d=1 to 0?\n * (Note: Connectivity is also a constraint in the problem statement for the INPUT silhouettes, \n * but the output object doesn't strictly need to be one connected component, though blocks must be. \n * Wait, the problem says \"For each silhouette, all 1 elements form one connected component.\" \n * It does NOT say the output object must preserve this connectivity for the silhouette. \n * It says \"silhouettes ... completely match\". So we just need coverage.)\n * 4. Block Generation:\n * - Intersection voxels -> Shared blocks.\n * - Remaining V1 -> V1-only blocks.\n * - Remaining V2 -> V2-only blocks.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_D = 14;\nconst double TIME_LIMIT = 5.85; \n\n// ---------------- Geometry Structs ----------------\nstruct Point {\n int x, y, z;\n bool operator==(const Point& other) const { return x == other.x && y == other.y && z == other.z; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n Point operator+(const Point& other) const { return {x + other.x, y + other.y, z + other.z}; }\n Point operator-(const Point& other) const { return {x - other.x, y - other.y, z - other.z}; }\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n if (y != other.y) return y < other.y;\n return z < other.z;\n }\n};\n\n// Rotation Matrix Wrapper\nstruct Trans {\n int mx[3][3];\n Point apply(Point p) const {\n return {\n mx[0][0]*p.x + mx[0][1]*p.y + mx[0][2]*p.z,\n mx[1][0]*p.x + mx[1][1]*p.y + mx[1][2]*p.z,\n mx[2][0]*p.x + mx[2][1]*p.y + mx[2][2]*p.z\n };\n }\n // Inverse rotation (transpose for orthogonal matrices)\n Point inverse_apply(Point p) const {\n return {\n mx[0][0]*p.x + mx[1][0]*p.y + mx[2][0]*p.z,\n mx[0][1]*p.x + mx[1][1]*p.y + mx[2][1]*p.z,\n mx[0][2]*p.x + mx[1][2]*p.y + mx[2][2]*p.z\n };\n }\n};\n\n// ---------------- Globals ----------------\nint D;\nvector f1_in, r1_in, f2_in, r2_in;\nvector rotations;\nauto start_time = chrono::high_resolution_clock::now();\n\n// ---------------- Helpers ----------------\ndouble get_time() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\nbool in_bounds(int x, int y, int z) {\n return x >= 0 && x < D && y >= 0 && y < D && z >= 0 && z < D;\n}\nbool in_bounds(Point p) { return in_bounds(p.x, p.y, p.z); }\n\nvoid init_rotations() {\n int basis[3][3] = {{1,0,0}, {0,1,0}, {0,0,1}};\n vector dirs = {{1,0,0}, {-1,0,0}, {0,1,0}, {0,-1,0}, {0,0,1}, {0,0,-1}};\n for(auto& dx : dirs) {\n for(auto& dy : dirs) {\n if (dx.x == dy.x && dx.y == dy.y && dx.z == dy.z) continue;\n if (dx.x == -dy.x && dx.y == -dy.y && dx.z == -dy.z) continue;\n if (dx.x*dy.x + dx.y*dy.y + dx.z*dy.z != 0) continue; \n Point dz = { dx.y*dy.z - dx.z*dy.y, dx.z*dy.x - dx.x*dy.z, dx.x*dy.y - dx.y*dy.x };\n Trans t;\n t.mx[0][0] = dx.x; t.mx[0][1] = dy.x; t.mx[0][2] = dz.x;\n t.mx[1][0] = dx.y; t.mx[1][1] = dy.y; t.mx[1][2] = dz.y;\n t.mx[2][0] = dx.z; t.mx[2][1] = dy.z; t.mx[2][2] = dz.z;\n rotations.push_back(t);\n }\n }\n}\n\n// ---------------- Volume Management ----------------\n// A class to manage a set of voxels and check silhouette constraints efficiently\nstruct Volume {\n bool data[MAX_D][MAX_D][MAX_D];\n int count;\n \n // Silhouette counts: number of voxels covering a specific pixel\n int f_count[MAX_D][MAX_D]; // f[z][x]\n int r_count[MAX_D][MAX_D]; // r[z][y]\n\n Volume() { reset(); }\n\n void reset() {\n memset(data, 0, sizeof(data));\n memset(f_count, 0, sizeof(f_count));\n memset(r_count, 0, sizeof(r_count));\n count = 0;\n }\n\n void init_maximal(const vector& f, const vector& r) {\n reset();\n for(int z=0; z& f, const vector& r) const {\n for(int z=0; z cells1;\n vector cells2;\n};\n\nint main() {\n // IO\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n init_rotations();\n\n cin >> D;\n f1_in.resize(D); r1_in.resize(D);\n f2_in.resize(D); r2_in.resize(D);\n for(int i=0; i> f1_in[i];\n for(int i=0; i> r1_in[i];\n for(int i=0; i> f2_in[i];\n for(int i=0; i> r2_in[i];\n\n // Initial Maximal Volumes\n Volume max_v1, max_v2;\n max_v1.init_maximal(f1_in, r1_in);\n max_v2.init_maximal(f2_in, r2_in);\n\n // 1. Global Alignment Search\n // We want to find R, S such that overlap(max_v1, T(max_v2)) is maximized.\n // This gives us the best starting point for shared blocks.\n \n int best_overlap = -1;\n int best_r = 0;\n Point best_s = {0,0,0};\n\n // To speed up alignment search, convert max_v2 to a list of points\n vector pts2;\n for(int x=0; x overlap count\n // shift = p1 - R(p2)\n // Since coordinates are small, we can use a flat array with offset.\n static int shift_counts[30][30][30]; // indices offset by D\n // Reset (only the touched parts ideally, but small enough)\n // memset is fast\n memset(shift_counts, 0, sizeof(shift_counts));\n \n vector rot_pts2;\n rot_pts2.reserve(pts2.size());\n for(auto& p : pts2) rot_pts2.push_back(R.apply(p));\n\n for(int x=0; x -D && s.x < D && s.y > -D && s.y < D && s.z > -D && s.z < D) {\n shift_counts[s.x+D][s.y+D][s.z+D]++;\n }\n }\n }\n }\n\n // Find max in shift_counts\n for(int sx=-D+1; sx best_overlap) {\n best_overlap = val;\n best_r = r;\n best_s = {sx, sy, sz};\n }\n }\n }\n }\n \n if (get_time() > 1.0) break; // Safety break\n }\n\n // 2. Pruning Phase\n // We have the best alignment. \n // Frame 1: max_v1 (fixed coordinates)\n // Frame 2: max_v2 transformed by best_R, best_S to align with Frame 1.\n \n // Let's maintain two active sets of voxels: cur_v1 and cur_v2.\n // Initially they are max_v1 and max_v2.\n // We want to remove voxels from cur_v1 if they are not in T(cur_v2) AND not essential.\n // We want to remove voxels from cur_v2 if T(cur_v2) is not in cur_v1 AND not essential.\n \n Volume cur_v1 = max_v1;\n Volume cur_v2 = max_v2;\n const Trans& R = rotations[best_r];\n Point S = best_s;\n\n // Helper: map p2 (local) to global frame 1\n auto to_frame1 = [&](Point p2) { return R.apply(p2) + S; };\n // Helper: map p1 (global) to local frame 2\n auto to_frame2 = [&](Point p1) { return R.inverse_apply(p1 - S); };\n\n // Iterative pruning\n // We cycle through all voxels. \n // If a voxel exists in v1 but its counterpart in v2 doesn't exist (or is out of bounds),\n // it's a candidate for removal.\n // Prioritize removing.\n \n bool changed = true;\n while(changed && get_time() < TIME_LIMIT * 0.6) {\n changed = false;\n \n // Prune V1\n // Collect candidates to remove (to avoid iterator invalidation issues logically, though we iterate coords)\n // We shuffle order to avoid bias\n vector p1_candidates;\n for(int x=0; x p2_candidates;\n for(int x=0; x blocks;\n int block_id_counter = 1;\n \n // Map to track coverage\n // 0: unused, 1: covered\n // We need to be careful: we modify the \"Grid\" logic but here we operate on lists.\n // Let's reconstruct I, R1, R2 explicitly.\n \n set set_I; // stored in Frame 1 coords\n set set_R1; // Frame 1 coords\n set set_R2; // Frame 2 coords\n\n for(int x=0; x& source_set) {\n vector> components;\n while(!source_set.empty()) {\n vector comp;\n vector q;\n Point start = *source_set.begin();\n source_set.erase(source_set.begin());\n q.push_back(start);\n comp.push_back(start);\n \n int head = 0;\n while(head < q.size()) {\n Point u = q[head++];\n int dx[] = {1,-1,0,0,0,0}, dy[] = {0,0,1,-1,0,0}, dz[] = {0,0,0,0,1,-1};\n for(int k=0; k<6; ++k) {\n Point v = {u.x+dx[k], u.y+dy[k], u.z+dz[k]};\n if (source_set.count(v)) {\n source_set.erase(v);\n q.push_back(v);\n comp.push_back(v);\n }\n }\n }\n components.push_back(comp);\n }\n return components;\n };\n\n // Shared blocks\n auto comps_I = extract_components(set_I);\n for(auto& comp : comps_I) {\n FinalBlock b;\n b.id = block_id_counter++;\n b.cells1 = comp;\n for(auto& p : comp) b.cells2.push_back(to_frame2(p));\n blocks.push_back(b);\n }\n\n // R1 blocks\n auto comps_R1 = extract_components(set_R1);\n for(auto& comp : comps_R1) {\n FinalBlock b;\n b.id = block_id_counter++;\n b.cells1 = comp;\n // cells2 empty\n blocks.push_back(b);\n }\n\n // R2 blocks\n auto comps_R2 = extract_components(set_R2);\n for(auto& comp : comps_R2) {\n FinalBlock b;\n b.id = block_id_counter++;\n b.cells2 = comp;\n // cells1 empty\n blocks.push_back(b);\n }\n\n // 4. Output Generation\n int map1[MAX_D][MAX_D][MAX_D];\n int map2[MAX_D][MAX_D][MAX_D];\n memset(map1, 0, sizeof(map1));\n memset(map2, 0, sizeof(map2));\n\n for(auto& b : blocks) {\n for(auto& p : b.cells1) map1[p.x][p.y][p.z] = b.id;\n for(auto& p : b.cells2) map2[p.x][p.y][p.z] = b.id;\n }\n\n cout << blocks.size() << \"\\n\";\n \n // Output Map 1\n for(int x=0; x 0$ to the root. This is a Steiner Tree problem.\n * Since N is small (100), we can approximate the Steiner Tree cost using a Minimum Spanning Tree on the subset\n * of active nodes, or simply by the union of shortest paths from root to each active node (Dijkstra).\n *\n * Phase B: Local Search / Optimization\n * - Start with a solution where all residents are assigned to their nearest station.\n * - Try to \"move\" residents from one station to another.\n * - Moving a resident might increase the $P$ of the new station but decrease the $P$ of the old one.\n * - It might also change the set of active stations, affecting edge costs.\n * - Try to \"deactivate\" a station by moving all its residents to other nearby stations. This saves the edge connection cost\n * but likely increases coverage costs ($\\sum P^2$).\n *\n * Phase C: Edge Pruning\n * - Once the set of required stations (with $P_i > 0$) is fixed, we need the minimum cost subgraph connecting them to root.\n * - We can use a heuristic Steiner Tree algorithm:\n * 1. Start with all edges in the shortest path tree from root to all required nodes.\n * 2. Greedily remove redundant edges if connectivity is maintained.\n * 3. Or, construct a Metric Closure on required nodes and run MST, then map back to original graph edges (Standard Steiner Tree approx).\n * Given N=100, a simpler approach is: Compute Dijkstra from root. For every required node, trace back parents. Union these edges.\n * Then try to run a Randomized Kruskal's or Prim's restricted to the nodes involved to see if we can find cheaper paths.\n *\n * 4. Refined Approach for Contest:\n * - The coordinate range is [-10000, 10000]. N=100, K=2000-5000.\n * - $P_i \\le 5000$.\n * - Since we must cover ALL residents (to get a non-trivial score), we focus on minimizing cost for full coverage.\n * \n * Algorithm:\n * 1. Calculate distance matrix `dist_mat[k][i]` (resident k to station i).\n * 2. Initial State:\n * - For each resident, find the station with minimal `dist_mat[k][i]`. Let's call this `nearest[k]`.\n * - Initially, active stations are those that are `nearest` for at least one resident.\n * - $P_i = \\max ( \\text{dist}(k, i) )$ for all $k$ assigned to $i$.\n * - Calculate edge cost to connect these stations.\n *\n * 3. Optimization (Hill Climbing / Simulated Annealing):\n * - State: Assignment of each resident to a station.\n * - Neighbor Move 1: Change assignment of resident $k$ from station $u$ to station $v$ (where $v$ is close to $k$).\n * - Neighbor Move 2: Turn off a leaf station in the current tree if its residents can be cheaply covered by neighbors.\n * \n * Evaluating the cost of a state is expensive (Steiner Tree). We need a proxy or fast update.\n * Fast Steiner Tree approximation:\n * - Maintain the set of \"active\" stations (those with assigned residents).\n * - Cost = MST of (Active Stations + Root + Steiner Points?). Actually, just taking the union of Shortest Paths from Root is a good upper bound.\n * - Better: Precompute all-pairs shortest paths (Floyd-Warshall or N Dijkstra). The cost to add a node $u$ to an existing tree $T$ is $\\min_{v \\in T} \\text{dist}_{graph}(u, v)$.\n * - Let's stick to: Cost = $\\sum P_i^2 + \\text{SteinerTreeCost}(\\text{ActiveNodes})$.\n *\n * 4. Specific heuristic for \"Broadcasting\":\n * - Often it's better to have a few powerful stations than many weak ones, because edge costs are high?\n * - Or maybe edge costs are low? $100 D \\le w \\le 2500 D$. $P^2$ grows fast.\n * - Let's check magnitudes. Max distance ~20000. $P \\le 5000$. $P^2$ can be $25 \\times 10^6$.\n * - Edge weights: Distance 1000 -> $w \\approx 10^5 \\dots 2.5 \\times 10^6$.\n * - So turning on an edge costs roughly $(300 \\dots 500)^2$ in terms of power.\n * - It suggests we should aggregate residents to stations to avoid long cable runs, but $P^2$ penalty discourages huge radii.\n * - Balance is key.\n *\n * 5. Implementation Details:\n * - Precompute APSP (All-Pairs Shortest Paths) on the graph (only 100 nodes).\n * - State Representation: `P[i]` array.\n * - We don't need to store resident assignment explicitly in the state for local search if we define state by \"active stations and their powers\".\n * - Actually, let's define state by the boolean vector of \"Used Edges\" and integer vector \"P\".\n * - But the search space is too big.\n * - Back to: State = { active_stations }.\n * - Residents are assigned to the active station that covers them with minimal $P_i$ increase? No, residents are simply covered if dist <= P.\n * - Let's iterate on P.\n * \n * Let's try a \"Power Optimization\" approach.\n * 1. Start with all P=0.\n * 2. Identify uncovered residents.\n * 3. Pick a resident. Find cheapest way to cover it:\n * - Increase P of an already connected station. Cost: $(P_{new}^2 - P_{old}^2)$.\n * - Connect a new station and set its P. Cost: Path_to_root + $P_{new}^2$.\n * \n * This looks like a greedy construction. Let's do a randomized greedy or beam search.\n * \n * Refined Algorithm:\n * 1. Compute APSP between all nodes $u, v$. Store path reconstruction info.\n * 2. K-Means like clustering? No, the graph structure is fixed.\n * 3. Attempt: Randomized Greedy with Decay.\n * - Initially, tree contains only root (Station 1).\n * - While uncovered residents exist:\n * - Select a subset of uncovered residents (or one).\n * - Try to cover them by:\n * a) Increasing P of a node in current tree.\n * b) Extending the tree to a new node $v$ and setting $P_v$ to cover.\n * - Pick the option with best (Cost Increase / Residents Covered) ratio.\n * 4. Post-process: Prune edges. Prune powers.\n * - Iterate nodes $u$: try reducing $P_u$. If some residents become uncovered, can they be covered by neighbors cheaply?\n * - Re-calculate MST/Steiner Tree for the set of nodes with $P > 0$.\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Types ---\nusing ll = long long;\nconst ll INF_LL = 1e18;\nconst int MAX_P = 5000;\n\nstruct Point {\n int x, y;\n};\n\nstruct Edge {\n int u, v, w, id;\n};\n\nstruct Resident {\n int x, y, id;\n};\n\n// --- Global Inputs ---\nint N, M, K;\nvector stations;\nvector edges;\nvector residents;\nvector>> adj; // u -> {v, weight}\n\n// --- Precomputed Data ---\n// dist_residents[k][i] = squared euclidean distance from resident k to station i\n// We store squared distance to avoid sqrt until necessary, but P is linear radius.\n// Problem says P_i >= dist. So P_i^2 >= dist^2.\n// Wait, problem says \"circular region of radius P_i\". So coverage: dist_eucl(k, i) <= P_i.\n// Which is dist_sq(k, i) <= P_i^2.\nvector> dist_sq_residents; \n\n// Graph shortest paths (weights)\nvector> graph_dist; \n// Next hop for reconstruction\nvector> graph_next_hop; \n\n// --- Utility Functions ---\n\nint dist_sq(const Point& p1, const Point& p2) {\n return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);\n}\n\nint dist_sq(const Resident& r, const Point& p) {\n return (r.x - p.x) * (r.x - p.x) + (r.y - p.y) * (r.y - p.y);\n}\n\n// Standard Dijkstras for APSP on small N=100\nvoid precompute_apsp() {\n graph_dist.assign(N + 1, vector(N + 1, INF_LL));\n graph_next_hop.assign(N + 1, vector(N + 1, -1));\n\n for (int i = 1; i <= N; ++i) {\n graph_dist[i][i] = 0;\n priority_queue, vector>, greater>> pq;\n pq.push({0, i});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d > graph_dist[i][u]) continue;\n\n for (auto& edge : adj[u]) {\n int v = edge.first;\n int w = edge.second;\n if (graph_dist[i][u] + w < graph_dist[i][v]) {\n graph_dist[i][v] = graph_dist[i][u] + w;\n // To reconstruct path i -> ... -> v, we want the predecessor of v?\n // Or simply storing distances is enough for Steiner approximation, \n // and we reconstruct tree explicitly later.\n // Let's store nothing for next_hop for now, simple Dijkstra is enough.\n pq.push({graph_dist[i][v], v});\n }\n }\n }\n }\n}\n\n// --- Solution Representation ---\nstruct Solution {\n vector P;\n vector edge_on;\n ll score;\n\n Solution() : P(N + 1, 0), edge_on(M, false), score(INF_LL) {}\n};\n\n// --- Logic to build edge set from Active Nodes ---\n// Given a set of nodes with P > 0, construct a low-cost tree connecting them to root (1).\n// We use a simple heuristic: Steiner Tree approx using MST on metric closure or just union of shortest paths.\n// Since N is small, we can be greedy:\n// Start with component {1}.\n// Iteratively add the closest required node to the current component.\npair> build_connectivity(const vector& P_vals) {\n vector is_active(N + 1, false);\n vector active_nodes;\n active_nodes.push_back(1);\n for (int i = 2; i <= N; ++i) {\n if (P_vals[i] > 0) {\n is_active[i] = true;\n active_nodes.push_back(i);\n }\n }\n\n // Prim-like algorithm to connect all active_nodes\n // But we are operating on the original graph.\n // We want to connect all `active_nodes` to the component containing `1`.\n // Actually, this is exactly the Steiner Tree problem.\n // Heuristic:\n // Set C = {1}. Set R = {active_nodes} \\ {1}.\n // While R is not empty:\n // Find u in C, v in R minimizing dist(u, v).\n // Add path u-v to the tree edges.\n // Add all nodes on path u-v to C. Remove v from R.\n \n // This works well.\n vector in_component(N + 1, false);\n in_component[1] = true;\n \n // We need to keep track of which edges are used\n vector used_edges(M, false);\n ll edges_cost = 0;\n\n // To efficiently find closest, we can just iterate. N is small.\n int num_connected = 1;\n int target_count = active_nodes.size(); \n \n // Since active_nodes includes 1, size is correct.\n // If only 1 is active, we are done.\n if (target_count <= 1) return {0, used_edges};\n\n // Optimization: track min dist from component to each node\n vector min_dist_to_comp(N + 1, INF_LL);\n vector parent_in_comp(N + 1, -1); // which node in comp is closest\n \n // Initialize with node 1\n for(int i=1; i<=N; ++i) {\n min_dist_to_comp[i] = graph_dist[1][i];\n parent_in_comp[i] = 1;\n }\n\n int remain = target_count - 1;\n \n // Which nodes from R are still not in C?\n vector covered(N + 1, false); // covered means in component\n covered[1] = true;\n\n // Keep adding until all required nodes are covered\n while(remain > 0) {\n int best_node = -1;\n ll best_val = INF_LL;\n\n // Find closest required node not yet covered\n for (int i : active_nodes) {\n if (!covered[i]) {\n if (min_dist_to_comp[i] < best_val) {\n best_val = min_dist_to_comp[i];\n best_node = i;\n }\n }\n }\n\n if (best_node == -1) break; // Should not happen if connected\n\n // Add path from best_node to parent_in_comp[best_node]\n int curr = best_node;\n int target = parent_in_comp[best_node];\n \n // Reconstruct path using a simple BFS/Dijkstra or just run Dijkstra again restricted to search?\n // We precomputed distances but not predecessors.\n // Let's run a quick search to find the actual path from `target` to `curr` (or vice versa)\n // and mark edges.\n // Since we need to mark edges on the path and add nodes to component.\n \n // Find path from `target` (in comp) to `curr` (outside) with length `best_val`.\n // Wait, graph_dist stores shortest path length. We need the actual path.\n // We can recover it step by step.\n \n int u = target;\n int v = curr;\n // Reconstruct path from u to v\n // Backward reconstruction from v to u using distances\n int temp_curr = v;\n while (temp_curr != u) {\n covered[temp_curr] = true;\n \n // Find neighbor w that satisfies dist(u, w) + weight(w, temp_curr) == dist(u, temp_curr)\n // AND dist(u, temp_curr) should match the optimal distance segment?\n // Actually, simply: dist(u, temp_curr) == dist(u, w) + weight.\n // Be careful: min_dist_to_comp[i] is dist from some node in comp.\n // `best_val` is exactly graph_dist[target][curr].\n \n bool found = false;\n for (auto& edge : adj[temp_curr]) {\n int neighbor = edge.first;\n int w_idx = edge.second; // weight\n // Identify edge index\n // We need edge index from input.\n // Let's store edge index in adj.\n // Done: struct Edge has id. adj needs to store id too? \n // Let's scan edges or update adj.\n // Updating adj to store {v, weight, id} is better.\n }\n \n // Let's update ADJ structure first to support this efficiently\n break; // Placeholder\n }\n \n // Since reconstructing path is annoying without predecessors, let's do a slightly different greedy:\n // Prim's algorithm on the graph of *all* nodes, but we only care about connecting `active_nodes`.\n // Actually, standard \"Union of Shortest Paths\" is a decent heuristic.\n // Let's refine the \"Add closest required node\" strategy.\n // When we add `best_node`, we trace the shortest path from `best_node` to `parent_in_comp[best_node]`.\n // All edges on this path are added. All nodes on this path are added to the component.\n // We update min_dist_to_comp for all remaining nodes using the newly added nodes.\n \n // RE-IMPLEMENTATION INSIDE LOOP:\n // 1. Reconstruct path from `target` to `curr`.\n // Since we know dist[target][curr], we pick neighbor `next` of `curr` such that \n // dist[target][next] + weight(next, curr) == dist[target][curr].\n // Add edge (next, curr).\n // Move curr to next. Repeat until curr == target.\n // 2. For each node `x` on this path (including original `curr`):\n // If `x` was required and not covered, decrement remain.\n // Mark `x` as covered.\n // Update `min_dist_to_comp` for all other nodes using `x` as source.\n \n vector path_nodes;\n temp_curr = v;\n while (temp_curr != u) {\n path_nodes.push_back(temp_curr);\n int best_next = -1;\n int best_edge_id = -1;\n \n for (const auto& e : edges) {\n int neighbor = -1;\n if (e.u == temp_curr) neighbor = e.v;\n else if (e.v == temp_curr) neighbor = e.u;\n \n if (neighbor != -1) {\n if (abs(graph_dist[u][neighbor] + e.w - graph_dist[u][temp_curr]) < 1e-9) { // integer arithmetic though\n if (graph_dist[u][neighbor] + e.w == graph_dist[u][temp_curr]) {\n best_next = neighbor;\n best_edge_id = e.id;\n break; \n }\n }\n }\n }\n \n // Add edge\n if (!used_edges[best_edge_id]) {\n used_edges[best_edge_id] = true;\n edges_cost += edges[best_edge_id].w;\n }\n temp_curr = best_next;\n }\n path_nodes.push_back(u); // Add target (already covered but useful for updates)\n \n // Process new nodes in component\n for (int newly_added : path_nodes) {\n // If this node was a required node and not counted yet\n // (Check logic: `covered` tracks if it's in component. \n // `is_active` tracks if it's required.\n // We need to decrement remain if `is_active[newly_added]` was true and `covered` was false BEFORE this loop?\n // No, let's just track strictly.)\n \n if (!covered[newly_added]) {\n covered[newly_added] = true;\n if (is_active[newly_added]) {\n remain--;\n }\n \n // Update distances\n for (int i = 1; i <= N; ++i) {\n if (!covered[i]) {\n ll d = graph_dist[newly_added][i]; // Precomputed APSP\n if (d < min_dist_to_comp[i]) {\n min_dist_to_comp[i] = d;\n parent_in_comp[i] = newly_added;\n }\n }\n }\n } else {\n // Even if covered, if we just 'reached' it via path reconstruction, \n // we don't need to do anything because it's already a source for distances.\n // However, strictly speaking, path reconstruction goes backwards from `curr` (outside) to `target` (inside).\n // `curr` is new. `target` is old. Intermediate nodes are new.\n // We should iterate path nodes in any order to update.\n }\n }\n // Since we iterate path_nodes, we might process `u` again. `covered[u]` is true, so no update triggered. Correct.\n // But wait, path_nodes includes `v` (curr) which was NOT covered.\n // Correct.\n }\n \n return {edges_cost, used_edges};\n}\n\n// --- Main Solver Class ---\n\nclass Solver {\npublic:\n void solve() {\n // 1. Read Input\n cin >> N >> M >> K;\n stations.resize(N + 1);\n for (int i = 1; i <= N; ++i) cin >> stations[i].x >> stations[i].y;\n \n adj.resize(N + 1);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n edges.push_back({u, v, w, i});\n adj[u].push_back({v, w}); // ID needed?\n adj[v].push_back({u, w});\n }\n \n residents.resize(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].x >> residents[i].y;\n residents[i].id = i;\n }\n\n // 2. Precompute\n precompute_apsp();\n dist_sq_residents.assign(K, vector(N + 1));\n for (int k = 0; k < K; ++k) {\n for (int i = 1; i <= N; ++i) {\n dist_sq_residents[k][i] = dist_sq(residents[k], stations[i]);\n }\n }\n\n // 3. Initial Solution: Closest Station\n // Assign each resident to the closest station.\n vector assignment(K);\n vector P(N + 1, 0);\n \n for (int k = 0; k < K; ++k) {\n int best_i = -1;\n int best_d = 2e9; // large enough\n for (int i = 1; i <= N; ++i) {\n if (dist_sq_residents[k][i] < best_d) {\n best_d = dist_sq_residents[k][i];\n best_i = i;\n }\n }\n assignment[k] = best_i;\n int needed_P = (int)ceil(sqrt(best_d));\n if (needed_P > P[best_i]) P[best_i] = needed_P;\n }\n \n // Build connectivity for initial solution\n auto [edge_cost, edge_mask] = build_connectivity(P);\n \n ll current_p_cost = 0;\n for(int p : P) current_p_cost += (ll)p * p;\n \n ll best_score = current_p_cost + edge_cost;\n vector best_P = P;\n vector best_edge_mask = edge_mask;\n\n // 4. Optimization Loop\n // We will use Hill Climbing / Simulated Annealing\n // Moves:\n // 1. Move a resident to a different station (one of the K-nearest stations).\n // 2. Pick a station, set P=0 (force drop), reassign its residents to nearest active stations.\n \n // Since evaluating full cost is expensive (Steiner Tree), we do it carefully.\n // Randomized Local Search\n \n auto start_time = chrono::steady_clock::now();\n double time_limit = 1.85; \n \n mt19937 rng(12345);\n\n while (true) {\n auto curr_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(curr_time - start_time).count();\n if (elapsed > time_limit) break;\n\n // Strategy:\n // Randomly pick a station `u` that is active.\n // Try to reduce its power or turn it off completely.\n // Or pick a resident and move it.\n \n // Let's implement \"Move Resident\"\n int k = uniform_int_distribution(0, K - 1)(rng);\n int old_station = assignment[k];\n \n // Pick a new station for this resident\n // Prefer stations that are already active or close\n int new_station = uniform_int_distribution(1, N)(rng);\n \n if (new_station == old_station) continue;\n \n // Backup state\n int old_P_u = P[old_station];\n int old_P_v = P[new_station];\n \n // Apply change\n assignment[k] = new_station;\n \n // Recompute P for old_station and new_station\n // This is O(K) effectively if we scan all residents, can be optimized by maintaining lists\n // Since K is up to 5000 and we have 1.8s, O(K) per iteration is okay if iteration count is not huge.\n // Better: maintain `vector> station_residents`.\n \n // Let's optimize `P` update\n // We need to find max dist for old_station after removal\n // and max dist for new_station after addition.\n \n // Lazy check: just recompute P for these two stations\n // (To do this fast, we need to know which residents are assigned to them)\n // Let's keep assignment vector.\n \n // Actually, recomputing P for old_station requires scanning all its residents.\n // Let's do the scan. It's not too slow.\n \n auto recalc_P = [&](int station_idx) {\n int max_d_sq = 0;\n // We iterate all K? Slow.\n // We should maintain reverse mapping.\n // But for a simple contest submission, let's try full K scan first, if TLE, optimize.\n // With K=5000, 10^5 ops/sec => 10^5 * K = 5*10^8 ops. Too slow for 2 sec.\n // We MUST maintain reverse lists.\n return 0; \n };\n \n // We can't afford O(K) per move inside the loop.\n // Let's change strategy:\n // Perturb the *Power Vector P* directly?\n // No, P depends on assignment.\n // Let's maintain `vector> residents_of_station(N+1)`.\n }\n \n // RESTARTING OPTIMIZATION WITH BETTER DATA STRUCTURES\n vector> residents_of(N + 1);\n for(int k=0; k(curr_time - start_time).count();\n if (elapsed > time_limit) break;\n }\n \n // MOVES\n // 1. Transfer resident k from u to v.\n // 2. Merge: Move all residents from u to v (if v is close).\n \n int type = uniform_int_distribution(0, 10)(rng);\n \n if (type < 6) { // Single resident move\n int k = uniform_int_distribution(0, K - 1)(rng);\n int u = assignment[k];\n // Pick v: prioritize active nodes or close nodes\n int v;\n if (uniform_int_distribution(0, 1)(rng)) {\n // Pick completely random\n v = uniform_int_distribution(1, N)(rng);\n } else {\n // Pick one of the active nodes (P > 0)\n vector actives;\n for(int i=1; i<=N; ++i) if(P[i] > 0) actives.push_back(i);\n if (actives.empty()) v = 1; // Should not happen\n else v = actives[uniform_int_distribution(0, actives.size()-1)(rng)];\n }\n \n if (u == v) continue;\n \n // Check if new P is within bounds\n int dist_k_v = dist_sq_residents[k][v];\n if (dist_k_v > 5000 * 5000) continue; // Too far\n \n // Calculate cost delta\n // Change in P_u^2 + P_v^2\n // P_v will be max(current_P_v, dist_k_v_sqrt)\n // P_u might decrease.\n \n int old_Pu = P[u];\n int old_Pv = P[v];\n \n // Tentative new P_v\n int new_Pv = max(old_Pv, (int)ceil(sqrt(dist_k_v)));\n \n // Tentative new P_u\n // We need to find max dist in residents_of[u] excluding k\n int new_Pu = 0;\n // Optimization: if k was not defining the max radius, P_u doesn't change.\n // If k was defining it, we need to scan.\n // Scan residents_of[u] is O(|Res_u|). On average K/N ~ 50. Fast enough.\n bool u_needs_recalc = false;\n if ((int)ceil(sqrt(dist_sq_residents[k][u])) == old_Pu) {\n u_needs_recalc = true;\n }\n \n if (!u_needs_recalc) {\n new_Pu = old_Pu;\n } else {\n int max_d = 0;\n for (int r : residents_of[u]) {\n if (r == k) continue;\n max_d = max(max_d, dist_sq_residents[r][u]);\n }\n new_Pu = (int)ceil(sqrt(max_d));\n }\n \n ll p_cost_delta = ((ll)new_Pu * new_Pu + (ll)new_Pv * new_Pv) - ((ll)old_Pu * old_Pu + (ll)old_Pv * old_Pv);\n \n // Edge cost delta?\n // This is expensive. We estimate.\n // If P_u becomes 0, we might save edge costs.\n // If P_v was 0 and becomes > 0, we might pay edge costs.\n // If both stay active/inactive state same, edge cost = 0 delta.\n \n bool u_was_active = (old_Pu > 0);\n bool u_is_active = (new_Pu > 0);\n bool v_was_active = (old_Pv > 0);\n bool v_is_active = (new_Pv > 0);\n \n // If activity status doesn't change, accept based on P cost.\n // If it changes, we need to run Steiner check.\n bool status_change = (u_was_active != u_is_active) || (v_was_active != v_is_active);\n \n // Heuristic acceptance\n if (!status_change) {\n if (p_cost_delta <= 0) {\n // Accept\n assignment[k] = v;\n P[u] = new_Pu;\n P[v] = new_Pv;\n \n // Update residents lists\n // Remove k from u\n for(size_t idx=0; idx actives;\n for(int i=1; i<=N; ++i) if(P[i] > 0 && i!=1) actives.push_back(i); // keep 1? maybe not\n if (actives.empty()) continue;\n int u = actives[uniform_int_distribution(0, actives.size()-1)(rng)];\n \n // Pick `v` close to `u`\n // Use precomputed graph dist to find nearby stations\n int v = -1;\n ll min_dist = INF_LL;\n \n // Try a few random nodes or iterate all\n for (int cand=1; cand<=N; ++cand) {\n if (cand == u) continue;\n if (graph_dist[u][cand] < min_dist) {\n min_dist = graph_dist[u][cand];\n v = cand;\n }\n }\n // Or randomly pick one nearby\n // Let's refine: pick v that is already active to encourage consolidation\n vector targets;\n for(int i=1; i<=N; ++i) if (i!=u) targets.push_back(i);\n if(targets.empty()) continue;\n v = targets[uniform_int_distribution(0, targets.size()-1)(rng)];\n\n // Try moving ALL residents of u to v\n if (residents_of[u].empty()) continue;\n \n bool feasible = true;\n int max_req_v = 0;\n for (int r : residents_of[v]) max_req_v = max(max_req_v, dist_sq_residents[r][v]);\n \n for (int r : residents_of[u]) {\n if (dist_sq_residents[r][v] > 5000*5000) {\n feasible = false; \n break;\n }\n max_req_v = max(max_req_v, dist_sq_residents[r][v]);\n }\n \n if (!feasible) continue;\n \n // Calculate costs\n int new_Pv = (int)ceil(sqrt(max_req_v));\n int new_Pu = 0;\n int old_Pv = P[v];\n int old_Pu = P[u];\n \n // Apply temp\n P[v] = new_Pv;\n P[u] = new_Pu;\n \n auto [new_edge_cost, new_mask] = build_connectivity(P);\n \n ll new_p_cost = 0;\n for(int i=1; i<=N; ++i) new_p_cost += (ll)P[i] * P[i];\n ll new_total_score = new_p_cost + new_edge_cost;\n \n if (new_total_score < best_score) {\n best_score = new_total_score;\n best_P = P;\n best_edge_mask = new_mask;\n \n // Update assignment and lists\n for(int r : residents_of[u]) {\n assignment[r] = v;\n residents_of[v].push_back(r);\n }\n residents_of[u].clear();\n } else {\n // Revert\n P[u] = old_Pu;\n P[v] = old_Pv;\n }\n }\n }\n\n // Final Check: Ensure Validity\n // We used `best_P` and `best_edge_mask` which correspond to `best_score`.\n // However, because we accepted some moves without checking edge costs (when status didn't change),\n // `best_score` might be slightly off or `best_edge_mask` might be stale relative to `best_P` if we didn't call build_connectivity.\n // Actually, in the code above:\n // 1. Single resident move, no status change: We updated `P` and `assignment`, but `best_edge_mask` is NOT updated.\n // The edge cost doesn't change, so `best_score` estimate is correct, but `best_edge_mask` is old.\n // This is fine because the SET of active nodes didn't change, so the MST is valid.\n // 2. Status change / Merge: We called build_connectivity and updated `best_edge_mask`.\n // So, `best_edge_mask` is valid for the SET of active nodes in `best_P`.\n \n // Output\n for (int i = 1; i <= N; ++i) cout << best_P[i] << (i == N ? \"\" : \" \");\n cout << endl;\n for (int i = 0; i < M; ++i) cout << (best_edge_mask[i] ? 1 : 0) << (i == M - 1 ? \"\" : \" \");\n cout << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n Solver solver;\n solver.solve();\n return 0;\n}","ahc021":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_OPS = 10000;\n\nstruct Coord {\n int x, y;\n bool operator==(const Coord& other) const { return x == other.x && y == other.y; }\n};\n\nstruct Op {\n Coord p1;\n Coord p2;\n};\n\nint grid[N][N];\nvector operations;\n\nvoid do_swap(Coord c1, Coord c2) {\n if (c1 == c2) return;\n swap(grid[c1.x][c1.y], grid[c2.x][c2.y]);\n operations.push_back({c1, c2});\n}\n\n// Sift down the value at (x, y) until the heap property is satisfied\n// or it reaches the bottom.\nvoid sift_down(int x, int y) {\n int cx = x, cy = y;\n while (cx < N - 1) {\n int child_l_val = grid[cx + 1][cy];\n int child_r_val = grid[cx + 1][cy + 1];\n int current_val = grid[cx][cy];\n\n // If current is smaller than both children, we are done locally.\n if (current_val < child_l_val && current_val < child_r_val) {\n break;\n }\n\n // Otherwise, swap with the smaller child\n if (child_l_val < child_r_val) {\n // Left is smaller, swap with left\n do_swap({cx, cy}, {cx + 1, cy});\n cx = cx + 1;\n cy = cy;\n } else {\n // Right is smaller (or equal), swap with right\n do_swap({cx, cy}, {cx + 1, cy + 1});\n cx = cx + 1;\n cy = cy + 1;\n }\n }\n}\n\nvoid solve() {\n // Bottom-up heap construction\n // We iterate from the second to last row up to the top.\n // This order ensures that when we process a node, its subtrees are already heapified,\n // so we only need to push the current node down.\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n sift_down(x, y);\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> grid[i][j];\n }\n }\n\n solve();\n\n cout << operations.size() << \"\\n\";\n for (const auto& op : operations) {\n cout << op.p1.x << \" \" << op.p1.y << \" \" << op.p2.x << \" \" << op.p2.y << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"/**\n * @brief Transit Warehouse Solution\n * \n * Strategy:\n * 1. Build a spanning tree that balances depth and branching factor.\n * A purely random DFS or BFS is suboptimal. We want a \"comb-like\" structure \n * or a \"long snake with small offshoots\" to allow differentiation between\n * very large values (deep in snake) and medium values (offshoots).\n * \n * 2. Assign a \"target rank\" to every cell.\n * We simulate a filling process where we always fill the deepest available node.\n * The order in which nodes are filled gives them a score from 0 to M-1.\n * Higher score = filled earlier = should hold larger values.\n * Lower score = filled later = closer to root = should hold smaller values.\n * \n * 3. Online placement:\n * For a container with value T:\n * - Calculate its percentile P among remaining unseen values.\n * - Identify currently \"placeable\" cells (leaves of the empty tree).\n * - Pick the leaf whose score is closest to the expected score for percentile P.\n * \n * 4. Retrieval:\n * Maintain a priority queue of accessible filled cells (initially just the ones adjacent to entrance).\n * Always pick the smallest value available to remove.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Global configuration\nconst int D = 9;\nconst int MAX_VAL = D * D; \n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n bool operator<(const Point& other) const { if (r != other.r) return r < other.r; return c < other.c; }\n};\n\nint dist(Point a, Point b) {\n return abs(a.r - b.r) + abs(a.c - b.c);\n}\n\n// Directions: Up, Left, Down, Right\nconst int dr[] = {-1, 0, 1, 0};\nconst int dc[] = {0, -1, 0, 1};\n\nstruct Node {\n Point p;\n vector children_idx;\n int parent_idx = -1;\n int id; // index in the nodes array\n \n // Heuristic score: intended relative order (0 = last to be filled/root, High = first to be filled/deep)\n int fill_order_rank = -1; \n};\n\nint N_obstacles;\nvector obstacles;\nbool is_obstacle[D][D];\nbool has_container[D][D];\nint container_val[D][D]; // Value stored at r,c\n\nPoint entrance = {0, (D - 1) / 2};\nvector entrance_adj;\n\n// The tree structure\nvector nodes;\nint root_node_idx = -1;\n// Map coordinates to node index\nint grid_node_map[D][D];\n\n// Available numbers management\nbool seen_number[MAX_VAL];\n\n// Check valid coordinate\nbool in_bounds(int r, int c) {\n return r >= 0 && r < D && c >= 0 && c < D;\n}\n\n// Initialize basic grid info\nvoid init_grid() {\n for(int r=0; r usable_cells;\n for(int r=0; r q;\n vector visited(D*D, false);\n \n // Root is effectively the entrance.\n // But the entrance cannot hold items. Its neighbors can.\n // We connect entrance to its neighbors.\n \n // Let's just treat the grid as a graph.\n // We want a parent pointer for every valid storage cell towards the entrance.\n \n // Priority for DFS: prefer neighbors that have fewer free neighbors (heuristic to avoid isolating cells).\n // Or simply prefer neighbors that are \"far\" from entrance to drive the path deep? No.\n \n // Let's stick to a BFS for tree shape stability, but modify the queue to be a Deque or PriorityQueue\n // to create \"long\" branches.\n // Actually, a pure \"Snake\" (Hamiltonian path) is ideal if N=0. \n // With obstacles, it's a tree.\n \n // Let's try to build the tree by traversing \"away\" from entrance.\n // Cells: Storage cells.\n // Root: We can imagine a super-root connected to entrance neighbors.\n // Let's just pick one entrance neighbor as the primary start if possible, or all of them.\n \n // Actually, to define \"leaves\" for placement, we need the parent-child relationship.\n // Parent = Closer to entrance (in the path sense).\n // Child = Further.\n \n // BFS usually gives \"bushy\" trees (bad for sorting, good for access).\n // DFS gives \"long\" trees (good for sorting).\n // We want DFS.\n \n auto get_idx = [&](int r, int c) { return r*D + c; };\n \n // We'll build the tree explicitly.\n // Start DFS from all entrance neighbors.\n \n vector dfs_stack;\n // We shuffle entrance neighbors to add randomness\n vector seeds;\n for(auto p : entrance_adj) {\n if(!is_obstacle[p.r][p.c]) seeds.push_back(p);\n }\n // Sort seeds? No, random is fine or fixed.\n // Let's sort by distance to center to break symmetry deterministically?\n \n // Mark entrance and obstacles as visited\n visited[get_idx(entrance.r, entrance.c)] = true;\n for(int r=0; r p_map(D*D, -1); // Parent mapping for reconstruction\n\n vector S;\n // Add seeds.\n // Note: We must connect seeds to entrance.\n for(auto p : seeds) {\n // Don't mark visited yet, let the loop handle\n // But we need to know they come from entrance\n p_map[get_idx(p.r, p.c)] = get_idx(entrance.r, entrance.c);\n S.push_back(p);\n // Mark seeds visited in stack to avoid duplication?\n // Standard DFS logic:\n }\n \n // Actually, strictly, let's just run DFS from entrance.\n // The neighbors are naturally pushed.\n \n // We want to visit all reachable nodes.\n // To avoid \"trapping\" pockets, we might need `visited` check on push?\n // Standard DFS: Mark on pop? No, mark on push (or strictly on discovery).\n \n // Reset\n fill(visited.begin(), visited.end(), false);\n visited[get_idx(entrance.r, entrance.c)] = true;\n for(int r=0; r> nbs;\n for(int i=0; i<4; ++i) {\n int nr = u.r + dr[i];\n int nc = u.c + dc[i];\n if(in_bounds(nr, nc) && !visited[get_idx(nr, nc)]) {\n // Heuristic: number of free neighbors\n int free_n = 0;\n for(int k=0; k<4; ++k) {\n int nnr = nr + dr[k];\n int nnc = nc + dc[k];\n if(in_bounds(nnr, nnc) && !visited[get_idx(nnr, nnc)]) free_n++;\n }\n // Heuristic 2: Distance to entrance (further is better)\n // Heuristic 3: Prefer moving towards the \"back\" (larger r) or \"sides\"\n int dist_ent = abs(nr - entrance.r) + abs(nc - entrance.c);\n \n // Combine: prefer low free_n (hugging walls/obstacles), high dist\n int score = -free_n * 100 + dist_ent;\n \n nbs.push_back({score, {nr, nc}});\n }\n }\n sort(nbs.rbegin(), nbs.rend()); // Descending score\n vector res;\n for(auto& kv : nbs) res.push_back(kv.second);\n return res;\n };\n\n // Re-implement DFS using explicit stack and parent tracking\n // The stack will store (u, p)\n struct State { Point u; Point p; };\n vector stack;\n \n // Initial neighbors\n auto initial_nbs = get_sorted_neighbors(entrance);\n // Push in reverse so best is popped first\n reverse(initial_nbs.begin(), initial_nbs.end());\n for(auto p : initial_nbs) stack.push_back({p, entrance});\n \n while(!stack.empty()) {\n State top = stack.back();\n stack.pop_back();\n \n int u_idx = get_idx(top.u.r, top.u.c);\n if(visited[u_idx]) continue;\n visited[u_idx] = true;\n \n // Add to tree\n int p_idx_in_nodes = grid_node_map[top.p.r][top.p.c];\n \n Node new_node;\n new_node.p = top.u;\n new_node.id = nodes.size();\n new_node.parent_idx = p_idx_in_nodes;\n nodes[p_idx_in_nodes].children_idx.push_back(new_node.id);\n grid_node_map[top.u.r][top.u.c] = new_node.id;\n nodes.push_back(new_node);\n \n // Add neighbors\n auto nbs = get_sorted_neighbors(top.u);\n reverse(nbs.begin(), nbs.end());\n for(auto next_p : nbs) {\n stack.push_back({next_p, top.u});\n }\n }\n}\n\n// Assign priorities to nodes based on a simulation of filling\n// Logic: \"Deepest available\" node gets the highest rank (reserved for large numbers).\nvoid assign_priorities() {\n // We simulate the filling process.\n // At each step, we identify all \"available\" nodes (leaves of the current empty tree).\n // We greedily pick the one that is \"deepest\" or \"most desirable\" for a large number.\n // The one we pick gets rank M. The next M-1, etc.\n \n // What is \"deepest\"?\n // Distance from root in the tree? Yes.\n // Tie-breaker? Subtree size?\n // Let's use (Depth, -SubtreeSize) as priority.\n // Actually, since we are filling leaves, the \"depth\" is static.\n \n int num_nodes = nodes.size(); // Includes dummy root\n // Actual storage nodes\n vector storage_nodes;\n for(int i=1; i depth(num_nodes, 0);\n vector degree(num_nodes, 0); // Number of children\n vector parent(num_nodes, -1);\n \n for(auto& node : nodes) {\n degree[node.id] = node.children_idx.size();\n for(int child : node.children_idx) {\n depth[child] = depth[node.id] + 1;\n parent[child] = node.id;\n }\n }\n \n // \"Available\" means degree is 0 (leaf in the dependency tree)\n // Note: In the actual problem, we fill a spot if it's empty and reachable.\n // In our tree model, we only fill leaves of the tree to preserve reachability of the rest of the tree.\n // This is a subset of valid moves, but a safe one.\n \n // Priority Queue for simulation: Stores node indices.\n // Ordered by Depth desc.\n auto comp = [&](int a, int b) {\n if (depth[a] != depth[b]) return depth[a] < depth[b]; // Max depth first\n return a < b;\n };\n priority_queue, decltype(comp)> pq(comp);\n \n vector current_degree = degree;\n \n for(int i=1; i> N_obstacles;\n if (cin.fail()) return; // Local test end or error\n\n init_grid();\n \n for(int i=0; i> r >> c;\n is_obstacle[r][c] = true;\n obstacles.push_back({r, c});\n }\n \n build_tree();\n assign_priorities();\n \n int total_containers = (D * D) - 1 - N_obstacles;\n \n // Used for tracking which numbers have appeared\n for(int i=0; i current_degree(nodes.size(), 0);\n for(auto& n : nodes) current_degree[n.id] = n.children_idx.size();\n \n // Active leaves (available spots)\n // We can just scan or maintain a set. Since D is small, scanning is fast.\n // But a set ordered by fill_order_rank is better.\n auto leaf_comp = [&](int a, int b) {\n return nodes[a].fill_order_rank < nodes[b].fill_order_rank;\n };\n // We want to quickly find a node with rank close to Target.\n // Sorted vector is fine.\n \n // Track available spots\n vector available_spots;\n for(int i=1; i<(int)nodes.size(); ++i) {\n if(current_degree[i] == 0) available_spots.push_back(i);\n }\n \n // Main Placement Loop\n for(int d=0; d> t;\n seen_number[t] = true;\n \n // 1. Estimate Rank of t among remaining numbers\n int smaller_unseen = 0;\n int total_unseen = 0;\n \n // This loop is O(M), M~80. Fast enough.\n // Optim: precalculate total unseen count.\n for(int v=0; v 0) {\n percentile = (double)smaller_unseen / (double)total_unseen;\n } else {\n percentile = 1.0; // Last item, doesn't matter\n }\n \n // 2. Map percentile to available spots\n // We have 'available_spots'. \n // But wait, we shouldn't just look at available spots.\n // We should look at the 'ideal' global rank we want to fill.\n // The set of ALL remaining empty spots has a distribution of 'fill_order_rank'.\n // We want to fill a spot that corresponds to 'percentile'.\n // BUT we are constrained to 'available_spots'.\n \n // Let's list all remaining empty spots and sort them by 'fill_order_rank'.\n vector all_empty_spots; \n for(int i=1; i<(int)nodes.size(); ++i) {\n if(container_val[nodes[i].p.r][nodes[i].p.c] == -1) {\n all_empty_spots.push_back(i);\n }\n }\n sort(all_empty_spots.begin(), all_empty_spots.end(), [&](int a, int b){\n return nodes[a].fill_order_rank < nodes[b].fill_order_rank;\n });\n \n // Target index in the sorted list of all empty spots\n int target_idx = (int)round(percentile * (all_empty_spots.size() - 1));\n int target_node = all_empty_spots[target_idx];\n int target_rank = nodes[target_node].fill_order_rank;\n \n // Now find the BEST MATCH from 'available_spots'\n int best_node = -1;\n int min_diff = 999999;\n \n // Tie-breaking: If multiple spots have same rank diff?\n // Not possible since ranks are unique.\n \n for(int cand : available_spots) {\n int diff = abs(nodes[cand].fill_order_rank - target_rank);\n if(diff < min_diff) {\n min_diff = diff;\n best_node = cand;\n }\n }\n \n // Place\n Point p = nodes[best_node].p;\n cout << p.r << \" \" << p.c << endl;\n \n has_container[p.r][p.c] = true;\n container_val[p.r][p.c] = t;\n \n // Update tree state\n // Remove best_node from available\n // Update parent's degree\n // If parent becomes available, add to list\n \n // Inefficient remove from vector, but N is small.\n for(auto it = available_spots.begin(); it != available_spots.end(); ++it) {\n if(*it == best_node) {\n available_spots.erase(it);\n break;\n }\n }\n \n int parent_id = nodes[best_node].parent_idx;\n if(parent_id != -1 && parent_id != 0) {\n current_degree[parent_id]--;\n if(current_degree[parent_id] == 0) {\n available_spots.push_back(parent_id);\n }\n }\n }\n \n // Retrieval Phase\n // We need to output the sequence of retrieval.\n // We must respect reachability.\n // In our tree logic, a node is reachable if its parent is removed (or it's adjacent to entrance).\n // Actually, reachability is geometric. But since we filled a tree, geometric reachability is guaranteed if we remove in Parent->Child order?\n // Wait.\n // Placement: Child filled before Parent. (Leaves first).\n // Retrieval: Parent removed before Child. (Root first).\n // Yes, removing the root of a subtree makes the children accessible.\n // So we can maintain a \"frontier\" of removable nodes.\n // Initially, this is the children of the dummy root (entrance).\n // We greedily pick the node with the SMALLEST value from the frontier.\n \n priority_queue, vector>, greater>> pq_retrieve;\n \n // Initial accessible nodes: children of dummy root\n for(int child : nodes[0].children_idx) {\n // The child is a valid container spot.\n // Value is in container_val\n int val = container_val[nodes[child].p.r][nodes[child].p.c];\n pq_retrieve.push({val, child});\n }\n \n while(!pq_retrieve.empty()) {\n pair top = pq_retrieve.top();\n pq_retrieve.pop();\n \n int u = top.second;\n Point p = nodes[u].p;\n \n cout << p.r << \" \" << p.c << endl;\n \n // Add children to PQ\n for(int child : nodes[u].children_idx) {\n int val = container_val[nodes[child].p.r][nodes[child].p.c];\n pq_retrieve.push({val, child});\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc024":"#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 = 50;\nconst int M = 100;\nconst int EMPTY = 0;\n\n// Directions\nconst int DR[] = {-1, 1, 0, 0};\nconst int DC[] = {0, 0, -1, 1};\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n};\n\n// Global State\nint grid[N][N];\nint original_grid[N][N];\nbool target_adj[M + 1][M + 1];\nint current_adj_count[M + 1][M + 1];\n\n// RNG\nmt19937 rng(12345);\n\n// Helper to get neighbors (valid coordinates only)\nvector get_neighbors(int r, int c) {\n vector nb;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n nb.push_back({nr, nc});\n }\n }\n return nb;\n}\n\n// Check connectivity for a specific color using BFS\nbool check_connectivity(int color, const vector& members) {\n if (members.empty()) return true;\n \n // Map coordinates to index in members for quick lookup, or use a visited grid\n // Since N is small, a static visited array is fine\n static int visited[N][N];\n static int visit_token = 0;\n visit_token++;\n \n int start_r = members[0].r;\n int start_c = members[0].c;\n \n queue q;\n q.push({start_r, start_c});\n visited[start_r][start_c] = visit_token;\n \n int count = 0;\n while (!q.empty()) {\n Point p = q.front();\n q.pop();\n count++;\n \n for (int i = 0; i < 4; ++i) {\n int nr = p.r + DR[i];\n int nc = p.c + DC[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n if (grid[nr][nc] == color && visited[nr][nc] != visit_token) {\n visited[nr][nc] = visit_token;\n q.push({nr, nc});\n }\n }\n }\n }\n \n return count == members.size();\n}\n\n// Check if a color was originally adjacent to boundary (0)\n// This is captured in target_adj[0][c]\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n_in, m_in;\n cin >> n_in >> m_in; // n=50, m=100 fixed\n \n // 1. Read Input\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cin >> original_grid[r][c];\n grid[r][c] = original_grid[r][c];\n }\n }\n \n // 2. Analyze Target Adjacency\n // Initialize\n for (int i = 0; i <= M; ++i) {\n for (int j = 0; j <= M; ++j) {\n target_adj[i][j] = false;\n }\n }\n \n // Check grid adjacencies\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = original_grid[r][c];\n \n // Check 4 neighbors\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v;\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n v = original_grid[nr][nc];\n } else {\n v = 0; // Outside is color 0\n }\n \n if (u != v) {\n target_adj[u][v] = true;\n target_adj[v][u] = true;\n }\n }\n }\n }\n \n // 3. Initialize Current Adjacency Counts\n // We need to maintain counts to know if removing a cell breaks the LAST connection\n // or creates a FORBIDDEN connection.\n for (int i = 0; i <= M; ++i) {\n for (int j = 0; j <= M; ++j) current_adj_count[i][j] = 0;\n }\n\n // Count current adjacencies in the working grid\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = grid[r][c];\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n \n if (u < v) { // Count each edge once\n current_adj_count[u][v]++;\n current_adj_count[v][u]++;\n }\n }\n }\n }\n\n // Track member cells for each color for fast connectivity checking\n vector> color_cells(M + 1);\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n color_cells[grid[r][c]].push_back({r, c});\n }\n }\n \n // 4. Iterative Shrinking\n // Candidates are non-zero cells adjacent to 0\n // Since checking candidates is fast, we can just iterate or keep a set.\n // A set of (r,c) is good.\n \n vector candidates;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n bool adj_zero = false;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n if (v == 0) {\n adj_zero = true;\n break;\n }\n }\n if (adj_zero) candidates.push_back({r, c});\n }\n }\n }\n \n // Shuffle candidates to avoid bias\n shuffle(candidates.begin(), candidates.end(), rng);\n \n // We can loop multiple times. In each pass, we try to remove cells.\n // If we remove a cell, its neighbors become new candidates.\n \n // Using a set for unique candidates in queue\n // But simple iteration over the grid or shuffling is often robust enough given the time limit.\n // Let's try a queue-based approach with a 'in_queue' check to propagate erosions.\n // Actually, since we want to maximize deletions, we can just loop until no progress is made.\n // With N=50, checking all cells is fast.\n \n bool changed = true;\n auto start_time = chrono::high_resolution_clock::now();\n \n while (changed) {\n changed = false;\n \n // Collect boundary cells\n vector boundary_cells;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != 0) {\n bool is_boundary = false;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n if (v == 0) {\n is_boundary = true;\n break;\n }\n }\n if (is_boundary) boundary_cells.push_back({r, c});\n }\n }\n }\n \n shuffle(boundary_cells.begin(), boundary_cells.end(), rng);\n \n for (const auto& p : boundary_cells) {\n int r = p.r;\n int c = p.c;\n int color = grid[r][c];\n \n if (color == 0) continue; // Already removed\n \n // --- CHECKS ---\n \n // 1. Check Adjacency Constraints\n bool possible = true;\n \n // Check neighbors of (r,c)\n vector neighbor_colors;\n for (int i = 0; i < 4; ++i) {\n int nr = r + DR[i];\n int nc = c + DC[i];\n int v = (nr >= 0 && nr < N && nc >= 0 && nc < N) ? grid[nr][nc] : 0;\n neighbor_colors.push_back(v);\n }\n \n // A. Check if removing breaks a required adjacency (color <-> neighbor)\n // B. Check if removing creates a forbidden adjacency (neighbor <-> 0)\n \n // A. Breakage\n // The edges being removed are between 'color' and each 'v' in neighbor_colors.\n // Note: multiple neighbors might have same color v. We need to count carefully.\n map edges_to_remove;\n for (int v : neighbor_colors) {\n if (v != color) { // Internal edges (color-color) don't count for adjacency between distinct sets\n edges_to_remove[v]++;\n }\n }\n \n for (auto const& [v, count] : edges_to_remove) {\n if (target_adj[color][v]) {\n if (current_adj_count[color][v] - count <= 0) {\n possible = false;\n break;\n }\n }\n }\n if (!possible) continue;\n \n // B. Forbidden exposure\n // If (r,c) becomes 0, then every neighbor v becomes adjacent to 0.\n // If target_adj[v][0] is false, this is forbidden.\n // Note: if v is already adjacent to 0 elsewhere, this is fine? \n // Actually, the condition \"if and only if there exist adjacent squares...\".\n // If v and 0 are adjacent in created map (which they will be if we turn (r,c) to 0),\n // then they MUST be adjacent in original map.\n // So we just check target_adj[v][0].\n for (int v : neighbor_colors) {\n if (v != 0 && v != color) { // If v is 0, it's fine. If v is color, it will be checked recursively later or it's fine (self).\n if (!target_adj[v][0]) {\n possible = false;\n break;\n }\n }\n }\n if (!possible) continue;\n\n // 2. Check Connectivity of 'color'\n // Optimization: Only check if local connectivity is broken\n // If the 3x3 area neighbors of 'color' are connected within 3x3 excluding center,\n // then global connectivity is preserved (assuming simply connected initially).\n // But general case: removing a node can disconnect a graph.\n // We construct the new list of cells temporarily.\n vector& cells = color_cells[color];\n vector next_cells;\n next_cells.reserve(cells.size());\n for(auto& cp : cells) {\n if(cp.r != r || cp.c != c) next_cells.push_back(cp);\n }\n \n if (!check_connectivity(color, next_cells)) {\n continue;\n }\n \n // 3. Check Connectivity of 0?\n // Problem says \"squares of color 0 can be connected through the outside\".\n // Since we only erode from boundary (adjacent to 0), the new 0 cell connects to existing 0.\n // We ensure the \"outside\" is a single component.\n // However, could we create an \"island\" of colors inside a ring of 0s?\n // No, because we only turn a cell to 0 if it touches an existing 0. \n // So the set of 0s stays connected.\n \n // --- COMMIT ---\n \n // Update Counts\n // Remove edges (color, v)\n for (int v : neighbor_colors) {\n if (v != color) {\n current_adj_count[color][v]--;\n current_adj_count[v][color]--;\n }\n }\n \n // Add edges (0, v)\n // But wait, if we change (r,c) to 0, it might merge with neighbor 0s.\n // The edges between the new 0 and neighbor 0s are 0-0 edges (internal), not counted in adj map usually?\n // Adjacency map counts edges between distinct sets.\n // Edges between new 0 and neighbor v (where v != 0):\n for (int v : neighbor_colors) {\n if (v != 0) { \n // Note: neighbor v was adjacent to 'color', now adjacent to '0'.\n // Wait, if v was 'color' (same component), now it is adjacent to '0'.\n // Correct logic:\n // The cell at (r,c) changes from 'color' to 0.\n // Neighbors that were v != 0 are now adjacent to this new 0.\n // Neighbors that were 0 are now adjacent to this new 0 (internal 0-0 edge).\n if (v != 0) {\n current_adj_count[0][v]++;\n current_adj_count[v][0]++;\n }\n }\n }\n\n // Update Grid\n grid[r][c] = 0;\n color_cells[color] = next_cells;\n changed = true;\n \n // Time check\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1800) {\n goto end_loops;\n }\n }\n }\n \n end_loops:;\n \n // 5. Output\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 cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"/**\n * AHC025 - Unweighable\n * \n * Strategy:\n * 1. Initial Sorting:\n * Since we want to partition items into equal-weight sets, knowing the relative order of weights is crucial.\n * We perform a merge sort to get a rough ordering of items by weight. Since comparisons are expensive and limited,\n * we need to be careful. However, with N up to 100 and Q up to 32N (min 2N), a full sort (N log N approx 665 for N=100)\n * might be feasible if Q is large, but risky if Q is small.\n * \n * Actually, N=100, N log2 N approx 664. Minimum Q is 2N = 200.\n * So we cannot always afford a full sort. We should prioritize sorting larger items or use a partial sort / approximate sort.\n * Let's try to maintain a sorted list. If Q is small, we might just sort into groups or do random comparisons to estimate.\n * \n * Strategy A (Small Q): Approximate sort or group-based sort.\n * Strategy B (Large Q): Full Merge Sort.\n * \n * Let's use a hybrid approach. We'll implement a standard `std::sort` with a custom comparator that uses the query.\n * To save queries, we can cache comparison results, but since we only compare once usually in sort, caching isn't huge.\n * \n * 2. Initial Distribution:\n * Once items are sorted (heaviest to lightest), we distribute them using a \"greedy snake\" approach (serpentine distribution).\n * Set 0 gets item 0, Set 1 gets item 1... Set D-1 gets item D-1.\n * Then Set D-1 gets item D, Set D-2 gets item D+1...\n * This balances the weights roughly.\n * \n * 3. Refinement (Hill Climbing / Simulated Annealing):\n * After the initial distribution, the sums won't be perfectly equal.\n * We have remaining queries. We use them to improve the balance.\n * \n * We want to compare the total weights of two sets, say Set A and Set B.\n * If weight(Set A) > weight(Set B), we should move an item from A to B, or swap a heavy item from A with a light item from B.\n * \n * However, the query allows comparing arbitrary subsets.\n * The most direct check for \"Is Set A heavier than Set B?\" is to put all items of A on Left and all items of B on Right.\n * Since items are distinct (partitioned), L and R are disjoint.\n * \n * Algorithm loop until Q runs out:\n * a. Pick two sets, say $S_i$ and $S_j$.\n * Heuristic to pick: Pick based on history? Or random?\n * Let's maintain a rough estimate of set weights? No, we can't know absolute values.\n * But we can maintain an ordering of sets.\n * Let's keep the sets sorted by their approximate total weight.\n * To do this, we can compare two sets $S_i$ and $S_j$ using 1 query.\n * b. If $S_i > S_j$, we try to swap items to reduce the gap.\n * If we just swap random items, we don't know if it improves.\n * We need to know individual item weights relative to the gap.\n * \n * Refined Strategy for Phase 2:\n * - Measure the relative order of the D sets. Sort the sets $S_{p_0}, S_{p_1}, \\dots, S_{p_{D-1}}$ such that $Weight(S_{p_0}) < Weight(S_{p_1}) < \\dots$.\n * This takes some queries. Since D is small (up to N/4 = 25), sorting D sets takes $D \\log D$ comparisons.\n * - Once we know the heaviest set $H$ and the lightest set $L$, we want to move weight from $H$ to $L$.\n * - Operations:\n * 1. Move an item $x \\in H$ to $L$.\n * 2. Swap $x \\in H$ and $y \\in L$ such that $w_x > w_y$.\n * - To do this effectively without exact weights, we rely on the sorted order of items from Phase 1.\n * If we swap a heavy item from $H$ with a light item from $L$, the gap decreases.\n * We need to check if we \"overshot\" (i.e., $H$ becomes lighter than $L$ significantly).\n * \n * Wait, the distribution of weights is exponential. There are a few very heavy items and many light ones.\n * The heavy items dominate the variance.\n * \n * Revised Complete Algorithm:\n * Phase 1: Sort all items.\n * Use `std::sort` with the query.\n * Constraint check: If we run out of queries during sort, we abort the sort and use the partially sorted array.\n * Since exponential distribution, sorting the heaviest items is most important.\n * Maybe sort only top K items fully if Q is tight?\n * Actually, standard sort is quite adaptive. Let's try full sort.\n * \n * Phase 2: Initial Greedy Assignment.\n * Sort indices $0..N-1$ based on the result of Phase 1.\n * Distribute items $0..N-1$ (heaviest to lightest) into buckets $0..D-1$ using serpentine method.\n * \n * Phase 3: Balancing.\n * While queries remain:\n * 1. Identify the current Heavy bucket and Light bucket.\n * We don't know absolute weights. We can maintain the current total weight relative to each other? No.\n * We can assume our greedy distribution made them roughly equal.\n * Let's pick two buckets at random (or cyclically). Compare them.\n * Actually, let's try to keep a \"Leaderboard\" of buckets.\n * But comparing sum of sets is expensive if sets change often.\n * \n * Alternative for Phase 3:\n * Since we sorted items, we have a strong prior $w_0 < w_1 < \\dots < w_{N-1}$.\n * Let's estimate weights!\n * Since weights are drawn from Exp(1e-5) and rounded, expected value is roughly const * (-ln(uniform)).\n * Or simpler: The sorted ranks give us expected weights.\n * $E[w_{(i)}] \\approx F^{-1}(i/N)$ roughly.\n * Let's assign \"virtual weights\" to items based on their sorted rank and the expected distribution of order statistics of Exponential distribution.\n * Virtual Weight $v_i$.\n * \n * Then, we can simulate the balancing process locally using $v_i$.\n * This gives a target configuration.\n * However, real weights deviate.\n * \n * Let's use the query to correct the virtual weights or the set sums.\n * Idea: The \"virtual weight\" approach is good for initialization, but we have the balance scale.\n * \n * Algorithm:\n * 1. Sort items $i_0, i_1, \\dots, i_{N-1}$ by weight (Light -> Heavy).\n * 2. Assign tentative weights $w^*_{k}$ to the item at rank $k$.\n * For exponential distribution, the expected value of the $k$-th smallest of $N$ items is $\\sum_{j=1}^{k+1} \\frac{1}{N-j+1}$ (scaled).\n * Let's use these expected values as proxies.\n * 3. Optimization Loop:\n * Current partition is based on minimizing variance of proxy sums.\n * Repeat while query budget > threshold:\n * a. Calculate proxy sums of all sets.\n * b. Pick the set $S_{max}$ with max proxy sum and $S_{min}$ with min proxy sum.\n * c. We suspect $Weight(S_{max}) > Weight(S_{min})$. Verify this with 1 query.\n * Result:\n * - If $S_{max} > S_{min}$: Our proxy is likely correct direction-wise.\n * We want to reduce gap.\n * Try to find a swap $(u \\in S_{max}, v \\in S_{min})$ or move $u \\in S_{max} \\to S_{min}$\n * that minimizes the proxy variance difference, but be careful not to overshoot.\n * Since we confirmed the gap exists, we perform the move/swap if the proxy model suggests it's an improvement.\n * *Crucial*: After the move, we should update our \"belief\" about the total weights? \n * Actually, if the scale says $S_{max} > S_{min}$, and we move a small amount, it's likely safe.\n * If we swap items with large rank difference, we might flip the inequality.\n * \n * - If $S_{max} < S_{min}$: Our proxy model is wrong!\n * The set we thought was heavy is actually lighter than the set we thought was light.\n * This means the specific items in $S_{min}$ are heavier than expected relative to items in $S_{max}$.\n * We can update the proxy weights?\n * Simple update: Multiply all weights in $S_{min}$ by $(1+\\alpha)$ and in $S_{max}$ by $(1-\\alpha)$.\n * Then re-calculate proxy sums and repeat.\n * \n * - If $S_{max} == S_{min}$: Perfect balance between these two.\n * Maybe pick the next max/min pair.\n * \n * This \"Proxy Weight Adjustment\" seems robust. It combines the statistical expectation with ground truth feedback.\n *\n * Refined Update Logic:\n * - Initialize $v_i$ = Expected value of $i$-th smallest item in Exp dist.\n * - Loop:\n * - Identify candidate sets $L, R$ (e.g. max and min proxy weight sums).\n * - Query: Compare $L$ vs $R$.\n * - If $L > R$:\n * - If proxy says $Sum(L) < Sum(R)$, we have a contradiction. Increase weights of items in $L$, decrease in $R$.\n * - If proxy says $Sum(L) > Sum(R)$, consistent. We can try to improve balance by swapping/moving items based on proxy weights.\n * Find a move that reduces $|Sum(L) - Sum(R)|$ according to proxy.\n * Perform the move virtually.\n * - If $L < R$:\n * - Symmetric to above.\n * - If $L = R$:\n * - If proxy says different, adjust weights to bring sums closer.\n * \n * Termination:\n * - When Q is exhausted.\n *\n * Initial Sort Implementation details:\n * - Since Q can be small (2N), we might not finish full sort.\n * - Check Q before every comparison. If Q=0, treat as equal (or stop sorting).\n * - If sorting stops early, we rely on the partial order.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --------------------------------------------------------------\n// Global Variables & Constants\n// --------------------------------------------------------------\nint N, D, Q;\nint query_count = 0;\n\n// Random engine\nmt19937 rng(12345);\n\n// --------------------------------------------------------------\n// Query Handling\n// --------------------------------------------------------------\n\n// Returns:\n// 1 if Left > Right\n// -1 if Left < Right\n// 0 if Left == Right\n// -2 if query limit exceeded (should handle gracefully)\nint query(const vector& L, const vector& R) {\n if (query_count >= Q) return -2;\n \n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << endl;\n \n query_count++;\n \n string res;\n cin >> res;\n if (res == \">\") return 1;\n if (res == \"<\") return -1;\n return 0;\n}\n\n// Helper for single item comparison\n// Returns true if i < j (weight)\n// Caches results? No, memory is cheap but logic is complex. \n// Simple direct comparison for sorting.\nbool compare_items(int i, int j) {\n if (i == j) return false;\n // Query: Left={i}, Right={j}\n // If i < j (weight), result is '<' (-1).\n int res = query({i}, {j});\n if (res == -2) return false; // Fallback\n return res == -1; \n}\n\n// --------------------------------------------------------------\n// Data Structures\n// --------------------------------------------------------------\n\nstruct Item {\n int id;\n int rank; // rank after sorting (0 = lightest)\n double est_weight; // Estimated weight\n};\n\n// --------------------------------------------------------------\n// Utilities\n// --------------------------------------------------------------\n\n// Generate expected values for order statistics of Exponential Distribution\n// E[X_(k)] for sample size n from Exp(lambda) is sum(1/(n-i+1)) for i=1..k * (1/lambda)\n// Since we care about relative weights, 1/lambda cancels out.\nvector get_expected_order_stats(int n) {\n vector stats(n);\n double current = 0.0;\n for (int i = 0; i < n; ++i) {\n // The smallest item (rank 0) corresponds to the first term\n // The i-th smallest (0-indexed)\n current += 1.0 / (n - i);\n stats[i] = current;\n }\n return stats;\n}\n\n// --------------------------------------------------------------\n// Main Solver\n// --------------------------------------------------------------\n\nvoid solve() {\n cin >> N >> D >> Q;\n \n vector p(N);\n iota(p.begin(), p.end(), 0);\n\n // --- Phase 1: Sort Items ---\n // We want to sort items by weight.\n // If Q is very limited, we might not finish. \n // Check budget. \n // Comparison sort requires roughly N log N.\n // With N=100, ~700 queries. Q >= 200.\n // If Q is small, we might want to save queries for balancing.\n // Let's reserve some queries for Phase 3.\n // Phase 3 needs at least ~N queries to be effective? Or just D log D?\n // Let's reserve roughly N queries for balancing if possible, but prioritize sorting.\n \n int sort_budget = Q - min(Q / 2, N * 2); \n if (sort_budget < 0) sort_budget = Q; // Use all if Q is tiny\n\n // Custom sort with budget check inside comparator\n // We use std::stable_sort to minimize comparisons if already partially ordered?\n // Actually, merge sort is good.\n // Let's try to use a lambda with capture.\n \n bool stopped_sorting = false;\n \n // Using a custom merge sort or std::sort might be tricky with early exit.\n // But std::sort compares A and B. If we run out of queries, we must return something consistent.\n // If budget out, we can stop querying and just use indices to break ties (random order).\n \n auto comp = [&](int i, int j) {\n if (query_count >= sort_budget) {\n stopped_sorting = true;\n return i < j; // Fallback deterministic\n }\n return compare_items(i, j);\n };\n\n // Try to sort.\n // Note: std::sort might not handle inconsistent comparison well if we switch logic mid-way,\n // but here we switch to deterministic index comparison which is a valid total ordering.\n stable_sort(p.begin(), p.end(), comp);\n \n // --- Phase 2: Assign Initial Estimates ---\n vector items(N);\n vector exp_stats = get_expected_order_stats(N);\n \n for (int i = 0; i < N; ++i) {\n items[p[i]].id = p[i];\n items[p[i]].rank = i;\n // Assign weight based on rank.\n // Scale it up slightly to avoid tiny number issues, though double is fine.\n // The distribution is exponential.\n // The sorted array p has p[0] as lightest, p[N-1] as heaviest.\n items[p[i]].est_weight = exp_stats[i] * 10000.0; \n }\n\n // Initial Assignment: Serpentine (greedy snake)\n // Sort sets by current total estimated weight (initially 0)\n // To do serpentine properly:\n // 1. Assign heaviest item to set 0, 2nd heaviest to set 1, ..., D-1 to set D-1\n // 2. Reverse direction: D-th heaviest to set D-1, ...\n // But actually, a min-heap approach is often better for partitioning (Number Partitioning - greedy).\n // \"Put the next heaviest item into the currently lightest set.\"\n \n vector> sets(D);\n vector set_weights(D, 0.0);\n \n // Iterate items from heaviest to lightest\n for (int i = N - 1; i >= 0; --i) {\n int item_idx = p[i];\n // Find set with min weight\n int best_set = 0;\n double min_w = 1e18;\n for (int s = 0; s < D; ++s) {\n if (set_weights[s] < min_w) {\n min_w = set_weights[s];\n best_set = s;\n }\n }\n sets[best_set].push_back(item_idx);\n set_weights[best_set] += items[item_idx].est_weight;\n }\n\n // --- Phase 3: Balancing Loop ---\n // Strategy: Compare \"heaviest\" and \"lightest\" set according to *estimates*.\n // Verify with query. Update estimates based on result. Repeat.\n \n // Parameters for update\n // When Scale says L > R but Model says L < R, we have a strong violation.\n // We need to increase weights in L and decrease in R.\n // How much? Multiplicative factor.\n double update_factor = 0.1; \n // Anneal the update factor?\n \n // Keep track of last interaction to avoid cycles?\n // Randomness helps.\n \n while (query_count < Q) {\n // 1. Identify candidates\n int s_max = -1, s_min = -1;\n double max_w = -1.0, min_w = 1e18;\n \n for (int s = 0; s < D; ++s) {\n double w = 0;\n for (int id : sets[s]) w += items[id].est_weight;\n set_weights[s] = w; // update cached sum\n \n if (w > max_w) { max_w = w; s_max = s; }\n if (w < min_w) { min_w = w; s_min = s; }\n }\n \n if (s_max == s_min) {\n // All equal in model? Unlikely with doubles.\n // Pick random distinct\n s_max = 0; s_min = 1; \n }\n\n // Sometimes pick 2nd max or 2nd min to avoid stuck in local optima\n // Or pick random pair with probability?\n // Let's stick to max/min for greedy convergence, but add randomness if stuck.\n // Simple epsilon-greedy\n if (rng() % 100 < 10) { // 10% chance\n s_max = rng() % D;\n s_min = rng() % D;\n while(s_max == s_min) s_min = rng() % D;\n }\n\n // 2. Query\n // We compare Set s_max vs Set s_min\n int res = query(sets[s_max], sets[s_min]);\n if (res == -2) break; // Done\n \n // 3. Handle Result\n // res = 1 => s_max > s_min (Model correct direction)\n // res = -1 => s_max < s_min (Model wrong direction)\n // res = 0 => Equal\n \n if (res == 1) {\n // s_max is indeed heavier.\n // Logic: Try to move weight from s_max to s_min to balance them.\n // We rely on item estimates to pick the move.\n // Possible moves:\n // a. Move item u from s_max to s_min.\n // b. Swap u in s_max with v in s_min (where u > v).\n \n // Find best move that reduces gap (in model) without flipping too much?\n // Actually, since s_max > s_min physically, we WANT to reduce the physical gap.\n // We assume model weights are correlated to physical weights.\n // We pick a move that reduces ModelGap.\n \n double current_diff = set_weights[s_max] - set_weights[s_min]; \n // Note: current_diff might be negative if model was wrong (res=-1 case), \n // but here res=1, so usually current_diff > 0. \n // If current_diff < 0 but res=1, the model is VERY wrong.\n \n if (current_diff < 0) {\n // Model says Min > Max, but Reality says Max > Min.\n // Serious discrepancy. Update weights first.\n // Increase s_max items, decrease s_min items.\n for (int id : sets[s_max]) items[id].est_weight *= (1.0 + update_factor);\n for (int id : sets[s_min]) items[id].est_weight *= (1.0 - update_factor);\n // normalize to prevent explosion?\n // maybe not strictly necessary for short runs.\n } else {\n // Model agrees with Reality.\n // Try to perform a swap/move.\n // We want new_diff to be closer to 0.\n // Ideally slightly positive or slightly negative (overshoot is risky but maybe okay).\n \n // Candidate moves\n int best_type = -1; // 0: move s_max->s_min, 1: swap\n int best_u = -1, best_v = -1; // u index in sets[s_max], v index in sets[s_min]\n double best_new_diff_abs = current_diff;\n \n // Try moving u from Max to Min\n if (sets[s_max].size() > 1) { // Can't empty a set? Problem says non-empty L/R for queries. Output doesn't say sets can't be empty but usually partitions are non-empty. Constraint D <= N/4 implies sets size >= 1 roughly.\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n int u = sets[s_max][i];\n double w_u = items[u].est_weight;\n // New diff would be: (W_max - w_u) - (W_min + w_u) = W_max - W_min - 2*w_u\n double new_diff = current_diff - 2 * w_u;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 0;\n best_u = i;\n }\n }\n }\n \n // Try swapping u from Max with v from Min\n // We want to swap heavy u with light v -> net flow from Max to Min.\n // Change = (W_max - w_u + w_v) - (W_min - w_v + w_u) = Diff - 2(w_u - w_v)\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n for (int j = 0; j < (int)sets[s_min].size(); ++j) {\n int u = sets[s_max][i];\n int v = sets[s_min][j];\n if (items[u].est_weight > items[v].est_weight) {\n double delta = items[u].est_weight - items[v].est_weight;\n double new_diff = current_diff - 2 * delta;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 1;\n best_u = i;\n best_v = j;\n }\n }\n }\n }\n \n if (best_type != -1) {\n // Execute Move\n if (best_type == 0) {\n int u = sets[s_max][best_u];\n sets[s_max].erase(sets[s_max].begin() + best_u);\n sets[s_min].push_back(u);\n } else {\n int u = sets[s_max][best_u];\n int v = sets[s_min][best_v];\n sets[s_max][best_u] = v;\n sets[s_min][best_v] = u;\n }\n } else {\n // No good move found (maybe step size too coarse).\n // We could try to adjust weights slightly to force a change next time?\n // Or just pick random swap?\n }\n }\n } \n else if (res == -1) {\n // s_max < s_min\n // Reality contradicts (or surpasses) Model expectation.\n // s_min is actually heavier.\n \n double current_diff = set_weights[s_max] - set_weights[s_min];\n // If current_diff > 0 (Model thought Max > Min), but Reality Max < Min.\n // Big Error.\n if (current_diff > 0) {\n for (int id : sets[s_max]) items[id].est_weight *= (1.0 - update_factor);\n for (int id : sets[s_min]) items[id].est_weight *= (1.0 + update_factor);\n } else {\n // Model thought Max < Min (and we queried anyway?).\n // Then Model agrees with Reality.\n // Same logic as res=1 but swapped roles.\n // Try to move from Min to Max.\n \n // Swap roles for calculation\n int temp = s_max; s_max = s_min; s_min = temp;\n current_diff = set_weights[s_max] - set_weights[s_min]; // Now positive in theory\n \n // Copy paste logic from above? Or refactor.\n // Let's do a quick inline logic for simplicity\n int best_type = -1; \n int best_u = -1, best_v = -1;\n double best_new_diff_abs = current_diff;\n \n // Move u from heavy (now s_max) to light\n if (sets[s_max].size() > 1) {\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n int u = sets[s_max][i];\n double new_diff = current_diff - 2 * items[u].est_weight;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 0;\n best_u = i;\n }\n }\n }\n // Swap\n for (int i = 0; i < (int)sets[s_max].size(); ++i) {\n for (int j = 0; j < (int)sets[s_min].size(); ++j) {\n int u = sets[s_max][i];\n int v = sets[s_min][j];\n if (items[u].est_weight > items[v].est_weight) {\n double delta = items[u].est_weight - items[v].est_weight;\n double new_diff = current_diff - 2 * delta;\n if (abs(new_diff) < best_new_diff_abs) {\n best_new_diff_abs = abs(new_diff);\n best_type = 1;\n best_u = i;\n best_v = j;\n }\n }\n }\n }\n \n if (best_type == 0) {\n int u = sets[s_max][best_u];\n sets[s_max].erase(sets[s_max].begin() + best_u);\n sets[s_min].push_back(u);\n } else if (best_type == 1) {\n int u = sets[s_max][best_u];\n int v = sets[s_min][best_v];\n sets[s_max][best_u] = v;\n sets[s_min][best_v] = u;\n }\n }\n }\n else {\n // Equal. Good!\n // Maybe try to equalize other sets?\n // Nothing to do for this pair.\n }\n }\n \n // --- Final Output ---\n // Format: d_0 d_1 ... d_{N-1}\n vector assignment(N);\n for (int s = 0; s < D; ++s) {\n for (int id : sets[s]) {\n assignment[id] = s;\n }\n }\n \n // Output result\n for (int i = 0; i < N; ++i) {\n cout << assignment[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << endl;\n}\n\nint main() {\n solve();\n return 0;\n}","ahc026":"/**\n * AHC026 - Stacking of Boxes\n * Improved Solution\n * \n * Strategy Improvements:\n * 1. Strict Sorted Stacks: Prioritize moves that maintain the property: \n * stack[i] < stack[i-1] (top is smaller than bottom).\n * This ensures we can access items without re-shuffling.\n * 2. Segmented Moves: When clearing above a target, break the covering boxes \n * into segments. A segment is a contiguous block of boxes moved together.\n * We try to find a segment starting from the top that fits 'perfectly' \n * onto another stack (val < dest_top).\n * 3. Fallback Logic: If no perfect move exists, minimize damage by placing \n * on the stack with the largest top value (to delay blocking) or \n * a dedicated temporary stack.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 200;\nconst int M = 10;\n\nstruct State {\n vector> stacks;\n // pos[v] = {stack_idx, height_index}\n vector> pos; \n\n State() {\n stacks.resize(M);\n pos.resize(N + 1);\n }\n};\n\nstruct Op {\n int v, i;\n};\n\nState state;\nvector history;\n\n// Track which boxes are currently \"active\" (not carried out)\nbool active[N + 1];\n\nvoid do_op2(int v) {\n int s_idx = state.pos[v].first;\n state.stacks[s_idx].pop_back();\n state.pos[v] = {-1, -1};\n active[v] = false;\n history.push_back({v, 0});\n}\n\nvoid do_op1(int v, int to_stack_idx) {\n int from_stack_idx = state.pos[v].first;\n int from_h_idx = state.pos[v].second;\n \n vector& from_s = state.stacks[from_stack_idx];\n vector& to_s = state.stacks[to_stack_idx];\n \n vector chunk;\n for (size_t k = from_h_idx; k < from_s.size(); ++k) {\n chunk.push_back(from_s[k]);\n }\n \n from_s.resize(from_h_idx);\n \n int start_h = to_s.size();\n for (int i = 0; i < (int)chunk.size(); ++i) {\n int box_val = chunk[i];\n to_s.push_back(box_val);\n state.pos[box_val] = {to_stack_idx, start_h + i};\n }\n \n history.push_back({v, to_stack_idx + 1}); \n}\n\n// Check if a chunk [v_bottom, ..., v_top] is \"internally sorted\" enough to move together.\n// Actually, the problem doesn't allow reordering inside a chunk move.\n// So we just evaluate if moving this chunk to dest_idx is good.\ndouble evaluate_move_score(const vector& chunk, int dest_idx, int current_target) {\n const vector& dest = state.stacks[dest_idx];\n int dest_top = dest.empty() ? 201 : dest.back();\n \n int bottom_val = chunk.front(); // The value that will sit directly on dest_top\n \n double penalty = 0;\n \n // Factor 1: Interface with destination\n if (bottom_val < dest_top) {\n // Good: maintaining sorted order (pyramid)\n // Bonus for tight fit?\n penalty -= 1000.0; // Base reward for a valid sorted move\n // Small gap is better?\n penalty += (dest_top - bottom_val) * 0.1; \n } else {\n // Bad: Inversion. We are blocking 'dest_top'.\n // Penalty proportional to how bad it is.\n penalty += 1000.0; // Base penalty\n \n // How dangerous is blocking dest_top?\n // If dest_top is needed soon (close to current_target), this is terrible.\n int urgency = dest_top - current_target;\n if (urgency < 0) urgency = 0; // Should not happen as active check covers this\n \n // Higher urgency (lower val) -> Higher penalty\n // We use 1/(urgency) scaling\n if (urgency < 20) {\n penalty += 100000.0 / (urgency + 1);\n } else {\n penalty += 500.0; // Generic blocking of far-future item\n }\n \n // Minimize the gap (bury largest possible value)\n penalty += (bottom_val - dest_top) * 1.0; \n }\n \n // Factor 2: Internal structure of the chunk relative to destination?\n // The chunk structure is fixed. But does it create future problems?\n // If the chunk contains a value X, and we put it on dest, \n // X is now at height H.\n // We only care if X blocks something below it (handled by Factor 1 for the interface)\n // or if X is blocked by something above it (internal to chunk, immutable).\n \n // Factor 3: Do not move to a stack that contains very immediate targets deep down?\n // Actually, Factor 1 covers the \"top\" of the stack. \n // But if the stack has immediate targets *below* the top, adding more stuff on top is bad\n // because we increase the digging cost for that future target.\n // We should check the *minimum* value in the destination stack? No, checking if it contains next few targets.\n \n for (int next_t = current_target + 1; next_t <= min(N, current_target + 15); ++next_t) {\n if (state.pos[next_t].first == dest_idx) {\n // Adding more items on top of a stack containing a soon-needed item\n penalty += 50000.0 / (next_t - current_target + 1);\n }\n }\n\n // Factor 4: Energy efficiency. \n // Handled outside? No, let's include normalized score.\n // But here we return a \"badness\" of the resulting state configuration.\n \n return penalty;\n}\n\nvoid solve() {\n int n, m;\n if (!(cin >> n >> m)) return;\n\n state.stacks.clear();\n state.stacks.resize(m);\n state.pos.assign(n + 1, {-1, -1});\n fill(active, active + n + 1, true);\n \n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int val;\n cin >> val;\n state.stacks[i].push_back(val);\n state.pos[val] = {i, j};\n }\n }\n \n for (int target = 1; target <= n; ++target) {\n active[target] = false; // About to be removed or currently being accessed\n \n int s_idx = state.pos[target].first;\n int h_idx = state.pos[target].second;\n \n if (h_idx == (int)state.stacks[s_idx].size() - 1) {\n do_op2(target);\n continue;\n }\n \n // Target is buried.\n // We repeatedly move chunks from the top until target is exposed.\n while (true) {\n int current_h = state.pos[target].second;\n int stack_len = state.stacks[s_idx].size();\n if (current_h == stack_len - 1) break;\n \n // Boxes to remove: from current_h + 1 to stack_len - 1.\n // We can move any top-k portion of these boxes.\n int available_depth = stack_len - 1 - current_h;\n \n double best_score = 1e18;\n int best_k = -1;\n int best_dest = -1;\n \n // Try all chunk sizes k=1..available_depth\n for (int k = 1; k <= available_depth; ++k) {\n int split_idx = stack_len - k;\n \n // Construct chunk for inspection\n vector chunk;\n for(int i=split_idx; i v -> u (biased towards high D neighbors).\n * b. Shortcut: u -> v -> w => u -> w (if u, w connected and v visited elsewhere).\n * c. Remove Detour: u -> v -> u => u (backtrack pruning).\n * 4. Data Structures: \n * - Precomputed all-pairs distances (using BFS since graph is unweighted) to support the greedy initializer.\n * - Used `vector` inserts/erases with undo logic. Given L ~ 3000 and 2 seconds, this allows ~100k-200k iterations.\n * \n * This approach balances local search speed with a strong initial configuration.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst int MAX_N = 40;\nconst double TIME_LIMIT = 1.90; \n\nint N;\nint D[MAX_N][MAX_N];\nint D_flat[MAX_N * MAX_N];\n\n// Adjacency List & Matrix\nstruct Edge {\n int to;\n char move; \n};\nvector adj[MAX_N * MAX_N];\nbool adj_mat[MAX_N * MAX_N][MAX_N * MAX_N];\n\n// Distances: dist_mat[u][v] stores shortest path distance from u to v\nint dist_mat[MAX_N * MAX_N][MAX_N * MAX_N];\n\n// Directions\nconst int di[] = {-1, 1, 0, 0};\nconst int dj[] = {0, 0, -1, 1};\nconst char dchar[] = {'U', 'D', 'L', 'R'};\n\n// Random Number Generator\nmt19937 rng(12345);\n\n// --- Timer ---\nstruct Timer {\n chrono::high_resolution_clock::time_point start;\n Timer() { start = chrono::high_resolution_clock::now(); }\n double elapsed() {\n chrono::duration diff = chrono::high_resolution_clock::now() - start;\n return diff.count();\n }\n} timer;\n\n// --- Precomputation ---\n\n// BFS to compute All-Pairs Shortest Paths on the unweighted grid graph\nvoid bfs_all_pairs() {\n for (int start_node = 0; start_node < N * N; ++start_node) {\n // Initialize distances\n for(int i=0; i q;\n q.push(start_node);\n dist_mat[start_node][start_node] = 0;\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n for(auto& e : adj[u]){\n if(dist_mat[start_node][e.to] > dist_mat[start_node][u] + 1){\n dist_mat[start_node][e.to] = dist_mat[start_node][u] + 1;\n q.push(e.to);\n }\n }\n }\n }\n}\n\nvoid read_input() {\n cin >> N;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> D[i][j];\n D_flat[i * N + j] = D[i][j];\n }\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = i * N + j;\n for (int k = 0; k < 4; ++k) {\n int ni = i + di[k];\n int nj = j + dj[k];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n bool blocked = false;\n if (k == 0) { if (h[ni][j] == '1') blocked = true; }\n else if (k == 1) { if (h[i][j] == '1') blocked = true; }\n else if (k == 2) { if (v[i][nj] == '1') blocked = true; }\n else if (k == 3) { if (v[i][j] == '1') blocked = true; }\n\n if (!blocked) {\n int target = ni * N + nj;\n adj[u].push_back({target, dchar[k]});\n adj_mat[u][target] = true;\n }\n }\n }\n }\n }\n bfs_all_pairs();\n}\n\nchar get_move_char(int u, int v) {\n for (auto& e : adj[u]) {\n if (e.to == v) return e.move;\n }\n return '?'; \n}\n\n// --- Score Logic ---\n// Calculates Average Dirtiness.\n// Formula equivalent to: (Sum over nodes u of [ d_u * Sum over gaps g of g^2 ]) / L\ndouble evaluate_path(const vector& path) {\n int L = path.size() - 1;\n if (L <= 0) return 1e18;\n\n static vector last_seen(MAX_N * MAX_N); \n static vector first_seen(MAX_N * MAX_N);\n \n // Reset helper arrays\n fill(last_seen.begin(), last_seen.begin() + N*N, -1);\n fill(first_seen.begin(), first_seen.begin() + N*N, -1);\n \n long long total_sq = 0;\n \n // Pass 1: Sum squares of internal gaps (between visits within 0..L)\n for (int t = 0; t <= L; ++t) {\n int u = path[t];\n if (first_seen[u] == -1) first_seen[u] = t;\n \n if (last_seen[u] != -1) {\n long long gap = t - last_seen[u];\n total_sq += (long long)D_flat[u] * (gap * gap);\n }\n last_seen[u] = t;\n }\n \n // Pass 2: Add wrap-around gaps\n // For a cyclic schedule of length L, the gap between the last visit at `last_seen[u]`\n // and the first visit at `first_seen[u]` (in the next cycle) is `(L - last_seen[u]) + first_seen[u]`.\n // Special case: The start/end node (path[0] == path[L]). \n // Its internal gap calculation already includes the gap of length L (from 0 to L).\n // So we only add wrap-gap for nodes that are NOT the start node.\n // Actually, path[0] and path[L] are the same instance in time in the cycle representation.\n // The loop above sums (L - 0)^2 = L^2 for the start node. Correct.\n // We need to handle others.\n \n for(int u=0; u get_greedy_path() {\n vector path;\n vector visited(N * N, false);\n int current = 0;\n path.push_back(current);\n visited[current] = true;\n int visited_cnt = 1;\n\n while (visited_cnt < N * N) {\n int best_next = -1;\n double best_score = -1e18;\n\n // Heuristic Score = D[v] / (dist[current][v])^2\n // This balances going to high-dirt nodes vs not travelling too far.\n for (int v = 0; v < N * N; ++v) {\n if (!visited[v]) {\n int d = dist_mat[current][v];\n // Avoid division by zero (though v!=current)\n double score = (double)D_flat[v] / (double)(d * d); \n if (score > best_score) {\n best_score = score;\n best_next = v;\n }\n }\n }\n \n // Reconstruct path from current to best_next using BFS predecessors\n int curr = current;\n int target = best_next;\n \n // Mini-BFS for path reconstruction\n queue q;\n q.push(curr);\n vector pred(N * N, -1);\n vector vis_bfs(N*N, false);\n vis_bfs[curr] = true;\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n if(u == target) break;\n for(auto& e : adj[u]){\n if(!vis_bfs[e.to]){\n vis_bfs[e.to] = true;\n pred[e.to] = u;\n q.push(e.to);\n }\n }\n }\n \n // Trace back\n vector segment;\n int crawl = target;\n while(crawl != curr){\n segment.push_back(crawl);\n crawl = pred[crawl];\n }\n reverse(segment.begin(), segment.end());\n \n // Append segment\n for(int node : segment){\n path.push_back(node);\n if(!visited[node]){\n visited[node] = true;\n visited_cnt++;\n }\n }\n current = target;\n }\n \n // Return to 0 to close the cycle\n int target = 0;\n int curr = current;\n if(curr != 0){\n queue q;\n q.push(curr);\n vector pred(N * N, -1);\n vector vis_bfs(N*N, false);\n vis_bfs[curr] = true;\n \n while(!q.empty()){\n int u = q.front(); q.pop();\n if(u == target) break;\n for(auto& e : adj[u]){\n if(!vis_bfs[e.to]){\n vis_bfs[e.to] = true;\n pred[e.to] = u;\n q.push(e.to);\n }\n }\n }\n vector segment;\n int crawl = target;\n while(crawl != curr){\n segment.push_back(crawl);\n crawl = pred[crawl];\n }\n reverse(segment.begin(), segment.end());\n for(int node : segment) path.push_back(node);\n }\n \n return path;\n}\n\n// Helper to maintain visit counts to ensure validity\nvector counts(MAX_N * MAX_N, 0);\nvoid recalc_counts(const vector& p) {\n fill(counts.begin(), counts.begin() + N * N, 0);\n for (size_t i = 0; i < p.size() - 1; ++i) {\n counts[p[i]]++;\n }\n}\n\n// --- Main ---\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n read_input();\n\n // 1. Generate Initial Solution\n vector path = get_greedy_path();\n \n // Fallback if path is absurdly long (unlikely with N=40)\n if (path.size() > 90000) { \n // Keep it, SA will prune if bad\n }\n\n double score = evaluate_path(path);\n recalc_counts(path);\n\n vector best_path = path;\n double best_score = score;\n\n // 2. Simulated Annealing\n double T0 = 50000.0; // Start temp\n double T_end = 10.0; // End temp\n \n int iter = 0;\n \n while (true) {\n iter++;\n // Check time every 512 iters\n if ((iter & 511) == 0) {\n if (timer.elapsed() > TIME_LIMIT) break;\n }\n\n double temp = T0 + (T_end - T0) * (timer.elapsed() / TIME_LIMIT);\n int type = rng() % 100;\n\n int idx = rng() % (path.size() - 1); // Random position 0..L-1\n\n // PROBABILITIES:\n // 40% Insert Detour\n // 40% Shortcut\n // 20% Remove Detour (backtrack pruning)\n \n if (type < 40) { \n // --- INSERT DETOUR: u -> v -> u ---\n int u = path[idx];\n if (adj[u].empty()) continue;\n if (path.size() + 2 > 100000) continue; // Length limit\n\n // Pick neighbor\n // Heuristic: 60% chance to pick neighbor with HIGH D, 40% random\n int v = -1;\n if ((rng() % 100) < 60) {\n int best_v = -1; int max_d = -1;\n for(auto& e : adj[u]){\n if(D_flat[e.to] > max_d){ max_d = D_flat[e.to]; best_v = e.to; } \n }\n v = best_v;\n } else {\n v = adj[u][rng() % adj[u].size()].to;\n }\n\n // Apply Move\n path.insert(path.begin() + idx + 1, v);\n path.insert(path.begin() + idx + 2, u);\n \n double new_score = evaluate_path(path);\n double diff = new_score - score;\n \n // Metropolis Criterion\n if (diff < 0 || exp(-diff * path.size() / temp) > (double)rng()/rng.max()) {\n score = new_score;\n counts[v]++; \n counts[u]++;\n if (score < best_score) {\n best_score = score;\n best_path = path;\n }\n } else {\n // Revert\n path.erase(path.begin() + idx + 1, path.begin() + idx + 3);\n }\n } \n else if (type < 80) {\n // --- SHORTCUT: ... u, v, w ... -> ... u, w ... ---\n if (idx + 2 >= path.size()) continue;\n \n int u = path[idx];\n int v = path[idx+1];\n int w = path[idx+2];\n \n // Check Validity: Edge u->w exists AND v is visited elsewhere\n if (adj_mat[u][w] && counts[v] > 1) {\n // Apply Move\n path.erase(path.begin() + idx + 1);\n \n double new_score = evaluate_path(path);\n double diff = new_score - score;\n \n if (diff < 0 || exp(-diff * path.size() / temp) > (double)rng()/rng.max()) {\n score = new_score;\n counts[v]--;\n if (score < best_score) {\n best_score = score;\n best_path = path;\n }\n } else {\n // Revert\n path.insert(path.begin() + idx + 1, v);\n }\n }\n }\n else {\n // --- REMOVE DETOUR: ... u, v, u ... -> ... u ... ---\n if (idx + 2 >= path.size()) continue;\n \n // Check pattern u, v, u\n if (path[idx] == path[idx+2]) {\n int v = path[idx+1];\n if (counts[v] > 1) {\n int saved_u = path[idx];\n int saved_v = path[idx+1];\n \n // Apply Move\n path.erase(path.begin() + idx + 1, path.begin() + idx + 3);\n \n double new_score = evaluate_path(path);\n double diff = new_score - score;\n \n if (diff < 0 || exp(-diff * path.size() / temp) > (double)rng()/rng.max()) {\n score = new_score;\n counts[v]--;\n counts[saved_u]--;\n if (score < best_score) {\n best_score = score;\n best_path = path;\n }\n } else {\n // Revert\n path.insert(path.begin() + idx + 1, saved_v);\n path.insert(path.begin() + idx + 2, saved_u);\n }\n }\n }\n }\n }\n\n // 3. Output Result\n string ans = \"\";\n for (size_t i = 0; i < best_path.size() - 1; ++i) {\n ans += get_move_char(best_path[i], best_path[i+1]);\n }\n cout << ans << endl;\n\n return 0;\n}","ahc028":"/**\n * Improved Solution for \"Kakizome Taikai\"\n * \n * Strategy:\n * 1. Modeling as Asymmetric TSP:\n * The problem is primarily about ordering the strings t_1...t_M to minimize the total typing cost.\n * We approximate the typing cost between string t_i and t_j as a static edge weight.\n * \n * 2. Precomputing Costs:\n * - Key-to-Key Distance: min_dist[c1][c2] = min(|r1-r2| + |c1-c2| + 1) for all instances of c1, c2.\n * - TSP Edge Weight w(i, j):\n * Let 'ov' be the overlap length where suffix of t_i matches prefix of t_j.\n * The characters strictly added by t_j are t_j[ov...4].\n * Cost = distance from t_i.back() to t_j[ov] + sum of steps inside t_j[ov...4].\n * This cost implicitly rewards high overlap (fewer terms in sum) and low movement.\n * \n * 3. Simulated Annealing (TSP Phase):\n * Optimize the permutation of indices.\n * Since edge weights are static, we can perform O(1) updates and run millions of iterations.\n * Moves: Swap, 2-Opt (Reverse), Insert (Or-Opt).\n * \n * 4. Post-Processing (Viterbi/DP):\n * Once the optimal string order is determined, construct the superstring S.\n * Run the exact DP to find the sequence of coordinates (r, c) that minimizes the actual cost for S.\n */\n\n#include \n#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_MAX = 15;\nconst int M_MAX = 200;\nconst int INF = 1e9;\n\n// --- Global Inputs ---\nint N, M;\nint start_r, start_c;\nchar grid[N_MAX][N_MAX];\nvector T;\nvector> char_positions[26];\n\n// --- Precomputed Data ---\n// min_char_dist[u][v]: min cost to move finger from any key 'u' to any key 'v' + 1 (press)\nint min_char_dist[26][26];\n\n// tsp_edge[i][j]: Approximate cost to append T[j] after T[i]\nint tsp_edge[M_MAX][M_MAX];\n// overlap_len[i][j]: Length of suffix of T[i] matching prefix of T[j]\nint overlap_len[M_MAX][M_MAX];\n\n// Cost to start with string T[i] from initial finger position (start_r, start_c)\nint start_node_cost[M_MAX];\n\n// --- Random Engine ---\nmt19937 rng(12345);\n\n// --- Helper Functions ---\n\ninline int dist_manhattan(int r1, int c1, int r2, int c2) {\n return abs(r1 - r2) + abs(c1 - c2);\n}\n\n// Calculate overlap: suffix of s1 vs prefix of s2\nint calc_overlap(const string& s1, const string& s2) {\n int max_ov = 0;\n int len1 = s1.length();\n int len2 = s2.length();\n for (int k = 1; k < min(len1, len2); ++k) {\n if (s1.substr(len1 - k) == s2.substr(0, k)) {\n max_ov = k;\n }\n }\n // Check potential full containment or suffix match up to length\n // The problem says length is always 5, but logic holds\n for (int k = min(len1, len2); k >= 1; --k) {\n if (s1.substr(len1 - k) == s2.substr(0, k)) return k;\n }\n return 0;\n}\n\nvoid precompute() {\n // 1. Min Char Distances\n for (int c1 = 0; c1 < 26; ++c1) {\n for (int c2 = 0; c2 < 26; ++c2) {\n int min_d = INF;\n for (auto p1 : char_positions[c1]) {\n for (auto p2 : char_positions[c2]) {\n int d = dist_manhattan(p1.first, p1.second, p2.first, p2.second);\n if (d < min_d) min_d = d;\n }\n }\n min_char_dist[c1][c2] = min_d + 1; // +1 for key press\n }\n }\n\n // 2. Overlaps and TSP Edge Weights\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) {\n if (i == j) {\n overlap_len[i][j] = 0;\n tsp_edge[i][j] = INF; // Should not visit self immediately usually\n continue;\n }\n \n int ov = calc_overlap(T[i], T[j]);\n overlap_len[i][j] = ov;\n \n // Cost calculation\n // Transition from last char of T[i] to first *new* char of T[j]\n // New chars indices in T[j] are [ov, ov+1, ..., len-1]\n // Note: T[i].back() is the character the finger is on.\n // The first char to type is T[j][ov].\n \n int cost = 0;\n if (ov < (int)T[j].length()) {\n // Move from T[i].back() to T[j][ov]\n int u = T[i].back() - 'A';\n int v = T[j][ov] - 'A';\n cost += min_char_dist[u][v];\n \n // Internal movements within the new suffix of T[j]\n for (int k = ov; k < (int)T[j].length() - 1; ++k) {\n int c_curr = T[j][k] - 'A';\n int c_next = T[j][k+1] - 'A';\n cost += min_char_dist[c_curr][c_next];\n }\n } else {\n // Full containment (unlikely for distinct len 5 strings, but possible conceptually)\n cost = 0; \n }\n tsp_edge[i][j] = cost;\n }\n }\n\n // 3. Start Costs\n for (int i = 0; i < M; ++i) {\n // Cost to type entire T[i] starting from (start_r, start_c)\n // First char T[i][0]\n int v0 = T[i][0] - 'A';\n int min_d_start = INF;\n for (auto p : char_positions[v0]) {\n min_d_start = min(min_d_start, dist_manhattan(start_r, start_c, p.first, p.second));\n }\n int cost = min_d_start + 1;\n \n // Rest of string\n for (int k = 0; k < (int)T[i].length() - 1; ++k) {\n int c_curr = T[i][k] - 'A';\n int c_next = T[i][k+1] - 'A';\n cost += min_char_dist[c_curr][c_next];\n }\n start_node_cost[i] = cost;\n }\n}\n\n// --- Solution Construction ---\n\n// Reconstructs superstring from permutation\nstring get_superstring(const vector& p) {\n if (p.empty()) return \"\";\n string s = T[p[0]];\n for (size_t i = 1; i < p.size(); ++i) {\n int u = p[i-1];\n int v = p[i];\n int ov = overlap_len[u][v];\n s += T[v].substr(ov);\n }\n return s;\n}\n\n// --- Final Optimization (Exact DP) ---\n// Returns {cost, path}\npair>> solve_exact_typing(const string& S) {\n if (S.empty()) return {0, {}};\n int L = S.length();\n \n // dp[i][pos_idx]\n // To reconstruct, we store parent pointers\n struct State {\n int cost;\n int parent_pos_idx;\n };\n \n // We can reuse memory vectors to be slightly faster, but L is small enough.\n // Flattening DP: dp[i * max_positions + j]\n \n // Max positions for a char is roughly N*N/26 approx 9. Max N=15 -> 225.\n // Let's use vector> for simplicity and safety.\n \n vector> dp(L);\n \n // Init first char\n int c0 = S[0] - 'A';\n int n0 = char_positions[c0].size();\n dp[0].resize(n0);\n for(int j=0; j> path(L);\n int curr_idx = best_idx;\n for(int i=L-1; i>=0; --i) {\n path[i] = char_positions[S[i]-'A'][curr_idx];\n curr_idx = dp[i][curr_idx].parent_pos_idx;\n }\n return {best_cost, path};\n}\n\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // 1. Input\n cin >> N >> M;\n cin >> start_r >> start_c;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> grid[i][j];\n char_positions[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n T.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> T[i];\n }\n\n // 2. Precompute Distances and TSP Weights\n precompute();\n\n // 3. Initial TSP Solution (Greedy Nearest Neighbor)\n vector p(M);\n vector visited(M, false);\n \n // Pick best start node\n int best_start = -1;\n int min_s_cost = INF;\n for(int i=0; i(now - start_clock).count();\n if(el > time_limit) break;\n Temp = T_start + (T_end - T_start) * (el / time_limit);\n }\n \n // Move Selection\n // 1. Swap (i, j)\n // 2. 2-Opt (Reverse i..j)\n // 3. Insert (Move i to j)\n \n int type = rng() % 10;\n int i = rng() % M;\n int j = rng() % M;\n if (i == j) continue;\n \n // Delta calculation\n int delta = 0;\n \n // --- SWAP (indices i and j) ---\n if (type < 4) { \n // simple swap p[i], p[j]\n // neighbors of i: i-1, i+1\n // neighbors of j: j-1, j+1\n // Handle boundary and adjacency\n if (i > j) swap(i, j);\n \n int u = p[i];\n int v = p[j];\n \n if (j == i + 1) {\n // Adjacent swap: ... a u v b ... -> ... a v u b ...\n int a = (i > 0) ? p[i-1] : -1;\n int b = (j < M_minus_1) ? p[j+1] : -1;\n \n // Remove old edges\n if (a != -1) delta -= tsp_edge[a][u];\n else delta -= start_node_cost[u]; // u was start\n \n delta -= tsp_edge[u][v];\n \n if (b != -1) delta -= tsp_edge[v][b];\n \n // Add new edges\n if (a != -1) delta += tsp_edge[a][v];\n else delta += start_node_cost[v]; // v is new start\n \n delta += tsp_edge[v][u];\n \n if (b != -1) delta += tsp_edge[u][b];\n \n } else {\n // Non-adjacent\n int u_prev = (i > 0) ? p[i-1] : -1;\n int u_next = p[i+1];\n int v_prev = p[j-1];\n int v_next = (j < M_minus_1) ? p[j+1] : -1;\n \n // Remove old\n if (u_prev != -1) delta -= tsp_edge[u_prev][u];\n else delta -= start_node_cost[u];\n delta -= tsp_edge[u][u_next];\n \n delta -= tsp_edge[v_prev][v];\n if (v_next != -1) delta -= tsp_edge[v][v_next];\n \n // Add new (u is at j, v is at i)\n if (u_prev != -1) delta += tsp_edge[u_prev][v];\n else delta += start_node_cost[v];\n delta += tsp_edge[v][u_next];\n \n delta += tsp_edge[v_prev][u];\n if (v_next != -1) delta += tsp_edge[u][v_next];\n }\n \n // Acceptance\n if (delta <= 0 || generate_canonical(rng) < exp(-delta / Temp)) {\n current_tsp_cost += delta;\n swap(p[i], p[j]);\n }\n \n } \n // --- 2-OPT (Reverse range i..j) ---\n else if (type < 8) {\n if (i > j) swap(i, j);\n // Reverse p[i...j]\n // Edges affected: (i-1 -> i) becomes (i-1 -> j)\n // (j -> j+1) becomes (i -> j+1)\n // Internal edges: u -> v becomes v -> u? \n // NO. TSP allows asymmetric weights. Reversing a path reverses the direction of ALL edges inside.\n // Delta = sum( edge(p[k+1], p[k]) ) - sum( edge(p[k], p[k+1]) ) for k in i..j-1\n // This is O(j-i), not O(1).\n // Since M is small (200), O(N) is fine.\n \n int u_start = p[i];\n int v_end = p[j];\n int u_before = (i > 0) ? p[i-1] : -1;\n int v_after = (j < M_minus_1) ? p[j+1] : -1;\n \n // Boundary connections\n if (u_before != -1) delta -= tsp_edge[u_before][u_start];\n else delta -= start_node_cost[u_start];\n \n if (v_after != -1) delta -= tsp_edge[v_end][v_after];\n \n if (u_before != -1) delta += tsp_edge[u_before][v_end];\n else delta += start_node_cost[v_end];\n \n if (v_after != -1) delta += tsp_edge[u_start][v_after];\n \n // Internal edges\n // Original: p[k] -> p[k+1]\n // New: p[k+1] -> p[k] (conceptually, since we reverse the sequence)\n for(int k=i; k(rng) < exp(-delta / Temp)) {\n current_tsp_cost += delta;\n reverse(p.begin() + i, p.begin() + j + 1);\n }\n }\n // --- INSERT / OR-OPT (Move block) ---\n else {\n // Not implemented for brevity/complexity balance, \n // 2-opt and Swap are usually sufficient for M=200 with asymmetric weights.\n // Could add simple single-element insert: move p[i] to position j\n \n // Let's implement simple insert: take p[i], insert after j (or at j)\n // To keep it simple, let's stick to swap/2-opt which covers the space well.\n // If we do random shuffle sometimes? No.\n // Let's do a simplified insert: Move p[i] to become p[j].\n // This effectively shifts elements. O(N) to update p.\n \n // Let's skip to save code complexity/bug risk, Swap/2-Opt is powerful.\n // Instead, do a \"Double Swap\" (3-cycle)\n int k = rng() % M;\n if (k == i || k == j) continue;\n // Swap i, j then j, k\n // This is just two swaps, handled by iterations.\n }\n }\n\n // 5. Construct Final String and Output Exact Path\n string final_S = get_superstring(p);\n \n // Final \"Real\" cost check (optional, for debug)\n // auto res = solve_exact_typing(final_S);\n // cerr << \"Final TSP Proxy Cost: \" << current_tsp_cost << endl;\n // cerr << \"Final Real Cost: \" << res.first << endl;\n \n // Output\n auto result = solve_exact_typing(final_S);\n for(const auto& pos : result.second) {\n cout << pos.first << \" \" << pos.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"/**\n * AHC030 - Polyomino Oil Field Search\n * \n * Strategy:\n * 1. Representation: We represent the state as a set of possible positions for each of the M polyominoes.\n * Since N and M are small (N<=20, M<=20), we can manage the possibilities.\n * \n * 2. Bayesian Inference / MCMC Approach:\n * The problem asks us to find the true configuration of M polyominoes placed on the NxN grid.\n * Let a configuration C be defined by the top-left coordinates (r_k, c_k) for each polyomino k=1..M.\n * We want to find C_true.\n * \n * We maintain a probability distribution over possible positions for each piece. However, the joint\n * distribution is too large ((N^2)^M).\n * Instead, we can keep a pool of \"valid candidates\" or perform a restricted search.\n * Since we need to query to gain information, we need to calculate the expected information gain or \n * simply reduce the entropy of the grid.\n * \n * Phase 1: Initial Scanning\n * - Perform \"divination\" queries (type 2) on large blocks (e.g., 2x2, 3x3, or larger depending on N).\n * A query on a set S returns a noisy sum of overlaps.\n * Cost is 1/sqrt(k). Larger k is cheaper but noisier.\n * We want to identify regions with high probability of containing oil.\n * \n * Phase 2: Refinement & Drill\n * - Based on the divination results, we update the probabilities of each polyomino being at each location.\n * - We calculate the \"marginal probability\" P(v(i,j) > 0) for each cell.\n * - If P(v(i,j) > 0) is very high (near 1) or very low (near 0), we are confident.\n * - If we are uncertain, we can drill (type 1, cost 1, exact result) or divine more.\n * - Drilling is expensive but gives ground truth. Divining is cheap but noisy.\n * \n * Since the total cost is summed up, and we want to minimize it, type 2 queries are very powerful \n * if used effectively.\n * \n * Algorithm Details:\n * 1. Generate all possible translations for each polyomino. Let L_k be the list of valid top-lefts for piece k.\n * 2. Maintain a set of \"plausible configurations\". Initially, this is too large.\n * Instead, we can use a greedy + local search or simple constraint satisfaction approach.\n * \n * High-level flow:\n * - Step 1: Divide the grid into disjoint small blocks (e.g., 4x4 or 3x3). Query them with type 2.\n * This gives us a rough heatmap.\n * - Step 2: Solve a CSP / Optimization problem: Find a configuration of (r_k, c_k) that best explains\n * the observed query results.\n * Let the observed value for query q be O_q. The expected value for a config C is E_q(C).\n * We want to minimize sum |O_q - E_q(C)| (weighted by variance).\n * Since observations are noisy, we can't strictly prune, but we can compute likelihoods.\n * \n * - Step 3: Calculate entropy of each cell based on the top K likely configurations.\n * Select the cell with highest entropy (closest to p=0.5 for v(i,j)>0) to drill.\n * Or select a set of cells to divine to differentiate between top configurations.\n * \n * - Step 4: Once we drill, we have hard constraints. Prune the search space of (r_k, c_k).\n * If a config is inconsistent with a drill result v(i,j), it is invalid (or we update the logic to handle overlaps).\n * Actually, v(i,j) is the count of overlaps. So v(i,j) from drill is a hard constraint on sum of overlaps.\n * \n * - Step 5: Repeat until the solution is unique or we are confident enough to guess.\n * The 'guess' operation allows retrying, but costs 1 if wrong.\n * \n * Heuristic for \"Likely Configurations\":\n * - Since M is up to 20, we can't iterate all combinations.\n * - We can use Hill Climbing / Simulated Annealing to find a configuration that fits current history.\n * - We keep a collection of distinct high-likelihood configurations.\n * - From this collection, we compute p(i,j) = fraction of configs having oil at (i,j).\n * - If p(i,j) > threshold, assume oil. If < 1-threshold, assume empty.\n * - If ambiguous, drill.\n * \n * Specifics for N <= 20:\n * - The grid is very small. N^2 = 400 max.\n * - Operations limit 2*N^2 = 800.\n * - We can drill quite a bit if needed, but cost is the score. We want to minimize drills.\n * - Divination is cost 1/sqrt(k). For k=16 (4x4), cost is 0.25. Much cheaper than drill.\n * \n * Modified Flow:\n * 1. Initial broad queries: Cover the grid with type 2 queries (e.g. partition into 3x3 or 4x4).\n * 2. Solver Loop:\n * a. Run SA/HC to find a set of valid configurations that match all history (drills + divinations).\n * - Cost function for SA: Log-likelihood of divination results + Hard penalty for drill violations.\n * b. Analyze the pool of solutions.\n * - If all solutions agree on the set of positive cells { (i,j) | v(i,j)>0 }, make a guess.\n * - Identify the cell (i,j) where the solutions disagree most (variance of v(i,j) is high).\n * - Drill that cell.\n * c. Add the new info to history and repeat.\n * \n * Handling \"v(i,j)\" vs \"v(i,j)>0\":\n * - The final answer requires the set of cells where v(i,j) > 0.\n * - Drill returns exact v(i,j).\n * - Divination returns noisy sum.\n * \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconstexpr int MAX_N = 20;\nconstexpr int MAX_M = 20;\n\n// Globals from input\nint N, M;\ndouble EPSILON;\n\nstruct Point {\n int r, c;\n bool operator<(const Point& other) const {\n return r < other.r || (r == other.r && c < other.c);\n }\n bool operator==(const Point& other) const {\n return r == other.r && c == other.c;\n }\n};\n\nstruct Polyomino {\n int id;\n int size;\n vector shape; // relative to (0,0) being top-left of bounding box\n};\nvector polys;\n\n// Precomputed valid positions for each polyomino\n// valid_positions[k] = list of (r, c) top-left coordinates such that poly k fits in NxN\nstruct Position {\n int r, c; // top-left\n};\nvector> possible_placements;\n// Maps poly_idx -> placement_idx -> list of cells occupied (absolute coords)\nvector>> precomputed_cells;\n\n// History\nstruct DrillResult {\n int r, c;\n int val;\n};\nvector drill_history;\n\nstruct DivinationResult {\n vector query_cells;\n int result_val;\n};\nvector div_history;\n\n// Grid state\n// -1: unknown, >=0: known exact value\nint known_grid[MAX_N][MAX_N]; \n\n// Random number generation\nmt19937 rng(12345);\n\n// Time management\nchrono::steady_clock::time_point start_time;\ndouble time_limit = 2.8;\n\ndouble get_time() {\n auto now = chrono::steady_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// I/O Helpers\nint query_drill(int r, int c) {\n cout << \"q 1 \" << r << \" \" << c << endl;\n int resp;\n cin >> resp;\n return resp;\n}\n\nint query_divine(const vector& pts) {\n cout << \"q \" << pts.size();\n for (const auto& p : pts) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int resp;\n cin >> resp;\n return resp;\n}\n\nbool guess_answer(const vector& pts) {\n cout << \"a \" << pts.size();\n for (const auto& p : pts) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int resp;\n cin >> resp;\n return resp == 1;\n}\n\nvoid debug_color(int r, int c, string color) {\n cout << \"#c \" << r << \" \" << c << \" \" << color << endl;\n}\n\n// Precomputation\nvoid precompute() {\n possible_placements.resize(M);\n precomputed_cells.resize(M);\n for (int k = 0; k < M; ++k) {\n // find bounding box\n int max_r = 0, max_c = 0;\n for(auto& p : polys[k].shape) {\n max_r = max(max_r, p.r);\n max_c = max(max_c, p.c);\n }\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (r + max_r < N && c + max_c < N) {\n possible_placements[k].push_back({r, c});\n vector occupied;\n for(auto& p : polys[k].shape) {\n occupied.push_back({r + p.r, c + p.c});\n }\n precomputed_cells[k].push_back(occupied);\n }\n }\n }\n }\n}\n\n// Solver State\nstruct State {\n vector placement_indices; // index into possible_placements[k]\n \n // Derived grid sum\n // This is expensive to recompute from scratch, so we might want incremental updates in SA\n // But N is small, maybe recomputing is fine for now.\n};\n\n// Probability helper\n// Returns log probability of observing 'obs' given true value 'v' and size 'k'\ndouble log_prob_divine(int k_cells, int v_sum, int obs) {\n double mean = (k_cells - v_sum) * EPSILON + v_sum * (1.0 - EPSILON);\n double var = k_cells * EPSILON * (1.0 - EPSILON);\n double sigma = sqrt(var);\n \n // Normal distribution PDF: P(x) = (1 / (sigma * sqrt(2pi))) * exp( -0.5 * ((x - mu)/sigma)^2 )\n // We observed 'obs', which is round(sample). So we integrate the PDF over [obs-0.5, obs+0.5].\n // However, for optimization, comparing densities at 'obs' is usually sufficient for \"score\".\n // Or simply use squared error term if we assume Gaussian.\n // (obs - mean)^2 / (2 * var)\n \n return -0.5 * pow(obs - mean, 2) / var;\n}\n\n// Cost function for SA\n// Lower is better\ndouble calculate_energy(const State& s) {\n // 1. Check Drill Consistency (Hard Constraints)\n // We can actually enforce this during neighbor generation, but let's check here\n static int grid_counts[MAX_N][MAX_N];\n for(int r=0; r minimize negative log likelihood\n for(const auto& div : div_history) {\n int current_sum = 0;\n for(auto& p : div.query_cells) {\n current_sum += grid_counts[p.r][p.c];\n }\n double lp = log_prob_divine(div.query_cells.size(), current_sum, div.result_val);\n energy -= lp; // Subtract log prob\n }\n\n return energy;\n}\n\n// Check if a state is consistent with hard constraints (drills)\nbool is_consistent(const State& s) {\n static int grid_counts[MAX_N][MAX_N];\n for(int r=0; r> N >> M >> EPSILON;\n polys.resize(M);\n for (int i = 0; i < M; ++i) {\n int d;\n cin >> d;\n polys[i].id = i;\n polys[i].size = d;\n for (int j = 0; j < d; ++j) {\n int r, c;\n cin >> r >> c;\n polys[i].shape.push_back({r, c});\n }\n }\n\n precompute();\n\n for(int r=0; r 15) block_size = 3; // 3x3 for larger maps to save queries\n \n // To avoid TLE in logic part and maximize info, we might do a checkered pattern or full tiling.\n // Full tiling is safest.\n for (int r = 0; r < N; r += block_size) {\n for (int c = 0; c < N; c += block_size) {\n vector pts;\n for (int dr = 0; dr < block_size; ++dr) {\n for (int dc = 0; dc < block_size; ++dc) {\n if (r + dr < N && c + dc < N) {\n pts.push_back({r + dr, c + dc});\n }\n }\n }\n if (pts.size() >= 2) { // Requirement: set size >= 2\n int res = query_divine(pts);\n div_history.push_back({pts, res});\n }\n }\n }\n\n // ------------------------------------------------\n // Main Loop: Drill and Refine\n // ------------------------------------------------\n // We maintain a set of \"good\" samples found by SA.\n // From these samples, we compute marginals and decide where to drill.\n\n while (get_time() < time_limit) {\n // Run Simulated Annealing to find a pool of consistent configurations\n vector pool;\n const int POOL_SIZE = 25; // Small pool due to time constraints\n \n // Generate pool\n // We run SA multiple times or one long run keeping best states?\n // Multiple short runs is better to escape local optima.\n \n for (int run = 0; run < POOL_SIZE; ++run) {\n if (get_time() > time_limit) break;\n\n State current;\n current.placement_indices.resize(M);\n // Random initialization\n for(int k=0; k dist(0, possible_placements[k].size() - 1);\n current.placement_indices[k] = dist(rng);\n }\n \n double current_energy = calculate_energy(current);\n \n // SA params\n double temp = 10.0;\n double cooling = 0.95;\n int steps = 200; // Increase if grid is large\n if (N > 15) steps = 300;\n\n for (int step = 0; step < steps; ++step) {\n // Neighbor: pick a piece and move it\n int k = uniform_int_distribution(0, M - 1)(rng);\n int old_idx = current.placement_indices[k];\n int new_idx = uniform_int_distribution(0, possible_placements[k].size() - 1)(rng);\n \n if(old_idx == new_idx) continue;\n\n current.placement_indices[k] = new_idx;\n double new_energy = calculate_energy(current);\n \n if (new_energy < current_energy) {\n current_energy = new_energy;\n } else {\n double prob = exp((current_energy - new_energy) / temp);\n if (generate_canonical(rng) < prob) {\n current_energy = new_energy;\n } else {\n // Revert\n current.placement_indices[k] = old_idx;\n }\n }\n temp *= cooling;\n }\n \n // Store if reasonable quality\n // \"Reasonable\" means hard constraints are satisfied (energy < 1e8)\n if (current_energy < 1e8) {\n pool.push_back(current);\n }\n }\n \n if (pool.empty()) {\n // This shouldn't happen unless hard constraints are contradictory or SA failed bad.\n // Fallback: Drill a random unknown cell\n vector unknown_cells;\n for(int r=0; r(0, unknown_cells.size()-1)(rng);\n int val = query_drill(unknown_cells[idx].r, unknown_cells[idx].c);\n known_grid[unknown_cells[idx].r][unknown_cells[idx].c] = val;\n drill_history.push_back({unknown_cells[idx].r, unknown_cells[idx].c, val});\n continue;\n }\n\n // Analyze pool\n // Calculate p(cell > 0)\n vector> positive_counts(N, vector(N, 0));\n for(const auto& s : pool) {\n // Reconstruct grid\n static int g[MAX_N][MAX_N];\n for(int r=0;r 0) positive_counts[r][c]++;\n }\n\n // Determine most uncertain cell\n // We want a cell where the pool disagrees most (closest to 50% positive)\n // But we also prioritize cells that haven't been drilled.\n double best_uncertainty = -1.0;\n Point best_p = {-1, -1};\n \n // Also check if all consistent solutions agree on the output set\n bool all_agree = true;\n vector first_sol_set;\n {\n // Build set for first sol\n set s1;\n static int g[MAX_N][MAX_N];\n for(int r=0;r0) first_sol_set.push_back({r,c});\n }\n\n for(size_t i=1; i s_curr;\n static int g[MAX_N][MAX_N];\n for(int r=0;r curr_set;\n for(int r=0;r0) curr_set.push_back({r,c});\n \n if(curr_set.size() != first_sol_set.size()) { all_agree = false; break; }\n for(size_t j=0; j= 5) {\n // Construct the answer from first_sol_set\n // Need to ensure drilled 0s are not in set, drilled >0 are in set (already handled by consistency)\n if (guess_answer(first_sol_set)) {\n return 0;\n } else {\n // Wrong guess. The pool was biased.\n // We need more info. Drill something not in history but maybe in the set?\n // Or just continue loop, the cost 1 penalty is applied.\n // To diversify, let's drill a random cell from the guessed set to confirm values?\n // Or better, drill a random uncertain cell if any exist, or just random.\n }\n }\n\n // Find best drill target\n for(int r=0; r best_uncertainty) {\n best_uncertainty = uncertainty;\n best_p = {r, c};\n }\n }\n }\n \n if (best_p.r != -1) {\n int val = query_drill(best_p.r, best_p.c);\n known_grid[best_p.r][best_p.c] = val;\n drill_history.push_back({best_p.r, best_p.c, val});\n } else {\n // All cells in pool are agreed upon (all 0 or all >0), but maybe we failed a guess?\n // Drill a random undrilled cell to increase constraints\n vector unknown_cells;\n for(int r=0; r ans;\n for(int r=0; r 0) ans.push_back({r, c});\n if(guess_answer(ans)) return 0;\n else break; // Should not happen if grid is fully drilled\n }\n \n int idx = uniform_int_distribution(0, unknown_cells.size()-1)(rng);\n int val = query_drill(unknown_cells[idx].r, unknown_cells[idx].c);\n known_grid[unknown_cells[idx].r][unknown_cells[idx].c] = val;\n drill_history.push_back({unknown_cells[idx].r, unknown_cells[idx].c, val});\n }\n }\n\n // Final fallback if time runs out\n // Collect all known > 0 and whatever the last pool suggests\n // This is just a desperate guess.\n return 0;\n}","ahc031":"/**\n * AHC031 - Event Hall Management\n *\n * Strategy:\n * 1. Vertical Stripe Decomposition:\n * We divide the 1000x1000 grid into N vertical columns.\n * Reservation k is always assigned to column k.\n *\n * 2. Width Optimization (Simulated Annealing):\n * We optimize the widths of these columns (w_k) such that sum(w_k) = 1000.\n * The objective function minimizes a \"strict\" cost:\n * - Assume strict minimal height needed: h_req = ceil(a_{d,k} / w_k).\n * - Calculate partition movement costs assuming we resize exactly to h_req every day.\n * - Include area penalty for insufficient space.\n * This drives widths to be sufficient for demand peaks while balancing stability.\n *\n * 3. Height Smoothing (Iterative DP):\n * After fixing widths, we determine the actual heights h_{d,k} >= h_req.\n * We can keep h_{d,k} larger than needed to match h_{d-1,k} and avoid partition movement costs.\n * Since vertical partition costs depend on neighbor columns, we use an iterative approach (Coordinate Descent):\n * - Optimize one column's height sequence using DP while keeping neighbors fixed.\n * - Repeat for all columns multiple times.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Global Constants & Inputs ---\nint W_SIZE; // 1000\nint D, N;\nvector> A; // A[d][k]\n\n// --- Random Number Generator ---\nmt19937 rng(12345);\n\n// --- Helper Functions ---\n\n// Evaluate cost for a given set of widths using \"strict\" height requirements.\n// This acts as the energy function for SA to find good column widths.\n// It assumes we resize the partition exactly to the required area every day.\nlong long evaluate_strict(const vector& widths) {\n long long score = 0;\n \n // Current heights for day d (h_curr) and previous day (h_prev)\n vector h_curr(N);\n vector h_prev(N);\n \n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int w = widths[k];\n int req = A[d][k];\n int h = 0;\n if (w > 0) {\n // Ceiling division\n h = (req + w - 1) / w;\n if (h > 1000) h = 1000; // Cap at grid size\n } else {\n h = 1000; // Penalty state\n }\n h_curr[k] = h;\n \n // Area penalty\n long long actual_area = (long long)w * h;\n if (actual_area < req) {\n score += 100LL * (req - actual_area);\n }\n }\n \n if (d > 0) {\n // Horizontal partition changes\n for (int k = 0; k < N; ++k) {\n if (h_curr[k] != h_prev[k]) {\n // Cost to remove old + add new?\n // If h < 1000, it's an internal wall.\n if (h_prev[k] < 1000) score += widths[k];\n if (h_curr[k] < 1000) score += widths[k];\n }\n }\n // Vertical partition changes\n // Vertical wall k is between col k-1 and k. exists for y in [0, max(h_k-1, h_k)]\n // Boundaries are at indices 1 to N-1.\n for (int k = 1; k < N; ++k) {\n int len_prev = (h_prev[k-1] > h_prev[k]) ? h_prev[k-1] : h_prev[k];\n int len_curr = (h_curr[k-1] > h_curr[k]) ? h_curr[k-1] : h_curr[k];\n score += abs(len_curr - len_prev);\n }\n }\n \n // Update prev\n h_prev = h_curr;\n }\n \n return score;\n}\n\n// Iterative DP Smoothing\n// 1. Fix widths.\n// 2. Determine initial strict heights.\n// 3. Iterate: pick a column, optimize its heights using DP considering neighbors fixed.\nvector> optimize_heights(const vector& widths) {\n // 1. Initial requirements\n vector> reqH(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n if (widths[k] == 0) reqH[d][k] = 1000;\n else {\n int val = (A[d][k] + widths[k] - 1) / widths[k];\n reqH[d][k] = min(1000, val);\n }\n }\n }\n \n // Current solution (initialized to strict)\n vector> H = reqH;\n \n // Candidate sets per column\n // To allow smoothing, we use heights from other days as candidates.\n // This creates a grid of likely optimal heights.\n vector> candidates(N);\n for(int k=0; k& cands = candidates[k];\n int C = cands.size();\n int w = widths[k];\n \n // dp[d][i] = min cost up to day d, ending with height cands[i]\n // We need to store the path\n // Using 1D arrays for DP to save allocation time, but need parent\n vector dp(C, 2e18);\n vector> parent(D, vector(C, -1));\n \n // Day 0: Initialize\n // L_0 = 0, so cost is 0 for any valid height.\n for(int i=0; i= reqH[0][k]) dp[i] = 0;\n else dp[i] = 2e18;\n }\n \n for(int d=1; d next_dp(C, 2e18);\n \n int h_prev_left = (k > 0) ? H[d-1][k-1] : 0;\n int h_prev_right = (k < N-1) ? H[d-1][k+1] : 0;\n int h_curr_left = (k > 0) ? H[d][k-1] : 0;\n int h_curr_right = (k < N-1) ? H[d][k+1] : 0;\n \n for(int i=0; i 1e17) continue;\n \n int h_old = cands[j];\n long long cost = 0;\n \n // Horizontal cost\n if (h_old != h_now) {\n if (h_old < 1000) cost += w;\n if (h_now < 1000) cost += w;\n }\n \n // Vertical Left cost\n if (k > 0) {\n int l_old = (h_old > h_prev_left) ? h_old : h_prev_left;\n int l_new = (h_now > h_curr_left) ? h_now : h_curr_left;\n cost += abs(l_new - l_old);\n }\n // Vertical Right cost\n if (k < N-1) {\n int r_old = (h_old > h_prev_right) ? h_old : h_prev_right;\n int r_new = (h_now > h_curr_right) ? h_now : h_curr_right;\n cost += abs(r_new - r_old);\n }\n \n if (dp[j] + cost < next_dp[i]) {\n next_dp[i] = dp[j] + cost;\n parent[d][i] = j;\n }\n }\n }\n dp = next_dp;\n }\n \n // Backtrack\n long long best_val = 2e18;\n int best_idx = -1;\n for(int i=0; i=0; --d) {\n H[d][k] = cands[curr];\n if(d>0) curr = parent[d][curr];\n }\n }\n }\n }\n return H;\n}\n\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n if (!(cin >> W_SIZE >> D >> N)) return 0;\n A.resize(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 auto start_time = chrono::high_resolution_clock::now();\n\n // 1. Initial Solution: Widths proportional to max demands\n vector widths(N);\n vector max_demands(N, 0);\n long long sum_max_demands = 0;\n \n for (int k = 0; k < N; ++k) {\n for (int d = 0; d < D; ++d) {\n max_demands[k] = max(max_demands[k], (long long)A[d][k]);\n }\n sum_max_demands += max_demands[k];\n }\n \n int current_width_sum = 0;\n for (int k = 0; k < N; ++k) {\n // Base allocation\n long long alloc = max_demands[k] * (long long)W_SIZE / (sum_max_demands > 0 ? sum_max_demands : 1);\n widths[k] = (int)alloc;\n if (widths[k] == 0 && max_demands[k] > 0) widths[k] = 1;\n current_width_sum += widths[k];\n }\n \n // Adjust sum to 1000\n while (current_width_sum < W_SIZE) {\n int k = rng() % N;\n widths[k]++;\n current_width_sum++;\n }\n while (current_width_sum > W_SIZE) {\n int k = rng() % N;\n if (widths[k] > 1) {\n widths[k]--;\n current_width_sum--;\n } else if (widths[k] == 1 && N > W_SIZE) { \n widths[k]--; \n current_width_sum--;\n }\n }\n \n long long current_score = evaluate_strict(widths);\n vector best_widths = widths;\n long long best_score = current_score;\n\n // 2. Simulated Annealing\n double TIME_LIMIT = 2.8;\n double temp_start = 20000.0;\n double temp_end = 100.0;\n \n int iter = 0;\n double temp = temp_start;\n \n while(true) {\n iter++;\n if ((iter & 255) == 0) { \n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n double ratio = elapsed / TIME_LIMIT;\n temp = temp_start * pow(temp_end / temp_start, ratio);\n }\n\n int i = rng() % N;\n int j = rng() % N;\n if (i == j) continue;\n if (widths[i] <= 1) continue; \n \n // Adaptive move size\n int diff = 1;\n if (widths[i] > 10 && (rng() % 10 == 0)) diff = 1 + rng() % (widths[i]/4);\n \n widths[i] -= diff;\n widths[j] += diff;\n \n long long new_score = evaluate_strict(widths);\n long long delta = new_score - current_score;\n \n if (delta <= 0 || exp(-delta / temp) > (double)(rng() % 10000) / 10000.0) {\n current_score = new_score;\n if (current_score < best_score) {\n best_score = current_score;\n best_widths = widths;\n }\n } else {\n // Revert\n widths[i] += diff;\n widths[j] -= diff;\n }\n }\n \n // 3. Post-processing: Smoothing\n widths = best_widths;\n vector> final_H = optimize_heights(widths);\n \n // Compute X coords\n vector X(N + 1, 0);\n for (int k = 0; k < N; ++k) X[k + 1] = X[k] + widths[k];\n \n // Output\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n int r1 = 0;\n int c1 = X[k];\n int r2 = final_H[d][k];\n int c2 = X[k+1];\n \n cout << r1 << \" \" << c1 << \" \" << r2 << \" \" << c2 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"/**\n * Heuristic Solution for Stamp Problem (AHC032)\n *\n * Problem Analysis:\n * 1. The board size is extremely small (9x9).\n * 2. The number of stamps is small (20).\n * 3. The max operations K is small (81). This corresponds exactly to the number of 1x1 cells on the board,\n * but significantly, it's also more than enough to cover the board with 3x3 stamps (since 9x9 / 3x3 = 9 stamps could cover it).\n * However, stamps overlap. The max top-left positions for a 3x3 stamp on a 9x9 board is (N-3+1) x (N-3+1) = 7x7 = 49 positions.\n * So we can theoretically stamp every possible top-left position at least once, or some twice.\n *\n * Objective:\n * Maximize sum( b[i][j] % MOD ) where MOD = 998244353.\n *\n * Key Insight:\n * Since we want to maximize the sum modulo P, this is a non-linear optimization problem due to the modulo operator.\n * A simple greedy approach (always adding the largest value) might get stuck in local optima because adding a value might\n * wrap around the modulo, decreasing the score significantly.\n *\n * State Space:\n * - Total cells: 81.\n * - Possible actions: 20 stamps * 49 positions = 980 actions.\n * - Max depth: 81.\n *\n * This suggests a local search or simulated annealing approach.\n *\n * Algorithm Strategy:\n *\n * 1. **Initial Solution**: Start with an empty set of operations.\n *\n * 2. **State Representation**:\n * - Current board values `current_b[9][9]`.\n * - Current score.\n * - List of operations `ops`.\n *\n * 3. **Neighbor Generation (Hill Climbing / Simulated Annealing)**:\n * We can modify the current solution by:\n * a) ADD: Add a random stamp at a random position (if |ops| < K).\n * b) REMOVE: Remove a random existing operation.\n * c) SWAP_STAMP: Change the stamp type of an existing operation.\n * d) SWAP_POS: Change the position of an existing operation.\n * e) REPLACE: Remove one op and add another (effectively a combination of b and a).\n *\n * Given the constraints and the nature of modulo arithmetic, a simple hill climbing might get stuck easily.\n * Simulated Annealing (SA) is ideal here.\n *\n * 4. **Score Calculation**:\n * We need to efficiently update the score.\n * - Calculating the full score takes O(N^2) = O(81).\n * - Incremental update: When adding/removing a stamp at (p, q), only 3x3 = 9 cells change.\n * Complexity O(9). This is very fast.\n *\n * 5. **Evaluation Function**:\n * Simply the sum of remainders.\n *\n * 6. **Specific Strategy (Beam Search vs SA)**:\n * - **Beam Search**: We could build the sequence of operations one by one.\n * State: (Board, Score). Transitions: Try all 980 possible moves. Keep top B states.\n * Since K is fixed and large (81), and we can stop early, this is essentially filling slots.\n * However, since the order of operations doesn't matter (addition is commutative), treating this as a sequence building problem\n * might be less effective than treating it as a \"set of operations\" problem optimization.\n * Also, \"removing\" isn't natural in Beam Search.\n *\n * - **Simulated Annealing**: Treat the solution as a multiset of operations (size 0 to K).\n * Transitions modify this multiset. The commutative property simplifies things immensely; we don't need to maintain order.\n * We just keep a count of how many times stamp m is applied at (p,q).\n * Let `count[m][p][q]` be the number of times stamp `m` is used at `p, q`.\n * Wait, K is global total count.\n * Since K=81 is relatively small, we can just keep a vector of operations.\n *\n * Let's stick to **Simulated Annealing**. It's robust for this kind of modulo maximization.\n *\n * 7. **Optimizations**:\n * - Fast incremental score update.\n * - Precompute the 3x3 updates.\n * - Time management: run as many iterations as possible within 1.95s.\n *\n * 8. **Refinement**:\n * The \"State\" is simply the current board `B`.\n * The \"Move\" is applying a stamp `(m, p, q)` or removing its inverse.\n * Wait, we can't \"remove\" simply by subtracting if we only store `B % MOD`. We need to handle the modulo logic correctly.\n * Actually, since `B` is just the sum, `(Original + Sum_Ops) % MOD`, subtraction is fine: `(Current - s + MOD) % MOD`.\n *\n * Let's refine the SA moves:\n * - Currently, we have a list of ops.\n * - Neighbor:\n * 1. Add a random op (if size < K).\n * 2. Remove a random op (if size > 0).\n * 3. Modify an op (change m or p or q).\n *\n * Since order doesn't matter, we can just pick an index in our `vector` to modify or remove.\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants and Globals ---\nconstexpr long long MOD = 998244353;\nconstexpr int N = 9;\nconstexpr int M_MAX = 20;\nconstexpr int K_MAX = 81;\nconstexpr int STAMP_SIZE = 3;\nconstexpr double TIME_LIMIT = 1.95; // Seconds\n\nstruct Operation {\n int m;\n int p;\n int q;\n};\n\n// Global inputs\nlong long A[N][N];\nlong long S[M_MAX][STAMP_SIZE][STAMP_SIZE];\nint N_in, M_in, K_in;\n\n// --- Random Number Generator ---\nstruct Xorshift {\n uint64_t x = 88172645463325252ull;\n inline uint64_t next() {\n x ^= x << 13;\n x ^= x >> 7;\n x ^= x << 17;\n return x;\n }\n inline int next_int(int n) {\n return next() % n;\n }\n inline double next_double() {\n return (double)next() / (double)(~0ull);\n }\n} rng;\n\n// --- State Management ---\n\nstruct State {\n long long b[N][N]; // Current board values\n long long score; // Current total score (sum of b[i][j] % MOD)\n vector ops;\n\n State() {\n score = 0;\n for(int i=0; i Decide -> (Update or Rollback).\n// Here, to be fastest:\n// 1. Calculate delta.\n// 2. If accepted, update b and score.\n// 3. If rejected, do nothing.\n\n// But we need to support both Add and Remove.\n\ninline long long calc_add_delta(const State& state, int m, int p, int q) {\n long long delta = 0;\n for(int i=0; i= MOD) new_val -= MOD;\n \n delta += (new_val - old_val);\n }\n }\n return delta;\n}\n\ninline void apply_add(State& state, int m, int p, int q) {\n for(int i=0; i= MOD) val -= MOD;\n }\n }\n state.ops.push_back({m, p, q});\n}\n\ninline long long calc_remove_delta(const State& state, int op_index) {\n const auto& op = state.ops[op_index];\n int m = op.m;\n int p = op.p;\n int q = op.q;\n \n long long delta = 0;\n for(int i=0; i Add new)\n// Returns pair\n// Note: Doing this in one step might be slightly more accurate for gradients, \n// but calculating delta is tricky because the \"Add\" depends on the state *after* \"Remove\".\n// Simple approach: Remove, then Add.\n// To do it purely for delta calculation without modifying state:\ninline long long calc_modify_delta(const State& state, int op_idx, int new_m, int new_p, int new_q) {\n const auto& old_op = state.ops[op_idx];\n int old_m = old_op.m;\n int old_p = old_op.p;\n int old_q = old_op.q;\n\n long long delta = 0;\n\n // Iterate over the union of affected cells (bounding box of old and new)\n // But simpler: just iterate over old 3x3 and new 3x3.\n // Be careful with overlaps if we update a temp board.\n // Since we can't easily clone the board, we do this cell by cell logic.\n \n // Map to store temporary changes for delta calculation\n // Key: (row << 8) | col, Value: current_value\n // Since N is small (9), we can use a small flat array or iterate carefully.\n // 3x3 is small enough. Let's just do it:\n // 1. Calculate effect of removal.\n // 2. Calculate effect of addition on top of removal.\n \n // To avoid allocating memory, we iterate through all 9x9 cells? No, just the affected ones.\n // Affected: (old_p, old_q) 3x3 AND (new_p, new_q) 3x3.\n \n // Let's use a small static buffer for the 9x9 board diffs, but that's overkill.\n // We can iterate the union of the two 3x3 areas.\n \n int min_r = min(old_p, new_p);\n int max_r = max(old_p, new_p) + 2;\n int min_c = min(old_q, new_q);\n int max_c = max(old_q, new_q) + 2;\n \n for(int r = min_r; r <= max_r; ++r) {\n for(int c = min_c; c <= max_c; ++c) {\n long long val = state.b[r][c];\n long long original_val = val;\n \n // Apply removal if inside old stamp\n if (r >= old_p && r < old_p + 3 && c >= old_q && c < old_q + 3) {\n val -= S[old_m][r - old_p][c - old_q];\n if (val < 0) val += MOD;\n }\n \n // Apply addition if inside new stamp\n if (r >= new_p && r < new_p + 3 && c >= new_q && c < new_q + 3) {\n val += S[new_m][r - new_p][c - new_q];\n if (val >= MOD) val -= MOD;\n }\n \n delta += (val - original_val);\n }\n }\n \n return delta;\n}\n\ninline void apply_modify(State& state, int op_idx, int new_m, int new_p, int new_q) {\n const auto& old_op = state.ops[op_idx];\n int old_m = old_op.m;\n int old_p = old_op.p;\n int old_q = old_op.q;\n\n // Remove old\n for(int i=0; i= MOD) val -= MOD;\n }\n }\n \n state.ops[op_idx] = {new_m, new_p, new_q};\n}\n\n\n// --- Main Solver ---\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n // Input\n cin >> N_in >> M_in >> K_in;\n for(int i=0; i> A[i][j];\n }\n }\n for(int m=0; m> S[m][i][j];\n }\n }\n }\n\n auto start_time = chrono::high_resolution_clock::now();\n\n State current_state;\n \n // Better Initial Solution?\n // Maybe fill randomly up to K? Or just start empty.\n // Starting empty allows SA to grow the solution naturally.\n // Given K is small, we can try to fill it.\n // Let's start with K/2 random operations.\n for(int k=0; k 0) { // Greedy initialization\n apply_add(current_state, m, p, q);\n current_state.score += delta;\n }\n }\n\n State best_state = current_state;\n \n // SA Parameters\n double t0 = 2e8; // Initial temperature (tuned)\n double t1 = 1e0; // Final temperature\n double temp = t0;\n int iter = 0;\n \n while (true) {\n iter++;\n if ((iter & 0xFF) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n \n // Temperature update (linear decay or exponential)\n double progress = elapsed / TIME_LIMIT;\n temp = t0 * pow(t1/t0, progress);\n }\n\n int type = rng.next_int(3); \n // 0: ADD\n // 1: REMOVE\n // 2: MODIFY\n \n // Bias towards MODIFY once we are full\n if (current_state.ops.size() == K_in && type == 0) type = 2;\n if (current_state.ops.empty() && (type == 1 || type == 2)) type = 0;\n\n if (type == 0) { // ADD\n if (current_state.ops.size() >= K_in) continue;\n \n int m = rng.next_int(M_in);\n int p = rng.next_int(N - 2);\n int q = rng.next_int(N - 2);\n \n long long delta = calc_add_delta(current_state, m, p, q);\n \n if (delta > 0 || rng.next_double() < exp(delta / temp)) {\n apply_add(current_state, m, p, q);\n current_state.score += delta;\n if (current_state.score > best_state.score) {\n best_state = current_state;\n }\n }\n }\n else if (type == 1) { // REMOVE\n if (current_state.ops.empty()) continue;\n \n int idx = rng.next_int(current_state.ops.size());\n \n long long delta = calc_remove_delta(current_state, idx);\n \n if (delta > 0 || rng.next_double() < exp(delta / temp)) {\n apply_remove(current_state, idx);\n current_state.score += delta;\n // Usually removing lowers score, but it might escape local optima\n if (current_state.score > best_state.score) {\n best_state = current_state;\n }\n }\n }\n else if (type == 2) { // MODIFY\n if (current_state.ops.empty()) continue;\n \n int idx = rng.next_int(current_state.ops.size());\n \n // Small perturbation: change position slightly OR change stamp\n int subtype = rng.next_int(2);\n int new_m = current_state.ops[idx].m;\n int new_p = current_state.ops[idx].p;\n int new_q = current_state.ops[idx].q;\n \n if (subtype == 0) { // Change Stamp\n new_m = rng.next_int(M_in);\n } else { // Change Pos\n // Try moving nearby first\n int d = rng.next_int(5); // 0..4\n if (d==0) new_p = max(0, new_p - 1);\n else if (d==1) new_p = min(N - 3, new_p + 1);\n else if (d==2) new_q = max(0, new_q - 1);\n else if (d==3) new_q = min(N - 3, new_q + 1);\n else {\n // Random jump\n new_p = rng.next_int(N - 2);\n new_q = rng.next_int(N - 2);\n }\n }\n \n if (new_m == current_state.ops[idx].m && new_p == current_state.ops[idx].p && new_q == current_state.ops[idx].q) continue;\n\n long long delta = calc_modify_delta(current_state, idx, new_m, new_p, new_q);\n \n if (delta > 0 || rng.next_double() < exp(delta / temp)) {\n apply_modify(current_state, idx, new_m, new_p, new_q);\n current_state.score += delta;\n if (current_state.score > best_state.score) {\n best_state = current_state;\n }\n }\n }\n }\n\n // Output\n cout << best_state.ops.size() << \"\\n\";\n for (const auto& op : best_state.ops) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"/**\n * AHC033 - Container Terminal\n * Refined Solution: Single Large Crane Strategy (\"The Boss\")\n * \n * Strategy Overview:\n * 1. Insight: The grid (5x5) is too small for 5 cranes to operate efficiently without complex cooperative pathfinding.\n * Small cranes get stuck easily because they cannot lift containers over others.\n * However, the Large Crane (Crane 0) can fly over obstacles.\n * 2. Approach:\n * - Immediately remove (Bomb) all small cranes (1-4) to clear the board.\n * - Use Crane 0 exclusively.\n * - Since the time limit is generous (10000 turns) and N is small (5), a single efficient crane is sufficient\n * to complete the task (~400-600 turns) compared to the penalty for incomplete tasks.\n * 3. Logic:\n * - Priority 1: Deliver. If any accessible container (on grid or at input gate) matches the current output requirement, deliver it immediately.\n * - Priority 2: Dig. If no immediate delivery is possible, scan input queues to find the \"most urgent\" container (needed soonest).\n * Move the container blocking it (at the input gate) to a temporary storage slot.\n * - Storage: Use columns 1, 2, 3 as buffer. Fill from column 3 back to 1 to keep input area clear.\n * 4. Benefits:\n * - Zero deadlocks (Crane 0 flies).\n * - Zero collisions (1 agent).\n * - Guaranteed completion (avoids massive M3 penalty).\n */\n\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\nconst int N = 5;\nconst int MAX_TURNS = 10000;\nconst int INVALID = -1;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const { return r == other.r && c == other.c; }\n bool operator!=(const Point& other) const { return !(*this == other); }\n int dist(const Point& other) const { return abs(r - other.r) + abs(c - other.c); }\n};\n\nstruct State {\n int grid[N][N]; // Container ID at (r,c) or INVALID\n vector input_queues[N]; // Remaining containers in queue (excluding spawned ones)\n int input_ptr[N]; // Index of next container to spawn from queue\n int next_output_idx[N]; // The order index (0..4) needed next for each row\n int dispatched_count = 0;\n \n // Crane 0 state\n Point crane_pos = {0, 0};\n int holding_id = INVALID;\n \n State() {\n for(int i=0; i history;\n \n Solver(const vector>& inputs) {\n state = State();\n for(int i=0; i= N * N) break;\n \n // Inputs arrive at start of turn logic\n state.update_inputs();\n\n char op = '.';\n \n // --- Logic ---\n \n if (state.holding_id != INVALID) {\n // CARRYING\n int cid = state.holding_id;\n int target_row = cid / N;\n \n if (is_next_needed(cid)) {\n // Deliver to Dispatch Gate\n Point dest = {target_row, N-1};\n if (state.crane_pos == dest) {\n // Check if we can drop (should be empty unless we just dropped, but update_outputs clears it)\n // Actually update_outputs runs at END of previous turn, so it should be clear.\n if (state.grid[dest.r][dest.c] == INVALID) {\n op = 'Q';\n state.grid[dest.r][dest.c] = cid;\n state.holding_id = INVALID;\n state.next_output_idx[target_row]++;\n state.dispatched_count++;\n } else {\n op = '.'; // Wait? Should not happen often.\n }\n } else {\n op = move_towards(dest);\n }\n } else {\n // Store\n // If we don't have a valid storage target, find one.\n if (target_pos.r == -1 || state.grid[target_pos.r][target_pos.c] != INVALID) {\n target_pos = find_storage_spot(cid);\n }\n \n if (state.crane_pos == target_pos) {\n if (state.grid[target_pos.r][target_pos.c] == INVALID) {\n op = 'Q';\n state.grid[target_pos.r][target_pos.c] = cid;\n state.holding_id = INVALID;\n target_pos = {-1, -1};\n } else {\n // Spot taken (maybe input spawned there if we targeted (r,0)? No, storage is cols 1-3).\n target_pos = find_storage_spot(cid);\n if(state.crane_pos != target_pos) op = move_towards(target_pos);\n else op = '.';\n }\n } else {\n op = move_towards(target_pos);\n }\n }\n } \n else {\n // EMPTY - Need to Pick\n Point best_pick = {-1, -1};\n int best_dist = 10000;\n bool found_urgent_on_grid = false;\n \n // 1. Scan grid for urgent items (Priority 1)\n // Include (r, 0) inputs.\n for(int r=0; r dest.r) return 'U';\n if (state.crane_pos.c < dest.c) return 'R';\n if (state.crane_pos.c > dest.c) return 'L';\n return '.';\n }\n \n Point find_storage_spot(int cid) {\n // Prefer columns 3 -> 2 -> 1 to keep input area (col 0) and maneuvering space open.\n // Prefer same row.\n int r = cid / N;\n \n // 1. Same row, cols 3,2,1\n for(int c=3; c>=1; --c) {\n if(state.grid[r][c] == INVALID) return {r, c};\n }\n // 2. Other rows, cols 3,2,1\n for(int i=0; i=1; --c) {\n if(state.grid[i][c] == INVALID) return {i, c};\n }\n }\n \n // Fallback: Should not happen with reasonable N=5 logic\n return state.crane_pos; \n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n_dummy;\n if (!(cin >> n_dummy)) return 0;\n \n vector> A(N, vector(N));\n for(int i=0; i> A[i][j];\n }\n }\n \n Solver solver(A);\n solver.solve();\n \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 std;\n\n// Problem Constants\nconst int N = 20;\nconst long long BASE_MOVE_COST = 100;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& other) const {\n return r == other.r && c == other.c;\n }\n bool operator!=(const Point& other) const {\n return !(*this == other);\n }\n};\n\n// Manhattan distance\nint dist(Point p1, Point p2) {\n return abs(p1.r - p2.r) + abs(p1.c - p2.c);\n}\n\nenum OpType { MOVE, LOAD, UNLOAD };\n\nstruct Operation {\n OpType type;\n int val; // direction (0:U, 1:D, 2:L, 3:R) or amount\n char getChar() const {\n if (type == LOAD) return '+';\n if (type == UNLOAD) return '-';\n if (type == MOVE) {\n if (val == 0) return 'U';\n if (val == 1) return 'D';\n if (val == 2) return 'L';\n if (val == 3) return 'R';\n }\n return '?';\n }\n};\n\nstruct Result {\n vector ops;\n long long cost;\n long long final_score;\n};\n\n// Global input\nint initial_grid[N][N];\nlong long INITIAL_BASE_SCORE = 0;\n\n// Random engine\nmt19937 rng(12345);\n\n// Timer\nauto start_time = chrono::high_resolution_clock::now();\ndouble get_time() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\nstruct State {\n int grid[N][N];\n Point truck_pos;\n int current_load;\n vector history;\n long long current_cost;\n \n State() {\n for(int i=0; i target.r) apply_move(0); // U\n else apply_move(1); // D\n }\n while (truck_pos.c != target.c) {\n if (truck_pos.c > target.c) apply_move(2); // L\n else apply_move(3); // R\n }\n }\n \n void load_soil(int amount) {\n if (amount <= 0) return;\n grid[truck_pos.r][truck_pos.c] -= amount;\n current_load += amount;\n current_cost += amount;\n history.push_back({LOAD, amount});\n }\n \n void unload_soil(int amount) {\n if (amount <= 0) return;\n grid[truck_pos.r][truck_pos.c] += amount;\n current_load -= amount;\n current_cost += amount;\n history.push_back({UNLOAD, amount});\n }\n};\n\nlong long calculate_score(const State& s) {\n long long diff = 0;\n for(int i=0; i active_cells;\n active_cells.reserve(N*N);\n \n // Optimization: reuse vector memory\n struct Candidate {\n int idx;\n double score;\n };\n vector candidates;\n candidates.reserve(N*N);\n\n while (s.history.size() < limit_steps) {\n active_cells.clear();\n for(int i=0; i 0) {\n // Source: Picking up soil\n // Value is proportional to amount picked up\n // Discounted if we are already carrying a lot (heuristic: discourage hoarding)\n double load_factor = 1.0 + (s.current_load / 50.0); \n score += (h * p_collect) / load_factor; \n \n // Additional penalty: Moving far while loaded is bad.\n // If we are already loaded, picking up more implies we carry 'current_load' further?\n // Not necessarily, but we want to discourage extending the path when heavy.\n score -= s.current_load * d * p_load_penalty;\n \n } else {\n // Sink: Dropping soil\n int drop_amt = min(s.current_load, -h);\n if (drop_amt > 0) {\n score += drop_amt * p_drop;\n // Bonus for completely clearing a cell (removes it from future consideration)\n if (s.grid[p.r][p.c] + drop_amt == 0) score += p_clear;\n } else {\n // Can't drop anything. Going here is useless.\n score = -1e18; \n }\n }\n candidates.push_back({k, score});\n }\n \n if (candidates.empty()) break; // Should not happen if active_cells not empty\n \n // Partial Sort or just Sort\n int pick_n = min((int)candidates.size(), beam_width);\n \n // Move the best 'pick_n' elements to the front\n std::partial_sort(candidates.begin(), candidates.begin() + pick_n, candidates.end(), \n [](const Candidate& a, const Candidate& b){\n return a.score > b.score;\n });\n \n // Random selection from top candidates\n int selected_rank = std::uniform_int_distribution<>(0, pick_n - 1)(rng);\n Point target = active_cells[candidates[selected_rank].idx];\n \n // Execute\n s.move_to(target);\n int h = s.grid[target.r][target.c];\n if (h > 0) {\n s.load_soil(h);\n } else if (h < 0) {\n int can_drop = min(s.current_load, -h);\n s.unload_soil(can_drop);\n }\n }\n \n return {s.history, s.current_cost, calculate_score(s)};\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n_in;\n if (!(cin >> n_in)) return 0;\n \n for(int i=0; i> initial_grid[i][j];\n INITIAL_BASE_SCORE += abs(initial_grid[i][j]);\n }\n }\n \n Result best_res;\n best_res.final_score = -1;\n \n // Hyperparameter Search\n int iterations = 0;\n while (get_time() < 1.90) {\n iterations++;\n \n double p_dist = 1.0;\n // Penalize carrying load over distance\n double p_load_penalty = std::uniform_real_distribution<>(0.1, 3.0)(rng);\n // Reward for picking up soil\n double p_collect = std::uniform_real_distribution<>(10.0, 200.0)(rng);\n // Reward for dropping soil (usually higher to clear buffer)\n double p_drop = std::uniform_real_distribution<>(50.0, 500.0)(rng);\n // Bonus for clearing a cell completely\n double p_clear = std::uniform_real_distribution<>(0.0, 1000.0)(rng);\n // Beam width for randomness\n int beam = std::uniform_int_distribution<>(1, 3)(rng);\n \n // Occasional specific strategies\n if (iterations % 10 == 0) {\n // Aggressive clearing\n p_drop = 1000.0; p_clear = 2000.0; p_load_penalty = 5.0; beam = 1;\n } else if (iterations % 10 == 1) {\n // Balanced\n p_drop = 200.0; p_collect = 100.0; p_dist = 1.5; beam = 2;\n }\n\n Result res = solve_greedy(p_dist, p_load_penalty, p_collect, p_drop, p_clear, beam);\n \n if (res.final_score > best_res.final_score) {\n best_res = res;\n }\n }\n \n for (const auto& op : best_res.ops) {\n if (op.type == MOVE) {\n cout << op.getChar() << \"\\n\";\n } else {\n cout << op.getChar() << op.val << \"\\n\";\n }\n }\n \n return 0;\n}","ahc035":"/**\n * AHC035 Solution - Refined\n *\n * Strategy:\n * 1. Selection:\n * - Identify current max value for each attribute across all seeds.\n * - Ensure seeds holding these max values are selected first. This preserves the \"gene pool\" potential,\n * ensuring that even if a seed has a low total sum, its unique high-value attribute is not lost.\n * - Fill remaining grid spots (up to N*N) with seeds having the highest Total Value (Elitism).\n *\n * 2. Initial Placement (Degree Heuristic):\n * - The number of offspring produced by a grid cell is proportional to its degree (number of neighbors).\n * - To maximize the expected sum of the next generation, high-value seeds should be placed in high-degree cells.\n * - We map the highest Total Value seeds to the grid cells sorted by degree (Center > Edge > Corner).\n *\n * 3. Placement Optimization (Hill Climbing):\n * - While the degree heuristic maximizes the population average, we want to maximize the \"best\" seed.\n * - We perform local search (swapping seeds in the grid) to maximize the sum of component-wise maximums\n * of adjacent neighbors: Sum(max(SeedA_i, SeedB_i)).\n * - This metric encourages placing \"complementary\" seeds together (e.g., one good at attribute 0, another at attribute 1),\n * increasing the variance and the potential upper bound of the offspring.\n *\n * 4. Time Management:\n * - The grid is small (N=6), allowing for intensive local search. We use a time-based loop to run\n * optimization for ~180ms per turn.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Constants\nconst int MAX_VAL = 100;\n\nstruct Seed {\n int id;\n vector features;\n int total_value;\n};\n\nint N, M, T;\nint SEED_COUNT;\nint GRID_SIZE;\n\n// Read seeds from input\nvector read_seeds(int count, int m) {\n vector seeds(count);\n for (int i = 0; i < count; ++i) {\n seeds[i].id = i;\n seeds[i].features.resize(m);\n int sum = 0;\n for (int j = 0; j < m; ++j) {\n cin >> seeds[i].features[j];\n sum += seeds[i].features[j];\n }\n seeds[i].total_value = sum;\n }\n return seeds;\n}\n\n// Calculate degrees of cells in NxN grid\n// Corners=2, Edges=3, Inner=4\nvector> get_degrees(int n) {\n vector> deg(n, vector(n, 0));\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n for(int r=0; r= 0 && nr < n && nc >= 0 && nc < n) {\n deg[r][c]++;\n }\n }\n }\n }\n return deg;\n}\n\n// Get grid coordinates sorted by importance:\n// 1. Higher degree is better.\n// 2. Closer to center is better (tie-breaker for tightness).\nvector> get_sorted_cells(int n) {\n vector> deg = get_degrees(n);\n vector> cells;\n cells.reserve(n*n);\n for(int r=0; r& a, const pair& b) {\n if (deg[a.first][a.second] != deg[b.first][b.second]) {\n return deg[a.first][a.second] > deg[b.first][b.second];\n }\n double da = pow(a.first - center, 2) + pow(a.second - center, 2);\n double db = pow(b.first - center, 2) + pow(b.second - center, 2);\n return da < db;\n });\n return cells;\n}\n\n// Objective Function for Hill Climbing:\n// Sum of component-wise max for all adjacent pairs.\n// Maximizing this increases the probability of generating \"Super Seeds\".\nlong long calculate_grid_score(const vector>& grid_indices, const vector& seeds) {\n long long score = 0;\n int n = grid_indices.size();\n \n // Horizontal edges\n for(int r=0; r& current_seeds) {\n // 1. Identify global max values for each attribute\n vector max_attr_val(M, -1);\n for(const auto& s : current_seeds) {\n for(int k=0; k 36 seeds)\n vector is_selected(current_seeds.size(), false);\n vector selected_indices;\n selected_indices.reserve(GRID_SIZE);\n\n // Priority 1: Gene Preservation\n // Select seeds that currently hold the maximum value for any attribute.\n for(int k=0; k best_sum) {\n best_sum = current_seeds[i].total_value;\n best_idx = i;\n }\n }\n }\n if(best_idx != -1 && !is_selected[best_idx]) {\n is_selected[best_idx] = true;\n selected_indices.push_back(best_idx);\n }\n }\n\n // Priority 2: Elitism\n // Fill remaining spots with seeds having the highest total value.\n vector> remaining;\n remaining.reserve(current_seeds.size());\n for(int i=0; i<(int)current_seeds.size(); ++i) {\n if(!is_selected[i]) remaining.push_back({current_seeds[i].total_value, i});\n }\n sort(remaining.rbegin(), remaining.rend());\n \n for(const auto& p : remaining) {\n if((int)selected_indices.size() < GRID_SIZE) {\n selected_indices.push_back(p.second);\n is_selected[p.second] = true;\n } else break;\n }\n\n // 3. Initial Placement (Degree Heuristic)\n // We want strong seeds in the center.\n // Sort the *selected* seeds by total value.\n vector placement_seeds = selected_indices;\n sort(placement_seeds.begin(), placement_seeds.end(), [&](int a, int b) {\n return current_seeds[a].total_value > current_seeds[b].total_value;\n });\n\n vector> sorted_cells = get_sorted_cells(N);\n vector> grid(N, vector(N));\n \n // Map best seed to best cell, second best seed to second best cell, etc.\n for(int i=0; i(now - start_clock).count() > 180) break;\n\n // Run a batch of iterations to amortize clock check overhead\n for(int k=0; k<200; ++k) {\n int r1 = rng() % N; \n int c1 = rng() % N;\n int r2 = rng() % N; \n int c2 = rng() % N;\n if(r1 == r2 && c1 == c2) continue;\n\n swap(grid[r1][c1], grid[r2][c2]);\n // Since N is very small (6), full recalculation is fast enough\n long long new_score = calculate_grid_score(grid, current_seeds);\n\n if(new_score > current_score) {\n current_score = new_score;\n } else {\n swap(grid[r1][c1], grid[r2][c2]); // Revert swap\n }\n }\n }\n\n // 5. Output\n for(int r=0; r> N >> M >> T)) return 0;\n \n SEED_COUNT = 2 * N * (N - 1);\n GRID_SIZE = N * N;\n \n vector seeds = read_seeds(SEED_COUNT, M);\n \n for(int t=0; t\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Globals ---\nint N, M, V;\nvector> grid_s;\nvector> grid_t;\n\n// Current state tracking\nvector> current_board;\nvector> remaining_targets;\n\n// Robot State\nstruct Robot {\n int num_leaves; // Vertices 1..num_leaves are leaves. Vertex 0 is root.\n int r, c;\n // Leaves state\n // Directions: 0:R, 1:D, 2:L, 3:U relative to parent (root)\n vector leaf_dirs; \n vector holding; // true if holding takoyaki\n};\n\nRobot robot;\n\n// Directions and Helper Constants\nconst int DR[] = {0, 1, 0, -1};\nconst int DC[] = {1, 0, -1, 0};\n\n// --- Helper Functions ---\n\n// Check if coordinates are within grid bounds\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\n// Helper to calculate rotation step\n// Returns 'R', 'L', or '.' and updates current direction\nchar get_rotation_step(int& curr_dir, int target_dir) {\n if (curr_dir == target_dir) return '.';\n int diff = (target_dir - curr_dir + 4) % 4;\n if (diff == 1) { // Clockwise\n curr_dir = (curr_dir + 1) % 4;\n return 'R';\n } else { // Counter-clockwise (diff is 3 or 2)\n // Note: 180 degree turn (diff=2) requires 2 steps. We take one step 'R' or 'L'.\n // Here we prioritize L for 3, R for 1. For 2, we pick R arbitrarily.\n if (diff == 3) {\n curr_dir = (curr_dir + 3) % 4;\n return 'L';\n } else {\n curr_dir = (curr_dir + 1) % 4;\n return 'R';\n }\n }\n}\n\n// Output formatted operation string\n// Format requires length 2V'.\n// S[0]: Root Move\n// S[1..V'-1]: Rotations for vertices 1..V'-1\n// S[V'..2V'-1]: Actions for vertices 0..V'-1\nvoid print_op(char move_root, const string& rotations, const string& leaf_actions) {\n string out;\n out += move_root; // Index 0\n out += rotations; // Index 1 to V'-1 (Length K)\n out += '.'; // Index V' (Action for Root, Vertex 0)\n out += leaf_actions; // Index V'+1 to 2V'-1 (Action for Leaves 1..K)\n cout << out << \"\\n\";\n}\n\nvoid solve() {\n // --- 1. Design Arm ---\n // Strategy: Star Graph with Root (0) and K leaves (1..K).\n // Edges are all length 1. This allows picking up from any neighbor of the root.\n // We use up to V-1 leaves to maximize carrying capacity.\n int K = V - 1;\n \n // Output Design\n cout << (K + 1) << endl; // V' = K + 1\n for (int i = 0; i < K; ++i) {\n cout << \"0 1\" << endl; // Parent 0, Length 1\n }\n \n // Initial Position (Top-Left)\n robot.r = 0; \n robot.c = 0;\n cout << robot.r << \" \" << robot.c << endl;\n \n // Initialize Robot Logic State\n robot.num_leaves = K;\n robot.leaf_dirs.assign(K, 0); // Initially all facing Right (0)\n robot.holding.assign(K, false);\n \n // Initialize Board State\n current_board = grid_s;\n remaining_targets = grid_t;\n \n // --- 2. Main Loop ---\n // Greedy approach: Pick up closest item or Drop to closest target.\n // Parallelism: Move root and rotate leaves simultaneously.\n \n int ops_count = 0;\n const int MAX_OPS = 100000;\n \n while (ops_count < MAX_OPS) {\n // Check termination: Are all required targets filled?\n bool done = true;\n for(int r=0; r\n vector> candidates; \n \n // 1. Search for Pickups\n // Only consider if we have empty leaves.\n // Valid Source: Has takoyaki (s=1), Is NOT a target (t=0). \n // (We skip s=1,t=1 cases as they are already satisfied).\n if (holding_count < K) {\n for(int r=0; r 0) {\n for(int r=0; r(a);\n int db = get<0>(b);\n if (abs(da - db) <= 2) { // If distances are very similar\n bool type_a = get<3>(a); \n bool type_b = get<3>(b);\n if (type_a != type_b) {\n // If holding > 50% capacity, prefer Drop (false)\n if (holding_count * 2 > K) return !type_a; \n else return type_a; // Else prefer Pick (true)\n }\n }\n return da < db;\n });\n \n auto best = candidates[0];\n int target_root_r = get<1>(best);\n int target_root_c = get<2>(best);\n bool is_pickup = get<3>(best);\n \n // --- Determine Operation Details ---\n // We need to find exactly which square adjacent to target_root is the objective.\n int obj_r = -1, obj_c = -1;\n for(int d=0; d<4; ++d) {\n int nr = target_root_r + DR[d];\n int nc = target_root_c + DC[d];\n if(!is_valid(nr, nc)) continue;\n if(is_pickup) {\n if(current_board[nr][nc] == 1 && grid_t[nr][nc] == 0) {\n obj_r = nr; obj_c = nc; break;\n }\n } else {\n if(current_board[nr][nc] == 0 && remaining_targets[nr][nc] == 1) {\n obj_r = nr; obj_c = nc; break;\n }\n }\n }\n \n // Calculate required leaf direction relative to target_root\n // (0,1)->0(R), (1,0)->1(D), (0,-1)->2(L), (-1,0)->3(U)\n int req_dir = -1;\n if(obj_r == target_root_r && obj_c == target_root_c + 1) req_dir = 0;\n else if(obj_r == target_root_r + 1 && obj_c == target_root_c) req_dir = 1;\n else if(obj_r == target_root_r && obj_c == target_root_c - 1) req_dir = 2;\n else if(obj_r == target_root_r - 1 && obj_c == target_root_c) req_dir = 3;\n \n // Select a suitable leaf\n int chosen_leaf = -1;\n int best_leaf_align = 100;\n for(int i=0; i 3 is 1 step\n if(dist < best_leaf_align) {\n best_leaf_align = dist;\n chosen_leaf = i;\n }\n }\n }\n \n if (chosen_leaf == -1) break; // Logic fallback\n \n // --- Execute Movement and Rotation Simultaneously ---\n while (robot.r != target_root_r || robot.c != target_root_c || robot.leaf_dirs[chosen_leaf] != req_dir) {\n char move_c = '.';\n string rots(K, '.');\n string acts(K, '.');\n \n // Move Root logic\n if (robot.r < target_root_r) { move_c = 'D'; robot.r++; }\n else if (robot.r > target_root_r) { move_c = 'U'; robot.r--; }\n else if (robot.c < target_root_c) { move_c = 'R'; robot.c++; }\n else if (robot.c > target_root_c) { move_c = 'L'; robot.c--; }\n \n // Rotate Leaf logic\n if (robot.leaf_dirs[chosen_leaf] != req_dir) {\n rots[chosen_leaf] = get_rotation_step(robot.leaf_dirs[chosen_leaf], req_dir);\n }\n \n print_op(move_c, rots, acts);\n ops_count++;\n if (ops_count >= MAX_OPS) return;\n }\n \n // --- Perform Pick/Drop Action ---\n string rots(K, '.');\n string acts(K, '.');\n acts[chosen_leaf] = 'P';\n print_op('.', rots, acts);\n ops_count++;\n \n // Update Logic State\n if (is_pickup) {\n robot.holding[chosen_leaf] = true;\n current_board[obj_r][obj_c] = 0;\n } else {\n robot.holding[chosen_leaf] = false;\n current_board[obj_r][obj_c] = 1;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n if (cin >> N >> M >> V) {\n grid_s.assign(N, vector(N));\n grid_t.assign(N, vector(N));\n \n for(int i=0; i> row;\n for(int j=0; j> row;\n for(int j=0; j\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\n// -----------------------------------------------------------------------------\n// Constants and Globals\n// -----------------------------------------------------------------------------\nconst int GRID_SIZE = 100000;\nconst int MAX_COORD = 100000;\nconst int N_POINTS = 5000;\nconst int MAX_VERTICES = 1000;\nconst int MAX_LENGTH = 400000;\n\n// Use a coarse grid for the constructive heuristic\nconst int K = 40; // 40x40 grid. Each cell is 2500x2500.\nconst int CELL_SIZE = MAX_COORD / K;\n\nstruct Point {\n int x, y;\n int id;\n};\n\nstruct GridCell {\n vector mackerel_indices;\n vector sardine_indices;\n int base_score; // mackerels - sardines inside this exact square\n};\n\n// Global data\nvector mackerels;\nvector sardines;\nGridCell grid[K][K];\n\n// Utility for time keeping\nauto start_time = chrono::high_resolution_clock::now();\ndouble get_time_sec() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n}\n\n// Random number generator\nmt19937 rng(12345);\n\n// -----------------------------------------------------------------------------\n// Geometry Helpers\n// -----------------------------------------------------------------------------\n\n// Represents a polygon as a sequence of points\nusing Polygon = vector>;\n\n// Calculate score of a polygon exactly\nlong long calculate_score(const Polygon& poly) {\n // A point is inside if winding number is non-zero.\n // Since we have simple rectilinear polygons, we can use a simpler scan-line or just standard PIP.\n // However, for the contest, calculating exact score frequently is slow.\n // We trust our heuristic construction.\n // This function is mainly for debugging or final verification if needed.\n return 0; \n}\n\n// Trace boundary of the boolean grid\n// Returns a list of vertices (x, y) in order.\n// The grid coordinates are scaled by CELL_SIZE later.\n// Returns empty if invalid (e.g. empty grid).\nPolygon trace_boundary(const vector>& active, int& perimeter_blocks, int& vertices_count) {\n int start_x = -1, start_y = -1;\n for (int i = 0; i < K; ++i) {\n for (int j = 0; j < K; ++j) {\n if (active[i][j]) {\n start_x = i;\n start_y = j;\n goto found;\n }\n }\n }\n found:;\n \n if (start_x == -1) return {};\n\n // Directions: 0: Right, 1: Down, 2: Left, 3: Up\n // dx, dy corresponding to moving along the grid lines\n int dx[] = {1, 0, -1, 0};\n int dy[] = {0, -1, 0, 1};\n \n // We trace the \"edges\" of the active cells.\n // An edge is defined by the coordinate of the grid line.\n // We start at the top-left corner of the first found block (start_x, start_y).\n // Since we scan row by row, (start_x, start_y) is the top-left-most block.\n // Its top edge is definitely a boundary.\n // Let's define our position as the intersection of grid lines.\n // (x, y) corresponds to the corner x*CELL_SIZE, y*CELL_SIZE.\n // Top-left of block (i, j) is grid node (i, j+1) in cartesian if y goes up?\n // Problem coords: x right, y up.\n // Grid indices: let's map active[x][y] to the spatial box [x*S, (x+1)*S] x [y*S, (y+1)*S].\n // Then the top-left corner of block (start_x, start_y) is (start_x, start_y+1).\n // Wait, let's trace standard \"marching squares\" style or wall following.\n \n // Current position in grid node coords (0..K, 0..K)\n int cx = start_x;\n int cy = start_y + 1;\n int dir = 0; // Initial facing direction: Right (along the top edge of the block)\n\n Polygon poly;\n poly.push_back({cx, cy});\n\n // Determine initial direction validity? \n // We are at (start_x, start_y+1). The block (start_x, start_y) is to our Bottom-Right (if we face Right).\n // Wall following rule (Right hand on wall):\n // The \"wall\" is the active cells. We walk along the boundary such that active cells are on the right.\n \n // Helper to check if a cell is active\n auto is_active = [&](int x, int y) {\n if (x < 0 || x >= K || y < 0 || y >= K) return false;\n return active[x][y];\n };\n\n int initial_cx = cx;\n int initial_cy = cy;\n int initial_dir = dir;\n bool first_move = true;\n\n perimeter_blocks = 0;\n vertices_count = 0;\n\n while (true) {\n if (!first_move && cx == initial_cx && cy == initial_cy && dir == initial_dir) break;\n first_move = false;\n\n // Try to turn right first (relative to current dir)\n int right_dir = (dir + 1) % 4;\n // Check the cell that would be to our \"right\" after turning right and moving.\n // Actually, let's just check the 4 cells around current node (cx, cy).\n // Depending on dir, we are moving along an edge.\n // Let's use a simpler logic:\n // We are at a vertex. We came from 'dir'.\n // We want to keep the active region to our RIGHT.\n // Cells around vertex (cx, cy):\n // Top-Right (cx, cy), Top-Left (cx-1, cy), Bottom-Left (cx-1, cy-1), Bottom-Right (cx, cy-1)\n // Indices are relative to the grid cell indices.\n \n // Let's re-evaluate based on \"look ahead\".\n // Current edge is between (cx, cy) and (cx+dx[dir], cy+dy[dir]).\n // Is the cell to the right of this edge active?\n // Edge directions: 0: +x (Right), 1: -y (Down), 2: -x (Left), 3: +y (Up)\n \n // Relative cell coords to the edge starting at (cx, cy) heading 'dir':\n // Dir 0 (Right): Cell (cx, cy-1) is to the Right (Bottom-Right). Cell (cx, cy) is Left (Top-Right).\n // Dir 1 (Down): Cell (cx-1, cy-1) is Right. Cell (cx, cy-1) is Left.\n // Dir 2 (Left): Cell (cx-1, cy) is Right. Cell (cx-1, cy-1) is Left.\n // Dir 3 (Up): Cell (cx, cy) is Right. Cell (cx-1, cy) is Left.\n \n // We want to find the new direction such that the active region remains on the right.\n // We check relative turn directions: Right, Straight, Left, U-turn (impossible in simple poly).\n \n // Candidate directions in preference order for Right-Hand rule:\n // Turn Right (dir+1), Straight (dir), Turn Left (dir-1), U-Turn (dir+2)\n // Wait, standard contour tracing:\n // Look at the 2x2 cells around current node (cx, cy).\n // Identify which are active.\n // Determine outgoing edge.\n // But we are maintaining state (cx, cy, dir).\n \n // Check \"front-right\" cell relative to current dir.\n // If it is active -> We must turn right to keep it on right side? No, if front-right is active, \n // we might need to go straight or turn right depending on front-left.\n // Let's use a robust state machine.\n // Cell to the Right of current edge (hypothetically if we moved `dir`):\n // Dir 0: (cx, cy-1)\n // Dir 1: (cx-1, cy-1)\n // Dir 2: (cx-1, cy)\n // Dir 3: (cx, cy)\n \n // Helper to get \"Right\" cell coords given current pos and dir\n auto get_right_cell = [&](int x, int y, int d) -> pair {\n if (d == 0) return {x, y - 1};\n if (d == 1) return {x - 1, y - 1};\n if (d == 2) return {x - 1, y};\n return {x, y};\n };\n\n // Helper to get \"Left\" cell coords\n auto get_left_cell = [&](int x, int y, int d) -> pair {\n if (d == 0) return {x, y};\n if (d == 1) return {x, y - 1};\n if (d == 2) return {x - 1, y - 1};\n return {x - 1, y};\n };\n\n // Logic:\n // Ideally we move in `dir`. The cell to our right MUST be active. The cell to our left MUST be inactive.\n // But at a corner, this changes.\n // At vertex (cx, cy):\n // We arrived here. Now we choose new `dir`.\n // We check all 4 outgoing directions from (cx, cy).\n // Valid outgoing edge must have Active on Right, Inactive on Left.\n \n int next_dir = -1;\n // We search for the valid outgoing direction.\n // Since we follow the boundary, there is exactly one valid continuation unless self-intersecting (touching corners).\n // Touching corners case (checkerboard):\n // I A\n // A I\n // This creates ambiguity. We should prefer staying connected to current component logic.\n // For simple boundary tracing of a set of 4-connected cells, if the set is valid (no holes, single component),\n // we should just pick the \"sharpest left turn\" (CCW) or \"sharpest right turn\" (CW) that is valid?\n // Let's try checking directions starting from (dir + 3) % 4 (Left turn) -> (dir) -> (dir + 1).\n // i.e. try to turn left, then straight, then right. (This traces CCW or something? We want CW?)\n // We defined \"Active on Right\". This is CW tracing.\n // Preference for CW tracing: Try turning Right first? No, if we trace CW, inside is on Right.\n // At a convex corner, we turn Right. At a concave corner, we turn Left.\n // So we should check: Turn Right, then Straight, then Turn Left.\n // If we check \"Turn Right\" ((dir + 1)%4): check if valid edge.\n // Valid edge means: Get_Right_Cell is Active, Get_Left_Cell is Inactive.\n \n for (int k = 1; k >= -2; --k) { // k=1 (Right), 0 (Straight), -1 (Left), -2 (Back - should not happen)\n int nd = (dir + k + 4) % 4;\n auto rc = get_right_cell(cx, cy, nd);\n auto lc = get_left_cell(cx, cy, nd);\n if (is_active(rc.first, rc.second) && !is_active(lc.first, lc.second)) {\n next_dir = nd;\n break;\n }\n }\n \n assert(next_dir != -1);\n\n // Add vertex if direction changed\n if (next_dir != dir && !poly.empty()) {\n // The last point added was (cx, cy).\n // Actually, we add points when we *complete* a segment or change direction.\n // Better: just accumulate all moves, then simplify.\n // Let's simplify on the fly:\n // if (next_dir == dir), we just extend.\n // if (next_dir != dir), (cx, cy) is a corner.\n // Wait, poly already has starting point.\n }\n \n if (next_dir != dir) {\n // We turn at (cx, cy). So (cx, cy) is a vertex.\n // Check if (cx, cy) is same as last vertex?\n if (poly.empty() || poly.back().first != cx || poly.back().second != cy) {\n poly.push_back({cx, cy});\n }\n }\n\n cx += dx[next_dir];\n cy += dy[next_dir];\n dir = next_dir;\n perimeter_blocks++;\n }\n\n vertices_count = poly.size();\n // Close the loop explicitly if needed, but format usually implies it.\n // The problem asks for vertices.\n return poly;\n}\n\n// -----------------------------------------------------------------------------\n// Core Logic\n// -----------------------------------------------------------------------------\n\n// Refine the boundary of the polygon by shifting edges perpendicular to their direction\n// to optimize the objective function locally.\nPolygon optimize_polygon(const Polygon& coarse_poly) {\n // coarse_poly coords are in grid units (0..K).\n // We need to convert to real coords.\n // Initially, map v -> v * CELL_SIZE.\n \n int m = coarse_poly.size();\n if (m == 0) return {};\n\n vector> current_poly(m);\n for(int i=0; i i) is horizontal at y=curr_y. It goes from v[prev].x to v[i].x.\n // If we move v[i].x, we are shortening/lengthening this edge.\n // We must not move v[i].x past v[prev].x (or beyond).\n // Actually, we can move past, but that changes topology (self-intersection).\n // To stay safe and simple: constrain x between v[prev].x and v[next2].x?\n // Be careful about direction.\n // Also we must check if we collide with *other* parts of the polygon. \n // Global intersection check is expensive. \n // Heuristic: constrain shift to a small window (e.g. +/- CELL_SIZE) or checking the grid.\n // Since we started from a grid, the \"safe\" range is roughly the grid cell width around the edge, \n // unless the shape is one cell wide.\n \n // Let's simplify: Limit shift to range [min(prev_x, next2_x), max(prev_x, next2_x)]. \n // This prevents the \"U\" shape from inverting.\n \n int low, high;\n int fixed_start, fixed_end; // The range of the perpendicular coordinate\n \n if (is_vertical) {\n // Shifting X.\n // Connected horizontal segments are at y = curr_y and y = next_y.\n // Range of y for this vertical edge:\n fixed_start = min((int)curr_y, (int)next_y);\n fixed_end = max((int)curr_y, (int)next_y);\n \n // Constraints on X\n int limit1 = current_poly[prev].first;\n int limit2 = current_poly[next2].first;\n low = min(limit1, limit2) + 1; // +1 to avoid collapse/overlap for now\n high = max(limit1, limit2) - 1;\n \n // Also bound by global limits\n low = max(low, 0);\n high = min(high, MAX_COORD);\n \n if (low > high) continue; // Cannot move\n\n // We want to find optimal x in [low, high].\n // The vertical edge \"sweeps\" area.\n // If we move x to x', the area change involves points in rectangle defined by x, x', fixed_start, fixed_end.\n // We need to know orientation to know if moving Right adds or removes area.\n // Boundary trace: Active on Right.\n // If moving from (x, y1) to (x, y2).\n // If y2 < y1 (Down), Interior is Right (Larger X). Moving X right shrinks polygon.\n // If y2 > y1 (Up), Interior is Right (Larger X). Moving X right expands polygon.\n // Wait, standard:\n // Up (y increasing): Right side is inside. So increasing X (moving edge right) reduces 'outside', increases 'inside'.\n // Down (y decreasing): Right side is inside. Increasing X increases 'outside', reduces 'inside'.\n \n int direction = (next_y > curr_y) ? 1 : -1; \n // If direction 1 (Up), Inside is Right. Increasing X => Add Mackerels, Add Sardines.\n // We want to Maximize (M - S).\n // Actually:\n // If we move edge to the Right (increase X):\n // If Up: We are sweeping \"into\" the interior? No.\n // Up vector: (0, 1). Right normal (1, 0). Inside is +X.\n // So the edge is the LEFT boundary of the shape.\n // Moving Left Boundary to the Right SHRINKs the shape.\n // So increasing X removes points.\n // Delta Score = - (Points in swept area).\n // We want to minimize points in swept area?\n // No, we want to find X that maximizes the Total Score.\n // Points between X_old and X_new are either added or removed.\n \n // Let's just compute the contribution of points in the strip y \\in [fixed_start, fixed_end].\n // For a point (px, py) in this y-range:\n // If py is in range:\n // If we place the edge at X.\n // If Up (Left Boundary): Point is inside if px > X.\n // If Down (Right Boundary): Point is inside if px < X.\n \n // So we want to choose X.\n // Collect all relevant points (mackerels and sardines) in y-range.\n // Sort them by X.\n // Iterate X through the sorted points and update score.\n \n vector> strip_points; // {x, weight}. Weight: +1 Mackerel, -1 Sardine\n for (const auto& p : mackerels) {\n if (p.y >= fixed_start && p.y <= fixed_end) strip_points.push_back({p.x, 1});\n }\n for (const auto& p : sardines) {\n if (p.y >= fixed_start && p.y <= fixed_end) strip_points.push_back({p.x, -1});\n }\n sort(strip_points.begin(), strip_points.end());\n\n // Base score? We only care about relative change.\n // Case Up (Left Boundary): inside if px > X.\n // Score contribution of this strip = Sum(weight for px > X).\n // As X increases, points drop out.\n // We start with X = low-1 (all points in range [low, high] are > X, so inside).\n // Then sweep X.\n \n // Case Down (Right Boundary): inside if px < X.\n // Score contribution = Sum(weight for px < X).\n // As X increases, points enter.\n\n // We only care about points within [low, high]. Points outside this X-range are unaffected by our choice \n // (they are permanently in or out regarding this edge's movement).\n \n // Filter points in [low, high]\n vector> active_points;\n for(auto& p : strip_points) {\n if (p.first >= low && p.first <= high) active_points.push_back(p);\n }\n \n int best_x = current_poly[i].first;\n long long best_val = -1e18; // Relative score\n \n if (direction == 1) { \n // Up: Inside is > X.\n // Total weight of all active points.\n // If we pick X, score is sum of weights with p.x > X.\n // Sweep: Start X < min(active). Score = Total Sum.\n // Move X past point p: Score -= p.weight.\n long long current_val = 0;\n for(auto& p : active_points) current_val += p.second;\n \n // Try X = low. (Points at X=low are > low? No. Boundary inclusion rule:\n // Problem says points ON edge are inside.\n // If Left Boundary is at X, points at X are inside.\n // So inside condition: p.x >= X.\n // Moving X past p (from p.x to p.x+1) removes p.\n \n // Initial candidate: X = low. All active points (>= low) are inside.\n if (current_val > best_val) { best_val = current_val; best_x = low; }\n \n // Sweep\n int p_idx = 0;\n for (int x = low + 1; x <= high; ++x) {\n // Remove points strictly less than x?\n // Points at x-1 are no longer >= x.\n while(p_idx < active_points.size() && active_points[p_idx].first < x) {\n current_val -= active_points[p_idx].second;\n p_idx++;\n }\n // If points are exactly at x? They are still inside.\n // We check this x as candidate.\n if (current_val >= best_val) { // Prefer larger X to break ties? Doesn't matter.\n best_val = current_val;\n best_x = x;\n }\n }\n } else {\n // Down: Inside is <= X (Points on edge included).\n // Sweep: Start X = low. Points <= low are inside.\n long long current_val = 0;\n int p_idx = 0;\n // Initial points at exactly low\n while(p_idx < active_points.size() && active_points[p_idx].first <= low) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n \n if (current_val > best_val) { best_val = current_val; best_x = low; }\n \n for (int x = low + 1; x <= high; ++x) {\n // Add points at x\n while(p_idx < active_points.size() && active_points[p_idx].first <= x) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n if (current_val >= best_val) {\n best_val = current_val;\n best_x = x;\n }\n }\n }\n \n if (best_x != current_poly[i].first) {\n current_poly[i].first = best_x;\n current_poly[next].first = best_x;\n changed = true;\n }\n } else {\n // Horizontal Edge. Shifting Y.\n // Logic is symmetric.\n fixed_start = min((int)curr_x, (int)next_x);\n fixed_end = max((int)curr_x, (int)next_x);\n\n int limit1 = current_poly[prev].second;\n int limit2 = current_poly[next2].second;\n low = min(limit1, limit2) + 1;\n high = max(limit1, limit2) - 1;\n \n low = max(low, 0);\n high = min(high, MAX_COORD);\n\n if (low > high) continue;\n\n vector> strip_points; \n for (const auto& p : mackerels) {\n if (p.x >= fixed_start && p.x <= fixed_end) strip_points.push_back({p.y, 1});\n }\n for (const auto& p : sardines) {\n if (p.x >= fixed_start && p.x <= fixed_end) strip_points.push_back({p.y, -1});\n }\n sort(strip_points.begin(), strip_points.end());\n\n vector> active_points;\n for(auto& p : strip_points) {\n if (p.first >= low && p.first <= high) active_points.push_back(p);\n }\n \n int direction = (next_x < curr_x) ? 1 : -1; \n // next_x < curr_x => Moving Left (-X). \n // Normal to right (0, -1) or something?\n // Let's trace:\n // Edge (curr_x, curr_y) -> (next_x, next_y). Y is constant.\n // Left (-X): (0, -1) is \"Right\" side (since vector is (-1, 0)).\n // Inside is Down (-Y) direction. Top Boundary.\n // Top Boundary: Inside is y <= Y.\n // Right (+X): Vector (1, 0). Right side is (0, -1) -> Down. Inside is Down?\n // Wait.\n // Vector (dx, 0). Right normal is (0, -dx).\n // If dx > 0 (Right): Normal (0, -1) (Down). Inside is y <= Y. (Top edge).\n // If dx < 0 (Left): Normal (0, 1) (Up). Inside is y >= Y. (Bottom edge).\n \n int best_y = current_poly[i].second;\n long long best_val = -1e18;\n\n if (direction == 1) { // dx < 0, Left. Bottom Edge. Inside y >= Y.\n long long current_val = 0;\n for(auto& p : active_points) current_val += p.second;\n \n if (current_val > best_val) { best_val = current_val; best_y = low; }\n \n int p_idx = 0;\n for (int y = low + 1; y <= high; ++y) {\n while(p_idx < active_points.size() && active_points[p_idx].first < y) {\n current_val -= active_points[p_idx].second;\n p_idx++;\n }\n if (current_val >= best_val) {\n best_val = current_val;\n best_y = y;\n }\n }\n } else { // dx > 0, Right. Top Edge. Inside y <= Y.\n long long current_val = 0;\n int p_idx = 0;\n while(p_idx < active_points.size() && active_points[p_idx].first <= low) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n \n if (current_val > best_val) { best_val = current_val; best_y = low; }\n \n for (int y = low + 1; y <= high; ++y) {\n while(p_idx < active_points.size() && active_points[p_idx].first <= y) {\n current_val += active_points[p_idx].second;\n p_idx++;\n }\n if (current_val >= best_val) {\n best_val = current_val;\n best_y = y;\n }\n }\n }\n\n if (best_y != current_poly[i].second) {\n current_poly[i].second = best_y;\n current_poly[next].second = best_y;\n changed = true;\n }\n }\n }\n if (!changed) break;\n }\n \n return current_poly;\n}\n\n// -----------------------------------------------------------------------------\n// Solver\n// -----------------------------------------------------------------------------\n\nvoid solve() {\n // Read input\n int N_dummy;\n if (!(cin >> N_dummy)) return;\n \n mackerels.resize(N_POINTS);\n for (int i = 0; i < N_POINTS; ++i) {\n cin >> mackerels[i].x >> mackerels[i].y;\n mackerels[i].id = i;\n }\n sardines.resize(N_POINTS);\n for (int i = 0; i < N_POINTS; ++i) {\n cin >> sardines[i].x >> sardines[i].y;\n sardines[i].id = i;\n }\n\n // Precompute Grid Weights\n for (int i = 0; i < K; ++i) {\n for (int j = 0; j < K; ++j) {\n grid[i][j].base_score = 0;\n }\n }\n\n auto get_grid_coords = [&](int x, int y) {\n return make_pair(min(x / CELL_SIZE, K - 1), min(y / CELL_SIZE, K - 1));\n };\n\n for (int i = 0; i < N_POINTS; ++i) {\n auto p = get_grid_coords(mackerels[i].x, mackerels[i].y);\n grid[p.first][p.second].mackerel_indices.push_back(i);\n grid[p.first][p.second].base_score++;\n }\n for (int i = 0; i < N_POINTS; ++i) {\n auto p = get_grid_coords(sardines[i].x, sardines[i].y);\n grid[p.first][p.second].sardine_indices.push_back(i);\n grid[p.first][p.second].base_score--;\n }\n\n // Initial State: Find best single cell\n int best_i = -1, best_j = -1;\n int max_cell_score = -1e9;\n for(int i=0; i max_cell_score) {\n max_cell_score = grid[i][j].base_score;\n best_i = i;\n best_j = j;\n }\n }\n }\n\n vector> active(K, vector(K, false));\n active[best_i][best_j] = true;\n\n // Simulated Annealing / Hill Climbing\n int current_score = max_cell_score;\n \n // To check connectivity efficiently, we can maintain counts or just run BFS.\n // Since K is small (40x40 = 1600), BFS is very fast (~10us).\n // We can afford full check.\n \n auto check_connectivity = [&](const vector>& state) {\n // Check if active cells are connected\n // Check if inactive cells are connected (no holes)\n int active_cnt = 0;\n int start_x = -1, start_y = -1;\n for(int i=0; i> visited(K, vector(K, false));\n deque> q;\n q.push_back({start_x, start_y});\n visited[start_x][start_y] = true;\n found_active++;\n \n int dx[] = {0, 0, 1, -1};\n int dy[] = {1, -1, 0, 0};\n\n while(!q.empty()) {\n auto [cx, cy] = q.front(); q.pop_front();\n for(int k=0; k<4; ++k) {\n int nx = cx + dx[k], ny = cy + dy[k];\n if (nx >= 0 && nx < K && ny >= 0 && ny < K && state[nx][ny] && !visited[nx][ny]) {\n visited[nx][ny] = true;\n found_active++;\n q.push_back({nx, ny});\n }\n }\n }\n if (found_active != active_cnt) return false;\n\n // Check for holes (Inactive connectivity to boundary)\n // We assume \"outside\" is connected to boundary of the grid.\n // BFS from all border inactive cells.\n int inactive_cnt = (K*K) - active_cnt;\n if (inactive_cnt == 0) return true; // Full grid\n\n // Reset visited\n for(int i=0; i= 0 && nx < K && ny >= 0 && ny < K && !state[nx][ny] && !visited[nx][ny]) {\n visited[nx][ny] = true;\n found_inactive++;\n q.push_back({nx, ny});\n }\n }\n }\n \n return found_inactive == inactive_cnt;\n };\n\n double T0 = 2000.0;\n double T1 = 10.0;\n double TL = 1.5; // Time limit for grid search\n int iter = 0;\n \n vector> boundary_candidates; // Neighbors of current shape\n // Initialize boundary candidates\n auto update_candidates = [&](const vector>& s) {\n boundary_candidates.clear();\n for(int i=0; i= 0 && nx < K && ny >= 0 && ny < K && !s[nx][ny]) {\n boundary_candidates.push_back({nx, ny});\n }\n }\n }\n }\n }\n // Unique\n sort(boundary_candidates.begin(), boundary_candidates.end());\n boundary_candidates.erase(unique(boundary_candidates.begin(), boundary_candidates.end()), boundary_candidates.end());\n };\n update_candidates(active);\n \n vector> active_list;\n active_list.push_back({best_i, best_j});\n\n while (true) {\n iter++;\n if ((iter & 127) == 0) {\n double t = get_time_sec();\n if (t > TL) break;\n }\n \n double time_ratio = get_time_sec() / TL;\n double temp = T0 + (T1 - T0) * time_ratio;\n\n // Two moves: Add a cell or Remove a cell\n int move_type = rng() % 2;\n \n if (move_type == 0) { // Add\n if (boundary_candidates.empty()) continue;\n int idx = rng() % boundary_candidates.size();\n auto p = boundary_candidates[idx];\n \n // Tentative add\n active[p.first][p.second] = true;\n \n if (check_connectivity(active)) {\n int delta = grid[p.first][p.second].base_score;\n if (delta >= 0 || exp(delta / temp) > (double)rng() / mt19937::max()) {\n current_score += delta;\n active_list.push_back(p);\n update_candidates(active); // Slow full update, optimize later if needed\n } else {\n active[p.first][p.second] = false; // Revert\n }\n } else {\n active[p.first][p.second] = false; // Revert\n }\n } else { // Remove\n if (active_list.size() <= 1) continue;\n int idx = rng() % active_list.size();\n auto p = active_list[idx];\n \n active[p.first][p.second] = false;\n \n if (check_connectivity(active)) {\n int delta = -grid[p.first][p.second].base_score;\n // Removing decreases score by base_score (so delta is negative of base_score)\n if (delta >= 0 || exp(delta / temp) > (double)rng() / mt19937::max()) {\n current_score += delta;\n active_list.erase(active_list.begin() + idx);\n update_candidates(active);\n } else {\n active[p.first][p.second] = true;\n }\n } else {\n active[p.first][p.second] = true;\n }\n }\n }\n\n // Final Construction\n int p_len, v_cnt;\n Polygon coarse_poly = trace_boundary(active, p_len, v_cnt);\n \n // Optimize coordinates\n Polygon final_poly = optimize_polygon(coarse_poly);\n\n // Ensure distinct vertices by minor perturbation if needed\n // But coordinate shift logic usually keeps them distinct if topology is preserved.\n // Check for duplicate sequential vertices (length 0 edges) and remove them.\n Polygon cleaned;\n for (size_t i = 0; i < final_poly.size(); ++i) {\n if (i > 0 && final_poly[i] == final_poly[i-1]) continue;\n cleaned.push_back(final_poly[i]);\n }\n if (!cleaned.empty() && cleaned.back() == cleaned.front()) cleaned.pop_back();\n \n // Also merge collinear edges\n Polygon merged;\n if (!cleaned.empty()) {\n merged.push_back(cleaned[0]);\n for (size_t i = 1; i < cleaned.size(); ++i) {\n // Check if segment (merged.back() -> cleaned[i]) is collinear with previous segment\n // Since it's rectilinear, check if both are horizontal or both vertical.\n if (merged.size() >= 2) {\n auto p1 = merged[merged.size()-2];\n auto p2 = merged.back();\n auto p3 = cleaned[i];\n bool seg1_vert = (p1.first == p2.first);\n bool seg2_vert = (p2.first == p3.first);\n if (seg1_vert == seg2_vert) {\n // Collinear, just update the last point\n merged.back() = p3;\n continue;\n }\n }\n merged.push_back(cleaned[i]);\n }\n // Check wrap-around collinearity\n if (merged.size() >= 3) {\n auto p1 = merged[merged.size()-2];\n auto p2 = merged.back();\n auto p3 = merged[0];\n bool seg1_vert = (p1.first == p2.first);\n bool seg2_vert = (p2.first == p3.first);\n if (seg1_vert == seg2_vert) {\n merged.pop_back();\n merged[0] = p2; // Effectively p2 replaces p3(start), cycle shifts\n }\n }\n }\n \n final_poly = merged;\n\n // Check constraints\n if (final_poly.size() > MAX_VERTICES) {\n // Naive fallback: bounding box of all mackerels\n // Or just the bounding box of active cells\n // Simplest valid output\n final_poly = {{0,0}, {100000, 0}, {100000, 100000}, {0, 100000}};\n }\n\n // Output\n cout << final_poly.size() << endl;\n for (const auto& p : final_poly) {\n cout << p.first << \" \" << p.second << endl;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n solve();\n return 0;\n}","ahc040":"/**\n * @file solution.cpp\n * @brief Randomized Greedy Shelf Packing with strict order constraints.\n * \n * Strategy:\n * 1. Constraint Handling: The problem requires operations to be output for rectangles\n * indices p in strictly ascending order (0, 1, ... N-1). We strictly follow this loop.\n * \n * 2. Algorithm: Randomized Greedy Shelf Packing.\n * - We simulate packing the rectangles one by one in the required order (0..N-1).\n * - We maintain a set of \"Shelves\". A shelf is defined as a sequence of rectangles\n * placed horizontally next to each other.\n * - For each rectangle 'i', we decide:\n * a. Which Shelf to place it on (or start a new one).\n * b. Orientation (Rotated or not).\n * - These decisions are made based on a randomized greedy heuristic:\n * - We try to fit 'i' into existing shelves such that the shelf width <= MAX_WIDTH.\n * - We prefer shelves where the height added is minimal (best fit).\n * - We also consider starting a new shelf.\n * - MAX_WIDTH is a hyperparameter that we search for.\n * \n * 3. Search / Optimization:\n * - In each turn, we run many iterations of this greedy construction.\n * - We vary MAX_WIDTH (around sqrt(Total Area)) and the random seed for tie-breaking.\n * - We simulate the physics (using 'U' moves) to calculate the exact bounding box (W, H).\n * - We keep the best sequence of operations found within the time limit.\n * \n * 4. Physics Simulation:\n * - Operations use d='U'. This moves rects \"up\" (decreasing y) until they hit y=0 or another rect.\n * - b=-1 starts a shelf at x=0.\n * - b=prev connects items in a shelf.\n * - Physically, shelves stack downwards (increasing y) because earlier shelves occupy y=0.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// --- Constants & Globals ---\nconst double TIME_LIMIT = 2.95;\n\nstruct Rect {\n int id;\n long long w, h; \n};\n\nstruct Operation {\n int p;\n int r;\n char d;\n int b;\n};\n\nstruct Placement {\n long long x, y, w, h;\n};\n\n// Global inputs\nint N, T;\nlong long sigma;\nvector rects;\nlong long total_area = 0;\n\n// Random number generator\nstruct Random {\n mt19937 rng;\n Random() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n int randint(int a, int b) { return uniform_int_distribution(a, b)(rng); }\n double randdouble(double a, double b) { return uniform_real_distribution(a, b)(rng); }\n} rnd;\n\n// --- Logic ---\n\n/**\n * @brief Simulates a placement sequence and returns the bounding box and operations.\n * \n * @param w_limit The maximum width allowed for a shelf.\n * @param seed Random seed for greedy choices.\n * @param out_ops Vector to store the generated operations.\n * @return pair {Width, Height}\n */\npair solve_greedy(long long w_limit, int seed, vector& out_ops) {\n out_ops.clear();\n out_ops.reserve(N);\n \n // Local RNG for deterministic behavior within this call if needed\n mt19937 local_rng(seed);\n auto rand_choice = [&](int n) { return uniform_int_distribution(0, n-1)(local_rng); };\n \n // Track placements for physics\n vector placed;\n placed.reserve(N);\n \n // Shelf state\n // A shelf is just a tracking of the last item placed on it and current width.\n // We don't track y here directly, physics handles it.\n struct Shelf {\n int id; // ID of the shelf (just index in shelves vector)\n int last_rect_idx; // The p-index of the right-most rect\n long long width; // Current accumulated width\n long long max_h; // Approx max height of items (heuristic use only)\n };\n \n vector shelves;\n \n long long global_W = 0;\n long long global_H = 0;\n\n // Enforce strict order 0..N-1\n for (int i = 0; i < N; ++i) {\n // Decide rotation: try both, pick best fit?\n // For simplicity in randomized greedy: pick a preferred orientation\n // or decide based on fit.\n // Strategy: Try both orientations for each valid shelf, pick best combination.\n \n struct Option {\n int shelf_idx; // -1 for new shelf\n int r; // 0 or 1\n long long cost; // lower is better\n };\n \n vector