{"model_name":"qwen3-max","codes":{"1":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int a, b, c, d; // top-left (a,b), bottom-right (c,d)\n int idx;\n \n Rectangle() : a(0), b(0), c(0), d(0), idx(-1) {}\n Rectangle(int a, int b, int c, int d, int idx) : a(a), b(b), c(c), d(d), idx(idx) {}\n \n int area() const { return (c - a) * (d - b); }\n \n bool contains(double x, double y) const {\n return x >= a && x < c && y >= b && y < d;\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(c <= other.a || other.c <= a || d <= other.b || other.d <= b);\n }\n \n // Returns the overlap area with another rectangle\n int overlapArea(const Rectangle& other) const {\n int overlap_width = max(0, min(c, other.c) - max(a, other.a));\n int overlap_height = max(0, min(d, other.d) - max(b, other.b));\n return overlap_width * overlap_height;\n }\n};\n\nstruct Company {\n int x, y, r, idx;\n double target_x, target_y;\n \n Company() : x(0), y(0), r(0), idx(-1), target_x(0.0), target_y(0.0) {}\n Company(int x, int y, int r, int idx) : x(x), y(y), r(r), idx(idx) {\n target_x = x + 0.5;\n target_y = y + 0.5;\n }\n};\n\n// Calculate satisfaction for a company\ndouble calculateSatisfaction(int desired_area, int actual_area) {\n if (actual_area == 0) return 0.0;\n double ratio = min(desired_area, actual_area) * 1.0 / max(desired_area, actual_area);\n return 1.0 - (1.0 - ratio) * (1.0 - ratio);\n}\n\n// Check if rectangles are valid (within bounds, no overlaps)\nbool isValid(const vector& rects, int n) {\n for (int i = 0; i < n; i++) {\n if (rects[i].a < 0 || rects[i].b < 0 || rects[i].c > 10000 || rects[i].d > 10000) {\n return false;\n }\n if (rects[i].a >= rects[i].c || rects[i].b >= rects[i].d) {\n return false;\n }\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n return false;\n }\n }\n }\n return true;\n}\n\n// Calculate total satisfaction\ndouble calculateTotalSatisfaction(const vector& rects, const vector& companies) {\n double total = 0.0;\n for (int i = 0; i < companies.size(); i++) {\n const Company& c = companies[i];\n const Rectangle& r = rects[i];\n if (r.contains(c.target_x, c.target_y)) {\n total += calculateSatisfaction(c.r, r.area());\n }\n }\n return total;\n}\n\n// Try to create initial rectangles centered at target points\nvector createInitialRectangles(const vector& companies) {\n vector rects(companies.size());\n \n for (int i = 0; i < companies.size(); i++) {\n const Company& c = companies[i];\n \n // Try to create a rectangle centered at (x+0.5, y+0.5) with area close to r_i\n int side = (int)sqrt(c.r);\n if (side * side < c.r) side++;\n \n // Calculate boundaries\n int width = side;\n int height = c.r / width;\n if (width * height < c.r) height++;\n \n // Center around the target point\n int left = (int)(c.target_x - width / 2.0);\n int top = (int)(c.target_y - height / 2.0);\n int right = left + width;\n int bottom = top + height;\n \n // Adjust if out of bounds\n if (left < 0) {\n left = 0;\n right = min(width, 10000);\n }\n if (right > 10000) {\n right = 10000;\n left = max(0, right - width);\n }\n if (top < 0) {\n top = 0;\n bottom = min(height, 10000);\n }\n if (bottom > 10000) {\n bottom = 10000;\n top = max(0, bottom - height);\n }\n \n // Ensure the target point is contained\n if (c.target_x < left + 0.5) left = (int)(c.target_x - 0.5);\n if (c.target_x >= right - 0.5) right = (int)(c.target_x + 1.5);\n if (c.target_y < top + 0.5) top = (int)(c.target_y - 0.5);\n if (c.target_y >= bottom - 0.5) bottom = (int)(c.target_y + 1.5);\n \n // Final bounds check\n left = max(0, left);\n top = max(0, top);\n right = min(10000, right);\n bottom = min(10000, bottom);\n \n rects[i] = Rectangle(left, top, right, bottom, i);\n }\n \n return rects;\n}\n\n// Resolve conflicts between rectangles (greedy approach)\nvoid resolveConflicts(vector& rects, const vector& companies) {\n int n = rects.size();\n const int MAX_ITER = 1000;\n \n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool conflict_resolved = true;\n \n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n conflict_resolved = false;\n \n // Try to shrink one of the rectangles\n // Priority: try to keep the one that's closer to its desired area\n \n double sat_i = rects[i].contains(companies[i].target_x, companies[i].target_y) ? \n calculateSatisfaction(companies[i].r, rects[i].area()) : 0.0;\n double sat_j = rects[j].contains(companies[j].target_x, companies[j].target_y) ? \n calculateSatisfaction(companies[j].r, rects[j].area()) : 0.0;\n \n // Shrink the rectangle with lower satisfaction\n if (sat_i <= sat_j) {\n // Try to shrink rectangle i\n Rectangle orig_i = rects[i];\n \n // Try different ways to shrink\n bool found = false;\n for (int tries = 0; tries < 10 && !found; tries++) {\n // Try reducing width or height\n if (orig_i.c - orig_i.a > 1) {\n int new_a = orig_i.a + 1;\n if (companies[i].target_x >= new_a + 0.5 && companies[i].target_x < orig_i.c - 0.5) {\n rects[i] = Rectangle(new_a, orig_i.b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_i.c - 1;\n if (companies[i].target_x >= orig_i.a + 0.5 && companies[i].target_x < new_c - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, new_c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_i.d - orig_i.b > 1) {\n int new_b = orig_i.b + 1;\n if (companies[i].target_y >= new_b + 0.5 && companies[i].target_y < orig_i.d - 0.5) {\n rects[i] = Rectangle(orig_i.a, new_b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_i.d - 1;\n if (companies[i].target_y >= orig_i.b + 0.5 && companies[i].target_y < new_d - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, orig_i.c, new_d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n \n if (!found) {\n // If can't resolve by shrinking i, try shrinking j\n Rectangle orig_j = rects[j];\n \n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_j.c - orig_j.a > 1) {\n int new_a = orig_j.a + 1;\n if (companies[j].target_x >= new_a + 0.5 && companies[j].target_x < orig_j.c - 0.5) {\n rects[j] = Rectangle(new_a, orig_j.b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_j.c - 1;\n if (companies[j].target_x >= orig_j.a + 0.5 && companies[j].target_x < new_c - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, new_c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_j.d - orig_j.b > 1) {\n int new_b = orig_j.b + 1;\n if (companies[j].target_y >= new_b + 0.5 && companies[j].target_y < orig_j.d - 0.5) {\n rects[j] = Rectangle(orig_j.a, new_b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_j.d - 1;\n if (companies[j].target_y >= orig_j.b + 0.5 && companies[j].target_y < new_d - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, orig_j.c, new_d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n }\n } else {\n // Try shrinking rectangle j first (symmetric to above)\n Rectangle orig_j = rects[j];\n \n bool found = false;\n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_j.c - orig_j.a > 1) {\n int new_a = orig_j.a + 1;\n if (companies[j].target_x >= new_a + 0.5 && companies[j].target_x < orig_j.c - 0.5) {\n rects[j] = Rectangle(new_a, orig_j.b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_j.c - 1;\n if (companies[j].target_x >= orig_j.a + 0.5 && companies[j].target_x < new_c - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, new_c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_j.d - orig_j.b > 1) {\n int new_b = orig_j.b + 1;\n if (companies[j].target_y >= new_b + 0.5 && companies[j].target_y < orig_j.d - 0.5) {\n rects[j] = Rectangle(orig_j.a, new_b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_j.d - 1;\n if (companies[j].target_y >= orig_j.b + 0.5 && companies[j].target_y < new_d - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, orig_j.c, new_d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n \n if (!found) {\n // Try shrinking i\n Rectangle orig_i = rects[i];\n \n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_i.c - orig_i.a > 1) {\n int new_a = orig_i.a + 1;\n if (companies[i].target_x >= new_a + 0.5 && companies[i].target_x < orig_i.c - 0.5) {\n rects[i] = Rectangle(new_a, orig_i.b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_i.c - 1;\n if (companies[i].target_x >= orig_i.a + 0.5 && companies[i].target_x < new_c - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, new_c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_i.d - orig_i.b > 1) {\n int new_b = orig_i.b + 1;\n if (companies[i].target_y >= new_b + 0.5 && companies[i].target_y < orig_i.d - 0.5) {\n rects[i] = Rectangle(orig_i.a, new_b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_i.d - 1;\n if (companies[i].target_y >= orig_i.b + 0.5 && companies[i].target_y < new_d - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, orig_i.c, new_d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n \n if (conflict_resolved) break;\n }\n}\n\n// Try to optimize rectangles by adjusting boundaries\nvoid optimizeRectangles(vector& rects, const vector& companies) {\n int n = rects.size();\n const int MAX_LOCAL_OPT_ITER = 500;\n double best_score = calculateTotalSatisfaction(rects, companies);\n \n // Use a simple local search\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int iter = 0; iter < MAX_LOCAL_OPT_ITER; iter++) {\n // Pick a random rectangle to adjust\n int idx = rng() % n;\n Rectangle orig = rects[idx];\n \n // Try small adjustments to boundaries\n vector> candidates;\n \n // Try moving each boundary by -1, 0, or 1 (if it doesn't cause overlap or exclude target point)\n for (int da : {-1, 0, 1}) {\n for (int db : {-1, 0, 1}) {\n for (int dc : {-1, 0, 1}) {\n for (int dd : {-1, 0, 1}) {\n if (da == 0 && db == 0 && dc == 0 && dd == 0) continue;\n \n int new_a = orig.a + da;\n int new_b = orig.b + db;\n int new_c = orig.c + dc;\n int new_d = orig.d + dd;\n \n // Check bounds\n if (new_a < 0 || new_b < 0 || new_c > 10000 || new_d > 10000) continue;\n if (new_a >= new_c || new_b >= new_d) continue;\n \n // Check target point containment\n double target_x = companies[idx].target_x;\n double target_y = companies[idx].target_y;\n if (target_x < new_a + 0.5 || target_x >= new_c - 0.5 || \n target_y < new_b + 0.5 || target_y >= new_d - 0.5) continue;\n \n // Check for overlaps with other rectangles\n bool has_overlap = false;\n Rectangle test_rect(new_a, new_b, new_c, new_d, idx);\n for (int j = 0; j < n; j++) {\n if (j != idx && test_rect.overlaps(rects[j])) {\n has_overlap = true;\n break;\n }\n }\n \n if (!has_overlap) {\n candidates.push_back({candidates.size(), test_rect});\n }\n }\n }\n }\n }\n \n // If we have candidates, pick the best one\n if (!candidates.empty()) {\n // Score each candidate\n vector> scored_candidates;\n for (auto& cand : candidates) {\n rects[idx] = cand.second;\n double score = calculateTotalSatisfaction(rects, companies);\n scored_candidates.push_back({score, cand.first});\n rects[idx] = orig; // restore\n }\n \n // Sort by score (descending)\n sort(scored_candidates.begin(), scored_candidates.end(), \n [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n // Pick the best improvement (or if none, maybe pick a random one for exploration)\n double best_candidate_score = scored_candidates[0].first;\n if (best_candidate_score > best_score || (rng() % 10 == 0 && !scored_candidates.empty())) {\n // Take the improvement (or sometimes a random candidate for exploration)\n int chosen_idx = 0;\n if (best_candidate_score <= best_score && !scored_candidates.empty()) {\n chosen_idx = rng() % min(3, (int)scored_candidates.size());\n }\n \n rects[idx] = candidates[scored_candidates[chosen_idx].second].second;\n best_score = max(best_score, scored_candidates[chosen_idx].first);\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n \n vector companies;\n for (int i = 0; i < n; i++) {\n int x, y, r;\n cin >> x >> y >> r;\n companies.push_back(Company(x, y, r, i));\n }\n \n // Create initial rectangles\n vector rects = createInitialRectangles(companies);\n \n // Resolve conflicts\n resolveConflicts(rects, companies);\n \n // Local optimization\n optimizeRectangles(rects, companies);\n \n // Final output\n for (int i = 0; i < n; i++) {\n cout << rects[i].a << \" \" << rects[i].b << \" \" << rects[i].c << \" \" << rects[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Tile {\n vector> squares;\n int total_value;\n int id;\n};\n\nclass Solution {\nprivate:\n int si, sj;\n vector> tile_ids;\n vector> values;\n vector tiles;\n int n = 50;\n high_resolution_clock::time_point start_time;\n const double time_limit = 1.9; // Leave 0.1 sec for overhead\n \n // Directions: U, D, L, R\n const vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n const string dir_chars = \"UDLR\";\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < n && j >= 0 && j < n;\n }\n \n double get_elapsed_time() {\n auto now = high_resolution_clock::now();\n auto duration = duration_cast(now - start_time);\n return duration.count() / 1000000.0;\n }\n \n // DFS with iterative deepening and pruning\n string dfs_search() {\n int start_tile_id = tile_ids[si][sj];\n unordered_set visited;\n visited.insert(start_tile_id);\n \n string best_path = \"\";\n int best_score = values[si][sj];\n \n // Try different depth limits\n for (int max_depth = 1; max_depth <= 100 && get_elapsed_time() < time_limit; max_depth++) {\n string current_path = \"\";\n int current_score = values[si][sj];\n int current_i = si, current_j = sj;\n \n dfs_recursive(current_i, current_j, visited, current_path, current_score, \n 0, max_depth, best_path, best_score);\n \n // If we found a complete path or time is running out, break\n if (get_elapsed_time() > time_limit * 0.8) break;\n }\n \n return best_path;\n }\n \n void dfs_recursive(int i, int j, unordered_set& visited, string& current_path,\n int current_score, int depth, int max_depth,\n string& best_path, int& best_score) {\n if (get_elapsed_time() > time_limit) return;\n if (depth >= max_depth) return;\n \n // Try all four directions\n vector> next_moves;\n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n if (visited.find(next_tile_id) == visited.end()) {\n next_moves.push_back({ni, nj});\n }\n }\n }\n \n // Sort moves by tile value (greedy heuristic)\n sort(next_moves.begin(), next_moves.end(), [this](const pair& a, const pair& b) {\n int tile_a = tile_ids[a.first][a.second];\n int tile_b = tile_ids[b.first][b.second];\n return tiles[tile_a].total_value > tiles[tile_b].total_value;\n });\n \n // Limit branches to avoid exponential explosion\n int max_branches = min(3, (int)next_moves.size());\n if (depth > 10) max_branches = min(2, max_branches);\n if (depth > 20) max_branches = min(1, max_branches);\n \n for (int idx = 0; idx < max_branches && idx < next_moves.size(); idx++) {\n int ni = next_moves[idx].first;\n int nj = next_moves[idx].second;\n int next_tile_id = tile_ids[ni][nj];\n \n // Skip if already visited\n if (visited.find(next_tile_id) != visited.end()) continue;\n \n // Calculate additional score from this tile\n int additional_score = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n if (square.first == ni && square.second == nj) {\n additional_score += values[ni][nj];\n } else {\n additional_score += values[square.first][square.second];\n }\n }\n \n // Make move\n visited.insert(next_tile_id);\n current_path.push_back(dir_chars[get_direction(i, j, ni, nj)]);\n \n int new_score = current_score + additional_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_path = current_path;\n }\n \n // Recurse\n dfs_recursive(ni, nj, visited, current_path, new_score, depth + 1, \n max_depth, best_path, best_score);\n \n // Backtrack\n current_path.pop_back();\n visited.erase(next_tile_id);\n }\n }\n \n int get_direction(int i, int j, int ni, int nj) {\n if (ni == i - 1) return 0; // U\n if (ni == i + 1) return 1; // D\n if (nj == j - 1) return 2; // L\n if (nj == j + 1) return 3; // R\n return -1; // Should never happen\n }\n \n // Greedy algorithm as fallback or for comparison\n string greedy_search() {\n string path = \"\";\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n int current_score = values[si][sj];\n \n while (get_elapsed_time() < time_limit) {\n vector>> candidates; // {score, {next_i, next_j, dir_index}}\n \n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n // Calculate score for this tile\n int tile_score = 0;\n for (auto& square : tiles[tile_id].squares) {\n tile_score += values[square.first][square.second];\n }\n candidates.push_back({tile_score, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) break;\n \n // Sort by score descending\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Pick the best candidate (with some randomness for exploration)\n int choice = 0;\n if (candidates.size() > 1 && get_elapsed_time() < time_limit * 0.5) {\n // Allow some randomness in early stages\n random_device rd;\n mt19937 gen(rd());\n uniform_real_distribution dis(0.0, 1.0);\n if (dis(gen) < 0.3) {\n choice = min(1, (int)candidates.size() - 1);\n }\n }\n \n int ni = candidates[choice].second.first;\n int nj = candidates[choice].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n path.push_back(dir_chars[dir]);\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n return path;\n }\n\npublic:\n void solve() {\n start_time = high_resolution_clock::now();\n \n // Read input\n cin >> si >> sj;\n \n tile_ids = vector>(n, vector(n));\n values = vector>(n, vector(n));\n \n // Read tile IDs\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> tile_ids[i][j];\n }\n }\n \n // Read values\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> values[i][j];\n }\n }\n \n // Build tile data structure\n unordered_map tile_map;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int id = tile_ids[i][j];\n if (tile_map.find(id) == tile_map.end()) {\n tile_map[id] = Tile{{}, 0, id};\n }\n tile_map[id].squares.push_back({i, j});\n tile_map[id].total_value += values[i][j];\n }\n }\n \n // Convert to vector for easier access\n for (auto& kv : tile_map) {\n tiles.push_back(kv.second);\n }\n \n // Try different strategies based on time remaining\n string result = \"\";\n \n // First, try DFS approach\n if (get_elapsed_time() < time_limit * 0.7) {\n result = dfs_search();\n }\n \n // If DFS didn't produce good results or time is running out, try greedy\n if (result.empty() || get_elapsed_time() < time_limit) {\n string greedy_result = greedy_search();\n if (greedy_result.length() > result.length() || \n (greedy_result.length() == result.length() && calculate_score(greedy_result) > calculate_score(result))) {\n result = greedy_result;\n }\n }\n \n // Output result\n cout << result << endl;\n }\n \n // Helper function to calculate score of a path (for comparison)\n int calculate_score(const string& path) {\n if (path.empty()) return values[si][sj];\n \n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n int total_score = values[si][sj];\n \n for (char c : path) {\n int d = (c == 'U') ? 0 : (c == 'D') ? 1 : (c == 'L') ? 2 : 3;\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n for (auto& square : tiles[tile_id].squares) {\n total_score += values[square.first][square.second];\n }\n visited.insert(tile_id);\n }\n \n current_i = ni;\n current_j = nj;\n }\n \n return total_score;\n }\n};\n\nint main() {\n Solution solver;\n solver.solve();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int INF = 1e9;\n\n// Direction arrays for Dijkstra\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Estimated edge weights\nvector> h_est(GRID_SIZE, vector(GRID_SIZE - 1, 5000.0)); // horizontal edges\nvector> v_est(GRID_SIZE - 1, vector(GRID_SIZE, 5000.0)); // vertical edges\n\n// Count of observations for each edge (for averaging)\nvector> h_count(GRID_SIZE, vector(GRID_SIZE - 1, 0));\nvector> v_count(GRID_SIZE - 1, vector(GRID_SIZE, 0));\n\n// For Dijkstra\nstruct Node {\n int x, y, cost;\n string path;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n\n// Check if coordinates are valid\nbool isValid(int x, int y) {\n return x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE;\n}\n\n// Dijkstra's algorithm to find shortest path based on current estimates\nstring dijkstra(int sx, int sy, int tx, int ty) {\n // Priority queue for Dijkstra\n priority_queue, greater> pq;\n vector> dist(GRID_SIZE, vector(GRID_SIZE, INF));\n vector> path(GRID_SIZE, vector(GRID_SIZE, \"\"));\n vector> visited(GRID_SIZE, vector(GRID_SIZE, false));\n \n pq.push({sx, sy, 0, \"\"});\n dist[sx][sy] = 0;\n \n while (!pq.empty()) {\n Node curr = pq.top();\n pq.pop();\n \n int x = curr.x;\n int y = curr.y;\n int cost = curr.cost;\n string currPath = curr.path;\n \n if (visited[x][y]) continue;\n visited[x][y] = true;\n \n // If we reached the target\n if (x == tx && y == ty) {\n return currPath;\n }\n \n // Try all four directions\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n \n if (!isValid(nx, ny)) continue;\n \n int edgeCost = 0;\n // Calculate edge cost based on direction\n if (i == 0 && x > 0) { // Up\n edgeCost = (int)v_est[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) { // Down\n edgeCost = (int)v_est[x][y];\n } else if (i == 2 && y > 0) { // Left\n edgeCost = (int)h_est[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) { // Right\n edgeCost = (int)h_est[x][y];\n } else {\n continue; // Invalid move\n }\n \n if (dist[nx][ny] > cost + edgeCost) {\n dist[nx][ny] = cost + edgeCost;\n pq.push({nx, ny, cost + edgeCost, currPath + dirChar[i]});\n }\n }\n }\n \n // If no path found (shouldn't happen in grid), return a simple path\n string fallback = \"\";\n int cx = sx, cy = sy;\n while (cx != tx) {\n if (cx < tx) {\n fallback += 'D';\n cx++;\n } else {\n fallback += 'U';\n cx--;\n }\n }\n while (cy != ty) {\n if (cy < ty) {\n fallback += 'R';\n cy++;\n } else {\n fallback += 'L';\n cy--;\n }\n }\n return fallback;\n}\n\n// Update edge weight estimates based on the feedback\nvoid updateEstimates(const string& path, int sx, int sy, int actual_cost) {\n // Calculate the expected cost based on current estimates\n int x = sx, y = sy;\n int expected_cost = 0;\n vector> edges_used; // Store edges used in this path\n vector edge_types; // 0: horizontal, 1: vertical\n vector> edge_coords; // Coordinates of edges\n \n for (char dir : path) {\n int nx = x, ny = y;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n \n // Calculate expected cost for this edge\n if (dir == 'U') {\n expected_cost += (int)v_est[x-1][y];\n edges_used.push_back({x-1, y});\n edge_types.push_back(1); // vertical\n edge_coords.push_back({x-1, y});\n } else if (dir == 'D') {\n expected_cost += (int)v_est[x][y];\n edges_used.push_back({x, y});\n edge_types.push_back(1); // vertical\n edge_coords.push_back({x, y});\n } else if (dir == 'L') {\n expected_cost += (int)h_est[x][y-1];\n edges_used.push_back({x, y-1});\n edge_types.push_back(0); // horizontal\n edge_coords.push_back({x, y-1});\n } else if (dir == 'R') {\n expected_cost += (int)h_est[x][y];\n edges_used.push_back({x, y});\n edge_types.push_back(0); // horizontal\n edge_coords.push_back({x, y});\n }\n \n x = nx;\n y = ny;\n }\n \n // Update estimates - distribute the error across all edges in the path\n int path_length = path.length();\n if (path_length > 0) {\n double error = actual_cost - expected_cost;\n double error_per_edge = error / path_length;\n \n for (int i = 0; i < edges_used.size(); i++) {\n int coord1 = edge_coords[i].first;\n int coord2 = edge_coords[i].second;\n \n if (edge_types[i] == 0) { // horizontal edge\n if (h_count[coord1][coord2] == 0) {\n h_est[coord1][coord2] += error_per_edge;\n } else {\n // Weighted average based on number of observations\n h_est[coord1][coord2] = (h_est[coord1][coord2] * h_count[coord1][coord2] + actual_cost * 1.0 / path_length) / (h_count[coord1][coord2] + 1);\n }\n h_count[coord1][coord2]++;\n } else { // vertical edge\n if (v_count[coord1][coord2] == 0) {\n v_est[coord1][coord2] += error_per_edge;\n } else {\n // Weighted average based on number of observations\n v_est[coord1][coord2] = (v_est[coord1][coord2] * v_count[coord1][coord2] + actual_cost * 1.0 / path_length) / (v_count[coord1][coord2] + 1);\n }\n v_count[coord1][coord2]++;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int prev_result = 0;\n \n for (int k = 0; k < 1000; k++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n \n // Find path using current estimates\n string path = dijkstra(si, sj, ti, tj);\n \n // Output path\n cout << path << endl;\n cout.flush(); // Important: flush output\n \n // Read the result\n int result;\n cin >> result;\n \n // Update estimates based on feedback\n updateEstimates(path, si, sj, result);\n \n // Update prev_result for next iteration\n prev_result = result;\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nconst char CHARS[8] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};\n\nclass MatrixSolver {\nprivate:\n int M;\n vector strings;\n vector matrix;\n vector matched;\n mt19937 rng;\n \npublic:\n MatrixSolver(int m, const vector& s) : M(m), strings(s), rng(random_device{}()) {\n // Initialize matrix with most frequent characters\n matrix.resize(N, string(N, '.'));\n matched.resize(M, false);\n \n // Frequency analysis for initialization\n vector charFreq(8, 0);\n for (const string& s : strings) {\n for (char c : s) {\n charFreq[c - 'A']++;\n }\n }\n \n // Fill matrix with most frequent character initially\n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = mostFreqChar;\n }\n }\n }\n \n // Check if string s matches at position (i,j) horizontally\n bool matchesHorizontal(const string& s, int i, int j) const {\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n if (matrix[i][col] != s[p] && matrix[i][col] != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if string s matches at position (i,j) vertically\n bool matchesVertical(const string& s, int i, int j) const {\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n if (matrix[row][j] != s[p] && matrix[row][j] != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if a string matches anywhere in the matrix\n bool matches(const string& s) const {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matchesHorizontal(s, i, j) || matchesVertical(s, i, j)) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Count how many strings are matched\n int countMatches() {\n int count = 0;\n for (int i = 0; i < M; i++) {\n if (matches(strings[i])) {\n matched[i] = true;\n count++;\n } else {\n matched[i] = false;\n }\n }\n return count;\n }\n \n // Get score based on problem definition\n long long getScore(int c, int d) {\n if (c < M) {\n return round(100000000.0 * c / M);\n } else {\n return round(100000000.0 * 2 * N * N / (2 * N * N - d));\n }\n }\n \n // Count number of '.' in matrix\n int countDots() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == '.') {\n count++;\n }\n }\n }\n return count;\n }\n \n // Try to improve matrix by changing one cell\n bool improve() {\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n bool improved = false;\n \n // Try changing each cell to each possible character\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char original = matrix[i][j];\n \n // Try each character A-H\n for (char c : CHARS) {\n if (c == original) continue;\n \n matrix[i][j] = c;\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) {\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n // Keep this change and continue improving\n } else {\n // Revert if not better\n matrix[i][j] = original;\n }\n }\n \n // Also try setting to '.' if it might help\n if (original != '.') {\n matrix[i][j] = '.';\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) {\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n } else {\n matrix[i][j] = original;\n }\n }\n }\n }\n \n return improved;\n }\n \n // Try to fix unmatched strings\n void fixUnmatched() {\n // Count how many times each position is involved in unmatched strings\n vector> positionImportance(N, vector(N, 0));\n \n for (int idx = 0; idx < M; idx++) {\n if (!matched[idx]) {\n const string& s = strings[idx];\n // Mark all positions where this string could potentially be placed\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Check if we can place horizontally\n bool canPlaceHorizontal = true;\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n if (matrix[i][col] != '.' && matrix[i][col] != s[p]) {\n canPlaceHorizontal = false;\n break;\n }\n }\n if (canPlaceHorizontal) {\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n positionImportance[i][col]++;\n }\n }\n \n // Check if we can place vertically\n bool canPlaceVertical = true;\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n if (matrix[row][j] != '.' && matrix[row][j] != s[p]) {\n canPlaceVertical = false;\n break;\n }\n }\n if (canPlaceVertical) {\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n positionImportance[row][j]++;\n }\n }\n }\n }\n }\n }\n \n // Find the most important position and try to set it to help unmatched strings\n int maxImportance = 0;\n int bestI = 0, bestJ = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (positionImportance[i][j] > maxImportance) {\n maxImportance = positionImportance[i][j];\n bestI = i;\n bestJ = j;\n }\n }\n }\n \n if (maxImportance > 0) {\n // Try to determine the best character for this position\n vector charScores(8, 0);\n for (int idx = 0; idx < M; idx++) {\n if (!matched[idx]) {\n const string& s = strings[idx];\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Check horizontal placement\n bool canPlaceHorizontal = true;\n int posInString = -1;\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n if (i == bestI && col == bestJ) {\n posInString = p;\n }\n if (matrix[i][col] != '.' && matrix[i][col] != s[p] && !(i == bestI && col == bestJ)) {\n canPlaceHorizontal = false;\n break;\n }\n }\n if (canPlaceHorizontal && posInString != -1) {\n charScores[s[posInString] - 'A']++;\n }\n \n // Check vertical placement\n bool canPlaceVertical = true;\n posInString = -1;\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n if (row == bestI && j == bestJ) {\n posInString = p;\n }\n if (matrix[row][j] != '.' && matrix[row][j] != s[p] && !(row == bestI && j == bestJ)) {\n canPlaceVertical = false;\n break;\n }\n }\n if (canPlaceVertical && posInString != -1) {\n charScores[s[posInString] - 'A']++;\n }\n }\n }\n }\n }\n \n // Choose the character with highest score\n int bestCharIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charScores[i] > charScores[bestCharIdx]) {\n bestCharIdx = i;\n }\n }\n \n if (charScores[bestCharIdx] > 0) {\n matrix[bestI][bestJ] = 'A' + bestCharIdx;\n }\n }\n }\n \n // Main solve method\n void solve() {\n // Initial evaluation\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n // Time tracking for optimization within time limit\n auto startTime = chrono::steady_clock::now();\n \n // Local search with time limit\n bool improving = true;\n int iteration = 0;\n \n while (improving && iteration < 100) {\n improving = improve();\n iteration++;\n \n // Check time limit (leave some margin)\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2500) break; // 2.5 seconds to be safe\n }\n \n // If we haven't matched all strings, try to fix unmatched ones\n if (currentMatches < M) {\n fixUnmatched();\n }\n \n // One final improvement pass\n improve();\n }\n \n // Output the matrix\n void output() const {\n for (int i = 0; i < N; i++) {\n cout << matrix[i] << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> N >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n MatrixSolver solver(M, strings);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_chars[4] = {'U', 'D', 'L', 'R'};\n\nstruct Position {\n int x, y;\n Position(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Position& other) const {\n return x == other.x && y == other.y;\n }\n bool operator<(const Position& other) const {\n return x < other.x || (x == other.x && y < other.y);\n }\n};\n\nstruct State {\n Position pos;\n int cost;\n string path;\n State(Position p, int c, string pa) : pos(p), cost(c), path(pa) {}\n};\n\nint N, si, sj;\nvector grid;\nvector> is_road;\nvector> move_cost;\n\n// Precomputed visibility - for each position, which positions are visible\nvector>> visibility;\n\n// Check if position is within bounds\nbool in_bounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// Precompute visibility for each road square\nvoid precompute_visibility() {\n visibility.resize(N, vector>(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!is_road[i][j]) continue;\n \n // Check horizontal visibility (same row)\n for (int j2 = 0; j2 < N; j2++) {\n if (!is_road[i][j2]) continue;\n \n // Check if all squares between (i,j) and (i,j2) are roads\n bool visible = true;\n int start = min(j, j2);\n int end = max(j, j2);\n for (int jj = start; jj <= end; jj++) {\n if (!is_road[i][jj]) {\n visible = false;\n break;\n }\n }\n if (visible) {\n visibility[i][j].insert(Position(i, j2));\n }\n }\n \n // Check vertical visibility (same column)\n for (int i2 = 0; i2 < N; i2++) {\n if (!is_road[i2][j]) continue;\n \n // Check if all squares between (i,j) and (i2,j) are roads\n bool visible = true;\n int start = min(i, i2);\n int end = max(i, i2);\n for (int ii = start; ii <= end; ii++) {\n if (!is_road[ii][j]) {\n visible = false;\n break;\n }\n }\n if (visible) {\n visibility[i][j].insert(Position(i2, j));\n }\n }\n }\n }\n}\n\n// Get all road positions\nvector get_road_positions() {\n vector roads;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (is_road[i][j]) {\n roads.push_back(Position(i, j));\n }\n }\n }\n return roads;\n}\n\n// Calculate total visible squares from a set of visited positions\nset get_visible_squares(const set& visited_positions) {\n set visible;\n for (const Position& pos : visited_positions) {\n for (const Position& v : visibility[pos.x][pos.y]) {\n visible.insert(v);\n }\n }\n return visible;\n}\n\n// Greedy approach to find a route that covers all visible squares\nstring find_route() {\n set visited;\n set covered;\n Position current(si, sj);\n visited.insert(current);\n covered = get_visible_squares(visited);\n \n string route = \"\";\n \n // Continue until all road squares are covered\n vector all_roads = get_road_positions();\n int total_roads = all_roads.size();\n \n // If we already cover everything from start, just return\n if (covered.size() == total_roads) {\n return \"\";\n }\n \n // Greedy selection: at each step, move to position that gives best coverage per cost\n int steps = 0;\n const int MAX_STEPS = N * N * 5; // Limit to avoid infinite loops\n \n while (covered.size() < total_roads && steps < MAX_STEPS) {\n steps++;\n \n // Find best next move\n Position best_next = current;\n int best_ratio = -1; // Newly covered squares per cost\n string best_dir = \"\";\n \n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n Position next(nx, ny);\n int cost = move_cost[nx][ny];\n \n // Calculate newly covered squares if we move to this position\n set new_visited = visited;\n new_visited.insert(next);\n set new_covered = get_visible_squares(new_visited);\n \n int newly_covered = 0;\n for (const Position& p : new_covered) {\n if (covered.find(p) == covered.end()) {\n newly_covered++;\n }\n }\n \n // Calculate ratio (avoid division by zero)\n int ratio = newly_covered * 1000 / cost; // Scale up to avoid precision issues\n \n // Prefer moves that give more new coverage per cost\n if (ratio > best_ratio || (ratio == best_ratio && cost < move_cost[best_next.x][best_next.y])) {\n best_ratio = ratio;\n best_next = next;\n best_dir = string(1, dir_chars[d]);\n }\n }\n \n // If no improvement found, try to move to any unvisited position\n if (best_ratio <= 0) {\n bool found = false;\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n Position next(nx, ny);\n \n // Prefer unvisited positions\n if (visited.find(next) == visited.end()) {\n best_next = next;\n best_dir = string(1, dir_chars[d]);\n found = true;\n break;\n }\n }\n \n // If no unvisited position, just pick any valid move\n if (!found) {\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n best_next = Position(nx, ny);\n best_dir = string(1, dir_chars[d]);\n break;\n }\n }\n }\n \n // Make the move\n current = best_next;\n visited.insert(current);\n set new_covered = get_visible_squares(visited);\n covered = new_covered;\n route += best_dir;\n \n // Early termination if we've covered everything\n if (covered.size() == total_roads) {\n break;\n }\n }\n \n // Return to start\n // Simple BFS to find shortest path back to start\n queue q;\n set visited_back;\n q.push(State(current, 0, \"\"));\n visited_back.insert(current);\n \n while (!q.empty()) {\n State s = q.front();\n q.pop();\n \n if (s.pos.x == si && s.pos.y == sj) {\n route += s.path;\n return route;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = s.pos.x + dx[d];\n int ny = s.pos.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n Position next(nx, ny);\n if (visited_back.find(next) != visited_back.end()) continue;\n \n visited_back.insert(next);\n q.push(State(next, s.cost + move_cost[nx][ny], s.path + dir_chars[d]));\n }\n }\n \n // If BFS failed (shouldn't happen in connected component), try a simple approach\n // Just keep moving in a direction that gets us closer to start\n while (current.x != si || current.y != sj) {\n bool moved = false;\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n // Check if this move gets us closer to start\n int current_dist = abs(current.x - si) + abs(current.y - sj);\n int new_dist = abs(nx - si) + abs(ny - sj);\n \n if (new_dist < current_dist) {\n current = Position(nx, ny);\n route += dir_chars[d];\n moved = true;\n break;\n }\n }\n \n // If no move gets us closer, pick any valid move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n current = Position(nx, ny);\n route += dir_chars[d];\n break;\n }\n }\n }\n \n return route;\n}\n\n// Simple optimization: remove immediate backtracking (e.g., \"UD\", \"LR\")\nstring optimize_route(const string& route) {\n if (route.empty()) return route;\n \n string optimized = \"\";\n for (char c : route) {\n if (optimized.empty()) {\n optimized += c;\n continue;\n }\n \n char last = optimized.back();\n bool cancel = false;\n \n // Check for immediate backtracking\n if ((c == 'U' && last == 'D') || (c == 'D' && last == 'U') ||\n (c == 'L' && last == 'R') || (c == 'R' && last == 'L')) {\n optimized.pop_back();\n cancel = true;\n }\n \n if (!cancel) {\n optimized += c;\n }\n }\n \n return optimized;\n}\n\nint main() {\n // Read input\n cin >> N >> si >> sj;\n grid.resize(N);\n is_road.resize(N, vector(N, false));\n move_cost.resize(N, vector(N, 0));\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n is_road[i][j] = true;\n move_cost[i][j] = grid[i][j] - '0';\n }\n }\n }\n \n // Precompute visibility\n precompute_visibility();\n \n // Find route\n string route = find_route();\n \n // Simple optimization\n route = optimize_route(route);\n \n // Output the route\n cout << route << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, K, R;\nvector> task_difficulty; // d[i][k] for task i, skill k\nvector> dependencies; // dependencies[i] = list of tasks that must be completed before task i\nvector> reverse_dependencies; // reverse_dependencies[i] = list of tasks that depend on task i\n\n// State tracking\nvector task_status; // -1: not started, 0: in progress, 1: completed\nvector member_assignment; // -1: idle, task_id: working on task\nvector member_busy_until; // day when member becomes available\n\n// Skill estimation\nvector> skill_lower_bound; // Lower bound for s[j][k]\nvector> skill_upper_bound; // Upper bound for s[j][k]\nvector> skill_exact; // Whether we know exact skill level\n\n// Random generator\nmt19937 rng;\n\n// Calculate w[i][j] = sum_k max(0, d[i][k] - s[j][k])\nint calculate_w(int task_id, int member_id) {\n int w = 0;\n for (int k = 0; k < K; k++) {\n int diff = task_difficulty[task_id][k] - skill_lower_bound[member_id][k];\n if (diff > 0) {\n w += diff;\n }\n }\n return w;\n}\n\n// Estimate completion time for task i by member j\nint estimate_completion_time(int task_id, int member_id) {\n int w = calculate_w(task_id, member_id);\n if (w == 0) {\n return 1;\n }\n // Since r_i is between -3 and 3, assume average case (0) for estimation\n return max(1, w);\n}\n\n// Check if task can be started (all dependencies completed)\nbool can_start_task(int task_id) {\n for (int dep : dependencies[task_id]) {\n if (task_status[dep] != 1) {\n return false;\n }\n }\n return true;\n}\n\n// Calculate criticality score for a task (how many tasks depend on it, directly or indirectly)\nint calculate_criticality(int task_id) {\n queue q;\n vector visited(N, false);\n int count = 0;\n \n q.push(task_id);\n visited[task_id] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v : reverse_dependencies[u]) {\n if (!visited[v]) {\n visited[v] = true;\n count++;\n q.push(v);\n }\n }\n }\n \n return count;\n}\n\n// Update skill estimates based on actual completion time\nvoid update_skill_estimates(int task_id, int member_id, int completion_time, int start_day, int end_day) {\n int actual_days = end_day - start_day + 1;\n \n if (actual_days == 1) {\n // w[i][j] = 0, so s[j][k] >= d[i][k] for all k\n for (int k = 0; k < K; k++) {\n skill_lower_bound[member_id][k] = max(skill_lower_bound[member_id][k], task_difficulty[task_id][k]);\n skill_exact[member_id][k] = true; // We know exact minimum\n }\n } else {\n // w[i][j] + r_i = actual_days, so w[i][j] = actual_days - r_i\n // Since r_i is between -3 and 3, w[i][j] is between actual_days-3 and actual_days+3\n // Use actual_days as estimate for w[i][j]\n int estimated_w = actual_days;\n \n // We know sum_k max(0, d[i][k] - s[j][k]) = estimated_w\n // This gives us constraints on s[j][k]\n // For simplicity, distribute the \"deficit\" proportionally\n int current_w = 0;\n vector deficits(K);\n for (int k = 0; k < K; k++) {\n int deficit = max(0, task_difficulty[task_id][k] - skill_lower_bound[member_id][k]);\n deficits[k] = deficit;\n current_w += deficit;\n }\n \n if (current_w < estimated_w) {\n // Our lower bounds are too high, adjust them down\n // This shouldn't happen normally, but can occur due to randomness\n // In this case, we don't update (or could decrease lower bounds)\n } else if (current_w > estimated_w) {\n // Our lower bounds are too low, we need to increase some of them\n // Increase skill estimates for skills with deficits\n int excess = current_w - estimated_w;\n \n // Simple approach: increase lower bounds for skills with deficits\n // Prioritize skills with larger deficits\n vector> deficit_skills;\n for (int k = 0; k < K; k++) {\n if (deficits[k] > 0) {\n deficit_skills.push_back({deficits[k], k});\n }\n }\n \n sort(deficit_skills.rbegin(), deficit_skills.rend());\n \n for (auto& p : deficit_skills) {\n int k = p.second;\n int reduce_by = min(deficits[k], excess);\n if (reduce_by > 0) {\n // This means we overestimated the deficit, so our skill lower bound was too low\n // We can't directly infer the correct skill level, so we'll just note that\n // our estimate was wrong and adjust conservatively\n excess -= reduce_by;\n }\n if (excess == 0) break;\n }\n }\n // If current_w == estimated_w, our estimates are consistent\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Initialize random generator\n rng.seed(12345);\n \n // Parse input\n cin >> N >> M >> K >> R;\n \n task_difficulty.resize(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> task_difficulty[i][k];\n }\n }\n \n dependencies.resize(N);\n reverse_dependencies.resize(N);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--; // Convert to 0-indexed\n dependencies[v].push_back(u);\n reverse_dependencies[u].push_back(v);\n }\n \n // Initialize state\n task_status.assign(N, -1); // -1: not started\n member_assignment.assign(M, -1); // -1: not assigned\n member_busy_until.assign(M, 0);\n \n // Initialize skill estimates\n skill_lower_bound.assign(M, vector(K, 0));\n skill_upper_bound.assign(M, vector(K, INT_MAX));\n skill_exact.assign(M, vector(K, false));\n \n int day = 0;\n vector start_day_of_task(N, -1);\n \n while (true) {\n day++;\n \n // Check if day limit exceeded\n if (day > 2000) {\n break;\n }\n \n // Process completions from previous day\n int n_completed;\n cin >> n_completed;\n \n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n \n vector completed_members(n_completed);\n for (int i = 0; i < n_completed; i++) {\n cin >> completed_members[i];\n completed_members[i]--; // Convert to 0-indexed\n }\n \n // Update task and member status for completed tasks\n for (int member_id : completed_members) {\n int task_id = member_assignment[member_id];\n if (task_id != -1) {\n task_status[task_id] = 1; // Mark as completed\n // Update skill estimates based on completion time\n update_skill_estimates(task_id, member_id, day - start_day_of_task[task_id], start_day_of_task[task_id], day);\n member_assignment[member_id] = -1;\n member_busy_until[member_id] = day;\n }\n }\n \n // Find available team members\n vector available_members;\n for (int j = 0; j < M; j++) {\n if (member_assignment[j] == -1 && member_busy_until[j] < day) {\n available_members.push_back(j);\n }\n }\n \n // Find ready tasks (dependencies satisfied and not started/completed)\n vector ready_tasks;\n for (int i = 0; i < N; i++) {\n if (task_status[i] == -1 && can_start_task(i)) {\n ready_tasks.push_back(i);\n }\n }\n \n // Create assignment output\n vector> assignments; // (member_id, task_id)\n \n if (!available_members.empty() && !ready_tasks.empty()) {\n // Simple greedy assignment: assign tasks to minimize estimated completion time\n // Could use Hungarian algorithm for optimal assignment, but greedy should work well\n \n // Shuffle ready tasks for some randomness (helps exploration)\n shuffle(ready_tasks.begin(), ready_tasks.end(), rng);\n \n // Sort available members by some criterion (e.g., average skill level)\n // For now, just use as is\n \n // Greedy assignment\n vector task_assigned(ready_tasks.size(), false);\n \n for (int member_idx = 0; member_idx < available_members.size(); member_idx++) {\n int member_id = available_members[member_idx];\n \n // Find best task for this member\n int best_task_idx = -1;\n int min_estimated_time = INT_MAX;\n \n for (int task_idx = 0; task_idx < ready_tasks.size(); task_idx++) {\n if (task_assigned[task_idx]) continue;\n \n int task_id = ready_tasks[task_idx];\n int est_time = estimate_completion_time(task_id, member_id);\n \n // Consider task criticality (tasks that unblock more tasks)\n int criticality = calculate_criticality(task_id);\n // Adjust estimated time by criticality (lower priority for critical tasks)\n int adjusted_time = est_time - criticality / 10; // Simple weighting\n \n if (adjusted_time < min_estimated_time) {\n min_estimated_time = adjusted_time;\n best_task_idx = task_idx;\n }\n }\n \n if (best_task_idx != -1) {\n int task_id = ready_tasks[best_task_idx];\n assignments.push_back({member_id, task_id});\n task_assigned[best_task_idx] = true;\n task_status[task_id] = 0; // Mark as in progress\n member_assignment[member_id] = task_id;\n start_day_of_task[task_id] = day;\n }\n }\n }\n \n // Output assignments\n cout << assignments.size();\n for (auto& assignment : assignments) {\n cout << \" \" << assignment.first + 1 << \" \" << assignment.second + 1;\n }\n cout << endl;\n cout.flush(); // Important: flush output\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\nstruct Order {\n int id;\n int pickup_x, pickup_y;\n int delivery_x, delivery_y;\n \n // Calculate Manhattan distance for this order\n int direct_distance() const {\n return abs(pickup_x - delivery_x) + abs(pickup_y - delivery_y);\n }\n \n // Distance from center to pickup and delivery\n int center_distance() const {\n return abs(pickup_x - 400) + abs(pickup_y - 400) + \n abs(delivery_x - 400) + abs(delivery_y - 400);\n }\n \n // \"Efficiency\" metric for order selection\n double efficiency_score() const {\n // Higher score = more efficient to deliver\n // We want orders that are closer to center and have shorter direct distances\n return 1.0 / (center_distance() + direct_distance());\n }\n};\n\n// Calculate Manhattan distance between two points\nint manhattan_distance(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nclass RouteOptimizer {\nprivate:\n vector orders;\n vector selected_orders;\n vector> route;\n vector pickup_done;\n vector delivery_done;\n \n // Track which order each location belongs to\n unordered_map location_to_order;\n \n // For precedence constraint checking\n vector pickup_index;\n vector delivery_index;\n \npublic:\n RouteOptimizer(const vector& all_orders) : orders(all_orders) {\n // Initialize data structures\n pickup_done.resize(50, false);\n delivery_done.resize(50, false);\n pickup_index.resize(50, -1);\n delivery_index.resize(50, -1);\n }\n \n // Select 50 orders based on efficiency\n void select_orders() {\n // Create indexed list for sorting\n vector> scores;\n for (int i = 0; i < 1000; i++) {\n scores.push_back({orders[i].efficiency_score(), i});\n }\n \n // Sort by efficiency (descending)\n sort(scores.begin(), scores.end(), [](const auto& a, const auto& b) {\n return a.first > b.first;\n });\n \n // Select top 50\n selected_orders.clear();\n for (int i = 0; i < 50; i++) {\n selected_orders.push_back(scores[i].second);\n }\n }\n \n // Construct initial route using greedy nearest neighbor\n void construct_initial_route() {\n route.clear();\n route.push_back({400, 400}); // Start at center\n \n // Reset tracking\n fill(pickup_done.begin(), pickup_done.end(), false);\n fill(delivery_done.begin(), delivery_done.end(), false);\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Build route step by step\n int current_x = 400, current_y = 400;\n int steps = 0;\n \n // Continue until all deliveries are done\n while (true) {\n // Find all possible next locations\n vector> candidates; // distance, order_idx, location_type (0=pickup, 1=delivery), actual location index\n \n for (int i = 0; i < 50; i++) {\n if (!pickup_done[i]) {\n // Can pick up this order\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].pickup_x, orders[selected_orders[i]].pickup_y);\n candidates.push_back({dist, i, 0, 2*i});\n } else if (!delivery_done[i]) {\n // Can deliver this order (pickup already done)\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].delivery_x, orders[selected_orders[i]].delivery_y);\n candidates.push_back({dist, i, 1, 2*i+1});\n }\n }\n \n if (candidates.empty()) {\n break; // All done\n }\n \n // Choose the nearest candidate\n sort(candidates.begin(), candidates.end());\n auto [dist, order_idx, loc_type, loc_idx] = candidates[0];\n \n if (loc_type == 0) {\n // Pick up\n pickup_done[order_idx] = true;\n pickup_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].pickup_x;\n current_y = orders[selected_orders[order_idx]].pickup_y;\n route.push_back({current_x, current_y});\n } else {\n // Deliver\n delivery_done[order_idx] = true;\n delivery_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].delivery_x;\n current_y = orders[selected_orders[order_idx]].delivery_y;\n route.push_back({current_x, current_y});\n }\n \n steps++;\n }\n \n // Return to center\n route.push_back({400, 400});\n }\n \n // 2-opt local search to improve route\n void optimize_route_2opt() {\n bool improved = true;\n while (improved) {\n improved = false;\n \n // Try all possible 2-opt swaps\n for (int i = 1; i < (int)route.size() - 2; i++) {\n for (int j = i + 1; j < (int)route.size() - 1; j++) {\n // Check if swap would violate any precedence constraints\n if (is_valid_2opt(i, j)) {\n // Calculate potential improvement\n int current_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[i].first, route[i].second) +\n manhattan_distance(route[j].first, route[j].second, route[j+1].first, route[j+1].second);\n int new_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[j].first, route[j].second) +\n manhattan_distance(route[i].first, route[i].second, route[j+1].first, route[j+1].second);\n \n if (new_cost < current_cost) {\n // Perform the swap\n reverse(route.begin() + i, route.begin() + j + 1);\n improved = true;\n \n // Update pickup/delivery indices\n update_indices();\n \n // Early break to restart search\n break;\n }\n }\n }\n if (improved) break;\n }\n }\n }\n \n // Check if 2-opt swap would violate precedence constraints\n bool is_valid_2opt(int i, int j) {\n // Create a copy of current state\n vector new_pickup_index = pickup_index;\n vector new_delivery_index = delivery_index;\n \n // Simulate the reversal and update indices\n for (int k = i; k <= j; k++) {\n int new_pos = i + (j - k);\n // Check which order this position belongs to\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (pickup_index[order_idx] == k) {\n new_pickup_index[order_idx] = new_pos;\n }\n if (delivery_index[order_idx] == k) {\n new_delivery_index[order_idx] = new_pos;\n }\n }\n }\n \n // Check all precedence constraints\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (new_pickup_index[order_idx] > new_delivery_index[order_idx]) {\n return false; // Violates pickup before delivery\n }\n }\n \n return true;\n }\n \n // Update indices after route modification\n void update_indices() {\n // Reset indices\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Rebuild indices by scanning the route\n for (int pos = 0; pos < (int)route.size(); pos++) {\n for (int i = 0; i < 50; i++) {\n // Check if this position is a pickup for order i\n if (route[pos].first == orders[selected_orders[i]].pickup_x && \n route[pos].second == orders[selected_orders[i]].pickup_y) {\n // Make sure we haven't already recorded this pickup\n if (pickup_index[i] == -1 || \n (pickup_index[i] != -1 && delivery_index[i] != -1)) {\n pickup_index[i] = pos;\n }\n }\n // Check if this position is a delivery for order i\n if (route[pos].first == orders[selected_orders[i]].delivery_x && \n route[pos].second == orders[selected_orders[i]].delivery_y) {\n delivery_index[i] = pos;\n }\n }\n }\n }\n \n // Calculate total route distance\n int calculate_total_distance() {\n int total = 0;\n for (int i = 0; i < (int)route.size() - 1; i++) {\n total += manhattan_distance(route[i].first, route[i].second, \n route[i+1].first, route[i+1].second);\n }\n return total;\n }\n \n // Main optimization method\n void optimize() {\n select_orders();\n construct_initial_route();\n optimize_route_2opt();\n }\n \n // Output the solution\n void output_solution() {\n // Output selected orders (1-indexed)\n cout << \"50\";\n for (int i = 0; i < 50; i++) {\n cout << \" \" << selected_orders[i] + 1; // Convert to 1-indexed\n }\n cout << endl;\n \n // Output route\n cout << route.size();\n for (int i = 0; i < (int)route.size(); i++) {\n cout << \" \" << route[i].first << \" \" << route[i].second;\n }\n cout << endl;\n }\n};\n\nint main() {\n // Read input\n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].pickup_x >> orders[i].pickup_y >> \n orders[i].delivery_x >> orders[i].delivery_y;\n orders[i].id = i;\n }\n \n // Create optimizer and run\n RouteOptimizer optimizer(orders);\n optimizer.optimize();\n optimizer.output_solution();\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Union-Find data structure\nstruct UnionFind {\n vector parent, rank, size;\n int components;\n \n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n size.resize(n, 1);\n components = n;\n for (int i = 0; i < n; i++) {\n parent[i] = i;\n }\n }\n \n int find(int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n }\n \n bool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n \n if (rank[x] < rank[y]) {\n swap(x, y);\n }\n parent[y] = x;\n size[x] += size[y];\n if (rank[x] == rank[y]) {\n rank[x]++;\n }\n components--;\n return true;\n }\n \n bool same(int x, int y) {\n return find(x) == find(y);\n }\n \n int getComponents() {\n return components;\n }\n \n int getSize(int x) {\n return size[find(x)];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 400;\n const int M = 1995;\n \n // Read vertex coordinates\n vector> vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].first >> vertices[i].second;\n }\n \n // Read edges (store for later use)\n vector> edges(M);\n vector base_distances(M);\n \n for (int i = 0; i < M; i++) {\n cin >> edges[i].first >> edges[i].second;\n // Calculate d_i (rounded Euclidean distance)\n int dx = vertices[edges[i].first].first - vertices[edges[i].second].first;\n int dy = vertices[edges[i].first].second - vertices[edges[i].second].second;\n double dist = sqrt(dx*dx + dy*dy);\n base_distances[i] = (int)round(dist);\n }\n \n // Initialize Union-Find\n UnionFind uf(N);\n \n // Process each edge\n for (int i = 0; i < M; i++) {\n int length;\n cin >> length;\n \n int u = edges[i].first;\n int v = edges[i].second;\n int d = base_distances[i];\n \n // Calculate cost ratio\n double ratio = (double)length / d;\n \n // Dynamic threshold based on progress\n // Early on, accept more edges; later, be more selective\n double progress = (double)i / M;\n double threshold = 2.0 - 1.0 * progress; // Start at 2.0, end at 1.0\n \n // If this edge connects different components and the ratio is acceptable\n bool should_accept = !uf.same(u, v) && ratio <= threshold;\n \n // If we still have many components, be more permissive\n if (uf.getComponents() > N/4 && ratio <= threshold + 0.5) {\n should_accept = !uf.same(u, v);\n }\n \n // If this is a very cheap edge, strongly consider accepting\n if (ratio <= 1.2 && !uf.same(u, v)) {\n should_accept = true;\n }\n \n // If we're running out of edges and still have many components, accept more liberally\n if (i > M - N && uf.getComponents() > 1 && !uf.same(u, v)) {\n should_accept = true;\n }\n \n // Output decision\n cout << (should_accept ? 1 : 0) << endl;\n cout.flush(); // Important: flush output\n \n // If accepted, unite the components\n if (should_accept) {\n uf.unite(u, v);\n }\n }\n \n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int MAX_TURNS = 300;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool isValid() const { return x >= 1 && x <= GRID_SIZE && y >= 1 && y <= GRID_SIZE; }\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator<(const Point& other) const { return x < other.x || (x == other.x && y < other.y); }\n};\n\n// Direction vectors for U, D, L, R\nconst vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\nconst string dir_chars = \"UDLR\";\nconst string block_chars = \"udlr\";\n\nclass Grid {\npublic:\n vector> impassable;\n vector human_positions;\n vector pet_positions;\n vector pet_types;\n int N, M;\n \n Grid() {\n impassable = vector>(GRID_SIZE + 1, vector(GRID_SIZE + 1, false));\n }\n \n bool isPassable(const Point& p) {\n if (!p.isValid()) return false;\n return !impassable[p.x][p.y];\n }\n \n // Check if we can make a square impassable (no pets or humans at start of turn, no adjacent pets)\n bool canBlock(const Point& p, const vector& current_human_positions, const vector& current_pet_positions) {\n if (!p.isValid()) return false;\n if (!isPassable(p)) return false; // Already impassable\n \n // Check if any human is at this position at the start of turn\n for (const Point& hp : current_human_positions) {\n if (hp == p) return false;\n }\n \n // Check if any pet is at this position at the start of turn\n for (const Point& pp : current_pet_positions) {\n if (pp == p) return false;\n }\n \n // Check if any adjacent square contains a pet\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (!adj.isValid()) continue;\n for (const Point& pp : current_pet_positions) {\n if (pp == adj) return false;\n }\n }\n \n return true;\n }\n \n // BFS to find reachable area from a point\n set getReachableArea(const Point& start) {\n set visited;\n queue q;\n q.push(start);\n visited.insert(start);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return visited;\n }\n \n // Count pets in a reachable area\n int countPetsInArea(const set& area) {\n int count = 0;\n for (const Point& pet_pos : pet_positions) {\n if (area.find(pet_pos) != area.end()) {\n count++;\n }\n }\n return count;\n }\n \n // Simple distance between two points\n int distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the closest pet to a human\n int findClosestPet(const Point& human_pos) {\n int min_dist = INT_MAX;\n int closest_pet = -1;\n \n for (int i = 0; i < N; i++) {\n int dist = distance(human_pos, pet_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = i;\n }\n }\n \n return closest_pet;\n }\n \n // Check if a pet can reach a human (simple BFS)\n bool canPetReachHuman(const Point& pet_pos, const Point& human_pos) {\n if (!isPassable(pet_pos) || !isPassable(human_pos)) return false;\n \n set visited;\n queue q;\n q.push(pet_pos);\n visited.insert(pet_pos);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n if (curr == human_pos) return true;\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return false;\n }\n \n // Get all adjacent passable squares\n vector getAdjacentPassable(const Point& p) {\n vector result;\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (adj.isValid() && isPassable(adj)) {\n result.push_back(adj);\n }\n }\n return result;\n }\n};\n\nint main() {\n Grid grid;\n \n // Read initial pet positions and types\n cin >> grid.N;\n grid.pet_positions.resize(grid.N);\n grid.pet_types.resize(grid.N);\n for (int i = 0; i < grid.N; i++) {\n cin >> grid.pet_positions[i].x >> grid.pet_positions[i].y >> grid.pet_types[i];\n }\n \n // Read initial human positions\n cin >> grid.M;\n grid.human_positions.resize(grid.M);\n for (int i = 0; i < grid.M; i++) {\n cin >> grid.human_positions[i].x >> grid.human_positions[i].y;\n }\n \n // Strategy variables\n vector human_has_walled(grid.M, false);\n vector wall_progress(grid.M, 0);\n int turn = 0;\n \n while (turn < MAX_TURNS) {\n string actions = \"\";\n \n // For each human, decide action\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char best_action = '.';\n \n // Early turns: focus on building walls\n if (turn < 150) {\n // Try to build a wall around the human\n bool found_block = false;\n \n // Check all directions for valid blocking\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, grid.human_positions, grid.pet_positions)) {\n // Prefer blocking in directions away from pets\n bool safe = true;\n for (int j = 0; j < grid.N; j++) {\n int pet_dist = grid.distance(block_pos, grid.pet_positions[j]);\n if (pet_dist <= 2) { // Avoid blocking near pets\n safe = false;\n break;\n }\n }\n \n if (safe) {\n best_action = block_chars[d];\n found_block = true;\n break;\n }\n }\n }\n \n // If can't block safely, try to move away from closest pet\n if (!found_block) {\n int closest_pet = grid.findClosestPet(human_pos);\n if (closest_pet != -1) {\n Point& pet_pos = grid.pet_positions[closest_pet];\n \n // Find direction away from pet\n int dx = human_pos.x - pet_pos.x;\n int dy = human_pos.y - pet_pos.y;\n \n vector> move_dirs;\n if (dx > 0) move_dirs.push_back({0, 0}); // U\n else if (dx < 0) move_dirs.push_back({1, 1}); // D\n if (dy > 0) move_dirs.push_back({2, 2}); // L\n else if (dy < 0) move_dirs.push_back({3, 3}); // R\n \n // If no clear direction away, try any direction\n if (move_dirs.empty()) {\n for (int d = 0; d < 4; d++) {\n move_dirs.push_back({d, d});\n }\n }\n \n // Try to move in the best direction\n for (auto& dir_range : move_dirs) {\n for (int d = dir_range.first; d <= dir_range.second; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n best_action = dir_chars[d];\n break;\n }\n }\n if (best_action != '.') break;\n }\n }\n }\n } \n // Mid to late game: focus on optimizing position\n else {\n // Calculate which action gives best expected score improvement\n double best_score = -1;\n \n // Try staying\n double stay_score = 0;\n \n // Try moving in each direction\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n // Temporarily move\n Point original_pos = human_pos;\n human_pos = move_pos;\n \n // Calculate score for this position\n set area = grid.getReachableArea(human_pos);\n int pet_count = grid.countPetsInArea(area);\n double score = (double)area.size() / 900.0 * pow(0.5, pet_count);\n \n if (score > best_score) {\n best_score = score;\n best_action = dir_chars[d];\n }\n \n // Restore position\n human_pos = original_pos;\n }\n }\n \n // If staying is best or no moves available, stay\n if (best_action == '.' || best_score <= stay_score) {\n best_action = '.';\n }\n \n // Occasionally try to block if it doesn't risk trapping ourselves\n if (turn < 250 && best_action == '.') {\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (grid.canBlock(block_pos, grid.human_positions, grid.pet_positions)) {\n // Check if blocking here would isolate us too much\n grid.impassable[block_pos.x][block_pos.y] = true;\n set area = grid.getReachableArea(human_pos);\n grid.impassable[block_pos.x][block_pos.y] = false;\n \n if (area.size() > 10) { // Don't block if it makes our area too small\n best_action = block_chars[d];\n break;\n }\n }\n }\n }\n }\n \n actions += best_action;\n \n // Update human position if moving\n if (best_action >= 'A' && best_action <= 'Z') {\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == best_action) {\n human_pos.x += dirs[d].first;\n human_pos.y += dirs[d].second;\n break;\n }\n }\n }\n // Update grid if blocking\n else if (best_action >= 'a' && best_action <= 'z') {\n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == best_action) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n grid.impassable[block_pos.x][block_pos.y] = true;\n break;\n }\n }\n }\n }\n \n // Output actions\n cout << actions << endl;\n cout.flush();\n \n // Read pet movements\n for (int i = 0; i < grid.N; i++) {\n string move;\n cin >> move;\n \n // Update pet position based on movement\n for (char c : move) {\n int dir_index = -1;\n for (int j = 0; j < 4; j++) {\n if (dir_chars[j] == c) {\n dir_index = j;\n break;\n }\n }\n if (dir_index != -1) {\n grid.pet_positions[i].x += dirs[dir_index].first;\n grid.pet_positions[i].y += dirs[dir_index].second;\n }\n }\n }\n \n turn++;\n }\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors for U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nstruct State {\n int x, y, dist;\n string path;\n State(int x, int y, int dist, string path) : x(x), y(dist), dist(dist), path(path) {}\n};\n\nbool isValid(int x, int y) {\n return x >= 0 && x < 20 && y >= 0 && y < 20;\n}\n\n// BFS to find shortest path\nstring findShortestPath(int sx, int sy, int tx, int ty, \n const vector& h_walls, \n const vector& v_walls) {\n queue q;\n vector> visited(20, vector(20, false));\n \n q.push(State(sx, sy, 0, \"\"));\n visited[sx][sy] = true;\n \n while (!q.empty()) {\n State curr = q.front();\n q.pop();\n \n if (curr.x == tx && curr.y == ty) {\n return curr.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = curr.x + dx[d];\n int ny = curr.y + dy[d];\n \n if (!isValid(nx, ny) || visited[nx][ny]) continue;\n \n // Check walls\n bool canMove = false;\n if (d == 0 && curr.x > 0 && v_walls[curr.x-1][curr.y] == '0') { // Up\n canMove = true;\n } else if (d == 1 && curr.x < 19 && v_walls[curr.x][curr.y] == '0') { // Down\n canMove = true;\n } else if (d == 2 && curr.y > 0 && h_walls[curr.x][curr.y-1] == '0') { // Left\n canMove = true;\n } else if (d == 3 && curr.y < 19 && h_walls[curr.x][curr.y] == '0') { // Right\n canMove = true;\n }\n \n if (canMove) {\n visited[nx][ny] = true;\n q.push(State(nx, ny, curr.dist + 1, curr.path + dir_char[d]));\n }\n }\n }\n \n return \"\"; // Should not happen as guaranteed reachable\n}\n\n// Calculate how many times to repeat the path based on probability p\nint calculateRepetitions(double p, int pathLength) {\n // Higher p means more likely to forget, so we need more repetitions\n // We want to ensure high probability of success while keeping length <= 200\n if (pathLength == 0) return 1;\n \n int maxReps = 200 / pathLength;\n if (maxReps == 0) return 1;\n \n // For high forget probability, use more repetitions\n // For low forget probability, use fewer repetitions to get better score (shorter time)\n int reps = 1;\n if (p >= 0.4) {\n reps = min(maxReps, 5);\n } else if (p >= 0.3) {\n reps = min(maxReps, 3);\n } else if (p >= 0.2) {\n reps = min(maxReps, 2);\n } else {\n reps = 1;\n }\n \n return reps;\n}\n\nint main() {\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h_walls(20);\n for (int i = 0; i < 20; i++) {\n if (i < 19) {\n cin >> h_walls[i];\n } else {\n // For i=19, there are no horizontal walls below (out of bounds)\n h_walls[i] = string(19, '1'); // Initialize with walls\n }\n }\n \n vector v_walls(19);\n for (int i = 0; i < 19; i++) {\n cin >> v_walls[i];\n }\n \n // Find shortest path\n string shortestPath = findShortestPath(si, sj, ti, tj, h_walls, v_walls);\n \n // Calculate repetitions based on forget probability\n int repetitions = calculateRepetitions(p, shortestPath.length());\n \n // Create final path by repeating the shortest path\n string finalPath = \"\";\n for (int i = 0; i < repetitions; i++) {\n finalPath += shortestPath;\n // If we're already at max length, break\n if (finalPath.length() >= 200) {\n finalPath = finalPath.substr(0, 200);\n break;\n }\n }\n \n // Ensure we don't exceed 200 characters\n if (finalPath.length() > 200) {\n finalPath = finalPath.substr(0, 200);\n }\n \n cout << finalPath << endl;\n \n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction constants: left, up, right, down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// Transition table: to[tile_type][entry_direction] = exit_direction or -1 if invalid\nconst int to[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\nconst int N = 30;\n\nclass Solution {\nprivate:\n vector> grid;\n vector> rotations;\n mt19937 rng;\n \npublic:\n Solution(const vector>& input_grid) : grid(input_grid), rng(random_device{}()) {\n rotations = vector>(N, vector(N, 0));\n }\n \n // Get the actual tile type after rotation\n int get_rotated_tile(int i, int j) {\n int base_type = grid[i][j];\n int rot = rotations[i][j] % 4;\n \n // Tile mapping after rotation\n if (base_type <= 3) {\n return (base_type + rot) % 4;\n } else if (base_type <= 5) {\n if (base_type == 4) {\n if (rot % 2 == 0) return 4;\n else return 5;\n } else { // base_type == 5\n if (rot % 2 == 0) return 5;\n else return 4;\n }\n } else { // base_type >= 6\n if (base_type == 6) {\n if (rot % 2 == 0) return 6;\n else return 7;\n } else { // base_type == 7\n if (rot % 2 == 0) return 7;\n else return 6;\n }\n }\n }\n \n // Calculate the length of a loop starting from (i, j) with direction d\n int calculate_loop_length(int si, int sj, int sd) {\n int i = si, j = sj, d = sd;\n int length = 0;\n \n do {\n int tile_type = get_rotated_tile(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0; // Line is broken\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= N || j < 0 || j >= N) return 0; // Out of bounds\n \n d = (d2 + 2) % 4; // Direction to the previous tile\n length++;\n \n // Check if we returned to start\n if (i == si && j == sj && d == sd) {\n return length;\n }\n } while (true);\n }\n \n // Find all loops and return their lengths\n vector find_all_loops() {\n vector loop_lengths;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions and directions in this loop as visited\n int ci = i, cj = j, cd = d;\n do {\n visited[ci][cj][cd] = true;\n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n ci += di[d2];\n cj += dj[d2];\n cd = (d2 + 2) % 4;\n } while (!(ci == i && cj == j && cd == d));\n \n loop_lengths.push_back(length);\n }\n }\n }\n }\n \n // Sort in descending order\n sort(loop_lengths.rbegin(), loop_lengths.rend());\n return loop_lengths;\n }\n \n // Calculate score: L1 * L2 (0 if less than 2 loops)\n long long calculate_score() {\n vector loops = find_all_loops();\n if (loops.size() < 2) return 0;\n return (long long)loops[0] * loops[1];\n }\n \n // Randomly initialize rotations\n void random_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n rotations[i][j] = uniform_int_distribution(0, 3)(rng);\n }\n }\n }\n \n // Try to improve solution using simulated annealing\n void simulated_annealing() {\n long long current_score = calculate_score();\n auto start_time = chrono::steady_clock::now();\n \n const double initial_temp = 1000.0;\n const double final_temp = 1.0;\n const double cooling_rate = 0.9995;\n \n double temp = initial_temp;\n \n while (temp > final_temp) {\n // Pick a random tile to modify\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n \n // Save current rotation\n int old_rot = rotations[i][j];\n \n // Try a new rotation\n int new_rot = uniform_int_distribution(0, 3)(rng);\n rotations[i][j] = new_rot;\n \n // Calculate new score\n long long new_score = calculate_score();\n \n // Accept or reject based on simulated annealing\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n }\n }\n \n if (!accept) {\n // Revert\n rotations[i][j] = old_rot;\n } else {\n current_score = new_score;\n }\n \n // Cool down\n temp *= cooling_rate;\n \n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1800) { // Stop before 2 seconds\n break;\n }\n }\n }\n \n // Run multiple restarts of simulated annealing\n void optimize() {\n long long best_score = 0;\n vector> best_rotations = rotations;\n \n // Try multiple random starts\n for (int restart = 0; restart < 5; restart++) {\n random_init();\n simulated_annealing();\n \n long long score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n \n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto start_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1500) { // Stop before time limit\n break;\n }\n }\n \n rotations = best_rotations;\n }\n \n // Output the solution\n string get_output() {\n string result = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n result += char('0' + rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n // Read input\n vector> grid(N, vector(N));\n for (int i = 0; i < N; i++) {\n string line;\n cin >> line;\n for (int j = 0; j < N; j++) {\n grid[i][j] = line[j] - '0';\n }\n }\n \n // Create and optimize solution\n Solution solution(grid);\n solution.optimize();\n \n // Output result\n cout << solution.get_output() << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\nconst int opposite_dir[4] = {1, 0, 3, 2}; // Opposite of U,D,L,R\n\nstruct State {\n vector board;\n int empty_x, empty_y;\n string moves;\n int score;\n \n State(const vector& b, int ex, int ey, const string& m = \"\") \n : board(b), empty_x(ex), empty_y(ey), moves(m) {\n score = calculateScore();\n }\n \n int calculateScore() const {\n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n // BFS to find connected component\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down (8) connects to up (2) of tile below\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right (4) connects to left (1) of tile right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n }\n \n bool operator<(const State& other) const {\n return score < other.score;\n }\n};\n\n// Calculate the score of a board configuration\nint calculateScore(const vector& board) {\n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n // BFS to find connected component\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down (8) connects to up (2) of tile below\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right (4) connects to left (1) of tile right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n}\n\n// Check if a move is valid\nbool isValidMove(int x, int y, int n) {\n return x >= 0 && x < n && y >= 0 && y < n;\n}\n\n// Apply a move to the board\nvoid applyMove(vector& board, int& empty_x, int& empty_y, int dir) {\n int new_x = empty_x + dx[dir];\n int new_y = empty_y + dy[dir];\n \n // Swap the empty space with the tile\n swap(board[empty_x][empty_y], board[new_x][new_y]);\n empty_x = new_x;\n empty_y = new_y;\n}\n\n// Heuristic: try to maximize the size of the largest connected component\nstring solve(const vector& initial_board, int N, int T) {\n int empty_x = -1, empty_y = -1;\n \n // Find the empty space\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_board[i][j] == '0') {\n empty_x = i;\n empty_y = j;\n break;\n }\n }\n if (empty_x != -1) break;\n }\n \n // If we're already at max score, return empty string\n int current_score = calculateScore(initial_board);\n if (current_score == N*N-1) {\n return \"\";\n }\n \n // Use a beam search approach for better performance\n const int BEAM_WIDTH = 50;\n vector beam;\n beam.push_back(State(initial_board, empty_x, empty_y, \"\"));\n \n // Try to find a good solution within T moves\n for (int step = 0; step < T && !beam.empty(); step++) {\n vector next_beam;\n \n for (auto& state : beam) {\n // Try all possible moves\n for (int dir = 0; dir < 4; dir++) {\n int new_x = state.empty_x + dx[dir];\n int new_y = state.empty_y + dy[dir];\n \n // Skip if move is invalid or would undo previous move\n if (!isValidMove(new_x, new_y, N)) continue;\n if (state.moves.size() > 0 && \n dir == opposite_dir[state.moves.back() - 'U']) continue;\n \n // Make a copy and apply the move\n vector new_board = state.board;\n int new_empty_x = state.empty_x;\n int new_empty_y = state.empty_y;\n string new_moves = state.moves + dir_char[dir];\n \n // Apply the move\n swap(new_board[new_empty_x][new_empty_y], new_board[new_x][new_y]);\n new_empty_x = new_x;\n new_empty_y = new_y;\n \n // Create new state\n State new_state(new_board, new_empty_x, new_empty_y, new_moves);\n \n // If we found a full tree, return immediately\n if (new_state.score == N*N-1) {\n return new_state.moves;\n }\n \n next_beam.push_back(new_state);\n }\n }\n \n // Sort by score (descending) and keep only the best BEAM_WIDTH states\n sort(next_beam.begin(), next_beam.end(), [](const State& a, const State& b) {\n if (a.score != b.score) return a.score > b.score;\n return a.moves.size() < b.moves.size(); // Prefer shorter sequences\n });\n \n if (next_beam.size() > BEAM_WIDTH) {\n next_beam.resize(BEAM_WIDTH);\n }\n \n beam = next_beam;\n }\n \n // Return the best solution found\n if (!beam.empty()) {\n sort(beam.begin(), beam.end(), [](const State& a, const State& b) {\n if (a.score != b.score) return a.score > b.score;\n return a.moves.size() < b.moves.size();\n });\n return beam[0].moves;\n }\n \n return \"\";\n}\n\nint main() {\n int N, T;\n cin >> N >> T;\n \n vector board(N);\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n string solution = solve(board, N, T);\n cout << solution << endl;\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n long long x, y;\n Point() : x(0), y(0) {}\n Point(long long x, long long y) : x(x), y(y) {}\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n \n long long cross(const Point& other) const {\n return x * other.y - y * other.x;\n }\n \n long long dot(const Point& other) const {\n return x * other.x + y * other.y;\n }\n \n long long dist2() const {\n return x * x + y * y;\n }\n \n double dist() const {\n return sqrt(x * x + y * y);\n }\n};\n\nstruct Line {\n Point p1, p2;\n Line() {}\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\n// Check which side of the line a point is on\n// Returns: 1 if on one side, -1 if on the other, 0 if on the line\nint side(const Point& p, const Line& line) {\n Point v1 = line.p2 - line.p1;\n Point v2 = p - line.p1;\n long long cross = v1.cross(v2);\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\n// Check if a point is strictly inside a region defined by lines\n// Each line defines a half-plane, and we need to be on the correct side of all lines\nbool isInside(const Point& p, const vector& lines, const vector& sides) {\n for (int i = 0; i < lines.size(); i++) {\n int s = side(p, lines[i]);\n if (s != sides[i]) return false;\n }\n return true;\n}\n\n// Get all regions created by the lines\n// Each region is defined by which side of each line it's on\nvector> getAllRegions(int n) {\n vector> regions;\n for (int mask = 0; mask < (1 << n); mask++) {\n vector region;\n for (int i = 0; i < n; i++) {\n region.push_back((mask >> i) & 1 ? 1 : -1);\n }\n regions.push_back(region);\n }\n return regions;\n}\n\n// Count strawberries in each region\nvector countStrawberriesInRegions(const vector& strawberries, const vector& lines, const vector>& regions) {\n vector counts(regions.size(), 0);\n for (const Point& s : strawberries) {\n bool onLine = false;\n for (const Line& line : lines) {\n if (side(s, line) == 0) {\n onLine = true;\n break;\n }\n }\n if (onLine) continue; // Strawberry on line doesn't count\n \n for (int i = 0; i < regions.size(); i++) {\n if (isInside(s, lines, regions[i])) {\n counts[i]++;\n break;\n }\n }\n }\n return counts;\n}\n\n// Calculate score\nint calculateScore(const vector& a, const vector& b) {\n int total = 0;\n int satisfied = 0;\n for (int d = 0; d < 10; d++) {\n satisfied += min(a[d], b[d]);\n total += a[d];\n }\n return round(1000000.0 * satisfied / total);\n}\n\n// Try to find a line that separates a group of strawberries from others\nLine findSeparatingLine(const vector& strawberries, const vector& group, const vector& existingLines) {\n // Simple approach: try to find a line that roughly separates the group from others\n if (group.size() == 0) {\n return Line(Point(0, 0), Point(1, 0));\n }\n \n // Calculate centroid of group\n Point centroid(0, 0);\n for (int i : group) {\n centroid.x += strawberries[i].x;\n centroid.y += strawberries[i].y;\n }\n centroid.x /= group.size();\n centroid.y /= group.size();\n \n // Calculate centroid of other strawberries\n vector others;\n for (int i = 0; i < strawberries.size(); i++) {\n if (find(group.begin(), group.end(), i) == group.end()) {\n others.push_back(i);\n }\n }\n \n if (others.empty()) {\n // If no others, just use a line near the group\n return Line(Point(centroid.x - 1, centroid.y - 1), Point(centroid.x + 1, centroid.y + 1));\n }\n \n Point otherCentroid(0, 0);\n for (int i : others) {\n otherCentroid.x += strawberries[i].x;\n otherCentroid.y += strawberries[i].y;\n }\n otherCentroid.x /= others.size();\n otherCentroid.y /= others.size();\n \n // Line perpendicular to the line connecting centroids\n Point dir = otherCentroid - centroid;\n Point perp(-dir.y, dir.x);\n \n // Make sure the points are integers and within bounds\n Point p1(centroid.x + perp.x, centroid.y + perp.y);\n Point p2(centroid.x - perp.x, centroid.y - perp.y);\n \n // Scale to make sure they're far enough apart\n if (p1.dist2() < 100) {\n p1.x *= 1000;\n p1.y *= 1000;\n p2.x *= 1000;\n p2.y *= 1000;\n }\n \n // Ensure bounds\n p1.x = max(-1000000000LL, min(1000000000LL, p1.x));\n p1.y = max(-1000000000LL, min(1000000000LL, p1.y));\n p2.x = max(-1000000000LL, min(1000000000LL, p2.x));\n p2.y = max(-1000000000LL, min(1000000000LL, p2.y));\n \n return Line(p1, p2);\n}\n\n// Calculate distance between two points\ndouble distance(const Point& a, const Point& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\n// Calculate distance from point to line\ndouble pointToLineDistance(const Point& p, const Line& line) {\n Point v = line.p2 - line.p1;\n Point w = p - line.p1;\n double c1 = w.dot(v);\n if (c1 <= 0) return p.dist();\n double c2 = v.dot(v);\n if (c2 <= c1) return distance(p, line.p2);\n double b = c1 / c2;\n Point pb(line.p1.x + b * v.x, line.p1.y + b * v.y);\n return distance(p, pb);\n}\n\n// Try to improve a line to minimize strawberries on it\nLine improveLine(const Line& line, const vector& strawberries, const vector& otherLines) {\n Line bestLine = line;\n double bestScore = 0;\n \n // Try small perturbations\n for (int dx1 = -1; dx1 <= 1; dx1++) {\n for (int dy1 = -1; dy1 <= 1; dy1++) {\n for (int dx2 = -1; dx2 <= 1; dx2++) {\n for (int dy2 = -1; dy2 <= 1; dy2++) {\n Point newP1(line.p1.x + dx1, line.p1.y + dy1);\n Point newP2(line.p2.x + dx2, line.p2.y + dy2);\n \n // Skip if points are the same\n if (newP1.x == newP2.x && newP1.y == newP2.y) continue;\n \n Line newLine(newP1, newP2);\n \n // Calculate score: minimize strawberries on line\n int onLine = 0;\n for (const Point& s : strawberries) {\n if (side(s, newLine) == 0) {\n onLine++;\n }\n }\n \n // Prefer lines with fewer strawberries on them\n double score = -onLine;\n \n if (score > bestScore || (score == bestScore && rand() % 2 == 0)) {\n bestScore = score;\n bestLine = newLine;\n }\n }\n }\n }\n }\n \n return bestLine;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n cin >> N >> K;\n \n vector a(10);\n for (int i = 0; i < 10; i++) {\n cin >> a[i];\n }\n \n vector strawberries(N);\n for (int i = 0; i < N; i++) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n \n // We'll use a greedy approach to create pieces of desired sizes\n vector lines;\n vector used(N, false);\n \n // First, try to create single strawberry pieces\n for (int d = 0; d < 10; d++) {\n if (a[d] == 0) continue;\n \n // Target: create a[d] pieces with d+1 strawberries each\n int targetCount = a[d];\n int strawberriesPerPiece = d + 1;\n \n for (int piece = 0; piece < targetCount && lines.size() < K; piece++) {\n // Find a group of strawberriesPerPiece strawberries that are close to each other\n vector group;\n \n // Find unused strawberries\n vector unused;\n for (int i = 0; i < N; i++) {\n if (!used[i]) {\n unused.push_back(i);\n }\n }\n \n if (unused.size() < strawberriesPerPiece) {\n // Not enough unused strawberries, skip\n break;\n }\n \n // Use a simple greedy approach: pick the first available strawberries\n for (int i = 0; i < strawberriesPerPiece && i < unused.size(); i++) {\n group.push_back(unused[i]);\n used[unused[i]] = true;\n }\n \n // If we need to isolate this group, add a line\n if (strawberriesPerPiece < N && !group.empty()) {\n // Find a line that separates this group from others (if possible)\n Line separatingLine = findSeparatingLine(strawberries, group, lines);\n \n // Try to improve the line to avoid cutting through strawberries\n separatingLine = improveLine(separatingLine, strawberries, lines);\n \n lines.push_back(separatingLine);\n \n // Stop if we've reached the limit\n if (lines.size() >= K) break;\n }\n }\n }\n \n // If we have remaining cuts, try to add random lines that might improve the partition\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution dis(-1000000000, 1000000000);\n \n while (lines.size() < K) {\n // Generate a random line\n Point p1(dis(gen), dis(gen));\n Point p2(dis(gen), dis(gen));\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n p2.x += 1;\n }\n \n Line line(p1, p2);\n \n // Improve the line\n line = improveLine(line, strawberries, lines);\n \n lines.push_back(line);\n }\n \n // Output the solution\n cout << lines.size() << \"\\n\";\n for (const Line& line : lines) {\n cout << line.p1.x << \" \" << line.p1.y << \" \" << line.p2.x << \" \" << line.p2.y << \"\\n\";\n }\n \n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n \n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n \n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n \n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y);\n }\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n};\n\nstruct Edge {\n Point p1, p2;\n Edge(Point a, Point b) {\n if (a < b) {\n p1 = a;\n p2 = b;\n } else {\n p1 = b;\n p2 = a;\n }\n }\n \n bool operator==(const Edge& other) const {\n return p1 == other.p1 && p2 == other.p2;\n }\n \n bool operator<(const Edge& other) const {\n if (p1 != other.p1) return p1 < other.p1;\n return p2 < other.p2;\n }\n};\n\nstruct Rectangle {\n vector points;\n vector edges;\n \n Rectangle(Point p1, Point p2, Point p3, Point p4) {\n points = {p1, p2, p3, p4};\n // Create edges\n edges.push_back(Edge(p1, p2));\n edges.push_back(Edge(p2, p3));\n edges.push_back(Edge(p3, p4));\n edges.push_back(Edge(p4, p1));\n }\n};\n\nstruct Candidate {\n Point newPoint;\n vector existingPoints;\n double weight;\n \n Candidate(Point np, vector ep, double w) : newPoint(np), existingPoints(ep), weight(w) {}\n \n bool operator<(const Candidate& other) const {\n // Higher weight first\n return weight < other.weight;\n }\n};\n\nclass RectJoinSolver {\nprivate:\n int N, M;\n int center;\n vector> hasDot;\n set drawnEdges;\n vector initialDots;\n vector> operations;\n \n // Calculate weight of a point\n double getWeight(int x, int y) {\n return (x - center) * (x - center) + (y - center) * (y - center) + 1;\n }\n \n // Check if point is on the grid\n bool isValidPoint(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n \n // Get all points on the perimeter of a rectangle\n vector getPerimeterPoints(const Rectangle& rect) {\n vector perimeter;\n \n // Add all four corners\n for (const Point& p : rect.points) {\n perimeter.push_back(p);\n }\n \n // Add points on edges (excluding corners)\n for (const Edge& edge : rect.edges) {\n int dx = edge.p2.x - edge.p1.x;\n int dy = edge.p2.y - edge.p1.y;\n \n int steps = max(abs(dx), abs(dy));\n if (steps == 0) continue;\n \n int stepX = (dx != 0) ? dx / abs(dx) : 0;\n int stepY = (dy != 0) ? dy / abs(dy) : 0;\n \n Point current = edge.p1;\n for (int i = 1; i < steps; i++) {\n current = Point(current.x + stepX, current.y + stepY);\n perimeter.push_back(current);\n }\n }\n \n return perimeter;\n }\n \n // Check if rectangle is valid (no other dots on perimeter except corners)\n bool isValidRectangle(const Rectangle& rect) {\n vector perimeter = getPerimeterPoints(rect);\n \n // Check if there are dots on perimeter other than the 4 corners\n for (const Point& p : perimeter) {\n bool isCorner = false;\n for (const Point& corner : rect.points) {\n if (p == corner) {\n isCorner = true;\n break;\n }\n }\n \n if (!isCorner && hasDot[p.x][p.y]) {\n return false;\n }\n }\n \n // Check if any edge shares a segment with existing edges\n for (const Edge& edge : rect.edges) {\n if (drawnEdges.find(edge) != drawnEdges.end()) {\n return false;\n }\n }\n \n return true;\n }\n \n // Try to form a rectangle with the given new point and existing dots\n vector findValidRectangle(Point newPoint, const vector& existingDots) {\n int existingCount = existingDots.size();\n \n // Try all combinations of 3 existing dots\n for (int i = 0; i < existingCount; i++) {\n for (int j = i + 1; j < existingCount; j++) {\n for (int k = j + 1; k < existingCount; k++) {\n Point p2 = existingDots[i];\n Point p3 = existingDots[j];\n Point p4 = existingDots[k];\n \n // Try different orderings to form rectangles\n vector> orderings = {\n {newPoint, p2, p3, p4},\n {newPoint, p2, p4, p3},\n {newPoint, p3, p2, p4},\n {newPoint, p3, p4, p2},\n {newPoint, p4, p2, p3},\n {newPoint, p4, p3, p2}\n };\n \n for (const auto& ordering : orderings) {\n if (isRectangle(ordering[0], ordering[1], ordering[2], ordering[3])) {\n Rectangle rect(ordering[0], ordering[1], ordering[2], ordering[3]);\n if (isValidRectangle(rect)) {\n return {p2, p3, p4}; // Return the 3 existing points\n }\n }\n }\n }\n }\n }\n \n return {}; // No valid rectangle found\n }\n \n // Check if 4 points form a rectangle (axis-aligned or 45-degree)\n bool isRectangle(Point p1, Point p2, Point p3, Point p4) {\n // For axis-aligned rectangles\n if (isAxisAlignedRectangle(p1, p2, p3, p4)) {\n return true;\n }\n \n // For 45-degree rectangles\n if (isDiagonalRectangle(p1, p2, p3, p4)) {\n return true;\n }\n \n return false;\n }\n \n // Check if 4 points form an axis-aligned rectangle\n bool isAxisAlignedRectangle(Point p1, Point p2, Point p3, Point p4) {\n vector xs = {p1.x, p2.x, p3.x, p4.x};\n vector ys = {p1.y, p2.y, p3.y, p4.y};\n sort(xs.begin(), xs.end());\n sort(ys.begin(), ys.end());\n \n // Check if there are exactly 2 distinct x-coordinates and 2 distinct y-coordinates\n if (xs[0] == xs[1] && xs[2] == xs[3] && ys[0] == ys[1] && ys[2] == ys[3]) {\n // Check if the points are at the corners\n set corners = {\n Point(xs[0], ys[0]), Point(xs[0], ys[3]),\n Point(xs[3], ys[0]), Point(xs[3], ys[3])\n };\n \n set actual = {p1, p2, p3, p4};\n return corners == actual;\n }\n \n return false;\n }\n \n // Check if 4 points form a 45-degree rectangle (diamond shape)\n bool isDiagonalRectangle(Point p1, Point p2, Point p3, Point p4) {\n // Calculate vectors between points\n vector points = {p1, p2, p3, p4};\n \n // Try all possible center points\n for (int i = 0; i < 4; i++) {\n for (int j = i + 1; j < 4; j++) {\n // Calculate potential center (midpoint of diagonal)\n Point center((points[i].x + points[j].x) / 2, (points[i].y + points[j].y) / 2);\n \n // Check if center has integer coordinates\n if ((points[i].x + points[j].x) % 2 != 0 || (points[i].y + points[j].y) % 2 != 0) {\n continue;\n }\n \n // Find the other two points\n vector otherPoints;\n for (int k = 0; k < 4; k++) {\n if (k != i && k != j) {\n otherPoints.push_back(points[k]);\n }\n }\n \n if (otherPoints.size() != 2) continue;\n \n // Check if they form a diagonal\n Point otherCenter((otherPoints[0].x + otherPoints[1].x) / 2, (otherPoints[0].y + otherPoints[1].y) / 2);\n if (otherCenter.x != center.x || otherCenter.y != center.y) {\n continue;\n }\n \n // Check if it's a square rotated by 45 degrees\n // Vectors from center to corners should be perpendicular and of equal length\n Point v1 = points[i] - center;\n Point v2 = otherPoints[0] - center;\n \n // Check if vectors are perpendicular (dot product = 0)\n if (v1.x * v2.x + v1.y * v2.y != 0) {\n continue;\n }\n \n // Check if vectors have the same length\n if (v1.x * v1.x + v1.y * v1.y != v2.x * v2.x + v2.y * v2.y) {\n continue;\n }\n \n // Check if all coordinates are integers and points are distinct\n bool allValid = true;\n for (const Point& p : points) {\n if (!isValidPoint(p.x, p.y)) {\n allValid = false;\n break;\n }\n }\n \n if (allValid) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n // Get all existing dots\n vector getAllDots() {\n vector dots;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (hasDot[x][y]) {\n dots.push_back(Point(x, y));\n }\n }\n }\n return dots;\n }\n \npublic:\n RectJoinSolver(int n, int m, const vector& initial) : N(n), M(m), initialDots(initial) {\n center = (N - 1) / 2;\n hasDot.assign(N, vector(N, false));\n \n // Mark initial dots\n for (const Point& p : initialDots) {\n hasDot[p.x][p.y] = true;\n }\n }\n \n void solve() {\n // Use priority queue to prioritize placing dots with higher weights\n priority_queue candidates;\n vector existingDots = getAllDots();\n \n // Add all possible candidate positions\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (!hasDot[x][y]) {\n double weight = getWeight(x, y);\n candidates.push(Candidate(Point(x, y), {}, weight));\n }\n }\n }\n \n bool madeProgress = true;\n while (madeProgress && !candidates.empty()) {\n madeProgress = false;\n vector remainingCandidates;\n \n // Try candidates in order of priority\n while (!candidates.empty()) {\n Candidate cand = candidates.top();\n candidates.pop();\n \n // Refresh existing dots (in case new dots were added)\n existingDots = getAllDots();\n \n // Try to find a valid rectangle for this candidate\n vector validPoints = findValidRectangle(cand.newPoint, existingDots);\n \n if (!validPoints.empty()) {\n // Found a valid rectangle, place the dot\n Point newDot = cand.newPoint;\n hasDot[newDot.x][newDot.y] = true;\n \n // Create rectangle to get edges\n Rectangle rect(newDot, validPoints[0], validPoints[1], validPoints[2]);\n \n // Add edges to drawn edges\n for (const Edge& edge : rect.edges) {\n drawnEdges.insert(edge);\n }\n \n // Record operation\n vector op = {newDot, validPoints[0], validPoints[1], validPoints[2]};\n vector opCoords;\n for (const Point& p : op) {\n opCoords.push_back(p.x);\n opCoords.push_back(p.y);\n }\n operations.push_back(op);\n \n // Refresh existing dots\n existingDots = getAllDots();\n \n // Add this point to all remaining candidates' existing dots\n madeProgress = true;\n break;\n } else {\n // Keep for next iteration\n remainingCandidates.push_back(cand);\n }\n }\n \n // If we made progress, rebuild the priority queue with updated weights\n if (madeProgress) {\n // Add back remaining candidates\n for (const Candidate& cand : remainingCandidates) {\n candidates.push(cand);\n }\n }\n }\n }\n \n void output() {\n cout << operations.size() << endl;\n for (const auto& op : operations) {\n for (int i = 0; i < 4; i++) {\n if (i > 0) cout << \" \";\n cout << op[i].x << \" \" << op[i].y;\n }\n cout << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n \n vector initialDots;\n for (int i = 0; i < M; i++) {\n int x, y;\n cin >> x >> y;\n initialDots.push_back(Point(x, y));\n }\n \n RectJoinSolver solver(N, M, initialDots);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\n\n// Directions: F=0 (forward/up), B=1 (backward/down), L=2 (left), R=3 (right)\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'F', 'B', 'L', 'R'};\n\nclass CandyBox {\nprivate:\n vector> grid;\n vector flavor_count;\n \npublic:\n CandyBox() : grid(N, vector(N, 0)), flavor_count(4, 0) {}\n \n // Place candy at position (calculated from 1-indexed empty cell number)\n void placeCandy(int pos, int flavor) {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == 0) {\n count++;\n if (count == pos) {\n grid[i][j] = flavor;\n flavor_count[flavor]++;\n return;\n }\n }\n }\n }\n }\n \n // Simulate tilting in a direction\n vector> simulateTilt(int dir) {\n vector> new_grid = grid;\n \n // Create movement order based on direction\n vector> cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (new_grid[i][j] != 0) {\n cells.push_back({i, j});\n }\n }\n }\n \n // Sort cells based on direction to process in correct order\n if (dir == 0) { // Forward (up): process from top to bottom\n sort(cells.begin(), cells.end());\n } else if (dir == 1) { // Backward (down): process from bottom to top\n sort(cells.begin(), cells.end(), greater>());\n } else if (dir == 2) { // Left: process from left to right\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second < b.second;\n return a.first < b.first;\n });\n } else { // Right: process from right to left\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second > b.second;\n return a.first < b.first;\n });\n }\n \n // Move each candy\n vector> temp_grid(N, vector(N, 0));\n for (auto& cell : cells) {\n int x = cell.first, y = cell.second;\n int flavor = new_grid[x][y];\n \n // Skip if already processed (moved)\n if (flavor == 0) continue;\n \n int nx = x, ny = y;\n while (true) {\n int tx = nx + dx[dir];\n int ty = ny + dy[dir];\n if (tx < 0 || tx >= N || ty < 0 || ty >= N || temp_grid[tx][ty] != 0) {\n break;\n }\n nx = tx;\n ny = ty;\n }\n temp_grid[nx][ny] = flavor;\n }\n \n return temp_grid;\n }\n \n // Calculate score for current grid state\n long long calculateScore() {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)flavor_count[i] * flavor_count[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Calculate score for a given grid state\n long long calculateScoreForGrid(const vector>& test_grid, const vector& test_counts) {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = test_grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && test_grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)test_counts[i] * test_counts[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Apply tilt to actual grid\n void applyTilt(int dir) {\n grid = simulateTilt(dir);\n }\n \n // Get current grid state\n vector> getGrid() const {\n return grid;\n }\n \n // Get flavor counts\n vector getFlavorCount() const {\n return flavor_count;\n }\n};\n\nint main() {\n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n CandyBox box;\n \n for (int t = 0; t < 100; t++) {\n int pos;\n cin >> pos;\n \n // Place the candy\n box.placeCandy(pos, flavors[t]);\n \n // If it's the last candy, we can choose any direction (it won't matter)\n if (t == 99) {\n cout << \"F\" << endl; // Arbitrary choice for last move\n cout.flush();\n continue;\n }\n \n // Try all 4 directions and pick the best\n long long best_score = -1;\n int best_dir = 0;\n \n vector current_counts = box.getFlavorCount();\n \n for (int dir = 0; dir < 4; dir++) {\n // Simulate tilt in this direction\n vector> test_grid = box.simulateTilt(dir);\n \n // Calculate score for this tilt\n long long score = box.calculateScoreForGrid(test_grid, current_counts);\n \n // Choose the direction with the highest score\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n // Apply the best tilt\n box.applyTilt(best_dir);\n \n // Output the direction\n cout << dir_char[best_dir] << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass Graph {\npublic:\n int N;\n vector> adj;\n \n Graph(int n) : N(n), adj(n, vector(n, false)) {}\n \n void add_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = true;\n adj[j][i] = true;\n }\n }\n \n void remove_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = false;\n adj[j][i] = false;\n }\n }\n \n bool has_edge(int i, int j) const {\n return adj[i][j];\n }\n \n string to_string() const {\n string s;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s += (adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n static Graph from_string(int n, const string& s) {\n Graph g(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (idx < s.length() && s[idx] == '1') {\n g.add_edge(i, j);\n }\n idx++;\n }\n }\n return g;\n }\n \n vector get_degree_sequence() const {\n vector degrees(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) degrees[i]++;\n }\n }\n sort(degrees.begin(), degrees.end());\n return degrees;\n }\n \n int count_edges() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) count++;\n }\n }\n return count;\n }\n \n int count_triangles() const {\n int triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n triangles++;\n }\n }\n }\n }\n }\n return triangles;\n }\n \n // Count number of 4-cycles\n int count_4cycles() const {\n int cycles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n for (int k = j + 1; k < N; k++) {\n for (int l = k + 1; l < N; l++) {\n if (adj[i][j] && adj[j][k] && adj[k][l] && adj[l][i] && \n !adj[i][k] && !adj[j][l]) {\n cycles++;\n }\n }\n }\n }\n }\n return cycles;\n }\n};\n\n// Features for graph classification\nstruct GraphFeatures {\n int edge_count;\n vector degree_sequence;\n int triangle_count;\n int four_cycle_count;\n double avg_degree;\n \n GraphFeatures(const Graph& g) {\n edge_count = g.count_edges();\n degree_sequence = g.get_degree_sequence();\n triangle_count = g.count_triangles();\n four_cycle_count = g.count_4cycles();\n avg_degree = 2.0 * edge_count / g.N;\n }\n};\n\n// Calculate distance between two feature sets\ndouble distance(const GraphFeatures& f1, const GraphFeatures& f2) {\n double d = 0.0;\n \n // Edge count difference\n d += abs(f1.edge_count - f2.edge_count) * 1.0;\n \n // Degree sequence difference (L1 distance)\n for (int i = 0; i < f1.degree_sequence.size(); i++) {\n d += abs(f1.degree_sequence[i] - f2.degree_sequence[i]) * 0.5;\n }\n \n // Triangle count difference\n d += abs(f1.triangle_count - f2.triangle_count) * 2.0;\n \n // 4-cycle count difference\n d += abs(f1.four_cycle_count - f2.four_cycle_count) * 3.0;\n \n return d;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Choose N based on M and epsilon\n int N = 30;\n if (M > 50 || epsilon > 0.2) {\n N = 40;\n }\n if (M > 80 || epsilon > 0.3) {\n N = 50;\n }\n if (epsilon < 0.1 && M < 30) {\n N = 20;\n }\n N = max(4, min(100, N));\n \n cout << N << endl;\n \n // Generate M graphs\n vector graphs;\n vector features;\n \n for (int k = 0; k < M; k++) {\n Graph g(N);\n \n // Base structure: different edge densities\n int base_edges = (k * N * (N - 1) / 2) / M;\n \n // Add edges in a structured way\n // Create different patterns: stars, cliques, paths, etc.\n \n if (k % 5 == 0) {\n // Star-like structure\n int center = k % N;\n for (int i = 0; i < min(N-1, base_edges); i++) {\n if ((center + i + 1) % N != center) {\n g.add_edge(center, (center + i + 1) % N);\n }\n }\n } else if (k % 5 == 1) {\n // Path-like structure\n for (int i = 0; i < min(N-1, base_edges); i++) {\n g.add_edge(i % N, (i + 1) % N);\n }\n } else if (k % 5 == 2) {\n // Cycle structure\n for (int i = 0; i < min(N, base_edges); i++) {\n g.add_edge(i % N, (i + 1) % N);\n }\n } else if (k % 5 == 3) {\n // Clique structure (complete subgraph)\n int clique_size = min(N, (int)sqrt(2 * base_edges) + 1);\n for (int i = 0; i < clique_size; i++) {\n for (int j = i + 1; j < clique_size; j++) {\n if (g.count_edges() < base_edges) {\n g.add_edge(i, j);\n }\n }\n }\n } else {\n // Random structure with controlled density\n vector> possible_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n possible_edges.push_back({i, j});\n }\n }\n \n // Shuffle and take first base_edges\n mt19937 rng(k * 12345 + 6789);\n shuffle(possible_edges.begin(), possible_edges.end(), rng);\n \n for (int i = 0; i < min((int)possible_edges.size(), base_edges); i++) {\n g.add_edge(possible_edges[i].first, possible_edges[i].second);\n }\n }\n \n // Add some additional structure for robustness\n // Create some cliques or specific patterns\n int pattern = k % 7;\n if (pattern == 0 && N >= 3) {\n // Add a triangle\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n } else if (pattern == 1 && N >= 4) {\n // Add a square\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 3);\n g.add_edge(3, 0);\n } else if (pattern == 2 && N >= 4) {\n // Add a star\n for (int i = 1; i < min(4, N); i++) {\n g.add_edge(0, i);\n }\n } else if (pattern == 3 && N >= 5) {\n // Add a 5-cycle\n for (int i = 0; i < min(5, N); i++) {\n g.add_edge(i, (i + 1) % min(5, N));\n }\n } else if (pattern == 4 && N >= 3) {\n // Add a path of 3\n for (int i = 0; i < min(3, N - 1); i++) {\n g.add_edge(i, i + 1);\n }\n } else if (pattern == 5 && N >= 4) {\n // Add a complete graph on 4 vertices\n for (int i = 0; i < min(4, N); i++) {\n for (int j = i + 1; j < min(4, N); j++) {\n g.add_edge(i, j);\n }\n }\n }\n \n // Store graph and its features\n graphs.push_back(g);\n features.push_back(GraphFeatures(g));\n \n // Output graph\n cout << g.to_string() << endl;\n cout.flush();\n }\n \n // Process 100 queries\n for (int k = 0; k < 100; k++) {\n string h_str;\n cin >> h_str;\n \n // Parse the graph\n Graph h = Graph::from_string(N, h_str);\n GraphFeatures h_features(h);\n \n // Find the closest graph\n int best_idx = 0;\n double min_dist = 1e9;\n \n for (int i = 0; i < M; i++) {\n double dist = distance(h_features, features[i]);\n if (dist < min_dist) {\n min_dist = dist;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Graph representation\nstruct Edge {\n int u, v, w, id;\n Edge(int u = 0, int v = 0, int w = 0, int id = 0) : u(u), v(v), w(w), id(id) {}\n};\n\nclass Graph {\npublic:\n int n, m, d, k;\n vector edges;\n vector>> adj; // adjacency list: to, weight\n vector> coords;\n \n Graph(int n = 0, int m = 0, int d = 0, int k = 0) : n(n), m(m), d(d), k(k) {\n adj.resize(n + 1);\n }\n \n void addEdge(int u, int v, int w, int id) {\n edges.emplace_back(u, v, w, id);\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n // Calculate shortest distances from source using Dijkstra\n vector dijkstra(int source) {\n vector dist(n + 1, 1e18);\n priority_queue, vector>, greater>> pq;\n \n dist[source] = 0;\n pq.emplace(0, source);\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto [v, w] : adj[u]) {\n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.emplace(dist[v], v);\n }\n }\n }\n \n return dist;\n }\n \n // Calculate all pairs shortest paths\n vector> allPairsShortestPaths() {\n vector> apsp(n + 1, vector(n + 1, 1e18));\n \n for (int i = 1; i <= n; i++) {\n auto dist = dijkstra(i);\n for (int j = 1; j <= n; j++) {\n apsp[i][j] = dist[j];\n }\n }\n \n return apsp;\n }\n \n // Calculate frustration for a given day (set of edge IDs to remove)\n double calculateFrustration(const vector>& original_apsp, const vector& edges_to_remove) {\n // Create a temporary graph without the edges to remove\n vector>> temp_adj = adj;\n \n // Remove edges\n unordered_set remove_set(edges_to_remove.begin(), edges_to_remove.end());\n for (int eid : edges_to_remove) {\n Edge& e = edges[eid];\n // Remove edge e.u - e.v\n for (auto it = temp_adj[e.u].begin(); it != temp_adj[e.u].end(); ++it) {\n if (it->first == e.v && it->second == e.w) {\n temp_adj[e.u].erase(it);\n break;\n }\n }\n for (auto it = temp_adj[e.v].begin(); it != temp_adj[e.v].end(); ++it) {\n if (it->first == e.u && it->second == e.w) {\n temp_adj[e.v].erase(it);\n break;\n }\n }\n }\n \n // Calculate sum of distance increases\n double frustration = 0.0;\n int unreachable_count = 0;\n \n for (int i = 1; i <= n; i++) {\n // Dijkstra from i in the modified graph\n vector dist(n + 1, 1e18);\n priority_queue, vector>, greater>> pq;\n \n dist[i] = 0;\n pq.emplace(0, i);\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto [v, w] : temp_adj[u]) {\n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.emplace(dist[v], v);\n }\n }\n }\n \n // Calculate frustration for source i\n for (int j = 1; j <= n; j++) {\n if (i == j) continue;\n \n long long new_dist = dist[j];\n if (new_dist >= 1e18) {\n new_dist = 1000000000; // Unreachable\n unreachable_count++;\n }\n \n long long orig_dist = original_apsp[i][j];\n if (orig_dist >= 1e18) orig_dist = 1000000000;\n \n frustration += (new_dist - orig_dist);\n }\n }\n \n // Average frustration\n frustration /= (n * (n - 1.0));\n \n return frustration;\n }\n};\n\n// Solution representation\nstruct Solution {\n vector schedule; // schedule[i] = day for edge i (1-indexed days)\n double total_frustration;\n Graph* graph;\n vector> original_apsp;\n \n Solution(Graph* g, const vector>& apsp) : graph(g), original_apsp(apsp) {\n schedule.resize(g->m);\n total_frustration = 0.0;\n }\n \n // Calculate total frustration for the entire schedule\n double calculateTotalFrustration() {\n double total = 0.0;\n \n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate frustration for each day\n for (int day = 1; day <= graph->d; day++) {\n double day_frustration = graph->calculateFrustration(original_apsp, edges_by_day[day]);\n total += day_frustration;\n }\n \n total_frustration = total / graph->d;\n return total_frustration;\n }\n \n // Get frustration as integer (rounded)\n long long getScore() {\n return llround(1000.0 * total_frustration);\n }\n};\n\n// Calculate edge betweenness centrality approximation\nvector calculateEdgeBetweenness(Graph& graph) {\n vector betweenness(graph.m, 0.0);\n \n // Sample a subset of vertices for efficiency\n vector sources;\n int sample_size = min(50, graph.n);\n for (int i = 1; i <= sample_size; i++) {\n sources.push_back(i);\n }\n \n // For each source, run Dijkstra and count edge usage\n for (int source : sources) {\n vector dist = graph.dijkstra(source);\n vector> prev(graph.n + 1); // predecessors for shortest paths\n \n // Build shortest path DAG\n for (int u = 1; u <= graph.n; u++) {\n if (dist[u] == 1e18) continue;\n for (auto [v, w] : graph.adj[u]) {\n if (dist[u] + w == dist[v]) {\n prev[v].push_back(u);\n }\n }\n }\n \n // Calculate dependencies (simplified betweenness)\n vector dependency(graph.n + 1, 0.0);\n vector order;\n for (int i = 1; i <= graph.n; i++) {\n if (dist[i] < 1e18) {\n order.push_back(i);\n }\n }\n \n // Sort by distance (for processing from farthest to nearest)\n sort(order.begin(), order.end(), [&](int a, int b) {\n return dist[a] > dist[b];\n });\n \n for (int u : order) {\n if (u == source) continue;\n \n // Distribute dependency to predecessors\n double share = (1.0 + dependency[u]) / prev[u].size();\n for (int p : prev[u]) {\n dependency[p] += share;\n \n // Find the edge between p and u and update betweenness\n for (int eid = 0; eid < graph.m; eid++) {\n Edge& e = graph.edges[eid];\n if ((e.u == p && e.v == u) || (e.u == u && e.v == p)) {\n betweenness[eid] += share;\n break;\n }\n }\n }\n }\n }\n \n return betweenness;\n}\n\n// Simulated annealing to improve solution\nvoid simulatedAnnealing(Solution& solution) {\n auto start_time = chrono::steady_clock::now();\n double temp = 1000.0;\n double cooling_rate = 0.995;\n int iterations = 0;\n int max_iterations = 50000;\n \n double current_score = solution.calculateTotalFrustration();\n \n // Random number generator\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> day_dist(1, solution.graph->d);\n uniform_int_distribution<> edge_dist(0, solution.graph->m - 1);\n uniform_real_distribution<> prob_dist(0.0, 1.0);\n \n while (iterations < max_iterations) {\n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n if (elapsed > 5000) break; // Leave 1 second for final output\n \n // Generate a neighbor by swapping two edges between days\n int idx1 = edge_dist(gen);\n int idx2 = edge_dist(gen);\n \n int old_day1 = solution.schedule[idx1];\n int old_day2 = solution.schedule[idx2];\n \n // Try different types of moves\n int new_day1, new_day2;\n \n if (prob_dist(gen) < 0.7) {\n // Swap the days of two edges\n new_day1 = old_day2;\n new_day2 = old_day1;\n } else {\n // Move one edge to a random day\n new_day1 = day_dist(gen);\n new_day2 = old_day2;\n }\n \n // Check constraints (at most K edges per day)\n vector count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1) continue;\n if (i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n bool valid = true;\n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n iterations++;\n continue;\n }\n \n // Make the move\n int save1 = solution.schedule[idx1];\n int save2 = solution.schedule[idx2];\n solution.schedule[idx1] = new_day1;\n solution.schedule[idx2] = new_day2;\n \n // Calculate new score\n double new_score = solution.calculateTotalFrustration();\n \n // Accept or reject the move\n double delta = new_score - current_score;\n double acceptance_prob = exp(-delta / temp);\n \n if (delta < 0 || prob_dist(gen) < acceptance_prob) {\n current_score = new_score;\n } else {\n // Revert the move\n solution.schedule[idx1] = save1;\n solution.schedule[idx2] = save2;\n }\n \n // Cool down\n temp *= cooling_rate;\n iterations++;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m, d, k;\n cin >> n >> m >> d >> k;\n \n Graph graph(n, m, d, k);\n \n // Read edges\n for (int i = 0; i < m; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n graph.addEdge(u, v, w, i);\n }\n \n // Read coordinates (we may not use them)\n for (int i = 0; i < n; i++) {\n int x, y;\n cin >> x >> y;\n graph.coords.emplace_back(x, y);\n }\n \n // Calculate original all pairs shortest paths\n auto start_time = chrono::steady_clock::now();\n auto original_apsp = graph.allPairsShortestPaths();\n \n // Calculate edge betweenness (importance)\n auto betweenness = calculateEdgeBetweenness(graph);\n \n // Create initial solution using edge betweenness\n vector> edge_importance;\n for (int i = 0; i < m; i++) {\n edge_importance.emplace_back(betweenness[i], i);\n }\n \n // Sort by importance (descending)\n sort(edge_importance.rbegin(), edge_importance.rend());\n \n Solution solution(&graph, original_apsp);\n \n // Greedy scheduling: distribute important edges across different days\n vector day_count(d + 1, 0);\n \n for (int i = 0; i < m; i++) {\n int edge_id = edge_importance[i].second;\n \n // Find the day with minimum edges scheduled (and not exceeding K)\n int best_day = 1;\n for (int day = 1; day <= d; day++) {\n if (day_count[day] < day_count[best_day]) {\n best_day = day;\n }\n }\n \n // If all days are equal, choose randomly among days with minimum count\n vector candidates;\n int min_count = day_count[best_day];\n for (int day = 1; day <= d; day++) {\n if (day_count[day] == min_count && day_count[day] < k) {\n candidates.push_back(day);\n }\n }\n \n if (!candidates.empty()) {\n best_day = candidates[0];\n if (candidates.size() > 1) {\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> dist(0, candidates.size() - 1);\n best_day = candidates[dist(gen)];\n }\n }\n \n solution.schedule[edge_id] = best_day;\n day_count[best_day]++;\n }\n \n // Refine with simulated annealing\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n \n if (elapsed < 4000) { // Only run SA if we have enough time\n simulatedAnnealing(solution);\n }\n \n // Output the solution\n for (int i = 0; i < m; i++) {\n if (i > 0) cout << \" \";\n cout << solution.schedule[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y, z;\n Point(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(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 bool operator==(const Point& other) const {\n return x == other.x && y == other.y && z == other.z;\n }\n};\n\n// Directions for 6-connected (face-to-face) polycubes\nconst int dx[6] = {1, -1, 0, 0, 0, 0};\nconst int dy[6] = {0, 0, 1, -1, 0, 0};\nconst int dz[6] = {0, 0, 0, 0, 1, -1};\n\nint D;\nvector f1, r1, f2, r2;\n\n// Check if a point is within bounds\nbool inBounds(const Point& p) {\n return p.x >= 0 && p.x < D && p.y >= 0 && p.y < D && p.z >= 0 && p.z < D;\n}\n\n// Get neighbors of a point (6-connected)\nvector getNeighbors(const Point& p) {\n vector neighbors;\n for (int i = 0; i < 6; i++) {\n Point np(p.x + dx[i], p.y + dy[i], p.z + dz[i]);\n if (inBounds(np)) {\n neighbors.push_back(np);\n }\n }\n return neighbors;\n}\n\n// Convert 3D coordinates to 1D index\nint toIndex(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\n// Convert 1D index to 3D coordinates\nPoint fromIndex(int idx) {\n int x = idx / (D * D);\n int y = (idx % (D * D)) / D;\n int z = idx % D;\n return Point(x, y, z);\n}\n\n// Main solution\nint main() {\n // Read input\n cin >> D;\n f1.resize(D);\n r1.resize(D);\n f2.resize(D);\n r2.resize(D);\n \n for (int i = 0; i < D; i++) {\n cin >> f1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> f2[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r2[i];\n }\n \n // Determine which positions must be filled for each arrangement\n vector>> mustFill1(D, vector>(D, vector(D, false)));\n vector>> mustFill2(D, vector>(D, vector(D, false)));\n \n // For first silhouette pair\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f1[z][x] == '1' && r1[z][y] == '1') {\n mustFill1[x][y][z] = true;\n }\n }\n }\n }\n \n // For second silhouette pair\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f2[z][x] == '1' && r2[z][y] == '1') {\n mustFill2[x][y][z] = true;\n }\n }\n }\n }\n \n // Count total positions needed for each arrangement\n int count1 = 0, count2 = 0;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z]) count1++;\n if (mustFill2[x][y][z]) count2++;\n }\n }\n }\n \n // Create blocks - simple approach: one block per position at first\n vector> blocks1(D * D * D, vector(0));\n vector> blocks2(D * D * D, vector(0));\n \n // We'll assign blocks greedily, trying to merge positions that appear in both arrangements\n vector blockId1(D * D * D, 0);\n vector blockId2(D * D * D, 0);\n \n // First, handle positions that are in both arrangements\n vector commonPositions;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && mustFill2[x][y][z]) {\n commonPositions.push_back(Point(x, y, z));\n }\n }\n }\n }\n \n // Create blocks for common positions\n int blockCount = 0;\n vector> commonBlocks;\n \n // Group common positions into connected blocks\n vector>> visited(D, vector>(D, vector(D, false)));\n \n for (const Point& p : commonPositions) {\n if (visited[p.x][p.y][p.z]) continue;\n \n // BFS to find connected component\n vector component;\n queue q;\n q.push(p);\n visited[p.x][p.y][p.z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n // Check all 6-connected neighbors that are also common positions\n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (!visited[neighbor.x][neighbor.y][neighbor.z] && \n mustFill1[neighbor.x][neighbor.y][neighbor.z] && \n mustFill2[neighbor.x][neighbor.y][neighbor.z]) {\n visited[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n commonBlocks.push_back(component);\n blockCount++;\n }\n }\n \n // Assign block IDs to common positions\n for (int i = 0; i < commonBlocks.size(); i++) {\n for (const Point& p : commonBlocks[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId1[idx] = i + 1; // Blocks are 1-indexed\n blockId2[idx] = i + 1;\n }\n }\n \n // Handle positions that are only in arrangement 1\n int currentBlock = blockCount;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && !mustFill2[x][y][z] && blockId1[toIndex(x, y, z)] == 0) {\n // Try to merge with adjacent blocks if possible\n bool merged = false;\n vector neighbors = getNeighbors(Point(x, y, z));\n \n for (const Point& neighbor : neighbors) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (mustFill1[neighbor.x][neighbor.y][neighbor.z] && blockId1[nidx] != 0) {\n blockId1[toIndex(x, y, z)] = blockId1[nidx];\n merged = true;\n break;\n }\n }\n \n if (!merged) {\n currentBlock++;\n blockId1[toIndex(x, y, z)] = currentBlock;\n }\n }\n }\n }\n }\n \n // Handle positions that are only in arrangement 2\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill2[x][y][z] && !mustFill1[x][y][z] && blockId2[toIndex(x, y, z)] == 0) {\n // Try to merge with adjacent blocks if possible\n bool merged = false;\n vector neighbors = getNeighbors(Point(x, y, z));\n \n for (const Point& neighbor : neighbors) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (mustFill2[neighbor.x][neighbor.y][neighbor.z] && blockId2[nidx] != 0) {\n blockId2[toIndex(x, y, z)] = blockId2[nidx];\n merged = true;\n break;\n }\n }\n \n if (!merged) {\n currentBlock++;\n blockId2[toIndex(x, y, z)] = currentBlock;\n }\n }\n }\n }\n }\n \n // Output\n cout << currentBlock << endl;\n \n // Output first arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << blockId1[i];\n }\n cout << endl;\n \n // Output second arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << blockId2[i];\n }\n cout << endl;\n \n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef long long ll;\n\nstruct Point {\n ll x, y;\n Point(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\nll distance_squared(const Point& a, const Point& b) {\n ll dx = a.x - b.x;\n ll dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\nll distance_rounded(const Point& a, const Point& b) {\n return round(sqrt(distance_squared(a, b)));\n}\n\nstruct Edge {\n int u, v;\n ll weight;\n Edge(int u = 0, int v = 0, ll weight = 0) : u(u), v(v), weight(weight) {}\n};\n\nstruct Resident {\n ll x, y;\n Resident(ll x = 0, ll y = 0) : x(x), y(x == 0 ? y : y) {}\n};\n\n// Union-Find for MST\nstruct UnionFind {\n vector parent, rank;\n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) parent[x] = y;\n else {\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n }\n bool same(int x, int y) {\n return find(x) == find(y);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n cin >> N >> M >> K;\n \n vector stations(N + 1);\n for (int i = 1; i <= N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M + 1);\n for (int j = 1; j <= M; ++j) {\n cin >> edges[j].u >> edges[j].v >> edges[j].weight;\n }\n \n vector residents(K + 1);\n for (int k = 1; k <= K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // For each resident, find the minimum radius needed from each station\n vector> minRadius(N + 1, vector(K + 1));\n for (int i = 1; i <= N; ++i) {\n for (int k = 1; k <= K; ++k) {\n minRadius[i][k] = distance_rounded(\n Point(stations[i].x, stations[i].y), \n Point(residents[k].x, residents[k].y)\n );\n }\n }\n \n // Output strengths for each station (initially 0)\n vector P(N + 1, 0);\n \n // Edge power status (0 = OFF, 1 = ON)\n vector B(M + 1, 0);\n \n // Step 1: Find which stations should be activated\n // For each resident, find the closest station\n vector closestStation(K + 1);\n vector closestDistance(K + 1);\n for (int k = 1; k <= K; ++k) {\n closestDistance[k] = LLONG_MAX;\n for (int i = 1; i <= N; ++i) {\n if (minRadius[i][k] < closestDistance[k]) {\n closestDistance[k] = minRadius[i][k];\n closestStation[k] = i;\n }\n }\n }\n \n // Stations that need to be activated (at least the ones covering residents)\n vector stationNeeded(N + 1, false);\n for (int k = 1; k <= K; ++k) {\n stationNeeded[closestStation[k]] = true;\n // Set P_i to at least the distance needed to cover its closest resident\n P[closestStation[k]] = max(P[closestStation[k]], closestDistance[k]);\n }\n \n // Ensure station 1 is activated (it's the source)\n stationNeeded[1] = true;\n \n // Step 2: Connect all needed stations to station 1 using MST approach\n // Collect all edges that connect stations we need\n vector>> weightedEdges;\n for (int j = 1; j <= M; ++j) {\n int u = edges[j].u;\n int v = edges[j].v;\n ll w = edges[j].weight;\n \n // Add edge if it connects two stations we might need\n weightedEdges.push_back({w, {u, v}});\n }\n \n // Sort edges by weight\n sort(weightedEdges.begin(), weightedEdges.end());\n \n // Use Union-Find to build MST\n UnionFind uf(N + 1);\n vector stationInTree(N + 1, false);\n stationInTree[1] = true; // Station 1 is always in the tree\n \n // First, ensure all needed stations are connected\n for (int i = 1; i <= N; ++i) {\n if (stationNeeded[i]) {\n stationInTree[i] = true;\n }\n }\n \n // Connect stations using MST\n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n // If both stations are needed or one is in tree and other is needed\n if ((stationInTree[u] && stationNeeded[v]) || \n (stationInTree[v] && stationNeeded[u]) ||\n (stationInTree[u] && stationInTree[v])) {\n if (!uf.same(u, v)) {\n uf.unite(u, v);\n stationInTree[u] = true;\n stationInTree[v] = true;\n \n // Find which edge index this corresponds to\n for (int j = 1; j <= M; ++j) {\n if ((edges[j].u == u && edges[j].v == v) || \n (edges[j].u == v && edges[j].v == u)) {\n B[j] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Make sure station 1 is connected to all activated stations\n // If not, we need to add more edges\n for (int i = 2; i <= N; ++i) {\n if (stationInTree[i] && !uf.same(1, i)) {\n // Find the cheapest edge to connect i to the tree\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (int j = 1; j <= M; ++j) {\n int u = edges[j].u;\n int v = edges[j].v;\n ll w = edges[j].weight;\n \n if ((u == i && stationInTree[v] && uf.same(1, v)) ||\n (v == i && stationInTree[u] && uf.same(1, u))) {\n if (w < minCost) {\n minCost = w;\n bestEdge = j;\n }\n }\n }\n \n if (bestEdge != -1) {\n B[bestEdge] = 1;\n int u = edges[bestEdge].u;\n int v = edges[bestEdge].v;\n uf.unite(u, v);\n }\n }\n }\n \n // Step 3: Optimize output strengths\n // For each station, set P_i to the minimum radius needed to cover all residents \n // that are closest to it or could be efficiently covered by it\n vector> residentsCoveredByStation(N + 1);\n for (int k = 1; k <= K; ++k) {\n residentsCoveredByStation[closestStation[k]].push_back(k);\n }\n \n // Adjust P_i values: for each station, set to max distance to residents it covers\n for (int i = 1; i <= N; ++i) {\n if (!stationInTree[i]) {\n P[i] = 0; // Don't waste power on stations not in the tree\n continue;\n }\n \n ll maxRadius = 0;\n for (int k = 1; k <= K; ++k) {\n // Check if this station can cover this resident with a reasonable radius\n // We'll assign residents to stations that can cover them efficiently\n ll d = minRadius[i][k];\n if (d <= 5000) { // Within maximum allowed radius\n // Check if this station is the most efficient one to cover this resident\n // (considering both distance and whether station is activated)\n bool shouldCover = false;\n if (closestStation[k] == i) {\n shouldCover = true;\n } else {\n // Consider if it's more efficient for this station to cover the resident\n // instead of the currently assigned station\n int currentStation = closestStation[k];\n if (stationInTree[currentStation]) {\n // Compare costs\n ll currentCost = P[currentStation] * P[currentStation];\n ll newCost = d * d;\n if (d < P[i] && newCost < currentCost / 2) {\n // This is a simplification - in practice, we'd need to consider\n // the global optimization\n shouldCover = true;\n }\n }\n }\n \n if (shouldCover) {\n maxRadius = max(maxRadius, d);\n }\n }\n }\n P[i] = maxRadius;\n }\n \n // Final verification and adjustment: ensure all residents are covered\n vector residentCovered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (stationInTree[i] && minRadius[i][k] <= P[i]) {\n residentCovered[k] = true;\n break;\n }\n }\n }\n \n // If any resident is not covered, increase P_i for the closest station in the tree\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered[k]) {\n ll minDist = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (stationInTree[i] && minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n \n if (bestStation != -1) {\n P[bestStation] = max(P[bestStation], minDist);\n }\n }\n }\n \n // Output the solution\n for (int i = 1; i <= N; ++i) {\n if (i > 1) cout << \" \";\n cout << P[i];\n }\n cout << endl;\n \n for (int j = 1; j <= M; ++j) {\n if (j > 1) cout << \" \";\n cout << B[j];\n }\n cout << endl;\n \n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_OPS = 10000;\n\n// Pyramid representation\nvector> pyramid;\nvector> target_pos; // target_pos[value] = {x, y}\n\n// Directions for adjacent positions (6 directions)\nvector> dirs = {\n {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}\n};\n\n// Check if coordinates are valid\nbool valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\n// Get the value at position (x, y)\nint get_value(int x, int y) {\n if (!valid(x, y)) return -1;\n return pyramid[x][y];\n}\n\n// Find position of a value\npair find_position(int value) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n if (pyramid[i][j] == value) {\n return {i, j};\n }\n }\n }\n return {-1, -1};\n}\n\n// Check if swap is valid (adjacent in 6 directions)\nbool can_swap(int x1, int y1, int x2, int y2) {\n if (!valid(x1, y1) || !valid(x2, y2)) return false;\n \n for (auto& dir : dirs) {\n int nx = x1 + dir.first;\n int ny = y1 + dir.second;\n if (nx == x2 && ny == y2) {\n return true;\n }\n }\n return false;\n}\n\n// Perform swap and record operation\nvoid perform_swap(int x1, int y1, int x2, int y2, vector>& ops) {\n if (!can_swap(x1, y1, x2, y2)) {\n // This shouldn't happen in correct implementation\n return;\n }\n \n swap(pyramid[x1][y1], pyramid[x2][y2]);\n ops.push_back({x1, y1, x2, y2});\n}\n\n// Count violations\nint count_violations() {\n int violations = 0;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current > left_child) violations++;\n if (current > right_child) violations++;\n }\n }\n return violations;\n}\n\n// Find shortest path to move a ball from (sx, sy) to (tx, ty) using BFS\nvector> find_path(int sx, int sy, int tx, int ty) {\n if (sx == tx && sy == ty) return {};\n \n vector> visited(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n \n q.push({sx, sy});\n visited[sx][sy] = true;\n \n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n \n if (x == tx && y == ty) {\n // Reconstruct path\n vector> path;\n pair curr = {tx, ty};\n while (curr != make_pair(sx, sy)) {\n path.push_back(curr);\n curr = parent[curr.first][curr.second];\n }\n reverse(path.begin(), path.end());\n return path;\n }\n \n // Try all 6 directions\n for (auto& dir : dirs) {\n int nx = x + dir.first;\n int ny = y + dir.second;\n \n if (valid(nx, ny) && !visited[nx][ny]) {\n visited[nx][ny] = true;\n parent[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n \n return {}; // No path found (shouldn't happen)\n}\n\n// Move a ball from its current position to target position\nvoid move_ball_to(int value, int tx, int ty, vector>& ops) {\n auto [sx, sy] = find_position(value);\n if (sx == tx && sy == ty) return;\n \n auto path = find_path(sx, sy, tx, ty);\n if (path.empty()) return;\n \n int cx = sx, cy = sy;\n for (auto [nx, ny] : path) {\n if (ops.size() >= MAX_OPS) break;\n perform_swap(cx, cy, nx, ny, ops);\n cx = nx;\n cy = ny;\n }\n}\n\n// Main solution\nvoid solve() {\n // Read input\n pyramid.resize(N);\n for (int i = 0; i < N; i++) {\n pyramid[i].resize(i + 1);\n for (int j = 0; j <= i; j++) {\n cin >> pyramid[i][j];\n }\n }\n \n vector> operations;\n \n // Strategy: Bottom-up approach\n // Start from the top and ensure each position has appropriate value\n \n // We'll use a priority approach - smaller values should be higher\n // Create a list of all values with their ideal positions (based on sorting)\n vector>> ideal_positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n // The \"ideal\" value for position (i,j) would be based on level\n // Smaller values should be at higher levels\n ideal_positions.push_back({i * 1000 + j, {i, j}});\n }\n }\n \n // Sort by level (and then by position within level)\n sort(ideal_positions.begin(), ideal_positions.end());\n \n // Create target mapping - what value should go where\n // We want smaller values at top, so assign values 0,1,2,... to positions in order\n vector target_values;\n for (int i = 0; i < N * (N + 1) / 2; i++) {\n target_values.push_back(i);\n }\n \n // Assign target positions for each value\n target_pos.resize(465);\n for (int i = 0; i < ideal_positions.size(); i++) {\n int value = target_values[i];\n auto [x, y] = ideal_positions[i].second;\n target_pos[value] = {x, y};\n }\n \n // Now, try to place the smallest values at the top\n // Process positions from top to bottom\n for (int level = 0; level < N && operations.size() < MAX_OPS; level++) {\n for (int pos = 0; pos <= level && operations.size() < MAX_OPS; pos++) {\n // The ideal value for this position should be relatively small\n // We'll say the first (level*(level+1)/2 + pos) smallest values should be in the first levels\n int ideal_rank = (level * (level + 1)) / 2 + pos;\n int ideal_value = ideal_rank;\n \n // If the current value is much larger than ideal, try to replace it\n int current_value = pyramid[level][pos];\n \n // If current value is reasonable, leave it\n if (current_value <= ideal_value + 20) {\n continue;\n }\n \n // Find a better value to put here\n for (int candidate_value = 0; candidate_value < min(ideal_value + 10, 465) && operations.size() < MAX_OPS; candidate_value++) {\n if (candidate_value == current_value) continue;\n \n auto [cx, cy] = find_position(candidate_value);\n if (cx == level && cy == pos) continue; // Already here\n \n // Check if this candidate is in a position where we want a larger value\n int candidate_ideal_rank = (cx * (cx + 1)) / 2 + cy;\n if (candidate_value >= candidate_ideal_rank - 10) {\n // This candidate is in a reasonable position, don't move it\n continue;\n }\n \n // Move candidate to current position\n if (operations.size() < MAX_OPS) {\n move_ball_to(candidate_value, level, pos, operations);\n }\n break;\n }\n }\n }\n \n // Now fix violations from bottom up\n for (int level = N - 2; level >= 0 && operations.size() < MAX_OPS; level--) {\n for (int pos = 0; pos <= level && operations.size() < MAX_OPS; pos++) {\n int current_value = pyramid[level][pos];\n int left_child = pyramid[level + 1][pos];\n int right_child = pyramid[level + 1][pos + 1];\n \n // If violation exists, try to fix it\n if (current_value > left_child || current_value > right_child) {\n // Find the smaller of the two children\n int smaller_child = min(left_child, right_child);\n int smaller_child_pos = (left_child <= right_child) ? pos : pos + 1;\n \n // If current value is larger than smaller child, swap them\n if (current_value > smaller_child && operations.size() < MAX_OPS) {\n perform_swap(level, pos, level + 1, smaller_child_pos, operations);\n }\n }\n }\n }\n \n // Additional passes to fix remaining violations\n for (int pass = 0; pass < 3 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n for (int level = N - 2; level >= 0 && operations.size() < MAX_OPS; level--) {\n for (int pos = 0; pos <= level && operations.size() < MAX_OPS; pos++) {\n int current_value = pyramid[level][pos];\n int left_child = pyramid[level + 1][pos];\n int right_child = pyramid[level + 1][pos + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_pos = (left_child <= right_child) ? pos : pos + 1;\n \n if (current_value > smaller_child && operations.size() < MAX_OPS) {\n perform_swap(level, pos, level + 1, smaller_child_pos, operations);\n changed = true;\n }\n }\n }\n }\n if (!changed) break;\n }\n \n // Output operations\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << op[0] << \" \" << op[1] << \" \" << op[2] << \" \" << op[3] << endl;\n }\n}\n\nint main() {\n solve();\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nconst int entrance_i = 0, entrance_j = 4;\n\n// Directions for 4-connectivity\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n};\n\nclass Warehouse {\nprivate:\n vector> grid; // -1: empty, -2: obstacle, -3: entrance, >=0: container number\n vector> obstacles;\n int N;\n map container_positions; // Map from position to container number\n \npublic:\n Warehouse(int n) : N(n) {\n grid.assign(D, vector(D, -1));\n obstacles.assign(D, vector(D, false));\n // Mark entrance\n grid[entrance_i][entrance_j] = -3;\n }\n \n void add_obstacle(int i, int j) {\n obstacles[i][j] = true;\n grid[i][j] = -2;\n }\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < D && j >= 0 && j < D;\n }\n \n bool is_empty(int i, int j) {\n return is_valid(i, j) && grid[i][j] == -1 && !obstacles[i][j] && !(i == entrance_i && j == entrance_j);\n }\n \n // BFS to find all reachable empty positions from entrance\n vector get_reachable_empty_positions() {\n vector> visited(D, vector(D, false));\n queue q;\n vector reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n // Check 4 adjacent squares\n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] == -1) { // Empty square\n reachable.push_back(Position(ni, nj));\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] >= 0) { // Container square - can traverse through it for reachability\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Calculate Manhattan distance from entrance\n int distance_from_entrance(int i, int j) {\n return abs(i - entrance_i) + abs(j - entrance_j);\n }\n \n // Estimate how many positions would become unreachable if we place a container at (i,j)\n int blocking_score(int i, int j) {\n if (!is_empty(i, j)) return INT_MAX;\n \n // Temporarily place a container here\n int original = grid[i][j];\n grid[i][j] = 999; // Temporary container\n \n // Count reachable positions\n vector reachable = get_reachable_empty_positions();\n int reachable_count = reachable.size();\n \n // Restore\n grid[i][j] = original;\n \n // Higher score means more blocking (worse)\n return (D*D - 1 - N - reachable_count);\n }\n \n // Place container with number t at position (i, j)\n void place_container(int t, int i, int j) {\n grid[i][j] = t;\n container_positions[Position(i, j)] = t;\n }\n \n // Get all currently reachable containers\n vector> get_reachable_containers() {\n vector> visited(D, vector(D, false));\n queue q;\n vector> reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] >= 0) { // Container\n reachable.push_back({Position(ni, nj), grid[ni][nj]});\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] == -1) { // Empty\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Get all containers sorted by their numbers\n vector> get_all_containers_sorted() {\n vector> containers;\n for (auto& p : container_positions) {\n containers.push_back({p.first, p.second});\n }\n sort(containers.begin(), containers.end(), [](const auto& a, const auto& b) {\n return a.second < b.second;\n });\n return containers;\n }\n};\n\nint main() {\n int N;\n cin >> D >> N; // Note: D is always 9 per problem statement\n \n Warehouse warehouse(N);\n \n // Read obstacles\n for (int i = 0; i < N; i++) {\n int ri, rj;\n cin >> ri >> rj;\n warehouse.add_obstacle(ri, rj);\n }\n \n vector arrived_containers;\n vector> placement_positions; // Store where each container was placed\n \n // Process each incoming container\n for (int d = 0; d < D*D - 1 - N; d++) {\n int t;\n cin >> t;\n arrived_containers.push_back(t);\n \n // Get all reachable empty positions\n vector reachable = warehouse.get_reachable_empty_positions();\n \n if (reachable.empty()) {\n // This shouldn't happen according to problem constraints\n // Just pick any empty position\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (warehouse.is_empty(i, j)) {\n cout << i << \" \" << j << endl;\n warehouse.place_container(t, i, j);\n placement_positions.push_back({i, j});\n goto placed;\n }\n }\n }\n }\n \n // Calculate statistics for decision making\n double avg_so_far = 0.0;\n if (d > 0) {\n for (int i = 0; i < d; i++) {\n avg_so_far += arrived_containers[i];\n }\n avg_so_far /= d;\n }\n \n // Score each reachable position\n vector> position_scores;\n for (auto& pos : reachable) {\n // Base score: distance from entrance (want smaller for smaller t)\n double distance_score = warehouse.distance_from_entrance(pos.i, pos.j);\n \n // Priority factor: if t is smaller than average, we want closer positions\n double priority_factor = 1.0;\n if (d > 0) {\n if (t < avg_so_far) {\n // This container should be removed earlier, so give it higher priority (lower score)\n priority_factor = 0.5;\n } else {\n // This container should be removed later, so lower priority (higher score)\n priority_factor = 2.0;\n }\n }\n \n // Blocking score: how much this placement would block other positions\n int block_score = warehouse.blocking_score(pos.i, pos.j);\n \n // Total score (lower is better)\n double total_score = distance_score * priority_factor + block_score * 0.1;\n \n position_scores.push_back({total_score, pos});\n }\n \n // Choose position with minimum score\n sort(position_scores.begin(), position_scores.end());\n Position chosen = position_scores[0].second;\n \n cout << chosen.i << \" \" << chosen.j << endl;\n cout.flush(); // Important: flush output\n \n warehouse.place_container(t, chosen.i, chosen.j);\n placement_positions.push_back({chosen.i, chosen.j});\n \n placed:; // Label for goto\n }\n \n // Determine removal order\n vector> containers_sorted = warehouse.get_all_containers_sorted();\n \n // Output removal order (by container number, ascending)\n for (auto& p : containers_sorted) {\n cout << p.first.i << \" \" << p.first.j << endl;\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nconst int M = 100;\n\nint main() {\n int n = N, m = M;\n vector> grid(n, vector(n));\n \n // Read input\n cin >> n >> m;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n \n // Determine adjacencies\n vector> adj(m + 1); // adj[c] contains colors adjacent to color c\n vector adj_to_external(m + 1, false); // whether color c is adjacent to external (0)\n \n // Check adjacencies in the original grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n \n // Check if adjacent to boundary (external)\n if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {\n adj_to_external[c] = true;\n }\n \n // Check 4-directional neighbors\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int d = grid[ni][nj];\n if (c != d) {\n adj[c].insert(d);\n adj[d].insert(c);\n }\n } else {\n // Adjacent to external\n adj_to_external[c] = true;\n adj[c].insert(0);\n // Note: We don't add to adj[0] as it's external and always connected\n }\n }\n }\n }\n \n // Create output grid, initially all color 0\n vector> result(n, vector(n, 0));\n \n // Strategy: Place one tile per color in a compact arrangement\n // Start by placing colors that need to be adjacent to external on the boundary\n \n vector colors;\n for (int i = 1; i <= m; i++) {\n colors.push_back(i);\n }\n \n // Sort colors by number of adjacencies (descending) to place high-degree nodes first\n sort(colors.begin(), colors.end(), [&](int a, int b) {\n return adj[a].size() > adj[b].size();\n });\n \n // Place colors on the grid\n int placed = 0;\n bool placed_grid[N][N] = {false};\n \n // First, try to place on the boundary for colors adjacent to external\n vector> boundary_positions;\n for (int i = 0; i < n; i++) {\n boundary_positions.push_back({i, 0});\n boundary_positions.push_back({i, n-1});\n }\n for (int j = 1; j < n-1; j++) {\n boundary_positions.push_back({0, j});\n boundary_positions.push_back({n-1, j});\n }\n \n int boundary_idx = 0;\n \n // Place colors adjacent to external on boundary\n for (int color : colors) {\n if (adj_to_external[color] && boundary_idx < boundary_positions.size()) {\n int x = boundary_positions[boundary_idx].first;\n int y = boundary_positions[boundary_idx].second;\n result[x][y] = color;\n placed_grid[x][y] = true;\n boundary_idx++;\n placed++;\n }\n }\n \n // Place remaining colors in the interior\n for (int color : colors) {\n if (placed >= m) break;\n \n bool already_placed = false;\n for (int i = 0; i < n && !already_placed; i++) {\n for (int j = 0; j < n && !already_placed; j++) {\n if (result[i][j] == color) {\n already_placed = true;\n }\n }\n }\n \n if (already_placed) continue;\n \n // Find a position to place this color\n bool placed_color = false;\n \n // Try to place adjacent to already placed colors it should be adjacent to\n for (int c : adj[color]) {\n if (c == 0) continue; // Skip external\n \n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (result[i][j] == c) {\n // Try to place adjacent to this tile\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n && !placed_grid[ni][nj]) {\n result[ni][nj] = color;\n placed_grid[ni][nj] = true;\n placed_color = true;\n placed++;\n break;\n }\n }\n }\n }\n }\n \n if (placed_color) break;\n }\n \n // If couldn't place adjacent to any adjacent color, place anywhere available\n if (!placed_color) {\n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (!placed_grid[i][j]) {\n result[i][j] = color;\n placed_grid[i][j] = true;\n placed_color = true;\n placed++;\n }\n }\n }\n }\n }\n \n // Output the result\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cout << result[i][j];\n if (j < n - 1) cout << \" \";\n }\n cout << endl;\n }\n \n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Simple disjoint set for potential use in grouping similar items\nstruct DisjointSet {\n vector parent, rank;\n \n DisjointSet(int n) : parent(n), rank(n, 0) {\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n \n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n \n void unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) swap(x, y);\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n};\n\n// For estimating weights from comparisons\nclass WeightEstimator {\nprivate:\n int n;\n vector weights;\n vector> comparison_results; // 1 if i > j, -1 if i < j, 0 if equal\n \npublic:\n WeightEstimator(int size) : n(size), weights(size, 1.0), comparison_results(size, vector(size, 0)) {}\n \n void add_comparison(int i, int j, const string& result) {\n if (result == \">\") {\n comparison_results[i][j] = 1;\n comparison_results[j][i] = -1;\n } else if (result == \"<\") {\n comparison_results[i][j] = -1;\n comparison_results[j][i] = 1;\n } else { // \"=\"\n comparison_results[i][j] = 0;\n comparison_results[j][i] = 0;\n }\n }\n \n // Use iterative method to estimate weights\n void estimate_weights() {\n // Initialize with uniform weights\n for (int i = 0; i < n; ++i) weights[i] = 1.0;\n \n // Use a simple iterative approach\n const int max_iterations = 100;\n const double learning_rate = 0.1;\n \n for (int iter = 0; iter < max_iterations; ++iter) {\n bool changed = false;\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (i == j || comparison_results[i][j] == 0) continue;\n \n double diff = weights[i] - weights[j];\n double target_diff = comparison_results[i][j] * 0.1; // Small positive/negative value\n \n if (comparison_results[i][j] == 1 && diff < 0.01) {\n weights[i] += learning_rate;\n weights[j] -= learning_rate * 0.5;\n changed = true;\n } else if (comparison_results[i][j] == -1 && diff > -0.01) {\n weights[i] -= learning_rate;\n weights[j] += learning_rate * 0.5;\n changed = true;\n }\n }\n }\n \n if (!changed) break;\n }\n \n // Normalize weights to positive values\n double min_weight = *min_element(weights.begin(), weights.end());\n if (min_weight <= 0) {\n for (int i = 0; i < n; ++i) {\n weights[i] += (1.0 - min_weight);\n }\n }\n }\n \n double get_weight(int i) const {\n return weights[i];\n }\n \n vector get_all_weights() const {\n return weights;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, D, Q;\n cin >> N >> D >> Q;\n \n // Initialize random generator\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937 rng(seed);\n uniform_int_distribution item_dist(0, N-1);\n uniform_int_distribution size_dist(1, N/3);\n \n // Create weight estimator\n WeightEstimator estimator(N);\n \n // Phase 1: Gather information through comparisons\n vector> pairwise_comparisons;\n \n // First, do some pairwise comparisons\n int queries_used = 0;\n vector item_compared(N, false);\n \n // Compare each item with at least one other item\n for (int i = 0; i < N && queries_used < Q/2; ++i) {\n int j = (i + 1) % N;\n if (queries_used >= Q) break;\n \n cout << \"1 1 \" << i << \" \" << j << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(i, j, result);\n queries_used++;\n pairwise_comparisons.push_back({i, j});\n item_compared[i] = true;\n item_compared[j] = true;\n }\n \n // Ensure all items are compared at least once\n for (int i = 0; i < N && queries_used < Q/2; ++i) {\n if (!item_compared[i]) {\n int j = (i == 0) ? 1 : 0;\n cout << \"1 1 \" << i << \" \" << j << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(i, j, result);\n queries_used++;\n pairwise_comparisons.push_back({i, j});\n }\n }\n \n // Use remaining queries for more informative comparisons\n while (queries_used < Q) {\n // Random sizes for left and right\n int left_size = min(size_dist(rng), N/2);\n int right_size = min(size_dist(rng), N/2);\n \n if (left_size == 0 || right_size == 0) {\n left_size = 1;\n right_size = 1;\n }\n \n // Generate random sets\n vector left_items, right_items;\n vector used(N, false);\n \n // Pick left items\n for (int i = 0; i < left_size; ++i) {\n int attempts = 0;\n int item = item_dist(rng);\n while (used[item] && attempts < 10) {\n item = item_dist(rng);\n attempts++;\n }\n if (!used[item]) {\n left_items.push_back(item);\n used[item] = true;\n }\n }\n \n // Pick right items\n for (int i = 0; i < right_size; ++i) {\n int attempts = 0;\n int item = item_dist(rng);\n while (used[item] && attempts < 10) {\n item = item_dist(rng);\n attempts++;\n }\n if (!used[item]) {\n right_items.push_back(item);\n used[item] = true;\n }\n }\n \n // Ensure we have at least one item on each side\n if (left_items.empty() || right_items.empty()) {\n if (left_items.empty()) {\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n left_items.push_back(i);\n used[i] = true;\n break;\n }\n }\n }\n if (right_items.empty()) {\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n right_items.push_back(i);\n used[i] = true;\n break;\n }\n }\n }\n }\n \n // Output query\n cout << left_items.size() << \" \" << right_items.size();\n for (int item : left_items) cout << \" \" << item;\n for (int item : right_items) cout << \" \" << item;\n cout << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n // For group comparisons, we can't directly add to estimator\n // But we can use this information later for refinement\n queries_used++;\n \n // If we have equality, we can treat these groups as having similar weights\n if (result == \"=\") {\n // Could implement logic to update estimates based on group equality\n // For now, just store this information\n }\n }\n \n // Estimate weights based on comparisons\n estimator.estimate_weights();\n vector estimated_weights = estimator.get_all_weights();\n \n // Phase 2: Partition items into D sets\n vector assignment(N, 0);\n vector set_weights(D, 0.0);\n \n // Create list of items with their estimated weights\n vector> items;\n for (int i = 0; i < N; ++i) {\n items.push_back({estimated_weights[i], i});\n }\n \n // Sort by weight (descending) for better greedy assignment\n sort(items.rbegin(), items.rend());\n \n // Greedy assignment: assign heaviest remaining item to lightest set\n for (auto& item : items) {\n int item_idx = item.second;\n double weight = item.first;\n \n // Find the set with minimum current weight\n int min_set = 0;\n for (int j = 1; j < D; ++j) {\n if (set_weights[j] < set_weights[min_set]) {\n min_set = j;\n }\n }\n \n assignment[item_idx] = min_set;\n set_weights[min_set] += weight;\n }\n \n // Local search improvement: try swapping items between sets\n const int max_swaps = N * D;\n for (int iter = 0; iter < max_swaps; ++iter) {\n // Randomly pick two different sets\n int set1 = rng() % D;\n int set2 = rng() % (D - 1);\n if (set2 >= set1) set2++;\n \n // Find items in these sets\n vector items_in_set1, items_in_set2;\n for (int i = 0; i < N; ++i) {\n if (assignment[i] == set1) items_in_set1.push_back(i);\n if (assignment[i] == set2) items_in_set2.push_back(i);\n }\n \n if (items_in_set1.empty() || items_in_set2.empty()) continue;\n \n // Try swapping a random pair\n int item1 = items_in_set1[rng() % items_in_set1.size()];\n int item2 = items_in_set2[rng() % items_in_set2.size()];\n \n double w1 = estimated_weights[item1];\n double w2 = estimated_weights[item2];\n \n // Calculate current variance\n double old_var = 0.0;\n double mean = 0.0;\n for (double w : set_weights) mean += w;\n mean /= D;\n for (double w : set_weights) old_var += (w - mean) * (w - mean);\n old_var /= D;\n \n // Calculate variance after swap\n vector new_weights = set_weights;\n new_weights[set1] = new_weights[set1] - w1 + w2;\n new_weights[set2] = new_weights[set2] - w2 + w1;\n \n double new_mean = 0.0;\n for (double w : new_weights) new_mean += w;\n new_mean /= D;\n \n double new_var = 0.0;\n for (double w : new_weights) new_var += (w - new_mean) * (w - new_mean);\n new_var /= D;\n \n // Accept swap if it improves variance\n if (new_var < old_var) {\n assignment[item1] = set2;\n assignment[item2] = set1;\n set_weights[set1] = new_weights[set1];\n set_weights[set2] = new_weights[set2];\n }\n }\n \n // Output final assignment\n for (int i = 0; i < N; ++i) {\n cout << assignment[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n \n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct BoxPosition {\n int stack_idx;\n int height; // 0-indexed from bottom\n bool removed;\n};\n\nint main() {\n int n = 200, m = 10;\n int boxes_per_stack = n / m;\n \n // Read input\n vector> stacks(m, vector(boxes_per_stack));\n vector box_positions(n + 1); // 1-indexed\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_positions[stacks[i][j]] = {i, j, false};\n }\n }\n \n vector> operations;\n \n // For each box from 1 to 200\n for (int target = 1; target <= n; target++) {\n // If box is already removed, skip (shouldn't happen)\n if (box_positions[target].removed) continue;\n \n int stack_idx = box_positions[target].stack_idx;\n int height = box_positions[target].height;\n \n // Check if box is at the top of its stack\n bool is_top = true;\n for (int i = height + 1; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) { // 0 indicates removed box\n is_top = false;\n break;\n }\n }\n \n // Clean up removed boxes from top of stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Recalculate if it's at the top after cleanup\n is_top = (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1);\n \n if (is_top) {\n // Can remove directly\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n continue;\n }\n \n // Need to move the box and everything above it\n // Find the best destination stack\n \n int best_stack = -1;\n int min_cost = INT_MAX;\n \n // First, try to find an empty stack\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n if (stacks[dest].empty()) {\n best_stack = dest;\n break;\n }\n }\n \n // If no empty stack, find stack with minimum additional cost\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n \n // Calculate cost of moving to this stack\n int boxes_to_move = 0;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move++;\n }\n }\n \n // Energy cost is boxes_to_move + 1\n int cost = boxes_to_move + 1;\n \n // Prefer stacks that are shorter or have higher-numbered boxes on top\n cost += stacks[dest].size(); // penalty for taller stacks\n \n if (cost < min_cost) {\n min_cost = cost;\n best_stack = dest;\n }\n }\n }\n \n // If still no valid destination, pick any different stack\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx) {\n best_stack = dest;\n break;\n }\n }\n }\n \n // Perform the move\n vector boxes_to_move;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move.push_back(stacks[stack_idx][i]);\n }\n }\n \n // Update stacks\n stacks[stack_idx].resize(height);\n \n for (int box : boxes_to_move) {\n stacks[best_stack].push_back(box);\n box_positions[box].stack_idx = best_stack;\n box_positions[box].height = stacks[best_stack].size() - 1;\n }\n \n operations.push_back({target, best_stack + 1});\n \n // Now try to remove the target box (it should be at the top)\n stack_idx = box_positions[target].stack_idx;\n height = box_positions[target].height;\n \n // Clean up the stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Verify it's at the top\n if (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1) {\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n } else {\n // Something went wrong, try one more move\n // This is a fallback - shouldn't happen in normal cases\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx && stacks[dest].empty()) {\n // Move just this box to empty stack\n stacks[stack_idx].erase(stacks[stack_idx].begin() + height);\n stacks[dest].push_back(target);\n box_positions[target].stack_idx = dest;\n box_positions[target].height = 0;\n operations.push_back({target, dest + 1});\n break;\n }\n }\n \n // Now remove it\n operations.push_back({target, 0});\n for (int i = 0; i < m; i++) {\n if (!stacks[i].empty() && stacks[i].back() == target) {\n stacks[i].pop_back();\n break;\n }\n }\n box_positions[target].removed = true;\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\n// Directions: R, D, L, U\nconst int di[4] = {0, 1, 0, -1};\nconst int dj[4] = {1, 0, -1, 0};\nconst string DIR = \"RDLU\";\n\nint N;\nvector h, v;\nvector> d;\nvector> visited;\nstring route = \"\";\n\n// Check if we can move from (i,j) to (ni,nj)\nbool canMove(int i, int j, int ni, int nj) {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n \n if (i == ni) { // horizontal move\n int min_j = min(j, nj);\n return v[i][min_j] == '0';\n } else { // vertical move\n int min_i = min(i, ni);\n return h[min_i][j] == '0';\n }\n}\n\n// DFS with priority based on dirtiness\nvoid dfs_priority(int i, int j, vector>& order) {\n visited[i][j] = true;\n \n // Collect all possible next moves with their priorities\n vector> next_moves; // (priority, direction)\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n // Priority: higher dirtiness gets higher priority\n next_moves.push_back({-d[ni][nj], dir}); // negative for descending sort\n }\n }\n \n // Sort by priority (descending dirtiness)\n sort(next_moves.begin(), next_moves.end());\n \n // Visit in priority order\n for (auto& move : next_moves) {\n int dir = move.second;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n \n route += DIR[dir];\n dfs_priority(ni, nj, order);\n route += DIR[(dir + 2) % 4]; // return\n }\n}\n\n// Calculate the average dirtiness for a given route\ndouble calculateAverageDirtiness(const string& r) {\n int L = r.size();\n if (L == 0) return 0.0;\n \n // Simulate L moves to reach steady state\n vector> dirt(N, vector(N, 0.0));\n \n int ci = 0, cj = 0; // current position\n \n // First L moves (to reach periodic state)\n for (int t = 0; t < L; t++) {\n // Update dirt: set current cell to 0, add d[i,j] to all other cells\n double current_dirt_sum = 0.0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == ci && j == cj) {\n dirt[i][j] = 0.0;\n } else {\n dirt[i][j] += d[i][j];\n }\n current_dirt_sum += dirt[i][j];\n }\n }\n \n // Move to next position\n char move = r[t];\n int dir;\n for (dir = 0; dir < 4; dir++) {\n if (DIR[dir] == move) break;\n }\n ci += di[dir];\n cj += dj[dir];\n }\n \n // Calculate average over next L moves (periodic state)\n double total_dirt_sum = 0.0;\n for (int t = 0; t < L; t++) {\n // Update dirt: set current cell to 0, add d[i,j] to all other cells\n double current_dirt_sum = 0.0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == ci && j == cj) {\n dirt[i][j] = 0.0;\n } else {\n dirt[i][j] += d[i][j];\n }\n current_dirt_sum += dirt[i][j];\n }\n }\n total_dirt_sum += current_dirt_sum;\n \n // Move to next position\n char move = r[t];\n int dir;\n for (dir = 0; dir < 4; dir++) {\n if (DIR[dir] == move) break;\n }\n ci += di[dir];\n cj += dj[dir];\n }\n \n return total_dirt_sum / L;\n}\n\n// Try to optimize by adding loops to revisit high-dirt cells\nstring addLoops(const string& base_route) {\n string result = base_route;\n int L = base_route.size();\n if (L >= 95000) return result; // Avoid exceeding limit\n \n // Track positions during route\n vector> positions;\n int ci = 0, cj = 0;\n positions.push_back({ci, cj});\n \n for (char move : base_route) {\n int dir;\n for (dir = 0; dir < 4; dir++) {\n if (DIR[dir] == move) break;\n }\n ci += di[dir];\n cj += dj[dir];\n positions.push_back({ci, cj});\n }\n \n // Find high-dirt cells and try to add small loops to revisit them\n vector>> dirt_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n dirt_cells.push_back({d[i][j], {i, j}});\n }\n }\n sort(dirt_cells.rbegin(), dirt_cells.rend()); // descending order\n \n // Try to add loops for top 10% of dirt cells\n int top_count = max(1, (int)(dirt_cells.size() * 0.1));\n for (int idx = 0; idx < top_count && result.size() < 95000; idx++) {\n int target_i = dirt_cells[idx].second.first;\n int target_j = dirt_cells[idx].second.second;\n \n // Find earliest visit to this cell\n int first_visit = -1;\n for (int t = 0; t < positions.size(); t++) {\n if (positions[t].first == target_i && positions[t].second == target_j) {\n first_visit = t;\n break;\n }\n }\n \n if (first_visit == -1) continue; // shouldn't happen\n \n // Try to add a small loop (go to neighbor and back)\n for (int dir = 0; dir < 4; dir++) {\n int ni = target_i + di[dir];\n int nj = target_j + dj[dir];\n \n if (canMove(target_i, target_j, ni, nj) && result.size() + 2 <= 100000) {\n // Insert loop at first_visit position\n string loop = string(1, DIR[dir]) + string(1, DIR[(dir + 2) % 4]);\n result.insert(first_visit, loop);\n \n // Update positions\n positions.insert(positions.begin() + first_visit + 1, {ni, nj});\n positions.insert(positions.begin() + first_visit + 2, {target_i, target_j});\n \n break;\n }\n }\n }\n \n return result;\n}\n\n// Local search: try swapping segments\nstring localSearch(const string& route) {\n if (route.size() > 99000) return route; // Don't optimize if too long\n \n string best_route = route;\n double best_score = calculateAverageDirtiness(route);\n \n // Try simple 2-opt swaps\n for (int i = 1; i < min(50, (int)route.size() - 1); i++) {\n for (int j = i + 1; j < min(100, (int)route.size()); j++) {\n if (j - i > 20) continue; // Limit segment size for performance\n \n string new_route = route;\n reverse(new_route.begin() + i, new_route.begin() + j);\n \n // Check if the new route is valid (returns to 0,0)\n int ci = 0, cj = 0;\n bool valid = true;\n for (char c : new_route) {\n int dir = DIR.find(c);\n if (dir == string::npos) {\n valid = false;\n break;\n }\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n if (!canMove(ci, cj, ni, nj)) {\n valid = false;\n break;\n }\n ci = ni;\n cj = nj;\n }\n if (!valid || ci != 0 || cj != 0) continue;\n \n double new_score = calculateAverageDirtiness(new_route);\n if (new_score < best_score) {\n best_score = new_score;\n best_route = new_route;\n }\n }\n }\n \n return best_route;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read input\n cin >> N;\n h.resize(N-1);\n for (int i = 0; i < N-1; i++) {\n cin >> h[i];\n }\n v.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> v[i];\n }\n d.resize(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n // Initialize visited array\n visited = vector>(N, vector(N, false));\n \n // Phase 1: Generate initial route using priority DFS\n vector> visit_order(N, vector(N, 0));\n dfs_priority(0, 0, visit_order);\n \n // Phase 2: Add loops to revisit high-dirt cells\n string optimized_route = addLoops(route);\n \n // Phase 3: Local search optimization\n string final_route = localSearch(optimized_route);\n \n // Make sure we don't exceed the length limit\n if (final_route.size() > 100000) {\n final_route = route; // Fallback to original if optimized is too long\n }\n \n cout << final_route << endl;\n \n return 0;\n}","ahc028":"#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// Structure to store position on grid\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n int distance(const Position& other) const {\n return abs(i - other.i) + abs(j - other.j);\n }\n};\n\nclass Solution {\nprivate:\n int N, M;\n Position start_pos;\n vector grid;\n vector targets;\n map> char_positions;\n \npublic:\n Solution() {\n cin >> N >> M;\n cin >> start_pos.i >> start_pos.j;\n grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n targets.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i];\n }\n \n // Build map of character positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char_positions[grid[i][j]].push_back(Position(i, j));\n }\n }\n }\n \n // Find the position with minimum distance from current position\n Position find_best_position(char c, const Position& current) {\n if (char_positions.find(c) == char_positions.end()) {\n // This shouldn't happen based on problem constraints\n return Position(0, 0);\n }\n \n Position best_pos = char_positions[c][0];\n int min_dist = current.distance(best_pos);\n \n for (const Position& pos : char_positions[c]) {\n int dist = current.distance(pos);\n if (dist < min_dist) {\n min_dist = dist;\n best_pos = pos;\n }\n }\n \n return best_pos;\n }\n \n // Calculate overlap between two strings\n int calculate_overlap(const string& s1, const string& s2) {\n int max_overlap = 0;\n int len1 = s1.length();\n int len2 = s2.length();\n \n // Try all possible overlaps\n for (int i = 1; i <= min(len1, len2); i++) {\n bool match = true;\n for (int j = 0; j < i; j++) {\n if (s1[len1 - i + j] != s2[j]) {\n match = false;\n break;\n }\n }\n if (match) {\n max_overlap = i;\n }\n }\n \n return max_overlap;\n }\n \n // Build superstring using greedy algorithm\n vector build_superstring_sequence() {\n if (M == 0) return {};\n \n vector used(M, false);\n vector result;\n \n // Start with the first string\n int current_idx = 0;\n used[current_idx] = true;\n result.push_back(targets[current_idx]);\n \n // Greedily add strings with maximum overlap\n for (int step = 1; step < M; step++) {\n int best_idx = -1;\n int best_overlap = -1;\n string current_string = result.back();\n \n for (int i = 0; i < M; i++) {\n if (used[i]) continue;\n \n int overlap = calculate_overlap(current_string, targets[i]);\n if (overlap > best_overlap) {\n best_overlap = overlap;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n // If no overlap found, just pick the first unused string\n for (int i = 0; i < M; i++) {\n if (!used[i]) {\n best_idx = i;\n break;\n }\n }\n }\n \n used[best_idx] = true;\n result.push_back(targets[best_idx]);\n }\n \n return result;\n }\n \n // Calculate the actual superstring and the operations needed\n vector generate_operations(const vector& sequence) {\n vector operations;\n Position current_pos = start_pos;\n \n // If sequence is empty, just return\n if (sequence.empty()) return operations;\n \n // Type the first string completely\n for (char c : sequence[0]) {\n Position best_pos = find_best_position(c, current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n \n // For subsequent strings, type only the non-overlapping part\n for (int i = 1; i < sequence.size(); i++) {\n const string& prev = sequence[i-1];\n const string& curr = sequence[i];\n \n // Find the overlap\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), curr.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != curr[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n \n // Type the non-overlapping part\n for (int j = overlap; j < curr.length(); j++) {\n Position best_pos = find_best_position(curr[j], current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n }\n \n return operations;\n }\n \n // Alternative approach: try different starting strings\n vector try_different_starts() {\n vector best_operations;\n long long best_cost = LLONG_MAX;\n \n // Try different starting strings (first 10 for efficiency)\n for (int start_idx = 0; start_idx < min(10, M); start_idx++) {\n vector used(M, false);\n vector sequence;\n \n // Start with current start_idx\n used[start_idx] = true;\n sequence.push_back(targets[start_idx]);\n \n // Greedily add remaining strings\n for (int step = 1; step < M; step++) {\n int best_idx = -1;\n int best_overlap = -1;\n string current_string = sequence.back();\n \n for (int i = 0; i < M; i++) {\n if (used[i]) continue;\n \n int overlap = calculate_overlap(current_string, targets[i]);\n if (overlap > best_overlap) {\n best_overlap = overlap;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n for (int i = 0; i < M; i++) {\n if (!used[i]) {\n best_idx = i;\n break;\n }\n }\n }\n \n used[best_idx] = true;\n sequence.push_back(targets[best_idx]);\n }\n \n // Generate operations\n vector operations = generate_operations(sequence);\n \n // Calculate cost\n long long cost = 0;\n Position current_pos = start_pos;\n for (const Position& op : operations) {\n cost += current_pos.distance(op) + 1;\n current_pos = op;\n }\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = operations;\n }\n }\n \n return best_operations;\n }\n \n void solve() {\n // Try different approaches and pick the best one\n vector operations = try_different_starts();\n \n // Output the operations\n for (const Position& pos : operations) {\n cout << pos.i << \" \" << pos.j << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n Solution solution;\n solution.solve();\n \n return 0;\n}","ahc030":"#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 double EPS = 1e-9;\n\n// Helper functions\ndouble square(double x) { return x * x; }\n\nstruct Point {\n int i, j;\n Point(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Point& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Point& other) const {\n return i == other.i && j == other.j;\n }\n};\n\n// Oil field representation\nstruct OilField {\n vector shape;\n int size;\n int max_i, max_j; // max coordinates in the shape\n};\n\nclass Solver {\nprivate:\n int N, M;\n double epsilon;\n vector oil_fields;\n vector> known_values; // -1 means unknown\n vector> probability; // probability that square has oil\n vector> confidence; // confidence in probability estimate\n mt19937 rng;\n \n // Tracking for optimization\n int operations_used = 0;\n double total_cost = 0.0;\n set known_oil_squares;\n set candidate_oil_squares;\n \n // For divination noise modeling\n double expected_value(int k, int actual_sum) {\n return (k - actual_sum) * epsilon + actual_sum * (1 - epsilon);\n }\n \n double variance(int k) {\n return k * epsilon * (1 - epsilon);\n }\n \n // Read input\n void read_input() {\n cin >> N >> M >> epsilon;\n \n oil_fields.resize(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n oil_fields[k].shape.resize(d);\n oil_fields[k].size = d;\n \n int min_i = 1000, min_j = 1000, max_i = -1, max_j = -1;\n for (int i = 0; i < d; i++) {\n int ii, jj;\n cin >> ii >> jj;\n oil_fields[k].shape[i] = Point(ii, jj);\n min_i = min(min_i, ii);\n min_j = min(min_j, jj);\n max_i = max(max_i, ii);\n max_j = max(max_j, jj);\n }\n \n // Translate to ensure top-left is (0,0) - already done in input\n oil_fields[k].max_i = max_i;\n oil_fields[k].max_j = max_j;\n }\n \n // Initialize known values and probability\n known_values.assign(N, vector(N, -1));\n probability.assign(N, vector(N, 0.5)); // Start with 50% probability\n confidence.assign(N, vector(N, 0.0)); // Start with 0 confidence\n \n // Initialize candidate squares (all possible positions for all oil fields)\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n candidate_oil_squares.insert(Point(i, j));\n }\n }\n }\n \n // Drill at point (i, j)\n int drill(int i, int j) {\n if (operations_used >= 2 * N * N) return -1;\n \n cout << \"q 1 \" << i << \" \" << j << endl;\n operations_used++;\n total_cost += 1.0;\n \n int value;\n cin >> value;\n \n known_values[i][j] = value;\n if (value > 0) {\n known_oil_squares.insert(Point(i, j));\n probability[i][j] = 1.0;\n confidence[i][j] = 1.0;\n } else {\n probability[i][j] = 0.0;\n confidence[i][j] = 1.0;\n }\n \n return value;\n }\n \n // Divine the sum of values in set S\n int divine(const vector& points) {\n if (points.size() < 2 || operations_used >= 2 * N * N) return -1;\n \n cout << \"q \" << points.size();\n for (const Point& p : points) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n operations_used++;\n total_cost += 1.0 / sqrt(points.size());\n \n int result;\n cin >> result;\n \n // Update probabilities based on result\n update_probabilities_from_divine(points, result);\n \n return result;\n }\n \n // Update probabilities based on divine result\n void update_probabilities_from_divine(const vector& points, int result) {\n if (result < 0) return;\n \n // Simple Bayesian update - adjust probabilities to be more consistent with result\n double current_sum_estimate = 0.0;\n for (const Point& p : points) {\n current_sum_estimate += probability[p.i][p.j];\n }\n \n double adjustment = (result - current_sum_estimate) / points.size();\n \n for (const Point& p : points) {\n if (known_values[p.i][p.j] == -1) { // Only update unknown squares\n probability[p.i][p.j] = max(0.0, min(1.0, probability[p.i][p.j] + adjustment * 0.5));\n confidence[p.i][p.j] = min(1.0, confidence[p.i][p.j] + 0.1);\n }\n }\n }\n \n // Check if point is valid\n bool is_valid_point(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n }\n \n // Check if oil field can be placed at (offset_i, offset_j)\n bool can_place_field(const OilField& field, int offset_i, int offset_j) {\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (!is_valid_point(i, j)) return false;\n // If we know this square has no oil, we can't place the field here\n if (known_values[i][j] == 0) return false;\n }\n return true;\n }\n \n // Calculate score for placing oil field at (offset_i, offset_j)\n double score_field_placement(const OilField& field, int offset_i, int offset_j) {\n if (!can_place_field(field, offset_i, offset_j)) return -1e9;\n \n double score = 0.0;\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (known_values[i][j] > 0) {\n // We know there's oil here, good!\n score += 10.0;\n } else if (known_values[i][j] == 0) {\n // We know there's no oil here, impossible\n return -1e9;\n } else {\n // Unknown, use probability\n score += probability[i][j];\n }\n }\n return score;\n }\n \n // Get all possible placements for an oil field\n vector> get_possible_placements(const OilField& field) {\n vector> placements;\n \n for (int i = 0; i <= N - 1 - field.max_i; i++) {\n for (int j = 0; j <= N - 1 - field.max_j; j++) {\n double score = score_field_placement(field, i, j);\n if (score > -1e8) {\n placements.push_back({Point(i, j), score});\n }\n }\n }\n \n // Sort by score\n sort(placements.begin(), placements.end(), [](const auto& a, const auto& b) {\n return a.second > b.second;\n });\n \n return placements;\n }\n \n // Phase 1: Coarse search with divination\n void phase1_coarse_search() {\n // Use larger blocks for divination\n int block_size = max(2, N / 4);\n \n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n if (operations_used >= 2 * N * N) return;\n \n vector block_points;\n for (int i = bi; i < min(bi + block_size, N); i++) {\n for (int j = bj; j < min(bj + block_size, N); j++) {\n if (known_values[i][j] == -1) { // Only include unknown squares\n block_points.push_back(Point(i, j));\n }\n }\n }\n \n // If we have at least 2 unknown points, divine the block\n if (block_points.size() >= 2) {\n int result = divine(block_points);\n // Results are processed in divine() via update_probabilities_from_divine\n }\n }\n }\n }\n \n // Phase 2: Targeted search based on probabilities\n void phase2_targeted_search() {\n // Create a priority queue of squares to investigate based on uncertainty and probability\n vector> candidates;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n // Prioritize squares with moderate confidence and high probability\n // We want to investigate squares that are likely to have oil but we're not sure\n double uncertainty = 1.0 - confidence[i][j];\n double priority = probability[i][j] * uncertainty;\n candidates.push_back({priority, Point(i, j)});\n }\n }\n }\n \n // Sort by priority\n sort(candidates.begin(), candidates.end(), greater>());\n \n // Investigate top candidates\n int to_investigate = min(20, (int)candidates.size());\n for (int idx = 0; idx < to_investigate; idx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& p = candidates[idx].second;\n \n // If probability is very high, drill directly\n if (probability[p.i][p.j] > 0.7) {\n drill(p.i, p.j);\n } \n // Otherwise, try to group with nearby squares for divination\n else {\n vector nearby;\n nearby.push_back(p);\n \n // Add nearby squares\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = p.i + di, nj = p.j + dj;\n if (is_valid_point(ni, nj) && known_values[ni][nj] == -1) {\n nearby.push_back(Point(ni, nj));\n }\n }\n }\n \n // If we have at least 2 squares, divine them\n if (nearby.size() >= 2 && nearby.size() <= 8) { // Limit size to reduce noise\n divine(nearby);\n } else {\n // Otherwise just drill this square\n drill(p.i, p.j);\n }\n }\n }\n }\n \n // Phase 3: Use shape information to guide search\n void phase3_shape_guided_search() {\n // For each oil field, find the most likely placements\n for (int fidx = 0; fidx < M; fidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const OilField& field = oil_fields[fidx];\n auto placements = get_possible_placements(field);\n \n if (placements.empty()) continue;\n \n // Try the top few placements\n int to_try = min(3, (int)placements.size());\n for (int pidx = 0; pidx < to_try; pidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& offset = placements[pidx].first;\n \n // Check if we can verify this placement\n bool need_verification = false;\n vector unknown_points;\n \n for (const Point& p : field.shape) {\n int i = p.i + offset.i;\n int j = p.j + offset.j;\n if (known_values[i][j] == -1) {\n need_verification = true;\n unknown_points.push_back(Point(i, j));\n }\n }\n \n if (!need_verification) continue; // Already verified or impossible\n \n // Try to verify with minimum operations\n if (unknown_points.size() == 1) {\n // Just drill the single unknown point\n const Point& pt = unknown_points[0];\n drill(pt.i, pt.j);\n } else if (unknown_points.size() <= 6) {\n // Divine the unknown points together\n divine(unknown_points);\n } else {\n // Drill the point with highest probability among unknowns\n Point best_point = unknown_points[0];\n double best_prob = probability[best_point.i][best_point.j];\n \n for (const Point& pt : unknown_points) {\n if (probability[pt.i][pt.j] > best_prob) {\n best_prob = probability[pt.i][pt.j];\n best_point = pt;\n }\n }\n \n drill(best_point.i, best_point.j);\n }\n }\n }\n }\n \n // Make final guess\n bool make_guess() {\n vector oil_squares;\n \n // Include all known oil squares\n for (const Point& p : known_oil_squares) {\n oil_squares.push_back(p);\n }\n \n // Include squares with high probability\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1 && probability[i][j] > 0.5) {\n oil_squares.push_back(Point(i, j));\n }\n }\n }\n \n // Remove duplicates (shouldn't happen but just in case)\n sort(oil_squares.begin(), oil_squares.end());\n oil_squares.erase(unique(oil_squares.begin(), oil_squares.end()), oil_squares.end());\n \n // Output guess\n cout << \"a \" << oil_squares.size();\n for (const Point& p : oil_squares) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n int result;\n cin >> result;\n \n return result == 1;\n }\n \n // Refine probabilities using shape constraints\n void refine_probabilities_with_shapes() {\n // For each square, calculate the probability based on possible oil field placements\n vector> new_prob(N, vector(N, 0.0));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] != -1) {\n new_prob[i][j] = (known_values[i][j] > 0) ? 1.0 : 0.0;\n continue;\n }\n \n double prob = 0.0;\n int count = 0;\n \n // Check how many oil fields could cover this square\n for (const OilField& field : oil_fields) {\n for (int oi = 0; oi <= N - 1 - field.max_i; oi++) {\n for (int oj = 0; oj <= N - 1 - field.max_j; oj++) {\n // Check if field can be placed at (oi, oj)\n if (!can_place_field(field, oi, oj)) continue;\n \n // Check if this square is covered by this placement\n bool covers = false;\n for (const Point& p : field.shape) {\n if (p.i + oi == i && p.j + oj == j) {\n covers = true;\n break;\n }\n }\n \n if (covers) {\n double placement_score = score_field_placement(field, oi, oj);\n if (placement_score > 0) {\n prob += min(1.0, placement_score / field.size);\n count++;\n }\n }\n }\n }\n }\n \n if (count > 0) {\n new_prob[i][j] = min(1.0, prob / count * 0.8 + probability[i][j] * 0.2);\n } else {\n new_prob[i][j] = probability[i][j];\n }\n }\n }\n \n // Update probabilities\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n probability[i][j] = new_prob[i][j];\n }\n }\n }\n }\n \npublic:\n Solver() : rng(random_device{}()) {}\n \n void solve() {\n read_input();\n \n // Phase 1: Coarse search with divination on large blocks\n phase1_coarse_search();\n \n // Phase 2: Refine with targeted search\n phase2_targeted_search();\n \n // Phase 3: Use shape information\n phase3_shape_guided_search();\n \n // Refine probabilities using shape constraints\n refine_probabilities_with_shapes();\n \n // Additional iterations if we have operations left\n while (operations_used < 2 * N * N) {\n // Check if we have high confidence in our answer\n int unknown_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n unknown_count++;\n }\n }\n }\n \n // If few unknowns, drill them directly\n if (unknown_count <= max(5, N/2)) {\n for (int i = 0; i < N && operations_used < 2 * N * N; i++) {\n for (int j = 0; j < N && operations_used < 2 * N * N; j++) {\n if (known_values[i][j] == -1) {\n drill(i, j);\n }\n }\n }\n } else {\n // Do another round of targeted search\n phase2_targeted_search();\n if (operations_used >= 2 * N * N) break;\n \n // Use shape information again\n phase3_shape_guided_search();\n if (operations_used >= 2 * N * N) break;\n \n // Refine probabilities\n refine_probabilities_with_shapes();\n }\n }\n \n // Make final guess\n bool success = make_guess();\n \n // If we failed, we could try again but we're out of operations\n // So just exit\n }\n};\n\nint main() {\n Solver solver;\n solver.solve();\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int i0, j0, i1, j1;\n \n Rectangle() : i0(0), j0(0), i1(0), j1(0) {}\n Rectangle(int i0, int j0, int i1, int j1) : i0(i0), j0(j0), i1(i1), j1(j1) {}\n \n int area() const {\n return (i1 - i0) * (j1 - j0);\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(i1 <= other.i0 || i0 >= other.i1 || j1 <= other.j0 || j0 >= other.j1);\n }\n};\n\nclass PartitionManager {\nprivate:\n int W;\n vector> horizontal_partitions; // [i][j] for horizontal partition at (i,j)-(i,j+1)\n vector> vertical_partitions; // [i][j] for vertical partition at (i,j)-(i+1,j)\n \npublic:\n PartitionManager(int W) : W(W) {\n horizontal_partitions.assign(W, vector(W, false));\n vertical_partitions.assign(W, vector(W, false));\n }\n \n void updateFromRectangles(const vector& rectangles) {\n // Reset all partitions\n for (int i = 0; i < W; i++) {\n fill(horizontal_partitions[i].begin(), horizontal_partitions[i].end(), false);\n fill(vertical_partitions[i].begin(), vertical_partitions[i].end(), false);\n }\n \n // Set partitions based on rectangles\n for (const auto& rect : rectangles) {\n // Top edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i0 > 0) vertical_partitions[rect.i0 - 1][j] = true;\n }\n // Bottom edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i1 < W) vertical_partitions[rect.i1 - 1][j] = true;\n }\n // Left edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j0 > 0) horizontal_partitions[i][rect.j0 - 1] = true;\n }\n // Right edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j1 < W) horizontal_partitions[i][rect.j1 - 1] = true;\n }\n }\n }\n \n int calculateChangeCost(const PartitionManager& prev) const {\n int cost = 0;\n \n // Horizontal partitions (i,j)-(i,j+1) where 1<=i<=W-1, 0<=j<=W-1\n for (int i = 1; i < W; i++) {\n for (int j = 0; j < W; j++) {\n if (horizontal_partitions[i-1][j] != prev.horizontal_partitions[i-1][j]) {\n cost++;\n }\n }\n }\n \n // Vertical partitions (i,j)-(i+1,j) where 0<=i<=W-1, 1<=j<=W-1\n for (int i = 0; i < W; i++) {\n for (int j = 1; j < W; j++) {\n if (vertical_partitions[i][j-1] != prev.vertical_partitions[i][j-1]) {\n cost++;\n }\n }\n }\n \n return cost;\n }\n \n const vector>& getHorizontalPartitions() const {\n return horizontal_partitions;\n }\n \n const vector>& getVerticalPartitions() const {\n return vertical_partitions;\n }\n};\n\nclass Solution {\nprivate:\n int W, D, N;\n vector> desired_areas;\n vector> solution;\n mt19937 rng;\n \npublic:\n Solution(int W, int D, int N, vector>&& areas) \n : W(W), D(D), N(N), desired_areas(move(areas)), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n solution.resize(D, vector(N));\n }\n \n // Calculate rental cost for a day\n long long calculateRentalCost(int day) const {\n long long cost = 0;\n for (int k = 0; k < N; k++) {\n int actual_area = solution[day][k].area();\n if (desired_areas[day][k] > actual_area) {\n cost += 100LL * (desired_areas[day][k] - actual_area);\n }\n }\n return cost;\n }\n \n // Calculate partition change cost for a day\n long long calculatePartitionCost(int day) const {\n if (day == 0) return 0;\n \n PartitionManager current(W), prev(W);\n current.updateFromRectangles(solution[day]);\n prev.updateFromRectangles(solution[day-1]);\n \n return current.calculateChangeCost(prev);\n }\n \n // Calculate total cost\n long long calculateTotalCost() const {\n long long total_cost = 0;\n for (int d = 0; d < D; d++) {\n total_cost += calculateRentalCost(d);\n total_cost += calculatePartitionCost(d);\n }\n return total_cost;\n }\n \n // Initialize day 0 with simple row-wise division\n void initializeDay0() {\n int total_height = W;\n vector heights(N);\n \n // Calculate heights proportional to desired areas\n long long total_desired = 0;\n for (int k = 0; k < N; k++) {\n total_desired += desired_areas[0][k];\n }\n \n int allocated_height = 0;\n for (int k = 0; k < N - 1; k++) {\n heights[k] = max(1, (int)((long long)desired_areas[0][k] * total_height / total_desired));\n allocated_height += heights[k];\n }\n heights[N-1] = total_height - allocated_height;\n if (heights[N-1] <= 0) {\n heights[N-1] = 1;\n // Adjust other heights if needed\n for (int k = 0; k < N-1 && allocated_height >= total_height; k++) {\n if (heights[k] > 1) {\n heights[k]--;\n allocated_height--;\n if (allocated_height < total_height) break;\n }\n }\n }\n \n // Create rectangles\n int current_i = 0;\n for (int k = 0; k < N; k++) {\n solution[0][k] = Rectangle(current_i, 0, current_i + heights[k], W);\n current_i += heights[k];\n }\n }\n \n // For subsequent days, start with previous day's solution and adjust\n void optimizeDay(int day) {\n // Start with previous day's configuration\n solution[day] = solution[day-1];\n \n // Calculate current areas\n vector current_areas(N);\n for (int k = 0; k < N; k++) {\n current_areas[k] = solution[day][k].area();\n }\n \n // Identify rectangles that need adjustment\n vector needs_more_area;\n for (int k = 0; k < N; k++) {\n if (current_areas[k] < desired_areas[day][k]) {\n needs_more_area.push_back(k);\n }\n }\n \n // Simple adjustment: try to expand rectangles that need more area\n for (int k : needs_more_area) {\n int deficit = desired_areas[day][k] - current_areas[k];\n \n // Try to expand in different directions\n Rectangle& rect = solution[day][k];\n \n // Try expanding right\n if (rect.j1 < W) {\n int can_expand = W - rect.j1;\n int needed_expand = (deficit + (rect.i1 - rect.i0) - 1) / (rect.i1 - rect.i0); // ceiling division\n int expand_by = min(can_expand, needed_expand);\n rect.j1 += expand_by;\n deficit -= expand_by * (rect.i1 - rect.i0);\n }\n \n // Try expanding down\n if (deficit > 0 && rect.i1 < W) {\n int can_expand = W - rect.i1;\n int needed_expand = (deficit + (rect.j1 - rect.j0) - 1) / (rect.j1 - rect.j0);\n int expand_by = min(can_expand, needed_expand);\n rect.i1 += expand_by;\n deficit -= expand_by * (rect.j1 - rect.j0);\n }\n \n // Try expanding left\n if (deficit > 0 && rect.j0 > 0) {\n int can_expand = rect.j0;\n int needed_expand = (deficit + (rect.i1 - rect.i0) - 1) / (rect.i1 - rect.i0);\n int expand_by = min(can_expand, needed_expand);\n rect.j0 -= expand_by;\n deficit -= expand_by * (rect.i1 - rect.i0);\n }\n \n // Try expanding up\n if (deficit > 0 && rect.i0 > 0) {\n int can_expand = rect.i0;\n int needed_expand = (deficit + (rect.j1 - rect.j0) - 1) / (rect.j1 - rect.j0);\n int expand_by = min(can_expand, needed_expand);\n rect.i0 -= expand_by;\n deficit -= expand_by * (rect.j1 - rect.j0);\n }\n }\n \n // Check for overlaps and resolve them\n resolveOverlaps(day);\n }\n \n // Simple overlap resolution\n void resolveOverlaps(int day) {\n // A simple approach: if rectangles overlap, adjust them\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (solution[day][i].overlaps(solution[day][j])) {\n // Simple resolution: move one rectangle\n // This is a very basic approach - in practice, you'd want something more sophisticated\n \n Rectangle& r1 = solution[day][i];\n Rectangle& r2 = solution[day][j];\n \n // If r1 is to the left of r2 but they overlap horizontally\n if (r1.j0 < r2.j1 && r1.j1 > r2.j0) {\n // Try to adjust horizontally\n if (r1.j1 > r2.j0) {\n int overlap = r1.j1 - r2.j0;\n // Move r2 to the right if possible\n if (r2.j1 + overlap <= W) {\n r2.j0 += overlap;\n r2.j1 += overlap;\n } else {\n // Otherwise move r1 to the left if possible\n if (r1.j0 >= overlap) {\n r1.j0 -= overlap;\n r1.j1 -= overlap;\n }\n }\n }\n }\n \n // If they overlap vertically\n if (r1.i0 < r2.i1 && r1.i1 > r2.i0) {\n int overlap = r1.i1 - r2.i0;\n // Move r2 down if possible\n if (r2.i1 + overlap <= W) {\n r2.i0 += overlap;\n r2.i1 += overlap;\n } else {\n // Otherwise move r1 up if possible\n if (r1.i0 >= overlap) {\n r1.i0 -= overlap;\n r1.i1 -= overlap;\n }\n }\n }\n }\n }\n }\n }\n \n // Local search optimization for a day\n void localSearchDay(int day, int iterations = 100) {\n // Keep track of the best solution\n auto best_solution = solution[day];\n long long best_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n for (int iter = 0; iter < iterations; iter++) {\n // Make a small random change\n auto current_solution = solution[day];\n \n // Select a random rectangle to modify\n int k = uniform_int_distribution(0, N-1)(rng);\n Rectangle& rect = current_solution[k];\n \n // Randomly adjust one of the boundaries\n int change_type = uniform_int_distribution(0, 3)(rng);\n int change_amount = uniform_int_distribution(-5, 5)(rng);\n \n switch (change_type) {\n case 0: // Adjust top\n if (rect.i0 + change_amount >= 0 && rect.i0 + change_amount < rect.i1) {\n rect.i0 += change_amount;\n }\n break;\n case 1: // Adjust left\n if (rect.j0 + change_amount >= 0 && rect.j0 + change_amount < rect.j1) {\n rect.j0 += change_amount;\n }\n break;\n case 2: // Adjust bottom\n if (rect.i1 + change_amount > rect.i0 && rect.i1 + change_amount <= W) {\n rect.i1 += change_amount;\n }\n break;\n case 3: // Adjust right\n if (rect.j1 + change_amount > rect.j0 && rect.j1 + change_amount <= W) {\n rect.j1 += change_amount;\n }\n break;\n }\n \n // Check for overlaps\n bool has_overlap = false;\n for (int i = 0; i < N && !has_overlap; i++) {\n for (int j = i + 1; j < N && !has_overlap; j++) {\n if (i != k && j != k && current_solution[i].overlaps(current_solution[j])) {\n has_overlap = true;\n }\n if ((i == k || j == k) && current_solution[i].overlaps(current_solution[j]) && i != j) {\n has_overlap = true;\n }\n }\n }\n \n if (!has_overlap) {\n // Calculate new cost\n solution[day] = current_solution;\n long long new_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n // Accept if better\n if (new_cost < best_cost) {\n best_solution = current_solution;\n best_cost = new_cost;\n }\n \n // Revert for next iteration\n solution[day] = best_solution;\n }\n }\n \n // Set the best solution found\n solution[day] = best_solution;\n }\n \n void solve() {\n // Initialize day 0\n initializeDay0();\n \n // Optimize subsequent days\n for (int d = 1; d < D; d++) {\n optimizeDay(d);\n // Apply local search for further improvement\n localSearchDay(d, 50);\n }\n }\n \n void output() const {\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cout << solution[d][k].i0 << \" \" \n << solution[d][k].j0 << \" \" \n << solution[d][k].i1 << \" \" \n << solution[d][k].j1 << endl;\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int W, D, N;\n cin >> W >> D >> N;\n \n vector> areas(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> areas[d][k];\n }\n }\n \n Solution solver(W, D, N, move(areas));\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n \n // Read initial board\n vector> board(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> board[i][j];\n }\n }\n \n // Read stamps\n vector>> stamps(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n cin >> stamps[m][i][j];\n }\n }\n }\n \n // Store operations\n vector> operations;\n \n // Greedy selection of operations\n for (int op = 0; op < K; op++) {\n long long best_improvement = -1;\n int best_stamp = -1, best_p = -1, best_q = -1;\n \n // Try each stamp at each possible position\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n // Calculate improvement from this operation\n long long improvement = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n long long current_value = board[p + i][q + j] % MOD;\n long long new_value = (current_value + stamps[m][i][j]) % MOD;\n \n // Calculate improvement (considering wrap-around)\n if (new_value > current_value) {\n improvement += (new_value - current_value);\n } else {\n // This operation makes the remainder smaller (wrapped around)\n // Only use if the decrease is small (could be beneficial for future operations)\n // For now, we'll be conservative and treat this as negative improvement\n improvement += (new_value - current_value);\n }\n }\n }\n \n // Update best operation\n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n \n // If no improvement, we could break early, but let's continue to use all K operations\n // as sometimes a \"bad\" operation now might enable better operations later\n if (best_improvement <= 0 && op > 0) {\n // Consider breaking if no improvement, but let's be conservative and continue\n // We'll still apply the best available even if negative\n }\n \n // Apply the best operation\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n board[best_p + i][best_q + j] += stamps[best_stamp][i][j];\n }\n }\n \n // Record the operation\n operations.push_back(make_tuple(best_stamp, best_p, best_q));\n }\n \n // Output\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << get<0>(op) << \" \" << get<1>(op) << \" \" << get<2>(op) << endl;\n }\n \n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int row, col;\n int holding; // -1 if not holding, container number otherwise\n bool is_large;\n bool bombed;\n};\n\nstruct ContainerInfo {\n int target_row; // which row's dispatch gate it should go to\n int target_order; // order within that row (0 to N-1)\n bool arrived;\n bool dispatched;\n int arrival_row; // which receiving gate it will arrive from\n int arrival_order; // order in which it arrives at that gate\n};\n\n// Direction vectors for U, D, L, R\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nclass Solver {\nprivate:\n int N;\n vector> A;\n vector cranes;\n vector> grid; // -1 if empty, container number otherwise\n vector> crane_grid; // true if crane is at that position\n vector containers;\n int turn_count;\n \n // Track which containers have been brought in from each receiving gate\n vector next_container_index;\n \n // BFS to find shortest path avoiding obstacles\n vector> find_path(int start_row, int start_col, int end_row, int end_col, \n bool carrying_container, bool is_large_crane) {\n if (start_row == end_row && start_col == end_col) {\n return {{start_row, start_col}};\n }\n \n vector> dist(N, vector(N, -1));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n \n dist[start_row][start_col] = 0;\n q.push({start_row, start_col});\n \n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n \n // Check bounds\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) continue;\n \n // Check if already visited\n if (dist[nr][nc] != -1) continue;\n \n // Check crane collision\n if (crane_grid[nr][nc]) continue;\n \n // If carrying container and not large crane, cannot move to occupied square\n if (carrying_container && !is_large_crane && grid[nr][nc] != -1) continue;\n \n dist[nr][nc] = dist[r][c] + 1;\n parent[nr][nc] = {r, c};\n q.push({nr, nc});\n \n if (nr == end_row && nc == end_col) {\n // Reconstruct path\n vector> path;\n int cur_r = nr, cur_c = nc;\n while (cur_r != -1) {\n path.push_back({cur_r, cur_c});\n auto p = parent[cur_r][cur_c];\n cur_r = p.first;\n cur_c = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n }\n }\n }\n \n return {}; // No path found\n }\n \n // Find the best crane for a task\n int find_best_crane(int target_row, int target_col, int container_num) {\n int best_crane = -1;\n int min_dist = INT_MAX;\n \n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding != -1) continue;\n \n auto path = find_path(cranes[i].row, cranes[i].col, target_row, target_col, \n false, cranes[i].is_large);\n if (!path.empty() && path.size() < min_dist) {\n min_dist = path.size();\n best_crane = i;\n }\n }\n \n return best_crane;\n }\n \n // Check if we can dispatch from a dispatch gate\n bool can_dispatch(int row) {\n return grid[row][N-1] != -1;\n }\n \n // Get next action for each crane\n vector get_next_actions() {\n vector actions(N, '.');\n \n // First, check if any crane can pick up a newly arrived container\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding != -1) continue;\n \n // Check if there's a container at current position\n if (grid[cranes[i].row][cranes[i].col] != -1) {\n actions[i] = 'P';\n continue;\n }\n }\n \n // Then, check if any crane can deliver a container to dispatch gate\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding == -1) continue;\n \n int container = cranes[i].holding;\n int target_row = containers[container].target_row;\n \n // If at dispatch gate and it's the correct one\n if (cranes[i].row == target_row && cranes[i].col == N-1) {\n actions[i] = 'Q';\n continue;\n }\n }\n \n // Move cranes toward their goals\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n if (actions[i] != '.') continue; // Already assigned\n \n if (cranes[i].holding != -1) {\n // Carrying a container - move toward its dispatch gate\n int container = cranes[i].holding;\n int target_row = containers[container].target_row;\n \n auto path = find_path(cranes[i].row, cranes[i].col, target_row, N-1, \n true, cranes[i].is_large);\n if (!path.empty() && path.size() > 1) {\n int next_r = path[1][0];\n int next_c = path[1][1];\n \n // Determine direction\n if (next_r < cranes[i].row) actions[i] = 'U';\n else if (next_r > cranes[i].row) actions[i] = 'D';\n else if (next_c < cranes[i].col) actions[i] = 'L';\n else if (next_c > cranes[i].col) actions[i] = 'R';\n }\n } else {\n // Not carrying - look for containers to pick up\n // Prefer containers that are ready to be picked up\n for (int r = 0; r < N; r++) {\n if (grid[r][0] != -1) { // Container at receiving gate\n auto path = find_path(cranes[i].row, cranes[i].col, r, 0, \n false, cranes[i].is_large);\n if (!path.empty() && path.size() > 1) {\n int next_r = path[1][0];\n int next_c = path[1][1];\n \n // Determine direction\n if (next_r < cranes[i].row) actions[i] = 'U';\n else if (next_r > cranes[i].row) actions[i] = 'D';\n else if (next_c < cranes[i].col) actions[i] = 'L';\n else if (next_c > cranes[i].col) actions[i] = 'R';\n break;\n }\n }\n }\n }\n }\n \n return actions;\n }\n \n // Simulate one turn\n bool simulate_turn(vector& actions) {\n // Step 1: Bring in new containers at receiving gates\n for (int i = 0; i < N; i++) {\n // Check if we can bring in next container\n if (next_container_index[i] < N && \n grid[i][0] == -1 && \n !crane_grid[i][0]) {\n int container = A[i][next_container_index[i]];\n grid[i][0] = container;\n containers[container].arrived = true;\n next_container_index[i]++;\n }\n }\n \n // Update crane grid\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n crane_grid[cranes[i].row][cranes[i].col] = true;\n }\n }\n \n // Step 2: Perform crane actions\n // Validate actions and check for collisions\n vector> next_positions(N, {-1, -1});\n vector will_bomb(N, false);\n \n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) {\n actions[i] = '.';\n continue;\n }\n \n char action = actions[i];\n int r = cranes[i].row;\n int c = cranes[i].col;\n \n if (action == 'P') {\n if (cranes[i].holding != -1 || grid[r][c] == -1) {\n return false; // Invalid action\n }\n } else if (action == 'Q') {\n if (cranes[i].holding == -1 || grid[r][c] != -1) {\n return false; // Invalid action\n }\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n int nr = r + dr[d];\n int nc = c + dc[d];\n \n if (nr < 0 || nr >= N || nc < 0 || nc >= N) {\n return false; // Out of bounds\n }\n \n if (cranes[i].holding != -1 && !cranes[i].is_large && grid[nr][nc] != -1) {\n return false; // Small crane can't move to occupied square while carrying\n }\n \n next_positions[i] = {nr, nc};\n } else if (action == 'B') {\n if (cranes[i].holding != -1) {\n return false; // Can't bomb while holding container\n }\n will_bomb[i] = true;\n }\n // '.' is always valid\n }\n \n // Check for crane collisions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || actions[i] == '.' || actions[i] == 'P' || actions[i] == 'Q' || actions[i] == 'B') {\n continue;\n }\n \n int nr = next_positions[i].first;\n int nc = next_positions[i].second;\n \n // Check if destination is already occupied by another crane (after move)\n for (int j = 0; j < N; j++) {\n if (i == j || cranes[j].bombed) continue;\n \n if (actions[j] == 'U' || actions[j] == 'D' || actions[j] == 'L' || actions[j] == 'R') {\n if (next_positions[i] == next_positions[j]) {\n return false; // Two cranes moving to same square\n }\n // Check for swapping\n if (next_positions[i].first == cranes[j].row && next_positions[i].second == cranes[j].col &&\n next_positions[j].first == cranes[i].row && next_positions[j].second == cranes[i].col) {\n return false; // Swapping not allowed\n }\n } else if (actions[j] != 'B') {\n // Crane j is staying or doing P/Q\n if (nr == cranes[j].row && nc == cranes[j].col) {\n return false; // Moving to square occupied by stationary crane\n }\n }\n }\n }\n \n // Apply actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n int& r = cranes[i].row;\n int& c = cranes[i].col;\n \n if (action == 'P') {\n cranes[i].holding = grid[r][c];\n grid[r][c] = -1;\n } else if (action == 'Q') {\n grid[r][c] = cranes[i].holding;\n cranes[i].holding = -1;\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n r += dr[d];\n c += dc[d];\n } else if (action == 'B') {\n cranes[i].bombed = true;\n }\n }\n \n // Clear crane grid for next turn\n crane_grid.assign(N, vector(N, false));\n \n // Step 3: Dispatch containers at dispatch gates\n for (int i = 0; i < N; i++) {\n if (grid[i][N-1] != -1) {\n int container = grid[i][N-1];\n containers[container].dispatched = true;\n grid[i][N-1] = -1;\n }\n }\n \n turn_count++;\n return true;\n }\n \n // Check if all containers are dispatched correctly\n bool is_complete() {\n for (int i = 0; i < N*N; i++) {\n if (!containers[i].dispatched) {\n return false;\n }\n }\n return true;\n }\n \npublic:\n Solver(int n, vector>& a) : N(n), A(a) {\n // Initialize cranes\n cranes.resize(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].holding = -1;\n cranes[i].is_large = (i == 0); // Crane 0 is large\n cranes[i].bombed = false;\n }\n \n // Initialize grid\n grid.assign(N, vector(N, -1));\n crane_grid.assign(N, vector(N, false));\n \n // Initialize container info\n containers.resize(N*N);\n for (int i = 0; i < N*N; i++) {\n containers[i].target_row = i / N;\n containers[i].target_order = i % N;\n containers[i].arrived = false;\n containers[i].dispatched = false;\n }\n \n // Set arrival info\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container = A[i][j];\n containers[container].arrival_row = i;\n containers[container].arrival_order = j;\n }\n }\n \n next_container_index.assign(N, 0);\n turn_count = 0;\n }\n \n vector solve() {\n vector results(N, \"\");\n \n // Simulate up to 10000 turns\n for (int turn = 0; turn < 10000; turn++) {\n // Get actions for this turn\n vector actions = get_next_actions();\n \n // Record actions\n for (int i = 0; i < N; i++) {\n results[i] += actions[i];\n }\n \n // Simulate the turn\n if (!simulate_turn(actions)) {\n // Invalid action, but we'll continue with what we have\n break;\n }\n \n // Check if we're done\n if (is_complete()) {\n break;\n }\n }\n \n return results;\n }\n};\n\nint main() {\n int N;\n cin >> N;\n \n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n Solver solver(N, A);\n vector results = solver.solve();\n \n for (int i = 0; i < N; i++) {\n cout << results[i] << endl;\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n\n int r = 0, c = 0;\n int truck = 0;\n vector ops;\n\n while (true) {\n bool all_zero = true;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) {\n all_zero = false;\n break;\n }\n }\n if (!all_zero) break;\n }\n if (all_zero) break;\n\n int target_r = -1, target_c = -1;\n int min_dist = INT_MAX;\n\n if (truck == 0) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break; // safety\n } else {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] < 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break; // safety\n }\n\n // Move to target\n while (r < target_r) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > target_r) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < target_c) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > target_c) {\n ops.push_back(\"L\");\n c--;\n }\n\n // Perform load/unload\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n } else if (h[r][c] < 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n }\n }\n\n for (const string& op : ops) {\n cout << op << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, T;\nint seed_count;\n\n// Compare seeds by total value\nstruct Seed {\n vector values;\n int id;\n int total_value;\n \n Seed() : id(-1), total_value(0) {}\n \n void calculate_total() {\n total_value = 0;\n for (int v : values) {\n total_value += v;\n }\n }\n};\n\nbool compare_seeds(const Seed& a, const Seed& b) {\n return a.total_value > b.total_value;\n}\n\n// Calculate how complementary two seeds are\nint calculate_complementarity(const Seed& a, const Seed& b) {\n int score = 0;\n for (int i = 0; i < M; i++) {\n score += max(a.values[i], b.values[i]);\n }\n return score;\n}\n\n// Calculate expected value of offspring from two seeds\nint calculate_expected_offspring_value(const Seed& a, const Seed& b) {\n int expected_value = 0;\n for (int i = 0; i < M; i++) {\n expected_value += (a.values[i] + b.values[i]) / 2;\n }\n return expected_value;\n}\n\n// Grid position with number of adjacent positions\nstruct Position {\n int row, col;\n int adjacency_count;\n \n Position(int r, int c) : row(r), col(c) {\n adjacency_count = 0;\n if (r > 0) adjacency_count++;\n if (r < N-1) adjacency_count++;\n if (c > 0) adjacency_count++;\n if (c < N-1) adjacency_count++;\n }\n};\n\nbool compare_positions(const Position& a, const Position& b) {\n return a.adjacency_count > b.adjacency_count;\n}\n\nint main() {\n cin >> N >> M >> T;\n seed_count = 2 * N * (N - 1);\n \n vector seeds(seed_count);\n \n // Read initial seeds\n for (int i = 0; i < seed_count; i++) {\n seeds[i].values.resize(M);\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n \n // Process T turns\n for (int t = 0; t < T; t++) {\n // Sort seeds by total value (descending)\n sort(seeds.begin(), seeds.end(), compare_seeds);\n \n // Create grid for planting\n vector> grid(N, vector(N, -1));\n vector used(seed_count, false);\n \n // Generate positions sorted by adjacency count (center positions first)\n vector positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.emplace_back(i, j);\n }\n }\n sort(positions.begin(), positions.end(), compare_positions);\n \n // Plant the top 36 seeds, placing highest value seeds in positions with most neighbors\n for (int i = 0; i < N * N; i++) {\n int row = positions[i].row;\n int col = positions[i].col;\n grid[row][col] = seeds[i].id;\n used[seeds[i].id] = true;\n }\n \n // Output the grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j];\n if (j < N - 1) {\n cout << \" \";\n }\n }\n cout << endl;\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n }\n \n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n bool in_bounds(int N) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nstruct State {\n Point root_pos;\n vector directions; // Direction of each edge (0=R, 1=D, 2=L, 3=U)\n vector holding; // What each fingertip is holding\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector initial_grid, target_grid;\n vector start_positions, target_positions;\n vector tree;\n int V_prime;\n vector fingertips;\n State current_state;\n mt19937 rng;\n \n // Direction vectors: Right, Down, Left, Up\n const vector DX = {1, 0, -1, 0};\n const vector DY = {0, 1, 0, -1};\n const string DIR_CHARS = \"RDLU\";\n \npublic:\n RoboticArmSolver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n void read_input() {\n cin >> N >> M >> V;\n initial_grid.resize(N);\n target_grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> initial_grid[i];\n }\n for (int i = 0; i < N; i++) {\n cin >> target_grid[i];\n }\n \n // Extract start and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '0') {\n start_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '0' && target_grid[i][j] == '1') {\n target_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n // Already in correct position, no need to move\n // But we still count it for M'\n M--;\n }\n }\n }\n \n // Shuffle for randomization\n shuffle(start_positions.begin(), start_positions.end(), rng);\n shuffle(target_positions.begin(), target_positions.end(), rng);\n }\n \n void design_arm() {\n // Determine number of vertices to use\n V_prime = min(V, 10); // Use up to 10 vertices for simplicity\n \n // Build a simple tree: root (0) connected to several children\n // Try to create a balanced tree with multiple fingertips\n tree.resize(V_prime);\n for (int i = 0; i < V_prime; i++) {\n tree[i].is_leaf = true; // Initially all are leaves\n }\n \n // Create tree structure\n // Root at 0\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Add children to root and possibly to other nodes\n int next_vertex = 1;\n vector current_level = {0};\n \n while (next_vertex < V_prime) {\n vector next_level;\n for (int parent : current_level) {\n if (next_vertex >= V_prime) break;\n \n // Add 1-2 children to each node\n int children_count = min(2, V_prime - next_vertex);\n for (int i = 0; i < children_count && next_vertex < V_prime; i++) {\n tree[next_vertex].parent = parent;\n tree[next_vertex].length = 1; // Use length 1 for simplicity\n tree[parent].children.push_back(next_vertex);\n tree[parent].is_leaf = false;\n next_level.push_back(next_vertex);\n next_vertex++;\n }\n }\n current_level = next_level;\n }\n \n // Identify fingertips (leaves)\n for (int i = 0; i < V_prime; i++) {\n if (tree[i].is_leaf) {\n fingertips.push_back(i);\n }\n }\n }\n \n Point find_initial_position() {\n // Find a central position that minimizes distance to start positions\n int best_x = N/2, best_y = N/2;\n double min_dist = 1e9;\n \n // Try positions around center\n for (int x = max(0, N/2 - 2); x <= min(N-1, N/2 + 2); x++) {\n for (int y = max(0, N/2 - 2); y <= min(N-1, N/2 + 2); y++) {\n double dist = 0;\n for (const Point& p : start_positions) {\n dist += abs(p.x - x) + abs(p.y - y);\n }\n if (dist < min_dist) {\n min_dist = dist;\n best_x = x;\n best_y = y;\n }\n }\n }\n \n return Point(best_x, best_y);\n }\n \n // Calculate positions of all vertices given root position and directions\n vector calculate_positions(const Point& root_pos, const vector& directions) {\n vector positions(V_prime);\n positions[0] = root_pos;\n \n for (int i = 1; i < V_prime; i++) {\n int parent = tree[i].parent;\n int dir = directions[i];\n int len = tree[i].length;\n \n positions[i] = Point(\n positions[parent].x + DY[dir] * len, // Note: Y is row, X is column\n positions[parent].y + DX[dir] * len\n );\n }\n \n return positions;\n }\n \n // Find distance between two points\n int manhattan_distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the best move for the arm\n string find_best_move() {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n string command(2 * V_prime, '.');\n \n // First, try to pick up or place takoyaki\n bool did_action = false;\n for (int i = 0; i < fingertips.size() && !did_action; i++) {\n int finger = fingertips[i];\n Point pos = positions[finger];\n \n if (!pos.in_bounds(N)) continue;\n \n // Check if we can pick up a takoyaki\n if (!current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '1' && \n target_grid[pos.x][pos.y] == '0') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = true;\n initial_grid[pos.x][pos.y] = '0'; // Remove from initial grid\n did_action = true;\n continue;\n }\n \n // Check if we can place a takoyaki\n if (current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '0' && \n target_grid[pos.x][pos.y] == '1') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = false;\n initial_grid[pos.x][pos.y] = '1'; // Add to grid (mark as delivered)\n did_action = true;\n continue;\n }\n }\n \n if (did_action) {\n return command;\n }\n \n // No pickup/place action, move toward a target\n // Find closest undelivered takoyaki or target position\n Point target_pos;\n bool move_to_start = false;\n \n if (!start_positions.empty()) {\n // Find closest start position that has a takoyaki\n int min_dist = 1e9;\n for (int i = 0; i < start_positions.size(); i++) {\n if (initial_grid[start_positions[i].x][start_positions[i].y] == '1') {\n int dist = manhattan_distance(current_state.root_pos, start_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n target_pos = start_positions[i];\n move_to_start = true;\n }\n }\n }\n }\n \n // If no start positions available or none have takoyaki, move to target positions\n if (!move_to_start || min_dist == 1e9) {\n for (int i = 0; i < target_positions.size(); i++) {\n if (initial_grid[target_positions[i].x][target_positions[i].y] == '0') {\n int dist = manhattan_distance(current_state.root_pos, target_positions[i]);\n if (dist < min_dist || min_dist == 1e9) {\n min_dist = dist;\n target_pos = target_positions[i];\n move_to_start = false;\n }\n }\n }\n }\n \n // Move toward target\n if (min_dist != 1e9) {\n int dx = target_pos.x - current_state.root_pos.x;\n int dy = target_pos.y - current_state.root_pos.y;\n \n if (dx != 0 || dy != 0) {\n // Determine best direction to move\n char best_dir = '.';\n int best_improvement = -1;\n \n for (int d = 0; d < 4; d++) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (!new_pos.in_bounds(N)) continue;\n \n int new_dist = abs(new_pos.x - target_pos.x) + abs(new_pos.y - target_pos.y);\n int improvement = min_dist - new_dist;\n \n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_dir = DIR_CHARS[d];\n command[0] = best_dir;\n }\n }\n \n // Update root position if we found a valid move\n if (best_dir != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == best_dir) {\n current_state.root_pos.x += DX[d];\n current_state.root_pos.y += DY[d];\n break;\n }\n }\n }\n }\n } else {\n // Random move if no clear target\n vector valid_moves = {'.', 'R', 'D', 'L', 'U'};\n int r = rng() % valid_moves.size();\n command[0] = valid_moves[r];\n \n if (command[0] != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == command[0]) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (new_pos.in_bounds(N)) {\n current_state.root_pos = new_pos;\n }\n break;\n }\n }\n }\n }\n \n // Random rotations to explore different configurations\n if (rng() % 3 == 0) { // 33% chance of rotation\n for (int i = 1; i < V_prime; i++) {\n if (rng() % 3 == 0) { // 33% chance per joint\n if (rng() % 2) {\n command[i] = 'R';\n current_state.directions[i] = (current_state.directions[i] + 1) % 4;\n } else {\n command[i] = 'L';\n current_state.directions[i] = (current_state.directions[i] + 3) % 4;\n }\n }\n }\n }\n \n return command;\n }\n \n void solve() {\n read_input();\n design_arm();\n \n // Output arm design\n cout << V_prime << endl;\n for (int i = 1; i < V_prime; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n \n // Find and output initial position\n Point initial_pos = find_initial_position();\n cout << initial_pos.x << \" \" << initial_pos.y << endl;\n \n // Initialize state\n current_state.root_pos = initial_pos;\n current_state.directions.resize(V_prime, 0); // All start pointing right\n current_state.holding.resize(V_prime, false);\n \n // Generate operations\n vector commands;\n int max_turns = min(50000, 100000); // Limit to avoid TLE\n \n for (int turn = 0; turn < max_turns; turn++) {\n string command = find_best_move();\n commands.push_back(command);\n \n // Check if all takoyaki are delivered\n int delivered = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n delivered++;\n }\n }\n }\n \n // Also count held takoyaki that can be placed\n for (int finger : fingertips) {\n if (current_state.holding[finger]) {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n Point pos = positions[finger];\n if (pos.in_bounds(N) && target_grid[pos.x][pos.y] == '1' && initial_grid[pos.x][pos.y] == '0') {\n delivered++; // Can be delivered in next turn\n }\n }\n }\n \n // If we've delivered all or have extra, break early\n if (delivered >= M) {\n break;\n }\n }\n \n // Output commands\n for (const string& cmd : commands) {\n cout << cmd << endl;\n }\n }\n};\n\nint main() {\n RoboticArmSolver solver;\n solver.solve();\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n int x1, y1, x2, y2; // x1 <= x2, y1 <= y2\n Rectangle(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : x1(x1), y1(y1), x2(x2), y2(y2) {}\n \n bool contains(const Point& p) const {\n return p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2;\n }\n \n int perimeter() const {\n return 2 * ((x2 - x1) + (y2 - y1));\n }\n \n int area() const {\n return (x2 - x1) * (y2 - y1);\n }\n};\n\n// Count points inside rectangle\npair countPoints(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n int mackerelCount = 0, sardineCount = 0;\n for (const auto& p : mackerels) {\n if (rect.contains(p)) mackerelCount++;\n }\n for (const auto& p : sardines) {\n if (rect.contains(p)) sardineCount++;\n }\n return {mackerelCount, sardineCount};\n}\n\n// Calculate score for rectangle\nint calculateScore(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n auto [m, s] = countPoints(mackerels, sardines, rect);\n return max(0, m - s + 1);\n}\n\n// Generate candidate rectangles around clusters of mackerels\nvector generateCandidateRectangles(const vector& mackerels, const vector& sardines) {\n vector candidates;\n \n // Try different sizes of rectangles around each mackerel\n for (int i = 0; i < mackerels.size(); i++) {\n int x = mackerels[i].x;\n int y = mackerels[i].y;\n \n // Try different sizes\n vector sizes = {500, 1000, 2000, 5000, 10000};\n for (int size : sizes) {\n int x1 = max(0, x - size/2);\n int y1 = max(0, y - size/2);\n int x2 = min(100000, x + size/2);\n int y2 = min(100000, y + size/2);\n \n Rectangle rect(x1, y1, x2, y2);\n auto [m, s] = countPoints(mackerels, sardines, rect);\n if (m > s) { // Only consider if beneficial\n candidates.push_back(rect);\n }\n }\n }\n \n // Also try rectangles that cover multiple mackerels\n for (int i = 0; i < min(100, (int)mackerels.size()); i++) {\n for (int j = i + 1; j < min(110, (int)mackerels.size()); j++) {\n int x1 = min(mackerels[i].x, mackerels[j].x);\n int y1 = min(mackerels[i].y, mackerels[j].y);\n int x2 = max(mackerels[i].x, mackerels[j].x);\n int y2 = max(mackerels[i].y, mackerels[j].y);\n \n // Expand a bit\n int dx = (x2 - x1) / 4;\n int dy = (y2 - y1) / 4;\n x1 = max(0, x1 - dx);\n y1 = max(0, y1 - dy);\n x2 = min(100000, x2 + dx);\n y2 = min(100000, y2 + dy);\n \n if (x2 > x1 && y2 > y1) {\n Rectangle rect(x1, y1, x2, y2);\n auto [m, s] = countPoints(mackerels, sardines, rect);\n if (m > s) {\n candidates.push_back(rect);\n }\n }\n }\n }\n \n // Remove duplicates\n sort(candidates.begin(), candidates.end(), [](const Rectangle& a, const Rectangle& b) {\n if (a.x1 != b.x1) return a.x1 < b.x1;\n if (a.y1 != b.y1) return a.y1 < b.y1;\n if (a.x2 != b.x2) return a.x2 < b.x2;\n return a.y2 < b.y2;\n });\n candidates.erase(unique(candidates.begin(), candidates.end(), [](const Rectangle& a, const Rectangle& b) {\n return a.x1 == b.x1 && a.y1 == b.y1 && a.x2 == b.x2 && a.y2 == b.y2;\n }), candidates.end());\n \n return candidates;\n}\n\n// Merge rectangles and create a polygon\nvector mergeRectanglesToPolygon(const vector& rectangles) {\n if (rectangles.empty()) {\n return {};\n }\n \n // Simple approach: create a bounding rectangle of all rectangles\n int x1 = 100000, y1 = 100000, x2 = 0, y2 = 0;\n for (const auto& rect : rectangles) {\n x1 = min(x1, rect.x1);\n y1 = min(y1, rect.y1);\n x2 = max(x2, rect.x2);\n y2 = max(y2, rect.y2);\n }\n \n // Create simple rectangle polygon\n vector polygon;\n polygon.push_back(Point(x1, y1));\n polygon.push_back(Point(x2, y1));\n polygon.push_back(Point(x2, y2));\n polygon.push_back(Point(x1, y2));\n \n return polygon;\n}\n\n// Simplify polygon by removing collinear points\nvector simplifyPolygon(const vector& polygon) {\n if (polygon.size() <= 2) return polygon;\n \n vector simplified;\n simplified.push_back(polygon[0]);\n \n for (int i = 1; i < polygon.size(); i++) {\n if (simplified.size() < 2) {\n simplified.push_back(polygon[i]);\n continue;\n }\n \n // Check if last three points are collinear\n Point p1 = simplified[simplified.size()-2];\n Point p2 = simplified[simplified.size()-1];\n Point p3 = polygon[i];\n \n // Check if they are collinear (cross product = 0)\n long long cross = (long long)(p2.x - p1.x) * (p3.y - p2.y) - (long long)(p2.y - p1.y) * (p3.x - p2.x);\n \n if (cross != 0) {\n simplified.push_back(polygon[i]);\n } else {\n // Replace the middle point with the new point\n simplified.back() = polygon[i];\n }\n }\n \n // Check first and last points with their neighbors\n if (simplified.size() >= 3) {\n Point p1 = simplified[simplified.size()-2];\n Point p2 = simplified[simplified.size()-1];\n Point p3 = simplified[0];\n long long cross = (long long)(p2.x - p1.x) * (p3.y - p2.y) - (long long)(p2.y - p1.y) * (p3.x - p2.x);\n \n if (cross == 0) {\n simplified.pop_back();\n if (!simplified.empty()) {\n simplified.back() = simplified[0];\n }\n }\n }\n \n return simplified;\n}\n\n// Calculate total edge length of polygon\nlong long calculateEdgeLength(const vector& polygon) {\n if (polygon.size() <= 1) return 0;\n \n long long length = 0;\n for (int i = 0; i < polygon.size(); i++) {\n int j = (i + 1) % polygon.size();\n length += abs(polygon[i].x - polygon[j].x) + abs(polygon[i].y - polygon[j].y);\n }\n return length;\n}\n\n// Check if polygon is valid\nbool isValidPolygon(const vector& polygon) {\n if (polygon.size() < 4) return false;\n if (polygon.size() > 1000) return false;\n if (calculateEdgeLength(polygon) > 400000) return false;\n \n // Check coordinates\n for (const auto& p : polygon) {\n if (p.x < 0 || p.x > 100000 || p.y < 0 || p.y > 100000) {\n return false;\n }\n }\n \n // Check uniqueness\n set uniquePoints(polygon.begin(), polygon.end());\n if (uniquePoints.size() != polygon.size()) {\n return false;\n }\n \n return true;\n}\n\n// Greedy algorithm to select best rectangles\nvector selectBestRectangles(const vector& mackerels, const vector& sardines, const vector& candidates) {\n vector selected;\n vector used(candidates.size(), false);\n \n // Sort candidates by score\n vector> scoredCandidates; // (score, index)\n for (int i = 0; i < candidates.size(); i++) {\n int score = calculateScore(mackerels, sardines, candidates[i]);\n if (score > 1) { // Only consider if score > 1\n scoredCandidates.push_back({score, i});\n }\n }\n \n sort(scoredCandidates.begin(), scoredCandidates.end(), greater>());\n \n // Greedily select rectangles\n for (int i = 0; i < min(10, (int)scoredCandidates.size()); i++) {\n int idx = scoredCandidates[i].second;\n selected.push_back(candidates[idx]);\n }\n \n return selected;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n \n vector mackerels(N);\n vector sardines(N);\n \n // Read mackerels\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n \n // Read sardines\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n \n // Generate candidate rectangles\n vector candidates = generateCandidateRectangles(mackerels, sardines);\n \n // If no good candidates, create a simple rectangle around all mackerels\n if (candidates.empty()) {\n int x1 = 100000, y1 = 100000, x2 = 0, y2 = 0;\n for (const auto& p : mackerels) {\n x1 = min(x1, p.x);\n y1 = min(y1, p.y);\n x2 = max(x2, p.x);\n y2 = max(y2, p.y);\n }\n \n // Add some padding\n int dx = (x2 - x1) / 10;\n int dy = (y2 - y1) / 10;\n x1 = max(0, x1 - dx);\n y1 = max(0, y1 - dy);\n x2 = min(100000, x2 + dx);\n y2 = min(100000, y2 + dy);\n \n candidates.push_back(Rectangle(x1, y1, x2, y2));\n }\n \n // Select best rectangles\n vector selected = selectBestRectangles(mackerels, sardines, candidates);\n \n // If still empty, use the best single candidate\n if (selected.empty() && !candidates.empty()) {\n selected.push_back(candidates[0]);\n }\n \n // Merge rectangles into a polygon\n vector polygon = mergeRectanglesToPolygon(selected);\n \n // If polygon is empty, create a simple 4-point rectangle\n if (polygon.empty()) {\n // Create a default rectangle in the middle\n polygon = {\n Point(25000, 25000),\n Point(75000, 25000),\n Point(75000, 75000),\n Point(25000, 75000)\n };\n }\n \n // Simplify polygon\n polygon = simplifyPolygon(polygon);\n \n // Ensure we have at least 4 points\n while (polygon.size() < 4) {\n polygon.push_back(polygon[0]);\n }\n \n // Ensure polygon is valid\n if (!isValidPolygon(polygon)) {\n // Fallback: create a simple rectangle around center of mackerels\n long long sumX = 0, sumY = 0;\n for (const auto& p : mackerels) {\n sumX += p.x;\n sumY += p.y;\n }\n int centerX = sumX / N;\n int centerY = sumY / N;\n \n int size = 10000;\n int x1 = max(0, centerX - size);\n int y1 = max(0, centerY - size);\n int x2 = min(100000, centerX + size);\n int y2 = min(100000, centerY + size);\n \n polygon = {\n Point(x1, y1),\n Point(x2, y1),\n Point(x2, y2),\n Point(x1, y2)\n };\n }\n \n // Output\n cout << polygon.size() << \"\\n\";\n for (const auto& p : polygon) {\n cout << p.x << \" \" << p.y << \"\\n\";\n }\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int w, h;\n int idx;\n};\n\nstruct Placement {\n int p, r;\n char d;\n int b;\n};\n\nclass RectanglePacker {\nprivate:\n int N, T;\n double sigma;\n vector> observed_wh;\n mt19937 rng;\n vector best_placement;\n long long best_score;\n int best_turn;\n vector> feedback_history;\n \npublic:\n RectanglePacker(int seed = 1234) : rng(seed) {\n best_score = LLONG_MAX;\n best_turn = -1;\n }\n \n void readInput() {\n cin >> N >> T >> sigma;\n observed_wh.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> observed_wh[i].first >> observed_wh[i].second;\n }\n }\n \n // Generate a random placement\n vector generateRandomPlacement(int n) {\n vector placement;\n uniform_int_distribution rotation_dist(0, 1);\n uniform_int_distribution direction_dist(0, 1);\n uniform_int_distribution ref_dist;\n \n for (int i = 0; i < n; i++) {\n int r = rotation_dist(rng);\n char d = direction_dist(rng) ? 'L' : 'U';\n int b_max = i - 1;\n int b = b_max >= 0 ? ref_dist(rng, uniform_int_distribution::param_type(-1, b_max)) : -1;\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Generate a greedy placement based on size\n vector generateGreedyPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n // Decide rotation: try to minimize the larger dimension\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n int r = (orig_w > orig_h) ? 1 : 0; // Rotate if width > height\n \n // Alternate between U and L for better packing\n char d = (i % 2 == 0) ? 'U' : 'L';\n \n // Reference to previous rectangle or -1\n int b = (i > 0) ? (i - 1) : -1;\n if (i > 2 && rng() % 3 == 0) {\n b = rng() % i; // Sometimes reference earlier rectangles\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Mutate an existing placement\n vector mutatePlacement(const vector& base, double temp) {\n vector result = base;\n int n = result.size();\n \n // Number of mutations based on temperature\n int num_mutations = max(1, (int)(temp * n / 10.0));\n \n uniform_int_distribution mutation_dist(0, 2); // 0=rotation, 1=direction, 2=reference\n uniform_int_distribution index_dist(0, n - 1);\n \n for (int i = 0; i < num_mutations; i++) {\n int idx = index_dist(rng);\n \n int mutation_type = mutation_dist(rng);\n switch (mutation_type) {\n case 0: // Change rotation\n result[idx].r = 1 - result[idx].r;\n break;\n case 1: // Change direction\n result[idx].d = (result[idx].d == 'U') ? 'L' : 'U';\n break;\n case 2: // Change reference\n int max_ref = idx - 1;\n if (max_ref >= 0) {\n uniform_int_distribution ref_dist(-1, max_ref);\n result[idx].b = ref_dist(rng);\n } else {\n result[idx].b = -1;\n }\n break;\n }\n }\n \n return result;\n }\n \n // Simulated annealing step\n vector getNextPlacement(int turn) {\n double temperature = 1.0 - (double)turn / T;\n \n if (turn == 0) {\n // First turn: try greedy approach\n return generateGreedyPlacement(N);\n }\n \n if (best_turn == -1 || rng() % 100 < 10) { // 10% chance of random restart\n if (rng() % 2 == 0) {\n return generateRandomPlacement(N);\n } else {\n return generateGreedyPlacement(N);\n }\n }\n \n // Otherwise, mutate the best solution found so far\n vector mutated = mutatePlacement(best_placement, temperature);\n \n // Occasionally try a completely different approach\n if (rng() % 100 < 5) {\n int n = min(N, (int)(N * 0.8 + rng() % (N * 0.2 + 1)));\n if (n < N) {\n mutated = generateRandomPlacement(n);\n } else {\n mutated = generateRandomPlacement(N);\n }\n }\n \n return mutated;\n }\n \n void outputPlacement(const vector& placement) {\n cout << placement.size() << endl;\n for (const auto& p : placement) {\n cout << p.p << \" \" << p.r << \" \" << p.d << \" \" << p.b << endl;\n }\n cout.flush();\n }\n \n long long calculateEstimatedScore(int W_prime, int H_prime, int n) {\n // Estimate the score based on noisy measurements\n long long score = (long long)W_prime + (long long)H_prime;\n \n // Add penalty for unused rectangles\n for (int i = n; i < N; i++) {\n score += (long long)observed_wh[i].first + (long long)observed_wh[i].second;\n }\n \n return score;\n }\n \n void processTurn(int turn) {\n vector placement = getNextPlacement(turn);\n \n // Output the placement\n outputPlacement(placement);\n \n // Read feedback\n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n feedback_history.push_back({W_prime, H_prime});\n \n // Calculate estimated score\n long long estimated_score = calculateEstimatedScore(W_prime, H_prime, placement.size());\n \n // Update best solution if this is better\n if (estimated_score < best_score) {\n best_score = estimated_score;\n best_placement = placement;\n best_turn = turn;\n }\n }\n \n void solve() {\n readInput();\n \n for (int turn = 0; turn < T; turn++) {\n processTurn(turn);\n }\n }\n};\n\nint main() {\n // Use current time as seed for randomness\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RectanglePacker packer(static_cast(seed));\n packer.solve();\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n \n vector A(N);\n for (int i = 0; i < N; i++) {\n cin >> A[i];\n }\n \n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n vector> coords(N);\n for (int i = 0; i < N; i++) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Create list of vertices sorted by beauty (descending)\n vector vertices(N);\n for (int i = 0; i < N; i++) {\n vertices[i] = i;\n }\n sort(vertices.begin(), vertices.end(), [&](int a, int b) {\n return A[a] > A[b];\n });\n \n vector parent(N, -2); // -2: unassigned, -1: root\n vector height(N, -1);\n vector used(N, false);\n \n // Greedy tree construction\n for (int start_idx = 0; start_idx < N; start_idx++) {\n int root = vertices[start_idx];\n if (parent[root] != -2) continue; // Already assigned\n \n // Start new tree with this vertex as root\n parent[root] = -1;\n height[root] = 0;\n used[root] = true;\n \n // BFS with priority queue based on beauty value\n priority_queue> pq; // (beauty, vertex)\n pq.push({A[root], root});\n \n while (!pq.empty()) {\n int u = pq.top().second;\n pq.pop();\n \n // If already processed in this tree with better path, skip\n if (used[u] && parent[u] != -1 && u != root) continue;\n \n // Explore neighbors\n for (int v : adj[u]) {\n if (parent[v] != -2) continue; // Already in some tree\n \n // Check if adding this vertex would exceed height limit\n if (height[u] + 1 <= H) {\n parent[v] = u;\n height[v] = height[u] + 1;\n used[v] = true;\n pq.push({A[v], v});\n }\n }\n }\n }\n \n // Assign any remaining unassigned vertices\n for (int i = 0; i < N; i++) {\n if (parent[i] == -2) {\n // Find the best parent among neighbors\n int best_parent = -1;\n int max_benefit = -1;\n \n for (int neighbor : adj[i]) {\n if (parent[neighbor] != -2 && height[neighbor] < H) {\n // Benefit: beauty * (height+1)\n int benefit = A[i] * (height[neighbor] + 1);\n if (benefit > max_benefit) {\n max_benefit = benefit;\n best_parent = neighbor;\n }\n }\n }\n \n if (best_parent != -1) {\n parent[i] = best_parent;\n height[i] = height[best_parent] + 1;\n } else {\n // Make it a root if no suitable parent found\n parent[i] = -1;\n height[i] = 0;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; i++) {\n cout << parent[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n \n // Read input\n cin >> N;\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n vector> operations;\n \n // For each cell that contains an Oni ('x')\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'x') {\n // Check which direction is safe (no Fukunokami)\n bool safe_up = true, safe_down = true, safe_left = true, safe_right = true;\n \n // Check upward direction\n for (int k = 0; k < i; k++) {\n if (board[k][j] == 'o') {\n safe_up = false;\n break;\n }\n }\n \n // Check downward direction\n for (int k = i + 1; k < N; k++) {\n if (board[k][j] == 'o') {\n safe_down = false;\n break;\n }\n }\n \n // Check leftward direction\n for (int k = 0; k < j; k++) {\n if (board[i][k] == 'o') {\n safe_left = false;\n break;\n }\n }\n \n // Check rightward direction\n for (int k = j + 1; k < N; k++) {\n if (board[i][k] == 'o') {\n safe_right = false;\n break;\n }\n }\n \n // Choose a safe direction (at least one is guaranteed to exist)\n if (safe_up) {\n // Shift column j upward (i+1) times\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'U', j});\n }\n // Shift column j downward (i+1) times to restore\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'D', j});\n }\n } else if (safe_down) {\n // Shift column j downward (N-1-i) times\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'D', j});\n }\n // Shift column j upward (N-1-i) times to restore\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'U', j});\n }\n } else if (safe_left) {\n // Shift row i left (j+1) times\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'L', i});\n }\n // Shift row i right (j+1) times to restore\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'R', i});\n }\n } else if (safe_right) {\n // Shift row i right (N-1-j) times\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'R', i});\n }\n // Shift row i left (N-1-j) times to restore\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'L', i});\n }\n }\n }\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\n// Structure to hold the state\nstruct State {\n vector a, b;\n long long error;\n \n State() : a(N), b(N), error(0) {}\n \n // Calculate error for this state\n long long calculateError(const vector& targets) {\n vector counts(N, 0);\n int current = 0; // Start with employee 0\n \n for (int week = 0; week < L; week++) {\n counts[current]++;\n // Determine next employee based on parity of current's count\n if (counts[current] % 2 == 1) { // odd\n current = a[current];\n } else { // even\n current = b[current];\n }\n }\n \n long long total_error = 0;\n for (int i = 0; i < N; i++) {\n total_error += abs(counts[i] - targets[i]);\n }\n return total_error;\n }\n};\n\nclass Solution {\nprivate:\n vector targets;\n mt19937 rng;\n \npublic:\n Solution(const vector& t) : targets(t), rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n // Generate a random initial solution\n State generateInitialSolution() {\n State s;\n \n // Initialize with a reasonable strategy: assign to employees with similar targets\n vector> target_indices;\n for (int i = 0; i < N; i++) {\n target_indices.push_back({targets[i], i});\n }\n sort(target_indices.begin(), target_indices.end());\n \n // For each employee, assign a_i and b_i to those with similar target values\n for (int i = 0; i < N; i++) {\n int idx = -1;\n for (int j = 0; j < N; j++) {\n if (target_indices[j].second == i) {\n idx = j;\n break;\n }\n }\n \n // Assign a_i and b_i to employees with close target values\n if (idx > 0) {\n s.a[i] = target_indices[idx - 1].second;\n } else {\n s.a[i] = target_indices[N - 1].second;\n }\n \n if (idx < N - 1) {\n s.b[i] = target_indices[idx + 1].second;\n } else {\n s.b[i] = target_indices[0].second;\n }\n }\n \n s.error = s.calculateError(targets);\n return s;\n }\n \n // Generate a random solution\n State generateRandomSolution() {\n State s;\n uniform_int_distribution dist(0, N - 1);\n \n for (int i = 0; i < N; i++) {\n s.a[i] = dist(rng);\n s.b[i] = dist(rng);\n }\n \n s.error = s.calculateError(targets);\n return s;\n }\n \n // Try to improve the solution with local search\n State localSearch(State current, int max_iterations) {\n State best = current;\n \n for (int iter = 0; iter < max_iterations; iter++) {\n State candidate = current;\n \n // Randomly perturb one or two assignments\n uniform_int_distribution dist(0, N - 1);\n uniform_int_distribution change_dist(0, 1);\n \n int changes = dist(rng) % 3 + 1; // 1 to 3 changes\n \n for (int c = 0; c < changes; c++) {\n int i = dist(rng);\n if (change_dist(rng) == 0) {\n candidate.a[i] = dist(rng);\n } else {\n candidate.b[i] = dist(rng);\n }\n }\n \n candidate.error = candidate.calculateError(targets);\n \n // Accept if better\n if (candidate.error < best.error) {\n best = candidate;\n current = candidate;\n }\n }\n \n return best;\n }\n \n // Simulated annealing approach\n State simulatedAnnealing(State initial, int max_iterations) {\n State current = initial;\n State best = initial;\n double temperature = 1000.0;\n double cooling_rate = 0.995;\n \n uniform_real_distribution real_dist(0.0, 1.0);\n uniform_int_distribution int_dist(0, N - 1);\n \n for (int iter = 0; iter < max_iterations; iter++) {\n State neighbor = current;\n \n // Make a random change\n int change_type = int_dist(rng) % 3;\n if (change_type == 0) {\n int i = int_dist(rng);\n neighbor.a[i] = int_dist(rng);\n } else if (change_type == 1) {\n int i = int_dist(rng);\n neighbor.b[i] = int_dist(rng);\n } else {\n int i = int_dist(rng);\n neighbor.a[i] = int_dist(rng);\n neighbor.b[i] = int_dist(rng);\n }\n \n neighbor.error = neighbor.calculateError(targets);\n \n // Calculate acceptance probability\n double delta = neighbor.error - current.error;\n double acceptance_probability = exp(-delta / temperature);\n \n // Accept the neighbor\n if (delta < 0 || real_dist(rng) < acceptance_probability) {\n current = neighbor;\n if (current.error < best.error) {\n best = current;\n }\n }\n \n // Cool down\n temperature *= cooling_rate;\n }\n \n return best;\n }\n \n // Main solve function\n State solve() {\n State best_solution;\n best_solution.error = LLONG_MAX;\n \n // Try multiple initial solutions\n const int NUM_TRIALS = 5;\n const int LOCAL_SEARCH_ITERATIONS = 1000;\n const int ANNEALING_ITERATIONS = 2000;\n \n for (int trial = 0; trial < NUM_TRIALS; trial++) {\n State initial;\n \n if (trial == 0) {\n initial = generateInitialSolution();\n } else {\n initial = generateRandomSolution();\n }\n \n // Try local search\n State improved = localSearch(initial, LOCAL_SEARCH_ITERATIONS);\n \n // Try simulated annealing\n State annealed = simulatedAnnealing(improved, ANNEALING_ITERATIONS);\n \n if (annealed.error < best_solution.error) {\n best_solution = annealed;\n }\n \n // Early termination if we get a perfect solution\n if (best_solution.error == 0) {\n break;\n }\n }\n \n return best_solution;\n }\n};\n\nint main() {\n int n, l;\n cin >> n >> l;\n \n vector targets(n);\n for (int i = 0; i < n; i++) {\n cin >> targets[i];\n }\n \n Solution solver(targets);\n State solution = solver.solve();\n \n // Output the solution\n for (int i = 0; i < n; i++) {\n cout << solution.a[i] << \" \" << solution.b[i] << endl;\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\nusing namespace std;\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy; // center coordinates\n};\n\nstruct Edge {\n int u, v;\n double estimated_dist;\n int true_dist = -1; // -1 means unknown\n};\n\n// Calculate estimated distance between city centers\ndouble estimate_distance(const City& a, const City& b) {\n double dx = a.cx - b.cx;\n double dy = a.cy - b.cy;\n return sqrt(dx*dx + dy*dy);\n}\n\n// Calculate minimum possible distance between two bounding boxes\ndouble min_possible_distance(const City& a, const City& b) {\n double min_dx = max(0, max(a.lx - b.rx, b.lx - a.rx));\n double min_dy = max(0, max(a.ly - b.ry, b.ly - a.ay));\n return sqrt(min_dx*min_dx + min_dy*min_dy);\n}\n\n// Calculate maximum possible distance between two bounding boxes\ndouble max_possible_distance(const City& a, const City& b) {\n double max_dx = max(abs(a.lx - b.rx), abs(a.rx - b.lx));\n double max_dy = max(abs(a.ly - b.ry), abs(a.ry - b.ly));\n return sqrt(max_dx*max_dx + max_dy*max_dy);\n}\n\n// Query result structure\nstruct QueryResult {\n vector> edges;\n};\n\nclass Solution {\nprivate:\n int N, M, Q, L, W;\n vector G;\n vector cities;\n mt19937 rng;\n \n // Store results of queries\n map, int> known_distances; // true distances between pairs\n vector query_results;\n \n // For building MST at the end\n vector> final_groups;\n vector>> final_edges;\n \npublic:\n Solution() : rng(random_device{}()) {}\n \n void read_input() {\n cin >> N >> M >> Q >> L >> W;\n G.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n cities.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].id = i;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2.0;\n }\n }\n \n QueryResult make_query(const vector& city_ids) {\n int k = city_ids.size();\n if (k < 2 || k > L) {\n cerr << \"Invalid query size: \" << k << endl;\n return {};\n }\n \n cout << \"? \" << k;\n for (int id : city_ids) {\n cout << \" \" << id;\n }\n cout << endl;\n cout.flush();\n \n QueryResult result;\n for (int i = 0; i < k - 1; i++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n result.edges.push_back({u, v});\n \n // Store this known edge (we don't know the exact distance but we know it's part of MST)\n known_distances[{u, v}] = -1; // Mark as known but distance unknown\n }\n \n query_results.push_back(result);\n return result;\n }\n \n // Estimate if two cities are likely to be close based on bounding boxes\n bool are_likely_close(const City& a, const City& b) {\n double est_dist = estimate_distance(a, b);\n double max_dist = max_possible_distance(a, b);\n \n // If estimated distance is small relative to max possible, they're likely close\n if (est_dist < max_dist * 0.3) {\n return true;\n }\n \n // If bounding boxes overlap, they're likely close\n bool overlap_x = !(a.rx < b.lx || b.rx < a.lx);\n bool overlap_y = !(a.ry < b.ly || b.ry < a.ly);\n if (overlap_x && overlap_y) {\n return true;\n }\n \n return false;\n }\n \n // Initial grouping based on spatial proximity\n void initial_grouping() {\n // Sort cities by x-coordinate of center, then y-coordinate\n vector city_order(N);\n for (int i = 0; i < N; i++) {\n city_order[i] = i;\n }\n \n sort(city_order.begin(), city_order.end(), [this](int a, int b) {\n if (cities[a].cx != cities[b].cx) {\n return cities[a].cx < cities[b].cx;\n }\n return cities[a].cy < cities[b].cy;\n });\n \n // Create initial groups by taking consecutive cities\n final_groups.resize(M);\n int start_idx = 0;\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < G[i]; j++) {\n final_groups[i].push_back(city_order[start_idx + j]);\n }\n start_idx += G[i];\n }\n }\n \n // Refine grouping using queries\n void refine_grouping() {\n // For this implementation, we'll use a simple strategy:\n // 1. For each group, if the group size <= L, query the entire group\n // 2. For larger groups, query overlapping subsets\n \n int queries_used = 0;\n \n // Process each group\n for (int group_idx = 0; group_idx < M && queries_used < Q; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size <= L) {\n // Query the entire group\n QueryResult result = make_query(group);\n queries_used++;\n \n // Store the edges for this group\n final_edges.resize(M);\n for (auto& edge : result.edges) {\n final_edges[group_idx].push_back(edge);\n }\n } else {\n // For larger groups, use sliding window approach\n // Query overlapping triplets (or larger sets up to L)\n int step = max(1, L - 1);\n for (int i = 0; i < group_size - 1 && queries_used < Q; i += step) {\n int end_idx = min(i + L, group_size);\n vector subset;\n for (int j = i; j < end_idx; j++) {\n subset.push_back(group[j]);\n }\n \n QueryResult result = make_query(subset);\n queries_used++;\n \n // Store the edges (we'll reconcile them later when building final MST)\n if (final_edges.size() <= group_idx) {\n final_edges.resize(group_idx + 1);\n }\n for (auto& edge : result.edges) {\n final_edges[group_idx].push_back(edge);\n }\n \n // Early termination if we've used all queries\n if (queries_used >= Q) break;\n }\n }\n }\n }\n \n // Build MST for each group using known edges and estimated distances\n void build_final_msts() {\n final_edges.clear();\n final_edges.resize(M);\n \n for (int group_idx = 0; group_idx < M; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size == 1) {\n // No edges needed\n continue;\n }\n \n // Create a graph with all possible edges in the group\n vector edges;\n for (int i = 0; i < group_size; i++) {\n for (int j = i + 1; j < group_size; j++) {\n int u = group[i];\n int v = group[j];\n if (u > v) swap(u, v);\n \n Edge e;\n e.u = u;\n e.v = v;\n e.estimated_dist = estimate_distance(cities[u], cities[v]);\n \n // If we know this edge from a query, prioritize it\n if (known_distances.count({u, v})) {\n e.estimated_dist = 0; // prioritize known edges\n }\n \n edges.push_back(e);\n }\n }\n \n // Sort edges by estimated distance\n sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {\n return a.estimated_dist < b.estimated_dist;\n });\n \n // Use Kruskal's algorithm to build MST\n vector parent(group_size);\n for (int i = 0; i < group_size; i++) {\n parent[i] = i;\n }\n \n function find = [&](int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n };\n \n auto unite = [&](int x, int y) {\n int rx = find(x);\n int ry = find(y);\n if (rx != ry) {\n parent[rx] = ry;\n return true;\n }\n return false;\n };\n \n // Build MST\n for (const Edge& e : edges) {\n int u_idx = -1, v_idx = -1;\n for (int i = 0; i < group_size; i++) {\n if (group[i] == e.u) u_idx = i;\n if (group[i] == e.v) v_idx = i;\n }\n \n if (u_idx != -1 && v_idx != -1 && unite(u_idx, v_idx)) {\n final_edges[group_idx].push_back({e.u, e.v});\n if (final_edges[group_idx].size() == group_size - 1) {\n break;\n }\n }\n }\n }\n }\n \n void output_answer() {\n cout << \"!\" << endl;\n \n for (int i = 0; i < M; i++) {\n // Output group members\n for (int j = 0; j < final_groups[i].size(); j++) {\n if (j > 0) cout << \" \";\n cout << final_groups[i][j];\n }\n cout << endl;\n \n // Output edges for this group\n for (auto& edge : final_edges[i]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n cout.flush();\n }\n \n void solve() {\n read_input();\n \n // Initial grouping\n initial_grouping();\n \n // Refine grouping with queries\n refine_grouping();\n \n // Build final MSTs for each group\n build_final_msts();\n \n // Output answer\n output_answer();\n }\n};\n\nint main() {\n Solution solution;\n solution.solve();\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Pos {\n int i, j;\n Pos(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator==(const Pos& other) const {\n return i == other.i && j == other.j;\n }\n bool operator<(const Pos& other) const {\n return i < other.i || (i == other.i && j < other.j);\n }\n};\n\nstruct State {\n Pos pos;\n vector> blocks;\n int targetIndex;\n vector actions;\n \n State(Pos p, const vector>& b, int ti) : pos(p), blocks(b), targetIndex(ti) {}\n};\n\n// Direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Manhattan distance\nint manhattan(const Pos& a, const Pos& b) {\n return abs(a.i - b.i) + abs(a.j - b.j);\n}\n\n// Check if position is valid\nbool isValid(const Pos& p, int N) {\n return p.i >= 0 && p.i < N && p.j >= 0 && p.j < N;\n}\n\n// Check if can move to position\nbool canMoveTo(const Pos& from, const Pos& to, const vector>& blocks, int N) {\n if (!isValid(to, N)) return false;\n if (blocks[to.i][to.j]) return false;\n return true;\n}\n\n// Sliding in a direction until hitting a block\nPos slide(const Pos& start, int dir, const vector>& blocks, int N) {\n Pos current = start;\n Pos next = {current.i + di[dir], current.j + dj[dir]};\n \n while (isValid(next, N) && !blocks[next.i][next.j]) {\n current = next;\n next = {current.i + di[dir], current.j + dj[dir]};\n }\n \n return current;\n}\n\n// A* search to find shortest path to target\nvector> findPath(const Pos& start, const Pos& target, vector> blocks, int N) {\n // Priority queue for A* (cost, position, path)\n using QueueItem = tuple>>;\n priority_queue, greater> pq;\n \n // Visited set\n set visited;\n \n // Start state\n pq.push({0, start, {}});\n \n while (!pq.empty()) {\n auto [cost, pos, path] = pq.top();\n pq.pop();\n \n if (pos == target) {\n return path;\n }\n \n if (visited.count(pos)) continue;\n visited.insert(pos);\n \n // Try normal moves in 4 directions\n for (int d = 0; d < 4; d++) {\n Pos next = {pos.i + di[d], pos.j + dj[d]};\n if (canMoveTo(pos, next, blocks, N)) {\n auto newPath = path;\n newPath.push_back({'M', dirChar[d]});\n int newCost = cost + 1 + manhattan(next, target);\n pq.push({newCost, next, newPath});\n }\n }\n \n // Try slides in 4 directions\n for (int d = 0; d < 4; d++) {\n Pos slideEnd = slide(pos, d, blocks, N);\n if (slideEnd != pos) { // Only if we actually moved\n auto newPath = path;\n newPath.push_back({'S', dirChar[d]});\n int newCost = cost + 1 + manhattan(slideEnd, target);\n pq.push({newCost, slideEnd, newPath});\n }\n }\n }\n \n // If A* fails, return empty path\n return {};\n}\n\n// Simple greedy approach for now - we'll enhance if needed\nvector> greedyPath(const Pos& start, const Pos& target, vector>& blocks, int N) {\n vector> actions;\n Pos current = start;\n \n while (current != target) {\n // First, try straight slide if possible\n bool usedSlide = false;\n \n // Check if we can slide directly to target (need to place blocker after)\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(current, next, blocks, N)) {\n // Calculate where we'd end up if we slid in this direction\n Pos slideEnd = slide(current, d, blocks, N);\n \n // If slide would overshoot target, we can place a block to stop at target\n if (d == 0 && current.i > target.i && target.i >= slideEnd.i) { // Up\n if (current.j == target.j) {\n // Check if we can place a block after target to stop there\n Pos blockerPos = {target.i - 1, target.j};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n // Place block\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n // Slide\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n } else if (d == 1 && current.i < target.i && target.i <= slideEnd.i) { // Down\n if (current.j == target.j) {\n Pos blockerPos = {target.i + 1, target.j};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n } else if (d == 2 && current.j > target.j && target.j >= slideEnd.j) { // Left\n if (current.i == target.i) {\n Pos blockerPos = {target.i, target.j - 1};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n } else if (d == 3 && current.j < target.j && target.j <= slideEnd.j) { // Right\n if (current.i == target.i) {\n Pos blockerPos = {target.i, target.j + 1};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n }\n }\n }\n \n if (usedSlide) continue;\n \n // If no slide strategy worked, try normal move\n bool moved = false;\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(current, next, blocks, N)) {\n // Heuristic: prefer moves that get us closer to target\n if (manhattan(next, target) < manhattan(current, target)) {\n actions.push_back({'M', dirChar[d]});\n current = next;\n moved = true;\n break;\n }\n }\n }\n \n // If no good move, try any valid move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(current, next, blocks, N)) {\n actions.push_back({'M', dirChar[d]});\n current = next;\n moved = true;\n break;\n }\n }\n }\n \n // If still can't move, we have a problem\n if (!moved) {\n // Emergency: try to remove a block that might be blocking us\n bool fixed = false;\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (isValid(next, N) && blocks[next.i][next.j]) {\n actions.push_back({'A', dirChar[d]});\n blocks[next.i][next.j] = false;\n fixed = true;\n break;\n }\n }\n \n if (!fixed) {\n // Still stuck, break to avoid infinite loop\n break;\n }\n }\n }\n \n return actions;\n}\n\nint main() {\n int N = 20, M = 40;\n cin >> N >> M;\n \n vector targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].i >> targets[i].j;\n }\n \n // Initialize board with no blocks\n vector> blocks(N, vector(N, false));\n Pos currentPos = targets[0];\n int visitedCount = 0;\n vector> allActions;\n \n // Visit each target in order (starting from index 1 since index 0 is start)\n for (int targetIdx = 1; targetIdx < M; targetIdx++) {\n const Pos& target = targets[targetIdx];\n \n // Special handling: if target has a block, remove it first\n if (blocks[target.i][target.j]) {\n // Find direction to target from current position\n int dir = -1;\n if (currentPos.i == target.i && currentPos.j == target.j + 1) dir = 3; // Right\n else if (currentPos.i == target.i && currentPos.j == target.j - 1) dir = 2; // Left\n else if (currentPos.i == target.i + 1 && currentPos.j == target.j) dir = 1; // Down\n else if (currentPos.i == target.i - 1 && currentPos.j == target.j) dir = 0; // Up\n \n if (dir != -1) {\n allActions.push_back({'A', dirChar[dir]});\n blocks[target.i][target.j] = false;\n } else {\n // Need to move adjacent to target first\n Pos moveTarget;\n if (target.i > 0) moveTarget = {target.i - 1, target.j}; // Try up\n else if (target.i < N-1) moveTarget = {target.i + 1, target.j}; // Try down\n else if (target.j > 0) moveTarget = {target.i, target.j - 1}; // Try left\n else moveTarget = {target.i, target.j + 1}; // Try right\n \n // Path to moveTarget\n auto pathToAdjacent = greedyPath(currentPos, moveTarget, blocks, N);\n for (auto& action : pathToAdjacent) {\n allActions.push_back(action);\n }\n currentPos = moveTarget;\n \n // Now remove block\n dir = (moveTarget.i == target.i - 1) ? 1 : \n (moveTarget.i == target.i + 1) ? 0 :\n (moveTarget.j == target.j - 1) ? 3 : 2;\n allActions.push_back({'A', dirChar[dir]});\n blocks[target.i][target.j] = false;\n \n // Move to target\n allActions.push_back({'M', dirChar[dir]});\n currentPos = target;\n visitedCount++;\n continue;\n }\n }\n \n // Find path to target\n vector> path = greedyPath(currentPos, target, blocks, N);\n \n // Execute path\n for (auto& action : path) {\n allActions.push_back(action);\n \n // Update current position based on action\n if (action.first == 'M') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (canMoveTo(currentPos, next, blocks, N)) {\n currentPos = next;\n }\n } else if (action.first == 'S') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n currentPos = slide(currentPos, dir, blocks, N);\n } else if (action.first == 'A') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos alterPos = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (isValid(alterPos, N)) {\n blocks[alterPos.i][alterPos.j] = !blocks[alterPos.i][alterPos.j];\n }\n }\n }\n \n // Check if we reached the target\n if (currentPos == target) {\n visitedCount++;\n } else {\n // Try one more time with simpler approach\n // Try to move directly if adjacent\n bool reached = false;\n for (int d = 0; d < 4; d++) {\n Pos next = {currentPos.i + di[d], currentPos.j + dj[d]};\n if (next == target && canMoveTo(currentPos, next, blocks, N)) {\n allActions.push_back({'M', dirChar[d]});\n currentPos = next;\n visitedCount++;\n reached = true;\n break;\n }\n }\n \n if (!reached) {\n // Try slide to target\n for (int d = 0; d < 4; d++) {\n Pos slideEnd = slide(currentPos, d, blocks, N);\n if (slideEnd == target) {\n allActions.push_back({'S', dirChar[d]});\n currentPos = target;\n visitedCount++;\n reached = true;\n break;\n }\n }\n }\n \n if (!reached) {\n // Skip this target if we can't reach it, but try to continue with others\n // In a real solution, we'd want to do more to ensure we can reach all targets\n }\n }\n }\n \n // Output all actions\n for (auto& action : allActions) {\n cout << action.first << \" \" << action.second << endl;\n }\n \n return 0;\n}"},"2":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int a, b, c, d; // top-left (a,b), bottom-right (c,d)\n int idx;\n \n Rectangle() : a(0), b(0), c(0), d(0), idx(-1) {}\n Rectangle(int a, int b, int c, int d, int idx) : a(a), b(b), c(c), d(d), idx(idx) {}\n \n int area() const { return (c - a) * (d - b); }\n \n bool contains(double x, double y) const {\n return x >= a && x < c && y >= b && y < d;\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(c <= other.a || other.c <= a || d <= other.b || other.d <= b);\n }\n \n // Returns the overlap area with another rectangle\n int overlapArea(const Rectangle& other) const {\n int overlap_width = max(0, min(c, other.c) - max(a, other.a));\n int overlap_height = max(0, min(d, other.d) - max(b, other.b));\n return overlap_width * overlap_height;\n }\n};\n\nstruct Company {\n int x, y, r, idx;\n double target_x, target_y;\n \n Company() : x(0), y(0), r(0), idx(-1), target_x(0.0), target_y(0.0) {}\n Company(int x, int y, int r, int idx) : x(x), y(y), r(r), idx(idx) {\n target_x = x + 0.5;\n target_y = y + 0.5;\n }\n};\n\n// Calculate satisfaction for a company\ndouble calculateSatisfaction(int desired_area, int actual_area) {\n if (actual_area == 0) return 0.0;\n double ratio = min(desired_area, actual_area) * 1.0 / max(desired_area, actual_area);\n return 1.0 - (1.0 - ratio) * (1.0 - ratio);\n}\n\n// Check if rectangles are valid (within bounds, no overlaps)\nbool isValid(const vector& rects, int n) {\n for (int i = 0; i < n; i++) {\n if (rects[i].a < 0 || rects[i].b < 0 || rects[i].c > 10000 || rects[i].d > 10000) {\n return false;\n }\n if (rects[i].a >= rects[i].c || rects[i].b >= rects[i].d) {\n return false;\n }\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n return false;\n }\n }\n }\n return true;\n}\n\n// Calculate total satisfaction\ndouble calculateTotalSatisfaction(const vector& rects, const vector& companies) {\n double total = 0.0;\n for (int i = 0; i < companies.size(); i++) {\n const Company& c = companies[i];\n const Rectangle& r = rects[i];\n if (r.contains(c.target_x, c.target_y)) {\n total += calculateSatisfaction(c.r, r.area());\n }\n }\n return total;\n}\n\n// Try to create initial rectangles centered at target points\nvector createInitialRectangles(const vector& companies) {\n vector rects(companies.size());\n \n for (int i = 0; i < companies.size(); i++) {\n const Company& c = companies[i];\n \n // Try to create a rectangle centered at (x+0.5, y+0.5) with area close to r_i\n int side = (int)sqrt(c.r);\n if (side * side < c.r) side++;\n \n // Calculate boundaries\n int width = side;\n int height = c.r / width;\n if (width * height < c.r) height++;\n \n // Center around the target point\n int left = (int)(c.target_x - width / 2.0);\n int top = (int)(c.target_y - height / 2.0);\n int right = left + width;\n int bottom = top + height;\n \n // Adjust if out of bounds\n if (left < 0) {\n left = 0;\n right = min(width, 10000);\n }\n if (right > 10000) {\n right = 10000;\n left = max(0, right - width);\n }\n if (top < 0) {\n top = 0;\n bottom = min(height, 10000);\n }\n if (bottom > 10000) {\n bottom = 10000;\n top = max(0, bottom - height);\n }\n \n // Ensure the target point is contained\n if (c.target_x < left + 0.5) left = (int)(c.target_x - 0.5);\n if (c.target_x >= right - 0.5) right = (int)(c.target_x + 1.5);\n if (c.target_y < top + 0.5) top = (int)(c.target_y - 0.5);\n if (c.target_y >= bottom - 0.5) bottom = (int)(c.target_y + 1.5);\n \n // Final bounds check\n left = max(0, left);\n top = max(0, top);\n right = min(10000, right);\n bottom = min(10000, bottom);\n \n rects[i] = Rectangle(left, top, right, bottom, i);\n }\n \n return rects;\n}\n\n// Resolve conflicts between rectangles (greedy approach)\nvoid resolveConflicts(vector& rects, const vector& companies) {\n int n = rects.size();\n const int MAX_ITER = 1000;\n \n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool conflict_resolved = true;\n \n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n conflict_resolved = false;\n \n // Try to shrink one of the rectangles\n // Priority: try to keep the one that's closer to its desired area\n \n double sat_i = rects[i].contains(companies[i].target_x, companies[i].target_y) ? \n calculateSatisfaction(companies[i].r, rects[i].area()) : 0.0;\n double sat_j = rects[j].contains(companies[j].target_x, companies[j].target_y) ? \n calculateSatisfaction(companies[j].r, rects[j].area()) : 0.0;\n \n // Shrink the rectangle with lower satisfaction\n if (sat_i <= sat_j) {\n // Try to shrink rectangle i\n Rectangle orig_i = rects[i];\n \n // Try different ways to shrink\n bool found = false;\n for (int tries = 0; tries < 10 && !found; tries++) {\n // Try reducing width or height\n if (orig_i.c - orig_i.a > 1) {\n int new_a = orig_i.a + 1;\n if (companies[i].target_x >= new_a + 0.5 && companies[i].target_x < orig_i.c - 0.5) {\n rects[i] = Rectangle(new_a, orig_i.b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_i.c - 1;\n if (companies[i].target_x >= orig_i.a + 0.5 && companies[i].target_x < new_c - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, new_c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_i.d - orig_i.b > 1) {\n int new_b = orig_i.b + 1;\n if (companies[i].target_y >= new_b + 0.5 && companies[i].target_y < orig_i.d - 0.5) {\n rects[i] = Rectangle(orig_i.a, new_b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_i.d - 1;\n if (companies[i].target_y >= orig_i.b + 0.5 && companies[i].target_y < new_d - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, orig_i.c, new_d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n \n if (!found) {\n // If can't resolve by shrinking i, try shrinking j\n Rectangle orig_j = rects[j];\n \n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_j.c - orig_j.a > 1) {\n int new_a = orig_j.a + 1;\n if (companies[j].target_x >= new_a + 0.5 && companies[j].target_x < orig_j.c - 0.5) {\n rects[j] = Rectangle(new_a, orig_j.b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_j.c - 1;\n if (companies[j].target_x >= orig_j.a + 0.5 && companies[j].target_x < new_c - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, new_c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_j.d - orig_j.b > 1) {\n int new_b = orig_j.b + 1;\n if (companies[j].target_y >= new_b + 0.5 && companies[j].target_y < orig_j.d - 0.5) {\n rects[j] = Rectangle(orig_j.a, new_b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_j.d - 1;\n if (companies[j].target_y >= orig_j.b + 0.5 && companies[j].target_y < new_d - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, orig_j.c, new_d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n }\n } else {\n // Try shrinking rectangle j first (symmetric to above)\n Rectangle orig_j = rects[j];\n \n bool found = false;\n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_j.c - orig_j.a > 1) {\n int new_a = orig_j.a + 1;\n if (companies[j].target_x >= new_a + 0.5 && companies[j].target_x < orig_j.c - 0.5) {\n rects[j] = Rectangle(new_a, orig_j.b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_j.c - 1;\n if (companies[j].target_x >= orig_j.a + 0.5 && companies[j].target_x < new_c - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, new_c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_j.d - orig_j.b > 1) {\n int new_b = orig_j.b + 1;\n if (companies[j].target_y >= new_b + 0.5 && companies[j].target_y < orig_j.d - 0.5) {\n rects[j] = Rectangle(orig_j.a, new_b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_j.d - 1;\n if (companies[j].target_y >= orig_j.b + 0.5 && companies[j].target_y < new_d - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, orig_j.c, new_d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n \n if (!found) {\n // Try shrinking i\n Rectangle orig_i = rects[i];\n \n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_i.c - orig_i.a > 1) {\n int new_a = orig_i.a + 1;\n if (companies[i].target_x >= new_a + 0.5 && companies[i].target_x < orig_i.c - 0.5) {\n rects[i] = Rectangle(new_a, orig_i.b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_i.c - 1;\n if (companies[i].target_x >= orig_i.a + 0.5 && companies[i].target_x < new_c - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, new_c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_i.d - orig_i.b > 1) {\n int new_b = orig_i.b + 1;\n if (companies[i].target_y >= new_b + 0.5 && companies[i].target_y < orig_i.d - 0.5) {\n rects[i] = Rectangle(orig_i.a, new_b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_i.d - 1;\n if (companies[i].target_y >= orig_i.b + 0.5 && companies[i].target_y < new_d - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, orig_i.c, new_d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n \n if (conflict_resolved) break;\n }\n}\n\n// Try to optimize rectangles by adjusting boundaries\nvoid optimizeRectangles(vector& rects, const vector& companies) {\n int n = rects.size();\n const int MAX_LOCAL_OPT_ITER = 500;\n double best_score = calculateTotalSatisfaction(rects, companies);\n \n // Use a simple local search\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int iter = 0; iter < MAX_LOCAL_OPT_ITER; iter++) {\n // Pick a random rectangle to adjust\n int idx = rng() % n;\n Rectangle orig = rects[idx];\n \n // Try small adjustments to boundaries\n vector> candidates;\n \n // Try moving each boundary by -1, 0, or 1 (if it doesn't cause overlap or exclude target point)\n for (int da : {-1, 0, 1}) {\n for (int db : {-1, 0, 1}) {\n for (int dc : {-1, 0, 1}) {\n for (int dd : {-1, 0, 1}) {\n if (da == 0 && db == 0 && dc == 0 && dd == 0) continue;\n \n int new_a = orig.a + da;\n int new_b = orig.b + db;\n int new_c = orig.c + dc;\n int new_d = orig.d + dd;\n \n // Check bounds\n if (new_a < 0 || new_b < 0 || new_c > 10000 || new_d > 10000) continue;\n if (new_a >= new_c || new_b >= new_d) continue;\n \n // Check target point containment\n double target_x = companies[idx].target_x;\n double target_y = companies[idx].target_y;\n if (target_x < new_a + 0.5 || target_x >= new_c - 0.5 || \n target_y < new_b + 0.5 || target_y >= new_d - 0.5) continue;\n \n // Check for overlaps with other rectangles\n bool has_overlap = false;\n Rectangle test_rect(new_a, new_b, new_c, new_d, idx);\n for (int j = 0; j < n; j++) {\n if (j != idx && test_rect.overlaps(rects[j])) {\n has_overlap = true;\n break;\n }\n }\n \n if (!has_overlap) {\n candidates.push_back({candidates.size(), test_rect});\n }\n }\n }\n }\n }\n \n // If we have candidates, pick the best one\n if (!candidates.empty()) {\n // Score each candidate\n vector> scored_candidates;\n for (auto& cand : candidates) {\n rects[idx] = cand.second;\n double score = calculateTotalSatisfaction(rects, companies);\n scored_candidates.push_back({score, cand.first});\n rects[idx] = orig; // restore\n }\n \n // Sort by score (descending)\n sort(scored_candidates.begin(), scored_candidates.end(), \n [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n // Pick the best improvement (or if none, maybe pick a random one for exploration)\n double best_candidate_score = scored_candidates[0].first;\n if (best_candidate_score > best_score || (rng() % 10 == 0 && !scored_candidates.empty())) {\n // Take the improvement (or sometimes a random candidate for exploration)\n int chosen_idx = 0;\n if (best_candidate_score <= best_score && !scored_candidates.empty()) {\n chosen_idx = rng() % min(3, (int)scored_candidates.size());\n }\n \n rects[idx] = candidates[scored_candidates[chosen_idx].second].second;\n best_score = max(best_score, scored_candidates[chosen_idx].first);\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n \n vector companies;\n for (int i = 0; i < n; i++) {\n int x, y, r;\n cin >> x >> y >> r;\n companies.push_back(Company(x, y, r, i));\n }\n \n // Create initial rectangles\n vector rects = createInitialRectangles(companies);\n \n // Resolve conflicts\n resolveConflicts(rects, companies);\n \n // Local optimization\n optimizeRectangles(rects, companies);\n \n // Final output\n for (int i = 0; i < n; i++) {\n cout << rects[i].a << \" \" << rects[i].b << \" \" << rects[i].c << \" \" << rects[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Tile {\n vector> squares;\n int total_value;\n int id;\n};\n\nclass Solution {\nprivate:\n int si, sj;\n vector> tile_ids;\n vector> values;\n vector tiles;\n int n = 50;\n high_resolution_clock::time_point start_time;\n const double time_limit = 1.9; // Leave 0.1 sec for overhead\n \n // Directions: U, D, L, R\n const vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n const string dir_chars = \"UDLR\";\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < n && j >= 0 && j < n;\n }\n \n double get_elapsed_time() {\n auto now = high_resolution_clock::now();\n auto duration = duration_cast(now - start_time);\n return duration.count() / 1000000.0;\n }\n \n // DFS with iterative deepening and pruning\n string dfs_search() {\n int start_tile_id = tile_ids[si][sj];\n unordered_set visited;\n visited.insert(start_tile_id);\n \n string best_path = \"\";\n int best_score = values[si][sj];\n \n // Try different depth limits\n for (int max_depth = 1; max_depth <= 100 && get_elapsed_time() < time_limit; max_depth++) {\n string current_path = \"\";\n int current_score = values[si][sj];\n int current_i = si, current_j = sj;\n \n dfs_recursive(current_i, current_j, visited, current_path, current_score, \n 0, max_depth, best_path, best_score);\n \n // If we found a complete path or time is running out, break\n if (get_elapsed_time() > time_limit * 0.8) break;\n }\n \n return best_path;\n }\n \n void dfs_recursive(int i, int j, unordered_set& visited, string& current_path,\n int current_score, int depth, int max_depth,\n string& best_path, int& best_score) {\n if (get_elapsed_time() > time_limit) return;\n if (depth >= max_depth) return;\n \n // Try all four directions\n vector> next_moves;\n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n if (visited.find(next_tile_id) == visited.end()) {\n next_moves.push_back({ni, nj});\n }\n }\n }\n \n // Sort moves by tile value (greedy heuristic)\n sort(next_moves.begin(), next_moves.end(), [this](const pair& a, const pair& b) {\n int tile_a = tile_ids[a.first][a.second];\n int tile_b = tile_ids[b.first][b.second];\n return tiles[tile_a].total_value > tiles[tile_b].total_value;\n });\n \n // Limit branches to avoid exponential explosion\n size_t max_branches = min(static_cast(3), next_moves.size());\n if (depth > 10) max_branches = min(static_cast(2), max_branches);\n if (depth > 20) max_branches = min(static_cast(1), max_branches);\n \n for (size_t idx = 0; idx < max_branches && idx < next_moves.size(); idx++) {\n int ni = next_moves[idx].first;\n int nj = next_moves[idx].second;\n int next_tile_id = tile_ids[ni][nj];\n \n // Skip if already visited\n if (visited.find(next_tile_id) != visited.end()) continue;\n \n // Calculate additional score from this tile\n int additional_score = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n if (square.first == ni && square.second == nj) {\n additional_score += values[ni][nj];\n } else {\n additional_score += values[square.first][square.second];\n }\n }\n \n // Make move\n visited.insert(next_tile_id);\n current_path.push_back(dir_chars[get_direction(i, j, ni, nj)]);\n \n int new_score = current_score + additional_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_path = current_path;\n }\n \n // Recurse\n dfs_recursive(ni, nj, visited, current_path, new_score, depth + 1, \n max_depth, best_path, best_score);\n \n // Backtrack\n current_path.pop_back();\n visited.erase(next_tile_id);\n }\n }\n \n int get_direction(int i, int j, int ni, int nj) {\n if (ni == i - 1) return 0; // U\n if (ni == i + 1) return 1; // D\n if (nj == j - 1) return 2; // L\n if (nj == j + 1) return 3; // R\n return -1; // Should never happen\n }\n \n // Greedy algorithm as fallback or for comparison\n string greedy_search() {\n string path = \"\";\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n // Removed unused variable current_score\n \n while (get_elapsed_time() < time_limit) {\n vector>> candidates; // {score, {next_i, next_j}}\n \n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n // Calculate score for this tile\n int tile_score = 0;\n for (auto& square : tiles[tile_id].squares) {\n tile_score += values[square.first][square.second];\n }\n candidates.push_back({tile_score, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) break;\n \n // Sort by score descending\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Pick the best candidate (with some randomness for exploration)\n int choice = 0;\n if (candidates.size() > 1 && get_elapsed_time() < time_limit * 0.5) {\n // Allow some randomness in early stages\n random_device rd;\n mt19937 gen(rd());\n uniform_real_distribution dis(0.0, 1.0);\n if (dis(gen) < 0.3) {\n choice = min(1, (int)candidates.size() - 1);\n }\n }\n \n int ni = candidates[choice].second.first;\n int nj = candidates[choice].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n path.push_back(dir_chars[dir]);\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n return path;\n }\n\npublic:\n void solve() {\n start_time = high_resolution_clock::now();\n \n // Read input\n cin >> si >> sj;\n \n tile_ids = vector>(n, vector(n));\n values = vector>(n, vector(n));\n \n // Read tile IDs\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> tile_ids[i][j];\n }\n }\n \n // Read values\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> values[i][j];\n }\n }\n \n // Build tile data structure\n unordered_map tile_map;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int id = tile_ids[i][j];\n if (tile_map.find(id) == tile_map.end()) {\n tile_map[id] = Tile{{}, 0, id};\n }\n tile_map[id].squares.push_back({i, j});\n tile_map[id].total_value += values[i][j];\n }\n }\n \n // Convert to vector for easier access\n for (auto& kv : tile_map) {\n tiles.push_back(kv.second);\n }\n \n // Try different strategies based on time remaining\n string result = \"\";\n \n // First, try DFS approach\n if (get_elapsed_time() < time_limit * 0.7) {\n result = dfs_search();\n }\n \n // If DFS didn't produce good results or time is running out, try greedy\n if (result.empty() || get_elapsed_time() < time_limit) {\n string greedy_result = greedy_search();\n if (greedy_result.length() > result.length() || \n (greedy_result.length() == result.length() && calculate_score(greedy_result) > calculate_score(result))) {\n result = greedy_result;\n }\n }\n \n // Output result\n cout << result << endl;\n }\n \n // Helper function to calculate score of a path (for comparison)\n int calculate_score(const string& path) {\n if (path.empty()) return values[si][sj];\n \n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n int total_score = values[si][sj];\n \n for (char c : path) {\n int d = (c == 'U') ? 0 : (c == 'D') ? 1 : (c == 'L') ? 2 : 3;\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n for (auto& square : tiles[tile_id].squares) {\n total_score += values[square.first][square.second];\n }\n visited.insert(tile_id);\n }\n \n current_i = ni;\n current_j = nj;\n }\n \n return total_score;\n }\n};\n\nint main() {\n Solution solver;\n solver.solve();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int INF = 1e9;\n\n// Direction arrays for Dijkstra\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Estimated edge weights\nvector> h_est(GRID_SIZE, vector(GRID_SIZE - 1, 5000.0)); // horizontal edges\nvector> v_est(GRID_SIZE - 1, vector(GRID_SIZE, 5000.0)); // vertical edges\n\n// Count of observations for each edge (for averaging)\nvector> h_count(GRID_SIZE, vector(GRID_SIZE - 1, 0));\nvector> v_count(GRID_SIZE - 1, vector(GRID_SIZE, 0));\n\n// For Dijkstra\nstruct Node {\n int x, y, cost;\n string path;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n\n// Check if coordinates are valid\nbool isValid(int x, int y) {\n return x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE;\n}\n\n// Dijkstra's algorithm to find shortest path based on current estimates\nstring dijkstra(int sx, int sy, int tx, int ty) {\n // Priority queue for Dijkstra\n priority_queue, greater> pq;\n vector> dist(GRID_SIZE, vector(GRID_SIZE, INF));\n vector> path(GRID_SIZE, vector(GRID_SIZE, \"\"));\n vector> visited(GRID_SIZE, vector(GRID_SIZE, false));\n \n pq.push({sx, sy, 0, \"\"});\n dist[sx][sy] = 0;\n \n while (!pq.empty()) {\n Node curr = pq.top();\n pq.pop();\n \n int x = curr.x;\n int y = curr.y;\n int cost = curr.cost;\n string currPath = curr.path;\n \n if (visited[x][y]) continue;\n visited[x][y] = true;\n \n // If we reached the target\n if (x == tx && y == ty) {\n return currPath;\n }\n \n // Try all four directions\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n \n if (!isValid(nx, ny)) continue;\n \n int edgeCost = 0;\n // Calculate edge cost based on direction\n if (i == 0 && x > 0) { // Up\n edgeCost = (int)v_est[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) { // Down\n edgeCost = (int)v_est[x][y];\n } else if (i == 2 && y > 0) { // Left\n edgeCost = (int)h_est[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) { // Right\n edgeCost = (int)h_est[x][y];\n } else {\n continue; // Invalid move\n }\n \n if (dist[nx][ny] > cost + edgeCost) {\n dist[nx][ny] = cost + edgeCost;\n pq.push({nx, ny, cost + edgeCost, currPath + dirChar[i]});\n }\n }\n }\n \n // If no path found (shouldn't happen in grid), return a simple path\n string fallback = \"\";\n int cx = sx, cy = sy;\n while (cx != tx) {\n if (cx < tx) {\n fallback += 'D';\n cx++;\n } else {\n fallback += 'U';\n cx--;\n }\n }\n while (cy != ty) {\n if (cy < ty) {\n fallback += 'R';\n cy++;\n } else {\n fallback += 'L';\n cy--;\n }\n }\n return fallback;\n}\n\n// Update edge weight estimates based on the feedback\nvoid updateEstimates(const string& path, int sx, int sy, int actual_cost) {\n // Calculate the expected cost based on current estimates\n int x = sx, y = sy;\n int expected_cost = 0;\n vector> edges_used; // Store edges used in this path\n vector edge_types; // 0: horizontal, 1: vertical\n vector> edge_coords; // Coordinates of edges\n \n for (char dir : path) {\n int nx = x, ny = y;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n \n // Calculate expected cost for this edge\n if (dir == 'U') {\n expected_cost += (int)v_est[x-1][y];\n edges_used.push_back({x-1, y});\n edge_types.push_back(1); // vertical\n edge_coords.push_back({x-1, y});\n } else if (dir == 'D') {\n expected_cost += (int)v_est[x][y];\n edges_used.push_back({x, y});\n edge_types.push_back(1); // vertical\n edge_coords.push_back({x, y});\n } else if (dir == 'L') {\n expected_cost += (int)h_est[x][y-1];\n edges_used.push_back({x, y-1});\n edge_types.push_back(0); // horizontal\n edge_coords.push_back({x, y-1});\n } else if (dir == 'R') {\n expected_cost += (int)h_est[x][y];\n edges_used.push_back({x, y});\n edge_types.push_back(0); // horizontal\n edge_coords.push_back({x, y});\n }\n \n x = nx;\n y = ny;\n }\n \n // Update estimates - distribute the error across all edges in the path\n int path_length = path.length();\n if (path_length > 0) {\n double error = actual_cost - expected_cost;\n double error_per_edge = error / path_length;\n \n for (int i = 0; i < edges_used.size(); i++) {\n int coord1 = edge_coords[i].first;\n int coord2 = edge_coords[i].second;\n \n if (edge_types[i] == 0) { // horizontal edge\n if (h_count[coord1][coord2] == 0) {\n h_est[coord1][coord2] += error_per_edge;\n } else {\n // Weighted average based on number of observations\n h_est[coord1][coord2] = (h_est[coord1][coord2] * h_count[coord1][coord2] + actual_cost * 1.0 / path_length) / (h_count[coord1][coord2] + 1);\n }\n h_count[coord1][coord2]++;\n } else { // vertical edge\n if (v_count[coord1][coord2] == 0) {\n v_est[coord1][coord2] += error_per_edge;\n } else {\n // Weighted average based on number of observations\n v_est[coord1][coord2] = (v_est[coord1][coord2] * v_count[coord1][coord2] + actual_cost * 1.0 / path_length) / (v_count[coord1][coord2] + 1);\n }\n v_count[coord1][coord2]++;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int prev_result = 0;\n \n for (int k = 0; k < 1000; k++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n \n // Find path using current estimates\n string path = dijkstra(si, sj, ti, tj);\n \n // Output path\n cout << path << endl;\n cout.flush(); // Important: flush output\n \n // Read the result\n int result;\n cin >> result;\n \n // Update estimates based on feedback\n updateEstimates(path, si, sj, result);\n \n // Update prev_result for next iteration\n prev_result = result;\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nconst char CHARS[8] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};\n\nclass MatrixSolver {\nprivate:\n int M;\n vector strings;\n vector matrix;\n vector matched;\n mt19937 rng;\n \npublic:\n MatrixSolver(int m, const vector& s) : M(m), strings(s), rng(random_device{}()) {\n // Initialize matrix with most frequent characters\n matrix.resize(N, string(N, '.'));\n matched.resize(M, false);\n \n // Frequency analysis for initialization\n vector charFreq(8, 0);\n for (const string& s : strings) {\n for (char c : s) {\n charFreq[c - 'A']++;\n }\n }\n \n // Fill matrix with most frequent character initially\n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = mostFreqChar;\n }\n }\n }\n \n // Check if string s matches at position (i,j) horizontally\n bool matchesHorizontal(const string& s, int i, int j) const {\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n if (matrix[i][col] != s[p] && matrix[i][col] != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if string s matches at position (i,j) vertically\n bool matchesVertical(const string& s, int i, int j) const {\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n if (matrix[row][j] != s[p] && matrix[row][j] != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if a string matches anywhere in the matrix\n bool matches(const string& s) const {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matchesHorizontal(s, i, j) || matchesVertical(s, i, j)) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Count how many strings are matched\n int countMatches() {\n int count = 0;\n for (int i = 0; i < M; i++) {\n if (matches(strings[i])) {\n matched[i] = true;\n count++;\n } else {\n matched[i] = false;\n }\n }\n return count;\n }\n \n // Get score based on problem definition\n long long getScore(int c, int d) {\n if (c < M) {\n return round(100000000.0 * c / M);\n } else {\n return round(100000000.0 * 2 * N * N / (2 * N * N - d));\n }\n }\n \n // Count number of '.' in matrix\n int countDots() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == '.') {\n count++;\n }\n }\n }\n return count;\n }\n \n // Try to improve matrix by changing one cell\n bool improve() {\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n bool improved = false;\n \n // Try changing each cell to each possible character\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char original = matrix[i][j];\n \n // Try each character A-H\n for (char c : CHARS) {\n if (c == original) continue;\n \n matrix[i][j] = c;\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) {\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n // Keep this change and continue improving\n } else {\n // Revert if not better\n matrix[i][j] = original;\n }\n }\n \n // Also try setting to '.' if it might help\n if (original != '.') {\n matrix[i][j] = '.';\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) {\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n } else {\n matrix[i][j] = original;\n }\n }\n }\n }\n \n return improved;\n }\n \n // Try to fix unmatched strings\n void fixUnmatched() {\n // Count how many times each position is involved in unmatched strings\n vector> positionImportance(N, vector(N, 0));\n \n for (int idx = 0; idx < M; idx++) {\n if (!matched[idx]) {\n const string& s = strings[idx];\n // Mark all positions where this string could potentially be placed\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Check if we can place horizontally\n bool canPlaceHorizontal = true;\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n if (matrix[i][col] != '.' && matrix[i][col] != s[p]) {\n canPlaceHorizontal = false;\n break;\n }\n }\n if (canPlaceHorizontal) {\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n positionImportance[i][col]++;\n }\n }\n \n // Check if we can place vertically\n bool canPlaceVertical = true;\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n if (matrix[row][j] != '.' && matrix[row][j] != s[p]) {\n canPlaceVertical = false;\n break;\n }\n }\n if (canPlaceVertical) {\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n positionImportance[row][j]++;\n }\n }\n }\n }\n }\n }\n \n // Find the most important position and try to set it to help unmatched strings\n int maxImportance = 0;\n int bestI = 0, bestJ = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (positionImportance[i][j] > maxImportance) {\n maxImportance = positionImportance[i][j];\n bestI = i;\n bestJ = j;\n }\n }\n }\n \n if (maxImportance > 0) {\n // Try to determine the best character for this position\n vector charScores(8, 0);\n for (int idx = 0; idx < M; idx++) {\n if (!matched[idx]) {\n const string& s = strings[idx];\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Check horizontal placement\n bool canPlaceHorizontal = true;\n int posInString = -1;\n for (int p = 0; p < s.size(); p++) {\n int col = (j + p) % N;\n if (i == bestI && col == bestJ) {\n posInString = p;\n }\n if (matrix[i][col] != '.' && matrix[i][col] != s[p] && !(i == bestI && col == bestJ)) {\n canPlaceHorizontal = false;\n break;\n }\n }\n if (canPlaceHorizontal && posInString != -1) {\n charScores[s[posInString] - 'A']++;\n }\n \n // Check vertical placement\n bool canPlaceVertical = true;\n posInString = -1;\n for (int p = 0; p < s.size(); p++) {\n int row = (i + p) % N;\n if (row == bestI && j == bestJ) {\n posInString = p;\n }\n if (matrix[row][j] != '.' && matrix[row][j] != s[p] && !(row == bestI && j == bestJ)) {\n canPlaceVertical = false;\n break;\n }\n }\n if (canPlaceVertical && posInString != -1) {\n charScores[s[posInString] - 'A']++;\n }\n }\n }\n }\n }\n \n // Choose the character with highest score\n int bestCharIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charScores[i] > charScores[bestCharIdx]) {\n bestCharIdx = i;\n }\n }\n \n if (charScores[bestCharIdx] > 0) {\n matrix[bestI][bestJ] = 'A' + bestCharIdx;\n }\n }\n }\n \n // Main solve method\n void solve() {\n // Initial evaluation\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n // Time tracking for optimization within time limit\n auto startTime = chrono::steady_clock::now();\n \n // Local search with time limit\n bool improving = true;\n int iteration = 0;\n \n while (improving && iteration < 100) {\n improving = improve();\n iteration++;\n \n // Check time limit (leave some margin)\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2500) break; // 2.5 seconds to be safe\n }\n \n // If we haven't matched all strings, try to fix unmatched ones\n if (currentMatches < M) {\n fixUnmatched();\n }\n \n // One final improvement pass\n improve();\n }\n \n // Output the matrix\n void output() const {\n for (int i = 0; i < N; i++) {\n cout << matrix[i] << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> N >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n MatrixSolver solver(M, strings);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_chars[4] = {'U', 'D', 'L', 'R'};\n\nstruct Position {\n int x, y;\n Position(int x=0, int y=0) : x(x), y(y) {}\n bool operator==(const Position& other) const {\n return x == other.x && y == other.y;\n }\n bool operator<(const Position& other) const {\n return x < other.x || (x == other.x && y < other.y);\n }\n};\n\nstruct State {\n Position pos;\n int cost;\n string path;\n State(Position p, int c, string pa) : pos(p), cost(c), path(pa) {}\n};\n\nint N, si, sj;\nvector grid;\nvector> is_road;\nvector> move_cost;\n\n// Precomputed visibility - for each position, which positions are visible\nvector>> visibility;\n\n// Check if position is within bounds\nbool in_bounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// Precompute visibility for each road square\nvoid precompute_visibility() {\n visibility.resize(N, vector>(N));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!is_road[i][j]) continue;\n \n // Check horizontal visibility (same row)\n for (int j2 = 0; j2 < N; j2++) {\n if (!is_road[i][j2]) continue;\n \n // Check if all squares between (i,j) and (i,j2) are roads\n bool visible = true;\n int start = min(j, j2);\n int end = max(j, j2);\n for (int jj = start; jj <= end; jj++) {\n if (!is_road[i][jj]) {\n visible = false;\n break;\n }\n }\n if (visible) {\n visibility[i][j].insert(Position(i, j2));\n }\n }\n \n // Check vertical visibility (same column)\n for (int i2 = 0; i2 < N; i2++) {\n if (!is_road[i2][j]) continue;\n \n // Check if all squares between (i,j) and (i2,j) are roads\n bool visible = true;\n int start = min(i, i2);\n int end = max(i, i2);\n for (int ii = start; ii <= end; ii++) {\n if (!is_road[ii][j]) {\n visible = false;\n break;\n }\n }\n if (visible) {\n visibility[i][j].insert(Position(i2, j));\n }\n }\n }\n }\n}\n\n// Get all road positions\nvector get_road_positions() {\n vector roads;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (is_road[i][j]) {\n roads.push_back(Position(i, j));\n }\n }\n }\n return roads;\n}\n\n// Calculate total visible squares from a set of visited positions\nset get_visible_squares(const set& visited_positions) {\n set visible;\n for (const Position& pos : visited_positions) {\n for (const Position& v : visibility[pos.x][pos.y]) {\n visible.insert(v);\n }\n }\n return visible;\n}\n\n// Greedy approach to find a route that covers all visible squares\nstring find_route() {\n set visited;\n set covered;\n Position current(si, sj);\n visited.insert(current);\n covered = get_visible_squares(visited);\n \n string route = \"\";\n \n // Continue until all road squares are covered\n vector all_roads = get_road_positions();\n int total_roads = all_roads.size();\n \n // If we already cover everything from start, just return\n if (covered.size() == total_roads) {\n return \"\";\n }\n \n // Greedy selection: at each step, move to position that gives best coverage per cost\n int steps = 0;\n const int MAX_STEPS = N * N * 5; // Limit to avoid infinite loops\n \n while (covered.size() < total_roads && steps < MAX_STEPS) {\n steps++;\n \n // Find best next move\n Position best_next = current;\n int best_ratio = -1; // Newly covered squares per cost\n string best_dir = \"\";\n \n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n Position next(nx, ny);\n int cost = move_cost[nx][ny];\n \n // Calculate newly covered squares if we move to this position\n set new_visited = visited;\n new_visited.insert(next);\n set new_covered = get_visible_squares(new_visited);\n \n int newly_covered = 0;\n for (const Position& p : new_covered) {\n if (covered.find(p) == covered.end()) {\n newly_covered++;\n }\n }\n \n // Calculate ratio (avoid division by zero)\n int ratio = newly_covered * 1000 / cost; // Scale up to avoid precision issues\n \n // Prefer moves that give more new coverage per cost\n if (ratio > best_ratio || (ratio == best_ratio && cost < move_cost[best_next.x][best_next.y])) {\n best_ratio = ratio;\n best_next = next;\n best_dir = string(1, dir_chars[d]);\n }\n }\n \n // If no improvement found, try to move to any unvisited position\n if (best_ratio <= 0) {\n bool found = false;\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n Position next(nx, ny);\n \n // Prefer unvisited positions\n if (visited.find(next) == visited.end()) {\n best_next = next;\n best_dir = string(1, dir_chars[d]);\n found = true;\n break;\n }\n }\n \n // If no unvisited position, just pick any valid move\n if (!found) {\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n best_next = Position(nx, ny);\n best_dir = string(1, dir_chars[d]);\n break;\n }\n }\n }\n \n // Make the move\n current = best_next;\n visited.insert(current);\n set new_covered = get_visible_squares(visited);\n covered = new_covered;\n route += best_dir;\n \n // Early termination if we've covered everything\n if (covered.size() == total_roads) {\n break;\n }\n }\n \n // Return to start\n // Simple BFS to find shortest path back to start\n queue q;\n set visited_back;\n q.push(State(current, 0, \"\"));\n visited_back.insert(current);\n \n while (!q.empty()) {\n State s = q.front();\n q.pop();\n \n if (s.pos.x == si && s.pos.y == sj) {\n route += s.path;\n return route;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = s.pos.x + dx[d];\n int ny = s.pos.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n Position next(nx, ny);\n if (visited_back.find(next) != visited_back.end()) continue;\n \n visited_back.insert(next);\n q.push(State(next, s.cost + move_cost[nx][ny], s.path + dir_chars[d]));\n }\n }\n \n // If BFS failed (shouldn't happen in connected component), try a simple approach\n // Just keep moving in a direction that gets us closer to start\n while (current.x != si || current.y != sj) {\n bool moved = false;\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n // Check if this move gets us closer to start\n int current_dist = abs(current.x - si) + abs(current.y - sj);\n int new_dist = abs(nx - si) + abs(ny - sj);\n \n if (new_dist < current_dist) {\n current = Position(nx, ny);\n route += dir_chars[d];\n moved = true;\n break;\n }\n }\n \n // If no move gets us closer, pick any valid move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n int nx = current.x + dx[d];\n int ny = current.y + dy[d];\n \n if (!in_bounds(nx, ny) || !is_road[nx][ny]) continue;\n \n current = Position(nx, ny);\n route += dir_chars[d];\n break;\n }\n }\n }\n \n return route;\n}\n\n// Simple optimization: remove immediate backtracking (e.g., \"UD\", \"LR\")\nstring optimize_route(const string& route) {\n if (route.empty()) return route;\n \n string optimized = \"\";\n for (char c : route) {\n if (optimized.empty()) {\n optimized += c;\n continue;\n }\n \n char last = optimized.back();\n bool cancel = false;\n \n // Check for immediate backtracking\n if ((c == 'U' && last == 'D') || (c == 'D' && last == 'U') ||\n (c == 'L' && last == 'R') || (c == 'R' && last == 'L')) {\n optimized.pop_back();\n cancel = true;\n }\n \n if (!cancel) {\n optimized += c;\n }\n }\n \n return optimized;\n}\n\nint main() {\n // Read input\n cin >> N >> si >> sj;\n grid.resize(N);\n is_road.resize(N, vector(N, false));\n move_cost.resize(N, vector(N, 0));\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n is_road[i][j] = true;\n move_cost[i][j] = grid[i][j] - '0';\n }\n }\n }\n \n // Precompute visibility\n precompute_visibility();\n \n // Find route\n string route = find_route();\n \n // Simple optimization\n route = optimize_route(route);\n \n // Output the route\n cout << route << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, K, R;\nvector> task_difficulty; // d[i][k] for task i, skill k\nvector> dependencies; // dependencies[i] = list of tasks that must be completed before task i\nvector> reverse_dependencies; // reverse_dependencies[i] = list of tasks that depend on task i\n\n// State tracking\nvector task_status; // -1: not started, 0: in progress, 1: completed\nvector member_assignment; // -1: idle, task_id: working on task\nvector member_busy_until; // day when member becomes available\n\n// Skill estimation\nvector> skill_lower_bound; // Lower bound for s[j][k]\nvector> skill_upper_bound; // Upper bound for s[j][k]\nvector> skill_exact; // Whether we know exact skill level\n\n// Random generator\nmt19937 rng;\n\n// Calculate w[i][j] = sum_k max(0, d[i][k] - s[j][k])\nint calculate_w(int task_id, int member_id) {\n int w = 0;\n for (int k = 0; k < K; k++) {\n int diff = task_difficulty[task_id][k] - skill_lower_bound[member_id][k];\n if (diff > 0) {\n w += diff;\n }\n }\n return w;\n}\n\n// Estimate completion time for task i by member j\nint estimate_completion_time(int task_id, int member_id) {\n int w = calculate_w(task_id, member_id);\n if (w == 0) {\n return 1;\n }\n // Since r_i is between -3 and 3, assume average case (0) for estimation\n return max(1, w);\n}\n\n// Check if task can be started (all dependencies completed)\nbool can_start_task(int task_id) {\n for (int dep : dependencies[task_id]) {\n if (task_status[dep] != 1) {\n return false;\n }\n }\n return true;\n}\n\n// Calculate criticality score for a task (how many tasks depend on it, directly or indirectly)\nint calculate_criticality(int task_id) {\n queue q;\n vector visited(N, false);\n int count = 0;\n \n q.push(task_id);\n visited[task_id] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v : reverse_dependencies[u]) {\n if (!visited[v]) {\n visited[v] = true;\n count++;\n q.push(v);\n }\n }\n }\n \n return count;\n}\n\n// Update skill estimates based on actual completion time\nvoid update_skill_estimates(int task_id, int member_id, int completion_time, int start_day, int end_day) {\n int actual_days = end_day - start_day + 1;\n \n if (actual_days == 1) {\n // w[i][j] = 0, so s[j][k] >= d[i][k] for all k\n for (int k = 0; k < K; k++) {\n skill_lower_bound[member_id][k] = max(skill_lower_bound[member_id][k], task_difficulty[task_id][k]);\n skill_exact[member_id][k] = true; // We know exact minimum\n }\n } else {\n // w[i][j] + r_i = actual_days, so w[i][j] = actual_days - r_i\n // Since r_i is between -3 and 3, w[i][j] is between actual_days-3 and actual_days+3\n // Use actual_days as estimate for w[i][j]\n int estimated_w = actual_days;\n \n // We know sum_k max(0, d[i][k] - s[j][k]) = estimated_w\n // This gives us constraints on s[j][k]\n // For simplicity, distribute the \"deficit\" proportionally\n int current_w = 0;\n vector deficits(K);\n for (int k = 0; k < K; k++) {\n int deficit = max(0, task_difficulty[task_id][k] - skill_lower_bound[member_id][k]);\n deficits[k] = deficit;\n current_w += deficit;\n }\n \n if (current_w < estimated_w) {\n // Our lower bounds are too high, adjust them down\n // This shouldn't happen normally, but can occur due to randomness\n // In this case, we don't update (or could decrease lower bounds)\n } else if (current_w > estimated_w) {\n // Our lower bounds are too low, we need to increase some of them\n // Increase skill estimates for skills with deficits\n int excess = current_w - estimated_w;\n \n // Simple approach: increase lower bounds for skills with deficits\n // Prioritize skills with larger deficits\n vector> deficit_skills;\n for (int k = 0; k < K; k++) {\n if (deficits[k] > 0) {\n deficit_skills.push_back({deficits[k], k});\n }\n }\n \n sort(deficit_skills.rbegin(), deficit_skills.rend());\n \n for (auto& p : deficit_skills) {\n int k = p.second;\n int reduce_by = min(deficits[k], excess);\n if (reduce_by > 0) {\n // This means we overestimated the deficit, so our skill lower bound was too low\n // We can't directly infer the correct skill level, so we'll just note that\n // our estimate was wrong and adjust conservatively\n excess -= reduce_by;\n }\n if (excess == 0) break;\n }\n }\n // If current_w == estimated_w, our estimates are consistent\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Initialize random generator\n rng.seed(12345);\n \n // Parse input\n cin >> N >> M >> K >> R;\n \n task_difficulty.resize(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> task_difficulty[i][k];\n }\n }\n \n dependencies.resize(N);\n reverse_dependencies.resize(N);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--; // Convert to 0-indexed\n dependencies[v].push_back(u);\n reverse_dependencies[u].push_back(v);\n }\n \n // Initialize state\n task_status.assign(N, -1); // -1: not started\n member_assignment.assign(M, -1); // -1: not assigned\n member_busy_until.assign(M, 0);\n \n // Initialize skill estimates\n skill_lower_bound.assign(M, vector(K, 0));\n skill_upper_bound.assign(M, vector(K, INT_MAX));\n skill_exact.assign(M, vector(K, false));\n \n int day = 0;\n vector start_day_of_task(N, -1);\n \n while (true) {\n day++;\n \n // Check if day limit exceeded\n if (day > 2000) {\n break;\n }\n \n // Process completions from previous day\n int n_completed;\n cin >> n_completed;\n \n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n \n vector completed_members(n_completed);\n for (int i = 0; i < n_completed; i++) {\n cin >> completed_members[i];\n completed_members[i]--; // Convert to 0-indexed\n }\n \n // Update task and member status for completed tasks\n for (int member_id : completed_members) {\n int task_id = member_assignment[member_id];\n if (task_id != -1) {\n task_status[task_id] = 1; // Mark as completed\n // Update skill estimates based on completion time\n update_skill_estimates(task_id, member_id, day - start_day_of_task[task_id], start_day_of_task[task_id], day);\n member_assignment[member_id] = -1;\n member_busy_until[member_id] = day;\n }\n }\n \n // Find available team members\n vector available_members;\n for (int j = 0; j < M; j++) {\n if (member_assignment[j] == -1 && member_busy_until[j] < day) {\n available_members.push_back(j);\n }\n }\n \n // Find ready tasks (dependencies satisfied and not started/completed)\n vector ready_tasks;\n for (int i = 0; i < N; i++) {\n if (task_status[i] == -1 && can_start_task(i)) {\n ready_tasks.push_back(i);\n }\n }\n \n // Create assignment output\n vector> assignments; // (member_id, task_id)\n \n if (!available_members.empty() && !ready_tasks.empty()) {\n // Simple greedy assignment: assign tasks to minimize estimated completion time\n // Could use Hungarian algorithm for optimal assignment, but greedy should work well\n \n // Shuffle ready tasks for some randomness (helps exploration)\n shuffle(ready_tasks.begin(), ready_tasks.end(), rng);\n \n // Sort available members by some criterion (e.g., average skill level)\n // For now, just use as is\n \n // Greedy assignment\n vector task_assigned(ready_tasks.size(), false);\n \n for (int member_idx = 0; member_idx < available_members.size(); member_idx++) {\n int member_id = available_members[member_idx];\n \n // Find best task for this member\n int best_task_idx = -1;\n int min_estimated_time = INT_MAX;\n \n for (int task_idx = 0; task_idx < ready_tasks.size(); task_idx++) {\n if (task_assigned[task_idx]) continue;\n \n int task_id = ready_tasks[task_idx];\n int est_time = estimate_completion_time(task_id, member_id);\n \n // Consider task criticality (tasks that unblock more tasks)\n int criticality = calculate_criticality(task_id);\n // Adjust estimated time by criticality (lower priority for critical tasks)\n int adjusted_time = est_time - criticality / 10; // Simple weighting\n \n if (adjusted_time < min_estimated_time) {\n min_estimated_time = adjusted_time;\n best_task_idx = task_idx;\n }\n }\n \n if (best_task_idx != -1) {\n int task_id = ready_tasks[best_task_idx];\n assignments.push_back({member_id, task_id});\n task_assigned[best_task_idx] = true;\n task_status[task_id] = 0; // Mark as in progress\n member_assignment[member_id] = task_id;\n start_day_of_task[task_id] = day;\n }\n }\n }\n \n // Output assignments\n cout << assignments.size();\n for (auto& assignment : assignments) {\n cout << \" \" << assignment.first + 1 << \" \" << assignment.second + 1;\n }\n cout << endl;\n cout.flush(); // Important: flush output\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#include \n\nusing namespace std;\n\nstruct Order {\n int id;\n int pickup_x, pickup_y;\n int delivery_x, delivery_y;\n \n // Calculate Manhattan distance for this order\n int direct_distance() const {\n return abs(pickup_x - delivery_x) + abs(pickup_y - delivery_y);\n }\n \n // Distance from center to pickup and delivery\n int center_distance() const {\n return abs(pickup_x - 400) + abs(pickup_y - 400) + \n abs(delivery_x - 400) + abs(delivery_y - 400);\n }\n \n // \"Efficiency\" metric for order selection\n double efficiency_score() const {\n // Higher score = more efficient to deliver\n // We want orders that are closer to center and have shorter direct distances\n return 1.0 / (center_distance() + direct_distance());\n }\n};\n\n// Calculate Manhattan distance between two points\nint manhattan_distance(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nclass RouteOptimizer {\nprivate:\n vector orders;\n vector selected_orders;\n vector> route;\n vector pickup_done;\n vector delivery_done;\n \n // Track which order each location belongs to\n unordered_map location_to_order;\n \n // For precedence constraint checking\n vector pickup_index;\n vector delivery_index;\n \npublic:\n RouteOptimizer(const vector& all_orders) : orders(all_orders) {\n // Initialize data structures\n pickup_done.resize(50, false);\n delivery_done.resize(50, false);\n pickup_index.resize(50, -1);\n delivery_index.resize(50, -1);\n }\n \n // Select 50 orders based on efficiency\n void select_orders() {\n // Create indexed list for sorting\n vector> scores;\n for (int i = 0; i < 1000; i++) {\n scores.push_back({orders[i].efficiency_score(), i});\n }\n \n // Sort by efficiency (descending)\n sort(scores.begin(), scores.end(), [](const auto& a, const auto& b) {\n return a.first > b.first;\n });\n \n // Select top 50\n selected_orders.clear();\n for (int i = 0; i < 50; i++) {\n selected_orders.push_back(scores[i].second);\n }\n }\n \n // Construct initial route using greedy nearest neighbor\n void construct_initial_route() {\n route.clear();\n route.push_back({400, 400}); // Start at center\n \n // Reset tracking\n fill(pickup_done.begin(), pickup_done.end(), false);\n fill(delivery_done.begin(), delivery_done.end(), false);\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Build route step by step\n int current_x = 400, current_y = 400;\n int steps = 0;\n \n // Continue until all deliveries are done\n while (true) {\n // Find all possible next locations\n vector> candidates; // distance, order_idx, location_type (0=pickup, 1=delivery), actual location index\n \n for (int i = 0; i < 50; i++) {\n if (!pickup_done[i]) {\n // Can pick up this order\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].pickup_x, orders[selected_orders[i]].pickup_y);\n candidates.push_back({dist, i, 0, 2*i});\n } else if (!delivery_done[i]) {\n // Can deliver this order (pickup already done)\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].delivery_x, orders[selected_orders[i]].delivery_y);\n candidates.push_back({dist, i, 1, 2*i+1});\n }\n }\n \n if (candidates.empty()) {\n break; // All done\n }\n \n // Choose the nearest candidate\n sort(candidates.begin(), candidates.end());\n auto [dist, order_idx, loc_type, loc_idx] = candidates[0];\n \n if (loc_type == 0) {\n // Pick up\n pickup_done[order_idx] = true;\n pickup_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].pickup_x;\n current_y = orders[selected_orders[order_idx]].pickup_y;\n route.push_back({current_x, current_y});\n } else {\n // Deliver\n delivery_done[order_idx] = true;\n delivery_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].delivery_x;\n current_y = orders[selected_orders[order_idx]].delivery_y;\n route.push_back({current_x, current_y});\n }\n \n steps++;\n }\n \n // Return to center\n route.push_back({400, 400});\n }\n \n // 2-opt local search to improve route\n void optimize_route_2opt() {\n bool improved = true;\n while (improved) {\n improved = false;\n \n // Try all possible 2-opt swaps\n for (int i = 1; i < (int)route.size() - 2; i++) {\n for (int j = i + 1; j < (int)route.size() - 1; j++) {\n // Check if swap would violate any precedence constraints\n if (is_valid_2opt(i, j)) {\n // Calculate potential improvement\n int current_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[i].first, route[i].second) +\n manhattan_distance(route[j].first, route[j].second, route[j+1].first, route[j+1].second);\n int new_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[j].first, route[j].second) +\n manhattan_distance(route[i].first, route[i].second, route[j+1].first, route[j+1].second);\n \n if (new_cost < current_cost) {\n // Perform the swap\n reverse(route.begin() + i, route.begin() + j + 1);\n improved = true;\n \n // Update pickup/delivery indices\n update_indices();\n \n // Early break to restart search\n break;\n }\n }\n }\n if (improved) break;\n }\n }\n }\n \n // Check if 2-opt swap would violate precedence constraints\n bool is_valid_2opt(int i, int j) {\n // Create a copy of current state\n vector new_pickup_index = pickup_index;\n vector new_delivery_index = delivery_index;\n \n // Simulate the reversal and update indices\n for (int k = i; k <= j; k++) {\n int new_pos = i + (j - k);\n // Check which order this position belongs to\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (pickup_index[order_idx] == k) {\n new_pickup_index[order_idx] = new_pos;\n }\n if (delivery_index[order_idx] == k) {\n new_delivery_index[order_idx] = new_pos;\n }\n }\n }\n \n // Check all precedence constraints\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (new_pickup_index[order_idx] > new_delivery_index[order_idx]) {\n return false; // Violates pickup before delivery\n }\n }\n \n return true;\n }\n \n // Update indices after route modification\n void update_indices() {\n // Reset indices\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Rebuild indices by scanning the route\n for (int pos = 0; pos < (int)route.size(); pos++) {\n for (int i = 0; i < 50; i++) {\n // Check if this position is a pickup for order i\n if (route[pos].first == orders[selected_orders[i]].pickup_x && \n route[pos].second == orders[selected_orders[i]].pickup_y) {\n // Make sure we haven't already recorded this pickup\n if (pickup_index[i] == -1 || \n (pickup_index[i] != -1 && delivery_index[i] != -1)) {\n pickup_index[i] = pos;\n }\n }\n // Check if this position is a delivery for order i\n if (route[pos].first == orders[selected_orders[i]].delivery_x && \n route[pos].second == orders[selected_orders[i]].delivery_y) {\n delivery_index[i] = pos;\n }\n }\n }\n }\n \n // Calculate total route distance\n int calculate_total_distance() {\n int total = 0;\n for (int i = 0; i < (int)route.size() - 1; i++) {\n total += manhattan_distance(route[i].first, route[i].second, \n route[i+1].first, route[i+1].second);\n }\n return total;\n }\n \n // Main optimization method\n void optimize() {\n select_orders();\n construct_initial_route();\n optimize_route_2opt();\n }\n \n // Output the solution\n void output_solution() {\n // Output selected orders (1-indexed)\n cout << \"50\";\n for (int i = 0; i < 50; i++) {\n cout << \" \" << selected_orders[i] + 1; // Convert to 1-indexed\n }\n cout << endl;\n \n // Output route\n cout << route.size();\n for (int i = 0; i < (int)route.size(); i++) {\n cout << \" \" << route[i].first << \" \" << route[i].second;\n }\n cout << endl;\n }\n};\n\nint main() {\n // Read input\n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].pickup_x >> orders[i].pickup_y >> \n orders[i].delivery_x >> orders[i].delivery_y;\n orders[i].id = i;\n }\n \n // Create optimizer and run\n RouteOptimizer optimizer(orders);\n optimizer.optimize();\n optimizer.output_solution();\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Union-Find data structure\nstruct UnionFind {\n vector parent, rank, size;\n int components;\n \n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n size.resize(n, 1);\n components = n;\n for (int i = 0; i < n; i++) {\n parent[i] = i;\n }\n }\n \n int find(int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n }\n \n bool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n \n if (rank[x] < rank[y]) {\n swap(x, y);\n }\n parent[y] = x;\n size[x] += size[y];\n if (rank[x] == rank[y]) {\n rank[x]++;\n }\n components--;\n return true;\n }\n \n bool same(int x, int y) {\n return find(x) == find(y);\n }\n \n int getComponents() {\n return components;\n }\n \n int getSize(int x) {\n return size[find(x)];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 400;\n const int M = 1995;\n \n // Read vertex coordinates\n vector> vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].first >> vertices[i].second;\n }\n \n // Read edges (store for later use)\n vector> edges(M);\n vector base_distances(M);\n \n for (int i = 0; i < M; i++) {\n cin >> edges[i].first >> edges[i].second;\n // Calculate d_i (rounded Euclidean distance)\n int dx = vertices[edges[i].first].first - vertices[edges[i].second].first;\n int dy = vertices[edges[i].first].second - vertices[edges[i].second].second;\n double dist = sqrt(dx*dx + dy*dy);\n base_distances[i] = (int)round(dist);\n }\n \n // Initialize Union-Find\n UnionFind uf(N);\n \n // Process each edge\n for (int i = 0; i < M; i++) {\n int length;\n cin >> length;\n \n int u = edges[i].first;\n int v = edges[i].second;\n int d = base_distances[i];\n \n // Calculate cost ratio\n double ratio = (double)length / d;\n \n // Dynamic threshold based on progress\n // Early on, accept more edges; later, be more selective\n double progress = (double)i / M;\n double threshold = 2.0 - 1.0 * progress; // Start at 2.0, end at 1.0\n \n // If this edge connects different components and the ratio is acceptable\n bool should_accept = !uf.same(u, v) && ratio <= threshold;\n \n // If we still have many components, be more permissive\n if (uf.getComponents() > N/4 && ratio <= threshold + 0.5) {\n should_accept = !uf.same(u, v);\n }\n \n // If this is a very cheap edge, strongly consider accepting\n if (ratio <= 1.2 && !uf.same(u, v)) {\n should_accept = true;\n }\n \n // If we're running out of edges and still have many components, accept more liberally\n if (i > M - N && uf.getComponents() > 1 && !uf.same(u, v)) {\n should_accept = true;\n }\n \n // Output decision\n cout << (should_accept ? 1 : 0) << endl;\n cout.flush(); // Important: flush output\n \n // If accepted, unite the components\n if (should_accept) {\n uf.unite(u, v);\n }\n }\n \n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int MAX_TURNS = 300;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool isValid() const { return x >= 1 && x <= GRID_SIZE && y >= 1 && y <= GRID_SIZE; }\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator<(const Point& other) const { return x < other.x || (x == other.x && y < other.y); }\n};\n\n// Direction vectors for U, D, L, R\nconst vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\nconst string dir_chars = \"UDLR\";\nconst string block_chars = \"udlr\";\n\nclass Grid {\npublic:\n vector> impassable;\n vector human_positions;\n vector pet_positions;\n vector pet_types;\n int N, M;\n \n Grid() {\n impassable = vector>(GRID_SIZE + 1, vector(GRID_SIZE + 1, false));\n }\n \n bool isPassable(const Point& p) {\n if (!p.isValid()) return false;\n return !impassable[p.x][p.y];\n }\n \n // Check if we can make a square impassable (no pets or humans at start of turn, no adjacent pets)\n bool canBlock(const Point& p, const vector& start_human_positions, const vector& current_pet_positions) {\n if (!p.isValid()) return false;\n if (!isPassable(p)) return false; // Already impassable\n \n // Check if any human is at this position at the start of turn\n for (const Point& hp : start_human_positions) {\n if (hp == p) return false;\n }\n \n // Check if any pet is at this position at the start of turn\n for (const Point& pp : current_pet_positions) {\n if (pp == p) return false;\n }\n \n // Check if any adjacent square contains a pet\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (!adj.isValid()) continue;\n for (const Point& pp : current_pet_positions) {\n if (pp == adj) return false;\n }\n }\n \n return true;\n }\n \n // BFS to find reachable area from a point\n set getReachableArea(const Point& start) {\n set visited;\n queue q;\n q.push(start);\n visited.insert(start);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return visited;\n }\n \n // Count pets in a reachable area\n int countPetsInArea(const set& area) {\n int count = 0;\n for (const Point& pet_pos : pet_positions) {\n if (area.find(pet_pos) != area.end()) {\n count++;\n }\n }\n return count;\n }\n \n // Simple distance between two points\n int distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the closest pet to a human\n int findClosestPet(const Point& human_pos) {\n int min_dist = INT_MAX;\n int closest_pet = -1;\n \n for (int i = 0; i < N; i++) {\n int dist = distance(human_pos, pet_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = i;\n }\n }\n \n return closest_pet;\n }\n \n // Check if a pet can reach a human (simple BFS)\n bool canPetReachHuman(const Point& pet_pos, const Point& human_pos) {\n if (!isPassable(pet_pos) || !isPassable(human_pos)) return false;\n \n set visited;\n queue q;\n q.push(pet_pos);\n visited.insert(pet_pos);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n if (curr == human_pos) return true;\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return false;\n }\n \n // Get all adjacent passable squares\n vector getAdjacentPassable(const Point& p) {\n vector result;\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (adj.isValid() && isPassable(adj)) {\n result.push_back(adj);\n }\n }\n return result;\n }\n};\n\nint main() {\n Grid grid;\n \n // Read initial pet positions and types\n cin >> grid.N;\n grid.pet_positions.resize(grid.N);\n grid.pet_types.resize(grid.N);\n for (int i = 0; i < grid.N; i++) {\n cin >> grid.pet_positions[i].x >> grid.pet_positions[i].y >> grid.pet_types[i];\n }\n \n // Read initial human positions\n cin >> grid.M;\n grid.human_positions.resize(grid.M);\n for (int i = 0; i < grid.M; i++) {\n cin >> grid.human_positions[i].x >> grid.human_positions[i].y;\n }\n \n // Strategy variables\n vector human_has_walled(grid.M, false);\n vector wall_progress(grid.M, 0);\n int turn = 0;\n \n while (turn < MAX_TURNS) {\n // Make a copy of human positions at the start of turn for validation\n vector start_human_positions = grid.human_positions;\n string actions = \"\";\n \n // For each human, decide action\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char best_action = '.';\n \n // Early turns: focus on building walls\n if (turn < 150) {\n // Try to build a wall around the human\n bool found_block = false;\n \n // Check all directions for valid blocking\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Prefer blocking in directions away from pets\n bool safe = true;\n for (int j = 0; j < grid.N; j++) {\n int pet_dist = grid.distance(block_pos, grid.pet_positions[j]);\n if (pet_dist <= 2) { // Avoid blocking near pets\n safe = false;\n break;\n }\n }\n \n if (safe) {\n best_action = block_chars[d];\n found_block = true;\n break;\n }\n }\n }\n \n // If can't block safely, try to move away from closest pet\n if (!found_block) {\n int closest_pet = grid.findClosestPet(human_pos);\n if (closest_pet != -1) {\n Point& pet_pos = grid.pet_positions[closest_pet];\n \n // Find direction away from pet\n int dx = human_pos.x - pet_pos.x;\n int dy = human_pos.y - pet_pos.y;\n \n vector> move_dirs;\n if (dx > 0) move_dirs.push_back({0, 0}); // U\n else if (dx < 0) move_dirs.push_back({1, 1}); // D\n if (dy > 0) move_dirs.push_back({2, 2}); // L\n else if (dy < 0) move_dirs.push_back({3, 3}); // R\n \n // If no clear direction away, try any direction\n if (move_dirs.empty()) {\n for (int d = 0; d < 4; d++) {\n move_dirs.push_back({d, d});\n }\n }\n \n // Try to move in the best direction\n for (auto& dir_range : move_dirs) {\n for (int d = dir_range.first; d <= dir_range.second; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n best_action = dir_chars[d];\n break;\n }\n }\n if (best_action != '.') break;\n }\n }\n }\n } \n // Mid to late game: focus on optimizing position\n else {\n // Calculate which action gives best expected score improvement\n double best_score = -1;\n \n // Try staying\n double stay_score = 0;\n \n // Store original position\n Point original_pos = human_pos;\n \n // Try moving in each direction\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n // Temporarily move\n human_pos = move_pos;\n \n // Calculate score for this position\n set area = grid.getReachableArea(human_pos);\n int pet_count = grid.countPetsInArea(area);\n double score = (double)area.size() / 900.0 * pow(0.5, pet_count);\n \n if (score > best_score) {\n best_score = score;\n best_action = dir_chars[d];\n }\n \n // Restore position for next iteration\n human_pos = original_pos;\n }\n }\n \n // Restore original position\n human_pos = original_pos;\n \n // If staying is best or no moves available, stay\n if (best_action == '.' || best_score <= stay_score) {\n best_action = '.';\n }\n \n // Occasionally try to block if it doesn't risk trapping ourselves\n if (turn < 250 && best_action == '.') {\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Check if blocking here would isolate us too much\n grid.impassable[block_pos.x][block_pos.y] = true;\n set area = grid.getReachableArea(human_pos);\n grid.impassable[block_pos.x][block_pos.y] = false;\n \n if (area.size() > 10) { // Don't block if it makes our area too small\n best_action = block_chars[d];\n break;\n }\n }\n }\n }\n }\n \n actions += best_action;\n }\n \n // Now apply all actions simultaneously\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char action = actions[i];\n \n // Update human position if moving\n if (action >= 'A' && action <= 'Z') {\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == action) {\n human_pos.x += dirs[d].first;\n human_pos.y += dirs[d].second;\n break;\n }\n }\n }\n // Update grid if blocking\n else if (action >= 'a' && action <= 'z') {\n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == action) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n grid.impassable[block_pos.x][block_pos.y] = true;\n break;\n }\n }\n }\n // If '.', do nothing\n }\n \n // Output actions\n cout << actions << endl;\n cout.flush();\n \n // Read pet movements\n for (int i = 0; i < grid.N; i++) {\n string move;\n cin >> move;\n \n // Update pet position based on movement\n for (char c : move) {\n int dir_index = -1;\n for (int j = 0; j < 4; j++) {\n if (dir_chars[j] == c) {\n dir_index = j;\n break;\n }\n }\n if (dir_index != -1) {\n grid.pet_positions[i].x += dirs[dir_index].first;\n grid.pet_positions[i].y += dirs[dir_index].second;\n }\n }\n }\n \n turn++;\n }\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors for U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nstruct State {\n int x, y, dist;\n string path;\n State(int x, int y, int dist, string path) : x(x), y(dist), dist(dist), path(path) {}\n};\n\nbool isValid(int x, int y) {\n return x >= 0 && x < 20 && y >= 0 && y < 20;\n}\n\n// BFS to find shortest path\nstring findShortestPath(int sx, int sy, int tx, int ty, \n const vector& h_walls, \n const vector& v_walls) {\n queue q;\n vector> visited(20, vector(20, false));\n \n q.push(State(sx, sy, 0, \"\"));\n visited[sx][sy] = true;\n \n while (!q.empty()) {\n State curr = q.front();\n q.pop();\n \n if (curr.x == tx && curr.y == ty) {\n return curr.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = curr.x + dx[d];\n int ny = curr.y + dy[d];\n \n if (!isValid(nx, ny) || visited[nx][ny]) continue;\n \n // Check walls\n bool canMove = false;\n if (d == 0 && curr.x > 0 && v_walls[curr.x-1][curr.y] == '0') { // Up\n canMove = true;\n } else if (d == 1 && curr.x < 19 && v_walls[curr.x][curr.y] == '0') { // Down\n canMove = true;\n } else if (d == 2 && curr.y > 0 && h_walls[curr.x][curr.y-1] == '0') { // Left\n canMove = true;\n } else if (d == 3 && curr.y < 19 && h_walls[curr.x][curr.y] == '0') { // Right\n canMove = true;\n }\n \n if (canMove) {\n visited[nx][ny] = true;\n q.push(State(nx, ny, curr.dist + 1, curr.path + dir_char[d]));\n }\n }\n }\n \n return \"\"; // Should not happen as guaranteed reachable\n}\n\n// Calculate how many times to repeat the path based on probability p\nint calculateRepetitions(double p, int pathLength) {\n // Higher p means more likely to forget, so we need more repetitions\n // We want to ensure high probability of success while keeping length <= 200\n if (pathLength == 0) return 1;\n \n int maxReps = 200 / pathLength;\n if (maxReps == 0) return 1;\n \n // For high forget probability, use more repetitions\n // For low forget probability, use fewer repetitions to get better score (shorter time)\n int reps = 1;\n if (p >= 0.4) {\n reps = min(maxReps, 5);\n } else if (p >= 0.3) {\n reps = min(maxReps, 3);\n } else if (p >= 0.2) {\n reps = min(maxReps, 2);\n } else {\n reps = 1;\n }\n \n return reps;\n}\n\nint main() {\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n vector h_walls(20);\n for (int i = 0; i < 20; i++) {\n if (i < 19) {\n cin >> h_walls[i];\n } else {\n // For i=19, there are no horizontal walls below (out of bounds)\n h_walls[i] = string(19, '1'); // Initialize with walls\n }\n }\n \n vector v_walls(19);\n for (int i = 0; i < 19; i++) {\n cin >> v_walls[i];\n }\n \n // Find shortest path\n string shortestPath = findShortestPath(si, sj, ti, tj, h_walls, v_walls);\n \n // Calculate repetitions based on forget probability\n int repetitions = calculateRepetitions(p, shortestPath.length());\n \n // Create final path by repeating the shortest path\n string finalPath = \"\";\n for (int i = 0; i < repetitions; i++) {\n finalPath += shortestPath;\n // If we're already at max length, break\n if (finalPath.length() >= 200) {\n finalPath = finalPath.substr(0, 200);\n break;\n }\n }\n \n // Ensure we don't exceed 200 characters\n if (finalPath.length() > 200) {\n finalPath = finalPath.substr(0, 200);\n }\n \n cout << finalPath << endl;\n \n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction constants: left, up, right, down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// Transition table: to[tile_type][entry_direction] = exit_direction or -1 if invalid\nconst int to[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\nconst int N = 30;\n\nclass Solution {\nprivate:\n vector> grid;\n vector> rotations;\n mt19937 rng;\n chrono::steady_clock::time_point start_time;\n \npublic:\n Solution(const vector>& input_grid) : grid(input_grid), rng(random_device{}()) {\n rotations = vector>(N, vector(N, 0));\n }\n \n // Get the actual tile type after rotation\n int get_rotated_tile(int i, int j) {\n int base_type = grid[i][j];\n int rot = rotations[i][j] % 4;\n \n // Tile mapping after rotation\n if (base_type <= 3) {\n return (base_type + rot) % 4;\n } else if (base_type <= 5) {\n if (base_type == 4) {\n if (rot % 2 == 0) return 4;\n else return 5;\n } else { // base_type == 5\n if (rot % 2 == 0) return 5;\n else return 4;\n }\n } else { // base_type >= 6\n if (base_type == 6) {\n if (rot % 2 == 0) return 6;\n else return 7;\n } else { // base_type == 7\n if (rot % 2 == 0) return 7;\n else return 6;\n }\n }\n }\n \n // Calculate the length of a loop starting from (i, j) with direction d\n int calculate_loop_length(int si, int sj, int sd) {\n int i = si, j = sj, d = sd;\n int length = 0;\n int max_steps = N * N * 4; // Safety limit to prevent infinite loops\n \n for (int step = 0; step < max_steps; step++) {\n int tile_type = get_rotated_tile(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0; // Line is broken\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= N || j < 0 || j >= N) return 0; // Out of bounds\n \n d = (d2 + 2) % 4; // Direction to the previous tile\n length++;\n \n // Check if we returned to start\n if (i == si && j == sj && d == sd) {\n return length;\n }\n }\n \n return 0; // Safety: prevent infinite loops\n }\n \n // Find all loops and return their lengths\n vector find_all_loops() {\n vector loop_lengths;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions and directions in this loop as visited\n int ci = i, cj = j, cd = d;\n int steps = 0;\n int max_steps = N * N * 4;\n \n do {\n if (steps >= max_steps) break;\n visited[ci][cj][cd] = true;\n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n if (d2 == -1) break;\n \n ci += di[d2];\n cj += dj[d2];\n \n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n cd = (d2 + 2) % 4;\n steps++;\n } while (!(ci == i && cj == j && cd == d));\n \n loop_lengths.push_back(length);\n }\n }\n }\n \n // Early termination if running out of time\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1700) {\n return loop_lengths;\n }\n }\n \n // Sort in descending order\n sort(loop_lengths.rbegin(), loop_lengths.rend());\n return loop_lengths;\n }\n \n // Calculate score: L1 * L2 (0 if less than 2 loops)\n long long calculate_score() {\n vector loops = find_all_loops();\n if (loops.size() < 2) return 0;\n return (long long)loops[0] * loops[1];\n }\n \n // Randomly initialize rotations\n void random_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n rotations[i][j] = uniform_int_distribution(0, 3)(rng);\n }\n }\n }\n \n // Try to improve solution using simulated annealing\n void simulated_annealing() {\n long long current_score = calculate_score();\n \n const double initial_temp = 500.0; // Reduced from 1000\n const double final_temp = 5.0; // Increased from 1\n const double cooling_rate = 0.999; // Faster cooling\n \n double temp = initial_temp;\n int max_iterations = 5000; // Limit iterations\n \n for (int iter = 0; iter < max_iterations; iter++) {\n // Pick a random tile to modify\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n \n // Save current rotation\n int old_rot = rotations[i][j];\n \n // Try a new rotation\n int new_rot = uniform_int_distribution(0, 3)(rng);\n rotations[i][j] = new_rot;\n \n // Calculate new score\n long long new_score = calculate_score();\n \n // Accept or reject based on simulated annealing\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n }\n }\n \n if (!accept) {\n // Revert\n rotations[i][j] = old_rot;\n } else {\n current_score = new_score;\n }\n \n // Cool down\n temp *= cooling_rate;\n \n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1800) { // Stop before 2 seconds\n break;\n }\n }\n }\n \n // Run fewer restarts with time limit\n void optimize() {\n start_time = chrono::steady_clock::now();\n long long best_score = 0;\n vector> best_rotations = rotations;\n \n // Try fewer random starts (2 instead of 5)\n for (int restart = 0; restart < 2; restart++) {\n random_init();\n simulated_annealing();\n \n long long score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n \n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1850) { // Stop before time limit\n break;\n }\n }\n \n rotations = best_rotations;\n }\n \n // Output the solution\n string get_output() {\n string result = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n result += char('0' + rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n // Read input\n vector> grid(N, vector(N));\n for (int i = 0; i < N; i++) {\n string line;\n cin >> line;\n for (int j = 0; j < N; j++) {\n grid[i][j] = line[j] - '0';\n }\n }\n \n // Create and optimize solution\n Solution solution(grid);\n solution.optimize();\n \n // Output result\n cout << solution.get_output() << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\nconst int opposite_dir[4] = {1, 0, 3, 2}; // Opposite of U,D,L,R\n\nstruct State {\n vector board;\n int empty_x, empty_y;\n string moves;\n int score;\n \n // Default constructor\n State() : empty_x(-1), empty_y(-1), score(0) {}\n \n // Parameterized constructor\n State(const vector& b, int ex, int ey, const string& m = \"\") \n : board(b), empty_x(ex), empty_y(ey), moves(m) {\n score = calculateScore();\n }\n \n int calculateScore() const {\n if (board.empty() || empty_x == -1) return 0;\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n // BFS to find connected component\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down (8) connects to up (2) of tile below\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right (4) connects to left (1) of tile right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n }\n \n bool operator<(const State& other) const {\n return score < other.score;\n }\n};\n\n// Calculate the score of a board configuration\nint calculateScore(const vector& board) {\n if (board.empty()) return 0;\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n // BFS to find connected component\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down (8) connects to up (2) of tile below\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right (4) connects to left (1) of tile right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n}\n\n// Check if a move is valid\nbool isValidMove(int x, int y, int n) {\n return x >= 0 && x < n && y >= 0 && y < n;\n}\n\n// Apply a move to the board\nvoid applyMove(vector& board, int& empty_x, int& empty_y, int dir) {\n int new_x = empty_x + dx[dir];\n int new_y = empty_y + dy[dir];\n \n // Swap the empty space with the tile\n swap(board[empty_x][empty_y], board[new_x][new_y]);\n empty_x = new_x;\n empty_y = new_y;\n}\n\n// Heuristic: try to maximize the size of the largest connected component\nstring solve(const vector& initial_board, int N, int T) {\n int empty_x = -1, empty_y = -1;\n \n // Find the empty space\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_board[i][j] == '0') {\n empty_x = i;\n empty_y = j;\n break;\n }\n }\n if (empty_x != -1) break;\n }\n \n // If we're already at max score, return empty string\n int current_score = calculateScore(initial_board);\n if (current_score == N*N-1) {\n return \"\";\n }\n \n // Use a beam search approach for better performance\n const int BEAM_WIDTH = 50;\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(State(initial_board, empty_x, empty_y, \"\"));\n \n // Try to find a good solution within T moves\n for (int step = 0; step < T && !beam.empty(); step++) {\n vector next_beam;\n next_beam.reserve(BEAM_WIDTH * 4); // Reserve space for potential moves\n \n for (auto& state : beam) {\n // Try all possible moves\n for (int dir = 0; dir < 4; dir++) {\n int new_x = state.empty_x + dx[dir];\n int new_y = state.empty_y + dy[dir];\n \n // Skip if move is invalid or would undo previous move\n if (!isValidMove(new_x, new_y, N)) continue;\n if (state.moves.size() > 0 && \n dir == opposite_dir[state.moves.back() - 'U']) continue;\n \n // Make a copy and apply the move\n vector new_board = state.board;\n int new_empty_x = state.empty_x;\n int new_empty_y = state.empty_y;\n string new_moves = state.moves + dir_char[dir];\n \n // Apply the move\n swap(new_board[new_empty_x][new_empty_y], new_board[new_x][new_y]);\n new_empty_x = new_x;\n new_empty_y = new_y;\n \n // Create new state\n State new_state(new_board, new_empty_x, new_empty_y, new_moves);\n \n // If we found a full tree, return immediately\n if (new_state.score == N*N-1) {\n return new_state.moves;\n }\n \n next_beam.push_back(new_state);\n }\n }\n \n // Sort by score (descending) and keep only the best BEAM_WIDTH states\n sort(next_beam.begin(), next_beam.end(), [](const State& a, const State& b) {\n if (a.score != b.score) return a.score > b.score;\n return a.moves.size() < b.moves.size(); // Prefer shorter sequences\n });\n \n if (next_beam.size() > BEAM_WIDTH) {\n next_beam.resize(BEAM_WIDTH);\n }\n \n beam = next_beam;\n }\n \n // Return the best solution found\n if (!beam.empty()) {\n sort(beam.begin(), beam.end(), [](const State& a, const State& b) {\n if (a.score != b.score) return a.score > b.score;\n return a.moves.size() < b.moves.size();\n });\n return beam[0].moves;\n }\n \n return \"\";\n}\n\nint main() {\n int N, T;\n cin >> N >> T;\n \n vector board(N);\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n string solution = solve(board, N, T);\n cout << solution << endl;\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n long long x, y;\n Point() : x(0), y(0) {}\n Point(long long x, long long y) : x(x), y(y) {}\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n \n long long cross(const Point& other) const {\n return x * other.y - y * other.x;\n }\n \n long long dot(const Point& other) const {\n return x * other.x + y * other.y;\n }\n \n long long dist2() const {\n return x * x + y * y;\n }\n \n double dist() const {\n return sqrt(x * x + y * y);\n }\n};\n\nstruct Line {\n Point p1, p2;\n Line() {}\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\n// Ensure point coordinates are within bounds\nPoint clampPoint(Point p) {\n const long long MIN_VAL = -1000000000;\n const long long MAX_VAL = 1000000000;\n p.x = max(MIN_VAL, min(MAX_VAL, p.x));\n p.y = max(MIN_VAL, min(MAX_VAL, p.y));\n return p;\n}\n\n// Check which side of the line a point is on\n// Returns: 1 if on one side, -1 if on the other, 0 if on the line\nint side(const Point& p, const Line& line) {\n Point v1 = line.p2 - line.p1;\n Point v2 = p - line.p1;\n long long cross = v1.cross(v2);\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\n// Check if a point is strictly inside a region defined by lines\n// Each line defines a half-plane, and we need to be on the correct side of all lines\nbool isInside(const Point& p, const vector& lines, const vector& sides) {\n for (int i = 0; i < lines.size(); i++) {\n int s = side(p, lines[i]);\n if (s != sides[i]) return false;\n }\n return true;\n}\n\n// Try to find a line that separates a group of strawberries from others\nLine findSeparatingLine(const vector& strawberries, const vector& group, const vector& existingLines) {\n // Simple approach: try to find a line that roughly separates the group from others\n if (group.size() == 0) {\n return Line(Point(0, 0), Point(1, 0));\n }\n \n // Calculate centroid of group\n Point centroid(0, 0);\n for (int i : group) {\n centroid.x += strawberries[i].x;\n centroid.y += strawberries[i].y;\n }\n centroid.x /= group.size();\n centroid.y /= group.size();\n \n // Calculate centroid of other strawberries\n vector others;\n for (int i = 0; i < strawberries.size(); i++) {\n if (find(group.begin(), group.end(), i) == group.end()) {\n others.push_back(i);\n }\n }\n \n if (others.empty()) {\n // If no others, just use a line near the group\n Point p1(centroid.x - 1, centroid.y - 1);\n Point p2(centroid.x + 1, centroid.y + 1);\n return Line(clampPoint(p1), clampPoint(p2));\n }\n \n Point otherCentroid(0, 0);\n for (int i : others) {\n otherCentroid.x += strawberries[i].x;\n otherCentroid.y += strawberries[i].y;\n }\n otherCentroid.x /= others.size();\n otherCentroid.y /= others.size();\n \n // Line perpendicular to the line connecting centroids\n Point dir = otherCentroid - centroid;\n Point perp(-dir.y, dir.x);\n \n // Make sure the points are integers and within bounds\n Point p1(centroid.x + perp.x, centroid.y + perp.y);\n Point p2(centroid.x - perp.x, centroid.y - perp.y);\n \n // Scale to make sure they're far enough apart but still within bounds\n if (p1.dist2() < 100) {\n // Scale but ensure we don't go out of bounds\n long long scale = 1000;\n // Check if scaling would exceed bounds\n if (abs(p1.x * scale) > 1000000000 || abs(p1.y * scale) > 1000000000) {\n scale = 1;\n }\n p1.x *= scale;\n p1.y *= scale;\n p2.x *= scale;\n p2.y *= scale;\n }\n \n // Ensure bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n return Line(p1, p2);\n}\n\n// Calculate distance between two points\ndouble distance(const Point& a, const Point& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\n// Try to improve a line to minimize strawberries on it\nLine improveLine(const Line& line, const vector& strawberries, const vector& otherLines) {\n Line bestLine = line;\n int bestOnLine = strawberries.size();\n \n // Try small perturbations within bounds\n for (int dx1 = -1; dx1 <= 1; dx1++) {\n for (int dy1 = -1; dy1 <= 1; dy1++) {\n for (int dx2 = -1; dx2 <= 1; dx2++) {\n for (int dy2 = -1; dy2 <= 1; dy2++) {\n Point newP1(line.p1.x + dx1, line.p1.y + dy1);\n Point newP2(line.p2.x + dx2, line.p2.y + dy2);\n \n // Clamp to bounds\n newP1 = clampPoint(newP1);\n newP2 = clampPoint(newP2);\n \n // Skip if points are the same\n if (newP1.x == newP2.x && newP1.y == newP2.y) {\n // Make them different\n if (newP2.x < 1000000000) newP2.x += 1;\n else if (newP2.x > -1000000000) newP2.x -= 1;\n else if (newP2.y < 1000000000) newP2.y += 1;\n else newP2.y -= 1;\n }\n \n Line newLine(newP1, newP2);\n \n // Calculate score: minimize strawberries on line\n int onLine = 0;\n for (const Point& s : strawberries) {\n if (side(s, newLine) == 0) {\n onLine++;\n }\n }\n \n // Prefer lines with fewer strawberries on them\n if (onLine < bestOnLine) {\n bestOnLine = onLine;\n bestLine = newLine;\n }\n }\n }\n }\n }\n \n return bestLine;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n cin >> N >> K;\n \n vector a(10);\n for (int i = 0; i < 10; i++) {\n cin >> a[i];\n }\n \n vector strawberries(N);\n for (int i = 0; i < N; i++) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n \n // We'll use a greedy approach to create pieces of desired sizes\n vector lines;\n vector used(N, false);\n \n // First, try to create single strawberry pieces\n for (int d = 0; d < 10; d++) {\n if (a[d] == 0) continue;\n \n // Target: create a[d] pieces with d+1 strawberries each\n int targetCount = a[d];\n int strawberriesPerPiece = d + 1;\n \n for (int piece = 0; piece < targetCount && lines.size() < K; piece++) {\n // Find a group of strawberriesPerPiece strawberries that are close to each other\n vector group;\n \n // Find unused strawberries\n vector unused;\n for (int i = 0; i < N; i++) {\n if (!used[i]) {\n unused.push_back(i);\n }\n }\n \n if (unused.size() < strawberriesPerPiece) {\n // Not enough unused strawberries, skip\n break;\n }\n \n // Use a simple greedy approach: pick the first available strawberries\n for (int i = 0; i < strawberriesPerPiece && i < unused.size(); i++) {\n group.push_back(unused[i]);\n used[unused[i]] = true;\n }\n \n // If we need to isolate this group, add a line\n if (strawberriesPerPiece < N && !group.empty()) {\n // Find a line that separates this group from others (if possible)\n Line separatingLine = findSeparatingLine(strawberries, group, lines);\n \n // Try to improve the line to avoid cutting through strawberries\n separatingLine = improveLine(separatingLine, strawberries, lines);\n \n lines.push_back(separatingLine);\n \n // Stop if we've reached the limit\n if (lines.size() >= K) break;\n }\n }\n }\n \n // If we have remaining cuts, try to add random lines that might improve the partition\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution dis(-1000000000, 1000000000);\n \n while (lines.size() < K) {\n // Generate a random line\n Point p1(dis(gen), dis(gen));\n Point p2(dis(gen), dis(gen));\n \n // Clamp to ensure within bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n Line line(p1, p2);\n \n // Improve the line\n line = improveLine(line, strawberries, lines);\n \n lines.push_back(line);\n }\n \n // Output the solution\n cout << lines.size() << \"\\n\";\n for (const Line& line : lines) {\n cout << line.p1.x << \" \" << line.p1.y << \" \" << line.p2.x << \" \" << line.p2.y << \"\\n\";\n }\n \n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n \n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n \n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n \n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y);\n }\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n};\n\nstruct Edge {\n Point p1, p2;\n Edge(Point a, Point b) {\n if (a < b) {\n p1 = a;\n p2 = b;\n } else {\n p1 = b;\n p2 = a;\n }\n }\n \n bool operator==(const Edge& other) const {\n return p1 == other.p1 && p2 == other.p2;\n }\n \n bool operator<(const Edge& other) const {\n if (p1 != other.p1) return p1 < other.p1;\n return p2 < other.p2;\n }\n};\n\nstruct Rectangle {\n vector points;\n vector edges;\n \n Rectangle(Point p1, Point p2, Point p3, Point p4) {\n points = {p1, p2, p3, p4};\n // Create edges\n edges.push_back(Edge(p1, p2));\n edges.push_back(Edge(p2, p3));\n edges.push_back(Edge(p3, p4));\n edges.push_back(Edge(p4, p1));\n }\n};\n\nstruct Candidate {\n Point newPoint;\n vector existingPoints;\n double weight;\n \n Candidate(Point np, vector ep, double w) : newPoint(np), existingPoints(ep), weight(w) {}\n \n bool operator<(const Candidate& other) const {\n // Higher weight first\n return weight < other.weight;\n }\n};\n\nclass RectJoinSolver {\nprivate:\n int N, M;\n int center;\n vector> hasDot;\n set drawnEdges;\n vector initialDots;\n vector> operations;\n \n // Calculate weight of a point\n double getWeight(int x, int y) {\n return (x - center) * (x - center) + (y - center) * (y - center) + 1;\n }\n \n // Check if point is on the grid\n bool isValidPoint(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n \n // Get all points on the perimeter of a rectangle\n vector getPerimeterPoints(const Rectangle& rect) {\n vector perimeter;\n \n // Add all four corners\n for (const Point& p : rect.points) {\n perimeter.push_back(p);\n }\n \n // Add points on edges (excluding corners)\n for (const Edge& edge : rect.edges) {\n int dx = edge.p2.x - edge.p1.x;\n int dy = edge.p2.y - edge.p1.y;\n \n int steps = max(abs(dx), abs(dy));\n if (steps == 0) continue;\n \n int stepX = (dx != 0) ? dx / abs(dx) : 0;\n int stepY = (dy != 0) ? dy / abs(dy) : 0;\n \n Point current = edge.p1;\n for (int i = 1; i < steps; i++) {\n current = Point(current.x + stepX, current.y + stepY);\n perimeter.push_back(current);\n }\n }\n \n return perimeter;\n }\n \n // Check if rectangle is valid (no other dots on perimeter except corners)\n bool isValidRectangle(const Rectangle& rect) {\n vector perimeter = getPerimeterPoints(rect);\n \n // Check if there are dots on perimeter other than the 4 corners\n for (const Point& p : perimeter) {\n bool isCorner = false;\n for (const Point& corner : rect.points) {\n if (p == corner) {\n isCorner = true;\n break;\n }\n }\n \n if (!isCorner && hasDot[p.x][p.y]) {\n return false;\n }\n }\n \n // Check if any edge shares a segment with existing edges\n for (const Edge& edge : rect.edges) {\n if (drawnEdges.find(edge) != drawnEdges.end()) {\n return false;\n }\n }\n \n return true;\n }\n \n // Try to form a rectangle with the given new point and existing dots\n vector findValidRectangle(Point newPoint, const vector& existingDots) {\n int existingCount = existingDots.size();\n \n // Try all combinations of 3 existing dots\n for (int i = 0; i < existingCount; i++) {\n for (int j = i + 1; j < existingCount; j++) {\n for (int k = j + 1; k < existingCount; k++) {\n Point p2 = existingDots[i];\n Point p3 = existingDots[j];\n Point p4 = existingDots[k];\n \n // Try different orderings to form rectangles\n vector> orderings = {\n {newPoint, p2, p3, p4},\n {newPoint, p2, p4, p3},\n {newPoint, p3, p2, p4},\n {newPoint, p3, p4, p2},\n {newPoint, p4, p2, p3},\n {newPoint, p4, p3, p2}\n };\n \n for (const auto& ordering : orderings) {\n if (isRectangle(ordering[0], ordering[1], ordering[2], ordering[3])) {\n Rectangle rect(ordering[0], ordering[1], ordering[2], ordering[3]);\n if (isValidRectangle(rect)) {\n return {p2, p3, p4}; // Return the 3 existing points\n }\n }\n }\n }\n }\n }\n \n return {}; // No valid rectangle found\n }\n \n // Check if 4 points form a rectangle (axis-aligned or 45-degree)\n bool isRectangle(Point p1, Point p2, Point p3, Point p4) {\n // For axis-aligned rectangles\n if (isAxisAlignedRectangle(p1, p2, p3, p4)) {\n return true;\n }\n \n // For 45-degree rectangles\n if (isDiagonalRectangle(p1, p2, p3, p4)) {\n return true;\n }\n \n return false;\n }\n \n // Check if 4 points form an axis-aligned rectangle\n bool isAxisAlignedRectangle(Point p1, Point p2, Point p3, Point p4) {\n vector xs = {p1.x, p2.x, p3.x, p4.x};\n vector ys = {p1.y, p2.y, p3.y, p4.y};\n sort(xs.begin(), xs.end());\n sort(ys.begin(), ys.end());\n \n // Check if there are exactly 2 distinct x-coordinates and 2 distinct y-coordinates\n if (xs[0] == xs[1] && xs[2] == xs[3] && ys[0] == ys[1] && ys[2] == ys[3]) {\n // Check if the points are at the corners\n set corners = {\n Point(xs[0], ys[0]), Point(xs[0], ys[3]),\n Point(xs[3], ys[0]), Point(xs[3], ys[3])\n };\n \n set actual = {p1, p2, p3, p4};\n return corners == actual;\n }\n \n return false;\n }\n \n // Check if 4 points form a 45-degree rectangle (diamond shape)\n bool isDiagonalRectangle(Point p1, Point p2, Point p3, Point p4) {\n // Calculate vectors between points\n vector points = {p1, p2, p3, p4};\n \n // Try all possible center points\n for (int i = 0; i < 4; i++) {\n for (int j = i + 1; j < 4; j++) {\n // Calculate potential center (midpoint of diagonal)\n Point center((points[i].x + points[j].x) / 2, (points[i].y + points[j].y) / 2);\n \n // Check if center has integer coordinates\n if ((points[i].x + points[j].x) % 2 != 0 || (points[i].y + points[j].y) % 2 != 0) {\n continue;\n }\n \n // Find the other two points\n vector otherPoints;\n for (int k = 0; k < 4; k++) {\n if (k != i && k != j) {\n otherPoints.push_back(points[k]);\n }\n }\n \n if (otherPoints.size() != 2) continue;\n \n // Check if they form a diagonal\n Point otherCenter((otherPoints[0].x + otherPoints[1].x) / 2, (otherPoints[0].y + otherPoints[1].y) / 2);\n if (otherCenter.x != center.x || otherCenter.y != center.y) {\n continue;\n }\n \n // Check if it's a square rotated by 45 degrees\n // Vectors from center to corners should be perpendicular and of equal length\n Point v1 = points[i] - center;\n Point v2 = otherPoints[0] - center;\n \n // Check if vectors are perpendicular (dot product = 0)\n if (v1.x * v2.x + v1.y * v2.y != 0) {\n continue;\n }\n \n // Check if vectors have the same length\n if (v1.x * v1.x + v1.y * v1.y != v2.x * v2.x + v2.y * v2.y) {\n continue;\n }\n \n // Check if all coordinates are integers and points are distinct\n bool allValid = true;\n for (const Point& p : points) {\n if (!isValidPoint(p.x, p.y)) {\n allValid = false;\n break;\n }\n }\n \n if (allValid) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n // Get all existing dots\n vector getAllDots() {\n vector dots;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (hasDot[x][y]) {\n dots.push_back(Point(x, y));\n }\n }\n }\n return dots;\n }\n \npublic:\n RectJoinSolver(int n, int m, const vector& initial) : N(n), M(m), initialDots(initial) {\n center = (N - 1) / 2;\n hasDot.assign(N, vector(N, false));\n \n // Mark initial dots\n for (const Point& p : initialDots) {\n hasDot[p.x][p.y] = true;\n }\n }\n \n void solve() {\n // Use priority queue to prioritize placing dots with higher weights\n priority_queue candidates;\n vector existingDots = getAllDots();\n \n // Add all possible candidate positions\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (!hasDot[x][y]) {\n double weight = getWeight(x, y);\n candidates.push(Candidate(Point(x, y), {}, weight));\n }\n }\n }\n \n bool madeProgress = true;\n while (madeProgress && !candidates.empty()) {\n madeProgress = false;\n vector remainingCandidates;\n \n // Try candidates in order of priority\n while (!candidates.empty()) {\n Candidate cand = candidates.top();\n candidates.pop();\n \n // Refresh existing dots (in case new dots were added)\n existingDots = getAllDots();\n \n // Try to find a valid rectangle for this candidate\n vector validPoints = findValidRectangle(cand.newPoint, existingDots);\n \n if (!validPoints.empty()) {\n // Found a valid rectangle, place the dot\n Point newDot = cand.newPoint;\n hasDot[newDot.x][newDot.y] = true;\n \n // Create rectangle to get edges\n Rectangle rect(newDot, validPoints[0], validPoints[1], validPoints[2]);\n \n // Add edges to drawn edges\n for (const Edge& edge : rect.edges) {\n drawnEdges.insert(edge);\n }\n \n // Record operation\n vector op = {newDot, validPoints[0], validPoints[1], validPoints[2]};\n vector opCoords;\n for (const Point& p : op) {\n opCoords.push_back(p.x);\n opCoords.push_back(p.y);\n }\n operations.push_back(op);\n \n // Refresh existing dots\n existingDots = getAllDots();\n \n // Add this point to all remaining candidates' existing dots\n madeProgress = true;\n break;\n } else {\n // Keep for next iteration\n remainingCandidates.push_back(cand);\n }\n }\n \n // If we made progress, rebuild the priority queue with updated weights\n if (madeProgress) {\n // Add back remaining candidates\n for (const Candidate& cand : remainingCandidates) {\n candidates.push(cand);\n }\n }\n }\n }\n \n void output() {\n cout << operations.size() << endl;\n for (const auto& op : operations) {\n for (int i = 0; i < 4; i++) {\n if (i > 0) cout << \" \";\n cout << op[i].x << \" \" << op[i].y;\n }\n cout << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n \n vector initialDots;\n for (int i = 0; i < M; i++) {\n int x, y;\n cin >> x >> y;\n initialDots.push_back(Point(x, y));\n }\n \n RectJoinSolver solver(N, M, initialDots);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\n\n// Directions: F=0 (forward/up), B=1 (backward/down), L=2 (left), R=3 (right)\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'F', 'B', 'L', 'R'};\n\nclass CandyBox {\nprivate:\n vector> grid;\n vector flavor_count;\n \npublic:\n CandyBox() : grid(N, vector(N, 0)), flavor_count(4, 0) {}\n \n // Place candy at position (calculated from 1-indexed empty cell number)\n void placeCandy(int pos, int flavor) {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == 0) {\n count++;\n if (count == pos) {\n grid[i][j] = flavor;\n flavor_count[flavor]++;\n return;\n }\n }\n }\n }\n }\n \n // Simulate tilting in a direction\n vector> simulateTilt(int dir) {\n vector> new_grid = grid;\n \n // Create movement order based on direction\n vector> cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (new_grid[i][j] != 0) {\n cells.push_back({i, j});\n }\n }\n }\n \n // Sort cells based on direction to process in correct order\n if (dir == 0) { // Forward (up): process from top to bottom\n sort(cells.begin(), cells.end());\n } else if (dir == 1) { // Backward (down): process from bottom to top\n sort(cells.begin(), cells.end(), greater>());\n } else if (dir == 2) { // Left: process from left to right\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second < b.second;\n return a.first < b.first;\n });\n } else { // Right: process from right to left\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second > b.second;\n return a.first < b.first;\n });\n }\n \n // Move each candy\n vector> temp_grid(N, vector(N, 0));\n for (auto& cell : cells) {\n int x = cell.first, y = cell.second;\n int flavor = new_grid[x][y];\n \n // Skip if already processed (moved)\n if (flavor == 0) continue;\n \n int nx = x, ny = y;\n while (true) {\n int tx = nx + dx[dir];\n int ty = ny + dy[dir];\n if (tx < 0 || tx >= N || ty < 0 || ty >= N || temp_grid[tx][ty] != 0) {\n break;\n }\n nx = tx;\n ny = ty;\n }\n temp_grid[nx][ny] = flavor;\n }\n \n return temp_grid;\n }\n \n // Calculate score for current grid state\n long long calculateScore() {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)flavor_count[i] * flavor_count[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Calculate score for a given grid state\n long long calculateScoreForGrid(const vector>& test_grid, const vector& test_counts) {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = test_grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && test_grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)test_counts[i] * test_counts[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Apply tilt to actual grid\n void applyTilt(int dir) {\n grid = simulateTilt(dir);\n }\n \n // Get current grid state\n vector> getGrid() const {\n return grid;\n }\n \n // Get flavor counts\n vector getFlavorCount() const {\n return flavor_count;\n }\n};\n\nint main() {\n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n CandyBox box;\n \n for (int t = 0; t < 100; t++) {\n int pos;\n cin >> pos;\n \n // Place the candy\n box.placeCandy(pos, flavors[t]);\n \n // If it's the last candy, we can choose any direction (it won't matter)\n if (t == 99) {\n cout << \"F\" << endl; // Arbitrary choice for last move\n cout.flush();\n continue;\n }\n \n // Try all 4 directions and pick the best\n long long best_score = -1;\n int best_dir = 0;\n \n vector current_counts = box.getFlavorCount();\n \n for (int dir = 0; dir < 4; dir++) {\n // Simulate tilt in this direction\n vector> test_grid = box.simulateTilt(dir);\n \n // Calculate score for this tilt\n long long score = box.calculateScoreForGrid(test_grid, current_counts);\n \n // Choose the direction with the highest score\n if (score > best_score) {\n best_score = score;\n best_dir = dir;\n }\n }\n \n // Apply the best tilt\n box.applyTilt(best_dir);\n \n // Output the direction\n cout << dir_char[best_dir] << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass Graph {\npublic:\n int N;\n vector> adj;\n \n Graph(int n) : N(n), adj(n, vector(n, false)) {}\n \n void add_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = true;\n adj[j][i] = true;\n }\n }\n \n void remove_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = false;\n adj[j][i] = false;\n }\n }\n \n bool has_edge(int i, int j) const {\n return adj[i][j];\n }\n \n string to_string() const {\n string s;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s += (adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n static Graph from_string(int n, const string& s) {\n Graph g(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (idx < s.length() && s[idx] == '1') {\n g.add_edge(i, j);\n }\n idx++;\n }\n }\n return g;\n }\n \n vector get_degree_sequence() const {\n vector degrees(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) degrees[i]++;\n }\n }\n sort(degrees.begin(), degrees.end());\n return degrees;\n }\n \n int count_edges() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) count++;\n }\n }\n return count;\n }\n \n int count_triangles() const {\n int triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n triangles++;\n }\n }\n }\n }\n }\n return triangles;\n }\n \n // Count number of 4-cliques\n int count_4cliques() const {\n int cliques = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n for (int k = j + 1; k < N; k++) {\n for (int l = k + 1; l < N; l++) {\n if (adj[i][j] && adj[i][k] && adj[i][l] && \n adj[j][k] && adj[j][l] && adj[k][l]) {\n cliques++;\n }\n }\n }\n }\n }\n return cliques;\n }\n \n // Count connected components\n int count_components() const {\n vector visited(N, false);\n int components = 0;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n components++;\n // BFS\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n }\n }\n return components;\n }\n \n // Get component sizes\n vector get_component_sizes() const {\n vector visited(N, false);\n vector sizes;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n int size = 0;\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n size++;\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n sizes.push_back(size);\n }\n }\n sort(sizes.begin(), sizes.end());\n return sizes;\n }\n};\n\n// Features for graph classification\nstruct GraphFeatures {\n int edge_count;\n vector degree_sequence;\n int triangle_count;\n int four_clique_count;\n int component_count;\n vector component_sizes;\n double avg_degree;\n int max_degree;\n int min_degree;\n \n GraphFeatures(const Graph& g) {\n edge_count = g.count_edges();\n degree_sequence = g.get_degree_sequence();\n triangle_count = g.count_triangles();\n four_clique_count = g.count_4cliques();\n component_count = g.count_components();\n component_sizes = g.get_component_sizes();\n avg_degree = 2.0 * edge_count / g.N;\n \n if (!degree_sequence.empty()) {\n max_degree = *max_element(degree_sequence.begin(), degree_sequence.end());\n min_degree = *min_element(degree_sequence.begin(), degree_sequence.end());\n } else {\n max_degree = min_degree = 0;\n }\n }\n};\n\n// Calculate distance between two feature sets\ndouble distance(const GraphFeatures& f1, const GraphFeatures& f2, double epsilon) {\n double d = 0.0;\n \n // Edge count difference - most basic but noisy\n // Expected error: epsilon * total_possible_edges\n double edge_weight = 1.0;\n if (epsilon > 0.2) {\n edge_weight = 0.5; // Less reliable at high noise\n }\n d += abs(f1.edge_count - f2.edge_count) * edge_weight;\n \n // Degree sequence difference (L1 distance)\n // More robust than raw edge count\n double degree_weight = 2.0 - epsilon; // More weight at higher noise\n for (int i = 0; i < min(f1.degree_sequence.size(), f2.degree_sequence.size()); i++) {\n d += abs(f1.degree_sequence[i] - f2.degree_sequence[i]) * degree_weight;\n }\n \n // Triangle count difference - very robust feature\n double triangle_weight = 5.0 * (1.0 + epsilon); // Triangles are robust indicators\n d += abs(f1.triangle_count - f2.triangle_count) * triangle_weight;\n \n // 4-clique count difference - even more robust\n double clique_weight = 10.0 * (1.0 + epsilon);\n d += abs(f1.four_clique_count - f2.four_clique_count) * clique_weight;\n \n // Component count - very robust to noise\n double component_weight = 8.0;\n d += abs(f1.component_count - f2.component_count) * component_weight;\n \n // Component sizes\n double comp_size_weight = 3.0;\n for (int i = 0; i < min(f1.component_sizes.size(), f2.component_sizes.size()); i++) {\n d += abs(f1.component_sizes[i] - f2.component_sizes[i]) * comp_size_weight;\n }\n \n // Max/Min degree\n double degree_extreme_weight = 2.0;\n d += abs(f1.max_degree - f2.max_degree) * degree_extreme_weight;\n d += abs(f1.min_degree - f2.min_degree) * degree_extreme_weight;\n \n return d;\n}\n\n// Generate a more distinctive graph for index k\nGraph generate_distinctive_graph(int N, int k, int M) {\n Graph g(N);\n \n // Calculate target edge density based on k\n double density = (k + 0.5) / M;\n int total_possible = N * (N - 1) / 2;\n int target_edges = (int)(density * total_possible);\n \n // Use different generation strategies based on k\n int strategy = k % 8;\n \n if (strategy == 0) {\n // Star-based with additional edges\n int center = k % N;\n for (int i = 0; i < N; i++) {\n if (i != center && g.count_edges() < target_edges) {\n g.add_edge(center, i);\n }\n }\n // Add some random edges to reach target\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 1; j < N && g.count_edges() < target_edges; j++) {\n if (i != center && j != center && !g.has_edge(i, j)) {\n if ((i * j + k) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n }\n else if (strategy == 1) {\n // Path-based with shortcuts\n for (int i = 0; i < N - 1; i++) {\n g.add_edge(i, i + 1);\n }\n // Add shortcuts\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 4 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 2) {\n // Cycle-based\n for (int i = 0; i < N; i++) {\n g.add_edge(i, (i + 1) % N);\n }\n // Add chords\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if ((i * 2 + j + k) % 5 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 3) {\n // Complete graph on subset\n int subset_size = min(N, (int)sqrt(2 * target_edges) + 2);\n for (int i = 0; i < subset_size; i++) {\n for (int j = i + 1; j < subset_size; j++) {\n if (g.count_edges() < target_edges) {\n g.add_edge(i, j);\n }\n }\n }\n // Add edges to other vertices\n for (int i = 0; i < subset_size && g.count_edges() < target_edges; i++) {\n for (int j = subset_size; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 4) {\n // Bipartite-like structure\n int split = N / 2;\n for (int i = 0; i < split; i++) {\n for (int j = split; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 2 == 0 || g.count_edges() < target_edges * 0.7) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 5) {\n // Random with high clustering\n mt19937 rng(k * 12345 + 6789);\n vector> edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n edges.push_back({i, j});\n }\n }\n \n // Prefer edges that create triangles\n shuffle(edges.begin(), edges.end(), rng);\n for (auto& e : edges) {\n if (g.count_edges() >= target_edges) break;\n \n // Check if adding this edge creates triangles\n int triangles_created = 0;\n for (int v = 0; v < N; v++) {\n if (v != e.first && v != e.second && \n g.has_edge(e.first, v) && g.has_edge(e.second, v)) {\n triangles_created++;\n }\n }\n \n // Higher probability to add if creates triangles\n if (triangles_created > 0 || rng() % 3 == 0) {\n g.add_edge(e.first, e.second);\n }\n }\n }\n else if (strategy == 6) {\n // Tree-like with additional edges\n // Create a tree first\n for (int i = 1; i < N; i++) {\n int parent = (i + k) % i;\n g.add_edge(i, parent);\n }\n // Add additional edges\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if (abs(i - j) > 1 && (i * j + k) % 4 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else { // strategy == 7\n // Grid-like structure if possible\n int rows = (int)sqrt(N);\n int cols = N / rows;\n if (rows * cols < N) cols++;\n \n for (int i = 0; i < N; i++) {\n int r = i / cols;\n int c = i % cols;\n \n // Right neighbor\n if (c + 1 < cols && r * cols + c + 1 < N) {\n int j = r * cols + c + 1;\n if (g.count_edges() < target_edges) {\n g.add_edge(i, j);\n }\n }\n // Down neighbor\n if (r + 1 < rows && (r + 1) * cols + c < N) {\n int j = (r + 1) * cols + c;\n if (g.count_edges() < target_edges) {\n g.add_edge(i, j);\n }\n }\n // Diagonal neighbor (for extra edges)\n if (c + 1 < cols && r + 1 < rows && (r + 1) * cols + c + 1 < N && \n g.count_edges() < target_edges && (i + k) % 3 == 0) {\n int j = (r + 1) * cols + c + 1;\n g.add_edge(i, j);\n }\n }\n }\n \n // Ensure we have enough distinctive features\n // Add specific patterns based on k for identification\n int pattern_id = k % 20;\n \n if (N >= 3) {\n // Create different triangle patterns\n if (pattern_id < 5) {\n // Create 1 triangle\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n } else if (pattern_id < 10) {\n // Create 2 triangles sharing an edge\n if (N >= 4) {\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n g.add_edge(1, 3);\n g.add_edge(3, 2);\n }\n } else if (pattern_id < 15) {\n // Create 3 triangles sharing a vertex\n if (N >= 4) {\n g.add_edge(0, 1);\n g.add_edge(0, 2);\n g.add_edge(0, 3);\n g.add_edge(1, 2);\n g.add_edge(2, 3);\n g.add_edge(3, 1);\n }\n } else {\n // Create 4-clique if possible\n if (N >= 4) {\n for (int i = 0; i < min(4, N); i++) {\n for (int j = i + 1; j < min(4, N); j++) {\n g.add_edge(i, j);\n }\n }\n }\n }\n }\n \n // Make sure we don't exceed target too much\n if (g.count_edges() > target_edges + N) {\n // Remove random edges if we have too many\n mt19937 rng(k * 98765 + 4321);\n for (int i = 0; i < N && g.count_edges() > target_edges; i++) {\n for (int j = i + 1; j < N && g.count_edges() > target_edges; j++) {\n if (g.has_edge(i, j) && rng() % 5 == 0) {\n g.remove_edge(i, j);\n }\n }\n }\n }\n \n return g;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Choose N more intelligently based on M and epsilon\n int N;\n \n if (epsilon <= 0.1) {\n // Low noise, can use smaller N\n N = 20 + (M / 20) * 5;\n } else if (epsilon <= 0.2) {\n // Medium noise\n N = 30 + (M / 20) * 5;\n } else if (epsilon <= 0.3) {\n // High noise\n N = 40 + (M / 20) * 5;\n } else {\n // Very high noise\n N = 50 + (M / 20) * 5;\n }\n \n // Ensure bounds\n N = max(15, min(80, N));\n \n // Special cases for very large M\n if (M > 80) {\n N = max(N, 60);\n }\n \n cout << N << endl;\n \n // Generate M graphs\n vector graphs;\n vector features;\n \n for (int k = 0; k < M; k++) {\n Graph g = generate_distinctive_graph(N, k, M);\n graphs.push_back(g);\n features.push_back(GraphFeatures(g));\n \n // Output graph\n cout << g.to_string() << endl;\n cout.flush();\n }\n \n // Process 100 queries\n for (int k = 0; k < 100; k++) {\n string h_str;\n cin >> h_str;\n \n // Parse the graph\n Graph h = Graph::from_string(N, h_str);\n GraphFeatures h_features(h);\n \n // Find the closest graph\n int best_idx = 0;\n double min_dist = 1e15; // Use larger initial value\n \n for (int i = 0; i < M; i++) {\n double dist = distance(h_features, features[i], epsilon);\n if (dist < min_dist) {\n min_dist = dist;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Graph representation\nstruct Edge {\n int u, v, w, id;\n Edge(int u = 0, int v = 0, int w = 0, int id = 0) : u(u), v(v), w(w), id(id) {}\n};\n\nclass Graph {\npublic:\n int n, m, d, k;\n vector edges;\n vector>> adj; // adjacency list: to, weight\n vector> coords;\n \n Graph(int n = 0, int m = 0, int d = 0, int k = 0) : n(n), m(m), d(d), k(k) {\n adj.resize(n + 1);\n }\n \n void addEdge(int u, int v, int w, int id) {\n edges.emplace_back(u, v, w, id);\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n // Calculate shortest distances from source using Dijkstra\n vector dijkstra(int source, const unordered_set& removed_edges = {}) {\n vector dist(n + 1, 1e18);\n priority_queue, vector>, greater>> pq;\n \n dist[source] = 0;\n pq.emplace(0, source);\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto [v, w] : adj[u]) {\n // Check if edge u-v is removed\n bool edge_removed = false;\n for (int eid : removed_edges) {\n Edge& e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n edge_removed = true;\n break;\n }\n }\n \n if (edge_removed) continue;\n \n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.emplace(dist[v], v);\n }\n }\n }\n \n return dist;\n }\n \n // Calculate frustration for a given day using sampling\n double calculateFrustrationSampling(const vector>& original_apsp, \n const vector& edges_to_remove, int sample_size = 100) {\n if (edges_to_remove.empty()) return 0.0;\n \n unordered_set remove_set(edges_to_remove.begin(), edges_to_remove.end());\n \n // Sample sources and targets\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> vertex_dist(1, n);\n \n vector sources;\n int actual_sample_size = min(sample_size, n);\n for (int i = 0; i < actual_sample_size; i++) {\n sources.push_back(vertex_dist(gen));\n }\n \n // Remove duplicates\n sort(sources.begin(), sources.end());\n sources.erase(unique(sources.begin(), sources.end()), sources.end());\n \n double frustration = 0.0;\n int pairs_count = 0;\n \n for (int source : sources) {\n // Run Dijkstra from source with removed edges\n auto dist = dijkstra(source, remove_set);\n \n // Sample targets\n vector targets;\n int target_sample_size = min(20, n - 1);\n for (int i = 0; i < target_sample_size; i++) {\n int target = vertex_dist(gen);\n if (target != source) {\n targets.push_back(target);\n }\n }\n \n // Remove duplicates\n sort(targets.begin(), targets.end());\n targets.erase(unique(targets.begin(), targets.end()), targets.end());\n \n for (int target : targets) {\n if (source == target) continue;\n \n long long new_dist = dist[target];\n if (new_dist >= 1e18) {\n new_dist = 1000000000; // Unreachable\n }\n \n long long orig_dist = original_apsp[source][target];\n if (orig_dist >= 1e18) orig_dist = 1000000000;\n \n frustration += (new_dist - orig_dist);\n pairs_count++;\n }\n }\n \n if (pairs_count == 0) return 0.0;\n \n // Scale up to approximate full frustration\n double avg_increase = frustration / pairs_count;\n return avg_increase;\n }\n};\n\n// Solution representation\nstruct Solution {\n vector schedule; // schedule[i] = day for edge i (1-indexed days)\n double total_frustration;\n Graph* graph;\n vector> original_apsp;\n \n Solution(Graph* g, const vector>& apsp) : graph(g), original_apsp(apsp) {\n schedule.resize(g->m);\n total_frustration = 0.0;\n }\n \n // Calculate total frustration for the entire schedule using sampling\n double calculateTotalFrustration() {\n double total = 0.0;\n \n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate frustration for each day\n for (int day = 1; day <= graph->d; day++) {\n double day_frustration = graph->calculateFrustrationSampling(original_apsp, edges_by_day[day]);\n total += day_frustration;\n }\n \n total_frustration = total / graph->d;\n return total_frustration;\n }\n \n // Get frustration as integer (rounded)\n long long getScore() {\n return llround(1000.0 * total_frustration);\n }\n \n // Calculate frustration change only for affected days after a swap\n double calculateDeltaFrustration(int idx1, int idx2, int new_day1, int new_day2) {\n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Add the new assignments\n edges_by_day[new_day1].push_back(idx1);\n edges_by_day[new_day2].push_back(idx2);\n \n // Calculate frustration only for the affected days\n double delta = 0.0;\n \n // Get original frustration for old days\n int old_day1 = schedule[idx1];\n int old_day2 = schedule[idx2];\n \n // Calculate new frustration for affected days\n double new_f1 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[new_day1]);\n double new_f2 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[new_day2]);\n \n // Restore original state for old days\n edges_by_day[new_day1].pop_back();\n edges_by_day[new_day2].pop_back();\n edges_by_day[old_day1].push_back(idx1);\n edges_by_day[old_day2].push_back(idx2);\n \n // Calculate old frustration for affected days\n double old_f1 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[old_day1]);\n double old_f2 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[old_day2]);\n \n // Restore for next iterations\n edges_by_day[old_day1].pop_back();\n edges_by_day[old_day2].pop_back();\n \n // Delta frustration\n delta = (new_f1 + new_f2 - old_f1 - old_f2) / graph->d;\n \n return delta;\n }\n};\n\n// Simple heuristic: prioritize edges with high weight (likely more important for shortest paths)\nvector calculateSimpleEdgeImportance(Graph& graph) {\n vector importance(graph.m, 0.0);\n \n for (int i = 0; i < graph.m; i++) {\n // Use edge weight as importance (higher weight = more important)\n // Also consider degree of vertices (edges connecting low-degree vertices might be more critical)\n int u = graph.edges[i].u;\n int v = graph.edges[i].v;\n int w = graph.edges[i].w;\n \n // Simple heuristic: weight * (some factor based on degrees)\n int deg_u = graph.adj[u].size();\n int deg_v = graph.adj[v].size();\n \n // Edges between low-degree vertices are more critical\n importance[i] = w * (1.0 / (deg_u * deg_v));\n }\n \n return importance;\n}\n\n// Optimized local search (simpler than SA)\nvoid localSearch(Solution& solution) {\n auto start_time = chrono::steady_clock::now();\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> edge_dist(0, solution.graph->m - 1);\n uniform_int_distribution<> day_dist(1, solution.graph->d);\n uniform_real_distribution<> prob_dist(0.0, 1.0);\n \n double current_score = solution.calculateTotalFrustration();\n int iterations = 0;\n int max_iterations = 2000; // Greatly reduced from 50000\n \n while (iterations < max_iterations) {\n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n if (elapsed > 4000) break; // More conservative time limit\n \n // Generate a neighbor by swapping two edges between days\n int idx1 = edge_dist(gen);\n int idx2 = edge_dist(gen);\n \n // Ensure different edges\n if (idx1 == idx2) {\n iterations++;\n continue;\n }\n \n int old_day1 = solution.schedule[idx1];\n int old_day2 = solution.schedule[idx2];\n \n // Try swapping days\n int new_day1 = old_day2;\n int new_day2 = old_day1;\n \n // Check constraints (at most K edges per day)\n vector count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n bool valid = true;\n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n // Try moving one edge to a different day\n new_day1 = day_dist(gen);\n new_day2 = old_day2;\n \n // Recalculate counts\n fill(count.begin(), count.end(), 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n valid = true;\n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n iterations++;\n continue;\n }\n }\n \n // Calculate delta frustration (only for affected days)\n double delta = solution.calculateDeltaFrustration(idx1, idx2, new_day1, new_day2);\n \n // Accept improvement\n if (delta < 0) {\n solution.schedule[idx1] = new_day1;\n solution.schedule[idx2] = new_day2;\n current_score += delta;\n }\n \n iterations++;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m, d, k;\n cin >> n >> m >> d >> k;\n \n Graph graph(n, m, d, k);\n \n // Read edges\n for (int i = 0; i < m; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n graph.addEdge(u, v, w, i);\n }\n \n // Read coordinates\n for (int i = 0; i < n; i++) {\n int x, y;\n cin >> x >> y;\n graph.coords.emplace_back(x, y);\n }\n \n // Calculate original all pairs shortest paths (but only for sampling)\n // Use sampling to estimate APSP instead of computing all pairs\n auto start_time = chrono::steady_clock::now();\n \n // Compute APSP for a sample of vertices only\n vector> original_apsp(n + 1, vector(n + 1, 1e18));\n \n // Sample 50 vertices for APSP calculation\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> vertex_dist(1, n);\n \n vector sample_vertices;\n int sample_size = min(50, n);\n for (int i = 0; i < sample_size; i++) {\n sample_vertices.push_back(vertex_dist(gen));\n }\n \n // Remove duplicates\n sort(sample_vertices.begin(), sample_vertices.end());\n sample_vertices.erase(unique(sample_vertices.begin(), sample_vertices.end()), sample_vertices.end());\n \n // Calculate shortest paths only for sampled vertices\n for (int source : sample_vertices) {\n auto dist = graph.dijkstra(source);\n for (int j = 1; j <= n; j++) {\n original_apsp[source][j] = dist[j];\n }\n }\n \n // Calculate simple edge importance\n auto importance = calculateSimpleEdgeImportance(graph);\n \n // Create initial solution\n Solution solution(&graph, original_apsp);\n \n // Sort edges by importance\n vector> edge_importance;\n for (int i = 0; i < m; i++) {\n edge_importance.emplace_back(importance[i], i);\n }\n \n // Sort by importance (descending)\n sort(edge_importance.rbegin(), edge_importance.rend());\n \n // Greedy scheduling with round-robin distribution\n vector day_count(d + 1, 0);\n \n for (int i = 0; i < m; i++) {\n int edge_id = edge_importance[i].second;\n \n // Use round-robin to distribute edges\n int day = (i % d) + 1;\n \n // If this day is full, find next available day\n int attempts = 0;\n while (day_count[day] >= k && attempts < d) {\n day = (day % d) + 1;\n attempts++;\n }\n \n // If still full, pick day with minimum count\n if (day_count[day] >= k) {\n int min_day = 1;\n for (int j = 1; j <= d; j++) {\n if (day_count[j] < day_count[min_day]) {\n min_day = j;\n }\n }\n day = min_day;\n }\n \n solution.schedule[edge_id] = day;\n day_count[day]++;\n }\n \n // Check if we have time for local search\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n \n if (elapsed < 3000) { // More conservative time check\n localSearch(solution);\n }\n \n // Output the solution\n for (int i = 0; i < m; i++) {\n if (i > 0) cout << \" \";\n cout << solution.schedule[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y, z;\n Point(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(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 bool operator==(const Point& other) const {\n return x == other.x && y == other.y && z == other.z;\n }\n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y, z + other.z);\n }\n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y, z - other.z);\n }\n};\n\n// Hash function for Point\nnamespace std {\n template<>\n struct hash {\n size_t operator()(const Point& p) const {\n return hash()(p.x) ^ hash()(p.y) ^ hash()(p.z);\n }\n };\n}\n\n// Directions for 6-connected (face-to-face) polycubes\nconst int dx[6] = {1, -1, 0, 0, 0, 0};\nconst int dy[6] = {0, 0, 1, -1, 0, 0};\nconst int dz[6] = {0, 0, 0, 0, 1, -1};\n\nint D;\nvector f1, r1, f2, r2;\n\n// Check if a point is within bounds\nbool inBounds(const Point& p) {\n return p.x >= 0 && p.x < D && p.y >= 0 && p.y < D && p.z >= 0 && p.z < D;\n}\n\n// Get neighbors of a point (6-connected)\nvector getNeighbors(const Point& p) {\n vector neighbors;\n for (int i = 0; i < 6; i++) {\n Point np(p.x + dx[i], p.y + dy[i], p.z + dz[i]);\n if (inBounds(np)) {\n neighbors.push_back(np);\n }\n }\n return neighbors;\n}\n\n// Convert 3D coordinates to 1D index\nint toIndex(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\n// Convert 1D index to 3D coordinates\nPoint fromIndex(int idx) {\n int x = idx / (D * D);\n int y = (idx % (D * D)) / D;\n int z = idx % D;\n return Point(x, y, z);\n}\n\n// Normalize a set of points by translating to origin\nvector normalize(const vector& points) {\n if (points.empty()) return points;\n \n int min_x = points[0].x, min_y = points[0].y, min_z = points[0].z;\n for (const Point& p : points) {\n min_x = min(min_x, p.x);\n min_y = min(min_y, p.y);\n min_z = min(min_z, p.z);\n }\n \n vector normalized;\n for (const Point& p : points) {\n normalized.push_back(Point(p.x - min_x, p.y - min_y, p.z - min_z));\n }\n return normalized;\n}\n\n// Generate all 24 rotations of a polycube\nvector> generateRotations(const vector& shape) {\n vector> rotations;\n vector normalized = normalize(shape);\n \n // All 24 rotations in 3D\n vector> rotation_matrices = {\n {1, 0, 0, 0, 1, 0, 0, 0, 1}, // identity\n {1, 0, 0, 0, 0, -1, 0, 1, 0}, // rotate around x\n {1, 0, 0, 0, -1, 0, 0, 0, -1}, // rotate around x\n {1, 0, 0, 0, 0, 1, 0, -1, 0}, // rotate around x\n \n {-1, 0, 0, 0, -1, 0, 0, 0, 1}, // rotate around z\n {-1, 0, 0, 0, 0, -1, 0, -1, 0}, // rotate around z\n {-1, 0, 0, 0, 1, 0, 0, 0, -1}, // rotate around z\n {-1, 0, 0, 0, 0, 1, 0, 1, 0}, // rotate around z\n \n {0, -1, 0, 1, 0, 0, 0, 0, 1}, // rotate around y\n {0, 0, 1, 1, 0, 0, 0, 1, 0}, // rotate around y\n {0, 1, 0, -1, 0, 0, 0, 0, 1}, // rotate around y\n {0, 0, -1, -1, 0, 0, 0, 1, 0}, // rotate around y\n \n {0, 1, 0, 1, 0, 0, 0, 0, -1}, // other rotations\n {0, 0, -1, -1, 0, 0, 0, -1, 0},\n {0, -1, 0, -1, 0, 0, 0, 0, -1},\n {0, 0, 1, 1, 0, 0, 0, -1, 0},\n \n {0, 1, 0, 0, 0, 1, 1, 0, 0},\n {0, 0, 1, 0, -1, 0, 1, 0, 0},\n {0, -1, 0, 0, 0, -1, 1, 0, 0},\n {0, 0, -1, 0, 1, 0, 1, 0, 0},\n \n {0, -1, 0, 0, 0, 1, -1, 0, 0},\n {0, 0, -1, 0, -1, 0, -1, 0, 0},\n {0, 1, 0, 0, 0, -1, -1, 0, 0},\n {0, 0, 1, 0, 1, 0, -1, 0, 0}\n };\n \n for (const auto& mat : rotation_matrices) {\n vector rotated;\n for (const Point& p : normalized) {\n int nx = mat[0] * p.x + mat[1] * p.y + mat[2] * p.z;\n int ny = mat[3] * p.x + mat[4] * p.y + mat[5] * p.z;\n int nz = mat[6] * p.x + mat[7] * p.y + mat[8] * p.z;\n rotated.push_back(Point(nx, ny, nz));\n }\n rotations.push_back(normalize(rotated));\n }\n \n // Remove duplicates\n vector> unique_rotations;\n set> seen;\n \n for (auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (seen.find(rot_set) == seen.end()) {\n seen.insert(rot_set);\n unique_rotations.push_back(rot);\n }\n }\n \n return unique_rotations;\n}\n\n// Check if two shapes are the same (considering rotations)\nbool shapesMatch(const vector& shape1, const vector& shape2) {\n if (shape1.size() != shape2.size()) return false;\n \n auto rotations = generateRotations(shape1);\n auto normalized2 = normalize(shape2);\n set set2(normalized2.begin(), normalized2.end());\n \n for (const auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (rot_set == set2) {\n return true;\n }\n }\n \n return false;\n}\n\n// Get canonical representation of a shape (for hashing)\nvector getCanonicalShape(const vector& shape) {\n if (shape.empty()) return shape;\n \n auto rotations = generateRotations(shape);\n sort(rotations.begin(), rotations.end(), [](const vector& a, const vector& b) {\n if (a.size() != b.size()) return a.size() < b.size();\n for (int i = 0; i < a.size(); i++) {\n if (a[i].x != b[i].x) return a[i].x < b[i].x;\n if (a[i].y != b[i].y) return a[i].y < b[i].y;\n if (a[i].z != b[i].z) return a[i].z < b[i].z;\n }\n return false;\n });\n \n return rotations.empty() ? shape : rotations[0];\n}\n\n// Hash function for vector\nnamespace std {\n template<>\n struct hash> {\n size_t operator()(const vector& v) const {\n size_t h = 0;\n for (const Point& p : v) {\n h ^= hash()(p.x) + 0x9e3779b9 + (h << 6) + (h >> 2);\n h ^= hash()(p.y) + 0x9e3779b9 + (h << 6) + (h >> 2);\n h ^= hash()(p.z) + 0x9e3779b9 + (h << 6) + (h >> 2);\n }\n return h;\n }\n };\n}\n\n// Main solution\nint main() {\n // Read input\n cin >> D;\n f1.resize(D);\n r1.resize(D);\n f2.resize(D);\n r2.resize(D);\n \n for (int i = 0; i < D; i++) {\n cin >> f1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> f2[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r2[i];\n }\n \n // Determine which positions must be filled for each arrangement\n vector>> mustFill1(D, vector>(D, vector(D, false)));\n vector>> mustFill2(D, vector>(D, vector(D, false)));\n \n // For first silhouette pair\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f1[z][x] == '1' && r1[z][y] == '1') {\n mustFill1[x][y][z] = true;\n }\n }\n }\n }\n \n // For second silhouette pair\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f2[z][x] == '1' && r2[z][y] == '1') {\n mustFill2[x][y][z] = true;\n }\n }\n }\n }\n \n // Create blocks for each arrangement separately\n vector blockId1(D * D * D, 0);\n vector blockId2(D * D * D, 0);\n \n // First, create connected components for arrangement 1\n vector> blocks1;\n vector>> visited1(D, vector>(D, vector(D, false)));\n \n int blockCount1 = 0;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && !visited1[x][y][z]) {\n // BFS to find connected component\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited1[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (!visited1[neighbor.x][neighbor.y][neighbor.z] && \n mustFill1[neighbor.x][neighbor.y][neighbor.z]) {\n visited1[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blocks1.push_back(component);\n blockCount1++;\n \n // Assign block ID to all positions in this component\n for (const Point& p : component) {\n blockId1[toIndex(p.x, p.y, p.z)] = blockCount1;\n }\n }\n }\n }\n }\n }\n \n // Create connected components for arrangement 2\n vector> blocks2;\n vector>> visited2(D, vector>(D, vector(D, false)));\n \n int blockCount2 = 0;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill2[x][y][z] && !visited2[x][y][z]) {\n // BFS to find connected component\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited2[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (!visited2[neighbor.x][neighbor.y][neighbor.z] && \n mustFill2[neighbor.x][neighbor.y][neighbor.z]) {\n visited2[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blocks2.push_back(component);\n blockCount2++;\n \n // Assign block ID to all positions in this component\n for (const Point& p : component) {\n blockId2[toIndex(p.x, p.y, p.z)] = blockCount2;\n }\n }\n }\n }\n }\n }\n \n // Now try to match blocks between arrangements based on shape\n vector blockMapping1(blockCount1 + 1, 0); // mapping from arrangement 1 block ID to final block ID\n vector blockMapping2(blockCount2 + 1, 0); // mapping from arrangement 2 block ID to final block ID\n \n int finalBlockCount = 0;\n vector used1(blockCount1 + 1, false);\n vector used2(blockCount2 + 1, false);\n \n // First, try to match blocks between arrangements\n for (int i = 1; i <= blockCount1; i++) {\n if (used1[i]) continue;\n for (int j = 1; j <= blockCount2; j++) {\n if (used2[j]) continue;\n \n // Check if shapes match\n if (shapesMatch(blocks1[i-1], blocks2[j-1])) {\n finalBlockCount++;\n blockMapping1[i] = finalBlockCount;\n blockMapping2[j] = finalBlockCount;\n used1[i] = true;\n used2[j] = true;\n break;\n }\n }\n }\n \n // Assign new block IDs for remaining blocks in arrangement 1\n for (int i = 1; i <= blockCount1; i++) {\n if (!used1[i]) {\n finalBlockCount++;\n blockMapping1[i] = finalBlockCount;\n }\n }\n \n // Assign new block IDs for remaining blocks in arrangement 2\n for (int j = 1; j <= blockCount2; j++) {\n if (!used2[j]) {\n finalBlockCount++;\n blockMapping2[j] = finalBlockCount;\n }\n }\n \n // Update block IDs in output arrays\n for (int i = 0; i < D * D * D; i++) {\n if (blockId1[i] != 0) {\n blockId1[i] = blockMapping1[blockId1[i]];\n }\n if (blockId2[i] != 0) {\n blockId2[i] = blockMapping2[blockId2[i]];\n }\n }\n \n // Output\n cout << finalBlockCount << endl;\n \n // Output first arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << blockId1[i];\n }\n cout << endl;\n \n // Output second arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << blockId2[i];\n }\n cout << endl;\n \n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef long long ll;\n\nstruct Point {\n ll x, y;\n Point(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\nll distance_squared(const Point& a, const Point& b) {\n ll dx = a.x - b.x;\n ll dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\nll distance_rounded(const Point& a, const Point& b) {\n return round(sqrt(distance_squared(a, b)));\n}\n\nstruct Edge {\n int u, v;\n ll weight;\n Edge(int u = 0, int v = 0, ll weight = 0) : u(u), v(v), weight(weight) {}\n};\n\nstruct Resident {\n ll x, y;\n Resident(ll x = 0, ll y = 0) : x(x), y(x == 0 ? y : y) {}\n};\n\n// Union-Find for MST\nstruct UnionFind {\n vector parent, rank;\n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) parent[x] = y;\n else {\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n }\n bool same(int x, int y) {\n return find(x) == find(y);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n cin >> N >> M >> K;\n \n vector stations(N + 1);\n for (int i = 1; i <= N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges(M + 1);\n for (int j = 1; j <= M; ++j) {\n cin >> edges[j].u >> edges[j].v >> edges[j].weight;\n }\n \n vector residents(K + 1);\n for (int k = 1; k <= K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // For each resident, find the minimum radius needed from each station\n vector> minRadius(N + 1, vector(K + 1));\n for (int i = 1; i <= N; ++i) {\n for (int k = 1; k <= K; ++k) {\n minRadius[i][k] = distance_rounded(\n Point(stations[i].x, stations[i].y), \n Point(residents[k].x, residents[k].y)\n );\n }\n }\n \n // Output strengths for each station (initially 0)\n vector P(N + 1, 0);\n \n // Edge power status (0 = OFF, 1 = ON)\n vector B(M + 1, 0);\n \n // Step 1: Find which stations should be activated\n // For each resident, find the closest station\n vector closestStation(K + 1);\n vector closestDistance(K + 1);\n for (int k = 1; k <= K; ++k) {\n closestDistance[k] = LLONG_MAX;\n for (int i = 1; i <= N; ++i) {\n if (minRadius[i][k] < closestDistance[k]) {\n closestDistance[k] = minRadius[i][k];\n closestStation[k] = i;\n }\n }\n }\n \n // Stations that need to be activated (at least the ones covering residents)\n vector stationNeeded(N + 1, false);\n for (int k = 1; k <= K; ++k) {\n stationNeeded[closestStation[k]] = true;\n // Set P_i to at least the distance needed to cover its closest resident\n P[closestStation[k]] = max(P[closestStation[k]], closestDistance[k]);\n }\n \n // Ensure station 1 is activated (it's the source)\n stationNeeded[1] = true;\n \n // Step 2: Connect all needed stations to station 1 using MST approach\n // Collect all edges that connect stations we need\n vector>> weightedEdges;\n for (int j = 1; j <= M; ++j) {\n int u = edges[j].u;\n int v = edges[j].v;\n ll w = edges[j].weight;\n \n // Add edge if it connects two stations we might need\n weightedEdges.push_back({w, {u, v}});\n }\n \n // Sort edges by weight\n sort(weightedEdges.begin(), weightedEdges.end());\n \n // Use Union-Find to build MST\n UnionFind uf(N + 1);\n vector stationInTree(N + 1, false);\n stationInTree[1] = true; // Station 1 is always in the tree\n \n // First, ensure all needed stations are connected\n for (int i = 1; i <= N; ++i) {\n if (stationNeeded[i]) {\n stationInTree[i] = true;\n }\n }\n \n // Connect stations using MST\n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n // If both stations are needed or one is in tree and other is needed\n if ((stationInTree[u] && stationNeeded[v]) || \n (stationInTree[v] && stationNeeded[u]) ||\n (stationInTree[u] && stationInTree[v])) {\n if (!uf.same(u, v)) {\n uf.unite(u, v);\n stationInTree[u] = true;\n stationInTree[v] = true;\n \n // Find which edge index this corresponds to\n for (int j = 1; j <= M; ++j) {\n if ((edges[j].u == u && edges[j].v == v) || \n (edges[j].u == v && edges[j].v == u)) {\n B[j] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Make sure station 1 is connected to all activated stations\n // If not, we need to add more edges\n for (int i = 2; i <= N; ++i) {\n if (stationInTree[i] && !uf.same(1, i)) {\n // Find the cheapest edge to connect i to the tree\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (int j = 1; j <= M; ++j) {\n int u = edges[j].u;\n int v = edges[j].v;\n ll w = edges[j].weight;\n \n if ((u == i && stationInTree[v] && uf.same(1, v)) ||\n (v == i && stationInTree[u] && uf.same(1, u))) {\n if (w < minCost) {\n minCost = w;\n bestEdge = j;\n }\n }\n }\n \n if (bestEdge != -1) {\n B[bestEdge] = 1;\n int u = edges[bestEdge].u;\n int v = edges[bestEdge].v;\n uf.unite(u, v);\n }\n }\n }\n \n // Step 3: Optimize output strengths\n // For each station, set P_i to the minimum radius needed to cover all residents \n // that are closest to it or could be efficiently covered by it\n vector> residentsCoveredByStation(N + 1);\n for (int k = 1; k <= K; ++k) {\n residentsCoveredByStation[closestStation[k]].push_back(k);\n }\n \n // Adjust P_i values: for each station, set to max distance to residents it covers\n for (int i = 1; i <= N; ++i) {\n if (!stationInTree[i]) {\n P[i] = 0; // Don't waste power on stations not in the tree\n continue;\n }\n \n ll maxRadius = 0;\n for (int k = 1; k <= K; ++k) {\n // Check if this station can cover this resident with a reasonable radius\n // We'll assign residents to stations that can cover them efficiently\n ll d = minRadius[i][k];\n if (d <= 5000) { // Within maximum allowed radius\n // Check if this station is the most efficient one to cover this resident\n // (considering both distance and whether station is activated)\n bool shouldCover = false;\n if (closestStation[k] == i) {\n shouldCover = true;\n } else {\n // Consider if it's more efficient for this station to cover the resident\n // instead of the currently assigned station\n int currentStation = closestStation[k];\n if (stationInTree[currentStation]) {\n // Compare costs\n ll currentCost = P[currentStation] * P[currentStation];\n ll newCost = d * d;\n if (d < P[i] && newCost < currentCost / 2) {\n // This is a simplification - in practice, we'd need to consider\n // the global optimization\n shouldCover = true;\n }\n }\n }\n \n if (shouldCover) {\n maxRadius = max(maxRadius, d);\n }\n }\n }\n P[i] = maxRadius;\n }\n \n // Final verification and adjustment: ensure all residents are covered\n vector residentCovered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (stationInTree[i] && minRadius[i][k] <= P[i]) {\n residentCovered[k] = true;\n break;\n }\n }\n }\n \n // If any resident is not covered, increase P_i for the closest station in the tree\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered[k]) {\n ll minDist = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (stationInTree[i] && minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n \n if (bestStation != -1) {\n P[bestStation] = max(P[bestStation], minDist);\n }\n }\n }\n \n // Output the solution\n for (int i = 1; i <= N; ++i) {\n if (i > 1) cout << \" \";\n cout << P[i];\n }\n cout << endl;\n \n for (int j = 1; j <= M; ++j) {\n if (j > 1) cout << \" \";\n cout << B[j];\n }\n cout << endl;\n \n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_OPS = 10000;\n\n// Pyramid representation\nvector> pyramid;\n\n// Directions for adjacent positions (6 directions)\nvector> dirs = {\n {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}\n};\n\n// Check if coordinates are valid\nbool valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\n// Get the value at position (x, y)\nint get_value(int x, int y) {\n if (!valid(x, y)) return -1;\n return pyramid[x][y];\n}\n\n// Find position of a value\npair find_position(int value) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n if (pyramid[i][j] == value) {\n return {i, j};\n }\n }\n }\n return {-1, -1};\n}\n\n// Check if swap is valid (adjacent in 6 directions)\nbool can_swap(int x1, int y1, int x2, int y2) {\n if (!valid(x1, y1) || !valid(x2, y2)) return false;\n \n for (auto& dir : dirs) {\n int nx = x1 + dir.first;\n int ny = y1 + dir.second;\n if (nx == x2 && ny == y2) {\n return true;\n }\n }\n return false;\n}\n\n// Perform swap and record operation\nvoid perform_swap(int x1, int y1, int x2, int y2, vector>& ops) {\n if (!can_swap(x1, y1, x2, y2)) {\n return;\n }\n \n swap(pyramid[x1][y1], pyramid[x2][y2]);\n ops.push_back({x1, y1, x2, y2});\n}\n\n// Count violations\nint count_violations() {\n int violations = 0;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current > left_child) violations++;\n if (current > right_child) violations++;\n }\n }\n return violations;\n}\n\n// Calculate the \"weight\" of a position - how important it is to have a small value here\nint position_weight(int x, int y) {\n // Higher levels and more central positions are more important\n // The weight is based on how many descendants this position has\n int levels_below = N - 1 - x;\n int descendants = (1 << (levels_below + 1)) - 1; // Approximate - actual would be more complex\n return descendants;\n}\n\n// Move a ball directly by swapping along a simple path\nvoid move_ball_direct(int from_x, int from_y, int to_x, int to_y, vector>& ops) {\n if (from_x == to_x && from_y == to_y) return;\n \n int cx = from_x, cy = from_y;\n \n // Move vertically first (if needed)\n while (cx < to_x && ops.size() < MAX_OPS) {\n // Move down\n if (cy <= to_y) {\n // Move down-right if possible\n if (valid(cx + 1, cy + 1)) {\n perform_swap(cx, cy, cx + 1, cy + 1, ops);\n cx++; cy++;\n } else if (valid(cx + 1, cy)) {\n perform_swap(cx, cy, cx + 1, cy, ops);\n cx++;\n } else break;\n } else {\n // Move down-left\n if (valid(cx + 1, cy)) {\n perform_swap(cx, cy, cx + 1, cy, ops);\n cx++;\n } else if (valid(cx + 1, cy + 1)) {\n perform_swap(cx, cy, cx + 1, cy + 1, ops);\n cx++; cy++;\n } else break;\n }\n }\n \n while (cx > to_x && ops.size() < MAX_OPS) {\n // Move up\n if (cy >= to_y) {\n // Move up-left\n if (valid(cx - 1, cy - 1)) {\n perform_swap(cx, cy, cx - 1, cy - 1, ops);\n cx--; cy--;\n } else if (valid(cx - 1, cy)) {\n perform_swap(cx, cy, cx - 1, cy, ops);\n cx--;\n } else break;\n } else {\n // Move up-right\n if (valid(cx - 1, cy)) {\n perform_swap(cx, cy, cx - 1, cy, ops);\n cx--;\n } else if (valid(cx - 1, cy - 1)) {\n perform_swap(cx, cy, cx - 1, cy - 1, ops);\n cx--; cy--;\n } else break;\n }\n }\n \n // Move horizontally\n while (cy < to_y && ops.size() < MAX_OPS) {\n if (valid(cx, cy + 1)) {\n perform_swap(cx, cy, cx, cy + 1, ops);\n cy++;\n } else break;\n }\n \n while (cy > to_y && ops.size() < MAX_OPS) {\n if (valid(cx, cy - 1)) {\n perform_swap(cx, cy, cx, cy - 1, ops);\n cy--;\n } else break;\n }\n}\n\n// Calculate the cost of having a value at a position\nlong long position_cost(int value, int x, int y) {\n // Lower values should be at higher levels\n // Cost increases with value and level\n long long level_cost = (long long)x * x * 10;\n long long value_cost = (long long)value * 3;\n \n // Central positions at higher levels are more valuable for small numbers\n int centrality = min(y, x - y);\n long long centrality_bonus = (N - x) * (N - x) * centrality;\n \n return level_cost + value_cost - centrality_bonus;\n}\n\n// Main solution\nvoid solve() {\n // Read input\n pyramid.resize(N);\n for (int i = 0; i < N; i++) {\n pyramid[i].resize(i + 1);\n for (int j = 0; j <= i; j++) {\n cin >> pyramid[i][j];\n }\n }\n \n vector> operations;\n \n // Phase 1: Rough sort by moving smaller values upward\n // Create a list of all values\n vector>> values;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n values.push_back({pyramid[i][j], {i, j}});\n }\n }\n \n // Sort by value (smallest first)\n sort(values.begin(), values.end());\n \n // Calculate ideal positions based on value and position weight\n vector>> position_scores;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n position_scores.push_back({-position_weight(i, j), {i, j}});\n }\n }\n sort(position_scores.begin(), position_scores.end());\n \n // Map each value to its ideal position\n vector> ideal_pos(465);\n for (int i = 0; i < min(values.size(), position_scores.size()); i++) {\n int value = values[i].first;\n auto [x, y] = position_scores[i].second;\n ideal_pos[value] = {x, y};\n }\n \n // Move the smallest 1/3 of values to the best positions\n int move_limit = min(150, (int)values.size());\n for (int i = 0; i < move_limit && operations.size() < MAX_OPS * 0.6; i++) {\n int value = values[i].first;\n auto [ideal_x, ideal_y] = ideal_pos[value];\n auto [current_x, current_y] = find_position(value);\n \n if (current_x != ideal_x || current_y != ideal_y) {\n // Only move if it's worth it (significant improvement)\n long long current_cost = position_cost(value, current_x, current_y);\n long long ideal_cost = position_cost(value, ideal_x, ideal_y);\n \n if (current_cost > ideal_cost + 100) {\n move_ball_direct(current_x, current_y, ideal_x, ideal_y, operations);\n }\n }\n }\n \n // Phase 2: Fix violations from bottom up\n for (int pass = 0; pass < 5 && operations.size() < MAX_OPS; pass++) {\n bool violations_fixed = false;\n int violations_start = count_violations();\n \n // Process from bottom up\n for (int level = N - 2; level >= 0; level--) {\n for (int pos = 0; pos <= level; pos++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[level][pos];\n int left_child = pyramid[level + 1][pos];\n int right_child = pyramid[level + 1][pos + 1];\n \n // If violation exists\n if (current_value > left_child || current_value > right_child) {\n // Find all balls in the subtree that are smaller than current_value\n vector>> candidates;\n \n // Check direct children first\n if (current_value > left_child) {\n candidates.push_back({left_child, {level + 1, pos}});\n }\n if (current_value > right_child) {\n candidates.push_back({right_child, {level + 1, pos + 1}});\n }\n \n // Check lower levels if needed\n if (candidates.empty() || candidates.size() < 2) {\n for (int l = level + 2; l < N; l++) {\n for (int p = max(0, pos - (l - level)); p <= min(l, pos + (l - level)); p++) {\n if (pyramid[l][p] < current_value) {\n candidates.push_back({pyramid[l][p], {l, p}});\n }\n }\n }\n }\n \n // Sort candidates by value (smallest first)\n sort(candidates.begin(), candidates.end());\n \n if (!candidates.empty()) {\n auto [swap_value, swap_pos] = candidates[0];\n int swap_x = swap_pos.first, swap_y = swap_pos.second;\n \n // Move the candidate up to current position\n vector> path;\n int cx = swap_x, cy = swap_y;\n \n // Build path upward\n while (cx > level && !path.empty() && operations.size() < MAX_OPS) {\n path.push_back({cx, cy});\n // Move toward target\n if (cy > pos) {\n if (valid(cx - 1, cy - 1)) {\n cx--; cy--;\n } else if (valid(cx - 1, cy)) {\n cx--;\n }\n } else if (cy < pos) {\n if (valid(cx - 1, cy)) {\n cx--;\n } else if (valid(cx - 1, cy - 1)) {\n cx--; cy--;\n }\n } else {\n if (valid(cx - 1, cy)) {\n cx--;\n } else if (valid(cx - 1, cy - 1)) {\n cx--; cy--;\n }\n }\n }\n \n // Execute path in reverse\n for (int i = path.size() - 1; i >= 0 && operations.size() < MAX_OPS; i--) {\n auto [px, py] = path[i];\n if (i == path.size() - 1) {\n // First swap\n perform_swap(swap_x, swap_y, px, py, operations);\n } else {\n auto [prev_x, prev_y] = path[i + 1];\n perform_swap(prev_x, prev_y, px, py, operations);\n }\n }\n \n // Final swap if needed\n if (cx != level || cy != pos) {\n if (valid(cx, cy) && valid(level, pos) && operations.size() < MAX_OPS) {\n perform_swap(cx, cy, level, pos, operations);\n }\n }\n \n violations_fixed = true;\n }\n }\n }\n }\n \n // If no violations fixed or no improvement, break\n int violations_end = count_violations();\n if (!violations_fixed || violations_end >= violations_start) {\n break;\n }\n }\n \n // Phase 3: Local optimization - fix remaining violations with minimal swaps\n for (int pass = 0; pass < 3 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n for (int level = N - 2; level >= 0; level--) {\n for (int pos = 0; pos <= level; pos++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[level][pos];\n int left_child = pyramid[level + 1][pos];\n int right_child = pyramid[level + 1][pos + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_pos = (left_child <= right_child) ? pos : pos + 1;\n \n // Direct swap if possible and beneficial\n if (current_value > smaller_child) {\n perform_swap(level, pos, level + 1, smaller_child_pos, operations);\n changed = true;\n }\n }\n }\n }\n if (!changed) break;\n }\n \n // Output operations\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << op[0] << \" \" << op[1] << \" \" << op[2] << \" \" << op[3] << endl;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n solve();\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nconst int entrance_i = 0, entrance_j = 4;\n\n// Directions for 4-connectivity\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n};\n\nclass Warehouse {\nprivate:\n vector> grid; // -1: empty, -2: obstacle, -3: entrance, >=0: container number\n vector> obstacles;\n int N;\n map container_positions; // Map from position to container number\n \npublic:\n Warehouse(int n) : N(n) {\n grid.assign(D, vector(D, -1));\n obstacles.assign(D, vector(D, false));\n // Mark entrance\n grid[entrance_i][entrance_j] = -3;\n }\n \n void add_obstacle(int i, int j) {\n obstacles[i][j] = true;\n grid[i][j] = -2;\n }\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < D && j >= 0 && j < D;\n }\n \n bool is_empty(int i, int j) {\n return is_valid(i, j) && grid[i][j] == -1 && !obstacles[i][j] && !(i == entrance_i && j == entrance_j);\n }\n \n // BFS to find all reachable empty positions from entrance\n vector get_reachable_empty_positions() {\n vector> visited(D, vector(D, false));\n queue q;\n vector reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n // Check 4 adjacent squares\n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] == -1) { // Empty square\n reachable.push_back(Position(ni, nj));\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] >= 0) { // Container square - can traverse through it for reachability\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Calculate Manhattan distance from entrance\n int distance_from_entrance(int i, int j) {\n return abs(i - entrance_i) + abs(j - entrance_j);\n }\n \n // Estimate how many positions would become unreachable if we place a container at (i,j)\n int blocking_score(int i, int j) {\n if (!is_empty(i, j)) return INT_MAX;\n \n // Temporarily place a container here\n int original = grid[i][j];\n grid[i][j] = 999; // Temporary container\n \n // Count reachable positions\n vector reachable = get_reachable_empty_positions();\n int reachable_count = reachable.size();\n \n // Restore\n grid[i][j] = original;\n \n // Higher score means more blocking (worse)\n return (D*D - 1 - N - reachable_count);\n }\n \n // Place container with number t at position (i, j)\n void place_container(int t, int i, int j) {\n grid[i][j] = t;\n container_positions[Position(i, j)] = t;\n }\n \n // Get all currently reachable containers\n vector> get_reachable_containers() {\n vector> visited(D, vector(D, false));\n queue q;\n vector> reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] >= 0) { // Container\n reachable.push_back({Position(ni, nj), grid[ni][nj]});\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] == -1) { // Empty\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Get all containers sorted by their numbers\n vector> get_all_containers_sorted() {\n vector> containers;\n for (auto& p : container_positions) {\n containers.push_back({p.first, p.second});\n }\n sort(containers.begin(), containers.end(), [](const auto& a, const auto& b) {\n return a.second < b.second;\n });\n return containers;\n }\n};\n\nint main() {\n int N;\n cin >> D >> N; // Note: D is always 9 per problem statement\n \n Warehouse warehouse(N);\n \n // Read obstacles\n for (int i = 0; i < N; i++) {\n int ri, rj;\n cin >> ri >> rj;\n warehouse.add_obstacle(ri, rj);\n }\n \n vector arrived_containers;\n vector> placement_positions; // Store where each container was placed\n \n // Process each incoming container\n for (int d = 0; d < D*D - 1 - N; d++) {\n int t;\n cin >> t;\n arrived_containers.push_back(t);\n \n // Get all reachable empty positions\n vector reachable = warehouse.get_reachable_empty_positions();\n \n if (reachable.empty()) {\n // This shouldn't happen according to problem constraints\n // Just pick any empty position\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (warehouse.is_empty(i, j)) {\n cout << i << \" \" << j << endl;\n warehouse.place_container(t, i, j);\n placement_positions.push_back({i, j});\n goto placed;\n }\n }\n }\n }\n \n // Calculate statistics for decision making\n double avg_so_far = 0.0;\n if (d > 0) {\n for (int i = 0; i < d; i++) {\n avg_so_far += arrived_containers[i];\n }\n avg_so_far /= d;\n }\n \n // Score each reachable position\n vector> position_scores;\n for (auto& pos : reachable) {\n // Base score: distance from entrance (want smaller for smaller t)\n double distance_score = warehouse.distance_from_entrance(pos.i, pos.j);\n \n // Priority factor: if t is smaller than average, we want closer positions\n double priority_factor = 1.0;\n if (d > 0) {\n if (t < avg_so_far) {\n // This container should be removed earlier, so give it higher priority (lower score)\n priority_factor = 0.5;\n } else {\n // This container should be removed later, so lower priority (higher score)\n priority_factor = 2.0;\n }\n }\n \n // Blocking score: how much this placement would block other positions\n int block_score = warehouse.blocking_score(pos.i, pos.j);\n \n // Total score (lower is better)\n double total_score = distance_score * priority_factor + block_score * 0.1;\n \n position_scores.push_back({total_score, pos});\n }\n \n // Choose position with minimum score\n sort(position_scores.begin(), position_scores.end());\n Position chosen = position_scores[0].second;\n \n cout << chosen.i << \" \" << chosen.j << endl;\n cout.flush(); // Important: flush output\n \n warehouse.place_container(t, chosen.i, chosen.j);\n placement_positions.push_back({chosen.i, chosen.j});\n \n placed:; // Label for goto\n }\n \n // Determine removal order\n vector> containers_sorted = warehouse.get_all_containers_sorted();\n \n // Output removal order (by container number, ascending)\n for (auto& p : containers_sorted) {\n cout << p.first.i << \" \" << p.first.j << endl;\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nconst int M = 100;\n\nint main() {\n int n = N, m = M;\n vector> grid(n, vector(n));\n \n // Read input\n cin >> n >> m;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n \n // Determine adjacencies\n vector> adj(m + 1); // adj[c] contains colors adjacent to color c\n vector adj_to_external(m + 1, false); // whether color c is adjacent to external (0)\n \n // Check adjacencies in the original grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n \n // Check if adjacent to boundary (external)\n if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {\n adj_to_external[c] = true;\n }\n \n // Check 4-directional neighbors\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int d = grid[ni][nj];\n if (c != d) {\n adj[c].insert(d);\n adj[d].insert(c);\n }\n } else {\n // Adjacent to external\n adj_to_external[c] = true;\n adj[c].insert(0);\n // Note: We don't add to adj[0] as it's external and always connected\n }\n }\n }\n }\n \n // Create output grid, initially all color 0\n vector> result(n, vector(n, 0));\n \n // Strategy: Place one tile per color in a compact arrangement\n // Start by placing colors that need to be adjacent to external on the boundary\n \n vector colors;\n for (int i = 1; i <= m; i++) {\n colors.push_back(i);\n }\n \n // Sort colors by number of adjacencies (descending) to place high-degree nodes first\n sort(colors.begin(), colors.end(), [&](int a, int b) {\n return adj[a].size() > adj[b].size();\n });\n \n // Place colors on the grid\n int placed = 0;\n bool placed_grid[N][N] = {false};\n \n // First, try to place on the boundary for colors adjacent to external\n vector> boundary_positions;\n for (int i = 0; i < n; i++) {\n boundary_positions.push_back({i, 0});\n boundary_positions.push_back({i, n-1});\n }\n for (int j = 1; j < n-1; j++) {\n boundary_positions.push_back({0, j});\n boundary_positions.push_back({n-1, j});\n }\n \n int boundary_idx = 0;\n \n // Place colors adjacent to external on boundary\n for (int color : colors) {\n if (adj_to_external[color] && boundary_idx < boundary_positions.size()) {\n int x = boundary_positions[boundary_idx].first;\n int y = boundary_positions[boundary_idx].second;\n result[x][y] = color;\n placed_grid[x][y] = true;\n boundary_idx++;\n placed++;\n }\n }\n \n // Place remaining colors in the interior\n for (int color : colors) {\n if (placed >= m) break;\n \n bool already_placed = false;\n for (int i = 0; i < n && !already_placed; i++) {\n for (int j = 0; j < n && !already_placed; j++) {\n if (result[i][j] == color) {\n already_placed = true;\n }\n }\n }\n \n if (already_placed) continue;\n \n // Find a position to place this color\n bool placed_color = false;\n \n // Try to place adjacent to already placed colors it should be adjacent to\n for (int c : adj[color]) {\n if (c == 0) continue; // Skip external\n \n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (result[i][j] == c) {\n // Try to place adjacent to this tile\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n && !placed_grid[ni][nj]) {\n result[ni][nj] = color;\n placed_grid[ni][nj] = true;\n placed_color = true;\n placed++;\n break;\n }\n }\n }\n }\n }\n \n if (placed_color) break;\n }\n \n // If couldn't place adjacent to any adjacent color, place anywhere available\n if (!placed_color) {\n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (!placed_grid[i][j]) {\n result[i][j] = color;\n placed_grid[i][j] = true;\n placed_color = true;\n placed++;\n }\n }\n }\n }\n }\n \n // Output the result\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cout << result[i][j];\n if (j < n - 1) cout << \" \";\n }\n cout << endl;\n }\n \n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Simple disjoint set for potential use in grouping similar items\nstruct DisjointSet {\n vector parent, rank;\n \n DisjointSet(int n) : parent(n), rank(n, 0) {\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n \n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n \n void unite(int x, int y) {\n x = find(x), y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) swap(x, y);\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n};\n\n// For estimating weights from comparisons\nclass WeightEstimator {\nprivate:\n int n;\n vector weights;\n vector> comparison_results; // 1 if i > j, -1 if i < j, 0 if equal\n \npublic:\n WeightEstimator(int size) : n(size), weights(size, 1.0), comparison_results(size, vector(size, 0)) {}\n \n void add_comparison(int i, int j, const string& result) {\n if (result == \">\") {\n comparison_results[i][j] = 1;\n comparison_results[j][i] = -1;\n } else if (result == \"<\") {\n comparison_results[i][j] = -1;\n comparison_results[j][i] = 1;\n } else { // \"=\"\n comparison_results[i][j] = 0;\n comparison_results[j][i] = 0;\n }\n }\n \n // Use iterative method to estimate weights\n void estimate_weights() {\n // Initialize with uniform weights\n for (int i = 0; i < n; ++i) weights[i] = 1.0;\n \n // Use a simple iterative approach\n const int max_iterations = 100;\n const double learning_rate = 0.1;\n \n for (int iter = 0; iter < max_iterations; ++iter) {\n bool changed = false;\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (i == j || comparison_results[i][j] == 0) continue;\n \n double diff = weights[i] - weights[j];\n double target_diff = comparison_results[i][j] * 0.1; // Small positive/negative value\n \n if (comparison_results[i][j] == 1 && diff < 0.01) {\n weights[i] += learning_rate;\n weights[j] -= learning_rate * 0.5;\n changed = true;\n } else if (comparison_results[i][j] == -1 && diff > -0.01) {\n weights[i] -= learning_rate;\n weights[j] += learning_rate * 0.5;\n changed = true;\n }\n }\n }\n \n if (!changed) break;\n }\n \n // Normalize weights to positive values\n double min_weight = *min_element(weights.begin(), weights.end());\n if (min_weight <= 0) {\n for (int i = 0; i < n; ++i) {\n weights[i] += (1.0 - min_weight);\n }\n }\n }\n \n double get_weight(int i) const {\n return weights[i];\n }\n \n vector get_all_weights() const {\n return weights;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, D, Q;\n cin >> N >> D >> Q;\n \n // Initialize random generator\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937 rng(seed);\n uniform_int_distribution item_dist(0, N-1);\n uniform_int_distribution size_dist(1, N/3);\n \n // Create weight estimator\n WeightEstimator estimator(N);\n \n // Phase 1: Gather information through comparisons\n vector> pairwise_comparisons;\n \n // First, do some pairwise comparisons\n int queries_used = 0;\n vector item_compared(N, false);\n \n // Compare each item with at least one other item\n for (int i = 0; i < N && queries_used < Q/2; ++i) {\n int j = (i + 1) % N;\n if (queries_used >= Q) break;\n \n cout << \"1 1 \" << i << \" \" << j << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(i, j, result);\n queries_used++;\n pairwise_comparisons.push_back({i, j});\n item_compared[i] = true;\n item_compared[j] = true;\n }\n \n // Ensure all items are compared at least once\n for (int i = 0; i < N && queries_used < Q/2; ++i) {\n if (!item_compared[i]) {\n int j = (i == 0) ? 1 : 0;\n cout << \"1 1 \" << i << \" \" << j << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(i, j, result);\n queries_used++;\n pairwise_comparisons.push_back({i, j});\n }\n }\n \n // Use remaining queries for more informative comparisons\n while (queries_used < Q) {\n // Random sizes for left and right\n int left_size = min(size_dist(rng), N/2);\n int right_size = min(size_dist(rng), N/2);\n \n if (left_size == 0 || right_size == 0) {\n left_size = 1;\n right_size = 1;\n }\n \n // Generate random sets\n vector left_items, right_items;\n vector used(N, false);\n \n // Pick left items\n for (int i = 0; i < left_size; ++i) {\n int attempts = 0;\n int item = item_dist(rng);\n while (used[item] && attempts < 10) {\n item = item_dist(rng);\n attempts++;\n }\n if (!used[item]) {\n left_items.push_back(item);\n used[item] = true;\n }\n }\n \n // Pick right items\n for (int i = 0; i < right_size; ++i) {\n int attempts = 0;\n int item = item_dist(rng);\n while (used[item] && attempts < 10) {\n item = item_dist(rng);\n attempts++;\n }\n if (!used[item]) {\n right_items.push_back(item);\n used[item] = true;\n }\n }\n \n // Ensure we have at least one item on each side\n if (left_items.empty() || right_items.empty()) {\n if (left_items.empty()) {\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n left_items.push_back(i);\n used[i] = true;\n break;\n }\n }\n }\n if (right_items.empty()) {\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n right_items.push_back(i);\n used[i] = true;\n break;\n }\n }\n }\n }\n \n // Output query\n cout << left_items.size() << \" \" << right_items.size();\n for (int item : left_items) cout << \" \" << item;\n for (int item : right_items) cout << \" \" << item;\n cout << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n // For group comparisons, we can't directly add to estimator\n // But we can use this information later for refinement\n queries_used++;\n \n // If we have equality, we can treat these groups as having similar weights\n if (result == \"=\") {\n // Could implement logic to update estimates based on group equality\n // For now, just store this information\n }\n }\n \n // Estimate weights based on comparisons\n estimator.estimate_weights();\n vector estimated_weights = estimator.get_all_weights();\n \n // Phase 2: Partition items into D sets\n vector assignment(N, 0);\n vector set_weights(D, 0.0);\n \n // Create list of items with their estimated weights\n vector> items;\n for (int i = 0; i < N; ++i) {\n items.push_back({estimated_weights[i], i});\n }\n \n // Sort by weight (descending) for better greedy assignment\n sort(items.rbegin(), items.rend());\n \n // Greedy assignment: assign heaviest remaining item to lightest set\n for (auto& item : items) {\n int item_idx = item.second;\n double weight = item.first;\n \n // Find the set with minimum current weight\n int min_set = 0;\n for (int j = 1; j < D; ++j) {\n if (set_weights[j] < set_weights[min_set]) {\n min_set = j;\n }\n }\n \n assignment[item_idx] = min_set;\n set_weights[min_set] += weight;\n }\n \n // Local search improvement: try swapping items between sets\n const int max_swaps = N * D;\n for (int iter = 0; iter < max_swaps; ++iter) {\n // Randomly pick two different sets\n int set1 = rng() % D;\n int set2 = rng() % (D - 1);\n if (set2 >= set1) set2++;\n \n // Find items in these sets\n vector items_in_set1, items_in_set2;\n for (int i = 0; i < N; ++i) {\n if (assignment[i] == set1) items_in_set1.push_back(i);\n if (assignment[i] == set2) items_in_set2.push_back(i);\n }\n \n if (items_in_set1.empty() || items_in_set2.empty()) continue;\n \n // Try swapping a random pair\n int item1 = items_in_set1[rng() % items_in_set1.size()];\n int item2 = items_in_set2[rng() % items_in_set2.size()];\n \n double w1 = estimated_weights[item1];\n double w2 = estimated_weights[item2];\n \n // Calculate current variance\n double old_var = 0.0;\n double mean = 0.0;\n for (double w : set_weights) mean += w;\n mean /= D;\n for (double w : set_weights) old_var += (w - mean) * (w - mean);\n old_var /= D;\n \n // Calculate variance after swap\n vector new_weights = set_weights;\n new_weights[set1] = new_weights[set1] - w1 + w2;\n new_weights[set2] = new_weights[set2] - w2 + w1;\n \n double new_mean = 0.0;\n for (double w : new_weights) new_mean += w;\n new_mean /= D;\n \n double new_var = 0.0;\n for (double w : new_weights) new_var += (w - new_mean) * (w - new_mean);\n new_var /= D;\n \n // Accept swap if it improves variance\n if (new_var < old_var) {\n assignment[item1] = set2;\n assignment[item2] = set1;\n set_weights[set1] = new_weights[set1];\n set_weights[set2] = new_weights[set2];\n }\n }\n \n // Output final assignment\n for (int i = 0; i < N; ++i) {\n cout << assignment[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n \n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct BoxPosition {\n int stack_idx;\n int height; // 0-indexed from bottom\n bool removed;\n};\n\nint main() {\n int n = 200, m = 10;\n int boxes_per_stack = n / m;\n \n // Read input\n vector> stacks(m, vector(boxes_per_stack));\n vector box_positions(n + 1); // 1-indexed\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_positions[stacks[i][j]] = {i, j, false};\n }\n }\n \n vector> operations;\n \n // For each box from 1 to 200\n for (int target = 1; target <= n; target++) {\n // If box is already removed, skip (shouldn't happen)\n if (box_positions[target].removed) continue;\n \n int stack_idx = box_positions[target].stack_idx;\n int height = box_positions[target].height;\n \n // Check if box is at the top of its stack\n bool is_top = true;\n for (int i = height + 1; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) { // 0 indicates removed box\n is_top = false;\n break;\n }\n }\n \n // Clean up removed boxes from top of stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Recalculate if it's at the top after cleanup\n is_top = (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1);\n \n if (is_top) {\n // Can remove directly\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n continue;\n }\n \n // Need to move the box and everything above it\n // Find the best destination stack\n \n int best_stack = -1;\n int min_cost = INT_MAX;\n \n // First, try to find an empty stack\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n if (stacks[dest].empty()) {\n best_stack = dest;\n break;\n }\n }\n \n // If no empty stack, find stack with minimum additional cost\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n \n // Calculate cost of moving to this stack\n int boxes_to_move = 0;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move++;\n }\n }\n \n // Energy cost is boxes_to_move + 1\n int cost = boxes_to_move + 1;\n \n // Prefer stacks that are shorter or have higher-numbered boxes on top\n cost += stacks[dest].size(); // penalty for taller stacks\n \n if (cost < min_cost) {\n min_cost = cost;\n best_stack = dest;\n }\n }\n }\n \n // If still no valid destination, pick any different stack\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx) {\n best_stack = dest;\n break;\n }\n }\n }\n \n // Perform the move\n vector boxes_to_move;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move.push_back(stacks[stack_idx][i]);\n }\n }\n \n // Update stacks\n stacks[stack_idx].resize(height);\n \n for (int box : boxes_to_move) {\n stacks[best_stack].push_back(box);\n box_positions[box].stack_idx = best_stack;\n box_positions[box].height = stacks[best_stack].size() - 1;\n }\n \n operations.push_back({target, best_stack + 1});\n \n // Now try to remove the target box (it should be at the top)\n stack_idx = box_positions[target].stack_idx;\n height = box_positions[target].height;\n \n // Clean up the stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Verify it's at the top\n if (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1) {\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n } else {\n // Something went wrong, try one more move\n // This is a fallback - shouldn't happen in normal cases\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx && stacks[dest].empty()) {\n // Move just this box to empty stack\n stacks[stack_idx].erase(stacks[stack_idx].begin() + height);\n stacks[dest].push_back(target);\n box_positions[target].stack_idx = dest;\n box_positions[target].height = 0;\n operations.push_back({target, dest + 1});\n break;\n }\n }\n \n // Now remove it\n operations.push_back({target, 0});\n for (int i = 0; i < m; i++) {\n if (!stacks[i].empty() && stacks[i].back() == target) {\n stacks[i].pop_back();\n break;\n }\n }\n box_positions[target].removed = true;\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \nusing namespace std;\n\n// Directions: R, D, L, U\nconst int di[4] = {0, 1, 0, -1};\nconst int dj[4] = {1, 0, -1, 0};\nconst string DIR = \"RDLU\";\n\nint N;\nvector h, v;\nvector> d;\nvector> visited;\nstring route = \"\";\n\n// Check if we can move from (i,j) to (ni,nj)\nbool canMove(int i, int j, int ni, int nj) {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n \n if (i == ni) { // horizontal move\n int min_j = min(j, nj);\n return v[i][min_j] == '0';\n } else { // vertical move\n int min_i = min(i, ni);\n return h[min_i][j] == '0';\n }\n}\n\n// DFS with priority based on dirtiness\nvoid dfs_priority(int i, int j) {\n visited[i][j] = true;\n \n // Collect all possible next moves with their priorities\n vector> next_moves; // (priority, direction)\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n // Priority: higher dirtiness gets higher priority\n next_moves.push_back({-d[ni][nj], dir}); // negative for descending sort\n }\n }\n \n // Sort by priority (descending dirtiness)\n sort(next_moves.begin(), next_moves.end());\n \n // Visit in priority order\n for (auto& move : next_moves) {\n int dir = move.second;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n \n route += DIR[dir];\n dfs_priority(ni, nj);\n route += DIR[(dir + 2) % 4]; // return\n }\n}\n\n// Lightweight optimization: Add only a few loops for the highest dirt cells\nstring addFewLoops(const string& base_route) {\n string result = base_route;\n if (result.size() >= 99000) return result; // Avoid exceeding limit\n \n // Track positions during route\n vector> positions;\n int ci = 0, cj = 0;\n positions.push_back({ci, cj});\n \n for (char move : base_route) {\n int dir = DIR.find(move);\n ci += di[dir];\n cj += dj[dir];\n positions.push_back({ci, cj});\n }\n \n // Find high-dirt cells\n vector>> dirt_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n dirt_cells.push_back({d[i][j], {i, j}});\n }\n }\n sort(dirt_cells.rbegin(), dirt_cells.rend()); // descending order\n \n // Only add loops for top 3 dirtiest cells (very conservative)\n int loops_added = 0;\n for (int idx = 0; idx < min(3, (int)dirt_cells.size()) && loops_added < 3; idx++) {\n int target_i = dirt_cells[idx].second.first;\n int target_j = dirt_cells[idx].second.second;\n \n // Find earliest visit to this cell\n int first_visit = -1;\n for (int t = 0; t < positions.size(); t++) {\n if (positions[t].first == target_i && positions[t].second == target_j) {\n first_visit = t;\n break;\n }\n }\n \n if (first_visit == -1) continue;\n \n // Try to add a small loop (go to neighbor and back)\n for (int dir = 0; dir < 4; dir++) {\n int ni = target_i + di[dir];\n int nj = target_j + dj[dir];\n \n if (canMove(target_i, target_j, ni, nj) && result.size() + 2 <= 99500) {\n // Insert loop at first_visit position\n string loop = string(1, DIR[dir]) + string(1, DIR[(dir + 2) % 4]);\n result.insert(first_visit, loop);\n \n // Update positions (only if we need to add more loops)\n if (loops_added < 2) { // Only update positions if we plan to add more loops\n positions.insert(positions.begin() + first_visit + 1, {ni, nj});\n positions.insert(positions.begin() + first_visit + 2, {target_i, target_j});\n }\n \n loops_added++;\n break;\n }\n }\n }\n \n return result;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read input\n cin >> N;\n h.resize(N-1);\n for (int i = 0; i < N-1; i++) {\n cin >> h[i];\n }\n v.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> v[i];\n }\n d.resize(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n // Initialize visited array\n visited = vector>(N, vector(N, false));\n \n // Generate initial route using priority DFS\n dfs_priority(0, 0);\n \n // Lightweight optimization: Add only a few loops\n string optimized_route = addFewLoops(route);\n \n // Ensure we don't exceed length limit\n if (optimized_route.size() > 100000) {\n cout << route << endl; // Fallback to original if optimized is too long\n } else {\n cout << optimized_route << endl;\n }\n \n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n int distance(const Position& other) const {\n return abs(i - other.i) + abs(j - other.j);\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n};\n\nstruct HashPosition {\n size_t operator()(const Position& p) const {\n return p.i * 1000 + p.j;\n }\n};\n\nclass Solution {\nprivate:\n int N, M;\n Position start_pos;\n vector grid;\n vector targets;\n map> char_positions;\n \n // Random number generator\n mt19937 rng;\n \npublic:\n Solution() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n cin >> N >> M;\n cin >> start_pos.i >> start_pos.j;\n grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n targets.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i];\n }\n \n // Build map of character positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char_positions[grid[i][j]].push_back(Position(i, j));\n }\n }\n }\n \n // Find the position with minimum distance from current position\n Position find_best_position(char c, const Position& current) {\n if (char_positions.find(c) == char_positions.end()) {\n return Position(0, 0);\n }\n \n Position best_pos = char_positions[c][0];\n int min_dist = current.distance(best_pos);\n \n for (const Position& pos : char_positions[c]) {\n int dist = current.distance(pos);\n if (dist < min_dist) {\n min_dist = dist;\n best_pos = pos;\n }\n }\n \n return best_pos;\n }\n \n // Calculate overlap between two strings\n int calculate_overlap(const string& s1, const string& s2) {\n int max_overlap = 0;\n int len1 = s1.length();\n int len2 = s2.length();\n \n for (int i = 1; i <= min(len1, len2); i++) {\n bool match = true;\n for (int j = 0; j < i; j++) {\n if (s1[len1 - i + j] != s2[j]) {\n match = false;\n break;\n }\n }\n if (match) {\n max_overlap = i;\n }\n }\n \n return max_overlap;\n }\n \n // Calculate the cost of typing a string from a given position\n long long calculate_string_cost(const string& str, Position current_pos) {\n long long cost = 0;\n for (char c : str) {\n Position best_pos = find_best_position(c, current_pos);\n cost += current_pos.distance(best_pos) + 1;\n current_pos = best_pos;\n }\n return cost;\n }\n \n // Build superstring using greedy algorithm with multiple strategies\n vector build_superstring_sequence_strategy(int strategy) {\n if (M == 0) return {};\n \n vector used(M, false);\n vector result;\n \n // Choose first string based on strategy\n int first_idx = 0;\n \n if (strategy == 0) {\n // Strategy 0: Start with the string that's cheapest to type from start position\n long long min_cost = LLONG_MAX;\n for (int i = 0; i < M; i++) {\n long long cost = calculate_string_cost(targets[i], start_pos);\n if (cost < min_cost) {\n min_cost = cost;\n first_idx = i;\n }\n }\n } else if (strategy == 1) {\n // Strategy 1: Start with random string\n first_idx = rng() % M;\n } else {\n // Strategy 2: Start with first string (original)\n first_idx = 0;\n }\n \n used[first_idx] = true;\n result.push_back(targets[first_idx]);\n \n // Greedily add strings with maximum overlap\n for (int step = 1; step < M; step++) {\n int best_idx = -1;\n int best_score = -1;\n string current_string = result.back();\n \n for (int i = 0; i < M; i++) {\n if (used[i]) continue;\n \n int overlap = calculate_overlap(current_string, targets[i]);\n \n // Score based on overlap and also consider the cost of typing non-overlapping part\n // from the end position of current string\n int score = overlap * 100; // prioritize overlap\n \n // Try to estimate typing cost for non-overlapping part\n if (overlap < targets[i].length()) {\n // Simulate typing the last character of current string\n Position current_end_pos = start_pos;\n if (!current_string.empty()) {\n for (char c : current_string) {\n current_end_pos = find_best_position(c, current_end_pos);\n }\n }\n \n // Estimate cost for non-overlapping part\n long long non_overlap_cost = 0;\n for (int j = overlap; j < targets[i].length(); j++) {\n Position best_pos = find_best_position(targets[i][j], current_end_pos);\n non_overlap_cost += current_end_pos.distance(best_pos) + 1;\n current_end_pos = best_pos;\n }\n \n // Subtract a fraction of cost from score (higher cost = lower score)\n score -= non_overlap_cost / 10;\n }\n \n if (score > best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n for (int i = 0; i < M; i++) {\n if (!used[i]) {\n best_idx = i;\n break;\n }\n }\n }\n \n used[best_idx] = true;\n result.push_back(targets[best_idx]);\n }\n \n return result;\n }\n \n // Generate operations with optimization for position selection\n vector generate_operations_optimized(const vector& sequence) {\n vector operations;\n Position current_pos = start_pos;\n \n if (sequence.empty()) return operations;\n \n // Type the first string\n for (char c : sequence[0]) {\n Position best_pos = find_best_position(c, current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n \n // For subsequent strings, type only the non-overlapping part\n for (int i = 1; i < sequence.size(); i++) {\n const string& prev = sequence[i-1];\n const string& curr = sequence[i];\n \n // Find the overlap\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), curr.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != curr[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n \n // Type the non-overlapping part\n for (int j = overlap; j < curr.length(); j++) {\n Position best_pos = find_best_position(curr[j], current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n }\n \n return operations;\n }\n \n // Calculate total cost of operations\n long long calculate_total_cost(const vector& operations) {\n long long cost = 0;\n Position current_pos = start_pos;\n for (const Position& op : operations) {\n cost += current_pos.distance(op) + 1;\n current_pos = op;\n }\n return cost;\n }\n \n // Try to optimize the position selection for a given sequence\n vector optimize_positions(const vector& sequence) {\n if (sequence.empty()) return {};\n \n vector operations;\n Position current_pos = start_pos;\n \n // For each string in sequence\n for (int seq_idx = 0; seq_idx < sequence.size(); seq_idx++) {\n const string& str = sequence[seq_idx];\n \n // If it's not the first string, we might have overlap\n int start_char_idx = 0;\n if (seq_idx > 0) {\n const string& prev = sequence[seq_idx - 1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n // For each character we need to type\n for (int j = start_char_idx; j < str.length(); j++) {\n char c = str[j];\n \n // If there are multiple positions for this character, try to look ahead\n if (char_positions[c].size() > 1 && j < str.length() - 1) {\n char next_char = str[j + 1];\n Position best_pos = char_positions[c][0];\n int best_score = INT_MAX;\n \n for (const Position& pos : char_positions[c]) {\n int move_cost = current_pos.distance(pos);\n \n // Look ahead to next character\n int next_min_cost = INT_MAX;\n for (const Position& next_pos : char_positions[next_char]) {\n int next_cost = pos.distance(next_pos);\n next_min_cost = min(next_min_cost, next_cost);\n }\n \n // Score is total estimated cost\n int score = move_cost + 1 + next_min_cost + 1;\n if (score < best_score) {\n best_score = score;\n best_pos = pos;\n }\n }\n \n operations.push_back(best_pos);\n current_pos = best_pos;\n } else {\n // Just pick the closest position\n Position best_pos = find_best_position(c, current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n }\n }\n \n return operations;\n }\n \n // Main solve function with multiple strategies\n void solve() {\n vector best_operations;\n long long best_cost = LLONG_MAX;\n \n // Try different strategies\n for (int strategy = 0; strategy < 3; strategy++) {\n vector sequence = build_superstring_sequence_strategy(strategy);\n vector operations = optimize_positions(sequence);\n \n long long cost = calculate_total_cost(operations);\n if (cost < best_cost) {\n best_cost = cost;\n best_operations = operations;\n }\n }\n \n // Try a few random permutations for improvement\n for (int trial = 0; trial < 5; trial++) {\n vector sequence = build_superstring_sequence_strategy(1); // random start\n vector operations = optimize_positions(sequence);\n \n long long cost = calculate_total_cost(operations);\n if (cost < best_cost) {\n best_cost = cost;\n best_operations = operations;\n }\n }\n \n // Output the best operations\n for (const Position& pos : best_operations) {\n cout << pos.i << \" \" << pos.j << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n Solution solution;\n solution.solve();\n \n return 0;\n}","ahc030":"#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 double EPS = 1e-9;\n\n// Helper functions\ndouble square(double x) { return x * x; }\n\nstruct Point {\n int i, j;\n Point(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Point& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Point& other) const {\n return i == other.i && j == other.j;\n }\n};\n\n// Oil field representation\nstruct OilField {\n vector shape;\n int size;\n int max_i, max_j; // max coordinates in the shape\n};\n\nclass Solver {\nprivate:\n int N, M;\n double epsilon;\n vector oil_fields;\n vector> known_values; // -1 means unknown\n vector> probability; // probability that square has oil\n vector> confidence; // confidence in probability estimate\n mt19937 rng;\n \n // Tracking for optimization\n int operations_used = 0;\n double total_cost = 0.0;\n set known_oil_squares;\n set candidate_oil_squares;\n \n // For divination noise modeling\n double expected_value(int k, int actual_sum) {\n return (k - actual_sum) * epsilon + actual_sum * (1 - epsilon);\n }\n \n double variance(int k) {\n return k * epsilon * (1 - epsilon);\n }\n \n // Read input\n void read_input() {\n cin >> N >> M >> epsilon;\n \n oil_fields.resize(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n oil_fields[k].shape.resize(d);\n oil_fields[k].size = d;\n \n int min_i = 1000, min_j = 1000, max_i = -1, max_j = -1;\n for (int i = 0; i < d; i++) {\n int ii, jj;\n cin >> ii >> jj;\n oil_fields[k].shape[i] = Point(ii, jj);\n min_i = min(min_i, ii);\n min_j = min(min_j, jj);\n max_i = max(max_i, ii);\n max_j = max(max_j, jj);\n }\n \n // Translate to ensure top-left is (0,0) - already done in input\n oil_fields[k].max_i = max_i;\n oil_fields[k].max_j = max_j;\n }\n \n // Initialize known values and probability\n known_values.assign(N, vector(N, -1));\n probability.assign(N, vector(N, 0.5)); // Start with 50% probability\n confidence.assign(N, vector(N, 0.0)); // Start with 0 confidence\n \n // Initialize candidate squares (all possible positions for all oil fields)\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n candidate_oil_squares.insert(Point(i, j));\n }\n }\n }\n \n // Drill at point (i, j)\n int drill(int i, int j) {\n if (operations_used >= 2 * N * N) return -1;\n \n cout << \"q 1 \" << i << \" \" << j << endl;\n operations_used++;\n total_cost += 1.0;\n \n int value;\n cin >> value;\n \n known_values[i][j] = value;\n if (value > 0) {\n known_oil_squares.insert(Point(i, j));\n probability[i][j] = 1.0;\n confidence[i][j] = 1.0;\n } else {\n probability[i][j] = 0.0;\n confidence[i][j] = 1.0;\n }\n \n return value;\n }\n \n // Divine the sum of values in set S\n int divine(const vector& points) {\n if (points.size() < 2 || operations_used >= 2 * N * N) return -1;\n \n cout << \"q \" << points.size();\n for (const Point& p : points) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n operations_used++;\n total_cost += 1.0 / sqrt(points.size());\n \n int result;\n cin >> result;\n \n // Update probabilities based on result\n update_probabilities_from_divine(points, result);\n \n return result;\n }\n \n // Update probabilities based on divine result\n void update_probabilities_from_divine(const vector& points, int result) {\n if (result < 0) return;\n \n // Simple Bayesian update - adjust probabilities to be more consistent with result\n double current_sum_estimate = 0.0;\n for (const Point& p : points) {\n current_sum_estimate += probability[p.i][p.j];\n }\n \n double adjustment = (result - current_sum_estimate) / points.size();\n \n for (const Point& p : points) {\n if (known_values[p.i][p.j] == -1) { // Only update unknown squares\n probability[p.i][p.j] = max(0.0, min(1.0, probability[p.i][p.j] + adjustment * 0.5));\n confidence[p.i][p.j] = min(1.0, confidence[p.i][p.j] + 0.1);\n }\n }\n }\n \n // Check if point is valid\n bool is_valid_point(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n }\n \n // Check if oil field can be placed at (offset_i, offset_j)\n bool can_place_field(const OilField& field, int offset_i, int offset_j) {\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (!is_valid_point(i, j)) return false;\n // If we know this square has no oil, we can't place the field here\n if (known_values[i][j] == 0) return false;\n }\n return true;\n }\n \n // Calculate score for placing oil field at (offset_i, offset_j)\n double score_field_placement(const OilField& field, int offset_i, int offset_j) {\n if (!can_place_field(field, offset_i, offset_j)) return -1e9;\n \n double score = 0.0;\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (known_values[i][j] > 0) {\n // We know there's oil here, good!\n score += 10.0;\n } else if (known_values[i][j] == 0) {\n // We know there's no oil here, impossible\n return -1e9;\n } else {\n // Unknown, use probability\n score += probability[i][j];\n }\n }\n return score;\n }\n \n // Get all possible placements for an oil field\n vector> get_possible_placements(const OilField& field) {\n vector> placements;\n \n for (int i = 0; i <= N - 1 - field.max_i; i++) {\n for (int j = 0; j <= N - 1 - field.max_j; j++) {\n double score = score_field_placement(field, i, j);\n if (score > -1e8) {\n placements.push_back({Point(i, j), score});\n }\n }\n }\n \n // Sort by score\n sort(placements.begin(), placements.end(), [](const auto& a, const auto& b) {\n return a.second > b.second;\n });\n \n return placements;\n }\n \n // Phase 1: Coarse search with divination\n void phase1_coarse_search() {\n // Use larger blocks for divination\n int block_size = max(2, N / 4);\n \n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n if (operations_used >= 2 * N * N) return;\n \n vector block_points;\n for (int i = bi; i < min(bi + block_size, N); i++) {\n for (int j = bj; j < min(bj + block_size, N); j++) {\n if (known_values[i][j] == -1) { // Only include unknown squares\n block_points.push_back(Point(i, j));\n }\n }\n }\n \n // If we have at least 2 unknown points, divine the block\n if (block_points.size() >= 2) {\n int result = divine(block_points);\n // Results are processed in divine() via update_probabilities_from_divine\n }\n }\n }\n }\n \n // Phase 2: Targeted search based on probabilities\n void phase2_targeted_search() {\n // Create a priority queue of squares to investigate based on uncertainty and probability\n vector> candidates;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n // Prioritize squares with moderate confidence and high probability\n // We want to investigate squares that are likely to have oil but we're not sure\n double uncertainty = 1.0 - confidence[i][j];\n double priority = probability[i][j] * uncertainty;\n candidates.push_back({priority, Point(i, j)});\n }\n }\n }\n \n // Sort by priority\n sort(candidates.begin(), candidates.end(), greater>());\n \n // Investigate top candidates\n int to_investigate = min(20, (int)candidates.size());\n for (int idx = 0; idx < to_investigate; idx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& p = candidates[idx].second;\n \n // If probability is very high, drill directly\n if (probability[p.i][p.j] > 0.7) {\n drill(p.i, p.j);\n } \n // Otherwise, try to group with nearby squares for divination\n else {\n vector nearby;\n nearby.push_back(p);\n \n // Add nearby squares\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = p.i + di, nj = p.j + dj;\n if (is_valid_point(ni, nj) && known_values[ni][nj] == -1) {\n nearby.push_back(Point(ni, nj));\n }\n }\n }\n \n // If we have at least 2 squares, divine them\n if (nearby.size() >= 2 && nearby.size() <= 8) { // Limit size to reduce noise\n divine(nearby);\n } else {\n // Otherwise just drill this square\n drill(p.i, p.j);\n }\n }\n }\n }\n \n // Phase 3: Use shape information to guide search\n void phase3_shape_guided_search() {\n // For each oil field, find the most likely placements\n for (int fidx = 0; fidx < M; fidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const OilField& field = oil_fields[fidx];\n auto placements = get_possible_placements(field);\n \n if (placements.empty()) continue;\n \n // Try the top few placements\n int to_try = min(3, (int)placements.size());\n for (int pidx = 0; pidx < to_try; pidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& offset = placements[pidx].first;\n \n // Check if we can verify this placement\n bool need_verification = false;\n vector unknown_points;\n \n for (const Point& p : field.shape) {\n int i = p.i + offset.i;\n int j = p.j + offset.j;\n if (known_values[i][j] == -1) {\n need_verification = true;\n unknown_points.push_back(Point(i, j));\n }\n }\n \n if (!need_verification) continue; // Already verified or impossible\n \n // Try to verify with minimum operations\n if (unknown_points.size() == 1) {\n // Just drill the single unknown point\n const Point& pt = unknown_points[0];\n drill(pt.i, pt.j);\n } else if (unknown_points.size() <= 6) {\n // Divine the unknown points together\n divine(unknown_points);\n } else {\n // Drill the point with highest probability among unknowns\n Point best_point = unknown_points[0];\n double best_prob = probability[best_point.i][best_point.j];\n \n for (const Point& pt : unknown_points) {\n if (probability[pt.i][pt.j] > best_prob) {\n best_prob = probability[pt.i][pt.j];\n best_point = pt;\n }\n }\n \n drill(best_point.i, best_point.j);\n }\n }\n }\n }\n \n // Make final guess\n bool make_guess() {\n vector oil_squares;\n \n // Include all known oil squares\n for (const Point& p : known_oil_squares) {\n oil_squares.push_back(p);\n }\n \n // Include squares with high probability\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1 && probability[i][j] > 0.5) {\n oil_squares.push_back(Point(i, j));\n }\n }\n }\n \n // Remove duplicates (shouldn't happen but just in case)\n sort(oil_squares.begin(), oil_squares.end());\n oil_squares.erase(unique(oil_squares.begin(), oil_squares.end()), oil_squares.end());\n \n // Output guess\n cout << \"a \" << oil_squares.size();\n for (const Point& p : oil_squares) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n int result;\n cin >> result;\n \n return result == 1;\n }\n \n // Refine probabilities using shape constraints\n void refine_probabilities_with_shapes() {\n // For each square, calculate the probability based on possible oil field placements\n vector> new_prob(N, vector(N, 0.0));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] != -1) {\n new_prob[i][j] = (known_values[i][j] > 0) ? 1.0 : 0.0;\n continue;\n }\n \n double prob = 0.0;\n int count = 0;\n \n // Check how many oil fields could cover this square\n for (const OilField& field : oil_fields) {\n for (int oi = 0; oi <= N - 1 - field.max_i; oi++) {\n for (int oj = 0; oj <= N - 1 - field.max_j; oj++) {\n // Check if field can be placed at (oi, oj)\n if (!can_place_field(field, oi, oj)) continue;\n \n // Check if this square is covered by this placement\n bool covers = false;\n for (const Point& p : field.shape) {\n if (p.i + oi == i && p.j + oj == j) {\n covers = true;\n break;\n }\n }\n \n if (covers) {\n double placement_score = score_field_placement(field, oi, oj);\n if (placement_score > 0) {\n prob += min(1.0, placement_score / field.size);\n count++;\n }\n }\n }\n }\n }\n \n if (count > 0) {\n new_prob[i][j] = min(1.0, prob / count * 0.8 + probability[i][j] * 0.2);\n } else {\n new_prob[i][j] = probability[i][j];\n }\n }\n }\n \n // Update probabilities\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n probability[i][j] = new_prob[i][j];\n }\n }\n }\n }\n \npublic:\n Solver() : rng(random_device{}()) {}\n \n void solve() {\n read_input();\n \n // Phase 1: Coarse search with divination on large blocks\n phase1_coarse_search();\n \n // Phase 2: Refine with targeted search\n phase2_targeted_search();\n \n // Phase 3: Use shape information\n phase3_shape_guided_search();\n \n // Refine probabilities using shape constraints\n refine_probabilities_with_shapes();\n \n // Additional iterations if we have operations left\n while (operations_used < 2 * N * N) {\n // Check if we have high confidence in our answer\n int unknown_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n unknown_count++;\n }\n }\n }\n \n // If few unknowns, drill them directly\n if (unknown_count <= max(5, N/2)) {\n for (int i = 0; i < N && operations_used < 2 * N * N; i++) {\n for (int j = 0; j < N && operations_used < 2 * N * N; j++) {\n if (known_values[i][j] == -1) {\n drill(i, j);\n }\n }\n }\n } else {\n // Do another round of targeted search\n phase2_targeted_search();\n if (operations_used >= 2 * N * N) break;\n \n // Use shape information again\n phase3_shape_guided_search();\n if (operations_used >= 2 * N * N) break;\n \n // Refine probabilities\n refine_probabilities_with_shapes();\n }\n }\n \n // Make final guess\n bool success = make_guess();\n \n // If we failed, we could try again but we're out of operations\n // So just exit\n }\n};\n\nint main() {\n Solver solver;\n solver.solve();\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int i0, j0, i1, j1;\n \n Rectangle() : i0(0), j0(0), i1(0), j1(0) {}\n Rectangle(int i0, int j0, int i1, int j1) : i0(i0), j0(j0), i1(i1), j1(j1) {}\n \n int area() const {\n return (i1 - i0) * (j1 - j0);\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(i1 <= other.i0 || i0 >= other.i1 || j1 <= other.j0 || j0 >= other.j1);\n }\n \n // Check if rectangle is valid (within bounds and has positive area)\n bool isValid(int W) const {\n return i0 >= 0 && j0 >= 0 && i1 <= W && j1 <= W && i0 < i1 && j0 < j1;\n }\n};\n\nclass PartitionManager {\nprivate:\n int W;\n vector> horizontal_partitions; // [i][j] for horizontal partition at (i,j)-(i,j+1)\n vector> vertical_partitions; // [i][j] for vertical partition at (i,j)-(i+1,j)\n \npublic:\n PartitionManager(int W) : W(W) {\n horizontal_partitions.assign(W, vector(W, false));\n vertical_partitions.assign(W, vector(W, false));\n }\n \n void updateFromRectangles(const vector& rectangles) {\n // Reset all partitions\n for (int i = 0; i < W; i++) {\n fill(horizontal_partitions[i].begin(), horizontal_partitions[i].end(), false);\n fill(vertical_partitions[i].begin(), vertical_partitions[i].end(), false);\n }\n \n // Set partitions based on rectangles\n for (const auto& rect : rectangles) {\n // Top edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i0 > 0) vertical_partitions[rect.i0 - 1][j] = true;\n }\n // Bottom edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i1 < W) vertical_partitions[rect.i1 - 1][j] = true;\n }\n // Left edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j0 > 0) horizontal_partitions[i][rect.j0 - 1] = true;\n }\n // Right edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j1 < W) horizontal_partitions[i][rect.j1 - 1] = true;\n }\n }\n }\n \n int calculateChangeCost(const PartitionManager& prev) const {\n int cost = 0;\n \n // Horizontal partitions (i,j)-(i,j+1) where 1<=i<=W-1, 0<=j<=W-1\n for (int i = 1; i < W; i++) {\n for (int j = 0; j < W; j++) {\n if (horizontal_partitions[i-1][j] != prev.horizontal_partitions[i-1][j]) {\n cost++;\n }\n }\n }\n \n // Vertical partitions (i,j)-(i+1,j) where 0<=i<=W-1, 1<=j<=W-1\n for (int i = 0; i < W; i++) {\n for (int j = 1; j < W; j++) {\n if (vertical_partitions[i][j-1] != prev.vertical_partitions[i][j-1]) {\n cost++;\n }\n }\n }\n \n return cost;\n }\n};\n\nclass Solution {\nprivate:\n int W, D, N;\n vector> desired_areas;\n vector> solution;\n mt19937 rng;\n \npublic:\n Solution(int W, int D, int N, vector>&& areas) \n : W(W), D(D), N(N), desired_areas(move(areas)), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n solution.resize(D, vector(N));\n }\n \n // Calculate rental cost for a day\n long long calculateRentalCost(int day) const {\n long long cost = 0;\n for (int k = 0; k < N; k++) {\n int actual_area = solution[day][k].area();\n if (desired_areas[day][k] > actual_area) {\n cost += 100LL * (desired_areas[day][k] - actual_area);\n }\n }\n return cost;\n }\n \n // Calculate partition change cost for a day\n long long calculatePartitionCost(int day) const {\n if (day == 0) return 0;\n \n PartitionManager current(W), prev(W);\n current.updateFromRectangles(solution[day]);\n prev.updateFromRectangles(solution[day-1]);\n \n return current.calculateChangeCost(prev);\n }\n \n // Calculate total cost\n long long calculateTotalCost() const {\n long long total_cost = 0;\n for (int d = 0; d < D; d++) {\n total_cost += calculateRentalCost(d);\n total_cost += calculatePartitionCost(d);\n }\n return total_cost;\n }\n \n // Check if any rectangles on a day overlap\n bool hasOverlap(int day) const {\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (solution[day][i].overlaps(solution[day][j])) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Initialize day 0 with simple row-wise division\n void initializeDay0() {\n int total_height = W;\n vector heights(N);\n \n // Calculate heights proportional to desired areas\n long long total_desired = 0;\n for (int k = 0; k < N; k++) {\n total_desired += desired_areas[0][k];\n }\n \n int allocated_height = 0;\n for (int k = 0; k < N - 1; k++) {\n heights[k] = max(1, (int)((long long)desired_areas[0][k] * total_height / total_desired));\n allocated_height += heights[k];\n }\n heights[N-1] = total_height - allocated_height;\n if (heights[N-1] <= 0) {\n heights[N-1] = 1;\n // Adjust other heights if needed\n for (int k = 0; k < N-1 && allocated_height >= total_height; k++) {\n if (heights[k] > 1) {\n heights[k]--;\n allocated_height--;\n if (allocated_height < total_height) break;\n }\n }\n }\n \n // Create rectangles\n int current_i = 0;\n for (int k = 0; k < N; k++) {\n solution[0][k] = Rectangle(current_i, 0, current_i + heights[k], W);\n current_i += heights[k];\n }\n }\n \n // More robust overlap resolution\n void resolveOverlaps(int day) {\n const int MAX_ITERATIONS = 100;\n int iteration = 0;\n \n while (hasOverlap(day) && iteration < MAX_ITERATIONS) {\n iteration++;\n \n // Create a copy of current solution\n vector temp_solution = solution[day];\n \n // Find the first overlapping pair\n int overlap_i = -1, overlap_j = -1;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (temp_solution[i].overlaps(temp_solution[j])) {\n overlap_i = i;\n overlap_j = j;\n break;\n }\n }\n if (overlap_i != -1) break;\n }\n \n if (overlap_i == -1) break; // No more overlaps\n \n Rectangle& r1 = temp_solution[overlap_i];\n Rectangle& r2 = temp_solution[overlap_j];\n \n // Try different strategies to resolve overlap\n \n // Strategy 1: Move r2 to the right of r1\n if (r1.j1 < W) {\n int new_j0 = r1.j1;\n if (new_j0 < r2.j1) { // Ensure positive width\n int width = r2.j1 - r2.j0;\n if (new_j0 + width <= W) {\n r2.j0 = new_j0;\n r2.j1 = new_j0 + width;\n }\n }\n }\n \n // Check if overlap is resolved\n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 2: Move r2 below r1\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n if (r1.i1 < W) {\n int new_i0 = r1.i1;\n if (new_i0 < r2.i1) { // Ensure positive height\n int height = r2.i1 - r2.i0;\n if (new_i0 + height <= W) {\n r2.i0 = new_i0;\n r2.i1 = new_i0 + height;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 3: Shrink r2\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Calculate overlap region\n int overlap_i0 = max(r1.i0, r2.i0);\n int overlap_i1 = min(r1.i1, r2.i1);\n int overlap_j0 = max(r1.j0, r2.j0);\n int overlap_j1 = min(r1.j1, r2.j1);\n \n // Try to shrink r2 from the side that has the least impact\n if (overlap_j1 - overlap_j0 > 0 && overlap_i1 - overlap_i0 > 0) {\n // Prefer to shrink in the direction with smaller dimension\n if (r2.j1 - r2.j0 < r2.i1 - r2.i0) {\n // Shrink horizontally\n if (r2.j0 == overlap_j0) {\n r2.j0 = overlap_j1;\n } else {\n r2.j1 = overlap_j0;\n }\n } else {\n // Shrink vertically\n if (r2.i0 == overlap_i0) {\n r2.i0 = overlap_i1;\n } else {\n r2.i1 = overlap_i0;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 4: Try to move r1 instead\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Move r1 to left of r2\n if (r2.j0 > 0) {\n int width = r1.j1 - r1.j0;\n if (r2.j0 - width >= 0) {\n r1.j0 = r2.j0 - width;\n r1.j1 = r2.j0;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // If no strategy works, try to resize one of the rectangles\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Shrink r2 to eliminate overlap\n if (r2.j1 > r1.j0 && r2.j0 < r1.j1) {\n // Horizontal overlap\n if (r2.j0 < r1.j0) {\n r2.j1 = r1.j0;\n } else {\n r2.j0 = r1.j1;\n }\n }\n \n if (r2.i1 > r1.i0 && r2.i0 < r1.i1) {\n // Vertical overlap\n if (r2.i0 < r1.i0) {\n r2.i1 = r1.i0;\n } else {\n r2.i0 = r1.i1;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Last resort: just separate them arbitrarily\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Force separation\n r2.j0 = r1.j1;\n r2.j1 = r2.j0 + max(1, r2.j1 - r2.j0);\n if (r2.j1 > W) {\n r2.j1 = W;\n r2.j0 = max(0, r2.j1 - max(1, r2.j1 - r2.j0));\n }\n \n if (r1.overlaps(r2)) {\n r2.i0 = r1.i1;\n r2.i1 = r2.i0 + max(1, r2.i1 - r2.i0);\n if (r2.i1 > W) {\n r2.i1 = W;\n r2.i0 = max(0, r2.i1 - max(1, r2.i1 - r2.i0));\n }\n }\n \n if (r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n }\n }\n \n // Final validation\n if (hasOverlap(day)) {\n // If still overlapping, use a more drastic approach\n // Arrange rectangles in a grid\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // For subsequent days, start with previous day's solution and adjust\n void optimizeDay(int day) {\n // Start with previous day's configuration\n solution[day] = solution[day-1];\n \n // Calculate current areas\n vector current_areas(N);\n for (int k = 0; k < N; k++) {\n current_areas[k] = solution[day][k].area();\n }\n \n // Identify rectangles that need adjustment\n vector needs_more_area;\n for (int k = 0; k < N; k++) {\n if (current_areas[k] < desired_areas[day][k]) {\n needs_more_area.push_back(k);\n }\n }\n \n // Simple adjustment: try to expand rectangles that need more area\n for (int k : needs_more_area) {\n int deficit = desired_areas[day][k] - current_areas[k];\n if (deficit <= 0) continue;\n \n Rectangle original_rect = solution[day][k];\n Rectangle& rect = solution[day][k];\n \n // Try different expansion strategies\n \n // Strategy 1: Expand right\n if (rect.j1 < W) {\n int can_expand = W - rect.j1;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j1 += expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 2: Expand down\n if (deficit > 0 && rect.i1 < W) {\n int can_expand = W - rect.i1;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i1 += expand_by;\n deficit -= expand_by * width;\n }\n \n // Strategy 3: Expand left\n if (deficit > 0 && rect.j0 > 0) {\n int can_expand = rect.j0;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j0 -= expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 4: Expand up\n if (deficit > 0 && rect.i0 > 0) {\n int can_expand = rect.i0;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i0 -= expand_by;\n deficit -= expand_by * width;\n }\n \n // Ensure rectangle is valid\n if (!rect.isValid(W)) {\n solution[day][k] = original_rect;\n }\n }\n \n // Check for overlaps and resolve them\n resolveOverlaps(day);\n \n // Verify no overlaps remain\n if (hasOverlap(day)) {\n // Fallback: use grid arrangement\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // Local search optimization for a day (with proper overlap checking)\n void localSearchDay(int day, int iterations = 50) {\n // Keep track of the best solution\n auto best_solution = solution[day];\n long long best_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n for (int iter = 0; iter < iterations; iter++) {\n // Make a small random change\n auto current_solution = solution[day];\n \n // Select a random rectangle to modify\n int k = uniform_int_distribution(0, N-1)(rng);\n Rectangle original_rect = current_solution[k];\n Rectangle& rect = current_solution[k];\n \n // Randomly adjust one of the boundaries\n int change_type = uniform_int_distribution(0, 3)(rng);\n int change_amount = uniform_int_distribution(-3, 3)(rng);\n \n // Skip if change_amount is 0\n if (change_amount == 0) continue;\n \n switch (change_type) {\n case 0: // Adjust top\n rect.i0 += change_amount;\n break;\n case 1: // Adjust left\n rect.j0 += change_amount;\n break;\n case 2: // Adjust bottom\n rect.i1 += change_amount;\n break;\n case 3: // Adjust right\n rect.j1 += change_amount;\n break;\n }\n \n // Validate the rectangle\n if (!rect.isValid(W)) {\n current_solution[k] = original_rect;\n }\n \n // Check for overlaps\n bool has_overlap = false;\n for (int i = 0; i < N && !has_overlap; i++) {\n for (int j = i + 1; j < N && !has_overlap; j++) {\n if (current_solution[i].overlaps(current_solution[j])) {\n has_overlap = true;\n }\n }\n }\n \n if (!has_overlap) {\n // Calculate new cost\n auto temp_solution = solution[day];\n solution[day] = current_solution;\n long long new_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n // Accept if better\n if (new_cost < best_cost) {\n best_solution = current_solution;\n best_cost = new_cost;\n }\n \n // Revert for next iteration\n solution[day] = temp_solution;\n }\n }\n \n // Set the best solution found\n solution[day] = best_solution;\n \n // Final overlap check\n if (hasOverlap(day)) {\n resolveOverlaps(day);\n }\n }\n \n void solve() {\n // Initialize day 0\n initializeDay0();\n \n // Ensure no overlaps on day 0\n resolveOverlaps(0);\n \n // Optimize subsequent days\n for (int d = 1; d < D; d++) {\n optimizeDay(d);\n // Apply local search for further improvement\n localSearchDay(d, 30);\n \n // Final validation\n if (hasOverlap(d)) {\n resolveOverlaps(d);\n }\n }\n }\n \n void output() const {\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cout << solution[d][k].i0 << \" \" \n << solution[d][k].j0 << \" \" \n << solution[d][k].i1 << \" \" \n << solution[d][k].j1 << endl;\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int W, D, N;\n cin >> W >> D >> N;\n \n vector> areas(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> areas[d][k];\n }\n }\n \n Solution solver(W, D, N, move(areas));\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n \n // Read initial board\n vector> board(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> board[i][j];\n }\n }\n \n // Read stamps\n vector>> stamps(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n cin >> stamps[m][i][j];\n }\n }\n }\n \n // Store operations\n vector> operations;\n \n // Greedy selection of operations\n for (int op = 0; op < K; op++) {\n long long best_improvement = -1e18; // Start with a very small value\n int best_stamp = -1, best_p = -1, best_q = -1;\n \n // Try each stamp at each possible position\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n // Calculate improvement from this operation\n long long improvement = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n long long current_remainder = board[p + i][q + j] % MOD;\n long long new_remainder = (board[p + i][q + j] + stamps[m][i][j]) % MOD;\n improvement += (new_remainder - current_remainder);\n }\n }\n \n // Update best operation\n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n \n // Apply the best operation (even if improvement is negative, as we must use operations)\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n board[best_p + i][best_q + j] += stamps[best_stamp][i][j];\n }\n }\n \n // Record the operation\n operations.push_back(make_tuple(best_stamp, best_p, best_q));\n }\n \n // Output\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << get<0>(op) << \" \" << get<1>(op) << \" \" << get<2>(op) << endl;\n }\n \n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int row, col;\n int holding; // -1 if not holding, container number otherwise\n bool is_large;\n bool bombed;\n};\n\nstruct ContainerInfo {\n int target_row; // which row's dispatch gate it should go to\n int target_order; // order within that row (0 to N-1)\n bool arrived;\n bool dispatched;\n int arrival_row; // which receiving gate it will arrive from\n int arrival_order; // order in which it arrives at that gate\n};\n\n// Direction vectors for U, D, L, R\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nclass Solver {\nprivate:\n int N;\n vector> A;\n vector cranes;\n vector> grid; // -1 if empty, container number otherwise\n int turn_count;\n \n // Track which containers have been brought in from each receiving gate\n vector next_container_index;\n \n // BFS to find shortest path avoiding obstacles\n vector> find_path(int start_row, int start_col, int end_row, int end_col, \n bool carrying_container, bool is_large_crane, \n const vector>& occupied) {\n if (start_row == end_row && start_col == end_col) {\n return {{start_row, start_col}};\n }\n \n vector> dist(N, vector(N, -1));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n \n dist[start_row][start_col] = 0;\n q.push({start_row, start_col});\n \n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n \n // Check bounds\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) continue;\n \n // Check if already visited\n if (dist[nr][nc] != -1) continue;\n \n // Check if occupied by a crane (in the current state, before movement)\n if (occupied[nr][nc]) continue;\n \n // If carrying container and not large crane, cannot move to occupied square\n if (carrying_container && !is_large_crane && grid[nr][nc] != -1) continue;\n \n dist[nr][nc] = dist[r][c] + 1;\n parent[nr][nc] = {r, c};\n q.push({nr, nc});\n \n if (nr == end_row && nc == end_col) {\n // Reconstruct path\n vector> path;\n int cur_r = nr, cur_c = nc;\n while (cur_r != -1) {\n path.push_back({cur_r, cur_c});\n auto p = parent[cur_r][cur_c];\n cur_r = p.first;\n cur_c = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n }\n }\n }\n \n return {}; // No path found\n }\n \n // Get next action for each crane\n vector get_next_actions(const vector>& crane_positions) {\n vector actions(N, '.');\n \n // First, check if any crane can pick up a newly arrived container\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding != -1) continue;\n \n // Check if there's a container at current position\n if (grid[cranes[i].row][cranes[i].col] != -1) {\n actions[i] = 'P';\n continue;\n }\n }\n \n // Then, check if any crane can deliver a container to dispatch gate\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding == -1) continue;\n \n int container = cranes[i].holding;\n int target_row = containers[container].target_row;\n \n // If at dispatch gate and it's the correct one\n if (cranes[i].row == target_row && cranes[i].col == N-1) {\n actions[i] = 'Q';\n continue;\n }\n }\n \n // Move cranes toward their goals\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n if (actions[i] != '.') continue; // Already assigned\n \n if (cranes[i].holding != -1) {\n // Carrying a container - move toward its dispatch gate\n int container = cranes[i].holding;\n int target_row = containers[container].target_row;\n \n auto path = find_path(cranes[i].row, cranes[i].col, target_row, N-1, \n true, cranes[i].is_large, crane_positions);\n if (!path.empty() && path.size() > 1) {\n int next_r = path[1][0];\n int next_c = path[1][1];\n \n // Determine direction\n if (next_r < cranes[i].row) actions[i] = 'U';\n else if (next_r > cranes[i].row) actions[i] = 'D';\n else if (next_c < cranes[i].col) actions[i] = 'L';\n else if (next_c > cranes[i].col) actions[i] = 'R';\n }\n } else {\n // Not carrying - look for containers to pick up\n // Prefer containers that are ready to be picked up\n for (int r = 0; r < N; r++) {\n if (grid[r][0] != -1) { // Container at receiving gate\n auto path = find_path(cranes[i].row, cranes[i].col, r, 0, \n false, cranes[i].is_large, crane_positions);\n if (!path.empty() && path.size() > 1) {\n int next_r = path[1][0];\n int next_c = path[1][1];\n \n // Determine direction\n if (next_r < cranes[i].row) actions[i] = 'U';\n else if (next_r > cranes[i].row) actions[i] = 'D';\n else if (next_c < cranes[i].col) actions[i] = 'L';\n else if (next_c > cranes[i].col) actions[i] = 'R';\n break;\n }\n }\n }\n }\n }\n \n return actions;\n }\n \n // Simulate one turn\n bool simulate_turn(vector& actions) {\n // Step 1: Bring in new containers at receiving gates\n for (int i = 0; i < N; i++) {\n // Check if we can bring in next container\n if (next_container_index[i] < N && \n grid[i][0] == -1) {\n // Check if there's no crane at the receiving gate\n bool crane_at_gate = false;\n for (int j = 0; j < N; j++) {\n if (!cranes[j].bombed && cranes[j].row == i && cranes[j].col == 0) {\n crane_at_gate = true;\n break;\n }\n }\n \n if (!crane_at_gate) {\n int container = A[i][next_container_index[i]];\n grid[i][0] = container;\n containers[container].arrived = true;\n next_container_index[i]++;\n }\n }\n }\n \n // Create a grid of current crane positions for collision detection\n vector> current_crane_positions(N, vector(N, false));\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n current_crane_positions[cranes[i].row][cranes[i].col] = true;\n }\n }\n \n // Validate actions and check for collisions\n vector> next_positions(N);\n vector will_bomb(N, false);\n \n // First, calculate intended next positions\n for (int i = 0; i < N; i++) {\n next_positions[i] = {cranes[i].row, cranes[i].col}; // Default to current position\n }\n \n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) {\n actions[i] = '.';\n continue;\n }\n \n char action = actions[i];\n int r = cranes[i].row;\n int c = cranes[i].col;\n \n if (action == 'P') {\n if (cranes[i].holding != -1 || grid[r][c] == -1) {\n return false; // Invalid action\n }\n } else if (action == 'Q') {\n if (cranes[i].holding == -1 || grid[r][c] != -1) {\n return false; // Invalid action\n }\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n int nr = r + dr[d];\n int nc = c + dc[d];\n \n if (nr < 0 || nr >= N || nc < 0 || nc >= N) {\n return false; // Out of bounds\n }\n \n if (cranes[i].holding != -1 && !cranes[i].is_large && grid[nr][nc] != -1) {\n return false; // Small crane can't move to occupied square while carrying\n }\n \n next_positions[i] = {nr, nc};\n } else if (action == 'B') {\n if (cranes[i].holding != -1) {\n return false; // Can't bomb while holding container\n }\n will_bomb[i] = true;\n }\n // '.' is always valid\n }\n \n // Check for crane collisions - this is the critical part\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || actions[i] == 'P' || actions[i] == 'Q' || actions[i] == 'B' || actions[i] == '.') {\n continue;\n }\n \n int next_r = next_positions[i].first;\n int next_c = next_positions[i].second;\n \n // Check if destination is already targeted by another crane\n for (int j = 0; j < N; j++) {\n if (i == j || cranes[j].bombed) continue;\n \n // If crane j is moving\n if (actions[j] == 'U' || actions[j] == 'D' || actions[j] == 'L' || actions[j] == 'R') {\n if (next_positions[i] == next_positions[j]) {\n return false; // Two cranes moving to same square\n }\n // Check for swapping\n if (next_positions[i].first == cranes[j].row && next_positions[i].second == cranes[j].col &&\n next_positions[j].first == cranes[i].row && next_positions[j].second == cranes[i].col) {\n return false; // Swapping not allowed\n }\n } \n // If crane j is stationary (not moving, not bombing, not picking up or releasing)\n else if (actions[j] == '.') {\n if (next_r == cranes[j].row && next_c == cranes[j].col) {\n return false; // Moving to square occupied by stationary crane\n }\n }\n }\n }\n \n // Check for cranes moving to positions where other cranes will be stationary after action\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || actions[i] == 'P' || actions[i] == 'Q' || actions[i] == 'B' || actions[i] == '.') {\n continue;\n }\n \n int next_r = next_positions[i].first;\n int next_c = next_positions[i].second;\n \n // Check if any crane is doing P, Q, or . and will be at the destination\n for (int j = 0; j < N; j++) {\n if (i == j || cranes[j].bombed) continue;\n \n if (actions[j] == 'P' || actions[j] == 'Q' || actions[j] == '.') {\n if (next_r == cranes[j].row && next_c == cranes[j].col) {\n return false; // Moving to square occupied by stationary crane\n }\n }\n }\n }\n \n // Check for two cranes swapping via intermediate square (a more complex case)\n // This is handled by the above checks\n \n // Apply actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n int& r = cranes[i].row;\n int& c = cranes[i].col;\n \n if (action == 'P') {\n cranes[i].holding = grid[r][c];\n grid[r][c] = -1;\n } else if (action == 'Q') {\n grid[r][c] = cranes[i].holding;\n cranes[i].holding = -1;\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n r += dr[d];\n c += dc[d];\n } else if (action == 'B') {\n cranes[i].bombed = true;\n }\n // '.' means stay in place\n }\n \n // Step 3: Dispatch containers at dispatch gates\n for (int i = 0; i < N; i++) {\n if (grid[i][N-1] != -1) {\n int container = grid[i][N-1];\n containers[container].dispatched = true;\n grid[i][N-1] = -1;\n }\n }\n \n turn_count++;\n return true;\n }\n \n // Check if all containers are dispatched correctly\n bool is_complete() {\n for (int i = 0; i < N*N; i++) {\n if (!containers[i].dispatched) {\n return false;\n }\n }\n return true;\n }\n \npublic:\n vector containers;\n \n Solver(int n, vector>& a) : N(n), A(a) {\n // Initialize cranes\n cranes.resize(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].holding = -1;\n cranes[i].is_large = (i == 0); // Crane 0 is large\n cranes[i].bombed = false;\n }\n \n // Initialize grid\n grid.assign(N, vector(N, -1));\n \n // Initialize container info\n containers.resize(N*N);\n for (int i = 0; i < N*N; i++) {\n containers[i].target_row = i / N;\n containers[i].target_order = i % N;\n containers[i].arrived = false;\n containers[i].dispatched = false;\n }\n \n // Set arrival info\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container = A[i][j];\n containers[container].arrival_row = i;\n containers[container].arrival_order = j;\n }\n }\n \n next_container_index.assign(N, 0);\n turn_count = 0;\n }\n \n vector solve() {\n vector results(N, \"\");\n \n // Simulate up to 10000 turns\n for (int turn = 0; turn < 10000; turn++) {\n // Create current crane positions grid\n vector> current_crane_positions(N, vector(N, false));\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n current_crane_positions[cranes[i].row][cranes[i].col] = true;\n }\n }\n \n // Get actions for this turn\n vector actions = get_next_actions(current_crane_positions);\n \n // Record actions\n for (int i = 0; i < N; i++) {\n results[i] += actions[i];\n }\n \n // Simulate the turn\n if (!simulate_turn(actions)) {\n // Invalid action, but we'll continue with what we have\n // In a real contest, we might want to try a fallback strategy\n break;\n }\n \n // Check if we're done\n if (is_complete()) {\n break;\n }\n }\n \n return results;\n }\n};\n\nint main() {\n int N;\n cin >> N;\n \n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n Solver solver(N, A);\n vector results = solver.solve();\n \n for (int i = 0; i < N; i++) {\n cout << results[i] << endl;\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n\n int r = 0, c = 0;\n int truck = 0;\n vector ops;\n\n while (true) {\n bool all_zero = true;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) {\n all_zero = false;\n break;\n }\n }\n if (!all_zero) break;\n }\n if (all_zero) break;\n\n int target_r = -1, target_c = -1;\n int min_dist = INT_MAX;\n\n if (truck == 0) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break; // safety\n } else {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] < 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break; // safety\n }\n\n // Move to target\n while (r < target_r) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > target_r) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < target_c) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > target_c) {\n ops.push_back(\"L\");\n c--;\n }\n\n // Perform load/unload\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n } else if (h[r][c] < 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n }\n }\n\n for (const string& op : ops) {\n cout << op << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, T;\nint seed_count;\n\n// Compare seeds by total value\nstruct Seed {\n vector values;\n int id;\n int total_value;\n \n Seed() : id(-1), total_value(0) {}\n \n void calculate_total() {\n total_value = 0;\n for (int v : values) {\n total_value += v;\n }\n }\n};\n\nbool compare_seeds(const Seed& a, const Seed& b) {\n return a.total_value > b.total_value;\n}\n\n// Calculate how complementary two seeds are\nint calculate_complementarity(const Seed& a, const Seed& b) {\n int score = 0;\n for (int i = 0; i < M; i++) {\n score += max(a.values[i], b.values[i]);\n }\n return score;\n}\n\n// Calculate expected value of offspring from two seeds\nint calculate_expected_offspring_value(const Seed& a, const Seed& b) {\n int expected_value = 0;\n for (int i = 0; i < M; i++) {\n expected_value += (a.values[i] + b.values[i]) / 2;\n }\n return expected_value;\n}\n\n// Grid position with number of adjacent positions\nstruct Position {\n int row, col;\n int adjacency_count;\n \n Position(int r, int c) : row(r), col(c) {\n adjacency_count = 0;\n if (r > 0) adjacency_count++;\n if (r < N-1) adjacency_count++;\n if (c > 0) adjacency_count++;\n if (c < N-1) adjacency_count++;\n }\n};\n\nbool compare_positions(const Position& a, const Position& b) {\n return a.adjacency_count > b.adjacency_count;\n}\n\nint main() {\n cin >> N >> M >> T;\n seed_count = 2 * N * (N - 1);\n \n vector seeds(seed_count);\n \n // Read initial seeds\n for (int i = 0; i < seed_count; i++) {\n seeds[i].values.resize(M);\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n \n // Process T turns\n for (int t = 0; t < T; t++) {\n // Sort seeds by total value (descending)\n sort(seeds.begin(), seeds.end(), compare_seeds);\n \n // Create grid for planting\n vector> grid(N, vector(N, -1));\n vector used(seed_count, false);\n \n // Generate positions sorted by adjacency count (center positions first)\n vector positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.emplace_back(i, j);\n }\n }\n sort(positions.begin(), positions.end(), compare_positions);\n \n // Plant the top 36 seeds, placing highest value seeds in positions with most neighbors\n for (int i = 0; i < N * N; i++) {\n int row = positions[i].row;\n int col = positions[i].col;\n grid[row][col] = seeds[i].id;\n used[seeds[i].id] = true;\n }\n \n // Output the grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j];\n if (j < N - 1) {\n cout << \" \";\n }\n }\n cout << endl;\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n }\n \n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n bool in_bounds(int N) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nstruct State {\n Point root_pos;\n vector directions; // Direction of each edge (0=R, 1=D, 2=L, 3=U)\n vector holding; // What each fingertip is holding\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector initial_grid, target_grid;\n vector start_positions, target_positions;\n vector tree;\n int V_prime;\n vector fingertips;\n State current_state;\n mt19937 rng;\n \n // Direction vectors: Right, Down, Left, Up\n const vector DX = {1, 0, -1, 0};\n const vector DY = {0, 1, 0, -1};\n const string DIR_CHARS = \"RDLU\";\n \npublic:\n RoboticArmSolver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n void read_input() {\n cin >> N >> M >> V;\n initial_grid.resize(N);\n target_grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> initial_grid[i];\n }\n for (int i = 0; i < N; i++) {\n cin >> target_grid[i];\n }\n \n // Extract start and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '0') {\n start_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '0' && target_grid[i][j] == '1') {\n target_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n // Already in correct position, no need to move\n // But we still count it for M'\n M--;\n }\n }\n }\n \n // Shuffle for randomization\n shuffle(start_positions.begin(), start_positions.end(), rng);\n shuffle(target_positions.begin(), target_positions.end(), rng);\n }\n \n void design_arm() {\n // Determine number of vertices to use\n V_prime = min(V, 10); // Use up to 10 vertices for simplicity\n \n // Build a simple tree: root (0) connected to several children\n // Try to create a balanced tree with multiple fingertips\n tree.resize(V_prime);\n for (int i = 0; i < V_prime; i++) {\n tree[i].is_leaf = true; // Initially all are leaves\n }\n \n // Create tree structure\n // Root at 0\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Add children to root and possibly to other nodes\n int next_vertex = 1;\n vector current_level = {0};\n \n while (next_vertex < V_prime) {\n vector next_level;\n for (int parent : current_level) {\n if (next_vertex >= V_prime) break;\n \n // Add 1-2 children to each node\n int children_count = min(2, V_prime - next_vertex);\n for (int i = 0; i < children_count && next_vertex < V_prime; i++) {\n tree[next_vertex].parent = parent;\n tree[next_vertex].length = 1; // Use length 1 for simplicity\n tree[parent].children.push_back(next_vertex);\n tree[parent].is_leaf = false;\n next_level.push_back(next_vertex);\n next_vertex++;\n }\n }\n current_level = next_level;\n }\n \n // Identify fingertips (leaves)\n for (int i = 0; i < V_prime; i++) {\n if (tree[i].is_leaf) {\n fingertips.push_back(i);\n }\n }\n }\n \n Point find_initial_position() {\n // Find a central position that minimizes distance to start positions\n int best_x = N/2, best_y = N/2;\n double min_dist = 1e9;\n \n // Try positions around center\n for (int x = max(0, N/2 - 2); x <= min(N-1, N/2 + 2); x++) {\n for (int y = max(0, N/2 - 2); y <= min(N-1, N/2 + 2); y++) {\n double dist = 0;\n for (const Point& p : start_positions) {\n dist += abs(p.x - x) + abs(p.y - y);\n }\n if (dist < min_dist) {\n min_dist = dist;\n best_x = x;\n best_y = y;\n }\n }\n }\n \n return Point(best_x, best_y);\n }\n \n // Calculate positions of all vertices given root position and directions\n vector calculate_positions(const Point& root_pos, const vector& directions) {\n vector positions(V_prime);\n positions[0] = root_pos;\n \n for (int i = 1; i < V_prime; i++) {\n int parent = tree[i].parent;\n int dir = directions[i];\n int len = tree[i].length;\n \n positions[i] = Point(\n positions[parent].x + DY[dir] * len, // Note: Y is row, X is column\n positions[parent].y + DX[dir] * len\n );\n }\n \n return positions;\n }\n \n // Find distance between two points\n int manhattan_distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the best move for the arm\n string find_best_move() {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n string command(2 * V_prime, '.');\n \n // First, try to pick up or place takoyaki\n bool did_action = false;\n for (int i = 0; i < fingertips.size() && !did_action; i++) {\n int finger = fingertips[i];\n Point pos = positions[finger];\n \n if (!pos.in_bounds(N)) continue;\n \n // Check if we can pick up a takoyaki\n if (!current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '1' && \n target_grid[pos.x][pos.y] == '0') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = true;\n initial_grid[pos.x][pos.y] = '0'; // Remove from initial grid\n did_action = true;\n continue;\n }\n \n // Check if we can place a takoyaki\n if (current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '0' && \n target_grid[pos.x][pos.y] == '1') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = false;\n initial_grid[pos.x][pos.y] = '1'; // Add to grid (mark as delivered)\n did_action = true;\n continue;\n }\n }\n \n if (did_action) {\n return command;\n }\n \n // No pickup/place action, move toward a target\n // Find closest undelivered takoyaki or target position\n Point target_pos;\n bool move_to_start = false;\n \n if (!start_positions.empty()) {\n // Find closest start position that has a takoyaki\n int min_dist = 1e9;\n for (int i = 0; i < start_positions.size(); i++) {\n if (initial_grid[start_positions[i].x][start_positions[i].y] == '1') {\n int dist = manhattan_distance(current_state.root_pos, start_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n target_pos = start_positions[i];\n move_to_start = true;\n }\n }\n }\n }\n \n // If no start positions available or none have takoyaki, move to target positions\n if (!move_to_start || min_dist == 1e9) {\n for (int i = 0; i < target_positions.size(); i++) {\n if (initial_grid[target_positions[i].x][target_positions[i].y] == '0') {\n int dist = manhattan_distance(current_state.root_pos, target_positions[i]);\n if (dist < min_dist || min_dist == 1e9) {\n min_dist = dist;\n target_pos = target_positions[i];\n move_to_start = false;\n }\n }\n }\n }\n \n // Move toward target\n if (min_dist != 1e9) {\n int dx = target_pos.x - current_state.root_pos.x;\n int dy = target_pos.y - current_state.root_pos.y;\n \n if (dx != 0 || dy != 0) {\n // Determine best direction to move\n char best_dir = '.';\n int best_improvement = -1;\n \n for (int d = 0; d < 4; d++) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (!new_pos.in_bounds(N)) continue;\n \n int new_dist = abs(new_pos.x - target_pos.x) + abs(new_pos.y - target_pos.y);\n int improvement = min_dist - new_dist;\n \n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_dir = DIR_CHARS[d];\n command[0] = best_dir;\n }\n }\n \n // Update root position if we found a valid move\n if (best_dir != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == best_dir) {\n current_state.root_pos.x += DX[d];\n current_state.root_pos.y += DY[d];\n break;\n }\n }\n }\n }\n } else {\n // Random move if no clear target\n vector valid_moves = {'.', 'R', 'D', 'L', 'U'};\n int r = rng() % valid_moves.size();\n command[0] = valid_moves[r];\n \n if (command[0] != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == command[0]) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (new_pos.in_bounds(N)) {\n current_state.root_pos = new_pos;\n }\n break;\n }\n }\n }\n }\n \n // Random rotations to explore different configurations\n if (rng() % 3 == 0) { // 33% chance of rotation\n for (int i = 1; i < V_prime; i++) {\n if (rng() % 3 == 0) { // 33% chance per joint\n if (rng() % 2) {\n command[i] = 'R';\n current_state.directions[i] = (current_state.directions[i] + 1) % 4;\n } else {\n command[i] = 'L';\n current_state.directions[i] = (current_state.directions[i] + 3) % 4;\n }\n }\n }\n }\n \n return command;\n }\n \n void solve() {\n read_input();\n design_arm();\n \n // Output arm design\n cout << V_prime << endl;\n for (int i = 1; i < V_prime; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n \n // Find and output initial position\n Point initial_pos = find_initial_position();\n cout << initial_pos.x << \" \" << initial_pos.y << endl;\n \n // Initialize state\n current_state.root_pos = initial_pos;\n current_state.directions.resize(V_prime, 0); // All start pointing right\n current_state.holding.resize(V_prime, false);\n \n // Generate operations\n vector commands;\n int max_turns = min(50000, 100000); // Limit to avoid TLE\n \n for (int turn = 0; turn < max_turns; turn++) {\n string command = find_best_move();\n commands.push_back(command);\n \n // Check if all takoyaki are delivered\n int delivered = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n delivered++;\n }\n }\n }\n \n // Also count held takoyaki that can be placed\n for (int finger : fingertips) {\n if (current_state.holding[finger]) {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n Point pos = positions[finger];\n if (pos.in_bounds(N) && target_grid[pos.x][pos.y] == '1' && initial_grid[pos.x][pos.y] == '0') {\n delivered++; // Can be delivered in next turn\n }\n }\n }\n \n // If we've delivered all or have extra, break early\n if (delivered >= M) {\n break;\n }\n }\n \n // Output commands\n for (const string& cmd : commands) {\n cout << cmd << endl;\n }\n }\n};\n\nint main() {\n RoboticArmSolver solver;\n solver.solve();\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n int x1, y1, x2, y2; // x1 <= x2, y1 <= y2\n Rectangle(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : x1(x1), y1(y1), x2(x2), y2(y2) {}\n \n bool contains(const Point& p) const {\n return p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2;\n }\n \n int perimeter() const {\n return 2 * ((x2 - x1) + (y2 - y1));\n }\n \n int area() const {\n return (x2 - x1) * (y2 - y1);\n }\n};\n\n// Optimized point counting using precomputed 2D grid\nclass PointCounter {\nprivate:\n static const int GRID_SIZE = 200; // Divide 10^5 into 200x200 grid\n static const int CELL_SIZE = 500; // 100000 / 200 = 500\n vector> mackerelGrid;\n vector> sardineGrid;\n const vector& mackerels;\n const vector& sardines;\n \npublic:\n PointCounter(const vector& m, const vector& s) \n : mackerels(m), sardines(s) {\n mackerelGrid.assign(GRID_SIZE + 1, vector(GRID_SIZE + 1, 0));\n sardineGrid.assign(GRID_SIZE + 1, vector(GRID_SIZE + 1, 0));\n \n // Build the grid\n for (const auto& p : mackerels) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n mackerelGrid[gx][gy]++;\n }\n \n for (const auto& p : sardines) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n sardineGrid[gx][gy]++;\n }\n }\n \n // Fast approximate counting using grid\n pair fastCount(const Rectangle& rect) {\n int mackerelCount = 0, sardineCount = 0;\n \n int gx1 = max(0, rect.x1 / CELL_SIZE);\n int gy1 = max(0, rect.y1 / CELL_SIZE);\n int gx2 = min(GRID_SIZE - 1, rect.x2 / CELL_SIZE);\n int gy2 = min(GRID_SIZE - 1, rect.y2 / CELL_SIZE);\n \n // Quick grid-based counting for large rectangles\n for (int gx = gx1; gx <= gx2; gx++) {\n for (int gy = gy1; gy <= gy2; gy++) {\n mackerelCount += mackerelGrid[gx][gy];\n sardineCount += sardineGrid[gx][gy];\n }\n }\n \n // For small rectangles or when more precision is needed, use exact counting\n // But only if the rectangle is small enough\n if ((rect.x2 - rect.x1) * (rect.y2 - rect.y1) < 25000000) { // 5000x5000\n mackerelCount = 0;\n sardineCount = 0;\n for (const auto& p : mackerels) {\n if (rect.contains(p)) mackerelCount++;\n }\n for (const auto& p : sardines) {\n if (rect.contains(p)) sardineCount++;\n }\n }\n \n return {mackerelCount, sardineCount};\n }\n};\n\n// Calculate score for rectangle\nint calculateScore(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n PointCounter counter(mackerels, sardines);\n auto [m, s] = counter.fastCount(rect);\n return max(0, m - s + 1);\n}\n\n// Generate limited number of candidate rectangles\nvector generateCandidateRectangles(const vector& mackerels, const vector& sardines) {\n vector candidates;\n const int MAX_CANDIDATES = 200; // Limit to avoid TLE\n \n // Sample a subset of mackerels to avoid O(N^2) complexity\n vector sampleIndices;\n int sampleSize = min(500, (int)mackerels.size());\n \n // Use a simple sampling strategy\n for (int i = 0; i < sampleSize; i++) {\n sampleIndices.push_back(i * mackerels.size() / sampleSize);\n }\n \n // Generate rectangles around individual mackerels with different sizes\n for (int idx : sampleIndices) {\n int x = mackerels[idx].x;\n int y = mackerels[idx].y;\n \n // Try different sizes (fewer sizes to reduce candidates)\n vector sizes = {1000, 3000, 7000, 15000};\n for (int size : sizes) {\n int x1 = max(0, x - size/2);\n int y1 = max(0, y - size/2);\n int x2 = min(100000, x + size/2);\n int y2 = min(100000, y + size/2);\n \n Rectangle rect(x1, y1, x2, y2);\n PointCounter counter(mackerels, sardines);\n auto [m, s] = counter.fastCount(rect);\n if (m > s && m > 0) { // Only consider if beneficial\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n \n if (candidates.size() < MAX_CANDIDATES) {\n // Try rectangles that cover pairs of mackerels (limited number)\n for (int i = 0; i < min(50, (int)sampleIndices.size()); i++) {\n for (int j = i + 1; j < min(i + 10, (int)sampleIndices.size()); j++) {\n int x1 = min(mackerels[sampleIndices[i]].x, mackerels[sampleIndices[j]].x);\n int y1 = min(mackerels[sampleIndices[i]].y, mackerels[sampleIndices[j]].y);\n int x2 = max(mackerels[sampleIndices[i]].x, mackerels[sampleIndices[j]].x);\n int y2 = max(mackerels[sampleIndices[i]].y, mackerels[sampleIndices[j]].y);\n \n // Expand a bit\n int dx = max(1, (x2 - x1) / 4);\n int dy = max(1, (y2 - y1) / 4);\n x1 = max(0, x1 - dx);\n y1 = max(0, y1 - dy);\n x2 = min(100000, x2 + dx);\n y2 = min(100000, y2 + dy);\n \n if (x2 > x1 && y2 > y1) {\n Rectangle rect(x1, y1, x2, y2);\n PointCounter counter(mackerels, sardines);\n auto [m, s] = counter.fastCount(rect);\n if (m > s && m > 0) {\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n }\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n \n // Sort by score and keep top candidates\n sort(candidates.begin(), candidates.end(), [&](const Rectangle& a, const Rectangle& b) {\n int scoreA = calculateScore(mackerels, sardines, a);\n int scoreB = calculateScore(mackerels, sardines, b);\n return scoreA > scoreB;\n });\n \n if (candidates.size() > 50) {\n candidates.resize(50);\n }\n \n return candidates;\n}\n\n// Merge rectangles into a simple bounding polygon\nvector mergeRectanglesToPolygon(const vector& rectangles) {\n if (rectangles.empty()) {\n return {};\n }\n \n // Create a bounding rectangle of all selected rectangles\n int x1 = 100000, y1 = 100000, x2 = 0, y2 = 0;\n for (const auto& rect : rectangles) {\n x1 = min(x1, rect.x1);\n y1 = min(y1, rect.y1);\n x2 = max(x2, rect.x2);\n y2 = max(y2, rect.y2);\n }\n \n // Create simple rectangle polygon\n vector polygon;\n polygon.push_back(Point(x1, y1));\n polygon.push_back(Point(x2, y1));\n polygon.push_back(Point(x2, y2));\n polygon.push_back(Point(x1, y2));\n \n return polygon;\n}\n\n// Simplify polygon (remove collinear points if any)\nvector simplifyPolygon(const vector& polygon) {\n if (polygon.size() <= 2) return polygon;\n \n vector simplified;\n simplified.push_back(polygon[0]);\n \n for (int i = 1; i < polygon.size(); i++) {\n if (simplified.size() < 2) {\n simplified.push_back(polygon[i]);\n continue;\n }\n \n Point p1 = simplified[simplified.size()-2];\n Point p2 = simplified[simplified.size()-1];\n Point p3 = polygon[i];\n \n // Check if they are collinear (cross product = 0)\n long long cross = (long long)(p2.x - p1.x) * (p3.y - p2.y) - (long long)(p2.y - p1.y) * (p3.x - p2.x);\n \n if (cross != 0) {\n simplified.push_back(polygon[i]);\n } else {\n simplified.back() = polygon[i];\n }\n }\n \n return simplified;\n}\n\n// Calculate total edge length of polygon\nlong long calculateEdgeLength(const vector& polygon) {\n if (polygon.size() <= 1) return 0;\n \n long long length = 0;\n for (int i = 0; i < polygon.size(); i++) {\n int j = (i + 1) % polygon.size();\n length += abs(polygon[i].x - polygon[j].x) + abs(polygon[i].y - polygon[j].y);\n }\n return length;\n}\n\n// Greedy selection of best rectangle\nRectangle selectBestRectangle(const vector& mackerels, const vector& sardines, const vector& candidates) {\n if (candidates.empty()) {\n return Rectangle(25000, 25000, 75000, 75000);\n }\n \n Rectangle bestRect = candidates[0];\n int bestScore = calculateScore(mackerels, sardines, bestRect);\n \n for (const auto& rect : candidates) {\n int score = calculateScore(mackerels, sardines, rect);\n if (score > bestScore) {\n bestScore = score;\n bestRect = rect;\n }\n }\n \n return bestRect;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n \n vector mackerels(N);\n vector sardines(N);\n \n // Read mackerels\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n \n // Read sardines\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n \n // Generate limited number of candidate rectangles\n vector candidates = generateCandidateRectangles(mackerels, sardines);\n \n // Select the best single rectangle\n Rectangle bestRect = selectBestRectangle(mackerels, sardines, candidates);\n \n // Create polygon from the best rectangle\n vector polygon = {\n Point(bestRect.x1, bestRect.y1),\n Point(bestRect.x2, bestRect.y1),\n Point(bestRect.x2, bestRect.y2),\n Point(bestRect.x1, bestRect.y2)\n };\n \n // Output\n cout << polygon.size() << \"\\n\";\n for (const auto& p : polygon) {\n cout << p.x << \" \" << p.y << \"\\n\";\n }\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include // Added for LLONG_MAX\n\nusing namespace std;\n\nstruct Rectangle {\n int w, h;\n int idx;\n};\n\nstruct Placement {\n int p, r;\n char d;\n int b;\n};\n\nclass RectanglePacker {\nprivate:\n int N, T;\n double sigma;\n vector> observed_wh;\n mt19937 rng;\n vector best_placement;\n long long best_score;\n int best_turn;\n vector> feedback_history;\n \npublic:\n RectanglePacker(int seed = 1234) : rng(seed) {\n best_score = LLONG_MAX;\n best_turn = -1;\n }\n \n void readInput() {\n cin >> N >> T >> sigma;\n observed_wh.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> observed_wh[i].first >> observed_wh[i].second;\n }\n }\n \n // Generate a random placement\n vector generateRandomPlacement(int n) {\n vector placement;\n uniform_int_distribution rotation_dist(0, 1);\n uniform_int_distribution direction_dist(0, 1);\n \n for (int i = 0; i < n; i++) {\n int r = rotation_dist(rng);\n char d = direction_dist(rng) ? 'L' : 'U';\n int b_max = i - 1;\n int b = -1;\n if (b_max >= 0) {\n uniform_int_distribution ref_dist(-1, b_max);\n b = ref_dist(rng);\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Generate a greedy placement based on size\n vector generateGreedyPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n // Decide rotation: try to minimize the larger dimension\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n int r = (orig_w > orig_h) ? 1 : 0; // Rotate if width > height\n \n // Alternate between U and L for better packing\n char d = (i % 2 == 0) ? 'U' : 'L';\n \n // Reference to previous rectangle or -1\n int b = (i > 0) ? (i - 1) : -1;\n if (i > 2 && rng() % 3 == 0) {\n uniform_int_distribution ref_dist(0, i - 1);\n b = ref_dist(rng);\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Mutate an existing placement\n vector mutatePlacement(const vector& base, double temp) {\n vector result = base;\n int n = result.size();\n \n // Number of mutations based on temperature\n int num_mutations = max(1, (int)(temp * n / 10.0));\n \n uniform_int_distribution mutation_dist(0, 2); // 0=rotation, 1=direction, 2=reference\n uniform_int_distribution index_dist(0, n - 1);\n \n for (int i = 0; i < num_mutations; i++) {\n if (n == 0) break;\n int idx = index_dist(rng);\n \n int mutation_type = mutation_dist(rng);\n switch (mutation_type) {\n case 0: // Change rotation\n result[idx].r = 1 - result[idx].r;\n break;\n case 1: // Change direction\n result[idx].d = (result[idx].d == 'U') ? 'L' : 'U';\n break;\n case 2: // Change reference\n int max_ref = idx - 1;\n if (max_ref >= 0) {\n uniform_int_distribution ref_dist(-1, max_ref);\n result[idx].b = ref_dist(rng);\n } else {\n result[idx].b = -1;\n }\n break;\n }\n }\n \n return result;\n }\n \n // Simulated annealing step\n vector getNextPlacement(int turn) {\n double temperature = 1.0 - (double)turn / T;\n \n if (turn == 0) {\n // First turn: try greedy approach\n return generateGreedyPlacement(N);\n }\n \n if (best_turn == -1 || rng() % 100 < 10) { // 10% chance of random restart\n if (rng() % 2 == 0) {\n return generateRandomPlacement(N);\n } else {\n return generateGreedyPlacement(N);\n }\n }\n \n // Otherwise, mutate the best solution found so far\n vector mutated = mutatePlacement(best_placement, temperature);\n \n // Occasionally try a completely different approach\n if (rng() % 100 < 5) {\n // Fixed the % operator with double issue\n int partial_n = (int)(N * 0.8);\n int range = (int)(N * 0.2) + 1;\n if (range > 0) {\n uniform_int_distribution size_dist(partial_n, partial_n + range - 1);\n int n = min(N, size_dist(rng));\n if (n < N) {\n mutated = generateRandomPlacement(n);\n }\n }\n }\n \n return mutated;\n }\n \n void outputPlacement(const vector& placement) {\n cout << placement.size() << endl;\n for (const auto& p : placement) {\n cout << p.p << \" \" << p.r << \" \" << p.d << \" \" << p.b << endl;\n }\n cout.flush();\n }\n \n long long calculateEstimatedScore(int W_prime, int H_prime, int n) {\n // Estimate the score based on noisy measurements\n long long score = (long long)W_prime + (long long)H_prime;\n \n // Add penalty for unused rectangles\n for (int i = n; i < N; i++) {\n score += (long long)observed_wh[i].first + (long long)observed_wh[i].second;\n }\n \n return score;\n }\n \n void processTurn(int turn) {\n vector placement = getNextPlacement(turn);\n \n // Output the placement\n outputPlacement(placement);\n \n // Read feedback\n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n feedback_history.push_back({W_prime, H_prime});\n \n // Calculate estimated score\n long long estimated_score = calculateEstimatedScore(W_prime, H_prime, placement.size());\n \n // Update best solution if this is better\n if (estimated_score < best_score) {\n best_score = estimated_score;\n best_placement = placement;\n best_turn = turn;\n }\n }\n \n void solve() {\n readInput();\n \n for (int turn = 0; turn < T; turn++) {\n processTurn(turn);\n }\n }\n};\n\nint main() {\n // Use current time as seed for randomness\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RectanglePacker packer(static_cast(seed));\n packer.solve();\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n \n vector A(N);\n for (int i = 0; i < N; i++) {\n cin >> A[i];\n }\n \n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n vector> coords(N);\n for (int i = 0; i < N; i++) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Create list of vertices sorted by beauty (descending)\n vector vertices(N);\n for (int i = 0; i < N; i++) {\n vertices[i] = i;\n }\n sort(vertices.begin(), vertices.end(), [&](int a, int b) {\n return A[a] > A[b];\n });\n \n vector parent(N, -2); // -2: unassigned, -1: root\n vector height(N, -1);\n vector used(N, false);\n \n // Greedy tree construction\n for (int start_idx = 0; start_idx < N; start_idx++) {\n int root = vertices[start_idx];\n if (parent[root] != -2) continue; // Already assigned\n \n // Start new tree with this vertex as root\n parent[root] = -1;\n height[root] = 0;\n used[root] = true;\n \n // BFS with priority queue based on beauty value\n priority_queue> pq; // (beauty, vertex)\n pq.push({A[root], root});\n \n while (!pq.empty()) {\n int u = pq.top().second;\n pq.pop();\n \n // If already processed in this tree with better path, skip\n if (used[u] && parent[u] != -1 && u != root) continue;\n \n // Explore neighbors\n for (int v : adj[u]) {\n if (parent[v] != -2) continue; // Already in some tree\n \n // Check if adding this vertex would exceed height limit\n if (height[u] + 1 <= H) {\n parent[v] = u;\n height[v] = height[u] + 1;\n used[v] = true;\n pq.push({A[v], v});\n }\n }\n }\n }\n \n // Assign any remaining unassigned vertices\n for (int i = 0; i < N; i++) {\n if (parent[i] == -2) {\n // Find the best parent among neighbors\n int best_parent = -1;\n int max_benefit = -1;\n \n for (int neighbor : adj[i]) {\n if (parent[neighbor] != -2 && height[neighbor] < H) {\n // Benefit: beauty * (height+1)\n int benefit = A[i] * (height[neighbor] + 1);\n if (benefit > max_benefit) {\n max_benefit = benefit;\n best_parent = neighbor;\n }\n }\n }\n \n if (best_parent != -1) {\n parent[i] = best_parent;\n height[i] = height[best_parent] + 1;\n } else {\n // Make it a root if no suitable parent found\n parent[i] = -1;\n height[i] = 0;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; i++) {\n cout << parent[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n \n // Read input\n cin >> N;\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n vector> operations;\n \n // For each cell that contains an Oni ('x')\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'x') {\n // Check which direction is safe (no Fukunokami)\n bool safe_up = true, safe_down = true, safe_left = true, safe_right = true;\n \n // Check upward direction\n for (int k = 0; k < i; k++) {\n if (board[k][j] == 'o') {\n safe_up = false;\n break;\n }\n }\n \n // Check downward direction\n for (int k = i + 1; k < N; k++) {\n if (board[k][j] == 'o') {\n safe_down = false;\n break;\n }\n }\n \n // Check leftward direction\n for (int k = 0; k < j; k++) {\n if (board[i][k] == 'o') {\n safe_left = false;\n break;\n }\n }\n \n // Check rightward direction\n for (int k = j + 1; k < N; k++) {\n if (board[i][k] == 'o') {\n safe_right = false;\n break;\n }\n }\n \n // Choose a safe direction (at least one is guaranteed to exist)\n if (safe_up) {\n // Shift column j upward (i+1) times\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'U', j});\n }\n // Shift column j downward (i+1) times to restore\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'D', j});\n }\n } else if (safe_down) {\n // Shift column j downward (N-1-i) times\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'D', j});\n }\n // Shift column j upward (N-1-i) times to restore\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'U', j});\n }\n } else if (safe_left) {\n // Shift row i left (j+1) times\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'L', i});\n }\n // Shift row i right (j+1) times to restore\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'R', i});\n }\n } else if (safe_right) {\n // Shift row i right (N-1-j) times\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'R', i});\n }\n // Shift row i left (N-1-j) times to restore\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'L', i});\n }\n }\n }\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\n// Structure to hold the state\nstruct State {\n vector a, b;\n long long error;\n \n State() : a(N), b(N), error(0) {}\n \n // Calculate error for this state\n long long calculateError(const vector& targets) {\n vector counts(N, 0);\n int current = 0; // Start with employee 0\n \n for (int week = 0; week < L; week++) {\n counts[current]++;\n // Determine next employee based on parity of current's count\n if (counts[current] % 2 == 1) { // odd\n current = a[current];\n } else { // even\n current = b[current];\n }\n }\n \n long long total_error = 0;\n for (int i = 0; i < N; i++) {\n total_error += abs(counts[i] - targets[i]);\n }\n return total_error;\n }\n};\n\nclass Solution {\nprivate:\n vector targets;\n mt19937 rng;\n \npublic:\n Solution(const vector& t) : targets(t), rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n // Generate a random initial solution\n State generateInitialSolution() {\n State s;\n \n // Initialize with a reasonable strategy: assign to employees with similar targets\n vector> target_indices;\n for (int i = 0; i < N; i++) {\n target_indices.push_back({targets[i], i});\n }\n sort(target_indices.begin(), target_indices.end());\n \n // For each employee, assign a_i and b_i to those with similar target values\n for (int i = 0; i < N; i++) {\n int idx = -1;\n for (int j = 0; j < N; j++) {\n if (target_indices[j].second == i) {\n idx = j;\n break;\n }\n }\n \n // Assign a_i and b_i to employees with close target values\n if (idx > 0) {\n s.a[i] = target_indices[idx - 1].second;\n } else {\n s.a[i] = target_indices[N - 1].second;\n }\n \n if (idx < N - 1) {\n s.b[i] = target_indices[idx + 1].second;\n } else {\n s.b[i] = target_indices[0].second;\n }\n }\n \n s.error = s.calculateError(targets);\n return s;\n }\n \n // Generate a random solution\n State generateRandomSolution() {\n State s;\n uniform_int_distribution dist(0, N - 1);\n \n for (int i = 0; i < N; i++) {\n s.a[i] = dist(rng);\n s.b[i] = dist(rng);\n }\n \n s.error = s.calculateError(targets);\n return s;\n }\n \n // Try to improve the solution with local search\n State localSearch(State current, int max_iterations) {\n State best = current;\n \n for (int iter = 0; iter < max_iterations; iter++) {\n State candidate = current;\n \n // Randomly perturb one or two assignments\n uniform_int_distribution dist(0, N - 1);\n uniform_int_distribution change_dist(0, 1);\n \n int changes = dist(rng) % 3 + 1; // 1 to 3 changes\n \n for (int c = 0; c < changes; c++) {\n int i = dist(rng);\n if (change_dist(rng) == 0) {\n candidate.a[i] = dist(rng);\n } else {\n candidate.b[i] = dist(rng);\n }\n }\n \n candidate.error = candidate.calculateError(targets);\n \n // Accept if better\n if (candidate.error < best.error) {\n best = candidate;\n current = candidate;\n }\n }\n \n return best;\n }\n \n // Simulated annealing approach\n State simulatedAnnealing(State initial, int max_iterations) {\n State current = initial;\n State best = initial;\n double temperature = 1000.0;\n double cooling_rate = 0.995;\n \n uniform_real_distribution real_dist(0.0, 1.0);\n uniform_int_distribution int_dist(0, N - 1);\n \n for (int iter = 0; iter < max_iterations; iter++) {\n State neighbor = current;\n \n // Make a random change\n int change_type = int_dist(rng) % 3;\n if (change_type == 0) {\n int i = int_dist(rng);\n neighbor.a[i] = int_dist(rng);\n } else if (change_type == 1) {\n int i = int_dist(rng);\n neighbor.b[i] = int_dist(rng);\n } else {\n int i = int_dist(rng);\n neighbor.a[i] = int_dist(rng);\n neighbor.b[i] = int_dist(rng);\n }\n \n neighbor.error = neighbor.calculateError(targets);\n \n // Calculate acceptance probability\n double delta = neighbor.error - current.error;\n double acceptance_probability = exp(-delta / temperature);\n \n // Accept the neighbor\n if (delta < 0 || real_dist(rng) < acceptance_probability) {\n current = neighbor;\n if (current.error < best.error) {\n best = current;\n }\n }\n \n // Cool down\n temperature *= cooling_rate;\n }\n \n return best;\n }\n \n // Main solve function\n State solve() {\n State best_solution;\n best_solution.error = LLONG_MAX;\n \n // Try multiple initial solutions\n const int NUM_TRIALS = 5;\n const int LOCAL_SEARCH_ITERATIONS = 1000;\n const int ANNEALING_ITERATIONS = 2000;\n \n for (int trial = 0; trial < NUM_TRIALS; trial++) {\n State initial;\n \n if (trial == 0) {\n initial = generateInitialSolution();\n } else {\n initial = generateRandomSolution();\n }\n \n // Try local search\n State improved = localSearch(initial, LOCAL_SEARCH_ITERATIONS);\n \n // Try simulated annealing\n State annealed = simulatedAnnealing(improved, ANNEALING_ITERATIONS);\n \n if (annealed.error < best_solution.error) {\n best_solution = annealed;\n }\n \n // Early termination if we get a perfect solution\n if (best_solution.error == 0) {\n break;\n }\n }\n \n return best_solution;\n }\n};\n\nint main() {\n int n, l;\n cin >> n >> l;\n \n vector targets(n);\n for (int i = 0; i < n; i++) {\n cin >> targets[i];\n }\n \n Solution solver(targets);\n State solution = solver.solve();\n \n // Output the solution\n for (int i = 0; i < n; i++) {\n cout << solution.a[i] << \" \" << solution.b[i] << endl;\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\nusing namespace std;\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy; // center coordinates\n};\n\nstruct Edge {\n int u, v;\n double estimated_dist;\n int true_dist = -1; // -1 means unknown\n};\n\n// Calculate estimated distance between city centers\ndouble estimate_distance(const City& a, const City& b) {\n double dx = a.cx - b.cx;\n double dy = a.cy - b.cy;\n return sqrt(dx*dx + dy*dy);\n}\n\n// Calculate minimum possible distance between two bounding boxes\ndouble min_possible_distance(const City& a, const City& b) {\n double min_dx = max(0, max(a.lx - b.rx, b.lx - a.rx));\n double min_dy = max(0, max(a.ly - b.ry, b.ly - a.ay));\n return sqrt(min_dx*min_dx + min_dy*min_dy);\n}\n\n// Calculate maximum possible distance between two bounding boxes\ndouble max_possible_distance(const City& a, const City& b) {\n double max_dx = max(abs(a.lx - b.rx), abs(a.rx - b.lx));\n double max_dy = max(abs(a.ly - b.ry), abs(a.ry - b.ly));\n return sqrt(max_dx*max_dx + max_dy*max_dy);\n}\n\n// Query result structure\nstruct QueryResult {\n vector> edges;\n};\n\nclass Solution {\nprivate:\n int N, M, Q, L, W;\n vector G;\n vector cities;\n mt19937 rng;\n \n // Store results of queries\n map, int> known_distances; // true distances between pairs\n vector query_results;\n \n // For building MST at the end\n vector> final_groups;\n vector>> final_edges;\n \npublic:\n Solution() : rng(random_device{}()) {}\n \n void read_input() {\n cin >> N >> M >> Q >> L >> W;\n G.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n cities.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].id = i;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2.0;\n }\n }\n \n QueryResult make_query(const vector& city_ids) {\n int k = city_ids.size();\n if (k < 2 || k > L) {\n cerr << \"Invalid query size: \" << k << endl;\n return {};\n }\n \n cout << \"? \" << k;\n for (int id : city_ids) {\n cout << \" \" << id;\n }\n cout << endl;\n cout.flush();\n \n QueryResult result;\n for (int i = 0; i < k - 1; i++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n result.edges.push_back({u, v});\n \n // Store this known edge (we don't know the exact distance but we know it's part of MST)\n known_distances[{u, v}] = -1; // Mark as known but distance unknown\n }\n \n query_results.push_back(result);\n return result;\n }\n \n // Estimate if two cities are likely to be close based on bounding boxes\n bool are_likely_close(const City& a, const City& b) {\n double est_dist = estimate_distance(a, b);\n double max_dist = max_possible_distance(a, b);\n \n // If estimated distance is small relative to max possible, they're likely close\n if (est_dist < max_dist * 0.3) {\n return true;\n }\n \n // If bounding boxes overlap, they're likely close\n bool overlap_x = !(a.rx < b.lx || b.rx < a.lx);\n bool overlap_y = !(a.ry < b.ly || b.ry < a.ly);\n if (overlap_x && overlap_y) {\n return true;\n }\n \n return false;\n }\n \n // Initial grouping based on spatial proximity\n void initial_grouping() {\n // Sort cities by x-coordinate of center, then y-coordinate\n vector city_order(N);\n for (int i = 0; i < N; i++) {\n city_order[i] = i;\n }\n \n sort(city_order.begin(), city_order.end(), [this](int a, int b) {\n if (cities[a].cx != cities[b].cx) {\n return cities[a].cx < cities[b].cx;\n }\n return cities[a].cy < cities[b].cy;\n });\n \n // Create initial groups by taking consecutive cities\n final_groups.resize(M);\n int start_idx = 0;\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < G[i]; j++) {\n final_groups[i].push_back(city_order[start_idx + j]);\n }\n start_idx += G[i];\n }\n }\n \n // Refine grouping using queries\n void refine_grouping() {\n // For this implementation, we'll use a simple strategy:\n // 1. For each group, if the group size <= L, query the entire group\n // 2. For larger groups, query overlapping subsets\n \n int queries_used = 0;\n \n // Process each group\n for (int group_idx = 0; group_idx < M && queries_used < Q; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size <= L) {\n // Query the entire group\n QueryResult result = make_query(group);\n queries_used++;\n \n // Store the edges for this group\n final_edges.resize(M);\n for (auto& edge : result.edges) {\n final_edges[group_idx].push_back(edge);\n }\n } else {\n // For larger groups, use sliding window approach\n // Query overlapping triplets (or larger sets up to L)\n int step = max(1, L - 1);\n for (int i = 0; i < group_size - 1 && queries_used < Q; i += step) {\n int end_idx = min(i + L, group_size);\n vector subset;\n for (int j = i; j < end_idx; j++) {\n subset.push_back(group[j]);\n }\n \n QueryResult result = make_query(subset);\n queries_used++;\n \n // Store the edges (we'll reconcile them later when building final MST)\n if (final_edges.size() <= group_idx) {\n final_edges.resize(group_idx + 1);\n }\n for (auto& edge : result.edges) {\n final_edges[group_idx].push_back(edge);\n }\n \n // Early termination if we've used all queries\n if (queries_used >= Q) break;\n }\n }\n }\n }\n \n // Build MST for each group using known edges and estimated distances\n void build_final_msts() {\n final_edges.clear();\n final_edges.resize(M);\n \n for (int group_idx = 0; group_idx < M; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size == 1) {\n // No edges needed\n continue;\n }\n \n // Create a graph with all possible edges in the group\n vector edges;\n for (int i = 0; i < group_size; i++) {\n for (int j = i + 1; j < group_size; j++) {\n int u = group[i];\n int v = group[j];\n if (u > v) swap(u, v);\n \n Edge e;\n e.u = u;\n e.v = v;\n e.estimated_dist = estimate_distance(cities[u], cities[v]);\n \n // If we know this edge from a query, prioritize it\n if (known_distances.count({u, v})) {\n e.estimated_dist = 0; // prioritize known edges\n }\n \n edges.push_back(e);\n }\n }\n \n // Sort edges by estimated distance\n sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {\n return a.estimated_dist < b.estimated_dist;\n });\n \n // Use Kruskal's algorithm to build MST\n vector parent(group_size);\n for (int i = 0; i < group_size; i++) {\n parent[i] = i;\n }\n \n function find = [&](int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n };\n \n auto unite = [&](int x, int y) {\n int rx = find(x);\n int ry = find(y);\n if (rx != ry) {\n parent[rx] = ry;\n return true;\n }\n return false;\n };\n \n // Build MST\n for (const Edge& e : edges) {\n int u_idx = -1, v_idx = -1;\n for (int i = 0; i < group_size; i++) {\n if (group[i] == e.u) u_idx = i;\n if (group[i] == e.v) v_idx = i;\n }\n \n if (u_idx != -1 && v_idx != -1 && unite(u_idx, v_idx)) {\n final_edges[group_idx].push_back({e.u, e.v});\n if (final_edges[group_idx].size() == group_size - 1) {\n break;\n }\n }\n }\n }\n }\n \n void output_answer() {\n cout << \"!\" << endl;\n \n for (int i = 0; i < M; i++) {\n // Output group members\n for (int j = 0; j < final_groups[i].size(); j++) {\n if (j > 0) cout << \" \";\n cout << final_groups[i][j];\n }\n cout << endl;\n \n // Output edges for this group\n for (auto& edge : final_edges[i]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n cout.flush();\n }\n \n void solve() {\n read_input();\n \n // Initial grouping\n initial_grouping();\n \n // Refine grouping with queries\n refine_grouping();\n \n // Build final MSTs for each group\n build_final_msts();\n \n // Output answer\n output_answer();\n }\n};\n\nint main() {\n Solution solution;\n solution.solve();\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Pos {\n int i, j;\n Pos(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator==(const Pos& other) const {\n return i == other.i && j == other.j;\n }\n bool operator<(const Pos& other) const {\n return i < other.i || (i == other.i && j < other.j);\n }\n};\n\nstruct State {\n Pos pos;\n vector> blocks;\n int targetIndex;\n vector actions;\n \n State(Pos p, const vector>& b, int ti) : pos(p), blocks(b), targetIndex(ti) {}\n};\n\n// Direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Manhattan distance\nint manhattan(const Pos& a, const Pos& b) {\n return abs(a.i - b.i) + abs(a.j - b.j);\n}\n\n// Check if position is valid\nbool isValid(const Pos& p, int N) {\n return p.i >= 0 && p.i < N && p.j >= 0 && p.j < N;\n}\n\n// Check if can move to position\nbool canMoveTo(const Pos& from, const Pos& to, const vector>& blocks, int N) {\n if (!isValid(to, N)) return false;\n if (blocks[to.i][to.j]) return false;\n return true;\n}\n\n// Sliding in a direction until hitting a block\nPos slide(const Pos& start, int dir, const vector>& blocks, int N) {\n Pos current = start;\n Pos next = {current.i + di[dir], current.j + dj[dir]};\n \n while (isValid(next, N) && !blocks[next.i][next.j]) {\n current = next;\n next = {current.i + di[dir], current.j + dj[dir]};\n }\n \n return current;\n}\n\n// A* search to find shortest path to target\nvector> findPath(const Pos& start, const Pos& target, vector> blocks, int N) {\n // Priority queue for A* (cost, position, path)\n using QueueItem = tuple>>;\n priority_queue, greater> pq;\n \n // Visited set\n set visited;\n \n // Start state\n pq.push({0, start, {}});\n \n while (!pq.empty()) {\n auto [cost, pos, path] = pq.top();\n pq.pop();\n \n if (pos == target) {\n return path;\n }\n \n if (visited.count(pos)) continue;\n visited.insert(pos);\n \n // Try normal moves in 4 directions\n for (int d = 0; d < 4; d++) {\n Pos next = {pos.i + di[d], pos.j + dj[d]};\n if (canMoveTo(pos, next, blocks, N)) {\n auto newPath = path;\n newPath.push_back({'M', dirChar[d]});\n int newCost = cost + 1 + manhattan(next, target);\n pq.push({newCost, next, newPath});\n }\n }\n \n // Try slides in 4 directions\n for (int d = 0; d < 4; d++) {\n Pos slideEnd = slide(pos, d, blocks, N);\n if (slideEnd != pos) { // Only if we actually moved\n auto newPath = path;\n newPath.push_back({'S', dirChar[d]});\n int newCost = cost + 1 + manhattan(slideEnd, target);\n pq.push({newCost, slideEnd, newPath});\n }\n }\n }\n \n // If A* fails, return empty path\n return {};\n}\n\n// Simple greedy approach for now - we'll enhance if needed\nvector> greedyPath(const Pos& start, const Pos& target, vector>& blocks, int N) {\n vector> actions;\n Pos current = start;\n \n while (current != target) {\n // First, try straight slide if possible\n bool usedSlide = false;\n \n // Check if we can slide directly to target (need to place blocker after)\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(current, next, blocks, N)) {\n // Calculate where we'd end up if we slid in this direction\n Pos slideEnd = slide(current, d, blocks, N);\n \n // If slide would overshoot target, we can place a block to stop at target\n if (d == 0 && current.i > target.i && target.i >= slideEnd.i) { // Up\n if (current.j == target.j) {\n // Check if we can place a block after target to stop there\n Pos blockerPos = {target.i - 1, target.j};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n // Place block\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n // Slide\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n } else if (d == 1 && current.i < target.i && target.i <= slideEnd.i) { // Down\n if (current.j == target.j) {\n Pos blockerPos = {target.i + 1, target.j};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n } else if (d == 2 && current.j > target.j && target.j >= slideEnd.j) { // Left\n if (current.i == target.i) {\n Pos blockerPos = {target.i, target.j - 1};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n } else if (d == 3 && current.j < target.j && target.j <= slideEnd.j) { // Right\n if (current.i == target.i) {\n Pos blockerPos = {target.i, target.j + 1};\n if (isValid(blockerPos, N) && !blocks[blockerPos.i][blockerPos.j] && blockerPos != target) {\n actions.push_back({'A', dirChar[d]});\n blocks[blockerPos.i][blockerPos.j] = true;\n actions.push_back({'S', dirChar[d]});\n current = target;\n usedSlide = true;\n break;\n }\n }\n }\n }\n }\n \n if (usedSlide) continue;\n \n // If no slide strategy worked, try normal move\n bool moved = false;\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(current, next, blocks, N)) {\n // Heuristic: prefer moves that get us closer to target\n if (manhattan(next, target) < manhattan(current, target)) {\n actions.push_back({'M', dirChar[d]});\n current = next;\n moved = true;\n break;\n }\n }\n }\n \n // If no good move, try any valid move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(current, next, blocks, N)) {\n actions.push_back({'M', dirChar[d]});\n current = next;\n moved = true;\n break;\n }\n }\n }\n \n // If still can't move, we have a problem\n if (!moved) {\n // Emergency: try to remove a block that might be blocking us\n bool fixed = false;\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (isValid(next, N) && blocks[next.i][next.j]) {\n actions.push_back({'A', dirChar[d]});\n blocks[next.i][next.j] = false;\n fixed = true;\n break;\n }\n }\n \n if (!fixed) {\n // Still stuck, break to avoid infinite loop\n break;\n }\n }\n }\n \n return actions;\n}\n\nint main() {\n int N = 20, M = 40;\n cin >> N >> M;\n \n vector targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].i >> targets[i].j;\n }\n \n // Initialize board with no blocks\n vector> blocks(N, vector(N, false));\n Pos currentPos = targets[0];\n int visitedCount = 0;\n vector> allActions;\n \n // Visit each target in order (starting from index 1 since index 0 is start)\n for (int targetIdx = 1; targetIdx < M; targetIdx++) {\n const Pos& target = targets[targetIdx];\n \n // Special handling: if target has a block, remove it first\n if (blocks[target.i][target.j]) {\n // Find direction to target from current position\n int dir = -1;\n if (currentPos.i == target.i && currentPos.j == target.j + 1) dir = 3; // Right\n else if (currentPos.i == target.i && currentPos.j == target.j - 1) dir = 2; // Left\n else if (currentPos.i == target.i + 1 && currentPos.j == target.j) dir = 1; // Down\n else if (currentPos.i == target.i - 1 && currentPos.j == target.j) dir = 0; // Up\n \n if (dir != -1) {\n allActions.push_back({'A', dirChar[dir]});\n blocks[target.i][target.j] = false;\n } else {\n // Need to move adjacent to target first\n Pos moveTarget;\n if (target.i > 0) moveTarget = {target.i - 1, target.j}; // Try up\n else if (target.i < N-1) moveTarget = {target.i + 1, target.j}; // Try down\n else if (target.j > 0) moveTarget = {target.i, target.j - 1}; // Try left\n else moveTarget = {target.i, target.j + 1}; // Try right\n \n // Path to moveTarget\n auto pathToAdjacent = greedyPath(currentPos, moveTarget, blocks, N);\n for (auto& action : pathToAdjacent) {\n allActions.push_back(action);\n }\n currentPos = moveTarget;\n \n // Now remove block\n dir = (moveTarget.i == target.i - 1) ? 1 : \n (moveTarget.i == target.i + 1) ? 0 :\n (moveTarget.j == target.j - 1) ? 3 : 2;\n allActions.push_back({'A', dirChar[dir]});\n blocks[target.i][target.j] = false;\n \n // Move to target\n allActions.push_back({'M', dirChar[dir]});\n currentPos = target;\n visitedCount++;\n continue;\n }\n }\n \n // Find path to target\n vector> path = greedyPath(currentPos, target, blocks, N);\n \n // Execute path\n for (auto& action : path) {\n allActions.push_back(action);\n \n // Update current position based on action\n if (action.first == 'M') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (canMoveTo(currentPos, next, blocks, N)) {\n currentPos = next;\n }\n } else if (action.first == 'S') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n currentPos = slide(currentPos, dir, blocks, N);\n } else if (action.first == 'A') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos alterPos = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (isValid(alterPos, N)) {\n blocks[alterPos.i][alterPos.j] = !blocks[alterPos.i][alterPos.j];\n }\n }\n }\n \n // Check if we reached the target\n if (currentPos == target) {\n visitedCount++;\n } else {\n // Try one more time with simpler approach\n // Try to move directly if adjacent\n bool reached = false;\n for (int d = 0; d < 4; d++) {\n Pos next = {currentPos.i + di[d], currentPos.j + dj[d]};\n if (next == target && canMoveTo(currentPos, next, blocks, N)) {\n allActions.push_back({'M', dirChar[d]});\n currentPos = next;\n visitedCount++;\n reached = true;\n break;\n }\n }\n \n if (!reached) {\n // Try slide to target\n for (int d = 0; d < 4; d++) {\n Pos slideEnd = slide(currentPos, d, blocks, N);\n if (slideEnd == target) {\n allActions.push_back({'S', dirChar[d]});\n currentPos = target;\n visitedCount++;\n reached = true;\n break;\n }\n }\n }\n \n if (!reached) {\n // Skip this target if we can't reach it, but try to continue with others\n // In a real solution, we'd want to do more to ensure we can reach all targets\n }\n }\n }\n \n // Output all actions\n for (auto& action : allActions) {\n cout << action.first << \" \" << action.second << endl;\n }\n \n return 0;\n}"},"4":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int a, b, c, d; // top-left (a,b), bottom-right (c,d)\n int idx;\n \n Rectangle() : a(0), b(0), c(0), d(0), idx(-1) {}\n Rectangle(int a, int b, int c, int d, int idx) : a(a), b(b), c(c), d(d), idx(idx) {}\n \n int area() const { return (c - a) * (d - b); }\n \n bool contains(double x, double y) const {\n return x >= a && x < c && y >= b && y < d;\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(c <= other.a || other.c <= a || d <= other.b || other.d <= b);\n }\n \n // Returns the overlap area with another rectangle\n int overlapArea(const Rectangle& other) const {\n int overlap_width = max(0, min(c, other.c) - max(a, other.a));\n int overlap_height = max(0, min(d, other.d) - max(b, other.b));\n return overlap_width * overlap_height;\n }\n};\n\nstruct Company {\n int x, y, r, idx;\n double target_x, target_y;\n \n Company() : x(0), y(0), r(0), idx(-1), target_x(0.0), target_y(0.0) {}\n Company(int x, int y, int r, int idx) : x(x), y(y), r(r), idx(idx) {\n target_x = x + 0.5;\n target_y = y + 0.5;\n }\n};\n\n// Calculate satisfaction for a company\ndouble calculateSatisfaction(int desired_area, int actual_area) {\n if (actual_area == 0) return 0.0;\n double ratio = min(desired_area, actual_area) * 1.0 / max(desired_area, actual_area);\n return 1.0 - (1.0 - ratio) * (1.0 - ratio);\n}\n\n// Check if rectangles are valid (within bounds, no overlaps)\nbool isValid(const vector& rects, int n) {\n for (int i = 0; i < n; i++) {\n if (rects[i].a < 0 || rects[i].b < 0 || rects[i].c > 10000 || rects[i].d > 10000) {\n return false;\n }\n if (rects[i].a >= rects[i].c || rects[i].b >= rects[i].d) {\n return false;\n }\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n return false;\n }\n }\n }\n return true;\n}\n\n// Calculate total satisfaction\ndouble calculateTotalSatisfaction(const vector& rects, const vector& companies) {\n double total = 0.0;\n for (int i = 0; i < companies.size(); i++) {\n const Company& c = companies[i];\n const Rectangle& r = rects[i];\n if (r.contains(c.target_x, c.target_y)) {\n total += calculateSatisfaction(c.r, r.area());\n }\n }\n return total;\n}\n\n// Try to create initial rectangles centered at target points\nvector createInitialRectangles(const vector& companies) {\n vector rects(companies.size());\n \n for (int i = 0; i < companies.size(); i++) {\n const Company& c = companies[i];\n \n // Try to create a rectangle centered at (x+0.5, y+0.5) with area close to r_i\n int side = (int)sqrt(c.r);\n if (side * side < c.r) side++;\n \n // Calculate boundaries\n int width = side;\n int height = c.r / width;\n if (width * height < c.r) height++;\n \n // Center around the target point\n int left = (int)(c.target_x - width / 2.0);\n int top = (int)(c.target_y - height / 2.0);\n int right = left + width;\n int bottom = top + height;\n \n // Adjust if out of bounds\n if (left < 0) {\n left = 0;\n right = min(width, 10000);\n }\n if (right > 10000) {\n right = 10000;\n left = max(0, right - width);\n }\n if (top < 0) {\n top = 0;\n bottom = min(height, 10000);\n }\n if (bottom > 10000) {\n bottom = 10000;\n top = max(0, bottom - height);\n }\n \n // Ensure the target point is contained\n if (c.target_x < left + 0.5) left = (int)(c.target_x - 0.5);\n if (c.target_x >= right - 0.5) right = (int)(c.target_x + 1.5);\n if (c.target_y < top + 0.5) top = (int)(c.target_y - 0.5);\n if (c.target_y >= bottom - 0.5) bottom = (int)(c.target_y + 1.5);\n \n // Final bounds check\n left = max(0, left);\n top = max(0, top);\n right = min(10000, right);\n bottom = min(10000, bottom);\n \n rects[i] = Rectangle(left, top, right, bottom, i);\n }\n \n return rects;\n}\n\n// Resolve conflicts between rectangles (greedy approach)\nvoid resolveConflicts(vector& rects, const vector& companies) {\n int n = rects.size();\n const int MAX_ITER = 1000;\n \n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool conflict_resolved = true;\n \n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n conflict_resolved = false;\n \n // Try to shrink one of the rectangles\n // Priority: try to keep the one that's closer to its desired area\n \n double sat_i = rects[i].contains(companies[i].target_x, companies[i].target_y) ? \n calculateSatisfaction(companies[i].r, rects[i].area()) : 0.0;\n double sat_j = rects[j].contains(companies[j].target_x, companies[j].target_y) ? \n calculateSatisfaction(companies[j].r, rects[j].area()) : 0.0;\n \n // Shrink the rectangle with lower satisfaction\n if (sat_i <= sat_j) {\n // Try to shrink rectangle i\n Rectangle orig_i = rects[i];\n \n // Try different ways to shrink\n bool found = false;\n for (int tries = 0; tries < 10 && !found; tries++) {\n // Try reducing width or height\n if (orig_i.c - orig_i.a > 1) {\n int new_a = orig_i.a + 1;\n if (companies[i].target_x >= new_a + 0.5 && companies[i].target_x < orig_i.c - 0.5) {\n rects[i] = Rectangle(new_a, orig_i.b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_i.c - 1;\n if (companies[i].target_x >= orig_i.a + 0.5 && companies[i].target_x < new_c - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, new_c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_i.d - orig_i.b > 1) {\n int new_b = orig_i.b + 1;\n if (companies[i].target_y >= new_b + 0.5 && companies[i].target_y < orig_i.d - 0.5) {\n rects[i] = Rectangle(orig_i.a, new_b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_i.d - 1;\n if (companies[i].target_y >= orig_i.b + 0.5 && companies[i].target_y < new_d - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, orig_i.c, new_d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n \n if (!found) {\n // If can't resolve by shrinking i, try shrinking j\n Rectangle orig_j = rects[j];\n \n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_j.c - orig_j.a > 1) {\n int new_a = orig_j.a + 1;\n if (companies[j].target_x >= new_a + 0.5 && companies[j].target_x < orig_j.c - 0.5) {\n rects[j] = Rectangle(new_a, orig_j.b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_j.c - 1;\n if (companies[j].target_x >= orig_j.a + 0.5 && companies[j].target_x < new_c - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, new_c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_j.d - orig_j.b > 1) {\n int new_b = orig_j.b + 1;\n if (companies[j].target_y >= new_b + 0.5 && companies[j].target_y < orig_j.d - 0.5) {\n rects[j] = Rectangle(orig_j.a, new_b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_j.d - 1;\n if (companies[j].target_y >= orig_j.b + 0.5 && companies[j].target_y < new_d - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, orig_j.c, new_d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n }\n } else {\n // Try shrinking rectangle j first (symmetric to above)\n Rectangle orig_j = rects[j];\n \n bool found = false;\n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_j.c - orig_j.a > 1) {\n int new_a = orig_j.a + 1;\n if (companies[j].target_x >= new_a + 0.5 && companies[j].target_x < orig_j.c - 0.5) {\n rects[j] = Rectangle(new_a, orig_j.b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_j.c - 1;\n if (companies[j].target_x >= orig_j.a + 0.5 && companies[j].target_x < new_c - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, new_c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_j.d - orig_j.b > 1) {\n int new_b = orig_j.b + 1;\n if (companies[j].target_y >= new_b + 0.5 && companies[j].target_y < orig_j.d - 0.5) {\n rects[j] = Rectangle(orig_j.a, new_b, orig_j.c, orig_j.d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_j.d - 1;\n if (companies[j].target_y >= orig_j.b + 0.5 && companies[j].target_y < new_d - 0.5) {\n rects[j] = Rectangle(orig_j.a, orig_j.b, orig_j.c, new_d, j);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n \n if (!found) {\n // Try shrinking i\n Rectangle orig_i = rects[i];\n \n for (int tries = 0; tries < 10 && !found; tries++) {\n if (orig_i.c - orig_i.a > 1) {\n int new_a = orig_i.a + 1;\n if (companies[i].target_x >= new_a + 0.5 && companies[i].target_x < orig_i.c - 0.5) {\n rects[i] = Rectangle(new_a, orig_i.b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_c = orig_i.c - 1;\n if (companies[i].target_x >= orig_i.a + 0.5 && companies[i].target_x < new_c - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, new_c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n \n if (orig_i.d - orig_i.b > 1) {\n int new_b = orig_i.b + 1;\n if (companies[i].target_y >= new_b + 0.5 && companies[i].target_y < orig_i.d - 0.5) {\n rects[i] = Rectangle(orig_i.a, new_b, orig_i.c, orig_i.d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n \n int new_d = orig_i.d - 1;\n if (companies[i].target_y >= orig_i.b + 0.5 && companies[i].target_y < new_d - 0.5) {\n rects[i] = Rectangle(orig_i.a, orig_i.b, orig_i.c, new_d, i);\n if (!rects[i].overlaps(rects[j])) {\n found = true;\n break;\n }\n }\n }\n }\n }\n }\n }\n }\n }\n \n if (conflict_resolved) break;\n }\n}\n\n// Try to optimize rectangles by adjusting boundaries\nvoid optimizeRectangles(vector& rects, const vector& companies) {\n int n = rects.size();\n const int MAX_LOCAL_OPT_ITER = 500;\n double best_score = calculateTotalSatisfaction(rects, companies);\n \n // Use a simple local search\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int iter = 0; iter < MAX_LOCAL_OPT_ITER; iter++) {\n // Pick a random rectangle to adjust\n int idx = rng() % n;\n Rectangle orig = rects[idx];\n \n // Try small adjustments to boundaries\n vector> candidates;\n \n // Try moving each boundary by -1, 0, or 1 (if it doesn't cause overlap or exclude target point)\n for (int da : {-1, 0, 1}) {\n for (int db : {-1, 0, 1}) {\n for (int dc : {-1, 0, 1}) {\n for (int dd : {-1, 0, 1}) {\n if (da == 0 && db == 0 && dc == 0 && dd == 0) continue;\n \n int new_a = orig.a + da;\n int new_b = orig.b + db;\n int new_c = orig.c + dc;\n int new_d = orig.d + dd;\n \n // Check bounds\n if (new_a < 0 || new_b < 0 || new_c > 10000 || new_d > 10000) continue;\n if (new_a >= new_c || new_b >= new_d) continue;\n \n // Check target point containment\n double target_x = companies[idx].target_x;\n double target_y = companies[idx].target_y;\n if (target_x < new_a + 0.5 || target_x >= new_c - 0.5 || \n target_y < new_b + 0.5 || target_y >= new_d - 0.5) continue;\n \n // Check for overlaps with other rectangles\n bool has_overlap = false;\n Rectangle test_rect(new_a, new_b, new_c, new_d, idx);\n for (int j = 0; j < n; j++) {\n if (j != idx && test_rect.overlaps(rects[j])) {\n has_overlap = true;\n break;\n }\n }\n \n if (!has_overlap) {\n candidates.push_back({candidates.size(), test_rect});\n }\n }\n }\n }\n }\n \n // If we have candidates, pick the best one\n if (!candidates.empty()) {\n // Score each candidate\n vector> scored_candidates;\n for (auto& cand : candidates) {\n rects[idx] = cand.second;\n double score = calculateTotalSatisfaction(rects, companies);\n scored_candidates.push_back({score, cand.first});\n rects[idx] = orig; // restore\n }\n \n // Sort by score (descending)\n sort(scored_candidates.begin(), scored_candidates.end(), \n [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n // Pick the best improvement (or if none, maybe pick a random one for exploration)\n double best_candidate_score = scored_candidates[0].first;\n if (best_candidate_score > best_score || (rng() % 10 == 0 && !scored_candidates.empty())) {\n // Take the improvement (or sometimes a random candidate for exploration)\n int chosen_idx = 0;\n if (best_candidate_score <= best_score && !scored_candidates.empty()) {\n chosen_idx = rng() % min(3, (int)scored_candidates.size());\n }\n \n rects[idx] = candidates[scored_candidates[chosen_idx].second].second;\n best_score = max(best_score, scored_candidates[chosen_idx].first);\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n;\n cin >> n;\n \n vector companies;\n for (int i = 0; i < n; i++) {\n int x, y, r;\n cin >> x >> y >> r;\n companies.push_back(Company(x, y, r, i));\n }\n \n // Create initial rectangles\n vector rects = createInitialRectangles(companies);\n \n // Resolve conflicts\n resolveConflicts(rects, companies);\n \n // Local optimization\n optimizeRectangles(rects, companies);\n \n // Final output\n for (int i = 0; i < n; i++) {\n cout << rects[i].a << \" \" << rects[i].b << \" \" << rects[i].c << \" \" << rects[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Tile {\n vector> squares;\n int total_value;\n int id;\n};\n\nclass Solution {\nprivate:\n int si, sj;\n vector> tile_ids;\n vector> values;\n vector tiles;\n int n = 50;\n high_resolution_clock::time_point start_time;\n const double time_limit = 1.9; // Leave 0.1 sec for overhead\n \n // Directions: U, D, L, R\n const vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n const string dir_chars = \"UDLR\";\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < n && j >= 0 && j < n;\n }\n \n double get_elapsed_time() {\n auto now = high_resolution_clock::now();\n auto duration = duration_cast(now - start_time);\n return duration.count() / 1000000.0;\n }\n \n // DFS with iterative deepening and pruning\n string dfs_search() {\n int start_tile_id = tile_ids[si][sj];\n unordered_set visited;\n visited.insert(start_tile_id);\n \n string best_path = \"\";\n int best_score = values[si][sj];\n \n // Try different depth limits\n for (int max_depth = 1; max_depth <= 100 && get_elapsed_time() < time_limit; max_depth++) {\n string current_path = \"\";\n int current_score = values[si][sj];\n int current_i = si, current_j = sj;\n \n dfs_recursive(current_i, current_j, visited, current_path, current_score, \n 0, max_depth, best_path, best_score);\n \n // If we found a complete path or time is running out, break\n if (get_elapsed_time() > time_limit * 0.8) break;\n }\n \n return best_path;\n }\n \n void dfs_recursive(int i, int j, unordered_set& visited, string& current_path,\n int current_score, int depth, int max_depth,\n string& best_path, int& best_score) {\n if (get_elapsed_time() > time_limit) return;\n if (depth >= max_depth) return;\n \n // Try all four directions\n vector> next_moves;\n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n if (visited.find(next_tile_id) == visited.end()) {\n next_moves.push_back({ni, nj});\n }\n }\n }\n \n // Sort moves by tile value (greedy heuristic)\n sort(next_moves.begin(), next_moves.end(), [this](const pair& a, const pair& b) {\n int tile_a = tile_ids[a.first][a.second];\n int tile_b = tile_ids[b.first][b.second];\n return tiles[tile_a].total_value > tiles[tile_b].total_value;\n });\n \n // Limit branches to avoid exponential explosion\n size_t max_branches = min(static_cast(3), next_moves.size());\n if (depth > 10) max_branches = min(static_cast(2), max_branches);\n if (depth > 20) max_branches = min(static_cast(1), max_branches);\n \n for (size_t idx = 0; idx < max_branches && idx < next_moves.size(); idx++) {\n int ni = next_moves[idx].first;\n int nj = next_moves[idx].second;\n int next_tile_id = tile_ids[ni][nj];\n \n // Skip if already visited\n if (visited.find(next_tile_id) != visited.end()) continue;\n \n // Calculate additional score from this tile\n int additional_score = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n if (square.first == ni && square.second == nj) {\n additional_score += values[ni][nj];\n } else {\n additional_score += values[square.first][square.second];\n }\n }\n \n // Make move\n visited.insert(next_tile_id);\n current_path.push_back(dir_chars[get_direction(i, j, ni, nj)]);\n \n int new_score = current_score + additional_score;\n if (new_score > best_score) {\n best_score = new_score;\n best_path = current_path;\n }\n \n // Recurse\n dfs_recursive(ni, nj, visited, current_path, new_score, depth + 1, \n max_depth, best_path, best_score);\n \n // Backtrack\n current_path.pop_back();\n visited.erase(next_tile_id);\n }\n }\n \n int get_direction(int i, int j, int ni, int nj) {\n if (ni == i - 1) return 0; // U\n if (ni == i + 1) return 1; // D\n if (nj == j - 1) return 2; // L\n if (nj == j + 1) return 3; // R\n return -1; // Should never happen\n }\n \n // Greedy algorithm as fallback or for comparison\n string greedy_search() {\n string path = \"\";\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n // Removed unused variable current_score\n \n while (get_elapsed_time() < time_limit) {\n vector>> candidates; // {score, {next_i, next_j}}\n \n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n // Calculate score for this tile\n int tile_score = 0;\n for (auto& square : tiles[tile_id].squares) {\n tile_score += values[square.first][square.second];\n }\n candidates.push_back({tile_score, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) break;\n \n // Sort by score descending\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Pick the best candidate (with some randomness for exploration)\n int choice = 0;\n if (candidates.size() > 1 && get_elapsed_time() < time_limit * 0.5) {\n // Allow some randomness in early stages\n random_device rd;\n mt19937 gen(rd());\n uniform_real_distribution dis(0.0, 1.0);\n if (dis(gen) < 0.3) {\n choice = min(1, (int)candidates.size() - 1);\n }\n }\n \n int ni = candidates[choice].second.first;\n int nj = candidates[choice].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n path.push_back(dir_chars[dir]);\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n return path;\n }\n\npublic:\n void solve() {\n start_time = high_resolution_clock::now();\n \n // Read input\n cin >> si >> sj;\n \n tile_ids = vector>(n, vector(n));\n values = vector>(n, vector(n));\n \n // Read tile IDs\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> tile_ids[i][j];\n }\n }\n \n // Read values\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> values[i][j];\n }\n }\n \n // Build tile data structure\n unordered_map tile_map;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int id = tile_ids[i][j];\n if (tile_map.find(id) == tile_map.end()) {\n tile_map[id] = Tile{{}, 0, id};\n }\n tile_map[id].squares.push_back({i, j});\n tile_map[id].total_value += values[i][j];\n }\n }\n \n // Convert to vector for easier access\n for (auto& kv : tile_map) {\n tiles.push_back(kv.second);\n }\n \n // Try different strategies based on time remaining\n string result = \"\";\n \n // First, try DFS approach\n if (get_elapsed_time() < time_limit * 0.7) {\n result = dfs_search();\n }\n \n // If DFS didn't produce good results or time is running out, try greedy\n if (result.empty() || get_elapsed_time() < time_limit) {\n string greedy_result = greedy_search();\n if (greedy_result.length() > result.length() || \n (greedy_result.length() == result.length() && calculate_score(greedy_result) > calculate_score(result))) {\n result = greedy_result;\n }\n }\n \n // Output result\n cout << result << endl;\n }\n \n // Helper function to calculate score of a path (for comparison)\n int calculate_score(const string& path) {\n if (path.empty()) return values[si][sj];\n \n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n int total_score = values[si][sj];\n \n for (char c : path) {\n int d = (c == 'U') ? 0 : (c == 'D') ? 1 : (c == 'L') ? 2 : 3;\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n for (auto& square : tiles[tile_id].squares) {\n total_score += values[square.first][square.second];\n }\n visited.insert(tile_id);\n }\n \n current_i = ni;\n current_j = nj;\n }\n \n return total_score;\n }\n};\n\nint main() {\n Solution solver;\n solver.solve();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int INF = 1e9;\n\n// Direction arrays for Dijkstra\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Estimated edge weights\nvector> h_est(GRID_SIZE, vector(GRID_SIZE - 1, 5000.0)); // horizontal edges\nvector> v_est(GRID_SIZE - 1, vector(GRID_SIZE, 5000.0)); // vertical edges\n\n// Count of observations for each edge (for averaging)\nvector> h_count(GRID_SIZE, vector(GRID_SIZE - 1, 0));\nvector> v_count(GRID_SIZE - 1, vector(GRID_SIZE, 0));\n\n// For Dijkstra\nstruct Node {\n int x, y, cost;\n string path;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n\n// Check if coordinates are valid\nbool isValid(int x, int y) {\n return x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE;\n}\n\n// Dijkstra's algorithm to find shortest path based on current estimates\nstring dijkstra(int sx, int sy, int tx, int ty) {\n // Priority queue for Dijkstra\n priority_queue, greater> pq;\n vector> dist(GRID_SIZE, vector(GRID_SIZE, INF));\n vector> path(GRID_SIZE, vector(GRID_SIZE, \"\"));\n vector> visited(GRID_SIZE, vector(GRID_SIZE, false));\n \n pq.push({sx, sy, 0, \"\"});\n dist[sx][sy] = 0;\n \n while (!pq.empty()) {\n Node curr = pq.top();\n pq.pop();\n \n int x = curr.x;\n int y = curr.y;\n int cost = curr.cost;\n string currPath = curr.path;\n \n if (visited[x][y]) continue;\n visited[x][y] = true;\n \n // If we reached the target\n if (x == tx && y == ty) {\n return currPath;\n }\n \n // Try all four directions\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n \n if (!isValid(nx, ny)) continue;\n \n int edgeCost = 0;\n // Calculate edge cost based on direction\n if (i == 0 && x > 0) { // Up\n edgeCost = (int)v_est[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) { // Down\n edgeCost = (int)v_est[x][y];\n } else if (i == 2 && y > 0) { // Left\n edgeCost = (int)h_est[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) { // Right\n edgeCost = (int)h_est[x][y];\n } else {\n continue; // Invalid move\n }\n \n if (dist[nx][ny] > cost + edgeCost) {\n dist[nx][ny] = cost + edgeCost;\n pq.push({nx, ny, cost + edgeCost, currPath + dirChar[i]});\n }\n }\n }\n \n // If no path found (shouldn't happen in grid), return a simple path\n string fallback = \"\";\n int cx = sx, cy = sy;\n while (cx != tx) {\n if (cx < tx) {\n fallback += 'D';\n cx++;\n } else {\n fallback += 'U';\n cx--;\n }\n }\n while (cy != ty) {\n if (cy < ty) {\n fallback += 'R';\n cy++;\n } else {\n fallback += 'L';\n cy--;\n }\n }\n return fallback;\n}\n\n// Update edge weight estimates based on the feedback\nvoid updateEstimates(const string& path, int sx, int sy, int actual_cost) {\n // Calculate the expected cost based on current estimates\n int x = sx, y = sy;\n int expected_cost = 0;\n vector> edges_used; // Store edges used in this path\n vector edge_types; // 0: horizontal, 1: vertical\n vector> edge_coords; // Coordinates of edges\n \n for (char dir : path) {\n int nx = x, ny = y;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n \n // Calculate expected cost for this edge\n if (dir == 'U') {\n expected_cost += (int)v_est[x-1][y];\n edges_used.push_back({x-1, y});\n edge_types.push_back(1); // vertical\n edge_coords.push_back({x-1, y});\n } else if (dir == 'D') {\n expected_cost += (int)v_est[x][y];\n edges_used.push_back({x, y});\n edge_types.push_back(1); // vertical\n edge_coords.push_back({x, y});\n } else if (dir == 'L') {\n expected_cost += (int)h_est[x][y-1];\n edges_used.push_back({x, y-1});\n edge_types.push_back(0); // horizontal\n edge_coords.push_back({x, y-1});\n } else if (dir == 'R') {\n expected_cost += (int)h_est[x][y];\n edges_used.push_back({x, y});\n edge_types.push_back(0); // horizontal\n edge_coords.push_back({x, y});\n }\n \n x = nx;\n y = ny;\n }\n \n // Update estimates - distribute the error across all edges in the path\n int path_length = path.length();\n if (path_length > 0) {\n double error = actual_cost - expected_cost;\n double error_per_edge = error / path_length;\n \n for (int i = 0; i < edges_used.size(); i++) {\n int coord1 = edge_coords[i].first;\n int coord2 = edge_coords[i].second;\n \n if (edge_types[i] == 0) { // horizontal edge\n if (h_count[coord1][coord2] == 0) {\n h_est[coord1][coord2] += error_per_edge;\n } else {\n // Weighted average based on number of observations\n h_est[coord1][coord2] = (h_est[coord1][coord2] * h_count[coord1][coord2] + actual_cost * 1.0 / path_length) / (h_count[coord1][coord2] + 1);\n }\n h_count[coord1][coord2]++;\n } else { // vertical edge\n if (v_count[coord1][coord2] == 0) {\n v_est[coord1][coord2] += error_per_edge;\n } else {\n // Weighted average based on number of observations\n v_est[coord1][coord2] = (v_est[coord1][coord2] * v_count[coord1][coord2] + actual_cost * 1.0 / path_length) / (v_count[coord1][coord2] + 1);\n }\n v_count[coord1][coord2]++;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int prev_result = 0;\n \n for (int k = 0; k < 1000; k++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n \n // Find path using current estimates\n string path = dijkstra(si, sj, ti, tj);\n \n // Output path\n cout << path << endl;\n cout.flush(); // Important: flush output\n \n // Read the result\n int result;\n cin >> result;\n \n // Update estimates based on feedback\n updateEstimates(path, si, sj, result);\n \n // Update prev_result for next iteration\n prev_result = result;\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20; // Fixed to 20 as per problem\nconst char CHARS[8] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};\n\nclass MatrixSolver {\nprivate:\n int M;\n vector strings;\n vector matrix;\n vector matched;\n mt19937 rng;\n \npublic:\n MatrixSolver(int m, const vector& s) : M(m), strings(s), rng(random_device{}()) {\n // Initialize matrix with most frequent characters\n matrix.resize(N, string(N, '.'));\n matched.resize(M, false);\n \n // Frequency analysis for initialization\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n // Fill matrix with most frequent character initially\n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = mostFreqChar;\n }\n }\n }\n \n // Check if string s matches at position (i,j) horizontally\n bool matchesHorizontal(const string& s, int i, int j) const {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n \n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n if (matrix[i][col] != s[p] && matrix[i][col] != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if string s matches at position (i,j) vertically\n bool matchesVertical(const string& s, int i, int j) const {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n \n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n if (matrix[row][j] != s[p] && matrix[row][j] != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if a string matches anywhere in the matrix\n bool matches(const string& s) const {\n if (s.empty()) return true;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matchesHorizontal(s, i, j) || matchesVertical(s, i, j)) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Count how many strings are matched\n int countMatches() {\n int count = 0;\n for (int i = 0; i < M; i++) {\n if (i < static_cast(strings.size()) && matches(strings[i])) {\n matched[i] = true;\n count++;\n } else {\n matched[i] = false;\n }\n }\n return count;\n }\n \n // Get score based on problem definition\n long long getScore(int c, int d) {\n if (c < M) {\n return static_cast(round(100000000.0 * static_cast(c) / static_cast(M)));\n } else {\n double denominator = 2.0 * N * N - static_cast(d);\n if (denominator <= 0) denominator = 1.0; // Avoid division by zero\n return static_cast(round(100000000.0 * 2.0 * N * N / denominator));\n }\n }\n \n // Count number of '.' in matrix\n int countDots() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == '.') {\n count++;\n }\n }\n }\n return count;\n }\n \n // Try to improve matrix by changing one cell\n bool improve() {\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n bool improved = false;\n \n // Add some randomness to avoid getting stuck\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Try changing each cell to each possible character\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n if (i < 0 || i >= N || j < 0 || j >= N) continue;\n \n char original = matrix[i][j];\n \n // Create a vector of characters to try\n vector tryChars(CHARS, CHARS + 8);\n tryChars.push_back('.'); // Also try '.'\n \n // Shuffle to add randomness\n shuffle(tryChars.begin(), tryChars.end(), rng);\n \n for (char c : tryChars) {\n if (c == original) continue;\n \n matrix[i][j] = c;\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) {\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n // Keep this change and continue improving\n } else {\n // Revert if not better\n matrix[i][j] = original;\n }\n }\n }\n \n return improved;\n }\n \n // Simplified approach to fix unmatched strings\n void fixUnmatchedSimple() {\n vector unmatchedIndices;\n for (int i = 0; i < M; i++) {\n if (!matched[i]) {\n unmatchedIndices.push_back(i);\n }\n }\n \n if (unmatchedIndices.empty()) return;\n \n // Shuffle unmatched indices for randomness\n shuffle(unmatchedIndices.begin(), unmatchedIndices.end(), rng);\n \n // Try to fix a few unmatched strings\n int limit = min(50, static_cast(unmatchedIndices.size()));\n for (int idx = 0; idx < limit; idx++) {\n int strIdx = unmatchedIndices[idx];\n const string& s = strings[strIdx];\n \n if (s.empty()) continue;\n \n // Try to find a position to place this string\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n bool placed = false;\n \n // Try horizontal placement\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n if (matrix[i][col] != '.' && matrix[i][col] != s[p]) {\n canPlace = false;\n break;\n }\n }\n \n if (canPlace) {\n // Place the string\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n matrix[i][col] = s[p];\n }\n placed = true;\n break;\n }\n }\n \n if (placed) continue;\n \n // Try vertical placement\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n if (matrix[row][j] != '.' && matrix[row][j] != s[p]) {\n canPlace = false;\n break;\n }\n }\n \n if (canPlace) {\n // Place the string\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n matrix[row][j] = s[p];\n }\n placed = true;\n break;\n }\n }\n }\n }\n \n // Main solve method\n void solve() {\n try {\n // Initial evaluation\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n // Time tracking for optimization within time limit\n auto startTime = chrono::steady_clock::now();\n \n // First, try to match as many strings as possible with simple approach\n fixUnmatchedSimple();\n \n // Local search with time limit\n int iteration = 0;\n const int maxIterations = 50;\n \n while (iteration < maxIterations) {\n bool improved = improve();\n iteration++;\n \n // Check time limit (leave some margin)\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2500) break;\n \n // If no improvement, try fixing unmatched strings\n if (!improved && iteration % 10 == 0) {\n fixUnmatchedSimple();\n }\n }\n \n // Final check\n countMatches();\n \n } catch (...) {\n // In case of any exception, fall back to a simple solution\n // Fill matrix with most frequent character\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = mostFreqChar;\n }\n }\n }\n }\n \n // Output the matrix\n void output() const {\n for (int i = 0; i < N; i++) {\n // Ensure each row has exactly N characters\n if (i < static_cast(matrix.size()) && matrix[i].size() == N) {\n cout << matrix[i] << endl;\n } else {\n // Fallback: output row of most common character\n cout << string(N, 'A') << endl;\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n try {\n MatrixSolver solver(M, strings);\n solver.solve();\n solver.output();\n } catch (...) {\n // Fallback solution if everything fails\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n cout << string(N, mostFreqChar) << endl;\n }\n }\n \n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_chars[4] = {'U', 'D', 'L', 'R'};\n\nint N, si, sj;\nvector grid;\nvector> move_cost;\n\n// Check if position is within bounds\ninline bool in_bounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// Check if a position is visible from another\ninline bool is_visible(int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Same row\n int start = min(y1, y2);\n int end = max(y1, y2);\n for (int j = start; j <= end; j++) {\n if (grid[x1][j] == '#') return false;\n }\n return true;\n } else if (y1 == y2) {\n // Same column\n int start = min(x1, x2);\n int end = max(x1, x2);\n for (int i = start; i <= end; i++) {\n if (grid[i][y1] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\n// Find path from (start_x, start_y) to (end_x, end_y) using BFS\nstring find_path(int start_x, int start_y, int end_x, int end_y) {\n if (start_x == end_x && start_y == end_y) return \"\";\n \n queue, string>> q;\n vector> visited(N, vector(N, false));\n \n q.push({{start_x, start_y}, \"\"});\n visited[start_x][start_y] = true;\n \n while (!q.empty()) {\n auto current = q.front();\n q.pop();\n \n int x = current.first.first;\n int y = current.first.second;\n string path = current.second;\n \n if (x == end_x && y == end_y) {\n return path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#' || visited[nx][ny]) continue;\n \n visited[nx][ny] = true;\n q.push({{nx, ny}, path + dir_chars[d]});\n }\n }\n \n // If BFS failed, use simple greedy approach\n string fallback = \"\";\n int x = start_x, y = start_y;\n \n while (x != end_x || y != end_y) {\n int best_d = -1;\n int best_dist = abs(x - end_x) + abs(y - end_y);\n \n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#') continue;\n \n int new_dist = abs(nx - end_x) + abs(ny - end_y);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_d = d;\n }\n }\n \n if (best_d == -1) {\n // Pick any valid move\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#') continue;\n \n best_d = d;\n break;\n }\n \n if (best_d == -1) break; // No valid moves\n }\n \n x += dx[best_d];\n y += dy[best_d];\n fallback += dir_chars[best_d];\n }\n \n return fallback;\n}\n\n// Coverage-based route finding\nstring find_route() {\n vector> covered(N, vector(N, false));\n string route = \"\";\n int cur_x = si, cur_y = sj;\n \n // Mark squares visible from start\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && is_visible(si, sj, i, j)) {\n covered[i][j] = true;\n }\n }\n }\n \n // Count road squares and covered squares\n auto count_road_squares = [&]() {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') count++;\n }\n }\n return count;\n };\n \n auto count_covered = [&]() {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (covered[i][j]) count++;\n }\n }\n return count;\n };\n \n auto update_coverage = [&](int x, int y) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && !covered[i][j] && is_visible(x, y, i, j)) {\n covered[i][j] = true;\n }\n }\n }\n };\n \n int total_roads = count_road_squares();\n int covered_count = count_covered();\n \n if (covered_count >= total_roads) {\n return route; // Already covered everything\n }\n \n // Strategy: Systematically cover rows and columns\n vector> key_positions;\n \n // Add positions that can cover entire rows/columns\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n key_positions.push_back({i, j});\n }\n }\n }\n \n // Sort key positions by potential coverage (descending)\n sort(key_positions.begin(), key_positions.end(), [&](const pair& a, const pair& b) {\n int cover_a = 0, cover_b = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && !covered[i][j]) {\n if (is_visible(a.first, a.second, i, j)) cover_a++;\n if (is_visible(b.first, b.second, i, j)) cover_b++;\n }\n }\n }\n return cover_a > cover_b;\n });\n \n // Visit key positions in order of potential coverage\n const int MAX_POSITIONS = min(50, (int)key_positions.size());\n for (int idx = 0; idx < MAX_POSITIONS && covered_count < total_roads; idx++) {\n int target_x = key_positions[idx].first;\n int target_y = key_positions[idx].second;\n \n // Skip if already at this position\n if (cur_x == target_x && cur_y == target_y) {\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n continue;\n }\n \n // Find path to target\n string path_to_target = find_path(cur_x, cur_y, target_x, target_y);\n if (path_to_target.empty()) continue;\n \n route += path_to_target;\n cur_x = target_x;\n cur_y = target_y;\n \n // Update coverage\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n \n // Early termination\n if (covered_count >= total_roads) break;\n }\n \n // If still not covered everything, try additional positions\n if (covered_count < total_roads) {\n for (int i = 0; i < N && covered_count < total_roads; i++) {\n for (int j = 0; j < N && covered_count < total_roads; j++) {\n if (grid[i][j] != '#' && !covered[i][j]) {\n // Find path to this uncovered position\n string path_to_target = find_path(cur_x, cur_y, i, j);\n if (path_to_target.empty()) continue;\n \n route += path_to_target;\n cur_x = i;\n cur_y = j;\n \n // Update coverage\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n }\n }\n }\n }\n \n // Return to start\n string return_path = find_path(cur_x, cur_y, si, sj);\n route += return_path;\n \n return route;\n}\n\n// Aggressive optimization: remove immediate backtracking and simple loops\nstring optimize_route(const string& route) {\n if (route.empty()) return route;\n \n string optimized = route;\n bool changed = true;\n \n // Multiple passes to remove backtracking\n while (changed) {\n changed = false;\n string new_optimized = \"\";\n \n for (size_t i = 0; i < optimized.size(); i++) {\n if (new_optimized.empty()) {\n new_optimized += optimized[i];\n continue;\n }\n \n char last = new_optimized.back();\n char current = optimized[i];\n bool cancel = false;\n \n // Check for immediate backtracking\n if ((current == 'U' && last == 'D') || (current == 'D' && last == 'U') ||\n (current == 'L' && last == 'R') || (current == 'R' && last == 'L')) {\n new_optimized.pop_back();\n cancel = true;\n changed = true;\n }\n \n if (!cancel) {\n new_optimized += current;\n }\n }\n \n optimized = new_optimized;\n }\n \n return optimized;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Read input\n cin >> N >> si >> sj;\n grid.resize(N);\n move_cost.resize(N, vector(N, 0));\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n move_cost[i][j] = grid[i][j] - '0';\n }\n }\n }\n \n // Find route\n string route = find_route();\n \n // Optimize route\n route = optimize_route(route);\n \n // Output the route\n cout << route << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, K, R;\nvector> task_difficulty; // d[i][k] for task i, skill k\nvector> dependencies; // dependencies[i] = list of tasks that must be completed before task i\nvector> reverse_dependencies; // reverse_dependencies[i] = list of tasks that depend on task i\n\n// State tracking\nvector task_status; // -1: not started, 0: in progress, 1: completed\nvector member_assignment; // -1: idle, task_id: working on task\nvector member_busy_until; // day when member becomes available\n\n// Skill estimation\nvector> skill_lower_bound; // Lower bound for s[j][k]\nvector> skill_upper_bound; // Upper bound for s[j][k]\nvector> skill_exact; // Whether we know exact skill level\n\n// Random generator\nmt19937 rng;\n\n// Calculate w[i][j] = sum_k max(0, d[i][k] - s[j][k])\nint calculate_w(int task_id, int member_id) {\n int w = 0;\n for (int k = 0; k < K; k++) {\n int diff = task_difficulty[task_id][k] - skill_lower_bound[member_id][k];\n if (diff > 0) {\n w += diff;\n }\n }\n return w;\n}\n\n// Estimate completion time for task i by member j\nint estimate_completion_time(int task_id, int member_id) {\n int w = calculate_w(task_id, member_id);\n if (w == 0) {\n return 1;\n }\n // Since r_i is between -3 and 3, assume average case (0) for estimation\n return max(1, w);\n}\n\n// Check if task can be started (all dependencies completed)\nbool can_start_task(int task_id) {\n for (int dep : dependencies[task_id]) {\n if (task_status[dep] != 1) {\n return false;\n }\n }\n return true;\n}\n\n// Calculate criticality score for a task (how many tasks depend on it, directly or indirectly)\nint calculate_criticality(int task_id) {\n queue q;\n vector visited(N, false);\n int count = 0;\n \n q.push(task_id);\n visited[task_id] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v : reverse_dependencies[u]) {\n if (!visited[v]) {\n visited[v] = true;\n count++;\n q.push(v);\n }\n }\n }\n \n return count;\n}\n\n// Update skill estimates based on actual completion time\nvoid update_skill_estimates(int task_id, int member_id, int completion_time, int start_day, int end_day) {\n int actual_days = end_day - start_day + 1;\n \n if (actual_days == 1) {\n // w[i][j] = 0, so s[j][k] >= d[i][k] for all k\n for (int k = 0; k < K; k++) {\n skill_lower_bound[member_id][k] = max(skill_lower_bound[member_id][k], task_difficulty[task_id][k]);\n skill_exact[member_id][k] = true; // We know exact minimum\n }\n } else {\n // w[i][j] + r_i = actual_days, so w[i][j] = actual_days - r_i\n // Since r_i is between -3 and 3, w[i][j] is between actual_days-3 and actual_days+3\n // Use actual_days as estimate for w[i][j]\n int estimated_w = actual_days;\n \n // We know sum_k max(0, d[i][k] - s[j][k]) = estimated_w\n // This gives us constraints on s[j][k]\n // For simplicity, distribute the \"deficit\" proportionally\n int current_w = 0;\n vector deficits(K);\n for (int k = 0; k < K; k++) {\n int deficit = max(0, task_difficulty[task_id][k] - skill_lower_bound[member_id][k]);\n deficits[k] = deficit;\n current_w += deficit;\n }\n \n if (current_w < estimated_w) {\n // Our lower bounds are too high, adjust them down\n // This shouldn't happen normally, but can occur due to randomness\n // In this case, we don't update (or could decrease lower bounds)\n } else if (current_w > estimated_w) {\n // Our lower bounds are too low, we need to increase some of them\n // Increase skill estimates for skills with deficits\n int excess = current_w - estimated_w;\n \n // Simple approach: increase lower bounds for skills with deficits\n // Prioritize skills with larger deficits\n vector> deficit_skills;\n for (int k = 0; k < K; k++) {\n if (deficits[k] > 0) {\n deficit_skills.push_back({deficits[k], k});\n }\n }\n \n sort(deficit_skills.rbegin(), deficit_skills.rend());\n \n for (auto& p : deficit_skills) {\n int k = p.second;\n int reduce_by = min(deficits[k], excess);\n if (reduce_by > 0) {\n // This means we overestimated the deficit, so our skill lower bound was too low\n // We can't directly infer the correct skill level, so we'll just note that\n // our estimate was wrong and adjust conservatively\n excess -= reduce_by;\n }\n if (excess == 0) break;\n }\n }\n // If current_w == estimated_w, our estimates are consistent\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Initialize random generator\n rng.seed(12345);\n \n // Parse input\n cin >> N >> M >> K >> R;\n \n task_difficulty.resize(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> task_difficulty[i][k];\n }\n }\n \n dependencies.resize(N);\n reverse_dependencies.resize(N);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--; // Convert to 0-indexed\n dependencies[v].push_back(u);\n reverse_dependencies[u].push_back(v);\n }\n \n // Initialize state\n task_status.assign(N, -1); // -1: not started\n member_assignment.assign(M, -1); // -1: not assigned\n member_busy_until.assign(M, 0);\n \n // Initialize skill estimates\n skill_lower_bound.assign(M, vector(K, 0));\n skill_upper_bound.assign(M, vector(K, INT_MAX));\n skill_exact.assign(M, vector(K, false));\n \n int day = 0;\n vector start_day_of_task(N, -1);\n \n while (true) {\n day++;\n \n // Check if day limit exceeded\n if (day > 2000) {\n break;\n }\n \n // Process completions from previous day\n int n_completed;\n cin >> n_completed;\n \n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n \n vector completed_members(n_completed);\n for (int i = 0; i < n_completed; i++) {\n cin >> completed_members[i];\n completed_members[i]--; // Convert to 0-indexed\n }\n \n // Update task and member status for completed tasks\n for (int member_id : completed_members) {\n int task_id = member_assignment[member_id];\n if (task_id != -1) {\n task_status[task_id] = 1; // Mark as completed\n // Update skill estimates based on completion time\n update_skill_estimates(task_id, member_id, day - start_day_of_task[task_id], start_day_of_task[task_id], day);\n member_assignment[member_id] = -1;\n member_busy_until[member_id] = day;\n }\n }\n \n // Find available team members\n vector available_members;\n for (int j = 0; j < M; j++) {\n if (member_assignment[j] == -1 && member_busy_until[j] < day) {\n available_members.push_back(j);\n }\n }\n \n // Find ready tasks (dependencies satisfied and not started/completed)\n vector ready_tasks;\n for (int i = 0; i < N; i++) {\n if (task_status[i] == -1 && can_start_task(i)) {\n ready_tasks.push_back(i);\n }\n }\n \n // Create assignment output\n vector> assignments; // (member_id, task_id)\n \n if (!available_members.empty() && !ready_tasks.empty()) {\n // Simple greedy assignment: assign tasks to minimize estimated completion time\n // Could use Hungarian algorithm for optimal assignment, but greedy should work well\n \n // Shuffle ready tasks for some randomness (helps exploration)\n shuffle(ready_tasks.begin(), ready_tasks.end(), rng);\n \n // Sort available members by some criterion (e.g., average skill level)\n // For now, just use as is\n \n // Greedy assignment\n vector task_assigned(ready_tasks.size(), false);\n \n for (int member_idx = 0; member_idx < available_members.size(); member_idx++) {\n int member_id = available_members[member_idx];\n \n // Find best task for this member\n int best_task_idx = -1;\n int min_estimated_time = INT_MAX;\n \n for (int task_idx = 0; task_idx < ready_tasks.size(); task_idx++) {\n if (task_assigned[task_idx]) continue;\n \n int task_id = ready_tasks[task_idx];\n int est_time = estimate_completion_time(task_id, member_id);\n \n // Consider task criticality (tasks that unblock more tasks)\n int criticality = calculate_criticality(task_id);\n // Adjust estimated time by criticality (lower priority for critical tasks)\n int adjusted_time = est_time - criticality / 10; // Simple weighting\n \n if (adjusted_time < min_estimated_time) {\n min_estimated_time = adjusted_time;\n best_task_idx = task_idx;\n }\n }\n \n if (best_task_idx != -1) {\n int task_id = ready_tasks[best_task_idx];\n assignments.push_back({member_id, task_id});\n task_assigned[best_task_idx] = true;\n task_status[task_id] = 0; // Mark as in progress\n member_assignment[member_id] = task_id;\n start_day_of_task[task_id] = day;\n }\n }\n }\n \n // Output assignments\n cout << assignments.size();\n for (auto& assignment : assignments) {\n cout << \" \" << assignment.first + 1 << \" \" << assignment.second + 1;\n }\n cout << endl;\n cout.flush(); // Important: flush output\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#include \n\nusing namespace std;\n\nstruct Order {\n int id;\n int pickup_x, pickup_y;\n int delivery_x, delivery_y;\n \n // Calculate Manhattan distance for this order\n int direct_distance() const {\n return abs(pickup_x - delivery_x) + abs(pickup_y - delivery_y);\n }\n \n // Distance from center to pickup and delivery\n int center_distance() const {\n return abs(pickup_x - 400) + abs(pickup_y - 400) + \n abs(delivery_x - 400) + abs(delivery_y - 400);\n }\n \n // \"Efficiency\" metric for order selection\n double efficiency_score() const {\n // Higher score = more efficient to deliver\n // We want orders that are closer to center and have shorter direct distances\n return 1.0 / (center_distance() + direct_distance());\n }\n};\n\n// Calculate Manhattan distance between two points\nint manhattan_distance(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nclass RouteOptimizer {\nprivate:\n vector orders;\n vector selected_orders;\n vector> route;\n vector pickup_done;\n vector delivery_done;\n \n // Track which order each location belongs to\n unordered_map location_to_order;\n \n // For precedence constraint checking\n vector pickup_index;\n vector delivery_index;\n \npublic:\n RouteOptimizer(const vector& all_orders) : orders(all_orders) {\n // Initialize data structures\n pickup_done.resize(50, false);\n delivery_done.resize(50, false);\n pickup_index.resize(50, -1);\n delivery_index.resize(50, -1);\n }\n \n // Select 50 orders based on efficiency\n void select_orders() {\n // Create indexed list for sorting\n vector> scores;\n for (int i = 0; i < 1000; i++) {\n scores.push_back({orders[i].efficiency_score(), i});\n }\n \n // Sort by efficiency (descending)\n sort(scores.begin(), scores.end(), [](const auto& a, const auto& b) {\n return a.first > b.first;\n });\n \n // Select top 50\n selected_orders.clear();\n for (int i = 0; i < 50; i++) {\n selected_orders.push_back(scores[i].second);\n }\n }\n \n // Construct initial route using greedy nearest neighbor\n void construct_initial_route() {\n route.clear();\n route.push_back({400, 400}); // Start at center\n \n // Reset tracking\n fill(pickup_done.begin(), pickup_done.end(), false);\n fill(delivery_done.begin(), delivery_done.end(), false);\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Build route step by step\n int current_x = 400, current_y = 400;\n int steps = 0;\n \n // Continue until all deliveries are done\n while (true) {\n // Find all possible next locations\n vector> candidates; // distance, order_idx, location_type (0=pickup, 1=delivery), actual location index\n \n for (int i = 0; i < 50; i++) {\n if (!pickup_done[i]) {\n // Can pick up this order\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].pickup_x, orders[selected_orders[i]].pickup_y);\n candidates.push_back({dist, i, 0, 2*i});\n } else if (!delivery_done[i]) {\n // Can deliver this order (pickup already done)\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].delivery_x, orders[selected_orders[i]].delivery_y);\n candidates.push_back({dist, i, 1, 2*i+1});\n }\n }\n \n if (candidates.empty()) {\n break; // All done\n }\n \n // Choose the nearest candidate\n sort(candidates.begin(), candidates.end());\n auto [dist, order_idx, loc_type, loc_idx] = candidates[0];\n \n if (loc_type == 0) {\n // Pick up\n pickup_done[order_idx] = true;\n pickup_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].pickup_x;\n current_y = orders[selected_orders[order_idx]].pickup_y;\n route.push_back({current_x, current_y});\n } else {\n // Deliver\n delivery_done[order_idx] = true;\n delivery_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].delivery_x;\n current_y = orders[selected_orders[order_idx]].delivery_y;\n route.push_back({current_x, current_y});\n }\n \n steps++;\n }\n \n // Return to center\n route.push_back({400, 400});\n }\n \n // 2-opt local search to improve route\n void optimize_route_2opt() {\n bool improved = true;\n while (improved) {\n improved = false;\n \n // Try all possible 2-opt swaps\n for (int i = 1; i < (int)route.size() - 2; i++) {\n for (int j = i + 1; j < (int)route.size() - 1; j++) {\n // Check if swap would violate any precedence constraints\n if (is_valid_2opt(i, j)) {\n // Calculate potential improvement\n int current_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[i].first, route[i].second) +\n manhattan_distance(route[j].first, route[j].second, route[j+1].first, route[j+1].second);\n int new_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[j].first, route[j].second) +\n manhattan_distance(route[i].first, route[i].second, route[j+1].first, route[j+1].second);\n \n if (new_cost < current_cost) {\n // Perform the swap\n reverse(route.begin() + i, route.begin() + j + 1);\n improved = true;\n \n // Update pickup/delivery indices\n update_indices();\n \n // Early break to restart search\n break;\n }\n }\n }\n if (improved) break;\n }\n }\n }\n \n // Check if 2-opt swap would violate precedence constraints\n bool is_valid_2opt(int i, int j) {\n // Create a copy of current state\n vector new_pickup_index = pickup_index;\n vector new_delivery_index = delivery_index;\n \n // Simulate the reversal and update indices\n for (int k = i; k <= j; k++) {\n int new_pos = i + (j - k);\n // Check which order this position belongs to\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (pickup_index[order_idx] == k) {\n new_pickup_index[order_idx] = new_pos;\n }\n if (delivery_index[order_idx] == k) {\n new_delivery_index[order_idx] = new_pos;\n }\n }\n }\n \n // Check all precedence constraints\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (new_pickup_index[order_idx] > new_delivery_index[order_idx]) {\n return false; // Violates pickup before delivery\n }\n }\n \n return true;\n }\n \n // Update indices after route modification\n void update_indices() {\n // Reset indices\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Rebuild indices by scanning the route\n for (int pos = 0; pos < (int)route.size(); pos++) {\n for (int i = 0; i < 50; i++) {\n // Check if this position is a pickup for order i\n if (route[pos].first == orders[selected_orders[i]].pickup_x && \n route[pos].second == orders[selected_orders[i]].pickup_y) {\n // Make sure we haven't already recorded this pickup\n if (pickup_index[i] == -1 || \n (pickup_index[i] != -1 && delivery_index[i] != -1)) {\n pickup_index[i] = pos;\n }\n }\n // Check if this position is a delivery for order i\n if (route[pos].first == orders[selected_orders[i]].delivery_x && \n route[pos].second == orders[selected_orders[i]].delivery_y) {\n delivery_index[i] = pos;\n }\n }\n }\n }\n \n // Calculate total route distance\n int calculate_total_distance() {\n int total = 0;\n for (int i = 0; i < (int)route.size() - 1; i++) {\n total += manhattan_distance(route[i].first, route[i].second, \n route[i+1].first, route[i+1].second);\n }\n return total;\n }\n \n // Main optimization method\n void optimize() {\n select_orders();\n construct_initial_route();\n optimize_route_2opt();\n }\n \n // Output the solution\n void output_solution() {\n // Output selected orders (1-indexed)\n cout << \"50\";\n for (int i = 0; i < 50; i++) {\n cout << \" \" << selected_orders[i] + 1; // Convert to 1-indexed\n }\n cout << endl;\n \n // Output route\n cout << route.size();\n for (int i = 0; i < (int)route.size(); i++) {\n cout << \" \" << route[i].first << \" \" << route[i].second;\n }\n cout << endl;\n }\n};\n\nint main() {\n // Read input\n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].pickup_x >> orders[i].pickup_y >> \n orders[i].delivery_x >> orders[i].delivery_y;\n orders[i].id = i;\n }\n \n // Create optimizer and run\n RouteOptimizer optimizer(orders);\n optimizer.optimize();\n optimizer.output_solution();\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Union-Find data structure\nstruct UnionFind {\n vector parent, rank, size;\n int components;\n \n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n size.resize(n, 1);\n components = n;\n for (int i = 0; i < n; i++) {\n parent[i] = i;\n }\n }\n \n int find(int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n }\n \n bool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n \n if (rank[x] < rank[y]) {\n swap(x, y);\n }\n parent[y] = x;\n size[x] += size[y];\n if (rank[x] == rank[y]) {\n rank[x]++;\n }\n components--;\n return true;\n }\n \n bool same(int x, int y) {\n return find(x) == find(y);\n }\n \n int getComponents() {\n return components;\n }\n \n int getSize(int x) {\n return size[find(x)];\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 400;\n const int M = 1995;\n \n // Read vertex coordinates\n vector> vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].first >> vertices[i].second;\n }\n \n // Read edges (store for later use)\n vector> edges(M);\n vector base_distances(M);\n \n for (int i = 0; i < M; i++) {\n cin >> edges[i].first >> edges[i].second;\n // Calculate d_i (rounded Euclidean distance)\n int dx = vertices[edges[i].first].first - vertices[edges[i].second].first;\n int dy = vertices[edges[i].first].second - vertices[edges[i].second].second;\n double dist = sqrt(dx*dx + dy*dy);\n base_distances[i] = (int)round(dist);\n }\n \n // Initialize Union-Find\n UnionFind uf(N);\n \n // Process each edge\n for (int i = 0; i < M; i++) {\n int length;\n cin >> length;\n \n int u = edges[i].first;\n int v = edges[i].second;\n int d = base_distances[i];\n \n // Calculate cost ratio\n double ratio = (double)length / d;\n \n // Dynamic threshold based on progress\n // Early on, accept more edges; later, be more selective\n double progress = (double)i / M;\n double threshold = 2.0 - 1.0 * progress; // Start at 2.0, end at 1.0\n \n // If this edge connects different components and the ratio is acceptable\n bool should_accept = !uf.same(u, v) && ratio <= threshold;\n \n // If we still have many components, be more permissive\n if (uf.getComponents() > N/4 && ratio <= threshold + 0.5) {\n should_accept = !uf.same(u, v);\n }\n \n // If this is a very cheap edge, strongly consider accepting\n if (ratio <= 1.2 && !uf.same(u, v)) {\n should_accept = true;\n }\n \n // If we're running out of edges and still have many components, accept more liberally\n if (i > M - N && uf.getComponents() > 1 && !uf.same(u, v)) {\n should_accept = true;\n }\n \n // Output decision\n cout << (should_accept ? 1 : 0) << endl;\n cout.flush(); // Important: flush output\n \n // If accepted, unite the components\n if (should_accept) {\n uf.unite(u, v);\n }\n }\n \n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int MAX_TURNS = 300;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool isValid() const { return x >= 1 && x <= GRID_SIZE && y >= 1 && y <= GRID_SIZE; }\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator<(const Point& other) const { \n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n Point operator+(const Point& other) const { return Point(x + other.x, y + other.y); }\n};\n\n// Direction vectors for U, D, L, R\nconst vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\nconst vector dirPoints = {Point(-1, 0), Point(1, 0), Point(0, -1), Point(0, 1)};\nconst string dir_chars = \"UDLR\";\nconst string block_chars = \"udlr\";\n\nclass Grid {\npublic:\n vector> impassable;\n vector human_positions;\n vector pet_positions;\n vector pet_types;\n int N, M;\n \n Grid() {\n impassable = vector>(GRID_SIZE + 1, vector(GRID_SIZE + 1, false));\n }\n \n bool isPassable(const Point& p) {\n if (!p.isValid()) return false;\n return !impassable[p.x][p.y];\n }\n \n // Check if we can make a square impassable (no pets or humans at start of turn, no adjacent pets)\n bool canBlock(const Point& p, const vector& start_human_positions, const vector& current_pet_positions) {\n if (!p.isValid()) return false;\n if (!isPassable(p)) return false; // Already impassable\n \n // Check if any human is at this position at the start of turn\n for (const Point& hp : start_human_positions) {\n if (hp == p) return false;\n }\n \n // Check if any pet is at this position at the start of turn\n for (const Point& pp : current_pet_positions) {\n if (pp == p) return false;\n }\n \n // Check if any adjacent square contains a pet\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (!adj.isValid()) continue;\n for (const Point& pp : current_pet_positions) {\n if (pp == adj) return false;\n }\n }\n \n return true;\n }\n \n // BFS to find reachable area from a point\n set getReachableArea(const Point& start) {\n set visited;\n queue q;\n q.push(start);\n visited.insert(start);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return visited;\n }\n \n // Count pets in a reachable area\n int countPetsInArea(const set& area) {\n int count = 0;\n for (const Point& pet_pos : pet_positions) {\n if (area.find(pet_pos) != area.end()) {\n count++;\n }\n }\n return count;\n }\n \n // Simple distance between two points\n int distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the closest pet to a human\n int findClosestPet(const Point& human_pos) {\n int min_dist = INT_MAX;\n int closest_pet = -1;\n \n for (int i = 0; i < N; i++) {\n int dist = distance(human_pos, pet_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = i;\n }\n }\n \n return closest_pet;\n }\n \n // Check if a pet can reach a human in the next few moves\n bool canPetReachHumanSoon(const Point& pet_pos, const Point& human_pos, int pet_type) {\n if (!isPassable(pet_pos) || !isPassable(human_pos)) return false;\n \n int max_moves = 1;\n if (pet_type == 2) max_moves = 2; // Pig\n else if (pet_type == 3) max_moves = 3; // Rabbit\n else if (pet_type == 4 || pet_type == 5) max_moves = 2; // Dog or Cat (target + random)\n \n set visited;\n queue> q;\n q.push({pet_pos, 0});\n visited.insert(pet_pos);\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n \n if (curr.second > max_moves) continue;\n if (curr.first == human_pos) return true;\n \n for (const auto& dir : dirs) {\n Point next(curr.first.x + dir.first, curr.first.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push({next, curr.second + 1});\n }\n }\n }\n \n return false;\n }\n \n // Get all adjacent passable squares\n vector getAdjacentPassable(const Point& p) {\n vector result;\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (adj.isValid() && isPassable(adj)) {\n result.push_back(adj);\n }\n }\n return result;\n }\n \n // Calculate score for a human at a given position\n double calculateScore(const Point& pos) {\n set area = getReachableArea(pos);\n int pet_count = countPetsInArea(area);\n return (double)area.size() / 900.0 * pow(0.5, pet_count);\n }\n \n // Find a good blocking position to protect from a specific pet\n Point findBlockToProtectFromPet(const Point& human_pos, const Point& pet_pos, const vector& start_human_positions) {\n // Try to find a position between human and pet to block\n vector candidates;\n \n // Consider positions around the human\n for (const auto& dir : dirs) {\n Point block_pos(human_pos.x + dir.first, human_pos.y + dir.second);\n if (canBlock(block_pos, start_human_positions, pet_positions)) {\n // Score this position based on how well it blocks the pet\n int pet_to_human_dist = distance(pet_pos, human_pos);\n int pet_to_block_dist = distance(pet_pos, block_pos);\n \n // Prefer blocks that are closer to the pet (intercept)\n if (pet_to_block_dist < pet_to_human_dist) {\n candidates.push_back(block_pos);\n }\n }\n }\n \n if (candidates.empty()) return Point(-1, -1);\n \n // Choose the candidate that maximizes distance from pet to human after blocking\n Point best_candidate = candidates[0];\n int best_dist = 0;\n \n for (const Point& candidate : candidates) {\n // Temporarily block\n impassable[candidate.x][candidate.y] = true;\n \n // Calculate shortest path from pet to human\n int dist = INT_MAX;\n set visited;\n queue> q;\n q.push({pet_pos, 0});\n visited.insert(pet_pos);\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n \n if (curr.first == human_pos) {\n dist = curr.second;\n break;\n }\n \n for (const auto& dir : dirs) {\n Point next(curr.first.x + dir.first, curr.first.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push({next, curr.second + 1});\n }\n }\n }\n \n impassable[candidate.x][candidate.y] = false; // Restore\n \n if (dist > best_dist) {\n best_dist = dist;\n best_candidate = candidate;\n }\n }\n \n return best_dist > 0 ? best_candidate : Point(-1, -1);\n }\n};\n\nint main() {\n Grid grid;\n \n // Read initial pet positions and types\n cin >> grid.N;\n grid.pet_positions.resize(grid.N);\n grid.pet_types.resize(grid.N);\n for (int i = 0; i < grid.N; i++) {\n cin >> grid.pet_positions[i].x >> grid.pet_positions[i].y >> grid.pet_types[i];\n }\n \n // Read initial human positions\n cin >> grid.M;\n grid.human_positions.resize(grid.M);\n for (int i = 0; i < grid.M; i++) {\n cin >> grid.human_positions[i].x >> grid.human_positions[i].y;\n }\n \n int turn = 0;\n \n while (turn < MAX_TURNS) {\n // Make a copy of human positions at the start of turn for validation\n vector start_human_positions = grid.human_positions;\n string actions = \"\";\n \n // For each human, decide action\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char best_action = '.';\n double best_score = -1;\n \n // Emergency response: if a pet can reach this human soon, prioritize blocking\n bool emergency = false;\n Point emergency_block(-1, -1);\n \n for (int j = 0; j < grid.N; j++) {\n if (grid.canPetReachHumanSoon(grid.pet_positions[j], human_pos, grid.pet_types[j])) {\n Point block_pos = grid.findBlockToProtectFromPet(human_pos, grid.pet_positions[j], start_human_positions);\n if (block_pos.x != -1) {\n emergency = true;\n emergency_block = block_pos;\n break;\n }\n }\n }\n \n if (emergency) {\n // Find which direction to block\n for (int d = 0; d < 4; d++) {\n Point block_attempt = human_pos + dirPoints[d];\n if (block_attempt == emergency_block) {\n best_action = block_chars[d];\n break;\n }\n }\n actions += best_action;\n continue;\n }\n \n // Early game: build walls strategically\n if (turn < 100) {\n // Try to build a perimeter around the center of humans\n Point center(0, 0);\n for (const Point& hp : start_human_positions) {\n center.x += hp.x;\n center.y += hp.y;\n }\n center.x /= grid.M;\n center.y /= grid.M;\n \n // For each human, try to build outward from center\n vector> block_candidates;\n \n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Score based on distance from pets and contribution to perimeter\n double score = 0;\n \n // Avoid pets\n bool too_close_to_pet = false;\n for (int j = 0; j < grid.N; j++) {\n if (grid.distance(block_pos, grid.pet_positions[j]) <= 3) {\n too_close_to_pet = true;\n break;\n }\n }\n \n if (too_close_to_pet) continue;\n \n // Prefer positions that help create a convex hull around humans\n int dist_to_center = grid.distance(block_pos, center);\n score = dist_to_center; // Prefer outer positions\n \n block_candidates.push_back({score, block_pos});\n }\n }\n \n if (!block_candidates.empty()) {\n // Sort by score (descending)\n sort(block_candidates.begin(), block_candidates.end(), [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n // Choose the best block candidate\n Point best_block = block_candidates[0].second;\n for (int d = 0; d < 4; d++) {\n Point block_attempt = human_pos + dirPoints[d];\n if (block_attempt == best_block) {\n best_action = block_chars[d];\n break;\n }\n }\n }\n \n // If no good blocking, try to move toward center or away from pets\n if (best_action == '.') {\n int closest_pet = grid.findClosestPet(human_pos);\n if (closest_pet != -1) {\n Point& pet_pos = grid.pet_positions[closest_pet];\n \n // Try to move away from closest pet or toward center if safe\n vector> move_candidates;\n \n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n double score = 0;\n \n // Distance from pet (want to increase)\n int new_dist_to_pet = grid.distance(move_pos, pet_pos);\n int curr_dist_to_pet = grid.distance(human_pos, pet_pos);\n if (new_dist_to_pet > curr_dist_to_pet) {\n score += 10; // Bonus for moving away\n }\n \n // Distance to center (want to decrease if safe)\n Point center(0, 0);\n for (const Point& hp : start_human_positions) {\n center.x += hp.x;\n center.y += hp.y;\n }\n center.x /= grid.M;\n center.y /= grid.M;\n \n int new_dist_to_center = grid.distance(move_pos, center);\n int curr_dist_to_center = grid.distance(human_pos, center);\n if (new_dist_to_center < curr_dist_to_center && curr_dist_to_pet > 5) {\n score += 5; // Bonus for moving toward center if safe\n }\n \n // Penalize if moving too close to any pet\n bool too_close = false;\n for (int j = 0; j < grid.N; j++) {\n if (grid.distance(move_pos, grid.pet_positions[j]) <= 2) {\n too_close = true;\n break;\n }\n }\n if (too_close) {\n score -= 100;\n }\n \n move_candidates.push_back({score, d});\n }\n }\n \n if (!move_candidates.empty()) {\n sort(move_candidates.begin(), move_candidates.end(), [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n if (move_candidates[0].first > -50) { // Only move if score is reasonable\n best_action = dir_chars[move_candidates[0].second];\n }\n }\n }\n }\n }\n // Mid to late game: optimize for score\n else {\n // Calculate score for staying\n double stay_score = grid.calculateScore(human_pos);\n best_score = stay_score;\n best_action = '.';\n \n // Try moving in each direction\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n double score = grid.calculateScore(move_pos);\n \n // Bonus for moving toward other humans (to create larger connected areas)\n double human_bonus = 0;\n for (int j = 0; j < grid.M; j++) {\n if (j != i) {\n int dist_before = grid.distance(human_pos, grid.human_positions[j]);\n int dist_after = grid.distance(move_pos, grid.human_positions[j]);\n if (dist_after < dist_before) {\n human_bonus += 2.0 / dist_after; // More bonus for getting closer\n }\n }\n }\n score += human_bonus * 0.1; // Scale the bonus\n \n if (score > best_score) {\n best_score = score;\n best_action = dir_chars[d];\n }\n }\n }\n \n // Consider blocking if it significantly improves score\n if (turn < 250) {\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Temporarily block to evaluate\n grid.impassable[block_pos.x][block_pos.y] = true;\n double score = grid.calculateScore(human_pos);\n grid.impassable[block_pos.x][block_pos.y] = false;\n \n // Only block if it improves score significantly and doesn't make area too small\n set area = grid.getReachableArea(human_pos);\n if (score > best_score * 1.1 && area.size() > 20) {\n best_score = score;\n best_action = block_chars[d];\n }\n }\n }\n }\n }\n \n actions += best_action;\n }\n \n // Now apply all actions simultaneously\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char action = actions[i];\n \n // Update human position if moving\n if (action >= 'A' && action <= 'Z') {\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == action) {\n human_pos.x += dirs[d].first;\n human_pos.y += dirs[d].second;\n break;\n }\n }\n }\n // Update grid if blocking\n else if (action >= 'a' && action <= 'z') {\n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == action) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n grid.impassable[block_pos.x][block_pos.y] = true;\n break;\n }\n }\n }\n // If '.', do nothing\n }\n \n // Output actions\n cout << actions << endl;\n cout.flush();\n \n // Read pet movements\n for (int i = 0; i < grid.N; i++) {\n string move;\n cin >> move;\n \n // Update pet position based on movement\n for (char c : move) {\n int dir_index = -1;\n for (int j = 0; j < 4; j++) {\n if (dir_chars[j] == c) {\n dir_index = j;\n break;\n }\n }\n if (dir_index != -1) {\n grid.pet_positions[i].x += dirs[dir_index].first;\n grid.pet_positions[i].y += dirs[dir_index].second;\n }\n }\n }\n \n turn++;\n }\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors for U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nstruct State {\n int x, y, dist;\n string path;\n State(int x, int y, int dist, string path) : x(x), y(y), dist(dist), path(path) {}\n};\n\nbool isValid(int x, int y) {\n return x >= 0 && x < 20 && y >= 0 && y < 20;\n}\n\n// BFS to find shortest path\nstring findShortestPath(int sx, int sy, int tx, int ty, \n const vector& h_walls, \n const vector& v_walls) {\n if (sx == tx && sy == ty) {\n return \"\";\n }\n \n queue q;\n vector> visited(20, vector(20, false));\n \n q.push(State(sx, sy, 0, \"\"));\n visited[sx][sy] = true;\n \n while (!q.empty()) {\n State curr = q.front();\n q.pop();\n \n if (curr.x == tx && curr.y == ty) {\n return curr.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = curr.x + dx[d];\n int ny = curr.y + dy[d];\n \n if (!isValid(nx, ny) || visited[nx][ny]) continue;\n \n // Check walls - '1' means wall exists, '0' means no wall\n bool canMove = false;\n if (d == 0) { // Up\n if (curr.x > 0 && v_walls[curr.x-1][curr.y] == '0') {\n canMove = true;\n }\n } else if (d == 1) { // Down\n if (curr.x < 19 && v_walls[curr.x][curr.y] == '0') {\n canMove = true;\n }\n } else if (d == 2) { // Left\n if (curr.y > 0 && h_walls[curr.x][curr.y-1] == '0') {\n canMove = true;\n }\n } else if (d == 3) { // Right\n if (curr.y < 19 && h_walls[curr.x][curr.y] == '0') {\n canMove = true;\n }\n }\n \n if (canMove) {\n visited[nx][ny] = true;\n q.push(State(nx, ny, curr.dist + 1, curr.path + dir_char[d]));\n }\n }\n }\n \n return \"\";\n}\n\n// Calculate optimal number of repetitions to maximize expected score\nint calculateOptimalRepetitions(double p, int pathLength) {\n if (pathLength == 0) return 1;\n if (pathLength > 200) return 1;\n \n int maxReps = 200 / pathLength;\n if (maxReps == 0) return 1;\n \n // Calculate expected score for different repetition counts\n // Expected score = sum_{k=1}^{reps} [P(first success at repetition k) * (401 - k*pathLength)]\n // P(first success at repetition k) = (probability of failing first k-1 repetitions) * (probability of succeeding at k-th)\n // This is an approximation - true probability depends on which characters are forgotten\n \n int bestReps = 1;\n double bestExpectedScore = 0.0;\n \n // For higher p (more forgetting), we need more repetitions\n // But too many repetitions means higher t (later arrival time), which reduces score (401-t)\n \n for (int reps = 1; reps <= maxReps; reps++) {\n double expectedScore = 0.0;\n \n // Simple model: probability of completing the path in one attempt\n // If each character has probability (1-p) of being remembered,\n // then probability of remembering all characters in path is (1-p)^pathLength\n double successProbPerAttempt = pow(1.0 - p, pathLength);\n \n // Expected score calculation\n // P(success on exactly the k-th repetition) = (1-successProbPerAttempt)^(k-1) * successProbPerAttempt\n for (int k = 1; k <= reps; k++) {\n double probSuccessOnKth = pow(1.0 - successProbPerAttempt, k-1) * successProbPerAttempt;\n int arrivalTime = k * pathLength;\n if (arrivalTime < 401) {\n expectedScore += probSuccessOnKth * (401.0 - arrivalTime);\n }\n }\n \n // Also account for probability of never succeeding\n // This doesn't contribute to expected score (since S=0 in that case)\n \n if (expectedScore > bestExpectedScore) {\n bestExpectedScore = expectedScore;\n bestReps = reps;\n }\n }\n \n // Ensure at least 1 repetition\n return max(1, bestReps);\n}\n\n// Alternative strategy: create a path that visits the target multiple times\nstring createRobustPath(int sx, int sy, int tx, int ty,\n const vector& h_walls, \n const vector& v_walls,\n double p) {\n string shortestPath = findShortestPath(sx, sy, tx, ty, h_walls, v_walls);\n if (shortestPath.empty()) return \"\";\n \n int pathLength = shortestPath.length();\n if (pathLength == 0) return \"\";\n \n // Calculate optimal repetitions\n int reps = calculateOptimalRepetitions(p, pathLength);\n \n // Create final path\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += shortestPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n \n return result;\n}\n\nint main() {\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n // Read horizontal walls: 20 rows, each with 19 characters\n vector h_walls(20);\n for (int i = 0; i < 20; i++) {\n cin >> h_walls[i];\n }\n \n // Read vertical walls: 19 rows, each with 20 characters\n vector v_walls(19);\n for (int i = 0; i < 19; i++) {\n cin >> v_walls[i];\n }\n \n // Create robust path\n string finalPath = createRobustPath(si, sj, ti, tj, h_walls, v_walls, p);\n \n // If the above fails, try a simple fallback\n if (finalPath.empty() || finalPath.length() > 200) {\n string shortestPath = findShortestPath(si, sj, ti, tj, h_walls, v_walls);\n \n if (shortestPath.empty() && (si != ti || sj != tj)) {\n // Greedy fallback\n string greedyPath = \"\";\n int cx = si, cy = sj;\n \n while ((cx != ti || cy != tj) && greedyPath.length() < 200) {\n bool moved = false;\n \n // Try to move in direction of target\n if (cx < ti && cx < 19 && v_walls[cx][cy] == '0') {\n greedyPath += 'D';\n cx++;\n moved = true;\n } else if (cx > ti && cx > 0 && v_walls[cx-1][cy] == '0') {\n greedyPath += 'U';\n cx--;\n moved = true;\n } else if (cy < tj && cy < 19 && h_walls[cx][cy] == '0') {\n greedyPath += 'R';\n cy++;\n moved = true;\n } else if (cy > tj && cy > 0 && h_walls[cx][cy-1] == '0') {\n greedyPath += 'L';\n cy--;\n moved = true;\n }\n \n // If can't move toward target, try any valid move\n if (!moved) {\n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d];\n int ny = cy + dy[d];\n if (isValid(nx, ny)) {\n bool canMove = false;\n if (d == 0 && cx > 0 && v_walls[cx-1][cy] == '0') canMove = true;\n else if (d == 1 && cx < 19 && v_walls[cx][cy] == '0') canMove = true;\n else if (d == 2 && cy > 0 && h_walls[cx][cy-1] == '0') canMove = true;\n else if (d == 3 && cy < 19 && h_walls[cx][cy] == '0') canMove = true;\n \n if (canMove) {\n greedyPath += dir_char[d];\n cx = nx;\n cy = ny;\n moved = true;\n break;\n }\n }\n }\n }\n \n // If completely stuck, break\n if (!moved) break;\n }\n \n shortestPath = greedyPath;\n }\n \n if (!shortestPath.empty()) {\n int reps = calculateOptimalRepetitions(p, shortestPath.length() ? shortestPath.length() : 1);\n finalPath = \"\";\n for (int i = 0; i < reps; i++) {\n finalPath += shortestPath;\n if (finalPath.length() >= 200) {\n finalPath = finalPath.substr(0, 200);\n break;\n }\n }\n }\n }\n \n // Ensure final path is valid\n if (finalPath.empty()) {\n finalPath = \"R\";\n }\n \n if (finalPath.length() > 200) {\n finalPath = finalPath.substr(0, 200);\n }\n \n cout << finalPath << endl;\n \n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction constants: left, up, right, down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// Transition table: to[tile_type][entry_direction] = exit_direction or -1 if invalid\nconst int to[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\nconst int N = 30;\n\nclass Solution {\nprivate:\n vector> grid;\n vector> rotations;\n mt19937 rng;\n chrono::steady_clock::time_point start_time;\n \npublic:\n Solution(const vector>& input_grid) : grid(input_grid), rng(random_device{}()) {\n rotations = vector>(N, vector(N, 0));\n }\n \n // Get the actual tile type after rotation\n int get_rotated_tile(int i, int j) {\n int base_type = grid[i][j];\n int rot = rotations[i][j] % 4;\n \n // Tile mapping after rotation\n if (base_type <= 3) {\n return (base_type + rot) % 4;\n } else if (base_type <= 5) {\n if (base_type == 4) {\n if (rot % 2 == 0) return 4;\n else return 5;\n } else { // base_type == 5\n if (rot % 2 == 0) return 5;\n else return 4;\n }\n } else { // base_type >= 6\n if (base_type == 6) {\n if (rot % 2 == 0) return 6;\n else return 7;\n } else { // base_type == 7\n if (rot % 2 == 0) return 7;\n else return 6;\n }\n }\n }\n \n // Calculate the length of a loop starting from (i, j) with direction d\n int calculate_loop_length(int si, int sj, int sd) {\n int i = si, j = sj, d = sd;\n int length = 0;\n int max_steps = N * N * 2; // Safety limit\n \n for (int step = 0; step < max_steps; step++) {\n int tile_type = get_rotated_tile(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0; // Line is broken\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= N || j < 0 || j >= N) return 0; // Out of bounds\n \n d = (d2 + 2) % 4; // Direction to the previous tile\n length++;\n \n // Check if we returned to start\n if (i == si && j == sj && d == sd) {\n return length;\n }\n }\n \n return 0; // Safety: prevent infinite loops\n }\n \n // Find all loops and return their lengths\n vector find_all_loops() {\n vector loop_lengths;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions and directions in this loop as visited\n int ci = i, cj = j, cd = d;\n int steps = 0;\n int max_steps = N * N * 2;\n \n do {\n if (steps >= max_steps) break;\n visited[ci][cj][cd] = true;\n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n if (d2 == -1) break;\n \n ci += di[d2];\n cj += dj[d2];\n \n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n cd = (d2 + 2) % 4;\n steps++;\n } while (!(ci == i && cj == j && cd == d) && steps < max_steps);\n \n loop_lengths.push_back(length);\n }\n }\n }\n \n // Early termination if running out of time\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1700) {\n return loop_lengths;\n }\n }\n \n // Sort in descending order\n sort(loop_lengths.rbegin(), loop_lengths.rend());\n return loop_lengths;\n }\n \n // Calculate score: L1 * L2 (0 if less than 2 loops)\n long long calculate_score() {\n vector loops = find_all_loops();\n if (loops.size() < 2) return 0;\n return (long long)loops[0] * loops[1];\n }\n \n // Smarter initialization - try to create potential loops\n void smart_init() {\n // Initialize with rotations that tend to connect with neighbors\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // For border tiles, rotate to face inward\n if (i == 0) {\n if (grid[i][j] <= 3) rotations[i][j] = 1; // Curved up\n else if (grid[i][j] == 6) rotations[i][j] = 1; // Vertical\n else if (grid[i][j] == 7) rotations[i][j] = 0; // Horizontal\n } else if (i == N-1) {\n if (grid[i][j] <= 3) rotations[i][j] = 3; // Curved down\n else if (grid[i][j] == 6) rotations[i][j] = 1; // Vertical\n else if (grid[i][j] == 7) rotations[i][j] = 0; // Horizontal\n } else if (j == 0) {\n if (grid[i][j] <= 3) rotations[i][j] = 0; // Curved left\n else if (grid[i][j] == 6) rotations[i][j] = 0; // Horizontal\n else if (grid[i][j] == 7) rotations[i][j] = 1; // Vertical\n } else if (j == N-1) {\n if (grid[i][j] <= 3) rotations[i][j] = 2; // Curved right\n else if (grid[i][j] == 6) rotations[i][j] = 0; // Horizontal\n else if (grid[i][j] == 7) rotations[i][j] = 1; // Vertical\n } else {\n // For interior tiles, use random but favor connections\n if (grid[i][j] <= 3) {\n rotations[i][j] = uniform_int_distribution(0, 3)(rng);\n } else if (grid[i][j] <= 5) {\n rotations[i][j] = uniform_int_distribution(0, 1)(rng) * 2; // Only even rotations\n } else { // 6 or 7\n rotations[i][j] = uniform_int_distribution(0, 1)(rng); // Only 0 or 1\n }\n }\n }\n }\n }\n \n // Randomly initialize rotations\n void random_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n rotations[i][j] = uniform_int_distribution(0, 3)(rng);\n }\n }\n }\n \n // Greedy initialization - try to maximize local connections\n void greedy_init() {\n // Start with all zeros\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n rotations[i][j] = 0;\n }\n }\n \n // For each tile, try all rotations and pick the one that maximizes local connections\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int best_rot = 0;\n int best_connections = 0;\n \n // Try each rotation\n for (int r = 0; r < 4; r++) {\n rotations[i][j] = r;\n int connections = 0;\n \n // Check connections with neighbors\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d];\n int nj = j + dj[d];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n int tile_type = get_rotated_tile(i, j);\n int exit_dir = to[tile_type][d];\n \n if (exit_dir != -1) {\n int opposite_dir = (exit_dir + 2) % 4;\n int neighbor_tile = get_rotated_tile(ni, nj);\n int neighbor_exit = to[neighbor_tile][opposite_dir];\n \n if (neighbor_exit != -1) {\n connections++;\n }\n }\n }\n }\n \n if (connections > best_connections) {\n best_connections = connections;\n best_rot = r;\n }\n }\n \n rotations[i][j] = best_rot;\n }\n }\n }\n \n // Try to improve solution using simulated annealing\n void simulated_annealing() {\n long long current_score = calculate_score();\n \n const double initial_temp = 800.0;\n const double final_temp = 10.0;\n const double cooling_rate = 0.9993;\n \n double temp = initial_temp;\n int iteration = 0;\n int stagnation_count = 0;\n long long best_score_in_run = current_score;\n \n // Limit based on time rather than iterations\n while (true) {\n // Pick a random tile to modify\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n \n // Save current rotation\n int old_rot = rotations[i][j];\n \n // Try a new rotation (sometimes make a more focused change)\n int new_rot;\n if (uniform_real_distribution(0.0, 1.0)(rng) < 0.7) {\n // Try adjacent rotation (more local search)\n new_rot = (old_rot + uniform_int_distribution(1, 3)(rng)) % 4;\n } else {\n // Try completely random rotation\n new_rot = uniform_int_distribution(0, 3)(rng);\n }\n \n rotations[i][j] = new_rot;\n \n // Calculate new score\n long long new_score = calculate_score();\n \n // Accept or reject based on simulated annealing\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n stagnation_count = 0;\n } else if (new_score == current_score) {\n accept = true;\n stagnation_count++;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n stagnation_count++;\n } else {\n stagnation_count++;\n }\n }\n \n if (!accept) {\n // Revert\n rotations[i][j] = old_rot;\n } else {\n current_score = new_score;\n if (current_score > best_score_in_run) {\n best_score_in_run = current_score;\n stagnation_count = 0;\n }\n }\n \n // Adaptive cooling - cool faster if stagnating\n if (stagnation_count > 100) {\n temp *= 0.95; // Faster cooling\n stagnation_count = 0;\n } else {\n temp *= cooling_rate;\n }\n \n // Check time limit and break conditions\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n if (elapsed_ms > 1850 || temp < final_temp) {\n break;\n }\n \n iteration++;\n }\n }\n \n // Run multiple restarts with different initializations\n void optimize() {\n start_time = chrono::steady_clock::now();\n long long best_score = 0;\n vector> best_rotations = rotations;\n \n // Try different initialization strategies\n int restarts = 0;\n \n // Strategy 1: Smart initialization\n smart_init();\n simulated_annealing();\n long long score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n restarts++;\n \n // Check time\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1500) {\n // Strategy 2: Greedy initialization\n greedy_init();\n simulated_annealing();\n score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n restarts++;\n }\n \n // Check time again\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1600 && restarts < 3) {\n // Strategy 3: Random initialization\n random_init();\n simulated_annealing();\n score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n rotations = best_rotations;\n }\n \n // Output the solution\n string get_output() {\n string result = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n result += char('0' + rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n // Read input\n vector> grid(N, vector(N));\n for (int i = 0; i < N; i++) {\n string line;\n cin >> line;\n for (int j = 0; j < N; j++) {\n grid[i][j] = line[j] - '0';\n }\n }\n \n // Create and optimize solution\n Solution solution(grid);\n solution.optimize();\n \n // Output result\n cout << solution.get_output() << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\nconst int opposite_dir[4] = {1, 0, 3, 2}; // Opposite of U,D,L,R\n\nstruct State {\n vector board;\n int empty_x, empty_y;\n string moves;\n int score;\n int potential_score; // Additional heuristic for potential connections\n \n // Default constructor\n State() : empty_x(-1), empty_y(-1), score(0), potential_score(0) {}\n \n // Parameterized constructor\n State(const vector& b, int ex, int ey, const string& m = \"\") \n : board(b), empty_x(ex), empty_y(ey), moves(m) {\n calculateScores();\n }\n \n void calculateScores() {\n if (board.empty() || empty_x == -1) {\n score = 0;\n potential_score = 0;\n return;\n }\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n int total_potential = 0;\n \n // Calculate actual connected components\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n // Calculate potential connections (heuristic)\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0') continue;\n \n int tile_val = (board[i][j] >= 'a') ? (board[i][j] - 'a' + 10) : (board[i][j] - '0');\n \n // Potential down connection\n if ((tile_val & 8) && i + 1 < n && board[i+1][j] != '0') {\n int below_val = (board[i+1][j] >= 'a') ? (board[i+1][j] - 'a' + 10) : (board[i+1][j] - '0');\n if (below_val & 2) {\n total_potential++;\n }\n }\n \n // Potential right connection\n if ((tile_val & 4) && j + 1 < n && board[i][j+1] != '0') {\n int right_val = (board[i][j+1] >= 'a') ? (board[i][j+1] - 'a' + 10) : (board[i][j+1] - '0');\n if (right_val & 1) {\n total_potential++;\n }\n }\n }\n }\n \n score = max_component_size;\n potential_score = total_potential;\n }\n \n // Composite score for sorting\n int getCompositeScore() const {\n // Prioritize actual score, then potential connections, then shorter paths\n return score * 1000000 + potential_score * 100 - (int)moves.size();\n }\n \n // Equality operator for State\n bool operator==(const State& other) const {\n if (board != other.board) return false;\n if (empty_x != other.empty_x) return false;\n if (empty_y != other.empty_y) return false;\n return true;\n }\n};\n\n// Calculate the score of a board configuration\nint calculateScore(const vector& board) {\n if (board.empty()) return 0;\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n}\n\n// Check if a move is valid\nbool isValidMove(int x, int y, int n) {\n return x >= 0 && x < n && y >= 0 && y < n;\n}\n\n// Enhanced solve function with multiple strategies\nstring solve(const vector& initial_board, int N, int T) {\n int empty_x = -1, empty_y = -1;\n \n // Find the empty space\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_board[i][j] == '0') {\n empty_x = i;\n empty_y = j;\n break;\n }\n }\n if (empty_x != -1) break;\n }\n \n // If we're already at max score, return empty string\n int current_score = calculateScore(initial_board);\n if (current_score == N*N-1) {\n return \"\";\n }\n \n // Use dynamic beam width based on N\n size_t BEAM_WIDTH = min(100, N * N * 2);\n \n // Strategy 1: Beam search with enhanced heuristic\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(State(initial_board, empty_x, empty_y, \"\"));\n \n auto start_time = chrono::steady_clock::now();\n const int time_limit_ms = 2800; // Leave 200ms margin for 3000ms limit\n \n // Try to find a good solution within T moves\n for (int step = 0; step < T && !beam.empty(); step++) {\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n if (elapsed_ms > time_limit_ms) {\n break;\n }\n \n vector next_beam;\n next_beam.reserve(min(BEAM_WIDTH * 4, (size_t)500));\n \n for (auto& state : beam) {\n // Try all possible moves\n for (int dir = 0; dir < 4; dir++) {\n int new_x = state.empty_x + dx[dir];\n int new_y = state.empty_y + dy[dir];\n \n // Skip if move is invalid\n if (!isValidMove(new_x, new_y, N)) continue;\n \n // Skip if would undo previous move (except for first move)\n if (state.moves.size() > 0 && \n dir == opposite_dir[state.moves.back() - 'U']) continue;\n \n // Make a copy and apply the move\n vector new_board = state.board;\n int new_empty_x = state.empty_x;\n int new_empty_y = state.empty_y;\n string new_moves = state.moves + dir_char[dir];\n \n // Apply the move\n swap(new_board[new_empty_x][new_empty_y], new_board[new_x][new_y]);\n new_empty_x = new_x;\n new_empty_y = new_y;\n \n // Create new state\n State new_state;\n new_state.board = new_board;\n new_state.empty_x = new_empty_x;\n new_state.empty_y = new_empty_y;\n new_state.moves = new_moves;\n new_state.calculateScores();\n \n // If we found a full tree, return immediately\n if (new_state.score == N*N-1) {\n return new_state.moves;\n }\n \n next_beam.push_back(new_state);\n }\n }\n \n // Sort by composite score (descending)\n sort(next_beam.begin(), next_beam.end(), [](const State& a, const State& b) {\n if (a.getCompositeScore() != b.getCompositeScore()) {\n return a.getCompositeScore() > b.getCompositeScore();\n }\n return a.moves.size() < b.moves.size();\n });\n \n // Keep only the best states\n if (next_beam.size() > BEAM_WIDTH) {\n next_beam.resize(BEAM_WIDTH);\n }\n \n // If we're not making progress, try to diversify\n if (step > 10 && next_beam.size() > BEAM_WIDTH/2) {\n // Keep the top 80% by score, and 20% randomly for diversity\n size_t keep_by_score = (size_t)(next_beam.size() * 0.8);\n vector diversified;\n for (size_t i = 0; i < keep_by_score && i < next_beam.size(); i++) {\n diversified.push_back(next_beam[i]);\n }\n \n if (keep_by_score < next_beam.size()) {\n // Add some random states for diversity\n random_device rd;\n mt19937 gen(rd());\n vector indices;\n for (size_t i = keep_by_score; i < next_beam.size(); i++) {\n indices.push_back(i);\n }\n shuffle(indices.begin(), indices.end(), gen);\n \n size_t to_add = min((size_t)(next_beam.size() * 0.2), (size_t)indices.size());\n for (size_t i = 0; i < to_add && diversified.size() < BEAM_WIDTH; i++) {\n diversified.push_back(next_beam[indices[i]]);\n }\n \n // If we still have space, fill with best remaining\n for (size_t i = 0; i < indices.size() && diversified.size() < BEAM_WIDTH; i++) {\n bool found = false;\n for (const auto& state : diversified) {\n if (state == next_beam[indices[i]]) {\n found = true;\n break;\n }\n }\n if (!found) {\n diversified.push_back(next_beam[indices[i]]);\n }\n if (diversified.size() >= BEAM_WIDTH) break;\n }\n \n next_beam = diversified;\n }\n }\n \n beam = next_beam;\n \n // Early termination if we have a very good solution\n if (!beam.empty() && beam[0].score > N*N*0.9) {\n // Focus on improving this good solution\n BEAM_WIDTH = min(BEAM_WIDTH, (size_t)30);\n }\n }\n \n // Return the best solution found\n if (!beam.empty()) {\n sort(beam.begin(), beam.end(), [](const State& a, const State& b) {\n if (a.score != b.score) return a.score > b.score;\n if (a.potential_score != b.potential_score) return a.potential_score > b.potential_score;\n return a.moves.size() < b.moves.size();\n });\n return beam[0].moves;\n }\n \n return \"\";\n}\n\nint main() {\n int N, T;\n cin >> N >> T;\n \n vector board(N);\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n string solution = solve(board, N, T);\n cout << solution << endl;\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n long long x, y;\n Point() : x(0), y(0) {}\n Point(long long x, long long y) : x(x), y(y) {}\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n \n long long cross(const Point& other) const {\n return x * other.y - y * other.x;\n }\n \n long long dot(const Point& other) const {\n return x * other.x + y * other.y;\n }\n \n long long dist2() const {\n return x * x + y * y;\n }\n \n double dist() const {\n return sqrt(x * x + y * y);\n }\n};\n\nstruct Line {\n Point p1, p2;\n Line() {}\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\n// Ensure point coordinates are within bounds\nPoint clampPoint(Point p) {\n const long long MIN_VAL = -1000000000;\n const long long MAX_VAL = 1000000000;\n p.x = max(MIN_VAL, min(MAX_VAL, p.x));\n p.y = max(MIN_VAL, min(MAX_VAL, p.y));\n return p;\n}\n\n// Check which side of the line a point is on\n// Returns: 1 if on one side, -1 if on the other, 0 if on the line\nint side(const Point& p, const Line& line) {\n Point v1 = line.p2 - line.p1;\n Point v2 = p - line.p1;\n long long cross = v1.cross(v2);\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\n// Check if a point is strictly inside a region defined by lines\n// Each line defines a half-plane, and we need to be on the correct side of all lines\nbool isInside(const Point& p, const vector& lines, const vector& sides) {\n for (int i = 0; i < lines.size(); i++) {\n int s = side(p, lines[i]);\n if (s != sides[i]) return false;\n }\n return true;\n}\n\n// Try to find a line that separates a group of strawberries from others\nLine findSeparatingLine(const vector& strawberries, const vector& group, const vector& existingLines) {\n // Simple approach: try to find a line that roughly separates the group from others\n if (group.size() == 0) {\n return Line(Point(0, 0), Point(1, 0));\n }\n \n // Calculate centroid of group\n Point centroid(0, 0);\n for (int i : group) {\n centroid.x += strawberries[i].x;\n centroid.y += strawberries[i].y;\n }\n centroid.x /= group.size();\n centroid.y /= group.size();\n \n // Calculate centroid of other strawberries\n vector others;\n for (int i = 0; i < strawberries.size(); i++) {\n if (find(group.begin(), group.end(), i) == group.end()) {\n others.push_back(i);\n }\n }\n \n if (others.empty()) {\n // If no others, just use a line near the group\n Point p1(centroid.x - 1, centroid.y - 1);\n Point p2(centroid.x + 1, centroid.y + 1);\n return Line(clampPoint(p1), clampPoint(p2));\n }\n \n Point otherCentroid(0, 0);\n for (int i : others) {\n otherCentroid.x += strawberries[i].x;\n otherCentroid.y += strawberries[i].y;\n }\n otherCentroid.x /= others.size();\n otherCentroid.y /= others.size();\n \n // Line perpendicular to the line connecting centroids\n Point dir = otherCentroid - centroid;\n Point perp(-dir.y, dir.x);\n \n // Make sure the points are integers and within bounds\n Point p1(centroid.x + perp.x, centroid.y + perp.y);\n Point p2(centroid.x - perp.x, centroid.y - perp.y);\n \n // Scale to make sure they're far enough apart but still within bounds\n if (p1.dist2() < 100) {\n // Scale but ensure we don't go out of bounds\n long long scale = 1000;\n // Check if scaling would exceed bounds\n if (abs(p1.x * scale) > 1000000000 || abs(p1.y * scale) > 1000000000) {\n scale = 1;\n }\n p1.x *= scale;\n p1.y *= scale;\n p2.x *= scale;\n p2.y *= scale;\n }\n \n // Ensure bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n return Line(p1, p2);\n}\n\n// Calculate distance between two points\ndouble distance(const Point& a, const Point& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\n// Try to improve a line to minimize strawberries on it\nLine improveLine(const Line& line, const vector& strawberries, const vector& otherLines) {\n Line bestLine = line;\n int bestOnLine = strawberries.size();\n \n // Try small perturbations within bounds\n for (int dx1 = -1; dx1 <= 1; dx1++) {\n for (int dy1 = -1; dy1 <= 1; dy1++) {\n for (int dx2 = -1; dx2 <= 1; dx2++) {\n for (int dy2 = -1; dy2 <= 1; dy2++) {\n Point newP1(line.p1.x + dx1, line.p1.y + dy1);\n Point newP2(line.p2.x + dx2, line.p2.y + dy2);\n \n // Clamp to bounds\n newP1 = clampPoint(newP1);\n newP2 = clampPoint(newP2);\n \n // Skip if points are the same\n if (newP1.x == newP2.x && newP1.y == newP2.y) {\n // Make them different\n if (newP2.x < 1000000000) newP2.x += 1;\n else if (newP2.x > -1000000000) newP2.x -= 1;\n else if (newP2.y < 1000000000) newP2.y += 1;\n else newP2.y -= 1;\n }\n \n Line newLine(newP1, newP2);\n \n // Calculate score: minimize strawberries on line\n int onLine = 0;\n for (const Point& s : strawberries) {\n if (side(s, newLine) == 0) {\n onLine++;\n }\n }\n \n // Prefer lines with fewer strawberries on them\n if (onLine < bestOnLine) {\n bestOnLine = onLine;\n bestLine = newLine;\n }\n }\n }\n }\n }\n \n return bestLine;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n cin >> N >> K;\n \n vector a(10);\n for (int i = 0; i < 10; i++) {\n cin >> a[i];\n }\n \n vector strawberries(N);\n for (int i = 0; i < N; i++) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n \n // We'll use a greedy approach to create pieces of desired sizes\n vector lines;\n vector used(N, false);\n \n // First, try to create single strawberry pieces\n for (int d = 0; d < 10; d++) {\n if (a[d] == 0) continue;\n \n // Target: create a[d] pieces with d+1 strawberries each\n int targetCount = a[d];\n int strawberriesPerPiece = d + 1;\n \n for (int piece = 0; piece < targetCount && lines.size() < K; piece++) {\n // Find a group of strawberriesPerPiece strawberries that are close to each other\n vector group;\n \n // Find unused strawberries\n vector unused;\n for (int i = 0; i < N; i++) {\n if (!used[i]) {\n unused.push_back(i);\n }\n }\n \n if (unused.size() < strawberriesPerPiece) {\n // Not enough unused strawberries, skip\n break;\n }\n \n // Use a simple greedy approach: pick the first available strawberries\n for (int i = 0; i < strawberriesPerPiece && i < unused.size(); i++) {\n group.push_back(unused[i]);\n used[unused[i]] = true;\n }\n \n // If we need to isolate this group, add a line\n if (strawberriesPerPiece < N && !group.empty()) {\n // Find a line that separates this group from others (if possible)\n Line separatingLine = findSeparatingLine(strawberries, group, lines);\n \n // Try to improve the line to avoid cutting through strawberries\n separatingLine = improveLine(separatingLine, strawberries, lines);\n \n lines.push_back(separatingLine);\n \n // Stop if we've reached the limit\n if (lines.size() >= K) break;\n }\n }\n }\n \n // If we have remaining cuts, try to add random lines that might improve the partition\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution dis(-1000000000, 1000000000);\n \n while (lines.size() < K) {\n // Generate a random line\n Point p1(dis(gen), dis(gen));\n Point p2(dis(gen), dis(gen));\n \n // Clamp to ensure within bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n Line line(p1, p2);\n \n // Improve the line\n line = improveLine(line, strawberries, lines);\n \n lines.push_back(line);\n }\n \n // Output the solution\n cout << lines.size() << \"\\n\";\n for (const Line& line : lines) {\n cout << line.p1.x << \" \" << line.p1.y << \" \" << line.p2.x << \" \" << line.p2.y << \"\\n\";\n }\n \n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n \n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n \n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n \n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y);\n }\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n};\n\nstruct Edge {\n Point p1, p2;\n Edge(Point a, Point b) {\n if (a < b) {\n p1 = a;\n p2 = b;\n } else {\n p1 = b;\n p2 = a;\n }\n }\n \n bool operator==(const Edge& other) const {\n return p1 == other.p1 && p2 == other.p2;\n }\n \n bool operator<(const Edge& other) const {\n if (p1 != other.p1) return p1 < other.p1;\n return p2 < other.p2;\n }\n};\n\nstruct Rectangle {\n vector points;\n vector edges;\n \n Rectangle(Point p1, Point p2, Point p3, Point p4) {\n points = {p1, p2, p3, p4};\n // Create edges\n edges.push_back(Edge(p1, p2));\n edges.push_back(Edge(p2, p3));\n edges.push_back(Edge(p3, p4));\n edges.push_back(Edge(p4, p1));\n }\n};\n\nstruct Candidate {\n Point newPoint;\n vector existingPoints;\n double weight;\n \n Candidate(Point np, vector ep, double w) : newPoint(np), existingPoints(ep), weight(w) {}\n \n bool operator<(const Candidate& other) const {\n // Higher weight first\n return weight < other.weight;\n }\n};\n\nclass RectJoinSolver {\nprivate:\n int N, M;\n int center;\n vector> hasDot;\n set drawnEdges;\n vector initialDots;\n vector> operations;\n \n // Calculate weight of a point\n double getWeight(int x, int y) {\n return (x - center) * (x - center) + (y - center) * (y - center) + 1;\n }\n \n // Check if point is on the grid\n bool isValidPoint(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n \n // Get all points on the perimeter of a rectangle\n vector getPerimeterPoints(const Rectangle& rect) {\n vector perimeter;\n \n // Add all four corners\n for (const Point& p : rect.points) {\n perimeter.push_back(p);\n }\n \n // Add points on edges (excluding corners)\n for (const Edge& edge : rect.edges) {\n int dx = edge.p2.x - edge.p1.x;\n int dy = edge.p2.y - edge.p1.y;\n \n int steps = max(abs(dx), abs(dy));\n if (steps == 0) continue;\n \n int stepX = (dx != 0) ? dx / abs(dx) : 0;\n int stepY = (dy != 0) ? dy / abs(dy) : 0;\n \n Point current = edge.p1;\n for (int i = 1; i < steps; i++) {\n current = Point(current.x + stepX, current.y + stepY);\n perimeter.push_back(current);\n }\n }\n \n return perimeter;\n }\n \n // Check if rectangle is valid (no other dots on perimeter except corners)\n bool isValidRectangle(const Rectangle& rect) {\n vector perimeter = getPerimeterPoints(rect);\n \n // Check if there are dots on perimeter other than the 4 corners\n for (const Point& p : perimeter) {\n bool isCorner = false;\n for (const Point& corner : rect.points) {\n if (p == corner) {\n isCorner = true;\n break;\n }\n }\n \n if (!isCorner && hasDot[p.x][p.y]) {\n return false;\n }\n }\n \n // Check if any edge shares a segment with existing edges\n for (const Edge& edge : rect.edges) {\n if (drawnEdges.find(edge) != drawnEdges.end()) {\n return false;\n }\n }\n \n return true;\n }\n \n // Try to form a rectangle with the given new point and existing dots\n vector findValidRectangle(Point newPoint, const vector& existingDots) {\n int existingCount = existingDots.size();\n \n // Try all combinations of 3 existing dots\n for (int i = 0; i < existingCount; i++) {\n for (int j = i + 1; j < existingCount; j++) {\n for (int k = j + 1; k < existingCount; k++) {\n Point p2 = existingDots[i];\n Point p3 = existingDots[j];\n Point p4 = existingDots[k];\n \n // Try different orderings to form rectangles\n vector> orderings = {\n {newPoint, p2, p3, p4},\n {newPoint, p2, p4, p3},\n {newPoint, p3, p2, p4},\n {newPoint, p3, p4, p2},\n {newPoint, p4, p2, p3},\n {newPoint, p4, p3, p2}\n };\n \n for (const auto& ordering : orderings) {\n if (isRectangle(ordering[0], ordering[1], ordering[2], ordering[3])) {\n Rectangle rect(ordering[0], ordering[1], ordering[2], ordering[3]);\n if (isValidRectangle(rect)) {\n return {p2, p3, p4}; // Return the 3 existing points\n }\n }\n }\n }\n }\n }\n \n return {}; // No valid rectangle found\n }\n \n // Check if 4 points form a rectangle (axis-aligned or 45-degree)\n bool isRectangle(Point p1, Point p2, Point p3, Point p4) {\n // For axis-aligned rectangles\n if (isAxisAlignedRectangle(p1, p2, p3, p4)) {\n return true;\n }\n \n // For 45-degree rectangles\n if (isDiagonalRectangle(p1, p2, p3, p4)) {\n return true;\n }\n \n return false;\n }\n \n // Check if 4 points form an axis-aligned rectangle\n bool isAxisAlignedRectangle(Point p1, Point p2, Point p3, Point p4) {\n vector xs = {p1.x, p2.x, p3.x, p4.x};\n vector ys = {p1.y, p2.y, p3.y, p4.y};\n sort(xs.begin(), xs.end());\n sort(ys.begin(), ys.end());\n \n // Check if there are exactly 2 distinct x-coordinates and 2 distinct y-coordinates\n if (xs[0] == xs[1] && xs[2] == xs[3] && ys[0] == ys[1] && ys[2] == ys[3]) {\n // Check if the points are at the corners\n set corners = {\n Point(xs[0], ys[0]), Point(xs[0], ys[3]),\n Point(xs[3], ys[0]), Point(xs[3], ys[3])\n };\n \n set actual = {p1, p2, p3, p4};\n return corners == actual;\n }\n \n return false;\n }\n \n // Check if 4 points form a 45-degree rectangle (diamond shape)\n bool isDiagonalRectangle(Point p1, Point p2, Point p3, Point p4) {\n // Calculate vectors between points\n vector points = {p1, p2, p3, p4};\n \n // Try all possible center points\n for (int i = 0; i < 4; i++) {\n for (int j = i + 1; j < 4; j++) {\n // Calculate potential center (midpoint of diagonal)\n Point center((points[i].x + points[j].x) / 2, (points[i].y + points[j].y) / 2);\n \n // Check if center has integer coordinates\n if ((points[i].x + points[j].x) % 2 != 0 || (points[i].y + points[j].y) % 2 != 0) {\n continue;\n }\n \n // Find the other two points\n vector otherPoints;\n for (int k = 0; k < 4; k++) {\n if (k != i && k != j) {\n otherPoints.push_back(points[k]);\n }\n }\n \n if (otherPoints.size() != 2) continue;\n \n // Check if they form a diagonal\n Point otherCenter((otherPoints[0].x + otherPoints[1].x) / 2, (otherPoints[0].y + otherPoints[1].y) / 2);\n if (otherCenter.x != center.x || otherCenter.y != center.y) {\n continue;\n }\n \n // Check if it's a square rotated by 45 degrees\n // Vectors from center to corners should be perpendicular and of equal length\n Point v1 = points[i] - center;\n Point v2 = otherPoints[0] - center;\n \n // Check if vectors are perpendicular (dot product = 0)\n if (v1.x * v2.x + v1.y * v2.y != 0) {\n continue;\n }\n \n // Check if vectors have the same length\n if (v1.x * v1.x + v1.y * v1.y != v2.x * v2.x + v2.y * v2.y) {\n continue;\n }\n \n // Check if all coordinates are integers and points are distinct\n bool allValid = true;\n for (const Point& p : points) {\n if (!isValidPoint(p.x, p.y)) {\n allValid = false;\n break;\n }\n }\n \n if (allValid) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n // Get all existing dots\n vector getAllDots() {\n vector dots;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (hasDot[x][y]) {\n dots.push_back(Point(x, y));\n }\n }\n }\n return dots;\n }\n \npublic:\n RectJoinSolver(int n, int m, const vector& initial) : N(n), M(m), initialDots(initial) {\n center = (N - 1) / 2;\n hasDot.assign(N, vector(N, false));\n \n // Mark initial dots\n for (const Point& p : initialDots) {\n hasDot[p.x][p.y] = true;\n }\n }\n \n void solve() {\n // Use priority queue to prioritize placing dots with higher weights\n priority_queue candidates;\n vector existingDots = getAllDots();\n \n // Add all possible candidate positions\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (!hasDot[x][y]) {\n double weight = getWeight(x, y);\n candidates.push(Candidate(Point(x, y), {}, weight));\n }\n }\n }\n \n bool madeProgress = true;\n while (madeProgress && !candidates.empty()) {\n madeProgress = false;\n vector remainingCandidates;\n \n // Try candidates in order of priority\n while (!candidates.empty()) {\n Candidate cand = candidates.top();\n candidates.pop();\n \n // Refresh existing dots (in case new dots were added)\n existingDots = getAllDots();\n \n // Try to find a valid rectangle for this candidate\n vector validPoints = findValidRectangle(cand.newPoint, existingDots);\n \n if (!validPoints.empty()) {\n // Found a valid rectangle, place the dot\n Point newDot = cand.newPoint;\n hasDot[newDot.x][newDot.y] = true;\n \n // Create rectangle to get edges\n Rectangle rect(newDot, validPoints[0], validPoints[1], validPoints[2]);\n \n // Add edges to drawn edges\n for (const Edge& edge : rect.edges) {\n drawnEdges.insert(edge);\n }\n \n // Record operation\n vector op = {newDot, validPoints[0], validPoints[1], validPoints[2]};\n vector opCoords;\n for (const Point& p : op) {\n opCoords.push_back(p.x);\n opCoords.push_back(p.y);\n }\n operations.push_back(op);\n \n // Refresh existing dots\n existingDots = getAllDots();\n \n // Add this point to all remaining candidates' existing dots\n madeProgress = true;\n break;\n } else {\n // Keep for next iteration\n remainingCandidates.push_back(cand);\n }\n }\n \n // If we made progress, rebuild the priority queue with updated weights\n if (madeProgress) {\n // Add back remaining candidates\n for (const Candidate& cand : remainingCandidates) {\n candidates.push(cand);\n }\n }\n }\n }\n \n void output() {\n cout << operations.size() << endl;\n for (const auto& op : operations) {\n for (int i = 0; i < 4; i++) {\n if (i > 0) cout << \" \";\n cout << op[i].x << \" \" << op[i].y;\n }\n cout << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n \n vector initialDots;\n for (int i = 0; i < M; i++) {\n int x, y;\n cin >> x >> y;\n initialDots.push_back(Point(x, y));\n }\n \n RectJoinSolver solver(N, M, initialDots);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\n\n// Directions: F=0 (forward/up), B=1 (backward/down), L=2 (left), R=3 (right)\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'F', 'B', 'L', 'R'};\n\nclass CandyBox {\nprivate:\n vector> grid;\n vector flavor_count;\n vector future_flavors;\n int current_step;\n \npublic:\n CandyBox(const vector& flavors) : grid(N, vector(N, 0)), flavor_count(4, 0), future_flavors(flavors), current_step(0) {}\n \n // Place candy at position (calculated from 1-indexed empty cell number)\n void placeCandy(int pos, int flavor) {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == 0) {\n count++;\n if (count == pos) {\n grid[i][j] = flavor;\n flavor_count[flavor]++;\n return;\n }\n }\n }\n }\n }\n \n // Simulate tilting in a direction\n vector> simulateTilt(int dir) {\n vector> new_grid = grid;\n \n // Create movement order based on direction\n vector> cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (new_grid[i][j] != 0) {\n cells.push_back({i, j});\n }\n }\n }\n \n // Sort cells based on direction to process in correct order\n if (dir == 0) { // Forward (up): process from top to bottom\n sort(cells.begin(), cells.end());\n } else if (dir == 1) { // Backward (down): process from bottom to top\n sort(cells.begin(), cells.end(), greater>());\n } else if (dir == 2) { // Left: process from left to right\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second < b.second;\n return a.first < b.first;\n });\n } else { // Right: process from right to left\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second > b.second;\n return a.first < b.first;\n });\n }\n \n // Move each candy\n vector> temp_grid(N, vector(N, 0));\n for (auto& cell : cells) {\n int x = cell.first, y = cell.second;\n int flavor = new_grid[x][y];\n \n // Skip if already processed (moved)\n if (flavor == 0) continue;\n \n int nx = x, ny = y;\n while (true) {\n int tx = nx + dx[dir];\n int ty = ny + dy[dir];\n if (tx < 0 || tx >= N || ty < 0 || ty >= N || temp_grid[tx][ty] != 0) {\n break;\n }\n nx = tx;\n ny = ty;\n }\n temp_grid[nx][ny] = flavor;\n }\n \n return temp_grid;\n }\n \n // Calculate score for a given grid state\n long long calculateScoreForGrid(const vector>& test_grid, const vector& test_counts) {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = test_grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && test_grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)test_counts[i] * test_counts[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Calculate a bonus score for potential connectivity\n double calculateConnectivityBonus(const vector>& test_grid, int current_flavor) {\n double bonus = 0.0;\n \n // For each candy of the current flavor, check if it's adjacent to another candy of the same flavor\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] == current_flavor) {\n // Check 4 directions for adjacent candies of the same flavor\n int adjacent_count = 0;\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d][0];\n int nj = j + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && test_grid[ni][nj] == current_flavor) {\n adjacent_count++;\n }\n }\n // Add bonus for each adjacency (small bonus to avoid overriding actual score)\n bonus += adjacent_count * 0.1;\n }\n }\n }\n \n return bonus;\n }\n \n // Calculate distance to nearest same-flavor candy\n double calculateDistanceBonus(const vector>& test_grid, int current_flavor) {\n double bonus = 0.0;\n \n // For each candy of the current flavor\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] == current_flavor) {\n // Find distance to nearest other candy of the same flavor\n int min_dist = INT_MAX;\n bool found_other = false;\n \n for (int ni = 0; ni < N; ni++) {\n for (int nj = 0; nj < N; nj++) {\n if (test_grid[ni][nj] == current_flavor && (ni != i || nj != j)) {\n int dist = abs(ni - i) + abs(nj - j);\n if (dist < min_dist) {\n min_dist = dist;\n found_other = true;\n }\n }\n }\n }\n \n // If found another candy of the same flavor, add bonus based on proximity\n if (found_other) {\n bonus += 1.0 / (1.0 + min_dist); // Closer = higher bonus\n }\n }\n }\n }\n \n return bonus;\n }\n \n // Apply tilt to actual grid\n void applyTilt(int dir) {\n grid = simulateTilt(dir);\n }\n \n // Get current grid state\n vector> getGrid() const {\n return grid;\n }\n \n // Get flavor counts\n vector getFlavorCount() const {\n return flavor_count;\n }\n \n // Update current step\n void updateStep(int step) {\n current_step = step;\n }\n};\n\nint main() {\n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n CandyBox box(flavors);\n \n for (int t = 0; t < 100; t++) {\n int pos;\n cin >> pos;\n \n // Update current step\n box.updateStep(t);\n \n // Place the candy\n box.placeCandy(pos, flavors[t]);\n \n // If it's the last candy, we can choose any direction (it won't matter)\n if (t == 99) {\n cout << \"F\" << endl;\n cout.flush();\n continue;\n }\n \n // Try all 4 directions and pick the best\n double best_combined_score = -1e18;\n int best_dir = 0;\n \n vector current_counts = box.getFlavorCount();\n \n for (int dir = 0; dir < 4; dir++) {\n // Simulate tilt in this direction\n vector> test_grid = box.simulateTilt(dir);\n \n // Calculate base score\n long long base_score = box.calculateScoreForGrid(test_grid, current_counts);\n \n // Calculate small bonuses for improved connectivity\n double connectivity_bonus = box.calculateConnectivityBonus(test_grid, flavors[t]);\n double distance_bonus = box.calculateDistanceBonus(test_grid, flavors[t]);\n \n // Combine scores with very small weights for bonuses\n double combined_score = base_score + connectivity_bonus + distance_bonus * 0.5;\n \n // Choose the direction with the highest combined score\n if (combined_score > best_combined_score) {\n best_combined_score = combined_score;\n best_dir = dir;\n }\n }\n \n // Apply the best tilt\n box.applyTilt(best_dir);\n \n // Output the direction\n cout << dir_char[best_dir] << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass Graph {\npublic:\n int N;\n vector> adj;\n \n Graph(int n) : N(n), adj(n, vector(n, false)) {}\n \n void add_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = true;\n adj[j][i] = true;\n }\n }\n \n void remove_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = false;\n adj[j][i] = false;\n }\n }\n \n bool has_edge(int i, int j) const {\n return adj[i][j];\n }\n \n string to_string() const {\n string s;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s += (adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n static Graph from_string(int n, const string& s) {\n Graph g(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (idx < s.length() && s[idx] == '1') {\n g.add_edge(i, j);\n }\n idx++;\n }\n }\n return g;\n }\n \n vector get_degree_sequence() const {\n vector degrees(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) degrees[i]++;\n }\n }\n sort(degrees.begin(), degrees.end());\n return degrees;\n }\n \n int count_edges() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) count++;\n }\n }\n return count;\n }\n \n int count_triangles() const {\n int triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n triangles++;\n }\n }\n }\n }\n }\n return triangles;\n }\n \n // Count number of 4-cliques\n int count_4cliques() const {\n int cliques = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n for (int k = j + 1; k < N; k++) {\n for (int l = k + 1; l < N; l++) {\n if (adj[i][j] && adj[i][k] && adj[i][l] && \n adj[j][k] && adj[j][l] && adj[k][l]) {\n cliques++;\n }\n }\n }\n }\n }\n return cliques;\n }\n \n // Count connected components\n int count_components() const {\n vector visited(N, false);\n int components = 0;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n components++;\n // BFS\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n }\n }\n return components;\n }\n \n // Get component sizes\n vector get_component_sizes() const {\n vector visited(N, false);\n vector sizes;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n int size = 0;\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n size++;\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n sizes.push_back(size);\n }\n }\n sort(sizes.begin(), sizes.end());\n return sizes;\n }\n};\n\n// Features for graph classification\nstruct GraphFeatures {\n int edge_count;\n vector degree_sequence;\n int triangle_count;\n int four_clique_count;\n int component_count;\n vector component_sizes;\n double avg_degree;\n int max_degree;\n int min_degree;\n \n GraphFeatures(const Graph& g) {\n edge_count = g.count_edges();\n degree_sequence = g.get_degree_sequence();\n triangle_count = g.count_triangles();\n four_clique_count = g.count_4cliques();\n component_count = g.count_components();\n component_sizes = g.get_component_sizes();\n avg_degree = 2.0 * edge_count / g.N;\n \n if (!degree_sequence.empty()) {\n max_degree = *max_element(degree_sequence.begin(), degree_sequence.end());\n min_degree = *min_element(degree_sequence.begin(), degree_sequence.end());\n } else {\n max_degree = min_degree = 0;\n }\n }\n};\n\n// Calculate distance between two feature sets\ndouble distance(const GraphFeatures& f1, const GraphFeatures& f2, double epsilon) {\n double d = 0.0;\n \n // Edge count difference - most basic but noisy\n // Expected error: epsilon * total_possible_edges\n double edge_weight = 1.0;\n if (epsilon > 0.2) {\n edge_weight = 0.5; // Less reliable at high noise\n }\n d += abs(f1.edge_count - f2.edge_count) * edge_weight;\n \n // Degree sequence difference (L1 distance)\n // More robust than raw edge count\n double degree_weight = 2.0 - epsilon; // More weight at higher noise\n for (int i = 0; i < min(f1.degree_sequence.size(), f2.degree_sequence.size()); i++) {\n d += abs(f1.degree_sequence[i] - f2.degree_sequence[i]) * degree_weight;\n }\n \n // Triangle count difference - very robust feature\n double triangle_weight = 5.0 * (1.0 + epsilon); // Triangles are robust indicators\n d += abs(f1.triangle_count - f2.triangle_count) * triangle_weight;\n \n // 4-clique count difference - even more robust\n double clique_weight = 10.0 * (1.0 + epsilon);\n d += abs(f1.four_clique_count - f2.four_clique_count) * clique_weight;\n \n // Component count - very robust to noise\n double component_weight = 8.0;\n d += abs(f1.component_count - f2.component_count) * component_weight;\n \n // Component sizes\n double comp_size_weight = 3.0;\n for (int i = 0; i < min(f1.component_sizes.size(), f2.component_sizes.size()); i++) {\n d += abs(f1.component_sizes[i] - f2.component_sizes[i]) * comp_size_weight;\n }\n \n // Max/Min degree\n double degree_extreme_weight = 2.0;\n d += abs(f1.max_degree - f2.max_degree) * degree_extreme_weight;\n d += abs(f1.min_degree - f2.min_degree) * degree_extreme_weight;\n \n return d;\n}\n\n// Generate a more distinctive graph for index k\nGraph generate_distinctive_graph(int N, int k, int M) {\n Graph g(N);\n \n // Calculate target edge density based on k\n double density = (k + 0.5) / M;\n int total_possible = N * (N - 1) / 2;\n int target_edges = (int)(density * total_possible);\n \n // Use different generation strategies based on k\n int strategy = k % 8;\n \n if (strategy == 0) {\n // Star-based with additional edges\n int center = k % N;\n for (int i = 0; i < N; i++) {\n if (i != center && g.count_edges() < target_edges) {\n g.add_edge(center, i);\n }\n }\n // Add some random edges to reach target\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 1; j < N && g.count_edges() < target_edges; j++) {\n if (i != center && j != center && !g.has_edge(i, j)) {\n if ((i * j + k) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n }\n else if (strategy == 1) {\n // Path-based with shortcuts\n for (int i = 0; i < N - 1; i++) {\n g.add_edge(i, i + 1);\n }\n // Add shortcuts\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 4 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 2) {\n // Cycle-based\n for (int i = 0; i < N; i++) {\n g.add_edge(i, (i + 1) % N);\n }\n // Add chords\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if ((i * 2 + j + k) % 5 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 3) {\n // Complete graph on subset\n int subset_size = min(N, (int)sqrt(2 * target_edges) + 2);\n for (int i = 0; i < subset_size; i++) {\n for (int j = i + 1; j < subset_size; j++) {\n if (g.count_edges() < target_edges) {\n g.add_edge(i, j);\n }\n }\n }\n // Add edges to other vertices\n for (int i = 0; i < subset_size && g.count_edges() < target_edges; i++) {\n for (int j = subset_size; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 4) {\n // Bipartite-like structure\n int split = N / 2;\n for (int i = 0; i < split; i++) {\n for (int j = split; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 2 == 0 || g.count_edges() < target_edges * 0.7) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (strategy == 5) {\n // Random with high clustering\n mt19937 rng(k * 12345 + 6789);\n vector> edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n edges.push_back({i, j});\n }\n }\n \n // Prefer edges that create triangles\n shuffle(edges.begin(), edges.end(), rng);\n for (auto& e : edges) {\n if (g.count_edges() >= target_edges) break;\n \n // Check if adding this edge creates triangles\n int triangles_created = 0;\n for (int v = 0; v < N; v++) {\n if (v != e.first && v != e.second && \n g.has_edge(e.first, v) && g.has_edge(e.second, v)) {\n triangles_created++;\n }\n }\n \n // Higher probability to add if creates triangles\n if (triangles_created > 0 || rng() % 3 == 0) {\n g.add_edge(e.first, e.second);\n }\n }\n }\n else if (strategy == 6) {\n // Tree-like with additional edges\n // Create a tree first\n for (int i = 1; i < N; i++) {\n int parent = (i + k) % i;\n g.add_edge(i, parent);\n }\n // Add additional edges\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if (abs(i - j) > 1 && (i * j + k) % 4 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else { // strategy == 7\n // Grid-like structure if possible\n int rows = (int)sqrt(N);\n int cols = N / rows;\n if (rows * cols < N) cols++;\n \n for (int i = 0; i < N; i++) {\n int r = i / cols;\n int c = i % cols;\n \n // Right neighbor\n if (c + 1 < cols && r * cols + c + 1 < N) {\n int j = r * cols + c + 1;\n if (g.count_edges() < target_edges) {\n g.add_edge(i, j);\n }\n }\n // Down neighbor\n if (r + 1 < rows && (r + 1) * cols + c < N) {\n int j = (r + 1) * cols + c;\n if (g.count_edges() < target_edges) {\n g.add_edge(i, j);\n }\n }\n // Diagonal neighbor (for extra edges)\n if (c + 1 < cols && r + 1 < rows && (r + 1) * cols + c + 1 < N && \n g.count_edges() < target_edges && (i + k) % 3 == 0) {\n int j = (r + 1) * cols + c + 1;\n g.add_edge(i, j);\n }\n }\n }\n \n // Ensure we have enough distinctive features\n // Add specific patterns based on k for identification\n int pattern_id = k % 20;\n \n if (N >= 3) {\n // Create different triangle patterns\n if (pattern_id < 5) {\n // Create 1 triangle\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n } else if (pattern_id < 10) {\n // Create 2 triangles sharing an edge\n if (N >= 4) {\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n g.add_edge(1, 3);\n g.add_edge(3, 2);\n }\n } else if (pattern_id < 15) {\n // Create 3 triangles sharing a vertex\n if (N >= 4) {\n g.add_edge(0, 1);\n g.add_edge(0, 2);\n g.add_edge(0, 3);\n g.add_edge(1, 2);\n g.add_edge(2, 3);\n g.add_edge(3, 1);\n }\n } else {\n // Create 4-clique if possible\n if (N >= 4) {\n for (int i = 0; i < min(4, N); i++) {\n for (int j = i + 1; j < min(4, N); j++) {\n g.add_edge(i, j);\n }\n }\n }\n }\n }\n \n // Make sure we don't exceed target too much\n if (g.count_edges() > target_edges + N) {\n // Remove random edges if we have too many\n mt19937 rng(k * 98765 + 4321);\n for (int i = 0; i < N && g.count_edges() > target_edges; i++) {\n for (int j = i + 1; j < N && g.count_edges() > target_edges; j++) {\n if (g.has_edge(i, j) && rng() % 5 == 0) {\n g.remove_edge(i, j);\n }\n }\n }\n }\n \n return g;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Choose N more intelligently based on M and epsilon\n int N;\n \n if (epsilon <= 0.1) {\n // Low noise, can use smaller N\n N = 20 + (M / 20) * 5;\n } else if (epsilon <= 0.2) {\n // Medium noise\n N = 30 + (M / 20) * 5;\n } else if (epsilon <= 0.3) {\n // High noise\n N = 40 + (M / 20) * 5;\n } else {\n // Very high noise\n N = 50 + (M / 20) * 5;\n }\n \n // Ensure bounds\n N = max(15, min(80, N));\n \n // Special cases for very large M\n if (M > 80) {\n N = max(N, 60);\n }\n \n cout << N << endl;\n \n // Generate M graphs\n vector graphs;\n vector features;\n \n for (int k = 0; k < M; k++) {\n Graph g = generate_distinctive_graph(N, k, M);\n graphs.push_back(g);\n features.push_back(GraphFeatures(g));\n \n // Output graph\n cout << g.to_string() << endl;\n cout.flush();\n }\n \n // Process 100 queries\n for (int k = 0; k < 100; k++) {\n string h_str;\n cin >> h_str;\n \n // Parse the graph\n Graph h = Graph::from_string(N, h_str);\n GraphFeatures h_features(h);\n \n // Find the closest graph\n int best_idx = 0;\n double min_dist = 1e15; // Use larger initial value\n \n for (int i = 0; i < M; i++) {\n double dist = distance(h_features, features[i], epsilon);\n if (dist < min_dist) {\n min_dist = dist;\n best_idx = i;\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Graph representation\nstruct Edge {\n int u, v, w, id;\n Edge(int u = 0, int v = 0, int w = 0, int id = 0) : u(u), v(v), w(w), id(id) {}\n};\n\nclass Graph {\npublic:\n int n, m, d, k;\n vector edges;\n vector>> adj; // adjacency list: to, weight\n vector> coords;\n \n Graph(int n = 0, int m = 0, int d = 0, int k = 0) : n(n), m(m), d(d), k(k) {\n adj.resize(n + 1);\n }\n \n void addEdge(int u, int v, int w, int id) {\n edges.emplace_back(u, v, w, id);\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n // Calculate shortest distances from source using Dijkstra\n vector dijkstra(int source, const unordered_set& removed_edges = {}) {\n vector dist(n + 1, 1e18);\n priority_queue, vector>, greater>> pq;\n \n dist[source] = 0;\n pq.emplace(0, source);\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto [v, w] : adj[u]) {\n // Check if edge u-v is removed\n bool edge_removed = false;\n for (int eid : removed_edges) {\n Edge& e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n edge_removed = true;\n break;\n }\n }\n \n if (edge_removed) continue;\n \n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.emplace(dist[v], v);\n }\n }\n }\n \n return dist;\n }\n \n // Calculate frustration for a given day using sampling\n double calculateFrustrationSampling(const vector>& original_apsp, \n const vector& edges_to_remove, int sample_size = 100) {\n if (edges_to_remove.empty()) return 0.0;\n \n unordered_set remove_set(edges_to_remove.begin(), edges_to_remove.end());\n \n // Sample sources and targets\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> vertex_dist(1, n);\n \n vector sources;\n int actual_sample_size = min(sample_size, n);\n for (int i = 0; i < actual_sample_size; i++) {\n sources.push_back(vertex_dist(gen));\n }\n \n // Remove duplicates\n sort(sources.begin(), sources.end());\n sources.erase(unique(sources.begin(), sources.end()), sources.end());\n \n double frustration = 0.0;\n int pairs_count = 0;\n \n for (int source : sources) {\n // Run Dijkstra from source with removed edges\n auto dist = dijkstra(source, remove_set);\n \n // Sample targets\n vector targets;\n int target_sample_size = min(20, n - 1);\n for (int i = 0; i < target_sample_size; i++) {\n int target = vertex_dist(gen);\n if (target != source) {\n targets.push_back(target);\n }\n }\n \n // Remove duplicates\n sort(targets.begin(), targets.end());\n targets.erase(unique(targets.begin(), targets.end()), targets.end());\n \n for (int target : targets) {\n if (source == target) continue;\n \n long long new_dist = dist[target];\n if (new_dist >= 1e18) {\n new_dist = 1000000000; // Unreachable\n }\n \n long long orig_dist = original_apsp[source][target];\n if (orig_dist >= 1e18) orig_dist = 1000000000;\n \n frustration += (new_dist - orig_dist);\n pairs_count++;\n }\n }\n \n if (pairs_count == 0) return 0.0;\n \n // Scale up to approximate full frustration\n double avg_increase = frustration / pairs_count;\n return avg_increase;\n }\n};\n\n// Solution representation\nstruct Solution {\n vector schedule; // schedule[i] = day for edge i (1-indexed days)\n double total_frustration;\n Graph* graph;\n vector> original_apsp;\n \n Solution(Graph* g, const vector>& apsp) : graph(g), original_apsp(apsp) {\n schedule.resize(g->m);\n total_frustration = 0.0;\n }\n \n // Calculate total frustration for the entire schedule using sampling\n double calculateTotalFrustration() {\n double total = 0.0;\n \n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate frustration for each day\n for (int day = 1; day <= graph->d; day++) {\n double day_frustration = graph->calculateFrustrationSampling(original_apsp, edges_by_day[day]);\n total += day_frustration;\n }\n \n total_frustration = total / graph->d;\n return total_frustration;\n }\n \n // Get frustration as integer (rounded)\n long long getScore() {\n return llround(1000.0 * total_frustration);\n }\n \n // Calculate frustration change only for affected days after a swap\n double calculateDeltaFrustration(int idx1, int idx2, int new_day1, int new_day2) {\n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Add the new assignments\n edges_by_day[new_day1].push_back(idx1);\n edges_by_day[new_day2].push_back(idx2);\n \n // Calculate frustration only for the affected days\n double delta = 0.0;\n \n // Get original frustration for old days\n int old_day1 = schedule[idx1];\n int old_day2 = schedule[idx2];\n \n // Calculate new frustration for affected days\n double new_f1 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[new_day1]);\n double new_f2 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[new_day2]);\n \n // Restore original state for old days\n edges_by_day[new_day1].pop_back();\n edges_by_day[new_day2].pop_back();\n edges_by_day[old_day1].push_back(idx1);\n edges_by_day[old_day2].push_back(idx2);\n \n // Calculate old frustration for affected days\n double old_f1 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[old_day1]);\n double old_f2 = graph->calculateFrustrationSampling(original_apsp, edges_by_day[old_day2]);\n \n // Restore for next iterations\n edges_by_day[old_day1].pop_back();\n edges_by_day[old_day2].pop_back();\n \n // Delta frustration\n delta = (new_f1 + new_f2 - old_f1 - old_f2) / graph->d;\n \n return delta;\n }\n};\n\n// Simple heuristic: prioritize edges with high weight (likely more important for shortest paths)\nvector calculateSimpleEdgeImportance(Graph& graph) {\n vector importance(graph.m, 0.0);\n \n for (int i = 0; i < graph.m; i++) {\n // Use edge weight as importance (higher weight = more important)\n // Also consider degree of vertices (edges connecting low-degree vertices might be more critical)\n int u = graph.edges[i].u;\n int v = graph.edges[i].v;\n int w = graph.edges[i].w;\n \n // Simple heuristic: weight * (some factor based on degrees)\n int deg_u = graph.adj[u].size();\n int deg_v = graph.adj[v].size();\n \n // Edges between low-degree vertices are more critical\n importance[i] = w * (1.0 / (deg_u * deg_v));\n }\n \n return importance;\n}\n\n// Optimized local search (simpler than SA)\nvoid localSearch(Solution& solution) {\n auto start_time = chrono::steady_clock::now();\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> edge_dist(0, solution.graph->m - 1);\n uniform_int_distribution<> day_dist(1, solution.graph->d);\n uniform_real_distribution<> prob_dist(0.0, 1.0);\n \n double current_score = solution.calculateTotalFrustration();\n int iterations = 0;\n int max_iterations = 2000; // Greatly reduced from 50000\n \n while (iterations < max_iterations) {\n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n if (elapsed > 4000) break; // More conservative time limit\n \n // Generate a neighbor by swapping two edges between days\n int idx1 = edge_dist(gen);\n int idx2 = edge_dist(gen);\n \n // Ensure different edges\n if (idx1 == idx2) {\n iterations++;\n continue;\n }\n \n int old_day1 = solution.schedule[idx1];\n int old_day2 = solution.schedule[idx2];\n \n // Try swapping days\n int new_day1 = old_day2;\n int new_day2 = old_day1;\n \n // Check constraints (at most K edges per day)\n vector count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n bool valid = true;\n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n // Try moving one edge to a different day\n new_day1 = day_dist(gen);\n new_day2 = old_day2;\n \n // Recalculate counts\n fill(count.begin(), count.end(), 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n valid = true;\n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n iterations++;\n continue;\n }\n }\n \n // Calculate delta frustration (only for affected days)\n double delta = solution.calculateDeltaFrustration(idx1, idx2, new_day1, new_day2);\n \n // Accept improvement\n if (delta < 0) {\n solution.schedule[idx1] = new_day1;\n solution.schedule[idx2] = new_day2;\n current_score += delta;\n }\n \n iterations++;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int n, m, d, k;\n cin >> n >> m >> d >> k;\n \n Graph graph(n, m, d, k);\n \n // Read edges\n for (int i = 0; i < m; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n graph.addEdge(u, v, w, i);\n }\n \n // Read coordinates\n for (int i = 0; i < n; i++) {\n int x, y;\n cin >> x >> y;\n graph.coords.emplace_back(x, y);\n }\n \n // Calculate original all pairs shortest paths (but only for sampling)\n // Use sampling to estimate APSP instead of computing all pairs\n auto start_time = chrono::steady_clock::now();\n \n // Compute APSP for a sample of vertices only\n vector> original_apsp(n + 1, vector(n + 1, 1e18));\n \n // Sample 50 vertices for APSP calculation\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> vertex_dist(1, n);\n \n vector sample_vertices;\n int sample_size = min(50, n);\n for (int i = 0; i < sample_size; i++) {\n sample_vertices.push_back(vertex_dist(gen));\n }\n \n // Remove duplicates\n sort(sample_vertices.begin(), sample_vertices.end());\n sample_vertices.erase(unique(sample_vertices.begin(), sample_vertices.end()), sample_vertices.end());\n \n // Calculate shortest paths only for sampled vertices\n for (int source : sample_vertices) {\n auto dist = graph.dijkstra(source);\n for (int j = 1; j <= n; j++) {\n original_apsp[source][j] = dist[j];\n }\n }\n \n // Calculate simple edge importance\n auto importance = calculateSimpleEdgeImportance(graph);\n \n // Create initial solution\n Solution solution(&graph, original_apsp);\n \n // Sort edges by importance\n vector> edge_importance;\n for (int i = 0; i < m; i++) {\n edge_importance.emplace_back(importance[i], i);\n }\n \n // Sort by importance (descending)\n sort(edge_importance.rbegin(), edge_importance.rend());\n \n // Greedy scheduling with round-robin distribution\n vector day_count(d + 1, 0);\n \n for (int i = 0; i < m; i++) {\n int edge_id = edge_importance[i].second;\n \n // Use round-robin to distribute edges\n int day = (i % d) + 1;\n \n // If this day is full, find next available day\n int attempts = 0;\n while (day_count[day] >= k && attempts < d) {\n day = (day % d) + 1;\n attempts++;\n }\n \n // If still full, pick day with minimum count\n if (day_count[day] >= k) {\n int min_day = 1;\n for (int j = 1; j <= d; j++) {\n if (day_count[j] < day_count[min_day]) {\n min_day = j;\n }\n }\n day = min_day;\n }\n \n solution.schedule[edge_id] = day;\n day_count[day]++;\n }\n \n // Check if we have time for local search\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n \n if (elapsed < 3000) { // More conservative time check\n localSearch(solution);\n }\n \n // Output the solution\n for (int i = 0; i < m; i++) {\n if (i > 0) cout << \" \";\n cout << solution.schedule[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y, z;\n Point(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(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 bool operator==(const Point& other) const {\n return x == other.x && y == other.y && z == other.z;\n }\n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y, z + other.z);\n }\n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y, z - other.z);\n }\n};\n\nnamespace std {\n template<>\n struct hash {\n size_t operator()(const Point& p) const {\n return hash()(p.x) ^ hash()(p.y) ^ hash()(p.z);\n }\n };\n}\n\n// Directions for 6-connected (face-to-face) polycubes\nconst int dx[6] = {1, -1, 0, 0, 0, 0};\nconst int dy[6] = {0, 0, 1, -1, 0, 0};\nconst int dz[6] = {0, 0, 0, 0, 1, -1};\n\nint D;\nvector f1, r1, f2, r2;\n\nbool inBounds(const Point& p) {\n return p.x >= 0 && p.x < D && p.y >= 0 && p.y < D && p.z >= 0 && p.z < D;\n}\n\nvector getNeighbors(const Point& p) {\n vector neighbors;\n for (int i = 0; i < 6; i++) {\n Point np(p.x + dx[i], p.y + dy[i], p.z + dz[i]);\n if (inBounds(np)) {\n neighbors.push_back(np);\n }\n }\n return neighbors;\n}\n\nint toIndex(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nPoint fromIndex(int idx) {\n int x = idx / (D * D);\n int y = (idx % (D * D)) / D;\n int z = idx % D;\n return Point(x, y, z);\n}\n\nvector normalize(const vector& points) {\n if (points.empty()) return points;\n \n int min_x = points[0].x, min_y = points[0].y, min_z = points[0].z;\n for (const Point& p : points) {\n min_x = min(min_x, p.x);\n min_y = min(min_y, p.y);\n min_z = min(min_z, p.z);\n }\n \n vector normalized;\n for (const Point& p : points) {\n normalized.push_back(Point(p.x - min_x, p.y - min_y, p.z - min_z));\n }\n return normalized;\n}\n\nvector> generateRotations(const vector& shape) {\n if (shape.empty()) return {shape};\n \n vector normalized = normalize(shape);\n vector> rotations;\n \n // 24 rotation matrices for 3D\n int rotations_3d[24][9] = {\n {1,0,0, 0,1,0, 0,0,1}, {1,0,0, 0,0,-1, 0,1,0}, {1,0,0, 0,-1,0, 0,0,-1}, {1,0,0, 0,0,1, 0,-1,0},\n {-1,0,0, 0,-1,0, 0,0,1}, {-1,0,0, 0,0,-1, 0,-1,0}, {-1,0,0, 0,1,0, 0,0,-1}, {-1,0,0, 0,0,1, 0,1,0},\n {0,-1,0, 1,0,0, 0,0,1}, {0,0,1, 1,0,0, 0,1,0}, {0,1,0, -1,0,0, 0,0,1}, {0,0,-1, -1,0,0, 0,1,0},\n {0,1,0, 1,0,0, 0,0,-1}, {0,0,-1, -1,0,0, 0,-1,0}, {0,-1,0, -1,0,0, 0,0,-1}, {0,0,1, 1,0,0, 0,-1,0},\n {0,1,0, 0,0,1, 1,0,0}, {0,0,1, 0,-1,0, 1,0,0}, {0,-1,0, 0,0,-1, 1,0,0}, {0,0,-1, 0,1,0, 1,0,0},\n {0,-1,0, 0,0,1, -1,0,0}, {0,0,-1, 0,-1,0, -1,0,0}, {0,1,0, 0,0,-1, -1,0,0}, {0,0,1, 0,1,0, -1,0,0}\n };\n \n for (int i = 0; i < 24; i++) {\n vector rotated;\n for (const Point& p : normalized) {\n int nx = rotations_3d[i][0] * p.x + rotations_3d[i][1] * p.y + rotations_3d[i][2] * p.z;\n int ny = rotations_3d[i][3] * p.x + rotations_3d[i][4] * p.y + rotations_3d[i][5] * p.z;\n int nz = rotations_3d[i][6] * p.x + rotations_3d[i][7] * p.y + rotations_3d[i][8] * p.z;\n rotated.push_back(Point(nx, ny, nz));\n }\n rotations.push_back(normalize(rotated));\n }\n \n // Remove duplicates\n vector> unique_rotations;\n set> seen;\n \n for (auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (seen.find(rot_set) == seen.end()) {\n seen.insert(rot_set);\n unique_rotations.push_back(rot);\n }\n }\n \n return unique_rotations;\n}\n\nbool shapesMatch(const vector& shape1, const vector& shape2) {\n if (shape1.size() != shape2.size()) return false;\n \n auto rotations = generateRotations(shape1);\n auto normalized2 = normalize(shape2);\n set set2(normalized2.begin(), normalized2.end());\n \n for (const auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (rot_set == set2) {\n return true;\n }\n }\n \n return false;\n}\n\n// Check if a set of points forms a connected component\nbool isConnected(const vector& points) {\n if (points.empty() || points.size() == 1) return true;\n \n set pointSet(points.begin(), points.end());\n map visited;\n \n // Start BFS from the first point\n queue q;\n q.push(points[0]);\n visited[points[0]] = true;\n int visitedCount = 1;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (pointSet.find(neighbor) != pointSet.end() && !visited[neighbor]) {\n visited[neighbor] = true;\n visitedCount++;\n q.push(neighbor);\n }\n }\n }\n \n return visitedCount == points.size();\n}\n\n// Split a potentially disconnected set of points into connected components\nvector> splitIntoConnectedComponents(const vector& points) {\n if (points.empty()) return {};\n if (points.size() == 1) return {points};\n \n set pointSet(points.begin(), points.end());\n map visited;\n vector> components;\n \n for (const Point& p : points) {\n if (visited[p]) continue;\n \n // BFS to find connected component\n vector component;\n queue q;\n q.push(p);\n visited[p] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (pointSet.find(neighbor) != pointSet.end() && !visited[neighbor]) {\n visited[neighbor] = true;\n q.push(neighbor);\n }\n }\n }\n \n components.push_back(component);\n }\n \n return components;\n}\n\nint main() {\n cin >> D;\n f1.resize(D);\n r1.resize(D);\n f2.resize(D);\n r2.resize(D);\n \n for (int i = 0; i < D; i++) {\n cin >> f1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> f2[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r2[i];\n }\n \n // Determine which positions must be filled for each arrangement\n vector>> mustFill1(D, vector>(D, vector(D, false)));\n vector>> mustFill2(D, vector>(D, vector(D, false)));\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f1[z][x] == '1' && r1[z][y] == '1') {\n mustFill1[x][y][z] = true;\n }\n if (f2[z][x] == '1' && r2[z][y] == '1') {\n mustFill2[x][y][z] = true;\n }\n }\n }\n }\n \n // Identify common positions\n vector>> common(D, vector>(D, vector(D, false)));\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && mustFill2[x][y][z]) {\n common[x][y][z] = true;\n }\n }\n }\n }\n \n // Create blocks - prioritize common positions\n vector blockId1(D * D * D, 0);\n vector blockId2(D * D * D, 0);\n \n // First, create large blocks from common positions\n vector>> visitedCommon(D, vector>(D, vector(D, false)));\n int blockCount = 0;\n \n // Process common positions first\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (common[x][y][z] && !visitedCommon[x][y][z]) {\n // Grow a large block using BFS\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visitedCommon[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n // Look for neighbors in common positions\n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (!visitedCommon[neighbor.x][neighbor.y][neighbor.z] && \n common[neighbor.x][neighbor.y][neighbor.z]) {\n visitedCommon[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n // Assign to both arrangements\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId1[idx] = blockCount;\n blockId2[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n \n // Process remaining positions in arrangement 1\n vector>> visited1 = visitedCommon;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && !visited1[x][y][z]) {\n // Try to extend existing blocks first\n bool extended = false;\n vector neighbors = getNeighbors(Point(x, y, z));\n \n // Group neighbors by block ID\n map> neighborBlocks;\n for (const Point& neighbor : neighbors) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (blockId1[nidx] != 0) {\n neighborBlocks[blockId1[nidx]].push_back(neighbor);\n }\n }\n \n // Try to extend to the largest neighboring block\n int bestBlockId = 0;\n int maxSize = 0;\n for (auto& kv : neighborBlocks) {\n if (kv.second.size() > 0) { // Prefer blocks with more adjacent cubes\n if (kv.second.size() > maxSize) {\n maxSize = kv.second.size();\n bestBlockId = kv.first;\n }\n }\n }\n \n if (bestBlockId != 0) {\n blockId1[toIndex(x, y, z)] = bestBlockId;\n visited1[x][y][z] = true;\n extended = true;\n }\n \n if (!extended) {\n // Create new block\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited1[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector localNeighbors = getNeighbors(curr);\n for (const Point& neighbor : localNeighbors) {\n if (!visited1[neighbor.x][neighbor.y][neighbor.z] && \n mustFill1[neighbor.x][neighbor.y][neighbor.z]) {\n visited1[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId1[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n }\n \n // Process remaining positions in arrangement 2\n vector>> visited2 = visitedCommon;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill2[x][y][z] && !visited2[x][y][z]) {\n // Try to extend existing blocks first\n bool extended = false;\n vector neighbors = getNeighbors(Point(x, y, z));\n \n // Group neighbors by block ID\n map> neighborBlocks;\n for (const Point& neighbor : neighbors) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (blockId2[nidx] != 0) {\n neighborBlocks[blockId2[nidx]].push_back(neighbor);\n }\n }\n \n // Try to extend to the largest neighboring block\n int bestBlockId = 0;\n int maxSize = 0;\n for (auto& kv : neighborBlocks) {\n if (kv.second.size() > 0) {\n if (kv.second.size() > maxSize) {\n maxSize = kv.second.size();\n bestBlockId = kv.first;\n }\n }\n }\n \n if (bestBlockId != 0) {\n blockId2[toIndex(x, y, z)] = bestBlockId;\n visited2[x][y][z] = true;\n extended = true;\n }\n \n if (!extended) {\n // Create new block\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited2[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector localNeighbors = getNeighbors(curr);\n for (const Point& neighbor : localNeighbors) {\n if (!visited2[neighbor.x][neighbor.y][neighbor.z] && \n mustFill2[neighbor.x][neighbor.y][neighbor.z]) {\n visited2[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId2[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n }\n \n // Now ensure shape consistency and connectivity\n // For each block ID, extract its shape in both arrangements\n vector> shapes1(blockCount + 1);\n vector> shapes2(blockCount + 1);\n \n for (int i = 0; i < D * D * D; i++) {\n Point p = fromIndex(i);\n if (blockId1[i] != 0) {\n shapes1[blockId1[i]].push_back(p);\n }\n if (blockId2[i] != 0) {\n shapes2[blockId2[i]].push_back(p);\n }\n }\n \n // Verify connectivity and fix if needed\n vector finalBlockId1(D * D * D, 0);\n vector finalBlockId2(D * D * D, 0);\n int finalBlockCount = 0;\n vector blockRemapping(blockCount + 1, 0);\n \n // Process each block\n for (int i = 1; i <= blockCount; i++) {\n // Check connectivity for arrangement 1\n if (!shapes1[i].empty() && !isConnected(shapes1[i])) {\n // Split into connected components\n auto components = splitIntoConnectedComponents(shapes1[i]);\n for (const auto& component : components) {\n finalBlockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n }\n } else if (!shapes1[i].empty()) {\n // Connected, assign block ID\n finalBlockCount++;\n blockRemapping[i] = finalBlockCount;\n for (const Point& p : shapes1[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n }\n \n // Check connectivity for arrangement 2\n if (!shapes2[i].empty() && !isConnected(shapes2[i])) {\n // Split into connected components\n auto components = splitIntoConnectedComponents(shapes2[i]);\n for (const auto& component : components) {\n finalBlockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n } else if (!shapes2[i].empty() && blockRemapping[i] != 0) {\n // Check if shapes match for blocks that appear in both arrangements\n vector shape1 = shapes1[i];\n vector shape2 = shapes2[i];\n \n if (shapesMatch(shape1, shape2)) {\n // Shapes match, use same block ID\n for (const Point& p : shape2) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = blockRemapping[i];\n }\n } else {\n // Shapes don't match, create new block\n finalBlockCount++;\n for (const Point& p : shape2) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n } else if (!shapes2[i].empty() && blockRemapping[i] == 0) {\n // Block only in arrangement 2\n finalBlockCount++;\n for (const Point& p : shapes2[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n }\n \n // For blocks that were split in arrangement 1 but not in arrangement 2, fix arrangement 2\n for (int i = 1; i <= blockCount; i++) {\n if (!shapes1[i].empty() && !shapes2[i].empty()) {\n // If block was split in arrangement 1, need to handle arrangement 2 accordingly\n if (!isConnected(shapes1[i]) && isConnected(shapes2[i])) {\n // Check shape matching for each connected component of arrangement 1 with arrangement 2\n auto components = splitIntoConnectedComponents(shapes1[i]);\n \n // Try to match components with arrangement 2\n for (const auto& component : components) {\n if (shapesMatch(component, shapes2[i])) {\n // Found a match, update arrangement 2 to use the same block ID as this component\n for (const Point& p : shapes2[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n // Find the block ID assigned to this component in arrangement 1\n if (finalBlockId1[toIndex(component[0].x, component[0].y, component[0].z)] != 0) {\n int matchedId = finalBlockId1[toIndex(component[0].x, component[0].y, component[0].z)];\n finalBlockId2[idx] = matchedId;\n }\n }\n break;\n }\n }\n }\n }\n }\n \n // Output\n cout << finalBlockCount << endl;\n \n // Output first arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << finalBlockId1[i];\n }\n cout << endl;\n \n // Output second arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << finalBlockId2[i];\n }\n cout << endl;\n \n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef long long ll;\n\nstruct Point {\n ll x, y;\n Point(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\nll distance_squared(const Point& a, const Point& b) {\n ll dx = a.x - b.x;\n ll dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\nll distance_rounded(const Point& a, const Point& b) {\n return ll(round(sqrt(distance_squared(a, b))));\n}\n\nstruct Edge {\n int u, v;\n ll weight;\n int index;\n Edge(int u = 0, int v = 0, ll weight = 0, int index = 0) : u(u), v(v), weight(weight), index(index) {}\n};\n\nstruct Resident {\n ll x, y;\n Resident(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\n// Union-Find for MST\nstruct UnionFind {\n vector parent, rank;\n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) parent[x] = y;\n else {\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n }\n bool same(int x, int y) {\n return find(x) == find(y);\n }\n};\n\n// Dijkstra for shortest path\nvector dijkstra(const vector>>& graph, int start, int n) {\n vector dist(n + 1, LLONG_MAX);\n priority_queue, vector>, greater>> pq;\n \n dist[start] = 0;\n pq.push({0, start});\n \n while (!pq.empty()) {\n ll d = pq.top().first;\n int u = pq.top().second;\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto& edge : graph[u]) {\n int v = edge.first;\n ll w = edge.second;\n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.push({dist[v], v});\n }\n }\n }\n \n return dist;\n}\n\n// Calculate total cost for a solution\nll calculateTotalCost(const vector& P, const vector& B, const vector& edges) {\n ll cost = 0;\n // Add power costs\n for (size_t i = 1; i < P.size(); ++i) {\n cost += P[i] * P[i];\n }\n // Add cable costs\n for (size_t j = 1; j < B.size(); ++j) {\n if (B[j] == 1) {\n cost += edges[j-1].weight;\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n cin >> N >> M >> K;\n \n vector stations(N + 1);\n for (int i = 1; i <= N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges;\n for (int j = 1; j <= M; ++j) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n edges.push_back(Edge(u, v, w, j));\n }\n \n vector residents(K + 1);\n for (int k = 1; k <= K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // For each resident, find the minimum radius needed from each station\n vector> minRadius(N + 1, vector(K + 1, 0));\n for (int i = 1; i <= N; ++i) {\n for (int k = 1; k <= K; ++k) {\n minRadius[i][k] = distance_rounded(\n Point(stations[i].x, stations[i].y), \n Point(residents[k].x, residents[k].y)\n );\n }\n }\n \n // Output strengths for each station\n vector P(N + 1, 0);\n \n // Edge power status\n vector B(M + 1, 0);\n \n // Build adjacency list for the graph\n vector>> graph(N + 1);\n for (auto& e : edges) {\n graph[e.u].push_back({e.v, e.weight});\n graph[e.v].push_back({e.u, e.weight});\n }\n \n // Calculate shortest distances from station 1 to all other stations\n vector distFrom1 = dijkstra(graph, 1, N);\n \n // Try multiple strategies and pick the best one\n \n // Strategy 1: Greedy by total cost (cable + power)\n vector P1(N + 1, 0);\n vector B1(M + 1, 0);\n \n // For each resident, calculate the total cost of covering them through each station\n vector>> residentCoverage(K + 1);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (distFrom1[i] != LLONG_MAX && minRadius[i][k] <= 5000) {\n ll powerCost = minRadius[i][k] * minRadius[i][k];\n ll totalCost = distFrom1[i] + powerCost;\n residentCoverage[k].push_back({totalCost, i});\n }\n }\n sort(residentCoverage[k].begin(), residentCoverage[k].end());\n }\n \n // Assign residents to stations\n vector> assignedResidents(N + 1);\n for (int k = 1; k <= K; ++k) {\n if (!residentCoverage[k].empty()) {\n int bestStation = residentCoverage[k][0].second;\n assignedResidents[bestStation].push_back(k);\n P1[bestStation] = max(P1[bestStation], minRadius[bestStation][k]);\n }\n }\n \n // Mark stations that need to be activated\n vector stationActivated(N + 1, false);\n for (int i = 1; i <= N; ++i) {\n if (!assignedResidents[i].empty()) {\n stationActivated[i] = true;\n }\n }\n stationActivated[1] = true;\n \n // Build MST to connect activated stations\n UnionFind uf(N + 1);\n vector inTree(N + 1, false);\n inTree[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (stationActivated[i]) {\n inTree[i] = true;\n }\n }\n \n // Sort edges by weight\n vector>> weightedEdges;\n for (auto& e : edges) {\n weightedEdges.push_back({e.weight, {e.u, e.v}});\n }\n sort(weightedEdges.begin(), weightedEdges.end());\n \n // Kruskal's algorithm for MST\n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree[u] && stationActivated[v]) || \n (inTree[v] && stationActivated[u]) ||\n (inTree[u] && inTree[v])) {\n if (!uf.same(u, v)) {\n uf.unite(u, v);\n inTree[u] = true;\n inTree[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B1[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity to station 1\n for (int i = 2; i <= N; ++i) {\n if (stationActivated[i] && !uf.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf.same(1, e.v)) || (e.v == i && uf.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B1[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf.unite(u, v);\n }\n }\n }\n \n // Strategy 2: Cluster-based approach\n vector P2(N + 1, 0);\n vector B2(M + 1, 0);\n \n // Group residents by proximity to stations\n vector> stationGroups(N + 1);\n for (int k = 1; k <= K; ++k) {\n int bestStation = 1;\n ll minDist = minRadius[1][k];\n \n for (int i = 2; i <= N; ++i) {\n if (minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n stationGroups[bestStation].push_back(k);\n }\n \n // Activate stations that have residents assigned\n vector activated2(N + 1, false);\n activated2[1] = true;\n \n for (int i = 1; i <= N; ++i) {\n if (!stationGroups[i].empty()) {\n activated2[i] = true;\n // Calculate required power for this station\n for (int k : stationGroups[i]) {\n P2[i] = max(P2[i], minRadius[i][k]);\n }\n }\n }\n \n // Connect activated stations with MST\n UnionFind uf2(N + 1);\n vector inTree2(N + 1, false);\n inTree2[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (activated2[i]) {\n inTree2[i] = true;\n }\n }\n \n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree2[u] && activated2[v]) || \n (inTree2[v] && activated2[u]) ||\n (inTree2[u] && inTree2[v])) {\n if (!uf2.same(u, v)) {\n uf2.unite(u, v);\n inTree2[u] = true;\n inTree2[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B2[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity\n for (int i = 2; i <= N; ++i) {\n if (activated2[i] && !uf2.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf2.same(1, e.v)) || (e.v == i && uf2.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B2[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf2.unite(u, v);\n }\n }\n }\n \n // Strategy 3: Balanced approach - minimize sum of squares with constraint on cable cost\n vector P3(N + 1, 0);\n vector B3(M + 1, 0);\n \n // For each station, calculate efficiency: residents covered per power cost\n vector> stationEfficiency;\n for (int i = 1; i <= N; ++i) {\n if (i == 1) continue; // Always include station 1\n \n // Calculate how many residents this station can cover with reasonable power\n int residentsCovered = 0;\n ll minPowerNeeded = 0;\n \n for (int k = 1; k <= K; ++k) {\n if (minRadius[i][k] <= 2000) { // Reasonable radius\n residentsCovered++;\n minPowerNeeded = max(minPowerNeeded, minRadius[i][k]);\n }\n }\n \n if (residentsCovered > 0 && distFrom1[i] != LLONG_MAX) {\n double efficiency = (double)residentsCovered / (double)(minPowerNeeded * minPowerNeeded + distFrom1[i]);\n stationEfficiency.push_back({efficiency, i});\n }\n }\n \n // Sort by efficiency (descending)\n sort(stationEfficiency.rbegin(), stationEfficiency.rend());\n \n // Greedily select stations based on efficiency\n vector activated3(N + 1, false);\n activated3[1] = true;\n vector residentCovered3(K + 1, false);\n \n // Start by covering residents with station 1\n for (int k = 1; k <= K; ++k) {\n if (minRadius[1][k] <= 5000) {\n P3[1] = max(P3[1], minRadius[1][k]);\n residentCovered3[k] = true;\n }\n }\n \n // Add stations based on efficiency until all residents are covered\n for (auto& eff : stationEfficiency) {\n int i = eff.second;\n \n // Check if we still need to cover residents\n bool allCovered = true;\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k]) {\n allCovered = false;\n break;\n }\n }\n if (allCovered) break;\n \n // Check if this station can cover uncovered residents\n bool canCover = false;\n ll requiredPower = 0;\n \n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k] && minRadius[i][k] <= 5000) {\n canCover = true;\n requiredPower = max(requiredPower, minRadius[i][k]);\n }\n }\n \n if (canCover) {\n activated3[i] = true;\n P3[i] = requiredPower;\n \n // Mark covered residents\n for (int k = 1; k <= K; ++k) {\n if (minRadius[i][k] <= requiredPower) {\n residentCovered3[k] = true;\n }\n }\n }\n }\n \n // For any remaining uncovered residents, assign to closest activated station\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k]) {\n ll minDist = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (activated3[i] && minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n \n if (bestStation != -1) {\n P3[bestStation] = max(P3[bestStation], minDist);\n residentCovered3[k] = true;\n }\n }\n }\n \n // Connect activated stations with MST\n UnionFind uf3(N + 1);\n vector inTree3(N + 1, false);\n inTree3[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (activated3[i]) {\n inTree3[i] = true;\n }\n }\n \n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree3[u] && activated3[v]) || \n (inTree3[v] && activated3[u]) ||\n (inTree3[u] && inTree3[v])) {\n if (!uf3.same(u, v)) {\n uf3.unite(u, v);\n inTree3[u] = true;\n inTree3[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B3[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity\n for (int i = 2; i <= N; ++i) {\n if (activated3[i] && !uf3.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf3.same(1, e.v)) || (e.v == i && uf3.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B3[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf3.unite(u, v);\n }\n }\n }\n \n // Calculate costs for each strategy\n ll cost1 = calculateTotalCost(P1, B1, edges);\n ll cost2 = calculateTotalCost(P2, B2, edges);\n ll cost3 = calculateTotalCost(P3, B3, edges);\n \n // Verify coverage for each strategy\n auto verifyCoverage = [&](const vector& P, const vector& inTree) -> bool {\n vector covered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (inTree[i] && minRadius[i][k] <= P[i]) {\n covered[k] = true;\n break;\n }\n }\n }\n \n for (int k = 1; k <= K; ++k) {\n if (!covered[k]) return false;\n }\n return true;\n };\n \n vector inTree1(N + 1, false);\n for (int i = 1; i <= N; ++i) {\n inTree1[i] = (i == 1) || stationActivated[i];\n }\n // Update inTree1 based on actual connectivity\n UnionFind uf_check1(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B1[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check1.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree1[i] = uf_check1.same(1, i);\n }\n \n vector inTree2_vec(N + 1, false);\n UnionFind uf_check2(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B2[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check2.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree2_vec[i] = uf_check2.same(1, i);\n }\n \n vector inTree3_vec(N + 1, false);\n UnionFind uf_check3(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B3[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check3.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree3_vec[i] = uf_check3.same(1, i);\n }\n \n bool coverage1 = verifyCoverage(P1, inTree1);\n bool coverage2 = verifyCoverage(P2, inTree2_vec);\n bool coverage3 = verifyCoverage(P3, inTree3_vec);\n \n // Choose the best strategy\n if (coverage1 && coverage2 && coverage3) {\n if (cost1 <= cost2 && cost1 <= cost3) {\n P = P1;\n B = B1;\n } else if (cost2 <= cost1 && cost2 <= cost3) {\n P = P2;\n B = B2;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage1 && coverage2) {\n if (cost1 <= cost2) {\n P = P1;\n B = B1;\n } else {\n P = P2;\n B = B2;\n }\n } else if (coverage1 && coverage3) {\n if (cost1 <= cost3) {\n P = P1;\n B = B1;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage2 && coverage3) {\n if (cost2 <= cost3) {\n P = P2;\n B = B2;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage1) {\n P = P1;\n B = B1;\n } else if (coverage2) {\n P = P2;\n B = B2;\n } else if (coverage3) {\n P = P3;\n B = B3;\n }\n \n // Final verification and fix: ensure all residents are covered\n vector finalInTree(N + 1, false);\n UnionFind uf_final(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_final.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n finalInTree[i] = uf_final.same(1, i);\n }\n \n vector residentCovered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (finalInTree[i] && minRadius[i][k] <= P[i]) {\n residentCovered[k] = true;\n break;\n }\n }\n }\n \n // Fix uncovered residents\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered[k]) {\n ll minExtraCost = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (finalInTree[i]) {\n ll newPower = max(P[i], minRadius[i][k]);\n ll extraCost = newPower * newPower - P[i] * P[i];\n \n if (extraCost < minExtraCost) {\n minExtraCost = extraCost;\n bestStation = i;\n }\n }\n }\n \n if (bestStation != -1) {\n P[bestStation] = max(P[bestStation], minRadius[bestStation][k]);\n }\n }\n }\n \n // Output the solution\n for (int i = 1; i <= N; ++i) {\n if (i > 1) cout << \" \";\n cout << P[i];\n }\n cout << endl;\n \n for (int j = 1; j <= M; ++j) {\n if (j > 1) cout << \" \";\n cout << B[j];\n }\n cout << endl;\n \n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_OPS = 9000; // More conservative limit\n\n// Pyramid representation\nvector> pyramid;\n\n// Directions for adjacent positions (6 directions)\nvector> dirs = {\n {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}\n};\n\n// Check if coordinates are valid\nbool valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\n// Find position of a value\npair find_position(int value) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n if (pyramid[i][j] == value) {\n return {i, j};\n }\n }\n }\n return {-1, -1};\n}\n\n// Check if swap is valid (adjacent in 6 directions)\nbool can_swap(int x1, int y1, int x2, int y2) {\n if (!valid(x1, y1) || !valid(x2, y2)) return false;\n \n for (auto& dir : dirs) {\n int nx = x1 + dir.first;\n int ny = y1 + dir.second;\n if (nx == x2 && ny == y2) {\n return true;\n }\n }\n return false;\n}\n\n// Perform swap and record operation\nvoid perform_swap(int x1, int y1, int x2, int y2, vector>& ops) {\n if (!can_swap(x1, y1, x2, y2)) {\n return;\n }\n \n swap(pyramid[x1][y1], pyramid[x2][y2]);\n ops.push_back({x1, y1, x2, y2});\n}\n\n// Count violations\nint count_violations() {\n int violations = 0;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current > left_child) violations++;\n if (current > right_child) violations++;\n }\n }\n return violations;\n}\n\n// Simple directed move (vertical first, then horizontal)\nvoid move_ball_direct(int from_x, int from_y, int to_x, int to_y, vector>& ops) {\n if (from_x == to_x && from_y == to_y) return;\n if (ops.size() >= MAX_OPS) return;\n \n int cx = from_x, cy = from_y;\n int max_steps = 100; // Safety limit\n int steps = 0;\n \n // Move vertically (up or down)\n while (cx != to_x && steps < max_steps && ops.size() < MAX_OPS) {\n bool moved = false;\n \n if (cx < to_x) {\n // Move down\n if (cy <= to_y && valid(cx + 1, cy + 1)) {\n perform_swap(cx, cy, cx + 1, cy + 1, ops);\n cx++; cy++;\n moved = true;\n } else if (valid(cx + 1, cy)) {\n perform_swap(cx, cy, cx + 1, cy, ops);\n cx++;\n moved = true;\n }\n } else {\n // Move up\n if (cy >= to_y && valid(cx - 1, cy - 1)) {\n perform_swap(cx, cy, cx - 1, cy - 1, ops);\n cx--; cy--;\n moved = true;\n } else if (valid(cx - 1, cy)) {\n perform_swap(cx, cy, cx - 1, cy, ops);\n cx--;\n moved = true;\n }\n }\n \n if (!moved) break;\n steps++;\n }\n \n // Move horizontally\n while (cy != to_y && steps < max_steps && ops.size() < MAX_OPS) {\n bool moved = false;\n \n if (cy < to_y && valid(cx, cy + 1)) {\n perform_swap(cx, cy, cx, cy + 1, ops);\n cy++;\n moved = true;\n } else if (cy > to_y && valid(cx, cy - 1)) {\n perform_swap(cx, cy, cx, cy - 1, ops);\n cy--;\n moved = true;\n }\n \n if (!moved) break;\n steps++;\n }\n}\n\n// Calculate how \"wrong\" a value is at its position\nlong long position_error(int value, int x, int y) {\n // Smaller values should be at higher levels\n // Penalize large values at high levels, small values at low levels (less penalty)\n if (x == 0) return value * 100; // Top position should have very small value\n \n // Expected value range for this position\n double expected_ratio = (double)x / (N - 1);\n int expected_value = (int)(expected_ratio * 465);\n \n // Penalty based on difference from expected value\n long long penalty = 0;\n if (value < expected_value / 2) {\n // Small value at low level - less penalty\n penalty = (expected_value / 2 - value) * 2;\n } else if (value > expected_value * 2) {\n // Large value at high level - high penalty\n penalty = (value - expected_value * 2) * 5;\n }\n \n return penalty;\n}\n\n// Main solution\nvoid solve() {\n // Read input\n pyramid.resize(N);\n for (int i = 0; i < N; i++) {\n pyramid[i].resize(i + 1);\n for (int j = 0; j <= i; j++) {\n cin >> pyramid[i][j];\n }\n }\n \n vector> operations;\n \n // Phase 1: Quick positioning of extreme values\n // Get all values with positions\n vector>> values_with_pos;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j <= i; j++) {\n values_with_pos.push_back({pyramid[i][j], {i, j}});\n }\n }\n \n // Sort by value\n sort(values_with_pos.begin(), values_with_pos.end());\n \n // Move the smallest 50 values to higher positions if they're too low\n for (int i = 0; i < 50 && operations.size() < MAX_OPS * 0.3; i++) {\n int value = values_with_pos[i].first;\n int current_x = values_with_pos[i].second.first;\n int current_y = values_with_pos[i].second.second;\n \n // Target position: higher up (closer to top)\n int target_x = i / 5; // First 5 at level 0, next 5 at level 1, etc.\n int target_y = min(target_x, current_y);\n \n // Only move if current position is significantly lower than target\n if (current_x > target_x + 1) {\n move_ball_direct(current_x, current_y, target_x, target_y, operations);\n }\n }\n \n // Phase 2: Fix violations from top to bottom, then bottom to top\n int prev_violations = count_violations();\n int no_improvement_count = 0;\n \n for (int pass = 0; pass < 10 && operations.size() < MAX_OPS; pass++) {\n // Fix from top to bottom (handle high-level violations first)\n for (int x = 0; x < N - 1 && operations.size() < MAX_OPS; x++) {\n for (int y = 0; y <= x && operations.size() < MAX_OPS; y++) {\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n // If violation exists\n if (current_value > left_child || current_value > right_child) {\n // Find smallest value in the subtree (up to 3 levels down)\n int best_value = current_value;\n pair best_pos = {x, y};\n bool found_better = false;\n \n // Check direct children\n if (left_child < best_value) {\n best_value = left_child;\n best_pos = {x + 1, y};\n found_better = true;\n }\n if (right_child < best_value) {\n best_value = right_child;\n best_pos = {x + 1, y + 1};\n found_better = true;\n }\n \n // Check grandchildren if needed\n if (!found_better && x + 2 < N) {\n for (int dx = 2; dx <= min(3, N - 1 - x); dx++) {\n for (int dy = max(0, y); dy <= min(y + dx, x + dx); dy++) {\n if (valid(x + dx, dy) && pyramid[x + dx][dy] < best_value) {\n best_value = pyramid[x + dx][dy];\n best_pos = {x + dx, dy};\n found_better = true;\n break;\n }\n }\n if (found_better) break;\n }\n }\n \n // If found a better value, move it up\n if (found_better && best_pos.first != x && operations.size() < MAX_OPS) {\n // Move directly or swap up\n if (best_pos.first == x + 1) {\n // Direct swap\n perform_swap(x, y, best_pos.first, best_pos.second, operations);\n } else {\n // Move up through path\n move_ball_direct(best_pos.first, best_pos.second, x, y, operations);\n }\n }\n }\n }\n }\n \n // Fix from bottom to top (handle low-level violations)\n for (int x = N - 2; x >= 0 && operations.size() < MAX_OPS; x--) {\n for (int y = 0; y <= x && operations.size() < MAX_OPS; y++) {\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n // If violation exists\n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child && operations.size() < MAX_OPS) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n }\n }\n }\n }\n \n // Check if we're making progress\n int current_violations = count_violations();\n if (current_violations >= prev_violations) {\n no_improvement_count++;\n if (no_improvement_count >= 3) {\n break; // Stop if no improvement for 3 consecutive passes\n }\n } else {\n no_improvement_count = 0;\n prev_violations = current_violations;\n }\n }\n \n // Phase 3: Local optimization - fix remaining violations with direct swaps\n for (int pass = 0; pass < 3 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n for (int x = 0; x < N - 1 && operations.size() < MAX_OPS; x++) {\n for (int y = 0; y <= x && operations.size() < MAX_OPS; y++) {\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n }\n if (!changed) break;\n }\n \n // Output operations\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << op[0] << \" \" << op[1] << \" \" << op[2] << \" \" << op[3] << endl;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n solve();\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nconst int entrance_i = 0, entrance_j = 4;\n\n// Directions for 4-connectivity\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n};\n\nclass Warehouse {\nprivate:\n vector> grid; // -1: empty, -2: obstacle, -3: entrance, >=0: container number\n vector> obstacles;\n int N;\n map container_positions; // Map from position to container number\n \npublic:\n Warehouse(int n) : N(n) {\n grid.assign(D, vector(D, -1));\n obstacles.assign(D, vector(D, false));\n // Mark entrance\n grid[entrance_i][entrance_j] = -3;\n }\n \n void add_obstacle(int i, int j) {\n obstacles[i][j] = true;\n grid[i][j] = -2;\n }\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < D && j >= 0 && j < D;\n }\n \n bool is_empty(int i, int j) {\n return is_valid(i, j) && grid[i][j] == -1 && !obstacles[i][j] && !(i == entrance_i && j == entrance_j);\n }\n \n // BFS to find all reachable empty positions from entrance\n vector get_reachable_empty_positions() {\n vector> visited(D, vector(D, false));\n queue q;\n vector reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n // Check 4 adjacent squares\n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] == -1) { // Empty square\n reachable.push_back(Position(ni, nj));\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] >= 0) { // Container square - can traverse through it for reachability\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Calculate Manhattan distance from entrance\n int distance_from_entrance(int i, int j) {\n return abs(i - entrance_i) + abs(j - entrance_j);\n }\n \n // Estimate how many positions would become unreachable if we place a container at (i,j)\n int blocking_score(int i, int j) {\n if (!is_empty(i, j)) return INT_MAX;\n \n // Temporarily place a container here\n int original = grid[i][j];\n grid[i][j] = 999; // Temporary container\n \n // Count reachable positions\n vector reachable = get_reachable_empty_positions();\n int reachable_count = reachable.size();\n \n // Restore\n grid[i][j] = original;\n \n // Higher score means more blocking (worse)\n return (D*D - 1 - N - reachable_count);\n }\n \n // Place container with number t at position (i, j)\n void place_container(int t, int i, int j) {\n grid[i][j] = t;\n container_positions[Position(i, j)] = t;\n }\n \n // Get all currently reachable containers\n vector> get_reachable_containers() {\n vector> visited(D, vector(D, false));\n queue q;\n vector> reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] >= 0) { // Container\n reachable.push_back({Position(ni, nj), grid[ni][nj]});\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] == -1) { // Empty\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Get all containers sorted by their numbers\n vector> get_all_containers_sorted() {\n vector> containers;\n for (auto& p : container_positions) {\n containers.push_back({p.first, p.second});\n }\n sort(containers.begin(), containers.end(), [](const auto& a, const auto& b) {\n return a.second < b.second;\n });\n return containers;\n }\n};\n\nint main() {\n int N;\n cin >> D >> N; // Note: D is always 9 per problem statement\n \n Warehouse warehouse(N);\n \n // Read obstacles\n for (int i = 0; i < N; i++) {\n int ri, rj;\n cin >> ri >> rj;\n warehouse.add_obstacle(ri, rj);\n }\n \n vector arrived_containers;\n vector> placement_positions; // Store where each container was placed\n \n // Process each incoming container\n for (int d = 0; d < D*D - 1 - N; d++) {\n int t;\n cin >> t;\n arrived_containers.push_back(t);\n \n // Get all reachable empty positions\n vector reachable = warehouse.get_reachable_empty_positions();\n \n if (reachable.empty()) {\n // This shouldn't happen according to problem constraints\n // Just pick any empty position\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (warehouse.is_empty(i, j)) {\n cout << i << \" \" << j << endl;\n warehouse.place_container(t, i, j);\n placement_positions.push_back({i, j});\n goto placed;\n }\n }\n }\n }\n \n // Calculate statistics for decision making\n double avg_so_far = 0.0;\n if (d > 0) {\n for (int i = 0; i < d; i++) {\n avg_so_far += arrived_containers[i];\n }\n avg_so_far /= d;\n }\n \n // Score each reachable position\n vector> position_scores;\n for (auto& pos : reachable) {\n // Base score: distance from entrance (want smaller for smaller t)\n double distance_score = warehouse.distance_from_entrance(pos.i, pos.j);\n \n // Priority factor: if t is smaller than average, we want closer positions\n double priority_factor = 1.0;\n if (d > 0) {\n if (t < avg_so_far) {\n // This container should be removed earlier, so give it higher priority (lower score)\n priority_factor = 0.5;\n } else {\n // This container should be removed later, so lower priority (higher score)\n priority_factor = 2.0;\n }\n }\n \n // Blocking score: how much this placement would block other positions\n int block_score = warehouse.blocking_score(pos.i, pos.j);\n \n // Total score (lower is better)\n double total_score = distance_score * priority_factor + block_score * 0.1;\n \n position_scores.push_back({total_score, pos});\n }\n \n // Choose position with minimum score\n sort(position_scores.begin(), position_scores.end());\n Position chosen = position_scores[0].second;\n \n cout << chosen.i << \" \" << chosen.j << endl;\n cout.flush(); // Important: flush output\n \n warehouse.place_container(t, chosen.i, chosen.j);\n placement_positions.push_back({chosen.i, chosen.j});\n \n placed:; // Label for goto\n }\n \n // Determine removal order\n vector> containers_sorted = warehouse.get_all_containers_sorted();\n \n // Output removal order (by container number, ascending)\n for (auto& p : containers_sorted) {\n cout << p.first.i << \" \" << p.first.j << endl;\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nconst int M = 100;\n\nint main() {\n int n = N, m = M;\n vector> grid(n, vector(n));\n \n // Read input\n cin >> n >> m;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n \n // Determine adjacencies\n vector> adj(m + 1); // adj[c] contains colors adjacent to color c\n vector adj_to_external(m + 1, false); // whether color c is adjacent to external (0)\n \n // Check adjacencies in the original grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n \n // Check if adjacent to boundary (external)\n if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {\n adj_to_external[c] = true;\n }\n \n // Check 4-directional neighbors\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int d = grid[ni][nj];\n if (c != d) {\n adj[c].insert(d);\n adj[d].insert(c);\n }\n } else {\n // Adjacent to external\n adj_to_external[c] = true;\n adj[c].insert(0);\n // Note: We don't add to adj[0] as it's external and always connected\n }\n }\n }\n }\n \n // Create output grid, initially all color 0\n vector> result(n, vector(n, 0));\n \n // Strategy: Place one tile per color in a compact arrangement\n // Start by placing colors that need to be adjacent to external on the boundary\n \n vector colors;\n for (int i = 1; i <= m; i++) {\n colors.push_back(i);\n }\n \n // Sort colors by number of adjacencies (descending) to place high-degree nodes first\n sort(colors.begin(), colors.end(), [&](int a, int b) {\n return adj[a].size() > adj[b].size();\n });\n \n // Place colors on the grid\n int placed = 0;\n bool placed_grid[N][N] = {false};\n \n // First, try to place on the boundary for colors adjacent to external\n vector> boundary_positions;\n for (int i = 0; i < n; i++) {\n boundary_positions.push_back({i, 0});\n boundary_positions.push_back({i, n-1});\n }\n for (int j = 1; j < n-1; j++) {\n boundary_positions.push_back({0, j});\n boundary_positions.push_back({n-1, j});\n }\n \n int boundary_idx = 0;\n \n // Place colors adjacent to external on boundary\n for (int color : colors) {\n if (adj_to_external[color] && boundary_idx < boundary_positions.size()) {\n int x = boundary_positions[boundary_idx].first;\n int y = boundary_positions[boundary_idx].second;\n result[x][y] = color;\n placed_grid[x][y] = true;\n boundary_idx++;\n placed++;\n }\n }\n \n // Place remaining colors in the interior\n for (int color : colors) {\n if (placed >= m) break;\n \n bool already_placed = false;\n for (int i = 0; i < n && !already_placed; i++) {\n for (int j = 0; j < n && !already_placed; j++) {\n if (result[i][j] == color) {\n already_placed = true;\n }\n }\n }\n \n if (already_placed) continue;\n \n // Find a position to place this color\n bool placed_color = false;\n \n // Try to place adjacent to already placed colors it should be adjacent to\n for (int c : adj[color]) {\n if (c == 0) continue; // Skip external\n \n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (result[i][j] == c) {\n // Try to place adjacent to this tile\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n && !placed_grid[ni][nj]) {\n result[ni][nj] = color;\n placed_grid[ni][nj] = true;\n placed_color = true;\n placed++;\n break;\n }\n }\n }\n }\n }\n \n if (placed_color) break;\n }\n \n // If couldn't place adjacent to any adjacent color, place anywhere available\n if (!placed_color) {\n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (!placed_grid[i][j]) {\n result[i][j] = color;\n placed_grid[i][j] = true;\n placed_color = true;\n placed++;\n }\n }\n }\n }\n }\n \n // Output the result\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cout << result[i][j];\n if (j < n - 1) cout << \" \";\n }\n cout << endl;\n }\n \n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass AdvancedWeightEstimator {\nprivate:\n int n;\n vector weights;\n vector>> comparisons; // Store all comparisons for each item\n \npublic:\n AdvancedWeightEstimator(int size) : n(size), weights(size, 1.0), comparisons(size) {}\n \n void add_comparison(int left_idx, int right_idx, const string& result) {\n comparisons[left_idx].push_back({right_idx, result});\n // For reverse, flip the result\n string reverse_result = result;\n if (result == \">\") reverse_result = \"<\";\n else if (result == \"<\") reverse_result = \">\";\n comparisons[right_idx].push_back({left_idx, reverse_result});\n }\n \n // Use a more sophisticated approach to estimate weights\n void estimate_weights() {\n // Start with all weights as 1.0\n fill(weights.begin(), weights.end(), 1.0);\n \n // Use a variant of the Bradley-Terry model with iterative refinement\n const int max_iterations = 200;\n const double learning_rate = 0.05;\n // Removed unused regularization variable\n \n for (int iter = 0; iter < max_iterations; ++iter) {\n vector new_weights = weights;\n double total_change = 0.0;\n \n // For each item, adjust its weight based on comparisons\n for (int i = 0; i < n; ++i) {\n if (comparisons[i].empty()) continue;\n \n double adjustment = 0.0;\n int count = 0;\n \n for (auto& comp : comparisons[i]) {\n int j = comp.first;\n const string& result = comp.second;\n \n double expected_ratio = weights[i] / (weights[i] + weights[j]);\n double actual_ratio = 0.5; // default for \"=\"\n \n if (result == \">\") actual_ratio = 0.9; // i is heavier\n else if (result == \"<\") actual_ratio = 0.1; // i is lighter\n \n // Adjust weight based on difference between expected and actual\n double error = actual_ratio - expected_ratio;\n adjustment += error * weights[j]; // Scale by opponent's weight\n count++;\n }\n \n if (count > 0) {\n adjustment /= count;\n new_weights[i] += learning_rate * adjustment;\n // Add small regularization to avoid extreme values\n new_weights[i] = max(0.1, new_weights[i]);\n total_change += abs(adjustment);\n }\n }\n \n // Update weights\n weights = new_weights;\n \n // Early termination if changes are small\n if (total_change < 1e-6 && iter > 50) break;\n }\n \n // Normalize to ensure positive weights\n double min_weight = *min_element(weights.begin(), weights.end());\n if (min_weight <= 0) {\n double offset = 1.0 - min_weight;\n for (int i = 0; i < n; ++i) {\n weights[i] += offset;\n }\n }\n \n // Scale weights to reasonable range\n double max_weight = *max_element(weights.begin(), weights.end());\n if (max_weight > 1000) {\n double scale = 1000.0 / max_weight;\n for (int i = 0; i < n; ++i) {\n weights[i] *= scale;\n }\n }\n }\n \n double get_weight(int i) const {\n return weights[i];\n }\n \n vector get_all_weights() const {\n return weights;\n }\n \n // Get relative ordering based on comparisons (fallback if weight estimation fails)\n vector get_ranking() {\n vector> wins(n); // (item_index, win_count)\n for (int i = 0; i < n; ++i) {\n wins[i] = {i, 0};\n for (auto& comp : comparisons[i]) {\n if (comp.second == \">\") wins[i].second++;\n else if (comp.second == \"<\") wins[i].second--;\n }\n }\n \n sort(wins.begin(), wins.end(), [](const pair& a, const pair& b) {\n return a.second > b.second;\n });\n \n vector ranking(n);\n for (int i = 0; i < n; ++i) {\n ranking[wins[i].first] = i;\n }\n return ranking;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, D, Q;\n cin >> N >> D >> Q;\n \n // Initialize random generator\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n mt19937 rng(seed);\n uniform_int_distribution item_dist(0, N-1);\n \n // Create weight estimator\n AdvancedWeightEstimator estimator(N);\n \n // Phase 1: Strategic information gathering\n vector item_used(N, false);\n int queries_used = 0;\n \n // Step 1: Compare each item with a few others to build initial graph\n vector items_list(N); // Renamed from 'items' to 'items_list'\n iota(items_list.begin(), items_list.end(), 0);\n \n // Shuffle items for randomization\n shuffle(items_list.begin(), items_list.end(), rng);\n \n // Compare each item with 2-3 others\n for (int i = 0; i < N && queries_used < min(Q/3, N*2); ++i) {\n int base_item = items_list[i];\n \n // Compare with next 1-2 items in the shuffled list\n for (int j = 1; j <= 2 && i + j < N && queries_used < min(Q/3, N*2); ++j) {\n int compare_item = items_list[(i + j) % N];\n \n cout << \"1 1 \" << base_item << \" \" << compare_item << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(base_item, compare_item, result);\n queries_used++;\n item_used[base_item] = true;\n item_used[compare_item] = true;\n }\n }\n \n // Step 2: Compare larger groups for better calibration\n // Create roughly equal-sized groups and compare them\n if (queries_used < Q) {\n vector> groups(min(D*2, N/3));\n for (int i = 0; i < N; ++i) {\n groups[i % groups.size()].push_back(i);\n }\n \n // Compare different combinations of groups\n for (size_t i = 0; i < groups.size() && queries_used < Q*2/3; ++i) { // Changed int to size_t\n for (size_t j = i + 1; j < groups.size() && queries_used < Q*2/3; ++j) { // Changed int to size_t\n if (groups[i].empty() || groups[j].empty()) continue;\n \n // Limit group size to avoid using too many items\n int max_size = max(1, min(5, (int)min(groups[i].size(), groups[j].size())));\n vector left_items, right_items;\n \n for (int k = 0; k < min(max_size, (int)groups[i].size()); ++k) {\n left_items.push_back(groups[i][k]);\n }\n for (int k = 0; k < min(max_size, (int)groups[j].size()); ++k) {\n right_items.push_back(groups[j][k]);\n }\n \n if (left_items.empty() || right_items.empty()) continue;\n \n cout << left_items.size() << \" \" << right_items.size();\n for (int item : left_items) cout << \" \" << item;\n for (int item : right_items) cout << \" \" << item;\n cout << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n // Store the comparison (using first item as representative for simplicity)\n if (!left_items.empty() && !right_items.empty()) {\n estimator.add_comparison(left_items[0], right_items[0], result);\n }\n queries_used++;\n }\n }\n }\n \n // Step 3: Use remaining queries for high-value comparisons\n // Focus on items that have been in close comparisons or haven't been compared much\n vector comparison_count(N, 0);\n for (int i = 0; i < N; ++i) {\n comparison_count[i] = estimator.get_ranking()[i]; // Use ranking as proxy for comparison count\n }\n \n while (queries_used < Q) {\n // Find items that might be close in weight (middle ranked items)\n vector> items_by_rank;\n auto ranking = estimator.get_ranking();\n for (int i = 0; i < N; ++i) {\n items_by_rank.push_back({ranking[i], i});\n }\n sort(items_by_rank.begin(), items_by_rank.end());\n \n // Pick items from the middle of the ranking (likely to be close in weight)\n int middle = N / 2;\n int start = max(0, middle - 5);\n int end = min(N, middle + 5);\n \n if (start >= end) {\n start = 0;\n end = min(N, 5);\n }\n \n vector candidate_items;\n for (int i = start; i < end; ++i) {\n candidate_items.push_back(items_by_rank[i].second);\n }\n \n if (candidate_items.size() < 2) {\n // Fallback: pick random items\n candidate_items.clear();\n for (int i = 0; i < N; ++i) {\n candidate_items.push_back(i);\n }\n shuffle(candidate_items.begin(), candidate_items.end(), rng);\n }\n \n // Compare two items from candidates\n int idx1 = 0;\n int idx2 = 1;\n if (candidate_items.size() > 2) {\n idx1 = rng() % candidate_items.size();\n idx2 = rng() % (candidate_items.size() - 1);\n if (idx2 >= idx1) idx2++;\n }\n \n if (idx1 < (int)candidate_items.size() && idx2 < (int)candidate_items.size()) { // Cast to int for comparison\n int item1 = candidate_items[idx1];\n int item2 = candidate_items[idx2];\n \n cout << \"1 1 \" << item1 << \" \" << item2 << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(item1, item2, result);\n queries_used++;\n } else {\n // If we can't pick two distinct items, do a random comparison\n int item1 = rng() % N;\n int item2 = rng() % (N - 1);\n if (item2 >= item1) item2++;\n \n cout << \"1 1 \" << item1 << \" \" << item2 << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(item1, item2, result);\n queries_used++;\n }\n }\n \n // Estimate weights based on comparisons\n estimator.estimate_weights();\n vector estimated_weights = estimator.get_all_weights();\n \n // Validate weights - if they seem unreasonable, fall back to ranking\n bool weights_valid = true;\n double weight_sum = accumulate(estimated_weights.begin(), estimated_weights.end(), 0.0);\n if (weight_sum < 0.1 * N || weight_sum > 1000 * N) {\n weights_valid = false;\n }\n \n if (!weights_valid) {\n // Fallback: use ranking-based weights\n auto ranking = estimator.get_ranking();\n for (int i = 0; i < N; ++i) {\n estimated_weights[i] = (N - ranking[i]); // Higher rank (more wins) = higher weight\n }\n }\n \n // Phase 2: Advanced partitioning\n vector assignment(N, 0);\n vector set_weights(D, 0.0);\n \n // Create list of items with their estimated weights\n vector> weighted_items; // Renamed from 'items' to 'weighted_items'\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({estimated_weights[i], i});\n }\n \n // Sort by weight (descending) for better greedy assignment\n sort(weighted_items.rbegin(), weighted_items.rend());\n \n // Advanced greedy assignment with look-ahead\n for (auto& item : weighted_items) { // Now 'item' is a pair\n int item_idx = item.second;\n double weight = item.first;\n \n // Find the set with minimum current weight\n int best_set = 0;\n double best_imbalance = numeric_limits::max();\n \n for (int j = 0; j < D; ++j) {\n // Calculate potential imbalance after adding this item\n vector temp_weights = set_weights;\n temp_weights[j] += weight;\n \n double mean = accumulate(temp_weights.begin(), temp_weights.end(), 0.0) / D;\n double imbalance = 0.0;\n for (int k = 0; k < D; ++k) {\n imbalance += abs(temp_weights[k] - mean);\n }\n \n if (imbalance < best_imbalance) {\n best_imbalance = imbalance;\n best_set = j;\n }\n }\n \n assignment[item_idx] = best_set;\n set_weights[best_set] += weight;\n }\n \n // Advanced local search with multiple strategies\n const int max_improvements = N * D * 2;\n int improvements = 0;\n \n // Strategy 1: Single item moves\n for (int iter = 0; iter < max_improvements / 2 && improvements < max_improvements; ++iter) {\n // Pick a random item\n int item_idx = rng() % N;\n double item_weight = estimated_weights[item_idx];\n int current_set = assignment[item_idx];\n \n // Try moving it to other sets\n for (int new_set = 0; new_set < D; ++new_set) {\n if (new_set == current_set) continue;\n \n // Calculate current variance\n double mean = accumulate(set_weights.begin(), set_weights.end(), 0.0) / D;\n double old_var = 0.0;\n for (double w : set_weights) {\n old_var += (w - mean) * (w - mean);\n }\n old_var /= D;\n \n // Calculate variance after move\n vector new_weights = set_weights;\n new_weights[current_set] -= item_weight;\n new_weights[new_set] += item_weight;\n \n double new_mean = accumulate(new_weights.begin(), new_weights.end(), 0.0) / D;\n double new_var = 0.0;\n for (double w : new_weights) {\n new_var += (w - new_mean) * (w - new_mean);\n }\n new_var /= D;\n \n // Accept move if it improves variance\n if (new_var < old_var - 1e-9) { // Small epsilon to avoid floating point issues\n assignment[item_idx] = new_set;\n set_weights = new_weights;\n improvements++;\n break; // Move to next iteration\n }\n }\n }\n \n // Strategy 2: Swap items between sets\n for (int iter = 0; iter < max_improvements / 2 && improvements < max_improvements; ++iter) {\n // Pick two different sets\n int set1 = rng() % D;\n int set2 = rng() % (D - 1);\n if (set2 >= set1) set2++;\n \n // Get items in these sets\n vector items_set1, items_set2;\n for (int i = 0; i < N; ++i) {\n if (assignment[i] == set1) items_set1.push_back(i);\n if (assignment[i] == set2) items_set2.push_back(i);\n }\n \n if (items_set1.empty() || items_set2.empty()) continue;\n \n // Try swapping random pairs\n int item1 = items_set1[rng() % items_set1.size()];\n int item2 = items_set2[rng() % items_set2.size()];\n \n double w1 = estimated_weights[item1];\n double w2 = estimated_weights[item2];\n \n // Calculate current variance\n double mean = accumulate(set_weights.begin(), set_weights.end(), 0.0) / D;\n double old_var = 0.0;\n for (double w : set_weights) {\n old_var += (w - mean) * (w - mean);\n }\n old_var /= D;\n \n // Calculate variance after swap\n vector new_weights = set_weights;\n new_weights[set1] = new_weights[set1] - w1 + w2;\n new_weights[set2] = new_weights[set2] - w2 + w1;\n \n double new_mean = accumulate(new_weights.begin(), new_weights.end(), 0.0) / D;\n double new_var = 0.0;\n for (double w : new_weights) {\n new_var += (w - new_mean) * (w - new_mean);\n }\n new_var /= D;\n \n // Accept swap if it improves variance\n if (new_var < old_var - 1e-9) {\n assignment[item1] = set2;\n assignment[item2] = set1;\n set_weights = new_weights;\n improvements++;\n }\n }\n \n // Output final assignment\n for (int i = 0; i < N; ++i) {\n cout << assignment[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n \n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct BoxPosition {\n int stack_idx;\n int height; // 0-indexed from bottom\n bool removed;\n};\n\nint main() {\n int n = 200, m = 10;\n int boxes_per_stack = n / m;\n \n // Read input\n vector> stacks(m, vector(boxes_per_stack));\n vector box_positions(n + 1); // 1-indexed\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_positions[stacks[i][j]] = {i, j, false};\n }\n }\n \n vector> operations;\n \n // For each box from 1 to 200\n for (int target = 1; target <= n; target++) {\n // If box is already removed, skip (shouldn't happen)\n if (box_positions[target].removed) continue;\n \n int stack_idx = box_positions[target].stack_idx;\n int height = box_positions[target].height;\n \n // Check if box is at the top of its stack\n bool is_top = true;\n for (int i = height + 1; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) { // 0 indicates removed box\n is_top = false;\n break;\n }\n }\n \n // Clean up removed boxes from top of stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Recalculate if it's at the top after cleanup\n is_top = (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1);\n \n if (is_top) {\n // Can remove directly\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n continue;\n }\n \n // Need to move the box and everything above it\n // Find the best destination stack\n \n int best_stack = -1;\n int min_cost = INT_MAX;\n \n // First, try to find an empty stack\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n if (stacks[dest].empty()) {\n best_stack = dest;\n break;\n }\n }\n \n // If no empty stack, find stack with minimum additional cost\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n \n // Calculate cost of moving to this stack\n int boxes_to_move = 0;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move++;\n }\n }\n \n // Energy cost is boxes_to_move + 1\n int cost = boxes_to_move + 1;\n \n // Prefer stacks that are shorter or have higher-numbered boxes on top\n cost += stacks[dest].size(); // penalty for taller stacks\n \n if (cost < min_cost) {\n min_cost = cost;\n best_stack = dest;\n }\n }\n }\n \n // If still no valid destination, pick any different stack\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx) {\n best_stack = dest;\n break;\n }\n }\n }\n \n // Perform the move\n vector boxes_to_move;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move.push_back(stacks[stack_idx][i]);\n }\n }\n \n // Update stacks\n stacks[stack_idx].resize(height);\n \n for (int box : boxes_to_move) {\n stacks[best_stack].push_back(box);\n box_positions[box].stack_idx = best_stack;\n box_positions[box].height = stacks[best_stack].size() - 1;\n }\n \n operations.push_back({target, best_stack + 1});\n \n // Now try to remove the target box (it should be at the top)\n stack_idx = box_positions[target].stack_idx;\n height = box_positions[target].height;\n \n // Clean up the stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Verify it's at the top\n if (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1) {\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n } else {\n // Something went wrong, try one more move\n // This is a fallback - shouldn't happen in normal cases\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx && stacks[dest].empty()) {\n // Move just this box to empty stack\n stacks[stack_idx].erase(stacks[stack_idx].begin() + height);\n stacks[dest].push_back(target);\n box_positions[target].stack_idx = dest;\n box_positions[target].height = 0;\n operations.push_back({target, dest + 1});\n break;\n }\n }\n \n // Now remove it\n operations.push_back({target, 0});\n for (int i = 0; i < m; i++) {\n if (!stacks[i].empty() && stacks[i].back() == target) {\n stacks[i].pop_back();\n break;\n }\n }\n box_positions[target].removed = true;\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \nusing namespace std;\n\n// Directions: R, D, L, U\nconst int di[4] = {0, 1, 0, -1};\nconst int dj[4] = {1, 0, -1, 0};\nconst string DIR = \"RDLU\";\n\nint N;\nvector h, v;\nvector> d;\nvector> visited;\nstring route = \"\";\n\n// Check if we can move from (i,j) to (ni,nj)\nbool canMove(int i, int j, int ni, int nj) {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n \n if (i == ni) { // horizontal move\n int min_j = min(j, nj);\n return v[i][min_j] == '0';\n } else { // vertical move\n int min_i = min(i, ni);\n return h[min_i][j] == '0';\n }\n}\n\n// DFS with priority based on dirtiness\nvoid dfs_priority(int i, int j) {\n visited[i][j] = true;\n \n // Collect all possible next moves with their priorities\n vector> next_moves; // (priority, direction)\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n // Priority: higher dirtiness gets higher priority\n next_moves.push_back({-d[ni][nj], dir}); // negative for descending sort\n }\n }\n \n // Sort by priority (descending dirtiness)\n sort(next_moves.begin(), next_moves.end());\n \n // Visit in priority order\n for (auto& move : next_moves) {\n int dir = move.second;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n \n route += DIR[dir];\n dfs_priority(ni, nj);\n route += DIR[(dir + 2) % 4]; // return\n }\n}\n\n// Lightweight optimization: Add only a few loops for the highest dirt cells\nstring addFewLoops(const string& base_route) {\n string result = base_route;\n if (result.size() >= 99000) return result; // Avoid exceeding limit\n \n // Track positions during route\n vector> positions;\n int ci = 0, cj = 0;\n positions.push_back({ci, cj});\n \n for (char move : base_route) {\n int dir = DIR.find(move);\n ci += di[dir];\n cj += dj[dir];\n positions.push_back({ci, cj});\n }\n \n // Find high-dirt cells\n vector>> dirt_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n dirt_cells.push_back({d[i][j], {i, j}});\n }\n }\n sort(dirt_cells.rbegin(), dirt_cells.rend()); // descending order\n \n // Only add loops for top 3 dirtiest cells (very conservative)\n int loops_added = 0;\n for (int idx = 0; idx < min(3, (int)dirt_cells.size()) && loops_added < 3; idx++) {\n int target_i = dirt_cells[idx].second.first;\n int target_j = dirt_cells[idx].second.second;\n \n // Find earliest visit to this cell\n int first_visit = -1;\n for (int t = 0; t < positions.size(); t++) {\n if (positions[t].first == target_i && positions[t].second == target_j) {\n first_visit = t;\n break;\n }\n }\n \n if (first_visit == -1) continue;\n \n // Try to add a small loop (go to neighbor and back)\n for (int dir = 0; dir < 4; dir++) {\n int ni = target_i + di[dir];\n int nj = target_j + dj[dir];\n \n if (canMove(target_i, target_j, ni, nj) && result.size() + 2 <= 99500) {\n // Insert loop at first_visit position\n string loop = string(1, DIR[dir]) + string(1, DIR[(dir + 2) % 4]);\n result.insert(first_visit, loop);\n \n // Update positions (only if we need to add more loops)\n if (loops_added < 2) { // Only update positions if we plan to add more loops\n positions.insert(positions.begin() + first_visit + 1, {ni, nj});\n positions.insert(positions.begin() + first_visit + 2, {target_i, target_j});\n }\n \n loops_added++;\n break;\n }\n }\n }\n \n return result;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read input\n cin >> N;\n h.resize(N-1);\n for (int i = 0; i < N-1; i++) {\n cin >> h[i];\n }\n v.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> v[i];\n }\n d.resize(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n // Initialize visited array\n visited = vector>(N, vector(N, false));\n \n // Generate initial route using priority DFS\n dfs_priority(0, 0);\n \n // Lightweight optimization: Add only a few loops\n string optimized_route = addFewLoops(route);\n \n // Ensure we don't exceed length limit\n if (optimized_route.size() > 100000) {\n cout << route << endl; // Fallback to original if optimized is too long\n } else {\n cout << optimized_route << endl;\n }\n \n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n int distance(const Position& other) const {\n return abs(i - other.i) + abs(j - other.j);\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n};\n\nclass Solution {\nprivate:\n int N, M;\n Position start_pos;\n vector grid;\n vector targets;\n map> char_positions;\n \n // Random number generator\n mt19937 rng;\n \npublic:\n Solution() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n cin >> N >> M;\n cin >> start_pos.i >> start_pos.j;\n grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n targets.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i];\n }\n \n // Build map of character positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char_positions[grid[i][j]].push_back(Position(i, j));\n }\n }\n }\n \n // Find the position with minimum distance from current position\n Position find_best_position(char c, const Position& current) {\n if (char_positions.find(c) == char_positions.end()) {\n return Position(0, 0);\n }\n \n Position best_pos = char_positions[c][0];\n int min_dist = current.distance(best_pos);\n \n for (const Position& pos : char_positions[c]) {\n int dist = current.distance(pos);\n if (dist < min_dist) {\n min_dist = dist;\n best_pos = pos;\n }\n }\n \n return best_pos;\n }\n \n // Calculate overlap between two strings\n int calculate_overlap(const string& s1, const string& s2) {\n int max_overlap = 0;\n int len1 = s1.length();\n int len2 = s2.length();\n \n for (int i = 1; i <= min(len1, len2); i++) {\n bool match = true;\n for (int j = 0; j < i; j++) {\n if (s1[len1 - i + j] != s2[j]) {\n match = false;\n break;\n }\n }\n if (match) {\n max_overlap = i;\n }\n }\n \n return max_overlap;\n }\n \n // Calculate the cost of typing a string from a given position\n long long calculate_string_cost(const string& str, Position current_pos) {\n long long cost = 0;\n for (char c : str) {\n Position best_pos = find_best_position(c, current_pos);\n cost += current_pos.distance(best_pos) + 1;\n current_pos = best_pos;\n }\n return cost;\n }\n \n // Build superstring using improved greedy with multiple scoring metrics\n vector build_superstring_sequence_improved(int strategy) {\n if (M == 0) return {};\n \n vector used(M, false);\n vector result;\n \n // Choose first string based on strategy\n int first_idx = 0;\n \n if (strategy == 0) {\n // Strategy 0: Start with the string that's cheapest to type from start position\n long long min_cost = LLONG_MAX;\n for (int i = 0; i < M; i++) {\n long long cost = calculate_string_cost(targets[i], start_pos);\n if (cost < min_cost) {\n min_cost = cost;\n first_idx = i;\n }\n }\n } else if (strategy == 1) {\n // Strategy 1: Start with string having highest frequency characters\n map char_freq;\n for (int i = 0; i < M; i++) {\n for (char c : targets[i]) {\n char_freq[c]++;\n }\n }\n \n int best_score = -1;\n for (int i = 0; i < M; i++) {\n int score = 0;\n for (char c : targets[i]) {\n score += char_freq[c];\n }\n if (score > best_score) {\n best_score = score;\n first_idx = i;\n }\n }\n } else if (strategy == 2) {\n // Strategy 2: Random start\n first_idx = rng() % M;\n } else {\n // Strategy 3: Start with string that has characters close to start position\n int best_score = INT_MAX;\n for (int i = 0; i < M; i++) {\n int score = 0;\n for (char c : targets[i]) {\n int min_dist = INT_MAX;\n for (const Position& pos : char_positions[c]) {\n min_dist = min(min_dist, start_pos.distance(pos));\n }\n score += min_dist;\n }\n if (score < best_score) {\n best_score = score;\n first_idx = i;\n }\n }\n }\n \n used[first_idx] = true;\n result.push_back(targets[first_idx]);\n \n // Greedily add strings with optimized scoring\n for (int step = 1; step < M; step++) {\n int best_idx = -1;\n double best_score = -1;\n string current_string = result.back();\n \n for (int i = 0; i < M; i++) {\n if (used[i]) continue;\n \n int overlap = calculate_overlap(current_string, targets[i]);\n \n // Simulate end position after typing current string\n Position current_end_pos = start_pos;\n for (char c : current_string) {\n current_end_pos = find_best_position(c, current_end_pos);\n }\n \n // Calculate cost of typing non-overlapping part\n long long non_overlap_cost = 0;\n Position temp_pos = current_end_pos;\n for (int j = overlap; j < targets[i].length(); j++) {\n Position best_pos = find_best_position(targets[i][j], temp_pos);\n non_overlap_cost += temp_pos.distance(best_pos) + 1;\n temp_pos = best_pos;\n }\n \n // Calculate score with multiple factors\n double score = 0.0;\n \n // Factor 1: Overlap benefit (higher overlap = better)\n score += overlap * 100.0;\n \n // Factor 2: Cost penalty (lower cost = better)\n if (non_overlap_cost > 0) {\n score -= non_overlap_cost * 0.5;\n }\n \n // Factor 3: Future potential - how many other strings can overlap with this one\n int future_potential = 0;\n for (int k = 0; k < M; k++) {\n if (used[k]) continue;\n if (k == i) continue;\n int future_overlap = calculate_overlap(targets[i], targets[k]);\n future_potential += future_overlap;\n }\n score += future_potential * 10.0;\n \n if (score > best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n for (int i = 0; i < M; i++) {\n if (!used[i]) {\n best_idx = i;\n break;\n }\n }\n }\n \n used[best_idx] = true;\n result.push_back(targets[best_idx]);\n }\n \n return result;\n }\n \n // Advanced position selection with multi-character look-ahead\n vector generate_operations_advanced(const vector& sequence) {\n vector operations;\n Position current_pos = start_pos;\n \n if (sequence.empty()) return operations;\n \n // Process each string in sequence\n for (int seq_idx = 0; seq_idx < sequence.size(); seq_idx++) {\n const string& str = sequence[seq_idx];\n \n // Calculate overlap with previous string\n int start_char_idx = 0;\n if (seq_idx > 0) {\n const string& prev = sequence[seq_idx - 1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n // Type characters with advanced position selection\n for (int j = start_char_idx; j < str.length(); j++) {\n char c = str[j];\n \n // If we have multiple positions and characters remaining, use look-ahead\n if (char_positions[c].size() > 1 && j < str.length() - 1) {\n Position best_pos = char_positions[c][0];\n double best_score = 1e9;\n \n // Look ahead up to 2 characters\n int look_ahead = min(2, (int)str.length() - j - 1);\n \n for (const Position& pos : char_positions[c]) {\n double score = current_pos.distance(pos) + 1; // cost to move to this position\n \n // Simulate future costs\n Position future_pos = pos;\n for (int k = 1; k <= look_ahead; k++) {\n char future_char = str[j + k];\n Position future_best = find_best_position(future_char, future_pos);\n score += future_pos.distance(future_best) + 1;\n future_pos = future_best;\n }\n \n // Also consider overall grid distribution - prefer central positions\n double centrality_bonus = abs(pos.i - N/2) + abs(pos.j - N/2);\n score += centrality_bonus * 0.1; // slight penalty for edge positions\n \n if (score < best_score) {\n best_score = score;\n best_pos = pos;\n }\n }\n \n operations.push_back(best_pos);\n current_pos = best_pos;\n } else {\n // Simple case: just pick closest position\n Position best_pos = find_best_position(c, current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n }\n }\n \n return operations;\n }\n \n // Calculate total cost of operations\n long long calculate_total_cost(const vector& operations) {\n long long cost = 0;\n Position current_pos = start_pos;\n for (const Position& op : operations) {\n cost += current_pos.distance(op) + 1;\n current_pos = op;\n }\n return cost;\n }\n \n // Try to locally optimize the solution by adjusting positions\n vector local_optimization(const vector& original_ops, const vector& sequence) {\n if (original_ops.empty()) return original_ops;\n \n vector optimized = original_ops;\n long long original_cost = calculate_total_cost(original_ops);\n long long best_cost = original_cost;\n vector best_ops = original_ops;\n \n // Try random perturbations\n for (int trial = 0; trial < 10; trial++) {\n vector candidate = original_ops;\n \n // Randomly adjust some positions\n int num_adjustments = min(5, (int)candidate.size() / 10);\n for (int adj = 0; adj < num_adjustments; adj++) {\n int idx = rng() % candidate.size();\n \n // Find the character that should be at this position\n char target_char = '?';\n int op_idx = 0;\n int seq_idx = 0;\n int char_idx = 0;\n \n // Reconstruct which character corresponds to this operation\n Position current_pos = start_pos;\n for (int i = 0; i < sequence.size(); i++) {\n const string& str = sequence[i];\n int start_char_idx = 0;\n \n if (i > 0) {\n const string& prev = sequence[i-1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n for (int j = start_char_idx; j < str.length(); j++) {\n if (op_idx == idx) {\n target_char = str[j];\n break;\n }\n op_idx++;\n }\n \n if (target_char != '?') break;\n }\n \n if (target_char != '?' && char_positions[target_char].size() > 1) {\n // Try a different position for this character\n Position current_context_pos = start_pos;\n if (idx > 0) {\n current_context_pos = candidate[idx - 1];\n } else {\n current_context_pos = start_pos;\n }\n \n Position prev_best = candidate[idx];\n Position new_best = find_best_position(target_char, current_context_pos);\n \n // Try to find a different position (not the closest one)\n for (const Position& pos : char_positions[target_char]) {\n if (pos.i != prev_best.i || pos.j != prev_best.j) {\n if (current_context_pos.distance(pos) <= current_context_pos.distance(prev_best) + 3) {\n // Only consider if not too much worse\n new_best = pos;\n break;\n }\n }\n }\n \n candidate[idx] = new_best;\n }\n }\n \n long long new_cost = calculate_total_cost(candidate);\n if (new_cost < best_cost) {\n best_cost = new_cost;\n best_ops = candidate;\n }\n }\n \n return best_ops;\n }\n \n // Main solve function with comprehensive strategies\n void solve() {\n vector best_operations;\n long long best_cost = LLONG_MAX;\n vector best_sequence;\n \n // Try different strategies for building sequence\n for (int strategy = 0; strategy < 4; strategy++) {\n vector sequence = build_superstring_sequence_improved(strategy);\n vector operations = generate_operations_advanced(sequence);\n \n // Try local optimization\n vector optimized_ops = local_optimization(operations, sequence);\n long long cost = calculate_total_cost(optimized_ops);\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = optimized_ops;\n best_sequence = sequence;\n }\n }\n \n // Try additional random trials\n for (int trial = 0; trial < 5; trial++) {\n vector sequence = build_superstring_sequence_improved(2); // random strategy\n vector operations = generate_operations_advanced(sequence);\n \n vector optimized_ops = local_optimization(operations, sequence);\n long long cost = calculate_total_cost(optimized_ops);\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = optimized_ops;\n best_sequence = sequence;\n }\n }\n \n // One final optimization pass\n if (!best_operations.empty()) {\n vector final_optimized = local_optimization(best_operations, best_sequence);\n long long final_cost = calculate_total_cost(final_optimized);\n if (final_cost < best_cost) {\n best_operations = final_optimized;\n }\n }\n \n // Output the best operations\n for (const Position& pos : best_operations) {\n cout << pos.i << \" \" << pos.j << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n Solution solution;\n solution.solve();\n \n return 0;\n}","ahc030":"#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 double EPS = 1e-9;\n\n// Helper functions\ndouble square(double x) { return x * x; }\n\nstruct Point {\n int i, j;\n Point(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Point& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Point& other) const {\n return i == other.i && j == other.j;\n }\n};\n\n// Oil field representation\nstruct OilField {\n vector shape;\n int size;\n int max_i, max_j; // max coordinates in the shape\n};\n\nclass Solver {\nprivate:\n int N, M;\n double epsilon;\n vector oil_fields;\n vector> known_values; // -1 means unknown\n vector> probability; // probability that square has oil\n vector> confidence; // confidence in probability estimate\n mt19937 rng;\n \n // Tracking for optimization\n int operations_used = 0;\n double total_cost = 0.0;\n set known_oil_squares;\n set candidate_oil_squares;\n \n // For divination noise modeling\n double expected_value(int k, int actual_sum) {\n return (k - actual_sum) * epsilon + actual_sum * (1 - epsilon);\n }\n \n double variance(int k) {\n return k * epsilon * (1 - epsilon);\n }\n \n // Read input\n void read_input() {\n cin >> N >> M >> epsilon;\n \n oil_fields.resize(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n oil_fields[k].shape.resize(d);\n oil_fields[k].size = d;\n \n int min_i = 1000, min_j = 1000, max_i = -1, max_j = -1;\n for (int i = 0; i < d; i++) {\n int ii, jj;\n cin >> ii >> jj;\n oil_fields[k].shape[i] = Point(ii, jj);\n min_i = min(min_i, ii);\n min_j = min(min_j, jj);\n max_i = max(max_i, ii);\n max_j = max(max_j, jj);\n }\n \n // Translate to ensure top-left is (0,0) - already done in input\n oil_fields[k].max_i = max_i;\n oil_fields[k].max_j = max_j;\n }\n \n // Initialize known values and probability\n known_values.assign(N, vector(N, -1));\n probability.assign(N, vector(N, 0.5)); // Start with 50% probability\n confidence.assign(N, vector(N, 0.0)); // Start with 0 confidence\n \n // Initialize candidate squares (all possible positions for all oil fields)\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n candidate_oil_squares.insert(Point(i, j));\n }\n }\n }\n \n // Drill at point (i, j)\n int drill(int i, int j) {\n if (operations_used >= 2 * N * N) return -1;\n \n cout << \"q 1 \" << i << \" \" << j << endl;\n operations_used++;\n total_cost += 1.0;\n \n int value;\n cin >> value;\n \n known_values[i][j] = value;\n if (value > 0) {\n known_oil_squares.insert(Point(i, j));\n probability[i][j] = 1.0;\n confidence[i][j] = 1.0;\n } else {\n probability[i][j] = 0.0;\n confidence[i][j] = 1.0;\n }\n \n return value;\n }\n \n // Divine the sum of values in set S\n int divine(const vector& points) {\n if (points.size() < 2 || operations_used >= 2 * N * N) return -1;\n \n cout << \"q \" << points.size();\n for (const Point& p : points) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n operations_used++;\n total_cost += 1.0 / sqrt(points.size());\n \n int result;\n cin >> result;\n \n // Update probabilities based on result\n update_probabilities_from_divine(points, result);\n \n return result;\n }\n \n // Update probabilities based on divine result\n void update_probabilities_from_divine(const vector& points, int result) {\n if (result < 0) return;\n \n // Simple Bayesian update - adjust probabilities to be more consistent with result\n double current_sum_estimate = 0.0;\n for (const Point& p : points) {\n current_sum_estimate += probability[p.i][p.j];\n }\n \n double adjustment = (result - current_sum_estimate) / points.size();\n \n for (const Point& p : points) {\n if (known_values[p.i][p.j] == -1) { // Only update unknown squares\n probability[p.i][p.j] = max(0.0, min(1.0, probability[p.i][p.j] + adjustment * 0.5));\n confidence[p.i][p.j] = min(1.0, confidence[p.i][p.j] + 0.1);\n }\n }\n }\n \n // Check if point is valid\n bool is_valid_point(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n }\n \n // Check if oil field can be placed at (offset_i, offset_j)\n bool can_place_field(const OilField& field, int offset_i, int offset_j) {\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (!is_valid_point(i, j)) return false;\n // If we know this square has no oil, we can't place the field here\n if (known_values[i][j] == 0) return false;\n }\n return true;\n }\n \n // Calculate score for placing oil field at (offset_i, offset_j)\n double score_field_placement(const OilField& field, int offset_i, int offset_j) {\n if (!can_place_field(field, offset_i, offset_j)) return -1e9;\n \n double score = 0.0;\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (known_values[i][j] > 0) {\n // We know there's oil here, good!\n score += 10.0;\n } else if (known_values[i][j] == 0) {\n // We know there's no oil here, impossible\n return -1e9;\n } else {\n // Unknown, use probability\n score += probability[i][j];\n }\n }\n return score;\n }\n \n // Get all possible placements for an oil field\n vector> get_possible_placements(const OilField& field) {\n vector> placements;\n \n for (int i = 0; i <= N - 1 - field.max_i; i++) {\n for (int j = 0; j <= N - 1 - field.max_j; j++) {\n double score = score_field_placement(field, i, j);\n if (score > -1e8) {\n placements.push_back({Point(i, j), score});\n }\n }\n }\n \n // Sort by score\n sort(placements.begin(), placements.end(), [](const auto& a, const auto& b) {\n return a.second > b.second;\n });\n \n return placements;\n }\n \n // Phase 1: Coarse search with divination\n void phase1_coarse_search() {\n // Use larger blocks for divination\n int block_size = max(2, N / 4);\n \n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n if (operations_used >= 2 * N * N) return;\n \n vector block_points;\n for (int i = bi; i < min(bi + block_size, N); i++) {\n for (int j = bj; j < min(bj + block_size, N); j++) {\n if (known_values[i][j] == -1) { // Only include unknown squares\n block_points.push_back(Point(i, j));\n }\n }\n }\n \n // If we have at least 2 unknown points, divine the block\n if (block_points.size() >= 2) {\n int result = divine(block_points);\n // Results are processed in divine() via update_probabilities_from_divine\n }\n }\n }\n }\n \n // Phase 2: Targeted search based on probabilities\n void phase2_targeted_search() {\n // Create a priority queue of squares to investigate based on uncertainty and probability\n vector> candidates;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n // Prioritize squares with moderate confidence and high probability\n // We want to investigate squares that are likely to have oil but we're not sure\n double uncertainty = 1.0 - confidence[i][j];\n double priority = probability[i][j] * uncertainty;\n candidates.push_back({priority, Point(i, j)});\n }\n }\n }\n \n // Sort by priority\n sort(candidates.begin(), candidates.end(), greater>());\n \n // Investigate top candidates\n int to_investigate = min(20, (int)candidates.size());\n for (int idx = 0; idx < to_investigate; idx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& p = candidates[idx].second;\n \n // If probability is very high, drill directly\n if (probability[p.i][p.j] > 0.7) {\n drill(p.i, p.j);\n } \n // Otherwise, try to group with nearby squares for divination\n else {\n vector nearby;\n nearby.push_back(p);\n \n // Add nearby squares\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = p.i + di, nj = p.j + dj;\n if (is_valid_point(ni, nj) && known_values[ni][nj] == -1) {\n nearby.push_back(Point(ni, nj));\n }\n }\n }\n \n // If we have at least 2 squares, divine them\n if (nearby.size() >= 2 && nearby.size() <= 8) { // Limit size to reduce noise\n divine(nearby);\n } else {\n // Otherwise just drill this square\n drill(p.i, p.j);\n }\n }\n }\n }\n \n // Phase 3: Use shape information to guide search\n void phase3_shape_guided_search() {\n // For each oil field, find the most likely placements\n for (int fidx = 0; fidx < M; fidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const OilField& field = oil_fields[fidx];\n auto placements = get_possible_placements(field);\n \n if (placements.empty()) continue;\n \n // Try the top few placements\n int to_try = min(3, (int)placements.size());\n for (int pidx = 0; pidx < to_try; pidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& offset = placements[pidx].first;\n \n // Check if we can verify this placement\n bool need_verification = false;\n vector unknown_points;\n \n for (const Point& p : field.shape) {\n int i = p.i + offset.i;\n int j = p.j + offset.j;\n if (known_values[i][j] == -1) {\n need_verification = true;\n unknown_points.push_back(Point(i, j));\n }\n }\n \n if (!need_verification) continue; // Already verified or impossible\n \n // Try to verify with minimum operations\n if (unknown_points.size() == 1) {\n // Just drill the single unknown point\n const Point& pt = unknown_points[0];\n drill(pt.i, pt.j);\n } else if (unknown_points.size() <= 6) {\n // Divine the unknown points together\n divine(unknown_points);\n } else {\n // Drill the point with highest probability among unknowns\n Point best_point = unknown_points[0];\n double best_prob = probability[best_point.i][best_point.j];\n \n for (const Point& pt : unknown_points) {\n if (probability[pt.i][pt.j] > best_prob) {\n best_prob = probability[pt.i][pt.j];\n best_point = pt;\n }\n }\n \n drill(best_point.i, best_point.j);\n }\n }\n }\n }\n \n // Make final guess\n bool make_guess() {\n vector oil_squares;\n \n // Include all known oil squares\n for (const Point& p : known_oil_squares) {\n oil_squares.push_back(p);\n }\n \n // Include squares with high probability\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1 && probability[i][j] > 0.5) {\n oil_squares.push_back(Point(i, j));\n }\n }\n }\n \n // Remove duplicates (shouldn't happen but just in case)\n sort(oil_squares.begin(), oil_squares.end());\n oil_squares.erase(unique(oil_squares.begin(), oil_squares.end()), oil_squares.end());\n \n // Output guess\n cout << \"a \" << oil_squares.size();\n for (const Point& p : oil_squares) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n int result;\n cin >> result;\n \n return result == 1;\n }\n \n // Refine probabilities using shape constraints\n void refine_probabilities_with_shapes() {\n // For each square, calculate the probability based on possible oil field placements\n vector> new_prob(N, vector(N, 0.0));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] != -1) {\n new_prob[i][j] = (known_values[i][j] > 0) ? 1.0 : 0.0;\n continue;\n }\n \n double prob = 0.0;\n int count = 0;\n \n // Check how many oil fields could cover this square\n for (const OilField& field : oil_fields) {\n for (int oi = 0; oi <= N - 1 - field.max_i; oi++) {\n for (int oj = 0; oj <= N - 1 - field.max_j; oj++) {\n // Check if field can be placed at (oi, oj)\n if (!can_place_field(field, oi, oj)) continue;\n \n // Check if this square is covered by this placement\n bool covers = false;\n for (const Point& p : field.shape) {\n if (p.i + oi == i && p.j + oj == j) {\n covers = true;\n break;\n }\n }\n \n if (covers) {\n double placement_score = score_field_placement(field, oi, oj);\n if (placement_score > 0) {\n prob += min(1.0, placement_score / field.size);\n count++;\n }\n }\n }\n }\n }\n \n if (count > 0) {\n new_prob[i][j] = min(1.0, prob / count * 0.8 + probability[i][j] * 0.2);\n } else {\n new_prob[i][j] = probability[i][j];\n }\n }\n }\n \n // Update probabilities\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n probability[i][j] = new_prob[i][j];\n }\n }\n }\n }\n \npublic:\n Solver() : rng(random_device{}()) {}\n \n void solve() {\n read_input();\n \n // Phase 1: Coarse search with divination on large blocks\n phase1_coarse_search();\n \n // Phase 2: Refine with targeted search\n phase2_targeted_search();\n \n // Phase 3: Use shape information\n phase3_shape_guided_search();\n \n // Refine probabilities using shape constraints\n refine_probabilities_with_shapes();\n \n // Additional iterations if we have operations left\n while (operations_used < 2 * N * N) {\n // Check if we have high confidence in our answer\n int unknown_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n unknown_count++;\n }\n }\n }\n \n // If few unknowns, drill them directly\n if (unknown_count <= max(5, N/2)) {\n for (int i = 0; i < N && operations_used < 2 * N * N; i++) {\n for (int j = 0; j < N && operations_used < 2 * N * N; j++) {\n if (known_values[i][j] == -1) {\n drill(i, j);\n }\n }\n }\n } else {\n // Do another round of targeted search\n phase2_targeted_search();\n if (operations_used >= 2 * N * N) break;\n \n // Use shape information again\n phase3_shape_guided_search();\n if (operations_used >= 2 * N * N) break;\n \n // Refine probabilities\n refine_probabilities_with_shapes();\n }\n }\n \n // Make final guess\n bool success = make_guess();\n \n // If we failed, we could try again but we're out of operations\n // So just exit\n }\n};\n\nint main() {\n Solver solver;\n solver.solve();\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int i0, j0, i1, j1;\n \n Rectangle() : i0(0), j0(0), i1(0), j1(0) {}\n Rectangle(int i0, int j0, int i1, int j1) : i0(i0), j0(j0), i1(i1), j1(j1) {}\n \n int area() const {\n return (i1 - i0) * (j1 - j0);\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(i1 <= other.i0 || i0 >= other.i1 || j1 <= other.j0 || j0 >= other.j1);\n }\n \n // Check if rectangle is valid (within bounds and has positive area)\n bool isValid(int W) const {\n return i0 >= 0 && j0 >= 0 && i1 <= W && j1 <= W && i0 < i1 && j0 < j1;\n }\n};\n\nclass PartitionManager {\nprivate:\n int W;\n vector> horizontal_partitions; // [i][j] for horizontal partition at (i,j)-(i,j+1)\n vector> vertical_partitions; // [i][j] for vertical partition at (i,j)-(i+1,j)\n \npublic:\n PartitionManager(int W) : W(W) {\n horizontal_partitions.assign(W, vector(W, false));\n vertical_partitions.assign(W, vector(W, false));\n }\n \n void updateFromRectangles(const vector& rectangles) {\n // Reset all partitions\n for (int i = 0; i < W; i++) {\n fill(horizontal_partitions[i].begin(), horizontal_partitions[i].end(), false);\n fill(vertical_partitions[i].begin(), vertical_partitions[i].end(), false);\n }\n \n // Set partitions based on rectangles\n for (const auto& rect : rectangles) {\n // Top edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i0 > 0) vertical_partitions[rect.i0 - 1][j] = true;\n }\n // Bottom edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i1 < W) vertical_partitions[rect.i1 - 1][j] = true;\n }\n // Left edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j0 > 0) horizontal_partitions[i][rect.j0 - 1] = true;\n }\n // Right edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j1 < W) horizontal_partitions[i][rect.j1 - 1] = true;\n }\n }\n }\n \n int calculateChangeCost(const PartitionManager& prev) const {\n int cost = 0;\n \n // Horizontal partitions (i,j)-(i,j+1) where 1<=i<=W-1, 0<=j<=W-1\n for (int i = 1; i < W; i++) {\n for (int j = 0; j < W; j++) {\n if (horizontal_partitions[i-1][j] != prev.horizontal_partitions[i-1][j]) {\n cost++;\n }\n }\n }\n \n // Vertical partitions (i,j)-(i+1,j) where 0<=i<=W-1, 1<=j<=W-1\n for (int i = 0; i < W; i++) {\n for (int j = 1; j < W; j++) {\n if (vertical_partitions[i][j-1] != prev.vertical_partitions[i][j-1]) {\n cost++;\n }\n }\n }\n \n return cost;\n }\n};\n\nclass Solution {\nprivate:\n int W, D, N;\n vector> desired_areas;\n vector> solution;\n mt19937 rng;\n \npublic:\n Solution(int W, int D, int N, vector>&& areas) \n : W(W), D(D), N(N), desired_areas(move(areas)), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n solution.resize(D, vector(N));\n }\n \n // Calculate rental cost for a day\n long long calculateRentalCost(int day) const {\n long long cost = 0;\n for (int k = 0; k < N; k++) {\n int actual_area = solution[day][k].area();\n if (desired_areas[day][k] > actual_area) {\n cost += 100LL * (desired_areas[day][k] - actual_area);\n }\n }\n return cost;\n }\n \n // Calculate partition change cost for a day\n long long calculatePartitionCost(int day) const {\n if (day == 0) return 0;\n \n PartitionManager current(W), prev(W);\n current.updateFromRectangles(solution[day]);\n prev.updateFromRectangles(solution[day-1]);\n \n return current.calculateChangeCost(prev);\n }\n \n // Calculate total cost\n long long calculateTotalCost() const {\n long long total_cost = 0;\n for (int d = 0; d < D; d++) {\n total_cost += calculateRentalCost(d);\n total_cost += calculatePartitionCost(d);\n }\n return total_cost;\n }\n \n // Check if any rectangles on a day overlap\n bool hasOverlap(int day) const {\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (solution[day][i].overlaps(solution[day][j])) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Initialize day 0 with simple row-wise division\n void initializeDay0() {\n int total_height = W;\n vector heights(N);\n \n // Calculate heights proportional to desired areas\n long long total_desired = 0;\n for (int k = 0; k < N; k++) {\n total_desired += desired_areas[0][k];\n }\n \n int allocated_height = 0;\n for (int k = 0; k < N - 1; k++) {\n heights[k] = max(1, (int)((long long)desired_areas[0][k] * total_height / total_desired));\n allocated_height += heights[k];\n }\n heights[N-1] = total_height - allocated_height;\n if (heights[N-1] <= 0) {\n heights[N-1] = 1;\n // Adjust other heights if needed\n for (int k = 0; k < N-1 && allocated_height >= total_height; k++) {\n if (heights[k] > 1) {\n heights[k]--;\n allocated_height--;\n if (allocated_height < total_height) break;\n }\n }\n }\n \n // Create rectangles\n int current_i = 0;\n for (int k = 0; k < N; k++) {\n solution[0][k] = Rectangle(current_i, 0, current_i + heights[k], W);\n current_i += heights[k];\n }\n }\n \n // More robust overlap resolution\n void resolveOverlaps(int day) {\n const int MAX_ITERATIONS = 100;\n int iteration = 0;\n \n while (hasOverlap(day) && iteration < MAX_ITERATIONS) {\n iteration++;\n \n // Create a copy of current solution\n vector temp_solution = solution[day];\n \n // Find the first overlapping pair\n int overlap_i = -1, overlap_j = -1;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (temp_solution[i].overlaps(temp_solution[j])) {\n overlap_i = i;\n overlap_j = j;\n break;\n }\n }\n if (overlap_i != -1) break;\n }\n \n if (overlap_i == -1) break; // No more overlaps\n \n Rectangle& r1 = temp_solution[overlap_i];\n Rectangle& r2 = temp_solution[overlap_j];\n \n // Try different strategies to resolve overlap\n \n // Strategy 1: Move r2 to the right of r1\n if (r1.j1 < W) {\n int new_j0 = r1.j1;\n if (new_j0 < r2.j1) { // Ensure positive width\n int width = r2.j1 - r2.j0;\n if (new_j0 + width <= W) {\n r2.j0 = new_j0;\n r2.j1 = new_j0 + width;\n }\n }\n }\n \n // Check if overlap is resolved\n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 2: Move r2 below r1\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n if (r1.i1 < W) {\n int new_i0 = r1.i1;\n if (new_i0 < r2.i1) { // Ensure positive height\n int height = r2.i1 - r2.i0;\n if (new_i0 + height <= W) {\n r2.i0 = new_i0;\n r2.i1 = new_i0 + height;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 3: Shrink r2\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Calculate overlap region\n int overlap_i0 = max(r1.i0, r2.i0);\n int overlap_i1 = min(r1.i1, r2.i1);\n int overlap_j0 = max(r1.j0, r2.j0);\n int overlap_j1 = min(r1.j1, r2.j1);\n \n // Try to shrink r2 from the side that has the least impact\n if (overlap_j1 - overlap_j0 > 0 && overlap_i1 - overlap_i0 > 0) {\n // Prefer to shrink in the direction with smaller dimension\n if (r2.j1 - r2.j0 < r2.i1 - r2.i0) {\n // Shrink horizontally\n if (r2.j0 == overlap_j0) {\n r2.j0 = overlap_j1;\n } else {\n r2.j1 = overlap_j0;\n }\n } else {\n // Shrink vertically\n if (r2.i0 == overlap_i0) {\n r2.i0 = overlap_i1;\n } else {\n r2.i1 = overlap_i0;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 4: Try to move r1 instead\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Move r1 to left of r2\n if (r2.j0 > 0) {\n int width = r1.j1 - r1.j0;\n if (r2.j0 - width >= 0) {\n r1.j0 = r2.j0 - width;\n r1.j1 = r2.j0;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // If no strategy works, try to resize one of the rectangles\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Shrink r2 to eliminate overlap\n if (r2.j1 > r1.j0 && r2.j0 < r1.j1) {\n // Horizontal overlap\n if (r2.j0 < r1.j0) {\n r2.j1 = r1.j0;\n } else {\n r2.j0 = r1.j1;\n }\n }\n \n if (r2.i1 > r1.i0 && r2.i0 < r1.i1) {\n // Vertical overlap\n if (r2.i0 < r1.i0) {\n r2.i1 = r1.i0;\n } else {\n r2.i0 = r1.i1;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Last resort: just separate them arbitrarily\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Force separation\n r2.j0 = r1.j1;\n r2.j1 = r2.j0 + max(1, r2.j1 - r2.j0);\n if (r2.j1 > W) {\n r2.j1 = W;\n r2.j0 = max(0, r2.j1 - max(1, r2.j1 - r2.j0));\n }\n \n if (r1.overlaps(r2)) {\n r2.i0 = r1.i1;\n r2.i1 = r2.i0 + max(1, r2.i1 - r2.i0);\n if (r2.i1 > W) {\n r2.i1 = W;\n r2.i0 = max(0, r2.i1 - max(1, r2.i1 - r2.i0));\n }\n }\n \n if (r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n }\n }\n \n // Final validation\n if (hasOverlap(day)) {\n // If still overlapping, use a more drastic approach\n // Arrange rectangles in a grid\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // For subsequent days, start with previous day's solution and adjust\n void optimizeDay(int day) {\n // Start with previous day's configuration\n solution[day] = solution[day-1];\n \n // Calculate current areas\n vector current_areas(N);\n for (int k = 0; k < N; k++) {\n current_areas[k] = solution[day][k].area();\n }\n \n // Identify rectangles that need adjustment\n vector needs_more_area;\n for (int k = 0; k < N; k++) {\n if (current_areas[k] < desired_areas[day][k]) {\n needs_more_area.push_back(k);\n }\n }\n \n // Simple adjustment: try to expand rectangles that need more area\n for (int k : needs_more_area) {\n int deficit = desired_areas[day][k] - current_areas[k];\n if (deficit <= 0) continue;\n \n Rectangle original_rect = solution[day][k];\n Rectangle& rect = solution[day][k];\n \n // Try different expansion strategies\n \n // Strategy 1: Expand right\n if (rect.j1 < W) {\n int can_expand = W - rect.j1;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j1 += expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 2: Expand down\n if (deficit > 0 && rect.i1 < W) {\n int can_expand = W - rect.i1;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i1 += expand_by;\n deficit -= expand_by * width;\n }\n \n // Strategy 3: Expand left\n if (deficit > 0 && rect.j0 > 0) {\n int can_expand = rect.j0;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j0 -= expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 4: Expand up\n if (deficit > 0 && rect.i0 > 0) {\n int can_expand = rect.i0;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i0 -= expand_by;\n deficit -= expand_by * width;\n }\n \n // Ensure rectangle is valid\n if (!rect.isValid(W)) {\n solution[day][k] = original_rect;\n }\n }\n \n // Check for overlaps and resolve them\n resolveOverlaps(day);\n \n // Verify no overlaps remain\n if (hasOverlap(day)) {\n // Fallback: use grid arrangement\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // Local search optimization for a day (with proper overlap checking)\n void localSearchDay(int day, int iterations = 50) {\n // Keep track of the best solution\n auto best_solution = solution[day];\n long long best_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n for (int iter = 0; iter < iterations; iter++) {\n // Make a small random change\n auto current_solution = solution[day];\n \n // Select a random rectangle to modify\n int k = uniform_int_distribution(0, N-1)(rng);\n Rectangle original_rect = current_solution[k];\n Rectangle& rect = current_solution[k];\n \n // Randomly adjust one of the boundaries\n int change_type = uniform_int_distribution(0, 3)(rng);\n int change_amount = uniform_int_distribution(-3, 3)(rng);\n \n // Skip if change_amount is 0\n if (change_amount == 0) continue;\n \n switch (change_type) {\n case 0: // Adjust top\n rect.i0 += change_amount;\n break;\n case 1: // Adjust left\n rect.j0 += change_amount;\n break;\n case 2: // Adjust bottom\n rect.i1 += change_amount;\n break;\n case 3: // Adjust right\n rect.j1 += change_amount;\n break;\n }\n \n // Validate the rectangle\n if (!rect.isValid(W)) {\n current_solution[k] = original_rect;\n }\n \n // Check for overlaps\n bool has_overlap = false;\n for (int i = 0; i < N && !has_overlap; i++) {\n for (int j = i + 1; j < N && !has_overlap; j++) {\n if (current_solution[i].overlaps(current_solution[j])) {\n has_overlap = true;\n }\n }\n }\n \n if (!has_overlap) {\n // Calculate new cost\n auto temp_solution = solution[day];\n solution[day] = current_solution;\n long long new_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n // Accept if better\n if (new_cost < best_cost) {\n best_solution = current_solution;\n best_cost = new_cost;\n }\n \n // Revert for next iteration\n solution[day] = temp_solution;\n }\n }\n \n // Set the best solution found\n solution[day] = best_solution;\n \n // Final overlap check\n if (hasOverlap(day)) {\n resolveOverlaps(day);\n }\n }\n \n void solve() {\n // Initialize day 0\n initializeDay0();\n \n // Ensure no overlaps on day 0\n resolveOverlaps(0);\n \n // Optimize subsequent days\n for (int d = 1; d < D; d++) {\n optimizeDay(d);\n // Apply local search for further improvement\n localSearchDay(d, 30);\n \n // Final validation\n if (hasOverlap(d)) {\n resolveOverlaps(d);\n }\n }\n }\n \n void output() const {\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cout << solution[d][k].i0 << \" \" \n << solution[d][k].j0 << \" \" \n << solution[d][k].i1 << \" \" \n << solution[d][k].j1 << endl;\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int W, D, N;\n cin >> W >> D >> N;\n \n vector> areas(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> areas[d][k];\n }\n }\n \n Solution solver(W, D, N, move(areas));\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\n// Calculate improvement from applying a stamp at position (p,q)\nlong long calculateImprovement(const vector>& board, \n const vector>& stamp,\n int p, int q) {\n long long improvement = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n long long current_remainder = board[p + i][q + j] % MOD;\n long long new_remainder = (board[p + i][q + j] + stamp[i][j]) % MOD;\n improvement += (new_remainder - current_remainder);\n }\n }\n return improvement;\n}\n\n// Apply a stamp operation to a board (modifies the board)\nvoid applyStamp(vector>& board, \n const vector>& stamp,\n int p, int q) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n board[p + i][q + j] += stamp[i][j];\n }\n }\n}\n\n// Simple 2-step lookahead evaluation\nlong long evaluateTwoStep(const vector>& board, \n const vector>>& stamps,\n int m1, int p1, int q1,\n int M, int N) {\n // Create a copy of the board\n vector> temp_board = board;\n \n // Apply first operation\n applyStamp(temp_board, stamps[m1], p1, q1);\n \n // Find the best second operation\n long long best_second_improvement = -1e18;\n for (int m2 = 0; m2 < M; m2++) {\n for (int p2 = 0; p2 <= N - 3; p2++) {\n for (int q2 = 0; q2 <= N - 3; q2++) {\n long long improvement = calculateImprovement(temp_board, stamps[m2], p2, q2);\n best_second_improvement = max(best_second_improvement, improvement);\n }\n }\n }\n \n // Return total expected improvement\n long long first_improvement = calculateImprovement(board, stamps[m1], p1, q1);\n return first_improvement + max(0LL, best_second_improvement);\n}\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n \n // Read initial board\n vector> board(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> board[i][j];\n }\n }\n \n // Read stamps\n vector>> stamps(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n cin >> stamps[m][i][j];\n }\n }\n }\n \n // Store operations\n vector> operations;\n \n // Pre-calculate average improvement per stamp to guide selection\n vector stamp_values(M, 0);\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n stamp_values[m] += stamps[m][i][j] % MOD;\n }\n }\n }\n \n // Greedy selection with 2-step lookahead for early operations\n for (int op = 0; op < K; op++) {\n long long best_improvement = -1e18;\n int best_stamp = -1, best_p = -1, best_q = -1;\n \n // For the first 20 operations, use 2-step lookahead\n // For remaining operations, use simple greedy (faster and often better)\n if (op < 20) {\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n long long improvement = evaluateTwoStep(board, stamps, m, p, q, M, N);\n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n } else {\n // Simple greedy for remaining operations\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n long long improvement = calculateImprovement(board, stamps[m], p, q);\n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n }\n \n // Apply the best operation\n applyStamp(board, stamps[best_stamp], best_p, best_q);\n \n // Record the operation\n operations.push_back(make_tuple(best_stamp, best_p, best_q));\n }\n \n // Local search refinement: try swapping adjacent operations\n for (int i = 0; i < operations.size() - 1; i++) {\n // Create a copy of the board in state before operation i\n vector> temp_board = board;\n \n // Reverse operations from end to i\n for (int j = operations.size() - 1; j >= i; j--) {\n int m = get<0>(operations[j]);\n int p = get<1>(operations[j]);\n int q = get<2>(operations[j]);\n for (int x = 0; x < 3; x++) {\n for (int y = 0; y < 3; y++) {\n temp_board[p + x][q + y] -= stamps[m][x][y];\n }\n }\n }\n \n // Try swapping operations i and i+1\n int m1 = get<0>(operations[i]);\n int p1 = get<1>(operations[i]);\n int q1 = get<2>(operations[i]);\n int m2 = get<0>(operations[i+1]);\n int p2 = get<1>(operations[i+1]);\n int q2 = get<2>(operations[i+1]);\n \n // Calculate score with original order\n vector> board_orig = temp_board;\n applyStamp(board_orig, stamps[m1], p1, q1);\n applyStamp(board_orig, stamps[m2], p2, q2);\n long long score_orig = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n score_orig += board_orig[r][c] % MOD;\n }\n }\n \n // Calculate score with swapped order\n vector> board_swap = temp_board;\n applyStamp(board_swap, stamps[m2], p2, q2);\n applyStamp(board_swap, stamps[m1], p1, q1);\n long long score_swap = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n score_swap += board_swap[r][c] % MOD;\n }\n }\n \n // If swapping improves score, do it\n if (score_swap > score_orig) {\n swap(operations[i], operations[i+1]);\n // Update the board to reflect the swap\n board = board_swap;\n } else {\n // Restore the board if no swap\n board = board_orig;\n }\n }\n \n // Output\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << get<0>(op) << \" \" << get<1>(op) << \" \" << get<2>(op) << endl;\n }\n \n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int row, col;\n int holding; // -1 if not holding, container number otherwise\n bool is_large;\n bool bombed;\n};\n\nstruct ContainerInfo {\n int target_row; // which row's dispatch gate it should go to\n int target_order; // order within that row (0 to N-1)\n bool arrived;\n bool dispatched;\n int arrival_row; // which receiving gate it will arrive from\n int arrival_order; // order in which it arrives at that gate\n};\n\n// Direction vectors for U, D, L, R\nconst int dr[4] = {-1, 1, 0, 0};\nconst int dc[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nclass Solver {\nprivate:\n int N;\n vector> A;\n vector cranes;\n vector> grid; // -1 if empty, container number otherwise\n int turn_count;\n \n // Track which containers have been brought in from each receiving gate\n vector next_container_index;\n \n // BFS to find shortest path avoiding obstacles\n vector> find_path(int start_row, int start_col, int end_row, int end_col, \n bool carrying_container, bool is_large_crane,\n const vector>& static_obstacles) {\n if (start_row == end_row && start_col == end_col) {\n return {{start_row, start_col}};\n }\n \n vector> dist(N, vector(N, -1));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n \n dist[start_row][start_col] = 0;\n q.push({start_row, start_col});\n \n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n \n // Check bounds\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) continue;\n \n // Check if already visited\n if (dist[nr][nc] != -1) continue;\n \n // Check static obstacles (containers for small cranes)\n if (carrying_container && !is_large_crane && grid[nr][nc] != -1) {\n continue;\n }\n \n // Check static obstacles (permanent obstacles)\n if (static_obstacles[nr][nc]) {\n continue;\n }\n \n dist[nr][nc] = dist[r][c] + 1;\n parent[nr][nc] = {r, c};\n q.push({nr, nc});\n \n if (nr == end_row && nc == end_col) {\n // Reconstruct path\n vector> path;\n int cur_r = nr, cur_c = nc;\n while (cur_r != -1) {\n path.push_back({cur_r, cur_c});\n auto p = parent[cur_r][cur_c];\n cur_r = p.first;\n cur_c = p.second;\n }\n reverse(path.begin(), path.end());\n return path;\n }\n }\n }\n \n return {}; // No path found\n }\n \n // Check if a move is valid considering crane collisions\n bool is_valid_move(int crane_id, char action, const vector>& current_positions,\n const vector& proposed_actions, const vector>& proposed_positions) {\n if (action == '.' || action == 'P' || action == 'Q' || action == 'B') {\n return true;\n }\n \n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n int current_r = current_positions[crane_id].first;\n int current_c = current_positions[crane_id].second;\n int next_r = current_r + dr[d];\n int next_c = current_c + dc[d];\n \n // Check bounds\n if (next_r < 0 || next_r >= N || next_c < 0 || next_c >= N) {\n return false;\n }\n \n // Check for collisions with other cranes' proposed positions\n for (int i = 0; i < N; i++) {\n if (i == crane_id || cranes[i].bombed) continue;\n \n // Check if moving to the same position\n if (proposed_positions[i].first == next_r && proposed_positions[i].second == next_c) {\n return false;\n }\n \n // Check for swapping\n if (proposed_positions[i].first == current_r && proposed_positions[i].second == current_c &&\n ((proposed_actions[i] == 'U' && action == 'D') ||\n (proposed_actions[i] == 'D' && action == 'U') ||\n (proposed_actions[i] == 'L' && action == 'R') ||\n (proposed_actions[i] == 'R' && action == 'L'))) {\n // Check if they would swap\n int opp_d = (proposed_actions[i] == 'U') ? 0 : (proposed_actions[i] == 'D') ? 1 : (proposed_actions[i] == 'L') ? 2 : 3;\n int opp_next_r = current_positions[i].first + dr[opp_d];\n int opp_next_c = current_positions[i].second + dc[opp_d];\n \n if (opp_next_r == next_r && opp_next_c == next_c) {\n return false;\n }\n }\n }\n \n return true;\n }\n \n // Calculate proposed positions for cranes\n vector> calculate_proposed_positions(const vector>& current_positions, \n const vector& actions) {\n vector> proposed_positions = current_positions;\n \n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n proposed_positions[i].first = current_positions[i].first + dr[d];\n proposed_positions[i].second = current_positions[i].second + dc[d];\n }\n }\n \n return proposed_positions;\n }\n \n // Get next action with improved coordination\n vector get_coordinated_actions() {\n vector actions(N, '.');\n vector> current_positions(N);\n \n // Record current positions\n for (int i = 0; i < N; i++) {\n current_positions[i] = {cranes[i].row, cranes[i].col};\n }\n \n // Create static obstacles (only consider non-crane obstacles for pathfinding)\n vector> static_obstacles(N, vector(N, false));\n \n // First priority: Pick up containers if possible and it's safe\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding != -1) continue;\n \n // Check if there's a container at current position\n if (grid[cranes[i].row][cranes[i].col] != -1) {\n actions[i] = 'P';\n }\n }\n \n // Second priority: Deliver containers to dispatch gates\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || cranes[i].holding == -1) continue;\n \n int container = cranes[i].holding;\n int target_row = containers[container].target_row;\n \n // If at dispatch gate and it's the correct one\n if (cranes[i].row == target_row && cranes[i].col == N-1) {\n actions[i] = 'Q';\n }\n }\n \n // Get current state of proposed positions\n vector> proposed_positions = calculate_proposed_positions(current_positions, actions);\n \n // Third priority: Move cranes toward goals\n // Start with cranes that are not doing anything yet\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || actions[i] != '.') continue;\n \n char best_action = '.';\n int best_score = -1;\n \n // Try each possible direction\n for (int d = 0; d < 4; d++) {\n char action = dir_char[d];\n vector test_actions = actions;\n test_actions[i] = action;\n \n vector> test_positions = calculate_proposed_positions(current_positions, test_actions);\n \n // Check if this move is valid\n if (!is_valid_move(i, action, current_positions, test_actions, test_positions)) {\n continue;\n }\n \n // Check if this move is physically possible (for small cranes)\n int next_r = cranes[i].row + dr[d];\n int next_c = cranes[i].col + dc[d];\n \n if (cranes[i].holding != -1 && !cranes[i].is_large && grid[next_r][next_c] != -1) {\n continue; // Small crane can't move to occupied square while carrying\n }\n \n // Calculate score for this move\n int score = 0;\n \n if (cranes[i].holding != -1) {\n // Carrying a container - prioritize moving toward target\n int container = cranes[i].holding;\n int target_row = containers[container].target_row;\n int dist_before = abs(cranes[i].row - target_row) + abs(cranes[i].col - (N-1));\n int dist_after = abs(next_r - target_row) + abs(next_c - (N-1));\n \n if (dist_after < dist_before) {\n score = 1000 - dist_after; // Higher score for getting closer to target\n } else {\n score = -100; // Penalize moves away from target\n }\n } else {\n // Not carrying - look for containers to pick up\n // Prefer moving toward receiving gates with containers\n int min_dist_to_container = INT_MAX;\n int target_r = -1, target_c = -1;\n \n for (int r = 0; r < N; r++) {\n if (grid[r][0] != -1) { // Container at receiving gate\n int dist = abs(next_r - r) + abs(next_c - 0);\n if (dist < min_dist_to_container) {\n min_dist_to_container = dist;\n target_r = r;\n target_c = 0;\n }\n }\n }\n \n if (min_dist_to_container != INT_MAX) {\n // Also check for any container on the grid\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n if (grid[r][c] != -1) {\n int dist = abs(next_r - r) + abs(next_c - c);\n if (dist < min_dist_to_container) {\n min_dist_to_container = dist;\n target_r = r;\n target_c = c;\n }\n }\n }\n }\n \n int current_dist = abs(cranes[i].row - target_r) + abs(cranes[i].col - target_c);\n if (min_dist_to_container < current_dist) {\n score = 500 - min_dist_to_container; // Higher score for getting closer to a container\n } else {\n score = -50; // Penalize moves away from containers\n }\n } else {\n score = -10; // Small penalty for moving without clear purpose\n }\n }\n \n if (score > best_score) {\n best_score = score;\n best_action = action;\n }\n }\n \n actions[i] = best_action;\n proposed_positions = calculate_proposed_positions(current_positions, actions);\n }\n \n // Check if all actions are valid together\n proposed_positions = calculate_proposed_positions(current_positions, actions);\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n if (actions[i] == 'U' || actions[i] == 'D' || actions[i] == 'L' || actions[i] == 'R') {\n if (!is_valid_move(i, actions[i], current_positions, actions, proposed_positions)) {\n actions[i] = '.'; // Fall back to no move\n }\n }\n }\n \n return actions;\n }\n \n // Simulate one turn\n bool simulate_turn(vector& actions) {\n // Step 1: Bring in new containers at receiving gates\n for (int i = 0; i < N; i++) {\n // Check if we can bring in next container\n if (next_container_index[i] < N && grid[i][0] == -1) {\n // Check if there's no crane at the receiving gate\n bool crane_at_gate = false;\n for (int j = 0; j < N; j++) {\n if (!cranes[j].bombed && cranes[j].row == i && cranes[j].col == 0 && \n actions[j] != 'U' && actions[j] != 'D' && actions[j] != 'L' && actions[j] != 'R') {\n // Only consider cranes that will be stationary at the gate\n crane_at_gate = true;\n break;\n }\n }\n \n if (!crane_at_gate) {\n int container = A[i][next_container_index[i]];\n grid[i][0] = container;\n containers[container].arrived = true;\n next_container_index[i]++;\n }\n }\n }\n \n // Validate actions and check for collisions\n vector> current_positions(N);\n for (int i = 0; i < N; i++) {\n current_positions[i] = {cranes[i].row, cranes[i].col};\n }\n \n vector> next_positions = current_positions;\n vector will_bomb(N, false);\n \n // Validate individual actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) {\n actions[i] = '.';\n continue;\n }\n \n char action = actions[i];\n int r = cranes[i].row;\n int c = cranes[i].col;\n \n if (action == 'P') {\n if (cranes[i].holding != -1 || grid[r][c] == -1) {\n actions[i] = '.'; // Invalid action, do nothing\n }\n } else if (action == 'Q') {\n if (cranes[i].holding == -1 || grid[r][c] != -1) {\n actions[i] = '.'; // Invalid action, do nothing\n }\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n int nr = r + dr[d];\n int nc = c + dc[d];\n \n if (nr < 0 || nr >= N || nc < 0 || nc >= N) {\n actions[i] = '.'; // Out of bounds, do nothing\n } else if (cranes[i].holding != -1 && !cranes[i].is_large && grid[nr][nc] != -1) {\n actions[i] = '.'; // Small crane can't move to occupied square while carrying\n } else {\n next_positions[i] = {nr, nc};\n }\n } else if (action == 'B') {\n if (cranes[i].holding != -1) {\n actions[i] = '.'; // Can't bomb while holding container\n } else {\n will_bomb[i] = true;\n }\n }\n }\n \n // Calculate final next positions\n next_positions = current_positions;\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n next_positions[i].first = current_positions[i].first + dr[d];\n next_positions[i].second = current_positions[i].second + dc[d];\n }\n }\n \n // Check for collisions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed || actions[i] == 'P' || actions[i] == 'Q' || actions[i] == 'B' || actions[i] == '.') {\n continue;\n }\n \n for (int j = 0; j < N; j++) {\n if (i == j || cranes[j].bombed) continue;\n \n // Check for same destination\n if (actions[j] == 'U' || actions[j] == 'D' || actions[j] == 'L' || actions[j] == 'R') {\n if (next_positions[i] == next_positions[j]) {\n actions[i] = '.'; // Collision, revert to no move\n break;\n }\n }\n \n // Check for swapping\n if ((actions[i] == 'U' && actions[j] == 'D') ||\n (actions[i] == 'D' && actions[j] == 'U') ||\n (actions[i] == 'L' && actions[j] == 'R') ||\n (actions[i] == 'R' && actions[j] == 'L')) {\n if (next_positions[i] == current_positions[j] && \n next_positions[j] == current_positions[i]) {\n actions[i] = '.'; // Swapping, revert to no move\n break;\n }\n }\n }\n }\n \n // Recalculate next positions after collision checks\n next_positions = current_positions;\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n next_positions[i].first = current_positions[i].first + dr[d];\n next_positions[i].second = current_positions[i].second + dc[d];\n }\n }\n \n // Apply actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n int& r = cranes[i].row;\n int& c = cranes[i].col;\n \n if (action == 'P') {\n cranes[i].holding = grid[r][c];\n grid[r][c] = -1;\n } else if (action == 'Q') {\n grid[r][c] = cranes[i].holding;\n cranes[i].holding = -1;\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n int d = (action == 'U') ? 0 : (action == 'D') ? 1 : (action == 'L') ? 2 : 3;\n r = next_positions[i].first;\n c = next_positions[i].second;\n } else if (action == 'B') {\n cranes[i].bombed = true;\n }\n // '.' means stay in place\n }\n \n // Step 3: Dispatch containers at dispatch gates\n for (int i = 0; i < N; i++) {\n if (grid[i][N-1] != -1) {\n int container = grid[i][N-1];\n containers[container].dispatched = true;\n grid[i][N-1] = -1;\n }\n }\n \n turn_count++;\n return true;\n }\n \n // Check if all containers are dispatched correctly\n bool is_complete() {\n for (int i = 0; i < N*N; i++) {\n if (!containers[i].dispatched) {\n return false;\n }\n }\n return true;\n }\n \n // Check if we're making progress (to avoid infinite loops)\n bool is_making_progress() {\n // Simple progress check: are any containers being dispatched?\n static int last_dispatched_count = 0;\n static int turns_since_last_progress = 0;\n \n int current_dispatched_count = 0;\n for (int i = 0; i < N*N; i++) {\n if (containers[i].dispatched) {\n current_dispatched_count++;\n }\n }\n \n if (current_dispatched_count > last_dispatched_count) {\n last_dispatched_count = current_dispatched_count;\n turns_since_last_progress = 0;\n } else {\n turns_since_last_progress++;\n }\n \n // If no progress in 100 turns, we might be stuck\n return turns_since_last_progress < 100;\n }\n \npublic:\n vector containers;\n \n Solver(int n, vector>& a) : N(n), A(a) {\n // Initialize cranes\n cranes.resize(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].holding = -1;\n cranes[i].is_large = (i == 0); // Crane 0 is large\n cranes[i].bombed = false;\n }\n \n // Initialize grid\n grid.assign(N, vector(N, -1));\n \n // Initialize container info\n containers.resize(N*N);\n for (int i = 0; i < N*N; i++) {\n containers[i].target_row = i / N;\n containers[i].target_order = i % N;\n containers[i].arrived = false;\n containers[i].dispatched = false;\n }\n \n // Set arrival info\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container = A[i][j];\n containers[container].arrival_row = i;\n containers[container].arrival_order = j;\n }\n }\n \n next_container_index.assign(N, 0);\n turn_count = 0;\n }\n \n vector solve() {\n vector results(N, \"\");\n \n // Simulate up to 10000 turns\n for (int turn = 0; turn < 10000; turn++) {\n // Get coordinated actions\n vector actions = get_coordinated_actions();\n \n // Record actions\n for (int i = 0; i < N; i++) {\n results[i] += actions[i];\n }\n \n // Simulate the turn\n simulate_turn(actions);\n \n // Check if we're done\n if (is_complete()) {\n break;\n }\n \n // Check if we're stuck\n if (turn > 500 && !is_making_progress()) {\n // Try a recovery strategy - move all cranes to clear positions\n break;\n }\n }\n \n return results;\n }\n};\n\nint main() {\n int N;\n cin >> N;\n \n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n Solver solver(N, A);\n vector results = solver.solve();\n \n for (int i = 0; i < N; i++) {\n cout << results[i] << endl;\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n\n int r = 0, c = 0;\n int truck = 0;\n vector ops;\n\n while (true) {\n bool all_zero = true;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) {\n all_zero = false;\n break;\n }\n }\n if (!all_zero) break;\n }\n if (all_zero) break;\n\n int target_r = -1, target_c = -1;\n\n if (truck == 0) {\n int min_dist = INT_MAX;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break;\n } else {\n int best_score = INT_MIN;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] < 0) {\n int dist = abs(i - r) + abs(j - c);\n int d = min(truck, -h[i][j]);\n if (d <= 0) continue;\n int score = d - 100 * dist;\n if (score > best_score) {\n best_score = score;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break;\n }\n\n while (r < target_r) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > target_r) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < target_c) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > target_c) {\n ops.push_back(\"L\");\n c--;\n }\n\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n } else if (h[r][c] < 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n }\n }\n\n for (const string& op : ops) {\n cout << op << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, T;\nint seed_count;\n\n// Seed structure\nstruct Seed {\n vector values;\n int id;\n int total_value;\n \n Seed() : id(-1), total_value(0) {}\n \n void calculate_total() {\n total_value = 0;\n for (int v : values) {\n total_value += v;\n }\n }\n \n // Calculate how many criteria this seed is in top K for\n int count_top_k_criteria(const vector>& criterion_ranks, int k) {\n if (id < 0 || id >= criterion_ranks[0].size()) return 0;\n int count = 0;\n for (int i = 0; i < M; i++) {\n if (criterion_ranks[i][id] < k) {\n count++;\n }\n }\n return count;\n }\n};\n\n// Compare seeds by total value\nbool compare_seeds_by_value(const Seed& a, const Seed& b) {\n return a.total_value > b.total_value;\n}\n\n// Position in grid\nstruct Position {\n int row, col;\n int adjacency_count;\n \n Position(int r, int c) : row(r), col(c) {\n adjacency_count = 0;\n if (r > 0) adjacency_count++;\n if (r < N-1) adjacency_count++;\n if (c > 0) adjacency_count++;\n if (c < N-1) adjacency_count++;\n }\n};\n\nbool compare_positions(const Position& a, const Position& b) {\n return a.adjacency_count > b.adjacency_count;\n}\n\n// Calculate complementarity score between two seeds\nint calculate_complementarity(const Seed& a, const Seed& b) {\n int score = 0;\n for (int i = 0; i < M; i++) {\n score += max(a.values[i], b.values[i]);\n }\n return score;\n}\n\nint main() {\n cin >> N >> M >> T;\n seed_count = 2 * N * (N - 1);\n \n vector seeds(seed_count);\n \n // Read initial seeds\n for (int i = 0; i < seed_count; i++) {\n seeds[i].values.resize(M);\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n \n // Process T turns\n for (int t = 0; t < T; t++) {\n // For each criterion, create ranking of seeds\n vector> criterion_ranks(M, vector(seed_count));\n for (int crit = 0; crit < M; crit++) {\n vector> crit_values; // (value, seed_id)\n for (int i = 0; i < seed_count; i++) {\n crit_values.push_back({seeds[i].values[crit], i});\n }\n sort(crit_values.begin(), crit_values.end(), greater>());\n for (int rank = 0; rank < seed_count; rank++) {\n criterion_ranks[crit][crit_values[rank].second] = rank;\n }\n }\n \n // Create a combined score for selection\n vector> selection_scores(seed_count);\n for (int i = 0; i < seed_count; i++) {\n // Base score is total value\n double score = seeds[i].total_value;\n \n // Bonus for being in top 5 for any criterion\n int top5_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][i] < 5) {\n top5_count++;\n }\n }\n score += top5_count * 10; // Bonus for specialization\n \n // Bonus for being in top 1 for any criterion\n int top1_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][i] == 0) {\n top1_count++;\n }\n }\n score += top1_count * 50; // Bigger bonus for being best in a criterion\n \n selection_scores[i] = {score, i};\n }\n \n // Sort by combined score\n sort(selection_scores.begin(), selection_scores.end(), greater>());\n \n // Select top 36 seeds\n vector selected_seeds;\n for (int i = 0; i < N * N; i++) {\n selected_seeds.push_back(selection_scores[i].second);\n }\n \n // Create grid for planting\n vector> grid(N, vector(N, -1));\n \n // Generate positions sorted by adjacency count\n vector positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.emplace_back(i, j);\n }\n }\n sort(positions.begin(), positions.end(), compare_positions);\n \n // First, place seeds that are best in at least one criterion in high-adjacency positions\n vector placed(seed_count, false);\n unordered_set placed_indices;\n \n // Place the absolute best seeds (top 1 in any criterion) in top 20 positions (center focused)\n int pos_idx = 0;\n for (int i = 0; i < selected_seeds.size() && pos_idx < min(20, (int)positions.size()); i++) {\n int seed_id = selected_seeds[i];\n bool is_top1 = false;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][seed_id] == 0) {\n is_top1 = true;\n break;\n }\n }\n if (is_top1 && pos_idx < 20) { // Place top-1 seeds in top 20 positions (center focused)\n int row = positions[pos_idx].row;\n int col = positions[pos_idx].col;\n grid[row][col] = seed_id;\n placed[seed_id] = true;\n placed_indices.insert(i);\n pos_idx++;\n }\n }\n \n // Place remaining seeds from selected_seeds\n for (int i = 0; i < selected_seeds.size(); i++) {\n if (placed[selected_seeds[i]]) continue;\n \n if (pos_idx < positions.size()) {\n int row = positions[pos_idx].row;\n int col = positions[pos_idx].col;\n grid[row][col] = selected_seeds[i];\n placed[selected_seeds[i]] = true;\n pos_idx++;\n }\n }\n \n // Now optimize placement by trying to place complementary seeds adjacent to each other\n // For each position, try to swap with another to improve complementarity\n if (t < T - 1 && N * N > 1) { // Only optimize if we have more turns and multiple positions\n for (int iter = 0; iter < 5; iter++) { // Small number of iterations\n bool improved = false;\n \n for (int i1 = 0; i1 < N; i1++) {\n for (int j1 = 0; j1 < N; j1++) {\n for (int i2 = i1; i2 < N; i2++) {\n for (int j2 = (i2 == i1) ? j1 + 1 : 0; j2 < N; j2++) {\n // Calculate current complementarity score for these positions\n int current_score = 0;\n int seed1 = grid[i1][j1];\n int seed2 = grid[i2][j2];\n \n // Check neighbors of position 1\n vector> neighbors1;\n if (i1 > 0) neighbors1.push_back({i1-1, j1});\n if (i1 < N-1) neighbors1.push_back({i1+1, j1});\n if (j1 > 0) neighbors1.push_back({i1, j1-1});\n if (j1 < N-1) neighbors1.push_back({i1, j1+1});\n \n // Check neighbors of position 2\n vector> neighbors2;\n if (i2 > 0) neighbors2.push_back({i2-1, j2});\n if (i2 < N-1) neighbors2.push_back({i2+1, j2});\n if (j2 > 0) neighbors2.push_back({i2, j2-1});\n if (j2 < N-1) neighbors2.push_back({i2, j2+1});\n \n // Calculate current complementarity\n for (auto& nb : neighbors1) {\n if (!(nb.first == i2 && nb.second == j2)) { // Avoid self-comparison\n int nb_seed = grid[nb.first][nb.second];\n if (nb_seed != -1) {\n current_score += calculate_complementarity(\n seeds[seed1], seeds[nb_seed]);\n }\n }\n }\n \n for (auto& nb : neighbors2) {\n if (!(nb.first == i1 && nb.second == j1)) { // Avoid self-comparison\n int nb_seed = grid[nb.first][nb.second];\n if (nb_seed != -1) {\n current_score += calculate_complementarity(\n seeds[seed2], seeds[nb_seed]);\n }\n }\n }\n \n // Calculate score if we swap\n int swapped_score = 0;\n for (auto& nb : neighbors1) {\n if (!(nb.first == i2 && nb.second == j2)) {\n int nb_seed = grid[nb.first][nb.second];\n if (nb_seed != -1) {\n swapped_score += calculate_complementarity(\n seeds[seed2], seeds[nb_seed]);\n }\n }\n }\n \n for (auto& nb : neighbors2) {\n if (!(nb.first == i1 && nb.second == j1)) {\n int nb_seed = grid[nb.first][nb.second];\n if (nb_seed != -1) {\n swapped_score += calculate_complementarity(\n seeds[seed1], seeds[nb_seed]);\n }\n }\n }\n \n // If swapping improves the score, do it\n if (swapped_score > current_score + 5) { // Small threshold to avoid noise\n swap(grid[i1][j1], grid[i2][j2]);\n improved = true;\n }\n }\n }\n }\n }\n \n if (!improved) break;\n }\n }\n \n // Output the grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j];\n if (j < N - 1) {\n cout << \" \";\n }\n }\n cout << endl;\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n }\n \n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n bool in_bounds(int N) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nstruct State {\n Point root_pos;\n vector directions; // Direction of each edge (0=R, 1=D, 2=L, 3=U)\n vector holding; // What each fingertip is holding\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector initial_grid, target_grid;\n vector start_positions, target_positions;\n vector tree;\n int V_prime;\n vector fingertips;\n State current_state;\n mt19937 rng;\n \n // Direction vectors: Right, Down, Left, Up\n const vector DX = {1, 0, -1, 0};\n const vector DY = {0, 1, 0, -1};\n const string DIR_CHARS = \"RDLU\";\n \npublic:\n RoboticArmSolver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n void read_input() {\n cin >> N >> M >> V;\n initial_grid.resize(N);\n target_grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> initial_grid[i];\n }\n for (int i = 0; i < N; i++) {\n cin >> target_grid[i];\n }\n \n // Extract start and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '0') {\n start_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '0' && target_grid[i][j] == '1') {\n target_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n // Already in correct position, no need to move\n // But we still count it for M'\n M--;\n }\n }\n }\n \n // Shuffle for randomization\n shuffle(start_positions.begin(), start_positions.end(), rng);\n shuffle(target_positions.begin(), target_positions.end(), rng);\n }\n \n void design_arm() {\n // Determine number of vertices to use\n V_prime = min(V, 10); // Use up to 10 vertices for simplicity\n \n // Build a simple tree: root (0) connected to several children\n // Try to create a balanced tree with multiple fingertips\n tree.resize(V_prime);\n for (int i = 0; i < V_prime; i++) {\n tree[i].is_leaf = true; // Initially all are leaves\n }\n \n // Create tree structure\n // Root at 0\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Add children to root and possibly to other nodes\n int next_vertex = 1;\n vector current_level = {0};\n \n while (next_vertex < V_prime) {\n vector next_level;\n for (int parent : current_level) {\n if (next_vertex >= V_prime) break;\n \n // Add 1-2 children to each node\n int children_count = min(2, V_prime - next_vertex);\n for (int i = 0; i < children_count && next_vertex < V_prime; i++) {\n tree[next_vertex].parent = parent;\n tree[next_vertex].length = 1; // Use length 1 for simplicity\n tree[parent].children.push_back(next_vertex);\n tree[parent].is_leaf = false;\n next_level.push_back(next_vertex);\n next_vertex++;\n }\n }\n current_level = next_level;\n }\n \n // Identify fingertips (leaves)\n for (int i = 0; i < V_prime; i++) {\n if (tree[i].is_leaf) {\n fingertips.push_back(i);\n }\n }\n }\n \n Point find_initial_position() {\n // Find a central position that minimizes distance to start positions\n int best_x = N/2, best_y = N/2;\n double min_dist = 1e9;\n \n // Try positions around center\n for (int x = max(0, N/2 - 2); x <= min(N-1, N/2 + 2); x++) {\n for (int y = max(0, N/2 - 2); y <= min(N-1, N/2 + 2); y++) {\n double dist = 0;\n for (const Point& p : start_positions) {\n dist += abs(p.x - x) + abs(p.y - y);\n }\n if (dist < min_dist) {\n min_dist = dist;\n best_x = x;\n best_y = y;\n }\n }\n }\n \n return Point(best_x, best_y);\n }\n \n // Calculate positions of all vertices given root position and directions\n vector calculate_positions(const Point& root_pos, const vector& directions) {\n vector positions(V_prime);\n positions[0] = root_pos;\n \n for (int i = 1; i < V_prime; i++) {\n int parent = tree[i].parent;\n int dir = directions[i];\n int len = tree[i].length;\n \n positions[i] = Point(\n positions[parent].x + DY[dir] * len, // Note: Y is row, X is column\n positions[parent].y + DX[dir] * len\n );\n }\n \n return positions;\n }\n \n // Find distance between two points\n int manhattan_distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the best move for the arm\n string find_best_move() {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n string command(2 * V_prime, '.');\n \n // First, try to pick up or place takoyaki\n bool did_action = false;\n for (int i = 0; i < fingertips.size() && !did_action; i++) {\n int finger = fingertips[i];\n Point pos = positions[finger];\n \n if (!pos.in_bounds(N)) continue;\n \n // Check if we can pick up a takoyaki\n if (!current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '1' && \n target_grid[pos.x][pos.y] == '0') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = true;\n initial_grid[pos.x][pos.y] = '0'; // Remove from initial grid\n did_action = true;\n continue;\n }\n \n // Check if we can place a takoyaki\n if (current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '0' && \n target_grid[pos.x][pos.y] == '1') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = false;\n initial_grid[pos.x][pos.y] = '1'; // Add to grid (mark as delivered)\n did_action = true;\n continue;\n }\n }\n \n if (did_action) {\n return command;\n }\n \n // No pickup/place action, move toward a target\n // Find closest undelivered takoyaki or target position\n Point target_pos;\n bool move_to_start = false;\n \n if (!start_positions.empty()) {\n // Find closest start position that has a takoyaki\n int min_dist = 1e9;\n for (int i = 0; i < start_positions.size(); i++) {\n if (initial_grid[start_positions[i].x][start_positions[i].y] == '1') {\n int dist = manhattan_distance(current_state.root_pos, start_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n target_pos = start_positions[i];\n move_to_start = true;\n }\n }\n }\n }\n \n // If no start positions available or none have takoyaki, move to target positions\n if (!move_to_start || min_dist == 1e9) {\n for (int i = 0; i < target_positions.size(); i++) {\n if (initial_grid[target_positions[i].x][target_positions[i].y] == '0') {\n int dist = manhattan_distance(current_state.root_pos, target_positions[i]);\n if (dist < min_dist || min_dist == 1e9) {\n min_dist = dist;\n target_pos = target_positions[i];\n move_to_start = false;\n }\n }\n }\n }\n \n // Move toward target\n if (min_dist != 1e9) {\n int dx = target_pos.x - current_state.root_pos.x;\n int dy = target_pos.y - current_state.root_pos.y;\n \n if (dx != 0 || dy != 0) {\n // Determine best direction to move\n char best_dir = '.';\n int best_improvement = -1;\n \n for (int d = 0; d < 4; d++) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (!new_pos.in_bounds(N)) continue;\n \n int new_dist = abs(new_pos.x - target_pos.x) + abs(new_pos.y - target_pos.y);\n int improvement = min_dist - new_dist;\n \n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_dir = DIR_CHARS[d];\n command[0] = best_dir;\n }\n }\n \n // Update root position if we found a valid move\n if (best_dir != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == best_dir) {\n current_state.root_pos.x += DX[d];\n current_state.root_pos.y += DY[d];\n break;\n }\n }\n }\n }\n } else {\n // Random move if no clear target\n vector valid_moves = {'.', 'R', 'D', 'L', 'U'};\n int r = rng() % valid_moves.size();\n command[0] = valid_moves[r];\n \n if (command[0] != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == command[0]) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (new_pos.in_bounds(N)) {\n current_state.root_pos = new_pos;\n }\n break;\n }\n }\n }\n }\n \n // Random rotations to explore different configurations\n if (rng() % 3 == 0) { // 33% chance of rotation\n for (int i = 1; i < V_prime; i++) {\n if (rng() % 3 == 0) { // 33% chance per joint\n if (rng() % 2) {\n command[i] = 'R';\n current_state.directions[i] = (current_state.directions[i] + 1) % 4;\n } else {\n command[i] = 'L';\n current_state.directions[i] = (current_state.directions[i] + 3) % 4;\n }\n }\n }\n }\n \n return command;\n }\n \n void solve() {\n read_input();\n design_arm();\n \n // Output arm design\n cout << V_prime << endl;\n for (int i = 1; i < V_prime; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n \n // Find and output initial position\n Point initial_pos = find_initial_position();\n cout << initial_pos.x << \" \" << initial_pos.y << endl;\n \n // Initialize state\n current_state.root_pos = initial_pos;\n current_state.directions.resize(V_prime, 0); // All start pointing right\n current_state.holding.resize(V_prime, false);\n \n // Generate operations\n vector commands;\n int max_turns = min(50000, 100000); // Limit to avoid TLE\n \n for (int turn = 0; turn < max_turns; turn++) {\n string command = find_best_move();\n commands.push_back(command);\n \n // Check if all takoyaki are delivered\n int delivered = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n delivered++;\n }\n }\n }\n \n // Also count held takoyaki that can be placed\n for (int finger : fingertips) {\n if (current_state.holding[finger]) {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n Point pos = positions[finger];\n if (pos.in_bounds(N) && target_grid[pos.x][pos.y] == '1' && initial_grid[pos.x][pos.y] == '0') {\n delivered++; // Can be delivered in next turn\n }\n }\n }\n \n // If we've delivered all or have extra, break early\n if (delivered >= M) {\n break;\n }\n }\n \n // Output commands\n for (const string& cmd : commands) {\n cout << cmd << endl;\n }\n }\n};\n\nint main() {\n RoboticArmSolver solver;\n solver.solve();\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n int x1, y1, x2, y2; // x1 <= x2, y1 <= y2\n Rectangle(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : x1(x1), y1(y1), x2(x2), y2(y2) {}\n \n bool contains(const Point& p) const {\n return p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2;\n }\n \n int perimeter() const {\n return 2 * ((x2 - x1) + (y2 - y1));\n }\n \n int area() const {\n return (x2 - x1) * (y2 - y1);\n }\n};\n\n// Optimized point counting using precomputed 2D grid\nclass PointCounter {\nprivate:\n static const int GRID_SIZE = 200; // Divide 10^5 into 200x200 grid\n static const int CELL_SIZE = 500; // 100000 / 200 = 500\n vector> mackerelGrid;\n vector> sardineGrid;\n const vector& mackerels;\n const vector& sardines;\n \npublic:\n PointCounter(const vector& m, const vector& s) \n : mackerels(m), sardines(s) {\n mackerelGrid.assign(GRID_SIZE + 1, vector(GRID_SIZE + 1, 0));\n sardineGrid.assign(GRID_SIZE + 1, vector(GRID_SIZE + 1, 0));\n \n // Build the grid\n for (const auto& p : mackerels) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n mackerelGrid[gx][gy]++;\n }\n \n for (const auto& p : sardines) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n sardineGrid[gx][gy]++;\n }\n }\n \n // Fast approximate counting using grid\n pair fastCount(const Rectangle& rect) {\n int mackerelCount = 0, sardineCount = 0;\n \n int gx1 = max(0, rect.x1 / CELL_SIZE);\n int gy1 = max(0, rect.y1 / CELL_SIZE);\n int gx2 = min(GRID_SIZE - 1, rect.x2 / CELL_SIZE);\n int gy2 = min(GRID_SIZE - 1, rect.y2 / CELL_SIZE);\n \n // Quick grid-based counting for large rectangles\n for (int gx = gx1; gx <= gx2; gx++) {\n for (int gy = gy1; gy <= gy2; gy++) {\n mackerelCount += mackerelGrid[gx][gy];\n sardineCount += sardineGrid[gx][gy];\n }\n }\n \n // For small rectangles or when more precision is needed, use exact counting\n // But only if the rectangle is small enough\n if ((rect.x2 - rect.x1) * (rect.y2 - rect.y1) < 25000000) { // 5000x5000\n mackerelCount = 0;\n sardineCount = 0;\n for (const auto& p : mackerels) {\n if (rect.contains(p)) mackerelCount++;\n }\n for (const auto& p : sardines) {\n if (rect.contains(p)) sardineCount++;\n }\n }\n \n return {mackerelCount, sardineCount};\n }\n};\n\n// Calculate score for rectangle\nint calculateScore(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n PointCounter counter(mackerels, sardines);\n auto [m, s] = counter.fastCount(rect);\n return max(0, m - s + 1);\n}\n\n// Generate limited number of candidate rectangles\nvector generateCandidateRectangles(const vector& mackerels, const vector& sardines) {\n vector candidates;\n const int MAX_CANDIDATES = 200; // Limit to avoid TLE\n \n // Sample a subset of mackerels to avoid O(N^2) complexity\n vector sampleIndices;\n int sampleSize = min(500, (int)mackerels.size());\n \n // Use a simple sampling strategy\n for (int i = 0; i < sampleSize; i++) {\n sampleIndices.push_back(i * mackerels.size() / sampleSize);\n }\n \n // Generate rectangles around individual mackerels with different sizes\n for (int idx : sampleIndices) {\n int x = mackerels[idx].x;\n int y = mackerels[idx].y;\n \n // Try different sizes (fewer sizes to reduce candidates)\n vector sizes = {1000, 3000, 7000, 15000};\n for (int size : sizes) {\n int x1 = max(0, x - size/2);\n int y1 = max(0, y - size/2);\n int x2 = min(100000, x + size/2);\n int y2 = min(100000, y + size/2);\n \n Rectangle rect(x1, y1, x2, y2);\n PointCounter counter(mackerels, sardines);\n auto [m, s] = counter.fastCount(rect);\n if (m > s && m > 0) { // Only consider if beneficial\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n \n if (candidates.size() < MAX_CANDIDATES) {\n // Try rectangles that cover pairs of mackerels (limited number)\n for (int i = 0; i < min(50, (int)sampleIndices.size()); i++) {\n for (int j = i + 1; j < min(i + 10, (int)sampleIndices.size()); j++) {\n int x1 = min(mackerels[sampleIndices[i]].x, mackerels[sampleIndices[j]].x);\n int y1 = min(mackerels[sampleIndices[i]].y, mackerels[sampleIndices[j]].y);\n int x2 = max(mackerels[sampleIndices[i]].x, mackerels[sampleIndices[j]].x);\n int y2 = max(mackerels[sampleIndices[i]].y, mackerels[sampleIndices[j]].y);\n \n // Expand a bit\n int dx = max(1, (x2 - x1) / 4);\n int dy = max(1, (y2 - y1) / 4);\n x1 = max(0, x1 - dx);\n y1 = max(0, y1 - dy);\n x2 = min(100000, x2 + dx);\n y2 = min(100000, y2 + dy);\n \n if (x2 > x1 && y2 > y1) {\n Rectangle rect(x1, y1, x2, y2);\n PointCounter counter(mackerels, sardines);\n auto [m, s] = counter.fastCount(rect);\n if (m > s && m > 0) {\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n }\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n \n // Sort by score and keep top candidates\n sort(candidates.begin(), candidates.end(), [&](const Rectangle& a, const Rectangle& b) {\n int scoreA = calculateScore(mackerels, sardines, a);\n int scoreB = calculateScore(mackerels, sardines, b);\n return scoreA > scoreB;\n });\n \n if (candidates.size() > 50) {\n candidates.resize(50);\n }\n \n return candidates;\n}\n\n// Merge rectangles into a simple bounding polygon\nvector mergeRectanglesToPolygon(const vector& rectangles) {\n if (rectangles.empty()) {\n return {};\n }\n \n // Create a bounding rectangle of all selected rectangles\n int x1 = 100000, y1 = 100000, x2 = 0, y2 = 0;\n for (const auto& rect : rectangles) {\n x1 = min(x1, rect.x1);\n y1 = min(y1, rect.y1);\n x2 = max(x2, rect.x2);\n y2 = max(y2, rect.y2);\n }\n \n // Create simple rectangle polygon\n vector polygon;\n polygon.push_back(Point(x1, y1));\n polygon.push_back(Point(x2, y1));\n polygon.push_back(Point(x2, y2));\n polygon.push_back(Point(x1, y2));\n \n return polygon;\n}\n\n// Simplify polygon (remove collinear points if any)\nvector simplifyPolygon(const vector& polygon) {\n if (polygon.size() <= 2) return polygon;\n \n vector simplified;\n simplified.push_back(polygon[0]);\n \n for (int i = 1; i < polygon.size(); i++) {\n if (simplified.size() < 2) {\n simplified.push_back(polygon[i]);\n continue;\n }\n \n Point p1 = simplified[simplified.size()-2];\n Point p2 = simplified[simplified.size()-1];\n Point p3 = polygon[i];\n \n // Check if they are collinear (cross product = 0)\n long long cross = (long long)(p2.x - p1.x) * (p3.y - p2.y) - (long long)(p2.y - p1.y) * (p3.x - p2.x);\n \n if (cross != 0) {\n simplified.push_back(polygon[i]);\n } else {\n simplified.back() = polygon[i];\n }\n }\n \n return simplified;\n}\n\n// Calculate total edge length of polygon\nlong long calculateEdgeLength(const vector& polygon) {\n if (polygon.size() <= 1) return 0;\n \n long long length = 0;\n for (int i = 0; i < polygon.size(); i++) {\n int j = (i + 1) % polygon.size();\n length += abs(polygon[i].x - polygon[j].x) + abs(polygon[i].y - polygon[j].y);\n }\n return length;\n}\n\n// Greedy selection of best rectangle\nRectangle selectBestRectangle(const vector& mackerels, const vector& sardines, const vector& candidates) {\n if (candidates.empty()) {\n return Rectangle(25000, 25000, 75000, 75000);\n }\n \n Rectangle bestRect = candidates[0];\n int bestScore = calculateScore(mackerels, sardines, bestRect);\n \n for (const auto& rect : candidates) {\n int score = calculateScore(mackerels, sardines, rect);\n if (score > bestScore) {\n bestScore = score;\n bestRect = rect;\n }\n }\n \n return bestRect;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n \n vector mackerels(N);\n vector sardines(N);\n \n // Read mackerels\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n \n // Read sardines\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n \n // Generate limited number of candidate rectangles\n vector candidates = generateCandidateRectangles(mackerels, sardines);\n \n // Select the best single rectangle\n Rectangle bestRect = selectBestRectangle(mackerels, sardines, candidates);\n \n // Create polygon from the best rectangle\n vector polygon = {\n Point(bestRect.x1, bestRect.y1),\n Point(bestRect.x2, bestRect.y1),\n Point(bestRect.x2, bestRect.y2),\n Point(bestRect.x1, bestRect.y2)\n };\n \n // Output\n cout << polygon.size() << \"\\n\";\n for (const auto& p : polygon) {\n cout << p.x << \" \" << p.y << \"\\n\";\n }\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include // Added for LLONG_MAX\n\nusing namespace std;\n\nstruct Rectangle {\n int w, h;\n int idx;\n};\n\nstruct Placement {\n int p, r;\n char d;\n int b;\n};\n\nclass RectanglePacker {\nprivate:\n int N, T;\n double sigma;\n vector> observed_wh;\n mt19937 rng;\n vector best_placement;\n long long best_score;\n int best_turn;\n vector> feedback_history;\n \npublic:\n RectanglePacker(int seed = 1234) : rng(seed) {\n best_score = LLONG_MAX;\n best_turn = -1;\n }\n \n void readInput() {\n cin >> N >> T >> sigma;\n observed_wh.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> observed_wh[i].first >> observed_wh[i].second;\n }\n }\n \n // Generate a random placement\n vector generateRandomPlacement(int n) {\n vector placement;\n uniform_int_distribution rotation_dist(0, 1);\n uniform_int_distribution direction_dist(0, 1);\n \n for (int i = 0; i < n; i++) {\n int r = rotation_dist(rng);\n char d = direction_dist(rng) ? 'L' : 'U';\n int b_max = i - 1;\n int b = -1;\n if (b_max >= 0) {\n uniform_int_distribution ref_dist(-1, b_max);\n b = ref_dist(rng);\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Generate a greedy placement based on size\n vector generateGreedyPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n // Decide rotation: try to minimize the larger dimension\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n int r = (orig_w > orig_h) ? 1 : 0; // Rotate if width > height\n \n // Alternate between U and L for better packing\n char d = (i % 2 == 0) ? 'U' : 'L';\n \n // Reference to previous rectangle or -1\n int b = (i > 0) ? (i - 1) : -1;\n if (i > 2 && rng() % 3 == 0) {\n uniform_int_distribution ref_dist(0, i - 1);\n b = ref_dist(rng);\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Mutate an existing placement\n vector mutatePlacement(const vector& base, double temp) {\n vector result = base;\n int n = result.size();\n \n // Number of mutations based on temperature\n int num_mutations = max(1, (int)(temp * n / 10.0));\n \n uniform_int_distribution mutation_dist(0, 2); // 0=rotation, 1=direction, 2=reference\n uniform_int_distribution index_dist(0, n - 1);\n \n for (int i = 0; i < num_mutations; i++) {\n if (n == 0) break;\n int idx = index_dist(rng);\n \n int mutation_type = mutation_dist(rng);\n switch (mutation_type) {\n case 0: // Change rotation\n result[idx].r = 1 - result[idx].r;\n break;\n case 1: // Change direction\n result[idx].d = (result[idx].d == 'U') ? 'L' : 'U';\n break;\n case 2: // Change reference\n int max_ref = idx - 1;\n if (max_ref >= 0) {\n uniform_int_distribution ref_dist(-1, max_ref);\n result[idx].b = ref_dist(rng);\n } else {\n result[idx].b = -1;\n }\n break;\n }\n }\n \n return result;\n }\n \n // Simulated annealing step\n vector getNextPlacement(int turn) {\n double temperature = 1.0 - (double)turn / T;\n \n if (turn == 0) {\n // First turn: try greedy approach\n return generateGreedyPlacement(N);\n }\n \n if (best_turn == -1 || rng() % 100 < 10) { // 10% chance of random restart\n if (rng() % 2 == 0) {\n return generateRandomPlacement(N);\n } else {\n return generateGreedyPlacement(N);\n }\n }\n \n // Otherwise, mutate the best solution found so far\n vector mutated = mutatePlacement(best_placement, temperature);\n \n // Occasionally try a completely different approach\n if (rng() % 100 < 5) {\n // Fixed the % operator with double issue\n int partial_n = (int)(N * 0.8);\n int range = (int)(N * 0.2) + 1;\n if (range > 0) {\n uniform_int_distribution size_dist(partial_n, partial_n + range - 1);\n int n = min(N, size_dist(rng));\n if (n < N) {\n mutated = generateRandomPlacement(n);\n }\n }\n }\n \n return mutated;\n }\n \n void outputPlacement(const vector& placement) {\n cout << placement.size() << endl;\n for (const auto& p : placement) {\n cout << p.p << \" \" << p.r << \" \" << p.d << \" \" << p.b << endl;\n }\n cout.flush();\n }\n \n long long calculateEstimatedScore(int W_prime, int H_prime, int n) {\n // Estimate the score based on noisy measurements\n long long score = (long long)W_prime + (long long)H_prime;\n \n // Add penalty for unused rectangles\n for (int i = n; i < N; i++) {\n score += (long long)observed_wh[i].first + (long long)observed_wh[i].second;\n }\n \n return score;\n }\n \n void processTurn(int turn) {\n vector placement = getNextPlacement(turn);\n \n // Output the placement\n outputPlacement(placement);\n \n // Read feedback\n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n feedback_history.push_back({W_prime, H_prime});\n \n // Calculate estimated score\n long long estimated_score = calculateEstimatedScore(W_prime, H_prime, placement.size());\n \n // Update best solution if this is better\n if (estimated_score < best_score) {\n best_score = estimated_score;\n best_placement = placement;\n best_turn = turn;\n }\n }\n \n void solve() {\n readInput();\n \n for (int turn = 0; turn < T; turn++) {\n processTurn(turn);\n }\n }\n};\n\nint main() {\n // Use current time as seed for randomness\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RectanglePacker packer(static_cast(seed));\n packer.solve();\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n cin >> N >> M >> H;\n \n vector A(N);\n for (int i = 0; i < N; i++) {\n cin >> A[i];\n }\n \n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n if (u >= 0 && u < N && v >= 0 && v < N) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n }\n \n vector> coords(N);\n for (int i = 0; i < N; i++) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Simple solution: Greedy assignment\n vector parent(N, -1);\n vector height(N, 0);\n vector assigned(N, false);\n \n // Create list of vertices sorted by beauty (descending)\n vector vertices(N);\n for (int i = 0; i < N; i++) {\n vertices[i] = i;\n }\n sort(vertices.begin(), vertices.end(), [&](int a, int b) {\n return A[a] > A[b];\n });\n \n // Assign each vertex\n for (int i = 0; i < N; i++) {\n int v = vertices[i];\n if (assigned[v]) continue;\n \n // Start a new tree with this vertex as root\n parent[v] = -1;\n height[v] = 0;\n assigned[v] = true;\n \n // BFS to assign neighbors\n queue q;\n q.push(v);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n // Collect unassigned neighbors\n vector> neighbors; // (beauty, vertex)\n for (int neighbor : adj[u]) {\n if (neighbor >= 0 && neighbor < N && !assigned[neighbor] && height[u] + 1 <= H) {\n neighbors.push_back({A[neighbor], neighbor});\n }\n }\n \n // Sort by beauty (descending)\n sort(neighbors.begin(), neighbors.end(), greater>());\n \n // Assign neighbors\n for (auto& nb : neighbors) {\n int next_v = nb.second;\n if (!assigned[next_v] && height[u] + 1 <= H) {\n parent[next_v] = u;\n height[next_v] = height[u] + 1;\n assigned[next_v] = true;\n q.push(next_v);\n \n // Safety break to avoid excessive memory usage\n if (q.size() > N) break;\n }\n }\n \n // Safety break\n if (q.size() > 2 * N) break;\n }\n }\n \n // Handle any remaining unassigned vertices\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n // Find the best parent among neighbors\n int best_parent = -1;\n int min_height = H + 1;\n \n for (int neighbor : adj[i]) {\n if (neighbor >= 0 && neighbor < N && assigned[neighbor] && height[neighbor] < min_height) {\n min_height = height[neighbor];\n best_parent = neighbor;\n }\n }\n \n if (best_parent != -1 && min_height < H) {\n parent[i] = best_parent;\n height[i] = min_height + 1;\n } else {\n // Make it a root\n parent[i] = -1;\n height[i] = 0;\n }\n assigned[i] = true;\n }\n }\n \n // Final validation pass - ensure no invalid references\n for (int i = 0; i < N; i++) {\n if (parent[i] != -1) {\n // Ensure parent is valid\n if (parent[i] < 0 || parent[i] >= N) {\n parent[i] = -1;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; i++) {\n cout << parent[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n \n // Read input\n cin >> N;\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n vector> operations;\n \n // For each cell that contains an Oni ('x')\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'x') {\n // Check which direction is safe (no Fukunokami)\n bool safe_up = true, safe_down = true, safe_left = true, safe_right = true;\n \n // Check upward direction\n for (int k = 0; k < i; k++) {\n if (board[k][j] == 'o') {\n safe_up = false;\n break;\n }\n }\n \n // Check downward direction\n for (int k = i + 1; k < N; k++) {\n if (board[k][j] == 'o') {\n safe_down = false;\n break;\n }\n }\n \n // Check leftward direction\n for (int k = 0; k < j; k++) {\n if (board[i][k] == 'o') {\n safe_left = false;\n break;\n }\n }\n \n // Check rightward direction\n for (int k = j + 1; k < N; k++) {\n if (board[i][k] == 'o') {\n safe_right = false;\n break;\n }\n }\n \n // Choose a safe direction (at least one is guaranteed to exist)\n if (safe_up) {\n // Shift column j upward (i+1) times\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'U', j});\n }\n // Shift column j downward (i+1) times to restore\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'D', j});\n }\n } else if (safe_down) {\n // Shift column j downward (N-1-i) times\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'D', j});\n }\n // Shift column j upward (N-1-i) times to restore\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'U', j});\n }\n } else if (safe_left) {\n // Shift row i left (j+1) times\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'L', i});\n }\n // Shift row i right (j+1) times to restore\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'R', i});\n }\n } else if (safe_right) {\n // Shift row i right (N-1-j) times\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'R', i});\n }\n // Shift row i left (N-1-j) times to restore\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'L', i});\n }\n }\n }\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\n// Optimized error calculation\nlong long calculateError(const vector& a, const vector& b, const vector& targets) {\n vector counts(N, 0);\n int current = 0;\n \n // Simple simulation - optimized for speed\n for (int week = 0; week < L; week++) {\n counts[current]++;\n current = (counts[current] % 2 == 1) ? a[current] : b[current];\n }\n \n long long total_error = 0;\n for (int i = 0; i < N; i++) {\n total_error += abs(counts[i] - targets[i]);\n }\n return total_error;\n}\n\n// Find employees with highest error\nvector getHighErrorEmployees(const vector& actual, const vector& targets, int count) {\n vector> errors;\n for (int i = 0; i < N; i++) {\n errors.push_back({abs(actual[i] - targets[i]), i});\n }\n sort(errors.rbegin(), errors.rend()); // Sort in descending order\n \n vector result;\n for (int i = 0; i < min(count, N); i++) {\n result.push_back(errors[i].second);\n }\n return result;\n}\n\n// Calculate actual assignments (not just error)\nvector calculateAssignments(const vector& a, const vector& b) {\n vector counts(N, 0);\n int current = 0;\n \n for (int week = 0; week < L; week++) {\n counts[current]++;\n current = (counts[current] % 2 == 1) ? a[current] : b[current];\n }\n \n return counts;\n}\n\n// Construct better initial solution\nvector> createInitialSolution(const vector& targets) {\n vector> result(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n \n // Method 1: Sort by targets and connect adjacent employees\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return targets[i] < targets[j];\n });\n \n // Create a cycle based on sorted order\n for (int i = 0; i < N; i++) {\n int emp = indices[i];\n int next_idx = (i + 1) % N;\n int prev_idx = (i - 1 + N) % N;\n \n // Assign to adjacent employees in sorted order\n result[emp].first = indices[prev_idx];\n result[emp].second = indices[next_idx];\n }\n \n return result;\n}\n\n// Smart local search\nvector> improveSolution(const vector>& initial, const vector& targets) {\n vector a(N), b(N);\n for (int i = 0; i < N; i++) {\n a[i] = initial[i].first;\n b[i] = initial[i].second;\n }\n \n long long best_error = calculateError(a, b, targets);\n vector best_a = a, best_b = b;\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n uniform_real_distribution prob_dist(0.0, 1.0);\n \n // Get initial assignments\n vector current_assignments = calculateAssignments(a, b);\n \n // Smart local search with more iterations\n const int MAX_ITERATIONS = 800; // Increased from 50 to 800\n for (int iter = 0; iter < MAX_ITERATIONS; iter++) {\n // Get employees with highest error\n vector high_error_emps = getHighErrorEmployees(current_assignments, targets, 10);\n \n // Make a copy for modification\n vector new_a = a, new_b = b;\n \n // Choose an employee to modify - prefer high error employees\n int emp;\n if (prob_dist(rng) < 0.7 && !high_error_emps.empty()) {\n emp = high_error_emps[dist(rng) % high_error_emps.size()];\n } else {\n emp = dist(rng);\n }\n \n // Decide whether to change a or b (or both)\n int change_type = dist(rng) % 3;\n \n if (change_type == 0) { // Change a[emp]\n // Prefer employees who are under-assigned if current employee is over-assigned, and vice versa\n int target_diff = targets[emp] - current_assignments[emp];\n if (target_diff > 0) { // emp is under-assigned, point to someone who might reduce their assignment\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.begin(), target_diffs.end()); // Sort by who is most over-assigned\n if (!target_diffs.empty()) {\n new_a[emp] = target_diffs[0].second; // Point to most over-assigned\n } else {\n new_a[emp] = dist(rng);\n }\n } else { // emp is over-assigned, point to someone who might increase their assignment\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.rbegin(), target_diffs.rend()); // Sort by who is most under-assigned\n if (!target_diffs.empty()) {\n new_a[emp] = target_diffs[0].second; // Point to most under-assigned\n } else {\n new_a[emp] = dist(rng);\n }\n }\n } else if (change_type == 1) { // Change b[emp]\n // Similar logic\n int target_diff = targets[emp] - current_assignments[emp];\n if (target_diff > 0) {\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.begin(), target_diffs.end());\n if (!target_diffs.empty()) {\n new_b[emp] = target_diffs[0].second;\n } else {\n new_b[emp] = dist(rng);\n }\n } else {\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.rbegin(), target_diffs.rend());\n if (!target_diffs.empty()) {\n new_b[emp] = target_diffs[0].second;\n } else {\n new_b[emp] = dist(rng);\n }\n }\n } else { // Change both a[emp] and b[emp]\n int target_diff = targets[emp] - current_assignments[emp];\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n \n if (target_diff > 0) {\n sort(target_diffs.begin(), target_diffs.end());\n if (target_diffs.size() >= 2) {\n new_a[emp] = target_diffs[0].second;\n new_b[emp] = target_diffs[1].second;\n } else {\n new_a[emp] = dist(rng);\n new_b[emp] = dist(rng);\n }\n } else {\n sort(target_diffs.rbegin(), target_diffs.rend());\n if (target_diffs.size() >= 2) {\n new_a[emp] = target_diffs[0].second;\n new_b[emp] = target_diffs[1].second;\n } else {\n new_a[emp] = dist(rng);\n new_b[emp] = dist(rng);\n }\n }\n }\n \n // Calculate new error\n long long new_error = calculateError(new_a, new_b, targets);\n \n // Accept improvement\n if (new_error < best_error) {\n best_error = new_error;\n best_a = new_a;\n best_b = new_b;\n a = new_a;\n b = new_b;\n current_assignments = calculateAssignments(a, b);\n }\n }\n \n // Convert back to result format\n vector> result(N);\n for (int i = 0; i < N; i++) {\n result[i] = {best_a[i], best_b[i]};\n }\n \n return result;\n}\n\nint main() {\n int n, l;\n cin >> n >> l;\n \n vector targets(n);\n for (int i = 0; i < n; i++) {\n cin >> targets[i];\n }\n \n // Create initial solution\n vector> initial_solution = createInitialSolution(targets);\n \n // Improve with smart local search\n vector> solution = improveSolution(initial_solution, targets);\n \n // Output the solution\n for (int i = 0; i < n; i++) {\n cout << solution[i].first << \" \" << solution[i].second << endl;\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#include \n\nusing namespace std;\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy; // center coordinates\n \n City() : id(-1), lx(0), rx(0), ly(0), ry(0), cx(0), cy(0) {}\n \n City(int id, int lx, int rx, int ly, int ry) : id(id), lx(lx), rx(rx), ly(ly), ry(ry) {\n cx = (lx + rx) / 2.0;\n cy = (ly + ry) / 2.0;\n }\n};\n\nstruct Edge {\n int u, v;\n double estimated_dist;\n int true_dist = -1; // -1 means unknown\n \n Edge() : u(-1), v(-1), estimated_dist(0) {}\n \n Edge(int u, int v, double dist) : u(u), v(v), estimated_dist(dist) {}\n \n bool operator<(const Edge& other) const {\n if (abs(estimated_dist - other.estimated_dist) > 1e-9) {\n return estimated_dist < other.estimated_dist;\n }\n if (u != other.u) return u < other.u;\n return v < other.v;\n }\n};\n\n// Calculate estimated distance between city centers\ndouble estimate_distance(const City& a, const City& b) {\n double dx = a.cx - b.cx;\n double dy = a.cy - b.cy;\n return sqrt(dx*dx + dy*dy);\n}\n\n// Calculate minimum possible distance between two bounding boxes\ndouble min_possible_distance(const City& a, const City& b) {\n double dx1 = static_cast(a.lx - b.rx);\n double dx2 = static_cast(b.lx - a.rx);\n double min_dx = max(0.0, max(dx1, dx2));\n \n double dy1 = static_cast(a.ly - b.ry);\n double dy2 = static_cast(b.ly - a.ry);\n double min_dy = max(0.0, max(dy1, dy2));\n \n return sqrt(min_dx*min_dx + min_dy*min_dy);\n}\n\n// Calculate maximum possible distance between two bounding boxes\ndouble max_possible_distance(const City& a, const City& b) {\n double dx1 = abs(static_cast(a.lx - b.rx));\n double dx2 = abs(static_cast(a.rx - b.lx));\n double max_dx = max(dx1, dx2);\n \n double dy1 = abs(static_cast(a.ly - b.ry));\n double dy2 = abs(static_cast(a.ry - b.ly));\n double max_dy = max(dy1, dy2);\n \n return sqrt(max_dx*max_dx + max_dy*max_dy);\n}\n\n// Calculate a conservative estimate of distance (upper bound for MST pruning)\ndouble conservative_estimate(const City& a, const City& b) {\n return max_possible_distance(a, b);\n}\n\n// Calculate an optimistic estimate of distance (lower bound)\ndouble optimistic_estimate(const City& a, const City& b) {\n return min_possible_distance(a, b);\n}\n\n// Query result structure\nstruct QueryResult {\n vector> edges;\n vector cities;\n};\n\nclass Solution {\nprivate:\n int N, M, Q, L, W;\n vector G;\n vector cities;\n mt19937 rng;\n \n // Store results of queries\n map, int> known_distances; // true distances between pairs\n vector query_results;\n \n // For building final solution\n vector> final_groups;\n vector>> final_edges;\n \n // Track which city pairs we've queried\n set> queried_pairs;\n \npublic:\n Solution() : rng(random_device{}()) {}\n \n void read_input() {\n cin >> N >> M >> Q >> L >> W;\n G.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n cities.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].id = i;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2.0;\n }\n }\n \n QueryResult make_query(const vector& city_ids) {\n int k = city_ids.size();\n if (k < 2 || k > L) {\n cerr << \"Invalid query size: \" << k << endl;\n return {};\n }\n \n cout << \"? \" << k;\n for (int id : city_ids) {\n cout << \" \" << id;\n }\n cout << endl;\n cout.flush();\n \n QueryResult result;\n result.cities = city_ids;\n \n for (int i = 0; i < k - 1; i++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n result.edges.push_back({u, v});\n \n // Store this known edge\n queried_pairs.insert({u, v});\n queried_pairs.insert({v, u});\n }\n \n query_results.push_back(result);\n return result;\n }\n \n // Calculate overlap between two bounding boxes (higher = more likely to be close)\n double calculate_overlap_score(const City& a, const City& b) {\n // Calculate intersection area\n int inter_lx = max(a.lx, b.lx);\n int inter_rx = min(a.rx, b.rx);\n int inter_ly = max(a.ly, b.ly);\n int inter_ry = min(a.ry, b.ry);\n \n double inter_area = 0.0;\n if (inter_lx < inter_rx && inter_ly < inter_ry) {\n inter_area = (inter_rx - inter_lx) * (inter_ry - inter_ly);\n }\n \n // Calculate union area\n double area_a = (a.rx - a.lx) * (a.ry - a.ly);\n double area_b = (b.rx - b.lx) * (b.ry - b.ly);\n double union_area = area_a + area_b - inter_area;\n \n if (union_area == 0) return 0.0;\n return inter_area / union_area;\n }\n \n // Better initial grouping using k-means like clustering\n void improved_initial_grouping() {\n // Create initial groups based on estimated distances\n final_groups.resize(M);\n \n // Sort group sizes in descending order for better assignment\n vector> sorted_groups; // (size, original_index)\n for (int i = 0; i < M; i++) {\n sorted_groups.push_back({G[i], i});\n }\n sort(sorted_groups.rbegin(), sorted_groups.rend()); // descending order\n \n // Track assigned cities\n vector assigned(N, false);\n \n // For each group (largest first)\n for (auto& group_info : sorted_groups) {\n int group_size = group_info.first;\n int original_idx = group_info.second;\n \n // Find the best starting city (least connected to others)\n int start_city = -1;\n double min_avg_dist = 1e18;\n \n for (int i = 0; i < N; i++) {\n if (assigned[i]) continue;\n \n double avg_dist = 0.0;\n int count = 0;\n for (int j = 0; j < N; j++) {\n if (i != j && !assigned[j]) {\n avg_dist += estimate_distance(cities[i], cities[j]);\n count++;\n }\n }\n \n if (count > 0) avg_dist /= count;\n \n if (start_city == -1 || avg_dist < min_avg_dist) {\n min_avg_dist = avg_dist;\n start_city = i;\n }\n }\n \n if (start_city == -1) {\n // Assign remaining cities\n for (int i = 0; i < N && final_groups[original_idx].size() < group_size; i++) {\n if (!assigned[i]) {\n final_groups[original_idx].push_back(i);\n assigned[i] = true;\n }\n }\n continue;\n }\n \n // Start with the selected city\n final_groups[original_idx].push_back(start_city);\n assigned[start_city] = true;\n \n // Greedily add closest cities\n while (final_groups[original_idx].size() < group_size) {\n int best_city = -1;\n double min_dist = 1e18;\n \n for (int i = 0; i < N; i++) {\n if (assigned[i]) continue;\n \n // Calculate average distance to cities in current group\n double avg_dist = 0.0;\n for (int city_in_group : final_groups[original_idx]) {\n avg_dist += estimate_distance(cities[i], cities[city_in_group]);\n }\n avg_dist /= final_groups[original_idx].size();\n \n if (best_city == -1 || avg_dist < min_dist) {\n min_dist = avg_dist;\n best_city = i;\n }\n }\n \n if (best_city != -1) {\n final_groups[original_idx].push_back(best_city);\n assigned[best_city] = true;\n } else {\n // Fallback: add any remaining city\n for (int i = 0; i < N && final_groups[original_idx].size() < group_size; i++) {\n if (!assigned[i]) {\n final_groups[original_idx].push_back(i);\n assigned[i] = true;\n }\n }\n }\n }\n }\n \n // Restore original group order\n vector> temp_groups = final_groups;\n for (int i = 0; i < M; i++) {\n final_groups[i] = temp_groups[i];\n }\n }\n \n // Select best subset for query based on uncertainty\n vector select_query_subset() {\n // Find cities with high position uncertainty\n vector> uncertainty_scores;\n for (int i = 0; i < N; i++) {\n double uncertainty = (cities[i].rx - cities[i].lx) + (cities[i].ry - cities[i].ly);\n uncertainty_scores.push_back({-uncertainty, i}); // negative for sorting\n }\n sort(uncertainty_scores.begin(), uncertainty_scores.end());\n \n // Create candidate sets\n vector> candidate_sets;\n \n // Candidate 1: Highest uncertainty cities\n vector high_uncertainty_set;\n for (int i = 0; i < min(L, (int)uncertainty_scores.size()); i++) {\n high_uncertainty_set.push_back(uncertainty_scores[i].second);\n }\n candidate_sets.push_back(high_uncertainty_set);\n \n // Candidate 2: Cities with overlapping bounding boxes\n for (int i = 0; i < N && candidate_sets.size() < 3; i++) {\n vector overlap_set;\n overlap_set.push_back(i);\n \n for (int j = 0; j < N && overlap_set.size() < L; j++) {\n if (i != j) {\n double overlap = calculate_overlap_score(cities[i], cities[j]);\n if (overlap > 0.1) { // if significant overlap\n overlap_set.push_back(j);\n }\n }\n }\n \n if (overlap_set.size() >= 2) {\n candidate_sets.push_back(overlap_set);\n }\n }\n \n // Candidate 3: Random sampling\n vector random_set;\n vector all_cities(N);\n for (int i = 0; i < N; i++) all_cities[i] = i;\n shuffle(all_cities.begin(), all_cities.end(), rng);\n for (int i = 0; i < min(L, N); i++) {\n random_set.push_back(all_cities[i]);\n }\n candidate_sets.push_back(random_set);\n \n // Select the best candidate (prioritize ones with overlapping boxes)\n for (auto& candidate : candidate_sets) {\n if (candidate.size() >= 2 && candidate.size() <= L) {\n return candidate;\n }\n }\n \n // Fallback\n vector fallback;\n for (int i = 0; i < min(L, N); i++) {\n fallback.push_back(i);\n }\n return fallback;\n }\n \n // Strategic querying to improve grouping\n void strategic_querying() {\n int queries_used = 0;\n \n // First, query some promising subsets for information\n while (queries_used < min(Q / 2, 50)) { // Use half of queries for exploration\n vector subset = select_query_subset();\n \n // Ensure we don't query the exact same set twice\n sort(subset.begin(), subset.end());\n static set> queried_subsets;\n if (queried_subsets.find(subset) != queried_subsets.end()) {\n // Add some variation\n if (subset.size() > 2) {\n subset.pop_back();\n subset.push_back((subset.back() + 1) % N);\n }\n }\n queried_subsets.insert(subset);\n \n QueryResult result = make_query(subset);\n queries_used++;\n }\n \n // Use remaining queries to validate and improve groups\n int group_idx = 0;\n while (queries_used < Q && group_idx < M) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size <= L) {\n // Query the entire group for verification\n QueryResult result = make_query(group);\n queries_used++;\n } else {\n // Query the most uncertain part of the group\n vector> city_uncertainties;\n for (int i = 0; i < group_size; i++) {\n int city_id = group[i];\n double uncertainty = (cities[city_id].rx - cities[city_id].lx) + \n (cities[city_id].ry - cities[city_id].ly);\n city_uncertainties.push_back({-uncertainty, i}); // negative for sorting\n }\n sort(city_uncertainties.begin(), city_uncertainties.end());\n \n // Take up to L cities with highest uncertainty\n vector uncertain_subset;\n for (int i = 0; i < min(L, (int)city_uncertainties.size()); i++) {\n uncertain_subset.push_back(group[city_uncertainties[i].second]);\n }\n \n if (uncertain_subset.size() >= 2) {\n QueryResult result = make_query(uncertain_subset);\n queries_used++;\n }\n }\n \n group_idx++;\n }\n }\n \n // Build MST for each group using known edges and better distance estimates\n void build_better_msts() {\n final_edges.clear();\n final_edges.resize(M);\n \n for (int group_idx = 0; group_idx < M; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size == 1) {\n continue;\n }\n \n // Create a graph with all possible edges in the group\n vector edges;\n for (int i = 0; i < group_size; i++) {\n for (int j = i + 1; j < group_size; j++) {\n int u = group[i];\n int v = group[j];\n if (u > v) swap(u, v);\n \n // Use known distance if available\n double estimated_dist;\n if (known_distances.find({u, v}) != known_distances.end()) {\n // We know this edge exists in some MST, so prioritize it\n estimated_dist = 0;\n } else {\n // Use a weighted estimate based on bounding box information\n double center_dist = estimate_distance(cities[u], cities[v]);\n double min_dist = min_possible_distance(cities[u], cities[v]);\n double max_dist = max_possible_distance(cities[u], cities[v]);\n \n // Weighted estimate: favor lower bounds for MST\n estimated_dist = min_dist * 0.7 + center_dist * 0.3;\n }\n \n edges.push_back(Edge(u, v, estimated_dist));\n }\n }\n \n // Sort edges by estimated distance\n sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {\n if (abs(a.estimated_dist - b.estimated_dist) > 1e-9) {\n return a.estimated_dist < b.estimated_dist;\n }\n if (a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n \n // Use Kruskal's algorithm to build MST\n vector parent(group_size);\n for (int i = 0; i < group_size; i++) {\n parent[i] = i;\n }\n \n function find_root = [&](int x) {\n if (parent[x] != x) {\n parent[x] = find_root(parent[x]);\n }\n return parent[x];\n };\n \n auto unite = [&](int x, int y) {\n int rx = find_root(x);\n int ry = find_root(y);\n if (rx != ry) {\n parent[rx] = ry;\n return true;\n }\n return false;\n };\n \n // Build MST\n for (const Edge& e : edges) {\n int u_idx = -1, v_idx = -1;\n for (int i = 0; i < group_size; i++) {\n if (group[i] == e.u) u_idx = i;\n if (group[i] == e.v) v_idx = i;\n }\n \n if (u_idx != -1 && v_idx != -1 && unite(u_idx, v_idx)) {\n final_edges[group_idx].push_back({e.u, e.v});\n if (final_edges[group_idx].size() == (size_t)(group_size - 1)) {\n break;\n }\n }\n }\n }\n }\n \n void output_answer() {\n cout << \"!\" << endl;\n \n for (int i = 0; i < M; i++) {\n // Output group members\n for (int j = 0; j < (int)final_groups[i].size(); j++) {\n if (j > 0) cout << \" \";\n cout << final_groups[i][j];\n }\n cout << endl;\n \n // Output edges for this group\n for (auto& edge : final_edges[i]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n cout.flush();\n }\n \n void solve() {\n read_input();\n \n // Use improved initial grouping\n improved_initial_grouping();\n \n // Use strategic querying to gather information and validate groups\n strategic_querying();\n \n // Build final MSTs with better distance estimates\n build_better_msts();\n \n // Output answer\n output_answer();\n }\n};\n\nint main() {\n Solution solution;\n solution.solve();\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Pos {\n int i, j;\n Pos(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator==(const Pos& other) const {\n return i == other.i && j == other.j;\n }\n};\n\n// Manhattan distance helper (moved before it's used)\nint manhattan(const Pos& a, const Pos& b) {\n return abs(a.i - b.i) + abs(a.j - b.j);\n}\n\n// Direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Check if position is valid\nbool isValid(const Pos& p, int N) {\n return p.i >= 0 && p.i < N && p.j >= 0 && p.j < N;\n}\n\n// Check if can move to position (removed unused 'from' parameter)\nbool canMoveTo(const Pos& to, const vector>& blocks, int N) {\n if (!isValid(to, N)) return false;\n if (blocks[to.i][to.j]) return false;\n return true;\n}\n\n// Sliding in a direction until hitting a block\nPos slide(const Pos& start, int dir, const vector>& blocks, int N) {\n Pos current = start;\n Pos next = {current.i + di[dir], current.j + dj[dir]};\n \n while (isValid(next, N) && !blocks[next.i][next.j]) {\n current = next;\n next = {current.i + di[dir], current.j + dj[dir]};\n }\n \n return current;\n}\n\n// Simple direct path using Manhattan distance\nvector> simplePath(const Pos& start, const Pos& target, vector>& blocks, int N) {\n vector> actions;\n Pos current = start;\n \n // If we're already at target, return empty path\n if (current == target) {\n return actions;\n }\n \n // Handle case where target has a block\n if (blocks[target.i][target.j]) {\n // Find adjacent position to target\n Pos adjacent;\n bool found = false;\n \n // Try up, down, left, right in order\n for (int d = 0; d < 4; d++) {\n Pos adj = {target.i + di[d], target.j + dj[d]};\n if (isValid(adj, N) && !blocks[adj.i][adj.j]) {\n adjacent = adj;\n found = true;\n break;\n }\n }\n \n if (found) {\n // Path to adjacent position\n auto pathToAdjacent = simplePath(current, adjacent, blocks, N);\n actions.insert(actions.end(), pathToAdjacent.begin(), pathToAdjacent.end());\n current = adjacent;\n \n // Remove block at target\n int dirToTarget = -1;\n if (current.i == target.i - 1) dirToTarget = 1; // Down\n else if (current.i == target.i + 1) dirToTarget = 0; // Up\n else if (current.j == target.j - 1) dirToTarget = 3; // Right\n else if (current.j == target.j + 1) dirToTarget = 2; // Left\n \n if (dirToTarget != -1) {\n actions.push_back({'A', dirChar[dirToTarget]});\n blocks[target.i][target.j] = false;\n \n // Move to target\n actions.push_back({'M', dirChar[dirToTarget]});\n return actions;\n }\n }\n // If couldn't find adjacent, fall through to normal pathfinding\n }\n \n // Try to use slide if it's a straight line with no obstacles\n for (int d = 0; d < 4; d++) {\n // Check if target is in this direction\n bool isInLine = false;\n if (d == 0 && current.i > target.i && current.j == target.j) isInLine = true; // Up\n else if (d == 1 && current.i < target.i && current.j == target.j) isInLine = true; // Down\n else if (d == 2 && current.j > target.j && current.i == target.i) isInLine = true; // Left\n else if (d == 3 && current.j < target.j && current.i == target.i) isInLine = true; // Right\n \n if (isInLine) {\n // Check if path is clear (no blocks)\n bool pathClear = true;\n Pos check = current;\n while (check != target) {\n check = {check.i + di[d], check.j + dj[d]};\n if (check != target && blocks[check.i][check.j]) {\n pathClear = false;\n break;\n }\n }\n \n if (pathClear) {\n // Check if sliding would stop exactly at target\n Pos slideEnd = slide(current, d, blocks, N);\n if (slideEnd == target) {\n actions.push_back({'S', dirChar[d]});\n return actions;\n }\n }\n }\n }\n \n // Simple greedy Manhattan moves\n while (current != target) {\n // Try to move in direction that reduces distance to target\n int bestDir = -1;\n int minDist = manhattan(current, target) + 1;\n \n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(next, blocks, N)) {\n int dist = abs(next.i - target.i) + abs(next.j - target.j);\n if (dist < minDist) {\n minDist = dist;\n bestDir = d;\n }\n }\n }\n \n // If no improving move, take any valid move\n if (bestDir == -1) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(next, blocks, N)) {\n bestDir = d;\n break;\n }\n }\n }\n \n // If still no valid move, we need to remove a blocking block\n if (bestDir == -1) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (isValid(next, N) && blocks[next.i][next.j]) {\n actions.push_back({'A', dirChar[d]});\n blocks[next.i][next.j] = false;\n bestDir = -2; // Flag to retry\n break;\n }\n }\n \n if (bestDir == -2) continue; // Retry after removing block\n else break; // Truly stuck\n }\n \n // Execute move\n actions.push_back({'M', dirChar[bestDir]});\n current = {current.i + di[bestDir], current.j + dj[bestDir]};\n \n // Safety break to avoid infinite loops\n if (actions.size() > 1000) break;\n }\n \n return actions;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N = 20, M = 40;\n cin >> N >> M;\n \n vector targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].i >> targets[i].j;\n }\n \n // Initialize board with no blocks\n vector> blocks(N, vector(N, false));\n Pos currentPos = targets[0];\n vector> allActions;\n \n // Visit each target in order (starting from index 1 since index 0 is start)\n for (int targetIdx = 1; targetIdx < M; targetIdx++) {\n const Pos& target = targets[targetIdx];\n \n // Simple approach: get path and execute it\n vector> path = simplePath(currentPos, target, blocks, N);\n \n // Execute path and update current position\n for (auto& action : path) {\n allActions.push_back(action);\n \n // Update current position based on action\n if (action.first == 'M') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (canMoveTo(next, blocks, N)) {\n currentPos = next;\n }\n } else if (action.first == 'S') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n currentPos = slide(currentPos, dir, blocks, N);\n } else if (action.first == 'A') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos alterPos = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (isValid(alterPos, N)) {\n blocks[alterPos.i][alterPos.j] = !blocks[alterPos.i][alterPos.j];\n }\n }\n }\n \n // Safety check: if we didn't reach target, try one direct move\n if (currentPos != target) {\n for (int d = 0; d < 4; d++) {\n Pos next = {currentPos.i + di[d], currentPos.j + dj[d]};\n if (next == target && canMoveTo(next, blocks, N)) {\n allActions.push_back({'M', dirChar[d]});\n currentPos = next;\n break;\n }\n }\n }\n }\n \n // Output all actions\n for (auto& action : allActions) {\n cout << action.first << \" \" << action.second << \"\\n\";\n }\n \n return 0;\n}"},"8":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int a, b, c, d; // left, top, right, bottom\n int idx;\n \n Rectangle() : a(0), b(0), c(0), d(0), idx(-1) {}\n Rectangle(int a, int b, int c, int d, int idx) : a(a), b(b), c(c), d(d), idx(idx) {}\n \n int area() const { return (c - a) * (d - b); }\n \n bool contains(double x, double y) const {\n return x >= a && x < c && y >= b && y < d;\n }\n \n // Very explicit overlap detection\n bool overlaps(const Rectangle& other) const {\n // No overlap if one rectangle is completely to the left, right, above, or below the other\n if (c <= other.a) return false; // this is completely to the left of other\n if (a >= other.c) return false; // this is completely to the right of other\n if (d <= other.b) return false; // this is completely above other\n if (b >= other.d) return false; // this is completely below other\n \n // If none of the above conditions are true, they must overlap\n return true;\n }\n};\n\nstruct Company {\n int x, y, r, idx;\n double target_x, target_y;\n \n Company() : x(0), y(0), r(0), idx(-1), target_x(0.0), target_y(0.0) {}\n Company(int x, int y, int r, int idx) : x(x), y(y), r(r), idx(idx) {\n target_x = x + 0.5;\n target_y = y + 0.5;\n }\n};\n\n// Calculate satisfaction for a company\ndouble calculateSatisfaction(int desired_area, int actual_area) {\n if (actual_area == 0) return 0.0;\n double ratio = min(desired_area, actual_area) * 1.0 / max(desired_area, actual_area);\n return 1.0 - (1.0 - ratio) * (1.0 - ratio);\n}\n\n// Calculate total satisfaction\ndouble calculateTotalSatisfaction(const vector& rects, const vector& companies) {\n size_t n = companies.size();\n double total = 0.0;\n for (size_t i = 0; i < n; i++) {\n const Company& c = companies[i];\n const Rectangle& r = rects[i];\n if (r.contains(c.target_x, c.target_y)) {\n total += calculateSatisfaction(c.r, r.area());\n }\n }\n return total;\n}\n\n// Create initial rectangles centered at target points\nvector createInitialRectangles(const vector& companies) {\n size_t n = companies.size();\n vector rects(n);\n \n for (size_t i = 0; i < n; i++) {\n const Company& c = companies[i];\n \n // Calculate approximate dimensions\n int width = (int)sqrt(c.r);\n if (width == 0) width = 1;\n int height = c.r / width;\n if (height == 0) height = 1;\n if (width * height < c.r) height++;\n \n // Center around the target point\n int left = (int)(c.target_x - width / 2.0);\n int top = (int)(c.target_y - height / 2.0);\n int right = left + width;\n int bottom = top + height;\n \n // Adjust if out of bounds\n if (left < 0) {\n left = 0;\n right = min(width, 10000);\n }\n if (right > 10000) {\n right = 10000;\n left = max(0, right - width);\n }\n if (top < 0) {\n top = 0;\n bottom = min(height, 10000);\n }\n if (bottom > 10000) {\n bottom = 10000;\n top = max(0, bottom - height);\n }\n \n // Ensure the target point is contained\n if (c.target_x < left + 0.5) left = max(0, (int)(c.target_x - 0.5));\n if (c.target_x >= right - 0.5) right = min(10000, (int)(c.target_x + 1.5));\n if (c.target_y < top + 0.5) top = max(0, (int)(c.target_y - 0.5));\n if (c.target_y >= bottom - 0.5) bottom = min(10000, (int)(c.target_y + 1.5));\n \n // Final bounds check\n left = max(0, left);\n top = max(0, top);\n right = min(10000, right);\n bottom = min(10000, bottom);\n \n rects[i] = Rectangle(left, top, right, bottom, i);\n }\n \n return rects;\n}\n\n// Resolve a specific overlap between two rectangles\nbool resolveSpecificOverlap(Rectangle& r1, Rectangle& r2, const Company& c1, const Company& c2) {\n // Try to shrink the rectangle with the smaller area first\n if (r1.area() <= r2.area()) {\n // Try to shrink r1\n vector> adjustments;\n \n // Try width adjustments first\n if (r1.c - r1.a > 1) {\n if (c1.target_x < r1.c - 1 - 0.5) {\n adjustments.push_back({0, 1}); // shrink right\n }\n if (c1.target_x >= r1.a + 1 + 0.5) {\n adjustments.push_back({0, -1}); // shrink left\n }\n }\n \n // Try height adjustments\n if (r1.d - r1.b > 1) {\n if (c1.target_y < r1.d - 1 - 0.5) {\n adjustments.push_back({1, 1}); // shrink bottom\n }\n if (c1.target_y >= r1.b + 1 + 0.5) {\n adjustments.push_back({1, -1}); // shrink top\n }\n }\n \n // Try each adjustment\n for (auto& adj : adjustments) {\n Rectangle test = r1;\n if (adj.first == 0) { // width\n if (adj.second == 1) { // shrink right\n test.c -= 1;\n } else { // shrink left\n test.a += 1;\n }\n } else { // height\n if (adj.second == 1) { // shrink bottom\n test.d -= 1;\n } else { // shrink top\n test.b += 1;\n }\n }\n \n // Ensure target point is still contained\n if (!test.contains(c1.target_x, c1.target_y)) {\n continue;\n }\n \n // Check if this resolves the overlap\n if (!test.overlaps(r2)) {\n r1 = test;\n return true;\n }\n }\n \n // If no adjustment worked, force shrink r1 to minimum size around target point\n int new_a = (int)c1.target_x;\n int new_c = new_a + 1;\n int new_b = (int)c1.target_y;\n int new_d = new_b + 1;\n \n r1 = Rectangle(new_a, new_b, new_c, new_d, r1.idx);\n return !r1.overlaps(r2);\n } else {\n // Try to shrink r2\n vector> adjustments;\n \n if (r2.c - r2.a > 1) {\n if (c2.target_x < r2.c - 1 - 0.5) {\n adjustments.push_back({0, 1}); // shrink right\n }\n if (c2.target_x >= r2.a + 1 + 0.5) {\n adjustments.push_back({0, -1}); // shrink left\n }\n }\n \n if (r2.d - r2.b > 1) {\n if (c2.target_y < r2.d - 1 - 0.5) {\n adjustments.push_back({1, 1}); // shrink bottom\n }\n if (c2.target_y >= r2.b + 1 + 0.5) {\n adjustments.push_back({1, -1}); // shrink top\n }\n }\n \n for (auto& adj : adjustments) {\n Rectangle test = r2;\n if (adj.first == 0) {\n if (adj.second == 1) {\n test.c -= 1;\n } else {\n test.a += 1;\n }\n } else {\n if (adj.second == 1) {\n test.d -= 1;\n } else {\n test.b += 1;\n }\n }\n \n if (!test.contains(c2.target_x, c2.target_y)) {\n continue;\n }\n \n if (!r1.overlaps(test)) {\n r2 = test;\n return true;\n }\n }\n \n // Force shrink r2 to minimum size around target point\n int new_a = (int)c2.target_x;\n int new_c = new_a + 1;\n int new_b = (int)c2.target_y;\n int new_d = new_b + 1;\n \n r2 = Rectangle(new_a, new_b, new_c, new_d, r2.idx);\n return !r1.overlaps(r2);\n }\n}\n\n// Exhaustive overlap resolution - continue until no overlaps exist\nvoid exhaustiveOverlapResolution(vector& rects, const vector& companies) {\n size_t n = rects.size();\n const int MAX_ITERATIONS = 50000; // High limit to ensure completion\n int iterations = 0;\n bool overlaps_exist = true;\n \n while (overlaps_exist && iterations < MAX_ITERATIONS) {\n overlaps_exist = false;\n \n // Check every pair systematically\n for (size_t i = 0; i < n; i++) {\n for (size_t j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n overlaps_exist = true;\n \n // Resolve this specific overlap\n bool resolved = resolveSpecificOverlap(rects[i], rects[j], companies[i], companies[j]);\n \n if (!resolved) {\n // If normal resolution failed, force one rectangle to minimum size\n if (rects[i].area() <= rects[j].area()) {\n int new_a = (int)companies[i].target_x;\n int new_c = new_a + 1;\n int new_b = (int)companies[i].target_y;\n int new_d = new_b + 1;\n rects[i] = Rectangle(new_a, new_b, new_c, new_d, i);\n } else {\n int new_a = (int)companies[j].target_x;\n int new_c = new_a + 1;\n int new_b = (int)companies[j].target_y;\n int new_d = new_b + 1;\n rects[j] = Rectangle(new_a, new_b, new_c, new_d, j);\n }\n }\n \n // Break and restart checking from the beginning\n // This is important because our adjustment might have created new overlaps\n goto restart_checking;\n }\n }\n }\n \n restart_checking:\n iterations++;\n \n // Safety break if taking too long\n if (iterations > 10000) {\n // Force all rectangles to minimum size as last resort\n for (size_t k = 0; k < n; k++) {\n int new_a = (int)companies[k].target_x;\n int new_c = new_a + 1;\n int new_b = (int)companies[k].target_y;\n int new_d = new_b + 1;\n rects[k] = Rectangle(new_a, new_b, new_c, new_d, k);\n }\n break;\n }\n }\n}\n\n// Light optimization that ensures no overlaps are created\nvoid optimizeRectangles(vector& rects, const vector& companies) {\n size_t n = rects.size();\n const int MAX_LOCAL_OPT_ITER = 100;\n double best_score = calculateTotalSatisfaction(rects, companies);\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n for (int iter = 0; iter < MAX_LOCAL_OPT_ITER; iter++) {\n // Pick a random rectangle to adjust\n size_t idx = rng() % n;\n Rectangle orig = rects[idx];\n \n // Try small adjustments to boundaries\n vector candidates;\n \n // Define adjustments - try to expand first, then shrink\n int adjustments[12][4] = {\n // Try expanding (more likely to improve satisfaction)\n {0, 0, 1, 0}, {0, 0, 0, 1}, {-1, 0, 0, 0}, {0, -1, 0, 0},\n // Then try shrinking\n {0, 0, -1, 0}, {0, 0, 0, -1}, {1, 0, 0, 0}, {0, 1, 0, 0},\n // Try corner adjustments\n {-1, -1, 0, 0}, {0, 0, 1, 1}, {-1, 0, 1, 0}, {0, -1, 0, 1}\n };\n \n for (int k = 0; k < 12; k++) {\n int da = adjustments[k][0];\n int db = adjustments[k][1];\n int dc = adjustments[k][2];\n int dd = adjustments[k][3];\n \n int new_a = orig.a + da;\n int new_b = orig.b + db;\n int new_c = orig.c + dc;\n int new_d = orig.d + dd;\n \n // Check bounds\n if (new_a < 0 || new_b < 0 || new_c > 10000 || new_d > 10000) continue;\n if (new_a >= new_c || new_b >= new_d) continue;\n \n // Check target point containment\n double target_x = companies[idx].target_x;\n double target_y = companies[idx].target_y;\n if (target_x < new_a + 0.5 || target_x >= new_c - 0.5 || \n target_y < new_b + 0.5 || target_y >= new_d - 0.5) continue;\n \n // Check for overlaps with other rectangles\n bool has_overlap = false;\n Rectangle test_rect(new_a, new_b, new_c, new_d, idx);\n for (size_t j = 0; j < n; j++) {\n if (j != idx && test_rect.overlaps(rects[j])) {\n has_overlap = true;\n break;\n }\n }\n \n if (!has_overlap) {\n candidates.push_back(test_rect);\n }\n }\n \n // If we have candidates, pick the best one\n if (!candidates.empty()) {\n double best_candidate_score = -1.0;\n Rectangle best_candidate;\n \n for (auto& cand : candidates) {\n rects[idx] = cand;\n double score = calculateTotalSatisfaction(rects, companies);\n if (score > best_candidate_score) {\n best_candidate_score = score;\n best_candidate = cand;\n }\n }\n \n // Apply the best candidate if it improves the score\n if (best_candidate_score > best_score) {\n rects[idx] = best_candidate;\n best_score = best_candidate_score;\n } else {\n // Restore original if no improvement\n rects[idx] = orig;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n auto start_time = chrono::steady_clock::now();\n \n int n;\n cin >> n;\n \n vector companies;\n for (int i = 0; i < n; i++) {\n int x, y, r;\n cin >> x >> y >> r;\n companies.push_back(Company(x, y, r, i));\n }\n \n // Create initial rectangles\n vector rects = createInitialRectangles(companies);\n \n // Exhaustively resolve all overlaps\n exhaustiveOverlapResolution(rects, companies);\n \n // Verify no overlaps exist\n size_t size_n = rects.size();\n for (size_t i = 0; i < size_n; i++) {\n for (size_t j = i + 1; j < size_n; j++) {\n if (rects[i].overlaps(rects[j])) {\n // Absolute emergency: Force both to minimum size\n rects[i] = Rectangle((int)companies[i].target_x, (int)companies[i].target_y, \n (int)companies[i].target_x + 1, (int)companies[i].target_y + 1, i);\n rects[j] = Rectangle((int)companies[j].target_x, (int)companies[j].target_y, \n (int)companies[j].target_x + 1, (int)companies[j].target_y + 1, j);\n }\n }\n }\n \n // Only do optimization if we have time remaining\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n if (elapsed_ms < 3000) {\n optimizeRectangles(rects, companies);\n \n // Re-verify no overlaps were created during optimization\n for (size_t i = 0; i < size_n; i++) {\n for (size_t j = i + 1; j < size_n; j++) {\n if (rects[i].overlaps(rects[j])) {\n // Fix any overlaps created during optimization\n if (rects[i].area() <= rects[j].area()) {\n rects[i] = Rectangle((int)companies[i].target_x, (int)companies[i].target_y, \n (int)companies[i].target_x + 1, (int)companies[i].target_y + 1, i);\n } else {\n rects[j] = Rectangle((int)companies[j].target_x, (int)companies[j].target_y, \n (int)companies[j].target_x + 1, (int)companies[j].target_y + 1, j);\n }\n }\n }\n }\n }\n \n // Final validity check and output\n for (int i = 0; i < n; i++) {\n // Ensure bounds\n rects[i].a = max(0, rects[i].a);\n rects[i].b = max(0, rects[i].b);\n rects[i].c = min(10000, rects[i].c);\n rects[i].d = min(10000, rects[i].d);\n \n // Ensure minimum size and target point containment\n if (rects[i].a >= rects[i].c) {\n rects[i].a = (int)companies[i].target_x;\n rects[i].c = min(10000, rects[i].a + 1);\n }\n if (rects[i].b >= rects[i].d) {\n rects[i].b = (int)companies[i].target_y;\n rects[i].d = min(10000, rects[i].b + 1);\n }\n if (!rects[i].contains(companies[i].target_x, companies[i].target_y)) {\n rects[i].a = (int)companies[i].target_x;\n rects[i].c = min(10000, rects[i].a + 1);\n rects[i].b = (int)companies[i].target_y;\n rects[i].d = min(10000, rects[i].b + 1);\n }\n \n cout << rects[i].a << \" \" << rects[i].b << \" \" << rects[i].c << \" \" << rects[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Tile {\n vector> squares;\n int total_value;\n int id;\n};\n\nclass Solution {\nprivate:\n int si, sj;\n vector> tile_ids;\n vector> values;\n vector tiles;\n int n = 50;\n high_resolution_clock::time_point start_time;\n const double time_limit = 1.9;\n \n // Directions: U, D, L, R\n const vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n const string dir_chars = \"UDLR\";\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < n && j >= 0 && j < n;\n }\n \n double get_elapsed_time() {\n auto now = high_resolution_clock::now();\n auto duration = duration_cast(now - start_time);\n return duration.count() / 1000000.0;\n }\n \n int get_direction(int i, int j, int ni, int nj) {\n if (ni == i - 1) return 0; // U\n if (ni == i + 1) return 1; // D\n if (nj == j - 1) return 2; // L\n if (nj == j + 1) return 3; // R\n return -1;\n }\n \n // Validate a path with detailed checks\n bool validate_path(const string& path, int& final_score) {\n unordered_set visited_tiles;\n visited_tiles.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n final_score = values[si][sj]; // Start with initial position score\n \n for (size_t k = 0; k < path.length(); k++) {\n char c = path[k];\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n else return false; // Invalid direction\n \n if (d == -1) return false;\n \n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n // Check if new position is valid\n if (!is_valid(ni, nj)) {\n return false;\n }\n \n int tile_id = tile_ids[ni][nj];\n \n // Check if we've already visited this tile\n if (visited_tiles.find(tile_id) != visited_tiles.end()) {\n return false;\n }\n \n // Add all squares of this tile to score and mark tile as visited\n visited_tiles.insert(tile_id);\n for (auto& square : tiles[tile_id].squares) {\n final_score += values[square.first][square.second];\n }\n \n current_i = ni;\n current_j = nj;\n }\n \n return true;\n }\n \n // Simple greedy approach - most reliable\n string simple_greedy() {\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n string path = \"\";\n \n while (get_elapsed_time() < time_limit * 0.95) {\n vector>> candidates; // {tile_value, {next_i, next_j}}\n \n // Check all 4 directions\n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n \n // Only consider if we haven't visited this tile\n if (visited.find(next_tile_id) == visited.end()) {\n // Calculate total value of this tile\n int tile_value = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n tile_value += values[square.first][square.second];\n }\n candidates.push_back({tile_value, {ni, nj}});\n }\n }\n }\n \n // If no valid moves, break\n if (candidates.empty()) {\n break;\n }\n \n // Sort by tile value (descending)\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Pick the highest value tile\n int best_ni = candidates[0].second.first;\n int best_nj = candidates[0].second.second;\n int dir = get_direction(current_i, current_j, best_ni, best_nj);\n \n // Update path and visited set\n path += dir_chars[dir];\n visited.insert(tile_ids[best_ni][best_nj]);\n \n // Move to new position\n current_i = best_ni;\n current_j = best_nj;\n }\n \n return path;\n }\n \n // Greedy with randomness for exploration\n string greedy_with_randomness() {\n string best_path = \"\";\n int best_score = values[si][sj]; // At least we have the starting position\n \n // Try multiple times with different randomness\n for (int attempt = 0; attempt < 5 && get_elapsed_time() < time_limit * 0.8; attempt++) {\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n string path = \"\";\n \n random_device rd;\n mt19937 gen(rd());\n \n while (get_elapsed_time() < time_limit * 0.75) {\n vector>> candidates;\n \n // Check all 4 directions\n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n \n if (visited.find(next_tile_id) == visited.end()) {\n int tile_value = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n tile_value += values[square.first][square.second];\n }\n candidates.push_back({tile_value, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) {\n break;\n }\n \n // Sort by tile value\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Select with some randomness\n int selected_idx = 0;\n if (candidates.size() > 1 && attempt > 0) {\n uniform_real_distribution dis(0.0, 1.0);\n double r = dis(gen);\n // Higher attempts use more randomness\n double threshold = 0.2 + attempt * 0.15;\n if (r < threshold && candidates.size() > 1) {\n // Pick from top candidates\n int max_idx = min(2, (int)candidates.size() - 1);\n uniform_int_distribution idx_dis(0, max_idx);\n selected_idx = idx_dis(gen);\n }\n }\n \n int ni = candidates[selected_idx].second.first;\n int nj = candidates[selected_idx].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n path += dir_chars[dir];\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n // Validate and score this path\n int path_score = 0;\n if (validate_path(path, path_score)) {\n if (path_score > best_score) {\n best_score = path_score;\n best_path = path;\n }\n }\n }\n \n return best_path;\n }\n \n // Simple beam search with careful validation\n string beam_search() {\n // Use a simple beam search with small beam width\n struct State {\n int i, j;\n int score;\n string path;\n unordered_set visited;\n \n State(int _i, int _j, int _score, string _path, unordered_set _visited) \n : i(_i), j(_j), score(_score), path(_path), visited(_visited) {}\n \n bool operator<(const State& other) const {\n return score < other.score; // Max heap\n }\n };\n \n priority_queue pq;\n \n // Start state\n unordered_set start_visited;\n start_visited.insert(tile_ids[si][sj]);\n pq.push(State(si, sj, values[si][sj], \"\", start_visited));\n \n string best_path = \"\";\n int best_score = values[si][sj];\n \n int iterations = 0;\n while (!pq.empty() && get_elapsed_time() < time_limit * 0.6 && iterations < 1000) {\n State current = pq.top();\n pq.pop();\n \n // Update best if current is better\n if (current.score > best_score) {\n best_score = current.score;\n best_path = current.path;\n }\n \n // Don't expand if we've done too many iterations\n if (iterations > 500) break;\n \n // Generate next moves\n vector> next_states;\n \n for (int d = 0; d < 4; d++) {\n int ni = current.i + dirs[d].first;\n int nj = current.j + dirs[d].second;\n \n if (is_valid(ni, nj)) {\n int tile_id = tile_ids[ni][nj];\n \n if (current.visited.find(tile_id) == current.visited.end()) {\n // Create new state\n unordered_set new_visited = current.visited;\n new_visited.insert(tile_id);\n \n string new_path = current.path + dir_chars[d];\n \n // Calculate new score\n int additional_score = 0;\n for (auto& square : tiles[tile_id].squares) {\n additional_score += values[square.first][square.second];\n }\n int new_score = current.score + additional_score;\n \n next_states.push_back({new_score, State(ni, nj, new_score, new_path, new_visited)});\n }\n }\n }\n \n // Sort by score\n sort(next_states.begin(), next_states.end(), greater>());\n \n // Add top 3 to queue\n for (int i = 0; i < min(3, (int)next_states.size()); i++) {\n pq.push(next_states[i].second);\n }\n \n iterations++;\n }\n \n return best_path;\n }\n\npublic:\n void solve() {\n start_time = high_resolution_clock::now();\n \n // Read input\n cin >> si >> sj;\n \n tile_ids = vector>(n, vector(n));\n values = vector>(n, vector(n));\n \n // Read tile IDs\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> tile_ids[i][j];\n }\n }\n \n // Read values\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> values[i][j];\n }\n }\n \n // Build tile data structure\n unordered_map tile_map;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int id = tile_ids[i][j];\n if (tile_map.find(id) == tile_map.end()) {\n tile_map[id] = Tile{{}, 0, id};\n }\n tile_map[id].squares.push_back({i, j});\n tile_map[id].total_value += values[i][j];\n }\n }\n \n // Convert to vector\n for (auto& kv : tile_map) {\n tiles.push_back(kv.second);\n }\n \n string result = \"\";\n int best_score = values[si][sj];\n \n // Try different approaches in order of reliability\n \n // 1. Simple greedy (most reliable)\n if (get_elapsed_time() < time_limit * 0.3) {\n string greedy_result = simple_greedy();\n int score = 0;\n if (validate_path(greedy_result, score)) {\n if (score > best_score) {\n best_score = score;\n result = greedy_result;\n }\n }\n }\n \n // 2. Greedy with randomness\n if (get_elapsed_time() < time_limit * 0.6) {\n string random_greedy = greedy_with_randomness();\n int score = 0;\n if (validate_path(random_greedy, score)) {\n if (score > best_score) {\n best_score = score;\n result = random_greedy;\n }\n }\n }\n \n // 3. Simple beam search\n if (get_elapsed_time() < time_limit * 0.8) {\n string beam_result = beam_search();\n int score = 0;\n if (validate_path(beam_result, score)) {\n if (score > best_score) {\n best_score = score;\n result = beam_result;\n }\n }\n }\n \n // Final validation\n int final_score = 0;\n if (!validate_path(result, final_score)) {\n // Fallback: return empty path (always valid)\n result = \"\";\n }\n \n // Output result\n cout << result << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solution solver;\n solver.solve();\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst long long INF = 1e15;\n\n// Direction arrays for Dijkstra\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Estimated edge weights\nvector> h_est(GRID_SIZE, vector(GRID_SIZE - 1, 5000.0)); // horizontal edges\nvector> v_est(GRID_SIZE - 1, vector(GRID_SIZE, 5000.0)); // vertical edges\n\n// Uncertainty for each edge\nvector> h_uncertainty(GRID_SIZE, vector(GRID_SIZE - 1, 2000.0));\nvector> v_uncertainty(GRID_SIZE - 1, vector(GRID_SIZE, 2000.0));\n\n// Count of observations for each edge\nvector> h_count(GRID_SIZE, vector(GRID_SIZE - 1, 0));\nvector> v_count(GRID_SIZE - 1, vector(GRID_SIZE, 0));\n\n// Track min/max observed values for dynamic bounds\ndouble global_min_observed = 1000.0;\ndouble global_max_observed = 9000.0;\n\n// For Dijkstra\nstruct Node {\n int x, y;\n double cost;\n string path;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n\n// Check if coordinates are valid\nbool isValid(int x, int y) {\n return x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE;\n}\n\n// Simple Manhattan path for early queries or fallback\nstring getManhattanPath(int sx, int sy, int tx, int ty) {\n string path = \"\";\n int cx = sx, cy = sy;\n \n // Move vertically first (prioritize moving in the direction with larger difference)\n int dx = tx - sx;\n int dy = ty - sy;\n \n // Decide whether to prioritize horizontal or vertical based on which has larger absolute difference\n if (abs(dx) > abs(dy)) {\n // Move horizontally first\n while (cy < ty) {\n path += 'R';\n cy++;\n }\n while (cy > ty) {\n path += 'L';\n cy--;\n }\n while (cx < tx) {\n path += 'D';\n cx++;\n }\n while (cx > tx) {\n path += 'U';\n cx--;\n }\n } else {\n // Move vertically first\n while (cx < tx) {\n path += 'D';\n cx++;\n }\n while (cx > tx) {\n path += 'U';\n cx--;\n }\n while (cy < ty) {\n path += 'R';\n cy++;\n }\n while (cy > ty) {\n path += 'L';\n cy--;\n }\n }\n \n return path;\n}\n\n// Dijkstra's algorithm to find shortest path based on current estimates\nstring dijkstra(int sx, int sy, int tx, int ty, int query_num) {\n // For very early queries, use Manhattan with some randomness for exploration\n if (query_num < 3) {\n return getManhattanPath(sx, sy, tx, ty);\n }\n \n // Priority queue for Dijkstra\n priority_queue, greater> pq;\n vector> dist(GRID_SIZE, vector(GRID_SIZE, INF));\n vector> visited(GRID_SIZE, vector(GRID_SIZE, false));\n \n pq.push({sx, sy, 0.0, \"\"});\n dist[sx][sy] = 0.0;\n \n while (!pq.empty()) {\n Node curr = pq.top();\n pq.pop();\n \n int x = curr.x;\n int y = curr.y;\n double cost = curr.cost;\n string currPath = curr.path;\n \n if (visited[x][y]) continue;\n visited[x][y] = true;\n \n // If we reached the target\n if (x == tx && y == ty) {\n return currPath;\n }\n \n // Try all four directions\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n \n if (!isValid(nx, ny)) continue;\n \n double edgeCost = 0.0;\n // Calculate edge cost based on direction\n if (i == 0 && x > 0) { // Up\n edgeCost = v_est[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) { // Down\n edgeCost = v_est[x][y];\n } else if (i == 2 && y > 0) { // Left\n edgeCost = h_est[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) { // Right\n edgeCost = h_est[x][y];\n } else {\n continue; // Invalid move\n }\n \n // Apply dynamic bounds based on observed values\n double min_bound = max(500.0, global_min_observed - 500.0);\n double max_bound = min(9500.0, global_max_observed + 500.0);\n edgeCost = max(min_bound, min(max_bound, edgeCost));\n \n // Add exploration bonus based on query number and uncertainty\n double exploration_bonus = 0.0;\n if (query_num < 500) {\n // More sophisticated exploration: decrease over time and scale with uncertainty\n double exploration_factor = 0.03 * exp(-query_num / 300.0);\n if (i == 0 && x > 0) exploration_bonus = -exploration_factor * v_uncertainty[x-1][y];\n else if (i == 1 && x < GRID_SIZE-1) exploration_bonus = -exploration_factor * v_uncertainty[x][y];\n else if (i == 2 && y > 0) exploration_bonus = -exploration_factor * h_uncertainty[x][y-1];\n else if (i == 3 && y < GRID_SIZE-1) exploration_bonus = -exploration_factor * h_uncertainty[x][y];\n }\n \n // Add small noise to break ties and encourage exploration\n double noise = 0.0;\n if (query_num < 200) {\n noise = (rand() % 100) / 1000.0 * edgeCost * 0.01;\n }\n \n if (dist[nx][ny] > cost + edgeCost + exploration_bonus + noise) {\n dist[nx][ny] = cost + edgeCost + exploration_bonus + noise;\n pq.push({nx, ny, cost + edgeCost + exploration_bonus + noise, currPath + dirChar[i]});\n }\n }\n }\n \n // Fallback to Manhattan path if Dijkstra fails\n return getManhattanPath(sx, sy, tx, ty);\n}\n\n// Update edge weight estimates based on the feedback\nvoid updateEstimates(const string& path, int sx, int sy, int actual_cost, int query_num) {\n // Calculate the expected cost based on current estimates\n int x = sx, y = sy;\n double expected_cost = 0.0;\n vector> edge_coords;\n vector edge_types;\n vector edge_weights;\n vector edge_uncertainties;\n \n for (char dir : path) {\n if (dir == 'U' && x > 0) {\n double cost = v_est[x-1][y];\n expected_cost += cost;\n edge_coords.push_back({x-1, y});\n edge_types.push_back(1); // vertical\n edge_weights.push_back(cost);\n edge_uncertainties.push_back(v_uncertainty[x-1][y]);\n x--;\n } else if (dir == 'D' && x < GRID_SIZE-1) {\n double cost = v_est[x][y];\n expected_cost += cost;\n edge_coords.push_back({x, y});\n edge_types.push_back(1); // vertical\n edge_weights.push_back(cost);\n edge_uncertainties.push_back(v_uncertainty[x][y]);\n x++;\n } else if (dir == 'L' && y > 0) {\n double cost = h_est[x][y-1];\n expected_cost += cost;\n edge_coords.push_back({x, y-1});\n edge_types.push_back(0); // horizontal\n edge_weights.push_back(cost);\n edge_uncertainties.push_back(h_uncertainty[x][y-1]);\n y--;\n } else if (dir == 'R' && y < GRID_SIZE-1) {\n double cost = h_est[x][y];\n expected_cost += cost;\n edge_coords.push_back({x, y});\n edge_types.push_back(0); // horizontal\n edge_weights.push_back(cost);\n edge_uncertainties.push_back(h_uncertainty[x][y]);\n y++;\n }\n }\n \n // Calculate total error\n double total_error = actual_cost - expected_cost;\n int path_length = edge_coords.size();\n \n if (path_length == 0) return;\n \n // Adaptive learning rate based on query number and relative error\n double base_learning_rate = 0.15;\n double relative_error = abs(total_error) / max(1.0, expected_cost);\n \n // Higher learning rate for larger relative errors (we're very wrong)\n double error_factor = 1.0 + min(1.0, relative_error); // Cap at 2x\n \n double learning_rate = base_learning_rate * error_factor;\n \n // Adjust learning rate based on query number (decrease over time)\n if (query_num < 100) {\n learning_rate = min(0.4, 0.3 * error_factor);\n } else if (query_num < 250) {\n learning_rate = min(0.3, 0.2 * error_factor);\n } else if (query_num < 500) {\n learning_rate = min(0.2, 0.15 * error_factor);\n } else if (query_num < 800) {\n learning_rate = min(0.15, 0.1 * error_factor);\n } else {\n learning_rate = min(0.1, 0.05 * error_factor);\n }\n \n // Update global observed bounds\n double estimated_avg_edge_cost = expected_cost / path_length;\n double observed_avg_edge_cost = actual_cost / path_length;\n global_min_observed = min(global_min_observed, observed_avg_edge_cost * 0.8);\n global_max_observed = max(global_max_observed, observed_avg_edge_cost * 1.2);\n \n // Calculate total weight for proportional attribution\n double total_weight = 0.0;\n for (double w : edge_weights) {\n total_weight += w;\n }\n \n // If total weight is 0, use equal distribution\n bool use_equal_distribution = (total_weight < 1e-6);\n \n for (int i = 0; i < path_length; i++) {\n int coord1 = edge_coords[i].first;\n int coord2 = edge_coords[i].second;\n double weight = edge_weights[i];\n double uncertainty = edge_uncertainties[i];\n int count = (edge_types[i] == 0) ? h_count[coord1][coord2] : v_count[coord1][coord2];\n \n // Calculate error contribution\n double error_contribution;\n if (use_equal_distribution) {\n error_contribution = total_error / path_length;\n } else {\n // Proportional to weight with uncertainty boost for less observed edges\n double weight_factor = weight / total_weight;\n double uncertainty_boost = 1.0 + (0.2 * uncertainty / 2000.0) * exp(-count / 20.0);\n error_contribution = total_error * weight_factor * uncertainty_boost;\n }\n \n if (edge_types[i] == 0) { // horizontal edge\n double old_value = h_est[coord1][coord2];\n double update_amount = learning_rate * error_contribution;\n h_est[coord1][coord2] += update_amount;\n \n // Apply dynamic bounds\n double min_bound = max(500.0, global_min_observed - 500.0);\n double max_bound = min(9500.0, global_max_observed + 500.0);\n h_est[coord1][coord2] = max(min_bound, min(max_bound, h_est[coord1][coord2]));\n \n // Update uncertainty: reduce more if update was small relative to value\n double update_ratio = abs(update_amount) / max(1000.0, abs(old_value));\n double uncertainty_reduction = 0.95 + 0.05 * min(1.0, update_ratio * 5.0);\n h_uncertainty[coord1][coord2] *= uncertainty_reduction;\n h_uncertainty[coord1][coord2] = max(30.0, h_uncertainty[coord1][coord2]);\n \n // Update count\n h_count[coord1][coord2]++;\n } else { // vertical edge\n double old_value = v_est[coord1][coord2];\n double update_amount = learning_rate * error_contribution;\n v_est[coord1][coord2] += update_amount;\n \n // Apply dynamic bounds\n double min_bound = max(500.0, global_min_observed - 500.0);\n double max_bound = min(9500.0, global_max_observed + 500.0);\n v_est[coord1][coord2] = max(min_bound, min(max_bound, v_est[coord1][coord2]));\n \n // Update uncertainty\n double update_ratio = abs(update_amount) / max(1000.0, abs(old_value));\n double uncertainty_reduction = 0.95 + 0.05 * min(1.0, update_ratio * 5.0);\n v_uncertainty[coord1][coord2] *= uncertainty_reduction;\n v_uncertainty[coord1][coord2] = max(30.0, v_uncertainty[coord1][coord2]);\n \n // Update count\n v_count[coord1][coord2]++;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Seed random for exploration noise\n srand(12345);\n \n for (int k = 0; k < 1000; k++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n \n // Find path using current estimates\n string path = dijkstra(si, sj, ti, tj, k);\n \n // Output path\n cout << path << endl;\n cout.flush();\n \n // Read the result\n int result;\n cin >> result;\n \n // Update estimates based on feedback\n updateEstimates(path, si, sj, result, k);\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nconst char CHARS[8] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};\n\n// Helper function to validate a character\nbool isValidChar(char c) {\n if (c == '.') return true;\n for (char valid : CHARS) {\n if (c == valid) return true;\n }\n return false;\n}\n\n// Helper function to sanitize a character\nchar sanitizeChar(char c) {\n if (isValidChar(c)) return c;\n // Return most common fallback\n return 'A';\n}\n\nclass MatrixSolver {\nprivate:\n int M;\n vector strings;\n vector matrix;\n vector matched;\n mt19937 rng;\n \npublic:\n MatrixSolver(int m, const vector& s) : M(m), strings(s), rng(random_device{}()) {\n // Initialize matrix with valid characters\n matrix.resize(N, string(N, 'A')); // Start with 'A' instead of '.' for safety\n matched.resize(M, false);\n }\n \n // Check if string s matches at position (i,j) horizontally\n bool matchesHorizontal(const string& s, int i, int j) const {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n \n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n \n // Ensure we have valid characters\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : 'A';\n if (cell != s[p] && cell != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if string s matches at position (i,j) vertically\n bool matchesVertical(const string& s, int i, int j) const {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n \n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n \n // Ensure we have valid characters\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : 'A';\n if (cell != s[p] && cell != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if a string matches anywhere in the matrix\n bool matches(const string& s) const {\n if (s.empty()) return true;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matchesHorizontal(s, i, j) || matchesVertical(s, i, j)) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Count how many strings are matched\n int countMatches() {\n int count = 0;\n for (int i = 0; i < M; i++) {\n if (i < static_cast(strings.size()) && !strings[i].empty() && matches(strings[i])) {\n matched[i] = true;\n count++;\n } else {\n matched[i] = false;\n }\n }\n return count;\n }\n \n // Get score based on problem definition\n long long getScore(int c, int d) {\n if (c < M) {\n return static_cast(round(100000000.0 * static_cast(c) / static_cast(M)));\n } else {\n double denominator = 2.0 * N * N - static_cast(d);\n if (denominator <= 0) denominator = 1.0;\n return static_cast(round(100000000.0 * 2.0 * N * N / denominator));\n }\n }\n \n // Count number of '.' in matrix\n int countDots() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == '.') {\n count++;\n }\n }\n }\n return count;\n }\n \n // Initialize matrix based on string frequency\n void initializeByFrequency() {\n // Count character frequencies\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n // Fill matrix with most frequent character\n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = mostFreqChar;\n }\n }\n }\n \n // Initialize by trying to place longer strings first\n void initializeByStringPlacement() {\n // Start with all dots for maximum flexibility\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = '.';\n }\n }\n \n // Sort strings by length (descending) to place longer ones first\n vector> stringLengths; // {length, index}\n for (int i = 0; i < M; i++) {\n stringLengths.push_back({static_cast(strings[i].size()), i});\n }\n sort(stringLengths.rbegin(), stringLengths.rend());\n \n // Try to place each string\n for (int idx = 0; idx < min(100, static_cast(stringLengths.size())); idx++) {\n int strIdx = stringLengths[idx].second;\n const string& s = strings[strIdx];\n \n if (s.empty()) continue;\n \n // Generate random positions to try\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Try horizontal placement\n bool placed = false;\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlace = false;\n break;\n }\n }\n \n if (canPlace) {\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n matrix[i][col] = s[p];\n }\n placed = true;\n break;\n }\n }\n \n if (!placed) {\n // Try vertical placement\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlace = false;\n break;\n }\n }\n \n if (canPlace) {\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n matrix[row][j] = s[p];\n }\n placed = true;\n break;\n }\n }\n }\n }\n }\n \n // Try to improve matrix by changing one cell\n bool improve() {\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n bool improved = false;\n \n // Create shuffled list of positions\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Try changing each cell\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n if (i < 0 || i >= N || j < 0 || j >= N) continue;\n \n char original = isValidChar(matrix[i][j]) ? matrix[i][j] : 'A';\n \n // Create list of characters to try\n vector tryChars;\n for (char c : CHARS) {\n if (c != original) {\n tryChars.push_back(c);\n }\n }\n tryChars.push_back('.'); // Try empty\n // Don't add original to avoid no-ops\n \n // Shuffle for randomness\n shuffle(tryChars.begin(), tryChars.end(), rng);\n \n for (char c : tryChars) {\n matrix[i][j] = c;\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) { // Only accept improvements\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n // Keep this change\n } else {\n // Revert if not better\n matrix[i][j] = original;\n }\n }\n }\n \n return improved;\n }\n \n // More aggressive approach to fix unmatched strings\n void fixUnmatchedAggressive() {\n vector unmatchedIndices;\n for (int i = 0; i < M; i++) {\n if (!matched[i]) {\n unmatchedIndices.push_back(i);\n }\n }\n \n if (unmatchedIndices.empty()) return;\n \n // Shuffle unmatched indices\n shuffle(unmatchedIndices.begin(), unmatchedIndices.end(), rng);\n \n // Try to fix up to 30 unmatched strings\n int limit = min(30, static_cast(unmatchedIndices.size()));\n for (int idx = 0; idx < limit; idx++) {\n int strIdx = unmatchedIndices[idx];\n if (strIdx < 0 || strIdx >= M) continue;\n const string& s = strings[strIdx];\n \n if (s.empty()) continue;\n \n // Generate all possible positions\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Score each position for horizontal placement\n vector>> horizontalScores; // {score, {i, j}}\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n int conflicts = 0;\n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : '.';\n if (cell != '.' && cell != s[p]) {\n conflicts++;\n canPlace = false;\n }\n }\n \n if (canPlace || conflicts <= 1) { // Allow up to 1 conflict\n horizontalScores.push_back({conflicts, pos});\n }\n }\n \n // Score each position for vertical placement\n vector>> verticalScores; // {score, {i, j}}\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n int conflicts = 0;\n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : '.';\n if (cell != '.' && cell != s[p]) {\n conflicts++;\n canPlace = false;\n }\n }\n \n if (canPlace || conflicts <= 1) { // Allow up to 1 conflict\n verticalScores.push_back({conflicts, pos});\n }\n }\n \n // Sort by score (lower conflicts is better)\n sort(horizontalScores.begin(), horizontalScores.end());\n sort(verticalScores.begin(), verticalScores.end());\n \n // Try to place with minimum conflicts\n bool placed = false;\n \n // Try horizontal first\n if (!horizontalScores.empty() && horizontalScores[0].first <= 1) {\n int i = horizontalScores[0].second.first;\n int j = horizontalScores[0].second.second;\n \n // Place the string (overwriting conflicting cells)\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n matrix[i][col] = s[p];\n }\n placed = true;\n }\n \n // Try vertical if horizontal failed\n if (!placed && !verticalScores.empty() && verticalScores[0].first <= 1) {\n int i = verticalScores[0].second.first;\n int j = verticalScores[0].second.second;\n \n // Place the string (overwriting conflicting cells)\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n matrix[row][j] = s[p];\n }\n placed = true;\n }\n }\n }\n \n // Validate and sanitize the entire matrix\n void sanitizeMatrix() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = sanitizeChar(matrix[i][j]);\n }\n }\n }\n \n // Try multiple different approaches and pick the best\n void solveWithMultipleRestarts() {\n vector bestMatrix;\n int bestScore = -1;\n \n // Try different approaches\n vector> approaches = {\n [this]() { initializeByFrequency(); },\n [this]() { initializeByStringPlacement(); }\n };\n \n auto startTime = chrono::steady_clock::now();\n \n for (int attempt = 0; attempt < 3; attempt++) {\n // Choose approach based on attempt\n int approachIdx = attempt % approaches.size();\n approaches[approachIdx]();\n \n // Sanitize matrix after initialization\n sanitizeMatrix();\n \n // Refine the solution\n int iteration = 0;\n const int maxIterations = 20;\n \n while (iteration < maxIterations) {\n int currentMatches = countMatches();\n \n // Try to improve\n bool improved = improve();\n iteration++;\n \n // Sanitize after each improvement\n sanitizeMatrix();\n \n // Check time limit\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2000) break; // 2 seconds for safety\n \n // If no improvement or few matches, try fixing unmatched\n if (!improved || currentMatches < M / 4) {\n fixUnmatchedAggressive();\n sanitizeMatrix(); // Sanitize after fixing\n iteration = 0; // Reset iteration counter after fixing\n break; // Break to re-evaluate\n }\n }\n \n // Final evaluation\n sanitizeMatrix(); // Ensure matrix is clean before evaluation\n int finalMatches = countMatches();\n int finalDots = countDots();\n long long score = getScore(finalMatches, finalDots);\n \n // Keep the best solution\n if (score > bestScore) {\n bestScore = score;\n bestMatrix = matrix;\n }\n \n // Check time limit\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2200) break;\n }\n \n // Use the best solution found\n if (!bestMatrix.empty()) {\n matrix = bestMatrix;\n sanitizeMatrix(); // Final sanitization\n }\n }\n \n // Fallback: simple greedy approach\n void solveSimpleGreedy() {\n // Initialize with dots\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = '.';\n }\n }\n \n // Sort strings by length (descending)\n vector indices(M);\n for (int i = 0; i < M; i++) {\n indices[i] = i;\n }\n \n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return strings[a].size() > strings[b].size();\n });\n \n // Try to place each string\n for (int idx : indices) {\n if (idx < 0 || idx >= M) continue;\n const string& s = strings[idx];\n if (s.empty()) continue;\n \n // Try all positions\n for (int i = 0; i < N && !matches(s); i++) {\n for (int j = 0; j < N && !matches(s); j++) {\n // Try horizontal\n bool canPlaceHorizontal = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlaceHorizontal = false;\n break;\n }\n }\n \n if (canPlaceHorizontal) {\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n matrix[i][col] = s[p];\n }\n break;\n }\n \n // Try vertical\n bool canPlaceVertical = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlaceVertical = false;\n break;\n }\n }\n \n if (canPlaceVertical) {\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n matrix[row][j] = s[p];\n }\n break;\n }\n }\n }\n }\n \n // Final sanitization\n sanitizeMatrix();\n }\n \n // Main solve method\n void solve() {\n try {\n auto startTime = chrono::steady_clock::now();\n \n // Initialize with safe values\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = 'A';\n }\n }\n \n // Try sophisticated approach first\n solveWithMultipleRestarts();\n \n // Check if we have at least some matches\n int currentMatches = countMatches();\n \n // If we're doing very poorly, try simple greedy as fallback\n if (currentMatches < M / 10) {\n solveSimpleGreedy();\n }\n \n // Final improvements\n for (int i = 0; i < 5; i++) {\n improve();\n sanitizeMatrix(); // Sanitize after each improvement\n \n // Check time limit\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2500) break;\n }\n \n // Final sanitization before output\n sanitizeMatrix();\n \n } catch (...) {\n // Fallback: simple frequency-based solution\n initializeByFrequency();\n sanitizeMatrix();\n }\n }\n \n // Output the matrix\n void output() const {\n for (int i = 0; i < N; i++) {\n string row;\n if (i < static_cast(matrix.size())) {\n row = matrix[i];\n } else {\n row = string(N, 'A');\n }\n \n // Ensure row has exactly N characters and all are valid\n if (row.size() != N) {\n row = string(N, 'A');\n }\n \n // Validate each character\n for (int j = 0; j < N; j++) {\n if (!isValidChar(row[j])) {\n row[j] = 'A';\n }\n }\n \n cout << row << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n try {\n MatrixSolver solver(M, strings);\n solver.solve();\n solver.output();\n } catch (...) {\n // Ultimate fallback\n // Find most frequent character\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n cout << string(N, mostFreqChar) << endl;\n }\n }\n \n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_chars[4] = {'U', 'D', 'L', 'R'};\n\nint N, si, sj;\nvector grid;\nvector> move_cost;\n\n// Check if position is within bounds\ninline bool in_bounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// Check if a position is visible from another\ninline bool is_visible(int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Same row\n int start = min(y1, y2);\n int end = max(y1, y2);\n for (int j = start; j <= end; j++) {\n if (grid[x1][j] == '#') return false;\n }\n return true;\n } else if (y1 == y2) {\n // Same column\n int start = min(x1, x2);\n int end = max(x1, x2);\n for (int i = start; i <= end; i++) {\n if (grid[i][y1] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\n// Find path from (start_x, start_y) to (end_x, end_y) using BFS\nstring find_path(int start_x, int start_y, int end_x, int end_y) {\n if (start_x == end_x && start_y == end_y) return \"\";\n \n queue, string>> q;\n vector> visited(N, vector(N, false));\n \n q.push({{start_x, start_y}, \"\"});\n visited[start_x][start_y] = true;\n \n while (!q.empty()) {\n auto current = q.front();\n q.pop();\n \n int x = current.first.first;\n int y = current.first.second;\n string path = current.second;\n \n if (x == end_x && y == end_y) {\n return path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#' || visited[nx][ny]) continue;\n \n visited[nx][ny] = true;\n q.push({{nx, ny}, path + dir_chars[d]});\n }\n }\n \n // If BFS failed, use simple greedy approach\n string fallback = \"\";\n int x = start_x, y = start_y;\n \n while (x != end_x || y != end_y) {\n int best_d = -1;\n int best_dist = abs(x - end_x) + abs(y - end_y);\n \n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#') continue;\n \n int new_dist = abs(nx - end_x) + abs(ny - end_y);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_d = d;\n }\n }\n \n if (best_d == -1) {\n // Pick any valid move\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#') continue;\n \n best_d = d;\n break;\n }\n \n if (best_d == -1) break; // No valid moves\n }\n \n x += dx[best_d];\n y += dy[best_d];\n fallback += dir_chars[best_d];\n }\n \n return fallback;\n}\n\n// Coverage-based route finding\nstring find_route() {\n vector> covered(N, vector(N, false));\n string route = \"\";\n int cur_x = si, cur_y = sj;\n \n // Mark squares visible from start\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && is_visible(si, sj, i, j)) {\n covered[i][j] = true;\n }\n }\n }\n \n // Count road squares and covered squares\n auto count_road_squares = [&]() {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') count++;\n }\n }\n return count;\n };\n \n auto count_covered = [&]() {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (covered[i][j]) count++;\n }\n }\n return count;\n };\n \n auto update_coverage = [&](int x, int y) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && !covered[i][j] && is_visible(x, y, i, j)) {\n covered[i][j] = true;\n }\n }\n }\n };\n \n int total_roads = count_road_squares();\n int covered_count = count_covered();\n \n if (covered_count >= total_roads) {\n return route; // Already covered everything\n }\n \n // Strategy: Systematically cover rows and columns\n vector> key_positions;\n \n // Add positions that can cover entire rows/columns\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n key_positions.push_back({i, j});\n }\n }\n }\n \n // Sort key positions by potential coverage (descending)\n sort(key_positions.begin(), key_positions.end(), [&](const pair& a, const pair& b) {\n int cover_a = 0, cover_b = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && !covered[i][j]) {\n if (is_visible(a.first, a.second, i, j)) cover_a++;\n if (is_visible(b.first, b.second, i, j)) cover_b++;\n }\n }\n }\n return cover_a > cover_b;\n });\n \n // Visit key positions in order of potential coverage\n const int MAX_POSITIONS = min(50, (int)key_positions.size());\n for (int idx = 0; idx < MAX_POSITIONS && covered_count < total_roads; idx++) {\n int target_x = key_positions[idx].first;\n int target_y = key_positions[idx].second;\n \n // Skip if already at this position\n if (cur_x == target_x && cur_y == target_y) {\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n continue;\n }\n \n // Find path to target\n string path_to_target = find_path(cur_x, cur_y, target_x, target_y);\n if (path_to_target.empty()) continue;\n \n route += path_to_target;\n cur_x = target_x;\n cur_y = target_y;\n \n // Update coverage\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n \n // Early termination\n if (covered_count >= total_roads) break;\n }\n \n // If still not covered everything, try additional positions\n if (covered_count < total_roads) {\n for (int i = 0; i < N && covered_count < total_roads; i++) {\n for (int j = 0; j < N && covered_count < total_roads; j++) {\n if (grid[i][j] != '#' && !covered[i][j]) {\n // Find path to this uncovered position\n string path_to_target = find_path(cur_x, cur_y, i, j);\n if (path_to_target.empty()) continue;\n \n route += path_to_target;\n cur_x = i;\n cur_y = j;\n \n // Update coverage\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n }\n }\n }\n }\n \n // Return to start\n string return_path = find_path(cur_x, cur_y, si, sj);\n route += return_path;\n \n return route;\n}\n\n// Aggressive optimization: remove immediate backtracking and simple loops\nstring optimize_route(const string& route) {\n if (route.empty()) return route;\n \n string optimized = route;\n bool changed = true;\n \n // Multiple passes to remove backtracking\n while (changed) {\n changed = false;\n string new_optimized = \"\";\n \n for (size_t i = 0; i < optimized.size(); i++) {\n if (new_optimized.empty()) {\n new_optimized += optimized[i];\n continue;\n }\n \n char last = new_optimized.back();\n char current = optimized[i];\n bool cancel = false;\n \n // Check for immediate backtracking\n if ((current == 'U' && last == 'D') || (current == 'D' && last == 'U') ||\n (current == 'L' && last == 'R') || (current == 'R' && last == 'L')) {\n new_optimized.pop_back();\n cancel = true;\n changed = true;\n }\n \n if (!cancel) {\n new_optimized += current;\n }\n }\n \n optimized = new_optimized;\n }\n \n return optimized;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Read input\n cin >> N >> si >> sj;\n grid.resize(N);\n move_cost.resize(N, vector(N, 0));\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n move_cost[i][j] = grid[i][j] - '0';\n }\n }\n }\n \n // Find route\n string route = find_route();\n \n // Optimize route\n route = optimize_route(route);\n \n // Output the route\n cout << route << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, K, R;\nvector> task_difficulty; // d[i][k] for task i, skill k\nvector> dependencies; // dependencies[i] = list of tasks that must be completed before task i\nvector> reverse_dependencies; // reverse_dependencies[i] = list of tasks that depend on task i\n\n// State tracking\nvector task_status; // -1: not started, 0: in progress, 1: completed\nvector member_assignment; // -1: idle, task_id: working on task\nvector member_busy_until; // day when member becomes available\n\n// Skill estimation\nvector> skill_lower_bound; // Lower bound for s[j][k]\nvector> skill_upper_bound; // Upper bound for s[j][k]\nvector> skill_exact; // Whether we know exact skill level\n\n// Random generator\nmt19937 rng;\n\n// Calculate w[i][j] = sum_k max(0, d[i][k] - s[j][k])\nint calculate_w(int task_id, int member_id) {\n int w = 0;\n for (int k = 0; k < K; k++) {\n int diff = task_difficulty[task_id][k] - skill_lower_bound[member_id][k];\n if (diff > 0) {\n w += diff;\n }\n }\n return w;\n}\n\n// Estimate completion time for task i by member j\nint estimate_completion_time(int task_id, int member_id) {\n int w = calculate_w(task_id, member_id);\n if (w == 0) {\n return 1;\n }\n // Since r_i is between -3 and 3, assume average case (0) for estimation\n return max(1, w);\n}\n\n// Check if task can be started (all dependencies completed)\nbool can_start_task(int task_id) {\n for (int dep : dependencies[task_id]) {\n if (task_status[dep] != 1) {\n return false;\n }\n }\n return true;\n}\n\n// Calculate criticality score for a task (how many tasks depend on it, directly or indirectly)\nint calculate_criticality(int task_id) {\n queue q;\n vector visited(N, false);\n int count = 0;\n \n q.push(task_id);\n visited[task_id] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v : reverse_dependencies[u]) {\n if (!visited[v]) {\n visited[v] = true;\n count++;\n q.push(v);\n }\n }\n }\n \n return count;\n}\n\n// Update skill estimates based on actual completion time\nvoid update_skill_estimates(int task_id, int member_id, int completion_time, int start_day, int end_day) {\n int actual_days = end_day - start_day + 1;\n \n if (actual_days == 1) {\n // w[i][j] = 0, so s[j][k] >= d[i][k] for all k\n for (int k = 0; k < K; k++) {\n skill_lower_bound[member_id][k] = max(skill_lower_bound[member_id][k], task_difficulty[task_id][k]);\n skill_exact[member_id][k] = true; // We know exact minimum\n }\n } else {\n // w[i][j] + r_i = actual_days, so w[i][j] = actual_days - r_i\n // Since r_i is between -3 and 3, w[i][j] is between actual_days-3 and actual_days+3\n // Use actual_days as estimate for w[i][j]\n int estimated_w = actual_days;\n \n // We know sum_k max(0, d[i][k] - s[j][k]) = estimated_w\n // This gives us constraints on s[j][k]\n // For simplicity, distribute the \"deficit\" proportionally\n int current_w = 0;\n vector deficits(K);\n for (int k = 0; k < K; k++) {\n int deficit = max(0, task_difficulty[task_id][k] - skill_lower_bound[member_id][k]);\n deficits[k] = deficit;\n current_w += deficit;\n }\n \n if (current_w < estimated_w) {\n // Our lower bounds are too high, adjust them down\n // This shouldn't happen normally, but can occur due to randomness\n // In this case, we don't update (or could decrease lower bounds)\n } else if (current_w > estimated_w) {\n // Our lower bounds are too low, we need to increase some of them\n // Increase skill estimates for skills with deficits\n int excess = current_w - estimated_w;\n \n // Simple approach: increase lower bounds for skills with deficits\n // Prioritize skills with larger deficits\n vector> deficit_skills;\n for (int k = 0; k < K; k++) {\n if (deficits[k] > 0) {\n deficit_skills.push_back({deficits[k], k});\n }\n }\n \n sort(deficit_skills.rbegin(), deficit_skills.rend());\n \n for (auto& p : deficit_skills) {\n int k = p.second;\n int reduce_by = min(deficits[k], excess);\n if (reduce_by > 0) {\n // This means we overestimated the deficit, so our skill lower bound was too low\n // We can't directly infer the correct skill level, so we'll just note that\n // our estimate was wrong and adjust conservatively\n excess -= reduce_by;\n }\n if (excess == 0) break;\n }\n }\n // If current_w == estimated_w, our estimates are consistent\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Initialize random generator\n rng.seed(12345);\n \n // Parse input\n cin >> N >> M >> K >> R;\n \n task_difficulty.resize(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> task_difficulty[i][k];\n }\n }\n \n dependencies.resize(N);\n reverse_dependencies.resize(N);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--; v--; // Convert to 0-indexed\n dependencies[v].push_back(u);\n reverse_dependencies[u].push_back(v);\n }\n \n // Initialize state\n task_status.assign(N, -1); // -1: not started\n member_assignment.assign(M, -1); // -1: not assigned\n member_busy_until.assign(M, 0);\n \n // Initialize skill estimates\n skill_lower_bound.assign(M, vector(K, 0));\n skill_upper_bound.assign(M, vector(K, INT_MAX));\n skill_exact.assign(M, vector(K, false));\n \n int day = 0;\n vector start_day_of_task(N, -1);\n \n while (true) {\n day++;\n \n // Check if day limit exceeded\n if (day > 2000) {\n break;\n }\n \n // Process completions from previous day\n int n_completed;\n cin >> n_completed;\n \n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n \n vector completed_members(n_completed);\n for (int i = 0; i < n_completed; i++) {\n cin >> completed_members[i];\n completed_members[i]--; // Convert to 0-indexed\n }\n \n // Update task and member status for completed tasks\n for (int member_id : completed_members) {\n int task_id = member_assignment[member_id];\n if (task_id != -1) {\n task_status[task_id] = 1; // Mark as completed\n // Update skill estimates based on completion time\n update_skill_estimates(task_id, member_id, day - start_day_of_task[task_id], start_day_of_task[task_id], day);\n member_assignment[member_id] = -1;\n member_busy_until[member_id] = day;\n }\n }\n \n // Find available team members\n vector available_members;\n for (int j = 0; j < M; j++) {\n if (member_assignment[j] == -1 && member_busy_until[j] < day) {\n available_members.push_back(j);\n }\n }\n \n // Find ready tasks (dependencies satisfied and not started/completed)\n vector ready_tasks;\n for (int i = 0; i < N; i++) {\n if (task_status[i] == -1 && can_start_task(i)) {\n ready_tasks.push_back(i);\n }\n }\n \n // Create assignment output\n vector> assignments; // (member_id, task_id)\n \n if (!available_members.empty() && !ready_tasks.empty()) {\n // Simple greedy assignment: assign tasks to minimize estimated completion time\n // Could use Hungarian algorithm for optimal assignment, but greedy should work well\n \n // Shuffle ready tasks for some randomness (helps exploration)\n shuffle(ready_tasks.begin(), ready_tasks.end(), rng);\n \n // Sort available members by some criterion (e.g., average skill level)\n // For now, just use as is\n \n // Greedy assignment\n vector task_assigned(ready_tasks.size(), false);\n \n for (int member_idx = 0; member_idx < available_members.size(); member_idx++) {\n int member_id = available_members[member_idx];\n \n // Find best task for this member\n int best_task_idx = -1;\n int min_estimated_time = INT_MAX;\n \n for (int task_idx = 0; task_idx < ready_tasks.size(); task_idx++) {\n if (task_assigned[task_idx]) continue;\n \n int task_id = ready_tasks[task_idx];\n int est_time = estimate_completion_time(task_id, member_id);\n \n // Consider task criticality (tasks that unblock more tasks)\n int criticality = calculate_criticality(task_id);\n // Adjust estimated time by criticality (lower priority for critical tasks)\n int adjusted_time = est_time - criticality / 10; // Simple weighting\n \n if (adjusted_time < min_estimated_time) {\n min_estimated_time = adjusted_time;\n best_task_idx = task_idx;\n }\n }\n \n if (best_task_idx != -1) {\n int task_id = ready_tasks[best_task_idx];\n assignments.push_back({member_id, task_id});\n task_assigned[best_task_idx] = true;\n task_status[task_id] = 0; // Mark as in progress\n member_assignment[member_id] = task_id;\n start_day_of_task[task_id] = day;\n }\n }\n }\n \n // Output assignments\n cout << assignments.size();\n for (auto& assignment : assignments) {\n cout << \" \" << assignment.first + 1 << \" \" << assignment.second + 1;\n }\n cout << endl;\n cout.flush(); // Important: flush output\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#include \n\nusing namespace std;\n\nstruct Order {\n int id;\n int pickup_x, pickup_y;\n int delivery_x, delivery_y;\n \n // Calculate Manhattan distance for this order\n int direct_distance() const {\n return abs(pickup_x - delivery_x) + abs(pickup_y - delivery_y);\n }\n \n // Distance from center to pickup and delivery\n int center_distance() const {\n return abs(pickup_x - 400) + abs(pickup_y - 400) + \n abs(delivery_x - 400) + abs(delivery_y - 400);\n }\n \n // \"Efficiency\" metric for order selection\n double efficiency_score() const {\n // Higher score = more efficient to deliver\n // We want orders that are closer to center and have shorter direct distances\n return 1.0 / (center_distance() + direct_distance());\n }\n};\n\n// Calculate Manhattan distance between two points\nint manhattan_distance(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nclass RouteOptimizer {\nprivate:\n vector orders;\n vector selected_orders;\n vector> route;\n vector pickup_done;\n vector delivery_done;\n \n // Track which order each location belongs to\n unordered_map location_to_order;\n \n // For precedence constraint checking\n vector pickup_index;\n vector delivery_index;\n \npublic:\n RouteOptimizer(const vector& all_orders) : orders(all_orders) {\n // Initialize data structures\n pickup_done.resize(50, false);\n delivery_done.resize(50, false);\n pickup_index.resize(50, -1);\n delivery_index.resize(50, -1);\n }\n \n // Select 50 orders based on efficiency\n void select_orders() {\n // Create indexed list for sorting\n vector> scores;\n for (int i = 0; i < 1000; i++) {\n scores.push_back({orders[i].efficiency_score(), i});\n }\n \n // Sort by efficiency (descending)\n sort(scores.begin(), scores.end(), [](const auto& a, const auto& b) {\n return a.first > b.first;\n });\n \n // Select top 50\n selected_orders.clear();\n for (int i = 0; i < 50; i++) {\n selected_orders.push_back(scores[i].second);\n }\n }\n \n // Construct initial route using greedy nearest neighbor\n void construct_initial_route() {\n route.clear();\n route.push_back({400, 400}); // Start at center\n \n // Reset tracking\n fill(pickup_done.begin(), pickup_done.end(), false);\n fill(delivery_done.begin(), delivery_done.end(), false);\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Build route step by step\n int current_x = 400, current_y = 400;\n int steps = 0;\n \n // Continue until all deliveries are done\n while (true) {\n // Find all possible next locations\n vector> candidates; // distance, order_idx, location_type (0=pickup, 1=delivery), actual location index\n \n for (int i = 0; i < 50; i++) {\n if (!pickup_done[i]) {\n // Can pick up this order\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].pickup_x, orders[selected_orders[i]].pickup_y);\n candidates.push_back({dist, i, 0, 2*i});\n } else if (!delivery_done[i]) {\n // Can deliver this order (pickup already done)\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].delivery_x, orders[selected_orders[i]].delivery_y);\n candidates.push_back({dist, i, 1, 2*i+1});\n }\n }\n \n if (candidates.empty()) {\n break; // All done\n }\n \n // Choose the nearest candidate\n sort(candidates.begin(), candidates.end());\n auto [dist, order_idx, loc_type, loc_idx] = candidates[0];\n \n if (loc_type == 0) {\n // Pick up\n pickup_done[order_idx] = true;\n pickup_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].pickup_x;\n current_y = orders[selected_orders[order_idx]].pickup_y;\n route.push_back({current_x, current_y});\n } else {\n // Deliver\n delivery_done[order_idx] = true;\n delivery_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].delivery_x;\n current_y = orders[selected_orders[order_idx]].delivery_y;\n route.push_back({current_x, current_y});\n }\n \n steps++;\n }\n \n // Return to center\n route.push_back({400, 400});\n }\n \n // 2-opt local search to improve route\n void optimize_route_2opt() {\n bool improved = true;\n while (improved) {\n improved = false;\n \n // Try all possible 2-opt swaps\n for (int i = 1; i < (int)route.size() - 2; i++) {\n for (int j = i + 1; j < (int)route.size() - 1; j++) {\n // Check if swap would violate any precedence constraints\n if (is_valid_2opt(i, j)) {\n // Calculate potential improvement\n int current_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[i].first, route[i].second) +\n manhattan_distance(route[j].first, route[j].second, route[j+1].first, route[j+1].second);\n int new_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[j].first, route[j].second) +\n manhattan_distance(route[i].first, route[i].second, route[j+1].first, route[j+1].second);\n \n if (new_cost < current_cost) {\n // Perform the swap\n reverse(route.begin() + i, route.begin() + j + 1);\n improved = true;\n \n // Update pickup/delivery indices\n update_indices();\n \n // Early break to restart search\n break;\n }\n }\n }\n if (improved) break;\n }\n }\n }\n \n // Check if 2-opt swap would violate precedence constraints\n bool is_valid_2opt(int i, int j) {\n // Create a copy of current state\n vector new_pickup_index = pickup_index;\n vector new_delivery_index = delivery_index;\n \n // Simulate the reversal and update indices\n for (int k = i; k <= j; k++) {\n int new_pos = i + (j - k);\n // Check which order this position belongs to\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (pickup_index[order_idx] == k) {\n new_pickup_index[order_idx] = new_pos;\n }\n if (delivery_index[order_idx] == k) {\n new_delivery_index[order_idx] = new_pos;\n }\n }\n }\n \n // Check all precedence constraints\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (new_pickup_index[order_idx] > new_delivery_index[order_idx]) {\n return false; // Violates pickup before delivery\n }\n }\n \n return true;\n }\n \n // Update indices after route modification\n void update_indices() {\n // Reset indices\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Rebuild indices by scanning the route\n for (int pos = 0; pos < (int)route.size(); pos++) {\n for (int i = 0; i < 50; i++) {\n // Check if this position is a pickup for order i\n if (route[pos].first == orders[selected_orders[i]].pickup_x && \n route[pos].second == orders[selected_orders[i]].pickup_y) {\n // Make sure we haven't already recorded this pickup\n if (pickup_index[i] == -1 || \n (pickup_index[i] != -1 && delivery_index[i] != -1)) {\n pickup_index[i] = pos;\n }\n }\n // Check if this position is a delivery for order i\n if (route[pos].first == orders[selected_orders[i]].delivery_x && \n route[pos].second == orders[selected_orders[i]].delivery_y) {\n delivery_index[i] = pos;\n }\n }\n }\n }\n \n // Calculate total route distance\n int calculate_total_distance() {\n int total = 0;\n for (int i = 0; i < (int)route.size() - 1; i++) {\n total += manhattan_distance(route[i].first, route[i].second, \n route[i+1].first, route[i+1].second);\n }\n return total;\n }\n \n // Main optimization method\n void optimize() {\n select_orders();\n construct_initial_route();\n optimize_route_2opt();\n }\n \n // Output the solution\n void output_solution() {\n // Output selected orders (1-indexed)\n cout << \"50\";\n for (int i = 0; i < 50; i++) {\n cout << \" \" << selected_orders[i] + 1; // Convert to 1-indexed\n }\n cout << endl;\n \n // Output route\n cout << route.size();\n for (int i = 0; i < (int)route.size(); i++) {\n cout << \" \" << route[i].first << \" \" << route[i].second;\n }\n cout << endl;\n }\n};\n\nint main() {\n // Read input\n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].pickup_x >> orders[i].pickup_y >> \n orders[i].delivery_x >> orders[i].delivery_y;\n orders[i].id = i;\n }\n \n // Create optimizer and run\n RouteOptimizer optimizer(orders);\n optimizer.optimize();\n optimizer.output_solution();\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Union-Find data structure\nstruct UnionFind {\n vector parent, rank;\n int components;\n \n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n components = n;\n for (int i = 0; i < n; i++) {\n parent[i] = i;\n }\n }\n \n int find(int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n }\n \n bool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n \n if (rank[x] < rank[y]) {\n swap(x, y);\n }\n parent[y] = x;\n if (rank[x] == rank[y]) {\n rank[x]++;\n }\n components--;\n return true;\n }\n \n bool same(int x, int y) {\n return find(x) == find(y);\n }\n \n int getComponents() {\n return components;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 400;\n const int M = 1995;\n \n // Read vertex coordinates\n vector> vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].first >> vertices[i].second;\n }\n \n // Read edges (store for later use)\n vector> edges(M);\n vector base_distances(M);\n \n for (int i = 0; i < M; i++) {\n cin >> edges[i].first >> edges[i].second;\n // Calculate d_i (rounded Euclidean distance)\n int dx = vertices[edges[i].first].first - vertices[edges[i].second].first;\n int dy = vertices[edges[i].first].second - vertices[edges[i].second].second;\n double dist = sqrt(dx*dx + dy*dy);\n base_distances[i] = (int)round(dist);\n }\n \n // Initialize Union-Find\n UnionFind uf(N);\n int edges_accepted = 0;\n const int MIN_EDGES_FOR_SPANNING_TREE = N - 1;\n \n // Process each edge\n for (int i = 0; i < M; i++) {\n int length;\n cin >> length;\n \n int u = edges[i].first;\n int v = edges[i].second;\n int d = base_distances[i];\n \n // Calculate cost ratio\n double ratio = (double)length / d;\n \n bool should_accept = false;\n \n // Check if this edge connects different components\n bool connects_different = !uf.same(u, v);\n \n // Calculate remaining information\n int components_remaining = uf.getComponents();\n int remaining_edges = M - i;\n \n // AGGRESSIVE STRATEGY FOR CONNECTIVITY:\n \n // Strategy 1: If we haven't completed the spanning tree, accept any edge that connects different components\n // This guarantees we'll get a spanning tree if enough connecting edges are available\n if (edges_accepted < MIN_EDGES_FOR_SPANNING_TREE && connects_different) {\n should_accept = true;\n }\n // Strategy 2: If we're very close to the end and still have multiple components, accept ANY connecting edge\n else if (remaining_edges <= 10 && connects_different && components_remaining > 1) {\n should_accept = true;\n }\n // Strategy 3: After having a spanning tree, only accept if it's a good deal and doesn't create a cycle\n else if (connects_different && ratio <= 1.3) {\n should_accept = true;\n }\n \n // Output decision\n cout << (should_accept ? 1 : 0) << endl;\n cout.flush();\n \n // If accepted, unite the components\n if (should_accept) {\n uf.unite(u, v);\n edges_accepted++;\n }\n }\n \n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int MAX_TURNS = 300;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool isValid() const { return x >= 1 && x <= GRID_SIZE && y >= 1 && y <= GRID_SIZE; }\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator<(const Point& other) const { \n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n Point operator+(const Point& other) const { return Point(x + other.x, y + other.y); }\n};\n\n// Direction vectors for U, D, L, R\nconst vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\nconst vector dirPoints = {Point(-1, 0), Point(1, 0), Point(0, -1), Point(0, 1)};\nconst string dir_chars = \"UDLR\";\nconst string block_chars = \"udlr\";\n\nclass Grid {\npublic:\n vector> impassable;\n vector human_positions;\n vector pet_positions;\n vector pet_types;\n int N, M;\n \n Grid() {\n impassable = vector>(GRID_SIZE + 1, vector(GRID_SIZE + 1, false));\n }\n \n bool isPassable(const Point& p) {\n if (!p.isValid()) return false;\n return !impassable[p.x][p.y];\n }\n \n // Check if we can make a square impassable (no pets or humans at start of turn, no adjacent pets)\n bool canBlock(const Point& p, const vector& start_human_positions, const vector& current_pet_positions) {\n if (!p.isValid()) return false;\n if (!isPassable(p)) return false; // Already impassable\n \n // Check if any human is at this position at the start of turn\n for (const Point& hp : start_human_positions) {\n if (hp == p) return false;\n }\n \n // Check if any pet is at this position at the start of turn\n for (const Point& pp : current_pet_positions) {\n if (pp == p) return false;\n }\n \n // Check if any adjacent square contains a pet\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (!adj.isValid()) continue;\n for (const Point& pp : current_pet_positions) {\n if (pp == adj) return false;\n }\n }\n \n return true;\n }\n \n // BFS to find reachable area from a point\n set getReachableArea(const Point& start) {\n set visited;\n queue q;\n q.push(start);\n visited.insert(start);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return visited;\n }\n \n // Count pets in a reachable area\n int countPetsInArea(const set& area) {\n int count = 0;\n for (const Point& pet_pos : pet_positions) {\n if (area.find(pet_pos) != area.end()) {\n count++;\n }\n }\n return count;\n }\n \n // Simple distance between two points\n int distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the closest pet to a human\n int findClosestPet(const Point& human_pos) {\n int min_dist = INT_MAX;\n int closest_pet = -1;\n \n for (int i = 0; i < N; i++) {\n int dist = distance(human_pos, pet_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = i;\n }\n }\n \n return closest_pet;\n }\n \n // Check if a pet can reach a human in the next few moves\n bool canPetReachHumanSoon(const Point& pet_pos, const Point& human_pos, int pet_type) {\n if (!isPassable(pet_pos) || !isPassable(human_pos)) return false;\n \n int max_moves = 1;\n if (pet_type == 2) max_moves = 2; // Pig\n else if (pet_type == 3) max_moves = 3; // Rabbit\n else if (pet_type == 4 || pet_type == 5) max_moves = 2; // Dog or Cat\n \n // Simple Manhattan distance check (faster than BFS for this purpose)\n int manhattan_dist = distance(pet_pos, human_pos);\n return manhattan_dist <= max_moves;\n }\n \n // Calculate simple score for a human at a given position\n double calculateSimpleScore(const Point& pos) {\n if (!isPassable(pos)) return 0;\n \n set area = getReachableArea(pos);\n int pet_count = countPetsInArea(area);\n return (double)area.size() / 900.0 * pow(0.5, pet_count);\n }\n \n // Count intelligent pets (dogs and cats)\n int countIntelligentPets() {\n int count = 0;\n for (int type : pet_types) {\n if (type == 4 || type == 5) count++; // Dogs and cats\n }\n return count;\n }\n \n // Simple path distance using BFS\n int simplePathDistance(const Point& start, const Point& target) {\n if (!isPassable(start) || !isPassable(target)) return INT_MAX;\n if (start == target) return 0;\n \n vector> dist(GRID_SIZE + 1, vector(GRID_SIZE + 1, -1));\n queue q;\n q.push(start);\n dist[start.x][start.y] = 0;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n if (curr == target) return dist[curr.x][curr.y];\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && dist[next.x][next.y] == -1) {\n dist[next.x][next.y] = dist[curr.x][curr.y] + 1;\n q.push(next);\n }\n }\n }\n \n return INT_MAX;\n }\n};\n\nint main() {\n Grid grid;\n \n // Read initial pet positions and types\n cin >> grid.N;\n grid.pet_positions.resize(grid.N);\n grid.pet_types.resize(grid.N);\n for (int i = 0; i < grid.N; i++) {\n cin >> grid.pet_positions[i].x >> grid.pet_positions[i].y >> grid.pet_types[i];\n }\n \n // Read initial human positions\n cin >> grid.M;\n grid.human_positions.resize(grid.M);\n for (int i = 0; i < grid.M; i++) {\n cin >> grid.human_positions[i].x >> grid.human_positions[i].y;\n }\n \n // Count intelligent pets\n int intelligent_pet_count = grid.countIntelligentPets();\n bool has_many_intelligent_pets = (intelligent_pet_count > grid.N / 2);\n \n int turn = 0;\n \n while (turn < MAX_TURNS) {\n // Make a copy of human positions at the start of turn for validation\n vector start_human_positions = grid.human_positions;\n string actions = \"\";\n \n // For each human, decide action\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char best_action = '.';\n double best_score = -1;\n \n // Check for immediate threats\n bool immediate_threat = false;\n int threatening_pet = -1;\n \n for (int j = 0; j < grid.N; j++) {\n if (grid.canPetReachHumanSoon(grid.pet_positions[j], human_pos, grid.pet_types[j])) {\n immediate_threat = true;\n threatening_pet = j;\n break;\n }\n }\n \n if (immediate_threat) {\n // Try to block the threatening pet\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Simple heuristic: prefer blocking in the direction of the threat\n Point& pet_pos = grid.pet_positions[threatening_pet];\n int block_dist = grid.distance(block_pos, pet_pos);\n int direct_dist = grid.distance(human_pos, pet_pos);\n \n // If blocking position is between human and pet\n if (block_dist < direct_dist) {\n best_action = block_chars[d];\n break;\n }\n }\n }\n \n // If can't block, try to move away\n if (best_action == '.') {\n Point& pet_pos = grid.pet_positions[threatening_pet];\n \n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n int dist_before = grid.distance(human_pos, pet_pos);\n int dist_after = grid.distance(move_pos, pet_pos);\n \n if (dist_after > dist_before) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n }\n \n actions += best_action;\n continue;\n }\n \n // Early game strategy (turns 0-100)\n if (turn < 100) {\n // For maps with many intelligent pets, focus on building a defensive perimeter\n if (has_many_intelligent_pets) {\n // Calculate centroid of all humans\n int sum_x = 0, sum_y = 0;\n for (const Point& p : start_human_positions) {\n sum_x += p.x;\n sum_y += p.y;\n }\n Point centroid(sum_x / grid.M, sum_y / grid.M);\n \n // Try to build walls on the periphery\n vector> block_options;\n \n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Prefer positions that are farther from centroid (building outward)\n int dist_to_centroid = grid.distance(block_pos, centroid);\n int min_pet_dist = 100;\n \n for (const Point& pet_pos : grid.pet_positions) {\n min_pet_dist = min(min_pet_dist, grid.distance(block_pos, pet_pos));\n }\n \n // Only consider if reasonably far from pets\n if (min_pet_dist >= 3) {\n block_options.push_back({dist_to_centroid, block_chars[d]});\n }\n }\n }\n \n if (!block_options.empty()) {\n // Choose the block position farthest from centroid\n sort(block_options.begin(), block_options.end(), greater>());\n best_action = block_options[0].second;\n }\n // If no good block, move toward centroid\n else {\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n int dist_before = grid.distance(human_pos, centroid);\n int dist_after = grid.distance(move_pos, centroid);\n \n if (dist_after < dist_before) {\n // Make sure not moving too close to pets\n bool too_close = false;\n for (const Point& pet_pos : grid.pet_positions) {\n if (grid.distance(move_pos, pet_pos) <= 2) {\n too_close = true;\n break;\n }\n }\n \n if (!too_close) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n }\n }\n }\n // For mostly random pets, focus on individual safety\n else {\n // Try to build a personal safe zone\n vector> block_options;\n \n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n int min_pet_dist = 100;\n for (const Point& pet_pos : grid.pet_positions) {\n min_pet_dist = min(min_pet_dist, grid.distance(block_pos, pet_pos));\n }\n \n if (min_pet_dist >= 3) {\n block_options.push_back({min_pet_dist, block_chars[d]});\n }\n }\n }\n \n if (!block_options.empty()) {\n // Choose block position farthest from closest pet\n sort(block_options.begin(), block_options.end(), greater>());\n best_action = block_options[0].second;\n }\n // If no good block, move away from closest pet\n else {\n int closest_pet = grid.findClosestPet(human_pos);\n if (closest_pet != -1) {\n Point& pet_pos = grid.pet_positions[closest_pet];\n \n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n int dist_before = grid.distance(human_pos, pet_pos);\n int dist_after = grid.distance(move_pos, pet_pos);\n \n if (dist_after > dist_before) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n }\n }\n }\n }\n // Mid to late game strategy (turns 100-300)\n else {\n // Calculate current score\n double current_score = grid.calculateSimpleScore(human_pos);\n best_score = current_score;\n best_action = '.';\n \n // Try moving in each direction\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n double score = grid.calculateSimpleScore(move_pos);\n \n // Small bonus for moving toward other humans (encourage grouping)\n double grouping_bonus = 0;\n for (int j = 0; j < grid.M; j++) {\n if (j != i) {\n int dist_before = grid.distance(human_pos, grid.human_positions[j]);\n int dist_after = grid.distance(move_pos, grid.human_positions[j]);\n if (dist_after < dist_before && dist_after > 0) {\n grouping_bonus += 0.01 / dist_after;\n }\n }\n }\n \n score += grouping_bonus;\n \n if (score > best_score) {\n best_score = score;\n best_action = dir_chars[d];\n }\n }\n }\n \n // Consider blocking if in mid-game (turns 100-250)\n if (turn < 250) {\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Temporarily block to evaluate\n bool original = grid.impassable[block_pos.x][block_pos.y];\n grid.impassable[block_pos.x][block_pos.y] = true;\n \n double score = grid.calculateSimpleScore(human_pos);\n \n // Check if this isolates us too much\n set area = grid.getReachableArea(human_pos);\n \n grid.impassable[block_pos.x][block_pos.y] = original;\n \n // Only block if score improves and area is reasonable\n if (score > best_score * 1.05 && area.size() > 20) {\n best_score = score;\n best_action = block_chars[d];\n }\n }\n }\n }\n }\n \n // Fallback: if no decision made, stay put\n if (best_action == '.') {\n // Last resort: try to move to any adjacent passable square\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n \n actions += best_action;\n }\n \n // Validate actions to ensure no human is moving to a square that another human is blocking\n string validated_actions = actions; // Keep as string, not vector\n for (int i = 0; i < grid.M; i++) {\n if (actions[i] >= 'A' && actions[i] <= 'Z') { // If human is moving\n Point& human_pos = grid.human_positions[i];\n Point move_pos = human_pos;\n \n // Calculate where this human would move\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == actions[i]) {\n move_pos.x += dirs[d].first;\n move_pos.y += dirs[d].second;\n break;\n }\n }\n \n // Check if any other human is blocking this square in this turn\n bool blocked_by_other = false;\n for (int j = 0; j < grid.M; j++) {\n if (i != j && actions[j] >= 'a' && actions[j] <= 'z') { // If another human is blocking\n Point& other_human_pos = grid.human_positions[j];\n Point block_pos = other_human_pos;\n \n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == actions[j]) {\n block_pos.x += dirs[d].first;\n block_pos.y += dirs[d].second;\n break;\n }\n }\n \n if (block_pos == move_pos) {\n blocked_by_other = true;\n break;\n }\n }\n }\n \n // If the move is blocked by another human's action, cancel the move\n if (blocked_by_other) {\n validated_actions[i] = '.'; // Stay instead of moving\n }\n }\n }\n \n // Apply all actions simultaneously\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char action = validated_actions[i];\n \n // Update human position if moving\n if (action >= 'A' && action <= 'Z') {\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == action) {\n // Double-check that the destination is still passable\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n human_pos = move_pos;\n } else {\n // If somehow still invalid, stay put\n // This is a safety check\n }\n break;\n }\n }\n }\n // Update grid if blocking\n else if (action >= 'a' && action <= 'z') {\n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == action) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n // Double-check we can still block here\n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n grid.impassable[block_pos.x][block_pos.y] = true;\n }\n break;\n }\n }\n }\n // If '.', do nothing\n }\n \n // Output actions (now validated_actions is a string, so this works)\n cout << validated_actions << endl;\n cout.flush();\n \n // Read pet movements\n for (int i = 0; i < grid.N; i++) {\n string move;\n cin >> move;\n \n // Update pet position based on movement\n for (char c : move) {\n int dir_index = -1;\n for (int j = 0; j < 4; j++) {\n if (dir_chars[j] == c) {\n dir_index = j;\n break;\n }\n }\n if (dir_index != -1) {\n grid.pet_positions[i].x += dirs[dir_index].first;\n grid.pet_positions[i].y += dirs[dir_index].second;\n }\n }\n }\n \n turn++;\n }\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors for U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nstruct State {\n int x, y, dist;\n string path;\n State(int x, int y, int dist, string path) : x(x), y(y), dist(dist), path(path) {}\n};\n\nbool isValid(int x, int y) {\n return x >= 0 && x < 20 && y >= 0 && y < 20;\n}\n\n// BFS to find shortest path\nstring findShortestPath(int sx, int sy, int tx, int ty, \n const vector& h_walls, \n const vector& v_walls) {\n if (sx == tx && sy == ty) {\n return \"\";\n }\n \n queue q;\n vector> visited(20, vector(20, false));\n \n q.push(State(sx, sy, 0, \"\"));\n visited[sx][sy] = true;\n \n while (!q.empty()) {\n State curr = q.front();\n q.pop();\n \n if (curr.x == tx && curr.y == ty) {\n return curr.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = curr.x + dx[d];\n int ny = curr.y + dy[d];\n \n if (!isValid(nx, ny) || visited[nx][ny]) continue;\n \n // Check walls - '1' means wall exists, '0' means no wall\n bool canMove = false;\n if (d == 0) { // Up\n if (curr.x > 0 && v_walls[curr.x-1][curr.y] == '0') {\n canMove = true;\n }\n } else if (d == 1) { // Down\n if (curr.x < 19 && v_walls[curr.x][curr.y] == '0') {\n canMove = true;\n }\n } else if (d == 2) { // Left\n if (curr.y > 0 && h_walls[curr.x][curr.y-1] == '0') {\n canMove = true;\n }\n } else if (d == 3) { // Right\n if (curr.y < 19 && h_walls[curr.x][curr.y] == '0') {\n canMove = true;\n }\n }\n \n if (canMove) {\n visited[nx][ny] = true;\n q.push(State(nx, ny, curr.dist + 1, curr.path + dir_char[d]));\n }\n }\n }\n \n return \"\";\n}\n\n// Calculate optimal repetitions with improved probability model\nint calculateOptimalRepetitions(double p, int pathLength, bool isSmallLoop = false) {\n if (pathLength == 0) return 1;\n if (pathLength > 200) return 1;\n \n int maxReps = 200 / pathLength;\n if (maxReps == 0) return 1;\n \n // Cap at reasonable values\n maxReps = min(maxReps, 12);\n \n // Calculate probability of success with different repetition counts\n // More sophisticated model considering that not all moves need to be remembered\n double successProbPerAttempt;\n \n if (isSmallLoop) {\n // For paths with small loops, be more conservative\n if (p < 0.3) {\n successProbPerAttempt = pow(1.0 - p, pathLength * 0.6);\n } else if (p < 0.4) {\n successProbPerAttempt = pow(1.0 - p, pathLength * 0.8);\n } else {\n successProbPerAttempt = pow(1.0 - p, pathLength);\n }\n } else {\n // Standard path\n if (p < 0.2) {\n // Very low p, very high success probability\n successProbPerAttempt = pow(1.0 - p, pathLength * 0.3);\n } else if (p < 0.3) {\n // Low p, high success probability\n successProbPerAttempt = pow(1.0 - p, pathLength * 0.5);\n } else if (p < 0.4) {\n // Medium p, medium success probability\n successProbPerAttempt = pow(1.0 - p, pathLength * 0.7);\n } else {\n // High p, more conservative\n successProbPerAttempt = pow(1.0 - p, pathLength * 0.9);\n }\n }\n \n // Ensure reasonable bounds\n successProbPerAttempt = max(0.02, min(0.99, successProbPerAttempt));\n \n int bestReps = 1;\n double bestExpectedScore = 0.0;\n \n for (int reps = 1; reps <= maxReps; reps++) {\n double expectedScore = 0.0;\n \n // Calculate expected score with geometric distribution\n for (int k = 1; k <= reps; k++) {\n double probSuccessOnKth = pow(1.0 - successProbPerAttempt, k-1) * successProbPerAttempt;\n int arrivalTime = k * pathLength;\n if (arrivalTime < 401) {\n expectedScore += probSuccessOnKth * (401.0 - arrivalTime);\n }\n }\n \n // Add diminishing returns bonus for higher repetitions\n double bonus = 1.0 + log(reps) * 0.1;\n expectedScore *= bonus;\n \n if (expectedScore > bestExpectedScore) {\n bestExpectedScore = expectedScore;\n bestReps = reps;\n }\n }\n \n // Special handling for edge cases\n if (p >= 0.45 && pathLength <= 40) {\n bestReps = min(maxReps, max(bestReps, 5));\n } else if (p >= 0.4 && pathLength <= 40) {\n bestReps = min(maxReps, max(bestReps, 4));\n } else if (p >= 0.35 && pathLength <= 40) {\n bestReps = min(maxReps, max(bestReps, 3));\n }\n \n // For very short paths, be more aggressive\n if (pathLength <= 15 && p >= 0.25) {\n bestReps = min(maxReps, max(bestReps, 6));\n }\n \n return max(1, bestReps);\n}\n\n// Create robust path with intelligent repetition and loop optimization\nstring createRobustPath(int sx, int sy, int tx, int ty,\n const vector& h_walls, \n const vector& v_walls,\n double p) {\n string shortestPath = findShortestPath(sx, sy, tx, ty, h_walls, v_walls);\n if (shortestPath.empty()) return \"\";\n \n int pathLength = shortestPath.length();\n if (pathLength == 0) return \"\";\n \n // For high p and short paths, try to add small loops for robustness\n if (p >= 0.4 && pathLength <= 35) {\n // Try to find the best small loop from target\n string bestLoop = \"\";\n int bestLoopScore = -1;\n \n // Try single step loops (move and back)\n for (int d = 0; d < 4; d++) {\n int nx = tx + dx[d];\n int ny = ty + dy[d];\n \n bool canMoveOut = false, canMoveBack = false;\n \n // Check if we can move out\n if (d == 0 && tx > 0 && v_walls[tx-1][ty] == '0') canMoveOut = true;\n else if (d == 1 && tx < 19 && v_walls[tx][ty] == '0') canMoveOut = true;\n else if (d == 2 && ty > 0 && h_walls[tx][ty-1] == '0') canMoveOut = true;\n else if (d == 3 && ty < 19 && h_walls[tx][ty] == '0') canMoveOut = true;\n \n if (canMoveOut) {\n // Check if we can move back\n int backDir = (d + 2) % 4; // opposite direction\n if (backDir == 0 && nx > 0 && v_walls[nx-1][ny] == '0') canMoveBack = true;\n else if (backDir == 1 && nx < 19 && v_walls[nx][ny] == '0') canMoveBack = true;\n else if (backDir == 2 && ny > 0 && h_walls[nx][ny-1] == '0') canMoveBack = true;\n else if (backDir == 3 && ny < 19 && h_walls[nx][ny] == '0') canMoveBack = true;\n \n if (canMoveBack) {\n string loop = string(1, dir_char[d]) + string(1, dir_char[backDir]);\n \n // Calculate if this loop improves expected score\n string pathWithLoop = shortestPath + loop;\n int newLength = pathWithLoop.length();\n int reps = calculateOptimalRepetitions(p, newLength, true);\n \n if (newLength * reps <= 200) {\n // This is a viable option\n int score = reps * (401 - newLength); // Simplified score estimation\n if (score > bestLoopScore) {\n bestLoopScore = score;\n bestLoop = loop;\n }\n }\n }\n }\n }\n \n if (!bestLoop.empty()) {\n string pathWithLoop = shortestPath + bestLoop;\n int reps = calculateOptimalRepetitions(p, pathWithLoop.length(), true);\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += pathWithLoop;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n return result;\n }\n }\n \n // For medium p and medium paths, try a different strategy: create a path that passes through target multiple times\n if (p >= 0.3 && p < 0.45 && pathLength >= 20 && pathLength <= 60) {\n // See if we can find a path that goes beyond target and comes back\n // This creates more opportunities to hit the target\n \n // Simple approach: continue past target in one direction and come back\n for (int d = 0; d < 4; d++) {\n int nx = tx + dx[d];\n int ny = ty + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMoveOut = false;\n if (d == 0 && tx > 0 && v_walls[tx-1][ty] == '0') canMoveOut = true;\n else if (d == 1 && tx < 19 && v_walls[tx][ty] == '0') canMoveOut = true;\n else if (d == 2 && ty > 0 && h_walls[tx][ty-1] == '0') canMoveOut = true;\n else if (d == 3 && ty < 19 && h_walls[tx][ty] == '0') canMoveOut = true;\n \n if (canMoveOut) {\n // Try to find path back to target from (nx, ny)\n string returnPath = findShortestPath(nx, ny, tx, ty, h_walls, v_walls);\n if (!returnPath.empty()) {\n string extendedPath = shortestPath + string(1, dir_char[d]) + returnPath;\n int reps = calculateOptimalRepetitions(p, extendedPath.length());\n \n if (extendedPath.length() * reps <= 200) {\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += extendedPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n return result;\n }\n }\n }\n }\n }\n }\n \n // Default: use simple repetition with optimized count\n int reps = calculateOptimalRepetitions(p, pathLength);\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += shortestPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n \n return result;\n}\n\nint main() {\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n // Read horizontal walls: 20 rows, each with 19 characters\n vector h_walls(20);\n for (int i = 0; i < 20; i++) {\n cin >> h_walls[i];\n }\n \n // Read vertical walls: 19 rows, each with 20 characters\n vector v_walls(19);\n for (int i = 0; i < 19; i++) {\n cin >> v_walls[i];\n }\n \n // Create robust path\n string finalPath = createRobustPath(si, sj, ti, tj, h_walls, v_walls, p);\n \n // Comprehensive fallback strategy\n if (finalPath.empty() || finalPath.length() > 200) {\n string shortestPath = findShortestPath(si, sj, ti, tj, h_walls, v_walls);\n \n if (shortestPath.empty() && (si != ti || sj != tj)) {\n // Multi-stage greedy approach\n string greedyPath = \"\";\n int cx = si, cy = sj;\n \n // Stage 1: Try to get closer to target\n while ((cx != ti || cy != tj) && greedyPath.length() < 200) {\n // Calculate manhattan distance for each possible move\n vector> options; // (distance, direction)\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d];\n int ny = cy + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMove = false;\n if (d == 0 && cx > 0 && v_walls[cx-1][cy] == '0') canMove = true;\n else if (d == 1 && cx < 19 && v_walls[cx][cy] == '0') canMove = true;\n else if (d == 2 && cy > 0 && h_walls[cx][cy-1] == '0') canMove = true;\n else if (d == 3 && cy < 19 && h_walls[cx][cy] == '0') canMove = true;\n \n if (canMove) {\n int manhattan = abs(nx - ti) + abs(ny - tj);\n options.push_back({manhattan, d});\n }\n }\n }\n \n if (options.empty()) break;\n \n // Sort by manhattan distance (ascending)\n sort(options.begin(), options.end());\n int bestDir = options[0].second;\n \n greedyPath += dir_char[bestDir];\n cx += dx[bestDir];\n cy += dy[bestDir];\n }\n \n shortestPath = greedyPath;\n }\n \n if (!shortestPath.empty()) {\n int reps = calculateOptimalRepetitions(p, max(1, (int)shortestPath.length()));\n finalPath = \"\";\n for (int i = 0; i < reps; i++) {\n finalPath += shortestPath;\n if (finalPath.length() >= 200) {\n finalPath = finalPath.substr(0, 200);\n break;\n }\n }\n }\n }\n \n // Final safety checks\n if (finalPath.empty()) {\n // Create a simple back-and-forth path for basic redundancy\n finalPath = \"RL\";\n int repetitions = min(100, 200 / 2);\n string temp = \"\";\n for (int i = 0; i < repetitions; i++) {\n temp += finalPath;\n }\n finalPath = temp;\n }\n \n if (finalPath.length() > 200) {\n finalPath = finalPath.substr(0, 200);\n }\n \n cout << finalPath << endl;\n \n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction constants: left, up, right, down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// Transition table: to[tile_type][entry_direction] = exit_direction or -1 if invalid\nconst int to[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\nconst int N = 30;\n\nclass Solution {\nprivate:\n vector> grid;\n vector> rotations;\n mt19937 rng;\n chrono::steady_clock::time_point start_time;\n \npublic:\n Solution(const vector>& input_grid) : grid(input_grid), rng(random_device{}()) {\n rotations = vector>(N, vector(N, 0));\n }\n \n // Get the actual tile type after rotation\n int get_rotated_tile(int i, int j) const {\n int base_type = grid[i][j];\n int rot = rotations[i][j] % 4;\n \n // Tile mapping after rotation\n if (base_type <= 3) {\n return (base_type + rot) % 4;\n } else if (base_type <= 5) {\n if (base_type == 4) {\n if (rot % 2 == 0) return 4;\n else return 5;\n } else { // base_type == 5\n if (rot % 2 == 0) return 5;\n else return 4;\n }\n } else { // base_type >= 6\n if (base_type == 6) {\n if (rot % 2 == 0) return 6;\n else return 7;\n } else { // base_type == 7\n if (rot % 2 == 0) return 7;\n else return 6;\n }\n }\n }\n \n // Calculate the length of a loop starting from (i, j) with direction d\n int calculate_loop_length(int si, int sj, int sd) const {\n int i = si, j = sj, d = sd;\n int length = 0;\n int max_steps = N * N;\n \n for (int step = 0; step < max_steps; step++) {\n int tile_type = get_rotated_tile(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0; // Line is broken\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= N || j < 0 || j >= N) return 0; // Out of bounds\n \n d = (d2 + 2) % 4; // Direction to the previous tile\n length++;\n \n // Check if we returned to start\n if (i == si && j == sj && d == sd) {\n return length;\n }\n }\n \n return 0;\n }\n \n // Find all loops and return their lengths\n vector find_all_loops() const {\n vector loop_lengths;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions and directions in this loop as visited\n int ci = i, cj = j, cd = d;\n int steps = 0;\n int max_steps = N * N;\n \n do {\n if (steps >= max_steps) break;\n visited[ci][cj][cd] = true;\n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n if (d2 == -1) break;\n \n ci += di[d2];\n cj += dj[d2];\n \n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n cd = (d2 + 2) % 4;\n steps++;\n } while (!(ci == i && cj == j && cd == d) && steps < max_steps);\n \n loop_lengths.push_back(length);\n }\n }\n }\n \n // Early termination if running out of time\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1800) {\n return loop_lengths;\n }\n }\n \n // Sort in descending order\n sort(loop_lengths.rbegin(), loop_lengths.rend());\n return loop_lengths;\n }\n \n // Calculate score: L1 * L2 (0 if less than 2 loops)\n long long calculate_score() const {\n vector loops = find_all_loops();\n if (loops.size() < 2) return 0;\n return (long long)loops[0] * loops[1];\n }\n \n // Simple smart initialization - create potential circular patterns\n void smart_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Create a spiral-like pattern\n if (i < N/2 && j < N/2) {\n // Top-left quadrant: curve down-right\n if (grid[i][j] <= 3) rotations[i][j] = 2;\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = (i % 2 == 0) ? 0 : 1;\n } else if (i < N/2 && j >= N/2) {\n // Top-right quadrant: curve down-left\n if (grid[i][j] <= 3) rotations[i][j] = 3;\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = (i % 2 == 0) ? 0 : 1;\n } else if (i >= N/2 && j < N/2) {\n // Bottom-left quadrant: curve up-right\n if (grid[i][j] <= 3) rotations[i][j] = 1;\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = (i % 2 == 0) ? 0 : 1;\n } else {\n // Bottom-right quadrant: curve up-left\n if (grid[i][j] <= 3) rotations[i][j] = 0;\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = (i % 2 == 0) ? 0 : 1;\n }\n }\n }\n }\n \n // Random initialization\n void random_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n rotations[i][j] = uniform_int_distribution(0, 3)(rng);\n }\n }\n }\n \n // Try to improve solution using simulated annealing\n void simulated_annealing() {\n long long current_score = calculate_score();\n long long best_score_in_run = current_score;\n vector> best_rotations_in_run = rotations;\n \n const double initial_temp = 800.0;\n const double final_temp = 10.0;\n const double cooling_rate = 0.9993;\n \n double temp = initial_temp;\n int stagnation_count = 0;\n \n while (temp > final_temp) {\n // Pick a random tile to modify\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n \n // Save current rotation\n int old_rot = rotations[i][j];\n \n // Try a new rotation\n int new_rot;\n if (uniform_real_distribution(0.0, 1.0)(rng) < 0.7) {\n // Try adjacent rotation (incremental change)\n new_rot = (old_rot + 1 + uniform_int_distribution(0, 2)(rng)) % 4;\n } else {\n // Try completely random rotation\n new_rot = uniform_int_distribution(0, 3)(rng);\n }\n \n rotations[i][j] = new_rot;\n \n // Calculate new score\n long long new_score = calculate_score();\n \n // Accept or reject based on simulated annealing\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n stagnation_count = 0;\n } else if (new_score == current_score) {\n // Accept with some probability to explore\n if (uniform_real_distribution(0.0, 1.0)(rng) < 0.2) {\n accept = true;\n }\n stagnation_count++;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n stagnation_count++;\n } else {\n stagnation_count++;\n }\n }\n \n if (!accept) {\n // Revert\n rotations[i][j] = old_rot;\n } else {\n current_score = new_score;\n if (current_score > best_score_in_run) {\n best_score_in_run = current_score;\n best_rotations_in_run = rotations;\n stagnation_count = 0;\n }\n }\n \n // Adaptive cooling - cool faster if stagnating\n if (stagnation_count > 30) {\n temp *= 0.95;\n stagnation_count = 0;\n } else {\n temp *= cooling_rate;\n }\n \n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1900) {\n break;\n }\n }\n \n // Restore the best solution found in this run\n if (best_score_in_run > current_score) {\n rotations = best_rotations_in_run;\n }\n }\n \n // Optimize with a simpler approach\n void optimize() {\n start_time = chrono::steady_clock::now();\n long long best_score = 0;\n vector> best_rotations = rotations;\n \n // Try smart initialization first\n smart_init();\n simulated_annealing();\n \n long long score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n \n // Check time and try random initialization if time permits\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1200) {\n random_init();\n simulated_annealing();\n \n score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n // One more quick refinement with smart init if time permits\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1500) {\n smart_init();\n // Run a shorter simulated annealing\n long long current_score = calculate_score();\n const double initial_temp = 500.0;\n const double final_temp = 20.0;\n const double cooling_rate = 0.999;\n \n double temp = initial_temp;\n int stagnation_count = 0;\n \n while (temp > final_temp) {\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n \n int old_rot = rotations[i][j];\n int new_rot = uniform_int_distribution(0, 3)(rng);\n \n rotations[i][j] = new_rot;\n long long new_score = calculate_score();\n \n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n }\n }\n \n if (!accept) {\n rotations[i][j] = old_rot;\n } else {\n current_score = new_score;\n }\n \n if (stagnation_count > 20) {\n temp *= 0.9;\n stagnation_count = 0;\n } else {\n temp *= cooling_rate;\n }\n \n // Check time limit\n auto now = chrono::steady_clock::now();\n auto ms = chrono::duration_cast(now - start_time).count();\n if (ms > 1900) {\n break;\n }\n }\n \n score = calculate_score();\n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n rotations = best_rotations;\n }\n \n // Output the solution\n string get_output() {\n string result = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n result += char('0' + rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n // Read input\n vector> grid(N, vector(N));\n for (int i = 0; i < N; i++) {\n string line;\n cin >> line;\n for (int j = 0; j < N; j++) {\n grid[i][j] = line[j] - '0';\n }\n }\n \n // Create and optimize solution\n Solution solution(grid);\n solution.optimize();\n \n // Output result\n cout << solution.get_output() << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\nconst int opposite_dir[4] = {1, 0, 3, 2}; // Opposite of U,D,L,R\n\nstruct State {\n vector board;\n int empty_x, empty_y;\n string moves;\n int score;\n int potential_score;\n \n // Default constructor\n State() : empty_x(-1), empty_y(-1), score(0), potential_score(0) {}\n \n // Parameterized constructor\n State(const vector& b, int ex, int ey, const string& m = \"\") \n : board(b), empty_x(ex), empty_y(ey), moves(m) {\n calculateScores();\n }\n \n void calculateScores() {\n if (board.empty() || empty_x == -1) {\n score = 0;\n potential_score = 0;\n return;\n }\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n int total_potential = 0;\n \n // Calculate actual connected components\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n // Calculate potential connections (heuristic)\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0') continue;\n \n int tile_val = (board[i][j] >= 'a') ? (board[i][j] - 'a' + 10) : (board[i][j] - '0');\n \n // Potential down connection\n if ((tile_val & 8) && i + 1 < n && board[i+1][j] != '0') {\n int below_val = (board[i+1][j] >= 'a') ? (board[i+1][j] - 'a' + 10) : (board[i+1][j] - '0');\n if (below_val & 2) {\n total_potential++;\n }\n }\n \n // Potential right connection\n if ((tile_val & 4) && j + 1 < n && board[i][j+1] != '0') {\n int right_val = (board[i][j+1] >= 'a') ? (board[i][j+1] - 'a' + 10) : (board[i][j+1] - '0');\n if (right_val & 1) {\n total_potential++;\n }\n }\n }\n }\n \n score = max_component_size;\n potential_score = total_potential;\n }\n \n // Composite score for sorting\n long long getCompositeScore() const {\n // Focus on actual score first, then potential, then shorter paths\n return (long long)score * 1000000000LL + \n (long long)potential_score * 1000000LL - \n (long long)moves.size();\n }\n \n // Board hash for duplicate detection\n string getBoardHash() const {\n string hash = \"\";\n for (const auto& row : board) {\n hash += row;\n }\n return hash;\n }\n \n // Equality operator for State\n bool operator==(const State& other) const {\n if (board != other.board) return false;\n if (empty_x != other.empty_x) return false;\n if (empty_y != other.empty_y) return false;\n return true;\n }\n};\n\n// Calculate the score of a board configuration\nint calculateScore(const vector& board) {\n if (board.empty()) return 0;\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n}\n\n// Check if a move is valid\nbool isValidMove(int x, int y, int n) {\n return x >= 0 && x < n && y >= 0 && y < n;\n}\n\n// Enhanced beam search with restart capability\nstring solve(const vector& initial_board, int N, int T) {\n int empty_x = -1, empty_y = -1;\n \n // Find the empty space\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_board[i][j] == '0') {\n empty_x = i;\n empty_y = j;\n break;\n }\n }\n if (empty_x != -1) break;\n }\n \n // If we're already at max score, return empty string\n int current_score = calculateScore(initial_board);\n if (current_score == N*N-1) {\n return \"\";\n }\n \n // Calculate beam width based on N\n size_t BEAM_WIDTH = 0;\n if (N <= 7) {\n BEAM_WIDTH = 200;\n } else if (N <= 9) {\n BEAM_WIDTH = 150;\n } else {\n BEAM_WIDTH = 100;\n }\n \n // Track best solution found so far\n string best_solution = \"\";\n int best_score = current_score;\n \n // Use multiple attempts with different random seeds\n const int MAX_ATTEMPTS = 3;\n auto start_time = chrono::steady_clock::now();\n const int time_limit_ms = 2800;\n \n for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {\n // Reset beam for this attempt\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(State(initial_board, empty_x, empty_y, \"\"));\n \n // Track if we're making progress\n int last_improvement_step = 0;\n size_t current_beam_width = BEAM_WIDTH;\n \n // Try to find a good solution within T moves\n for (int step = 0; step < T && !beam.empty(); step++) {\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n // Check time limit\n if (elapsed_ms > time_limit_ms) {\n break;\n }\n \n // Fix: Cast to size_t for reserve\n size_t reserve_size = min(current_beam_width * 3, static_cast(500));\n vector next_beam;\n next_beam.reserve(reserve_size);\n \n // Track seen states to avoid duplicates\n unordered_set seen_states;\n \n for (auto& state : beam) {\n // Try all possible moves\n for (int dir = 0; dir < 4; dir++) {\n int new_x = state.empty_x + dx[dir];\n int new_y = state.empty_y + dy[dir];\n \n // Skip if move is invalid\n if (!isValidMove(new_x, new_y, N)) continue;\n \n // Skip if would undo previous move (anti-loop)\n if (state.moves.size() > 0 && \n dir == opposite_dir[state.moves.back() - 'U']) continue;\n \n // Make a copy and apply the move\n vector new_board = state.board;\n int new_empty_x = state.empty_x;\n int new_empty_y = state.empty_y;\n string new_moves = state.moves + dir_char[dir];\n \n // Apply the move\n swap(new_board[new_empty_x][new_empty_y], new_board[new_x][new_y]);\n new_empty_x = new_x;\n new_empty_y = new_y;\n \n // Create new state\n State new_state(new_board, new_empty_x, new_empty_y, new_moves);\n \n // If we found a full tree, return immediately\n if (new_state.score == N*N-1) {\n return new_state.moves;\n }\n \n // Update best solution if this is better\n if (new_state.score > best_score) {\n best_score = new_state.score;\n best_solution = new_state.moves;\n last_improvement_step = step;\n }\n \n // Check for duplicates\n string board_hash = new_state.getBoardHash();\n if (seen_states.find(board_hash) == seen_states.end()) {\n seen_states.insert(board_hash);\n next_beam.push_back(new_state);\n }\n }\n }\n \n // If no new states, break\n if (next_beam.empty()) break;\n \n // Sort by composite score (descending)\n sort(next_beam.begin(), next_beam.end(), [](const State& a, const State& b) {\n return a.getCompositeScore() > b.getCompositeScore();\n });\n \n // Keep only the best states with diversity\n if (next_beam.size() > current_beam_width) {\n size_t keep_by_score = static_cast(current_beam_width * 0.7);\n vector selected_beam;\n \n for (size_t i = 0; i < keep_by_score && i < next_beam.size(); i++) {\n selected_beam.push_back(next_beam[i]);\n }\n \n // Add diverse states\n if (selected_beam.size() < current_beam_width && next_beam.size() > keep_by_score) {\n random_device rd;\n mt19937 gen(rd() + attempt * 1000); // Different seed for each attempt\n vector remaining_indices;\n \n for (size_t i = keep_by_score; i < next_beam.size(); i++) {\n remaining_indices.push_back(i);\n }\n \n // Shuffle remaining indices\n shuffle(remaining_indices.begin(), remaining_indices.end(), gen);\n \n // Add diverse states\n for (size_t i = 0; i < remaining_indices.size() && selected_beam.size() < current_beam_width; i++) {\n // Add with a probability based on potential score\n double selection_prob = 0.7 + (double)next_beam[remaining_indices[i]].potential_score / (N * N * 2);\n if (uniform_real_distribution(0, 1)(gen) < selection_prob) {\n selected_beam.push_back(next_beam[remaining_indices[i]]);\n }\n if (selected_beam.size() >= current_beam_width) break;\n }\n \n // If still not enough, fill with best remaining\n for (size_t i = 0; i < remaining_indices.size() && selected_beam.size() < current_beam_width; i++) {\n selected_beam.push_back(next_beam[remaining_indices[i]]);\n if (selected_beam.size() >= current_beam_width) break;\n }\n \n next_beam = selected_beam;\n } else {\n next_beam.resize(current_beam_width);\n }\n }\n \n // Adaptive beam width based on progress\n if (step - last_improvement_step > 15) {\n // Increase exploration if stuck\n current_beam_width = min(static_cast(250), current_beam_width + 20);\n } else if (best_score > N*N*0.8) {\n // Focus on refinement if we have a good solution\n current_beam_width = min(current_beam_width, static_cast(50));\n }\n \n // Periodic forced exploration every 10 steps\n if (step > 0 && step % 10 == 0 && next_beam.size() > 10) {\n random_device rd;\n mt19937 gen(rd() + step * 100 + attempt * 1000);\n \n // Randomly shuffle a few states to encourage exploration\n size_t shuffle_count = min(static_cast(5), next_beam.size() / 5);\n for (size_t i = 0; i < shuffle_count; i++) {\n size_t idx1 = uniform_int_distribution(0, next_beam.size() - 1)(gen);\n size_t idx2 = uniform_int_distribution(0, next_beam.size() - 1)(gen);\n if (idx1 != idx2) {\n swap(next_beam[idx1], next_beam[idx2]);\n }\n }\n }\n \n beam = next_beam;\n \n // Early termination if we have an excellent solution\n if (best_score == N*N-1) {\n return best_solution;\n }\n }\n \n // If we found a perfect solution in this attempt, return it\n if (best_score == N*N-1) {\n return best_solution;\n }\n \n // If time is running out, don't start another attempt\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > time_limit_ms * 0.8 && attempt < MAX_ATTEMPTS - 1) {\n // Reduce beam width for remaining attempts\n BEAM_WIDTH = max(static_cast(50), BEAM_WIDTH / 2);\n }\n }\n \n // Return the best solution found\n if (!best_solution.empty() && best_score > current_score) {\n return best_solution;\n }\n \n // Fallback: return best from final beam\n return \"\";\n}\n\nint main() {\n int N, T;\n cin >> N >> T;\n \n vector board(N);\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n string solution = solve(board, N, T);\n cout << solution << endl;\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n long long x, y;\n Point() : x(0), y(0) {}\n Point(long long x, long long y) : x(x), y(y) {}\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n \n long long cross(const Point& other) const {\n return x * other.y - y * other.x;\n }\n \n long long dot(const Point& other) const {\n return x * other.x + y * other.y;\n }\n \n long long dist2() const {\n return x * x + y * y;\n }\n \n double dist() const {\n return sqrt(x * x + y * y);\n }\n};\n\nstruct Line {\n Point p1, p2;\n Line() {}\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\n// Ensure point coordinates are within bounds\nPoint clampPoint(Point p) {\n const long long MIN_VAL = -1000000000;\n const long long MAX_VAL = 1000000000;\n p.x = max(MIN_VAL, min(MAX_VAL, p.x));\n p.y = max(MIN_VAL, min(MAX_VAL, p.y));\n return p;\n}\n\n// Check which side of the line a point is on\n// Returns: 1 if on one side, -1 if on the other, 0 if on the line\nint side(const Point& p, const Line& line) {\n Point v1 = line.p2 - line.p1;\n Point v2 = p - line.p1;\n long long cross = v1.cross(v2);\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\n// Check if a point is strictly inside a region defined by lines\n// Each line defines a half-plane, and we need to be on the correct side of all lines\nbool isInside(const Point& p, const vector& lines, const vector& sides) {\n for (int i = 0; i < lines.size(); i++) {\n int s = side(p, lines[i]);\n if (s != sides[i]) return false;\n }\n return true;\n}\n\n// Try to find a line that separates a group of strawberries from others\nLine findSeparatingLine(const vector& strawberries, const vector& group, const vector& existingLines) {\n // Simple approach: try to find a line that roughly separates the group from others\n if (group.size() == 0) {\n return Line(Point(0, 0), Point(1, 0));\n }\n \n // Calculate centroid of group\n Point centroid(0, 0);\n for (int i : group) {\n centroid.x += strawberries[i].x;\n centroid.y += strawberries[i].y;\n }\n centroid.x /= group.size();\n centroid.y /= group.size();\n \n // Calculate centroid of other strawberries\n vector others;\n for (int i = 0; i < strawberries.size(); i++) {\n if (find(group.begin(), group.end(), i) == group.end()) {\n others.push_back(i);\n }\n }\n \n if (others.empty()) {\n // If no others, just use a line near the group\n Point p1(centroid.x - 1, centroid.y - 1);\n Point p2(centroid.x + 1, centroid.y + 1);\n return Line(clampPoint(p1), clampPoint(p2));\n }\n \n Point otherCentroid(0, 0);\n for (int i : others) {\n otherCentroid.x += strawberries[i].x;\n otherCentroid.y += strawberries[i].y;\n }\n otherCentroid.x /= others.size();\n otherCentroid.y /= others.size();\n \n // Line perpendicular to the line connecting centroids\n Point dir = otherCentroid - centroid;\n Point perp(-dir.y, dir.x);\n \n // Make sure the points are integers and within bounds\n Point p1(centroid.x + perp.x, centroid.y + perp.y);\n Point p2(centroid.x - perp.x, centroid.y - perp.y);\n \n // Scale to make sure they're far enough apart but still within bounds\n if (p1.dist2() < 100) {\n // Scale but ensure we don't go out of bounds\n long long scale = 1000;\n // Check if scaling would exceed bounds\n if (abs(p1.x * scale) > 1000000000 || abs(p1.y * scale) > 1000000000) {\n scale = 1;\n }\n p1.x *= scale;\n p1.y *= scale;\n p2.x *= scale;\n p2.y *= scale;\n }\n \n // Ensure bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n return Line(p1, p2);\n}\n\n// Calculate distance between two points\ndouble distance(const Point& a, const Point& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\n// Try to improve a line to minimize strawberries on it\nLine improveLine(const Line& line, const vector& strawberries, const vector& otherLines) {\n Line bestLine = line;\n int bestOnLine = strawberries.size();\n \n // Try small perturbations within bounds\n for (int dx1 = -1; dx1 <= 1; dx1++) {\n for (int dy1 = -1; dy1 <= 1; dy1++) {\n for (int dx2 = -1; dx2 <= 1; dx2++) {\n for (int dy2 = -1; dy2 <= 1; dy2++) {\n Point newP1(line.p1.x + dx1, line.p1.y + dy1);\n Point newP2(line.p2.x + dx2, line.p2.y + dy2);\n \n // Clamp to bounds\n newP1 = clampPoint(newP1);\n newP2 = clampPoint(newP2);\n \n // Skip if points are the same\n if (newP1.x == newP2.x && newP1.y == newP2.y) {\n // Make them different\n if (newP2.x < 1000000000) newP2.x += 1;\n else if (newP2.x > -1000000000) newP2.x -= 1;\n else if (newP2.y < 1000000000) newP2.y += 1;\n else newP2.y -= 1;\n }\n \n Line newLine(newP1, newP2);\n \n // Calculate score: minimize strawberries on line\n int onLine = 0;\n for (const Point& s : strawberries) {\n if (side(s, newLine) == 0) {\n onLine++;\n }\n }\n \n // Prefer lines with fewer strawberries on them\n if (onLine < bestOnLine) {\n bestOnLine = onLine;\n bestLine = newLine;\n }\n }\n }\n }\n }\n \n return bestLine;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n cin >> N >> K;\n \n vector a(10);\n for (int i = 0; i < 10; i++) {\n cin >> a[i];\n }\n \n vector strawberries(N);\n for (int i = 0; i < N; i++) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n \n // We'll use a greedy approach to create pieces of desired sizes\n vector lines;\n vector used(N, false);\n \n // First, try to create single strawberry pieces\n for (int d = 0; d < 10; d++) {\n if (a[d] == 0) continue;\n \n // Target: create a[d] pieces with d+1 strawberries each\n int targetCount = a[d];\n int strawberriesPerPiece = d + 1;\n \n for (int piece = 0; piece < targetCount && lines.size() < K; piece++) {\n // Find a group of strawberriesPerPiece strawberries that are close to each other\n vector group;\n \n // Find unused strawberries\n vector unused;\n for (int i = 0; i < N; i++) {\n if (!used[i]) {\n unused.push_back(i);\n }\n }\n \n if (unused.size() < strawberriesPerPiece) {\n // Not enough unused strawberries, skip\n break;\n }\n \n // Use a simple greedy approach: pick the first available strawberries\n for (int i = 0; i < strawberriesPerPiece && i < unused.size(); i++) {\n group.push_back(unused[i]);\n used[unused[i]] = true;\n }\n \n // If we need to isolate this group, add a line\n if (strawberriesPerPiece < N && !group.empty()) {\n // Find a line that separates this group from others (if possible)\n Line separatingLine = findSeparatingLine(strawberries, group, lines);\n \n // Try to improve the line to avoid cutting through strawberries\n separatingLine = improveLine(separatingLine, strawberries, lines);\n \n lines.push_back(separatingLine);\n \n // Stop if we've reached the limit\n if (lines.size() >= K) break;\n }\n }\n }\n \n // If we have remaining cuts, try to add random lines that might improve the partition\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution dis(-1000000000, 1000000000);\n \n while (lines.size() < K) {\n // Generate a random line\n Point p1(dis(gen), dis(gen));\n Point p2(dis(gen), dis(gen));\n \n // Clamp to ensure within bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n Line line(p1, p2);\n \n // Improve the line\n line = improveLine(line, strawberries, lines);\n \n lines.push_back(line);\n }\n \n // Output the solution\n cout << lines.size() << \"\\n\";\n for (const Line& line : lines) {\n cout << line.p1.x << \" \" << line.p1.y << \" \" << line.p2.x << \" \" << line.p2.y << \"\\n\";\n }\n \n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n \n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n \n bool operator!=(const Point& other) const {\n return !(*this == other);\n }\n \n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n};\n\nclass RectJoinSolver {\nprivate:\n int N, M;\n int center;\n vector> hasDot;\n vector> hasHorizontalEdge; // hasHorizontalEdge[x][y] = true if edge from (x,y) to (x+1,y) exists\n vector> hasVerticalEdge; // hasVerticalEdge[x][y] = true if edge from (x,y) to (x,y+1) exists\n vector initialDots;\n vector> operations;\n \n high_resolution_clock::time_point startTime;\n const double timeLimit = 4.0;\n \n // Calculate weight of a point\n double getWeight(int x, int y) {\n return (x - center) * (x - center) + (y - center) * (y - center) + 1;\n }\n \n // Check if point is on the grid\n bool isValidPoint(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n \n // Check if we're running out of time\n bool isTimeExceeded() {\n auto currentTime = high_resolution_clock::now();\n auto duration = duration_cast(currentTime - startTime);\n return duration.count() > timeLimit * 1000;\n }\n \n // Get all points on a horizontal edge from (x1,y) to (x2,y)\n vector getHorizontalEdgePoints(int x1, int x2, int y) {\n vector points;\n int minX = min(x1, x2);\n int maxX = max(x1, x2);\n for (int x = minX; x <= maxX; x++) {\n points.push_back(Point(x, y));\n }\n return points;\n }\n \n // Get all points on a vertical edge from (x,y1) to (x,y2)\n vector getVerticalEdgePoints(int x, int y1, int y2) {\n vector points;\n int minY = min(y1, y2);\n int maxY = max(y1, y2);\n for (int y = minY; y <= maxY; y++) {\n points.push_back(Point(x, y));\n }\n return points;\n }\n \n // Check if the four points form a valid axis-aligned rectangle when connected in order\n bool isValidAxisAlignedRectangleInOrder(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n // Check if consecutive points form right angles and parallel sides\n \n // Check p1->p2->p3 forms a right angle\n bool p1p2_horizontal = (p1.y == p2.y);\n bool p1p2_vertical = (p1.x == p2.x);\n bool p2p3_horizontal = (p2.y == p3.y);\n bool p2p3_vertical = (p2.x == p3.x);\n \n // Must be axis-aligned\n if (!p1p2_horizontal && !p1p2_vertical) return false;\n if (!p2p3_horizontal && !p2p3_vertical) return false;\n \n // Must form a right angle (perpendicular)\n if ((p1p2_horizontal && !p2p3_vertical) || (p1p2_vertical && !p2p3_horizontal)) {\n return false;\n }\n \n // Check p2->p3->p4 forms a right angle\n bool p3p4_horizontal = (p3.y == p4.y);\n bool p3p4_vertical = (p3.x == p4.x);\n \n if (!p3p4_horizontal && !p3p4_vertical) return false;\n \n if ((p2p3_horizontal && !p3p4_vertical) || (p2p3_vertical && !p3p4_horizontal)) {\n return false;\n }\n \n // Check p3->p4->p1 forms a right angle\n bool p4p1_horizontal = (p4.y == p1.y);\n bool p4p1_vertical = (p4.x == p1.x);\n \n if (!p4p1_horizontal && !p4p1_vertical) return false;\n \n if ((p3p4_horizontal && !p4p1_vertical) || (p3p4_vertical && !p4p1_horizontal)) {\n return false;\n }\n \n // Check p4->p1->p2 forms a right angle\n if ((p4p1_horizontal && !p1p2_vertical) || (p4p1_vertical && !p1p2_horizontal)) {\n return false;\n }\n \n // Check if it closes properly (p4 connects to p1)\n if (!((p4.x == p1.x && p4.y == p1.y) || \n (p4.x == p1.x || p4.y == p1.y))) {\n return false;\n }\n \n // Verify opposite sides are equal length (Manhattan distance)\n int len_p1p2 = abs(p1.x - p2.x) + abs(p1.y - p2.y);\n int len_p3p4 = abs(p3.x - p4.x) + abs(p3.y - p4.y);\n if (len_p1p2 != len_p3p4) return false;\n \n int len_p2p3 = abs(p2.x - p3.x) + abs(p2.y - p3.y);\n int len_p4p1 = abs(p4.x - p1.x) + abs(p4.y - p1.y);\n if (len_p2p3 != len_p4p1) return false;\n \n return true;\n }\n \n // Get all points on the perimeter of a rectangle defined by 4 points in order\n vector getPerimeterPointsInOrder(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n vector perimeter;\n set seen;\n \n // Add points from edge p1->p2\n if (p1.y == p2.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p1.x, p2.x, p1.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p1.x == p2.x) { // vertical\n vector edge = getVerticalEdgePoints(p1.x, p1.y, p2.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n // Add points from edge p2->p3\n if (p2.y == p3.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p2.x, p3.x, p2.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p2.x == p3.x) { // vertical\n vector edge = getVerticalEdgePoints(p2.x, p2.y, p3.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n // Add points from edge p3->p4\n if (p3.y == p4.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p3.x, p4.x, p3.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p3.x == p4.x) { // vertical\n vector edge = getVerticalEdgePoints(p3.x, p3.y, p4.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n // Add points from edge p4->p1\n if (p4.y == p1.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p4.x, p1.x, p4.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p4.x == p1.x) { // vertical\n vector edge = getVerticalEdgePoints(p4.x, p4.y, p1.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n return perimeter;\n }\n \n // Check if the rectangle has no other dots on perimeter except the 4 corners\n bool hasNoOtherDotsOnPerimeter(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n vector perimeter = getPerimeterPointsInOrder(p1, p2, p3, p4);\n set corners = {p1, p2, p3, p4};\n \n for (const Point& p : perimeter) {\n if (corners.find(p) == corners.end() && hasDot[p.x][p.y]) {\n return false;\n }\n }\n \n return true;\n }\n \n // Check if the rectangle edges don't overlap with existing edges\n bool hasNoSharedEdges(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n // Check edge p1->p2\n if (p1.y == p2.y) { // horizontal\n int minY = p1.y;\n int minX = min(p1.x, p2.x);\n int maxX = max(p1.x, p2.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p1.x == p2.x) { // vertical\n int minX = p1.x;\n int minY = min(p1.y, p2.y);\n int maxY = max(p1.y, p2.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n // Check edge p2->p3\n if (p2.y == p3.y) { // horizontal\n int minY = p2.y;\n int minX = min(p2.x, p3.x);\n int maxX = max(p2.x, p3.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p2.x == p3.x) { // vertical\n int minX = p2.x;\n int minY = min(p2.y, p3.y);\n int maxY = max(p2.y, p3.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n // Check edge p3->p4\n if (p3.y == p4.y) { // horizontal\n int minY = p3.y;\n int minX = min(p3.x, p4.x);\n int maxX = max(p3.x, p4.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p3.x == p4.x) { // vertical\n int minX = p3.x;\n int minY = min(p3.y, p4.y);\n int maxY = max(p3.y, p4.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n // Check edge p4->p1\n if (p4.y == p1.y) { // horizontal\n int minY = p4.y;\n int minX = min(p4.x, p1.x);\n int maxX = max(p4.x, p1.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p4.x == p1.x) { // vertical\n int minX = p4.x;\n int minY = min(p4.y, p1.y);\n int maxY = max(p4.y, p1.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n return true;\n }\n \n // Mark the edges of the rectangle as drawn\n void markRectangleEdges(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n // Mark edge p1->p2\n if (p1.y == p2.y) { // horizontal\n int minY = p1.y;\n int minX = min(p1.x, p2.x);\n int maxX = max(p1.x, p2.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p1.x == p2.x) { // vertical\n int minX = p1.x;\n int minY = min(p1.y, p2.y);\n int maxY = max(p1.y, p2.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n \n // Mark edge p2->p3\n if (p2.y == p3.y) { // horizontal\n int minY = p2.y;\n int minX = min(p2.x, p3.x);\n int maxX = max(p2.x, p3.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p2.x == p3.x) { // vertical\n int minX = p2.x;\n int minY = min(p2.y, p3.y);\n int maxY = max(p2.y, p3.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n \n // Mark edge p3->p4\n if (p3.y == p4.y) { // horizontal\n int minY = p3.y;\n int minX = min(p3.x, p4.x);\n int maxX = max(p3.x, p4.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p3.x == p4.x) { // vertical\n int minX = p3.x;\n int minY = min(p3.y, p4.y);\n int maxY = max(p3.y, p4.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n \n // Mark edge p4->p1\n if (p4.y == p1.y) { // horizontal\n int minY = p4.y;\n int minX = min(p4.x, p1.x);\n int maxX = max(p4.x, p1.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p4.x == p1.x) { // vertical\n int minX = p4.x;\n int minY = min(p4.y, p1.y);\n int maxY = max(p4.y, p1.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n }\n \n // Get all existing dots\n vector getAllDots() {\n vector dots;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (hasDot[x][y]) {\n dots.push_back(Point(x, y));\n }\n }\n }\n return dots;\n }\n \n // Try all possible rectangles with the new point as p1\n vector findValidRectangle(Point newPoint, const vector& existingDots) {\n int n = existingDots.size();\n \n // Try all permutations of 3 existing dots as p2, p3, p4\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j == i) continue;\n for (int k = 0; k < n; k++) {\n if (k == i || k == j) continue;\n \n Point p2 = existingDots[i];\n Point p3 = existingDots[j];\n Point p4 = existingDots[k];\n \n // Check if these 4 points form a valid rectangle in order\n if (isValidAxisAlignedRectangleInOrder(newPoint, p2, p3, p4)) {\n // Check if no other dots on perimeter\n if (hasNoOtherDotsOnPerimeter(newPoint, p2, p3, p4)) {\n // Check if no shared edges\n if (hasNoSharedEdges(newPoint, p2, p3, p4)) {\n // Found a valid rectangle\n return {p2, p3, p4};\n }\n }\n }\n }\n }\n }\n \n return {}; // No valid rectangle found\n }\n\npublic:\n RectJoinSolver(int n, int m, const vector& initial) : N(n), M(m), initialDots(initial) {\n center = (N - 1) / 2;\n hasDot.assign(N, vector(N, false));\n hasHorizontalEdge.assign(N, vector(N, false));\n hasVerticalEdge.assign(N, vector(N, false));\n \n // Mark initial dots\n for (const Point& p : initialDots) {\n hasDot[p.x][p.y] = true;\n }\n \n startTime = high_resolution_clock::now();\n }\n \n void solve() {\n while (!isTimeExceeded()) {\n vector existingDots = getAllDots();\n bool madeProgress = false;\n \n // Create a list of candidate positions, sorted by weight (descending)\n vector> candidates;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (!hasDot[x][y]) {\n double weight = getWeight(x, y);\n candidates.push_back({weight, Point(x, y)});\n }\n }\n }\n \n // Sort by weight descending\n sort(candidates.begin(), candidates.end(), \n [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n // Try candidates in order of weight\n for (const auto& candidate : candidates) {\n if (isTimeExceeded()) break;\n \n Point newPoint = candidate.second;\n vector validPoints = findValidRectangle(newPoint, existingDots);\n \n if (!validPoints.empty()) {\n // Double check before committing\n if (isValidAxisAlignedRectangleInOrder(newPoint, validPoints[0], validPoints[1], validPoints[2]) &&\n hasNoOtherDotsOnPerimeter(newPoint, validPoints[0], validPoints[1], validPoints[2]) &&\n hasNoSharedEdges(newPoint, validPoints[0], validPoints[1], validPoints[2])) {\n \n // Place the dot\n hasDot[newPoint.x][newPoint.y] = true;\n \n // Mark the edges as drawn\n markRectangleEdges(newPoint, validPoints[0], validPoints[1], validPoints[2]);\n \n // Record operation\n vector opCoords = {\n newPoint.x, newPoint.y,\n validPoints[0].x, validPoints[0].y,\n validPoints[1].x, validPoints[1].y,\n validPoints[2].x, validPoints[2].y\n };\n operations.push_back(opCoords);\n \n madeProgress = true;\n break; // Restart with updated board\n }\n }\n }\n \n if (!madeProgress) {\n break; // No more valid moves\n }\n }\n }\n \n void output() {\n cout << operations.size() << endl;\n for (const auto& op : operations) {\n for (int i = 0; i < 8; i++) {\n if (i > 0) cout << \" \";\n cout << op[i];\n }\n cout << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n \n vector initialDots;\n for (int i = 0; i < M; i++) {\n int x, y;\n cin >> x >> y;\n initialDots.push_back(Point(x, y));\n }\n \n RectJoinSolver solver(N, M, initialDots);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\n\n// Directions: F=0 (forward/up), B=1 (backward/down), L=2 (left), R=3 (right)\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'F', 'B', 'L', 'R'};\n\nclass CandyBox {\nprivate:\n vector> grid;\n vector flavor_count;\n vector future_flavors;\n int current_step;\n \npublic:\n CandyBox(const vector& flavors) : grid(N, vector(N, 0)), flavor_count(4, 0), future_flavors(flavors), current_step(0) {}\n \n // Place candy at position (calculated from 1-indexed empty cell number)\n void placeCandy(int pos, int flavor) {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == 0) {\n count++;\n if (count == pos) {\n grid[i][j] = flavor;\n flavor_count[flavor]++;\n return;\n }\n }\n }\n }\n }\n \n // Simulate tilting in a direction\n vector> simulateTilt(int dir) {\n vector> new_grid = grid;\n \n // Create movement order based on direction\n vector> cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (new_grid[i][j] != 0) {\n cells.push_back({i, j});\n }\n }\n }\n \n // Sort cells based on direction to process in correct order\n if (dir == 0) { // Forward (up): process from top to bottom\n sort(cells.begin(), cells.end());\n } else if (dir == 1) { // Backward (down): process from bottom to top\n sort(cells.begin(), cells.end(), greater>());\n } else if (dir == 2) { // Left: process from left to right\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second < b.second;\n return a.first < b.first;\n });\n } else { // Right: process from right to left\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second > b.second;\n return a.first < b.first;\n });\n }\n \n // Move each candy\n vector> temp_grid(N, vector(N, 0));\n for (auto& cell : cells) {\n int x = cell.first, y = cell.second;\n int flavor = new_grid[x][y];\n \n // Skip if already processed (moved)\n if (flavor == 0) continue;\n \n int nx = x, ny = y;\n while (true) {\n int tx = nx + dx[dir];\n int ty = ny + dy[dir];\n if (tx < 0 || tx >= N || ty < 0 || ty >= N || temp_grid[tx][ty] != 0) {\n break;\n }\n nx = tx;\n ny = ty;\n }\n temp_grid[nx][ny] = flavor;\n }\n \n return temp_grid;\n }\n \n // Calculate score for a given grid state\n long long calculateScoreForGrid(const vector>& test_grid, const vector& test_counts) {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = test_grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && test_grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)test_counts[i] * test_counts[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Calculate a bonus score for potential connectivity\n double calculateConnectivityBonus(const vector>& test_grid, int current_flavor) {\n double bonus = 0.0;\n \n // For each candy of the current flavor, check if it's adjacent to another candy of the same flavor\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] == current_flavor) {\n // Check 4 directions for adjacent candies of the same flavor\n int adjacent_count = 0;\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d][0];\n int nj = j + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && test_grid[ni][nj] == current_flavor) {\n adjacent_count++;\n }\n }\n // Add bonus for each adjacency (small bonus to avoid overriding actual score)\n bonus += adjacent_count * 0.1;\n }\n }\n }\n \n return bonus;\n }\n \n // Calculate distance to nearest same-flavor candy\n double calculateDistanceBonus(const vector>& test_grid, int current_flavor) {\n double bonus = 0.0;\n \n // For each candy of the current flavor\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] == current_flavor) {\n // Find distance to nearest other candy of the same flavor\n int min_dist = INT_MAX;\n bool found_other = false;\n \n for (int ni = 0; ni < N; ni++) {\n for (int nj = 0; nj < N; nj++) {\n if (test_grid[ni][nj] == current_flavor && (ni != i || nj != j)) {\n int dist = abs(ni - i) + abs(nj - j);\n if (dist < min_dist) {\n min_dist = dist;\n found_other = true;\n }\n }\n }\n }\n \n // If found another candy of the same flavor, add bonus based on proximity\n if (found_other) {\n bonus += 1.0 / (1.0 + min_dist); // Closer = higher bonus\n }\n }\n }\n }\n \n return bonus;\n }\n \n // Apply tilt to actual grid\n void applyTilt(int dir) {\n grid = simulateTilt(dir);\n }\n \n // Get current grid state\n vector> getGrid() const {\n return grid;\n }\n \n // Get flavor counts\n vector getFlavorCount() const {\n return flavor_count;\n }\n \n // Update current step\n void updateStep(int step) {\n current_step = step;\n }\n};\n\nint main() {\n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n CandyBox box(flavors);\n \n for (int t = 0; t < 100; t++) {\n int pos;\n cin >> pos;\n \n // Update current step\n box.updateStep(t);\n \n // Place the candy\n box.placeCandy(pos, flavors[t]);\n \n // If it's the last candy, we can choose any direction (it won't matter)\n if (t == 99) {\n cout << \"F\" << endl;\n cout.flush();\n continue;\n }\n \n // Try all 4 directions and pick the best\n double best_combined_score = -1e18;\n int best_dir = 0;\n \n vector current_counts = box.getFlavorCount();\n \n for (int dir = 0; dir < 4; dir++) {\n // Simulate tilt in this direction\n vector> test_grid = box.simulateTilt(dir);\n \n // Calculate base score\n long long base_score = box.calculateScoreForGrid(test_grid, current_counts);\n \n // Calculate small bonuses for improved connectivity\n double connectivity_bonus = box.calculateConnectivityBonus(test_grid, flavors[t]);\n double distance_bonus = box.calculateDistanceBonus(test_grid, flavors[t]);\n \n // Combine scores with very small weights for bonuses\n double combined_score = base_score + connectivity_bonus + distance_bonus * 0.5;\n \n // Choose the direction with the highest combined score\n if (combined_score > best_combined_score) {\n best_combined_score = combined_score;\n best_dir = dir;\n }\n }\n \n // Apply the best tilt\n box.applyTilt(best_dir);\n \n // Output the direction\n cout << dir_char[best_dir] << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass Graph {\npublic:\n int N;\n vector> adj;\n \n Graph(int n) : N(n), adj(n, vector(n, false)) {}\n \n void add_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = true;\n adj[j][i] = true;\n }\n }\n \n void remove_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = false;\n adj[j][i] = false;\n }\n }\n \n bool has_edge(int i, int j) const {\n return adj[i][j];\n }\n \n string to_string() const {\n string s;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s += (adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n static Graph from_string(int n, const string& s) {\n Graph g(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (idx < (int)s.length() && s[idx] == '1') {\n g.add_edge(i, j);\n }\n idx++;\n }\n }\n return g;\n }\n \n vector get_degree_sequence() const {\n vector degrees(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) degrees[i]++;\n }\n }\n sort(degrees.begin(), degrees.end());\n return degrees;\n }\n \n int count_edges() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) count++;\n }\n }\n return count;\n }\n \n int count_triangles() const {\n int triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n triangles++;\n }\n }\n }\n }\n }\n return triangles;\n }\n \n // Count number of 4-cliques\n int count_4cliques() const {\n int cliques = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n for (int k = j + 1; k < N; k++) {\n for (int l = k + 1; l < N; l++) {\n if (adj[i][j] && adj[i][k] && adj[i][l] && \n adj[j][k] && adj[j][l] && adj[k][l]) {\n cliques++;\n }\n }\n }\n }\n }\n return cliques;\n }\n \n // Count connected components\n int count_components() const {\n vector visited(N, false);\n int components = 0;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n components++;\n // BFS\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n }\n }\n return components;\n }\n \n // Get component sizes\n vector get_component_sizes() const {\n vector visited(N, false);\n vector sizes;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n int size = 0;\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n size++;\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n sizes.push_back(size);\n }\n }\n sort(sizes.begin(), sizes.end());\n return sizes;\n }\n \n // Check for specific signature patterns\n int get_signature_id() const {\n if (N < 5) return 0;\n \n // Look for patterns in the first 5 vertices\n int patterns = 0;\n \n // Check for triangle on vertices 0,1,2\n bool has_triangle_012 = (adj[0][1] && adj[1][2] && adj[2][0]);\n \n // Check for 4-cycle on 0,1,2,3\n bool has_4cycle_0123 = false;\n if (N >= 4) {\n has_4cycle_0123 = (adj[0][1] && adj[1][2] && adj[2][3] && adj[3][0] && \n !adj[0][2] && !adj[1][3]);\n }\n \n // Check for star on 0,1,2,3\n bool has_star_0123 = false;\n if (N >= 4) {\n has_star_0123 = (adj[0][1] && adj[0][2] && adj[0][3] && \n !adj[1][2] && !adj[1][3] && !adj[2][3]);\n }\n \n // Check for 4-clique on 0,1,2,3\n bool has_4clique_0123 = false;\n if (N >= 4) {\n has_4clique_0123 = (adj[0][1] && adj[0][2] && adj[0][3] && \n adj[1][2] && adj[1][3] && adj[2][3]);\n }\n \n // Check for edge between 3,4\n bool has_edge_34 = (N >= 5) ? adj[3][4] : false;\n \n // Assign signature based on patterns\n if (has_triangle_012 && !has_4cycle_0123 && !has_star_0123) {\n patterns = 0;\n } else if (has_4cycle_0123 && !has_star_0123 && !has_4clique_0123) {\n patterns = 1;\n } else if (has_star_0123 && !has_4clique_0123) {\n patterns = 2;\n } else if (has_4clique_0123) {\n patterns = 3;\n } else if (has_triangle_012 && has_edge_34) {\n patterns = 4;\n } else {\n patterns = 5; // default\n }\n \n return patterns;\n }\n};\n\n// Features for graph classification\nstruct GraphFeatures {\n int edge_count;\n vector degree_sequence;\n int triangle_count;\n int four_clique_count;\n int component_count;\n vector component_sizes;\n double avg_degree;\n int max_degree;\n int min_degree;\n int signature_id;\n int N;\n \n GraphFeatures(const Graph& g) {\n N = g.N;\n edge_count = g.count_edges();\n degree_sequence = g.get_degree_sequence();\n triangle_count = g.count_triangles();\n four_clique_count = g.count_4cliques();\n component_count = g.count_components();\n component_sizes = g.get_component_sizes();\n avg_degree = (N > 0) ? 2.0 * edge_count / N : 0.0;\n signature_id = g.get_signature_id();\n \n if (!degree_sequence.empty()) {\n max_degree = *max_element(degree_sequence.begin(), degree_sequence.end());\n min_degree = *min_element(degree_sequence.begin(), degree_sequence.end());\n } else {\n max_degree = min_degree = 0;\n }\n }\n};\n\n// Calculate distance between two feature sets\ndouble distance(const GraphFeatures& f1, const GraphFeatures& f2, double epsilon) {\n double d = 0.0;\n \n // Use simpler, more direct weighting\n \n // Edge count (always reliable as fallback)\n d += abs(f1.edge_count - f2.edge_count) * 0.5;\n \n // Degree sequence (very robust)\n for (int i = 0; i < (int)min(f1.degree_sequence.size(), f2.degree_sequence.size()); i++) {\n d += abs(f1.degree_sequence[i] - f2.degree_sequence[i]) * 1.0;\n }\n \n // Triangle count (very robust)\n d += abs(f1.triangle_count - f2.triangle_count) * 3.0;\n \n // 4-clique count (extremely robust)\n d += abs(f1.four_clique_count - f2.four_clique_count) * 5.0;\n \n // Component count (extremely robust)\n d += abs(f1.component_count - f2.component_count) * 4.0;\n \n // Component sizes (very robust)\n for (int i = 0; i < (int)min(f1.component_sizes.size(), f2.component_sizes.size()); i++) {\n d += abs(f1.component_sizes[i] - f2.component_sizes[i]) * 2.0;\n }\n \n // Signature ID (critical for identification)\n if (f1.signature_id != f2.signature_id) {\n d += 10.0; // Heavy penalty for different signatures\n }\n \n // For high noise, add some emphasis on edge count as fallback\n if (epsilon > 0.3) {\n d += abs(f1.edge_count - f2.edge_count) * 1.0; // Double weight for edge count\n }\n \n return d;\n}\n\n// Generate a highly distinctive graph for index k\nGraph generate_distinctive_graph(int N, int k, int M) {\n Graph g(N);\n \n // Choose base structure based on k\n int base_type = k % 6;\n int density_group = (k / 6) % 5; // 5 different density groups\n \n // Set target edge count based on density group\n double densities[] = {0.2, 0.35, 0.5, 0.65, 0.8};\n double target_density = densities[density_group];\n int target_edges = (int)(target_density * N * (N - 1) / 2);\n \n // Generate base structure\n if (base_type == 0) {\n // Random graph with triangle bias\n mt19937 rng(k * 12345);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (g.count_edges() < target_edges && (rng() % 100) < (target_density * 100)) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (base_type == 1) {\n // Regular graph approximation\n int degree = (int)(target_density * (N - 1));\n for (int i = 0; i < N; i++) {\n vector candidates;\n for (int j = 0; j < N; j++) {\n if (i != j && !g.has_edge(i, j) && g.count_edges() < target_edges) {\n candidates.push_back(j);\n }\n }\n mt19937 rng(k * 6789 + i);\n shuffle(candidates.begin(), candidates.end(), rng);\n for (int j = 0; j < min(degree, (int)candidates.size()) && g.count_edges() < target_edges; j++) {\n g.add_edge(i, candidates[j]);\n }\n }\n }\n else if (base_type == 2) {\n // Small world model\n // Start with ring\n for (int i = 0; i < N; i++) {\n g.add_edge(i, (i + 1) % N);\n }\n // Add random shortcuts\n mt19937 rng(k * 2468);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N; j++) {\n if (!g.has_edge(i, j) && (rng() % 3) == 0) {\n g.add_edge(i, j);\n if (g.count_edges() >= target_edges) break;\n }\n }\n }\n }\n else if (base_type == 3) {\n // Scale-free like (preferential attachment)\n if (N > 1) {\n g.add_edge(0, 1);\n mt19937 rng(k * 1357);\n for (int i = 2; i < N && g.count_edges() < target_edges; i++) {\n vector candidates;\n for (int j = 0; j < i; j++) {\n int degree = 0;\n for (int l = 0; l < i; l++) {\n if (g.has_edge(j, l)) degree++;\n }\n for (int l = 0; l <= degree; l++) {\n candidates.push_back(j);\n }\n }\n if (!candidates.empty()) {\n shuffle(candidates.begin(), candidates.end(), rng);\n g.add_edge(i, candidates[0]);\n }\n }\n // Add more edges if needed\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 1; j < N; j++) {\n if (!g.has_edge(i, j) && (rng() % 4) == 0) {\n g.add_edge(i, j);\n if (g.count_edges() >= target_edges) break;\n }\n }\n }\n }\n }\n else if (base_type == 4) {\n // Modular graph (communities)\n int n_communities = 2 + (k % 3);\n int comm_size = N / n_communities;\n \n // Make communities dense\n for (int c = 0; c < n_communities; c++) {\n int start = c * comm_size;\n int end = (c == n_communities - 1) ? N : (c + 1) * comm_size;\n \n for (int i = start; i < end; i++) {\n for (int j = i + 1; j < end; j++) {\n if (g.count_edges() < target_edges * 0.8) {\n g.add_edge(i, j);\n }\n }\n }\n }\n \n // Add some between-community edges\n mt19937 rng(k * 9753);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 1; j < N; j++) {\n int comm_i = i / comm_size;\n int comm_j = j / comm_size;\n if (comm_i != comm_j && (rng() % 5) == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else { // base_type == 5\n // Tree-based with extra edges\n for (int i = 1; i < N; i++) {\n g.add_edge(i, (i - 1) / 2); // Binary tree\n }\n \n // Add extra edges\n mt19937 rng(k * 8642);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N; j++) {\n if (!g.has_edge(i, j) && (rng() % 3) == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n \n // Add signature on first 5 vertices (noise-resistant identifier)\n if (N >= 5) {\n int signature = k % 5;\n \n // Clear existing edges among first 5 vertices\n for (int i = 0; i < 5; i++) {\n for (int j = i + 1; j < 5; j++) {\n g.remove_edge(i, j);\n }\n }\n \n // Apply signature pattern\n if (signature == 0) {\n // Triangle on 0,1,2\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n }\n else if (signature == 1) {\n // 4-cycle on 0,1,2,3\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 3);\n g.add_edge(3, 0);\n }\n else if (signature == 2) {\n // Star on 0,1,2,3\n g.add_edge(0, 1);\n g.add_edge(0, 2);\n g.add_edge(0, 3);\n }\n else if (signature == 3) {\n // 4-clique on 0,1,2,3\n g.add_edge(0, 1);\n g.add_edge(0, 2);\n g.add_edge(0, 3);\n g.add_edge(1, 2);\n g.add_edge(1, 3);\n g.add_edge(2, 3);\n }\n else { // signature == 4\n // Triangle on 0,1,2 + edge 3,4\n g.add_edge(0, 1);\n g.add_edge(1, 2);\n g.add_edge(2, 0);\n g.add_edge(3, 4);\n }\n }\n \n // Adjust edge count if needed\n if (g.count_edges() < target_edges * 0.9) {\n // Add random edges\n mt19937 rng(k * 112233);\n vector> missing_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (!g.has_edge(i, j)) {\n missing_edges.push_back({i, j});\n }\n }\n }\n shuffle(missing_edges.begin(), missing_edges.end(), rng);\n for (auto& e : missing_edges) {\n if (g.count_edges() >= target_edges) break;\n g.add_edge(e.first, e.second);\n }\n }\n else if (g.count_edges() > target_edges * 1.1) {\n // Remove random edges (avoid removing signature edges)\n mt19937 rng(k * 332211);\n vector> existing_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (g.has_edge(i, j)) {\n // Don't include signature edges if possible\n if (i >= 5 || j >= 5) {\n existing_edges.push_back({i, j});\n }\n }\n }\n }\n shuffle(existing_edges.begin(), existing_edges.end(), rng);\n for (auto& e : existing_edges) {\n if (g.count_edges() <= target_edges) break;\n g.remove_edge(e.first, e.second);\n }\n }\n \n return g;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Choose N based on M and epsilon\n int N;\n \n // Base N on epsilon\n if (epsilon <= 0.1) {\n N = 20;\n } else if (epsilon <= 0.2) {\n N = 30;\n } else if (epsilon <= 0.3) {\n N = 40;\n } else {\n N = 50;\n }\n \n // Increase N for larger M\n if (M > 75) {\n N += 15;\n } else if (M > 50) {\n N += 10;\n } else if (M > 25) {\n N += 5;\n }\n \n // Ensure bounds\n N = max(20, min(80, N));\n \n cout << N << endl;\n \n // Generate M graphs\n vector graphs;\n vector features;\n \n for (int k = 0; k < M; k++) {\n Graph g = generate_distinctive_graph(N, k, M);\n graphs.push_back(g);\n features.push_back(GraphFeatures(g));\n \n // Output graph\n cout << g.to_string() << endl;\n cout.flush();\n }\n \n // Process 100 queries\n for (int k = 0; k < 100; k++) {\n string h_str;\n cin >> h_str;\n \n // Parse the graph\n Graph h = Graph::from_string(N, h_str);\n GraphFeatures h_features(h);\n \n // Find the closest graph\n int best_idx = 0;\n double min_dist = 1e15;\n \n // Special handling for high noise\n if (epsilon > 0.35) {\n // Use edge count as primary feature\n int h_edges = h.count_edges();\n int total_possible = N * (N - 1) / 2;\n \n // Find graph with closest edge count\n int best_diff = abs(features[0].edge_count - h_edges);\n best_idx = 0;\n \n for (int i = 1; i < M; i++) {\n int diff = abs(features[i].edge_count - h_edges);\n if (diff < best_diff) {\n best_diff = diff;\n best_idx = i;\n }\n }\n } else {\n // Use full feature set\n for (int i = 0; i < M; i++) {\n double dist = distance(h_features, features[i], epsilon);\n if (dist < min_dist) {\n min_dist = dist;\n best_idx = i;\n }\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#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// Graph representation\nstruct Edge {\n int u, v, w, id;\n Edge(int u = 0, int v = 0, int w = 0, int id = 0) : u(u), v(v), w(w), id(id) {}\n};\n\nclass Graph {\npublic:\n int n, m, d, k;\n vector edges;\n vector>> adj; // adjacency list: to, weight\n vector> coords;\n \n Graph(int n = 0, int m = 0, int d = 0, int k = 0) : n(n), m(m), d(d), k(k) {\n adj.resize(n + 1);\n }\n \n void addEdge(int u, int v, int w, int id) {\n edges.emplace_back(u, v, w, id);\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n // Calculate shortest distances from source using Dijkstra\n vector dijkstra(int source, const unordered_set& removed_edges = {}) {\n vector dist(n + 1, 1e18);\n priority_queue, vector>, greater>> pq;\n \n dist[source] = 0;\n pq.emplace(0, source);\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto [v, w] : adj[u]) {\n // Check if edge u-v is removed\n bool edge_removed = false;\n for (int eid : removed_edges) {\n Edge& e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n edge_removed = true;\n break;\n }\n }\n \n if (edge_removed) continue;\n \n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.emplace(dist[v], v);\n }\n }\n }\n \n return dist;\n }\n \n // Calculate frustration for a given day using minimal sampling\n double calculateFrustrationSampling(const vector>& original_apsp, \n const vector& edges_to_remove) {\n if (edges_to_remove.empty()) return 0.0;\n \n unordered_set remove_set(edges_to_remove.begin(), edges_to_remove.end());\n \n // Use fixed seed for consistency\n mt19937 gen(42);\n uniform_int_distribution<> vertex_dist(1, n);\n \n // Very small sample size\n int source_sample_size = min(10, n / 20);\n if (source_sample_size < 3) source_sample_size = 3;\n \n vector sources;\n for (int i = 0; i < source_sample_size; i++) {\n sources.push_back(vertex_dist(gen));\n }\n \n // Remove duplicates\n sort(sources.begin(), sources.end());\n sources.erase(unique(sources.begin(), sources.end()), sources.end());\n \n double frustration = 0.0;\n int pairs_count = 0;\n \n for (int source : sources) {\n // Run Dijkstra from source with removed edges\n auto dist = dijkstra(source, remove_set);\n \n // Very small target sample size\n int target_sample_size = min(5, n / 20);\n if (target_sample_size < 2) target_sample_size = 2;\n \n vector targets;\n for (int i = 0; i < target_sample_size; i++) {\n int target = vertex_dist(gen);\n if (target != source) {\n targets.push_back(target);\n }\n }\n \n // Remove duplicates\n sort(targets.begin(), targets.end());\n targets.erase(unique(targets.begin(), targets.end()), targets.end());\n \n for (int target : targets) {\n if (source == target) continue;\n \n long long new_dist = dist[target];\n if (new_dist >= 1e18) {\n new_dist = 1000000000; // Unreachable\n }\n \n long long orig_dist = original_apsp[source][target];\n if (orig_dist >= 1e18) orig_dist = 1000000000;\n \n frustration += (new_dist - orig_dist);\n pairs_count++;\n }\n }\n \n if (pairs_count == 0) return 0.0;\n \n // Scale up to approximate full frustration\n double avg_increase = frustration / pairs_count;\n return avg_increase;\n }\n};\n\n// Solution representation\nstruct Solution {\n vector schedule; // schedule[i] = day for edge i (1-indexed days)\n double total_frustration;\n Graph* graph;\n vector> original_apsp;\n \n Solution(Graph* g, const vector>& apsp) : graph(g), original_apsp(apsp) {\n schedule.resize(g->m);\n total_frustration = 0.0;\n }\n \n // Calculate total frustration for the entire schedule using sampling\n double calculateTotalFrustration() {\n double total = 0.0;\n \n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate frustration for each day\n for (int day = 1; day <= graph->d; day++) {\n double day_frustration = graph->calculateFrustrationSampling(original_apsp, edges_by_day[day]);\n total += day_frustration;\n }\n \n total_frustration = total / graph->d;\n return total_frustration;\n }\n \n // Get frustration as integer (rounded)\n long long getScore() {\n return llround(1000.0 * total_frustration);\n }\n \n // Calculate frustration change only for affected days after a swap\n double calculateDeltaFrustration(int idx1, int idx2, int new_day1, int new_day2) {\n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate current frustration for old days\n int old_day1 = schedule[idx1];\n int old_day2 = schedule[idx2];\n \n double old_f1 = 0.0, old_f2 = 0.0;\n if (old_day1 == old_day2) {\n vector old_edges = edges_by_day[old_day1];\n old_edges.push_back(idx1);\n old_edges.push_back(idx2);\n old_f1 = old_f2 = graph->calculateFrustrationSampling(original_apsp, old_edges);\n } else {\n vector old_edges1 = edges_by_day[old_day1];\n old_edges1.push_back(idx1);\n old_f1 = graph->calculateFrustrationSampling(original_apsp, old_edges1);\n \n vector old_edges2 = edges_by_day[old_day2];\n old_edges2.push_back(idx2);\n old_f2 = graph->calculateFrustrationSampling(original_apsp, old_edges2);\n }\n \n // Calculate new frustration for new days\n double new_f1 = 0.0, new_f2 = 0.0;\n if (new_day1 == new_day2) {\n vector new_edges = edges_by_day[new_day1];\n new_edges.push_back(idx1);\n new_edges.push_back(idx2);\n new_f1 = new_f2 = graph->calculateFrustrationSampling(original_apsp, new_edges);\n } else {\n vector new_edges1 = edges_by_day[new_day1];\n new_edges1.push_back(idx1);\n new_f1 = graph->calculateFrustrationSampling(original_apsp, new_edges1);\n \n vector new_edges2 = edges_by_day[new_day2];\n new_edges2.push_back(idx2);\n new_f2 = graph->calculateFrustrationSampling(original_apsp, new_edges2);\n }\n \n // Delta frustration\n double delta = (new_f1 + new_f2 - old_f1 - old_f2) / graph->d;\n \n return delta;\n }\n};\n\n// Simple but effective edge importance\nvector calculateSimpleEdgeImportance(Graph& graph) {\n vector importance(graph.m, 0.0);\n \n for (int i = 0; i < graph.m; i++) {\n int u = graph.edges[i].u;\n int v = graph.edges[i].v;\n int w = graph.edges[i].w;\n \n // Simple heuristic: weight divided by product of degrees\n // Lower degree vertices -> more critical edge\n int deg_u = graph.adj[u].size();\n int deg_v = graph.adj[v].size();\n \n importance[i] = (double)w / (deg_u + deg_v);\n }\n \n return importance;\n}\n\n// Light local search\nvoid lightLocalSearch(Solution& solution) {\n auto start_time = chrono::steady_clock::now();\n mt19937 gen(42);\n uniform_int_distribution<> edge_dist(0, solution.graph->m - 1);\n uniform_int_distribution<> day_dist(1, solution.graph->d);\n \n double current_score = solution.calculateTotalFrustration();\n int iterations = 0;\n int max_iterations = 1000; // Greatly reduced\n \n while (iterations < max_iterations) {\n // Check time limit frequently\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n if (elapsed > 2000) break; // Very conservative\n \n // Pick two random edges\n int idx1 = edge_dist(gen);\n int idx2 = edge_dist(gen);\n if (idx1 == idx2) {\n iterations++;\n continue;\n }\n \n int old_day1 = solution.schedule[idx1];\n int old_day2 = solution.schedule[idx2];\n \n // Try swapping their days\n int new_day1 = old_day2;\n int new_day2 = old_day1;\n \n // Check constraints\n bool valid = true;\n vector count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n iterations++;\n continue;\n }\n \n // Calculate delta (with minimal sampling)\n double delta = solution.calculateDeltaFrustration(idx1, idx2, new_day1, new_day2);\n \n // Always accept improvements\n if (delta < 0) {\n solution.schedule[idx1] = new_day1;\n solution.schedule[idx2] = new_day2;\n current_score += delta;\n }\n \n iterations++;\n }\n}\n\n// Generate initial solution\nSolution generateInitialSolution(Graph& graph, const vector>& original_apsp) {\n // Calculate edge importance\n auto importance = calculateSimpleEdgeImportance(graph);\n \n Solution solution(&graph, original_apsp);\n vector day_count(graph.d + 1, 0);\n \n // Create pairs of (importance, edge_id)\n vector> edge_importance;\n for (int i = 0; i < graph.m; i++) {\n edge_importance.emplace_back(importance[i], i);\n }\n \n // Sort by importance (descending)\n sort(edge_importance.rbegin(), edge_importance.rend());\n \n // Distribute edges using round-robin\n for (int i = 0; i < graph.m; i++) {\n int edge_id = edge_importance[i].second;\n \n // Use round-robin with fallback to least loaded day\n int day = (i % graph.d) + 1;\n int attempts = 0;\n \n while (day_count[day] >= graph.k && attempts < graph.d) {\n day = (day % graph.d) + 1;\n attempts++;\n }\n \n if (day_count[day] >= graph.k) {\n int min_day = 1;\n for (int j = 1; j <= graph.d; j++) {\n if (day_count[j] < day_count[min_day]) {\n min_day = j;\n }\n }\n day = min_day;\n }\n \n solution.schedule[edge_id] = day;\n day_count[day]++;\n }\n \n return solution;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n auto total_start_time = chrono::steady_clock::now();\n \n int n, m, d, k;\n cin >> n >> m >> d >> k;\n \n Graph graph(n, m, d, k);\n \n // Read edges\n for (int i = 0; i < m; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n graph.addEdge(u, v, w, i);\n }\n \n // Read coordinates\n for (int i = 0; i < n; i++) {\n int x, y;\n cin >> x >> y;\n graph.coords.emplace_back(x, y);\n }\n \n // Compute APSP for a minimal sample of vertices\n vector> original_apsp(n + 1, vector(n + 1, 1e18));\n \n // Sample only 10-20 vertices for APSP calculation\n mt19937 gen(42);\n uniform_int_distribution<> vertex_dist(1, n);\n \n vector sample_vertices;\n int sample_size = min(20, max(5, n / 30)); // Very small sample\n \n for (int i = 0; i < sample_size; i++) {\n sample_vertices.push_back(vertex_dist(gen));\n }\n \n // Remove duplicates\n sort(sample_vertices.begin(), sample_vertices.end());\n sample_vertices.erase(unique(sample_vertices.begin(), sample_vertices.end()), sample_vertices.end());\n \n // Calculate shortest paths for sampled vertices\n for (int source : sample_vertices) {\n auto dist = graph.dijkstra(source);\n for (int j = 1; j <= n; j++) {\n original_apsp[source][j] = dist[j];\n }\n }\n \n // Check time and generate initial solution\n auto after_apsp_time = chrono::steady_clock::now();\n auto elapsed_so_far = chrono::duration_cast(after_apsp_time - total_start_time).count();\n \n Solution solution = generateInitialSolution(graph, original_apsp);\n \n // Only do local search if we have enough time\n if (elapsed_so_far < 2000) {\n lightLocalSearch(solution);\n }\n \n // Output the solution\n for (int i = 0; i < m; i++) {\n if (i > 0) cout << \" \";\n cout << solution.schedule[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y, z;\n Point(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(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 bool operator==(const Point& other) const {\n return x == other.x && y == other.y && z == other.z;\n }\n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y, z + other.z);\n }\n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y, z - other.z);\n }\n};\n\nnamespace std {\n template<>\n struct hash {\n size_t operator()(const Point& p) const {\n return hash()(p.x) ^ hash()(p.y) ^ hash()(p.z);\n }\n };\n}\n\n// Directions for 6-connected (face-to-face) polycubes\nconst int dx[6] = {1, -1, 0, 0, 0, 0};\nconst int dy[6] = {0, 0, 1, -1, 0, 0};\nconst int dz[6] = {0, 0, 0, 0, 1, -1};\n\nint D;\nvector f1, r1, f2, r2;\n\nbool inBounds(const Point& p) {\n return p.x >= 0 && p.x < D && p.y >= 0 && p.y < D && p.z >= 0 && p.z < D;\n}\n\nvector getNeighbors(const Point& p) {\n vector neighbors;\n for (int i = 0; i < 6; i++) {\n Point np(p.x + dx[i], p.y + dy[i], p.z + dz[i]);\n if (inBounds(np)) {\n neighbors.push_back(np);\n }\n }\n return neighbors;\n}\n\nint toIndex(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nPoint fromIndex(int idx) {\n int x = idx / (D * D);\n int y = (idx % (D * D)) / D;\n int z = idx % D;\n return Point(x, y, z);\n}\n\nvector normalize(const vector& points) {\n if (points.empty()) return points;\n \n int min_x = points[0].x, min_y = points[0].y, min_z = points[0].z;\n for (const Point& p : points) {\n min_x = min(min_x, p.x);\n min_y = min(min_y, p.y);\n min_z = min(min_z, p.z);\n }\n \n vector normalized;\n for (const Point& p : points) {\n normalized.push_back(Point(p.x - min_x, p.y - min_y, p.z - min_z));\n }\n return normalized;\n}\n\nvector> generateRotations(const vector& shape) {\n if (shape.empty()) return {shape};\n \n vector normalized = normalize(shape);\n vector> rotations;\n \n // 24 rotation matrices for 3D\n int rotations_3d[24][9] = {\n {1,0,0, 0,1,0, 0,0,1}, {1,0,0, 0,0,-1, 0,1,0}, {1,0,0, 0,-1,0, 0,0,-1}, {1,0,0, 0,0,1, 0,-1,0},\n {-1,0,0, 0,-1,0, 0,0,1}, {-1,0,0, 0,0,-1, 0,-1,0}, {-1,0,0, 0,1,0, 0,0,-1}, {-1,0,0, 0,0,1, 0,1,0},\n {0,-1,0, 1,0,0, 0,0,1}, {0,0,1, 1,0,0, 0,1,0}, {0,1,0, -1,0,0, 0,0,1}, {0,0,-1, -1,0,0, 0,1,0},\n {0,1,0, 1,0,0, 0,0,-1}, {0,0,-1, -1,0,0, 0,-1,0}, {0,-1,0, -1,0,0, 0,0,-1}, {0,0,1, 1,0,0, 0,-1,0},\n {0,1,0, 0,0,1, 1,0,0}, {0,0,1, 0,-1,0, 1,0,0}, {0,-1,0, 0,0,-1, 1,0,0}, {0,0,-1, 0,1,0, 1,0,0},\n {0,-1,0, 0,0,1, -1,0,0}, {0,0,-1, 0,-1,0, -1,0,0}, {0,1,0, 0,0,-1, -1,0,0}, {0,0,1, 0,1,0, -1,0,0}\n };\n \n for (int i = 0; i < 24; i++) {\n vector rotated;\n for (const Point& p : normalized) {\n int nx = rotations_3d[i][0] * p.x + rotations_3d[i][1] * p.y + rotations_3d[i][2] * p.z;\n int ny = rotations_3d[i][3] * p.x + rotations_3d[i][4] * p.y + rotations_3d[i][5] * p.z;\n int nz = rotations_3d[i][6] * p.x + rotations_3d[i][7] * p.y + rotations_3d[i][8] * p.z;\n rotated.push_back(Point(nx, ny, nz));\n }\n rotations.push_back(normalize(rotated));\n }\n \n // Remove duplicates\n vector> unique_rotations;\n set> seen;\n \n for (auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (seen.find(rot_set) == seen.end()) {\n seen.insert(rot_set);\n unique_rotations.push_back(rot);\n }\n }\n \n return unique_rotations;\n}\n\nbool shapesMatch(const vector& shape1, const vector& shape2) {\n if (shape1.size() != shape2.size()) return false;\n \n auto rotations = generateRotations(shape1);\n auto normalized2 = normalize(shape2);\n set set2(normalized2.begin(), normalized2.end());\n \n for (const auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (rot_set == set2) {\n return true;\n }\n }\n \n return false;\n}\n\n// Check if a set of points forms a connected component\nbool isConnected(const vector& points) {\n if (points.empty() || points.size() == 1) return true;\n \n set pointSet(points.begin(), points.end());\n map visited;\n \n // Start BFS from the first point\n queue q;\n q.push(points[0]);\n visited[points[0]] = true;\n int visitedCount = 1;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (pointSet.find(neighbor) != pointSet.end() && !visited[neighbor]) {\n visited[neighbor] = true;\n visitedCount++;\n q.push(neighbor);\n }\n }\n }\n \n return visitedCount == points.size();\n}\n\n// Split a potentially disconnected set of points into connected components\nvector> splitIntoConnectedComponents(const vector& points) {\n if (points.empty()) return {};\n if (points.size() == 1) return {points};\n \n set pointSet(points.begin(), points.end());\n map visited;\n vector> components;\n \n for (const Point& p : points) {\n if (visited[p]) continue;\n \n // BFS to find connected component\n vector component;\n queue q;\n q.push(p);\n visited[p] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (pointSet.find(neighbor) != pointSet.end() && !visited[neighbor]) {\n visited[neighbor] = true;\n q.push(neighbor);\n }\n }\n }\n \n components.push_back(component);\n }\n \n return components;\n}\n\nint main() {\n cin >> D;\n f1.resize(D);\n r1.resize(D);\n f2.resize(D);\n r2.resize(D);\n \n for (int i = 0; i < D; i++) {\n cin >> f1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> f2[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r2[i];\n }\n \n // Determine which positions must be filled for each arrangement\n vector>> mustFill1(D, vector>(D, vector(D, false)));\n vector>> mustFill2(D, vector>(D, vector(D, false)));\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f1[z][x] == '1' && r1[z][y] == '1') {\n mustFill1[x][y][z] = true;\n }\n if (f2[z][x] == '1' && r2[z][y] == '1') {\n mustFill2[x][y][z] = true;\n }\n }\n }\n }\n \n // Identify common positions\n vector>> common(D, vector>(D, vector(D, false)));\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && mustFill2[x][y][z]) {\n common[x][y][z] = true;\n }\n }\n }\n }\n \n // Create blocks - prioritize common positions\n vector blockId1(D * D * D, 0);\n vector blockId2(D * D * D, 0);\n \n // First, create large blocks from common positions\n vector>> visitedCommon(D, vector>(D, vector(D, false)));\n int blockCount = 0;\n \n // Process common positions first\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (common[x][y][z] && !visitedCommon[x][y][z]) {\n // Grow a large block using BFS\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visitedCommon[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n // Look for neighbors in common positions\n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (!visitedCommon[neighbor.x][neighbor.y][neighbor.z] && \n common[neighbor.x][neighbor.y][neighbor.z]) {\n visitedCommon[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n // Assign to both arrangements\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId1[idx] = blockCount;\n blockId2[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n \n // Process remaining positions in arrangement 1\n vector>> visited1 = visitedCommon;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill1[x][y][z] && !visited1[x][y][z]) {\n // Try to extend existing blocks first\n bool extended = false;\n vector neighbors = getNeighbors(Point(x, y, z));\n \n // Group neighbors by block ID\n map> neighborBlocks;\n for (const Point& neighbor : neighbors) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (blockId1[nidx] != 0) {\n neighborBlocks[blockId1[nidx]].push_back(neighbor);\n }\n }\n \n // Try to extend to the largest neighboring block\n int bestBlockId = 0;\n int maxSize = 0;\n for (auto& kv : neighborBlocks) {\n if (kv.second.size() > 0) { // Prefer blocks with more adjacent cubes\n if (kv.second.size() > maxSize) {\n maxSize = kv.second.size();\n bestBlockId = kv.first;\n }\n }\n }\n \n if (bestBlockId != 0) {\n blockId1[toIndex(x, y, z)] = bestBlockId;\n visited1[x][y][z] = true;\n extended = true;\n }\n \n if (!extended) {\n // Create new block\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited1[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector localNeighbors = getNeighbors(curr);\n for (const Point& neighbor : localNeighbors) {\n if (!visited1[neighbor.x][neighbor.y][neighbor.z] && \n mustFill1[neighbor.x][neighbor.y][neighbor.z]) {\n visited1[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId1[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n }\n \n // Process remaining positions in arrangement 2\n vector>> visited2 = visitedCommon;\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (mustFill2[x][y][z] && !visited2[x][y][z]) {\n // Try to extend existing blocks first\n bool extended = false;\n vector neighbors = getNeighbors(Point(x, y, z));\n \n // Group neighbors by block ID\n map> neighborBlocks;\n for (const Point& neighbor : neighbors) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (blockId2[nidx] != 0) {\n neighborBlocks[blockId2[nidx]].push_back(neighbor);\n }\n }\n \n // Try to extend to the largest neighboring block\n int bestBlockId = 0;\n int maxSize = 0;\n for (auto& kv : neighborBlocks) {\n if (kv.second.size() > 0) {\n if (kv.second.size() > maxSize) {\n maxSize = kv.second.size();\n bestBlockId = kv.first;\n }\n }\n }\n \n if (bestBlockId != 0) {\n blockId2[toIndex(x, y, z)] = bestBlockId;\n visited2[x][y][z] = true;\n extended = true;\n }\n \n if (!extended) {\n // Create new block\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited2[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector localNeighbors = getNeighbors(curr);\n for (const Point& neighbor : localNeighbors) {\n if (!visited2[neighbor.x][neighbor.y][neighbor.z] && \n mustFill2[neighbor.x][neighbor.y][neighbor.z]) {\n visited2[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId2[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n }\n \n // Now ensure shape consistency and connectivity\n // For each block ID, extract its shape in both arrangements\n vector> shapes1(blockCount + 1);\n vector> shapes2(blockCount + 1);\n \n for (int i = 0; i < D * D * D; i++) {\n Point p = fromIndex(i);\n if (blockId1[i] != 0) {\n shapes1[blockId1[i]].push_back(p);\n }\n if (blockId2[i] != 0) {\n shapes2[blockId2[i]].push_back(p);\n }\n }\n \n // Verify connectivity and fix if needed\n vector finalBlockId1(D * D * D, 0);\n vector finalBlockId2(D * D * D, 0);\n int finalBlockCount = 0;\n vector blockRemapping(blockCount + 1, 0);\n \n // Process each block\n for (int i = 1; i <= blockCount; i++) {\n // Check connectivity for arrangement 1\n if (!shapes1[i].empty() && !isConnected(shapes1[i])) {\n // Split into connected components\n auto components = splitIntoConnectedComponents(shapes1[i]);\n for (const auto& component : components) {\n finalBlockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n }\n } else if (!shapes1[i].empty()) {\n // Connected, assign block ID\n finalBlockCount++;\n blockRemapping[i] = finalBlockCount;\n for (const Point& p : shapes1[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n }\n \n // Check connectivity for arrangement 2\n if (!shapes2[i].empty() && !isConnected(shapes2[i])) {\n // Split into connected components\n auto components = splitIntoConnectedComponents(shapes2[i]);\n for (const auto& component : components) {\n finalBlockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n } else if (!shapes2[i].empty() && blockRemapping[i] != 0) {\n // Check if shapes match for blocks that appear in both arrangements\n vector shape1 = shapes1[i];\n vector shape2 = shapes2[i];\n \n if (shapesMatch(shape1, shape2)) {\n // Shapes match, use same block ID\n for (const Point& p : shape2) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = blockRemapping[i];\n }\n } else {\n // Shapes don't match, create new block\n finalBlockCount++;\n for (const Point& p : shape2) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n } else if (!shapes2[i].empty() && blockRemapping[i] == 0) {\n // Block only in arrangement 2\n finalBlockCount++;\n for (const Point& p : shapes2[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n }\n \n // For blocks that were split in arrangement 1 but not in arrangement 2, fix arrangement 2\n for (int i = 1; i <= blockCount; i++) {\n if (!shapes1[i].empty() && !shapes2[i].empty()) {\n // If block was split in arrangement 1, need to handle arrangement 2 accordingly\n if (!isConnected(shapes1[i]) && isConnected(shapes2[i])) {\n // Check shape matching for each connected component of arrangement 1 with arrangement 2\n auto components = splitIntoConnectedComponents(shapes1[i]);\n \n // Try to match components with arrangement 2\n for (const auto& component : components) {\n if (shapesMatch(component, shapes2[i])) {\n // Found a match, update arrangement 2 to use the same block ID as this component\n for (const Point& p : shapes2[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n // Find the block ID assigned to this component in arrangement 1\n if (finalBlockId1[toIndex(component[0].x, component[0].y, component[0].z)] != 0) {\n int matchedId = finalBlockId1[toIndex(component[0].x, component[0].y, component[0].z)];\n finalBlockId2[idx] = matchedId;\n }\n }\n break;\n }\n }\n }\n }\n }\n \n // Output\n cout << finalBlockCount << endl;\n \n // Output first arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << finalBlockId1[i];\n }\n cout << endl;\n \n // Output second arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << finalBlockId2[i];\n }\n cout << endl;\n \n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef long long ll;\n\nstruct Point {\n ll x, y;\n Point(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\nll distance_squared(const Point& a, const Point& b) {\n ll dx = a.x - b.x;\n ll dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\nll distance_rounded(const Point& a, const Point& b) {\n return ll(round(sqrt(distance_squared(a, b))));\n}\n\nstruct Edge {\n int u, v;\n ll weight;\n int index;\n Edge(int u = 0, int v = 0, ll weight = 0, int index = 0) : u(u), v(v), weight(weight), index(index) {}\n};\n\nstruct Resident {\n ll x, y;\n Resident(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\n// Union-Find for MST\nstruct UnionFind {\n vector parent, rank;\n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) parent[x] = y;\n else {\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n }\n bool same(int x, int y) {\n return find(x) == find(y);\n }\n};\n\n// Dijkstra for shortest path\nvector dijkstra(const vector>>& graph, int start, int n) {\n vector dist(n + 1, LLONG_MAX);\n priority_queue, vector>, greater>> pq;\n \n dist[start] = 0;\n pq.push({0, start});\n \n while (!pq.empty()) {\n ll d = pq.top().first;\n int u = pq.top().second;\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto& edge : graph[u]) {\n int v = edge.first;\n ll w = edge.second;\n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.push({dist[v], v});\n }\n }\n }\n \n return dist;\n}\n\n// Calculate total cost for a solution\nll calculateTotalCost(const vector& P, const vector& B, const vector& edges) {\n ll cost = 0;\n // Add power costs\n for (size_t i = 1; i < P.size(); ++i) {\n cost += P[i] * P[i];\n }\n // Add cable costs\n for (size_t j = 1; j < B.size(); ++j) {\n if (B[j] == 1) {\n cost += edges[j-1].weight;\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n cin >> N >> M >> K;\n \n vector stations(N + 1);\n for (int i = 1; i <= N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges;\n for (int j = 1; j <= M; ++j) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n edges.push_back(Edge(u, v, w, j));\n }\n \n vector residents(K + 1);\n for (int k = 1; k <= K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // For each resident, find the minimum radius needed from each station\n vector> minRadius(N + 1, vector(K + 1, 0));\n for (int i = 1; i <= N; ++i) {\n for (int k = 1; k <= K; ++k) {\n minRadius[i][k] = distance_rounded(\n Point(stations[i].x, stations[i].y), \n Point(residents[k].x, residents[k].y)\n );\n }\n }\n \n // Output strengths for each station\n vector P(N + 1, 0);\n \n // Edge power status\n vector B(M + 1, 0);\n \n // Build adjacency list for the graph\n vector>> graph(N + 1);\n for (auto& e : edges) {\n graph[e.u].push_back({e.v, e.weight});\n graph[e.v].push_back({e.u, e.weight});\n }\n \n // Calculate shortest distances from station 1 to all other stations\n vector distFrom1 = dijkstra(graph, 1, N);\n \n // Try multiple strategies and pick the best one\n \n // Strategy 1: Greedy by total cost (cable + power)\n vector P1(N + 1, 0);\n vector B1(M + 1, 0);\n \n // For each resident, calculate the total cost of covering them through each station\n vector>> residentCoverage(K + 1);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (distFrom1[i] != LLONG_MAX && minRadius[i][k] <= 5000) {\n ll powerCost = minRadius[i][k] * minRadius[i][k];\n ll totalCost = distFrom1[i] + powerCost;\n residentCoverage[k].push_back({totalCost, i});\n }\n }\n sort(residentCoverage[k].begin(), residentCoverage[k].end());\n }\n \n // Assign residents to stations\n vector> assignedResidents(N + 1);\n for (int k = 1; k <= K; ++k) {\n if (!residentCoverage[k].empty()) {\n int bestStation = residentCoverage[k][0].second;\n assignedResidents[bestStation].push_back(k);\n P1[bestStation] = max(P1[bestStation], minRadius[bestStation][k]);\n }\n }\n \n // Mark stations that need to be activated\n vector stationActivated(N + 1, false);\n for (int i = 1; i <= N; ++i) {\n if (!assignedResidents[i].empty()) {\n stationActivated[i] = true;\n }\n }\n stationActivated[1] = true;\n \n // Build MST to connect activated stations\n UnionFind uf(N + 1);\n vector inTree(N + 1, false);\n inTree[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (stationActivated[i]) {\n inTree[i] = true;\n }\n }\n \n // Sort edges by weight\n vector>> weightedEdges;\n for (auto& e : edges) {\n weightedEdges.push_back({e.weight, {e.u, e.v}});\n }\n sort(weightedEdges.begin(), weightedEdges.end());\n \n // Kruskal's algorithm for MST\n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree[u] && stationActivated[v]) || \n (inTree[v] && stationActivated[u]) ||\n (inTree[u] && inTree[v])) {\n if (!uf.same(u, v)) {\n uf.unite(u, v);\n inTree[u] = true;\n inTree[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B1[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity to station 1\n for (int i = 2; i <= N; ++i) {\n if (stationActivated[i] && !uf.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf.same(1, e.v)) || (e.v == i && uf.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B1[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf.unite(u, v);\n }\n }\n }\n \n // Strategy 2: Cluster-based approach\n vector P2(N + 1, 0);\n vector B2(M + 1, 0);\n \n // Group residents by proximity to stations\n vector> stationGroups(N + 1);\n for (int k = 1; k <= K; ++k) {\n int bestStation = 1;\n ll minDist = minRadius[1][k];\n \n for (int i = 2; i <= N; ++i) {\n if (minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n stationGroups[bestStation].push_back(k);\n }\n \n // Activate stations that have residents assigned\n vector activated2(N + 1, false);\n activated2[1] = true;\n \n for (int i = 1; i <= N; ++i) {\n if (!stationGroups[i].empty()) {\n activated2[i] = true;\n // Calculate required power for this station\n for (int k : stationGroups[i]) {\n P2[i] = max(P2[i], minRadius[i][k]);\n }\n }\n }\n \n // Connect activated stations with MST\n UnionFind uf2(N + 1);\n vector inTree2(N + 1, false);\n inTree2[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (activated2[i]) {\n inTree2[i] = true;\n }\n }\n \n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree2[u] && activated2[v]) || \n (inTree2[v] && activated2[u]) ||\n (inTree2[u] && inTree2[v])) {\n if (!uf2.same(u, v)) {\n uf2.unite(u, v);\n inTree2[u] = true;\n inTree2[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B2[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity\n for (int i = 2; i <= N; ++i) {\n if (activated2[i] && !uf2.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf2.same(1, e.v)) || (e.v == i && uf2.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B2[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf2.unite(u, v);\n }\n }\n }\n \n // Strategy 3: Balanced approach - minimize sum of squares with constraint on cable cost\n vector P3(N + 1, 0);\n vector B3(M + 1, 0);\n \n // For each station, calculate efficiency: residents covered per power cost\n vector> stationEfficiency;\n for (int i = 1; i <= N; ++i) {\n if (i == 1) continue; // Always include station 1\n \n // Calculate how many residents this station can cover with reasonable power\n int residentsCovered = 0;\n ll minPowerNeeded = 0;\n \n for (int k = 1; k <= K; ++k) {\n if (minRadius[i][k] <= 2000) { // Reasonable radius\n residentsCovered++;\n minPowerNeeded = max(minPowerNeeded, minRadius[i][k]);\n }\n }\n \n if (residentsCovered > 0 && distFrom1[i] != LLONG_MAX) {\n double efficiency = (double)residentsCovered / (double)(minPowerNeeded * minPowerNeeded + distFrom1[i]);\n stationEfficiency.push_back({efficiency, i});\n }\n }\n \n // Sort by efficiency (descending)\n sort(stationEfficiency.rbegin(), stationEfficiency.rend());\n \n // Greedily select stations based on efficiency\n vector activated3(N + 1, false);\n activated3[1] = true;\n vector residentCovered3(K + 1, false);\n \n // Start by covering residents with station 1\n for (int k = 1; k <= K; ++k) {\n if (minRadius[1][k] <= 5000) {\n P3[1] = max(P3[1], minRadius[1][k]);\n residentCovered3[k] = true;\n }\n }\n \n // Add stations based on efficiency until all residents are covered\n for (auto& eff : stationEfficiency) {\n int i = eff.second;\n \n // Check if we still need to cover residents\n bool allCovered = true;\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k]) {\n allCovered = false;\n break;\n }\n }\n if (allCovered) break;\n \n // Check if this station can cover uncovered residents\n bool canCover = false;\n ll requiredPower = 0;\n \n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k] && minRadius[i][k] <= 5000) {\n canCover = true;\n requiredPower = max(requiredPower, minRadius[i][k]);\n }\n }\n \n if (canCover) {\n activated3[i] = true;\n P3[i] = requiredPower;\n \n // Mark covered residents\n for (int k = 1; k <= K; ++k) {\n if (minRadius[i][k] <= requiredPower) {\n residentCovered3[k] = true;\n }\n }\n }\n }\n \n // For any remaining uncovered residents, assign to closest activated station\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k]) {\n ll minDist = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (activated3[i] && minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n \n if (bestStation != -1) {\n P3[bestStation] = max(P3[bestStation], minDist);\n residentCovered3[k] = true;\n }\n }\n }\n \n // Connect activated stations with MST\n UnionFind uf3(N + 1);\n vector inTree3(N + 1, false);\n inTree3[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (activated3[i]) {\n inTree3[i] = true;\n }\n }\n \n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree3[u] && activated3[v]) || \n (inTree3[v] && activated3[u]) ||\n (inTree3[u] && inTree3[v])) {\n if (!uf3.same(u, v)) {\n uf3.unite(u, v);\n inTree3[u] = true;\n inTree3[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B3[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity\n for (int i = 2; i <= N; ++i) {\n if (activated3[i] && !uf3.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf3.same(1, e.v)) || (e.v == i && uf3.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B3[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf3.unite(u, v);\n }\n }\n }\n \n // Calculate costs for each strategy\n ll cost1 = calculateTotalCost(P1, B1, edges);\n ll cost2 = calculateTotalCost(P2, B2, edges);\n ll cost3 = calculateTotalCost(P3, B3, edges);\n \n // Verify coverage for each strategy\n auto verifyCoverage = [&](const vector& P, const vector& inTree) -> bool {\n vector covered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (inTree[i] && minRadius[i][k] <= P[i]) {\n covered[k] = true;\n break;\n }\n }\n }\n \n for (int k = 1; k <= K; ++k) {\n if (!covered[k]) return false;\n }\n return true;\n };\n \n vector inTree1(N + 1, false);\n for (int i = 1; i <= N; ++i) {\n inTree1[i] = (i == 1) || stationActivated[i];\n }\n // Update inTree1 based on actual connectivity\n UnionFind uf_check1(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B1[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check1.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree1[i] = uf_check1.same(1, i);\n }\n \n vector inTree2_vec(N + 1, false);\n UnionFind uf_check2(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B2[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check2.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree2_vec[i] = uf_check2.same(1, i);\n }\n \n vector inTree3_vec(N + 1, false);\n UnionFind uf_check3(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B3[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check3.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree3_vec[i] = uf_check3.same(1, i);\n }\n \n bool coverage1 = verifyCoverage(P1, inTree1);\n bool coverage2 = verifyCoverage(P2, inTree2_vec);\n bool coverage3 = verifyCoverage(P3, inTree3_vec);\n \n // Choose the best strategy\n if (coverage1 && coverage2 && coverage3) {\n if (cost1 <= cost2 && cost1 <= cost3) {\n P = P1;\n B = B1;\n } else if (cost2 <= cost1 && cost2 <= cost3) {\n P = P2;\n B = B2;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage1 && coverage2) {\n if (cost1 <= cost2) {\n P = P1;\n B = B1;\n } else {\n P = P2;\n B = B2;\n }\n } else if (coverage1 && coverage3) {\n if (cost1 <= cost3) {\n P = P1;\n B = B1;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage2 && coverage3) {\n if (cost2 <= cost3) {\n P = P2;\n B = B2;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage1) {\n P = P1;\n B = B1;\n } else if (coverage2) {\n P = P2;\n B = B2;\n } else if (coverage3) {\n P = P3;\n B = B3;\n }\n \n // Final verification and fix: ensure all residents are covered\n vector finalInTree(N + 1, false);\n UnionFind uf_final(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_final.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n finalInTree[i] = uf_final.same(1, i);\n }\n \n vector residentCovered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (finalInTree[i] && minRadius[i][k] <= P[i]) {\n residentCovered[k] = true;\n break;\n }\n }\n }\n \n // Fix uncovered residents\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered[k]) {\n ll minExtraCost = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (finalInTree[i]) {\n ll newPower = max(P[i], minRadius[i][k]);\n ll extraCost = newPower * newPower - P[i] * P[i];\n \n if (extraCost < minExtraCost) {\n minExtraCost = extraCost;\n bestStation = i;\n }\n }\n }\n \n if (bestStation != -1) {\n P[bestStation] = max(P[bestStation], minRadius[bestStation][k]);\n }\n }\n }\n \n // Output the solution\n for (int i = 1; i <= N; ++i) {\n if (i > 1) cout << \" \";\n cout << P[i];\n }\n cout << endl;\n \n for (int j = 1; j <= M; ++j) {\n if (j > 1) cout << \" \";\n cout << B[j];\n }\n cout << endl;\n \n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_OPS = 9800; // Very conservative limit\n\n// Pyramid representation\nvector> pyramid;\n\n// Directions for adjacent positions (6 directions)\nvector> dirs = {\n {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}\n};\n\n// Check if coordinates are valid\nbool valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\n// Check if swap is valid (adjacent in 6 directions)\nbool can_swap(int x1, int y1, int x2, int y2) {\n if (!valid(x1, y1) || !valid(x2, y2)) return false;\n \n for (auto& dir : dirs) {\n int nx = x1 + dir.first;\n int ny = y1 + dir.second;\n if (nx == x2 && ny == y2) {\n return true;\n }\n }\n return false;\n}\n\n// Perform swap and record operation\nvoid perform_swap(int x1, int y1, int x2, int y2, vector>& ops) {\n if (!can_swap(x1, y1, x2, y2)) {\n return;\n }\n \n swap(pyramid[x1][y1], pyramid[x2][y2]);\n ops.push_back({x1, y1, x2, y2});\n}\n\n// Count violations and get maximum difference\npair analyze_violations() {\n int violations = 0;\n int max_diff = 0;\n \n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current > left_child) {\n violations++;\n max_diff = max(max_diff, current - left_child);\n }\n if (current > right_child) {\n violations++;\n max_diff = max(max_diff, current - right_child);\n }\n }\n }\n return {violations, max_diff};\n}\n\n// Main solution\nvoid solve() {\n // Read input\n pyramid.resize(N);\n for (int i = 0; i < N; i++) {\n pyramid[i].resize(i + 1);\n for (int j = 0; j <= i; j++) {\n cin >> pyramid[i][j];\n }\n }\n \n vector> operations;\n \n // Skip Phase 1 - no initial repositioning\n \n // Phase 2: Multiple bottom-up passes with increasing focus\n auto [initial_violations, max_diff] = analyze_violations();\n \n for (int pass = 0; pass < 15 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n \n // Bottom-up pass\n for (int x = N - 2; x >= 0; x--) {\n for (int y = 0; y <= x; y++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n // Focus on larger violations first\n int left_diff = current_value - left_child;\n int right_diff = current_value - right_child;\n \n if (left_diff > 0 || right_diff > 0) {\n // Always swap with the smaller child\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n }\n \n // Check if we've fixed all violations\n auto [current_violations, _] = analyze_violations();\n if (current_violations == 0) break;\n \n // If no changes and still violations, try top-down\n if (!changed && operations.size() < MAX_OPS) {\n bool top_down_changed = false;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n top_down_changed = true;\n }\n }\n }\n }\n \n if (!top_down_changed) {\n // Try another bottom-up pass with more aggressive approach\n for (int x = N - 2; x >= 0; x--) {\n for (int y = x; y >= 0; y--) { // Reverse order within level\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n }\n }\n }\n }\n }\n }\n }\n \n // Phase 3: Aggressive fixing for remaining violations\n for (int pass = 0; pass < 5 && operations.size() < MAX_OPS; pass++) {\n auto [remaining_violations, _] = analyze_violations();\n if (remaining_violations == 0) break;\n \n bool changed = false;\n \n // Prioritize violations with largest differences\n vector>> violation_list;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n int max_diff = 0;\n if (current_value > left_child) max_diff = max(max_diff, current_value - left_child);\n if (current_value > right_child) max_diff = max(max_diff, current_value - right_child);\n \n if (max_diff > 0) {\n violation_list.push_back({-max_diff, {x, y}}); // Negative for sorting\n }\n }\n }\n \n sort(violation_list.begin(), violation_list.end());\n \n // Fix top 50% of violations by difference\n int fix_count = min(20, (int)violation_list.size());\n for (int i = 0; i < fix_count && operations.size() < MAX_OPS; i++) {\n int x = violation_list[i].second.first;\n int y = violation_list[i].second.second;\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n \n if (!changed) break;\n }\n \n // Phase 4: Final cleanup - ensure no violations remain\n for (int pass = 0; pass < 3 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n }\n if (!changed) break;\n }\n \n // Output operations\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << op[0] << \" \" << op[1] << \" \" << op[2] << \" \" << op[3] << endl;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n solve();\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nconst int entrance_i = 0, entrance_j = 4;\n\n// Directions for 4-connectivity\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n};\n\nclass Warehouse {\nprivate:\n vector> grid; // -1: empty, -2: obstacle, -3: entrance, >=0: container number\n vector> obstacles;\n int N;\n map container_positions; // Map from position to container number\n \npublic:\n Warehouse(int n) : N(n) {\n grid.assign(D, vector(D, -1));\n obstacles.assign(D, vector(D, false));\n // Mark entrance\n grid[entrance_i][entrance_j] = -3;\n }\n \n void add_obstacle(int i, int j) {\n obstacles[i][j] = true;\n grid[i][j] = -2;\n }\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < D && j >= 0 && j < D;\n }\n \n bool is_empty(int i, int j) {\n return is_valid(i, j) && grid[i][j] == -1 && !obstacles[i][j] && !(i == entrance_i && j == entrance_j);\n }\n \n // BFS to find all reachable empty positions from entrance\n vector get_reachable_empty_positions() {\n vector> visited(D, vector(D, false));\n queue q;\n vector reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n // Check 4 adjacent squares\n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] == -1) { // Empty square\n reachable.push_back(Position(ni, nj));\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] >= 0) { // Container square - can traverse through it for reachability\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Calculate Manhattan distance from entrance\n int distance_from_entrance(int i, int j) {\n return abs(i - entrance_i) + abs(j - entrance_j);\n }\n \n // Estimate how many positions would become unreachable if we place a container at (i,j)\n int blocking_score(int i, int j) {\n if (!is_empty(i, j)) return INT_MAX;\n \n // Temporarily place a container here\n int original = grid[i][j];\n grid[i][j] = 999; // Temporary container\n \n // Count reachable positions\n vector reachable = get_reachable_empty_positions();\n int reachable_count = reachable.size();\n \n // Restore\n grid[i][j] = original;\n \n // Higher score means more blocking (worse)\n return (D*D - 1 - N - reachable_count);\n }\n \n // Place container with number t at position (i, j)\n void place_container(int t, int i, int j) {\n grid[i][j] = t;\n container_positions[Position(i, j)] = t;\n }\n \n // Get all currently reachable containers\n vector> get_reachable_containers() {\n vector> visited(D, vector(D, false));\n queue q;\n vector> reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] >= 0) { // Container\n reachable.push_back({Position(ni, nj), grid[ni][nj]});\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] == -1) { // Empty\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Get all containers sorted by their numbers\n vector> get_all_containers_sorted() {\n vector> containers;\n for (auto& p : container_positions) {\n containers.push_back({p.first, p.second});\n }\n sort(containers.begin(), containers.end(), [](const auto& a, const auto& b) {\n return a.second < b.second;\n });\n return containers;\n }\n};\n\nint main() {\n int N;\n cin >> D >> N; // Note: D is always 9 per problem statement\n \n Warehouse warehouse(N);\n \n // Read obstacles\n for (int i = 0; i < N; i++) {\n int ri, rj;\n cin >> ri >> rj;\n warehouse.add_obstacle(ri, rj);\n }\n \n vector arrived_containers;\n vector> placement_positions; // Store where each container was placed\n \n // Process each incoming container\n for (int d = 0; d < D*D - 1 - N; d++) {\n int t;\n cin >> t;\n arrived_containers.push_back(t);\n \n // Get all reachable empty positions\n vector reachable = warehouse.get_reachable_empty_positions();\n \n if (reachable.empty()) {\n // This shouldn't happen according to problem constraints\n // Just pick any empty position\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (warehouse.is_empty(i, j)) {\n cout << i << \" \" << j << endl;\n warehouse.place_container(t, i, j);\n placement_positions.push_back({i, j});\n goto placed;\n }\n }\n }\n }\n \n // Calculate statistics for decision making\n double avg_so_far = 0.0;\n if (d > 0) {\n for (int i = 0; i < d; i++) {\n avg_so_far += arrived_containers[i];\n }\n avg_so_far /= d;\n }\n \n // Score each reachable position\n vector> position_scores;\n for (auto& pos : reachable) {\n // Base score: distance from entrance (want smaller for smaller t)\n double distance_score = warehouse.distance_from_entrance(pos.i, pos.j);\n \n // Priority factor: if t is smaller than average, we want closer positions\n double priority_factor = 1.0;\n if (d > 0) {\n if (t < avg_so_far) {\n // This container should be removed earlier, so give it higher priority (lower score)\n priority_factor = 0.5;\n } else {\n // This container should be removed later, so lower priority (higher score)\n priority_factor = 2.0;\n }\n }\n \n // Blocking score: how much this placement would block other positions\n int block_score = warehouse.blocking_score(pos.i, pos.j);\n \n // Total score (lower is better)\n double total_score = distance_score * priority_factor + block_score * 0.1;\n \n position_scores.push_back({total_score, pos});\n }\n \n // Choose position with minimum score\n sort(position_scores.begin(), position_scores.end());\n Position chosen = position_scores[0].second;\n \n cout << chosen.i << \" \" << chosen.j << endl;\n cout.flush(); // Important: flush output\n \n warehouse.place_container(t, chosen.i, chosen.j);\n placement_positions.push_back({chosen.i, chosen.j});\n \n placed:; // Label for goto\n }\n \n // Determine removal order\n vector> containers_sorted = warehouse.get_all_containers_sorted();\n \n // Output removal order (by container number, ascending)\n for (auto& p : containers_sorted) {\n cout << p.first.i << \" \" << p.first.j << endl;\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nconst int M = 100;\n\nint main() {\n int n = N, m = M;\n vector> grid(n, vector(n));\n \n // Read input\n cin >> n >> m;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n \n // Determine adjacencies\n vector> adj(m + 1); // adj[c] contains colors adjacent to color c\n vector adj_to_external(m + 1, false); // whether color c is adjacent to external (0)\n \n // Check adjacencies in the original grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n \n // Check if adjacent to boundary (external)\n if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {\n adj_to_external[c] = true;\n }\n \n // Check 4-directional neighbors\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int d = grid[ni][nj];\n if (c != d) {\n adj[c].insert(d);\n adj[d].insert(c);\n }\n } else {\n // Adjacent to external\n adj_to_external[c] = true;\n adj[c].insert(0);\n // Note: We don't add to adj[0] as it's external and always connected\n }\n }\n }\n }\n \n // Create output grid, initially all color 0\n vector> result(n, vector(n, 0));\n \n // Strategy: Place one tile per color in a compact arrangement\n // Start by placing colors that need to be adjacent to external on the boundary\n \n vector colors;\n for (int i = 1; i <= m; i++) {\n colors.push_back(i);\n }\n \n // Sort colors by number of adjacencies (descending) to place high-degree nodes first\n sort(colors.begin(), colors.end(), [&](int a, int b) {\n return adj[a].size() > adj[b].size();\n });\n \n // Place colors on the grid\n int placed = 0;\n bool placed_grid[N][N] = {false};\n \n // First, try to place on the boundary for colors adjacent to external\n vector> boundary_positions;\n for (int i = 0; i < n; i++) {\n boundary_positions.push_back({i, 0});\n boundary_positions.push_back({i, n-1});\n }\n for (int j = 1; j < n-1; j++) {\n boundary_positions.push_back({0, j});\n boundary_positions.push_back({n-1, j});\n }\n \n int boundary_idx = 0;\n \n // Place colors adjacent to external on boundary\n for (int color : colors) {\n if (adj_to_external[color] && boundary_idx < boundary_positions.size()) {\n int x = boundary_positions[boundary_idx].first;\n int y = boundary_positions[boundary_idx].second;\n result[x][y] = color;\n placed_grid[x][y] = true;\n boundary_idx++;\n placed++;\n }\n }\n \n // Place remaining colors in the interior\n for (int color : colors) {\n if (placed >= m) break;\n \n bool already_placed = false;\n for (int i = 0; i < n && !already_placed; i++) {\n for (int j = 0; j < n && !already_placed; j++) {\n if (result[i][j] == color) {\n already_placed = true;\n }\n }\n }\n \n if (already_placed) continue;\n \n // Find a position to place this color\n bool placed_color = false;\n \n // Try to place adjacent to already placed colors it should be adjacent to\n for (int c : adj[color]) {\n if (c == 0) continue; // Skip external\n \n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (result[i][j] == c) {\n // Try to place adjacent to this tile\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n && !placed_grid[ni][nj]) {\n result[ni][nj] = color;\n placed_grid[ni][nj] = true;\n placed_color = true;\n placed++;\n break;\n }\n }\n }\n }\n }\n \n if (placed_color) break;\n }\n \n // If couldn't place adjacent to any adjacent color, place anywhere available\n if (!placed_color) {\n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (!placed_grid[i][j]) {\n result[i][j] = color;\n placed_grid[i][j] = true;\n placed_color = true;\n placed++;\n }\n }\n }\n }\n }\n \n // Output the result\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cout << result[i][j];\n if (j < n - 1) cout << \" \";\n }\n cout << endl;\n }\n \n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nclass SimpleWeightEstimator {\nprivate:\n int n;\n vector weights;\n vector> win_matrix;\n \npublic:\n SimpleWeightEstimator(int size) : n(size), weights(size, 1.0), win_matrix(size, vector(size, 0)) {}\n \n void add_comparison(int i, int j, const string& result) {\n if (result == \">\") {\n win_matrix[i][j] += 1;\n win_matrix[j][i] -= 1;\n } else if (result == \"<\") {\n win_matrix[i][j] -= 1;\n win_matrix[j][i] += 1;\n }\n }\n \n void estimate_weights() {\n fill(weights.begin(), weights.end(), 1.0);\n \n const int max_iterations = 50; // Reduced from 100\n const double learning_rate = 0.1;\n \n for (int iter = 0; iter < max_iterations; ++iter) {\n vector new_weights = weights;\n bool changed = false;\n \n for (int i = 0; i < n; ++i) {\n double adjustment = 0.0;\n int comparisons = 0;\n \n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n \n if (win_matrix[i][j] != 0) {\n adjustment += win_matrix[i][j] * (weights[j] * 0.1);\n comparisons += abs(win_matrix[i][j]);\n }\n }\n \n if (comparisons > 0) {\n adjustment /= comparisons;\n new_weights[i] += learning_rate * adjustment;\n new_weights[i] = max(0.1, new_weights[i]);\n if (abs(adjustment) > 1e-6) changed = true;\n }\n }\n \n weights = new_weights;\n if (!changed) break;\n }\n \n double min_weight = *min_element(weights.begin(), weights.end());\n if (min_weight <= 0) {\n double offset = 1.0 - min_weight;\n for (int i = 0; i < n; ++i) {\n weights[i] += offset;\n }\n }\n }\n \n vector get_all_weights() const {\n return weights;\n }\n \n vector get_simple_ranking() {\n vector> scores(n);\n for (int i = 0; i < n; ++i) {\n int score = 0;\n for (int j = 0; j < n; ++j) {\n score += win_matrix[i][j];\n }\n scores[i] = {score, i};\n }\n \n sort(scores.begin(), scores.end(), greater>());\n \n vector ranking(n);\n for (int i = 0; i < n; ++i) {\n ranking[scores[i].second] = i;\n }\n return ranking;\n }\n};\n\n// Time tracking utility\nclass Timer {\nprivate:\n steady_clock::time_point start_time;\n double time_limit_sec;\n \npublic:\n Timer(double limit = 1.8) : time_limit_sec(limit) {\n start_time = steady_clock::now();\n }\n \n double elapsed() {\n auto now = steady_clock::now();\n return duration_cast>(now - start_time).count();\n }\n \n bool is_time_critical() {\n return elapsed() > time_limit_sec;\n }\n};\n\nvector improved_partitioning(const vector& weights, int D, Timer& timer) {\n int n = weights.size();\n vector assignment(n, 0);\n \n if (D == 1) return assignment;\n \n // Create list of items with weights and indices\n vector> items;\n for (int i = 0; i < n; ++i) {\n items.push_back({weights[i], i});\n }\n \n // Sort in descending order\n sort(items.rbegin(), items.rend());\n \n // Initialize D sets\n vector set_weights(D, 0.0);\n \n // Greedy assignment\n for (auto& item : items) {\n // Find set with minimum weight\n int min_set = 0;\n for (int j = 1; j < D; ++j) {\n if (set_weights[j] < set_weights[min_set]) {\n min_set = j;\n }\n }\n \n assignment[item.second] = min_set;\n set_weights[min_set] += item.first;\n }\n \n // Early return if time is critical\n if (timer.is_time_critical()) {\n return assignment;\n }\n \n // Local search optimization - simplified version\n const int max_moves = min(n * 2, 100); // Reduced iterations\n int moves = 0;\n \n for (int iter = 0; iter < max_moves && moves < max_moves; ++iter) {\n if (timer.is_time_critical()) break;\n \n double mean_weight = accumulate(set_weights.begin(), set_weights.end(), 0.0) / D;\n \n // Find the heaviest and lightest sets\n int heaviest = 0, lightest = 0;\n for (int i = 1; i < D; ++i) {\n if (set_weights[i] > set_weights[heaviest]) heaviest = i;\n if (set_weights[i] < set_weights[lightest]) lightest = i;\n }\n \n if (heaviest == lightest) break;\n if (set_weights[heaviest] - set_weights[lightest] < 1e-6) break;\n \n // Create lists of items in heaviest and lightest sets\n vector> heaviest_items, lightest_items;\n for (int i = 0; i < n; ++i) {\n if (assignment[i] == heaviest) {\n heaviest_items.push_back({weights[i], i});\n } else if (assignment[i] == lightest) {\n lightest_items.push_back({weights[i], i});\n }\n }\n \n if (heaviest_items.empty() || lightest_items.empty()) continue;\n \n // Sort heaviest items in ascending order (smallest first)\n sort(heaviest_items.begin(), heaviest_items.end());\n \n // Try moving the smallest item from heaviest to lightest\n auto& smallest_item = heaviest_items[0];\n double item_weight = smallest_item.first;\n \n // Check if moving improves balance\n double new_heavy_weight = set_weights[heaviest] - item_weight;\n double new_light_weight = set_weights[lightest] + item_weight;\n \n double old_imbalance = abs(set_weights[heaviest] - mean_weight) + abs(set_weights[lightest] - mean_weight);\n double new_imbalance = abs(new_heavy_weight - mean_weight) + abs(new_light_weight - mean_weight);\n \n if (new_imbalance < old_imbalance && new_light_weight <= set_weights[heaviest]) {\n // Move the item\n assignment[smallest_item.second] = lightest;\n set_weights[heaviest] = new_heavy_weight;\n set_weights[lightest] = new_light_weight;\n moves++;\n }\n }\n \n return assignment;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, D, Q;\n cin >> N >> D >> Q;\n \n // Start timer early\n Timer timer(1.7); // Set time limit to 1.7s to be safe\n \n // Initialize random generator\n auto seed = steady_clock::now().time_since_epoch().count();\n mt19937 rng(seed);\n uniform_int_distribution item_dist(0, N-1);\n \n // Create weight estimator\n SimpleWeightEstimator estimator(N);\n \n // Phase 1: Strategic information gathering\n int queries_used = 0;\n \n // Step 1: Establish baseline with pairwise comparisons\n vector items(N);\n iota(items.begin(), items.end(), 0);\n shuffle(items.begin(), items.end(), rng);\n \n // Compare adjacent items (limited to N/2 for efficiency)\n for (int i = 0; i < min(N - 1, N/2) && queries_used < min(Q/4, N/2); ++i) {\n if (timer.is_time_critical()) break;\n \n int item1 = items[i];\n int item2 = items[i + 1];\n \n cout << \"1 1 \" << item1 << \" \" << item2 << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(item1, item2, result);\n queries_used++;\n }\n \n // Step 2: Compare items with similar rankings (limited iterations)\n if (queries_used < Q * 2 / 3 && !timer.is_time_critical()) {\n estimator.estimate_weights(); // Estimate once before this phase\n auto current_weights = estimator.get_all_weights();\n vector> weighted_items;\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n \n // Only compare nearby items (reduced iterations)\n const int max_comparisons = min(Q * 2 / 3 - queries_used, N);\n int comparisons_done = 0;\n \n for (int i = 0; i < N - 1 && comparisons_done < max_comparisons && queries_used < Q * 2 / 3; ++i) {\n if (timer.is_time_critical()) break;\n \n // Only compare with next 1-2 items\n for (int j = 1; j <= min(2, N-i-1) && comparisons_done < max_comparisons && queries_used < Q * 2 / 3; ++j) {\n if (timer.is_time_critical()) break;\n \n int item1 = weighted_items[i].second;\n int item2 = weighted_items[i + j].second;\n \n cout << \"1 1 \" << item1 << \" \" << item2 << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(item1, item2, result);\n queries_used++;\n comparisons_done++;\n }\n }\n }\n \n // Step 3: Group comparisons (simplified)\n if (queries_used < Q * 5 / 6 && !timer.is_time_critical()) {\n estimator.estimate_weights();\n auto current_weights = estimator.get_all_weights();\n vector> weighted_items;\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n \n // Create fewer groups\n int num_groups = min(D, max(2, N / 8));\n vector> groups(num_groups);\n for (int i = 0; i < N; ++i) {\n groups[i % num_groups].push_back(weighted_items[i].second);\n }\n \n // Compare groups (limited iterations)\n const int max_group_comparisons = min(Q * 5 / 6 - queries_used, num_groups * 2);\n int group_comparisons_done = 0;\n \n for (int i = 0; i < num_groups && group_comparisons_done < max_group_comparisons && queries_used < Q * 5 / 6; ++i) {\n if (timer.is_time_critical()) break;\n \n for (int j = i + 1; j < num_groups && group_comparisons_done < max_group_comparisons && queries_used < Q * 5 / 6; ++j) {\n if (timer.is_time_critical()) break;\n \n if (groups[i].empty() || groups[j].empty()) continue;\n \n // Take only 1 item from each group\n vector left_items, right_items;\n left_items.push_back(groups[i][0]);\n right_items.push_back(groups[j][0]);\n \n cout << \"1 1 \" << left_items[0] << \" \" << right_items[0] << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(left_items[0], right_items[0], result);\n queries_used++;\n group_comparisons_done++;\n }\n }\n }\n \n // Step 4: Refine with closest items (simplified approach)\n if (!timer.is_time_critical()) {\n // Estimate weights once\n estimator.estimate_weights();\n auto current_weights = estimator.get_all_weights();\n vector> weighted_items;\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n \n // Use remaining queries for adjacent items in sorted order\n while (queries_used < Q && !timer.is_time_critical()) {\n // Pick a random position and compare with next item\n int pos = rng() % (N - 1);\n int item1 = weighted_items[pos].second;\n int item2 = weighted_items[pos + 1].second;\n \n cout << \"1 1 \" << item1 << \" \" << item2 << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(item1, item2, result);\n queries_used++;\n \n // Re-sort every 5 queries to adapt to new information\n if (queries_used % 5 == 0) {\n estimator.estimate_weights();\n current_weights = estimator.get_all_weights();\n for (int i = 0; i < N; ++i) {\n weighted_items[i] = {current_weights[i], i};\n }\n sort(weighted_items.begin(), weighted_items.end());\n }\n }\n }\n \n // Final weight estimation\n if (!timer.is_time_critical()) {\n estimator.estimate_weights();\n }\n vector estimated_weights = estimator.get_all_weights();\n \n // Fallback if needed\n double weight_sum = accumulate(estimated_weights.begin(), estimated_weights.end(), 0.0);\n if (weight_sum < 0.1 * N) {\n auto ranking = estimator.get_simple_ranking();\n for (int i = 0; i < N; ++i) {\n estimated_weights[i] = (N - ranking[i]) * 10.0;\n }\n }\n \n // Partitioning\n vector assignment = improved_partitioning(estimated_weights, D, timer);\n \n // Minimal local search if time permits\n if (!timer.is_time_critical()) {\n vector set_weights(D, 0.0);\n for (int i = 0; i < N; ++i) {\n set_weights[assignment[i]] += estimated_weights[i];\n }\n \n // Very limited swapping\n const int max_swaps = min(N, 20); // Severely limit swaps\n for (int iter = 0; iter < max_swaps; ++iter) {\n if (timer.is_time_critical()) break;\n \n int item1 = rng() % N;\n int item2 = rng() % N;\n if (item1 == item2) continue;\n \n int set1 = assignment[item1];\n int set2 = assignment[item2];\n if (set1 == set2) continue;\n \n double w1 = estimated_weights[item1];\n double w2 = estimated_weights[item2];\n \n double mean = accumulate(set_weights.begin(), set_weights.end(), 0.0) / D;\n double old_var = 0.0;\n for (double w : set_weights) {\n old_var += (w - mean) * (w - mean);\n }\n old_var /= D;\n \n // Calculate variance after swap\n double new_var = old_var;\n double old_diff1 = set_weights[set1] - mean;\n double old_diff2 = set_weights[set2] - mean;\n double new_diff1 = (set_weights[set1] - w1 + w2) - mean;\n double new_diff2 = (set_weights[set2] - w2 + w1) - mean;\n \n new_var = new_var - (old_diff1 * old_diff1 + old_diff2 * old_diff2) / D + \n (new_diff1 * new_diff1 + new_diff2 * new_diff2) / D;\n \n // Accept swap if it improves variance\n if (new_var < old_var) {\n assignment[item1] = set2;\n assignment[item2] = set1;\n set_weights[set1] = set_weights[set1] - w1 + w2;\n set_weights[set2] = set_weights[set2] - w2 + w1;\n }\n }\n }\n \n // Output final assignment\n for (int i = 0; i < N; ++i) {\n cout << assignment[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n \n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct BoxPosition {\n int stack_idx;\n int height; // 0-indexed from bottom\n bool removed;\n};\n\nint main() {\n int n = 200, m = 10;\n int boxes_per_stack = n / m;\n \n // Read input\n vector> stacks(m, vector(boxes_per_stack));\n vector box_positions(n + 1); // 1-indexed\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_positions[stacks[i][j]] = {i, j, false};\n }\n }\n \n vector> operations;\n \n // For each box from 1 to 200\n for (int target = 1; target <= n; target++) {\n // If box is already removed, skip (shouldn't happen)\n if (box_positions[target].removed) continue;\n \n int stack_idx = box_positions[target].stack_idx;\n int height = box_positions[target].height;\n \n // Check if box is at the top of its stack\n bool is_top = true;\n for (int i = height + 1; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) { // 0 indicates removed box\n is_top = false;\n break;\n }\n }\n \n // Clean up removed boxes from top of stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Recalculate if it's at the top after cleanup\n is_top = (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1);\n \n if (is_top) {\n // Can remove directly\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n continue;\n }\n \n // Need to move the box and everything above it\n // Find the best destination stack\n \n int best_stack = -1;\n int min_cost = INT_MAX;\n \n // First, try to find an empty stack\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n if (stacks[dest].empty()) {\n best_stack = dest;\n break;\n }\n }\n \n // If no empty stack, find stack with minimum additional cost\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n \n // Calculate cost of moving to this stack\n int boxes_to_move = 0;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move++;\n }\n }\n \n // Energy cost is boxes_to_move + 1\n int cost = boxes_to_move + 1;\n \n // Prefer stacks that are shorter or have higher-numbered boxes on top\n cost += stacks[dest].size(); // penalty for taller stacks\n \n if (cost < min_cost) {\n min_cost = cost;\n best_stack = dest;\n }\n }\n }\n \n // If still no valid destination, pick any different stack\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx) {\n best_stack = dest;\n break;\n }\n }\n }\n \n // Perform the move\n vector boxes_to_move;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move.push_back(stacks[stack_idx][i]);\n }\n }\n \n // Update stacks\n stacks[stack_idx].resize(height);\n \n for (int box : boxes_to_move) {\n stacks[best_stack].push_back(box);\n box_positions[box].stack_idx = best_stack;\n box_positions[box].height = stacks[best_stack].size() - 1;\n }\n \n operations.push_back({target, best_stack + 1});\n \n // Now try to remove the target box (it should be at the top)\n stack_idx = box_positions[target].stack_idx;\n height = box_positions[target].height;\n \n // Clean up the stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Verify it's at the top\n if (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1) {\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n } else {\n // Something went wrong, try one more move\n // This is a fallback - shouldn't happen in normal cases\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx && stacks[dest].empty()) {\n // Move just this box to empty stack\n stacks[stack_idx].erase(stacks[stack_idx].begin() + height);\n stacks[dest].push_back(target);\n box_positions[target].stack_idx = dest;\n box_positions[target].height = 0;\n operations.push_back({target, dest + 1});\n break;\n }\n }\n \n // Now remove it\n operations.push_back({target, 0});\n for (int i = 0; i < m; i++) {\n if (!stacks[i].empty() && stacks[i].back() == target) {\n stacks[i].pop_back();\n break;\n }\n }\n box_positions[target].removed = true;\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\n// Directions: R, D, L, U\nconst int di[4] = {0, 1, 0, -1};\nconst int dj[4] = {1, 0, -1, 0};\nconst string DIR = \"RDLU\";\n\nint N;\nvector h, v;\nvector> d;\nvector> visited;\nstring route = \"\";\n\n// Check if we can move from (i,j) to (ni,nj)\nbool canMove(int i, int j, int ni, int nj) {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n \n if (i == ni) { // horizontal move\n int min_j = min(j, nj);\n return v[i][min_j] == '0';\n } else { // vertical move\n int min_i = min(i, ni);\n return h[min_i][j] == '0';\n }\n}\n\n// Calculate distance to nearest high-value cell\nint distanceToHighValue(int i, int j, const vector>& dirt, int threshold) {\n queue> q;\n vector> seen(N, vector(N, false));\n \n q.push({i, j});\n seen[i][j] = true;\n \n int dist = 0;\n while (!q.empty()) {\n int size = q.size();\n for (int k = 0; k < size; k++) {\n auto [ci, cj] = q.front(); q.pop();\n if (dirt[ci][cj] >= threshold) return dist;\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !seen[ni][nj] && canMove(ci, cj, ni, nj)) {\n seen[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n dist++;\n }\n return N * N; // Large value if no high-value cell found\n}\n\n// DFS with advanced prioritization\nvoid dfs_priority(int i, int j, const vector>& dirt) {\n visited[i][j] = true;\n \n // Calculate threshold for \"high value\" cells (75th percentile)\n vector all_dirt;\n for (int ii = 0; ii < N; ii++) {\n for (int jj = 0; jj < N; jj++) {\n if (!visited[ii][jj]) {\n all_dirt.push_back(dirt[ii][jj]);\n }\n }\n }\n int threshold = 1;\n if (!all_dirt.empty()) {\n sort(all_dirt.begin(), all_dirt.end());\n threshold = all_dirt.size() >= 4 ? all_dirt[all_dirt.size() - all_dirt.size()/4] : all_dirt.back();\n }\n \n // Collect all possible next moves\n vector> next_moves; // (priority, direction)\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n // Advanced priority formula:\n // 1. High dirtiness (primary factor)\n // 2. Proximity to other high-dirt cells (cluster effect)\n // 3. Distance to nearest high-value cell (exploration bonus)\n // 4. Distance from start (prefer closer cells to reduce travel time)\n \n double base_priority = -dirt[ni][nj]; // negative for descending sort\n \n // Cluster bonus: check 3x3 neighborhood\n double cluster_bonus = 0.0;\n int cluster_count = 0;\n for (int dii = -1; dii <= 1; dii++) {\n for (int djj = -1; djj <= 1; djj++) {\n int nii = ni + dii;\n int njj = nj + djj;\n if (nii >= 0 && nii < N && njj >= 0 && njj < N && !(dii == 0 && djj == 0)) {\n cluster_bonus += dirt[nii][njj] * 0.15;\n cluster_count++;\n }\n }\n }\n \n // Distance to nearest high-value cell (lower distance = higher priority)\n int dist_to_high = distanceToHighValue(ni, nj, dirt, threshold);\n double distance_penalty = dist_to_high * 0.5;\n \n // Distance from start (lower distance = higher priority)\n int dist_from_start = ni + nj;\n double start_penalty = dist_from_start * 0.3;\n \n // Combine factors\n double priority = base_priority - cluster_bonus + distance_penalty + start_penalty;\n \n next_moves.push_back({priority, dir});\n }\n }\n \n // Sort by priority (more negative = higher priority)\n sort(next_moves.begin(), next_moves.end());\n \n // Visit in priority order\n for (auto& move : next_moves) {\n int dir = move.second;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n \n route += DIR[dir];\n dfs_priority(ni, nj, dirt);\n route += DIR[(dir + 2) % 4]; // return\n }\n}\n\n// Get positions after executing route\nvector> getPositions(const string& r) {\n vector> positions;\n int ci = 0, cj = 0;\n positions.push_back({ci, cj});\n \n for (char move : r) {\n int dir = DIR.find(move);\n if (dir == -1) {\n break;\n }\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n \n // Safety check\n if (!canMove(ci, cj, ni, nj)) {\n break;\n }\n \n ci = ni;\n cj = nj;\n positions.push_back({ci, cj});\n }\n \n return positions;\n}\n\n// Validate the entire route\nbool validateRoute(const string& r) {\n int ci = 0, cj = 0;\n \n for (size_t k = 0; k < r.size(); k++) {\n char move = r[k];\n int dir = DIR.find(move);\n if (dir == -1) return false; // Invalid direction\n \n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n \n if (!canMove(ci, cj, ni, nj)) {\n return false; // Hits a wall\n }\n \n ci = ni;\n cj = nj;\n }\n \n // Must end at (0,0)\n return (ci == 0 && cj == 0);\n}\n\n// More intelligent loop addition with better placement\nstring addSmartLoops(const string& base_route) {\n string result = base_route;\n if (result.size() >= 99000) return result;\n \n // Get positions\n vector> positions = getPositions(base_route);\n \n // Create a map of visit times for each cell\n vector>> visit_times(N, vector>(N));\n for (size_t t = 0; t < positions.size(); t++) {\n int i = positions[t].first;\n int j = positions[t].second;\n visit_times[i][j].push_back(t);\n }\n \n // Create list of cells with their dirtiness\n vector>> dirt_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n dirt_cells.push_back({d[i][j], {i, j}});\n }\n }\n sort(dirt_cells.rbegin(), dirt_cells.rend()); // descending order\n \n // For high-dirt cells, calculate best place to add a revisit loop\n vector>> loop_candidates;\n for (int idx = 0; idx < min(15, (int)dirt_cells.size()); idx++) {\n int i = dirt_cells[idx].second.first;\n int j = dirt_cells[idx].second.second;\n int dirtiness = dirt_cells[idx].first;\n \n if (visit_times[i][j].empty()) continue;\n \n // Calculate benefit: higher dirtiness cells should be revisited more frequently\n double benefit = dirtiness;\n \n // Consider current revisit frequency (less frequent = higher priority for adding loop)\n double frequency_penalty = visit_times[i][j].size() * 5.0;\n benefit -= frequency_penalty;\n \n // Only consider if benefit is positive\n if (benefit <= 0) continue;\n \n // Find the optimal position to add a loop\n int best_pos = -1;\n int best_dir = -1;\n double best_ratio = 0;\n \n // Try to add a loop after each visit to a neighbor\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (!canMove(i, j, ni, nj)) continue;\n \n // Check all visits to this neighbor\n for (int t : visit_times[ni][nj]) {\n // Calculate cost-benefit ratio\n double ratio = benefit / 2.0; // Cost is 2 moves\n \n if (ratio > best_ratio && result.size() + 2 <= 99500) {\n best_ratio = ratio;\n best_pos = t + 1; // Add after visiting the neighbor\n best_dir = dir;\n }\n }\n }\n \n if (best_dir != -1 && best_ratio > 5.0) {\n loop_candidates.push_back({best_ratio, {i, j}});\n // Store position and direction in a separate structure\n loop_candidates.back().second.first = best_pos;\n loop_candidates.back().second.second = best_dir;\n }\n }\n \n // Sort by benefit/cost ratio\n sort(loop_candidates.rbegin(), loop_candidates.rend());\n \n // Add up to 5 loops with highest benefit/cost ratio\n int loops_added = 0;\n for (int idx = 0; idx < min(5, (int)loop_candidates.size()) && loops_added < 5; idx++) {\n double ratio = loop_candidates[idx].first;\n int best_pos = loop_candidates[idx].second.first;\n int best_dir = loop_candidates[idx].second.second;\n \n // Add the loop (move to cell and back)\n if (best_pos >= 0 && best_pos <= (int)result.size() && best_dir >= 0 && best_dir < 4) {\n string loop = string(1, DIR[best_dir]) + string(1, DIR[(best_dir + 2) % 4]);\n result.insert(best_pos, loop);\n loops_added++;\n \n // Validate after each modification\n if (!validateRoute(result)) {\n // If invalid, revert and continue with next candidate\n result.erase(best_pos, 2);\n loops_added--;\n continue;\n }\n }\n }\n \n return result;\n}\n\n// Try multiple strategies and pick the best\nstring tryMultipleStrategies() {\n vector candidates;\n \n // Strategy 1: Advanced priority DFS\n {\n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n visited[0][0] = true;\n dfs_priority(0, 0, d);\n if (validateRoute(route)) {\n candidates.push_back(route);\n }\n }\n \n // Strategy 2: Simple DFS (row-major order)\n {\n string simple_route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n \n function simple_dfs = [&](int i, int j) {\n visited[i][j] = true;\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !visited[ni][nj]) {\n bool can_move = false;\n if (dir == 0 && j < N-1 && v[i][j] == '0') can_move = true;\n else if (dir == 1 && i < N-1 && h[i][j] == '0') can_move = true;\n else if (dir == 2 && j > 0 && v[i][j-1] == '0') can_move = true;\n else if (dir == 3 && i > 0 && h[i-1][j] == '0') can_move = true;\n \n if (can_move) {\n simple_route += DIR[dir];\n simple_dfs(ni, nj);\n simple_route += DIR[(dir + 2) % 4];\n }\n }\n }\n };\n \n visited[0][0] = true;\n simple_dfs(0, 0);\n if (validateRoute(simple_route)) {\n candidates.push_back(simple_route);\n }\n }\n \n // Strategy 3: Reverse priority (visit low-dirt cells first, high-dirt cells last)\n {\n vector> reverse_d(N, vector(N));\n int max_dirt = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n max_dirt = max(max_dirt, d[i][j]);\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n reverse_d[i][j] = max_dirt - d[i][j] + 1;\n }\n }\n \n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n visited[0][0] = true;\n dfs_priority(0, 0, reverse_d);\n if (validateRoute(route)) {\n candidates.push_back(route);\n }\n }\n \n // Pick the shortest valid route as baseline\n string best_route = \"\";\n if (!candidates.empty()) {\n best_route = candidates[0];\n for (string& candidate : candidates) {\n if (validateRoute(candidate) && (best_route.empty() || candidate.size() < best_route.size())) {\n best_route = candidate;\n }\n }\n }\n \n return best_route;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read input\n cin >> N;\n h.resize(N-1);\n for (int i = 0; i < N-1; i++) {\n cin >> h[i];\n }\n v.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> v[i];\n }\n d.resize(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n // Initialize visited array\n visited = vector>(N, vector(N, false));\n \n // Try multiple strategies and pick the best\n route = tryMultipleStrategies();\n \n // If no strategy worked, use basic DFS\n if (route.empty() || !validateRoute(route)) {\n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n \n function basic_dfs = [&](int i, int j) {\n visited[i][j] = true;\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !visited[ni][nj]) {\n bool can_move = false;\n if (dir == 0 && j < N-1 && v[i][j] == '0') can_move = true;\n else if (dir == 1 && i < N-1 && h[i][j] == '0') can_move = true;\n else if (dir == 2 && j > 0 && v[i][j-1] == '0') can_move = true;\n else if (dir == 3 && i > 0 && h[i-1][j] == '0') can_move = true;\n \n if (can_move) {\n route += DIR[dir];\n basic_dfs(ni, nj);\n route += DIR[(dir + 2) % 4];\n }\n }\n }\n };\n \n visited[0][0] = true;\n basic_dfs(0, 0);\n }\n \n // Add smart loops based on cost-benefit analysis\n string optimized_route = addSmartLoops(route);\n \n // Final validation\n if (!validateRoute(optimized_route) || optimized_route.size() > 100000) {\n optimized_route = route; // Fallback to original route\n }\n \n cout << optimized_route << endl;\n \n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n int distance(const Position& other) const {\n return abs(i - other.i) + abs(j - other.j);\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n};\n\nclass Solution {\nprivate:\n int N, M;\n Position start_pos;\n vector grid;\n vector targets;\n map> char_positions;\n \n // Random number generator\n mt19937 rng;\n \npublic:\n Solution() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n cin >> N >> M;\n cin >> start_pos.i >> start_pos.j;\n grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n targets.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i];\n }\n \n // Build map of character positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char_positions[grid[i][j]].push_back(Position(i, j));\n }\n }\n }\n \n // Find the position with minimum distance from current position\n Position find_best_position(char c, const Position& current) {\n if (char_positions.find(c) == char_positions.end()) {\n return Position(0, 0);\n }\n \n Position best_pos = char_positions[c][0];\n int min_dist = current.distance(best_pos);\n \n for (const Position& pos : char_positions[c]) {\n int dist = current.distance(pos);\n if (dist < min_dist) {\n min_dist = dist;\n best_pos = pos;\n }\n }\n \n return best_pos;\n }\n \n // Calculate overlap between two strings\n int calculate_overlap(const string& s1, const string& s2) {\n int max_overlap = 0;\n int len1 = s1.length();\n int len2 = s2.length();\n \n for (int i = 1; i <= min(len1, len2); i++) {\n bool match = true;\n for (int j = 0; j < i; j++) {\n if (s1[len1 - i + j] != s2[j]) {\n match = false;\n break;\n }\n }\n if (match) {\n max_overlap = i;\n }\n }\n \n return max_overlap;\n }\n \n // Calculate the cost of typing a string from a given position\n long long calculate_string_cost(const string& str, Position current_pos) {\n long long cost = 0;\n for (char c : str) {\n Position best_pos = find_best_position(c, current_pos);\n cost += current_pos.distance(best_pos) + 1;\n current_pos = best_pos;\n }\n return cost;\n }\n \n // Build superstring using improved greedy with multiple scoring metrics\n vector build_superstring_sequence_improved(int strategy) {\n if (M == 0) return {};\n \n vector used(M, false);\n vector result;\n \n // Choose first string based on strategy\n int first_idx = 0;\n \n if (strategy == 0) {\n // Strategy 0: Start with the string that's cheapest to type from start position\n long long min_cost = LLONG_MAX;\n for (int i = 0; i < M; i++) {\n long long cost = calculate_string_cost(targets[i], start_pos);\n if (cost < min_cost) {\n min_cost = cost;\n first_idx = i;\n }\n }\n } else if (strategy == 1) {\n // Strategy 1: Start with string having highest frequency characters\n map char_freq;\n for (int i = 0; i < M; i++) {\n for (char c : targets[i]) {\n char_freq[c]++;\n }\n }\n \n int best_score = -1;\n for (int i = 0; i < M; i++) {\n int score = 0;\n for (char c : targets[i]) {\n score += char_freq[c];\n }\n if (score > best_score) {\n best_score = score;\n first_idx = i;\n }\n }\n } else if (strategy == 2) {\n // Strategy 2: Random start\n first_idx = rng() % M;\n } else {\n // Strategy 3: Start with string that has characters close to start position\n int best_score = INT_MAX;\n for (int i = 0; i < M; i++) {\n int score = 0;\n for (char c : targets[i]) {\n int min_dist = INT_MAX;\n for (const Position& pos : char_positions[c]) {\n min_dist = min(min_dist, start_pos.distance(pos));\n }\n score += min_dist;\n }\n if (score < best_score) {\n best_score = score;\n first_idx = i;\n }\n }\n }\n \n used[first_idx] = true;\n result.push_back(targets[first_idx]);\n \n // Greedily add strings with optimized scoring\n for (int step = 1; step < M; step++) {\n int best_idx = -1;\n double best_score = -1;\n string current_string = result.back();\n \n for (int i = 0; i < M; i++) {\n if (used[i]) continue;\n \n int overlap = calculate_overlap(current_string, targets[i]);\n \n // Simulate end position after typing current string\n Position current_end_pos = start_pos;\n for (char c : current_string) {\n current_end_pos = find_best_position(c, current_end_pos);\n }\n \n // Calculate cost of typing non-overlapping part\n long long non_overlap_cost = 0;\n Position temp_pos = current_end_pos;\n for (int j = overlap; j < targets[i].length(); j++) {\n Position best_pos = find_best_position(targets[i][j], temp_pos);\n non_overlap_cost += temp_pos.distance(best_pos) + 1;\n temp_pos = best_pos;\n }\n \n // Calculate score with multiple factors\n double score = 0.0;\n \n // Factor 1: Overlap benefit (higher overlap = better)\n score += overlap * 100.0;\n \n // Factor 2: Cost penalty (lower cost = better)\n if (non_overlap_cost > 0) {\n score -= non_overlap_cost * 0.5;\n }\n \n // Factor 3: Future potential - how many other strings can overlap with this one\n int future_potential = 0;\n for (int k = 0; k < M; k++) {\n if (used[k]) continue;\n if (k == i) continue;\n int future_overlap = calculate_overlap(targets[i], targets[k]);\n future_potential += future_overlap;\n }\n score += future_potential * 10.0;\n \n if (score > best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n for (int i = 0; i < M; i++) {\n if (!used[i]) {\n best_idx = i;\n break;\n }\n }\n }\n \n used[best_idx] = true;\n result.push_back(targets[best_idx]);\n }\n \n return result;\n }\n \n // Advanced position selection with multi-character look-ahead\n vector generate_operations_advanced(const vector& sequence) {\n vector operations;\n Position current_pos = start_pos;\n \n if (sequence.empty()) return operations;\n \n // Process each string in sequence\n for (int seq_idx = 0; seq_idx < sequence.size(); seq_idx++) {\n const string& str = sequence[seq_idx];\n \n // Calculate overlap with previous string\n int start_char_idx = 0;\n if (seq_idx > 0) {\n const string& prev = sequence[seq_idx - 1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n // Type characters with advanced position selection\n for (int j = start_char_idx; j < str.length(); j++) {\n char c = str[j];\n \n // If we have multiple positions and characters remaining, use look-ahead\n if (char_positions[c].size() > 1 && j < str.length() - 1) {\n Position best_pos = char_positions[c][0];\n double best_score = 1e9;\n \n // Look ahead up to 2 characters\n int look_ahead = min(2, (int)str.length() - j - 1);\n \n for (const Position& pos : char_positions[c]) {\n double score = current_pos.distance(pos) + 1; // cost to move to this position\n \n // Simulate future costs\n Position future_pos = pos;\n for (int k = 1; k <= look_ahead; k++) {\n char future_char = str[j + k];\n Position future_best = find_best_position(future_char, future_pos);\n score += future_pos.distance(future_best) + 1;\n future_pos = future_best;\n }\n \n // Also consider overall grid distribution - prefer central positions\n double centrality_bonus = abs(pos.i - N/2) + abs(pos.j - N/2);\n score += centrality_bonus * 0.1; // slight penalty for edge positions\n \n if (score < best_score) {\n best_score = score;\n best_pos = pos;\n }\n }\n \n operations.push_back(best_pos);\n current_pos = best_pos;\n } else {\n // Simple case: just pick closest position\n Position best_pos = find_best_position(c, current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n }\n }\n \n return operations;\n }\n \n // Calculate total cost of operations\n long long calculate_total_cost(const vector& operations) {\n long long cost = 0;\n Position current_pos = start_pos;\n for (const Position& op : operations) {\n cost += current_pos.distance(op) + 1;\n current_pos = op;\n }\n return cost;\n }\n \n // Try to locally optimize the solution by adjusting positions\n vector local_optimization(const vector& original_ops, const vector& sequence) {\n if (original_ops.empty()) return original_ops;\n \n vector optimized = original_ops;\n long long original_cost = calculate_total_cost(original_ops);\n long long best_cost = original_cost;\n vector best_ops = original_ops;\n \n // Try random perturbations\n for (int trial = 0; trial < 10; trial++) {\n vector candidate = original_ops;\n \n // Randomly adjust some positions\n int num_adjustments = min(5, (int)candidate.size() / 10);\n for (int adj = 0; adj < num_adjustments; adj++) {\n int idx = rng() % candidate.size();\n \n // Find the character that should be at this position\n char target_char = '?';\n int op_idx = 0;\n int seq_idx = 0;\n int char_idx = 0;\n \n // Reconstruct which character corresponds to this operation\n Position current_pos = start_pos;\n for (int i = 0; i < sequence.size(); i++) {\n const string& str = sequence[i];\n int start_char_idx = 0;\n \n if (i > 0) {\n const string& prev = sequence[i-1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n for (int j = start_char_idx; j < str.length(); j++) {\n if (op_idx == idx) {\n target_char = str[j];\n break;\n }\n op_idx++;\n }\n \n if (target_char != '?') break;\n }\n \n if (target_char != '?' && char_positions[target_char].size() > 1) {\n // Try a different position for this character\n Position current_context_pos = start_pos;\n if (idx > 0) {\n current_context_pos = candidate[idx - 1];\n } else {\n current_context_pos = start_pos;\n }\n \n Position prev_best = candidate[idx];\n Position new_best = find_best_position(target_char, current_context_pos);\n \n // Try to find a different position (not the closest one)\n for (const Position& pos : char_positions[target_char]) {\n if (pos.i != prev_best.i || pos.j != prev_best.j) {\n if (current_context_pos.distance(pos) <= current_context_pos.distance(prev_best) + 3) {\n // Only consider if not too much worse\n new_best = pos;\n break;\n }\n }\n }\n \n candidate[idx] = new_best;\n }\n }\n \n long long new_cost = calculate_total_cost(candidate);\n if (new_cost < best_cost) {\n best_cost = new_cost;\n best_ops = candidate;\n }\n }\n \n return best_ops;\n }\n \n // Main solve function with comprehensive strategies\n void solve() {\n vector best_operations;\n long long best_cost = LLONG_MAX;\n vector best_sequence;\n \n // Try different strategies for building sequence\n for (int strategy = 0; strategy < 4; strategy++) {\n vector sequence = build_superstring_sequence_improved(strategy);\n vector operations = generate_operations_advanced(sequence);\n \n // Try local optimization\n vector optimized_ops = local_optimization(operations, sequence);\n long long cost = calculate_total_cost(optimized_ops);\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = optimized_ops;\n best_sequence = sequence;\n }\n }\n \n // Try additional random trials\n for (int trial = 0; trial < 5; trial++) {\n vector sequence = build_superstring_sequence_improved(2); // random strategy\n vector operations = generate_operations_advanced(sequence);\n \n vector optimized_ops = local_optimization(operations, sequence);\n long long cost = calculate_total_cost(optimized_ops);\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = optimized_ops;\n best_sequence = sequence;\n }\n }\n \n // One final optimization pass\n if (!best_operations.empty()) {\n vector final_optimized = local_optimization(best_operations, best_sequence);\n long long final_cost = calculate_total_cost(final_optimized);\n if (final_cost < best_cost) {\n best_operations = final_optimized;\n }\n }\n \n // Output the best operations\n for (const Position& pos : best_operations) {\n cout << pos.i << \" \" << pos.j << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n Solution solution;\n solution.solve();\n \n return 0;\n}","ahc030":"#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 double EPS = 1e-9;\n\n// Helper functions\ndouble square(double x) { return x * x; }\n\nstruct Point {\n int i, j;\n Point(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Point& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Point& other) const {\n return i == other.i && j == other.j;\n }\n};\n\n// Oil field representation\nstruct OilField {\n vector shape;\n int size;\n int max_i, max_j; // max coordinates in the shape\n};\n\nclass Solver {\nprivate:\n int N, M;\n double epsilon;\n vector oil_fields;\n vector> known_values; // -1 means unknown\n vector> probability; // probability that square has oil\n vector> confidence; // confidence in probability estimate\n mt19937 rng;\n \n // Tracking for optimization\n int operations_used = 0;\n double total_cost = 0.0;\n set known_oil_squares;\n set candidate_oil_squares;\n \n // For divination noise modeling\n double expected_value(int k, int actual_sum) {\n return (k - actual_sum) * epsilon + actual_sum * (1 - epsilon);\n }\n \n double variance(int k) {\n return k * epsilon * (1 - epsilon);\n }\n \n // Read input\n void read_input() {\n cin >> N >> M >> epsilon;\n \n oil_fields.resize(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n oil_fields[k].shape.resize(d);\n oil_fields[k].size = d;\n \n int min_i = 1000, min_j = 1000, max_i = -1, max_j = -1;\n for (int i = 0; i < d; i++) {\n int ii, jj;\n cin >> ii >> jj;\n oil_fields[k].shape[i] = Point(ii, jj);\n min_i = min(min_i, ii);\n min_j = min(min_j, jj);\n max_i = max(max_i, ii);\n max_j = max(max_j, jj);\n }\n \n // Translate to ensure top-left is (0,0) - already done in input\n oil_fields[k].max_i = max_i;\n oil_fields[k].max_j = max_j;\n }\n \n // Initialize known values and probability\n known_values.assign(N, vector(N, -1));\n probability.assign(N, vector(N, 0.5)); // Start with 50% probability\n confidence.assign(N, vector(N, 0.0)); // Start with 0 confidence\n \n // Initialize candidate squares (all possible positions for all oil fields)\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n candidate_oil_squares.insert(Point(i, j));\n }\n }\n }\n \n // Drill at point (i, j)\n int drill(int i, int j) {\n if (operations_used >= 2 * N * N) return -1;\n \n cout << \"q 1 \" << i << \" \" << j << endl;\n operations_used++;\n total_cost += 1.0;\n \n int value;\n cin >> value;\n \n known_values[i][j] = value;\n if (value > 0) {\n known_oil_squares.insert(Point(i, j));\n probability[i][j] = 1.0;\n confidence[i][j] = 1.0;\n } else {\n probability[i][j] = 0.0;\n confidence[i][j] = 1.0;\n }\n \n return value;\n }\n \n // Divine the sum of values in set S\n int divine(const vector& points) {\n if (points.size() < 2 || operations_used >= 2 * N * N) return -1;\n \n cout << \"q \" << points.size();\n for (const Point& p : points) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n operations_used++;\n total_cost += 1.0 / sqrt(points.size());\n \n int result;\n cin >> result;\n \n // Update probabilities based on result\n update_probabilities_from_divine(points, result);\n \n return result;\n }\n \n // Update probabilities based on divine result\n void update_probabilities_from_divine(const vector& points, int result) {\n if (result < 0) return;\n \n // Simple Bayesian update - adjust probabilities to be more consistent with result\n double current_sum_estimate = 0.0;\n for (const Point& p : points) {\n current_sum_estimate += probability[p.i][p.j];\n }\n \n double adjustment = (result - current_sum_estimate) / points.size();\n \n for (const Point& p : points) {\n if (known_values[p.i][p.j] == -1) { // Only update unknown squares\n probability[p.i][p.j] = max(0.0, min(1.0, probability[p.i][p.j] + adjustment * 0.5));\n confidence[p.i][p.j] = min(1.0, confidence[p.i][p.j] + 0.1);\n }\n }\n }\n \n // Check if point is valid\n bool is_valid_point(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n }\n \n // Check if oil field can be placed at (offset_i, offset_j)\n bool can_place_field(const OilField& field, int offset_i, int offset_j) {\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (!is_valid_point(i, j)) return false;\n // If we know this square has no oil, we can't place the field here\n if (known_values[i][j] == 0) return false;\n }\n return true;\n }\n \n // Calculate score for placing oil field at (offset_i, offset_j)\n double score_field_placement(const OilField& field, int offset_i, int offset_j) {\n if (!can_place_field(field, offset_i, offset_j)) return -1e9;\n \n double score = 0.0;\n for (const Point& p : field.shape) {\n int i = p.i + offset_i;\n int j = p.j + offset_j;\n if (known_values[i][j] > 0) {\n // We know there's oil here, good!\n score += 10.0;\n } else if (known_values[i][j] == 0) {\n // We know there's no oil here, impossible\n return -1e9;\n } else {\n // Unknown, use probability\n score += probability[i][j];\n }\n }\n return score;\n }\n \n // Get all possible placements for an oil field\n vector> get_possible_placements(const OilField& field) {\n vector> placements;\n \n for (int i = 0; i <= N - 1 - field.max_i; i++) {\n for (int j = 0; j <= N - 1 - field.max_j; j++) {\n double score = score_field_placement(field, i, j);\n if (score > -1e8) {\n placements.push_back({Point(i, j), score});\n }\n }\n }\n \n // Sort by score\n sort(placements.begin(), placements.end(), [](const auto& a, const auto& b) {\n return a.second > b.second;\n });\n \n return placements;\n }\n \n // Phase 1: Coarse search with divination\n void phase1_coarse_search() {\n // Use larger blocks for divination\n int block_size = max(2, N / 4);\n \n for (int bi = 0; bi < N; bi += block_size) {\n for (int bj = 0; bj < N; bj += block_size) {\n if (operations_used >= 2 * N * N) return;\n \n vector block_points;\n for (int i = bi; i < min(bi + block_size, N); i++) {\n for (int j = bj; j < min(bj + block_size, N); j++) {\n if (known_values[i][j] == -1) { // Only include unknown squares\n block_points.push_back(Point(i, j));\n }\n }\n }\n \n // If we have at least 2 unknown points, divine the block\n if (block_points.size() >= 2) {\n int result = divine(block_points);\n // Results are processed in divine() via update_probabilities_from_divine\n }\n }\n }\n }\n \n // Phase 2: Targeted search based on probabilities\n void phase2_targeted_search() {\n // Create a priority queue of squares to investigate based on uncertainty and probability\n vector> candidates;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n // Prioritize squares with moderate confidence and high probability\n // We want to investigate squares that are likely to have oil but we're not sure\n double uncertainty = 1.0 - confidence[i][j];\n double priority = probability[i][j] * uncertainty;\n candidates.push_back({priority, Point(i, j)});\n }\n }\n }\n \n // Sort by priority\n sort(candidates.begin(), candidates.end(), greater>());\n \n // Investigate top candidates\n int to_investigate = min(20, (int)candidates.size());\n for (int idx = 0; idx < to_investigate; idx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& p = candidates[idx].second;\n \n // If probability is very high, drill directly\n if (probability[p.i][p.j] > 0.7) {\n drill(p.i, p.j);\n } \n // Otherwise, try to group with nearby squares for divination\n else {\n vector nearby;\n nearby.push_back(p);\n \n // Add nearby squares\n for (int di = -1; di <= 1; di++) {\n for (int dj = -1; dj <= 1; dj++) {\n if (di == 0 && dj == 0) continue;\n int ni = p.i + di, nj = p.j + dj;\n if (is_valid_point(ni, nj) && known_values[ni][nj] == -1) {\n nearby.push_back(Point(ni, nj));\n }\n }\n }\n \n // If we have at least 2 squares, divine them\n if (nearby.size() >= 2 && nearby.size() <= 8) { // Limit size to reduce noise\n divine(nearby);\n } else {\n // Otherwise just drill this square\n drill(p.i, p.j);\n }\n }\n }\n }\n \n // Phase 3: Use shape information to guide search\n void phase3_shape_guided_search() {\n // For each oil field, find the most likely placements\n for (int fidx = 0; fidx < M; fidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const OilField& field = oil_fields[fidx];\n auto placements = get_possible_placements(field);\n \n if (placements.empty()) continue;\n \n // Try the top few placements\n int to_try = min(3, (int)placements.size());\n for (int pidx = 0; pidx < to_try; pidx++) {\n if (operations_used >= 2 * N * N) break;\n \n const Point& offset = placements[pidx].first;\n \n // Check if we can verify this placement\n bool need_verification = false;\n vector unknown_points;\n \n for (const Point& p : field.shape) {\n int i = p.i + offset.i;\n int j = p.j + offset.j;\n if (known_values[i][j] == -1) {\n need_verification = true;\n unknown_points.push_back(Point(i, j));\n }\n }\n \n if (!need_verification) continue; // Already verified or impossible\n \n // Try to verify with minimum operations\n if (unknown_points.size() == 1) {\n // Just drill the single unknown point\n const Point& pt = unknown_points[0];\n drill(pt.i, pt.j);\n } else if (unknown_points.size() <= 6) {\n // Divine the unknown points together\n divine(unknown_points);\n } else {\n // Drill the point with highest probability among unknowns\n Point best_point = unknown_points[0];\n double best_prob = probability[best_point.i][best_point.j];\n \n for (const Point& pt : unknown_points) {\n if (probability[pt.i][pt.j] > best_prob) {\n best_prob = probability[pt.i][pt.j];\n best_point = pt;\n }\n }\n \n drill(best_point.i, best_point.j);\n }\n }\n }\n }\n \n // Make final guess\n bool make_guess() {\n vector oil_squares;\n \n // Include all known oil squares\n for (const Point& p : known_oil_squares) {\n oil_squares.push_back(p);\n }\n \n // Include squares with high probability\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1 && probability[i][j] > 0.5) {\n oil_squares.push_back(Point(i, j));\n }\n }\n }\n \n // Remove duplicates (shouldn't happen but just in case)\n sort(oil_squares.begin(), oil_squares.end());\n oil_squares.erase(unique(oil_squares.begin(), oil_squares.end()), oil_squares.end());\n \n // Output guess\n cout << \"a \" << oil_squares.size();\n for (const Point& p : oil_squares) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n \n int result;\n cin >> result;\n \n return result == 1;\n }\n \n // Refine probabilities using shape constraints\n void refine_probabilities_with_shapes() {\n // For each square, calculate the probability based on possible oil field placements\n vector> new_prob(N, vector(N, 0.0));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] != -1) {\n new_prob[i][j] = (known_values[i][j] > 0) ? 1.0 : 0.0;\n continue;\n }\n \n double prob = 0.0;\n int count = 0;\n \n // Check how many oil fields could cover this square\n for (const OilField& field : oil_fields) {\n for (int oi = 0; oi <= N - 1 - field.max_i; oi++) {\n for (int oj = 0; oj <= N - 1 - field.max_j; oj++) {\n // Check if field can be placed at (oi, oj)\n if (!can_place_field(field, oi, oj)) continue;\n \n // Check if this square is covered by this placement\n bool covers = false;\n for (const Point& p : field.shape) {\n if (p.i + oi == i && p.j + oj == j) {\n covers = true;\n break;\n }\n }\n \n if (covers) {\n double placement_score = score_field_placement(field, oi, oj);\n if (placement_score > 0) {\n prob += min(1.0, placement_score / field.size);\n count++;\n }\n }\n }\n }\n }\n \n if (count > 0) {\n new_prob[i][j] = min(1.0, prob / count * 0.8 + probability[i][j] * 0.2);\n } else {\n new_prob[i][j] = probability[i][j];\n }\n }\n }\n \n // Update probabilities\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n probability[i][j] = new_prob[i][j];\n }\n }\n }\n }\n \npublic:\n Solver() : rng(random_device{}()) {}\n \n void solve() {\n read_input();\n \n // Phase 1: Coarse search with divination on large blocks\n phase1_coarse_search();\n \n // Phase 2: Refine with targeted search\n phase2_targeted_search();\n \n // Phase 3: Use shape information\n phase3_shape_guided_search();\n \n // Refine probabilities using shape constraints\n refine_probabilities_with_shapes();\n \n // Additional iterations if we have operations left\n while (operations_used < 2 * N * N) {\n // Check if we have high confidence in our answer\n int unknown_count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (known_values[i][j] == -1) {\n unknown_count++;\n }\n }\n }\n \n // If few unknowns, drill them directly\n if (unknown_count <= max(5, N/2)) {\n for (int i = 0; i < N && operations_used < 2 * N * N; i++) {\n for (int j = 0; j < N && operations_used < 2 * N * N; j++) {\n if (known_values[i][j] == -1) {\n drill(i, j);\n }\n }\n }\n } else {\n // Do another round of targeted search\n phase2_targeted_search();\n if (operations_used >= 2 * N * N) break;\n \n // Use shape information again\n phase3_shape_guided_search();\n if (operations_used >= 2 * N * N) break;\n \n // Refine probabilities\n refine_probabilities_with_shapes();\n }\n }\n \n // Make final guess\n bool success = make_guess();\n \n // If we failed, we could try again but we're out of operations\n // So just exit\n }\n};\n\nint main() {\n Solver solver;\n solver.solve();\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int i0, j0, i1, j1;\n \n Rectangle() : i0(0), j0(0), i1(0), j1(0) {}\n Rectangle(int i0, int j0, int i1, int j1) : i0(i0), j0(j0), i1(i1), j1(j1) {}\n \n int area() const {\n return (i1 - i0) * (j1 - j0);\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(i1 <= other.i0 || i0 >= other.i1 || j1 <= other.j0 || j0 >= other.j1);\n }\n \n // Check if rectangle is valid (within bounds and has positive area)\n bool isValid(int W) const {\n return i0 >= 0 && j0 >= 0 && i1 <= W && j1 <= W && i0 < i1 && j0 < j1;\n }\n};\n\nclass PartitionManager {\nprivate:\n int W;\n vector> horizontal_partitions; // [i][j] for horizontal partition at (i,j)-(i,j+1)\n vector> vertical_partitions; // [i][j] for vertical partition at (i,j)-(i+1,j)\n \npublic:\n PartitionManager(int W) : W(W) {\n horizontal_partitions.assign(W, vector(W, false));\n vertical_partitions.assign(W, vector(W, false));\n }\n \n void updateFromRectangles(const vector& rectangles) {\n // Reset all partitions\n for (int i = 0; i < W; i++) {\n fill(horizontal_partitions[i].begin(), horizontal_partitions[i].end(), false);\n fill(vertical_partitions[i].begin(), vertical_partitions[i].end(), false);\n }\n \n // Set partitions based on rectangles\n for (const auto& rect : rectangles) {\n // Top edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i0 > 0) vertical_partitions[rect.i0 - 1][j] = true;\n }\n // Bottom edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i1 < W) vertical_partitions[rect.i1 - 1][j] = true;\n }\n // Left edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j0 > 0) horizontal_partitions[i][rect.j0 - 1] = true;\n }\n // Right edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j1 < W) horizontal_partitions[i][rect.j1 - 1] = true;\n }\n }\n }\n \n int calculateChangeCost(const PartitionManager& prev) const {\n int cost = 0;\n \n // Horizontal partitions (i,j)-(i,j+1) where 1<=i<=W-1, 0<=j<=W-1\n for (int i = 1; i < W; i++) {\n for (int j = 0; j < W; j++) {\n if (horizontal_partitions[i-1][j] != prev.horizontal_partitions[i-1][j]) {\n cost++;\n }\n }\n }\n \n // Vertical partitions (i,j)-(i+1,j) where 0<=i<=W-1, 1<=j<=W-1\n for (int i = 0; i < W; i++) {\n for (int j = 1; j < W; j++) {\n if (vertical_partitions[i][j-1] != prev.vertical_partitions[i][j-1]) {\n cost++;\n }\n }\n }\n \n return cost;\n }\n};\n\nclass Solution {\nprivate:\n int W, D, N;\n vector> desired_areas;\n vector> solution;\n mt19937 rng;\n \npublic:\n Solution(int W, int D, int N, vector>&& areas) \n : W(W), D(D), N(N), desired_areas(move(areas)), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n solution.resize(D, vector(N));\n }\n \n // Calculate rental cost for a day\n long long calculateRentalCost(int day) const {\n long long cost = 0;\n for (int k = 0; k < N; k++) {\n int actual_area = solution[day][k].area();\n if (desired_areas[day][k] > actual_area) {\n cost += 100LL * (desired_areas[day][k] - actual_area);\n }\n }\n return cost;\n }\n \n // Calculate partition change cost for a day\n long long calculatePartitionCost(int day) const {\n if (day == 0) return 0;\n \n PartitionManager current(W), prev(W);\n current.updateFromRectangles(solution[day]);\n prev.updateFromRectangles(solution[day-1]);\n \n return current.calculateChangeCost(prev);\n }\n \n // Calculate total cost\n long long calculateTotalCost() const {\n long long total_cost = 0;\n for (int d = 0; d < D; d++) {\n total_cost += calculateRentalCost(d);\n total_cost += calculatePartitionCost(d);\n }\n return total_cost;\n }\n \n // Check if any rectangles on a day overlap\n bool hasOverlap(int day) const {\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (solution[day][i].overlaps(solution[day][j])) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Initialize day 0 with simple row-wise division\n void initializeDay0() {\n int total_height = W;\n vector heights(N);\n \n // Calculate heights proportional to desired areas\n long long total_desired = 0;\n for (int k = 0; k < N; k++) {\n total_desired += desired_areas[0][k];\n }\n \n int allocated_height = 0;\n for (int k = 0; k < N - 1; k++) {\n heights[k] = max(1, (int)((long long)desired_areas[0][k] * total_height / total_desired));\n allocated_height += heights[k];\n }\n heights[N-1] = total_height - allocated_height;\n if (heights[N-1] <= 0) {\n heights[N-1] = 1;\n // Adjust other heights if needed\n for (int k = 0; k < N-1 && allocated_height >= total_height; k++) {\n if (heights[k] > 1) {\n heights[k]--;\n allocated_height--;\n if (allocated_height < total_height) break;\n }\n }\n }\n \n // Create rectangles\n int current_i = 0;\n for (int k = 0; k < N; k++) {\n solution[0][k] = Rectangle(current_i, 0, current_i + heights[k], W);\n current_i += heights[k];\n }\n }\n \n // More robust overlap resolution\n void resolveOverlaps(int day) {\n const int MAX_ITERATIONS = 100;\n int iteration = 0;\n \n while (hasOverlap(day) && iteration < MAX_ITERATIONS) {\n iteration++;\n \n // Create a copy of current solution\n vector temp_solution = solution[day];\n \n // Find the first overlapping pair\n int overlap_i = -1, overlap_j = -1;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (temp_solution[i].overlaps(temp_solution[j])) {\n overlap_i = i;\n overlap_j = j;\n break;\n }\n }\n if (overlap_i != -1) break;\n }\n \n if (overlap_i == -1) break; // No more overlaps\n \n Rectangle& r1 = temp_solution[overlap_i];\n Rectangle& r2 = temp_solution[overlap_j];\n \n // Try different strategies to resolve overlap\n \n // Strategy 1: Move r2 to the right of r1\n if (r1.j1 < W) {\n int new_j0 = r1.j1;\n if (new_j0 < r2.j1) { // Ensure positive width\n int width = r2.j1 - r2.j0;\n if (new_j0 + width <= W) {\n r2.j0 = new_j0;\n r2.j1 = new_j0 + width;\n }\n }\n }\n \n // Check if overlap is resolved\n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 2: Move r2 below r1\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n if (r1.i1 < W) {\n int new_i0 = r1.i1;\n if (new_i0 < r2.i1) { // Ensure positive height\n int height = r2.i1 - r2.i0;\n if (new_i0 + height <= W) {\n r2.i0 = new_i0;\n r2.i1 = new_i0 + height;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 3: Shrink r2\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Calculate overlap region\n int overlap_i0 = max(r1.i0, r2.i0);\n int overlap_i1 = min(r1.i1, r2.i1);\n int overlap_j0 = max(r1.j0, r2.j0);\n int overlap_j1 = min(r1.j1, r2.j1);\n \n // Try to shrink r2 from the side that has the least impact\n if (overlap_j1 - overlap_j0 > 0 && overlap_i1 - overlap_i0 > 0) {\n // Prefer to shrink in the direction with smaller dimension\n if (r2.j1 - r2.j0 < r2.i1 - r2.i0) {\n // Shrink horizontally\n if (r2.j0 == overlap_j0) {\n r2.j0 = overlap_j1;\n } else {\n r2.j1 = overlap_j0;\n }\n } else {\n // Shrink vertically\n if (r2.i0 == overlap_i0) {\n r2.i0 = overlap_i1;\n } else {\n r2.i1 = overlap_i0;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 4: Try to move r1 instead\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Move r1 to left of r2\n if (r2.j0 > 0) {\n int width = r1.j1 - r1.j0;\n if (r2.j0 - width >= 0) {\n r1.j0 = r2.j0 - width;\n r1.j1 = r2.j0;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // If no strategy works, try to resize one of the rectangles\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Shrink r2 to eliminate overlap\n if (r2.j1 > r1.j0 && r2.j0 < r1.j1) {\n // Horizontal overlap\n if (r2.j0 < r1.j0) {\n r2.j1 = r1.j0;\n } else {\n r2.j0 = r1.j1;\n }\n }\n \n if (r2.i1 > r1.i0 && r2.i0 < r1.i1) {\n // Vertical overlap\n if (r2.i0 < r1.i0) {\n r2.i1 = r1.i0;\n } else {\n r2.i0 = r1.i1;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Last resort: just separate them arbitrarily\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Force separation\n r2.j0 = r1.j1;\n r2.j1 = r2.j0 + max(1, r2.j1 - r2.j0);\n if (r2.j1 > W) {\n r2.j1 = W;\n r2.j0 = max(0, r2.j1 - max(1, r2.j1 - r2.j0));\n }\n \n if (r1.overlaps(r2)) {\n r2.i0 = r1.i1;\n r2.i1 = r2.i0 + max(1, r2.i1 - r2.i0);\n if (r2.i1 > W) {\n r2.i1 = W;\n r2.i0 = max(0, r2.i1 - max(1, r2.i1 - r2.i0));\n }\n }\n \n if (r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n }\n }\n \n // Final validation\n if (hasOverlap(day)) {\n // If still overlapping, use a more drastic approach\n // Arrange rectangles in a grid\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // For subsequent days, start with previous day's solution and adjust\n void optimizeDay(int day) {\n // Start with previous day's configuration\n solution[day] = solution[day-1];\n \n // Calculate current areas\n vector current_areas(N);\n for (int k = 0; k < N; k++) {\n current_areas[k] = solution[day][k].area();\n }\n \n // Identify rectangles that need adjustment\n vector needs_more_area;\n for (int k = 0; k < N; k++) {\n if (current_areas[k] < desired_areas[day][k]) {\n needs_more_area.push_back(k);\n }\n }\n \n // Simple adjustment: try to expand rectangles that need more area\n for (int k : needs_more_area) {\n int deficit = desired_areas[day][k] - current_areas[k];\n if (deficit <= 0) continue;\n \n Rectangle original_rect = solution[day][k];\n Rectangle& rect = solution[day][k];\n \n // Try different expansion strategies\n \n // Strategy 1: Expand right\n if (rect.j1 < W) {\n int can_expand = W - rect.j1;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j1 += expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 2: Expand down\n if (deficit > 0 && rect.i1 < W) {\n int can_expand = W - rect.i1;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i1 += expand_by;\n deficit -= expand_by * width;\n }\n \n // Strategy 3: Expand left\n if (deficit > 0 && rect.j0 > 0) {\n int can_expand = rect.j0;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j0 -= expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 4: Expand up\n if (deficit > 0 && rect.i0 > 0) {\n int can_expand = rect.i0;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i0 -= expand_by;\n deficit -= expand_by * width;\n }\n \n // Ensure rectangle is valid\n if (!rect.isValid(W)) {\n solution[day][k] = original_rect;\n }\n }\n \n // Check for overlaps and resolve them\n resolveOverlaps(day);\n \n // Verify no overlaps remain\n if (hasOverlap(day)) {\n // Fallback: use grid arrangement\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // Local search optimization for a day (with proper overlap checking)\n void localSearchDay(int day, int iterations = 50) {\n // Keep track of the best solution\n auto best_solution = solution[day];\n long long best_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n for (int iter = 0; iter < iterations; iter++) {\n // Make a small random change\n auto current_solution = solution[day];\n \n // Select a random rectangle to modify\n int k = uniform_int_distribution(0, N-1)(rng);\n Rectangle original_rect = current_solution[k];\n Rectangle& rect = current_solution[k];\n \n // Randomly adjust one of the boundaries\n int change_type = uniform_int_distribution(0, 3)(rng);\n int change_amount = uniform_int_distribution(-3, 3)(rng);\n \n // Skip if change_amount is 0\n if (change_amount == 0) continue;\n \n switch (change_type) {\n case 0: // Adjust top\n rect.i0 += change_amount;\n break;\n case 1: // Adjust left\n rect.j0 += change_amount;\n break;\n case 2: // Adjust bottom\n rect.i1 += change_amount;\n break;\n case 3: // Adjust right\n rect.j1 += change_amount;\n break;\n }\n \n // Validate the rectangle\n if (!rect.isValid(W)) {\n current_solution[k] = original_rect;\n }\n \n // Check for overlaps\n bool has_overlap = false;\n for (int i = 0; i < N && !has_overlap; i++) {\n for (int j = i + 1; j < N && !has_overlap; j++) {\n if (current_solution[i].overlaps(current_solution[j])) {\n has_overlap = true;\n }\n }\n }\n \n if (!has_overlap) {\n // Calculate new cost\n auto temp_solution = solution[day];\n solution[day] = current_solution;\n long long new_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n // Accept if better\n if (new_cost < best_cost) {\n best_solution = current_solution;\n best_cost = new_cost;\n }\n \n // Revert for next iteration\n solution[day] = temp_solution;\n }\n }\n \n // Set the best solution found\n solution[day] = best_solution;\n \n // Final overlap check\n if (hasOverlap(day)) {\n resolveOverlaps(day);\n }\n }\n \n void solve() {\n // Initialize day 0\n initializeDay0();\n \n // Ensure no overlaps on day 0\n resolveOverlaps(0);\n \n // Optimize subsequent days\n for (int d = 1; d < D; d++) {\n optimizeDay(d);\n // Apply local search for further improvement\n localSearchDay(d, 30);\n \n // Final validation\n if (hasOverlap(d)) {\n resolveOverlaps(d);\n }\n }\n }\n \n void output() const {\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cout << solution[d][k].i0 << \" \" \n << solution[d][k].j0 << \" \" \n << solution[d][k].i1 << \" \" \n << solution[d][k].j1 << endl;\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int W, D, N;\n cin >> W >> D >> N;\n \n vector> areas(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> areas[d][k];\n }\n }\n \n Solution solver(W, D, N, move(areas));\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\n// Calculate improvement from applying a stamp at position (p,q)\nlong long calculateImprovement(const vector>& board, \n const vector>& stamp,\n int p, int q) {\n long long improvement = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n long long current_remainder = board[p + i][q + j] % MOD;\n long long new_remainder = (board[p + i][q + j] + stamp[i][j]) % MOD;\n improvement += (new_remainder - current_remainder);\n }\n }\n return improvement;\n}\n\n// Apply a stamp operation to a board (modifies the board)\nvoid applyStamp(vector>& board, \n const vector>& stamp,\n int p, int q) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n board[p + i][q + j] += stamp[i][j];\n }\n }\n}\n\n// Calculate position value (center positions are more valuable)\ndouble calculatePositionValue(int p, int q, int N) {\n int center_p = (N - 3) / 2;\n int center_q = (N - 3) / 2;\n int dist = abs(p - center_p) + abs(q - center_q);\n // Center positions have higher value\n return 1.0 + (6.0 - dist) * 0.05;\n}\n\n// Calculate stamp value\nlong long calculateStampValue(const vector>& stamp) {\n long long value = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n value += stamp[i][j];\n }\n }\n return value;\n}\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n \n // Read initial board\n vector> board(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> board[i][j];\n }\n }\n \n // Read stamps\n vector>> stamps(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n cin >> stamps[m][i][j];\n }\n }\n }\n \n // Calculate stamp values for prioritization\n vector stamp_values(M);\n for (int m = 0; m < M; m++) {\n stamp_values[m] = calculateStampValue(stamps[m]);\n }\n \n // Store operations\n vector> operations;\n \n // Greedy selection of operations\n for (int op = 0; op < K; op++) {\n long long best_improvement = -1e18;\n int best_stamp = -1, best_p = -1, best_q = -1;\n \n // Calculate current score for adaptive decisions\n long long current_total_score = 0;\n int cells_near_limit = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n current_total_score += board[i][j] % MOD;\n if ((board[i][j] % MOD) > MOD / 2) {\n cells_near_limit++;\n }\n }\n }\n \n // Use 2-step lookahead for early operations or when many cells are near limit\n bool use_lookahead = (op < 25) || (cells_near_limit > 20);\n \n if (use_lookahead) {\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n // Create a copy of the board\n vector> temp_board = board;\n applyStamp(temp_board, stamps[m], p, q);\n \n // Find best second operation\n long long best_second_improvement = -1e18;\n for (int m2 = 0; m2 < M; m2++) {\n for (int p2 = 0; p2 <= N - 3; p2++) {\n for (int q2 = 0; q2 <= N - 3; q2++) {\n long long improvement = calculateImprovement(temp_board, stamps[m2], p2, q2);\n if (improvement > best_second_improvement) {\n best_second_improvement = improvement;\n }\n }\n }\n }\n \n // Calculate total improvement\n long long first_improvement = calculateImprovement(board, stamps[m], p, q);\n double position_value = calculatePositionValue(p, q, N);\n double stamp_priority = 1.0 + (stamp_values[m] * 0.000000001); // Small bonus for high-value stamps\n \n double total_improvement = static_cast(first_improvement) * position_value * stamp_priority + \n max(0.0, static_cast(best_second_improvement) * 0.8);\n \n if (static_cast(total_improvement) > best_improvement) {\n best_improvement = static_cast(total_improvement);\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n } else {\n // Simple greedy for remaining operations\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n long long improvement = calculateImprovement(board, stamps[m], p, q);\n double position_value = calculatePositionValue(p, q, N);\n double stamp_priority = 1.0 + (stamp_values[m] * 0.000000001);\n \n long long weighted_improvement = static_cast(static_cast(improvement) * position_value * stamp_priority);\n \n if (weighted_improvement > best_improvement) {\n best_improvement = weighted_improvement;\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n }\n \n // Apply the best operation\n applyStamp(board, stamps[best_stamp], best_p, best_q);\n \n // Record the operation\n operations.push_back(make_tuple(best_stamp, best_p, best_q));\n }\n \n // Enhanced local search: try swapping operations (not just adjacent)\n for (int i = 0; i < static_cast(operations.size()) - 1; i++) {\n for (int j = i + 1; j < static_cast(operations.size()); j++) {\n if (j > i + 3) break; // Limit to nearby operations for efficiency\n \n // Create a copy of the board in state before operation i\n vector> temp_board = board;\n \n // Reverse all operations from end to i\n for (int k = static_cast(operations.size()) - 1; k >= i; k--) {\n int m = get<0>(operations[k]);\n int p = get<1>(operations[k]);\n int q = get<2>(operations[k]);\n for (int x = 0; x < 3; x++) {\n for (int y = 0; y < 3; y++) {\n temp_board[p + x][q + y] -= stamps[m][x][y];\n }\n }\n }\n \n // Create a temporary operations vector for testing\n vector> temp_operations = operations;\n \n // Swap operations i and j\n swap(temp_operations[i], temp_operations[j]);\n \n // Apply operations from i to end\n vector> test_board = temp_board;\n for (int k = i; k < static_cast(temp_operations.size()); k++) {\n int m = get<0>(temp_operations[k]);\n int p = get<1>(temp_operations[k]);\n int q = get<2>(temp_operations[k]);\n applyStamp(test_board, stamps[m], p, q);\n }\n \n // Calculate score with swap\n long long score_with_swap = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n score_with_swap += test_board[r][c] % MOD;\n }\n }\n \n // Calculate original score\n vector> orig_board = temp_board;\n for (int k = i; k < static_cast(operations.size()); k++) {\n int m = get<0>(operations[k]);\n int p = get<1>(operations[k]);\n int q = get<2>(operations[k]);\n applyStamp(orig_board, stamps[m], p, q);\n }\n long long score_original = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n score_original += orig_board[r][c] % MOD;\n }\n }\n \n // If swapping improves score, do it\n if (score_with_swap > score_original) {\n swap(operations[i], operations[j]);\n board = test_board;\n }\n }\n }\n \n // Output\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << get<0>(op) << \" \" << get<1>(op) << \" \" << get<2>(op) << endl;\n }\n \n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int row, col;\n int holding; // -1 if not holding, container number otherwise\n bool is_large;\n bool bombed;\n};\n\nstruct ContainerInfo {\n int target_row;\n int target_order;\n bool arrived;\n bool dispatched;\n int arrival_row;\n int arrival_order;\n};\n\nclass Solver {\nprivate:\n int N;\n vector> A;\n vector cranes;\n vector> grid;\n int turn_count;\n vector next_container_index;\n vector containers;\n \n // Get direction from current position to target\n char get_direction(int from_r, int from_c, int to_r, int to_c) {\n if (from_r > to_r) return 'U';\n if (from_r < to_r) return 'D';\n if (from_c > to_c) return 'L';\n if (from_c < to_c) return 'R';\n return '.'; // Already at target\n }\n \n // Calculate next position after action\n pair get_next_position(int crane_id, char action) {\n int r = cranes[crane_id].row;\n int c = cranes[crane_id].col;\n \n if (action == 'U') r--;\n else if (action == 'D') r++;\n else if (action == 'L') c--;\n else if (action == 'R') c++;\n // For 'P', 'Q', 'B', '.', stay in place\n \n return {r, c};\n }\n \n // Check if move is physically valid (bounds, container constraints)\n bool is_physically_valid(int crane_id, char action) {\n if (action == '.' || action == 'P' || action == 'Q' || action == 'B') {\n return true;\n }\n \n pair next_pos = get_next_position(crane_id, action);\n int nr = next_pos.first;\n int nc = next_pos.second;\n \n // Check bounds\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) {\n return false;\n }\n \n // Check if small crane is carrying and trying to move to occupied square\n if (cranes[crane_id].holding != -1 && !cranes[crane_id].is_large && grid[nr][nc] != -1) {\n return false;\n }\n \n return true;\n }\n \n // Comprehensive collision detection that checks final state\n bool has_collision(const vector& actions) {\n // Calculate next positions for all cranes\n vector> current_positions(N);\n vector> next_positions(N);\n \n for (int i = 0; i < N; i++) {\n current_positions[i] = {cranes[i].row, cranes[i].col};\n next_positions[i] = get_next_position(i, actions[i]);\n }\n \n // Check for two cranes ending up in the same position\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n for (int j = i + 1; j < N; j++) {\n if (cranes[j].bombed) continue;\n \n if (next_positions[i] == next_positions[j]) {\n return true;\n }\n }\n }\n \n // Check for swapping (crane i moves to crane j's position and vice versa)\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n for (int j = 0; j < N; j++) {\n if (i == j || cranes[j].bombed) continue;\n \n if (next_positions[i] == current_positions[j] && \n next_positions[j] == current_positions[i]) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n // Check if a specific crane's move is causing a collision\n bool is_causing_collision(int crane_id, const vector& actions) {\n if (cranes[crane_id].bombed) return false;\n \n char original_action = actions[crane_id];\n if (original_action != 'U' && original_action != 'D' && \n original_action != 'L' && original_action != 'R') {\n return false;\n }\n \n // Create a test set of actions where this crane doesn't move\n vector test_actions = actions;\n test_actions[crane_id] = '.';\n \n // If removing this crane's move eliminates the collision, it was causing it\n return has_collision(actions) && !has_collision(test_actions);\n }\n \n // Validate pickup action\n bool is_valid_pickup(int crane_id) {\n return cranes[crane_id].holding == -1 && \n grid[cranes[crane_id].row][cranes[crane_id].col] != -1;\n }\n \n // Validate release action\n bool is_valid_release(int crane_id) {\n return cranes[crane_id].holding != -1 && \n grid[cranes[crane_id].row][cranes[crane_id].col] == -1;\n }\n \n // Get action for crane during initial dispersion phase\n char get_dispersion_action(int crane_id) {\n // Move crane i to column i to disperse them\n int target_col = min(crane_id, N-1);\n \n if (cranes[crane_id].col < target_col) {\n return 'R';\n } else if (cranes[crane_id].col > target_col) {\n return 'L';\n }\n \n return '.';\n }\n \n // Get action for crane during normal operation\n char get_normal_action(int crane_id) {\n Crane& crane = cranes[crane_id];\n \n // Priority 1: If holding a container, deliver it to target dispatch gate\n if (crane.holding != -1) {\n int container = crane.holding;\n int target_row = containers[container].target_row;\n \n // If at the correct dispatch gate, release the container\n if (crane.row == target_row && crane.col == N-1) {\n return 'Q';\n }\n \n // Move toward target dispatch gate\n // First align row, then column\n if (crane.row != target_row) {\n return get_direction(crane.row, crane.col, target_row, crane.col);\n } else {\n return get_direction(crane.row, crane.col, target_row, N-1);\n }\n }\n \n // Priority 2: If at a square with a container, pick it up\n if (crane.holding == -1 && grid[crane.row][crane.col] != -1) {\n return 'P';\n }\n \n // Priority 3: Move to receiving gate of assigned row to pick up containers\n // Each crane i is responsible for row i\n if (crane.col > 0) {\n return 'L'; // Move left toward receiving gate\n }\n \n return '.';\n }\n \n vector get_actions() {\n vector actions(N, '.');\n \n // Phase 1: Disperse cranes (first N turns)\n if (turn_count < N) {\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n actions[i] = get_dispersion_action(i);\n }\n }\n } \n // Phase 2: Normal operation\n else {\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n actions[i] = get_normal_action(i);\n }\n }\n }\n \n // Validate individual actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) {\n actions[i] = '.';\n continue;\n }\n \n char& action = actions[i];\n \n if (action == 'P') {\n if (!is_valid_pickup(i)) {\n action = '.';\n }\n } else if (action == 'Q') {\n if (!is_valid_release(i)) {\n action = '.';\n }\n } else if (action == 'B') {\n if (cranes[i].holding != -1) {\n action = '.';\n }\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n if (!is_physically_valid(i, action)) {\n action = '.';\n }\n }\n }\n \n // If there's a collision, resolve it by making cranes that are causing collisions stop\n if (has_collision(actions)) {\n // Create a safe version where potentially colliding cranes don't move\n vector safe_actions = actions;\n \n // Go through each crane and if it's causing a collision, make it stop\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n if (is_causing_collision(i, actions)) {\n safe_actions[i] = '.';\n }\n }\n \n // If the safe version still has collisions, make ALL moving cranes stop\n if (has_collision(safe_actions)) {\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n if (safe_actions[i] == 'U' || safe_actions[i] == 'D' || \n safe_actions[i] == 'L' || safe_actions[i] == 'R') {\n safe_actions[i] = '.';\n }\n }\n }\n \n actions = safe_actions;\n }\n \n return actions;\n }\n \n bool simulate_turn(vector& actions) {\n // Step 1: Bring in new containers at receiving gates\n for (int i = 0; i < N; i++) {\n if (next_container_index[i] < N && grid[i][0] == -1) {\n // Calculate next positions for all cranes\n vector> next_positions(N);\n for (int j = 0; j < N; j++) {\n next_positions[j] = get_next_position(j, actions[j]);\n }\n \n // Check if position will be occupied\n bool will_be_occupied = false;\n \n for (int j = 0; j < N; j++) {\n if (cranes[j].bombed) continue;\n \n int next_r = next_positions[j].first;\n int next_c = next_positions[j].second;\n \n // If crane will be at (i,0) and not picking up\n if (next_r == i && next_c == 0 && actions[j] != 'P' && actions[j] != 'Q') {\n will_be_occupied = true;\n break;\n }\n \n // Also check if a crane is already there and not picking up\n if (cranes[j].row == i && cranes[j].col == 0 && \n (actions[j] == '.' || actions[j] == 'B') && actions[j] != 'P') {\n will_be_occupied = true;\n break;\n }\n }\n \n if (!will_be_occupied) {\n int container = A[i][next_container_index[i]];\n grid[i][0] = container;\n containers[container].arrived = true;\n next_container_index[i]++;\n }\n }\n }\n \n // Final collision check - if there's still a collision, make all cranes stop moving\n if (has_collision(actions)) {\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n if (actions[i] == 'U' || actions[i] == 'D' || actions[i] == 'L' || actions[i] == 'R') {\n actions[i] = '.';\n }\n }\n }\n \n // Apply actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n int& r = cranes[i].row;\n int& c = cranes[i].col;\n \n if (action == 'P') {\n cranes[i].holding = grid[r][c];\n grid[r][c] = -1;\n } else if (action == 'Q') {\n grid[r][c] = cranes[i].holding;\n cranes[i].holding = -1;\n } else if (action == 'U') {\n r--;\n } else if (action == 'D') {\n r++;\n } else if (action == 'L') {\n c--;\n } else if (action == 'R') {\n c++;\n } else if (action == 'B') {\n cranes[i].bombed = true;\n }\n }\n \n // Step 3: Dispatch containers at dispatch gates\n for (int i = 0; i < N; i++) {\n if (grid[i][N-1] != -1) {\n int container = grid[i][N-1];\n // Only dispatch if it's the correct gate for this container\n if (container / N == i) {\n containers[container].dispatched = true;\n grid[i][N-1] = -1;\n }\n }\n }\n \n turn_count++;\n return true;\n }\n \n bool is_complete() {\n for (int i = 0; i < N*N; i++) {\n if (!containers[i].dispatched) {\n return false;\n }\n }\n return true;\n }\n \npublic:\n Solver(int n, vector>& a) : N(n), A(a) {\n // Initialize cranes\n cranes.resize(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].holding = -1;\n cranes[i].is_large = (i == 0);\n cranes[i].bombed = false;\n }\n \n // Initialize grid\n grid.assign(N, vector(N, -1));\n \n // Initialize container info\n containers.resize(N*N);\n for (int i = 0; i < N*N; i++) {\n containers[i].target_row = i / N;\n containers[i].target_order = i % N;\n containers[i].arrived = false;\n containers[i].dispatched = false;\n }\n \n // Set arrival info\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container = A[i][j];\n containers[container].arrival_row = i;\n containers[container].arrival_order = j;\n }\n }\n \n next_container_index.assign(N, 0);\n turn_count = 0;\n }\n \n vector solve() {\n vector results(N, \"\");\n \n // Simulate up to 10000 turns\n for (int turn = 0; turn < 10000; turn++) {\n vector actions = get_actions();\n \n // Record actions\n for (int i = 0; i < N; i++) {\n results[i] += actions[i];\n }\n \n // Simulate the turn\n simulate_turn(actions);\n \n // Check if we're done\n if (is_complete()) {\n break;\n }\n }\n \n return results;\n }\n};\n\nint main() {\n int N;\n cin >> N;\n \n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n Solver solver(N, A);\n vector results = solver.solve();\n \n for (int i = 0; i < N; i++) {\n cout << results[i] << endl;\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n\n int r = 0, c = 0;\n int truck = 0;\n vector ops;\n\n while (true) {\n bool all_zero = true;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) {\n all_zero = false;\n break;\n }\n }\n if (!all_zero) break;\n }\n if (all_zero) break;\n\n int target_r = -1, target_c = -1;\n\n if (truck == 0) {\n int min_dist = INT_MAX;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break;\n } else {\n int best_score = INT_MIN;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] < 0) {\n int dist = abs(i - r) + abs(j - c);\n int d = min(truck, -h[i][j]);\n if (d <= 0) continue;\n int score = d - 100 * dist;\n if (score > best_score) {\n best_score = score;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break;\n }\n\n // Move to target with enhanced opportunistic loading/unloading\n while (r != target_r || c != target_c) {\n bool moved = false;\n \n // 1. Check current square\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n continue; // Stay in place and re-evaluate\n } else if (h[r][c] < 0 && truck > 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n continue; // Stay in place and re-evaluate\n }\n \n // 2. Calculate adaptive threshold with truck load awareness\n int distance_to_target = abs(target_r - r) + abs(target_c - c);\n \n int base_threshold = 30;\n int distance_factor = 5;\n \n if (truck > 0) {\n // When loaded, be more aggressive to reduce load\n // Reduce factor as truck gets heavier (more eager to unload)\n distance_factor = max(3, 8 - truck / 100);\n base_threshold = max(20, 40 - truck / 50);\n }\n \n int adaptive_threshold = max(base_threshold, distance_to_target * distance_factor);\n \n // 3. Check adjacent squares for high-value opportunities\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dir_char[] = {'U', 'D', 'L', 'R'};\n \n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n \n if (nr < 0 || nr >= N || nc < 0 || nc >= N) continue;\n \n bool is_high_value = false;\n if (truck == 0 && h[nr][nc] > adaptive_threshold) {\n is_high_value = true;\n } else if (truck > 0 && h[nr][nc] < 0 && (-h[nr][nc]) > adaptive_threshold) {\n is_high_value = true;\n }\n \n if (is_high_value) {\n // Move to this high-value square\n ops.push_back(string(1, dir_char[k]));\n r = nr;\n c = nc;\n moved = true;\n break;\n }\n }\n \n if (moved) continue;\n \n // 4. No high-value adjacent opportunities, move toward target\n if (r < target_r) {\n ops.push_back(\"D\");\n r++;\n } else if (r > target_r) {\n ops.push_back(\"U\");\n r--;\n } else if (c < target_c) {\n ops.push_back(\"R\");\n c++;\n } else if (c > target_c) {\n ops.push_back(\"L\");\n c--;\n }\n }\n\n // Final load/unload at target (in case we didn't do it in the loop)\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n } else if (h[r][c] < 0 && truck > 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n }\n }\n\n for (const string& op : ops) {\n cout << op << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, T;\nint seed_count;\n\n// Seed structure\nstruct Seed {\n vector values;\n int id;\n int total_value;\n \n Seed() : id(-1), total_value(0) {}\n \n void calculate_total() {\n total_value = 0;\n for (int v : values) {\n total_value += v;\n }\n }\n};\n\n// Position in grid\nstruct Position {\n int row, col;\n int adjacency_count;\n \n Position(int r, int c) : row(r), col(c) {\n adjacency_count = 0;\n if (r > 0) adjacency_count++;\n if (r < N-1) adjacency_count++;\n if (c > 0) adjacency_count++;\n if (c < N-1) adjacency_count++;\n }\n};\n\nbool compare_positions(const Position& a, const Position& b) {\n return a.adjacency_count > b.adjacency_count;\n}\n\n// Calculate complementarity score between two seeds\nint calculate_complementarity(const Seed& a, const Seed& b) {\n int score = 0;\n for (int i = 0; i < M; i++) {\n score += max(a.values[i], b.values[i]);\n }\n return score;\n}\n\n// Calculate diversity score - how different this seed is from others\ndouble calculate_diversity_score(const Seed& seed, const vector& seeds, const vector& selected) {\n double score = 0;\n int selected_count = 0;\n \n for (int i = 0; i < seeds.size(); i++) {\n if (selected[i]) {\n double distance = 0;\n for (int j = 0; j < M; j++) {\n distance += abs(seed.values[j] - seeds[i].values[j]);\n }\n score += distance;\n selected_count++;\n }\n }\n \n if (selected_count > 0) {\n score /= selected_count;\n }\n \n return score;\n}\n\nint main() {\n cin >> N >> M >> T;\n seed_count = 2 * N * (N - 1);\n \n vector seeds(seed_count);\n \n // Read initial seeds\n for (int i = 0; i < seed_count; i++) {\n seeds[i].values.resize(M);\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n \n // Process T turns\n for (int t = 0; t < T; t++) {\n // For each criterion, create ranking of seeds and find maximum possible\n vector> criterion_ranks(M, vector(seed_count));\n vector max_possible(M, 0);\n for (int crit = 0; crit < M; crit++) {\n vector> crit_values; // (value, seed_id)\n for (int i = 0; i < seed_count; i++) {\n crit_values.push_back({seeds[i].values[crit], i});\n max_possible[crit] = max(max_possible[crit], seeds[i].values[crit]);\n }\n sort(crit_values.begin(), crit_values.end(), greater>());\n for (int rank = 0; rank < seed_count; rank++) {\n criterion_ranks[crit][crit_values[rank].second] = rank;\n }\n }\n \n // Create a combined score for selection\n vector> selection_scores(seed_count);\n \n // Calculate average and standard deviation for each criterion\n vector avg_values(M, 0);\n vector std_dev_values(M, 0);\n \n for (int crit = 0; crit < M; crit++) {\n double sum = 0;\n for (int i = 0; i < seed_count; i++) {\n sum += seeds[i].values[crit];\n }\n avg_values[crit] = sum / seed_count;\n \n double sum_sq = 0;\n for (int i = 0; i < seed_count; i++) {\n sum_sq += (seeds[i].values[crit] - avg_values[crit]) * (seeds[i].values[crit] - avg_values[crit]);\n }\n std_dev_values[crit] = sqrt(sum_sq / seed_count);\n }\n \n for (int i = 0; i < seed_count; i++) {\n double score = 0;\n \n // Adjust weights based on generation\n double value_weight = 1.0 + 0.5 * (double)t / T;\n double diversity_weight = 1.0 - 0.8 * (double)t / T; // Higher in early generations\n \n // 1. Total value (base score)\n score += seeds[i].total_value * value_weight;\n \n // 2. Bonus for being in top 5 for any criterion\n int top5_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][i] < 5) {\n top5_count++;\n }\n }\n score += top5_count * 20;\n \n // 3. Bonus for being in top 1 for any criterion\n int top1_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][i] == 0) {\n top1_count++;\n }\n }\n score += top1_count * 80;\n \n // 4. Bonus for being close to the maximum in any criterion\n int near_max_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (max_possible[crit] > 0 && \n seeds[i].values[crit] >= max_possible[crit] * 0.9) {\n near_max_count++;\n }\n }\n score += near_max_count * 30;\n \n // 5. Bonus for being significantly above average in any criterion (z-score > 1.5)\n int outstanding_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (std_dev_values[crit] > 0) {\n double z_score = (seeds[i].values[crit] - avg_values[crit]) / std_dev_values[crit];\n if (z_score > 1.5) {\n outstanding_count++;\n }\n }\n }\n score += outstanding_count * 25;\n \n // 6. Diversity bonus for early generations\n if (t < T / 2) {\n vector dummy_selected(seed_count, false);\n double diversity_score = calculate_diversity_score(seeds[i], seeds, dummy_selected);\n score += diversity_score * diversity_weight * 0.05; // Small weight to avoid overpowering\n }\n \n selection_scores[i] = {score, i};\n }\n \n // Sort by combined score\n sort(selection_scores.begin(), selection_scores.end(), greater>());\n \n // Select top 36 seeds\n vector selected_seeds;\n for (int i = 0; i < N * N; i++) {\n selected_seeds.push_back(selection_scores[i].second);\n }\n \n // Create grid for planting\n vector> grid(N, vector(N, -1));\n \n // Create a mapping of seeds to their complementarity with others\n vector> complementarity_map(seed_count, vector(seed_count, 0));\n for (int i = 0; i < selected_seeds.size(); i++) {\n for (int j = 0; j < selected_seeds.size(); j++) {\n if (i != j) {\n int seed_i = selected_seeds[i];\n int seed_j = selected_seeds[j];\n complementarity_map[seed_i][seed_j] = calculate_complementarity(\n seeds[seed_i], seeds[seed_j]);\n }\n }\n }\n \n // Generate positions sorted by adjacency count\n vector positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.emplace_back(i, j);\n }\n }\n \n // Special placement strategy for different phases\n vector placed(seed_count, false);\n \n if (t < T / 3) {\n // Early phase: Place highest scoring seed in center, then focus on diversity\n if (!selected_seeds.empty()) {\n int center_row = N/2, center_col = N/2;\n int best_seed = selected_seeds[0];\n grid[center_row][center_col] = best_seed;\n placed[best_seed] = true;\n }\n \n // Sort remaining positions by adjacency count (high adjacency first)\n sort(positions.begin(), positions.end(), compare_positions);\n \n // Place remaining seeds with focus on diversity from already placed seeds\n vector> remaining_positions;\n for (auto& pos : positions) {\n if (grid[pos.row][pos.col] == -1) {\n remaining_positions.push_back({pos.row, pos.col});\n }\n }\n \n vector remaining_seeds;\n for (int i = 1; i < selected_seeds.size(); i++) {\n remaining_seeds.push_back(selected_seeds[i]);\n }\n \n for (auto& pos : remaining_positions) {\n int row = pos.first;\n int col = pos.second;\n \n if (remaining_seeds.empty()) break;\n \n // Find seed with highest diversity from already placed seeds\n int best_seed_idx = 0;\n double best_diversity = -1;\n \n for (int i = 0; i < remaining_seeds.size(); i++) {\n int seed_id = remaining_seeds[i];\n \n // Calculate diversity score with already placed seeds\n double diversity_score = 0;\n int placed_count = 0;\n \n // Check all adjacent positions\n vector> neighbors = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& nb : neighbors) {\n int nb_row = nb.first;\n int nb_col = nb.second;\n \n if (nb_row >= 0 && nb_row < N && nb_col >= 0 && nb_col < N && \n grid[nb_row][nb_col] != -1) {\n int nb_seed = grid[nb_row][nb_col];\n double distance = 0;\n for (int j = 0; j < M; j++) {\n distance += abs(seeds[seed_id].values[j] - seeds[nb_seed].values[j]);\n }\n diversity_score += distance;\n placed_count++;\n }\n }\n \n // If no placed neighbors, use overall diversity\n if (placed_count == 0) {\n vector temp_placed(seed_count, false);\n for (auto& rs : remaining_seeds) {\n if (rs != seed_id) temp_placed[rs] = true;\n }\n diversity_score = calculate_diversity_score(seeds[seed_id], seeds, temp_placed);\n } else {\n diversity_score /= placed_count;\n }\n \n if (diversity_score > best_diversity) {\n best_diversity = diversity_score;\n best_seed_idx = i;\n }\n }\n \n // Place the most diverse seed\n int chosen_seed = remaining_seeds[best_seed_idx];\n grid[row][col] = chosen_seed;\n placed[chosen_seed] = true;\n remaining_seeds.erase(remaining_seeds.begin() + best_seed_idx);\n }\n } else {\n // Middle/Late phase: Greedy placement based on complementarity\n if (!selected_seeds.empty()) {\n int center_row = N/2, center_col = N/2;\n int best_seed = selected_seeds[0];\n grid[center_row][center_col] = best_seed;\n placed[best_seed] = true;\n }\n \n // Sort remaining positions by adjacency count (high adjacency first)\n sort(positions.begin(), positions.end(), compare_positions);\n \n vector> remaining_positions;\n for (auto& pos : positions) {\n if (grid[pos.row][pos.col] == -1) {\n remaining_positions.push_back({pos.row, pos.col});\n }\n }\n \n vector remaining_seeds;\n for (int i = 1; i < selected_seeds.size(); i++) {\n remaining_seeds.push_back(selected_seeds[i]);\n }\n \n // Place remaining seeds based on complementarity with neighbors\n for (auto& pos : remaining_positions) {\n int row = pos.first;\n int col = pos.second;\n \n if (remaining_seeds.empty()) break;\n \n // Find the best seed to place at this position based on complementarity with neighbors\n int best_seed_idx = 0;\n int best_score = -1;\n \n for (int i = 0; i < remaining_seeds.size(); i++) {\n int seed_id = remaining_seeds[i];\n \n // Calculate score based on complementarity with adjacent placed seeds\n int complementarity_score = 0;\n int neighbor_count = 0;\n \n // Check all adjacent positions\n vector> neighbors = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& nb : neighbors) {\n int nb_row = nb.first;\n int nb_col = nb.second;\n \n if (nb_row >= 0 && nb_row < N && nb_col >= 0 && nb_col < N && \n grid[nb_row][nb_col] != -1) {\n int nb_seed = grid[nb_row][nb_col];\n complementarity_score += complementarity_map[seed_id][nb_seed];\n neighbor_count++;\n }\n }\n \n // If no neighbors are placed yet, use the seed's base score\n if (neighbor_count == 0) {\n // Find the original score of this seed\n double base_score = 0;\n for (int j = 0; j < selection_scores.size(); j++) {\n if (selection_scores[j].second == seed_id) {\n base_score = selection_scores[j].first;\n break;\n }\n }\n complementarity_score = base_score;\n }\n \n if (complementarity_score > best_score) {\n best_score = complementarity_score;\n best_seed_idx = i;\n }\n }\n \n // Place the best seed\n int chosen_seed = remaining_seeds[best_seed_idx];\n grid[row][col] = chosen_seed;\n placed[chosen_seed] = true;\n remaining_seeds.erase(remaining_seeds.begin() + best_seed_idx);\n }\n }\n \n // Optimize placement with adjacency-based swapping\n if (t < T - 1) {\n bool improved = true;\n int iteration = 0;\n const int max_iterations = 20; // Increased from 15\n \n // Use different thresholds based on generation\n int threshold = 5 - (3 * t / T); // Higher threshold in early gens, lower in late gens\n if (threshold < 1) threshold = 1;\n \n while (improved && iteration < max_iterations) {\n improved = false;\n \n // Try swapping adjacent positions (up, down, left, right)\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Try swapping with right neighbor\n if (j < N - 1) {\n int seed1 = grid[i][j];\n int seed2 = grid[i][j+1];\n \n // Calculate current complementarity\n int current_score = 0;\n \n // Check all neighbors for both positions\n vector> neighbors;\n neighbors.push_back({i, j});\n neighbors.push_back({i, j+1});\n \n for (auto& pos : neighbors) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = grid[row][col];\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N && \n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n current_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // Calculate score if we swap\n int swapped_score = 0;\n \n // After swap, seed2 is at (i,j) and seed1 is at (i,j+1)\n vector> positions_after_swap;\n positions_after_swap.push_back({i, j}); // now has seed2\n positions_after_swap.push_back({i, j+1}); // now has seed1\n \n for (auto& pos : positions_after_swap) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = (row == i && col == j) ? seed2 : seed1;\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N &&\n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n swapped_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // If swapping improves the score, do it\n if (swapped_score > current_score + threshold) {\n swap(grid[i][j], grid[i][j+1]);\n improved = true;\n \n // Update complementarity map for these seeds\n for (int k = 0; k < seed_count; k++) {\n if (k != seed1 && k != seed2) {\n if (k < seed_count && seed1 < seed_count && seed2 < seed_count) {\n complementarity_map[seed1][k] = calculate_complementarity(seeds[seed1], seeds[k]);\n complementarity_map[k][seed1] = complementarity_map[seed1][k];\n complementarity_map[seed2][k] = calculate_complementarity(seeds[seed2], seeds[k]);\n complementarity_map[k][seed2] = complementarity_map[seed2][k];\n }\n }\n }\n }\n }\n \n // Try swapping with bottom neighbor\n if (i < N - 1) {\n int seed1 = grid[i][j];\n int seed2 = grid[i+1][j];\n \n // Calculate current complementarity\n int current_score = 0;\n \n // Check all neighbors for both positions\n vector> neighbors;\n neighbors.push_back({i, j});\n neighbors.push_back({i+1, j});\n \n for (auto& pos : neighbors) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = grid[row][col];\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N && \n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n current_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // Calculate score if we swap\n int swapped_score = 0;\n \n // After swap, seed2 is at (i,j) and seed1 is at (i+1,j)\n vector> positions_after_swap;\n positions_after_swap.push_back({i, j}); // now has seed2\n positions_after_swap.push_back({i+1, j}); // now has seed1\n \n for (auto& pos : positions_after_swap) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = (row == i && col == j) ? seed2 : seed1;\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N &&\n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n swapped_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // If swapping improves the score, do it\n if (swapped_score > current_score + threshold) {\n swap(grid[i][j], grid[i+1][j]);\n improved = true;\n \n // Update complementarity map for these seeds\n for (int k = 0; k < seed_count; k++) {\n if (k != seed1 && k != seed2) {\n if (k < seed_count && seed1 < seed_count && seed2 < seed_count) {\n complementarity_map[seed1][k] = calculate_complementarity(seeds[seed1], seeds[k]);\n complementarity_map[k][seed1] = complementarity_map[seed1][k];\n complementarity_map[seed2][k] = calculate_complementarity(seeds[seed2], seeds[k]);\n complementarity_map[k][seed2] = complementarity_map[seed2][k];\n }\n }\n }\n }\n }\n }\n }\n \n iteration++;\n }\n }\n \n // Output the grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j];\n if (j < N - 1) {\n cout << \" \";\n }\n }\n cout << endl;\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n }\n \n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n bool in_bounds(int N) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nstruct State {\n Point root_pos;\n vector directions; // Direction of each edge (0=R, 1=D, 2=L, 3=U)\n vector holding; // What each fingertip is holding\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector initial_grid, target_grid;\n vector start_positions, target_positions;\n vector tree;\n int V_prime;\n vector fingertips;\n State current_state;\n mt19937 rng;\n \n // Direction vectors: Right, Down, Left, Up\n const vector DX = {1, 0, -1, 0};\n const vector DY = {0, 1, 0, -1};\n const string DIR_CHARS = \"RDLU\";\n \npublic:\n RoboticArmSolver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n void read_input() {\n cin >> N >> M >> V;\n initial_grid.resize(N);\n target_grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> initial_grid[i];\n }\n for (int i = 0; i < N; i++) {\n cin >> target_grid[i];\n }\n \n // Extract start and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '0') {\n start_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '0' && target_grid[i][j] == '1') {\n target_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n // Already in correct position, no need to move\n // But we still count it for M'\n M--;\n }\n }\n }\n \n // Shuffle for randomization\n shuffle(start_positions.begin(), start_positions.end(), rng);\n shuffle(target_positions.begin(), target_positions.end(), rng);\n }\n \n void design_arm() {\n // Determine number of vertices to use\n V_prime = min(V, 10); // Use up to 10 vertices for simplicity\n \n // Build a simple tree: root (0) connected to several children\n // Try to create a balanced tree with multiple fingertips\n tree.resize(V_prime);\n for (int i = 0; i < V_prime; i++) {\n tree[i].is_leaf = true; // Initially all are leaves\n }\n \n // Create tree structure\n // Root at 0\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Add children to root and possibly to other nodes\n int next_vertex = 1;\n vector current_level = {0};\n \n while (next_vertex < V_prime) {\n vector next_level;\n for (int parent : current_level) {\n if (next_vertex >= V_prime) break;\n \n // Add 1-2 children to each node\n int children_count = min(2, V_prime - next_vertex);\n for (int i = 0; i < children_count && next_vertex < V_prime; i++) {\n tree[next_vertex].parent = parent;\n tree[next_vertex].length = 1; // Use length 1 for simplicity\n tree[parent].children.push_back(next_vertex);\n tree[parent].is_leaf = false;\n next_level.push_back(next_vertex);\n next_vertex++;\n }\n }\n current_level = next_level;\n }\n \n // Identify fingertips (leaves)\n for (int i = 0; i < V_prime; i++) {\n if (tree[i].is_leaf) {\n fingertips.push_back(i);\n }\n }\n }\n \n Point find_initial_position() {\n // Find a central position that minimizes distance to start positions\n int best_x = N/2, best_y = N/2;\n double min_dist = 1e9;\n \n // Try positions around center\n for (int x = max(0, N/2 - 2); x <= min(N-1, N/2 + 2); x++) {\n for (int y = max(0, N/2 - 2); y <= min(N-1, N/2 + 2); y++) {\n double dist = 0;\n for (const Point& p : start_positions) {\n dist += abs(p.x - x) + abs(p.y - y);\n }\n if (dist < min_dist) {\n min_dist = dist;\n best_x = x;\n best_y = y;\n }\n }\n }\n \n return Point(best_x, best_y);\n }\n \n // Calculate positions of all vertices given root position and directions\n vector calculate_positions(const Point& root_pos, const vector& directions) {\n vector positions(V_prime);\n positions[0] = root_pos;\n \n for (int i = 1; i < V_prime; i++) {\n int parent = tree[i].parent;\n int dir = directions[i];\n int len = tree[i].length;\n \n positions[i] = Point(\n positions[parent].x + DY[dir] * len, // Note: Y is row, X is column\n positions[parent].y + DX[dir] * len\n );\n }\n \n return positions;\n }\n \n // Find distance between two points\n int manhattan_distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the best move for the arm\n string find_best_move() {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n string command(2 * V_prime, '.');\n \n // First, try to pick up or place takoyaki\n bool did_action = false;\n for (int i = 0; i < fingertips.size() && !did_action; i++) {\n int finger = fingertips[i];\n Point pos = positions[finger];\n \n if (!pos.in_bounds(N)) continue;\n \n // Check if we can pick up a takoyaki\n if (!current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '1' && \n target_grid[pos.x][pos.y] == '0') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = true;\n initial_grid[pos.x][pos.y] = '0'; // Remove from initial grid\n did_action = true;\n continue;\n }\n \n // Check if we can place a takoyaki\n if (current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '0' && \n target_grid[pos.x][pos.y] == '1') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = false;\n initial_grid[pos.x][pos.y] = '1'; // Add to grid (mark as delivered)\n did_action = true;\n continue;\n }\n }\n \n if (did_action) {\n return command;\n }\n \n // No pickup/place action, move toward a target\n // Find closest undelivered takoyaki or target position\n Point target_pos;\n bool move_to_start = false;\n \n if (!start_positions.empty()) {\n // Find closest start position that has a takoyaki\n int min_dist = 1e9;\n for (int i = 0; i < start_positions.size(); i++) {\n if (initial_grid[start_positions[i].x][start_positions[i].y] == '1') {\n int dist = manhattan_distance(current_state.root_pos, start_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n target_pos = start_positions[i];\n move_to_start = true;\n }\n }\n }\n }\n \n // If no start positions available or none have takoyaki, move to target positions\n if (!move_to_start || min_dist == 1e9) {\n for (int i = 0; i < target_positions.size(); i++) {\n if (initial_grid[target_positions[i].x][target_positions[i].y] == '0') {\n int dist = manhattan_distance(current_state.root_pos, target_positions[i]);\n if (dist < min_dist || min_dist == 1e9) {\n min_dist = dist;\n target_pos = target_positions[i];\n move_to_start = false;\n }\n }\n }\n }\n \n // Move toward target\n if (min_dist != 1e9) {\n int dx = target_pos.x - current_state.root_pos.x;\n int dy = target_pos.y - current_state.root_pos.y;\n \n if (dx != 0 || dy != 0) {\n // Determine best direction to move\n char best_dir = '.';\n int best_improvement = -1;\n \n for (int d = 0; d < 4; d++) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (!new_pos.in_bounds(N)) continue;\n \n int new_dist = abs(new_pos.x - target_pos.x) + abs(new_pos.y - target_pos.y);\n int improvement = min_dist - new_dist;\n \n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_dir = DIR_CHARS[d];\n command[0] = best_dir;\n }\n }\n \n // Update root position if we found a valid move\n if (best_dir != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == best_dir) {\n current_state.root_pos.x += DX[d];\n current_state.root_pos.y += DY[d];\n break;\n }\n }\n }\n }\n } else {\n // Random move if no clear target\n vector valid_moves = {'.', 'R', 'D', 'L', 'U'};\n int r = rng() % valid_moves.size();\n command[0] = valid_moves[r];\n \n if (command[0] != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == command[0]) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (new_pos.in_bounds(N)) {\n current_state.root_pos = new_pos;\n }\n break;\n }\n }\n }\n }\n \n // Random rotations to explore different configurations\n if (rng() % 3 == 0) { // 33% chance of rotation\n for (int i = 1; i < V_prime; i++) {\n if (rng() % 3 == 0) { // 33% chance per joint\n if (rng() % 2) {\n command[i] = 'R';\n current_state.directions[i] = (current_state.directions[i] + 1) % 4;\n } else {\n command[i] = 'L';\n current_state.directions[i] = (current_state.directions[i] + 3) % 4;\n }\n }\n }\n }\n \n return command;\n }\n \n void solve() {\n read_input();\n design_arm();\n \n // Output arm design\n cout << V_prime << endl;\n for (int i = 1; i < V_prime; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n \n // Find and output initial position\n Point initial_pos = find_initial_position();\n cout << initial_pos.x << \" \" << initial_pos.y << endl;\n \n // Initialize state\n current_state.root_pos = initial_pos;\n current_state.directions.resize(V_prime, 0); // All start pointing right\n current_state.holding.resize(V_prime, false);\n \n // Generate operations\n vector commands;\n int max_turns = min(50000, 100000); // Limit to avoid TLE\n \n for (int turn = 0; turn < max_turns; turn++) {\n string command = find_best_move();\n commands.push_back(command);\n \n // Check if all takoyaki are delivered\n int delivered = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n delivered++;\n }\n }\n }\n \n // Also count held takoyaki that can be placed\n for (int finger : fingertips) {\n if (current_state.holding[finger]) {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n Point pos = positions[finger];\n if (pos.in_bounds(N) && target_grid[pos.x][pos.y] == '1' && initial_grid[pos.x][pos.y] == '0') {\n delivered++; // Can be delivered in next turn\n }\n }\n }\n \n // If we've delivered all or have extra, break early\n if (delivered >= M) {\n break;\n }\n }\n \n // Output commands\n for (const string& cmd : commands) {\n cout << cmd << endl;\n }\n }\n};\n\nint main() {\n RoboticArmSolver solver;\n solver.solve();\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n int x1, y1, x2, y2; // x1 <= x2, y1 <= y2\n Rectangle(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : x1(x1), y1(y1), x2(x2), y2(y2) {}\n \n bool contains(const Point& p) const {\n return p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2;\n }\n \n int perimeter() const {\n return 2 * ((x2 - x1) + (y2 - y1));\n }\n \n int area() const {\n return (x2 - x1) * (y2 - y1);\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(x2 < other.x1 || x1 > other.x2 || y2 < other.y1 || y1 > other.y2);\n }\n \n Rectangle merge(const Rectangle& other) const {\n return Rectangle(\n min(x1, other.x1),\n min(y1, other.y1),\n max(x2, other.x2),\n max(y2, other.y2)\n );\n }\n \n // Calculate overlap area\n int overlapArea(const Rectangle& other) const {\n int overlapX1 = max(x1, other.x1);\n int overlapY1 = max(y1, other.y1);\n int overlapX2 = min(x2, other.x2);\n int overlapY2 = min(y2, other.y2);\n \n if (overlapX2 <= overlapX1 || overlapY2 <= overlapY1) {\n return 0;\n }\n \n return (overlapX2 - overlapX1) * (overlapY2 - overlapY1);\n }\n};\n\n// Calculate score for rectangle\npair countPoints(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n int mackerelCount = 0, sardineCount = 0;\n \n for (const auto& p : mackerels) {\n if (rect.contains(p)) mackerelCount++;\n }\n \n for (const auto& p : sardines) {\n if (rect.contains(p)) sardineCount++;\n }\n \n return {mackerelCount, sardineCount};\n}\n\nint calculateScore(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n auto [m, s] = countPoints(mackerels, sardines, rect);\n return max(0, m - s + 1);\n}\n\n// Generate candidate rectangles\nvector generateCandidateRectangles(const vector& mackerels, const vector& sardines) {\n vector candidates;\n const int MAX_CANDIDATES = 80;\n \n // Calculate statistical properties of mackerels\n long long sumX = 0, sumY = 0;\n for (const auto& p : mackerels) {\n sumX += p.x;\n sumY += p.y;\n }\n int centerX = sumX / mackerels.size();\n int centerY = sumY / mackerels.size();\n \n // Calculate standard deviation for adaptive sizing\n long long sumDX2 = 0, sumDY2 = 0;\n for (const auto& p : mackerels) {\n long long dx = p.x - centerX;\n long long dy = p.y - centerY;\n sumDX2 += dx * dx;\n sumDY2 += dy * dy;\n }\n int stdX = sqrt(sumDX2 / mackerels.size());\n int stdY = sqrt(sumDY2 / mackerels.size());\n int avgStd = (stdX + stdY) / 2;\n \n // Use a variety of rectangle sizes based on data distribution\n vector baseSizes = {500, 1000, 2000, 4000, 8000};\n if (avgStd > 1000) {\n baseSizes.push_back(avgStd);\n baseSizes.push_back(avgStd * 2);\n baseSizes.push_back(avgStd * 3);\n }\n baseSizes.push_back(15000);\n baseSizes.push_back(25000);\n \n // Remove duplicates and sort\n sort(baseSizes.begin(), baseSizes.end());\n baseSizes.erase(unique(baseSizes.begin(), baseSizes.end()), baseSizes.end());\n \n // Sample mackerels strategically - prioritize dense regions\n vector> densityScores; // (density_score, index)\n \n // Simple density estimation using a coarse grid\n const int DENSITY_GRID_SIZE = 20;\n const int DENSITY_CELL_SIZE = 100000 / DENSITY_GRID_SIZE;\n vector> densityGrid(DENSITY_GRID_SIZE, vector(DENSITY_GRID_SIZE, 0));\n \n for (const auto& p : mackerels) {\n int gx = min(DENSITY_GRID_SIZE - 1, p.x / DENSITY_CELL_SIZE);\n int gy = min(DENSITY_GRID_SIZE - 1, p.y / DENSITY_CELL_SIZE);\n densityGrid[gx][gy]++;\n }\n \n // Score each mackerel by the density of its cell\n for (int i = 0; i < (int)mackerels.size(); i++) {\n int gx = min(DENSITY_GRID_SIZE - 1, mackerels[i].x / DENSITY_CELL_SIZE);\n int gy = min(DENSITY_GRID_SIZE - 1, mackerels[i].y / DENSITY_CELL_SIZE);\n int density = densityGrid[gx][gy];\n densityScores.push_back({density, i});\n }\n \n // Sort by density (descending)\n sort(densityScores.begin(), densityScores.end(), greater>());\n \n // Use top 200 mackerels (highest density regions)\n int sampleSize = min(200, (int)densityScores.size());\n \n for (int i = 0; i < sampleSize && candidates.size() < MAX_CANDIDATES; i++) {\n int idx = densityScores[i].second;\n int x = mackerels[idx].x;\n int y = mackerels[idx].y;\n \n for (int size : baseSizes) {\n int x1 = max(0, x - size/2);\n int y1 = max(0, y - size/2);\n int x2 = min(100000, x + size/2);\n int y2 = min(100000, y + size/2);\n \n Rectangle rect(x1, y1, x2, y2);\n auto [m, s] = countPoints(mackerels, sardines, rect);\n \n // Only add if it has positive score and reasonable mackerel count\n if (m - s > 0 && m > 2) {\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n }\n \n // Add some rectangles covering entire dense grid cells\n if (candidates.size() < MAX_CANDIDATES) {\n for (int i = 0; i < DENSITY_GRID_SIZE && candidates.size() < MAX_CANDIDATES; i++) {\n for (int j = 0; j < DENSITY_GRID_SIZE && candidates.size() < MAX_CANDIDATES; j++) {\n if (densityGrid[i][j] >= 5) { // Only consider cells with at least 5 mackerels\n int x1 = i * DENSITY_CELL_SIZE;\n int y1 = j * DENSITY_CELL_SIZE;\n int x2 = min(100000, (i + 1) * DENSITY_CELL_SIZE);\n int y2 = min(100000, (j + 1) * DENSITY_CELL_SIZE);\n \n // Add padding to capture nearby points\n int pad = DENSITY_CELL_SIZE / 3;\n x1 = max(0, x1 - pad);\n y1 = max(0, y1 - pad);\n x2 = min(100000, x2 + pad);\n y2 = min(100000, y2 + pad);\n \n Rectangle rect(x1, y1, x2, y2);\n auto [m, s] = countPoints(mackerels, sardines, rect);\n if (m - s > 0 && m > 3) {\n candidates.push_back(rect);\n }\n }\n }\n }\n }\n \n // Remove duplicate rectangles\n sort(candidates.begin(), candidates.end(), [](const Rectangle& a, const Rectangle& b) {\n if (a.x1 != b.x1) return a.x1 < b.x1;\n if (a.y1 != b.y1) return a.y1 < b.y1;\n if (a.x2 != b.x2) return a.x2 < b.x2;\n return a.y2 < b.y2;\n });\n \n auto last = unique(candidates.begin(), candidates.end(), [](const Rectangle& a, const Rectangle& b) {\n return a.x1 == b.x1 && a.y1 == b.y1 && a.x2 == b.x2 && a.y2 == b.y2;\n });\n candidates.erase(last, candidates.end());\n \n // Sort by score\n sort(candidates.begin(), candidates.end(), [&](const Rectangle& a, const Rectangle& b) {\n return calculateScore(mackerels, sardines, a) > calculateScore(mackerels, sardines, b);\n });\n \n // Keep top candidates\n if (candidates.size() > 30) {\n candidates.resize(30);\n }\n \n return candidates;\n}\n\n// Create a polygon from a single rectangle\nvector createPolygonFromRectangle(const Rectangle& rect) {\n return {\n Point(rect.x1, rect.y1),\n Point(rect.x2, rect.y1),\n Point(rect.x2, rect.y2),\n Point(rect.x1, rect.y2)\n };\n}\n\n// Main function to find best solution\nvector findBestSolution(const vector& mackerels, const vector& sardines) {\n // Generate candidate rectangles\n vector candidates = generateCandidateRectangles(mackerels, sardines);\n \n if (candidates.empty()) {\n // Fallback: use a rectangle around center of mackerels\n long long sumX = 0, sumY = 0;\n for (const auto& p : mackerels) {\n sumX += p.x;\n sumY += p.y;\n }\n int centerX = sumX / mackerels.size();\n int centerY = sumY / mackerels.size();\n \n Rectangle fallback(max(0, centerX - 10000), max(0, centerY - 10000), \n min(100000, centerX + 10000), min(100000, centerY + 10000));\n return createPolygonFromRectangle(fallback);\n }\n \n // Score all candidates\n vector> scoredCandidates;\n for (const auto& rect : candidates) {\n int score = calculateScore(mackerels, sardines, rect);\n scoredCandidates.push_back({score, rect});\n }\n \n // Sort by score (fix: only compare the score, not the Rectangle)\n sort(scoredCandidates.begin(), scoredCandidates.end(), [](const pair& a, const pair& b) {\n return a.first > b.first; // Compare only by score\n });\n \n // Try the top 5 candidates\n for (int i = 0; i < min(5, (int)scoredCandidates.size()); i++) {\n if (scoredCandidates[i].first > 1) { // Ensure positive score\n return createPolygonFromRectangle(scoredCandidates[i].second);\n }\n }\n \n // Fallback to best candidate even if score is low\n return createPolygonFromRectangle(scoredCandidates[0].second);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n \n vector mackerels(N);\n vector sardines(N);\n \n // Read mackerels\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n \n // Read sardines\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n \n // Find best solution\n vector polygon = findBestSolution(mackerels, sardines);\n \n // Validate and ensure we have at least 4 points\n if (polygon.size() < 4) {\n // Create fallback rectangle\n long long sumX = 0, sumY = 0;\n for (const auto& p : mackerels) {\n sumX += p.x;\n sumY += p.y;\n }\n int centerX = sumX / mackerels.size();\n int centerY = sumY / mackerels.size();\n \n polygon = {\n Point(max(0, centerX - 5000), max(0, centerY - 5000)),\n Point(min(100000, centerX + 5000), max(0, centerY - 5000)),\n Point(min(100000, centerX + 5000), min(100000, centerY + 5000)),\n Point(max(0, centerX - 5000), min(100000, centerY + 5000))\n };\n }\n \n // Output\n cout << polygon.size() << \"\\n\";\n for (const auto& p : polygon) {\n cout << p.x << \" \" << p.y << \"\\n\";\n }\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Placement {\n int p, r;\n char d;\n int b;\n};\n\nclass RectanglePacker {\nprivate:\n int N, T;\n double sigma;\n vector> observed_wh;\n mt19937 rng;\n vector best_placement;\n long long best_score;\n int best_turn;\n vector> feedback_history;\n \n // Track strategy performance\n struct StrategyStats {\n int attempts;\n long long total_score;\n double success_rate; // Higher is better (lower scores)\n };\n \n vector strategy_stats;\n int current_strategy;\n \npublic:\n RectanglePacker(int seed = 1234) : rng(seed) {\n best_score = LLONG_MAX;\n best_turn = -1;\n \n // Initialize 5 core strategies\n strategy_stats.resize(5);\n for (int i = 0; i < 5; i++) {\n strategy_stats[i] = {0, 0, 0.5};\n }\n current_strategy = 0;\n }\n \n void readInput() {\n cin >> N >> T >> sigma;\n observed_wh.resize(N);\n \n for (int i = 0; i < N; i++) {\n cin >> observed_wh[i].first >> observed_wh[i].second;\n }\n }\n \n // Random placement - keep it simple\n vector generateRandomPlacement(int n) {\n vector placement;\n uniform_int_distribution rotation_dist(0, 1);\n uniform_int_distribution direction_dist(0, 1);\n \n for (int i = 0; i < n; i++) {\n int r = rotation_dist(rng);\n char d = direction_dist(rng) ? 'L' : 'U';\n int b = -1;\n if (i > 0) {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Simple greedy placement\n vector generateGreedyPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n // Simple rotation rule: rotate if width > height\n int r = (orig_w > orig_h) ? 1 : 0;\n \n // Simple direction: alternate\n char d = (i % 2 == 0) ? 'U' : 'L';\n \n // Simple reference: mostly previous rectangle\n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 85) {\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Size-based placement\n vector generateSizeBasedPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n // For extreme aspect ratios, rotate to make more square-like\n int r;\n if (orig_w > orig_h * 3 || orig_h > orig_w * 3) {\n r = (orig_w > orig_h) ? 1 : 0;\n } else {\n r = (orig_w > orig_h) ? 1 : 0;\n }\n \n // Direction based on effective dimensions\n int eff_w = r ? orig_h : orig_w;\n int eff_h = r ? orig_w : orig_h;\n \n char d;\n if (eff_w > eff_h * 2) {\n d = 'U'; // Very wide, stack up\n } else if (eff_h > eff_w * 2) {\n d = 'L'; // Very tall, stack left\n } else {\n d = (i % 2 == 0) ? 'U' : 'L'; // Otherwise alternate\n }\n \n // Reference: prefer previous rectangle\n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 75) {\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Width-minimizing placement\n vector generateWidthFocusedPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n // Rotate to minimize width\n int r = (orig_w < orig_h) ? 0 : 1;\n \n // Prefer U direction to minimize width growth\n char d = 'U';\n if (rng() % 100 < 25) {\n d = 'L';\n }\n \n // Reference: prefer previous\n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 70) {\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Height-minimizing placement\n vector generateHeightFocusedPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n // Rotate to minimize height\n int r = (orig_h < orig_w) ? 0 : 1;\n \n // Prefer L direction to minimize height growth\n char d = 'L';\n if (rng() % 100 < 25) {\n d = 'U';\n }\n \n // Reference: prefer previous\n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 70) {\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back({i, r, d, b});\n }\n \n return placement;\n }\n \n // Simplified mutation\n vector mutatePlacement(const vector& base, int turn) {\n if (base.empty()) return base;\n \n vector result = base;\n int n = result.size();\n \n // Number of mutations: 1-3 based on turn\n int num_mutations = 1;\n if (turn < T/3) num_mutations = 3;\n else if (turn < 2*T/3) num_mutations = 2;\n \n uniform_int_distribution mutation_dist(0, 3); // 0=rotation, 1=direction, 2=reference, 3=feedback\n uniform_int_distribution index_dist(0, n - 1);\n \n for (int i = 0; i < num_mutations; i++) {\n int idx = index_dist(rng);\n int mutation_type = mutation_dist(rng);\n \n switch (mutation_type) {\n case 0: // Change rotation\n result[idx].r = 1 - result[idx].r;\n break;\n case 1: // Change direction\n result[idx].d = (result[idx].d == 'U') ? 'L' : 'U';\n break;\n case 2: // Change reference\n if (idx > 0) {\n uniform_int_distribution ref_dist(-1, idx - 1);\n result[idx].b = ref_dist(rng);\n } else {\n result[idx].b = -1;\n }\n break;\n case 3: // Feedback-based mutation\n if (!feedback_history.empty()) {\n int last_W = feedback_history.back().first;\n int last_H = feedback_history.back().second;\n \n int orig_w = observed_wh[idx].first;\n int orig_h = observed_wh[idx].second;\n \n if (last_W > last_H * 1.5) {\n // Width too large, stack up and reduce width\n result[idx].d = 'U';\n if (orig_w > orig_h) result[idx].r = 1;\n } else if (last_H > last_W * 1.5) {\n // Height too large, stack left and reduce height\n result[idx].d = 'L';\n if (orig_h > orig_w) result[idx].r = 1;\n }\n }\n break;\n }\n }\n \n return result;\n }\n \n // Update strategy statistics with simple success rate\n void updateStrategyStats(int strategy, long long score, int turn) {\n strategy_stats[strategy].attempts++;\n strategy_stats[strategy].total_score += score;\n \n // Calculate success rate based on improvement\n double relative_improvement = 1.0;\n if (best_turn != -1) {\n relative_improvement = (double)(best_score + 1) / (score + 1);\n }\n \n // Simple exponential moving average\n strategy_stats[strategy].success_rate = 0.8 * strategy_stats[strategy].success_rate + 0.2 * relative_improvement;\n }\n \n // Simplified strategy selection\n int selectStrategy(int turn) {\n if (turn < 5) {\n return turn % 5; // Try each strategy once at start\n }\n \n // Calculate selection probability based on success rate\n double total_success = 0;\n for (int i = 0; i < 5; i++) {\n total_success += strategy_stats[i].success_rate;\n }\n \n if (total_success == 0) return rng() % 5;\n \n double rand_val = uniform_real_distribution(0, total_success)(rng);\n double cum_sum = 0;\n \n for (int i = 0; i < 5; i++) {\n cum_sum += strategy_stats[i].success_rate;\n if (rand_val <= cum_sum) {\n return i;\n }\n }\n \n return 4; // Fallback\n }\n \n vector getNextPlacement(int turn) {\n // Calculate exploration rate (decrease over time)\n double exploration_rate = max(0.1, 0.8 * (1.0 - (double)turn / T));\n \n if (turn < 5) {\n current_strategy = turn % 5;\n } else if (rng() % 100 < (int)(exploration_rate * 100)) {\n // Exploration: random strategy\n current_strategy = rng() % 5;\n } else {\n // Exploitation: select best strategy\n current_strategy = selectStrategy(turn);\n }\n \n vector placement;\n \n // Generate placement based on strategy\n switch (current_strategy) {\n case 0:\n placement = generateRandomPlacement(N);\n break;\n case 1:\n placement = generateGreedyPlacement(N);\n break;\n case 2:\n placement = generateSizeBasedPlacement(N);\n break;\n case 3:\n placement = generateWidthFocusedPlacement(N);\n break;\n case 4:\n placement = generateHeightFocusedPlacement(N);\n break;\n }\n \n // Mutate best solution for later turns\n if (turn > 5 && best_turn != -1 && rng() % 100 < 80) {\n placement = mutatePlacement(best_placement, turn);\n \n // Late game focused improvements\n if (turn > T/2 && rng() % 100 < 50) {\n int start_idx = max(1, (int)(placement.size() * 0.5));\n for (int i = start_idx; i < (int)placement.size(); i++) {\n // 30% chance to apply feedback-based optimization\n if (rng() % 100 < 30 && !feedback_history.empty()) {\n int last_W = feedback_history.back().first;\n int last_H = feedback_history.back().second;\n \n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n if (last_W > last_H * 1.3) {\n placement[i].d = 'U';\n if (rng() % 100 < 70 && orig_w > orig_h) {\n placement[i].r = 1;\n }\n } else if (last_H > last_W * 1.3) {\n placement[i].d = 'L';\n if (rng() % 100 < 70 && orig_h > orig_w) {\n placement[i].r = 1;\n }\n }\n }\n }\n }\n }\n \n // Occasionally try partial packing\n if (turn > 5 && rng() % 100 < 15 && N > 15) {\n uniform_int_distribution size_dist(max(N-8, N/2), N);\n int n = size_dist(rng);\n \n // Regenerate with same strategy\n switch (current_strategy) {\n case 0:\n placement = generateRandomPlacement(n);\n break;\n case 1:\n placement = generateGreedyPlacement(n);\n break;\n case 2:\n placement = generateSizeBasedPlacement(n);\n break;\n case 3:\n placement = generateWidthFocusedPlacement(n);\n break;\n case 4:\n placement = generateHeightFocusedPlacement(n);\n break;\n }\n }\n \n return placement;\n }\n \n void outputPlacement(const vector& placement) {\n cout << placement.size() << endl;\n for (const auto& p : placement) {\n cout << p.p << \" \" << p.r << \" \" << p.d << \" \" << p.b << endl;\n }\n cout.flush();\n }\n \n long long calculateEstimatedScore(int W_prime, int H_prime, int n) {\n long long score = (long long)W_prime + (long long)H_prime;\n \n // Add penalty for unused rectangles\n for (int i = n; i < N; i++) {\n score += (long long)observed_wh[i].first + (long long)observed_wh[i].second;\n }\n \n return score;\n }\n \n void processTurn(int turn) {\n vector placement = getNextPlacement(turn);\n \n // Output the placement\n outputPlacement(placement);\n \n // Read feedback\n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n feedback_history.push_back({W_prime, H_prime});\n \n // Calculate estimated score\n long long estimated_score = calculateEstimatedScore(W_prime, H_prime, placement.size());\n \n // Update strategy statistics\n updateStrategyStats(current_strategy, estimated_score, turn);\n \n // Update best solution if this is better\n if (estimated_score < best_score) {\n best_score = estimated_score;\n best_placement = placement;\n best_turn = turn;\n }\n }\n \n void solve() {\n readInput();\n \n for (int turn = 0; turn < T; turn++) {\n processTurn(turn);\n }\n }\n};\n\nint main() {\n // Use current time as seed for randomness\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RectanglePacker packer(static_cast(seed));\n packer.solve();\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n cin >> N >> M >> H;\n \n vector A(N);\n for (int i = 0; i < N; i++) {\n cin >> A[i];\n }\n \n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n if (u >= 0 && u < N && v >= 0 && v < N) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n }\n \n vector> coords(N);\n for (int i = 0; i < N; i++) {\n cin >> coords[i].first >> coords[i].second;\n }\n \n // Simple solution: Greedy assignment\n vector parent(N, -1);\n vector height(N, 0);\n vector assigned(N, false);\n \n // Create list of vertices sorted by beauty (descending)\n vector vertices(N);\n for (int i = 0; i < N; i++) {\n vertices[i] = i;\n }\n sort(vertices.begin(), vertices.end(), [&](int a, int b) {\n return A[a] > A[b];\n });\n \n // Assign each vertex\n for (int i = 0; i < N; i++) {\n int v = vertices[i];\n if (assigned[v]) continue;\n \n // Start a new tree with this vertex as root\n parent[v] = -1;\n height[v] = 0;\n assigned[v] = true;\n \n // BFS to assign neighbors\n queue q;\n q.push(v);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n // Collect unassigned neighbors\n vector> neighbors; // (beauty, vertex)\n for (int neighbor : adj[u]) {\n if (neighbor >= 0 && neighbor < N && !assigned[neighbor] && height[u] + 1 <= H) {\n neighbors.push_back({A[neighbor], neighbor});\n }\n }\n \n // Sort by beauty (descending)\n sort(neighbors.begin(), neighbors.end(), greater>());\n \n // Assign neighbors\n for (auto& nb : neighbors) {\n int next_v = nb.second;\n if (!assigned[next_v] && height[u] + 1 <= H) {\n parent[next_v] = u;\n height[next_v] = height[u] + 1;\n assigned[next_v] = true;\n q.push(next_v);\n \n // Safety break to avoid excessive memory usage\n if (q.size() > N) break;\n }\n }\n \n // Safety break\n if (q.size() > 2 * N) break;\n }\n }\n \n // Handle any remaining unassigned vertices\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n // Find the best parent among neighbors\n int best_parent = -1;\n int min_height = H + 1;\n \n for (int neighbor : adj[i]) {\n if (neighbor >= 0 && neighbor < N && assigned[neighbor] && height[neighbor] < min_height) {\n min_height = height[neighbor];\n best_parent = neighbor;\n }\n }\n \n if (best_parent != -1 && min_height < H) {\n parent[i] = best_parent;\n height[i] = min_height + 1;\n } else {\n // Make it a root\n parent[i] = -1;\n height[i] = 0;\n }\n assigned[i] = true;\n }\n }\n \n // Final validation pass - ensure no invalid references\n for (int i = 0; i < N; i++) {\n if (parent[i] != -1) {\n // Ensure parent is valid\n if (parent[i] < 0 || parent[i] >= N) {\n parent[i] = -1;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; i++) {\n cout << parent[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n \n // Read input\n cin >> N;\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n vector> operations;\n \n // For each cell that contains an Oni ('x')\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'x') {\n // Check which direction is safe (no Fukunokami)\n bool safe_up = true, safe_down = true, safe_left = true, safe_right = true;\n \n // Check upward direction\n for (int k = 0; k < i; k++) {\n if (board[k][j] == 'o') {\n safe_up = false;\n break;\n }\n }\n \n // Check downward direction\n for (int k = i + 1; k < N; k++) {\n if (board[k][j] == 'o') {\n safe_down = false;\n break;\n }\n }\n \n // Check leftward direction\n for (int k = 0; k < j; k++) {\n if (board[i][k] == 'o') {\n safe_left = false;\n break;\n }\n }\n \n // Check rightward direction\n for (int k = j + 1; k < N; k++) {\n if (board[i][k] == 'o') {\n safe_right = false;\n break;\n }\n }\n \n // Choose a safe direction (at least one is guaranteed to exist)\n if (safe_up) {\n // Shift column j upward (i+1) times\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'U', j});\n }\n // Shift column j downward (i+1) times to restore\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'D', j});\n }\n } else if (safe_down) {\n // Shift column j downward (N-1-i) times\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'D', j});\n }\n // Shift column j upward (N-1-i) times to restore\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'U', j});\n }\n } else if (safe_left) {\n // Shift row i left (j+1) times\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'L', i});\n }\n // Shift row i right (j+1) times to restore\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'R', i});\n }\n } else if (safe_right) {\n // Shift row i right (N-1-j) times\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'R', i});\n }\n // Shift row i left (N-1-j) times to restore\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'L', i});\n }\n }\n }\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\n// Optimized error calculation\nlong long calculateError(const vector& a, const vector& b, const vector& targets) {\n vector counts(N, 0);\n int current = 0;\n \n // Simple simulation - optimized for speed\n for (int week = 0; week < L; week++) {\n counts[current]++;\n current = (counts[current] % 2 == 1) ? a[current] : b[current];\n }\n \n long long total_error = 0;\n for (int i = 0; i < N; i++) {\n total_error += abs(counts[i] - targets[i]);\n }\n return total_error;\n}\n\n// Find employees with highest error\nvector getHighErrorEmployees(const vector& actual, const vector& targets, int count) {\n vector> errors;\n for (int i = 0; i < N; i++) {\n errors.push_back({abs(actual[i] - targets[i]), i});\n }\n sort(errors.rbegin(), errors.rend()); // Sort in descending order\n \n vector result;\n for (int i = 0; i < min(count, N); i++) {\n result.push_back(errors[i].second);\n }\n return result;\n}\n\n// Calculate actual assignments (not just error)\nvector calculateAssignments(const vector& a, const vector& b) {\n vector counts(N, 0);\n int current = 0;\n \n for (int week = 0; week < L; week++) {\n counts[current]++;\n current = (counts[current] % 2 == 1) ? a[current] : b[current];\n }\n \n return counts;\n}\n\n// Construct better initial solution\nvector> createInitialSolution(const vector& targets) {\n vector> result(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n \n // Method 1: Sort by targets and connect adjacent employees\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return targets[i] < targets[j];\n });\n \n // Create a cycle based on sorted order\n for (int i = 0; i < N; i++) {\n int emp = indices[i];\n int next_idx = (i + 1) % N;\n int prev_idx = (i - 1 + N) % N;\n \n // Assign to adjacent employees in sorted order\n result[emp].first = indices[prev_idx];\n result[emp].second = indices[next_idx];\n }\n \n return result;\n}\n\n// Smart local search\nvector> improveSolution(const vector>& initial, const vector& targets) {\n vector a(N), b(N);\n for (int i = 0; i < N; i++) {\n a[i] = initial[i].first;\n b[i] = initial[i].second;\n }\n \n long long best_error = calculateError(a, b, targets);\n vector best_a = a, best_b = b;\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n uniform_real_distribution prob_dist(0.0, 1.0);\n \n // Get initial assignments\n vector current_assignments = calculateAssignments(a, b);\n \n // Smart local search with more iterations\n const int MAX_ITERATIONS = 800; // Increased from 50 to 800\n for (int iter = 0; iter < MAX_ITERATIONS; iter++) {\n // Get employees with highest error\n vector high_error_emps = getHighErrorEmployees(current_assignments, targets, 10);\n \n // Make a copy for modification\n vector new_a = a, new_b = b;\n \n // Choose an employee to modify - prefer high error employees\n int emp;\n if (prob_dist(rng) < 0.7 && !high_error_emps.empty()) {\n emp = high_error_emps[dist(rng) % high_error_emps.size()];\n } else {\n emp = dist(rng);\n }\n \n // Decide whether to change a or b (or both)\n int change_type = dist(rng) % 3;\n \n if (change_type == 0) { // Change a[emp]\n // Prefer employees who are under-assigned if current employee is over-assigned, and vice versa\n int target_diff = targets[emp] - current_assignments[emp];\n if (target_diff > 0) { // emp is under-assigned, point to someone who might reduce their assignment\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.begin(), target_diffs.end()); // Sort by who is most over-assigned\n if (!target_diffs.empty()) {\n new_a[emp] = target_diffs[0].second; // Point to most over-assigned\n } else {\n new_a[emp] = dist(rng);\n }\n } else { // emp is over-assigned, point to someone who might increase their assignment\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.rbegin(), target_diffs.rend()); // Sort by who is most under-assigned\n if (!target_diffs.empty()) {\n new_a[emp] = target_diffs[0].second; // Point to most under-assigned\n } else {\n new_a[emp] = dist(rng);\n }\n }\n } else if (change_type == 1) { // Change b[emp]\n // Similar logic\n int target_diff = targets[emp] - current_assignments[emp];\n if (target_diff > 0) {\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.begin(), target_diffs.end());\n if (!target_diffs.empty()) {\n new_b[emp] = target_diffs[0].second;\n } else {\n new_b[emp] = dist(rng);\n }\n } else {\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n sort(target_diffs.rbegin(), target_diffs.rend());\n if (!target_diffs.empty()) {\n new_b[emp] = target_diffs[0].second;\n } else {\n new_b[emp] = dist(rng);\n }\n }\n } else { // Change both a[emp] and b[emp]\n int target_diff = targets[emp] - current_assignments[emp];\n vector> target_diffs;\n for (int i = 0; i < N; i++) {\n target_diffs.push_back({targets[i] - current_assignments[i], i});\n }\n \n if (target_diff > 0) {\n sort(target_diffs.begin(), target_diffs.end());\n if (target_diffs.size() >= 2) {\n new_a[emp] = target_diffs[0].second;\n new_b[emp] = target_diffs[1].second;\n } else {\n new_a[emp] = dist(rng);\n new_b[emp] = dist(rng);\n }\n } else {\n sort(target_diffs.rbegin(), target_diffs.rend());\n if (target_diffs.size() >= 2) {\n new_a[emp] = target_diffs[0].second;\n new_b[emp] = target_diffs[1].second;\n } else {\n new_a[emp] = dist(rng);\n new_b[emp] = dist(rng);\n }\n }\n }\n \n // Calculate new error\n long long new_error = calculateError(new_a, new_b, targets);\n \n // Accept improvement\n if (new_error < best_error) {\n best_error = new_error;\n best_a = new_a;\n best_b = new_b;\n a = new_a;\n b = new_b;\n current_assignments = calculateAssignments(a, b);\n }\n }\n \n // Convert back to result format\n vector> result(N);\n for (int i = 0; i < N; i++) {\n result[i] = {best_a[i], best_b[i]};\n }\n \n return result;\n}\n\nint main() {\n int n, l;\n cin >> n >> l;\n \n vector targets(n);\n for (int i = 0; i < n; i++) {\n cin >> targets[i];\n }\n \n // Create initial solution\n vector> initial_solution = createInitialSolution(targets);\n \n // Improve with smart local search\n vector> solution = improveSolution(initial_solution, targets);\n \n // Output the solution\n for (int i = 0; i < n; i++) {\n cout << solution[i].first << \" \" << solution[i].second << endl;\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#include \n\nusing namespace std;\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy; // center coordinates\n \n City() : id(-1), lx(0), rx(0), ly(0), ry(0), cx(0), cy(0) {}\n \n City(int id, int lx, int rx, int ly, int ry) : id(id), lx(lx), rx(rx), ly(ly), ry(ry) {\n cx = (lx + rx) / 2.0;\n cy = (ly + ry) / 2.0;\n }\n};\n\nstruct Edge {\n int u, v;\n double estimated_dist;\n int true_dist = -1; // -1 means unknown\n \n Edge() : u(-1), v(-1), estimated_dist(0) {}\n \n Edge(int u, int v, double dist) : u(u), v(v), estimated_dist(dist) {}\n \n bool operator<(const Edge& other) const {\n if (abs(estimated_dist - other.estimated_dist) > 1e-9) {\n return estimated_dist < other.estimated_dist;\n }\n if (u != other.u) return u < other.u;\n return v < other.v;\n }\n};\n\n// Calculate estimated distance between city centers\ndouble estimate_distance(const City& a, const City& b) {\n double dx = a.cx - b.cx;\n double dy = a.cy - b.cy;\n return sqrt(dx*dx + dy*dy);\n}\n\n// Calculate minimum possible distance between two bounding boxes\ndouble min_possible_distance(const City& a, const City& b) {\n double dx1 = static_cast(a.lx - b.rx);\n double dx2 = static_cast(b.lx - a.rx);\n double min_dx = max(0.0, max(dx1, dx2));\n \n double dy1 = static_cast(a.ly - b.ry);\n double dy2 = static_cast(b.ly - a.ry);\n double min_dy = max(0.0, max(dy1, dy2));\n \n return sqrt(min_dx*min_dx + min_dy*min_dy);\n}\n\n// Calculate maximum possible distance between two bounding boxes\ndouble max_possible_distance(const City& a, const City& b) {\n double dx1 = abs(static_cast(a.lx - b.rx));\n double dx2 = abs(static_cast(a.rx - b.lx));\n double max_dx = max(dx1, dx2);\n \n double dy1 = abs(static_cast(a.ly - b.ry));\n double dy2 = abs(static_cast(a.ry - b.ly));\n double max_dy = max(dy1, dy2);\n \n return sqrt(max_dx*max_dx + max_dy*max_dy);\n}\n\n// Calculate a conservative estimate of distance (upper bound for MST pruning)\ndouble conservative_estimate(const City& a, const City& b) {\n return max_possible_distance(a, b);\n}\n\n// Calculate an optimistic estimate of distance (lower bound)\ndouble optimistic_estimate(const City& a, const City& b) {\n return min_possible_distance(a, b);\n}\n\n// Query result structure\nstruct QueryResult {\n vector> edges;\n vector cities;\n};\n\nclass Solution {\nprivate:\n int N, M, Q, L, W;\n vector G;\n vector cities;\n mt19937 rng;\n \n // Store results of queries\n map, int> known_distances; // true distances between pairs\n vector query_results;\n \n // For building final solution\n vector> final_groups;\n vector>> final_edges;\n \n // Track which city pairs we've queried\n set> queried_pairs;\n \npublic:\n Solution() : rng(random_device{}()) {}\n \n void read_input() {\n cin >> N >> M >> Q >> L >> W;\n G.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n cities.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].id = i;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2.0;\n }\n }\n \n QueryResult make_query(const vector& city_ids) {\n int k = city_ids.size();\n if (k < 2 || k > L) {\n cerr << \"Invalid query size: \" << k << endl;\n return {};\n }\n \n cout << \"? \" << k;\n for (int id : city_ids) {\n cout << \" \" << id;\n }\n cout << endl;\n cout.flush();\n \n QueryResult result;\n result.cities = city_ids;\n \n for (int i = 0; i < k - 1; i++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n result.edges.push_back({u, v});\n \n // Store this known edge\n queried_pairs.insert({u, v});\n queried_pairs.insert({v, u});\n }\n \n query_results.push_back(result);\n return result;\n }\n \n // Calculate overlap between two bounding boxes (higher = more likely to be close)\n double calculate_overlap_score(const City& a, const City& b) {\n // Calculate intersection area\n int inter_lx = max(a.lx, b.lx);\n int inter_rx = min(a.rx, b.rx);\n int inter_ly = max(a.ly, b.ly);\n int inter_ry = min(a.ry, b.ry);\n \n double inter_area = 0.0;\n if (inter_lx < inter_rx && inter_ly < inter_ry) {\n inter_area = (inter_rx - inter_lx) * (inter_ry - inter_ly);\n }\n \n // Calculate union area\n double area_a = (a.rx - a.lx) * (a.ry - a.ly);\n double area_b = (b.rx - b.lx) * (b.ry - b.ly);\n double union_area = area_a + area_b - inter_area;\n \n if (union_area == 0) return 0.0;\n return inter_area / union_area;\n }\n \n // Better initial grouping using k-means like clustering\n void improved_initial_grouping() {\n // Create initial groups based on estimated distances\n final_groups.resize(M);\n \n // Sort group sizes in descending order for better assignment\n vector> sorted_groups; // (size, original_index)\n for (int i = 0; i < M; i++) {\n sorted_groups.push_back({G[i], i});\n }\n sort(sorted_groups.rbegin(), sorted_groups.rend()); // descending order\n \n // Track assigned cities\n vector assigned(N, false);\n \n // For each group (largest first)\n for (auto& group_info : sorted_groups) {\n int group_size = group_info.first;\n int original_idx = group_info.second;\n \n // Find the best starting city (least connected to others)\n int start_city = -1;\n double min_avg_dist = 1e18;\n \n for (int i = 0; i < N; i++) {\n if (assigned[i]) continue;\n \n double avg_dist = 0.0;\n int count = 0;\n for (int j = 0; j < N; j++) {\n if (i != j && !assigned[j]) {\n avg_dist += estimate_distance(cities[i], cities[j]);\n count++;\n }\n }\n \n if (count > 0) avg_dist /= count;\n \n if (start_city == -1 || avg_dist < min_avg_dist) {\n min_avg_dist = avg_dist;\n start_city = i;\n }\n }\n \n if (start_city == -1) {\n // Assign remaining cities\n for (int i = 0; i < N && final_groups[original_idx].size() < group_size; i++) {\n if (!assigned[i]) {\n final_groups[original_idx].push_back(i);\n assigned[i] = true;\n }\n }\n continue;\n }\n \n // Start with the selected city\n final_groups[original_idx].push_back(start_city);\n assigned[start_city] = true;\n \n // Greedily add closest cities\n while (final_groups[original_idx].size() < group_size) {\n int best_city = -1;\n double min_dist = 1e18;\n \n for (int i = 0; i < N; i++) {\n if (assigned[i]) continue;\n \n // Calculate average distance to cities in current group\n double avg_dist = 0.0;\n for (int city_in_group : final_groups[original_idx]) {\n avg_dist += estimate_distance(cities[i], cities[city_in_group]);\n }\n avg_dist /= final_groups[original_idx].size();\n \n if (best_city == -1 || avg_dist < min_dist) {\n min_dist = avg_dist;\n best_city = i;\n }\n }\n \n if (best_city != -1) {\n final_groups[original_idx].push_back(best_city);\n assigned[best_city] = true;\n } else {\n // Fallback: add any remaining city\n for (int i = 0; i < N && final_groups[original_idx].size() < group_size; i++) {\n if (!assigned[i]) {\n final_groups[original_idx].push_back(i);\n assigned[i] = true;\n }\n }\n }\n }\n }\n \n // Restore original group order\n vector> temp_groups = final_groups;\n for (int i = 0; i < M; i++) {\n final_groups[i] = temp_groups[i];\n }\n }\n \n // Select best subset for query based on uncertainty\n vector select_query_subset() {\n // Find cities with high position uncertainty\n vector> uncertainty_scores;\n for (int i = 0; i < N; i++) {\n double uncertainty = (cities[i].rx - cities[i].lx) + (cities[i].ry - cities[i].ly);\n uncertainty_scores.push_back({-uncertainty, i}); // negative for sorting\n }\n sort(uncertainty_scores.begin(), uncertainty_scores.end());\n \n // Create candidate sets\n vector> candidate_sets;\n \n // Candidate 1: Highest uncertainty cities\n vector high_uncertainty_set;\n for (int i = 0; i < min(L, (int)uncertainty_scores.size()); i++) {\n high_uncertainty_set.push_back(uncertainty_scores[i].second);\n }\n candidate_sets.push_back(high_uncertainty_set);\n \n // Candidate 2: Cities with overlapping bounding boxes\n for (int i = 0; i < N && candidate_sets.size() < 3; i++) {\n vector overlap_set;\n overlap_set.push_back(i);\n \n for (int j = 0; j < N && overlap_set.size() < L; j++) {\n if (i != j) {\n double overlap = calculate_overlap_score(cities[i], cities[j]);\n if (overlap > 0.1) { // if significant overlap\n overlap_set.push_back(j);\n }\n }\n }\n \n if (overlap_set.size() >= 2) {\n candidate_sets.push_back(overlap_set);\n }\n }\n \n // Candidate 3: Random sampling\n vector random_set;\n vector all_cities(N);\n for (int i = 0; i < N; i++) all_cities[i] = i;\n shuffle(all_cities.begin(), all_cities.end(), rng);\n for (int i = 0; i < min(L, N); i++) {\n random_set.push_back(all_cities[i]);\n }\n candidate_sets.push_back(random_set);\n \n // Select the best candidate (prioritize ones with overlapping boxes)\n for (auto& candidate : candidate_sets) {\n if (candidate.size() >= 2 && candidate.size() <= L) {\n return candidate;\n }\n }\n \n // Fallback\n vector fallback;\n for (int i = 0; i < min(L, N); i++) {\n fallback.push_back(i);\n }\n return fallback;\n }\n \n // Strategic querying to improve grouping\n void strategic_querying() {\n int queries_used = 0;\n \n // First, query some promising subsets for information\n while (queries_used < min(Q / 2, 50)) { // Use half of queries for exploration\n vector subset = select_query_subset();\n \n // Ensure we don't query the exact same set twice\n sort(subset.begin(), subset.end());\n static set> queried_subsets;\n if (queried_subsets.find(subset) != queried_subsets.end()) {\n // Add some variation\n if (subset.size() > 2) {\n subset.pop_back();\n subset.push_back((subset.back() + 1) % N);\n }\n }\n queried_subsets.insert(subset);\n \n QueryResult result = make_query(subset);\n queries_used++;\n }\n \n // Use remaining queries to validate and improve groups\n int group_idx = 0;\n while (queries_used < Q && group_idx < M) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size <= L) {\n // Query the entire group for verification\n QueryResult result = make_query(group);\n queries_used++;\n } else {\n // Query the most uncertain part of the group\n vector> city_uncertainties;\n for (int i = 0; i < group_size; i++) {\n int city_id = group[i];\n double uncertainty = (cities[city_id].rx - cities[city_id].lx) + \n (cities[city_id].ry - cities[city_id].ly);\n city_uncertainties.push_back({-uncertainty, i}); // negative for sorting\n }\n sort(city_uncertainties.begin(), city_uncertainties.end());\n \n // Take up to L cities with highest uncertainty\n vector uncertain_subset;\n for (int i = 0; i < min(L, (int)city_uncertainties.size()); i++) {\n uncertain_subset.push_back(group[city_uncertainties[i].second]);\n }\n \n if (uncertain_subset.size() >= 2) {\n QueryResult result = make_query(uncertain_subset);\n queries_used++;\n }\n }\n \n group_idx++;\n }\n }\n \n // Build MST for each group using known edges and better distance estimates\n void build_better_msts() {\n final_edges.clear();\n final_edges.resize(M);\n \n for (int group_idx = 0; group_idx < M; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size == 1) {\n continue;\n }\n \n // Create a graph with all possible edges in the group\n vector edges;\n for (int i = 0; i < group_size; i++) {\n for (int j = i + 1; j < group_size; j++) {\n int u = group[i];\n int v = group[j];\n if (u > v) swap(u, v);\n \n // Use known distance if available\n double estimated_dist;\n if (known_distances.find({u, v}) != known_distances.end()) {\n // We know this edge exists in some MST, so prioritize it\n estimated_dist = 0;\n } else {\n // Use a weighted estimate based on bounding box information\n double center_dist = estimate_distance(cities[u], cities[v]);\n double min_dist = min_possible_distance(cities[u], cities[v]);\n double max_dist = max_possible_distance(cities[u], cities[v]);\n \n // Weighted estimate: favor lower bounds for MST\n estimated_dist = min_dist * 0.7 + center_dist * 0.3;\n }\n \n edges.push_back(Edge(u, v, estimated_dist));\n }\n }\n \n // Sort edges by estimated distance\n sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {\n if (abs(a.estimated_dist - b.estimated_dist) > 1e-9) {\n return a.estimated_dist < b.estimated_dist;\n }\n if (a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n \n // Use Kruskal's algorithm to build MST\n vector parent(group_size);\n for (int i = 0; i < group_size; i++) {\n parent[i] = i;\n }\n \n function find_root = [&](int x) {\n if (parent[x] != x) {\n parent[x] = find_root(parent[x]);\n }\n return parent[x];\n };\n \n auto unite = [&](int x, int y) {\n int rx = find_root(x);\n int ry = find_root(y);\n if (rx != ry) {\n parent[rx] = ry;\n return true;\n }\n return false;\n };\n \n // Build MST\n for (const Edge& e : edges) {\n int u_idx = -1, v_idx = -1;\n for (int i = 0; i < group_size; i++) {\n if (group[i] == e.u) u_idx = i;\n if (group[i] == e.v) v_idx = i;\n }\n \n if (u_idx != -1 && v_idx != -1 && unite(u_idx, v_idx)) {\n final_edges[group_idx].push_back({e.u, e.v});\n if (final_edges[group_idx].size() == (size_t)(group_size - 1)) {\n break;\n }\n }\n }\n }\n }\n \n void output_answer() {\n cout << \"!\" << endl;\n \n for (int i = 0; i < M; i++) {\n // Output group members\n for (int j = 0; j < (int)final_groups[i].size(); j++) {\n if (j > 0) cout << \" \";\n cout << final_groups[i][j];\n }\n cout << endl;\n \n // Output edges for this group\n for (auto& edge : final_edges[i]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n cout.flush();\n }\n \n void solve() {\n read_input();\n \n // Use improved initial grouping\n improved_initial_grouping();\n \n // Use strategic querying to gather information and validate groups\n strategic_querying();\n \n // Build final MSTs with better distance estimates\n build_better_msts();\n \n // Output answer\n output_answer();\n }\n};\n\nint main() {\n Solution solution;\n solution.solve();\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Pos {\n int i, j;\n Pos(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator==(const Pos& other) const {\n return i == other.i && j == other.j;\n }\n};\n\n// Manhattan distance helper (moved before it's used)\nint manhattan(const Pos& a, const Pos& b) {\n return abs(a.i - b.i) + abs(a.j - b.j);\n}\n\n// Direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Check if position is valid\nbool isValid(const Pos& p, int N) {\n return p.i >= 0 && p.i < N && p.j >= 0 && p.j < N;\n}\n\n// Check if can move to position (removed unused 'from' parameter)\nbool canMoveTo(const Pos& to, const vector>& blocks, int N) {\n if (!isValid(to, N)) return false;\n if (blocks[to.i][to.j]) return false;\n return true;\n}\n\n// Sliding in a direction until hitting a block\nPos slide(const Pos& start, int dir, const vector>& blocks, int N) {\n Pos current = start;\n Pos next = {current.i + di[dir], current.j + dj[dir]};\n \n while (isValid(next, N) && !blocks[next.i][next.j]) {\n current = next;\n next = {current.i + di[dir], current.j + dj[dir]};\n }\n \n return current;\n}\n\n// Simple direct path using Manhattan distance\nvector> simplePath(const Pos& start, const Pos& target, vector>& blocks, int N) {\n vector> actions;\n Pos current = start;\n \n // If we're already at target, return empty path\n if (current == target) {\n return actions;\n }\n \n // Handle case where target has a block\n if (blocks[target.i][target.j]) {\n // Find adjacent position to target\n Pos adjacent;\n bool found = false;\n \n // Try up, down, left, right in order\n for (int d = 0; d < 4; d++) {\n Pos adj = {target.i + di[d], target.j + dj[d]};\n if (isValid(adj, N) && !blocks[adj.i][adj.j]) {\n adjacent = adj;\n found = true;\n break;\n }\n }\n \n if (found) {\n // Path to adjacent position\n auto pathToAdjacent = simplePath(current, adjacent, blocks, N);\n actions.insert(actions.end(), pathToAdjacent.begin(), pathToAdjacent.end());\n current = adjacent;\n \n // Remove block at target\n int dirToTarget = -1;\n if (current.i == target.i - 1) dirToTarget = 1; // Down\n else if (current.i == target.i + 1) dirToTarget = 0; // Up\n else if (current.j == target.j - 1) dirToTarget = 3; // Right\n else if (current.j == target.j + 1) dirToTarget = 2; // Left\n \n if (dirToTarget != -1) {\n actions.push_back({'A', dirChar[dirToTarget]});\n blocks[target.i][target.j] = false;\n \n // Move to target\n actions.push_back({'M', dirChar[dirToTarget]});\n return actions;\n }\n }\n // If couldn't find adjacent, fall through to normal pathfinding\n }\n \n // Try to use slide if it's a straight line with no obstacles\n for (int d = 0; d < 4; d++) {\n // Check if target is in this direction\n bool isInLine = false;\n if (d == 0 && current.i > target.i && current.j == target.j) isInLine = true; // Up\n else if (d == 1 && current.i < target.i && current.j == target.j) isInLine = true; // Down\n else if (d == 2 && current.j > target.j && current.i == target.i) isInLine = true; // Left\n else if (d == 3 && current.j < target.j && current.i == target.i) isInLine = true; // Right\n \n if (isInLine) {\n // Check if path is clear (no blocks)\n bool pathClear = true;\n Pos check = current;\n while (check != target) {\n check = {check.i + di[d], check.j + dj[d]};\n if (check != target && blocks[check.i][check.j]) {\n pathClear = false;\n break;\n }\n }\n \n if (pathClear) {\n // Check if sliding would stop exactly at target\n Pos slideEnd = slide(current, d, blocks, N);\n if (slideEnd == target) {\n actions.push_back({'S', dirChar[d]});\n return actions;\n }\n }\n }\n }\n \n // Simple greedy Manhattan moves\n while (current != target) {\n // Try to move in direction that reduces distance to target\n int bestDir = -1;\n int minDist = manhattan(current, target) + 1;\n \n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(next, blocks, N)) {\n int dist = abs(next.i - target.i) + abs(next.j - target.j);\n if (dist < minDist) {\n minDist = dist;\n bestDir = d;\n }\n }\n }\n \n // If no improving move, take any valid move\n if (bestDir == -1) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(next, blocks, N)) {\n bestDir = d;\n break;\n }\n }\n }\n \n // If still no valid move, we need to remove a blocking block\n if (bestDir == -1) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (isValid(next, N) && blocks[next.i][next.j]) {\n actions.push_back({'A', dirChar[d]});\n blocks[next.i][next.j] = false;\n bestDir = -2; // Flag to retry\n break;\n }\n }\n \n if (bestDir == -2) continue; // Retry after removing block\n else break; // Truly stuck\n }\n \n // Execute move\n actions.push_back({'M', dirChar[bestDir]});\n current = {current.i + di[bestDir], current.j + dj[bestDir]};\n \n // Safety break to avoid infinite loops\n if (actions.size() > 1000) break;\n }\n \n return actions;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N = 20, M = 40;\n cin >> N >> M;\n \n vector targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].i >> targets[i].j;\n }\n \n // Initialize board with no blocks\n vector> blocks(N, vector(N, false));\n Pos currentPos = targets[0];\n vector> allActions;\n \n // Visit each target in order (starting from index 1 since index 0 is start)\n for (int targetIdx = 1; targetIdx < M; targetIdx++) {\n const Pos& target = targets[targetIdx];\n \n // Simple approach: get path and execute it\n vector> path = simplePath(currentPos, target, blocks, N);\n \n // Execute path and update current position\n for (auto& action : path) {\n allActions.push_back(action);\n \n // Update current position based on action\n if (action.first == 'M') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (canMoveTo(next, blocks, N)) {\n currentPos = next;\n }\n } else if (action.first == 'S') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n currentPos = slide(currentPos, dir, blocks, N);\n } else if (action.first == 'A') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos alterPos = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (isValid(alterPos, N)) {\n blocks[alterPos.i][alterPos.j] = !blocks[alterPos.i][alterPos.j];\n }\n }\n }\n \n // Safety check: if we didn't reach target, try one direct move\n if (currentPos != target) {\n for (int d = 0; d < 4; d++) {\n Pos next = {currentPos.i + di[d], currentPos.j + dj[d]};\n if (next == target && canMoveTo(next, blocks, N)) {\n allActions.push_back({'M', dirChar[d]});\n currentPos = next;\n break;\n }\n }\n }\n }\n \n // Output all actions\n for (auto& action : allActions) {\n cout << action.first << \" \" << action.second << \"\\n\";\n }\n \n return 0;\n}"},"16":{"ahc001":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int a, b, c, d; // left, top, right, bottom\n int idx;\n \n Rectangle() : a(0), b(0), c(0), d(0), idx(-1) {}\n Rectangle(int a, int b, int c, int d, int idx) : a(a), b(b), c(c), d(d), idx(idx) {}\n \n int area() const { return (c - a) * (d - b); }\n \n bool contains(double x, double y) const {\n return x >= a && x < c && y >= b && y < d;\n }\n \n // Very explicit overlap detection\n bool overlaps(const Rectangle& other) const {\n if (c <= other.a) return false;\n if (a >= other.c) return false;\n if (d <= other.b) return false;\n if (b >= other.d) return false;\n return true;\n }\n \n // Calculate overlap area\n int overlapArea(const Rectangle& other) const {\n int left = max(a, other.a);\n int right = min(c, other.c);\n int top = max(b, other.b);\n int bottom = min(d, other.d);\n \n if (left >= right || top >= bottom) return 0;\n return (right - left) * (bottom - top);\n }\n};\n\nstruct Company {\n int x, y, r, idx;\n double target_x, target_y;\n \n Company() : x(0), y(0), r(0), idx(-1), target_x(0.0), target_y(0.0) {}\n Company(int x, int y, int r, int idx) : x(x), y(y), r(r), idx(idx) {\n target_x = x + 0.5;\n target_y = y + 0.5;\n }\n};\n\n// Calculate satisfaction for a company\ndouble calculateSatisfaction(int desired_area, int actual_area) {\n if (actual_area == 0) return 0.0;\n double ratio = min(desired_area, actual_area) * 1.0 / max(desired_area, actual_area);\n return 1.0 - (1.0 - ratio) * (1.0 - ratio);\n}\n\n// Calculate total satisfaction\ndouble calculateTotalSatisfaction(const vector& rects, const vector& companies) {\n size_t n = companies.size();\n double total = 0.0;\n for (size_t i = 0; i < n; i++) {\n const Company& c = companies[i];\n const Rectangle& r = rects[i];\n if (r.contains(c.target_x, c.target_y)) {\n total += calculateSatisfaction(c.r, r.area());\n }\n }\n return total;\n}\n\n// Simple struct for adjustments\nstruct Adjustment {\n int da, db, dc, dd;\n Adjustment(int a, int b, int c, int d) : da(a), db(b), dc(c), dd(d) {}\n};\n\n// Optimized initial rectangle placement\nvector createOptimizedInitialRectangles(const vector& companies) {\n size_t n = companies.size();\n vector rects(n);\n \n // Sort companies by desired area (largest first)\n vector> area_idx;\n for (size_t i = 0; i < n; i++) {\n area_idx.push_back({companies[i].r, static_cast(i)});\n }\n sort(area_idx.begin(), area_idx.end(), greater>());\n \n for (auto& ai : area_idx) {\n int i = ai.second;\n const Company& c = companies[i];\n \n // Calculate dimensions based on desired area and target point\n int width, height;\n \n // For very large areas, try to respect the square root dimensions\n if (c.r > 100000) {\n width = (int)sqrt(c.r * 1.1); // 10% larger initially\n height = (c.r * 1.1) / max(1, width);\n } else {\n // For smaller areas, be more precise\n width = (int)sqrt(c.r);\n if (width * width < c.r) width++;\n height = c.r / max(1, width);\n if (width * height < c.r) height++;\n }\n \n // Center around target point\n int left = (int)(c.target_x - width / 2.0);\n int top = (int)(c.target_y - height / 2.0);\n int right = left + width;\n int bottom = top + height;\n \n // Adjust if out of bounds\n if (left < 0) {\n left = 0;\n right = min(width, 10000);\n }\n if (right > 10000) {\n right = 10000;\n left = max(0, right - width);\n }\n if (top < 0) {\n top = 0;\n bottom = min(height, 10000);\n }\n if (bottom > 10000) {\n bottom = 10000;\n top = max(0, bottom - height);\n }\n \n // Ensure target point containment\n if (c.target_x < left + 0.5) left = max(0, (int)(c.target_x - 0.5));\n if (c.target_x >= right - 0.5) right = min(10000, (int)(c.target_x + 1.5));\n if (c.target_y < top + 0.5) top = max(0, (int)(c.target_y - 0.5));\n if (c.target_y >= bottom - 0.5) bottom = min(10000, (int)(c.target_y + 1.5));\n \n rects[i] = Rectangle(left, top, right, bottom, i);\n }\n \n return rects;\n}\n\n// Improved overlap resolution with satisfaction awareness\nvoid resolveOverlapOptimized(Rectangle& r1, Rectangle& r2, const Company& c1, const Company& c2) {\n // Calculate current satisfaction\n double sat1 = r1.contains(c1.target_x, c1.target_y) ? calculateSatisfaction(c1.r, r1.area()) : 0.0;\n double sat2 = r2.contains(c2.target_x, c2.target_y) ? calculateSatisfaction(c2.r, r2.area()) : 0.0;\n \n // Calculate aspect ratios\n double aspect1 = (double)(r1.c - r1.a) / max(1, r1.d - r1.b);\n double aspect2 = (double)(r2.c - r2.a) / max(1, r2.d - r2.b);\n double aspect_diff1 = fabs(aspect1 - 1.0);\n double aspect_diff2 = fabs(aspect2 - 1.0);\n \n // Combined score: lower satisfaction + worse aspect ratio = higher priority for adjustment\n double score1 = (1.0 - sat1) + aspect_diff1 * 0.1;\n double score2 = (1.0 - sat2) + aspect_diff2 * 0.1;\n \n // Prefer to adjust the rectangle with higher score (lower satisfaction + worse aspect)\n bool adjust_r1 = (score1 > score2) || (score1 == score2 && r1.idx > r2.idx);\n \n if (adjust_r1) {\n // Try to shrink r1\n int width = r1.c - r1.a;\n int height = r1.d - r1.b;\n \n // Try to preserve better aspect ratio by shrinking the more excessive dimension\n double target_ratio = 1.0;\n if (c1.r > 10000) {\n target_ratio = sqrt(c1.r) / (c1.r / max(1, (int)sqrt(c1.r)));\n }\n \n double current_ratio = (double)width / max(1, height);\n double ratio_diff = fabs(current_ratio - target_ratio);\n \n bool adjusted = false;\n \n // If width is excessively large compared to target ratio\n if (width > 1 && (current_ratio > target_ratio || ratio_diff > 0.5)) {\n if (c1.target_x < r1.c - 1 - 0.5) {\n r1.c -= 1;\n adjusted = true;\n } else if (c1.target_x >= r1.a + 1 + 0.5) {\n r1.a += 1;\n adjusted = true;\n }\n }\n \n // If height is excessively large or width adjustment didn't work\n if (!adjusted && height > 1) {\n if (c1.target_y < r1.d - 1 - 0.5) {\n r1.d -= 1;\n adjusted = true;\n } else if (c1.target_y >= r1.b + 1 + 0.5) {\n r1.b += 1;\n adjusted = true;\n }\n }\n \n // If still not adjusted, try any possible adjustment\n if (!adjusted) {\n if (width > 1 && c1.target_x < r1.c - 1 - 0.5) {\n r1.c -= 1;\n } else if (width > 1 && c1.target_x >= r1.a + 1 + 0.5) {\n r1.a += 1;\n } else if (height > 1 && c1.target_y < r1.d - 1 - 0.5) {\n r1.d -= 1;\n } else if (height > 1 && c1.target_y >= r1.b + 1 + 0.5) {\n r1.b += 1;\n } else if (width > 1) {\n r1.c -= 1;\n } else if (height > 1) {\n r1.d -= 1;\n } else {\n r1.a = (int)c1.target_x;\n r1.c = min(10000, r1.a + 1);\n r1.b = (int)c1.target_y;\n r1.d = min(10000, r1.b + 1);\n }\n }\n } else {\n // Try to shrink r2 (same logic)\n int width = r2.c - r2.a;\n int height = r2.d - r2.b;\n \n double target_ratio = 1.0;\n if (c2.r > 10000) {\n target_ratio = sqrt(c2.r) / (c2.r / max(1, (int)sqrt(c2.r)));\n }\n \n double current_ratio = (double)width / max(1, height);\n double ratio_diff = fabs(current_ratio - target_ratio);\n \n bool adjusted = false;\n \n if (width > 1 && (current_ratio > target_ratio || ratio_diff > 0.5)) {\n if (c2.target_x < r2.c - 1 - 0.5) {\n r2.c -= 1;\n adjusted = true;\n } else if (c2.target_x >= r2.a + 1 + 0.5) {\n r2.a += 1;\n adjusted = true;\n }\n }\n \n if (!adjusted && height > 1) {\n if (c2.target_y < r2.d - 1 - 0.5) {\n r2.d -= 1;\n adjusted = true;\n } else if (c2.target_y >= r2.b + 1 + 0.5) {\n r2.b += 1;\n adjusted = true;\n }\n }\n \n if (!adjusted) {\n if (width > 1 && c2.target_x < r2.c - 1 - 0.5) {\n r2.c -= 1;\n } else if (width > 1 && c2.target_x >= r2.a + 1 + 0.5) {\n r2.a += 1;\n } else if (height > 1 && c2.target_y < r2.d - 1 - 0.5) {\n r2.d -= 1;\n } else if (height > 1 && c2.target_y >= r2.b + 1 + 0.5) {\n r2.b += 1;\n } else if (width > 1) {\n r2.c -= 1;\n } else if (height > 1) {\n r2.d -= 1;\n } else {\n r2.a = (int)c2.target_x;\n r2.c = min(10000, r2.a + 1);\n r2.b = (int)c2.target_y;\n r2.d = min(10000, r2.b + 1);\n }\n }\n }\n \n // Ensure target point containment\n if (!r1.contains(c1.target_x, c1.target_y)) {\n r1.a = (int)c1.target_x;\n r1.c = min(10000, r1.a + 1);\n r1.b = (int)c1.target_y;\n r1.d = min(10000, r1.b + 1);\n }\n if (!r2.contains(c2.target_x, c2.target_y)) {\n r2.a = (int)c2.target_x;\n r2.c = min(10000, r2.a + 1);\n r2.b = (int)c2.target_y;\n r2.d = min(10000, r2.b + 1);\n }\n}\n\n// Exhaustive overlap resolution\nvoid exhaustiveOverlapResolution(vector& rects, const vector& companies) {\n size_t n = rects.size();\n const int MAX_ITERATIONS = 100000;\n int iterations = 0;\n \n while (iterations < MAX_ITERATIONS) {\n bool overlap_found = false;\n \n for (size_t i = 0; i < n; i++) {\n for (size_t j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n overlap_found = true;\n \n // Resolve overlap\n resolveOverlapOptimized(rects[i], rects[j], companies[i], companies[j]);\n \n // Emergency fix if still overlapping\n if (rects[i].overlaps(rects[j])) {\n if (i > j) {\n if (rects[i].c - rects[i].a > 1) {\n rects[i].c -= 1;\n } else if (rects[i].d - rects[i].b > 1) {\n rects[i].d -= 1;\n } else {\n rects[i].c = min(10000, rects[i].a + 1);\n rects[i].d = min(10000, rects[i].b + 1);\n }\n } else {\n if (rects[j].c - rects[j].a > 1) {\n rects[j].c -= 1;\n } else if (rects[j].d - rects[j].b > 1) {\n rects[j].d -= 1;\n } else {\n rects[j].c = min(10000, rects[j].a + 1);\n rects[j].d = min(10000, rects[j].b + 1);\n }\n }\n }\n \n goto restart_checking;\n }\n }\n }\n \n if (!overlap_found) {\n break;\n }\n \n restart_checking:\n iterations++;\n \n // Safety break\n if (iterations > 50000) {\n for (size_t k = 0; k < n; k++) {\n int new_a = (int)companies[k].target_x;\n int new_c = min(10000, new_a + 1);\n int new_b = (int)companies[k].target_y;\n int new_d = min(10000, new_b + 1);\n rects[k] = Rectangle(new_a, new_b, new_c, new_d, k);\n }\n break;\n }\n }\n}\n\n// Final validation\nvoid finalOverlapValidation(vector& rects, const vector& companies) {\n size_t n = rects.size();\n const int MAX_ATTEMPTS = 10000;\n int attempts = 0;\n \n bool overlaps_exist = true;\n while (overlaps_exist && attempts < MAX_ATTEMPTS) {\n overlaps_exist = false;\n \n for (size_t i = 0; i < n; i++) {\n for (size_t j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n overlaps_exist = true;\n \n resolveOverlapOptimized(rects[i], rects[j], companies[i], companies[j]);\n \n if (rects[i].overlaps(rects[j])) {\n if (i > j) {\n rects[i] = Rectangle((int)companies[i].target_x, (int)companies[i].target_y,\n min(10000, (int)companies[i].target_x + 1),\n min(10000, (int)companies[i].target_y + 1), i);\n } else {\n rects[j] = Rectangle((int)companies[j].target_x, (int)companies[j].target_y,\n min(10000, (int)companies[j].target_x + 1),\n min(10000, (int)companies[j].target_y + 1), j);\n }\n }\n \n goto continue_checking;\n }\n }\n }\n \n continue_checking:\n attempts++;\n }\n}\n\n// Adaptive optimization based on remaining time\nvoid adaptiveOptimization(vector& rects, const vector& companies, int time_remaining_ms) {\n size_t n = rects.size();\n double best_score = calculateTotalSatisfaction(rects, companies);\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Calculate iterations based on time remaining\n int iterations = min(2000, time_remaining_ms * 2);\n if (iterations < 100) iterations = 100;\n \n for (int iter = 0; iter < iterations; iter++) {\n // Focus on rectangles with lower satisfaction\n vector> satisfaction_idx;\n for (size_t i = 0; i < n; i++) {\n double sat = rects[i].contains(companies[i].target_x, companies[i].target_y) ? \n calculateSatisfaction(companies[i].r, rects[i].area()) : 0.0;\n satisfaction_idx.push_back({sat, i});\n }\n \n // Sort by satisfaction (lowest first)\n sort(satisfaction_idx.begin(), satisfaction_idx.end());\n \n // Pick from the lower 50% satisfaction rectangles\n int pick_range = max(1, (int)satisfaction_idx.size() / 2);\n size_t idx = satisfaction_idx[rng() % pick_range].second;\n \n Rectangle orig = rects[idx];\n \n vector candidates;\n \n // More aggressive adjustments when we have more time\n int max_adjustment = 3;\n if (time_remaining_ms < 1000) max_adjustment = 1;\n \n vector adjustments = {\n // Large expansions\n Adjustment(0, 0, max_adjustment, 0), Adjustment(0, 0, 0, max_adjustment), \n Adjustment(-max_adjustment, 0, 0, 0), Adjustment(0, -max_adjustment, 0, 0),\n // Medium expansions\n Adjustment(0, 0, 2, 0), Adjustment(0, 0, 0, 2), Adjustment(-2, 0, 0, 0), Adjustment(0, -2, 0, 0),\n // Small expansions\n Adjustment(0, 0, 1, 0), Adjustment(0, 0, 0, 1), Adjustment(-1, 0, 0, 0), Adjustment(0, -1, 0, 0),\n // Diagonal expansions\n Adjustment(-1, -1, 1, 1), Adjustment(-2, -2, 2, 2), \n Adjustment(-1, 0, 1, 0), Adjustment(0, -1, 0, 1),\n // Shrinks for repositioning (more conservative)\n Adjustment(1, 0, -1, 0), Adjustment(0, 1, 0, -1)\n };\n \n for (auto& adj : adjustments) {\n int new_a = orig.a + adj.da;\n int new_b = orig.b + adj.db;\n int new_c = orig.c + adj.dc;\n int new_d = orig.d + adj.dd;\n \n if (new_a < 0 || new_b < 0 || new_c > 10000 || new_d > 10000) continue;\n if (new_a >= new_c || new_b >= new_d) continue;\n \n double target_x = companies[idx].target_x;\n double target_y = companies[idx].target_y;\n if (target_x < new_a + 0.5 || target_x >= new_c - 0.5 || \n target_y < new_b + 0.5 || target_y >= new_d - 0.5) continue;\n \n bool has_overlap = false;\n Rectangle test_rect(new_a, new_b, new_c, new_d, idx);\n for (size_t j = 0; j < n; j++) {\n if (j != idx && test_rect.overlaps(rects[j])) {\n has_overlap = true;\n break;\n }\n }\n \n if (!has_overlap) {\n candidates.push_back(test_rect);\n }\n }\n \n if (!candidates.empty()) {\n double best_candidate_score = -1.0;\n Rectangle best_candidate;\n \n for (auto& cand : candidates) {\n rects[idx] = cand;\n double score = calculateTotalSatisfaction(rects, companies);\n if (score > best_candidate_score) {\n best_candidate_score = score;\n best_candidate = cand;\n }\n }\n \n // Apply if improves score (be more lenient when we have time)\n double threshold = (time_remaining_ms > 2000) ? 0.98 : 0.995;\n if (best_candidate_score > best_score * threshold) {\n rects[idx] = best_candidate;\n if (best_candidate_score > best_score) {\n best_score = best_candidate_score;\n }\n } else {\n rects[idx] = orig;\n }\n }\n }\n}\n\n// Final targeted optimization for low-satisfaction rectangles\nvoid finalTargetedOptimization(vector& rects, const vector& companies, int time_remaining_ms) {\n size_t n = rects.size();\n double best_score = calculateTotalSatisfaction(rects, companies);\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n \n // Focus only on rectangles with satisfaction below 0.8\n vector low_satisfaction_rects;\n for (size_t i = 0; i < n; i++) {\n double sat = rects[i].contains(companies[i].target_x, companies[i].target_y) ? \n calculateSatisfaction(companies[i].r, rects[i].area()) : 0.0;\n if (sat < 0.8) {\n low_satisfaction_rects.push_back(i);\n }\n }\n \n if (low_satisfaction_rects.empty()) return;\n \n // Limited iterations based on time\n int iterations = min(1000, time_remaining_ms);\n \n for (int iter = 0; iter < iterations; iter++) {\n size_t idx = low_satisfaction_rects[rng() % low_satisfaction_rects.size()];\n Rectangle orig = rects[idx];\n \n vector candidates;\n \n // Focus on expanding\n vector adjustments = {\n Adjustment(0, 0, 1, 0), Adjustment(0, 0, 0, 1), \n Adjustment(-1, 0, 0, 0), Adjustment(0, -1, 0, 0),\n Adjustment(-1, -1, 1, 1), Adjustment(-1, 0, 1, 0), \n Adjustment(0, -1, 0, 1)\n };\n \n for (auto& adj : adjustments) {\n int new_a = orig.a + adj.da;\n int new_b = orig.b + adj.db;\n int new_c = orig.c + adj.dc;\n int new_d = orig.d + adj.dd;\n \n if (new_a < 0 || new_b < 0 || new_c > 10000 || new_d > 10000) continue;\n if (new_a >= new_c || new_b >= new_d) continue;\n \n double target_x = companies[idx].target_x;\n double target_y = companies[idx].target_y;\n if (target_x < new_a + 0.5 || target_x >= new_c - 0.5 || \n target_y < new_b + 0.5 || target_y >= new_d - 0.5) continue;\n \n bool has_overlap = false;\n Rectangle test_rect(new_a, new_b, new_c, new_d, idx);\n for (size_t j = 0; j < n; j++) {\n if (j != idx && test_rect.overlaps(rects[j])) {\n has_overlap = true;\n break;\n }\n }\n \n if (!has_overlap) {\n candidates.push_back(test_rect);\n }\n }\n \n if (!candidates.empty()) {\n double best_candidate_score = -1.0;\n Rectangle best_candidate;\n \n for (auto& cand : candidates) {\n rects[idx] = cand;\n double score = calculateTotalSatisfaction(rects, companies);\n if (score > best_candidate_score) {\n best_candidate_score = score;\n best_candidate = cand;\n }\n }\n \n if (best_candidate_score > best_score * 0.99) {\n rects[idx] = best_candidate;\n if (best_candidate_score > best_score) {\n best_score = best_candidate_score;\n }\n } else {\n rects[idx] = orig;\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n auto start_time = chrono::steady_clock::now();\n \n int n;\n cin >> n;\n \n vector companies;\n for (int i = 0; i < n; i++) {\n int x, y, r;\n cin >> x >> y >> r;\n companies.push_back(Company(x, y, r, i));\n }\n \n // Create optimized initial rectangles\n vector rects = createOptimizedInitialRectangles(companies);\n \n // Resolve overlaps with optimized method\n exhaustiveOverlapResolution(rects, companies);\n \n // Final validation\n finalOverlapValidation(rects, companies);\n \n // Adaptive optimization based on remaining time\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n int time_remaining_ms = 5000 - (int)elapsed_ms; // Assuming 5s limit\n \n if (time_remaining_ms > 500) {\n vector backup = rects;\n adaptiveOptimization(rects, companies, time_remaining_ms);\n finalOverlapValidation(rects, companies);\n \n // Final targeted optimization if we still have time\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n time_remaining_ms = 5000 - (int)elapsed_ms;\n \n if (time_remaining_ms > 200) {\n vector backup2 = rects;\n finalTargetedOptimization(rects, companies, time_remaining_ms);\n finalOverlapValidation(rects, companies);\n \n // Revert if final optimization made things worse\n double new_score = calculateTotalSatisfaction(rects, companies);\n double old_score = calculateTotalSatisfaction(backup2, companies);\n if (new_score < old_score * 0.98) {\n rects = backup2;\n finalOverlapValidation(rects, companies);\n }\n }\n \n // Revert if optimization made things worse\n double new_score = calculateTotalSatisfaction(rects, companies);\n double old_score = calculateTotalSatisfaction(backup, companies);\n if (new_score < old_score * 0.98) {\n rects = backup;\n finalOverlapValidation(rects, companies);\n }\n }\n \n // Final preparation\n for (int i = 0; i < n; i++) {\n rects[i].a = max(0, rects[i].a);\n rects[i].b = max(0, rects[i].b);\n rects[i].c = min(10000, rects[i].c);\n rects[i].d = min(10000, rects[i].d);\n \n if (rects[i].a >= rects[i].c) {\n rects[i].a = (int)companies[i].target_x;\n rects[i].c = min(10000, rects[i].a + 1);\n }\n if (rects[i].b >= rects[i].d) {\n rects[i].b = (int)companies[i].target_y;\n rects[i].d = min(10000, rects[i].b + 1);\n }\n if (!rects[i].contains(companies[i].target_x, companies[i].target_y)) {\n rects[i].a = (int)companies[i].target_x;\n rects[i].c = min(10000, rects[i].a + 1);\n rects[i].b = (int)companies[i].target_y;\n rects[i].d = min(10000, rects[i].b + 1);\n }\n }\n \n // Final overlap check\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (rects[i].overlaps(rects[j])) {\n // Absolute emergency fix\n if (i > j) {\n rects[i] = Rectangle((int)companies[i].target_x, (int)companies[i].target_y,\n min(10000, (int)companies[i].target_x + 1),\n min(10000, (int)companies[i].target_y + 1), i);\n } else {\n rects[j] = Rectangle((int)companies[j].target_x, (int)companies[j].target_y,\n min(10000, (int)companies[j].target_x + 1),\n min(10000, (int)companies[j].target_y + 1), j);\n }\n }\n }\n }\n \n // Output\n for (int i = 0; i < n; i++) {\n cout << rects[i].a << \" \" << rects[i].b << \" \" << rects[i].c << \" \" << rects[i].d << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Tile {\n vector> squares;\n int total_value;\n int id;\n \n // Calculate the center of the tile\n pair get_center() const {\n double center_i = 0.0, center_j = 0.0;\n for (auto& square : squares) {\n center_i += square.first;\n center_j += square.second;\n }\n if (!squares.empty()) {\n center_i /= squares.size();\n center_j /= squares.size();\n }\n return {center_i, center_j};\n }\n \n // Calculate number of adjacent tiles\n int count_adjacent_tiles(const vector>& tile_ids, int n) const {\n unordered_set adjacent_tiles;\n for (auto& square : squares) {\n for (int d = 0; d < 4; d++) {\n int ni = square.first + (d == 0 ? -1 : d == 1 ? 1 : 0);\n int nj = square.second + (d == 2 ? -1 : d == 3 ? 1 : 0);\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int adj_tile_id = tile_ids[ni][nj];\n if (adj_tile_id != id) {\n adjacent_tiles.insert(adj_tile_id);\n }\n }\n }\n }\n return adjacent_tiles.size();\n }\n};\n\nclass Solution {\nprivate:\n int si, sj;\n vector> tile_ids;\n vector> values;\n vector tiles;\n int n = 50;\n high_resolution_clock::time_point start_time;\n const double time_limit = 1.9;\n \n // Directions: U, D, L, R\n const vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n const string dir_chars = \"UDLR\";\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < n && j >= 0 && j < n;\n }\n \n double get_elapsed_time() {\n auto now = high_resolution_clock::now();\n auto duration = duration_cast(now - start_time);\n return duration.count() / 1000000.0;\n }\n \n int get_direction(int i, int j, int ni, int nj) {\n if (ni == i - 1) return 0; // U\n if (ni == i + 1) return 1; // D\n if (nj == j - 1) return 2; // L\n if (nj == j + 1) return 3; // R\n return -1;\n }\n \n int get_direction_index(char c) {\n if (c == 'U') return 0;\n if (c == 'D') return 1;\n if (c == 'L') return 2;\n if (c == 'R') return 3;\n return 0;\n }\n \n // Validate a path with detailed step-by-step checking\n bool validate_path(const string& path, int& final_score) {\n if (path.empty()) {\n final_score = values[si][sj];\n return true;\n }\n \n unordered_set visited_tiles;\n visited_tiles.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n final_score = values[si][sj];\n \n for (size_t k = 0; k < path.length(); k++) {\n char c = path[k];\n \n // Validate direction character\n if (c != 'U' && c != 'D' && c != 'L' && c != 'R') {\n return false;\n }\n \n int d = get_direction_index(c);\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n // Check bounds\n if (ni < 0 || ni >= n || nj < 0 || nj >= n) {\n return false;\n }\n \n int tile_id = tile_ids[ni][nj];\n \n // Check if tile was already visited\n if (visited_tiles.find(tile_id) != visited_tiles.end()) {\n return false;\n }\n \n // Add tile to visited and add all its squares to score\n visited_tiles.insert(tile_id);\n for (auto& square : tiles[tile_id].squares) {\n final_score += values[square.first][square.second];\n }\n \n // Update current position\n current_i = ni;\n current_j = nj;\n }\n \n return true;\n }\n \n // Calculate average value of unvisited tiles\n double calculate_average_unvisited_value(const unordered_set& visited) {\n int unvisited_count = 0;\n long long total_value = 0;\n \n for (int i = 0; i < (int)tiles.size(); i++) {\n if (visited.find(i) == visited.end()) {\n unvisited_count++;\n total_value += tiles[i].total_value;\n }\n }\n \n if (unvisited_count == 0) return 0;\n return (double)total_value / unvisited_count;\n }\n \n // Enhanced greedy with multiple sophisticated heuristics\n string enhanced_greedy() {\n string best_path = \"\";\n int best_score = values[si][sj];\n \n // Try different heuristics\n for (int heuristic_type = 0; heuristic_type < 5 && get_elapsed_time() < time_limit * 0.7; heuristic_type++) {\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n string path = \"\";\n \n random_device rd;\n mt19937 gen(rd());\n uniform_real_distribution real_dis(0.0, 1.0);\n \n while (get_elapsed_time() < time_limit * 0.6) {\n vector>> candidates;\n \n // Check all 4 directions\n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n \n if (visited.find(next_tile_id) == visited.end()) {\n int tile_value = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n tile_value += values[square.first][square.second];\n }\n \n double score = 0.0;\n \n // Different heuristics based on type\n switch(heuristic_type) {\n case 0: // Pure tile value\n score = tile_value;\n break;\n case 1: // Value density (value per square)\n score = (double)tile_value / tiles[next_tile_id].squares.size();\n break;\n case 2: { // Value with connectivity bonus\n int connectivity = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n for (int nd = 0; nd < 4; nd++) {\n int nni = square.first + dirs[nd].first;\n int nnj = square.second + dirs[nd].second;\n if (is_valid(nni, nnj) && visited.find(tile_ids[nni][nnj]) == visited.end()) {\n connectivity++;\n }\n }\n }\n score = tile_value + connectivity * 5;\n break;\n }\n case 3: { // Value with distance penalty (prefer central tiles)\n double center_i = 24.5, center_j = 24.5; // Center of 50x50 grid\n auto tile_center = tiles[next_tile_id].get_center();\n double dist_to_center = abs(tile_center.first - center_i) + abs(tile_center.second - center_j);\n score = tile_value - dist_to_center * 3;\n break;\n }\n case 4: { // Value with path length consideration\n int connectivity = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n for (int nd = 0; nd < 4; nd++) {\n int nni = square.first + dirs[nd].first;\n int nnj = square.second + dirs[nd].second;\n if (is_valid(nni, nnj) && visited.find(tile_ids[nni][nnj]) == visited.end()) {\n connectivity++;\n }\n }\n }\n // Prefer tiles with good connectivity when path is long\n double bonus = connectivity * (1.0 + path.length() * 0.1);\n score = tile_value + bonus;\n break;\n }\n }\n \n candidates.push_back({score, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) {\n break;\n }\n \n // Sort by score (descending)\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Select with some randomness (more randomness early in path)\n int selected_idx = 0;\n double randomness_factor = 0.1 + path.length() * 0.001; // Increase randomness with path length\n if (candidates.size() > 1 && real_dis(gen) < randomness_factor) {\n int max_idx = min(2, (int)candidates.size() - 1);\n uniform_int_distribution idx_dis(0, max_idx);\n selected_idx = idx_dis(gen);\n }\n \n int ni = candidates[selected_idx].second.first;\n int nj = candidates[selected_idx].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n path += dir_chars[dir];\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n // Validate and update best\n int path_score = 0;\n if (validate_path(path, path_score) && path_score > best_score) {\n best_score = path_score;\n best_path = path;\n }\n }\n \n return best_path;\n }\n \n // Beam search with better heuristics\n string enhanced_beam_search() {\n struct State {\n int i, j;\n int score;\n string path;\n unordered_set visited;\n double heuristic_value;\n \n State(int _i, int _j, int _score, string _path, unordered_set _visited) \n : i(_i), j(_j), score(_score), path(_path), visited(_visited) {\n heuristic_value = score;\n }\n \n bool operator<(const State& other) const {\n return heuristic_value < other.heuristic_value; // Max heap\n }\n };\n \n string best_path = \"\";\n int best_score = values[si][sj];\n \n // Try different beam search strategies\n for (int strategy = 0; strategy < 2 && get_elapsed_time() < time_limit * 0.9; strategy++) {\n vector beam_widths = strategy == 0 ? vector{3, 5} : vector{5, 8, 12};\n \n for (int bw : beam_widths) {\n if (get_elapsed_time() > time_limit * 0.85) break;\n \n priority_queue pq;\n \n // Start state\n unordered_set start_visited;\n start_visited.insert(tile_ids[si][sj]);\n pq.push(State(si, sj, values[si][sj], \"\", start_visited));\n \n int iterations = 0;\n int max_iterations = strategy == 0 ? 800 : 1200;\n \n while (!pq.empty() && iterations < max_iterations && get_elapsed_time() < time_limit * 0.85) {\n // Keep only top states\n vector current_states;\n while (!pq.empty() && current_states.size() < static_cast(bw)) {\n current_states.push_back(pq.top());\n pq.pop();\n }\n \n // Clear remaining states\n while (!pq.empty()) pq.pop();\n \n // Update best from current states\n for (auto& state : current_states) {\n if (state.score > best_score) {\n best_score = state.score;\n best_path = state.path;\n }\n }\n \n // Expand states\n for (auto& state : current_states) {\n vector> next_states;\n \n for (int d = 0; d < 4; d++) {\n int ni = state.i + dirs[d].first;\n int nj = state.j + dirs[d].second;\n \n if (is_valid(ni, nj)) {\n int tile_id = tile_ids[ni][nj];\n \n if (state.visited.find(tile_id) == state.visited.end()) {\n // Create new visited set\n unordered_set new_visited = state.visited;\n new_visited.insert(tile_id);\n \n // Calculate new score\n int additional_score = 0;\n for (auto& square : tiles[tile_id].squares) {\n additional_score += values[square.first][square.second];\n }\n int new_score = state.score + additional_score;\n \n // Create new state\n string new_path = state.path + dir_chars[d];\n State new_state(ni, nj, new_score, new_path, new_visited);\n \n // Calculate heuristic value based on strategy\n if (strategy == 0) {\n // Simple heuristic: current score + average of remaining tiles\n double avg_remaining = calculate_average_unvisited_value(new_visited);\n int remaining_tiles_estimate = min(10, (int)(tiles.size() - new_visited.size()));\n new_state.heuristic_value = new_score + avg_remaining * remaining_tiles_estimate;\n } else {\n // More sophisticated heuristic\n double avg_remaining = calculate_average_unvisited_value(new_visited);\n int remaining_tiles_estimate = min(15, (int)(tiles.size() - new_visited.size()));\n \n // Bonus for tiles with good connectivity\n int connectivity_bonus = 0;\n for (auto& square : tiles[tile_id].squares) {\n for (int nd = 0; nd < 4; nd++) {\n int nni = square.first + dirs[nd].first;\n int nnj = square.second + dirs[nd].second;\n if (is_valid(nni, nnj) && new_visited.find(tile_ids[nni][nnj]) == new_visited.end()) {\n connectivity_bonus++;\n }\n }\n }\n \n new_state.heuristic_value = new_score + avg_remaining * remaining_tiles_estimate + connectivity_bonus * 5;\n }\n \n next_states.push_back({new_state.heuristic_value, new_state});\n }\n }\n }\n \n // Sort by heuristic value\n sort(next_states.begin(), next_states.end(), greater>());\n \n // Add top states to pq\n int states_to_add = min(3, (int)next_states.size());\n for (int i = 0; i < states_to_add; i++) {\n pq.push(next_states[i].second);\n }\n }\n \n iterations++;\n }\n }\n }\n \n return best_path;\n }\n \n // Randomized greedy with restarts\n string randomized_greedy_with_restarts() {\n string best_path = \"\";\n int best_score = values[si][sj];\n \n int max_restarts = 20;\n if (get_elapsed_time() > time_limit * 0.5) {\n max_restarts = 5;\n }\n \n for (int restart = 0; restart < max_restarts && get_elapsed_time() < time_limit * 0.8; restart++) {\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n \n int current_i = si, current_j = sj;\n string path = \"\";\n \n random_device rd;\n mt19937 gen(rd());\n uniform_real_distribution real_dis(0.0, 1.0);\n \n while (get_elapsed_time() < time_limit * 0.75) {\n vector>> candidates;\n \n // Check all 4 directions\n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n \n if (is_valid(ni, nj)) {\n int next_tile_id = tile_ids[ni][nj];\n \n if (visited.find(next_tile_id) == visited.end()) {\n int tile_value = 0;\n for (auto& square : tiles[next_tile_id].squares) {\n tile_value += values[square.first][square.second];\n }\n candidates.push_back({tile_value, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) {\n break;\n }\n \n // Sort by value\n sort(candidates.begin(), candidates.end(), greater>>());\n \n // Select with randomness based on restart number and path length\n int selected_idx = 0;\n double exploration_factor = (double)restart / max_restarts; // More exploration in later restarts\n double path_factor = min(0.5, path.length() * 0.01); // More randomness for longer paths\n \n if (candidates.size() > 1 && real_dis(gen) < 0.2 + exploration_factor * 0.3 + path_factor) {\n int max_idx = min(2, (int)candidates.size() - 1);\n uniform_int_distribution idx_dis(0, max_idx);\n selected_idx = idx_dis(gen);\n }\n \n int ni = candidates[selected_idx].second.first;\n int nj = candidates[selected_idx].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n path += dir_chars[dir];\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n // Validate and update best\n int path_score = 0;\n if (validate_path(path, path_score) && path_score > best_score) {\n best_score = path_score;\n best_path = path;\n }\n }\n \n return best_path;\n }\n\npublic:\n void solve() {\n start_time = high_resolution_clock::now();\n \n // Read input\n cin >> si >> sj;\n \n tile_ids = vector>(n, vector(n));\n values = vector>(n, vector(n));\n \n // Read tile IDs\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> tile_ids[i][j];\n }\n }\n \n // Read values\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> values[i][j];\n }\n }\n \n // Build tile data structure\n unordered_map tile_map;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int id = tile_ids[i][j];\n if (tile_map.find(id) == tile_map.end()) {\n tile_map[id] = Tile{{}, 0, id};\n }\n tile_map[id].squares.push_back({i, j});\n tile_map[id].total_value += values[i][j];\n }\n }\n \n // Convert to vector\n for (auto& kv : tile_map) {\n tiles.push_back(kv.second);\n }\n \n string result = \"\";\n int best_score = values[si][sj];\n \n // Strategy 1: Enhanced greedy with multiple heuristics\n if (get_elapsed_time() < time_limit * 0.3) {\n string greedy_result = enhanced_greedy();\n int score = 0;\n if (validate_path(greedy_result, score) && score > best_score) {\n best_score = score;\n result = greedy_result;\n }\n }\n \n // Strategy 2: Randomized greedy with restarts\n if (get_elapsed_time() < time_limit * 0.5) {\n string random_result = randomized_greedy_with_restarts();\n int score = 0;\n if (validate_path(random_result, score) && score > best_score) {\n best_score = score;\n result = random_result;\n }\n }\n \n // Strategy 3: Enhanced beam search\n if (get_elapsed_time() < time_limit * 0.9) {\n string beam_result = enhanced_beam_search();\n int score = 0;\n if (validate_path(beam_result, score) && score > best_score) {\n best_score = score;\n result = beam_result;\n }\n }\n \n // Final validation\n int final_score = 0;\n if (!validate_path(result, final_score)) {\n // Fallback to simple greedy\n unordered_set visited;\n visited.insert(tile_ids[si][sj]);\n int current_i = si, current_j = sj;\n string fallback = \"\";\n \n while (get_elapsed_time() < time_limit * 0.98) {\n vector>> candidates;\n \n for (int d = 0; d < 4; d++) {\n int ni = current_i + dirs[d].first;\n int nj = current_j + dirs[d].second;\n if (is_valid(ni, nj)) {\n int tile_id = tile_ids[ni][nj];\n if (visited.find(tile_id) == visited.end()) {\n int tile_value = 0;\n for (auto& square : tiles[tile_id].squares) {\n tile_value += values[square.first][square.second];\n }\n candidates.push_back({tile_value, {ni, nj}});\n }\n }\n }\n \n if (candidates.empty()) break;\n \n sort(candidates.begin(), candidates.end(), greater>>());\n \n int ni = candidates[0].second.first;\n int nj = candidates[0].second.second;\n int dir = get_direction(current_i, current_j, ni, nj);\n \n fallback += dir_chars[dir];\n visited.insert(tile_ids[ni][nj]);\n current_i = ni;\n current_j = nj;\n }\n \n if (validate_path(fallback, final_score)) {\n result = fallback;\n } else {\n result = \"\";\n }\n }\n \n // Output result\n cout << result << endl;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n Solution solver;\n solver.solve();\n return 0;\n}","ahc003":"#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 GRID_SIZE = 30;\nconst long long INF = 1e15;\n\n// Direction arrays for Dijkstra\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Estimated edge weights\nvector> h_est(GRID_SIZE, vector(GRID_SIZE - 1, 5000.0)); // horizontal edges\nvector> v_est(GRID_SIZE - 1, vector(GRID_SIZE, 5000.0)); // vertical edges\n\n// Uncertainty for each edge\nvector> h_uncertainty(GRID_SIZE, vector(GRID_SIZE - 1, 2000.0));\nvector> v_uncertainty(GRID_SIZE - 1, vector(GRID_SIZE, 2000.0));\n\n// Count of observations for each edge\nvector> h_count(GRID_SIZE, vector(GRID_SIZE - 1, 0));\nvector> v_count(GRID_SIZE - 1, vector(GRID_SIZE, 0));\n\n// Global bounds for edge weights\ndouble global_min_bound = 800.0;\ndouble global_max_bound = 9200.0;\n\n// Track performance metrics\ndeque recent_results;\nint low_score_streak = 0;\ndouble recent_performance_factor = 1.0;\nint very_low_score_count = 0;\n\n// Track performance by grid region (divide grid into 3x3 regions)\nvector> region_performance(3, vector(3, 0.0));\nvector> region_counts(3, vector(3, 0));\nvector> region_low_scores(3, vector(3, 0));\n\n// Track consecutive low scores by region\nvector> region_consecutive_low(3, vector(3, 0));\n\n// For Dijkstra\nstruct Node {\n int x, y;\n double cost;\n string path;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n\n// Forward declarations\nstring dijkstra(int sx, int sy, int tx, int ty, int query_num);\nstring getBlendedPath(int sx, int sy, int tx, int ty, int query_num);\nstring getManhattanPath(int sx, int sy, int tx, int ty);\nstring getAlternativeManhattanPath(int sx, int sy, int tx, int ty);\n\n// Check if coordinates are valid\nbool isValid(int x, int y) {\n return x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE;\n}\n\n// Simple Manhattan path for early queries or fallback\nstring getManhattanPath(int sx, int sy, int tx, int ty) {\n string path = \"\";\n int cx = sx, cy = sy;\n \n // Move in direction of larger difference first\n int v_diff = abs(tx - sx);\n int h_diff = abs(ty - sy);\n \n if (v_diff >= h_diff) {\n // Vertical first\n while (cx < tx) {\n path += 'D';\n cx++;\n }\n while (cx > tx) {\n path += 'U';\n cx--;\n }\n while (cy < ty) {\n path += 'R';\n cy++;\n }\n while (cy > ty) {\n path += 'L';\n cy--;\n }\n } else {\n // Horizontal first\n while (cy < ty) {\n path += 'R';\n cy++;\n }\n while (cy > ty) {\n path += 'L';\n cy--;\n }\n while (cx < tx) {\n path += 'D';\n cx++;\n }\n while (cx > tx) {\n path += 'U';\n cx--;\n }\n }\n \n return path;\n}\n\n// Alternative Manhattan path (different movement order)\nstring getAlternativeManhattanPath(int sx, int sy, int tx, int ty) {\n string path = \"\";\n int cx = sx, cy = sy;\n \n // Always horizontal first\n while (cy < ty) {\n path += 'R';\n cy++;\n }\n while (cy > ty) {\n path += 'L';\n cy--;\n }\n while (cx < tx) {\n path += 'D';\n cx++;\n }\n while (cx > tx) {\n path += 'U';\n cx--;\n }\n \n return path;\n}\n\n// Calculate Manhattan distance\nint manhattanDistance(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Try multiple paths and return the one with lowest estimated cost\n// Avoids recursion by using simpler path generation methods\nstring tryMultiplePaths(int sx, int sy, int tx, int ty, int query_num) {\n // Generate a few different paths using non-recursive methods\n vector candidate_paths;\n \n // Alternative 1: Standard Manhattan path\n string path1 = getManhattanPath(sx, sy, tx, ty);\n candidate_paths.push_back(path1);\n \n // Alternative 2: Alternative Manhattan path\n string path2 = getAlternativeManhattanPath(sx, sy, tx, ty);\n candidate_paths.push_back(path2);\n \n // Alternative 3: Blended path (without calling dijkstra)\n string path3 = getBlendedPath(sx, sy, tx, ty, query_num);\n candidate_paths.push_back(path3);\n \n // Evaluate estimated cost of each path\n vector> path_costs;\n for (string path : candidate_paths) {\n double cost = 0.0;\n int x = sx, y = sy;\n bool valid = true;\n \n // Validate path and calculate cost\n for (char dir : path) {\n int nx = x, ny = y;\n if (dir == 'U') nx--;\n else if (dir == 'D') nx++;\n else if (dir == 'L') ny--;\n else if (dir == 'R') ny++;\n else {\n valid = false;\n break;\n }\n \n // Check bounds\n if (nx < 0 || nx >= GRID_SIZE || ny < 0 || ny >= GRID_SIZE) {\n valid = false;\n break;\n }\n \n // Calculate cost\n if (dir == 'U' && x > 0) {\n cost += v_est[x-1][y];\n x = nx;\n y = ny;\n } else if (dir == 'D' && x < GRID_SIZE-1) {\n cost += v_est[x][y];\n x = nx;\n y = ny;\n } else if (dir == 'L' && y > 0) {\n cost += h_est[x][y-1];\n x = nx;\n y = ny;\n } else if (dir == 'R' && y < GRID_SIZE-1) {\n cost += h_est[x][y];\n x = nx;\n y = ny;\n } else {\n valid = false;\n break;\n }\n }\n \n // Check if path ends at target\n if (valid && x == tx && y == ty) {\n path_costs.push_back({cost, path});\n }\n }\n \n // Return path with lowest estimated cost\n if (!path_costs.empty()) {\n sort(path_costs.begin(), path_costs.end());\n return path_costs[0].second;\n }\n \n // Fallback to standard Manhattan path\n return getManhattanPath(sx, sy, tx, ty);\n}\n\n// Weighted blend path for transition phase\nstring getBlendedPath(int sx, int sy, int tx, int ty, int query_num) {\n if (query_num < 2) {\n // Alternate between two Manhattan strategies based on query number\n if (query_num % 2 == 0) {\n return getManhattanPath(sx, sy, tx, ty);\n } else {\n return getAlternativeManhattanPath(sx, sy, tx, ty);\n }\n }\n \n // Calculate blend factor (0.0 = pure Manhattan, 1.0 = pure learned)\n double blend_factor = min(1.0, (query_num - 2) / 8.0);\n \n // Use Dijkstra with modified costs based on blend factor\n priority_queue, greater> pq;\n vector> dist(GRID_SIZE, vector(GRID_SIZE, INF));\n vector> visited(GRID_SIZE, vector(GRID_SIZE, false));\n \n pq.push({sx, sy, 0.0, \"\"});\n dist[sx][sy] = 0.0;\n \n while (!pq.empty()) {\n Node curr = pq.top();\n pq.pop();\n \n int x = curr.x;\n int y = curr.y;\n double cost = curr.cost;\n string currPath = curr.path;\n \n if (visited[x][y]) continue;\n visited[x][y] = true;\n \n // If we reached the target\n if (x == tx && y == ty) {\n return currPath;\n }\n \n // Try all four directions\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n \n if (!isValid(nx, ny)) continue;\n \n double edgeCost = 0.0;\n // Calculate edge cost based on direction\n if (i == 0 && x > 0) { // Up\n edgeCost = v_est[x-1][y] * blend_factor + 5000.0 * (1.0 - blend_factor);\n } else if (i == 1 && x < GRID_SIZE-1) { // Down\n edgeCost = v_est[x][y] * blend_factor + 5000.0 * (1.0 - blend_factor);\n } else if (i == 2 && y > 0) { // Left\n edgeCost = h_est[x][y-1] * blend_factor + 5000.0 * (1.0 - blend_factor);\n } else if (i == 3 && y < GRID_SIZE-1) { // Right\n edgeCost = h_est[x][y] * blend_factor + 5000.0 * (1.0 - blend_factor);\n } else {\n continue; // Invalid move\n }\n \n // Apply global bounds\n edgeCost = max(global_min_bound, min(global_max_bound, edgeCost));\n \n // Add exploration bonus with intelligent boost\n double exploration_bonus = 0.0;\n if (query_num < 700) {\n double base_factor = 0.025 * (1.0 - query_num / 700.0);\n // Boost exploration if we've had recent low scores\n double performance_boost = 1.0 + min(0.7, low_score_streak * 0.15);\n \n // Region-based boost for historically poor performing regions\n int region_x = x / 10;\n int region_y = y / 10;\n region_x = min(2, max(0, region_x));\n region_y = min(2, max(0, region_y));\n double region_boost = 1.0;\n if (region_counts[region_x][region_y] > 3) {\n double avg_performance = region_performance[region_x][region_y] / region_counts[region_x][region_y];\n if (avg_performance < 840000) {\n region_boost = 1.0 + 0.4 * (840000 - avg_performance) / 840000;\n }\n }\n \n // Extra penalty for regions with many consecutive low scores\n if (region_consecutive_low[region_x][region_y] > 1) {\n region_boost *= (1.0 + 0.2 * region_consecutive_low[region_x][region_y]);\n }\n \n if (i == 0 && x > 0) {\n exploration_bonus = -base_factor * performance_boost * region_boost * v_uncertainty[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) {\n exploration_bonus = -base_factor * performance_boost * region_boost * v_uncertainty[x][y];\n } else if (i == 2 && y > 0) {\n exploration_bonus = -base_factor * performance_boost * region_boost * h_uncertainty[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) {\n exploration_bonus = -base_factor * performance_boost * region_boost * h_uncertainty[x][y];\n }\n }\n \n // Add noise for tie-breaking\n double noise = 0.0;\n if (query_num < 200) {\n noise = (rand() % 300) / 100000.0;\n // Add extra noise if we've had recent low scores\n if (low_score_streak > 0) {\n noise *= (1.0 + min(1.3, low_score_streak * 0.3));\n }\n }\n \n if (dist[nx][ny] > cost + edgeCost + exploration_bonus + noise) {\n dist[nx][ny] = cost + edgeCost + exploration_bonus + noise;\n pq.push({nx, ny, cost + edgeCost + exploration_bonus + noise, currPath + dirChar[i]});\n }\n }\n }\n \n // Fallback with alternation\n if (query_num % 2 == 0) {\n return getManhattanPath(sx, sy, tx, ty);\n } else {\n return getAlternativeManhattanPath(sx, sy, tx, ty);\n }\n}\n\n// Dijkstra's algorithm to find shortest path based on current estimates\nstring dijkstra(int sx, int sy, int tx, int ty, int query_num) {\n // For transition phase, use blended approach\n if (query_num < 10) {\n return getBlendedPath(sx, sy, tx, ty, query_num);\n }\n \n // If we're in a recovery mode after very low scores, try multiple paths\n // But avoid recursion by not calling dijkstra from tryMultiplePaths\n if (very_low_score_count > 3 && query_num > 50) {\n return tryMultiplePaths(sx, sy, tx, ty, query_num);\n }\n \n // Priority queue for Dijkstra\n priority_queue, greater> pq;\n vector> dist(GRID_SIZE, vector(GRID_SIZE, INF));\n vector> visited(GRID_SIZE, vector(GRID_SIZE, false));\n \n pq.push({sx, sy, 0.0, \"\"});\n dist[sx][sy] = 0.0;\n \n while (!pq.empty()) {\n Node curr = pq.top();\n pq.pop();\n \n int x = curr.x;\n int y = curr.y;\n double cost = curr.cost;\n string currPath = curr.path;\n \n if (visited[x][y]) continue;\n visited[x][y] = true;\n \n // If we reached the target\n if (x == tx && y == ty) {\n return currPath;\n }\n \n // Try all four directions\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n \n if (!isValid(nx, ny)) continue;\n \n double edgeCost = 0.0;\n // Calculate edge cost based on direction\n if (i == 0 && x > 0) { // Up\n edgeCost = v_est[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) { // Down\n edgeCost = v_est[x][y];\n } else if (i == 2 && y > 0) { // Left\n edgeCost = h_est[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) { // Right\n edgeCost = h_est[x][y];\n } else {\n continue; // Invalid move\n }\n \n // Apply bounds with uncertainty consideration\n double local_min_bound = global_min_bound;\n double local_max_bound = global_max_bound;\n \n if (i == 0 && x > 0) {\n if (v_uncertainty[x-1][y] > 1000.0) {\n local_min_bound = max(300.0, global_min_bound - 800.0);\n local_max_bound = min(9800.0, global_max_bound + 800.0);\n }\n } else if (i == 1 && x < GRID_SIZE-1) {\n if (v_uncertainty[x][y] > 1000.0) {\n local_min_bound = max(300.0, global_min_bound - 800.0);\n local_max_bound = min(9800.0, global_max_bound + 800.0);\n }\n } else if (i == 2 && y > 0) {\n if (h_uncertainty[x][y-1] > 1000.0) {\n local_min_bound = max(300.0, global_min_bound - 800.0);\n local_max_bound = min(9800.0, global_max_bound + 800.0);\n }\n } else if (i == 3 && y < GRID_SIZE-1) {\n if (h_uncertainty[x][y] > 1000.0) {\n local_min_bound = max(300.0, global_min_bound - 800.0);\n local_max_bound = min(9800.0, global_max_bound + 800.0);\n }\n }\n \n edgeCost = max(local_min_bound, min(local_max_bound, edgeCost));\n \n // Add intelligent exploration bonus\n double exploration_bonus = 0.0;\n if (query_num < 700) {\n double base_factor = 0.025 * (1.0 - query_num / 700.0);\n double performance_boost = 1.0 + min(0.7, low_score_streak * 0.15);\n \n // Region-based boost\n int region_x = nx / 10;\n int region_y = ny / 10;\n region_x = min(2, max(0, region_x));\n region_y = min(2, max(0, region_y));\n double region_boost = 1.0;\n if (region_counts[region_x][region_y] > 3) {\n double avg_performance = region_performance[region_x][region_y] / region_counts[region_x][region_y];\n if (avg_performance < 840000) {\n region_boost = 1.0 + 0.4 * (840000 - avg_performance) / 840000;\n }\n }\n \n // Extra penalty for regions with consecutive low scores\n if (region_consecutive_low[region_x][region_y] > 1) {\n region_boost *= (1.0 + 0.2 * region_consecutive_low[region_x][region_y]);\n }\n \n // Extra boost for edges far from start/end (encourage exploration of middle regions)\n int mid_x = (sx + tx) / 2;\n int mid_y = (sy + ty) / 2;\n int dist_to_mid = abs(nx - mid_x) + abs(ny - mid_y);\n int max_dist = max(1, manhattanDistance(sx, sy, tx, ty) / 2);\n double mid_boost = 1.0 + 0.5 * exp(-dist_to_mid / max_dist);\n \n if (i == 0 && x > 0) {\n exploration_bonus = -base_factor * performance_boost * region_boost * mid_boost * v_uncertainty[x-1][y];\n } else if (i == 1 && x < GRID_SIZE-1) {\n exploration_bonus = -base_factor * performance_boost * region_boost * mid_boost * v_uncertainty[x][y];\n } else if (i == 2 && y > 0) {\n exploration_bonus = -base_factor * performance_boost * region_boost * mid_boost * h_uncertainty[x][y-1];\n } else if (i == 3 && y < GRID_SIZE-1) {\n exploration_bonus = -base_factor * performance_boost * region_boost * mid_boost * h_uncertainty[x][y];\n }\n }\n \n // Add noise for tie-breaking\n double noise = 0.0;\n if (query_num < 200) {\n noise = (rand() % 300) / 100000.0;\n if (low_score_streak > 0) {\n noise *= (1.0 + min(1.3, low_score_streak * 0.3));\n }\n }\n \n if (dist[nx][ny] > cost + edgeCost + exploration_bonus + noise) {\n dist[nx][ny] = cost + edgeCost + exploration_bonus + noise;\n pq.push({nx, ny, cost + edgeCost + exploration_bonus + noise, currPath + dirChar[i]});\n }\n }\n }\n \n // Fallback to blended path\n return getBlendedPath(sx, sy, tx, ty, 10);\n}\n\n// Update edge weight estimates based on the feedback\nvoid updateEstimates(const string& path, int sx, int sy, int tx, int ty, int actual_cost, int query_num) {\n // Calculate the expected cost based on current estimates\n int x = sx, y = sy;\n double expected_cost = 0.0;\n vector> edge_coords;\n vector edge_types;\n vector edge_weights;\n vector edge_uncertainties;\n \n for (char dir : path) {\n if (dir == 'U' && x > 0) {\n expected_cost += v_est[x-1][y];\n edge_coords.push_back({x-1, y});\n edge_types.push_back(1); // vertical\n edge_weights.push_back(v_est[x-1][y]);\n edge_uncertainties.push_back(v_uncertainty[x-1][y]);\n x--;\n } else if (dir == 'D' && x < GRID_SIZE-1) {\n expected_cost += v_est[x][y];\n edge_coords.push_back({x, y});\n edge_types.push_back(1); // vertical\n edge_weights.push_back(v_est[x][y]);\n edge_uncertainties.push_back(v_uncertainty[x][y]);\n x++;\n } else if (dir == 'L' && y > 0) {\n expected_cost += h_est[x][y-1];\n edge_coords.push_back({x, y-1});\n edge_types.push_back(0); // horizontal\n edge_weights.push_back(h_est[x][y-1]);\n edge_uncertainties.push_back(h_uncertainty[x][y-1]);\n y--;\n } else if (dir == 'R' && y < GRID_SIZE-1) {\n expected_cost += h_est[x][y];\n edge_coords.push_back({x, y});\n edge_types.push_back(0); // horizontal\n edge_weights.push_back(h_est[x][y]);\n edge_uncertainties.push_back(h_uncertainty[x][y]);\n y++;\n }\n }\n \n // Calculate total error\n double total_error = actual_cost - expected_cost;\n int path_length = edge_coords.size();\n \n if (path_length == 0) return;\n \n // Track performance for adaptation\n recent_results.push_back(actual_cost);\n if (recent_results.size() > 15) {\n recent_results.pop_front();\n }\n \n // Update region performance tracking\n int start_region_x = sx / 10;\n int start_region_y = sy / 10;\n int end_region_x = (sx + (tx - sx) / 2) / 10; // Midpoint region\n int end_region_y = (sy + (ty - sy) / 2) / 10;\n \n start_region_x = min(2, max(0, start_region_x));\n start_region_y = min(2, max(0, start_region_y));\n end_region_x = min(2, max(0, end_region_x));\n end_region_y = min(2, max(0, end_region_y));\n \n region_performance[start_region_x][start_region_y] += actual_cost;\n region_counts[start_region_x][start_region_y]++;\n region_performance[end_region_x][end_region_y] += actual_cost;\n region_counts[end_region_x][end_region_y]++;\n \n // Track low scores by region\n bool is_low_score = actual_cost < 820000;\n if (is_low_score) {\n region_low_scores[start_region_x][start_region_y]++;\n region_low_scores[end_region_x][end_region_y]++;\n \n // Update consecutive low scores\n region_consecutive_low[start_region_x][start_region_y]++;\n region_consecutive_low[end_region_x][end_region_y]++;\n } else {\n // Reset consecutive low scores for these regions\n region_consecutive_low[start_region_x][start_region_y] = 0;\n region_consecutive_low[end_region_x][end_region_y] = 0;\n }\n \n // Update low score streak and very low score count\n if (actual_cost < 790000 && query_num > 50) { // Track very low scores\n very_low_score_count++;\n }\n \n if (actual_cost < 800000 && query_num > 50) {\n low_score_streak = min(15, low_score_streak + 1);\n recent_performance_factor = 0.7;\n } else if (actual_cost > 910000) {\n low_score_streak = max(0, low_score_streak - 2);\n recent_performance_factor = min(1.25, recent_performance_factor + 0.1);\n } else {\n low_score_streak = max(0, low_score_streak - 1);\n recent_performance_factor = min(1.0, recent_performance_factor + 0.05);\n }\n \n // Intelligent learning rate based on performance and error\n double relative_error = abs(total_error) / max(1.0, expected_cost);\n double base_learning_rate = 0.15;\n \n // More responsive error adaptation\n double error_factor = 1.0 + min(0.8, relative_error * 1.1);\n \n // Performance-based adjustment\n double performance_factor = 1.0;\n if (low_score_streak > 0) {\n performance_factor = 1.0 + min(0.6, low_score_streak * 0.1);\n } else {\n performance_factor = recent_performance_factor;\n }\n \n // Adjust based on query number\n double time_factor = 1.0;\n if (query_num < 50) {\n time_factor = 1.5;\n } else if (query_num < 150) {\n time_factor = 1.3;\n } else if (query_num < 350) {\n time_factor = 1.2;\n } else if (query_num < 600) {\n time_factor = 1.0;\n } else if (query_num < 800) {\n time_factor = 0.8;\n } else {\n time_factor = 0.6;\n }\n \n double learning_rate = base_learning_rate * error_factor * performance_factor * time_factor;\n learning_rate = max(0.03, min(0.55, learning_rate));\n \n // Update global bounds with more flexibility\n double observed_avg = actual_cost * 1.0 / path_length;\n global_min_bound = min(global_min_bound, observed_avg * 0.35);\n global_max_bound = max(global_max_bound, observed_avg * 1.65);\n global_min_bound = max(250.0, global_min_bound);\n global_max_bound = min(9900.0, global_max_bound);\n \n // Intelligent error attribution based on uncertainty and performance\n for (int i = 0; i < path_length; i++) {\n int coord1 = edge_coords[i].first;\n int coord2 = edge_coords[i].second;\n double weight = edge_weights[i];\n double uncertainty = edge_uncertainties[i];\n \n // Make equal distribution component proportional to uncertainty and performance\n double uncertainty_factor = min(1.0, uncertainty / 2000.0);\n double performance_factor_edge = 1.0;\n if (low_score_streak > 0) {\n performance_factor_edge = 1.3;\n }\n \n double proportional_weight = 0.6 + 0.2 * (1.0 - uncertainty_factor) * (2.0 - performance_factor_edge);\n double equal_weight = 0.4 - 0.2 * (1.0 - uncertainty_factor) * (2.0 - performance_factor_edge);\n \n // Ensure weights are in valid range\n proportional_weight = max(0.45, min(0.85, proportional_weight));\n equal_weight = 1.0 - proportional_weight;\n \n double proportional_contribution = total_error * (weight / max(1.0, expected_cost)) * proportional_weight;\n double equal_contribution = (total_error / path_length) * equal_weight;\n double error_contribution = proportional_contribution + equal_contribution;\n \n if (edge_types[i] == 0) { // horizontal edge\n double old_value = h_est[coord1][coord2];\n h_est[coord1][coord2] += learning_rate * error_contribution;\n \n // Apply global bounds\n h_est[coord1][coord2] = max(global_min_bound, min(global_max_bound, h_est[coord1][coord2]));\n \n // Update uncertainty with performance-aware reduction\n double update_ratio = abs(learning_rate * error_contribution) / max(1000.0, abs(old_value));\n double obs_factor = exp(-h_count[coord1][coord2] / 80.0);\n double performance_penalty = 1.0;\n if (low_score_streak > 0) {\n performance_penalty = 0.8;\n }\n double uncertainty_reduction = 0.92 + 0.08 * min(1.0, update_ratio * 2.5) * (0.4 + 0.6 * obs_factor) * performance_penalty;\n h_uncertainty[coord1][coord2] *= uncertainty_reduction;\n h_uncertainty[coord1][coord2] = max(15.0, h_uncertainty[coord1][coord2]);\n \n h_count[coord1][coord2]++;\n } else { // vertical edge\n double old_value = v_est[coord1][coord2];\n v_est[coord1][coord2] += learning_rate * error_contribution;\n \n // Apply global bounds\n v_est[coord1][coord2] = max(global_min_bound, min(global_max_bound, v_est[coord1][coord2]));\n \n // Update uncertainty\n double update_ratio = abs(learning_rate * error_contribution) / max(1000.0, abs(old_value));\n double obs_factor = exp(-v_count[coord1][coord2] / 80.0);\n double performance_penalty = 1.0;\n if (low_score_streak > 0) {\n performance_penalty = 0.8;\n }\n double uncertainty_reduction = 0.92 + 0.08 * min(1.0, update_ratio * 2.5) * (0.4 + 0.6 * obs_factor) * performance_penalty;\n v_uncertainty[coord1][coord2] *= uncertainty_reduction;\n v_uncertainty[coord1][coord2] = max(15.0, v_uncertainty[coord1][coord2]);\n \n v_count[coord1][coord2]++;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Seed random for exploration noise\n srand(12345);\n \n for (int k = 0; k < 1000; k++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n \n // Find path using current estimates\n string path = dijkstra(si, sj, ti, tj, k);\n \n // Validate path before output (additional safety check)\n int x = si, y = sj;\n bool valid = true;\n for (char dir : path) {\n if (dir == 'U') x--;\n else if (dir == 'D') x++;\n else if (dir == 'L') y--;\n else if (dir == 'R') y++;\n else {\n valid = false;\n break;\n }\n \n if (x < 0 || x >= GRID_SIZE || y < 0 || y >= GRID_SIZE) {\n valid = false;\n break;\n }\n }\n \n // Ensure we reached the target\n if (valid && (x != ti || y != tj)) {\n valid = false;\n }\n \n // If path is invalid, use fallback\n if (!valid) {\n path = getManhattanPath(si, sj, ti, tj);\n }\n \n // Output path\n cout << path << endl;\n cout.flush();\n \n // Read the result\n int result;\n cin >> result;\n \n // Update estimates based on feedback\n updateEstimates(path, si, sj, ti, tj, result, k);\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nconst char CHARS[8] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};\n\n// Helper function to validate a character\nbool isValidChar(char c) {\n if (c == '.') return true;\n for (char valid : CHARS) {\n if (c == valid) return true;\n }\n return false;\n}\n\n// Helper function to sanitize a character\nchar sanitizeChar(char c) {\n if (isValidChar(c)) return c;\n // Return most common fallback\n return 'A';\n}\n\nclass MatrixSolver {\nprivate:\n int M;\n vector strings;\n vector matrix;\n vector matched;\n mt19937 rng;\n \npublic:\n MatrixSolver(int m, const vector& s) : M(m), strings(s), rng(random_device{}()) {\n // Initialize matrix with valid characters\n matrix.resize(N, string(N, 'A')); // Start with 'A' instead of '.' for safety\n matched.resize(M, false);\n }\n \n // Check if string s matches at position (i,j) horizontally\n bool matchesHorizontal(const string& s, int i, int j) const {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n \n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n \n // Ensure we have valid characters\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : 'A';\n if (cell != s[p] && cell != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if string s matches at position (i,j) vertically\n bool matchesVertical(const string& s, int i, int j) const {\n if (i < 0 || i >= N || j < 0 || j >= N) return false;\n \n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n \n // Ensure we have valid characters\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : 'A';\n if (cell != s[p] && cell != '.') {\n return false;\n }\n }\n return true;\n }\n \n // Check if a string matches anywhere in the matrix\n bool matches(const string& s) const {\n if (s.empty()) return true;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matchesHorizontal(s, i, j) || matchesVertical(s, i, j)) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Count how many strings are matched\n int countMatches() {\n int count = 0;\n for (int i = 0; i < M; i++) {\n if (i < static_cast(strings.size()) && !strings[i].empty() && matches(strings[i])) {\n matched[i] = true;\n count++;\n } else {\n matched[i] = false;\n }\n }\n return count;\n }\n \n // Get score based on problem definition\n long long getScore(int c, int d) {\n if (c < M) {\n return static_cast(round(100000000.0 * static_cast(c) / static_cast(M)));\n } else {\n double denominator = 2.0 * N * N - static_cast(d);\n if (denominator <= 0) denominator = 1.0;\n return static_cast(round(100000000.0 * 2.0 * N * N / denominator));\n }\n }\n \n // Count number of '.' in matrix\n int countDots() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (matrix[i][j] == '.') {\n count++;\n }\n }\n }\n return count;\n }\n \n // Initialize matrix based on string frequency\n void initializeByFrequency() {\n // Count character frequencies\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n // Fill matrix with most frequent character\n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = mostFreqChar;\n }\n }\n }\n \n // Initialize by trying to place longer strings first\n void initializeByStringPlacement() {\n // Start with all dots for maximum flexibility\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = '.';\n }\n }\n \n // Sort strings by length (descending) to place longer ones first\n vector> stringLengths; // {length, index}\n for (int i = 0; i < M; i++) {\n stringLengths.push_back({static_cast(strings[i].size()), i});\n }\n sort(stringLengths.rbegin(), stringLengths.rend());\n \n // Try to place each string\n for (int idx = 0; idx < min(100, static_cast(stringLengths.size())); idx++) {\n int strIdx = stringLengths[idx].second;\n const string& s = strings[strIdx];\n \n if (s.empty()) continue;\n \n // Generate random positions to try\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Try horizontal placement\n bool placed = false;\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlace = false;\n break;\n }\n }\n \n if (canPlace) {\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n matrix[i][col] = s[p];\n }\n placed = true;\n break;\n }\n }\n \n if (!placed) {\n // Try vertical placement\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlace = false;\n break;\n }\n }\n \n if (canPlace) {\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n matrix[row][j] = s[p];\n }\n placed = true;\n break;\n }\n }\n }\n }\n }\n \n // Try to improve matrix by changing one cell\n bool improve() {\n int currentMatches = countMatches();\n int currentDots = countDots();\n long long currentScore = getScore(currentMatches, currentDots);\n \n bool improved = false;\n \n // Create shuffled list of positions\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Try changing each cell\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n if (i < 0 || i >= N || j < 0 || j >= N) continue;\n \n char original = isValidChar(matrix[i][j]) ? matrix[i][j] : 'A';\n \n // Create list of characters to try\n vector tryChars;\n for (char c : CHARS) {\n if (c != original) {\n tryChars.push_back(c);\n }\n }\n tryChars.push_back('.'); // Try empty\n // Don't add original to avoid no-ops\n \n // Shuffle for randomness\n shuffle(tryChars.begin(), tryChars.end(), rng);\n \n for (char c : tryChars) {\n matrix[i][j] = c;\n int newMatches = countMatches();\n int newDots = countDots();\n long long newScore = getScore(newMatches, newDots);\n \n if (newScore > currentScore) { // Only accept improvements\n currentScore = newScore;\n currentMatches = newMatches;\n currentDots = newDots;\n improved = true;\n // Keep this change\n } else {\n // Revert if not better\n matrix[i][j] = original;\n }\n }\n }\n \n return improved;\n }\n \n // More aggressive approach to fix unmatched strings\n void fixUnmatchedAggressive() {\n vector unmatchedIndices;\n for (int i = 0; i < M; i++) {\n if (!matched[i]) {\n unmatchedIndices.push_back(i);\n }\n }\n \n if (unmatchedIndices.empty()) return;\n \n // Shuffle unmatched indices\n shuffle(unmatchedIndices.begin(), unmatchedIndices.end(), rng);\n \n // Try to fix up to 30 unmatched strings\n int limit = min(30, static_cast(unmatchedIndices.size()));\n for (int idx = 0; idx < limit; idx++) {\n int strIdx = unmatchedIndices[idx];\n if (strIdx < 0 || strIdx >= M) continue;\n const string& s = strings[strIdx];\n \n if (s.empty()) continue;\n \n // Generate all possible positions\n vector> positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.push_back({i, j});\n }\n }\n shuffle(positions.begin(), positions.end(), rng);\n \n // Score each position for horizontal placement\n vector>> horizontalScores; // {score, {i, j}}\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n int conflicts = 0;\n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : '.';\n if (cell != '.' && cell != s[p]) {\n conflicts++;\n canPlace = false;\n }\n }\n \n if (canPlace || conflicts <= 1) { // Allow up to 1 conflict\n horizontalScores.push_back({conflicts, pos});\n }\n }\n \n // Score each position for vertical placement\n vector>> verticalScores; // {score, {i, j}}\n for (const auto& pos : positions) {\n int i = pos.first;\n int j = pos.second;\n \n int conflicts = 0;\n bool canPlace = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : '.';\n if (cell != '.' && cell != s[p]) {\n conflicts++;\n canPlace = false;\n }\n }\n \n if (canPlace || conflicts <= 1) { // Allow up to 1 conflict\n verticalScores.push_back({conflicts, pos});\n }\n }\n \n // Sort by score (lower conflicts is better)\n sort(horizontalScores.begin(), horizontalScores.end());\n sort(verticalScores.begin(), verticalScores.end());\n \n // Try to place with minimum conflicts\n bool placed = false;\n \n // Try horizontal first\n if (!horizontalScores.empty() && horizontalScores[0].first <= 1) {\n int i = horizontalScores[0].second.first;\n int j = horizontalScores[0].second.second;\n \n // Place the string (overwriting conflicting cells)\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n matrix[i][col] = s[p];\n }\n placed = true;\n }\n \n // Try vertical if horizontal failed\n if (!placed && !verticalScores.empty() && verticalScores[0].first <= 1) {\n int i = verticalScores[0].second.first;\n int j = verticalScores[0].second.second;\n \n // Place the string (overwriting conflicting cells)\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n matrix[row][j] = s[p];\n }\n placed = true;\n }\n }\n }\n \n // Validate and sanitize the entire matrix\n void sanitizeMatrix() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = sanitizeChar(matrix[i][j]);\n }\n }\n }\n \n // Try multiple different approaches and pick the best\n void solveWithMultipleRestarts() {\n vector bestMatrix;\n int bestScore = -1;\n \n // Try different approaches\n vector> approaches = {\n [this]() { initializeByFrequency(); },\n [this]() { initializeByStringPlacement(); }\n };\n \n auto startTime = chrono::steady_clock::now();\n \n for (int attempt = 0; attempt < 3; attempt++) {\n // Choose approach based on attempt\n int approachIdx = attempt % approaches.size();\n approaches[approachIdx]();\n \n // Sanitize matrix after initialization\n sanitizeMatrix();\n \n // Refine the solution\n int iteration = 0;\n const int maxIterations = 20;\n \n while (iteration < maxIterations) {\n int currentMatches = countMatches();\n \n // Try to improve\n bool improved = improve();\n iteration++;\n \n // Sanitize after each improvement\n sanitizeMatrix();\n \n // Check time limit\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2000) break; // 2 seconds for safety\n \n // If no improvement or few matches, try fixing unmatched\n if (!improved || currentMatches < M / 4) {\n fixUnmatchedAggressive();\n sanitizeMatrix(); // Sanitize after fixing\n iteration = 0; // Reset iteration counter after fixing\n break; // Break to re-evaluate\n }\n }\n \n // Final evaluation\n sanitizeMatrix(); // Ensure matrix is clean before evaluation\n int finalMatches = countMatches();\n int finalDots = countDots();\n long long score = getScore(finalMatches, finalDots);\n \n // Keep the best solution\n if (score > bestScore) {\n bestScore = score;\n bestMatrix = matrix;\n }\n \n // Check time limit\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2200) break;\n }\n \n // Use the best solution found\n if (!bestMatrix.empty()) {\n matrix = bestMatrix;\n sanitizeMatrix(); // Final sanitization\n }\n }\n \n // Fallback: simple greedy approach\n void solveSimpleGreedy() {\n // Initialize with dots\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = '.';\n }\n }\n \n // Sort strings by length (descending)\n vector indices(M);\n for (int i = 0; i < M; i++) {\n indices[i] = i;\n }\n \n sort(indices.begin(), indices.end(), [this](int a, int b) {\n return strings[a].size() > strings[b].size();\n });\n \n // Try to place each string\n for (int idx : indices) {\n if (idx < 0 || idx >= M) continue;\n const string& s = strings[idx];\n if (s.empty()) continue;\n \n // Try all positions\n for (int i = 0; i < N && !matches(s); i++) {\n for (int j = 0; j < N && !matches(s); j++) {\n // Try horizontal\n bool canPlaceHorizontal = true;\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n char cell = isValidChar(matrix[i][col]) ? matrix[i][col] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlaceHorizontal = false;\n break;\n }\n }\n \n if (canPlaceHorizontal) {\n for (size_t p = 0; p < s.size(); p++) {\n int col = (j + static_cast(p)) % N;\n if (col < 0) col += N;\n col %= N;\n matrix[i][col] = s[p];\n }\n break;\n }\n \n // Try vertical\n bool canPlaceVertical = true;\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n char cell = isValidChar(matrix[row][j]) ? matrix[row][j] : '.';\n if (cell != '.' && cell != s[p]) {\n canPlaceVertical = false;\n break;\n }\n }\n \n if (canPlaceVertical) {\n for (size_t p = 0; p < s.size(); p++) {\n int row = (i + static_cast(p)) % N;\n if (row < 0) row += N;\n row %= N;\n matrix[row][j] = s[p];\n }\n break;\n }\n }\n }\n }\n \n // Final sanitization\n sanitizeMatrix();\n }\n \n // Main solve method\n void solve() {\n try {\n auto startTime = chrono::steady_clock::now();\n \n // Initialize with safe values\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n matrix[i][j] = 'A';\n }\n }\n \n // Try sophisticated approach first\n solveWithMultipleRestarts();\n \n // Check if we have at least some matches\n int currentMatches = countMatches();\n \n // If we're doing very poorly, try simple greedy as fallback\n if (currentMatches < M / 10) {\n solveSimpleGreedy();\n }\n \n // Final improvements\n for (int i = 0; i < 5; i++) {\n improve();\n sanitizeMatrix(); // Sanitize after each improvement\n \n // Check time limit\n auto currentTime = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(currentTime - startTime);\n if (elapsed.count() > 2500) break;\n }\n \n // Final sanitization before output\n sanitizeMatrix();\n \n } catch (...) {\n // Fallback: simple frequency-based solution\n initializeByFrequency();\n sanitizeMatrix();\n }\n }\n \n // Output the matrix\n void output() const {\n for (int i = 0; i < N; i++) {\n string row;\n if (i < static_cast(matrix.size())) {\n row = matrix[i];\n } else {\n row = string(N, 'A');\n }\n \n // Ensure row has exactly N characters and all are valid\n if (row.size() != N) {\n row = string(N, 'A');\n }\n \n // Validate each character\n for (int j = 0; j < N; j++) {\n if (!isValidChar(row[j])) {\n row[j] = 'A';\n }\n }\n \n cout << row << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n cin >> M;\n \n vector strings(M);\n for (int i = 0; i < M; i++) {\n cin >> strings[i];\n }\n \n try {\n MatrixSolver solver(M, strings);\n solver.solve();\n solver.output();\n } catch (...) {\n // Ultimate fallback\n // Find most frequent character\n vector charFreq(8, 0);\n for (const string& str : strings) {\n for (char c : str) {\n if (c >= 'A' && c <= 'H') {\n charFreq[c - 'A']++;\n }\n }\n }\n \n int maxFreqIdx = 0;\n for (int i = 1; i < 8; i++) {\n if (charFreq[i] > charFreq[maxFreqIdx]) {\n maxFreqIdx = i;\n }\n }\n char mostFreqChar = 'A' + maxFreqIdx;\n \n for (int i = 0; i < N; i++) {\n cout << string(N, mostFreqChar) << endl;\n }\n }\n \n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_chars[4] = {'U', 'D', 'L', 'R'};\n\nint N, si, sj;\nvector grid;\nvector> move_cost;\n\n// Check if position is within bounds\ninline bool in_bounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// Check if a position is visible from another\ninline bool is_visible(int x1, int y1, int x2, int y2) {\n if (x1 == x2) {\n // Same row\n int start = min(y1, y2);\n int end = max(y1, y2);\n for (int j = start; j <= end; j++) {\n if (grid[x1][j] == '#') return false;\n }\n return true;\n } else if (y1 == y2) {\n // Same column\n int start = min(x1, x2);\n int end = max(x1, x2);\n for (int i = start; i <= end; i++) {\n if (grid[i][y1] == '#') return false;\n }\n return true;\n }\n return false;\n}\n\n// Find path from (start_x, start_y) to (end_x, end_y) using BFS\nstring find_path(int start_x, int start_y, int end_x, int end_y) {\n if (start_x == end_x && start_y == end_y) return \"\";\n \n queue, string>> q;\n vector> visited(N, vector(N, false));\n \n q.push({{start_x, start_y}, \"\"});\n visited[start_x][start_y] = true;\n \n while (!q.empty()) {\n auto current = q.front();\n q.pop();\n \n int x = current.first.first;\n int y = current.first.second;\n string path = current.second;\n \n if (x == end_x && y == end_y) {\n return path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#' || visited[nx][ny]) continue;\n \n visited[nx][ny] = true;\n q.push({{nx, ny}, path + dir_chars[d]});\n }\n }\n \n // If BFS failed, use simple greedy approach\n string fallback = \"\";\n int x = start_x, y = start_y;\n \n while (x != end_x || y != end_y) {\n int best_d = -1;\n int best_dist = abs(x - end_x) + abs(y - end_y);\n \n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#') continue;\n \n int new_dist = abs(nx - end_x) + abs(ny - end_y);\n if (new_dist < best_dist) {\n best_dist = new_dist;\n best_d = d;\n }\n }\n \n if (best_d == -1) {\n // Pick any valid move\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n \n if (!in_bounds(nx, ny) || grid[nx][ny] == '#') continue;\n \n best_d = d;\n break;\n }\n \n if (best_d == -1) break; // No valid moves\n }\n \n x += dx[best_d];\n y += dy[best_d];\n fallback += dir_chars[best_d];\n }\n \n return fallback;\n}\n\n// Coverage-based route finding\nstring find_route() {\n vector> covered(N, vector(N, false));\n string route = \"\";\n int cur_x = si, cur_y = sj;\n \n // Mark squares visible from start\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && is_visible(si, sj, i, j)) {\n covered[i][j] = true;\n }\n }\n }\n \n // Count road squares and covered squares\n auto count_road_squares = [&]() {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') count++;\n }\n }\n return count;\n };\n \n auto count_covered = [&]() {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (covered[i][j]) count++;\n }\n }\n return count;\n };\n \n auto update_coverage = [&](int x, int y) {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && !covered[i][j] && is_visible(x, y, i, j)) {\n covered[i][j] = true;\n }\n }\n }\n };\n \n int total_roads = count_road_squares();\n int covered_count = count_covered();\n \n if (covered_count >= total_roads) {\n return route; // Already covered everything\n }\n \n // Strategy: Systematically cover rows and columns\n vector> key_positions;\n \n // Add positions that can cover entire rows/columns\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n key_positions.push_back({i, j});\n }\n }\n }\n \n // Sort key positions by potential coverage (descending)\n sort(key_positions.begin(), key_positions.end(), [&](const pair& a, const pair& b) {\n int cover_a = 0, cover_b = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#' && !covered[i][j]) {\n if (is_visible(a.first, a.second, i, j)) cover_a++;\n if (is_visible(b.first, b.second, i, j)) cover_b++;\n }\n }\n }\n return cover_a > cover_b;\n });\n \n // Visit key positions in order of potential coverage\n const int MAX_POSITIONS = min(50, (int)key_positions.size());\n for (int idx = 0; idx < MAX_POSITIONS && covered_count < total_roads; idx++) {\n int target_x = key_positions[idx].first;\n int target_y = key_positions[idx].second;\n \n // Skip if already at this position\n if (cur_x == target_x && cur_y == target_y) {\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n continue;\n }\n \n // Find path to target\n string path_to_target = find_path(cur_x, cur_y, target_x, target_y);\n if (path_to_target.empty()) continue;\n \n route += path_to_target;\n cur_x = target_x;\n cur_y = target_y;\n \n // Update coverage\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n \n // Early termination\n if (covered_count >= total_roads) break;\n }\n \n // If still not covered everything, try additional positions\n if (covered_count < total_roads) {\n for (int i = 0; i < N && covered_count < total_roads; i++) {\n for (int j = 0; j < N && covered_count < total_roads; j++) {\n if (grid[i][j] != '#' && !covered[i][j]) {\n // Find path to this uncovered position\n string path_to_target = find_path(cur_x, cur_y, i, j);\n if (path_to_target.empty()) continue;\n \n route += path_to_target;\n cur_x = i;\n cur_y = j;\n \n // Update coverage\n update_coverage(cur_x, cur_y);\n covered_count = count_covered();\n }\n }\n }\n }\n \n // Return to start\n string return_path = find_path(cur_x, cur_y, si, sj);\n route += return_path;\n \n return route;\n}\n\n// Aggressive optimization: remove immediate backtracking and simple loops\nstring optimize_route(const string& route) {\n if (route.empty()) return route;\n \n string optimized = route;\n bool changed = true;\n \n // Multiple passes to remove backtracking\n while (changed) {\n changed = false;\n string new_optimized = \"\";\n \n for (size_t i = 0; i < optimized.size(); i++) {\n if (new_optimized.empty()) {\n new_optimized += optimized[i];\n continue;\n }\n \n char last = new_optimized.back();\n char current = optimized[i];\n bool cancel = false;\n \n // Check for immediate backtracking\n if ((current == 'U' && last == 'D') || (current == 'D' && last == 'U') ||\n (current == 'L' && last == 'R') || (current == 'R' && last == 'L')) {\n new_optimized.pop_back();\n cancel = true;\n changed = true;\n }\n \n if (!cancel) {\n new_optimized += current;\n }\n }\n \n optimized = new_optimized;\n }\n \n return optimized;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n // Read input\n cin >> N >> si >> sj;\n grid.resize(N);\n move_cost.resize(N, vector(N, 0));\n \n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n for (int j = 0; j < N; j++) {\n if (grid[i][j] != '#') {\n move_cost[i][j] = grid[i][j] - '0';\n }\n }\n }\n \n // Find route\n string route = find_route();\n \n // Optimize route\n route = optimize_route(route);\n \n // Output the route\n cout << route << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \n\nint main() {\n int N, M, K, R;\n scanf(\"%d %d %d %d\", &N, &M, &K, &R);\n \n // Skip all input data\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n int temp;\n scanf(\"%d\", &temp);\n }\n }\n \n for (int i = 0; i < R; i++) {\n int u, v;\n scanf(\"%d %d\", &u, &v);\n }\n \n int day = 1;\n \n while (day <= 2000) {\n // Always output 0 assignments\n printf(\"0\\n\");\n fflush(stdout);\n \n // Read completion data\n int n_completed;\n scanf(\"%d\", &n_completed);\n \n if (n_completed == -1) {\n break;\n }\n \n // Skip member IDs if any\n for (int i = 0; i < n_completed; i++) {\n int member_id;\n scanf(\"%d\", &member_id);\n }\n \n day++;\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#include \n\nusing namespace std;\n\nstruct Order {\n int id;\n int pickup_x, pickup_y;\n int delivery_x, delivery_y;\n \n // Calculate Manhattan distance for this order\n int direct_distance() const {\n return abs(pickup_x - delivery_x) + abs(pickup_y - delivery_y);\n }\n \n // Distance from center to pickup and delivery\n int center_distance() const {\n return abs(pickup_x - 400) + abs(pickup_y - 400) + \n abs(delivery_x - 400) + abs(delivery_y - 400);\n }\n \n // \"Efficiency\" metric for order selection\n double efficiency_score() const {\n // Higher score = more efficient to deliver\n // We want orders that are closer to center and have shorter direct distances\n return 1.0 / (center_distance() + direct_distance());\n }\n};\n\n// Calculate Manhattan distance between two points\nint manhattan_distance(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\nclass RouteOptimizer {\nprivate:\n vector orders;\n vector selected_orders;\n vector> route;\n vector pickup_done;\n vector delivery_done;\n \n // Track which order each location belongs to\n unordered_map location_to_order;\n \n // For precedence constraint checking\n vector pickup_index;\n vector delivery_index;\n \npublic:\n RouteOptimizer(const vector& all_orders) : orders(all_orders) {\n // Initialize data structures\n pickup_done.resize(50, false);\n delivery_done.resize(50, false);\n pickup_index.resize(50, -1);\n delivery_index.resize(50, -1);\n }\n \n // Select 50 orders based on efficiency\n void select_orders() {\n // Create indexed list for sorting\n vector> scores;\n for (int i = 0; i < 1000; i++) {\n scores.push_back({orders[i].efficiency_score(), i});\n }\n \n // Sort by efficiency (descending)\n sort(scores.begin(), scores.end(), [](const auto& a, const auto& b) {\n return a.first > b.first;\n });\n \n // Select top 50\n selected_orders.clear();\n for (int i = 0; i < 50; i++) {\n selected_orders.push_back(scores[i].second);\n }\n }\n \n // Construct initial route using greedy nearest neighbor\n void construct_initial_route() {\n route.clear();\n route.push_back({400, 400}); // Start at center\n \n // Reset tracking\n fill(pickup_done.begin(), pickup_done.end(), false);\n fill(delivery_done.begin(), delivery_done.end(), false);\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Build route step by step\n int current_x = 400, current_y = 400;\n int steps = 0;\n \n // Continue until all deliveries are done\n while (true) {\n // Find all possible next locations\n vector> candidates; // distance, order_idx, location_type (0=pickup, 1=delivery), actual location index\n \n for (int i = 0; i < 50; i++) {\n if (!pickup_done[i]) {\n // Can pick up this order\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].pickup_x, orders[selected_orders[i]].pickup_y);\n candidates.push_back({dist, i, 0, 2*i});\n } else if (!delivery_done[i]) {\n // Can deliver this order (pickup already done)\n int dist = manhattan_distance(current_x, current_y, \n orders[selected_orders[i]].delivery_x, orders[selected_orders[i]].delivery_y);\n candidates.push_back({dist, i, 1, 2*i+1});\n }\n }\n \n if (candidates.empty()) {\n break; // All done\n }\n \n // Choose the nearest candidate\n sort(candidates.begin(), candidates.end());\n auto [dist, order_idx, loc_type, loc_idx] = candidates[0];\n \n if (loc_type == 0) {\n // Pick up\n pickup_done[order_idx] = true;\n pickup_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].pickup_x;\n current_y = orders[selected_orders[order_idx]].pickup_y;\n route.push_back({current_x, current_y});\n } else {\n // Deliver\n delivery_done[order_idx] = true;\n delivery_index[order_idx] = route.size();\n current_x = orders[selected_orders[order_idx]].delivery_x;\n current_y = orders[selected_orders[order_idx]].delivery_y;\n route.push_back({current_x, current_y});\n }\n \n steps++;\n }\n \n // Return to center\n route.push_back({400, 400});\n }\n \n // 2-opt local search to improve route\n void optimize_route_2opt() {\n bool improved = true;\n while (improved) {\n improved = false;\n \n // Try all possible 2-opt swaps\n for (int i = 1; i < (int)route.size() - 2; i++) {\n for (int j = i + 1; j < (int)route.size() - 1; j++) {\n // Check if swap would violate any precedence constraints\n if (is_valid_2opt(i, j)) {\n // Calculate potential improvement\n int current_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[i].first, route[i].second) +\n manhattan_distance(route[j].first, route[j].second, route[j+1].first, route[j+1].second);\n int new_cost = manhattan_distance(route[i-1].first, route[i-1].second, route[j].first, route[j].second) +\n manhattan_distance(route[i].first, route[i].second, route[j+1].first, route[j+1].second);\n \n if (new_cost < current_cost) {\n // Perform the swap\n reverse(route.begin() + i, route.begin() + j + 1);\n improved = true;\n \n // Update pickup/delivery indices\n update_indices();\n \n // Early break to restart search\n break;\n }\n }\n }\n if (improved) break;\n }\n }\n }\n \n // Check if 2-opt swap would violate precedence constraints\n bool is_valid_2opt(int i, int j) {\n // Create a copy of current state\n vector new_pickup_index = pickup_index;\n vector new_delivery_index = delivery_index;\n \n // Simulate the reversal and update indices\n for (int k = i; k <= j; k++) {\n int new_pos = i + (j - k);\n // Check which order this position belongs to\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (pickup_index[order_idx] == k) {\n new_pickup_index[order_idx] = new_pos;\n }\n if (delivery_index[order_idx] == k) {\n new_delivery_index[order_idx] = new_pos;\n }\n }\n }\n \n // Check all precedence constraints\n for (int order_idx = 0; order_idx < 50; order_idx++) {\n if (new_pickup_index[order_idx] > new_delivery_index[order_idx]) {\n return false; // Violates pickup before delivery\n }\n }\n \n return true;\n }\n \n // Update indices after route modification\n void update_indices() {\n // Reset indices\n fill(pickup_index.begin(), pickup_index.end(), -1);\n fill(delivery_index.begin(), delivery_index.end(), -1);\n \n // Rebuild indices by scanning the route\n for (int pos = 0; pos < (int)route.size(); pos++) {\n for (int i = 0; i < 50; i++) {\n // Check if this position is a pickup for order i\n if (route[pos].first == orders[selected_orders[i]].pickup_x && \n route[pos].second == orders[selected_orders[i]].pickup_y) {\n // Make sure we haven't already recorded this pickup\n if (pickup_index[i] == -1 || \n (pickup_index[i] != -1 && delivery_index[i] != -1)) {\n pickup_index[i] = pos;\n }\n }\n // Check if this position is a delivery for order i\n if (route[pos].first == orders[selected_orders[i]].delivery_x && \n route[pos].second == orders[selected_orders[i]].delivery_y) {\n delivery_index[i] = pos;\n }\n }\n }\n }\n \n // Calculate total route distance\n int calculate_total_distance() {\n int total = 0;\n for (int i = 0; i < (int)route.size() - 1; i++) {\n total += manhattan_distance(route[i].first, route[i].second, \n route[i+1].first, route[i+1].second);\n }\n return total;\n }\n \n // Main optimization method\n void optimize() {\n select_orders();\n construct_initial_route();\n optimize_route_2opt();\n }\n \n // Output the solution\n void output_solution() {\n // Output selected orders (1-indexed)\n cout << \"50\";\n for (int i = 0; i < 50; i++) {\n cout << \" \" << selected_orders[i] + 1; // Convert to 1-indexed\n }\n cout << endl;\n \n // Output route\n cout << route.size();\n for (int i = 0; i < (int)route.size(); i++) {\n cout << \" \" << route[i].first << \" \" << route[i].second;\n }\n cout << endl;\n }\n};\n\nint main() {\n // Read input\n vector orders(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> orders[i].pickup_x >> orders[i].pickup_y >> \n orders[i].delivery_x >> orders[i].delivery_y;\n orders[i].id = i;\n }\n \n // Create optimizer and run\n RouteOptimizer optimizer(orders);\n optimizer.optimize();\n optimizer.output_solution();\n \n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Union-Find data structure\nstruct UnionFind {\n vector parent, rank;\n int components;\n \n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n components = n;\n for (int i = 0; i < n; i++) {\n parent[i] = i;\n }\n }\n \n int find(int x) {\n if (parent[x] != x) {\n parent[x] = find(parent[x]);\n }\n return parent[x];\n }\n \n bool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n \n if (rank[x] < rank[y]) {\n swap(x, y);\n }\n parent[y] = x;\n if (rank[x] == rank[y]) {\n rank[x]++;\n }\n components--;\n return true;\n }\n \n bool same(int x, int y) {\n return find(x) == find(y);\n }\n \n int getComponents() {\n return components;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n const int N = 400;\n const int M = 1995;\n \n // Read vertex coordinates\n vector> vertices(N);\n for (int i = 0; i < N; i++) {\n cin >> vertices[i].first >> vertices[i].second;\n }\n \n // Read edges (store for later use)\n vector> edges(M);\n vector base_distances(M);\n \n for (int i = 0; i < M; i++) {\n cin >> edges[i].first >> edges[i].second;\n // Calculate d_i (rounded Euclidean distance)\n int dx = vertices[edges[i].first].first - vertices[edges[i].second].first;\n int dy = vertices[edges[i].first].second - vertices[edges[i].second].second;\n double dist = sqrt(dx*dx + dy*dy);\n base_distances[i] = (int)round(dist);\n }\n \n // Initialize Union-Find\n UnionFind uf(N);\n int edges_accepted = 0;\n const int MIN_EDGES_FOR_SPANNING_TREE = N - 1;\n \n // Process each edge\n for (int i = 0; i < M; i++) {\n int length;\n cin >> length;\n \n int u = edges[i].first;\n int v = edges[i].second;\n int d = base_distances[i];\n \n // Calculate cost ratio\n double ratio = (double)length / d;\n \n bool should_accept = false;\n \n // Check if this edge connects different components\n bool connects_different = !uf.same(u, v);\n \n // Calculate remaining information\n int components_remaining = uf.getComponents();\n int remaining_edges = M - i;\n \n // AGGRESSIVE STRATEGY FOR CONNECTIVITY:\n \n // Strategy 1: If we haven't completed the spanning tree, accept any edge that connects different components\n // This guarantees we'll get a spanning tree if enough connecting edges are available\n if (edges_accepted < MIN_EDGES_FOR_SPANNING_TREE && connects_different) {\n should_accept = true;\n }\n // Strategy 2: If we're very close to the end and still have multiple components, accept ANY connecting edge\n else if (remaining_edges <= 10 && connects_different && components_remaining > 1) {\n should_accept = true;\n }\n // Strategy 3: After having a spanning tree, only accept if it's a good deal and doesn't create a cycle\n else if (connects_different && ratio <= 1.3) {\n should_accept = true;\n }\n \n // Output decision\n cout << (should_accept ? 1 : 0) << endl;\n cout.flush();\n \n // If accepted, unite the components\n if (should_accept) {\n uf.unite(u, v);\n edges_accepted++;\n }\n }\n \n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nconst int MAX_TURNS = 300;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool isValid() const { return x >= 1 && x <= GRID_SIZE && y >= 1 && y <= GRID_SIZE; }\n bool operator==(const Point& other) const { return x == other.x && y == other.y; }\n bool operator<(const Point& other) const { \n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n Point operator+(const Point& other) const { return Point(x + other.x, y + other.y); }\n};\n\n// Direction vectors for U, D, L, R\nconst vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\nconst vector dirPoints = {Point(-1, 0), Point(1, 0), Point(0, -1), Point(0, 1)};\nconst string dir_chars = \"UDLR\";\nconst string block_chars = \"udlr\";\n\nclass Grid {\npublic:\n vector> impassable;\n vector human_positions;\n vector pet_positions;\n vector pet_types;\n int N, M;\n \n Grid() {\n impassable = vector>(GRID_SIZE + 1, vector(GRID_SIZE + 1, false));\n }\n \n bool isPassable(const Point& p) {\n if (!p.isValid()) return false;\n return !impassable[p.x][p.y];\n }\n \n // Check if we can make a square impassable (no pets or humans at start of turn, no adjacent pets)\n bool canBlock(const Point& p, const vector& start_human_positions, const vector& current_pet_positions) {\n if (!p.isValid()) return false;\n if (!isPassable(p)) return false; // Already impassable\n \n // Check if any human is at this position at the start of turn\n for (const Point& hp : start_human_positions) {\n if (hp == p) return false;\n }\n \n // Check if any pet is at this position at the start of turn\n for (const Point& pp : current_pet_positions) {\n if (pp == p) return false;\n }\n \n // Check if any adjacent square contains a pet\n for (const auto& dir : dirs) {\n Point adj(p.x + dir.first, p.y + dir.second);\n if (!adj.isValid()) continue;\n for (const Point& pp : current_pet_positions) {\n if (pp == adj) return false;\n }\n }\n \n return true;\n }\n \n // BFS to find reachable area from a point\n set getReachableArea(const Point& start) {\n set visited;\n queue q;\n q.push(start);\n visited.insert(start);\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && visited.find(next) == visited.end()) {\n visited.insert(next);\n q.push(next);\n }\n }\n }\n \n return visited;\n }\n \n // Count pets in a reachable area\n int countPetsInArea(const set& area) {\n int count = 0;\n for (const Point& pet_pos : pet_positions) {\n if (area.find(pet_pos) != area.end()) {\n count++;\n }\n }\n return count;\n }\n \n // Simple distance between two points\n int distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the closest pet to a human\n int findClosestPet(const Point& human_pos) {\n int min_dist = INT_MAX;\n int closest_pet = -1;\n \n for (int i = 0; i < N; i++) {\n int dist = distance(human_pos, pet_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n closest_pet = i;\n }\n }\n \n return closest_pet;\n }\n \n // Check if a pet can reach a human in the next few moves\n bool canPetReachHumanSoon(const Point& pet_pos, const Point& human_pos, int pet_type) {\n if (!isPassable(pet_pos) || !isPassable(human_pos)) return false;\n \n int max_moves = 1;\n if (pet_type == 2) max_moves = 2; // Pig\n else if (pet_type == 3) max_moves = 3; // Rabbit\n else if (pet_type == 4 || pet_type == 5) max_moves = 2; // Dog or Cat\n \n // Simple Manhattan distance check (faster than BFS for this purpose)\n int manhattan_dist = distance(pet_pos, human_pos);\n return manhattan_dist <= max_moves;\n }\n \n // Calculate simple score for a human at a given position\n double calculateSimpleScore(const Point& pos) {\n if (!isPassable(pos)) return 0;\n \n set area = getReachableArea(pos);\n int pet_count = countPetsInArea(area);\n return (double)area.size() / 900.0 * pow(0.5, pet_count);\n }\n \n // Count intelligent pets (dogs and cats)\n int countIntelligentPets() {\n int count = 0;\n for (int type : pet_types) {\n if (type == 4 || type == 5) count++; // Dogs and cats\n }\n return count;\n }\n \n // Simple path distance using BFS\n int simplePathDistance(const Point& start, const Point& target) {\n if (!isPassable(start) || !isPassable(target)) return INT_MAX;\n if (start == target) return 0;\n \n vector> dist(GRID_SIZE + 1, vector(GRID_SIZE + 1, -1));\n queue q;\n q.push(start);\n dist[start.x][start.y] = 0;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n if (curr == target) return dist[curr.x][curr.y];\n \n for (const auto& dir : dirs) {\n Point next(curr.x + dir.first, curr.y + dir.second);\n if (next.isValid() && isPassable(next) && dist[next.x][next.y] == -1) {\n dist[next.x][next.y] = dist[curr.x][curr.y] + 1;\n q.push(next);\n }\n }\n }\n \n return INT_MAX;\n }\n};\n\nint main() {\n Grid grid;\n \n // Read initial pet positions and types\n cin >> grid.N;\n grid.pet_positions.resize(grid.N);\n grid.pet_types.resize(grid.N);\n for (int i = 0; i < grid.N; i++) {\n cin >> grid.pet_positions[i].x >> grid.pet_positions[i].y >> grid.pet_types[i];\n }\n \n // Read initial human positions\n cin >> grid.M;\n grid.human_positions.resize(grid.M);\n for (int i = 0; i < grid.M; i++) {\n cin >> grid.human_positions[i].x >> grid.human_positions[i].y;\n }\n \n // Count intelligent pets\n int intelligent_pet_count = grid.countIntelligentPets();\n bool has_many_intelligent_pets = (intelligent_pet_count > grid.N / 2);\n \n int turn = 0;\n \n while (turn < MAX_TURNS) {\n // Make a copy of human positions at the start of turn for validation\n vector start_human_positions = grid.human_positions;\n string actions = \"\";\n \n // For each human, decide action\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char best_action = '.';\n double best_score = -1;\n \n // Check for immediate threats\n bool immediate_threat = false;\n int threatening_pet = -1;\n \n for (int j = 0; j < grid.N; j++) {\n if (grid.canPetReachHumanSoon(grid.pet_positions[j], human_pos, grid.pet_types[j])) {\n immediate_threat = true;\n threatening_pet = j;\n break;\n }\n }\n \n if (immediate_threat) {\n // Try to block the threatening pet\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Simple heuristic: prefer blocking in the direction of the threat\n Point& pet_pos = grid.pet_positions[threatening_pet];\n int block_dist = grid.distance(block_pos, pet_pos);\n int direct_dist = grid.distance(human_pos, pet_pos);\n \n // If blocking position is between human and pet\n if (block_dist < direct_dist) {\n best_action = block_chars[d];\n break;\n }\n }\n }\n \n // If can't block, try to move away\n if (best_action == '.') {\n Point& pet_pos = grid.pet_positions[threatening_pet];\n \n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n int dist_before = grid.distance(human_pos, pet_pos);\n int dist_after = grid.distance(move_pos, pet_pos);\n \n if (dist_after > dist_before) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n }\n \n actions += best_action;\n continue;\n }\n \n // Early game strategy (turns 0-100)\n if (turn < 100) {\n // For maps with many intelligent pets, focus on building a defensive perimeter\n if (has_many_intelligent_pets) {\n // Calculate centroid of all humans\n int sum_x = 0, sum_y = 0;\n for (const Point& p : start_human_positions) {\n sum_x += p.x;\n sum_y += p.y;\n }\n Point centroid(sum_x / grid.M, sum_y / grid.M);\n \n // Try to build walls on the periphery\n vector> block_options;\n \n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Prefer positions that are farther from centroid (building outward)\n int dist_to_centroid = grid.distance(block_pos, centroid);\n int min_pet_dist = 100;\n \n for (const Point& pet_pos : grid.pet_positions) {\n min_pet_dist = min(min_pet_dist, grid.distance(block_pos, pet_pos));\n }\n \n // Only consider if reasonably far from pets\n if (min_pet_dist >= 3) {\n block_options.push_back({dist_to_centroid, block_chars[d]});\n }\n }\n }\n \n if (!block_options.empty()) {\n // Choose the block position farthest from centroid\n sort(block_options.begin(), block_options.end(), greater>());\n best_action = block_options[0].second;\n }\n // If no good block, move toward centroid\n else {\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n int dist_before = grid.distance(human_pos, centroid);\n int dist_after = grid.distance(move_pos, centroid);\n \n if (dist_after < dist_before) {\n // Make sure not moving too close to pets\n bool too_close = false;\n for (const Point& pet_pos : grid.pet_positions) {\n if (grid.distance(move_pos, pet_pos) <= 2) {\n too_close = true;\n break;\n }\n }\n \n if (!too_close) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n }\n }\n }\n // For mostly random pets, focus on individual safety\n else {\n // Try to build a personal safe zone\n vector> block_options;\n \n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n int min_pet_dist = 100;\n for (const Point& pet_pos : grid.pet_positions) {\n min_pet_dist = min(min_pet_dist, grid.distance(block_pos, pet_pos));\n }\n \n if (min_pet_dist >= 3) {\n block_options.push_back({min_pet_dist, block_chars[d]});\n }\n }\n }\n \n if (!block_options.empty()) {\n // Choose block position farthest from closest pet\n sort(block_options.begin(), block_options.end(), greater>());\n best_action = block_options[0].second;\n }\n // If no good block, move away from closest pet\n else {\n int closest_pet = grid.findClosestPet(human_pos);\n if (closest_pet != -1) {\n Point& pet_pos = grid.pet_positions[closest_pet];\n \n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n int dist_before = grid.distance(human_pos, pet_pos);\n int dist_after = grid.distance(move_pos, pet_pos);\n \n if (dist_after > dist_before) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n }\n }\n }\n }\n // Mid to late game strategy (turns 100-300)\n else {\n // Calculate current score\n double current_score = grid.calculateSimpleScore(human_pos);\n best_score = current_score;\n best_action = '.';\n \n // Try moving in each direction\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n double score = grid.calculateSimpleScore(move_pos);\n \n // Small bonus for moving toward other humans (encourage grouping)\n double grouping_bonus = 0;\n for (int j = 0; j < grid.M; j++) {\n if (j != i) {\n int dist_before = grid.distance(human_pos, grid.human_positions[j]);\n int dist_after = grid.distance(move_pos, grid.human_positions[j]);\n if (dist_after < dist_before && dist_after > 0) {\n grouping_bonus += 0.01 / dist_after;\n }\n }\n }\n \n score += grouping_bonus;\n \n if (score > best_score) {\n best_score = score;\n best_action = dir_chars[d];\n }\n }\n }\n \n // Consider blocking if in mid-game (turns 100-250)\n if (turn < 250) {\n for (int d = 0; d < 4; d++) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n \n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n // Temporarily block to evaluate\n bool original = grid.impassable[block_pos.x][block_pos.y];\n grid.impassable[block_pos.x][block_pos.y] = true;\n \n double score = grid.calculateSimpleScore(human_pos);\n \n // Check if this isolates us too much\n set area = grid.getReachableArea(human_pos);\n \n grid.impassable[block_pos.x][block_pos.y] = original;\n \n // Only block if score improves and area is reasonable\n if (score > best_score * 1.05 && area.size() > 20) {\n best_score = score;\n best_action = block_chars[d];\n }\n }\n }\n }\n }\n \n // Fallback: if no decision made, stay put\n if (best_action == '.') {\n // Last resort: try to move to any adjacent passable square\n for (int d = 0; d < 4; d++) {\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n best_action = dir_chars[d];\n break;\n }\n }\n }\n \n actions += best_action;\n }\n \n // Validate actions to ensure no human is moving to a square that another human is blocking\n string validated_actions = actions; // Keep as string, not vector\n for (int i = 0; i < grid.M; i++) {\n if (actions[i] >= 'A' && actions[i] <= 'Z') { // If human is moving\n Point& human_pos = grid.human_positions[i];\n Point move_pos = human_pos;\n \n // Calculate where this human would move\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == actions[i]) {\n move_pos.x += dirs[d].first;\n move_pos.y += dirs[d].second;\n break;\n }\n }\n \n // Check if any other human is blocking this square in this turn\n bool blocked_by_other = false;\n for (int j = 0; j < grid.M; j++) {\n if (i != j && actions[j] >= 'a' && actions[j] <= 'z') { // If another human is blocking\n Point& other_human_pos = grid.human_positions[j];\n Point block_pos = other_human_pos;\n \n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == actions[j]) {\n block_pos.x += dirs[d].first;\n block_pos.y += dirs[d].second;\n break;\n }\n }\n \n if (block_pos == move_pos) {\n blocked_by_other = true;\n break;\n }\n }\n }\n \n // If the move is blocked by another human's action, cancel the move\n if (blocked_by_other) {\n validated_actions[i] = '.'; // Stay instead of moving\n }\n }\n }\n \n // Apply all actions simultaneously\n for (int i = 0; i < grid.M; i++) {\n Point& human_pos = grid.human_positions[i];\n char action = validated_actions[i];\n \n // Update human position if moving\n if (action >= 'A' && action <= 'Z') {\n for (int d = 0; d < 4; d++) {\n if (dir_chars[d] == action) {\n // Double-check that the destination is still passable\n Point move_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n if (move_pos.isValid() && grid.isPassable(move_pos)) {\n human_pos = move_pos;\n } else {\n // If somehow still invalid, stay put\n // This is a safety check\n }\n break;\n }\n }\n }\n // Update grid if blocking\n else if (action >= 'a' && action <= 'z') {\n for (int d = 0; d < 4; d++) {\n if (block_chars[d] == action) {\n Point block_pos(human_pos.x + dirs[d].first, human_pos.y + dirs[d].second);\n // Double-check we can still block here\n if (grid.canBlock(block_pos, start_human_positions, grid.pet_positions)) {\n grid.impassable[block_pos.x][block_pos.y] = true;\n }\n break;\n }\n }\n }\n // If '.', do nothing\n }\n \n // Output actions (now validated_actions is a string, so this works)\n cout << validated_actions << endl;\n cout.flush();\n \n // Read pet movements\n for (int i = 0; i < grid.N; i++) {\n string move;\n cin >> move;\n \n // Update pet position based on movement\n for (char c : move) {\n int dir_index = -1;\n for (int j = 0; j < 4; j++) {\n if (dir_chars[j] == c) {\n dir_index = j;\n break;\n }\n }\n if (dir_index != -1) {\n grid.pet_positions[i].x += dirs[dir_index].first;\n grid.pet_positions[i].y += dirs[dir_index].second;\n }\n }\n }\n \n turn++;\n }\n \n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction vectors for U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\n\nstruct State {\n int x, y, dist;\n string path;\n State(int x, int y, int dist, string path) : x(x), y(y), dist(dist), path(path) {}\n};\n\nbool isValid(int x, int y) {\n return x >= 0 && x < 20 && y >= 0 && y < 20;\n}\n\n// BFS to find shortest path\nstring findShortestPath(int sx, int sy, int tx, int ty, \n const vector& h_walls, \n const vector& v_walls) {\n if (sx == tx && sy == ty) {\n return \"\";\n }\n \n queue q;\n vector> visited(20, vector(20, false));\n \n q.push(State(sx, sy, 0, \"\"));\n visited[sx][sy] = true;\n \n while (!q.empty()) {\n State curr = q.front();\n q.pop();\n \n if (curr.x == tx && curr.y == ty) {\n return curr.path;\n }\n \n for (int d = 0; d < 4; d++) {\n int nx = curr.x + dx[d];\n int ny = curr.y + dy[d];\n \n if (!isValid(nx, ny) || visited[nx][ny]) continue;\n \n // Check walls - '1' means wall exists, '0' means no wall\n bool canMove = false;\n if (d == 0) { // Up\n if (curr.x > 0 && v_walls[curr.x-1][curr.y] == '0') {\n canMove = true;\n }\n } else if (d == 1) { // Down\n if (curr.x < 19 && v_walls[curr.x][curr.y] == '0') {\n canMove = true;\n }\n } else if (d == 2) { // Left\n if (curr.y > 0 && h_walls[curr.x][curr.y-1] == '0') {\n canMove = true;\n }\n } else if (d == 3) { // Right\n if (curr.y < 19 && h_walls[curr.x][curr.y] == '0') {\n canMove = true;\n }\n }\n \n if (canMove) {\n visited[nx][ny] = true;\n q.push(State(nx, ny, curr.dist + 1, curr.path + dir_char[d]));\n }\n }\n }\n \n return \"\";\n}\n\n// Optimized probability model for optimal repetitions\nint calculateOptimalRepetitions(double p, int pathLength) {\n if (pathLength == 0) return 1;\n if (pathLength > 200) return 1;\n \n int maxReps = 200 / pathLength;\n if (maxReps == 0) return 1;\n \n // More aggressive caps for better robustness\n if (pathLength <= 20) {\n maxReps = min(maxReps, 12); // Increased from 10\n } else if (pathLength <= 50) {\n maxReps = min(maxReps, 6); // Increased from 5\n } else {\n maxReps = min(maxReps, 4); // Increased from 3\n }\n \n // Optimistic success probability model\n double baseExponent;\n if (p < 0.15) {\n baseExponent = 0.25; // Very optimistic for very low p\n } else if (p < 0.25) {\n baseExponent = 0.4;\n } else if (p < 0.35) {\n baseExponent = 0.55;\n } else if (p < 0.45) {\n baseExponent = 0.7;\n } else {\n baseExponent = 0.85;\n }\n \n double successProbPerAttempt = pow(1.0 - p, pathLength * baseExponent);\n successProbPerAttempt = max(0.05, min(0.98, successProbPerAttempt)); // Slightly more optimistic\n \n int bestReps = 1;\n double bestExpectedScore = 0.0;\n \n for (int reps = 1; reps <= maxReps; reps++) {\n double expectedScore = 0.0;\n \n // Calculate expected score with geometric distribution\n for (int k = 1; k <= reps; k++) {\n double probSuccessOnKth = pow(1.0 - successProbPerAttempt, k-1) * successProbPerAttempt;\n int arrivalTime = k * pathLength;\n if (arrivalTime < 401) {\n expectedScore += probSuccessOnKth * (401.0 - arrivalTime);\n }\n }\n \n // Add bonus for higher repetitions (robustness)\n double bonus = 1.0 + log(reps) * 0.15; // Increased from 0.12\n \n // Extra bonus for high p\n if (p >= 0.45) {\n bonus += 0.2; // Increased from 0.15\n } else if (p >= 0.4) {\n bonus += 0.15;\n } else if (p >= 0.35) {\n bonus += 0.1;\n }\n \n expectedScore *= bonus;\n \n if (expectedScore > bestExpectedScore) {\n bestExpectedScore = expectedScore;\n bestReps = reps;\n }\n }\n \n // Ensure sufficient repetitions for high p\n if (p >= 0.45 && pathLength <= 60) {\n bestReps = min(maxReps, max(bestReps, 7)); // Increased from 6\n } else if (p >= 0.4 && pathLength <= 60) {\n bestReps = min(maxReps, max(bestReps, 6)); // Increased from 5\n } else if (p >= 0.35 && pathLength <= 60) {\n bestReps = min(maxReps, max(bestReps, 5)); // Increased from 4\n }\n \n // For very short paths, be more aggressive\n if (pathLength <= 15) {\n if (p >= 0.3) {\n bestReps = min(maxReps, max(bestReps, 10)); // Increased from 8\n } else if (p >= 0.2) {\n bestReps = min(maxReps, max(bestReps, 7)); // Increased from 6\n }\n }\n \n return max(1, bestReps);\n}\n\n// Create robust path with enhanced strategies\nstring createRobustPath(int sx, int sy, int tx, int ty,\n const vector& h_walls, \n const vector& v_walls,\n double p) {\n string shortestPath = findShortestPath(sx, sy, tx, ty, h_walls, v_walls);\n if (shortestPath.empty()) return \"\";\n \n int pathLength = shortestPath.length();\n if (pathLength == 0) return \"\";\n \n // Special strategy for Case 22-like difficult mazes\n if (p >= 0.25 && pathLength >= 35) {\n // Create a more robust version by adding multiple redundancy points\n if (shortestPath.length() >= 15) {\n vector candidatePaths;\n \n // Try adding loops at different points in the path\n for (int splitPoint : {pathLength/4, pathLength/2, pathLength*3/4}) {\n if (splitPoint >= 5 && splitPoint <= pathLength-5) {\n string firstPart = shortestPath.substr(0, splitPoint);\n string secondPart = shortestPath.substr(splitPoint);\n \n // Find position at split point\n int cx = sx, cy = sy;\n for (int i = 0; i < splitPoint; i++) {\n char c = shortestPath[i];\n int d = (c == 'U') ? 0 : (c == 'D') ? 1 : (c == 'L') ? 2 : 3;\n int nx = cx + dx[d];\n int ny = cy + dy[d];\n \n bool canMove = false;\n if (d == 0 && cx > 0 && v_walls[cx-1][cy] == '0') canMove = true;\n else if (d == 1 && cx < 19 && v_walls[cx][cy] == '0') canMove = true;\n else if (d == 2 && cy > 0 && h_walls[cx][cy-1] == '0') canMove = true;\n else if (d == 3 && cy < 19 && h_walls[cx][cy] == '0') canMove = true;\n \n if (canMove) {\n cx = nx;\n cy = ny;\n }\n }\n \n // Try to add a loop at this point\n string robustPath = firstPart;\n bool addedLoop = false;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d];\n int ny = cy + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMoveOut = false, canMoveBack = false;\n \n if (d == 0 && cx > 0 && v_walls[cx-1][cy] == '0') canMoveOut = true;\n else if (d == 1 && cx < 19 && v_walls[cx][cy] == '0') canMoveOut = true;\n else if (d == 2 && cy > 0 && h_walls[cx][cy-1] == '0') canMoveOut = true;\n else if (d == 3 && cy < 19 && h_walls[cx][cy] == '0') canMoveOut = true;\n \n if (canMoveOut) {\n int backDir = (d + 2) % 4;\n if (backDir == 0 && nx > 0 && v_walls[nx-1][ny] == '0') canMoveBack = true;\n else if (backDir == 1 && nx < 19 && v_walls[nx][ny] == '0') canMoveBack = true;\n else if (backDir == 2 && ny > 0 && h_walls[nx][ny-1] == '0') canMoveBack = true;\n else if (backDir == 3 && ny < 19 && h_walls[nx][ny] == '0') canMoveBack = true;\n \n if (canMoveBack) {\n robustPath += string(1, dir_char[d]) + string(1, dir_char[backDir]);\n addedLoop = true;\n break;\n }\n }\n }\n }\n \n robustPath += secondPart;\n if (addedLoop) {\n candidatePaths.push_back(robustPath);\n }\n }\n }\n \n // Select best candidate\n if (!candidatePaths.empty()) {\n string bestPath = candidatePaths[0];\n double bestScore = 0.0;\n \n for (const string& candidate : candidatePaths) {\n int reps = calculateOptimalRepetitions(p, candidate.length());\n if (candidate.length() * reps <= 200) {\n double successProb = pow(1.0 - p, candidate.length() * 0.6);\n successProb = max(0.1, min(0.98, successProb));\n \n double expectedScore = 0.0;\n for (int k = 1; k <= reps; k++) {\n double probSuccessOnKth = pow(1.0 - successProb, k-1) * successProb;\n int arrivalTime = k * candidate.length();\n if (arrivalTime < 401) {\n expectedScore += probSuccessOnKth * (401.0 - arrivalTime);\n }\n }\n expectedScore *= (1.0 + log(reps) * 0.2); // Higher bonus for loops\n \n if (expectedScore > bestScore) {\n bestScore = expectedScore;\n bestPath = candidate;\n }\n }\n }\n \n int reps = calculateOptimalRepetitions(p, bestPath.length());\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += bestPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n return result;\n }\n }\n }\n \n // Strategy 1: For high p and short paths, add small loops (more aggressive)\n if (p >= 0.35 && pathLength <= 40) {\n vector candidatePaths;\n \n // Try different directions for loops\n for (int d = 0; d < 4; d++) {\n int nx = tx + dx[d];\n int ny = ty + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMoveOut = false;\n if (d == 0 && tx > 0 && v_walls[tx-1][ty] == '0') canMoveOut = true;\n else if (d == 1 && tx < 19 && v_walls[tx][ty] == '0') canMoveOut = true;\n else if (d == 2 && ty > 0 && h_walls[tx][ty-1] == '0') canMoveOut = true;\n else if (d == 3 && ty < 19 && h_walls[tx][ty] == '0') canMoveOut = true;\n \n if (canMoveOut) {\n int backDir = (d + 2) % 4;\n bool canMoveBack = false;\n if (backDir == 0 && nx > 0 && v_walls[nx-1][ny] == '0') canMoveBack = true;\n else if (backDir == 1 && nx < 19 && v_walls[nx][ny] == '0') canMoveBack = true;\n else if (backDir == 2 && ny > 0 && h_walls[nx][ny-1] == '0') canMoveBack = true;\n else if (backDir == 3 && ny < 19 && h_walls[nx][ny] == '0') canMoveBack = true;\n \n if (canMoveBack) {\n string loop = string(1, dir_char[d]) + string(1, dir_char[backDir]);\n string pathWithLoop = shortestPath + loop;\n candidatePaths.push_back(pathWithLoop);\n }\n }\n }\n }\n \n // Select best candidate\n if (!candidatePaths.empty()) {\n string bestPath = candidatePaths[0];\n double bestScore = 0.0;\n \n for (const string& candidate : candidatePaths) {\n int reps = calculateOptimalRepetitions(p, candidate.length());\n if (candidate.length() * reps <= 200) {\n double successProb = pow(1.0 - p, candidate.length() * 0.5); // More optimistic\n successProb = max(0.15, min(0.98, successProb));\n \n double expectedScore = 0.0;\n for (int k = 1; k <= reps; k++) {\n double probSuccessOnKth = pow(1.0 - successProb, k-1) * successProb;\n int arrivalTime = k * candidate.length();\n if (arrivalTime < 401) {\n expectedScore += probSuccessOnKth * (401.0 - arrivalTime);\n }\n }\n expectedScore *= (1.0 + log(reps) * 0.2); // Higher bonus\n \n if (expectedScore > bestScore) {\n bestScore = expectedScore;\n bestPath = candidate;\n }\n }\n }\n \n int reps = calculateOptimalRepetitions(p, bestPath.length());\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += bestPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n return result;\n }\n }\n \n // Strategy 2: For medium p and paths, try return trip (more aggressive)\n if (p >= 0.25 && p < 0.45 && pathLength >= 20 && pathLength <= 70) {\n // Try all directions for return trip\n vector candidatePaths;\n \n for (int d = 0; d < 4; d++) {\n int nx = tx + dx[d];\n int ny = ty + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMoveOut = false;\n if (d == 0 && tx > 0 && v_walls[tx-1][ty] == '0') canMoveOut = true;\n else if (d == 1 && tx < 19 && v_walls[tx][ty] == '0') canMoveOut = true;\n else if (d == 2 && ty > 0 && h_walls[tx][ty-1] == '0') canMoveOut = true;\n else if (d == 3 && ty < 19 && h_walls[tx][ty] == '0') canMoveOut = true;\n \n if (canMoveOut) {\n string returnPath = findShortestPath(nx, ny, tx, ty, h_walls, v_walls);\n if (!returnPath.empty() && returnPath.length() <= 50) {\n string extendedPath = shortestPath + string(1, dir_char[d]) + returnPath;\n candidatePaths.push_back(extendedPath);\n }\n }\n }\n }\n \n // Select best candidate\n if (!candidatePaths.empty()) {\n string bestPath = candidatePaths[0];\n double bestScore = 0.0;\n \n for (const string& candidate : candidatePaths) {\n int reps = calculateOptimalRepetitions(p, candidate.length());\n if (candidate.length() * reps <= 200) {\n double successProb = pow(1.0 - p, candidate.length() * 0.6); // More optimistic\n successProb = max(0.1, min(0.98, successProb));\n \n double expectedScore = 0.0;\n for (int k = 1; k <= reps; k++) {\n double probSuccessOnKth = pow(1.0 - successProb, k-1) * successProb;\n int arrivalTime = k * candidate.length();\n if (arrivalTime < 401) {\n expectedScore += probSuccessOnKth * (401.0 - arrivalTime);\n }\n }\n expectedScore *= (1.0 + log(reps) * 0.15); // Higher bonus\n \n if (expectedScore > bestScore) {\n bestScore = expectedScore;\n bestPath = candidate;\n }\n }\n }\n \n // Use more repetitions for return trip paths\n int reps = calculateOptimalRepetitions(p, bestPath.length());\n if (p >= 0.3) {\n reps = min(200 / (int)bestPath.length(), reps + 1);\n }\n \n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += bestPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n return result;\n }\n }\n \n // Default: use simple repetition with optimized count\n int reps = calculateOptimalRepetitions(p, pathLength);\n string result = \"\";\n for (int i = 0; i < reps; i++) {\n result += shortestPath;\n if (result.length() >= 200) {\n result = result.substr(0, 200);\n break;\n }\n }\n \n return result;\n}\n\n// Enhanced fallback for difficult cases (especially Case 22)\nstring createFallbackPath(int sx, int sy, int tx, int ty,\n const vector& h_walls, \n const vector& v_walls,\n double p) {\n string path = \"\";\n int cx = sx, cy = sy;\n vector> visited(20, vector(20, false));\n visited[cx][cy] = true;\n \n // Phase 1: Use greedy approach with Manhattan distance\n while ((cx != tx || cy != ty) && path.length() < 200) {\n vector> options;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d];\n int ny = cy + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMove = false;\n if (d == 0 && cx > 0 && v_walls[cx-1][cy] == '0') canMove = true;\n else if (d == 1 && cx < 19 && v_walls[cx][cy] == '0') canMove = true;\n else if (d == 2 && cy > 0 && h_walls[cx][cy-1] == '0') canMove = true;\n else if (d == 3 && cy < 19 && h_walls[cx][cy] == '0') canMove = true;\n \n if (canMove) {\n double manhattan = abs(nx - tx) + abs(ny - ty);\n double currentManhattan = abs(cx - tx) + abs(cy - ty);\n double improvement = currentManhattan - manhattan;\n \n // Bonus for moving toward target and unvisited cells\n double score = improvement + (visited[nx][ny] ? 0 : 0.3);\n options.push_back({score, d});\n }\n }\n }\n \n if (options.empty()) break;\n \n // Sort by score (descending)\n sort(options.begin(), options.end(), greater>());\n int bestDir = options[0].second;\n \n path += dir_char[bestDir];\n cx += dx[bestDir];\n cy += dy[bestDir];\n if (isValid(cx, cy)) {\n visited[cx][cy] = true;\n }\n }\n \n // Phase 2: Add multiple oscillations for robustness (targeting Case 22)\n if (p >= 0.25 && path.length() < 180) {\n // Find best oscillation pattern\n vector oscillations;\n \n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d];\n int ny = cy + dy[d];\n \n if (isValid(nx, ny)) {\n bool canMoveOut = false, canMoveBack = false;\n \n if (d == 0 && cx > 0 && v_walls[cx-1][cy] == '0') canMoveOut = true;\n else if (d == 1 && cx < 19 && v_walls[cx][cy] == '0') canMoveOut = true;\n else if (d == 2 && cy > 0 && h_walls[cx][cy-1] == '0') canMoveOut = true;\n else if (d == 3 && cy < 19 && h_walls[cx][cy] == '0') canMoveOut = true;\n \n if (canMoveOut) {\n int backDir = (d + 2) % 4;\n if (backDir == 0 && nx > 0 && v_walls[nx-1][ny] == '0') canMoveBack = true;\n else if (backDir == 1 && nx < 19 && v_walls[nx][ny] == '0') canMoveBack = true;\n else if (backDir == 2 && ny > 0 && h_walls[nx][ny-1] == '0') canMoveBack = true;\n else if (backDir == 3 && ny < 19 && h_walls[nx][ny] == '0') canMoveBack = true;\n \n if (canMoveBack) {\n string oscillation = string(1, dir_char[d]) + string(1, dir_char[backDir]);\n oscillations.push_back(oscillation);\n }\n }\n }\n }\n \n // Add multiple oscillations if available\n if (!oscillations.empty()) {\n string bestOscillation = oscillations[0];\n int remaining = 180 - (int)path.length();\n int oscReps = remaining / 2;\n oscReps = min(oscReps, 15); // More aggressive with oscillations\n \n for (int i = 0; i < oscReps; i++) {\n path += bestOscillation;\n }\n }\n }\n \n // Add repetitions for robustness\n if (p >= 0.3 && path.length() > 0) {\n int maxReps = 200 / max(1, (int)path.length());\n int reps = min(maxReps, p >= 0.4 ? 4 : 3); // More aggressive\n \n if (reps > 1) {\n string repeated = \"\";\n for (int i = 0; i < reps; i++) {\n repeated += path;\n if (repeated.length() >= 200) {\n repeated = repeated.substr(0, 200);\n break;\n }\n }\n return repeated;\n }\n }\n \n return path.substr(0, 200);\n}\n\nint main() {\n int si, sj, ti, tj;\n double p;\n cin >> si >> sj >> ti >> tj >> p;\n \n // Read horizontal walls: 20 rows, each with 19 characters\n vector h_walls(20);\n for (int i = 0; i < 20; i++) {\n cin >> h_walls[i];\n }\n \n // Read vertical walls: 19 rows, each with 20 characters\n vector v_walls(19);\n for (int i = 0; i < 19; i++) {\n cin >> v_walls[i];\n }\n \n // Create robust path\n string finalPath = createRobustPath(si, sj, ti, tj, h_walls, v_walls, p);\n \n // Fallback if needed\n if (finalPath.empty() || finalPath.length() > 200) {\n string shortestPath = findShortestPath(si, sj, ti, tj, h_walls, v_walls);\n \n if (shortestPath.empty()) {\n // Use enhanced fallback (especially for Case 22)\n finalPath = createFallbackPath(si, sj, ti, tj, h_walls, v_walls, p);\n } else {\n // Use more aggressive repetition strategy\n int reps = calculateOptimalRepetitions(p, max(1, (int)shortestPath.length()));\n // Add extra repetition for difficult cases\n if (p >= 0.3 && shortestPath.length() >= 30) {\n int maxPossibleReps = 200 / max(1, (int)shortestPath.length());\n if (reps < maxPossibleReps) {\n reps = min(maxPossibleReps, reps + 1);\n }\n }\n \n finalPath = \"\";\n for (int i = 0; i < reps; i++) {\n finalPath += shortestPath;\n if (finalPath.length() >= 200) {\n finalPath = finalPath.substr(0, 200);\n break;\n }\n }\n }\n }\n \n // Final safety check - ensure we have a valid path\n if (finalPath.empty()) {\n // Create a highly redundant default pattern\n finalPath = \"RULDRLDU\";\n int repetitions = min(25, 200 / 8);\n string temp = \"\";\n for (int i = 0; i < repetitions; i++) {\n temp += finalPath;\n }\n finalPath = temp;\n }\n \n if (finalPath.length() > 200) {\n finalPath = finalPath.substr(0, 200);\n }\n \n cout << finalPath << endl;\n \n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction constants: left, up, right, down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// Transition table: to[tile_type][entry_direction] = exit_direction or -1 if invalid\nconst int to[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1},\n};\n\nconst int N = 30;\n\nclass Solution {\nprivate:\n vector> grid;\n vector> rotations;\n mt19937 rng;\n chrono::steady_clock::time_point start_time;\n \npublic:\n Solution(const vector>& input_grid) : grid(input_grid), rng(random_device{}()) {\n rotations = vector>(N, vector(N, 0));\n }\n \n // Get the actual tile type after rotation\n int get_rotated_tile(int i, int j) const {\n int base_type = grid[i][j];\n int rot = rotations[i][j] % 4;\n \n // Tile mapping after rotation\n if (base_type <= 3) {\n return (base_type + rot) % 4;\n } else if (base_type <= 5) {\n if (base_type == 4) {\n if (rot % 2 == 0) return 4;\n else return 5;\n } else { // base_type == 5\n if (rot % 2 == 0) return 5;\n else return 4;\n }\n } else { // base_type >= 6\n if (base_type == 6) {\n if (rot % 2 == 0) return 6;\n else return 7;\n } else { // base_type == 7\n if (rot % 2 == 0) return 7;\n else return 6;\n }\n }\n }\n \n // Calculate the length of a loop starting from (i, j) with direction d\n int calculate_loop_length(int si, int sj, int sd) const {\n int i = si, j = sj, d = sd;\n int length = 0;\n int max_steps = N * N;\n \n for (int step = 0; step < max_steps; step++) {\n int tile_type = get_rotated_tile(i, j);\n int d2 = to[tile_type][d];\n \n if (d2 == -1) return 0; // Line is broken\n \n i += di[d2];\n j += dj[d2];\n \n if (i < 0 || i >= N || j < 0 || j >= N) return 0; // Out of bounds\n \n d = (d2 + 2) % 4; // Direction to the previous tile\n length++;\n \n // Check if we returned to start\n if (i == si && j == sj && d == sd) {\n return length;\n }\n }\n \n return 0;\n }\n \n // Find all loops and return their lengths\n vector find_all_loops() const {\n vector loop_lengths;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions and directions in this loop as visited\n int ci = i, cj = j, cd = d;\n int steps = 0;\n int max_steps = N * N;\n \n do {\n if (steps >= max_steps) break;\n visited[ci][cj][cd] = true;\n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n if (d2 == -1) break;\n \n ci += di[d2];\n cj += dj[d2];\n \n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n cd = (d2 + 2) % 4;\n steps++;\n } while (!(ci == i && cj == j && cd == d) && steps < max_steps);\n \n loop_lengths.push_back(length);\n }\n }\n }\n \n // Early termination if running out of time\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1850) {\n return loop_lengths;\n }\n }\n \n // Sort in descending order\n sort(loop_lengths.rbegin(), loop_lengths.rend());\n return loop_lengths;\n }\n \n // Calculate score: L1 * L2 (0 if less than 2 loops)\n long long calculate_score() const {\n vector loops = find_all_loops();\n if (loops.size() < 2) return 0;\n return (long long)loops[0] * loops[1];\n }\n \n // Get connectivity score for a tile (how well it connects with neighbors)\n int get_connectivity_score(int i, int j) {\n int score = 0;\n int current_rot = rotations[i][j];\n \n // Try each rotation and calculate connectivity\n for (int r = 0; r < 4; r++) {\n rotations[i][j] = r;\n int local_score = 0;\n \n // Check connections with neighbors\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d];\n int nj = j + dj[d];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n int tile_type = get_rotated_tile(i, j);\n int exit_dir = to[tile_type][d];\n \n if (exit_dir != -1) {\n int opposite_dir = (exit_dir + 2) % 4;\n int neighbor_tile = get_rotated_tile(ni, nj);\n int neighbor_exit = to[neighbor_tile][opposite_dir];\n \n if (neighbor_exit != -1) {\n local_score++;\n }\n }\n }\n }\n \n score = max(score, local_score);\n }\n \n // Restore original rotation\n rotations[i][j] = current_rot;\n return score;\n }\n \n // Get extended connectivity score (including second-level neighbors)\n int get_extended_connectivity_score(int i, int j) {\n int base_score = get_connectivity_score(i, j);\n int extended_score = base_score;\n \n // Add bonus for tiles near the border or center\n if (i == 0 || i == N-1 || j == 0 || j == N-1) {\n extended_score += 2;\n }\n \n int center = N / 2;\n if (abs(i - center) <= 3 && abs(j - center) <= 3) {\n extended_score += 1;\n }\n \n return extended_score;\n }\n \n // Spiral initialization - creates circular patterns\n void spiral_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i < N/2 && j < N/2) { // Top-left\n if (grid[i][j] <= 3) rotations[i][j] = 2; // Curve down-right\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = 0;\n } else if (i < N/2 && j >= N/2) { // Top-right\n if (grid[i][j] <= 3) rotations[i][j] = 3; // Curve down-left\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = 1;\n } else if (i >= N/2 && j < N/2) { // Bottom-left\n if (grid[i][j] <= 3) rotations[i][j] = 1; // Curve up-right\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = 1;\n } else { // Bottom-right\n if (grid[i][j] <= 3) rotations[i][j] = 0; // Curve up-left\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = 0;\n }\n }\n }\n }\n \n // Circular border initialization\n void circular_border_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == 0 && j == 0) rotations[i][j] = 1;\n else if (i == 0 && j == N-1) rotations[i][j] = 2;\n else if (i == N-1 && j == 0) rotations[i][j] = 0;\n else if (i == N-1 && j == N-1) rotations[i][j] = 3;\n else if (i == 0) rotations[i][j] = 1;\n else if (i == N-1) rotations[i][j] = 3;\n else if (j == 0) rotations[i][j] = 0;\n else if (j == N-1) rotations[i][j] = 2;\n else {\n // Interior: simple alternating pattern\n if ((i + j) % 2 == 0) {\n if (grid[i][j] <= 3) rotations[i][j] = 0;\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = 0;\n } else {\n if (grid[i][j] <= 3) rotations[i][j] = 2;\n else if (grid[i][j] <= 5) rotations[i][j] = 0;\n else rotations[i][j] = 1;\n }\n }\n }\n }\n }\n \n // Random initialization\n void random_init() {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n rotations[i][j] = uniform_int_distribution(0, 3)(rng);\n }\n }\n }\n \n // Try to improve solution using enhanced simulated annealing\n void enhanced_simulated_annealing() {\n long long current_score = calculate_score();\n long long best_score_in_run = current_score;\n vector> best_rotations_in_run = rotations;\n \n const double initial_temp = 1000.0;\n const double final_temp = 15.0;\n const double cooling_rate = 0.9995;\n \n double temp = initial_temp;\n int stagnation_count = 0;\n int improvement_count = 0;\n \n // Pre-calculate connectivity scores for all tiles\n vector> connectivity_scores(N, vector(N, 0));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n connectivity_scores[i][j] = get_extended_connectivity_score(i, j);\n }\n }\n \n while (temp > final_temp) {\n // Pick a tile with probability proportional to its connectivity score\n int total_score = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n total_score += connectivity_scores[i][j] + 1; // Add 1 to avoid zero\n }\n }\n \n int target = uniform_int_distribution(0, total_score - 1)(rng);\n int i = 0, j = 0;\n int cum_score = 0;\n \n for (int ti = 0; ti < N; ti++) {\n for (int tj = 0; tj < N; tj++) {\n cum_score += connectivity_scores[ti][tj] + 1;\n if (cum_score > target) {\n i = ti;\n j = tj;\n break;\n }\n }\n if (cum_score > target) break;\n }\n \n // Save current rotation\n int old_rot = rotations[i][j];\n \n // Try a new rotation\n int new_rot;\n double rand_val = uniform_real_distribution(0.0, 1.0)(rng);\n \n if (rand_val < 0.7) {\n // Try incremental change\n new_rot = (old_rot + 1 + uniform_int_distribution(0, 2)(rng)) % 4;\n } else {\n // Try random rotation\n new_rot = uniform_int_distribution(0, 3)(rng);\n }\n \n rotations[i][j] = new_rot;\n \n // Calculate new score\n long long new_score = calculate_score();\n \n // Accept or reject based on simulated annealing\n bool accept = false;\n if (new_score > current_score) {\n accept = true;\n stagnation_count = 0;\n improvement_count++;\n } else if (new_score == current_score) {\n // Accept with some probability to explore\n if (uniform_real_distribution(0.0, 1.0)(rng) < 0.2) {\n accept = true;\n }\n stagnation_count++;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (uniform_real_distribution(0.0, 1.0)(rng) < prob) {\n accept = true;\n stagnation_count++;\n } else {\n stagnation_count++;\n }\n }\n \n if (!accept) {\n // Revert\n rotations[i][j] = old_rot;\n } else {\n current_score = new_score;\n if (current_score > best_score_in_run) {\n best_score_in_run = current_score;\n best_rotations_in_run = rotations;\n stagnation_count = 0;\n improvement_count = 0;\n }\n }\n \n // Adaptive cooling\n if (stagnation_count > 30) {\n temp *= 0.94;\n stagnation_count = 0;\n } else if (improvement_count > 15) {\n temp *= 0.9997;\n improvement_count = 0;\n } else {\n temp *= cooling_rate;\n }\n \n // Check time limit\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > 1940) {\n break;\n }\n }\n \n // Restore the best solution found in this run\n if (best_score_in_run > current_score) {\n rotations = best_rotations_in_run;\n }\n }\n \n // Loop extension phase - try to extend existing loops\n void loop_extension_phase() {\n long long current_score = calculate_score();\n vector loops = find_all_loops();\n \n if (loops.size() < 1) {\n return; // No loops to extend\n }\n \n // Get all tiles that are part of loops\n vector> loop_tiles;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions in this loop and add tiles to our list\n int ci = i, cj = j, cd = d;\n int steps = 0;\n int max_steps = N * N;\n \n do {\n if (steps >= max_steps) break;\n visited[ci][cj][cd] = true;\n loop_tiles.push_back({ci, cj});\n \n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n if (d2 == -1) break;\n \n ci += di[d2];\n cj += dj[d2];\n \n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n cd = (d2 + 2) % 4;\n steps++;\n } while (!(ci == i && cj == j && cd == d) && steps < max_steps);\n }\n }\n }\n }\n \n // Remove duplicates\n sort(loop_tiles.begin(), loop_tiles.end());\n auto last = unique(loop_tiles.begin(), loop_tiles.end());\n loop_tiles.erase(last, loop_tiles.end());\n \n // For each loop tile, try to modify its neighbors to extend the loop\n vector> extension_candidates;\n for (const auto& tile : loop_tiles) {\n int i = tile.first;\n int j = tile.second;\n \n // Add neighboring tiles\n for (int d = 0; d < 4; d++) {\n int ni = i + di[d];\n int nj = j + dj[d];\n \n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n extension_candidates.push_back({ni, nj});\n }\n }\n }\n \n // Remove duplicates\n sort(extension_candidates.begin(), extension_candidates.end());\n last = unique(extension_candidates.begin(), extension_candidates.end());\n extension_candidates.erase(last, extension_candidates.end());\n \n // Shuffle extension candidates\n shuffle(extension_candidates.begin(), extension_candidates.end(), rng);\n \n // Try to improve extension candidates\n int max_attempts = min(150, (int)extension_candidates.size());\n for (int attempt = 0; attempt < max_attempts; attempt++) {\n int i = extension_candidates[attempt].first;\n int j = extension_candidates[attempt].second;\n \n int old_rot = rotations[i][j];\n int best_rot = old_rot;\n long long best_local_score = current_score;\n \n // Try all rotations for this tile\n for (int r = 0; r < 4; r++) {\n if (r == old_rot) continue;\n \n rotations[i][j] = r;\n long long score = calculate_score();\n \n if (score > best_local_score) {\n best_local_score = score;\n best_rot = r;\n }\n }\n \n rotations[i][j] = best_rot;\n current_score = calculate_score();\n \n // Check time\n auto now = chrono::steady_clock::now();\n auto ms = chrono::duration_cast(now - start_time).count();\n if (ms > 1970) break;\n }\n }\n \n // Loop-based local search - focus on tiles that are part of loops\n void loop_based_local_search() {\n long long current_score = calculate_score();\n vector loops = find_all_loops();\n \n if (loops.size() < 1) {\n return; // No loops to work with\n }\n \n // Get all tiles that are part of loops\n vector> loop_tiles;\n vector>> visited(N, vector>(N, vector(4, false)));\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n for (int d = 0; d < 4; d++) {\n if (visited[i][j][d]) continue;\n \n int length = calculate_loop_length(i, j, d);\n if (length > 0) {\n // Mark all positions in this loop and add tiles to our list\n int ci = i, cj = j, cd = d;\n int steps = 0;\n int max_steps = N * N;\n \n do {\n if (steps >= max_steps) break;\n visited[ci][cj][cd] = true;\n loop_tiles.push_back({ci, cj});\n \n int tile_type = get_rotated_tile(ci, cj);\n int d2 = to[tile_type][cd];\n \n if (d2 == -1) break;\n \n ci += di[d2];\n cj += dj[d2];\n \n if (ci < 0 || ci >= N || cj < 0 || cj >= N) break;\n \n cd = (d2 + 2) % 4;\n steps++;\n } while (!(ci == i && cj == j && cd == d) && steps < max_steps);\n }\n }\n }\n }\n \n // Remove duplicates\n sort(loop_tiles.begin(), loop_tiles.end());\n auto last = unique(loop_tiles.begin(), loop_tiles.end());\n loop_tiles.erase(last, loop_tiles.end());\n \n // Shuffle loop tiles\n shuffle(loop_tiles.begin(), loop_tiles.end(), rng);\n \n // Try to improve tiles in loops\n int max_attempts = min(200, (int)loop_tiles.size());\n for (int attempt = 0; attempt < max_attempts; attempt++) {\n int i = loop_tiles[attempt].first;\n int j = loop_tiles[attempt].second;\n \n int old_rot = rotations[i][j];\n int best_rot = old_rot;\n long long best_local_score = current_score;\n \n // Try all rotations for this tile\n for (int r = 0; r < 4; r++) {\n if (r == old_rot) continue;\n \n rotations[i][j] = r;\n long long score = calculate_score();\n \n if (score > best_local_score) {\n best_local_score = score;\n best_rot = r;\n }\n }\n \n rotations[i][j] = best_rot;\n current_score = calculate_score();\n \n // Check time\n auto now = chrono::steady_clock::now();\n auto ms = chrono::duration_cast(now - start_time).count();\n if (ms > 1970) break;\n }\n }\n \n // Improved local search - broader coverage with connectivity prioritization\n void improved_local_search() {\n long long current_score = calculate_score();\n \n // Create list of tiles to try with prioritization\n vector> tiles_to_try;\n \n // Add border tiles\n for (int i = 0; i < N; i++) {\n tiles_to_try.push_back({i, 0});\n tiles_to_try.push_back({i, N-1});\n }\n for (int j = 1; j < N-1; j++) {\n tiles_to_try.push_back({0, j});\n tiles_to_try.push_back({N-1, j});\n }\n \n // Add center region tiles\n int center = N / 2;\n for (int i = center - 5; i <= center + 5; i++) {\n for (int j = center - 5; j <= center + 5; j++) {\n if (i >= 0 && i < N && j >= 0 && j < N) {\n tiles_to_try.push_back({i, j});\n }\n }\n }\n \n // Add tiles in a grid pattern\n for (int i = 3; i < N; i += 4) {\n for (int j = 3; j < N; j += 4) {\n tiles_to_try.push_back({i, j});\n }\n }\n \n // Add tiles with high connectivity potential\n vector> connectivity_tiles;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int conn_score = get_extended_connectivity_score(i, j);\n if (conn_score >= 3) { // High connectivity potential\n connectivity_tiles.push_back({i, j});\n }\n }\n }\n \n // Add some of the high connectivity tiles\n shuffle(connectivity_tiles.begin(), connectivity_tiles.end(), rng);\n int conn_to_add = min(100, (int)connectivity_tiles.size());\n for (int i = 0; i < conn_to_add; i++) {\n tiles_to_try.push_back(connectivity_tiles[i]);\n }\n \n // Add random tiles\n for (int i = 0; i < 100; i++) {\n tiles_to_try.push_back({\n uniform_int_distribution(0, N-1)(rng),\n uniform_int_distribution(0, N-1)(rng)\n });\n }\n \n // Remove duplicates\n sort(tiles_to_try.begin(), tiles_to_try.end());\n auto last = unique(tiles_to_try.begin(), tiles_to_try.end());\n tiles_to_try.erase(last, tiles_to_try.end());\n \n // Shuffle tiles\n shuffle(tiles_to_try.begin(), tiles_to_try.end(), rng);\n \n // Try to improve tiles\n int max_attempts = min(300, (int)tiles_to_try.size());\n for (int attempt = 0; attempt < max_attempts; attempt++) {\n int i = tiles_to_try[attempt].first;\n int j = tiles_to_try[attempt].second;\n \n int old_rot = rotations[i][j];\n int best_rot = old_rot;\n long long best_local_score = current_score;\n \n // Try all rotations for this tile\n for (int r = 0; r < 4; r++) {\n if (r == old_rot) continue;\n \n rotations[i][j] = r;\n long long score = calculate_score();\n \n if (score > best_local_score) {\n best_local_score = score;\n best_rot = r;\n }\n }\n \n rotations[i][j] = best_rot;\n current_score = calculate_score();\n \n // Check time\n auto now = chrono::steady_clock::now();\n auto ms = chrono::duration_cast(now - start_time).count();\n if (ms > 1960) break;\n }\n }\n \n // Conservative final improvement - only make changes that improve score\n void conservative_improvement() {\n long long current_score = calculate_score();\n \n // First, try loop extension\n loop_extension_phase();\n long long new_score = calculate_score();\n \n if (new_score > current_score) {\n current_score = new_score;\n }\n \n // Then, try loop-based local search\n loop_based_local_search();\n new_score = calculate_score();\n \n if (new_score > current_score) {\n current_score = new_score;\n }\n \n // If we have a very good score, be extra conservative\n bool very_good_score = current_score > 200;\n \n // Try random tiles, but be more conservative\n int max_attempts = very_good_score ? 50 : 100;\n \n for (int attempt = 0; attempt < max_attempts; attempt++) {\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n \n int old_rot = rotations[i][j];\n int best_rot = old_rot;\n long long best_local_score = current_score;\n \n // Try all rotations for this tile\n for (int r = 0; r < 4; r++) {\n if (r == old_rot) continue;\n \n rotations[i][j] = r;\n long long score = calculate_score();\n \n if (score > best_local_score) {\n best_local_score = score;\n best_rot = r;\n }\n }\n \n // Only update if we found an improvement\n if (best_rot != old_rot) {\n rotations[i][j] = best_rot;\n current_score = calculate_score();\n } else {\n rotations[i][j] = old_rot;\n }\n \n // Check time\n auto now = chrono::steady_clock::now();\n auto ms = chrono::duration_cast(now - start_time).count();\n if (ms > 1990) break;\n }\n }\n \n // Optimize with refined approach\n void optimize() {\n start_time = chrono::steady_clock::now();\n long long best_score = 0;\n vector> best_rotations = rotations;\n \n // Strategy 1: Spiral initialization\n spiral_init();\n auto strategy_start = chrono::steady_clock::now();\n enhanced_simulated_annealing();\n long long score = calculate_score();\n \n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n \n // Strategy 2: Circular border initialization\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n // Try strategy 2 if we have enough time\n if (elapsed_ms < 1000) {\n circular_border_init();\n enhanced_simulated_annealing();\n score = calculate_score();\n \n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n // Strategy 3: Random initialization\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n // Try random initialization if time permits\n if (elapsed_ms < 1500) {\n random_init();\n enhanced_simulated_annealing();\n score = calculate_score();\n \n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n // Final refinement: improved local search\n rotations = best_rotations;\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1700) {\n improved_local_search();\n score = calculate_score();\n \n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n // Loop extension phase\n rotations = best_rotations;\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1850) {\n loop_extension_phase();\n score = calculate_score();\n \n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n // Conservative final improvement\n rotations = best_rotations;\n current_time = chrono::steady_clock::now();\n elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms < 1950) {\n conservative_improvement();\n score = calculate_score();\n \n if (score > best_score) {\n best_score = score;\n best_rotations = rotations;\n }\n }\n \n rotations = best_rotations;\n }\n \n // Output the solution\n string get_output() {\n string result = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n result += char('0' + rotations[i][j]);\n }\n }\n return result;\n }\n};\n\nint main() {\n // Read input\n vector> grid(N, vector(N));\n for (int i = 0; i < N; i++) {\n string line;\n cin >> line;\n for (int j = 0; j < N; j++) {\n grid[i][j] = line[j] - '0';\n }\n }\n \n // Create and optimize solution\n Solution solution(grid);\n solution.optimize();\n \n // Output result\n cout << solution.get_output() << endl;\n \n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Directions: U, D, L, R\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'U', 'D', 'L', 'R'};\nconst int opposite_dir[4] = {1, 0, 3, 2}; // Opposite of U,D,L,R\n\nstruct State {\n vector board;\n int empty_x, empty_y;\n string moves;\n int score;\n int potential_score;\n \n // Default constructor\n State() : empty_x(-1), empty_y(-1), score(0), potential_score(0) {}\n \n // Parameterized constructor\n State(const vector& b, int ex, int ey, const string& m = \"\") \n : board(b), empty_x(ex), empty_y(ey), moves(m) {\n calculateScores();\n }\n \n void calculateScores() {\n if (board.empty() || empty_x == -1) {\n score = 0;\n potential_score = 0;\n return;\n }\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n int total_potential = 0;\n \n // Calculate actual connected components\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n // Calculate potential connections (heuristic)\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0') continue;\n \n int tile_val = (board[i][j] >= 'a') ? (board[i][j] - 'a' + 10) : (board[i][j] - '0');\n \n // Potential down connection\n if ((tile_val & 8) && i + 1 < n && board[i+1][j] != '0') {\n int below_val = (board[i+1][j] >= 'a') ? (board[i+1][j] - 'a' + 10) : (board[i+1][j] - '0');\n if (below_val & 2) {\n total_potential++;\n }\n }\n \n // Potential right connection\n if ((tile_val & 4) && j + 1 < n && board[i][j+1] != '0') {\n int right_val = (board[i][j+1] >= 'a') ? (board[i][j+1] - 'a' + 10) : (board[i][j+1] - '0');\n if (right_val & 1) {\n total_potential++;\n }\n }\n }\n }\n \n score = max_component_size;\n potential_score = total_potential;\n }\n \n // Composite score for sorting\n long long getCompositeScore() const {\n // Focus on actual score first, then potential, then shorter paths\n return (long long)score * 1000000000LL + \n (long long)potential_score * 1000000LL - \n (long long)moves.size();\n }\n \n // Board hash for duplicate detection\n string getBoardHash() const {\n string hash = \"\";\n for (const auto& row : board) {\n hash += row;\n }\n return hash;\n }\n \n // Equality operator for State\n bool operator==(const State& other) const {\n if (board != other.board) return false;\n if (empty_x != other.empty_x) return false;\n if (empty_y != other.empty_y) return false;\n return true;\n }\n};\n\n// Calculate the score of a board configuration\nint calculateScore(const vector& board) {\n if (board.empty()) return 0;\n \n int n = board.size();\n vector> visited(n, vector(n, false));\n int max_component_size = 0;\n \n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (board[i][j] == '0' || visited[i][j]) continue;\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n int component_size = 1;\n \n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n int tile_val = (board[x][y] >= 'a') ? (board[x][y] - 'a' + 10) : (board[x][y] - '0');\n \n // Check down\n if ((tile_val & 8) && x + 1 < n && board[x+1][y] != '0') {\n int below_val = (board[x+1][y] >= 'a') ? (board[x+1][y] - 'a' + 10) : (board[x+1][y] - '0');\n if ((below_val & 2) && !visited[x+1][y]) {\n visited[x+1][y] = true;\n q.push({x+1, y});\n component_size++;\n }\n }\n \n // Check right\n if ((tile_val & 4) && y + 1 < n && board[x][y+1] != '0') {\n int right_val = (board[x][y+1] >= 'a') ? (board[x][y+1] - 'a' + 10) : (board[x][y+1] - '0');\n if ((right_val & 1) && !visited[x][y+1]) {\n visited[x][y+1] = true;\n q.push({x, y+1});\n component_size++;\n }\n }\n }\n \n max_component_size = max(max_component_size, component_size);\n }\n }\n \n return max_component_size;\n}\n\n// Check if a move is valid\nbool isValidMove(int x, int y, int n) {\n return x >= 0 && x < n && y >= 0 && y < n;\n}\n\n// Simple greedy fallback\nstring simpleGreedyFallback(const vector& initial_board, int N, int T) {\n int empty_x = -1, empty_y = -1;\n \n // Find the empty space\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_board[i][j] == '0') {\n empty_x = i;\n empty_y = j;\n break;\n }\n }\n if (empty_x != -1) break;\n }\n \n vector board = initial_board;\n string moves = \"\";\n \n for (int step = 0; step < T; step++) {\n int best_dir = -1;\n int best_score = calculateScore(board);\n \n // Try all possible moves\n for (int dir = 0; dir < 4; dir++) {\n int new_x = empty_x + dx[dir];\n int new_y = empty_y + dy[dir];\n \n if (!isValidMove(new_x, new_y, N)) continue;\n if (moves.size() > 0 && dir == opposite_dir[moves.back() - 'U']) continue;\n \n // Make a copy and apply the move\n vector new_board = board;\n int new_empty_x = empty_x;\n int new_empty_y = empty_y;\n \n swap(new_board[new_empty_x][new_empty_y], new_board[new_x][new_y]);\n int new_score = calculateScore(new_board);\n \n if (new_score > best_score) {\n best_score = new_score;\n best_dir = dir;\n }\n }\n \n // If no improving move, take first valid move\n if (best_dir == -1) {\n for (int dir = 0; dir < 4; dir++) {\n int new_x = empty_x + dx[dir];\n int new_y = empty_y + dy[dir];\n \n if (!isValidMove(new_x, new_y, N)) continue;\n if (moves.size() > 0 && dir == opposite_dir[moves.back() - 'U']) continue;\n \n best_dir = dir;\n break;\n }\n }\n \n if (best_dir == -1) break; // No valid moves\n \n // Apply the best move\n int new_x = empty_x + dx[best_dir];\n int new_y = empty_y + dy[best_dir];\n swap(board[empty_x][empty_y], board[new_x][new_y]);\n empty_x = new_x;\n empty_y = new_y;\n moves += dir_char[best_dir];\n \n // Check if we found a perfect solution\n if (best_score == N*N-1) {\n break;\n }\n }\n \n return moves;\n}\n\n// Main solve function - back to proven beam search approach\nstring solve(const vector& initial_board, int N, int T) {\n int empty_x = -1, empty_y = -1;\n \n // Find the empty space\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_board[i][j] == '0') {\n empty_x = i;\n empty_y = j;\n break;\n }\n }\n if (empty_x != -1) break;\n }\n \n // If we're already at max score, return empty string\n int current_score = calculateScore(initial_board);\n if (current_score == N*N-1) {\n return \"\";\n }\n \n // Calculate beam width based on N\n size_t BEAM_WIDTH = 0;\n if (N <= 7) {\n BEAM_WIDTH = 200;\n } else if (N <= 9) {\n BEAM_WIDTH = 150;\n } else {\n BEAM_WIDTH = 100;\n }\n \n // Track best solution found so far\n string best_solution = \"\";\n int best_score = current_score;\n \n // Use multiple attempts with different random seeds\n const int MAX_ATTEMPTS = 2;\n auto start_time = chrono::steady_clock::now();\n const int time_limit_ms = 2800;\n \n for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {\n // Reset beam for this attempt\n vector beam;\n beam.reserve(BEAM_WIDTH);\n beam.push_back(State(initial_board, empty_x, empty_y, \"\"));\n \n // Track if we're making progress\n int last_improvement_step = 0;\n size_t current_beam_width = BEAM_WIDTH;\n \n // Try to find a good solution within T moves\n for (int step = 0; step < T && !beam.empty(); step++) {\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n \n // Check time limit\n if (elapsed_ms > time_limit_ms) {\n break;\n }\n \n // Reserve appropriate size\n size_t reserve_size = min(current_beam_width * 3, static_cast(500));\n vector next_beam;\n next_beam.reserve(reserve_size);\n \n // Track seen states to avoid duplicates\n unordered_set seen_states;\n \n for (auto& state : beam) {\n // Try all possible moves\n for (int dir = 0; dir < 4; dir++) {\n int new_x = state.empty_x + dx[dir];\n int new_y = state.empty_y + dy[dir];\n \n // Skip if move is invalid\n if (!isValidMove(new_x, new_y, N)) continue;\n \n // Skip if would undo previous move (anti-loop)\n if (state.moves.size() > 0 && \n dir == opposite_dir[state.moves.back() - 'U']) continue;\n \n // Make a copy and apply the move\n vector new_board = state.board;\n int new_empty_x = state.empty_x;\n int new_empty_y = state.empty_y;\n string new_moves = state.moves + dir_char[dir];\n \n // Apply the move\n swap(new_board[new_empty_x][new_empty_y], new_board[new_x][new_y]);\n new_empty_x = new_x;\n new_empty_y = new_y;\n \n // Create new state\n State new_state(new_board, new_empty_x, new_empty_y, new_moves);\n \n // If we found a full tree, return immediately\n if (new_state.score == N*N-1) {\n return new_state.moves;\n }\n \n // Update best solution if this is better\n if (new_state.score > best_score) {\n best_score = new_state.score;\n best_solution = new_state.moves;\n last_improvement_step = step;\n }\n \n // Check for duplicates\n string board_hash = new_state.getBoardHash();\n if (seen_states.find(board_hash) == seen_states.end()) {\n seen_states.insert(board_hash);\n next_beam.push_back(new_state);\n }\n }\n }\n \n // If no new states, break\n if (next_beam.empty()) break;\n \n // Sort by composite score (descending)\n sort(next_beam.begin(), next_beam.end(), [](const State& a, const State& b) {\n return a.getCompositeScore() > b.getCompositeScore();\n });\n \n // Keep only the best states with diversity\n if (next_beam.size() > current_beam_width) {\n size_t keep_by_score = static_cast(current_beam_width * 0.7);\n vector selected_beam;\n \n for (size_t i = 0; i < keep_by_score && i < next_beam.size(); i++) {\n selected_beam.push_back(next_beam[i]);\n }\n \n // Add diverse states\n if (selected_beam.size() < current_beam_width && next_beam.size() > keep_by_score) {\n random_device rd;\n mt19937 gen(rd() + attempt * 1000); // Different seed for each attempt\n vector remaining_indices;\n \n for (size_t i = keep_by_score; i < next_beam.size(); i++) {\n remaining_indices.push_back(i);\n }\n \n // Shuffle remaining indices\n shuffle(remaining_indices.begin(), remaining_indices.end(), gen);\n \n // Add diverse states\n for (size_t i = 0; i < remaining_indices.size() && selected_beam.size() < current_beam_width; i++) {\n // Add with a probability based on potential score\n double selection_prob = 0.6 + (double)next_beam[remaining_indices[i]].potential_score / (N * N * 3);\n if (uniform_real_distribution(0, 1)(gen) < selection_prob) {\n selected_beam.push_back(next_beam[remaining_indices[i]]);\n }\n if (selected_beam.size() >= current_beam_width) break;\n }\n \n // If still not enough, fill with best remaining\n for (size_t i = 0; i < remaining_indices.size() && selected_beam.size() < current_beam_width; i++) {\n selected_beam.push_back(next_beam[remaining_indices[i]]);\n if (selected_beam.size() >= current_beam_width) break;\n }\n \n next_beam = selected_beam;\n } else {\n next_beam.resize(current_beam_width);\n }\n }\n \n // Adaptive beam width based on progress\n if (step - last_improvement_step > 15) {\n // Increase exploration if stuck\n current_beam_width = min(static_cast(250), current_beam_width + 20);\n } else if (best_score > N*N*0.8) {\n // Focus on refinement if we have a good solution\n current_beam_width = min(current_beam_width, static_cast(50));\n }\n \n // Periodic forced exploration every 10 steps\n if (step > 0 && step % 10 == 0 && next_beam.size() > 10) {\n random_device rd;\n mt19937 gen(rd() + step * 100 + attempt * 1000);\n \n // Randomly shuffle a few states to encourage exploration\n size_t shuffle_count = min(static_cast(5), next_beam.size() / 5);\n for (size_t i = 0; i < shuffle_count; i++) {\n size_t idx1 = uniform_int_distribution(0, next_beam.size() - 1)(gen);\n size_t idx2 = uniform_int_distribution(0, next_beam.size() - 1)(gen);\n if (idx1 != idx2) {\n swap(next_beam[idx1], next_beam[idx2]);\n }\n }\n }\n \n beam = next_beam;\n \n // Early termination if we have an excellent solution\n if (best_score == N*N-1) {\n return best_solution;\n }\n }\n \n // If we found a perfect solution in this attempt, return it\n if (best_score == N*N-1) {\n return best_solution;\n }\n \n // If time is running out, don't start another attempt\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if (elapsed_ms > time_limit_ms * 0.8 && attempt < MAX_ATTEMPTS - 1) {\n // Reduce beam width for remaining attempts\n BEAM_WIDTH = max(static_cast(50), BEAM_WIDTH / 2);\n }\n }\n \n // Fallback to simple greedy if we have a very poor solution\n auto current_time = chrono::steady_clock::now();\n auto elapsed_ms = chrono::duration_cast(current_time - start_time).count();\n if ((best_score < N*N*0.3 || best_solution.empty()) && elapsed_ms < time_limit_ms * 0.95) {\n string greedy_result = simpleGreedyFallback(initial_board, N, T);\n int greedy_score = 0;\n \n // Calculate score of greedy result\n vector test_board = initial_board;\n int ex = empty_x, ey = empty_y;\n for (char move : greedy_result) {\n int dir = (move == 'U') ? 0 : (move == 'D') ? 1 : (move == 'L') ? 2 : 3;\n int new_x = ex + dx[dir];\n int new_y = ey + dy[dir];\n swap(test_board[ex][ey], test_board[new_x][new_y]);\n ex = new_x;\n ey = new_y;\n }\n greedy_score = calculateScore(test_board);\n \n // Use greedy result if it's better\n if (greedy_score > best_score) {\n best_solution = greedy_result;\n }\n }\n \n // Return the best solution found\n return best_solution;\n}\n\nint main() {\n int N, T;\n cin >> N >> T;\n \n vector board(N);\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n string solution = solve(board, N, T);\n cout << solution << endl;\n \n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace atcoder;\n\nstruct Point {\n long long x, y;\n Point() : x(0), y(0) {}\n Point(long long x, long long y) : x(x), y(y) {}\n \n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n \n long long cross(const Point& other) const {\n return x * other.y - y * other.x;\n }\n \n long long dot(const Point& other) const {\n return x * other.x + y * other.y;\n }\n \n long long dist2() const {\n return x * x + y * y;\n }\n \n double dist() const {\n return sqrt(x * x + y * y);\n }\n};\n\nstruct Line {\n Point p1, p2;\n Line() {}\n Line(Point p1, Point p2) : p1(p1), p2(p2) {}\n};\n\n// Ensure point coordinates are within bounds\nPoint clampPoint(Point p) {\n const long long MIN_VAL = -1000000000;\n const long long MAX_VAL = 1000000000;\n p.x = max(MIN_VAL, min(MAX_VAL, p.x));\n p.y = max(MIN_VAL, min(MAX_VAL, p.y));\n return p;\n}\n\n// Check which side of the line a point is on\n// Returns: 1 if on one side, -1 if on the other, 0 if on the line\nint side(const Point& p, const Line& line) {\n Point v1 = line.p2 - line.p1;\n Point v2 = p - line.p1;\n long long cross = v1.cross(v2);\n if (cross > 0) return 1;\n if (cross < 0) return -1;\n return 0;\n}\n\n// Check if a point is strictly inside a region defined by lines\n// Each line defines a half-plane, and we need to be on the correct side of all lines\nbool isInside(const Point& p, const vector& lines, const vector& sides) {\n for (int i = 0; i < lines.size(); i++) {\n int s = side(p, lines[i]);\n if (s != sides[i]) return false;\n }\n return true;\n}\n\n// Try to find a line that separates a group of strawberries from others\nLine findSeparatingLine(const vector& strawberries, const vector& group, const vector& existingLines) {\n // Simple approach: try to find a line that roughly separates the group from others\n if (group.size() == 0) {\n return Line(Point(0, 0), Point(1, 0));\n }\n \n // Calculate centroid of group\n Point centroid(0, 0);\n for (int i : group) {\n centroid.x += strawberries[i].x;\n centroid.y += strawberries[i].y;\n }\n centroid.x /= group.size();\n centroid.y /= group.size();\n \n // Calculate centroid of other strawberries\n vector others;\n for (int i = 0; i < strawberries.size(); i++) {\n if (find(group.begin(), group.end(), i) == group.end()) {\n others.push_back(i);\n }\n }\n \n if (others.empty()) {\n // If no others, just use a line near the group\n Point p1(centroid.x - 1, centroid.y - 1);\n Point p2(centroid.x + 1, centroid.y + 1);\n return Line(clampPoint(p1), clampPoint(p2));\n }\n \n Point otherCentroid(0, 0);\n for (int i : others) {\n otherCentroid.x += strawberries[i].x;\n otherCentroid.y += strawberries[i].y;\n }\n otherCentroid.x /= others.size();\n otherCentroid.y /= others.size();\n \n // Line perpendicular to the line connecting centroids\n Point dir = otherCentroid - centroid;\n Point perp(-dir.y, dir.x);\n \n // Make sure the points are integers and within bounds\n Point p1(centroid.x + perp.x, centroid.y + perp.y);\n Point p2(centroid.x - perp.x, centroid.y - perp.y);\n \n // Scale to make sure they're far enough apart but still within bounds\n if (p1.dist2() < 100) {\n // Scale but ensure we don't go out of bounds\n long long scale = 1000;\n // Check if scaling would exceed bounds\n if (abs(p1.x * scale) > 1000000000 || abs(p1.y * scale) > 1000000000) {\n scale = 1;\n }\n p1.x *= scale;\n p1.y *= scale;\n p2.x *= scale;\n p2.y *= scale;\n }\n \n // Ensure bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n return Line(p1, p2);\n}\n\n// Calculate distance between two points\ndouble distance(const Point& a, const Point& b) {\n return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));\n}\n\n// Try to improve a line to minimize strawberries on it\nLine improveLine(const Line& line, const vector& strawberries, const vector& otherLines) {\n Line bestLine = line;\n int bestOnLine = strawberries.size();\n \n // Try small perturbations within bounds\n for (int dx1 = -1; dx1 <= 1; dx1++) {\n for (int dy1 = -1; dy1 <= 1; dy1++) {\n for (int dx2 = -1; dx2 <= 1; dx2++) {\n for (int dy2 = -1; dy2 <= 1; dy2++) {\n Point newP1(line.p1.x + dx1, line.p1.y + dy1);\n Point newP2(line.p2.x + dx2, line.p2.y + dy2);\n \n // Clamp to bounds\n newP1 = clampPoint(newP1);\n newP2 = clampPoint(newP2);\n \n // Skip if points are the same\n if (newP1.x == newP2.x && newP1.y == newP2.y) {\n // Make them different\n if (newP2.x < 1000000000) newP2.x += 1;\n else if (newP2.x > -1000000000) newP2.x -= 1;\n else if (newP2.y < 1000000000) newP2.y += 1;\n else newP2.y -= 1;\n }\n \n Line newLine(newP1, newP2);\n \n // Calculate score: minimize strawberries on line\n int onLine = 0;\n for (const Point& s : strawberries) {\n if (side(s, newLine) == 0) {\n onLine++;\n }\n }\n \n // Prefer lines with fewer strawberries on them\n if (onLine < bestOnLine) {\n bestOnLine = onLine;\n bestLine = newLine;\n }\n }\n }\n }\n }\n \n return bestLine;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, K;\n cin >> N >> K;\n \n vector a(10);\n for (int i = 0; i < 10; i++) {\n cin >> a[i];\n }\n \n vector strawberries(N);\n for (int i = 0; i < N; i++) {\n cin >> strawberries[i].x >> strawberries[i].y;\n }\n \n // We'll use a greedy approach to create pieces of desired sizes\n vector lines;\n vector used(N, false);\n \n // First, try to create single strawberry pieces\n for (int d = 0; d < 10; d++) {\n if (a[d] == 0) continue;\n \n // Target: create a[d] pieces with d+1 strawberries each\n int targetCount = a[d];\n int strawberriesPerPiece = d + 1;\n \n for (int piece = 0; piece < targetCount && lines.size() < K; piece++) {\n // Find a group of strawberriesPerPiece strawberries that are close to each other\n vector group;\n \n // Find unused strawberries\n vector unused;\n for (int i = 0; i < N; i++) {\n if (!used[i]) {\n unused.push_back(i);\n }\n }\n \n if (unused.size() < strawberriesPerPiece) {\n // Not enough unused strawberries, skip\n break;\n }\n \n // Use a simple greedy approach: pick the first available strawberries\n for (int i = 0; i < strawberriesPerPiece && i < unused.size(); i++) {\n group.push_back(unused[i]);\n used[unused[i]] = true;\n }\n \n // If we need to isolate this group, add a line\n if (strawberriesPerPiece < N && !group.empty()) {\n // Find a line that separates this group from others (if possible)\n Line separatingLine = findSeparatingLine(strawberries, group, lines);\n \n // Try to improve the line to avoid cutting through strawberries\n separatingLine = improveLine(separatingLine, strawberries, lines);\n \n lines.push_back(separatingLine);\n \n // Stop if we've reached the limit\n if (lines.size() >= K) break;\n }\n }\n }\n \n // If we have remaining cuts, try to add random lines that might improve the partition\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution dis(-1000000000, 1000000000);\n \n while (lines.size() < K) {\n // Generate a random line\n Point p1(dis(gen), dis(gen));\n Point p2(dis(gen), dis(gen));\n \n // Clamp to ensure within bounds\n p1 = clampPoint(p1);\n p2 = clampPoint(p2);\n \n // Ensure p1 and p2 are different\n if (p1.x == p2.x && p1.y == p2.y) {\n if (p2.x < 1000000000) p2.x += 1;\n else p2.x -= 1;\n }\n \n Line line(p1, p2);\n \n // Improve the line\n line = improveLine(line, strawberries, lines);\n \n lines.push_back(line);\n }\n \n // Output the solution\n cout << lines.size() << \"\\n\";\n for (const Line& line : lines) {\n cout << line.p1.x << \" \" << line.p1.y << \" \" << line.p2.x << \" \" << line.p2.y << \"\\n\";\n }\n \n return 0;\n}","ahc014":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n \n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n \n bool operator!=(const Point& other) const {\n return !(*this == other);\n }\n \n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n};\n\nclass RectJoinSolver {\nprivate:\n int N, M;\n int center;\n vector> hasDot;\n vector> hasHorizontalEdge; // hasHorizontalEdge[x][y] = true if edge from (x,y) to (x+1,y) exists\n vector> hasVerticalEdge; // hasVerticalEdge[x][y] = true if edge from (x,y) to (x,y+1) exists\n vector initialDots;\n vector> operations;\n \n high_resolution_clock::time_point startTime;\n const double timeLimit = 4.0;\n \n // Calculate weight of a point\n double getWeight(int x, int y) {\n return (x - center) * (x - center) + (y - center) * (y - center) + 1;\n }\n \n // Check if point is on the grid\n bool isValidPoint(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n \n // Check if we're running out of time\n bool isTimeExceeded() {\n auto currentTime = high_resolution_clock::now();\n auto duration = duration_cast(currentTime - startTime);\n return duration.count() > timeLimit * 1000;\n }\n \n // Get all points on a horizontal edge from (x1,y) to (x2,y)\n vector getHorizontalEdgePoints(int x1, int x2, int y) {\n vector points;\n int minX = min(x1, x2);\n int maxX = max(x1, x2);\n for (int x = minX; x <= maxX; x++) {\n points.push_back(Point(x, y));\n }\n return points;\n }\n \n // Get all points on a vertical edge from (x,y1) to (x,y2)\n vector getVerticalEdgePoints(int x, int y1, int y2) {\n vector points;\n int minY = min(y1, y2);\n int maxY = max(y1, y2);\n for (int y = minY; y <= maxY; y++) {\n points.push_back(Point(x, y));\n }\n return points;\n }\n \n // Check if the four points form a valid axis-aligned rectangle when connected in order\n bool isValidAxisAlignedRectangleInOrder(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n // Check if consecutive points form right angles and parallel sides\n \n // Check p1->p2->p3 forms a right angle\n bool p1p2_horizontal = (p1.y == p2.y);\n bool p1p2_vertical = (p1.x == p2.x);\n bool p2p3_horizontal = (p2.y == p3.y);\n bool p2p3_vertical = (p2.x == p3.x);\n \n // Must be axis-aligned\n if (!p1p2_horizontal && !p1p2_vertical) return false;\n if (!p2p3_horizontal && !p2p3_vertical) return false;\n \n // Must form a right angle (perpendicular)\n if ((p1p2_horizontal && !p2p3_vertical) || (p1p2_vertical && !p2p3_horizontal)) {\n return false;\n }\n \n // Check p2->p3->p4 forms a right angle\n bool p3p4_horizontal = (p3.y == p4.y);\n bool p3p4_vertical = (p3.x == p4.x);\n \n if (!p3p4_horizontal && !p3p4_vertical) return false;\n \n if ((p2p3_horizontal && !p3p4_vertical) || (p2p3_vertical && !p3p4_horizontal)) {\n return false;\n }\n \n // Check p3->p4->p1 forms a right angle\n bool p4p1_horizontal = (p4.y == p1.y);\n bool p4p1_vertical = (p4.x == p1.x);\n \n if (!p4p1_horizontal && !p4p1_vertical) return false;\n \n if ((p3p4_horizontal && !p4p1_vertical) || (p3p4_vertical && !p4p1_horizontal)) {\n return false;\n }\n \n // Check p4->p1->p2 forms a right angle\n if ((p4p1_horizontal && !p1p2_vertical) || (p4p1_vertical && !p1p2_horizontal)) {\n return false;\n }\n \n // Check if it closes properly (p4 connects to p1)\n if (!((p4.x == p1.x && p4.y == p1.y) || \n (p4.x == p1.x || p4.y == p1.y))) {\n return false;\n }\n \n // Verify opposite sides are equal length (Manhattan distance)\n int len_p1p2 = abs(p1.x - p2.x) + abs(p1.y - p2.y);\n int len_p3p4 = abs(p3.x - p4.x) + abs(p3.y - p4.y);\n if (len_p1p2 != len_p3p4) return false;\n \n int len_p2p3 = abs(p2.x - p3.x) + abs(p2.y - p3.y);\n int len_p4p1 = abs(p4.x - p1.x) + abs(p4.y - p1.y);\n if (len_p2p3 != len_p4p1) return false;\n \n return true;\n }\n \n // Get all points on the perimeter of a rectangle defined by 4 points in order\n vector getPerimeterPointsInOrder(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n vector perimeter;\n set seen;\n \n // Add points from edge p1->p2\n if (p1.y == p2.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p1.x, p2.x, p1.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p1.x == p2.x) { // vertical\n vector edge = getVerticalEdgePoints(p1.x, p1.y, p2.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n // Add points from edge p2->p3\n if (p2.y == p3.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p2.x, p3.x, p2.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p2.x == p3.x) { // vertical\n vector edge = getVerticalEdgePoints(p2.x, p2.y, p3.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n // Add points from edge p3->p4\n if (p3.y == p4.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p3.x, p4.x, p3.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p3.x == p4.x) { // vertical\n vector edge = getVerticalEdgePoints(p3.x, p3.y, p4.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n // Add points from edge p4->p1\n if (p4.y == p1.y) { // horizontal\n vector edge = getHorizontalEdgePoints(p4.x, p1.x, p4.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n } else if (p4.x == p1.x) { // vertical\n vector edge = getVerticalEdgePoints(p4.x, p4.y, p1.y);\n for (const Point& p : edge) {\n if (seen.find(p) == seen.end()) {\n perimeter.push_back(p);\n seen.insert(p);\n }\n }\n }\n \n return perimeter;\n }\n \n // Check if the rectangle has no other dots on perimeter except the 4 corners\n bool hasNoOtherDotsOnPerimeter(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n vector perimeter = getPerimeterPointsInOrder(p1, p2, p3, p4);\n set corners = {p1, p2, p3, p4};\n \n for (const Point& p : perimeter) {\n if (corners.find(p) == corners.end() && hasDot[p.x][p.y]) {\n return false;\n }\n }\n \n return true;\n }\n \n // Check if the rectangle edges don't overlap with existing edges\n bool hasNoSharedEdges(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n // Check edge p1->p2\n if (p1.y == p2.y) { // horizontal\n int minY = p1.y;\n int minX = min(p1.x, p2.x);\n int maxX = max(p1.x, p2.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p1.x == p2.x) { // vertical\n int minX = p1.x;\n int minY = min(p1.y, p2.y);\n int maxY = max(p1.y, p2.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n // Check edge p2->p3\n if (p2.y == p3.y) { // horizontal\n int minY = p2.y;\n int minX = min(p2.x, p3.x);\n int maxX = max(p2.x, p3.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p2.x == p3.x) { // vertical\n int minX = p2.x;\n int minY = min(p2.y, p3.y);\n int maxY = max(p2.y, p3.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n // Check edge p3->p4\n if (p3.y == p4.y) { // horizontal\n int minY = p3.y;\n int minX = min(p3.x, p4.x);\n int maxX = max(p3.x, p4.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p3.x == p4.x) { // vertical\n int minX = p3.x;\n int minY = min(p3.y, p4.y);\n int maxY = max(p3.y, p4.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n // Check edge p4->p1\n if (p4.y == p1.y) { // horizontal\n int minY = p4.y;\n int minX = min(p4.x, p1.x);\n int maxX = max(p4.x, p1.x);\n for (int x = minX; x < maxX; x++) {\n if (hasHorizontalEdge[x][minY]) {\n return false;\n }\n }\n } else if (p4.x == p1.x) { // vertical\n int minX = p4.x;\n int minY = min(p4.y, p1.y);\n int maxY = max(p4.y, p1.y);\n for (int y = minY; y < maxY; y++) {\n if (hasVerticalEdge[minX][y]) {\n return false;\n }\n }\n }\n \n return true;\n }\n \n // Mark the edges of the rectangle as drawn\n void markRectangleEdges(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {\n // Mark edge p1->p2\n if (p1.y == p2.y) { // horizontal\n int minY = p1.y;\n int minX = min(p1.x, p2.x);\n int maxX = max(p1.x, p2.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p1.x == p2.x) { // vertical\n int minX = p1.x;\n int minY = min(p1.y, p2.y);\n int maxY = max(p1.y, p2.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n \n // Mark edge p2->p3\n if (p2.y == p3.y) { // horizontal\n int minY = p2.y;\n int minX = min(p2.x, p3.x);\n int maxX = max(p2.x, p3.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p2.x == p3.x) { // vertical\n int minX = p2.x;\n int minY = min(p2.y, p3.y);\n int maxY = max(p2.y, p3.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n \n // Mark edge p3->p4\n if (p3.y == p4.y) { // horizontal\n int minY = p3.y;\n int minX = min(p3.x, p4.x);\n int maxX = max(p3.x, p4.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p3.x == p4.x) { // vertical\n int minX = p3.x;\n int minY = min(p3.y, p4.y);\n int maxY = max(p3.y, p4.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n \n // Mark edge p4->p1\n if (p4.y == p1.y) { // horizontal\n int minY = p4.y;\n int minX = min(p4.x, p1.x);\n int maxX = max(p4.x, p1.x);\n for (int x = minX; x < maxX; x++) {\n hasHorizontalEdge[x][minY] = true;\n }\n } else if (p4.x == p1.x) { // vertical\n int minX = p4.x;\n int minY = min(p4.y, p1.y);\n int maxY = max(p4.y, p1.y);\n for (int y = minY; y < maxY; y++) {\n hasVerticalEdge[minX][y] = true;\n }\n }\n }\n \n // Get all existing dots\n vector getAllDots() {\n vector dots;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (hasDot[x][y]) {\n dots.push_back(Point(x, y));\n }\n }\n }\n return dots;\n }\n \n // Try all possible rectangles with the new point as p1\n vector findValidRectangle(Point newPoint, const vector& existingDots) {\n int n = existingDots.size();\n \n // Try all permutations of 3 existing dots as p2, p3, p4\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j == i) continue;\n for (int k = 0; k < n; k++) {\n if (k == i || k == j) continue;\n \n Point p2 = existingDots[i];\n Point p3 = existingDots[j];\n Point p4 = existingDots[k];\n \n // Check if these 4 points form a valid rectangle in order\n if (isValidAxisAlignedRectangleInOrder(newPoint, p2, p3, p4)) {\n // Check if no other dots on perimeter\n if (hasNoOtherDotsOnPerimeter(newPoint, p2, p3, p4)) {\n // Check if no shared edges\n if (hasNoSharedEdges(newPoint, p2, p3, p4)) {\n // Found a valid rectangle\n return {p2, p3, p4};\n }\n }\n }\n }\n }\n }\n \n return {}; // No valid rectangle found\n }\n\npublic:\n RectJoinSolver(int n, int m, const vector& initial) : N(n), M(m), initialDots(initial) {\n center = (N - 1) / 2;\n hasDot.assign(N, vector(N, false));\n hasHorizontalEdge.assign(N, vector(N, false));\n hasVerticalEdge.assign(N, vector(N, false));\n \n // Mark initial dots\n for (const Point& p : initialDots) {\n hasDot[p.x][p.y] = true;\n }\n \n startTime = high_resolution_clock::now();\n }\n \n void solve() {\n while (!isTimeExceeded()) {\n vector existingDots = getAllDots();\n bool madeProgress = false;\n \n // Create a list of candidate positions, sorted by weight (descending)\n vector> candidates;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y < N; y++) {\n if (!hasDot[x][y]) {\n double weight = getWeight(x, y);\n candidates.push_back({weight, Point(x, y)});\n }\n }\n }\n \n // Sort by weight descending\n sort(candidates.begin(), candidates.end(), \n [](const pair& a, const pair& b) {\n return a.first > b.first;\n });\n \n // Try candidates in order of weight\n for (const auto& candidate : candidates) {\n if (isTimeExceeded()) break;\n \n Point newPoint = candidate.second;\n vector validPoints = findValidRectangle(newPoint, existingDots);\n \n if (!validPoints.empty()) {\n // Double check before committing\n if (isValidAxisAlignedRectangleInOrder(newPoint, validPoints[0], validPoints[1], validPoints[2]) &&\n hasNoOtherDotsOnPerimeter(newPoint, validPoints[0], validPoints[1], validPoints[2]) &&\n hasNoSharedEdges(newPoint, validPoints[0], validPoints[1], validPoints[2])) {\n \n // Place the dot\n hasDot[newPoint.x][newPoint.y] = true;\n \n // Mark the edges as drawn\n markRectangleEdges(newPoint, validPoints[0], validPoints[1], validPoints[2]);\n \n // Record operation\n vector opCoords = {\n newPoint.x, newPoint.y,\n validPoints[0].x, validPoints[0].y,\n validPoints[1].x, validPoints[1].y,\n validPoints[2].x, validPoints[2].y\n };\n operations.push_back(opCoords);\n \n madeProgress = true;\n break; // Restart with updated board\n }\n }\n }\n \n if (!madeProgress) {\n break; // No more valid moves\n }\n }\n }\n \n void output() {\n cout << operations.size() << endl;\n for (const auto& op : operations) {\n for (int i = 0; i < 8; i++) {\n if (i > 0) cout << \" \";\n cout << op[i];\n }\n cout << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n \n vector initialDots;\n for (int i = 0; i < M; i++) {\n int x, y;\n cin >> x >> y;\n initialDots.push_back(Point(x, y));\n }\n \n RectJoinSolver solver(N, M, initialDots);\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 10;\n\n// Directions: F=0 (forward/up), B=1 (backward/down), L=2 (left), R=3 (right)\nconst int dx[4] = {-1, 1, 0, 0};\nconst int dy[4] = {0, 0, -1, 1};\nconst char dir_char[4] = {'F', 'B', 'L', 'R'};\n\nclass CandyBox {\nprivate:\n vector> grid;\n vector flavor_count;\n vector future_flavors;\n int current_step;\n \npublic:\n CandyBox(const vector& flavors) : grid(N, vector(N, 0)), flavor_count(4, 0), future_flavors(flavors), current_step(0) {}\n \n // Place candy at position (calculated from 1-indexed empty cell number)\n void placeCandy(int pos, int flavor) {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == 0) {\n count++;\n if (count == pos) {\n grid[i][j] = flavor;\n flavor_count[flavor]++;\n return;\n }\n }\n }\n }\n }\n \n // Simulate tilting in a direction\n vector> simulateTilt(int dir) {\n vector> new_grid = grid;\n \n // Create movement order based on direction\n vector> cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (new_grid[i][j] != 0) {\n cells.push_back({i, j});\n }\n }\n }\n \n // Sort cells based on direction to process in correct order\n if (dir == 0) { // Forward (up): process from top to bottom\n sort(cells.begin(), cells.end());\n } else if (dir == 1) { // Backward (down): process from bottom to top\n sort(cells.begin(), cells.end(), greater>());\n } else if (dir == 2) { // Left: process from left to right\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second < b.second;\n return a.first < b.first;\n });\n } else { // Right: process from right to left\n sort(cells.begin(), cells.end(), [](const pair& a, const pair& b) {\n if (a.second != b.second) return a.second > b.second;\n return a.first < b.first;\n });\n }\n \n // Move each candy\n vector> temp_grid(N, vector(N, 0));\n for (auto& cell : cells) {\n int x = cell.first, y = cell.second;\n int flavor = new_grid[x][y];\n \n // Skip if already processed (moved)\n if (flavor == 0) continue;\n \n int nx = x, ny = y;\n while (true) {\n int tx = nx + dx[dir];\n int ty = ny + dy[dir];\n if (tx < 0 || tx >= N || ty < 0 || ty >= N || temp_grid[tx][ty] != 0) {\n break;\n }\n nx = tx;\n ny = ty;\n }\n temp_grid[nx][ny] = flavor;\n }\n \n return temp_grid;\n }\n \n // Calculate score for a given grid state\n long long calculateScoreForGrid(const vector>& test_grid, const vector& test_counts) {\n vector> visited(N, vector(N, false));\n vector component_sizes;\n \n // Find connected components using BFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] != 0 && !visited[i][j]) {\n int component_size = 0;\n int flavor = test_grid[i][j];\n \n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n \n while (!q.empty()) {\n auto curr = q.front();\n q.pop();\n component_size++;\n \n // Check 4 directions\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = curr.first + dirs[d][0];\n int nj = curr.second + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && \n !visited[ni][nj] && test_grid[ni][nj] == flavor) {\n visited[ni][nj] = true;\n q.push({ni, nj});\n }\n }\n }\n \n component_sizes.push_back(component_size);\n }\n }\n }\n \n // Calculate sum of squares of component sizes\n long long sum_squares = 0;\n for (int size : component_sizes) {\n sum_squares += (long long)size * size;\n }\n \n // Calculate denominator: sum of squares of total counts per flavor\n long long denom = 0;\n for (int i = 1; i <= 3; i++) {\n denom += (long long)test_counts[i] * test_counts[i];\n }\n \n // Return score as described in problem\n if (denom == 0) return 0;\n return (long long)round(1000000.0 * sum_squares / denom);\n }\n \n // Calculate a bonus score for potential connectivity\n double calculateConnectivityBonus(const vector>& test_grid, int current_flavor) {\n double bonus = 0.0;\n \n // For each candy of the current flavor, check if it's adjacent to another candy of the same flavor\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] == current_flavor) {\n // Check 4 directions for adjacent candies of the same flavor\n int adjacent_count = 0;\n int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n for (int d = 0; d < 4; d++) {\n int ni = i + dirs[d][0];\n int nj = j + dirs[d][1];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && test_grid[ni][nj] == current_flavor) {\n adjacent_count++;\n }\n }\n // Add bonus for each adjacency (small bonus to avoid overriding actual score)\n bonus += adjacent_count * 0.1;\n }\n }\n }\n \n return bonus;\n }\n \n // Calculate distance to nearest same-flavor candy\n double calculateDistanceBonus(const vector>& test_grid, int current_flavor) {\n double bonus = 0.0;\n \n // For each candy of the current flavor\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (test_grid[i][j] == current_flavor) {\n // Find distance to nearest other candy of the same flavor\n int min_dist = INT_MAX;\n bool found_other = false;\n \n for (int ni = 0; ni < N; ni++) {\n for (int nj = 0; nj < N; nj++) {\n if (test_grid[ni][nj] == current_flavor && (ni != i || nj != j)) {\n int dist = abs(ni - i) + abs(nj - j);\n if (dist < min_dist) {\n min_dist = dist;\n found_other = true;\n }\n }\n }\n }\n \n // If found another candy of the same flavor, add bonus based on proximity\n if (found_other) {\n bonus += 1.0 / (1.0 + min_dist); // Closer = higher bonus\n }\n }\n }\n }\n \n return bonus;\n }\n \n // Apply tilt to actual grid\n void applyTilt(int dir) {\n grid = simulateTilt(dir);\n }\n \n // Get current grid state\n vector> getGrid() const {\n return grid;\n }\n \n // Get flavor counts\n vector getFlavorCount() const {\n return flavor_count;\n }\n \n // Update current step\n void updateStep(int step) {\n current_step = step;\n }\n};\n\nint main() {\n vector flavors(100);\n for (int i = 0; i < 100; i++) {\n cin >> flavors[i];\n }\n \n CandyBox box(flavors);\n \n for (int t = 0; t < 100; t++) {\n int pos;\n cin >> pos;\n \n // Update current step\n box.updateStep(t);\n \n // Place the candy\n box.placeCandy(pos, flavors[t]);\n \n // If it's the last candy, we can choose any direction (it won't matter)\n if (t == 99) {\n cout << \"F\" << endl;\n cout.flush();\n continue;\n }\n \n // Try all 4 directions and pick the best\n double best_combined_score = -1e18;\n int best_dir = 0;\n \n vector current_counts = box.getFlavorCount();\n \n for (int dir = 0; dir < 4; dir++) {\n // Simulate tilt in this direction\n vector> test_grid = box.simulateTilt(dir);\n \n // Calculate base score\n long long base_score = box.calculateScoreForGrid(test_grid, current_counts);\n \n // Calculate small bonuses for improved connectivity\n double connectivity_bonus = box.calculateConnectivityBonus(test_grid, flavors[t]);\n double distance_bonus = box.calculateDistanceBonus(test_grid, flavors[t]);\n \n // Combine scores with very small weights for bonuses\n double combined_score = base_score + connectivity_bonus + distance_bonus * 0.5;\n \n // Choose the direction with the highest combined score\n if (combined_score > best_combined_score) {\n best_combined_score = combined_score;\n best_dir = dir;\n }\n }\n \n // Apply the best tilt\n box.applyTilt(best_dir);\n \n // Output the direction\n cout << dir_char[best_dir] << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nclass Graph {\npublic:\n int N;\n vector> adj;\n \n Graph(int n) : N(n), adj(n, vector(n, false)) {}\n \n void add_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = true;\n adj[j][i] = true;\n }\n }\n \n void remove_edge(int i, int j) {\n if (i != j) {\n adj[i][j] = false;\n adj[j][i] = false;\n }\n }\n \n bool has_edge(int i, int j) const {\n return adj[i][j];\n }\n \n string to_string() const {\n string s;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n s += (adj[i][j] ? '1' : '0');\n }\n }\n return s;\n }\n \n static Graph from_string(int n, const string& s) {\n Graph g(n);\n int idx = 0;\n for (int i = 0; i < n; i++) {\n for (int j = i + 1; j < n; j++) {\n if (idx < (int)s.length() && s[idx] == '1') {\n g.add_edge(i, j);\n }\n idx++;\n }\n }\n return g;\n }\n \n vector get_degree_sequence() const {\n vector degrees(N, 0);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (adj[i][j]) degrees[i]++;\n }\n }\n sort(degrees.begin(), degrees.end());\n return degrees;\n }\n \n int count_edges() const {\n int count = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) count++;\n }\n }\n return count;\n }\n \n int count_triangles() const {\n int triangles = 0;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (adj[i][j]) {\n for (int k = j + 1; k < N; k++) {\n if (adj[i][k] && adj[j][k]) {\n triangles++;\n }\n }\n }\n }\n }\n return triangles;\n }\n \n // Count connected components\n int count_components() const {\n vector visited(N, false);\n int components = 0;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n components++;\n // BFS\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n }\n }\n return components;\n }\n \n // Get component sizes\n vector get_component_sizes() const {\n vector visited(N, false);\n vector sizes;\n \n for (int i = 0; i < N; i++) {\n if (!visited[i]) {\n int size = 0;\n queue q;\n q.push(i);\n visited[i] = true;\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n size++;\n \n for (int v = 0; v < N; v++) {\n if (adj[u][v] && !visited[v]) {\n visited[v] = true;\n q.push(v);\n }\n }\n }\n sizes.push_back(size);\n }\n }\n sort(sizes.begin(), sizes.end());\n return sizes;\n }\n \n // Signature based on first 4 vertices\n int get_signature() const {\n if (N < 4) return 0;\n \n int edge_count = 0;\n if (has_edge(0, 1)) edge_count++;\n if (has_edge(0, 2)) edge_count++;\n if (has_edge(0, 3)) edge_count++;\n if (has_edge(1, 2)) edge_count++;\n if (has_edge(1, 3)) edge_count++;\n if (has_edge(2, 3)) edge_count++;\n \n return edge_count; // 0-6\n }\n};\n\n// Features for graph classification\nstruct GraphFeatures {\n int edge_count;\n vector degree_sequence;\n int triangle_count;\n int component_count;\n vector component_sizes;\n int signature;\n int N;\n \n GraphFeatures(const Graph& g) {\n N = g.N;\n edge_count = g.count_edges();\n degree_sequence = g.get_degree_sequence();\n triangle_count = g.count_triangles();\n component_count = g.count_components();\n component_sizes = g.get_component_sizes();\n signature = g.get_signature();\n }\n};\n\n// Well-tuned distance function\ndouble distance(const GraphFeatures& f1, const GraphFeatures& f2, double epsilon) {\n double d = 0.0;\n \n // Edge count\n d += abs(f1.edge_count - f2.edge_count) * 1.0;\n \n // Degree sequence\n int len = min(f1.degree_sequence.size(), f2.degree_sequence.size());\n for (int i = 0; i < len; i++) {\n d += abs(f1.degree_sequence[i] - f2.degree_sequence[i]) * 1.4;\n }\n \n // Component count (very noise-resistant)\n d += abs(f1.component_count - f2.component_count) * 3.2;\n \n // Component sizes (very noise-resistant)\n len = min(f1.component_sizes.size(), f2.component_sizes.size());\n for (int i = 0; i < len; i++) {\n d += abs(f1.component_sizes[i] - f2.component_sizes[i]) * 2.2;\n }\n \n // Triangle count\n d += abs(f1.triangle_count - f2.triangle_count) * 0.9;\n \n // Signature\n d += abs(f1.signature - f2.signature) * 2.1;\n \n // Add small constant to break ties deterministically\n d += 0.001 * (f1.signature + f2.signature);\n \n return d;\n}\n\n// Generate highly distinctive graphs\nGraph generate_distinctive_graph(int N, int k, int M) {\n Graph g(N);\n \n // Use k to determine parameters with more diversity\n int group = k % 8;\n int density_group = (k / 8) % 5; // Increased from 4 to 5 groups\n \n // More diverse densities\n double densities[] = {0.25, 0.4, 0.55, 0.7, 0.85};\n double target_density = densities[density_group];\n int target_edges = (int)(target_density * N * (N - 1) / 2);\n \n // Ensure minimum edges for distinctive features\n if (target_edges < 10 && N >= 5) target_edges = 10;\n \n // Generate different structures with more variation\n if (group == 0) {\n // Random graph with clustering bias\n mt19937 rng(k * 12345 + 789);\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (g.count_edges() < target_edges && (rng() % 100) < (target_density * 100 + 5)) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (group == 1) {\n // Complete graph on subset with variation\n int subset_size = min(N, (int)(sqrt(target_edges * 2.0) / 2.0 + 2 + (k % 3)));\n for (int i = 0; i < subset_size; i++) {\n for (int j = i + 1; j < subset_size; j++) {\n g.add_edge(i, j);\n }\n }\n // Add random edges with bias\n mt19937 rng(k * 6789 + 321);\n for (int i = 0; i < subset_size && g.count_edges() < target_edges; i++) {\n for (int j = subset_size; j < N && g.count_edges() < target_edges; j++) {\n if ((k + i + j) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (group == 2) {\n // Cycle with varied chords\n for (int i = 0; i < N; i++) {\n g.add_edge(i, (i + 1) % N);\n }\n mt19937 rng(k * 2468 + 135);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n int gap = min(j - i, N - (j - i));\n if (gap <= 5 && (gap + k) % 3 == 1) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (group == 3) {\n // Star-based with variation\n int center = k % max(1, N/2);\n for (int i = 0; i < N; i++) {\n if (i != center && g.count_edges() < target_edges * 0.7) {\n g.add_edge(center, i);\n }\n }\n mt19937 rng(k * 3210 + 987);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n if (i == center) continue;\n for (int j = i + 1; j < N && g.count_edges() < target_edges; j++) {\n if (j == center) continue;\n if ((i * j + k) % 4 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (group == 4) {\n // Modular with more variation\n int communities = 2 + (k % 4);\n int comm_size = N / communities;\n \n for (int c = 0; c < communities; c++) {\n int start = c * comm_size;\n int end = (c == communities - 1) ? N : (c + 1) * comm_size;\n \n // Variable density within communities\n double intra_density = 0.6 + (k % 3) * 0.1;\n mt19937 rng(k * 111 + c * 222);\n for (int i = start; i < end; i++) {\n for (int j = i + 1; j < end; j++) {\n if (g.count_edges() < target_edges * 0.8 && (rng() % 100) < (intra_density * 100)) {\n g.add_edge(i, j);\n }\n }\n }\n }\n \n // Add between-community edges\n mt19937 rng(k * 9753 + 456);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 1; j < N; j++) {\n int c1 = i / comm_size;\n int c2 = j / comm_size;\n if (c1 != c2 && (rng() % 6) == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (group == 5) {\n // Tree with additional edges\n for (int i = 1; i < N; i++) {\n g.add_edge(i, (i - 1) / 2);\n }\n mt19937 rng(k * 8642 + 357);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else if (group == 6) {\n // Path with varied shortcuts\n for (int i = 0; i < N - 1; i++) {\n g.add_edge(i, i + 1);\n }\n mt19937 rng(k * 5432 + 678);\n for (int i = 0; i < N && g.count_edges() < target_edges; i++) {\n for (int j = i + 2; j < N && g.count_edges() < target_edges; j++) {\n if ((j - i) <= 6 && (k + j - i) % 3 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n else { // group == 7\n // Bipartite with variation\n int split = N / 2 + (k % 3) - 1;\n split = max(2, min(N-2, split));\n \n mt19937 rng(k * 1357 + 890);\n for (int i = 0; i < split; i++) {\n for (int j = split; j < N && g.count_edges() < target_edges; j++) {\n if ((i + j + k) % 3 == 0 || g.count_edges() < target_edges * 0.6) {\n g.add_edge(i, j);\n }\n }\n }\n }\n \n // Create robust signature on first 4 vertices\n if (N >= 4) {\n // Clear existing edges\n for (int i = 0; i < 4; i++) {\n for (int j = i + 1; j < 4; j++) {\n g.remove_edge(i, j);\n }\n }\n \n // Add edges based on k (0-6 edges)\n int signature = k % 7;\n \n // Add signature edges with higher probability of survival\n if (signature >= 1) g.add_edge(0, 1);\n if (signature >= 2) g.add_edge(0, 2);\n if (signature >= 3) g.add_edge(1, 2);\n if (signature >= 4) g.add_edge(0, 3);\n if (signature >= 5) g.add_edge(1, 3);\n if (signature >= 6) g.add_edge(2, 3);\n \n // Add some redundant edges connected to signature vertices\n if (N > 4) {\n mt19937 rng(k * 555 + 111);\n for (int i = 0; i < 4; i++) {\n for (int j = 4; j < min(8, N); j++) {\n if (rng() % 4 == 0) {\n g.add_edge(i, j);\n }\n }\n }\n }\n }\n \n // Adjust edge count with priority for signature edges\n if (g.count_edges() < target_edges * 0.9) {\n mt19937 rng(k * 112233 + 445);\n vector> missing_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (!g.has_edge(i, j)) {\n missing_edges.push_back({i, j});\n }\n }\n }\n shuffle(missing_edges.begin(), missing_edges.end(), rng);\n for (auto& e : missing_edges) {\n if (g.count_edges() >= target_edges) break;\n g.add_edge(e.first, e.second);\n }\n }\n else if (g.count_edges() > target_edges * 1.1) {\n mt19937 rng(k * 332211 + 779);\n vector> existing_edges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (g.has_edge(i, j)) {\n // Strongly preserve signature edges\n bool is_signature_edge = false;\n if (i < 4 && j < 4) {\n int sig = k % 7;\n if (sig >= 1 && i == 0 && j == 1) is_signature_edge = true;\n if (sig >= 2 && i == 0 && j == 2) is_signature_edge = true;\n if (sig >= 3 && i == 1 && j == 2) is_signature_edge = true;\n if (sig >= 4 && i == 0 && j == 3) is_signature_edge = true;\n if (sig >= 5 && i == 1 && j == 3) is_signature_edge = true;\n if (sig >= 6 && i == 2 && j == 3) is_signature_edge = true;\n }\n \n if (!is_signature_edge) {\n existing_edges.push_back({i, j});\n }\n }\n }\n }\n shuffle(existing_edges.begin(), existing_edges.end(), rng);\n for (auto& e : existing_edges) {\n if (g.count_edges() <= target_edges) break;\n g.remove_edge(e.first, e.second);\n }\n }\n \n return g;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double epsilon;\n cin >> M >> epsilon;\n \n // Choose N based on M and epsilon with more fine-tuning\n int N;\n \n if (epsilon <= 0.1) {\n N = 20;\n } else if (epsilon <= 0.2) {\n N = 25;\n } else if (epsilon <= 0.3) {\n N = 30;\n } else {\n N = 35;\n }\n \n // More fine-tuned adjustment for M\n if (M > 90) {\n N += 15;\n } else if (M > 75) {\n N += 10;\n } else if (M > 50) {\n N += 6;\n } else if (M > 25) {\n N += 3;\n }\n \n // Ensure bounds\n N = max(20, min(70, N));\n \n cout << N << endl;\n \n // Generate M graphs\n vector graphs;\n vector features;\n \n for (int k = 0; k < M; k++) {\n Graph g = generate_distinctive_graph(N, k, M);\n graphs.push_back(g);\n features.push_back(GraphFeatures(g));\n \n // Output graph\n cout << g.to_string() << endl;\n cout.flush();\n }\n \n // Process 100 queries\n for (int k = 0; k < 100; k++) {\n string h_str;\n cin >> h_str;\n \n // Parse the graph\n Graph h = Graph::from_string(N, h_str);\n GraphFeatures h_features(h);\n \n // Use threshold-based approach with better-tuned weights\n int best_idx = 0;\n double min_dist = 1e15;\n \n if (epsilon > 0.3) {\n // High noise: use simple edge count + degree sequence\n for (int i = 0; i < M; i++) {\n double dist = abs(h_features.edge_count - features[i].edge_count) * 1.2;\n int len = min(h_features.degree_sequence.size(), features[i].degree_sequence.size());\n for (int j = 0; j < len; j++) {\n dist += abs(h_features.degree_sequence[j] - features[i].degree_sequence[j]) * 1.0;\n }\n // Add small tie-breaker\n dist += 0.001 * i;\n if (dist < min_dist) {\n min_dist = dist;\n best_idx = i;\n }\n }\n } else {\n // Low-medium noise: use full feature set\n for (int i = 0; i < M; i++) {\n double dist = distance(h_features, features[i], epsilon);\n if (dist < min_dist) {\n min_dist = dist;\n best_idx = i;\n }\n }\n }\n \n cout << best_idx << endl;\n cout.flush();\n }\n \n return 0;\n}","ahc017":"#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// Graph representation\nstruct Edge {\n int u, v, w, id;\n Edge(int u = 0, int v = 0, int w = 0, int id = 0) : u(u), v(v), w(w), id(id) {}\n};\n\nclass Graph {\npublic:\n int n, m, d, k;\n vector edges;\n vector>> adj; // adjacency list: to, weight\n vector> coords;\n \n Graph(int n = 0, int m = 0, int d = 0, int k = 0) : n(n), m(m), d(d), k(k) {\n adj.resize(n + 1);\n }\n \n void addEdge(int u, int v, int w, int id) {\n edges.emplace_back(u, v, w, id);\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n // Calculate shortest distances from source using Dijkstra\n vector dijkstra(int source, const unordered_set& removed_edges = {}) {\n vector dist(n + 1, 1e18);\n priority_queue, vector>, greater>> pq;\n \n dist[source] = 0;\n pq.emplace(0, source);\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto [v, w] : adj[u]) {\n // Check if edge u-v is removed\n bool edge_removed = false;\n for (int eid : removed_edges) {\n Edge& e = edges[eid];\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n edge_removed = true;\n break;\n }\n }\n \n if (edge_removed) continue;\n \n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.emplace(dist[v], v);\n }\n }\n }\n \n return dist;\n }\n \n // Calculate frustration with adaptive sampling based on graph size\n double calculateFrustrationSampling(const vector>& original_apsp, \n const vector& edges_to_remove) {\n if (edges_to_remove.empty()) return 0.0;\n \n unordered_set remove_set(edges_to_remove.begin(), edges_to_remove.end());\n \n // Use fixed seed for consistency\n mt19937 gen(42);\n uniform_int_distribution<> vertex_dist(1, n);\n \n // Adaptive sample size based on graph size\n int source_sample_size;\n if (n <= 600) {\n source_sample_size = min(15, max(6, n / 20));\n } else {\n source_sample_size = min(10, max(4, n / 40));\n }\n \n vector sources;\n \n // Include high-degree vertices\n vector> degree_vertices; // (degree, vertex)\n for (int i = 1; i <= n; i++) {\n degree_vertices.emplace_back(adj[i].size(), i);\n }\n sort(degree_vertices.rbegin(), degree_vertices.rend());\n \n // Take top high-degree vertices\n int high_degree_count = min(3, source_sample_size / 3);\n for (int i = 0; i < high_degree_count; i++) {\n sources.push_back(degree_vertices[i].second);\n }\n \n // Include low-degree vertices (potential bottlenecks)\n if (!degree_vertices.empty() && static_cast(sources.size()) < source_sample_size / 2) {\n sources.push_back(degree_vertices.back().second);\n }\n \n // Include some evenly spaced vertices\n int step = max(1, n / max(1, source_sample_size - static_cast(sources.size())));\n for (int i = 1; i <= n && static_cast(sources.size()) < source_sample_size; i += step) {\n if (find(sources.begin(), sources.end(), i) == sources.end()) {\n sources.push_back(i);\n }\n }\n \n // Fill with random vertices if needed\n while (static_cast(sources.size()) < source_sample_size) {\n int v = vertex_dist(gen);\n if (find(sources.begin(), sources.end(), v) == sources.end()) {\n sources.push_back(v);\n }\n }\n \n double frustration = 0.0;\n int pairs_count = 0;\n \n for (int source : sources) {\n // Run Dijkstra from source with removed edges\n auto dist = dijkstra(source, remove_set);\n \n // Adaptive target sample size\n int target_sample_size = min(5, max(3, n / 50));\n \n vector targets;\n \n // Include 1-2 high-degree vertices\n int high_degree_targets = min(2, target_sample_size / 2);\n for (int i = 0; i < high_degree_targets && i < static_cast(degree_vertices.size()); i++) {\n int target = degree_vertices[i].second;\n if (target != source) {\n targets.push_back(target);\n }\n }\n \n // Include 1 low-degree vertex\n if (static_cast(targets.size()) < target_sample_size && !degree_vertices.empty()) {\n int target = degree_vertices.back().second;\n if (target != source && find(targets.begin(), targets.end(), target) == targets.end()) {\n targets.push_back(target);\n }\n }\n \n // Fill with random vertices\n while (static_cast(targets.size()) < target_sample_size) {\n int target = vertex_dist(gen);\n if (target != source && find(targets.begin(), targets.end(), target) == targets.end()) {\n targets.push_back(target);\n }\n }\n \n for (int target : targets) {\n if (source == target) continue;\n \n long long new_dist = dist[target];\n if (new_dist >= 1e18) {\n new_dist = 1000000000; // Unreachable\n }\n \n long long orig_dist = original_apsp[source][target];\n if (orig_dist >= 1e18) orig_dist = 1000000000;\n \n frustration += (new_dist - orig_dist);\n pairs_count++;\n }\n }\n \n if (pairs_count == 0) return 0.0;\n \n // Scale up to approximate full frustration\n double avg_increase = frustration / pairs_count;\n return avg_increase;\n }\n};\n\n// Solution representation\nstruct Solution {\n vector schedule; // schedule[i] = day for edge i (1-indexed days)\n double total_frustration;\n Graph* graph;\n vector> original_apsp;\n \n Solution(Graph* g, const vector>& apsp) : graph(g), original_apsp(apsp) {\n schedule.resize(g->m);\n total_frustration = 0.0;\n }\n \n // Calculate total frustration for the entire schedule using sampling\n double calculateTotalFrustration() {\n double total = 0.0;\n \n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate frustration for each day\n for (int day = 1; day <= graph->d; day++) {\n double day_frustration = graph->calculateFrustrationSampling(original_apsp, edges_by_day[day]);\n total += day_frustration;\n }\n \n total_frustration = total / graph->d;\n return total_frustration;\n }\n \n // Get frustration as integer (rounded)\n long long getScore() {\n return llround(1000.0 * total_frustration);\n }\n \n // Calculate frustration change only for affected days after a swap\n double calculateDeltaFrustration(int idx1, int idx2, int new_day1, int new_day2) {\n // Group edges by day\n vector> edges_by_day(graph->d + 1);\n for (int i = 0; i < graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n edges_by_day[schedule[i]].push_back(i);\n }\n \n // Calculate current frustration for old days\n int old_day1 = schedule[idx1];\n int old_day2 = schedule[idx2];\n \n double old_f1 = 0.0, old_f2 = 0.0;\n if (old_day1 == old_day2) {\n vector old_edges = edges_by_day[old_day1];\n old_edges.push_back(idx1);\n old_edges.push_back(idx2);\n old_f1 = old_f2 = graph->calculateFrustrationSampling(original_apsp, old_edges);\n } else {\n vector old_edges1 = edges_by_day[old_day1];\n old_edges1.push_back(idx1);\n old_f1 = graph->calculateFrustrationSampling(original_apsp, old_edges1);\n \n vector old_edges2 = edges_by_day[old_day2];\n old_edges2.push_back(idx2);\n old_f2 = graph->calculateFrustrationSampling(original_apsp, old_edges2);\n }\n \n // Calculate new frustration for new days\n double new_f1 = 0.0, new_f2 = 0.0;\n if (new_day1 == new_day2) {\n vector new_edges = edges_by_day[new_day1];\n new_edges.push_back(idx1);\n new_edges.push_back(idx2);\n new_f1 = new_f2 = graph->calculateFrustrationSampling(original_apsp, new_edges);\n } else {\n vector new_edges1 = edges_by_day[new_day1];\n new_edges1.push_back(idx1);\n new_f1 = graph->calculateFrustrationSampling(original_apsp, new_edges1);\n \n vector new_edges2 = edges_by_day[new_day2];\n new_edges2.push_back(idx2);\n new_f2 = graph->calculateFrustrationSampling(original_apsp, new_edges2);\n }\n \n // Delta frustration\n double delta = (new_f1 + new_f2 - old_f1 - old_f2) / graph->d;\n \n return delta;\n }\n};\n\n// Hybrid edge importance\nvector calculateEdgeImportance(Graph& graph) {\n vector importance(graph.m, 0.0);\n \n for (int i = 0; i < graph.m; i++) {\n int u = graph.edges[i].u;\n int v = graph.edges[i].v;\n int w = graph.edges[i].w;\n \n // Hybrid heuristic\n int deg_u = graph.adj[u].size();\n int deg_v = graph.adj[v].size();\n \n // Primary: harmonic mean (conservative)\n double harmonic_mean = 2.0 * deg_u * deg_v / (deg_u + deg_v);\n if (harmonic_mean < 1.0) harmonic_mean = 1.0;\n \n // Add a small component based on maximum degree (to identify bridges)\n double max_deg = max(deg_u, deg_v);\n if (max_deg == 0) max_deg = 1.0;\n \n // Combine metrics\n importance[i] = (double)w / harmonic_mean * (0.9 + 0.1 * (1.0 / max_deg));\n }\n \n return importance;\n}\n\n// Adaptive local search\nvoid adaptiveLocalSearch(Solution& solution) {\n auto start_time = chrono::steady_clock::now();\n mt19937 gen(42);\n uniform_int_distribution<> edge_dist(0, solution.graph->m - 1);\n uniform_int_distribution<> day_dist(1, solution.graph->d);\n uniform_real_distribution<> prob_dist(0.0, 1.0);\n \n double current_score = solution.calculateTotalFrustration();\n int iterations = 0;\n int max_iterations = 1200;\n \n // Pre-calculate day loads\n vector day_count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n day_count[solution.schedule[i]]++;\n }\n \n double best_score = current_score;\n int no_improvement_count = 0;\n const int NO_IMPROVEMENT_LIMIT = 200;\n \n while (iterations < max_iterations) {\n // Check time limit frequently\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n if (elapsed > 2500) break;\n \n // Early termination if no improvement\n if (no_improvement_count > NO_IMPROVEMENT_LIMIT) {\n break;\n }\n \n // Select edges - adaptive based on graph size\n int idx1, idx2;\n \n // For larger graphs, be more conservative\n double importance_bias = 0.1; // 10% chance for important edges\n if (solution.graph->n <= 700) {\n importance_bias = 0.2; // 20% for smaller graphs\n }\n \n if (prob_dist(gen) < 1.0 - importance_bias) {\n idx1 = edge_dist(gen);\n idx2 = edge_dist(gen);\n if (idx1 == idx2) {\n idx2 = (idx1 + 1) % solution.graph->m;\n }\n } else {\n // Select important edges\n vector> edge_importance;\n for (int i = 0; i < solution.graph->m; i++) {\n int u = solution.graph->edges[i].u;\n int v = solution.graph->edges[i].v;\n int w = solution.graph->edges[i].w;\n int deg_u = solution.graph->adj[u].size();\n int deg_v = solution.graph->adj[v].size();\n double harmonic_mean = 2.0 * deg_u * deg_v / (deg_u + deg_v);\n if (harmonic_mean < 1.0) harmonic_mean = 1.0;\n double max_deg = max(deg_u, deg_v);\n edge_importance.emplace_back((double)w / harmonic_mean * (0.9 + 0.1 * (1.0 / max_deg)), i);\n }\n sort(edge_importance.rbegin(), edge_importance.rend());\n \n // Select from top 25%\n int top_size = max(1, static_cast(edge_importance.size()) / 4);\n idx1 = edge_importance[iterations % top_size].second;\n idx2 = edge_dist(gen);\n }\n \n int old_day1 = solution.schedule[idx1];\n int old_day2 = solution.schedule[idx2];\n int new_day1, new_day2;\n \n // Adaptive move types\n double r = prob_dist(gen);\n if (r < 0.75) {\n // Swap days (75%)\n new_day1 = old_day2;\n new_day2 = old_day1;\n } else if (r < 0.9) {\n // Move to least loaded day (15%)\n vector> days_sorted;\n for (int day = 1; day <= solution.graph->d; day++) {\n days_sorted.emplace_back(day_count[day], day);\n }\n sort(days_sorted.begin(), days_sorted.end());\n new_day1 = days_sorted[0].second;\n new_day2 = old_day2;\n } else {\n // Move to random day (10%)\n new_day1 = day_dist(gen);\n new_day2 = old_day2;\n }\n \n // Validate days\n if (new_day1 < 1 || new_day1 > solution.graph->d || \n new_day2 < 1 || new_day2 > solution.graph->d) {\n iterations++;\n continue;\n }\n \n // Check constraints\n bool valid = true;\n vector count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n iterations++;\n continue;\n }\n \n // Calculate delta\n double delta = solution.calculateDeltaFrustration(idx1, idx2, new_day1, new_day2);\n \n // Adaptive acceptance\n if (delta < 0) {\n // Update day counts\n day_count[old_day1]--;\n day_count[old_day2]--;\n day_count[new_day1]++;\n day_count[new_day2]++;\n \n solution.schedule[idx1] = new_day1;\n solution.schedule[idx2] = new_day2;\n current_score += delta;\n \n if (current_score < best_score) {\n best_score = current_score;\n no_improvement_count = 0;\n } else {\n no_improvement_count++;\n }\n } else {\n no_improvement_count++;\n }\n \n iterations++;\n }\n}\n\n// Generate initial solution with adaptive distribution\nSolution generateInitialSolution(Graph& graph, const vector>& original_apsp) {\n // Calculate edge importance\n auto importance = calculateEdgeImportance(graph);\n \n Solution solution(&graph, original_apsp);\n vector day_count(graph.d + 1, 0);\n \n // Create pairs of (importance, edge_id)\n vector> edge_importance;\n for (int i = 0; i < graph.m; i++) {\n edge_importance.emplace_back(importance[i], i);\n }\n \n // Sort by importance (descending)\n sort(edge_importance.rbegin(), edge_importance.rend());\n \n // Adaptive distribution strategy based on graph size\n int top_percent = 25; // Default: top 25%\n if (graph.n > 800) {\n top_percent = 30; // For larger graphs, be more conservative\n }\n \n int top_count = graph.m * top_percent / 100;\n \n for (int i = 0; i < graph.m; i++) {\n int edge_id = edge_importance[i].second;\n \n if (i < top_count) {\n // Top important edges: distribute to least loaded days\n int min_day = 1;\n for (int j = 1; j <= graph.d; j++) {\n if (day_count[j] < day_count[min_day]) {\n min_day = j;\n }\n }\n solution.schedule[edge_id] = min_day;\n day_count[min_day]++;\n } else {\n // Remaining edges: use round-robin\n int day = ((i - top_count) % graph.d) + 1;\n \n // If day is full, find next available\n int attempts = 0;\n while (day_count[day] >= graph.k && attempts < graph.d) {\n day = (day % graph.d) + 1;\n attempts++;\n }\n \n // If still full, find least loaded\n if (day_count[day] >= graph.k) {\n int min_day = 1;\n for (int j = 1; j <= graph.d; j++) {\n if (day_count[j] < day_count[min_day]) {\n min_day = j;\n }\n }\n day = min_day;\n }\n \n solution.schedule[edge_id] = day;\n day_count[day]++;\n }\n }\n \n // Final validation\n for (int i = 0; i < graph.m; i++) {\n if (solution.schedule[i] < 1 || solution.schedule[i] > graph.d) {\n int min_day = 1;\n for (int j = 1; j <= graph.d; j++) {\n if (day_count[j] < day_count[min_day]) {\n min_day = j;\n }\n }\n solution.schedule[i] = min_day;\n day_count[min_day]++;\n }\n }\n \n return solution;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n auto total_start_time = chrono::steady_clock::now();\n \n int n, m, d, k;\n cin >> n >> m >> d >> k;\n \n Graph graph(n, m, d, k);\n \n // Read edges\n for (int i = 0; i < m; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n graph.addEdge(u, v, w, i);\n }\n \n // Read coordinates\n for (int i = 0; i < n; i++) {\n int x, y;\n cin >> x >> y;\n graph.coords.emplace_back(x, y);\n }\n \n // Compute APSP for an adaptive sample of vertices\n vector> original_apsp(n + 1, vector(n + 1, 1e18));\n \n // Sample vertices for APSP calculation\n mt19937 gen(42);\n uniform_int_distribution<> vertex_dist(1, n);\n \n // Adaptive sample size\n int sample_size;\n if (n <= 700) {\n sample_size = min(18, max(8, n / 15));\n } else {\n sample_size = min(12, max(6, n / 30));\n }\n \n vector sample_vertices;\n \n // Include high-degree vertices\n vector> degree_vertices; // (degree, vertex)\n for (int i = 1; i <= n; i++) {\n degree_vertices.emplace_back(graph.adj[i].size(), i);\n }\n sort(degree_vertices.rbegin(), degree_vertices.rend());\n \n // Take some high-degree vertices\n int high_degree_count = min(4, sample_size / 3);\n for (int i = 0; i < high_degree_count; i++) {\n sample_vertices.push_back(degree_vertices[i].second);\n }\n \n // Take some low-degree vertices\n if (!degree_vertices.empty()) {\n sample_vertices.push_back(degree_vertices.back().second);\n }\n \n // Take some evenly spaced vertices\n int remaining = sample_size - static_cast(sample_vertices.size());\n if (remaining > 0) {\n int step = max(1, n / remaining);\n for (int i = 1; i <= n && static_cast(sample_vertices.size()) < sample_size; i += step) {\n if (find(sample_vertices.begin(), sample_vertices.end(), i) == sample_vertices.end()) {\n sample_vertices.push_back(i);\n }\n }\n }\n \n // Fill with random vertices if needed\n while (static_cast(sample_vertices.size()) < sample_size) {\n int v = vertex_dist(gen);\n if (find(sample_vertices.begin(), sample_vertices.end(), v) == sample_vertices.end()) {\n sample_vertices.push_back(v);\n }\n }\n \n // Calculate shortest paths for sampled vertices\n for (int source : sample_vertices) {\n auto dist = graph.dijkstra(source);\n for (int j = 1; j <= n; j++) {\n original_apsp[source][j] = dist[j];\n }\n }\n \n // Check time and generate initial solution\n auto after_apsp_time = chrono::steady_clock::now();\n auto elapsed_so_far = chrono::duration_cast(after_apsp_time - total_start_time).count();\n \n Solution solution = generateInitialSolution(graph, original_apsp);\n \n // Apply adaptive local search if time permits\n if (elapsed_so_far < 3000) {\n adaptiveLocalSearch(solution);\n }\n \n // Final refinement for large graphs that might need extra attention\n if (n > 800 && chrono::duration_cast(chrono::steady_clock::now() - total_start_time).count() < 4000) {\n // Quick additional local search with focus on reducing frustration\n auto start_time = chrono::steady_clock::now();\n mt19937 gen(42);\n uniform_int_distribution<> edge_dist(0, solution.graph->m - 1);\n uniform_int_distribution<> day_dist(1, solution.graph->d);\n \n vector day_count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n day_count[solution.schedule[i]]++;\n }\n \n int iterations = 0;\n int max_iterations = 300; // Quick additional refinement\n \n while (iterations < max_iterations) {\n auto current_time = chrono::steady_clock::now();\n auto elapsed = chrono::duration_cast(current_time - start_time).count();\n if (elapsed > 1000) break;\n \n // Focus on random swaps\n int idx1 = edge_dist(gen);\n int idx2 = edge_dist(gen);\n if (idx1 == idx2) {\n idx2 = (idx1 + 1) % solution.graph->m;\n }\n \n int old_day1 = solution.schedule[idx1];\n int old_day2 = solution.schedule[idx2];\n int new_day1 = old_day2;\n int new_day2 = old_day1;\n \n // Validate and check constraints\n if (new_day1 < 1 || new_day1 > solution.graph->d || \n new_day2 < 1 || new_day2 > solution.graph->d) {\n iterations++;\n continue;\n }\n \n bool valid = true;\n vector count(solution.graph->d + 1, 0);\n for (int i = 0; i < solution.graph->m; i++) {\n if (i == idx1 || i == idx2) continue;\n count[solution.schedule[i]]++;\n }\n count[new_day1]++;\n count[new_day2]++;\n \n for (int day = 1; day <= solution.graph->d; day++) {\n if (count[day] > solution.graph->k) {\n valid = false;\n break;\n }\n }\n \n if (!valid) {\n iterations++;\n continue;\n }\n \n // Calculate delta\n double delta = solution.calculateDeltaFrustration(idx1, idx2, new_day1, new_day2);\n \n // Only accept improvements\n if (delta < 0) {\n day_count[old_day1]--;\n day_count[old_day2]--;\n day_count[new_day1]++;\n day_count[new_day2]++;\n \n solution.schedule[idx1] = new_day1;\n solution.schedule[idx2] = new_day2;\n }\n \n iterations++;\n }\n }\n \n // Final validation\n for (int i = 0; i < m; i++) {\n if (solution.schedule[i] < 1 || solution.schedule[i] > d) {\n solution.schedule[i] = 1;\n }\n }\n \n // Output the solution\n for (int i = 0; i < m; i++) {\n if (i > 0) cout << \" \";\n cout << solution.schedule[i];\n }\n cout << endl;\n \n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y, z;\n Point(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(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 bool operator==(const Point& other) const {\n return x == other.x && y == other.y && z == other.z;\n }\n Point operator+(const Point& other) const {\n return Point(x + other.x, y + other.y, z + other.z);\n }\n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y, z - other.z);\n }\n};\n\nnamespace std {\n template<>\n struct hash {\n size_t operator()(const Point& p) const {\n return hash()(p.x) ^ hash()(p.y) ^ hash()(p.z);\n }\n };\n}\n\nconst int dx[6] = {1, -1, 0, 0, 0, 0};\nconst int dy[6] = {0, 0, 1, -1, 0, 0};\nconst int dz[6] = {0, 0, 0, 0, 1, -1};\n\nint D;\nvector f1, r1, f2, r2;\n\nbool inBounds(const Point& p) {\n return p.x >= 0 && p.x < D && p.y >= 0 && p.y < D && p.z >= 0 && p.z < D;\n}\n\nvector getNeighbors(const Point& p) {\n vector neighbors;\n for (int i = 0; i < 6; i++) {\n Point np(p.x + dx[i], p.y + dy[i], p.z + dz[i]);\n if (inBounds(np)) {\n neighbors.push_back(np);\n }\n }\n return neighbors;\n}\n\nint toIndex(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nPoint fromIndex(int idx) {\n int x = idx / (D * D);\n int y = (idx % (D * D)) / D;\n int z = idx % D;\n return Point(x, y, z);\n}\n\nvector normalize(const vector& points) {\n if (points.empty()) return points;\n \n int min_x = points[0].x, min_y = points[0].y, min_z = points[0].z;\n for (const Point& p : points) {\n min_x = min(min_x, p.x);\n min_y = min(min_y, p.y);\n min_z = min(min_z, p.z);\n }\n \n vector normalized;\n for (const Point& p : points) {\n normalized.push_back(Point(p.x - min_x, p.y - min_y, p.z - min_z));\n }\n return normalized;\n}\n\nvector> generateRotations(const vector& shape) {\n if (shape.empty()) return {shape};\n \n vector normalized = normalize(shape);\n vector> rotations;\n \n int rotations_3d[24][9] = {\n {1,0,0, 0,1,0, 0,0,1}, {1,0,0, 0,0,-1, 0,1,0}, {1,0,0, 0,-1,0, 0,0,-1}, {1,0,0, 0,0,1, 0,-1,0},\n {-1,0,0, 0,-1,0, 0,0,1}, {-1,0,0, 0,0,-1, 0,-1,0}, {-1,0,0, 0,1,0, 0,0,-1}, {-1,0,0, 0,0,1, 0,1,0},\n {0,-1,0, 1,0,0, 0,0,1}, {0,0,1, 1,0,0, 0,1,0}, {0,1,0, -1,0,0, 0,0,1}, {0,0,-1, -1,0,0, 0,1,0},\n {0,1,0, 1,0,0, 0,0,-1}, {0,0,-1, -1,0,0, 0,-1,0}, {0,-1,0, -1,0,0, 0,0,-1}, {0,0,1, 1,0,0, 0,-1,0},\n {0,1,0, 0,0,1, 1,0,0}, {0,0,1, 0,-1,0, 1,0,0}, {0,-1,0, 0,0,-1, 1,0,0}, {0,0,-1, 0,1,0, 1,0,0},\n {0,-1,0, 0,0,1, -1,0,0}, {0,0,-1, 0,-1,0, -1,0,0}, {0,1,0, 0,0,-1, -1,0,0}, {0,0,1, 0,1,0, -1,0,0}\n };\n \n for (int i = 0; i < 24; i++) {\n vector rotated;\n for (const Point& p : normalized) {\n int nx = rotations_3d[i][0] * p.x + rotations_3d[i][1] * p.y + rotations_3d[i][2] * p.z;\n int ny = rotations_3d[i][3] * p.x + rotations_3d[i][4] * p.y + rotations_3d[i][5] * p.z;\n int nz = rotations_3d[i][6] * p.x + rotations_3d[i][7] * p.y + rotations_3d[i][8] * p.z;\n rotated.push_back(Point(nx, ny, nz));\n }\n rotations.push_back(normalize(rotated));\n }\n \n return rotations;\n}\n\nbool shapesMatch(const vector& shape1, const vector& shape2) {\n if (shape1.size() != shape2.size()) return false;\n \n auto rotations = generateRotations(shape1);\n auto normalized2 = normalize(shape2);\n set set2(normalized2.begin(), normalized2.end());\n \n for (const auto& rot : rotations) {\n set rot_set(rot.begin(), rot.end());\n if (rot_set == set2) {\n return true;\n }\n }\n \n return false;\n}\n\nbool isConnected(const vector& points) {\n if (points.empty() || points.size() == 1) return true;\n \n set pointSet(points.begin(), points.end());\n map visited;\n \n queue q;\n q.push(points[0]);\n visited[points[0]] = true;\n size_t visitedCount = 1;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (pointSet.find(neighbor) != pointSet.end() && !visited[neighbor]) {\n visited[neighbor] = true;\n visitedCount++;\n q.push(neighbor);\n }\n }\n }\n \n return visitedCount == points.size();\n}\n\nvector> splitIntoConnectedComponents(const vector& points) {\n if (points.empty()) return {};\n if (points.size() == 1) return {points};\n \n set pointSet(points.begin(), points.end());\n map visited;\n vector> components;\n \n for (const Point& p : points) {\n if (visited[p]) continue;\n \n vector component;\n queue q;\n q.push(p);\n visited[p] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n vector neighbors = getNeighbors(curr);\n for (const Point& neighbor : neighbors) {\n if (pointSet.find(neighbor) != pointSet.end() && !visited[neighbor]) {\n visited[neighbor] = true;\n q.push(neighbor);\n }\n }\n }\n \n components.push_back(component);\n }\n \n return components;\n}\n\nclass SafeOptimizedBlockSolver {\nprivate:\n int D;\n vector f1, r1, f2, r2;\n \npublic:\n SafeOptimizedBlockSolver(int D, const vector& f1, const vector& r1,\n const vector& f2, const vector& r2) \n : D(D), f1(f1), r1(r1), f2(f2), r2(r2) {}\n \n pair, vector> solve() {\n vector blockId1(D * D * D, 0);\n vector blockId2(D * D * D, 0);\n int blockCount = 0;\n \n // Get positions that need to be filled\n vector>> mustFill1(D, vector>(D, vector(D, false)));\n vector>> mustFill2(D, vector>(D, vector(D, false)));\n vector>> common(D, vector>(D, vector(D, false)));\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (f1[z][x] == '1' && r1[z][y] == '1') {\n mustFill1[x][y][z] = true;\n }\n if (f2[z][x] == '1' && r2[z][y] == '1') {\n mustFill2[x][y][z] = true;\n }\n if (mustFill1[x][y][z] && mustFill2[x][y][z]) {\n common[x][y][z] = true;\n }\n }\n }\n }\n \n // Phase 1: Create larger blocks from common positions (safely)\n blockCount = createOptimizedCommonBlocks(blockId1, blockId2, common, blockCount);\n \n // Phase 2: Fill remaining positions in arrangement 1 with smart extension\n blockCount = fillRemainingPositionsWithSmartExtension(blockId1, mustFill1, 1, blockCount);\n \n // Phase 3: Fill remaining positions in arrangement 2 with smart extension\n blockCount = fillRemainingPositionsWithSmartExtension(blockId2, mustFill2, 2, blockCount);\n \n // Phase 4: Ensure shape consistency (critical)\n auto result = ensureShapeConsistency(blockId1, blockId2, blockCount);\n \n return result;\n }\n \nprivate:\n int createOptimizedCommonBlocks(vector& blockId1, vector& blockId2,\n const vector>>& common,\n int blockCount) {\n vector>> visited(D, vector>(D, vector(D, false)));\n \n // First, create a list of common positions sorted by density\n vector> commonPositions;\n \n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (common[x][y][z]) {\n int density = 0;\n vector neighbors = getNeighbors(Point(x, y, z));\n for (const Point& n : neighbors) {\n if (n.x >= 0 && n.x < D && n.y >= 0 && n.y < D && n.z >= 0 && n.z < D && \n common[n.x][n.y][n.z]) {\n density++;\n }\n }\n commonPositions.push_back({-density, Point(x, y, z)}); // negative for max heap\n }\n }\n }\n }\n \n // Sort by density (descending)\n sort(commonPositions.begin(), commonPositions.end());\n \n // Create blocks from high-density areas first\n for (auto& cp : commonPositions) {\n Point p = cp.second;\n if (visited[p.x][p.y][p.z]) continue;\n \n // BFS to create connected block, but try to make it larger by prioritizing dense areas\n vector component;\n queue q;\n q.push(p);\n visited[p.x][p.y][p.z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n // Get neighbors and sort by density to prioritize growth in dense areas\n vector> neighborDensity;\n vector neighbors = getNeighbors(curr);\n \n for (const Point& neighbor : neighbors) {\n if (neighbor.x >= 0 && neighbor.x < D && neighbor.y >= 0 && neighbor.y < D && \n neighbor.z >= 0 && neighbor.z < D && !visited[neighbor.x][neighbor.y][neighbor.z] && \n common[neighbor.x][neighbor.y][neighbor.z]) {\n int density = 0;\n vector nneighbors = getNeighbors(neighbor);\n for (const Point& nn : nneighbors) {\n if (nn.x >= 0 && nn.x < D && nn.y >= 0 && nn.y < D && nn.z >= 0 && nn.z < D && \n common[nn.x][nn.y][nn.z]) {\n density++;\n }\n }\n neighborDensity.push_back({-density, neighbor});\n }\n }\n \n // Sort by density (descending)\n sort(neighborDensity.begin(), neighborDensity.end());\n \n // Add neighbors to queue in order of density\n for (auto& nd : neighborDensity) {\n Point neighbor = nd.second;\n visited[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n for (const Point& point : component) {\n int idx = toIndex(point.x, point.y, point.z);\n blockId1[idx] = blockCount;\n blockId2[idx] = blockCount;\n }\n }\n }\n \n return blockCount;\n }\n \n int fillRemainingPositionsWithSmartExtension(vector& blockId, \n const vector>>& mustFill,\n int arrangement, int blockCount) {\n vector>> visited(D, vector>(D, vector(D, false)));\n \n // Mark already filled positions\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; z++) {\n if (blockId[toIndex(x, y, z)] != 0) {\n visited[x][y][z] = true;\n }\n }\n }\n }\n \n // Process by layers (z-coordinate) to create more regular blocks\n for (int z = 0; z < D; z++) {\n for (int x = 0; x < D; x++) {\n for (int y = 0; y < D; y++) {\n if (mustFill[x][y][z] && !visited[x][y][z]) {\n // Try to extend to an existing adjacent block with smart scoring\n vector> candidateBlocks; // (score, blockId)\n \n vector neighbors = getNeighbors(Point(x, y, z));\n for (const Point& neighbor : neighbors) {\n if (neighbor.x >= 0 && neighbor.x < D && \n neighbor.y >= 0 && neighbor.y < D && \n neighbor.z >= 0 && neighbor.z < D) {\n int nidx = toIndex(neighbor.x, neighbor.y, neighbor.z);\n if (blockId[nidx] != 0) {\n int blockIdVal = blockId[nidx];\n \n // Calculate score for this block\n int score = 0;\n \n // 1. Prefer blocks with more adjacent cubes\n int adjacentCount = 0;\n for (const Point& adj : neighbors) {\n if (adj.x >= 0 && adj.x < D && adj.y >= 0 && adj.y < D && adj.z >= 0 && adj.z < D) {\n int adjIdx = toIndex(adj.x, adj.y, adj.z);\n if (blockId[adjIdx] == blockIdVal) {\n adjacentCount++;\n }\n }\n }\n score += adjacentCount * 10;\n \n // 2. Prefer medium-sized blocks (size 3-8)\n int blockSize = 0;\n for (int i = 0; i < D * D * D; i++) {\n if (blockId[i] == blockIdVal) {\n blockSize++;\n }\n }\n \n if (blockSize >= 3 && blockSize <= 8) {\n score += 20; // Ideal size\n } else if (blockSize < 3) {\n score += 10; // Small blocks are good to grow\n } else if (blockSize > 15) {\n score -= 10; // Penalize very large blocks\n }\n \n // 3. Small bonus for blocks that might be shared (simplified)\n if (arrangement == 1) {\n score += 5;\n }\n \n candidateBlocks.push_back({score, blockIdVal});\n }\n }\n }\n \n // Sort by score (descending)\n sort(candidateBlocks.begin(), candidateBlocks.end(), greater>());\n \n if (!candidateBlocks.empty()) {\n blockId[toIndex(x, y, z)] = candidateBlocks[0].second;\n visited[x][y][z] = true;\n } else {\n // Create a new block\n vector component;\n queue q;\n q.push(Point(x, y, z));\n visited[x][y][z] = true;\n \n while (!q.empty()) {\n Point curr = q.front();\n q.pop();\n component.push_back(curr);\n \n // Simple BFS for connectivity\n vector localNeighbors = getNeighbors(curr);\n for (const Point& neighbor : localNeighbors) {\n if (neighbor.x >= 0 && neighbor.x < D && \n neighbor.y >= 0 && neighbor.y < D && \n neighbor.z >= 0 && neighbor.z < D &&\n !visited[neighbor.x][neighbor.y][neighbor.z] && \n mustFill[neighbor.x][neighbor.y][neighbor.z]) {\n visited[neighbor.x][neighbor.y][neighbor.z] = true;\n q.push(neighbor);\n }\n }\n }\n \n if (!component.empty()) {\n blockCount++;\n for (const Point& p : component) {\n int idx = toIndex(p.x, p.y, p.z);\n blockId[idx] = blockCount;\n }\n }\n }\n }\n }\n }\n }\n \n return blockCount;\n }\n \n pair, vector> ensureShapeConsistency(vector& blockId1, vector& blockId2, int blockCount) {\n // Extract blocks\n vector> blocks1(blockCount + 1);\n vector> blocks2(blockCount + 1);\n \n for (int i = 0; i < D * D * D; i++) {\n Point p = fromIndex(i);\n if (blockId1[i] != 0) {\n blocks1[blockId1[i]].push_back(p);\n }\n if (blockId2[i] != 0) {\n blocks2[blockId2[i]].push_back(p);\n }\n }\n \n // Create final block assignments\n vector finalBlockId1(D * D * D, 0);\n vector finalBlockId2(D * D * D, 0);\n int finalBlockCount = 0;\n vector mapping1(blockCount + 1, 0);\n vector mapping2(blockCount + 1, 0);\n \n // First, handle blocks that can be shared (same shape in both arrangements)\n for (int i = 1; i <= blockCount; i++) {\n if (!blocks1[i].empty() && !blocks2[i].empty() && \n isConnected(blocks1[i]) && isConnected(blocks2[i]) && \n shapesMatch(blocks1[i], blocks2[i])) {\n finalBlockCount++;\n mapping1[i] = finalBlockCount;\n mapping2[i] = finalBlockCount;\n \n for (const Point& p : blocks1[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n for (const Point& p : blocks2[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n }\n \n // Handle remaining blocks in arrangement 1\n for (int i = 1; i <= blockCount; i++) {\n if (mapping1[i] == 0 && !blocks1[i].empty() && isConnected(blocks1[i])) {\n finalBlockCount++;\n mapping1[i] = finalBlockCount;\n for (const Point& p : blocks1[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n }\n }\n \n // Handle remaining blocks in arrangement 2\n for (int i = 1; i <= blockCount; i++) {\n if (mapping2[i] == 0 && !blocks2[i].empty() && isConnected(blocks2[i])) {\n finalBlockCount++;\n mapping2[i] = finalBlockCount;\n for (const Point& p : blocks2[i]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n }\n \n // Final validation: split any disconnected blocks\n for (int blockId = 1; blockId <= finalBlockCount; blockId++) {\n vector points1, points2;\n for (int i = 0; i < D * D * D; i++) {\n if (finalBlockId1[i] == blockId) {\n points1.push_back(fromIndex(i));\n }\n if (finalBlockId2[i] == blockId) {\n points2.push_back(fromIndex(i));\n }\n }\n \n // Check and fix connectivity for arrangement 1\n if (!points1.empty() && !isConnected(points1)) {\n auto components = splitIntoConnectedComponents(points1);\n if (components.size() > 1) {\n // Keep the first component with the original ID, assign new IDs to others\n for (size_t j = 1; j < components.size(); j++) {\n finalBlockCount++;\n for (const Point& p : components[j]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId1[idx] = finalBlockCount;\n }\n }\n }\n }\n \n // Check and fix connectivity for arrangement 2\n if (!points2.empty() && !isConnected(points2)) {\n auto components = splitIntoConnectedComponents(points2);\n if (components.size() > 1) {\n // Keep the first component with the original ID, assign new IDs to others\n for (size_t j = 1; j < components.size(); j++) {\n finalBlockCount++;\n for (const Point& p : components[j]) {\n int idx = toIndex(p.x, p.y, p.z);\n finalBlockId2[idx] = finalBlockCount;\n }\n }\n }\n }\n }\n \n return {finalBlockId1, finalBlockId2};\n }\n};\n\nint main() {\n cin >> D;\n f1.resize(D);\n r1.resize(D);\n f2.resize(D);\n r2.resize(D);\n \n for (int i = 0; i < D; i++) {\n cin >> f1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r1[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> f2[i];\n }\n for (int i = 0; i < D; i++) {\n cin >> r2[i];\n }\n \n // Use the safe optimized solver\n SafeOptimizedBlockSolver solver(D, f1, r1, f2, r2);\n auto result = solver.solve();\n \n // Count total blocks\n int maxBlockId = 0;\n for (int i = 0; i < D * D * D; i++) {\n maxBlockId = max(maxBlockId, max(result.first[i], result.second[i]));\n }\n \n // Output\n cout << maxBlockId << endl;\n \n // Output first arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << result.first[i];\n }\n cout << endl;\n \n // Output second arrangement\n for (int i = 0; i < D * D * D; i++) {\n if (i > 0) cout << \" \";\n cout << result.second[i];\n }\n cout << endl;\n \n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef long long ll;\n\nstruct Point {\n ll x, y;\n Point(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\nll distance_squared(const Point& a, const Point& b) {\n ll dx = a.x - b.x;\n ll dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\nll distance_rounded(const Point& a, const Point& b) {\n return ll(round(sqrt(distance_squared(a, b))));\n}\n\nstruct Edge {\n int u, v;\n ll weight;\n int index;\n Edge(int u = 0, int v = 0, ll weight = 0, int index = 0) : u(u), v(v), weight(weight), index(index) {}\n};\n\nstruct Resident {\n ll x, y;\n Resident(ll x = 0, ll y = 0) : x(x), y(y) {}\n};\n\n// Union-Find for MST\nstruct UnionFind {\n vector parent, rank;\n UnionFind(int n) {\n parent.resize(n);\n rank.resize(n, 0);\n for (int i = 0; i < n; ++i) parent[i] = i;\n }\n int find(int x) {\n if (parent[x] != x) parent[x] = find(parent[x]);\n return parent[x];\n }\n void unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return;\n if (rank[x] < rank[y]) parent[x] = y;\n else {\n parent[y] = x;\n if (rank[x] == rank[y]) rank[x]++;\n }\n }\n bool same(int x, int y) {\n return find(x) == find(y);\n }\n};\n\n// Dijkstra for shortest path\nvector dijkstra(const vector>>& graph, int start, int n) {\n vector dist(n + 1, LLONG_MAX);\n priority_queue, vector>, greater>> pq;\n \n dist[start] = 0;\n pq.push({0, start});\n \n while (!pq.empty()) {\n ll d = pq.top().first;\n int u = pq.top().second;\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (auto& edge : graph[u]) {\n int v = edge.first;\n ll w = edge.second;\n if (dist[u] + w < dist[v]) {\n dist[v] = dist[u] + w;\n pq.push({dist[v], v});\n }\n }\n }\n \n return dist;\n}\n\n// Calculate total cost for a solution\nll calculateTotalCost(const vector& P, const vector& B, const vector& edges) {\n ll cost = 0;\n // Add power costs\n for (size_t i = 1; i < P.size(); ++i) {\n cost += P[i] * P[i];\n }\n // Add cable costs\n for (size_t j = 1; j < B.size(); ++j) {\n if (B[j] == 1) {\n cost += edges[j-1].weight;\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, K;\n cin >> N >> M >> K;\n \n vector stations(N + 1);\n for (int i = 1; i <= N; ++i) {\n cin >> stations[i].x >> stations[i].y;\n }\n \n vector edges;\n for (int j = 1; j <= M; ++j) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n edges.push_back(Edge(u, v, w, j));\n }\n \n vector residents(K + 1);\n for (int k = 1; k <= K; ++k) {\n cin >> residents[k].x >> residents[k].y;\n }\n \n // For each resident, find the minimum radius needed from each station\n vector> minRadius(N + 1, vector(K + 1, 0));\n for (int i = 1; i <= N; ++i) {\n for (int k = 1; k <= K; ++k) {\n minRadius[i][k] = distance_rounded(\n Point(stations[i].x, stations[i].y), \n Point(residents[k].x, residents[k].y)\n );\n }\n }\n \n // Output strengths for each station\n vector P(N + 1, 0);\n \n // Edge power status\n vector B(M + 1, 0);\n \n // Build adjacency list for the graph\n vector>> graph(N + 1);\n for (auto& e : edges) {\n graph[e.u].push_back({e.v, e.weight});\n graph[e.v].push_back({e.u, e.weight});\n }\n \n // Calculate shortest distances from station 1 to all other stations\n vector distFrom1 = dijkstra(graph, 1, N);\n \n // Try multiple strategies and pick the best one\n \n // Strategy 1: Greedy by total cost (cable + power)\n vector P1(N + 1, 0);\n vector B1(M + 1, 0);\n \n // For each resident, calculate the total cost of covering them through each station\n vector>> residentCoverage(K + 1);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (distFrom1[i] != LLONG_MAX && minRadius[i][k] <= 5000) {\n ll powerCost = minRadius[i][k] * minRadius[i][k];\n ll totalCost = distFrom1[i] + powerCost;\n residentCoverage[k].push_back({totalCost, i});\n }\n }\n sort(residentCoverage[k].begin(), residentCoverage[k].end());\n }\n \n // Assign residents to stations\n vector> assignedResidents(N + 1);\n for (int k = 1; k <= K; ++k) {\n if (!residentCoverage[k].empty()) {\n int bestStation = residentCoverage[k][0].second;\n assignedResidents[bestStation].push_back(k);\n P1[bestStation] = max(P1[bestStation], minRadius[bestStation][k]);\n }\n }\n \n // Mark stations that need to be activated\n vector stationActivated(N + 1, false);\n for (int i = 1; i <= N; ++i) {\n if (!assignedResidents[i].empty()) {\n stationActivated[i] = true;\n }\n }\n stationActivated[1] = true;\n \n // Build MST to connect activated stations\n UnionFind uf(N + 1);\n vector inTree(N + 1, false);\n inTree[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (stationActivated[i]) {\n inTree[i] = true;\n }\n }\n \n // Sort edges by weight\n vector>> weightedEdges;\n for (auto& e : edges) {\n weightedEdges.push_back({e.weight, {e.u, e.v}});\n }\n sort(weightedEdges.begin(), weightedEdges.end());\n \n // Kruskal's algorithm for MST\n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree[u] && stationActivated[v]) || \n (inTree[v] && stationActivated[u]) ||\n (inTree[u] && inTree[v])) {\n if (!uf.same(u, v)) {\n uf.unite(u, v);\n inTree[u] = true;\n inTree[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B1[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity to station 1\n for (int i = 2; i <= N; ++i) {\n if (stationActivated[i] && !uf.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf.same(1, e.v)) || (e.v == i && uf.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B1[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf.unite(u, v);\n }\n }\n }\n \n // Strategy 2: Cluster-based approach\n vector P2(N + 1, 0);\n vector B2(M + 1, 0);\n \n // Group residents by proximity to stations\n vector> stationGroups(N + 1);\n for (int k = 1; k <= K; ++k) {\n int bestStation = 1;\n ll minDist = minRadius[1][k];\n \n for (int i = 2; i <= N; ++i) {\n if (minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n stationGroups[bestStation].push_back(k);\n }\n \n // Activate stations that have residents assigned\n vector activated2(N + 1, false);\n activated2[1] = true;\n \n for (int i = 1; i <= N; ++i) {\n if (!stationGroups[i].empty()) {\n activated2[i] = true;\n // Calculate required power for this station\n for (int k : stationGroups[i]) {\n P2[i] = max(P2[i], minRadius[i][k]);\n }\n }\n }\n \n // Connect activated stations with MST\n UnionFind uf2(N + 1);\n vector inTree2(N + 1, false);\n inTree2[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (activated2[i]) {\n inTree2[i] = true;\n }\n }\n \n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree2[u] && activated2[v]) || \n (inTree2[v] && activated2[u]) ||\n (inTree2[u] && inTree2[v])) {\n if (!uf2.same(u, v)) {\n uf2.unite(u, v);\n inTree2[u] = true;\n inTree2[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B2[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity\n for (int i = 2; i <= N; ++i) {\n if (activated2[i] && !uf2.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf2.same(1, e.v)) || (e.v == i && uf2.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B2[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf2.unite(u, v);\n }\n }\n }\n \n // Strategy 3: Balanced approach - minimize sum of squares with constraint on cable cost\n vector P3(N + 1, 0);\n vector B3(M + 1, 0);\n \n // For each station, calculate efficiency: residents covered per power cost\n vector> stationEfficiency;\n for (int i = 1; i <= N; ++i) {\n if (i == 1) continue; // Always include station 1\n \n // Calculate how many residents this station can cover with reasonable power\n int residentsCovered = 0;\n ll minPowerNeeded = 0;\n \n for (int k = 1; k <= K; ++k) {\n if (minRadius[i][k] <= 2000) { // Reasonable radius\n residentsCovered++;\n minPowerNeeded = max(minPowerNeeded, minRadius[i][k]);\n }\n }\n \n if (residentsCovered > 0 && distFrom1[i] != LLONG_MAX) {\n double efficiency = (double)residentsCovered / (double)(minPowerNeeded * minPowerNeeded + distFrom1[i]);\n stationEfficiency.push_back({efficiency, i});\n }\n }\n \n // Sort by efficiency (descending)\n sort(stationEfficiency.rbegin(), stationEfficiency.rend());\n \n // Greedily select stations based on efficiency\n vector activated3(N + 1, false);\n activated3[1] = true;\n vector residentCovered3(K + 1, false);\n \n // Start by covering residents with station 1\n for (int k = 1; k <= K; ++k) {\n if (minRadius[1][k] <= 5000) {\n P3[1] = max(P3[1], minRadius[1][k]);\n residentCovered3[k] = true;\n }\n }\n \n // Add stations based on efficiency until all residents are covered\n for (auto& eff : stationEfficiency) {\n int i = eff.second;\n \n // Check if we still need to cover residents\n bool allCovered = true;\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k]) {\n allCovered = false;\n break;\n }\n }\n if (allCovered) break;\n \n // Check if this station can cover uncovered residents\n bool canCover = false;\n ll requiredPower = 0;\n \n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k] && minRadius[i][k] <= 5000) {\n canCover = true;\n requiredPower = max(requiredPower, minRadius[i][k]);\n }\n }\n \n if (canCover) {\n activated3[i] = true;\n P3[i] = requiredPower;\n \n // Mark covered residents\n for (int k = 1; k <= K; ++k) {\n if (minRadius[i][k] <= requiredPower) {\n residentCovered3[k] = true;\n }\n }\n }\n }\n \n // For any remaining uncovered residents, assign to closest activated station\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered3[k]) {\n ll minDist = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (activated3[i] && minRadius[i][k] < minDist) {\n minDist = minRadius[i][k];\n bestStation = i;\n }\n }\n \n if (bestStation != -1) {\n P3[bestStation] = max(P3[bestStation], minDist);\n residentCovered3[k] = true;\n }\n }\n }\n \n // Connect activated stations with MST\n UnionFind uf3(N + 1);\n vector inTree3(N + 1, false);\n inTree3[1] = true;\n for (int i = 1; i <= N; ++i) {\n if (activated3[i]) {\n inTree3[i] = true;\n }\n }\n \n for (auto& edge : weightedEdges) {\n ll weight = edge.first;\n int u = edge.second.first;\n int v = edge.second.second;\n \n if ((inTree3[u] && activated3[v]) || \n (inTree3[v] && activated3[u]) ||\n (inTree3[u] && inTree3[v])) {\n if (!uf3.same(u, v)) {\n uf3.unite(u, v);\n inTree3[u] = true;\n inTree3[v] = true;\n \n for (auto& e : edges) {\n if ((e.u == u && e.v == v) || (e.u == v && e.v == u)) {\n B3[e.index] = 1;\n break;\n }\n }\n }\n }\n }\n \n // Ensure connectivity\n for (int i = 2; i <= N; ++i) {\n if (activated3[i] && !uf3.same(1, i)) {\n ll minCost = LLONG_MAX;\n int bestEdge = -1;\n \n for (auto& e : edges) {\n if ((e.u == i && uf3.same(1, e.v)) || (e.v == i && uf3.same(1, e.u))) {\n if (e.weight < minCost) {\n minCost = e.weight;\n bestEdge = e.index;\n }\n }\n }\n \n if (bestEdge != -1) {\n B3[bestEdge] = 1;\n int u = edges[bestEdge - 1].u;\n int v = edges[bestEdge - 1].v;\n uf3.unite(u, v);\n }\n }\n }\n \n // Calculate costs for each strategy\n ll cost1 = calculateTotalCost(P1, B1, edges);\n ll cost2 = calculateTotalCost(P2, B2, edges);\n ll cost3 = calculateTotalCost(P3, B3, edges);\n \n // Verify coverage for each strategy\n auto verifyCoverage = [&](const vector& P, const vector& inTree) -> bool {\n vector covered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (inTree[i] && minRadius[i][k] <= P[i]) {\n covered[k] = true;\n break;\n }\n }\n }\n \n for (int k = 1; k <= K; ++k) {\n if (!covered[k]) return false;\n }\n return true;\n };\n \n vector inTree1(N + 1, false);\n for (int i = 1; i <= N; ++i) {\n inTree1[i] = (i == 1) || stationActivated[i];\n }\n // Update inTree1 based on actual connectivity\n UnionFind uf_check1(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B1[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check1.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree1[i] = uf_check1.same(1, i);\n }\n \n vector inTree2_vec(N + 1, false);\n UnionFind uf_check2(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B2[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check2.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree2_vec[i] = uf_check2.same(1, i);\n }\n \n vector inTree3_vec(N + 1, false);\n UnionFind uf_check3(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B3[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_check3.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n inTree3_vec[i] = uf_check3.same(1, i);\n }\n \n bool coverage1 = verifyCoverage(P1, inTree1);\n bool coverage2 = verifyCoverage(P2, inTree2_vec);\n bool coverage3 = verifyCoverage(P3, inTree3_vec);\n \n // Choose the best strategy\n if (coverage1 && coverage2 && coverage3) {\n if (cost1 <= cost2 && cost1 <= cost3) {\n P = P1;\n B = B1;\n } else if (cost2 <= cost1 && cost2 <= cost3) {\n P = P2;\n B = B2;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage1 && coverage2) {\n if (cost1 <= cost2) {\n P = P1;\n B = B1;\n } else {\n P = P2;\n B = B2;\n }\n } else if (coverage1 && coverage3) {\n if (cost1 <= cost3) {\n P = P1;\n B = B1;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage2 && coverage3) {\n if (cost2 <= cost3) {\n P = P2;\n B = B2;\n } else {\n P = P3;\n B = B3;\n }\n } else if (coverage1) {\n P = P1;\n B = B1;\n } else if (coverage2) {\n P = P2;\n B = B2;\n } else if (coverage3) {\n P = P3;\n B = B3;\n }\n \n // Final verification and fix: ensure all residents are covered\n vector finalInTree(N + 1, false);\n UnionFind uf_final(N + 1);\n for (int j = 1; j <= M; ++j) {\n if (B[j] == 1) {\n int u = edges[j-1].u;\n int v = edges[j-1].v;\n uf_final.unite(u, v);\n }\n }\n for (int i = 1; i <= N; ++i) {\n finalInTree[i] = uf_final.same(1, i);\n }\n \n vector residentCovered(K + 1, false);\n for (int k = 1; k <= K; ++k) {\n for (int i = 1; i <= N; ++i) {\n if (finalInTree[i] && minRadius[i][k] <= P[i]) {\n residentCovered[k] = true;\n break;\n }\n }\n }\n \n // Fix uncovered residents\n for (int k = 1; k <= K; ++k) {\n if (!residentCovered[k]) {\n ll minExtraCost = LLONG_MAX;\n int bestStation = -1;\n \n for (int i = 1; i <= N; ++i) {\n if (finalInTree[i]) {\n ll newPower = max(P[i], minRadius[i][k]);\n ll extraCost = newPower * newPower - P[i] * P[i];\n \n if (extraCost < minExtraCost) {\n minExtraCost = extraCost;\n bestStation = i;\n }\n }\n }\n \n if (bestStation != -1) {\n P[bestStation] = max(P[bestStation], minRadius[bestStation][k]);\n }\n }\n }\n \n // Output the solution\n for (int i = 1; i <= N; ++i) {\n if (i > 1) cout << \" \";\n cout << P[i];\n }\n cout << endl;\n \n for (int j = 1; j <= M; ++j) {\n if (j > 1) cout << \" \";\n cout << B[j];\n }\n cout << endl;\n \n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_OPS = 9800; // Very conservative limit\n\n// Pyramid representation\nvector> pyramid;\n\n// Directions for adjacent positions (6 directions)\nvector> dirs = {\n {-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}\n};\n\n// Check if coordinates are valid\nbool valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y <= x;\n}\n\n// Check if swap is valid (adjacent in 6 directions)\nbool can_swap(int x1, int y1, int x2, int y2) {\n if (!valid(x1, y1) || !valid(x2, y2)) return false;\n \n for (auto& dir : dirs) {\n int nx = x1 + dir.first;\n int ny = y1 + dir.second;\n if (nx == x2 && ny == y2) {\n return true;\n }\n }\n return false;\n}\n\n// Perform swap and record operation\nvoid perform_swap(int x1, int y1, int x2, int y2, vector>& ops) {\n if (!can_swap(x1, y1, x2, y2)) {\n return;\n }\n \n swap(pyramid[x1][y1], pyramid[x2][y2]);\n ops.push_back({x1, y1, x2, y2});\n}\n\n// Count violations and get maximum difference\npair analyze_violations() {\n int violations = 0;\n int max_diff = 0;\n \n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current > left_child) {\n violations++;\n max_diff = max(max_diff, current - left_child);\n }\n if (current > right_child) {\n violations++;\n max_diff = max(max_diff, current - right_child);\n }\n }\n }\n return {violations, max_diff};\n}\n\n// Main solution\nvoid solve() {\n // Read input\n pyramid.resize(N);\n for (int i = 0; i < N; i++) {\n pyramid[i].resize(i + 1);\n for (int j = 0; j <= i; j++) {\n cin >> pyramid[i][j];\n }\n }\n \n vector> operations;\n \n // Skip Phase 1 - no initial repositioning\n \n // Phase 2: Multiple bottom-up passes with increasing focus\n auto [initial_violations, max_diff] = analyze_violations();\n \n for (int pass = 0; pass < 15 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n \n // Bottom-up pass\n for (int x = N - 2; x >= 0; x--) {\n for (int y = 0; y <= x; y++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n // Focus on larger violations first\n int left_diff = current_value - left_child;\n int right_diff = current_value - right_child;\n \n if (left_diff > 0 || right_diff > 0) {\n // Always swap with the smaller child\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n }\n \n // Check if we've fixed all violations\n auto [current_violations, _] = analyze_violations();\n if (current_violations == 0) break;\n \n // If no changes and still violations, try top-down\n if (!changed && operations.size() < MAX_OPS) {\n bool top_down_changed = false;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n top_down_changed = true;\n }\n }\n }\n }\n \n if (!top_down_changed) {\n // Try another bottom-up pass with more aggressive approach\n for (int x = N - 2; x >= 0; x--) {\n for (int y = x; y >= 0; y--) { // Reverse order within level\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n }\n }\n }\n }\n }\n }\n }\n \n // Phase 3: Aggressive fixing for remaining violations\n for (int pass = 0; pass < 5 && operations.size() < MAX_OPS; pass++) {\n auto [remaining_violations, _] = analyze_violations();\n if (remaining_violations == 0) break;\n \n bool changed = false;\n \n // Prioritize violations with largest differences\n vector>> violation_list;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n int max_diff = 0;\n if (current_value > left_child) max_diff = max(max_diff, current_value - left_child);\n if (current_value > right_child) max_diff = max(max_diff, current_value - right_child);\n \n if (max_diff > 0) {\n violation_list.push_back({-max_diff, {x, y}}); // Negative for sorting\n }\n }\n }\n \n sort(violation_list.begin(), violation_list.end());\n \n // Fix top 50% of violations by difference\n int fix_count = min(20, (int)violation_list.size());\n for (int i = 0; i < fix_count && operations.size() < MAX_OPS; i++) {\n int x = violation_list[i].second.first;\n int y = violation_list[i].second.second;\n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n \n if (!changed) break;\n }\n \n // Phase 4: Final cleanup - ensure no violations remain\n for (int pass = 0; pass < 3 && operations.size() < MAX_OPS; pass++) {\n bool changed = false;\n for (int x = 0; x < N - 1; x++) {\n for (int y = 0; y <= x; y++) {\n if (operations.size() >= MAX_OPS) break;\n \n int current_value = pyramid[x][y];\n int left_child = pyramid[x + 1][y];\n int right_child = pyramid[x + 1][y + 1];\n \n if (current_value > left_child || current_value > right_child) {\n int smaller_child = min(left_child, right_child);\n int smaller_child_y = (left_child <= right_child) ? y : y + 1;\n \n if (current_value > smaller_child) {\n perform_swap(x, y, x + 1, smaller_child_y, operations);\n changed = true;\n }\n }\n }\n }\n if (!changed) break;\n }\n \n // Output operations\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << op[0] << \" \" << op[1] << \" \" << op[2] << \" \" << op[3] << endl;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n solve();\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nconst int entrance_i = 0, entrance_j = 4;\n\n// Directions for 4-connectivity\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n};\n\nclass Warehouse {\nprivate:\n vector> grid; // -1: empty, -2: obstacle, -3: entrance, >=0: container number\n vector> obstacles;\n int N;\n map container_positions; // Map from position to container number\n \npublic:\n Warehouse(int n) : N(n) {\n grid.assign(D, vector(D, -1));\n obstacles.assign(D, vector(D, false));\n // Mark entrance\n grid[entrance_i][entrance_j] = -3;\n }\n \n void add_obstacle(int i, int j) {\n obstacles[i][j] = true;\n grid[i][j] = -2;\n }\n \n bool is_valid(int i, int j) {\n return i >= 0 && i < D && j >= 0 && j < D;\n }\n \n bool is_empty(int i, int j) {\n return is_valid(i, j) && grid[i][j] == -1 && !obstacles[i][j] && !(i == entrance_i && j == entrance_j);\n }\n \n // BFS to find all reachable empty positions from entrance\n vector get_reachable_empty_positions() {\n vector> visited(D, vector(D, false));\n queue q;\n vector reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n // Check 4 adjacent squares\n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] == -1) { // Empty square\n reachable.push_back(Position(ni, nj));\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] >= 0) { // Container square - can traverse through it for reachability\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Calculate Manhattan distance from entrance\n int distance_from_entrance(int i, int j) {\n return abs(i - entrance_i) + abs(j - entrance_j);\n }\n \n // Estimate how many positions would become unreachable if we place a container at (i,j)\n int blocking_score(int i, int j) {\n if (!is_empty(i, j)) return INT_MAX;\n \n // Temporarily place a container here\n int original = grid[i][j];\n grid[i][j] = 999; // Temporary container\n \n // Count reachable positions\n vector reachable = get_reachable_empty_positions();\n int reachable_count = reachable.size();\n \n // Restore\n grid[i][j] = original;\n \n // Higher score means more blocking (worse)\n return (D*D - 1 - N - reachable_count);\n }\n \n // Place container with number t at position (i, j)\n void place_container(int t, int i, int j) {\n grid[i][j] = t;\n container_positions[Position(i, j)] = t;\n }\n \n // Get all currently reachable containers\n vector> get_reachable_containers() {\n vector> visited(D, vector(D, false));\n queue q;\n vector> reachable;\n \n q.push(Position(entrance_i, entrance_j));\n visited[entrance_i][entrance_j] = true;\n \n while (!q.empty()) {\n Position curr = q.front();\n q.pop();\n \n for (int d = 0; d < 4; d++) {\n int ni = curr.i + di[d];\n int nj = curr.j + dj[d];\n \n if (is_valid(ni, nj) && !visited[ni][nj] && !obstacles[ni][nj]) {\n visited[ni][nj] = true;\n if (grid[ni][nj] >= 0) { // Container\n reachable.push_back({Position(ni, nj), grid[ni][nj]});\n q.push(Position(ni, nj));\n } else if (grid[ni][nj] == -1) { // Empty\n q.push(Position(ni, nj));\n }\n }\n }\n }\n \n return reachable;\n }\n \n // Get all containers sorted by their numbers\n vector> get_all_containers_sorted() {\n vector> containers;\n for (auto& p : container_positions) {\n containers.push_back({p.first, p.second});\n }\n sort(containers.begin(), containers.end(), [](const auto& a, const auto& b) {\n return a.second < b.second;\n });\n return containers;\n }\n};\n\nint main() {\n int N;\n cin >> D >> N; // Note: D is always 9 per problem statement\n \n Warehouse warehouse(N);\n \n // Read obstacles\n for (int i = 0; i < N; i++) {\n int ri, rj;\n cin >> ri >> rj;\n warehouse.add_obstacle(ri, rj);\n }\n \n vector arrived_containers;\n vector> placement_positions; // Store where each container was placed\n \n // Process each incoming container\n for (int d = 0; d < D*D - 1 - N; d++) {\n int t;\n cin >> t;\n arrived_containers.push_back(t);\n \n // Get all reachable empty positions\n vector reachable = warehouse.get_reachable_empty_positions();\n \n if (reachable.empty()) {\n // This shouldn't happen according to problem constraints\n // Just pick any empty position\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (warehouse.is_empty(i, j)) {\n cout << i << \" \" << j << endl;\n warehouse.place_container(t, i, j);\n placement_positions.push_back({i, j});\n goto placed;\n }\n }\n }\n }\n \n // Calculate statistics for decision making\n double avg_so_far = 0.0;\n if (d > 0) {\n for (int i = 0; i < d; i++) {\n avg_so_far += arrived_containers[i];\n }\n avg_so_far /= d;\n }\n \n // Score each reachable position\n vector> position_scores;\n for (auto& pos : reachable) {\n // Base score: distance from entrance (want smaller for smaller t)\n double distance_score = warehouse.distance_from_entrance(pos.i, pos.j);\n \n // Priority factor: if t is smaller than average, we want closer positions\n double priority_factor = 1.0;\n if (d > 0) {\n if (t < avg_so_far) {\n // This container should be removed earlier, so give it higher priority (lower score)\n priority_factor = 0.5;\n } else {\n // This container should be removed later, so lower priority (higher score)\n priority_factor = 2.0;\n }\n }\n \n // Blocking score: how much this placement would block other positions\n int block_score = warehouse.blocking_score(pos.i, pos.j);\n \n // Total score (lower is better)\n double total_score = distance_score * priority_factor + block_score * 0.1;\n \n position_scores.push_back({total_score, pos});\n }\n \n // Choose position with minimum score\n sort(position_scores.begin(), position_scores.end());\n Position chosen = position_scores[0].second;\n \n cout << chosen.i << \" \" << chosen.j << endl;\n cout.flush(); // Important: flush output\n \n warehouse.place_container(t, chosen.i, chosen.j);\n placement_positions.push_back({chosen.i, chosen.j});\n \n placed:; // Label for goto\n }\n \n // Determine removal order\n vector> containers_sorted = warehouse.get_all_containers_sorted();\n \n // Output removal order (by container number, ascending)\n for (auto& p : containers_sorted) {\n cout << p.first.i << \" \" << p.first.j << endl;\n }\n \n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nconst int M = 100;\n\nint main() {\n int n = N, m = M;\n vector> grid(n, vector(n));\n \n // Read input\n cin >> n >> m;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n \n // Determine adjacencies\n vector> adj(m + 1); // adj[c] contains colors adjacent to color c\n vector adj_to_external(m + 1, false); // whether color c is adjacent to external (0)\n \n // Check adjacencies in the original grid\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n \n // Check if adjacent to boundary (external)\n if (i == 0 || i == n - 1 || j == 0 || j == n - 1) {\n adj_to_external[c] = true;\n }\n \n // Check 4-directional neighbors\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int d = grid[ni][nj];\n if (c != d) {\n adj[c].insert(d);\n adj[d].insert(c);\n }\n } else {\n // Adjacent to external\n adj_to_external[c] = true;\n adj[c].insert(0);\n // Note: We don't add to adj[0] as it's external and always connected\n }\n }\n }\n }\n \n // Create output grid, initially all color 0\n vector> result(n, vector(n, 0));\n \n // Strategy: Place one tile per color in a compact arrangement\n // Start by placing colors that need to be adjacent to external on the boundary\n \n vector colors;\n for (int i = 1; i <= m; i++) {\n colors.push_back(i);\n }\n \n // Sort colors by number of adjacencies (descending) to place high-degree nodes first\n sort(colors.begin(), colors.end(), [&](int a, int b) {\n return adj[a].size() > adj[b].size();\n });\n \n // Place colors on the grid\n int placed = 0;\n bool placed_grid[N][N] = {false};\n \n // First, try to place on the boundary for colors adjacent to external\n vector> boundary_positions;\n for (int i = 0; i < n; i++) {\n boundary_positions.push_back({i, 0});\n boundary_positions.push_back({i, n-1});\n }\n for (int j = 1; j < n-1; j++) {\n boundary_positions.push_back({0, j});\n boundary_positions.push_back({n-1, j});\n }\n \n int boundary_idx = 0;\n \n // Place colors adjacent to external on boundary\n for (int color : colors) {\n if (adj_to_external[color] && boundary_idx < boundary_positions.size()) {\n int x = boundary_positions[boundary_idx].first;\n int y = boundary_positions[boundary_idx].second;\n result[x][y] = color;\n placed_grid[x][y] = true;\n boundary_idx++;\n placed++;\n }\n }\n \n // Place remaining colors in the interior\n for (int color : colors) {\n if (placed >= m) break;\n \n bool already_placed = false;\n for (int i = 0; i < n && !already_placed; i++) {\n for (int j = 0; j < n && !already_placed; j++) {\n if (result[i][j] == color) {\n already_placed = true;\n }\n }\n }\n \n if (already_placed) continue;\n \n // Find a position to place this color\n bool placed_color = false;\n \n // Try to place adjacent to already placed colors it should be adjacent to\n for (int c : adj[color]) {\n if (c == 0) continue; // Skip external\n \n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (result[i][j] == c) {\n // Try to place adjacent to this tile\n int dx[] = {0, 1, 0, -1};\n int dy[] = {1, 0, -1, 0};\n \n for (int k = 0; k < 4; k++) {\n int ni = i + dx[k];\n int nj = j + dy[k];\n \n if (ni >= 0 && ni < n && nj >= 0 && nj < n && !placed_grid[ni][nj]) {\n result[ni][nj] = color;\n placed_grid[ni][nj] = true;\n placed_color = true;\n placed++;\n break;\n }\n }\n }\n }\n }\n \n if (placed_color) break;\n }\n \n // If couldn't place adjacent to any adjacent color, place anywhere available\n if (!placed_color) {\n for (int i = 0; i < n && !placed_color; i++) {\n for (int j = 0; j < n && !placed_color; j++) {\n if (!placed_grid[i][j]) {\n result[i][j] = color;\n placed_grid[i][j] = true;\n placed_color = true;\n placed++;\n }\n }\n }\n }\n }\n \n // Output the result\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cout << result[i][j];\n if (j < n - 1) cout << \" \";\n }\n cout << endl;\n }\n \n return 0;\n}","ahc025":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nclass SimpleWeightEstimator {\nprivate:\n int n;\n vector weights;\n vector> win_counts; // win_counts[i][j] tracks direct comparisons\n \npublic:\n SimpleWeightEstimator(int size) : n(size), weights(size, 1.0), win_counts(size, vector(size, 0)) {}\n \n void add_comparison(int i, int j, const string& result) {\n if (result == \">\") {\n win_counts[i][j] = 1;\n win_counts[j][i] = -1;\n } else if (result == \"<\") {\n win_counts[i][j] = -1;\n win_counts[j][i] = 1;\n } else { // \"=\"\n win_counts[i][j] = 0;\n win_counts[j][i] = 0;\n }\n }\n \n // Simple but effective weight estimation\n void estimate_weights() {\n // Start with uniform weights\n fill(weights.begin(), weights.end(), 1.0);\n \n // Use iterative method based on direct comparisons\n const int max_iterations = 30; // Reduced iterations for stability\n const double learning_rate = 0.2;\n \n for (int iter = 0; iter < max_iterations; ++iter) {\n vector new_weights = weights;\n bool significant_change = false;\n \n for (int i = 0; i < n; ++i) {\n double total_adjustment = 0.0;\n int comparison_count = 0;\n \n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n \n if (win_counts[i][j] != 0) {\n double expected_ratio = weights[i] / (weights[i] + weights[j]);\n double target_ratio = 0.5; // default\n \n if (win_counts[i][j] == 1) {\n target_ratio = 0.8; // i is heavier\n } else if (win_counts[i][j] == -1) {\n target_ratio = 0.2; // i is lighter\n }\n \n double error = target_ratio - expected_ratio;\n total_adjustment += error * weights[j];\n comparison_count++;\n }\n }\n \n if (comparison_count > 0) {\n double adjustment = total_adjustment / comparison_count;\n new_weights[i] += learning_rate * adjustment;\n new_weights[i] = max(0.1, new_weights[i]);\n \n if (abs(adjustment) > 0.01) {\n significant_change = true;\n }\n }\n }\n \n weights = new_weights;\n \n // Early termination if no significant changes\n if (!significant_change && iter > 10) {\n break;\n }\n }\n \n // Ensure all weights are positive\n double min_weight = *min_element(weights.begin(), weights.end());\n if (min_weight < 0.1) {\n double offset = 0.1 - min_weight;\n for (int i = 0; i < n; ++i) {\n weights[i] += offset;\n }\n }\n }\n \n vector get_all_weights() const {\n return weights;\n }\n \n // Get win-loss record for fallback\n vector get_win_loss_record() const {\n vector records(n, 0);\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n records[i] += win_counts[i][j];\n }\n }\n return records;\n }\n \n bool has_been_compared(int i, int j) const {\n return win_counts[i][j] != 0;\n }\n};\n\nclass Timer {\nprivate:\n steady_clock::time_point start_time;\n double time_limit_sec;\n \npublic:\n Timer(double limit = 1.75) : time_limit_sec(limit) {\n start_time = steady_clock::now();\n }\n \n double elapsed() {\n auto now = steady_clock::now();\n return duration_cast>(now - start_time).count();\n }\n \n bool is_time_critical() {\n return elapsed() > time_limit_sec;\n }\n};\n\n// Improved partitioning with better greedy approach\nvector optimized_partitioning(const vector& weights, int D, Timer& timer) {\n int n = weights.size();\n vector assignment(n, 0);\n \n if (D == 1) return assignment;\n \n // Create list of items with weights\n vector> weighted_items;\n for (int i = 0; i < n; ++i) {\n weighted_items.push_back({weights[i], i});\n }\n \n // Sort in descending order (heaviest first)\n sort(weighted_items.rbegin(), weighted_items.rend());\n \n // Initialize set weights\n vector set_weights(D, 0.0);\n \n // Greedy assignment with enhanced set selection\n for (auto& item : weighted_items) {\n if (timer.is_time_critical()) break;\n \n double item_weight = item.first;\n int item_idx = item.second;\n \n // Find the set with minimum current weight\n int best_set = 0;\n double min_weight = set_weights[0];\n \n for (int j = 1; j < D; ++j) {\n if (set_weights[j] < min_weight) {\n min_weight = set_weights[j];\n best_set = j;\n }\n }\n \n assignment[item_idx] = best_set;\n set_weights[best_set] += item_weight;\n }\n \n // Early return if time is critical\n if (timer.is_time_critical()) {\n return assignment;\n }\n \n // Local search with item reassignment (simplified)\n const int max_reassignments = min(n * 2, 50);\n double improvement_threshold = 0.01; // 1% improvement threshold\n \n // Calculate current variance\n auto calculate_variance = [](const vector& set_weights) {\n double mean = accumulate(set_weights.begin(), set_weights.end(), 0.0) / set_weights.size();\n double variance = 0.0;\n for (double w : set_weights) {\n variance += (w - mean) * (w - mean);\n }\n return variance / set_weights.size();\n };\n \n double current_variance = calculate_variance(set_weights);\n \n for (int iter = 0; iter < max_reassignments; ++iter) {\n if (timer.is_time_critical()) break;\n \n // Try moving each item to every other set\n bool improved = false;\n \n for (int item_idx = 0; item_idx < n && !improved; ++item_idx) {\n int current_set = assignment[item_idx];\n double item_weight = weights[item_idx];\n \n if (set_weights[current_set] - item_weight < 0) continue;\n \n // Try moving to other sets\n for (int new_set = 0; new_set < D && !improved; ++new_set) {\n if (new_set == current_set) continue;\n \n // Calculate variance after move\n vector new_set_weights = set_weights;\n new_set_weights[current_set] -= item_weight;\n new_set_weights[new_set] += item_weight;\n \n double new_variance = calculate_variance(new_set_weights);\n \n // Accept move if it improves variance significantly\n if (new_variance < current_variance * (1.0 - improvement_threshold)) {\n assignment[item_idx] = new_set;\n set_weights = new_set_weights;\n current_variance = new_variance;\n improved = true;\n }\n }\n }\n \n if (!improved) break; // No more significant improvements\n }\n \n // Additional local search: swap pairs of items between sets\n if (!timer.is_time_critical()) {\n const int max_swaps = min(n, 20);\n \n for (int iter = 0; iter < max_swaps; ++iter) {\n if (timer.is_time_critical()) break;\n \n // Pick two random items from different sets\n int item1 = -1, item2 = -1;\n int set1 = -1, set2 = -1;\n \n // Try to find two items from different sets\n for (int attempts = 0; attempts < 10 && (item1 == -1 || item2 == -1); ++attempts) {\n item1 = rand() % n;\n item2 = rand() % n;\n if (item1 == item2) continue;\n \n set1 = assignment[item1];\n set2 = assignment[item2];\n if (set1 != set2) break;\n \n item1 = -1; // reset if same set\n }\n \n if (item1 == -1 || item2 == -1 || set1 == set2) continue;\n \n double w1 = weights[item1];\n double w2 = weights[item2];\n \n // Calculate current variance\n double mean = accumulate(set_weights.begin(), set_weights.end(), 0.0) / D;\n double old_variance = 0.0;\n for (double w : set_weights) {\n old_variance += (w - mean) * (w - mean);\n }\n old_variance /= D;\n \n // Calculate variance after swap\n vector new_set_weights = set_weights;\n new_set_weights[set1] = new_set_weights[set1] - w1 + w2;\n new_set_weights[set2] = new_set_weights[set2] - w2 + w1;\n \n double new_variance = 0.0;\n double new_mean = accumulate(new_set_weights.begin(), new_set_weights.end(), 0.0) / D;\n for (double w : new_set_weights) {\n new_variance += (w - new_mean) * (w - new_mean);\n }\n new_variance /= D;\n \n // Accept swap if it improves variance\n if (new_variance < old_variance) {\n assignment[item1] = set2;\n assignment[item2] = set1;\n set_weights = new_set_weights;\n }\n }\n }\n \n return assignment;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, D, Q;\n cin >> N >> D >> Q;\n \n // Initialize random seed\n auto seed = steady_clock::now().time_since_epoch().count();\n srand(seed);\n \n // Start timer\n Timer timer(1.7);\n \n // Create weight estimator\n SimpleWeightEstimator estimator(N);\n \n // Phase 1: Strategic information gathering\n int queries_used = 0;\n \n // Step 1: Basic pairwise comparisons for initial ordering\n if (!timer.is_time_critical()) {\n vector items(N);\n iota(items.begin(), items.end(), 0);\n shuffle(items.begin(), items.end(), default_random_engine(seed));\n \n // Compare each item with the next one in shuffled order\n for (int i = 0; i < N - 1 && queries_used < min(Q/4, N); ++i) {\n if (timer.is_time_critical()) break;\n \n cout << \"1 1 \" << items[i] << \" \" << items[i + 1] << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(items[i], items[i + 1], result);\n queries_used++;\n }\n }\n \n // Step 2: Refine ordering with additional comparisons\n if (queries_used < Q * 2 / 3 && !timer.is_time_critical()) {\n // Get initial weight estimates\n estimator.estimate_weights();\n vector current_weights = estimator.get_all_weights();\n \n // Create ordered list\n vector> weighted_items;\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n \n // Compare items that are close in the current ordering\n for (int i = 0; i < N - 1 && queries_used < Q * 2 / 3; ++i) {\n if (timer.is_time_critical()) break;\n \n // Compare with items within 2 positions\n for (int j = 1; j <= 2 && i + j < N && queries_used < Q * 2 / 3; ++j) {\n if (timer.is_time_critical()) break;\n \n int item1 = weighted_items[i].second;\n int item2 = weighted_items[i + j].second;\n \n // Skip if already compared\n if (estimator.has_been_compared(item1, item2)) continue;\n \n cout << \"1 1 \" << item1 << \" \" << item2 << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(item1, item2, result);\n queries_used++;\n }\n }\n }\n \n // Step 3: Group comparisons for global calibration\n if (queries_used < Q * 4 / 5 && !timer.is_time_critical()) {\n // Update weights\n estimator.estimate_weights();\n vector current_weights = estimator.get_all_weights();\n \n // Create ordered list\n vector> weighted_items;\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n \n // Create groups of similar-weight items\n int num_groups = min(D, max(2, N / 5));\n vector> groups(num_groups);\n for (int i = 0; i < N; ++i) {\n groups[i % num_groups].push_back(weighted_items[i].second);\n }\n \n // Compare representative items from different groups\n for (int i = 0; i < num_groups && queries_used < Q * 4 / 5; ++i) {\n if (timer.is_time_critical()) break;\n \n if (groups[i].empty()) continue;\n \n // Use first item as representative\n int rep_i = groups[i][0];\n \n for (int j = 0; j < num_groups && queries_used < Q * 4 / 5; ++j) {\n if (timer.is_time_critical()) break;\n \n if (i == j || groups[j].empty()) continue;\n int rep_j = groups[j][0];\n \n // Skip if already compared\n if (estimator.has_been_compared(rep_i, rep_j)) continue;\n \n cout << \"1 1 \" << rep_i << \" \" << rep_j << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(rep_i, rep_j, result);\n queries_used++;\n }\n }\n }\n \n // Step 4: Use remaining queries for most informative comparisons\n if (!timer.is_time_critical()) {\n // Update weights\n estimator.estimate_weights();\n vector current_weights = estimator.get_all_weights();\n \n // Create ordered list\n vector> weighted_items;\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n \n // While we have queries remaining\n while (queries_used < Q && !timer.is_time_critical()) {\n // Find pair of items with most similar estimated weights that haven't been compared\n int best_i = -1, best_j = -1;\n double min_diff = numeric_limits::max();\n \n for (int i = 0; i < N - 1; ++i) {\n for (int j = i + 1; j < N; ++j) {\n int item_i = weighted_items[i].second;\n int item_j = weighted_items[j].second;\n \n if (!estimator.has_been_compared(item_i, item_j)) {\n double diff = abs(weighted_items[i].first - weighted_items[j].first);\n if (diff < min_diff) {\n min_diff = diff;\n best_i = item_i;\n best_j = item_j;\n }\n }\n }\n }\n \n // If no un-compared pair found, pick random pair\n if (best_i == -1 || best_j == -1) {\n best_i = rand() % N;\n best_j = rand() % N;\n if (best_j == best_i) {\n best_j = (best_i + 1) % N;\n }\n }\n \n cout << \"1 1 \" << best_i << \" \" << best_j << endl;\n cout.flush();\n \n string result;\n cin >> result;\n \n estimator.add_comparison(best_i, best_j, result);\n queries_used++;\n \n // Update weights every 3 queries\n if (queries_used % 3 == 0) {\n estimator.estimate_weights();\n current_weights = estimator.get_all_weights();\n \n // Recreate ordered list\n weighted_items.clear();\n for (int i = 0; i < N; ++i) {\n weighted_items.push_back({current_weights[i], i});\n }\n sort(weighted_items.begin(), weighted_items.end());\n }\n }\n }\n \n // Final weight estimation\n estimator.estimate_weights();\n vector estimated_weights = estimator.get_all_weights();\n \n // Fallback: if weights seem unreasonable, use win-loss record\n double weight_sum = accumulate(estimated_weights.begin(), estimated_weights.end(), 0.0);\n if (weight_sum < 0.1 * N) {\n vector win_loss_record = estimator.get_win_loss_record();\n vector> record_pairs;\n for (int i = 0; i < N; ++i) {\n record_pairs.push_back({win_loss_record[i], i});\n }\n sort(record_pairs.rbegin(), record_pairs.rend()); // sort by descending record\n \n for (int i = 0; i < N; ++i) {\n estimated_weights[record_pairs[i].second] = N - i;\n }\n }\n \n // Optimized partitioning\n vector assignment = optimized_partitioning(estimated_weights, D, timer);\n \n // Output final assignment\n for (int i = 0; i < N; ++i) {\n cout << assignment[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n \n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct BoxPosition {\n int stack_idx;\n int height; // 0-indexed from bottom\n bool removed;\n};\n\nint main() {\n int n = 200, m = 10;\n int boxes_per_stack = n / m;\n \n // Read input\n vector> stacks(m, vector(boxes_per_stack));\n vector box_positions(n + 1); // 1-indexed\n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < boxes_per_stack; j++) {\n cin >> stacks[i][j];\n box_positions[stacks[i][j]] = {i, j, false};\n }\n }\n \n vector> operations;\n \n // For each box from 1 to 200\n for (int target = 1; target <= n; target++) {\n // If box is already removed, skip (shouldn't happen)\n if (box_positions[target].removed) continue;\n \n int stack_idx = box_positions[target].stack_idx;\n int height = box_positions[target].height;\n \n // Check if box is at the top of its stack\n bool is_top = true;\n for (int i = height + 1; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) { // 0 indicates removed box\n is_top = false;\n break;\n }\n }\n \n // Clean up removed boxes from top of stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Recalculate if it's at the top after cleanup\n is_top = (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1);\n \n if (is_top) {\n // Can remove directly\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n continue;\n }\n \n // Need to move the box and everything above it\n // Find the best destination stack\n \n int best_stack = -1;\n int min_cost = INT_MAX;\n \n // First, try to find an empty stack\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n if (stacks[dest].empty()) {\n best_stack = dest;\n break;\n }\n }\n \n // If no empty stack, find stack with minimum additional cost\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest == stack_idx) continue;\n \n // Calculate cost of moving to this stack\n int boxes_to_move = 0;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move++;\n }\n }\n \n // Energy cost is boxes_to_move + 1\n int cost = boxes_to_move + 1;\n \n // Prefer stacks that are shorter or have higher-numbered boxes on top\n cost += stacks[dest].size(); // penalty for taller stacks\n \n if (cost < min_cost) {\n min_cost = cost;\n best_stack = dest;\n }\n }\n }\n \n // If still no valid destination, pick any different stack\n if (best_stack == -1) {\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx) {\n best_stack = dest;\n break;\n }\n }\n }\n \n // Perform the move\n vector boxes_to_move;\n for (int i = height; i < stacks[stack_idx].size(); i++) {\n if (stacks[stack_idx][i] != 0) {\n boxes_to_move.push_back(stacks[stack_idx][i]);\n }\n }\n \n // Update stacks\n stacks[stack_idx].resize(height);\n \n for (int box : boxes_to_move) {\n stacks[best_stack].push_back(box);\n box_positions[box].stack_idx = best_stack;\n box_positions[box].height = stacks[best_stack].size() - 1;\n }\n \n operations.push_back({target, best_stack + 1});\n \n // Now try to remove the target box (it should be at the top)\n stack_idx = box_positions[target].stack_idx;\n height = box_positions[target].height;\n \n // Clean up the stack\n while (!stacks[stack_idx].empty() && stacks[stack_idx].back() == 0) {\n stacks[stack_idx].pop_back();\n }\n \n // Verify it's at the top\n if (height < stacks[stack_idx].size() && \n stacks[stack_idx][height] == target &&\n height == (int)stacks[stack_idx].size() - 1) {\n operations.push_back({target, 0});\n stacks[stack_idx].pop_back();\n box_positions[target].removed = true;\n } else {\n // Something went wrong, try one more move\n // This is a fallback - shouldn't happen in normal cases\n for (int dest = 0; dest < m; dest++) {\n if (dest != stack_idx && stacks[dest].empty()) {\n // Move just this box to empty stack\n stacks[stack_idx].erase(stacks[stack_idx].begin() + height);\n stacks[dest].push_back(target);\n box_positions[target].stack_idx = dest;\n box_positions[target].height = 0;\n operations.push_back({target, dest + 1});\n break;\n }\n }\n \n // Now remove it\n operations.push_back({target, 0});\n for (int i = 0; i < m; i++) {\n if (!stacks[i].empty() && stacks[i].back() == target) {\n stacks[i].pop_back();\n break;\n }\n }\n box_positions[target].removed = true;\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\n// Directions: R, D, L, U\nconst int di[4] = {0, 1, 0, -1};\nconst int dj[4] = {1, 0, -1, 0};\nconst string DIR = \"RDLU\";\n\nint N;\nvector h, v;\nvector> d;\nvector> visited;\nstring route = \"\";\n\n// Check if we can move from (i,j) to (ni,nj)\nbool canMove(int i, int j, int ni, int nj) {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n \n if (i == ni) { // horizontal move\n int min_j = min(j, nj);\n return v[i][min_j] == '0';\n } else { // vertical move\n int min_i = min(i, ni);\n return h[min_i][j] == '0';\n }\n}\n\n// Get positions after executing route\nvector> getPositions(const string& r) {\n vector> positions;\n int ci = 0, cj = 0;\n positions.push_back({ci, cj});\n \n for (char move : r) {\n int dir = DIR.find(move);\n if (dir == -1) {\n break;\n }\n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n \n // Safety check\n if (!canMove(ci, cj, ni, nj)) {\n break;\n }\n \n ci = ni;\n cj = nj;\n positions.push_back({ci, cj});\n }\n \n return positions;\n}\n\n// Validate the entire route\nbool validateRoute(const string& r) {\n if (r.empty()) return false;\n \n int ci = 0, cj = 0;\n \n // Track visited cells\n vector> cell_visited(N, vector(N, false));\n cell_visited[ci][cj] = true;\n \n for (size_t k = 0; k < r.size(); k++) {\n char move = r[k];\n int dir = DIR.find(move);\n if (dir == -1) return false; // Invalid direction\n \n int ni = ci + di[dir];\n int nj = cj + dj[dir];\n \n if (!canMove(ci, cj, ni, nj)) {\n return false; // Hits a wall\n }\n \n ci = ni;\n cj = nj;\n cell_visited[ci][cj] = true;\n }\n \n // Must end at (0,0) and visit all cells\n if (ci != 0 || cj != 0) return false;\n \n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!cell_visited[i][j]) return false;\n }\n }\n \n return true;\n}\n\n// DFS with priority based on dirtiness\nvoid dfs_priority(int i, int j) {\n visited[i][j] = true;\n \n // Collect all possible next moves\n vector> next_moves; // (priority, direction)\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n // Priority: higher dirtiness gets higher priority\n next_moves.push_back({-d[ni][nj], dir}); // negative for descending sort\n \n // Add small bonus for being close to other high-dirt cells\n for (int dii = -1; dii <= 1; dii++) {\n for (int djj = -1; djj <= 1; djj++) {\n if (dii == 0 && djj == 0) continue;\n int nii = ni + dii;\n int njj = nj + djj;\n if (nii >= 0 && nii < N && njj >= 0 && njj < N) {\n next_moves.back().first -= d[nii][njj] * 0.1;\n }\n }\n }\n }\n }\n \n // Sort by priority\n sort(next_moves.begin(), next_moves.end());\n \n // Visit in priority order\n for (auto& move : next_moves) {\n int dir = move.second;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n \n route += DIR[dir];\n dfs_priority(ni, nj);\n route += DIR[(dir + 2) % 4]; // return\n }\n}\n\n// Simple DFS (row-major order)\nvoid dfs_simple(int i, int j) {\n visited[i][j] = true;\n \n // Visit in order: right, down, left, up\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n route += DIR[dir];\n dfs_simple(ni, nj);\n route += DIR[(dir + 2) % 4];\n }\n }\n}\n\n// DFS with reverse priority (low-dirt first)\nvoid dfs_reverse_priority(int i, int j) {\n visited[i][j] = true;\n \n // Collect all possible next moves\n vector> next_moves; // (priority, direction)\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (canMove(i, j, ni, nj) && !visited[ni][nj]) {\n // Priority: lower dirtiness gets higher priority\n next_moves.push_back({d[ni][nj], dir});\n }\n }\n \n // Sort by priority\n sort(next_moves.begin(), next_moves.end());\n \n // Visit in priority order\n for (auto& move : next_moves) {\n int dir = move.second;\n int ni = i + di[dir];\n int nj = j + dj[dir];\n \n route += DIR[dir];\n dfs_reverse_priority(ni, nj);\n route += DIR[(dir + 2) % 4]; // return\n }\n}\n\n// Intelligent loop addition with bounds checking\nstring addSmartLoops(const string& base_route) {\n if (base_route.size() >= 99000) return base_route;\n \n string result = base_route;\n vector> positions = getPositions(base_route);\n \n // Track visit times for each cell\n vector>> visit_times(N, vector>(N));\n for (size_t t = 0; t < positions.size(); t++) {\n int i = positions[t].first;\n int j = positions[t].second;\n visit_times[i][j].push_back(t);\n }\n \n // Create list of cells sorted by dirtiness\n vector>> dirt_cells;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n dirt_cells.push_back({d[i][j], {i, j}});\n }\n }\n sort(dirt_cells.rbegin(), dirt_cells.rend()); // descending order\n \n // Add loops for highest dirt cells\n int loops_added = 0;\n for (int idx = 0; idx < min(8, (int)dirt_cells.size()) && loops_added < 5; idx++) {\n int i = dirt_cells[idx].second.first;\n int j = dirt_cells[idx].second.second;\n int dirtiness = dirt_cells[idx].first;\n \n if (visit_times[i][j].empty()) continue;\n \n // Find best neighbor to add loop from\n int best_pos = -1;\n int best_dir = -1;\n int longest_gap = 0;\n \n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (!canMove(i, j, ni, nj)) continue;\n \n // Check if neighbor has been visited\n if (visit_times[ni][nj].empty()) continue;\n \n // Try each visit to the neighbor as potential insertion point\n for (size_t k = 0; k < visit_times[ni][nj].size(); k++) {\n int t = visit_times[ni][nj][k];\n \n // Make sure t is valid and we can insert at t+1\n if (t >= (int)result.size()) continue;\n \n // Calculate gap (simplified)\n int gap = 0;\n if (visit_times[ni][nj].size() > 1) {\n if (k == 0) {\n // Gap between last and first visit\n gap = (positions.size() - visit_times[ni][nj].back()) + visit_times[ni][nj][0];\n } else {\n // Gap between previous visit and current\n gap = t - visit_times[ni][nj][k-1];\n }\n } else {\n gap = positions.size();\n }\n \n // Use t+1 as insertion position (after visiting neighbor)\n int insert_pos = t + 1;\n \n // Validate insert position\n if (insert_pos < 0 || insert_pos > (int)result.size()) continue;\n \n if (gap > longest_gap && result.size() + 2 <= 99500) {\n longest_gap = gap;\n best_pos = insert_pos;\n best_dir = dir;\n }\n }\n }\n \n // Add loop if beneficial (long gaps for high-dirt cells)\n if (best_dir != -1 && longest_gap > 10 && dirtiness > 100 && \n best_pos >= 0 && best_pos <= (int)result.size()) {\n \n string loop = string(1, DIR[best_dir]) + string(1, DIR[(best_dir + 2) % 4]);\n \n // Final bounds check before insertion\n if (best_pos <= (int)result.size() && result.size() + 2 <= 100000) {\n result.insert(best_pos, loop);\n loops_added++;\n \n // Validate\n if (!validateRoute(result)) {\n result.erase(best_pos, 2);\n loops_added--;\n continue;\n }\n \n // Update positions\n positions = getPositions(result);\n for (int ii = 0; ii < N; ii++) {\n for (int jj = 0; jj < N; jj++) {\n visit_times[ii][jj].clear();\n }\n }\n for (size_t t = 0; t < positions.size(); t++) {\n int ii = positions[t].first;\n int jj = positions[t].second;\n visit_times[ii][jj].push_back(t);\n }\n }\n }\n }\n \n return result;\n}\n\n// Try multiple strategies and pick the shortest valid route\nstring tryMultipleStrategies() {\n vector candidates;\n \n // Strategy 1: Priority DFS (high-dirt first)\n {\n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n visited[0][0] = true;\n dfs_priority(0, 0);\n if (validateRoute(route)) {\n candidates.push_back(route);\n }\n }\n \n // Strategy 2: Simple DFS (row-major order)\n {\n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n visited[0][0] = true;\n dfs_simple(0, 0);\n if (validateRoute(route)) {\n candidates.push_back(route);\n }\n }\n \n // Strategy 3: Reverse priority DFS (low-dirt first)\n {\n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n visited[0][0] = true;\n dfs_reverse_priority(0, 0);\n if (validateRoute(route)) {\n candidates.push_back(route);\n }\n }\n \n // Pick the shortest valid route\n string best_route = \"\";\n if (!candidates.empty()) {\n best_route = candidates[0];\n for (string& candidate : candidates) {\n if (validateRoute(candidate) && (best_route.empty() || candidate.size() < best_route.size())) {\n best_route = candidate;\n }\n }\n }\n \n // If no valid route found, use simple DFS as fallback\n if (best_route.empty()) {\n route = \"\";\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n visited[0][0] = true;\n dfs_simple(0, 0);\n if (validateRoute(route)) {\n best_route = route;\n }\n }\n \n return best_route;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read input\n cin >> N;\n h.resize(N-1);\n for (int i = 0; i < N-1; i++) {\n cin >> h[i];\n }\n v.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> v[i];\n }\n d.resize(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n // Initialize visited array\n visited = vector>(N, vector(N, false));\n \n // Try multiple strategies and pick the best\n route = tryMultipleStrategies();\n \n // Add smart loops with additional safety checks\n string optimized_route = addSmartLoops(route);\n \n // Final validation and bounds check\n if (!validateRoute(optimized_route) || optimized_route.size() > 100000) {\n optimized_route = route; // Fallback to original route\n }\n \n // One last validation\n if (!validateRoute(optimized_route)) {\n // Ultimate fallback: simple DFS\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n visited[i][j] = false;\n }\n }\n route = \"\";\n visited[0][0] = true;\n dfs_simple(0, 0);\n optimized_route = route;\n }\n \n cout << optimized_route << endl;\n \n return 0;\n}","ahc028":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Position {\n int i, j;\n Position(int i = 0, int j = 0) : i(i), j(j) {}\n int distance(const Position& other) const {\n return abs(i - other.i) + abs(j - other.j);\n }\n bool operator==(const Position& other) const {\n return i == other.i && j == other.j;\n }\n bool operator<(const Position& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n};\n\nclass Solution {\nprivate:\n int N, M;\n Position start_pos;\n vector grid;\n vector targets;\n map> char_positions;\n \n // Random number generator\n mt19937 rng;\n \npublic:\n Solution() : rng(chrono::steady_clock::now().time_since_epoch().count()) {\n cin >> N >> M;\n cin >> start_pos.i >> start_pos.j;\n grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> grid[i];\n }\n targets.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i];\n }\n \n // Build map of character positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n char_positions[grid[i][j]].push_back(Position(i, j));\n }\n }\n }\n \n // Find the position with minimum distance from current position\n Position find_best_position(char c, const Position& current) {\n if (char_positions.find(c) == char_positions.end()) {\n return Position(0, 0);\n }\n \n Position best_pos = char_positions[c][0];\n int min_dist = current.distance(best_pos);\n \n for (const Position& pos : char_positions[c]) {\n int dist = current.distance(pos);\n if (dist < min_dist) {\n min_dist = dist;\n best_pos = pos;\n }\n }\n \n return best_pos;\n }\n \n // Calculate overlap between two strings\n int calculate_overlap(const string& s1, const string& s2) {\n int max_overlap = 0;\n int len1 = s1.length();\n int len2 = s2.length();\n \n for (int i = 1; i <= min(len1, len2); i++) {\n bool match = true;\n for (int j = 0; j < i; j++) {\n if (s1[len1 - i + j] != s2[j]) {\n match = false;\n break;\n }\n }\n if (match) {\n max_overlap = i;\n }\n }\n \n return max_overlap;\n }\n \n // Calculate the cost of typing a string from a given position\n long long calculate_string_cost(const string& str, Position current_pos) {\n long long cost = 0;\n for (char c : str) {\n Position best_pos = find_best_position(c, current_pos);\n cost += current_pos.distance(best_pos) + 1;\n current_pos = best_pos;\n }\n return cost;\n }\n \n // Build superstring using improved greedy with multiple scoring metrics\n vector build_superstring_sequence_improved(int strategy) {\n if (M == 0) return {};\n \n vector used(M, false);\n vector result;\n \n // Choose first string based on strategy\n int first_idx = 0;\n \n if (strategy == 0) {\n // Strategy 0: Start with the string that's cheapest to type from start position\n long long min_cost = LLONG_MAX;\n for (int i = 0; i < M; i++) {\n long long cost = calculate_string_cost(targets[i], start_pos);\n if (cost < min_cost) {\n min_cost = cost;\n first_idx = i;\n }\n }\n } else if (strategy == 1) {\n // Strategy 1: Start with string having highest frequency characters\n map char_freq;\n for (int i = 0; i < M; i++) {\n for (char c : targets[i]) {\n char_freq[c]++;\n }\n }\n \n int best_score = -1;\n for (int i = 0; i < M; i++) {\n int score = 0;\n for (char c : targets[i]) {\n score += char_freq[c];\n }\n if (score > best_score) {\n best_score = score;\n first_idx = i;\n }\n }\n } else if (strategy == 2) {\n // Strategy 2: Random start\n first_idx = rng() % M;\n } else {\n // Strategy 3: Start with string that has characters close to start position\n int best_score = INT_MAX;\n for (int i = 0; i < M; i++) {\n int score = 0;\n for (char c : targets[i]) {\n int min_dist = INT_MAX;\n for (const Position& pos : char_positions[c]) {\n min_dist = min(min_dist, start_pos.distance(pos));\n }\n score += min_dist;\n }\n if (score < best_score) {\n best_score = score;\n first_idx = i;\n }\n }\n }\n \n used[first_idx] = true;\n result.push_back(targets[first_idx]);\n \n // Greedily add strings with optimized scoring\n for (int step = 1; step < M; step++) {\n int best_idx = -1;\n double best_score = -1;\n string current_string = result.back();\n \n for (int i = 0; i < M; i++) {\n if (used[i]) continue;\n \n int overlap = calculate_overlap(current_string, targets[i]);\n \n // Simulate end position after typing current string\n Position current_end_pos = start_pos;\n for (char c : current_string) {\n current_end_pos = find_best_position(c, current_end_pos);\n }\n \n // Calculate cost of typing non-overlapping part\n long long non_overlap_cost = 0;\n Position temp_pos = current_end_pos;\n for (int j = overlap; j < targets[i].length(); j++) {\n Position best_pos = find_best_position(targets[i][j], temp_pos);\n non_overlap_cost += temp_pos.distance(best_pos) + 1;\n temp_pos = best_pos;\n }\n \n // Calculate score with multiple factors\n double score = 0.0;\n \n // Factor 1: Overlap benefit (higher overlap = better)\n score += overlap * 100.0;\n \n // Factor 2: Cost penalty (lower cost = better)\n if (non_overlap_cost > 0) {\n score -= non_overlap_cost * 0.5;\n }\n \n // Factor 3: Future potential - how many other strings can overlap with this one\n int future_potential = 0;\n for (int k = 0; k < M; k++) {\n if (used[k]) continue;\n if (k == i) continue;\n int future_overlap = calculate_overlap(targets[i], targets[k]);\n future_potential += future_overlap;\n }\n score += future_potential * 10.0;\n \n if (score > best_score) {\n best_score = score;\n best_idx = i;\n }\n }\n \n if (best_idx == -1) {\n for (int i = 0; i < M; i++) {\n if (!used[i]) {\n best_idx = i;\n break;\n }\n }\n }\n \n used[best_idx] = true;\n result.push_back(targets[best_idx]);\n }\n \n return result;\n }\n \n // Advanced position selection with multi-character look-ahead\n vector generate_operations_advanced(const vector& sequence) {\n vector operations;\n Position current_pos = start_pos;\n \n if (sequence.empty()) return operations;\n \n // Process each string in sequence\n for (int seq_idx = 0; seq_idx < sequence.size(); seq_idx++) {\n const string& str = sequence[seq_idx];\n \n // Calculate overlap with previous string\n int start_char_idx = 0;\n if (seq_idx > 0) {\n const string& prev = sequence[seq_idx - 1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n // Type characters with advanced position selection\n for (int j = start_char_idx; j < str.length(); j++) {\n char c = str[j];\n \n // If we have multiple positions and characters remaining, use look-ahead\n if (char_positions[c].size() > 1 && j < str.length() - 1) {\n Position best_pos = char_positions[c][0];\n double best_score = 1e9;\n \n // Look ahead up to 2 characters\n int look_ahead = min(2, (int)str.length() - j - 1);\n \n for (const Position& pos : char_positions[c]) {\n double score = current_pos.distance(pos) + 1; // cost to move to this position\n \n // Simulate future costs\n Position future_pos = pos;\n for (int k = 1; k <= look_ahead; k++) {\n char future_char = str[j + k];\n Position future_best = find_best_position(future_char, future_pos);\n score += future_pos.distance(future_best) + 1;\n future_pos = future_best;\n }\n \n // Also consider overall grid distribution - prefer central positions\n double centrality_bonus = abs(pos.i - N/2) + abs(pos.j - N/2);\n score += centrality_bonus * 0.1; // slight penalty for edge positions\n \n if (score < best_score) {\n best_score = score;\n best_pos = pos;\n }\n }\n \n operations.push_back(best_pos);\n current_pos = best_pos;\n } else {\n // Simple case: just pick closest position\n Position best_pos = find_best_position(c, current_pos);\n operations.push_back(best_pos);\n current_pos = best_pos;\n }\n }\n }\n \n return operations;\n }\n \n // Calculate total cost of operations\n long long calculate_total_cost(const vector& operations) {\n long long cost = 0;\n Position current_pos = start_pos;\n for (const Position& op : operations) {\n cost += current_pos.distance(op) + 1;\n current_pos = op;\n }\n return cost;\n }\n \n // Try to locally optimize the solution by adjusting positions\n vector local_optimization(const vector& original_ops, const vector& sequence) {\n if (original_ops.empty()) return original_ops;\n \n vector optimized = original_ops;\n long long original_cost = calculate_total_cost(original_ops);\n long long best_cost = original_cost;\n vector best_ops = original_ops;\n \n // Try random perturbations\n for (int trial = 0; trial < 10; trial++) {\n vector candidate = original_ops;\n \n // Randomly adjust some positions\n int num_adjustments = min(5, (int)candidate.size() / 10);\n for (int adj = 0; adj < num_adjustments; adj++) {\n int idx = rng() % candidate.size();\n \n // Find the character that should be at this position\n char target_char = '?';\n int op_idx = 0;\n int seq_idx = 0;\n int char_idx = 0;\n \n // Reconstruct which character corresponds to this operation\n Position current_pos = start_pos;\n for (int i = 0; i < sequence.size(); i++) {\n const string& str = sequence[i];\n int start_char_idx = 0;\n \n if (i > 0) {\n const string& prev = sequence[i-1];\n int overlap = 0;\n for (int j = 1; j <= min(prev.length(), str.length()); j++) {\n bool match = true;\n for (int k = 0; k < j; k++) {\n if (prev[prev.length() - j + k] != str[k]) {\n match = false;\n break;\n }\n }\n if (match) {\n overlap = j;\n }\n }\n start_char_idx = overlap;\n }\n \n for (int j = start_char_idx; j < str.length(); j++) {\n if (op_idx == idx) {\n target_char = str[j];\n break;\n }\n op_idx++;\n }\n \n if (target_char != '?') break;\n }\n \n if (target_char != '?' && char_positions[target_char].size() > 1) {\n // Try a different position for this character\n Position current_context_pos = start_pos;\n if (idx > 0) {\n current_context_pos = candidate[idx - 1];\n } else {\n current_context_pos = start_pos;\n }\n \n Position prev_best = candidate[idx];\n Position new_best = find_best_position(target_char, current_context_pos);\n \n // Try to find a different position (not the closest one)\n for (const Position& pos : char_positions[target_char]) {\n if (pos.i != prev_best.i || pos.j != prev_best.j) {\n if (current_context_pos.distance(pos) <= current_context_pos.distance(prev_best) + 3) {\n // Only consider if not too much worse\n new_best = pos;\n break;\n }\n }\n }\n \n candidate[idx] = new_best;\n }\n }\n \n long long new_cost = calculate_total_cost(candidate);\n if (new_cost < best_cost) {\n best_cost = new_cost;\n best_ops = candidate;\n }\n }\n \n return best_ops;\n }\n \n // Main solve function with comprehensive strategies\n void solve() {\n vector best_operations;\n long long best_cost = LLONG_MAX;\n vector best_sequence;\n \n // Try different strategies for building sequence\n for (int strategy = 0; strategy < 4; strategy++) {\n vector sequence = build_superstring_sequence_improved(strategy);\n vector operations = generate_operations_advanced(sequence);\n \n // Try local optimization\n vector optimized_ops = local_optimization(operations, sequence);\n long long cost = calculate_total_cost(optimized_ops);\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = optimized_ops;\n best_sequence = sequence;\n }\n }\n \n // Try additional random trials\n for (int trial = 0; trial < 5; trial++) {\n vector sequence = build_superstring_sequence_improved(2); // random strategy\n vector operations = generate_operations_advanced(sequence);\n \n vector optimized_ops = local_optimization(operations, sequence);\n long long cost = calculate_total_cost(optimized_ops);\n \n if (cost < best_cost) {\n best_cost = cost;\n best_operations = optimized_ops;\n best_sequence = sequence;\n }\n }\n \n // One final optimization pass\n if (!best_operations.empty()) {\n vector final_optimized = local_optimization(best_operations, best_sequence);\n long long final_cost = calculate_total_cost(final_optimized);\n if (final_cost < best_cost) {\n best_operations = final_optimized;\n }\n }\n \n // Output the best operations\n for (const Position& pos : best_operations) {\n cout << pos.i << \" \" << pos.j << endl;\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n Solution solution;\n solution.solve();\n \n return 0;\n}","ahc030":"#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n \n vector>> fields(M);\n for (int k = 0; k < M; k++) {\n int d;\n cin >> d;\n fields[k].resize(d);\n for (int i = 0; i < d; i++) {\n cin >> fields[k][i].first >> fields[k][i].second;\n }\n }\n \n vector> has_oil;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n cout.flush();\n \n int resp;\n cin >> resp;\n if (resp != 0) {\n has_oil.push_back(make_pair(i, j));\n }\n }\n }\n \n cout << \"a \" << has_oil.size();\n for (int i = 0; i < has_oil.size(); i++) {\n cout << \" \" << has_oil[i].first << \" \" << has_oil[i].second;\n }\n cout << endl;\n cout.flush();\n \n int resp;\n cin >> resp;\n \n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rectangle {\n int i0, j0, i1, j1;\n \n Rectangle() : i0(0), j0(0), i1(0), j1(0) {}\n Rectangle(int i0, int j0, int i1, int j1) : i0(i0), j0(j0), i1(i1), j1(j1) {}\n \n int area() const {\n return (i1 - i0) * (j1 - j0);\n }\n \n bool overlaps(const Rectangle& other) const {\n return !(i1 <= other.i0 || i0 >= other.i1 || j1 <= other.j0 || j0 >= other.j1);\n }\n \n // Check if rectangle is valid (within bounds and has positive area)\n bool isValid(int W) const {\n return i0 >= 0 && j0 >= 0 && i1 <= W && j1 <= W && i0 < i1 && j0 < j1;\n }\n};\n\nclass PartitionManager {\nprivate:\n int W;\n vector> horizontal_partitions; // [i][j] for horizontal partition at (i,j)-(i,j+1)\n vector> vertical_partitions; // [i][j] for vertical partition at (i,j)-(i+1,j)\n \npublic:\n PartitionManager(int W) : W(W) {\n horizontal_partitions.assign(W, vector(W, false));\n vertical_partitions.assign(W, vector(W, false));\n }\n \n void updateFromRectangles(const vector& rectangles) {\n // Reset all partitions\n for (int i = 0; i < W; i++) {\n fill(horizontal_partitions[i].begin(), horizontal_partitions[i].end(), false);\n fill(vertical_partitions[i].begin(), vertical_partitions[i].end(), false);\n }\n \n // Set partitions based on rectangles\n for (const auto& rect : rectangles) {\n // Top edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i0 > 0) vertical_partitions[rect.i0 - 1][j] = true;\n }\n // Bottom edge (excluding perimeter)\n for (int j = rect.j0; j < rect.j1; j++) {\n if (rect.i1 < W) vertical_partitions[rect.i1 - 1][j] = true;\n }\n // Left edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j0 > 0) horizontal_partitions[i][rect.j0 - 1] = true;\n }\n // Right edge (excluding perimeter)\n for (int i = rect.i0; i < rect.i1; i++) {\n if (rect.j1 < W) horizontal_partitions[i][rect.j1 - 1] = true;\n }\n }\n }\n \n int calculateChangeCost(const PartitionManager& prev) const {\n int cost = 0;\n \n // Horizontal partitions (i,j)-(i,j+1) where 1<=i<=W-1, 0<=j<=W-1\n for (int i = 1; i < W; i++) {\n for (int j = 0; j < W; j++) {\n if (horizontal_partitions[i-1][j] != prev.horizontal_partitions[i-1][j]) {\n cost++;\n }\n }\n }\n \n // Vertical partitions (i,j)-(i+1,j) where 0<=i<=W-1, 1<=j<=W-1\n for (int i = 0; i < W; i++) {\n for (int j = 1; j < W; j++) {\n if (vertical_partitions[i][j-1] != prev.vertical_partitions[i][j-1]) {\n cost++;\n }\n }\n }\n \n return cost;\n }\n};\n\nclass Solution {\nprivate:\n int W, D, N;\n vector> desired_areas;\n vector> solution;\n mt19937 rng;\n \npublic:\n Solution(int W, int D, int N, vector>&& areas) \n : W(W), D(D), N(N), desired_areas(move(areas)), rng(chrono::steady_clock::now().time_since_epoch().count()) {\n solution.resize(D, vector(N));\n }\n \n // Calculate rental cost for a day\n long long calculateRentalCost(int day) const {\n long long cost = 0;\n for (int k = 0; k < N; k++) {\n int actual_area = solution[day][k].area();\n if (desired_areas[day][k] > actual_area) {\n cost += 100LL * (desired_areas[day][k] - actual_area);\n }\n }\n return cost;\n }\n \n // Calculate partition change cost for a day\n long long calculatePartitionCost(int day) const {\n if (day == 0) return 0;\n \n PartitionManager current(W), prev(W);\n current.updateFromRectangles(solution[day]);\n prev.updateFromRectangles(solution[day-1]);\n \n return current.calculateChangeCost(prev);\n }\n \n // Calculate total cost\n long long calculateTotalCost() const {\n long long total_cost = 0;\n for (int d = 0; d < D; d++) {\n total_cost += calculateRentalCost(d);\n total_cost += calculatePartitionCost(d);\n }\n return total_cost;\n }\n \n // Check if any rectangles on a day overlap\n bool hasOverlap(int day) const {\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (solution[day][i].overlaps(solution[day][j])) {\n return true;\n }\n }\n }\n return false;\n }\n \n // Initialize day 0 with simple row-wise division\n void initializeDay0() {\n int total_height = W;\n vector heights(N);\n \n // Calculate heights proportional to desired areas\n long long total_desired = 0;\n for (int k = 0; k < N; k++) {\n total_desired += desired_areas[0][k];\n }\n \n int allocated_height = 0;\n for (int k = 0; k < N - 1; k++) {\n heights[k] = max(1, (int)((long long)desired_areas[0][k] * total_height / total_desired));\n allocated_height += heights[k];\n }\n heights[N-1] = total_height - allocated_height;\n if (heights[N-1] <= 0) {\n heights[N-1] = 1;\n // Adjust other heights if needed\n for (int k = 0; k < N-1 && allocated_height >= total_height; k++) {\n if (heights[k] > 1) {\n heights[k]--;\n allocated_height--;\n if (allocated_height < total_height) break;\n }\n }\n }\n \n // Create rectangles\n int current_i = 0;\n for (int k = 0; k < N; k++) {\n solution[0][k] = Rectangle(current_i, 0, current_i + heights[k], W);\n current_i += heights[k];\n }\n }\n \n // More robust overlap resolution\n void resolveOverlaps(int day) {\n const int MAX_ITERATIONS = 100;\n int iteration = 0;\n \n while (hasOverlap(day) && iteration < MAX_ITERATIONS) {\n iteration++;\n \n // Create a copy of current solution\n vector temp_solution = solution[day];\n \n // Find the first overlapping pair\n int overlap_i = -1, overlap_j = -1;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n if (temp_solution[i].overlaps(temp_solution[j])) {\n overlap_i = i;\n overlap_j = j;\n break;\n }\n }\n if (overlap_i != -1) break;\n }\n \n if (overlap_i == -1) break; // No more overlaps\n \n Rectangle& r1 = temp_solution[overlap_i];\n Rectangle& r2 = temp_solution[overlap_j];\n \n // Try different strategies to resolve overlap\n \n // Strategy 1: Move r2 to the right of r1\n if (r1.j1 < W) {\n int new_j0 = r1.j1;\n if (new_j0 < r2.j1) { // Ensure positive width\n int width = r2.j1 - r2.j0;\n if (new_j0 + width <= W) {\n r2.j0 = new_j0;\n r2.j1 = new_j0 + width;\n }\n }\n }\n \n // Check if overlap is resolved\n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 2: Move r2 below r1\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n if (r1.i1 < W) {\n int new_i0 = r1.i1;\n if (new_i0 < r2.i1) { // Ensure positive height\n int height = r2.i1 - r2.i0;\n if (new_i0 + height <= W) {\n r2.i0 = new_i0;\n r2.i1 = new_i0 + height;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 3: Shrink r2\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Calculate overlap region\n int overlap_i0 = max(r1.i0, r2.i0);\n int overlap_i1 = min(r1.i1, r2.i1);\n int overlap_j0 = max(r1.j0, r2.j0);\n int overlap_j1 = min(r1.j1, r2.j1);\n \n // Try to shrink r2 from the side that has the least impact\n if (overlap_j1 - overlap_j0 > 0 && overlap_i1 - overlap_i0 > 0) {\n // Prefer to shrink in the direction with smaller dimension\n if (r2.j1 - r2.j0 < r2.i1 - r2.i0) {\n // Shrink horizontally\n if (r2.j0 == overlap_j0) {\n r2.j0 = overlap_j1;\n } else {\n r2.j1 = overlap_j0;\n }\n } else {\n // Shrink vertically\n if (r2.i0 == overlap_i0) {\n r2.i0 = overlap_i1;\n } else {\n r2.i1 = overlap_i0;\n }\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Strategy 4: Try to move r1 instead\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Move r1 to left of r2\n if (r2.j0 > 0) {\n int width = r1.j1 - r1.j0;\n if (r2.j0 - width >= 0) {\n r1.j0 = r2.j0 - width;\n r1.j1 = r2.j0;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // If no strategy works, try to resize one of the rectangles\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Shrink r2 to eliminate overlap\n if (r2.j1 > r1.j0 && r2.j0 < r1.j1) {\n // Horizontal overlap\n if (r2.j0 < r1.j0) {\n r2.j1 = r1.j0;\n } else {\n r2.j0 = r1.j1;\n }\n }\n \n if (r2.i1 > r1.i0 && r2.i0 < r1.i1) {\n // Vertical overlap\n if (r2.i0 < r1.i0) {\n r2.i1 = r1.i0;\n } else {\n r2.i0 = r1.i1;\n }\n }\n \n if (!r1.overlaps(r2) && r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n continue;\n }\n \n // Last resort: just separate them arbitrarily\n temp_solution = solution[day]; // Restore\n r1 = temp_solution[overlap_i];\n r2 = temp_solution[overlap_j];\n \n // Force separation\n r2.j0 = r1.j1;\n r2.j1 = r2.j0 + max(1, r2.j1 - r2.j0);\n if (r2.j1 > W) {\n r2.j1 = W;\n r2.j0 = max(0, r2.j1 - max(1, r2.j1 - r2.j0));\n }\n \n if (r1.overlaps(r2)) {\n r2.i0 = r1.i1;\n r2.i1 = r2.i0 + max(1, r2.i1 - r2.i0);\n if (r2.i1 > W) {\n r2.i1 = W;\n r2.i0 = max(0, r2.i1 - max(1, r2.i1 - r2.i0));\n }\n }\n \n if (r1.isValid(W) && r2.isValid(W)) {\n solution[day] = temp_solution;\n }\n }\n \n // Final validation\n if (hasOverlap(day)) {\n // If still overlapping, use a more drastic approach\n // Arrange rectangles in a grid\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // For subsequent days, start with previous day's solution and adjust\n void optimizeDay(int day) {\n // Start with previous day's configuration\n solution[day] = solution[day-1];\n \n // Calculate current areas\n vector current_areas(N);\n for (int k = 0; k < N; k++) {\n current_areas[k] = solution[day][k].area();\n }\n \n // Identify rectangles that need adjustment\n vector needs_more_area;\n for (int k = 0; k < N; k++) {\n if (current_areas[k] < desired_areas[day][k]) {\n needs_more_area.push_back(k);\n }\n }\n \n // Simple adjustment: try to expand rectangles that need more area\n for (int k : needs_more_area) {\n int deficit = desired_areas[day][k] - current_areas[k];\n if (deficit <= 0) continue;\n \n Rectangle original_rect = solution[day][k];\n Rectangle& rect = solution[day][k];\n \n // Try different expansion strategies\n \n // Strategy 1: Expand right\n if (rect.j1 < W) {\n int can_expand = W - rect.j1;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j1 += expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 2: Expand down\n if (deficit > 0 && rect.i1 < W) {\n int can_expand = W - rect.i1;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i1 += expand_by;\n deficit -= expand_by * width;\n }\n \n // Strategy 3: Expand left\n if (deficit > 0 && rect.j0 > 0) {\n int can_expand = rect.j0;\n int height = rect.i1 - rect.i0;\n int expand_by = min(can_expand, (deficit + height - 1) / height);\n rect.j0 -= expand_by;\n deficit -= expand_by * height;\n }\n \n // Strategy 4: Expand up\n if (deficit > 0 && rect.i0 > 0) {\n int can_expand = rect.i0;\n int width = rect.j1 - rect.j0;\n int expand_by = min(can_expand, (deficit + width - 1) / width);\n rect.i0 -= expand_by;\n deficit -= expand_by * width;\n }\n \n // Ensure rectangle is valid\n if (!rect.isValid(W)) {\n solution[day][k] = original_rect;\n }\n }\n \n // Check for overlaps and resolve them\n resolveOverlaps(day);\n \n // Verify no overlaps remain\n if (hasOverlap(day)) {\n // Fallback: use grid arrangement\n int grid_size = ceil(sqrt(N));\n int cell_width = W / grid_size;\n int cell_height = W / grid_size;\n \n for (int k = 0; k < N; k++) {\n int row = k / grid_size;\n int col = k % grid_size;\n solution[day][k] = Rectangle(\n row * cell_height, \n col * cell_width,\n min(W, (row + 1) * cell_height),\n min(W, (col + 1) * cell_width)\n );\n }\n }\n }\n \n // Local search optimization for a day (with proper overlap checking)\n void localSearchDay(int day, int iterations = 50) {\n // Keep track of the best solution\n auto best_solution = solution[day];\n long long best_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n for (int iter = 0; iter < iterations; iter++) {\n // Make a small random change\n auto current_solution = solution[day];\n \n // Select a random rectangle to modify\n int k = uniform_int_distribution(0, N-1)(rng);\n Rectangle original_rect = current_solution[k];\n Rectangle& rect = current_solution[k];\n \n // Randomly adjust one of the boundaries\n int change_type = uniform_int_distribution(0, 3)(rng);\n int change_amount = uniform_int_distribution(-3, 3)(rng);\n \n // Skip if change_amount is 0\n if (change_amount == 0) continue;\n \n switch (change_type) {\n case 0: // Adjust top\n rect.i0 += change_amount;\n break;\n case 1: // Adjust left\n rect.j0 += change_amount;\n break;\n case 2: // Adjust bottom\n rect.i1 += change_amount;\n break;\n case 3: // Adjust right\n rect.j1 += change_amount;\n break;\n }\n \n // Validate the rectangle\n if (!rect.isValid(W)) {\n current_solution[k] = original_rect;\n }\n \n // Check for overlaps\n bool has_overlap = false;\n for (int i = 0; i < N && !has_overlap; i++) {\n for (int j = i + 1; j < N && !has_overlap; j++) {\n if (current_solution[i].overlaps(current_solution[j])) {\n has_overlap = true;\n }\n }\n }\n \n if (!has_overlap) {\n // Calculate new cost\n auto temp_solution = solution[day];\n solution[day] = current_solution;\n long long new_cost = calculateRentalCost(day) + (day > 0 ? calculatePartitionCost(day) : 0);\n \n // Accept if better\n if (new_cost < best_cost) {\n best_solution = current_solution;\n best_cost = new_cost;\n }\n \n // Revert for next iteration\n solution[day] = temp_solution;\n }\n }\n \n // Set the best solution found\n solution[day] = best_solution;\n \n // Final overlap check\n if (hasOverlap(day)) {\n resolveOverlaps(day);\n }\n }\n \n void solve() {\n // Initialize day 0\n initializeDay0();\n \n // Ensure no overlaps on day 0\n resolveOverlaps(0);\n \n // Optimize subsequent days\n for (int d = 1; d < D; d++) {\n optimizeDay(d);\n // Apply local search for further improvement\n localSearchDay(d, 30);\n \n // Final validation\n if (hasOverlap(d)) {\n resolveOverlaps(d);\n }\n }\n }\n \n void output() const {\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cout << solution[d][k].i0 << \" \" \n << solution[d][k].j0 << \" \" \n << solution[d][k].i1 << \" \" \n << solution[d][k].j1 << endl;\n }\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int W, D, N;\n cin >> W >> D >> N;\n \n vector> areas(D, vector(N));\n for (int d = 0; d < D; d++) {\n for (int k = 0; k < N; k++) {\n cin >> areas[d][k];\n }\n }\n \n Solution solver(W, D, N, move(areas));\n solver.solve();\n solver.output();\n \n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\n// Calculate improvement from applying a stamp at position (p,q)\nlong long calculateImprovement(const vector>& board, \n const vector>& stamp,\n int p, int q) {\n long long improvement = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n long long current_remainder = board[p + i][q + j] % MOD;\n long long new_remainder = (board[p + i][q + j] + stamp[i][j]) % MOD;\n improvement += (new_remainder - current_remainder);\n }\n }\n return improvement;\n}\n\n// Apply a stamp operation to a board (modifies the board)\nvoid applyStamp(vector>& board, \n const vector>& stamp,\n int p, int q) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n board[p + i][q + j] += stamp[i][j];\n }\n }\n}\n\n// Calculate position value (center positions are more valuable)\ndouble calculatePositionValue(int p, int q, int N) {\n int center_p = (N - 3) / 2;\n int center_q = (N - 3) / 2;\n int dist = abs(p - center_p) + abs(q - center_q);\n // Center positions have higher value\n return 1.0 + (6.0 - dist) * 0.05;\n}\n\n// Calculate stamp value\nlong long calculateStampValue(const vector>& stamp) {\n long long value = 0;\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n value += stamp[i][j];\n }\n }\n return value;\n}\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n \n // Read initial board\n vector> board(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> board[i][j];\n }\n }\n \n // Read stamps\n vector>> stamps(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) {\n for (int i = 0; i < 3; i++) {\n for (int j = 0; j < 3; j++) {\n cin >> stamps[m][i][j];\n }\n }\n }\n \n // Calculate stamp values for prioritization\n vector stamp_values(M);\n for (int m = 0; m < M; m++) {\n stamp_values[m] = calculateStampValue(stamps[m]);\n }\n \n // Store operations\n vector> operations;\n \n // Greedy selection of operations\n for (int op = 0; op < K; op++) {\n long long best_improvement = -1e18;\n int best_stamp = -1, best_p = -1, best_q = -1;\n \n // Calculate current score for adaptive decisions\n long long current_total_score = 0;\n int cells_near_limit = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n current_total_score += board[i][j] % MOD;\n if ((board[i][j] % MOD) > MOD / 2) {\n cells_near_limit++;\n }\n }\n }\n \n // Use 2-step lookahead for early operations or when many cells are near limit\n bool use_lookahead = (op < 25) || (cells_near_limit > 20);\n \n if (use_lookahead) {\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n // Create a copy of the board\n vector> temp_board = board;\n applyStamp(temp_board, stamps[m], p, q);\n \n // Find best second operation\n long long best_second_improvement = -1e18;\n for (int m2 = 0; m2 < M; m2++) {\n for (int p2 = 0; p2 <= N - 3; p2++) {\n for (int q2 = 0; q2 <= N - 3; q2++) {\n long long improvement = calculateImprovement(temp_board, stamps[m2], p2, q2);\n if (improvement > best_second_improvement) {\n best_second_improvement = improvement;\n }\n }\n }\n }\n \n // Calculate total improvement\n long long first_improvement = calculateImprovement(board, stamps[m], p, q);\n double position_value = calculatePositionValue(p, q, N);\n double stamp_priority = 1.0 + (stamp_values[m] * 0.000000001); // Small bonus for high-value stamps\n \n double total_improvement = static_cast(first_improvement) * position_value * stamp_priority + \n max(0.0, static_cast(best_second_improvement) * 0.8);\n \n if (static_cast(total_improvement) > best_improvement) {\n best_improvement = static_cast(total_improvement);\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n } else {\n // Simple greedy for remaining operations\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n long long improvement = calculateImprovement(board, stamps[m], p, q);\n double position_value = calculatePositionValue(p, q, N);\n double stamp_priority = 1.0 + (stamp_values[m] * 0.000000001);\n \n long long weighted_improvement = static_cast(static_cast(improvement) * position_value * stamp_priority);\n \n if (weighted_improvement > best_improvement) {\n best_improvement = weighted_improvement;\n best_stamp = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n }\n \n // Apply the best operation\n applyStamp(board, stamps[best_stamp], best_p, best_q);\n \n // Record the operation\n operations.push_back(make_tuple(best_stamp, best_p, best_q));\n }\n \n // Enhanced local search: try swapping operations (not just adjacent)\n for (int i = 0; i < static_cast(operations.size()) - 1; i++) {\n for (int j = i + 1; j < static_cast(operations.size()); j++) {\n if (j > i + 3) break; // Limit to nearby operations for efficiency\n \n // Create a copy of the board in state before operation i\n vector> temp_board = board;\n \n // Reverse all operations from end to i\n for (int k = static_cast(operations.size()) - 1; k >= i; k--) {\n int m = get<0>(operations[k]);\n int p = get<1>(operations[k]);\n int q = get<2>(operations[k]);\n for (int x = 0; x < 3; x++) {\n for (int y = 0; y < 3; y++) {\n temp_board[p + x][q + y] -= stamps[m][x][y];\n }\n }\n }\n \n // Create a temporary operations vector for testing\n vector> temp_operations = operations;\n \n // Swap operations i and j\n swap(temp_operations[i], temp_operations[j]);\n \n // Apply operations from i to end\n vector> test_board = temp_board;\n for (int k = i; k < static_cast(temp_operations.size()); k++) {\n int m = get<0>(temp_operations[k]);\n int p = get<1>(temp_operations[k]);\n int q = get<2>(temp_operations[k]);\n applyStamp(test_board, stamps[m], p, q);\n }\n \n // Calculate score with swap\n long long score_with_swap = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n score_with_swap += test_board[r][c] % MOD;\n }\n }\n \n // Calculate original score\n vector> orig_board = temp_board;\n for (int k = i; k < static_cast(operations.size()); k++) {\n int m = get<0>(operations[k]);\n int p = get<1>(operations[k]);\n int q = get<2>(operations[k]);\n applyStamp(orig_board, stamps[m], p, q);\n }\n long long score_original = 0;\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n score_original += orig_board[r][c] % MOD;\n }\n }\n \n // If swapping improves score, do it\n if (score_with_swap > score_original) {\n swap(operations[i], operations[j]);\n board = test_board;\n }\n }\n }\n \n // Output\n cout << operations.size() << endl;\n for (auto& op : operations) {\n cout << get<0>(op) << \" \" << get<1>(op) << \" \" << get<2>(op) << endl;\n }\n \n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int row, col;\n int holding; // -1 if not holding, container number otherwise\n bool is_large;\n bool bombed;\n};\n\nstruct ContainerInfo {\n int target_row;\n int target_order;\n bool arrived;\n bool dispatched;\n int arrival_row;\n int arrival_order;\n};\n\nclass Solver {\nprivate:\n int N;\n vector> A;\n vector cranes;\n vector> grid;\n int turn_count;\n vector next_container_index;\n vector containers;\n \n // Get direction from current position to target\n char get_direction(int from_r, int from_c, int to_r, int to_c) {\n if (from_r > to_r) return 'U';\n if (from_r < to_r) return 'D';\n if (from_c > to_c) return 'L';\n if (from_c < to_c) return 'R';\n return '.'; // Already at target\n }\n \n // Calculate next position after action\n pair get_next_position(int crane_id, char action) {\n int r = cranes[crane_id].row;\n int c = cranes[crane_id].col;\n \n if (action == 'U') r--;\n else if (action == 'D') r++;\n else if (action == 'L') c--;\n else if (action == 'R') c++;\n // For 'P', 'Q', 'B', '.', stay in place\n \n return {r, c};\n }\n \n // Check if move is physically valid (bounds, container constraints)\n bool is_physically_valid(int crane_id, char action) {\n if (action == '.' || action == 'P' || action == 'Q' || action == 'B') {\n return true;\n }\n \n pair next_pos = get_next_position(crane_id, action);\n int nr = next_pos.first;\n int nc = next_pos.second;\n \n // Check bounds\n if (nr < 0 || nr >= N || nc < 0 || nc >= N) {\n return false;\n }\n \n // Check if small crane is carrying and trying to move to occupied square\n if (cranes[crane_id].holding != -1 && !cranes[crane_id].is_large && grid[nr][nc] != -1) {\n return false;\n }\n \n return true;\n }\n \n // Comprehensive collision detection that checks final state\n bool has_collision(const vector& actions) {\n // Calculate next positions for all cranes\n vector> current_positions(N);\n vector> next_positions(N);\n \n for (int i = 0; i < N; i++) {\n current_positions[i] = {cranes[i].row, cranes[i].col};\n next_positions[i] = get_next_position(i, actions[i]);\n }\n \n // Check for two cranes ending up in the same position\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n for (int j = i + 1; j < N; j++) {\n if (cranes[j].bombed) continue;\n \n if (next_positions[i] == next_positions[j]) {\n return true;\n }\n }\n }\n \n // Check for swapping (crane i moves to crane j's position and vice versa)\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n for (int j = 0; j < N; j++) {\n if (i == j || cranes[j].bombed) continue;\n \n if (next_positions[i] == current_positions[j] && \n next_positions[j] == current_positions[i]) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n // Check if a specific crane's move is causing a collision\n bool is_causing_collision(int crane_id, const vector& actions) {\n if (cranes[crane_id].bombed) return false;\n \n char original_action = actions[crane_id];\n if (original_action != 'U' && original_action != 'D' && \n original_action != 'L' && original_action != 'R') {\n return false;\n }\n \n // Create a test set of actions where this crane doesn't move\n vector test_actions = actions;\n test_actions[crane_id] = '.';\n \n // If removing this crane's move eliminates the collision, it was causing it\n return has_collision(actions) && !has_collision(test_actions);\n }\n \n // Validate pickup action\n bool is_valid_pickup(int crane_id) {\n return cranes[crane_id].holding == -1 && \n grid[cranes[crane_id].row][cranes[crane_id].col] != -1;\n }\n \n // Validate release action\n bool is_valid_release(int crane_id) {\n return cranes[crane_id].holding != -1 && \n grid[cranes[crane_id].row][cranes[crane_id].col] == -1;\n }\n \n // Get action for crane during initial dispersion phase\n char get_dispersion_action(int crane_id) {\n // Move crane i to column i to disperse them\n int target_col = min(crane_id, N-1);\n \n if (cranes[crane_id].col < target_col) {\n return 'R';\n } else if (cranes[crane_id].col > target_col) {\n return 'L';\n }\n \n return '.';\n }\n \n // Get action for crane during normal operation\n char get_normal_action(int crane_id) {\n Crane& crane = cranes[crane_id];\n \n // Priority 1: If holding a container, deliver it to target dispatch gate\n if (crane.holding != -1) {\n int container = crane.holding;\n int target_row = containers[container].target_row;\n \n // If at the correct dispatch gate, release the container\n if (crane.row == target_row && crane.col == N-1) {\n return 'Q';\n }\n \n // Move toward target dispatch gate\n // First align row, then column\n if (crane.row != target_row) {\n return get_direction(crane.row, crane.col, target_row, crane.col);\n } else {\n return get_direction(crane.row, crane.col, target_row, N-1);\n }\n }\n \n // Priority 2: If at a square with a container, pick it up\n if (crane.holding == -1 && grid[crane.row][crane.col] != -1) {\n return 'P';\n }\n \n // Priority 3: Move to receiving gate of assigned row to pick up containers\n // Each crane i is responsible for row i\n if (crane.col > 0) {\n return 'L'; // Move left toward receiving gate\n }\n \n return '.';\n }\n \n vector get_actions() {\n vector actions(N, '.');\n \n // Phase 1: Disperse cranes (first N turns)\n if (turn_count < N) {\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n actions[i] = get_dispersion_action(i);\n }\n }\n } \n // Phase 2: Normal operation\n else {\n for (int i = 0; i < N; i++) {\n if (!cranes[i].bombed) {\n actions[i] = get_normal_action(i);\n }\n }\n }\n \n // Validate individual actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) {\n actions[i] = '.';\n continue;\n }\n \n char& action = actions[i];\n \n if (action == 'P') {\n if (!is_valid_pickup(i)) {\n action = '.';\n }\n } else if (action == 'Q') {\n if (!is_valid_release(i)) {\n action = '.';\n }\n } else if (action == 'B') {\n if (cranes[i].holding != -1) {\n action = '.';\n }\n } else if (action == 'U' || action == 'D' || action == 'L' || action == 'R') {\n if (!is_physically_valid(i, action)) {\n action = '.';\n }\n }\n }\n \n // If there's a collision, resolve it by making cranes that are causing collisions stop\n if (has_collision(actions)) {\n // Create a safe version where potentially colliding cranes don't move\n vector safe_actions = actions;\n \n // Go through each crane and if it's causing a collision, make it stop\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n if (is_causing_collision(i, actions)) {\n safe_actions[i] = '.';\n }\n }\n \n // If the safe version still has collisions, make ALL moving cranes stop\n if (has_collision(safe_actions)) {\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n if (safe_actions[i] == 'U' || safe_actions[i] == 'D' || \n safe_actions[i] == 'L' || safe_actions[i] == 'R') {\n safe_actions[i] = '.';\n }\n }\n }\n \n actions = safe_actions;\n }\n \n return actions;\n }\n \n bool simulate_turn(vector& actions) {\n // Step 1: Bring in new containers at receiving gates\n for (int i = 0; i < N; i++) {\n if (next_container_index[i] < N && grid[i][0] == -1) {\n // Calculate next positions for all cranes\n vector> next_positions(N);\n for (int j = 0; j < N; j++) {\n next_positions[j] = get_next_position(j, actions[j]);\n }\n \n // Check if position will be occupied\n bool will_be_occupied = false;\n \n for (int j = 0; j < N; j++) {\n if (cranes[j].bombed) continue;\n \n int next_r = next_positions[j].first;\n int next_c = next_positions[j].second;\n \n // If crane will be at (i,0) and not picking up\n if (next_r == i && next_c == 0 && actions[j] != 'P' && actions[j] != 'Q') {\n will_be_occupied = true;\n break;\n }\n \n // Also check if a crane is already there and not picking up\n if (cranes[j].row == i && cranes[j].col == 0 && \n (actions[j] == '.' || actions[j] == 'B') && actions[j] != 'P') {\n will_be_occupied = true;\n break;\n }\n }\n \n if (!will_be_occupied) {\n int container = A[i][next_container_index[i]];\n grid[i][0] = container;\n containers[container].arrived = true;\n next_container_index[i]++;\n }\n }\n }\n \n // Final collision check - if there's still a collision, make all cranes stop moving\n if (has_collision(actions)) {\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n if (actions[i] == 'U' || actions[i] == 'D' || actions[i] == 'L' || actions[i] == 'R') {\n actions[i] = '.';\n }\n }\n }\n \n // Apply actions\n for (int i = 0; i < N; i++) {\n if (cranes[i].bombed) continue;\n \n char action = actions[i];\n int& r = cranes[i].row;\n int& c = cranes[i].col;\n \n if (action == 'P') {\n cranes[i].holding = grid[r][c];\n grid[r][c] = -1;\n } else if (action == 'Q') {\n grid[r][c] = cranes[i].holding;\n cranes[i].holding = -1;\n } else if (action == 'U') {\n r--;\n } else if (action == 'D') {\n r++;\n } else if (action == 'L') {\n c--;\n } else if (action == 'R') {\n c++;\n } else if (action == 'B') {\n cranes[i].bombed = true;\n }\n }\n \n // Step 3: Dispatch containers at dispatch gates\n for (int i = 0; i < N; i++) {\n if (grid[i][N-1] != -1) {\n int container = grid[i][N-1];\n // Only dispatch if it's the correct gate for this container\n if (container / N == i) {\n containers[container].dispatched = true;\n grid[i][N-1] = -1;\n }\n }\n }\n \n turn_count++;\n return true;\n }\n \n bool is_complete() {\n for (int i = 0; i < N*N; i++) {\n if (!containers[i].dispatched) {\n return false;\n }\n }\n return true;\n }\n \npublic:\n Solver(int n, vector>& a) : N(n), A(a) {\n // Initialize cranes\n cranes.resize(N);\n for (int i = 0; i < N; i++) {\n cranes[i].row = i;\n cranes[i].col = 0;\n cranes[i].holding = -1;\n cranes[i].is_large = (i == 0);\n cranes[i].bombed = false;\n }\n \n // Initialize grid\n grid.assign(N, vector(N, -1));\n \n // Initialize container info\n containers.resize(N*N);\n for (int i = 0; i < N*N; i++) {\n containers[i].target_row = i / N;\n containers[i].target_order = i % N;\n containers[i].arrived = false;\n containers[i].dispatched = false;\n }\n \n // Set arrival info\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n int container = A[i][j];\n containers[container].arrival_row = i;\n containers[container].arrival_order = j;\n }\n }\n \n next_container_index.assign(N, 0);\n turn_count = 0;\n }\n \n vector solve() {\n vector results(N, \"\");\n \n // Simulate up to 10000 turns\n for (int turn = 0; turn < 10000; turn++) {\n vector actions = get_actions();\n \n // Record actions\n for (int i = 0; i < N; i++) {\n results[i] += actions[i];\n }\n \n // Simulate the turn\n simulate_turn(actions);\n \n // Check if we're done\n if (is_complete()) {\n break;\n }\n }\n \n return results;\n }\n};\n\nint main() {\n int N;\n cin >> N;\n \n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> A[i][j];\n }\n }\n \n Solver solver(N, A);\n vector results = solver.solve();\n \n for (int i = 0; i < N; i++) {\n cout << results[i] << endl;\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n\n int r = 0, c = 0;\n int truck = 0;\n vector ops;\n\n while (true) {\n bool all_zero = true;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) {\n all_zero = false;\n break;\n }\n }\n if (!all_zero) break;\n }\n if (all_zero) break;\n\n int target_r = -1, target_c = -1;\n\n if (truck == 0) {\n int min_dist = INT_MAX;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] > 0) {\n int dist = abs(i - r) + abs(j - c);\n if (dist < min_dist) {\n min_dist = dist;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break;\n } else {\n int best_score = INT_MIN;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] < 0) {\n int dist = abs(i - r) + abs(j - c);\n int d = min(truck, -h[i][j]);\n if (d <= 0) continue;\n int score = d - 100 * dist;\n if (score > best_score) {\n best_score = score;\n target_r = i;\n target_c = j;\n }\n }\n }\n }\n if (target_r == -1) break;\n }\n\n // Move to target with enhanced opportunistic loading/unloading\n while (r != target_r || c != target_c) {\n bool moved = false;\n \n // 1. Check current square\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n continue; // Stay in place and re-evaluate\n } else if (h[r][c] < 0 && truck > 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n continue; // Stay in place and re-evaluate\n }\n \n // 2. Calculate adaptive threshold with slightly refined truck load awareness\n int distance_to_target = abs(target_r - r) + abs(target_c - c);\n \n int base_threshold = 30;\n int distance_factor = 5;\n \n if (truck > 0) {\n // Slightly refined parameters for better edge case handling\n distance_factor = max(3, (int)(8.5 - truck / 100.0));\n base_threshold = max(22, 42 - truck / 50);\n }\n \n int adaptive_threshold = max(base_threshold, distance_to_target * distance_factor);\n \n // 3. Check adjacent squares for high-value opportunities\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dir_char[] = {'U', 'D', 'L', 'R'};\n \n for (int k = 0; k < 4; k++) {\n int nr = r + dr[k];\n int nc = c + dc[k];\n \n if (nr < 0 || nr >= N || nc < 0 || nc >= N) continue;\n \n bool is_high_value = false;\n if (truck == 0 && h[nr][nc] > adaptive_threshold) {\n is_high_value = true;\n } else if (truck > 0 && h[nr][nc] < 0 && (-h[nr][nc]) > adaptive_threshold) {\n is_high_value = true;\n }\n \n if (is_high_value) {\n // Move to this high-value square\n ops.push_back(string(1, dir_char[k]));\n r = nr;\n c = nc;\n moved = true;\n break;\n }\n }\n \n if (moved) continue;\n \n // 4. No high-value adjacent opportunities, move toward target\n if (r < target_r) {\n ops.push_back(\"D\");\n r++;\n } else if (r > target_r) {\n ops.push_back(\"U\");\n r--;\n } else if (c < target_c) {\n ops.push_back(\"R\");\n c++;\n } else if (c > target_c) {\n ops.push_back(\"L\");\n c--;\n }\n }\n\n // Final load/unload at target (in case we didn't do it in the loop)\n if (h[r][c] > 0) {\n int d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n truck += d;\n h[r][c] = 0;\n } else if (h[r][c] < 0 && truck > 0) {\n int need = -h[r][c];\n int d = min(truck, need);\n ops.push_back(\"-\" + to_string(d));\n truck -= d;\n h[r][c] += d;\n }\n }\n\n for (const string& op : ops) {\n cout << op << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Problem parameters\nint N, M, T;\nint seed_count;\n\n// Seed structure\nstruct Seed {\n vector values;\n int id;\n int total_value;\n \n Seed() : id(-1), total_value(0) {}\n \n void calculate_total() {\n total_value = 0;\n for (int v : values) {\n total_value += v;\n }\n }\n};\n\n// Position in grid\nstruct Position {\n int row, col;\n int adjacency_count;\n \n Position(int r, int c) : row(r), col(c) {\n adjacency_count = 0;\n if (r > 0) adjacency_count++;\n if (r < N-1) adjacency_count++;\n if (c > 0) adjacency_count++;\n if (c < N-1) adjacency_count++;\n }\n};\n\nbool compare_positions(const Position& a, const Position& b) {\n return a.adjacency_count > b.adjacency_count;\n}\n\n// Calculate complementarity score between two seeds\nint calculate_complementarity(const Seed& a, const Seed& b) {\n int score = 0;\n for (int i = 0; i < M; i++) {\n score += max(a.values[i], b.values[i]);\n }\n return score;\n}\n\n// Calculate diversity score - how different this seed is from others\ndouble calculate_diversity_score(const Seed& seed, const vector& seeds, const vector& selected) {\n double score = 0;\n int selected_count = 0;\n \n for (int i = 0; i < seeds.size(); i++) {\n if (selected[i]) {\n double distance = 0;\n for (int j = 0; j < M; j++) {\n distance += abs(seed.values[j] - seeds[i].values[j]);\n }\n score += distance;\n selected_count++;\n }\n }\n \n if (selected_count > 0) {\n score /= selected_count;\n }\n \n return score;\n}\n\nint main() {\n cin >> N >> M >> T;\n seed_count = 2 * N * (N - 1);\n \n vector seeds(seed_count);\n \n // Read initial seeds\n for (int i = 0; i < seed_count; i++) {\n seeds[i].values.resize(M);\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n \n // Process T turns\n for (int t = 0; t < T; t++) {\n // For each criterion, create ranking of seeds and find maximum possible\n vector> criterion_ranks(M, vector(seed_count));\n vector max_possible(M, 0);\n for (int crit = 0; crit < M; crit++) {\n vector> crit_values; // (value, seed_id)\n for (int i = 0; i < seed_count; i++) {\n crit_values.push_back({seeds[i].values[crit], i});\n max_possible[crit] = max(max_possible[crit], seeds[i].values[crit]);\n }\n sort(crit_values.begin(), crit_values.end(), greater>());\n for (int rank = 0; rank < seed_count; rank++) {\n criterion_ranks[crit][crit_values[rank].second] = rank;\n }\n }\n \n // Create a combined score for selection\n vector> selection_scores(seed_count);\n \n // Calculate average and standard deviation for each criterion\n vector avg_values(M, 0);\n vector std_dev_values(M, 0);\n \n for (int crit = 0; crit < M; crit++) {\n double sum = 0;\n for (int i = 0; i < seed_count; i++) {\n sum += seeds[i].values[crit];\n }\n avg_values[crit] = sum / seed_count;\n \n double sum_sq = 0;\n for (int i = 0; i < seed_count; i++) {\n sum_sq += (seeds[i].values[crit] - avg_values[crit]) * (seeds[i].values[crit] - avg_values[crit]);\n }\n std_dev_values[crit] = sqrt(sum_sq / seed_count);\n }\n \n for (int i = 0; i < seed_count; i++) {\n double score = 0;\n \n // Adjust weights based on generation\n double value_weight = 1.0 + 0.5 * (double)t / T;\n double diversity_weight = 1.0 - 0.8 * (double)t / T; // Higher in early generations\n \n // 1. Total value (base score)\n score += seeds[i].total_value * value_weight;\n \n // 2. Bonus for being in top 5 for any criterion\n int top5_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][i] < 5) {\n top5_count++;\n }\n }\n score += top5_count * 20;\n \n // 3. Bonus for being in top 1 for any criterion\n int top1_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (criterion_ranks[crit][i] == 0) {\n top1_count++;\n }\n }\n score += top1_count * 80;\n \n // 4. Bonus for being close to the maximum in any criterion\n int near_max_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (max_possible[crit] > 0 && \n seeds[i].values[crit] >= max_possible[crit] * 0.9) {\n near_max_count++;\n }\n }\n score += near_max_count * 30;\n \n // 5. Bonus for being significantly above average in any criterion (z-score > 1.5)\n int outstanding_count = 0;\n for (int crit = 0; crit < M; crit++) {\n if (std_dev_values[crit] > 0) {\n double z_score = (seeds[i].values[crit] - avg_values[crit]) / std_dev_values[crit];\n if (z_score > 1.5) {\n outstanding_count++;\n }\n }\n }\n score += outstanding_count * 25;\n \n // 6. Diversity bonus for early generations\n if (t < T / 2) {\n vector dummy_selected(seed_count, false);\n double diversity_score = calculate_diversity_score(seeds[i], seeds, dummy_selected);\n score += diversity_score * diversity_weight * 0.05; // Small weight to avoid overpowering\n }\n \n selection_scores[i] = {score, i};\n }\n \n // Sort by combined score\n sort(selection_scores.begin(), selection_scores.end(), greater>());\n \n // Select top 36 seeds\n vector selected_seeds;\n for (int i = 0; i < N * N; i++) {\n selected_seeds.push_back(selection_scores[i].second);\n }\n \n // Create grid for planting\n vector> grid(N, vector(N, -1));\n \n // Create a mapping of seeds to their complementarity with others\n vector> complementarity_map(seed_count, vector(seed_count, 0));\n for (int i = 0; i < selected_seeds.size(); i++) {\n for (int j = 0; j < selected_seeds.size(); j++) {\n if (i != j) {\n int seed_i = selected_seeds[i];\n int seed_j = selected_seeds[j];\n complementarity_map[seed_i][seed_j] = calculate_complementarity(\n seeds[seed_i], seeds[seed_j]);\n }\n }\n }\n \n // Generate positions sorted by adjacency count\n vector positions;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n positions.emplace_back(i, j);\n }\n }\n \n // Special placement strategy for different phases\n vector placed(seed_count, false);\n \n if (t < T / 3) {\n // Early phase: Place highest scoring seed in center, then focus on diversity\n if (!selected_seeds.empty()) {\n int center_row = N/2, center_col = N/2;\n int best_seed = selected_seeds[0];\n grid[center_row][center_col] = best_seed;\n placed[best_seed] = true;\n }\n \n // Sort remaining positions by adjacency count (high adjacency first)\n sort(positions.begin(), positions.end(), compare_positions);\n \n // Place remaining seeds with focus on diversity from already placed seeds\n vector> remaining_positions;\n for (auto& pos : positions) {\n if (grid[pos.row][pos.col] == -1) {\n remaining_positions.push_back({pos.row, pos.col});\n }\n }\n \n vector remaining_seeds;\n for (int i = 1; i < selected_seeds.size(); i++) {\n remaining_seeds.push_back(selected_seeds[i]);\n }\n \n for (auto& pos : remaining_positions) {\n int row = pos.first;\n int col = pos.second;\n \n if (remaining_seeds.empty()) break;\n \n // Find seed with highest diversity from already placed seeds\n int best_seed_idx = 0;\n double best_diversity = -1;\n \n for (int i = 0; i < remaining_seeds.size(); i++) {\n int seed_id = remaining_seeds[i];\n \n // Calculate diversity score with already placed seeds\n double diversity_score = 0;\n int placed_count = 0;\n \n // Check all adjacent positions\n vector> neighbors = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& nb : neighbors) {\n int nb_row = nb.first;\n int nb_col = nb.second;\n \n if (nb_row >= 0 && nb_row < N && nb_col >= 0 && nb_col < N && \n grid[nb_row][nb_col] != -1) {\n int nb_seed = grid[nb_row][nb_col];\n double distance = 0;\n for (int j = 0; j < M; j++) {\n distance += abs(seeds[seed_id].values[j] - seeds[nb_seed].values[j]);\n }\n diversity_score += distance;\n placed_count++;\n }\n }\n \n // If no placed neighbors, use overall diversity\n if (placed_count == 0) {\n vector temp_placed(seed_count, false);\n for (auto& rs : remaining_seeds) {\n if (rs != seed_id) temp_placed[rs] = true;\n }\n diversity_score = calculate_diversity_score(seeds[seed_id], seeds, temp_placed);\n } else {\n diversity_score /= placed_count;\n }\n \n if (diversity_score > best_diversity) {\n best_diversity = diversity_score;\n best_seed_idx = i;\n }\n }\n \n // Place the most diverse seed\n int chosen_seed = remaining_seeds[best_seed_idx];\n grid[row][col] = chosen_seed;\n placed[chosen_seed] = true;\n remaining_seeds.erase(remaining_seeds.begin() + best_seed_idx);\n }\n } else {\n // Middle/Late phase: Greedy placement based on complementarity\n if (!selected_seeds.empty()) {\n int center_row = N/2, center_col = N/2;\n int best_seed = selected_seeds[0];\n grid[center_row][center_col] = best_seed;\n placed[best_seed] = true;\n }\n \n // Sort remaining positions by adjacency count (high adjacency first)\n sort(positions.begin(), positions.end(), compare_positions);\n \n vector> remaining_positions;\n for (auto& pos : positions) {\n if (grid[pos.row][pos.col] == -1) {\n remaining_positions.push_back({pos.row, pos.col});\n }\n }\n \n vector remaining_seeds;\n for (int i = 1; i < selected_seeds.size(); i++) {\n remaining_seeds.push_back(selected_seeds[i]);\n }\n \n // Place remaining seeds based on complementarity with neighbors\n for (auto& pos : remaining_positions) {\n int row = pos.first;\n int col = pos.second;\n \n if (remaining_seeds.empty()) break;\n \n // Find the best seed to place at this position based on complementarity with neighbors\n int best_seed_idx = 0;\n int best_score = -1;\n \n for (int i = 0; i < remaining_seeds.size(); i++) {\n int seed_id = remaining_seeds[i];\n \n // Calculate score based on complementarity with adjacent placed seeds\n int complementarity_score = 0;\n int neighbor_count = 0;\n \n // Check all adjacent positions\n vector> neighbors = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& nb : neighbors) {\n int nb_row = nb.first;\n int nb_col = nb.second;\n \n if (nb_row >= 0 && nb_row < N && nb_col >= 0 && nb_col < N && \n grid[nb_row][nb_col] != -1) {\n int nb_seed = grid[nb_row][nb_col];\n complementarity_score += complementarity_map[seed_id][nb_seed];\n neighbor_count++;\n }\n }\n \n // If no neighbors are placed yet, use the seed's base score\n if (neighbor_count == 0) {\n // Find the original score of this seed\n double base_score = 0;\n for (int j = 0; j < selection_scores.size(); j++) {\n if (selection_scores[j].second == seed_id) {\n base_score = selection_scores[j].first;\n break;\n }\n }\n complementarity_score = base_score;\n }\n \n if (complementarity_score > best_score) {\n best_score = complementarity_score;\n best_seed_idx = i;\n }\n }\n \n // Place the best seed\n int chosen_seed = remaining_seeds[best_seed_idx];\n grid[row][col] = chosen_seed;\n placed[chosen_seed] = true;\n remaining_seeds.erase(remaining_seeds.begin() + best_seed_idx);\n }\n }\n \n // Optimize placement with adjacency-based swapping\n if (t < T - 1) {\n bool improved = true;\n int iteration = 0;\n const int max_iterations = 20; // Increased from 15\n \n // Use different thresholds based on generation\n int threshold = 5 - (3 * t / T); // Higher threshold in early gens, lower in late gens\n if (threshold < 1) threshold = 1;\n \n while (improved && iteration < max_iterations) {\n improved = false;\n \n // Try swapping adjacent positions (up, down, left, right)\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n // Try swapping with right neighbor\n if (j < N - 1) {\n int seed1 = grid[i][j];\n int seed2 = grid[i][j+1];\n \n // Calculate current complementarity\n int current_score = 0;\n \n // Check all neighbors for both positions\n vector> neighbors;\n neighbors.push_back({i, j});\n neighbors.push_back({i, j+1});\n \n for (auto& pos : neighbors) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = grid[row][col];\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N && \n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n current_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // Calculate score if we swap\n int swapped_score = 0;\n \n // After swap, seed2 is at (i,j) and seed1 is at (i,j+1)\n vector> positions_after_swap;\n positions_after_swap.push_back({i, j}); // now has seed2\n positions_after_swap.push_back({i, j+1}); // now has seed1\n \n for (auto& pos : positions_after_swap) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = (row == i && col == j) ? seed2 : seed1;\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N &&\n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n swapped_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // If swapping improves the score, do it\n if (swapped_score > current_score + threshold) {\n swap(grid[i][j], grid[i][j+1]);\n improved = true;\n \n // Update complementarity map for these seeds\n for (int k = 0; k < seed_count; k++) {\n if (k != seed1 && k != seed2) {\n if (k < seed_count && seed1 < seed_count && seed2 < seed_count) {\n complementarity_map[seed1][k] = calculate_complementarity(seeds[seed1], seeds[k]);\n complementarity_map[k][seed1] = complementarity_map[seed1][k];\n complementarity_map[seed2][k] = calculate_complementarity(seeds[seed2], seeds[k]);\n complementarity_map[k][seed2] = complementarity_map[seed2][k];\n }\n }\n }\n }\n }\n \n // Try swapping with bottom neighbor\n if (i < N - 1) {\n int seed1 = grid[i][j];\n int seed2 = grid[i+1][j];\n \n // Calculate current complementarity\n int current_score = 0;\n \n // Check all neighbors for both positions\n vector> neighbors;\n neighbors.push_back({i, j});\n neighbors.push_back({i+1, j});\n \n for (auto& pos : neighbors) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = grid[row][col];\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N && \n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n current_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // Calculate score if we swap\n int swapped_score = 0;\n \n // After swap, seed2 is at (i,j) and seed1 is at (i+1,j)\n vector> positions_after_swap;\n positions_after_swap.push_back({i, j}); // now has seed2\n positions_after_swap.push_back({i+1, j}); // now has seed1\n \n for (auto& pos : positions_after_swap) {\n int row = pos.first;\n int col = pos.second;\n int seed_id = (row == i && col == j) ? seed2 : seed1;\n \n // Check all adjacent positions\n vector> adj_positions = {\n {row-1, col}, {row+1, col}, {row, col-1}, {row, col+1}\n };\n \n for (auto& adj : adj_positions) {\n int adj_row = adj.first;\n int adj_col = adj.second;\n \n if (adj_row >= 0 && adj_row < N && adj_col >= 0 && adj_col < N &&\n !(adj_row == row && adj_col == col)) {\n int adj_seed = grid[adj_row][adj_col];\n if (adj_seed != -1) {\n swapped_score += complementarity_map[seed_id][adj_seed];\n }\n }\n }\n }\n \n // If swapping improves the score, do it\n if (swapped_score > current_score + threshold) {\n swap(grid[i][j], grid[i+1][j]);\n improved = true;\n \n // Update complementarity map for these seeds\n for (int k = 0; k < seed_count; k++) {\n if (k != seed1 && k != seed2) {\n if (k < seed_count && seed1 < seed_count && seed2 < seed_count) {\n complementarity_map[seed1][k] = calculate_complementarity(seeds[seed1], seeds[k]);\n complementarity_map[k][seed1] = complementarity_map[seed1][k];\n complementarity_map[seed2][k] = calculate_complementarity(seeds[seed2], seeds[k]);\n complementarity_map[k][seed2] = complementarity_map[seed2][k];\n }\n }\n }\n }\n }\n }\n }\n \n iteration++;\n }\n }\n \n // Output the grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j];\n if (j < N - 1) {\n cout << \" \";\n }\n }\n cout << endl;\n }\n cout.flush();\n \n // Read new seeds\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].values[j];\n }\n seeds[i].id = i;\n seeds[i].calculate_total();\n }\n }\n \n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n bool in_bounds(int N) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nstruct State {\n Point root_pos;\n vector directions; // Direction of each edge (0=R, 1=D, 2=L, 3=U)\n vector holding; // What each fingertip is holding\n};\n\nstruct TreeNode {\n int parent;\n int length;\n vector children;\n bool is_leaf;\n};\n\nclass RoboticArmSolver {\nprivate:\n int N, M, V;\n vector initial_grid, target_grid;\n vector start_positions, target_positions;\n vector tree;\n int V_prime;\n vector fingertips;\n State current_state;\n mt19937 rng;\n \n // Direction vectors: Right, Down, Left, Up\n const vector DX = {1, 0, -1, 0};\n const vector DY = {0, 1, 0, -1};\n const string DIR_CHARS = \"RDLU\";\n \npublic:\n RoboticArmSolver() : rng(chrono::steady_clock::now().time_since_epoch().count()) {}\n \n void read_input() {\n cin >> N >> M >> V;\n initial_grid.resize(N);\n target_grid.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> initial_grid[i];\n }\n for (int i = 0; i < N; i++) {\n cin >> target_grid[i];\n }\n \n // Extract start and target positions\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '0') {\n start_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '0' && target_grid[i][j] == '1') {\n target_positions.push_back(Point(i, j));\n }\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n // Already in correct position, no need to move\n // But we still count it for M'\n M--;\n }\n }\n }\n \n // Shuffle for randomization\n shuffle(start_positions.begin(), start_positions.end(), rng);\n shuffle(target_positions.begin(), target_positions.end(), rng);\n }\n \n void design_arm() {\n // Determine number of vertices to use\n V_prime = min(V, 10); // Use up to 10 vertices for simplicity\n \n // Build a simple tree: root (0) connected to several children\n // Try to create a balanced tree with multiple fingertips\n tree.resize(V_prime);\n for (int i = 0; i < V_prime; i++) {\n tree[i].is_leaf = true; // Initially all are leaves\n }\n \n // Create tree structure\n // Root at 0\n tree[0].parent = -1;\n tree[0].is_leaf = false;\n \n // Add children to root and possibly to other nodes\n int next_vertex = 1;\n vector current_level = {0};\n \n while (next_vertex < V_prime) {\n vector next_level;\n for (int parent : current_level) {\n if (next_vertex >= V_prime) break;\n \n // Add 1-2 children to each node\n int children_count = min(2, V_prime - next_vertex);\n for (int i = 0; i < children_count && next_vertex < V_prime; i++) {\n tree[next_vertex].parent = parent;\n tree[next_vertex].length = 1; // Use length 1 for simplicity\n tree[parent].children.push_back(next_vertex);\n tree[parent].is_leaf = false;\n next_level.push_back(next_vertex);\n next_vertex++;\n }\n }\n current_level = next_level;\n }\n \n // Identify fingertips (leaves)\n for (int i = 0; i < V_prime; i++) {\n if (tree[i].is_leaf) {\n fingertips.push_back(i);\n }\n }\n }\n \n Point find_initial_position() {\n // Find a central position that minimizes distance to start positions\n int best_x = N/2, best_y = N/2;\n double min_dist = 1e9;\n \n // Try positions around center\n for (int x = max(0, N/2 - 2); x <= min(N-1, N/2 + 2); x++) {\n for (int y = max(0, N/2 - 2); y <= min(N-1, N/2 + 2); y++) {\n double dist = 0;\n for (const Point& p : start_positions) {\n dist += abs(p.x - x) + abs(p.y - y);\n }\n if (dist < min_dist) {\n min_dist = dist;\n best_x = x;\n best_y = y;\n }\n }\n }\n \n return Point(best_x, best_y);\n }\n \n // Calculate positions of all vertices given root position and directions\n vector calculate_positions(const Point& root_pos, const vector& directions) {\n vector positions(V_prime);\n positions[0] = root_pos;\n \n for (int i = 1; i < V_prime; i++) {\n int parent = tree[i].parent;\n int dir = directions[i];\n int len = tree[i].length;\n \n positions[i] = Point(\n positions[parent].x + DY[dir] * len, // Note: Y is row, X is column\n positions[parent].y + DX[dir] * len\n );\n }\n \n return positions;\n }\n \n // Find distance between two points\n int manhattan_distance(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n }\n \n // Find the best move for the arm\n string find_best_move() {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n string command(2 * V_prime, '.');\n \n // First, try to pick up or place takoyaki\n bool did_action = false;\n for (int i = 0; i < fingertips.size() && !did_action; i++) {\n int finger = fingertips[i];\n Point pos = positions[finger];\n \n if (!pos.in_bounds(N)) continue;\n \n // Check if we can pick up a takoyaki\n if (!current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '1' && \n target_grid[pos.x][pos.y] == '0') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = true;\n initial_grid[pos.x][pos.y] = '0'; // Remove from initial grid\n did_action = true;\n continue;\n }\n \n // Check if we can place a takoyaki\n if (current_state.holding[finger] && \n initial_grid[pos.x][pos.y] == '0' && \n target_grid[pos.x][pos.y] == '1') {\n \n command[V_prime + finger] = 'P';\n current_state.holding[finger] = false;\n initial_grid[pos.x][pos.y] = '1'; // Add to grid (mark as delivered)\n did_action = true;\n continue;\n }\n }\n \n if (did_action) {\n return command;\n }\n \n // No pickup/place action, move toward a target\n // Find closest undelivered takoyaki or target position\n Point target_pos;\n bool move_to_start = false;\n \n if (!start_positions.empty()) {\n // Find closest start position that has a takoyaki\n int min_dist = 1e9;\n for (int i = 0; i < start_positions.size(); i++) {\n if (initial_grid[start_positions[i].x][start_positions[i].y] == '1') {\n int dist = manhattan_distance(current_state.root_pos, start_positions[i]);\n if (dist < min_dist) {\n min_dist = dist;\n target_pos = start_positions[i];\n move_to_start = true;\n }\n }\n }\n }\n \n // If no start positions available or none have takoyaki, move to target positions\n if (!move_to_start || min_dist == 1e9) {\n for (int i = 0; i < target_positions.size(); i++) {\n if (initial_grid[target_positions[i].x][target_positions[i].y] == '0') {\n int dist = manhattan_distance(current_state.root_pos, target_positions[i]);\n if (dist < min_dist || min_dist == 1e9) {\n min_dist = dist;\n target_pos = target_positions[i];\n move_to_start = false;\n }\n }\n }\n }\n \n // Move toward target\n if (min_dist != 1e9) {\n int dx = target_pos.x - current_state.root_pos.x;\n int dy = target_pos.y - current_state.root_pos.y;\n \n if (dx != 0 || dy != 0) {\n // Determine best direction to move\n char best_dir = '.';\n int best_improvement = -1;\n \n for (int d = 0; d < 4; d++) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (!new_pos.in_bounds(N)) continue;\n \n int new_dist = abs(new_pos.x - target_pos.x) + abs(new_pos.y - target_pos.y);\n int improvement = min_dist - new_dist;\n \n if (improvement > best_improvement) {\n best_improvement = improvement;\n best_dir = DIR_CHARS[d];\n command[0] = best_dir;\n }\n }\n \n // Update root position if we found a valid move\n if (best_dir != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == best_dir) {\n current_state.root_pos.x += DX[d];\n current_state.root_pos.y += DY[d];\n break;\n }\n }\n }\n }\n } else {\n // Random move if no clear target\n vector valid_moves = {'.', 'R', 'D', 'L', 'U'};\n int r = rng() % valid_moves.size();\n command[0] = valid_moves[r];\n \n if (command[0] != '.') {\n for (int d = 0; d < 4; d++) {\n if (DIR_CHARS[d] == command[0]) {\n Point new_pos(current_state.root_pos.x + DX[d], current_state.root_pos.y + DY[d]);\n if (new_pos.in_bounds(N)) {\n current_state.root_pos = new_pos;\n }\n break;\n }\n }\n }\n }\n \n // Random rotations to explore different configurations\n if (rng() % 3 == 0) { // 33% chance of rotation\n for (int i = 1; i < V_prime; i++) {\n if (rng() % 3 == 0) { // 33% chance per joint\n if (rng() % 2) {\n command[i] = 'R';\n current_state.directions[i] = (current_state.directions[i] + 1) % 4;\n } else {\n command[i] = 'L';\n current_state.directions[i] = (current_state.directions[i] + 3) % 4;\n }\n }\n }\n }\n \n return command;\n }\n \n void solve() {\n read_input();\n design_arm();\n \n // Output arm design\n cout << V_prime << endl;\n for (int i = 1; i < V_prime; i++) {\n cout << tree[i].parent << \" \" << tree[i].length << endl;\n }\n \n // Find and output initial position\n Point initial_pos = find_initial_position();\n cout << initial_pos.x << \" \" << initial_pos.y << endl;\n \n // Initialize state\n current_state.root_pos = initial_pos;\n current_state.directions.resize(V_prime, 0); // All start pointing right\n current_state.holding.resize(V_prime, false);\n \n // Generate operations\n vector commands;\n int max_turns = min(50000, 100000); // Limit to avoid TLE\n \n for (int turn = 0; turn < max_turns; turn++) {\n string command = find_best_move();\n commands.push_back(command);\n \n // Check if all takoyaki are delivered\n int delivered = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (initial_grid[i][j] == '1' && target_grid[i][j] == '1') {\n delivered++;\n }\n }\n }\n \n // Also count held takoyaki that can be placed\n for (int finger : fingertips) {\n if (current_state.holding[finger]) {\n vector positions = calculate_positions(current_state.root_pos, current_state.directions);\n Point pos = positions[finger];\n if (pos.in_bounds(N) && target_grid[pos.x][pos.y] == '1' && initial_grid[pos.x][pos.y] == '0') {\n delivered++; // Can be delivered in next turn\n }\n }\n }\n \n // If we've delivered all or have extra, break early\n if (delivered >= M) {\n break;\n }\n }\n \n // Output commands\n for (const string& cmd : commands) {\n cout << cmd << endl;\n }\n }\n};\n\nint main() {\n RoboticArmSolver solver;\n solver.solve();\n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x = 0, int y = 0) : x(x), y(y) {}\n bool operator<(const Point& other) const {\n if (x != other.x) return x < other.x;\n return y < other.y;\n }\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\nstruct Rectangle {\n int x1, y1, x2, y2; // x1 <= x2, y1 <= y2\n Rectangle(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0) : x1(x1), y1(y1), x2(x2), y2(y2) {}\n \n bool contains(const Point& p) const {\n return p.x >= x1 && p.x <= x2 && p.y >= y1 && p.y <= y2;\n }\n \n int area() const {\n return (x2 - x1) * (y2 - y1);\n }\n \n // Expand or shrink rectangle\n Rectangle expand(int padding) const {\n return Rectangle(\n max(0, x1 - padding),\n max(0, y1 - padding),\n min(100000, x2 + padding),\n min(100000, y2 + padding)\n );\n }\n};\n\n// Count points in rectangle\npair countPoints(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n int mackerelCount = 0, sardineCount = 0;\n \n for (const auto& p : mackerels) {\n if (rect.contains(p)) mackerelCount++;\n }\n \n for (const auto& p : sardines) {\n if (rect.contains(p)) sardineCount++;\n }\n \n return {mackerelCount, sardineCount};\n}\n\n// Calculate score for rectangle\nint calculateScore(const vector& mackerels, const vector& sardines, const Rectangle& rect) {\n auto [m, s] = countPoints(mackerels, sardines, rect);\n return max(0, m - s + 1);\n}\n\n// Calculate average distance between points to determine sparsity\ndouble calculateAverageDistance(const vector& points) {\n if (points.size() < 2) return 0.0;\n \n // Sample a subset to avoid O(N^2)\n int sampleSize = min(50, (int)points.size());\n long long totalDist = 0;\n int count = 0;\n \n for (int i = 0; i < sampleSize; i++) {\n for (int j = i + 1; j < sampleSize; j++) {\n long long dx = points[i].x - points[j].x;\n long long dy = points[i].y - points[j].y;\n totalDist += sqrt(dx * dx + dy * dy);\n count++;\n }\n }\n \n return count > 0 ? (double)totalDist / count : 0.0;\n}\n\n// Simple clustering: group points within a certain distance\nvector> findClusters(const vector& mackerels, int distance) {\n vector> clusters;\n vector visited(mackerels.size(), false);\n \n for (int i = 0; i < (int)mackerels.size(); i++) {\n if (visited[i]) continue;\n \n vector cluster;\n cluster.push_back(i);\n visited[i] = true;\n \n // Find all points within distance\n for (int j = i + 1; j < (int)mackerels.size(); j++) {\n if (visited[j]) continue;\n \n long long dx = mackerels[i].x - mackerels[j].x;\n long long dy = mackerels[i].y - mackerels[j].y;\n long long distSq = dx * dx + dy * dy;\n \n if (distSq <= (long long)distance * distance) {\n cluster.push_back(j);\n visited[j] = true;\n }\n }\n \n if (cluster.size() >= 2) { // Lower threshold to 2 for sparse cases\n clusters.push_back(cluster);\n }\n }\n \n return clusters;\n}\n\n// Generate grid sizes based on data characteristics\nvector determineGridSizes(const vector& mackerels) {\n double avgDist = calculateAverageDistance(mackerels);\n \n vector gridSizes;\n \n if (avgDist < 1500) {\n // Very clustered - use finer grids\n gridSizes = {25, 30, 35};\n } else if (avgDist < 3500) {\n // Moderately clustered\n gridSizes = {20, 25, 30};\n } else if (avgDist < 6000) {\n // Somewhat spread out\n gridSizes = {15, 20, 25};\n } else {\n // Very spread out - use coarser grids\n gridSizes = {10, 15, 20};\n }\n \n return gridSizes;\n}\n\n// Generate candidate rectangles with multiple strategies\nvector generateCandidateRectangles(const vector& mackerels, const vector& sardines) {\n vector candidates;\n const int MAX_CANDIDATES = 60;\n \n // Calculate average distance to adapt strategies\n double avgDist = calculateAverageDistance(mackerels);\n bool isSparse = avgDist > 5000;\n \n // Strategy 1: Adaptive grid sizes based on data characteristics\n vector gridSizes = determineGridSizes(mackerels);\n \n for (int gridSize : gridSizes) {\n if (candidates.size() >= MAX_CANDIDATES / 2) break;\n \n const int CELL_SIZE = 100000 / gridSize;\n vector> mackerelCount(gridSize, vector(gridSize, 0));\n vector> sardineCount(gridSize, vector(gridSize, 0));\n \n // Count points in each grid cell\n for (const auto& p : mackerels) {\n int gx = min(gridSize - 1, p.x / CELL_SIZE);\n int gy = min(gridSize - 1, p.y / CELL_SIZE);\n mackerelCount[gx][gy]++;\n }\n \n for (const auto& p : sardines) {\n int gx = min(gridSize - 1, p.x / CELL_SIZE);\n int gy = min(gridSize - 1, p.y / CELL_SIZE);\n sardineCount[gx][gy]++;\n }\n \n // Generate rectangles for high-scoring cells\n for (int i = 0; i < gridSize && candidates.size() < MAX_CANDIDATES / 2; i++) {\n for (int j = 0; j < gridSize && candidates.size() < MAX_CANDIDATES / 2; j++) {\n int m = mackerelCount[i][j];\n int s = sardineCount[i][j];\n \n if (m > 0 && (m > s || isSparse)) { // For sparse cases, be more permissive\n int x1 = i * CELL_SIZE;\n int y1 = j * CELL_SIZE;\n int x2 = min(100000, (i + 1) * CELL_SIZE);\n int y2 = min(100000, (j + 1) * CELL_SIZE);\n \n // Try different paddings\n vector paddings = {0, CELL_SIZE/4, CELL_SIZE/2};\n if (isSparse) {\n paddings = {0, CELL_SIZE/2, CELL_SIZE}; // Larger paddings for sparse cases\n }\n \n for (int pad : paddings) {\n int px1 = max(0, x1 - pad);\n int py1 = max(0, y1 - pad);\n int px2 = min(100000, x2 + pad);\n int py2 = min(100000, y2 + pad);\n \n Rectangle rect(px1, py1, px2, py2);\n int score = calculateScore(mackerels, sardines, rect);\n \n if (score > 2) { // Lower threshold for sparse cases\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES / 2) break;\n }\n }\n }\n }\n }\n }\n \n // Strategy 2: Adaptive clustering based on sparsity\n vector clusterDistances;\n if (isSparse) {\n clusterDistances = {3000, 5000, 8000}; // Larger distances for sparse cases\n } else {\n clusterDistances = {1000, 2000, 3000};\n }\n \n for (int distance : clusterDistances) {\n if (candidates.size() >= MAX_CANDIDATES * 3 / 4) break;\n \n auto clusters = findClusters(mackerels, distance);\n \n for (const auto& cluster : clusters) {\n if (candidates.size() >= MAX_CANDIDATES * 3 / 4) break;\n \n // Find bounding box of cluster\n int x1 = 100000, y1 = 100000, x2 = 0, y2 = 0;\n for (int idx : cluster) {\n x1 = min(x1, mackerels[idx].x);\n y1 = min(y1, mackerels[idx].y);\n x2 = max(x2, mackerels[idx].x);\n y2 = max(y2, mackerels[idx].y);\n }\n \n // Try different expansions\n vector expandFactors = {1.0, 1.2, 1.5, 2.0};\n if (isSparse) {\n expandFactors = {1.0, 1.1, 1.2, 1.3}; // Smaller expansions for sparse cases\n }\n \n for (double factor : expandFactors) {\n int dx = (int)((x2 - x1) * (factor - 1.0) / 2);\n int dy = (int)((y2 - y1) * (factor - 1.0) / 2);\n \n int ex1 = max(0, x1 - dx);\n int ey1 = max(0, y1 - dy);\n int ex2 = min(100000, x2 + dx);\n int ey2 = min(100000, y2 + dy);\n \n Rectangle rect(ex1, ey1, ex2, ey2);\n int score = calculateScore(mackerels, sardines, rect);\n \n if (score > 2) { // Lower threshold for sparse cases\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES * 3 / 4) break;\n }\n }\n }\n }\n \n // Strategy 3: Sample individual points with adaptive sizing\n if (candidates.size() < MAX_CANDIDATES) {\n // Create a 25x25 grid for density estimation\n const int GRID_SIZE = 25;\n const int CELL_SIZE = 100000 / GRID_SIZE;\n vector> mackerelDensity(GRID_SIZE, vector(GRID_SIZE, 0));\n vector> sardineDensity(GRID_SIZE, vector(GRID_SIZE, 0));\n \n for (const auto& p : mackerels) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n mackerelDensity[gx][gy]++;\n }\n \n for (const auto& p : sardines) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n sardineDensity[gx][gy]++;\n }\n \n // Score each mackerel by local density\n vector> mackerelScores; // (density_score, index)\n for (int i = 0; i < (int)mackerels.size(); i++) {\n int gx = min(GRID_SIZE - 1, mackerels[i].x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, mackerels[i].y / CELL_SIZE);\n int score = mackerelDensity[gx][gy] - sardineDensity[gx][gy];\n \n if (score > -5 || isSparse) { // More permissive for sparse cases\n mackerelScores.push_back({score, i});\n }\n }\n \n // Sort by score\n sort(mackerelScores.begin(), mackerelScores.end(), greater>());\n \n // Try top 60 mackerels\n int sampleSize = min(60, (int)mackerelScores.size());\n \n // Adaptive sizes based on sparsity\n vector sizes;\n if (isSparse) {\n sizes = {2000, 4000, 6000, 8000, 12000, 16000, 20000};\n } else {\n sizes = {1000, 2000, 3000, 5000, 8000, 12000};\n }\n \n for (int i = 0; i < sampleSize && candidates.size() < MAX_CANDIDATES; i++) {\n int idx = mackerelScores[i].second;\n int x = mackerels[idx].x;\n int y = mackerels[idx].y;\n \n for (int size : sizes) {\n int x1 = max(0, x - size/2);\n int y1 = max(0, y - size/2);\n int x2 = min(100000, x + size/2);\n int y2 = min(100000, y + size/2);\n \n Rectangle rect(x1, y1, x2, y2);\n int score = calculateScore(mackerels, sardines, rect);\n \n if (score > 2) { // Lower threshold for sparse cases\n candidates.push_back(rect);\n if (candidates.size() >= MAX_CANDIDATES) break;\n }\n }\n }\n }\n \n // Fine-tuning: Adjust boundaries of top candidates\n if (candidates.size() > 0) {\n // Take top 10 candidates for fine-tuning\n sort(candidates.begin(), candidates.end(), [&](const Rectangle& a, const Rectangle& b) {\n return calculateScore(mackerels, sardines, a) > calculateScore(mackerels, sardines, b);\n });\n \n vector fineTuned;\n int fineTuneCount = min(10, (int)candidates.size());\n \n for (int i = 0; i < fineTuneCount; i++) {\n Rectangle rect = candidates[i];\n int bestScore = calculateScore(mackerels, sardines, rect);\n \n // Try small adjustments\n vector adjustments = {-100, 100, -200, 200, -300, 300};\n \n for (int dx : adjustments) {\n for (int dy : adjustments) {\n Rectangle test = rect;\n \n // Adjust all boundaries\n test.x1 = max(0, test.x1 + dx);\n test.y1 = max(0, test.y1 + dy);\n test.x2 = min(100000, test.x2 + dx);\n test.y2 = min(100000, test.y2 + dy);\n \n if (test.x1 < test.x2 && test.y1 < test.y2) {\n int testScore = calculateScore(mackerels, sardines, test);\n if (testScore > bestScore) {\n bestScore = testScore;\n rect = test;\n }\n }\n }\n }\n \n fineTuned.push_back(rect);\n }\n \n // Add fine-tuned candidates back\n for (const auto& rect : fineTuned) {\n candidates.push_back(rect);\n }\n }\n \n // Remove duplicates\n sort(candidates.begin(), candidates.end(), [](const Rectangle& a, const Rectangle& b) {\n if (a.x1 != b.x1) return a.x1 < b.x1;\n if (a.y1 != b.y1) return a.y1 < b.y1;\n if (a.x2 != b.x2) return a.x2 < b.x2;\n return a.y2 < b.y2;\n });\n \n auto last = unique(candidates.begin(), candidates.end(), [](const Rectangle& a, const Rectangle& b) {\n return a.x1 == b.x1 && a.y1 == b.y1 && a.x2 == b.x2 && a.y2 == b.y2;\n });\n candidates.erase(last, candidates.end());\n \n // Sort by score\n sort(candidates.begin(), candidates.end(), [&](const Rectangle& a, const Rectangle& b) {\n return calculateScore(mackerels, sardines, a) > calculateScore(mackerels, sardines, b);\n });\n \n // Keep top candidates\n if (candidates.size() > 40) {\n candidates.resize(40);\n }\n \n return candidates;\n}\n\n// Create polygon from rectangle\nvector createPolygonFromRectangle(const Rectangle& rect) {\n return {\n Point(rect.x1, rect.y1),\n Point(rect.x2, rect.y1),\n Point(rect.x2, rect.y2),\n Point(rect.x1, rect.y2)\n };\n}\n\n// Fallback solution with multiple strategies\nvector createFallbackSolution(const vector& mackerels, const vector& sardines) {\n // Strategy 1: Center of mackerels\n long long sumX = 0, sumY = 0;\n for (const auto& p : mackerels) {\n sumX += p.x;\n sumY += p.y;\n }\n int centerX = sumX / mackerels.size();\n int centerY = sumY / mackerels.size();\n \n vector sizes = {5000, 10000, 15000, 20000, 25000};\n int bestScore = 0;\n Rectangle bestRect(30000, 30000, 70000, 70000);\n \n for (int size : sizes) {\n int x1 = max(0, centerX - size/2);\n int y1 = max(0, centerY - size/2);\n int x2 = min(100000, centerX + size/2);\n int y2 = min(100000, centerY + size/2);\n \n Rectangle rect(x1, y1, x2, y2);\n int score = calculateScore(mackerels, sardines, rect);\n \n if (score > bestScore) {\n bestScore = score;\n bestRect = rect;\n }\n }\n \n // Strategy 2: Try quadrants\n if (bestScore < 10) {\n vector> centers = {\n {25000, 25000}, {75000, 25000}, {25000, 75000}, {75000, 75000}, {50000, 50000}\n };\n \n for (const auto& center : centers) {\n Rectangle rect(\n max(0, center.first - 10000),\n max(0, center.second - 10000),\n min(100000, center.first + 10000),\n min(100000, center.second + 10000)\n );\n \n int score = calculateScore(mackerels, sardines, rect);\n if (score > bestScore) {\n bestScore = score;\n bestRect = rect;\n }\n }\n }\n \n // Strategy 3: Try small rectangles around top scoring mackerels\n if (bestScore < 10) {\n // Score each mackerel by local density\n const int GRID_SIZE = 20;\n const int CELL_SIZE = 100000 / GRID_SIZE;\n vector> mackerelDensity(GRID_SIZE, vector(GRID_SIZE, 0));\n vector> sardineDensity(GRID_SIZE, vector(GRID_SIZE, 0));\n \n for (const auto& p : mackerels) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n mackerelDensity[gx][gy]++;\n }\n \n for (const auto& p : sardines) {\n int gx = min(GRID_SIZE - 1, p.x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, p.y / CELL_SIZE);\n sardineDensity[gx][gy]++;\n }\n \n vector> mackerelScores;\n for (int i = 0; i < (int)mackerels.size(); i++) {\n int gx = min(GRID_SIZE - 1, mackerels[i].x / CELL_SIZE);\n int gy = min(GRID_SIZE - 1, mackerels[i].y / CELL_SIZE);\n int score = mackerelDensity[gx][gy] - sardineDensity[gx][gy];\n mackerelScores.push_back({score, i});\n }\n \n sort(mackerelScores.begin(), mackerelScores.end(), greater>());\n \n for (int i = 0; i < min(15, (int)mackerelScores.size()); i++) {\n int idx = mackerelScores[i].second;\n \n // Try different sizes\n vector sizes = {1000, 2000, 3000, 5000};\n for (int size : sizes) {\n Rectangle rect(\n max(0, mackerels[idx].x - size/2),\n max(0, mackerels[idx].y - size/2),\n min(100000, mackerels[idx].x + size/2),\n min(100000, mackerels[idx].y + size/2)\n );\n \n int score = calculateScore(mackerels, sardines, rect);\n if (score > bestScore) {\n bestScore = score;\n bestRect = rect;\n }\n }\n }\n }\n \n return createPolygonFromRectangle(bestRect);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n cin >> N;\n \n vector mackerels(N);\n vector sardines(N);\n \n // Read mackerels\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n \n // Read sardines\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n \n // Generate candidates\n vector candidates = generateCandidateRectangles(mackerels, sardines);\n \n // Find best candidate\n vector bestPolygon;\n int bestScore = 0;\n \n if (!candidates.empty()) {\n bestPolygon = createPolygonFromRectangle(candidates[0]);\n bestScore = calculateScore(mackerels, sardines, candidates[0]);\n }\n \n // If no good candidates found, use fallback\n if (bestScore <= 5) {\n bestPolygon = createFallbackSolution(mackerels, sardines);\n }\n \n // Output\n cout << bestPolygon.size() << \"\\n\";\n for (const auto& p : bestPolygon) {\n cout << p.x << \" \" << p.y << \"\\n\";\n }\n \n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Placement {\n int p, r;\n char d;\n int b;\n \n Placement(int p_val, int r_val, char d_val, int b_val) \n : p(p_val), r(r_val), d(d_val), b(b_val) {}\n};\n\nclass RectanglePacker {\nprivate:\n int N, T;\n double sigma;\n vector> observed_wh;\n mt19937 rng;\n vector best_placement;\n long long best_score;\n int best_turn;\n vector> feedback_history;\n \n struct StrategyStats {\n int attempts;\n long long total_score;\n double success_rate;\n long long best_score_achieved;\n };\n \n vector strategy_stats;\n int current_strategy;\n vector aspect_ratios;\n vector rectangle_costs;\n \npublic:\n RectanglePacker(int seed = 1234) : rng(seed) {\n best_score = LLONG_MAX;\n best_turn = -1;\n \n strategy_stats.resize(5);\n for (int i = 0; i < 5; i++) {\n strategy_stats[i] = {0, 0, 0.5, LLONG_MAX};\n }\n current_strategy = 0;\n }\n \n void readInput() {\n cin >> N >> T >> sigma;\n observed_wh.resize(N);\n aspect_ratios.resize(N);\n rectangle_costs.resize(N);\n \n for (int i = 0; i < N; i++) {\n cin >> observed_wh[i].first >> observed_wh[i].second;\n aspect_ratios[i] = (double)max(observed_wh[i].first, observed_wh[i].second) / \n min(observed_wh[i].first, observed_wh[i].second);\n rectangle_costs[i] = (long long)observed_wh[i].first + observed_wh[i].second;\n }\n }\n \n vector generateRandomPlacement(int n) {\n vector placement;\n uniform_int_distribution rotation_dist(0, 1);\n uniform_int_distribution direction_dist(0, 1);\n \n for (int i = 0; i < n; i++) {\n int r = rotation_dist(rng);\n char d = direction_dist(rng) ? 'L' : 'U';\n int b = -1;\n if (i > 0) {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n \n placement.push_back(Placement(i, r, d, b));\n }\n \n return placement;\n }\n \n vector generateGreedyPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n // For high-cost rectangles, be more careful with rotation\n int r;\n if (rectangle_costs[i] > 150000 && aspect_ratios[i] > 1.5) {\n r = (orig_w > orig_h) ? 1 : 0;\n } else {\n r = (orig_w > orig_h) ? 1 : 0;\n }\n \n char d = (i % 2 == 0) ? 'U' : 'L';\n \n if (!feedback_history.empty()) {\n int last_W = feedback_history.back().first;\n int last_H = feedback_history.back().second;\n \n // Slight adjustment to optimal threshold\n if (last_W > last_H * 1.25) {\n d = 'U';\n } else if (last_H > last_W * 1.25) {\n d = 'L';\n }\n }\n \n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 89) { // Slightly increased from 88\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back(Placement(i, r, d, b));\n }\n \n return placement;\n }\n \n vector generateSizeBasedPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n int r = (orig_w > orig_h) ? 1 : 0;\n \n int eff_w = r ? orig_h : orig_w;\n int eff_h = r ? orig_w : orig_h;\n \n char d;\n if (eff_w > eff_h * 1.8) { // Slightly adjusted from 2.0\n d = 'U';\n } else if (eff_h > eff_w * 1.8) {\n d = 'L';\n } else {\n d = (i % 2 == 0) ? 'U' : 'L';\n \n if (!feedback_history.empty()) {\n int last_W = feedback_history.back().first;\n int last_H = feedback_history.back().second;\n \n // Slight adjustment to optimal threshold\n if (last_W > last_H * 1.15) {\n d = 'U';\n } else if (last_H > last_W * 1.15) {\n d = 'L';\n }\n }\n }\n \n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 79) { // Slightly increased from 78\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back(Placement(i, r, d, b));\n }\n \n return placement;\n }\n \n vector generateWidthFocusedPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n int r = (orig_w > orig_h) ? 1 : 0;\n \n char d = 'U';\n if (rng() % 100 < 18) { // Slightly decreased from 20\n d = 'L';\n }\n \n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 73) { // Slightly increased from 72\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back(Placement(i, r, d, b));\n }\n \n return placement;\n }\n \n vector generateHeightFocusedPlacement(int n) {\n vector placement;\n \n for (int i = 0; i < n; i++) {\n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n int r = (orig_h > orig_w) ? 1 : 0;\n \n char d = 'L';\n if (rng() % 100 < 18) { // Slightly decreased from 20\n d = 'U';\n }\n \n int b = -1;\n if (i > 0) {\n if (rng() % 100 < 73) { // Slightly increased from 72\n b = i - 1;\n } else {\n uniform_int_distribution ref_dist(-1, i - 1);\n b = ref_dist(rng);\n }\n }\n \n placement.push_back(Placement(i, r, d, b));\n }\n \n return placement;\n }\n \n vector mutatePlacement(const vector& base, int turn) {\n if (base.empty()) return base;\n \n vector result = base;\n int n = result.size();\n \n int base_mutations = 2;\n if (turn < T/3) base_mutations = 3;\n else if (turn < 2*T/3) base_mutations = 2;\n else base_mutations = 1;\n \n int num_mutations = base_mutations;\n \n if (turn > 8 && feedback_history.size() > 3) {\n long long recent_avg = 0;\n for (int i = max(0, (int)feedback_history.size() - 3); i < (int)feedback_history.size(); i++) {\n recent_avg += feedback_history[i].first + feedback_history[i].second;\n }\n recent_avg /= 3;\n \n // Slight adjustment to optimal threshold\n if (recent_avg > best_score * 1.01 && rng() % 100 < 36) { // Slightly adjusted\n num_mutations++;\n }\n }\n \n uniform_int_distribution mutation_dist(0, 3);\n uniform_int_distribution index_dist(0, n - 1);\n \n for (int i = 0; i < num_mutations; i++) {\n int idx = index_dist(rng);\n int mutation_type = mutation_dist(rng);\n \n switch (mutation_type) {\n case 0:\n result[idx].r = 1 - result[idx].r;\n break;\n case 1:\n result[idx].d = (result[idx].d == 'U') ? 'L' : 'U';\n break;\n case 2:\n if (idx > 0) {\n uniform_int_distribution ref_dist(-1, idx - 1);\n result[idx].b = ref_dist(rng);\n } else {\n result[idx].b = -1;\n }\n break;\n case 3:\n if (!feedback_history.empty()) {\n int last_W = feedback_history.back().first;\n int last_H = feedback_history.back().second;\n \n int orig_w = observed_wh[idx].first;\n int orig_h = observed_wh[idx].second;\n \n // Slight adjustment to optimal thresholds\n if (last_W > last_H * 1.35) {\n result[idx].d = 'U';\n if (orig_w > orig_h * 1.05) { // Slightly adjusted\n result[idx].r = 1;\n }\n } else if (last_H > last_W * 1.35) {\n result[idx].d = 'L';\n if (orig_h > orig_w * 1.05) {\n result[idx].r = 1;\n }\n }\n }\n break;\n }\n }\n \n return result;\n }\n \n void updateStrategyStats(int strategy, long long score) {\n strategy_stats[strategy].attempts++;\n strategy_stats[strategy].total_score += score;\n strategy_stats[strategy].best_score_achieved = min(strategy_stats[strategy].best_score_achieved, score);\n \n double relative_improvement = 1.0;\n if (best_turn != -1) {\n relative_improvement = (double)(best_score + 1) / (score + 1);\n }\n \n // Slight adjustment to optimal learning rates\n if (score < best_score || best_turn == -1) {\n strategy_stats[strategy].success_rate = 0.82 * strategy_stats[strategy].success_rate + 0.18 * relative_improvement;\n } else {\n strategy_stats[strategy].success_rate = 0.92 * strategy_stats[strategy].success_rate + 0.08 * relative_improvement;\n }\n }\n \n int selectStrategy(int turn) {\n if (turn < 5) {\n return turn % 5;\n }\n \n // Slight adjustment to optimal temperature schedule\n double temperature = max(0.16, 1.0 - (double)turn / T * 0.68);\n \n vector adjusted_rates(5);\n double total_rate = 0;\n \n for (int i = 0; i < 5; i++) {\n if (strategy_stats[i].attempts == 0) {\n adjusted_rates[i] = 1.0;\n } else {\n // Slight adjustment to optimal exploration bonus\n double exploration_bonus = temperature * 0.42 / sqrt(strategy_stats[i].attempts);\n adjusted_rates[i] = strategy_stats[i].success_rate + exploration_bonus;\n }\n total_rate += adjusted_rates[i];\n }\n \n if (total_rate == 0) return rng() % 5;\n \n double rand_val = uniform_real_distribution(0, total_rate)(rng);\n double cum_sum = 0;\n \n for (int i = 0; i < 5; i++) {\n cum_sum += adjusted_rates[i];\n if (rand_val <= cum_sum) {\n return i;\n }\n }\n \n return 4;\n }\n \n vector getNextPlacement(int turn) {\n // Slight adjustment to optimal exploration rate\n double exploration_rate = max(0.13, 0.72 * (1.0 - (double)turn / T * 0.88));\n \n if (turn < 5) {\n current_strategy = turn % 5;\n } else if (static_cast(rng() % 100) < static_cast(exploration_rate * 100)) {\n current_strategy = rng() % 5;\n } else {\n current_strategy = selectStrategy(turn);\n }\n \n vector placement;\n \n switch (current_strategy) {\n case 0:\n placement = generateRandomPlacement(N);\n break;\n case 1:\n placement = generateGreedyPlacement(N);\n break;\n case 2:\n placement = generateSizeBasedPlacement(N);\n break;\n case 3:\n placement = generateWidthFocusedPlacement(N);\n break;\n case 4:\n placement = generateHeightFocusedPlacement(N);\n break;\n }\n \n // Slight adjustment to optimal mutation probability\n if (turn > 5 && best_turn != -1 && rng() % 100 < 79) { // Increased from 78\n placement = mutatePlacement(best_placement, turn);\n \n // Slight adjustment to optimal late-game improvements\n if (turn > T/4 && rng() % 100 < 52) { // Increased from 50\n int start_idx = max(1, (int)(placement.size() * 0.38)); // Slightly adjusted\n for (int i = start_idx; i < (int)placement.size(); i++) {\n if (!feedback_history.empty()) {\n int last_W = feedback_history.back().first;\n int last_H = feedback_history.back().second;\n \n int orig_w = observed_wh[i].first;\n int orig_h = observed_wh[i].second;\n \n // Slight adjustment to optimal thresholds\n if (last_W > last_H * 1.25) {\n if (rng() % 100 < 72) { // Increased from 70\n placement[i].d = 'U';\n }\n if (rng() % 100 < 47 && orig_w > orig_h) { // Increased from 45\n placement[i].r = 1;\n }\n } else if (last_H > last_W * 1.25) {\n if (rng() % 100 < 72) {\n placement[i].d = 'L';\n }\n if (rng() % 100 < 47 && orig_h > orig_w) {\n placement[i].r = 1;\n }\n }\n }\n }\n }\n }\n \n // Slight adjustment to optimal partial packing\n if (turn > 5 && rng() % 100 < 17 && N > 15) { // Increased from 16\n int base_size = N;\n \n if (feedback_history.size() > 2) {\n long long recent_avg = 0;\n for (int i = max(0, (int)feedback_history.size() - 2); i < (int)feedback_history.size(); i++) {\n recent_avg += feedback_history[i].first + feedback_history[i].second;\n }\n recent_avg /= 2;\n \n if (recent_avg > 1750000) { // Slightly adjusted from 1800000\n uniform_int_distribution size_dist(max(N/2, N-8), N-1);\n base_size = size_dist(rng);\n } else {\n uniform_int_distribution size_dist(max(N-5, N/2), N);\n base_size = size_dist(rng);\n }\n } else {\n uniform_int_distribution size_dist(max(N-5, N/2), N);\n base_size = size_dist(rng);\n }\n \n switch (current_strategy) {\n case 0:\n placement = generateRandomPlacement(base_size);\n break;\n case 1:\n placement = generateGreedyPlacement(base_size);\n break;\n case 2:\n placement = generateSizeBasedPlacement(base_size);\n break;\n case 3:\n placement = generateWidthFocusedPlacement(base_size);\n break;\n case 4:\n placement = generateHeightFocusedPlacement(base_size);\n break;\n }\n }\n \n return placement;\n }\n \n void outputPlacement(const vector& placement) {\n cout << placement.size() << endl;\n for (const auto& p : placement) {\n cout << p.p << \" \" << p.r << \" \" << p.d << \" \" << p.b << endl;\n }\n cout.flush();\n }\n \n long long calculateEstimatedScore(int W_prime, int H_prime, int n) {\n long long score = (long long)W_prime + (long long)H_prime;\n \n for (int i = n; i < N; i++) {\n score += (long long)observed_wh[i].first + (long long)observed_wh[i].second;\n }\n \n return score;\n }\n \n void processTurn(int turn) {\n vector placement = getNextPlacement(turn);\n \n outputPlacement(placement);\n \n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n feedback_history.push_back({W_prime, H_prime});\n \n long long estimated_score = calculateEstimatedScore(W_prime, H_prime, placement.size());\n \n updateStrategyStats(current_strategy, estimated_score);\n \n if (estimated_score < best_score) {\n best_score = estimated_score;\n best_placement = placement;\n best_turn = turn;\n }\n }\n \n void solve() {\n readInput();\n \n for (int turn = 0; turn < T; turn++) {\n processTurn(turn);\n }\n }\n};\n\nint main() {\n auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n RectanglePacker packer(static_cast(seed));\n packer.solve();\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Calculate the depth of a vertex\nint calculateDepth(int v, const vector& parent) {\n if (v < 0 || v >= parent.size()) return 0;\n int depth = 0;\n int current = v;\n int safety_counter = 0;\n while (parent[current] != -1 && safety_counter < 100) {\n current = parent[current];\n depth++;\n safety_counter++;\n }\n return depth;\n}\n\n// Check if assigning new_parent as parent of child would create a cycle\nbool wouldCreateCycle(int child, int new_parent, const vector& parent) {\n if (new_parent == -1) return false;\n if (child == new_parent) return true;\n \n // Follow parent chain from new_parent to see if we reach child\n int current = new_parent;\n int safety_counter = 0;\n while (current != -1 && current >= 0 && current < parent.size() && safety_counter < 100) {\n if (current == child) return true;\n current = parent[current];\n safety_counter++;\n }\n return false;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, H;\n cin >> N >> M >> H;\n \n vector A(N);\n for (int i = 0; i < N; i++) {\n cin >> A[i];\n }\n \n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n // Skip coordinates\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n \n // Best solution\n vector best_parent(N, -1);\n long long best_score = 0;\n \n // Try 2 different strategies\n for (int strategy = 0; strategy < 2; strategy++) {\n vector parent(N, -1);\n vector assigned(N, false);\n \n // Create list of vertices\n vector vertices(N);\n for (int i = 0; i < N; i++) {\n vertices[i] = i;\n }\n \n if (strategy == 0) {\n // Strategy 1: Sort by beauty (descending)\n sort(vertices.begin(), vertices.end(), [&](int a, int b) {\n return A[a] > A[b];\n });\n } else {\n // Strategy 2: Sort by beauty * degree\n sort(vertices.begin(), vertices.end(), [&](int a, int b) {\n return A[a] * (int)adj[a].size() > A[b] * (int)adj[b].size();\n });\n }\n \n // Build trees\n for (int v : vertices) {\n if (assigned[v]) continue;\n \n // Smart root selection\n bool make_root = true;\n \n // For top 20% beauty vertices, check if they should be children instead\n int threshold = max(1, N / 5);\n bool is_top = false;\n for (int i = 0; i < threshold; i++) {\n if (vertices[i] == v) {\n is_top = true;\n break;\n }\n }\n \n if (is_top) {\n // Check if there's a neighbor with significantly higher beauty\n for (int neighbor : adj[v]) {\n if (!assigned[neighbor] && A[neighbor] > A[v] * 1.1) { // Reduced from 1.2 to 1.1\n make_root = false;\n break;\n }\n }\n }\n \n if (make_root) {\n parent[v] = -1;\n assigned[v] = true;\n } else {\n // Find the best parent among unassigned neighbors with higher beauty\n int best_parent_candidate = -1;\n int highest_beauty = A[v];\n \n for (int neighbor : adj[v]) {\n if (!assigned[neighbor] && A[neighbor] > highest_beauty) {\n highest_beauty = A[neighbor];\n best_parent_candidate = neighbor;\n }\n }\n \n if (best_parent_candidate != -1) {\n parent[v] = best_parent_candidate;\n assigned[v] = true;\n // Make sure parent is assigned as root if not already assigned\n if (!assigned[best_parent_candidate]) {\n parent[best_parent_candidate] = -1;\n assigned[best_parent_candidate] = true;\n }\n } else {\n parent[v] = -1;\n assigned[v] = true;\n }\n }\n \n // BFS to build tree, prioritizing high-beauty vertices\n queue q;\n q.push(v);\n \n while (!q.empty()) {\n int u = q.front();\n q.pop();\n \n // Calculate current depth of u\n int depth_u = 0;\n int current = u;\n int safety_counter = 0;\n while (parent[current] != -1 && depth_u < H && safety_counter < 100) {\n current = parent[current];\n depth_u++;\n safety_counter++;\n }\n \n // Get unassigned neighbors\n vector> neighbors; // (beauty, vertex)\n for (int neighbor : adj[u]) {\n if (!assigned[neighbor] && depth_u < H) {\n neighbors.push_back({A[neighbor], neighbor});\n }\n }\n \n // Sort by beauty (descending)\n sort(neighbors.begin(), neighbors.end(), greater>());\n \n // Assign neighbors\n for (auto& nb : neighbors) {\n int next_v = nb.second;\n if (!assigned[next_v] && depth_u < H) {\n parent[next_v] = u;\n assigned[next_v] = true;\n q.push(next_v);\n }\n }\n }\n }\n \n // Handle any remaining unassigned vertices\n for (int i = 0; i < N; i++) {\n if (!assigned[i]) {\n // Find best parent among neighbors\n int best_parent_candidate = -1;\n long long best_score_contribution = -1;\n \n for (int neighbor : adj[i]) {\n if (assigned[neighbor]) {\n // Calculate depth of neighbor\n int depth = 0;\n int current = neighbor;\n int safety_counter = 0;\n while (parent[current] != -1 && depth < H && safety_counter < 100) {\n current = parent[current];\n depth++;\n safety_counter++;\n }\n \n if (depth < H) {\n long long score_contribution = (long long)A[i] * (depth + 1);\n if (score_contribution > best_score_contribution) {\n best_score_contribution = score_contribution;\n best_parent_candidate = neighbor;\n }\n }\n }\n }\n \n if (best_parent_candidate != -1) {\n parent[i] = best_parent_candidate;\n } else {\n parent[i] = -1;\n }\n assigned[i] = true;\n }\n }\n \n // Calculate score\n long long current_score = 0;\n for (int i = 0; i < N; i++) {\n // Calculate depth\n int depth = 0;\n int current = i;\n int safety_counter = 0;\n while (parent[current] != -1 && current >= 0 && current < N && safety_counter < 100) {\n current = parent[current];\n depth++;\n safety_counter++;\n }\n current_score += (long long)(depth + 1) * A[i];\n }\n \n // Update best solution\n if (current_score > best_score) {\n best_score = current_score;\n best_parent = parent;\n }\n }\n \n // Conservative local improvement for top 20 vertices\n vector> vertices_with_beauty(N);\n for (int i = 0; i < N; i++) {\n vertices_with_beauty[i] = {A[i], i};\n }\n sort(vertices_with_beauty.begin(), vertices_with_beauty.end(), greater>());\n \n // Try top 20 vertices (increased from 10)\n int improve_limit = min(20, N);\n \n for (int i = 0; i < improve_limit; i++) {\n int v = vertices_with_beauty[i].second;\n \n // Calculate current depth\n int current_depth = calculateDepth(v, best_parent);\n long long current_contribution = (long long)(current_depth + 1) * A[v];\n \n // Only try to improve if current depth is > 2 (changed from 3)\n if (current_depth <= 2) continue;\n \n // Try to find a neighbor at depth 0, 1, or 2\n for (int neighbor : adj[v]) {\n // Skip if would create cycle\n if (wouldCreateCycle(v, neighbor, best_parent)) continue;\n \n // Calculate neighbor's depth\n int neighbor_depth = calculateDepth(neighbor, best_parent);\n \n // Consider neighbors at depth <= 3 (expanded from <= 1)\n if (neighbor_depth <= 3 && neighbor_depth + 1 <= H) {\n long long new_contribution = (long long)(neighbor_depth + 1) * A[v];\n \n if (new_contribution > current_contribution) {\n best_parent[v] = neighbor;\n break; // Only make one change per vertex\n }\n }\n }\n }\n \n // Final safety check: ensure no height violations\n for (int i = 0; i < N; i++) {\n int depth = 0;\n int current = i;\n int safety_counter = 0;\n while (best_parent[current] != -1 && safety_counter < 100) {\n current = best_parent[current];\n depth++;\n safety_counter++;\n if (depth > H) {\n // Fix: make it a root\n best_parent[i] = -1;\n break;\n }\n }\n }\n \n // Output\n for (int i = 0; i < N; i++) {\n cout << best_parent[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n \n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n \n // Read input\n cin >> N;\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n \n vector> operations;\n \n // For each cell that contains an Oni ('x')\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'x') {\n // Check which direction is safe (no Fukunokami)\n bool safe_up = true, safe_down = true, safe_left = true, safe_right = true;\n \n // Check upward direction\n for (int k = 0; k < i; k++) {\n if (board[k][j] == 'o') {\n safe_up = false;\n break;\n }\n }\n \n // Check downward direction\n for (int k = i + 1; k < N; k++) {\n if (board[k][j] == 'o') {\n safe_down = false;\n break;\n }\n }\n \n // Check leftward direction\n for (int k = 0; k < j; k++) {\n if (board[i][k] == 'o') {\n safe_left = false;\n break;\n }\n }\n \n // Check rightward direction\n for (int k = j + 1; k < N; k++) {\n if (board[i][k] == 'o') {\n safe_right = false;\n break;\n }\n }\n \n // Choose a safe direction (at least one is guaranteed to exist)\n if (safe_up) {\n // Shift column j upward (i+1) times\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'U', j});\n }\n // Shift column j downward (i+1) times to restore\n for (int k = 0; k < i + 1; k++) {\n operations.push_back({'D', j});\n }\n } else if (safe_down) {\n // Shift column j downward (N-1-i) times\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'D', j});\n }\n // Shift column j upward (N-1-i) times to restore\n for (int k = 0; k < N - 1 - i; k++) {\n operations.push_back({'U', j});\n }\n } else if (safe_left) {\n // Shift row i left (j+1) times\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'L', i});\n }\n // Shift row i right (j+1) times to restore\n for (int k = 0; k < j + 1; k++) {\n operations.push_back({'R', i});\n }\n } else if (safe_right) {\n // Shift row i right (N-1-j) times\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'R', i});\n }\n // Shift row i left (N-1-j) times to restore\n for (int k = 0; k < N - 1 - j; k++) {\n operations.push_back({'L', i});\n }\n }\n }\n }\n }\n \n // Output operations\n for (auto& op : operations) {\n cout << op.first << \" \" << op.second << endl;\n }\n \n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\n// Ultra-fast error calculation\nlong long calculateErrorUltraFast(const vector& a, const vector& b, const vector& targets) {\n int counts[N] = {0};\n int current = 0;\n \n for (int week = 0; week < L; week++) {\n counts[current]++;\n current = (counts[current] & 1) ? a[current] : b[current];\n }\n \n long long total_error = 0;\n for (int i = 0; i < N; i++) {\n total_error += abs(counts[i] - targets[i]);\n }\n return total_error;\n}\n\n// Calculate actual assignments\nvector calculateAssignmentsFast(const vector& a, const vector& b) {\n vector counts(N, 0);\n int current = 0;\n \n for (int week = 0; week < L; week++) {\n counts[current]++;\n current = (counts[current] & 1) ? a[current] : b[current];\n }\n \n return counts;\n}\n\n// Get employees with highest error\nvector getHighErrorEmployees(const vector& actual, const vector& targets, int count) {\n vector> errors;\n for (int i = 0; i < N; i++) {\n errors.push_back({abs((long long)actual[i] - (long long)targets[i]), i});\n }\n sort(errors.rbegin(), errors.rend());\n \n vector result;\n for (int i = 0; i < min(count, N); i++) {\n result.push_back(errors[i].second);\n }\n return result;\n}\n\n// Analyze target distribution to detect special cases\nstruct TargetAnalysis {\n int max_target;\n int min_target;\n double avg_target;\n double std_dev;\n vector sorted_indices;\n bool has_extreme_values;\n bool is_balanced;\n};\n\nTargetAnalysis analyzeTargets(const vector& targets) {\n TargetAnalysis analysis;\n analysis.max_target = *max_element(targets.begin(), targets.end());\n analysis.min_target = *min_element(targets.begin(), targets.end());\n \n // Calculate average\n long long sum = 0;\n for (int t : targets) sum += t;\n analysis.avg_target = (double)sum / N;\n \n // Calculate standard deviation\n double variance = 0;\n for (int t : targets) {\n variance += (t - analysis.avg_target) * (t - analysis.avg_target);\n }\n analysis.std_dev = sqrt(variance / N);\n \n // Create sorted indices\n analysis.sorted_indices.resize(N);\n iota(analysis.sorted_indices.begin(), analysis.sorted_indices.end(), 0);\n sort(analysis.sorted_indices.begin(), analysis.sorted_indices.end(), \n [&](int i, int j) { return targets[i] < targets[j]; });\n \n // Detect extreme values (more than 3 standard deviations from mean)\n analysis.has_extreme_values = false;\n for (int i = 0; i < N; i++) {\n if (abs(targets[i] - analysis.avg_target) > 3 * analysis.std_dev) {\n analysis.has_extreme_values = true;\n break;\n }\n }\n \n // Check if distribution is relatively balanced\n analysis.is_balanced = (analysis.max_target - analysis.min_target) < analysis.avg_target / 2;\n \n return analysis;\n}\n\n// Create multiple types of initial solutions\nvector> createInitialSolutionType1(const vector& targets) {\n // Sort by targets and create an ordered cycle\n vector> result(N);\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return targets[i] < targets[j];\n });\n \n for (int i = 0; i < N; i++) {\n int emp = indices[i];\n int next_idx = (i + 1) % N;\n int prev_idx = (i - 1 + N) % N;\n \n result[emp].first = indices[prev_idx];\n result[emp].second = indices[next_idx];\n }\n \n return result;\n}\n\nvector> createInitialSolutionType2(const vector& targets) {\n // Random initial solution with bias toward similar targets\n vector> result(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n \n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return targets[i] < targets[j];\n });\n \n for (int i = 0; i < N; i++) {\n int emp = i;\n int pos = -1;\n for (int j = 0; j < N; j++) {\n if (indices[j] == emp) {\n pos = j;\n break;\n }\n }\n \n if (dist(rng) < 60) {\n int range = max(1, N / 10);\n int start = max(0, pos - range);\n int end = min(N - 1, pos + range);\n \n if (start <= end) {\n int nearby_idx1 = start + (dist(rng) % (end - start + 1));\n int nearby_idx2 = start + (dist(rng) % (end - start + 1));\n result[emp].first = indices[nearby_idx1];\n result[emp].second = indices[nearby_idx2];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n }\n \n return result;\n}\n\nvector> createInitialSolutionType3(const vector& targets) {\n // Create clusters based on target values\n vector> result(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n \n long long sum = 0;\n for (int t : targets) sum += t;\n int avg = sum / N;\n \n vector below_avg, above_avg;\n for (int i = 0; i < N; i++) {\n if (targets[i] <= avg) {\n below_avg.push_back(i);\n } else {\n above_avg.push_back(i);\n }\n }\n \n if (below_avg.empty() || above_avg.empty()) {\n for (int i = 0; i < N; i++) {\n result[i].first = dist(rng);\n result[i].second = dist(rng);\n }\n return result;\n }\n \n for (int i = 0; i < N; i++) {\n if (targets[i] <= avg) {\n if (dist(rng) < 70) {\n result[i].first = above_avg[dist(rng) % above_avg.size()];\n result[i].second = above_avg[dist(rng) % above_avg.size()];\n } else {\n result[i].first = below_avg[dist(rng) % below_avg.size()];\n result[i].second = below_avg[dist(rng) % below_avg.size()];\n }\n } else {\n if (dist(rng) < 70) {\n result[i].first = below_avg[dist(rng) % below_avg.size()];\n result[i].second = below_avg[dist(rng) % below_avg.size()];\n } else {\n result[i].first = above_avg[dist(rng) % above_avg.size()];\n result[i].second = above_avg[dist(rng) % above_avg.size()];\n }\n }\n }\n \n return result;\n}\n\n// New initial solution type 4: Extremes handling\nvector> createInitialSolutionType4(const vector& targets) {\n // Focus on handling employees with extreme target values\n vector> result(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n \n // Find employees with highest and lowest targets\n vector> target_pairs;\n for (int i = 0; i < N; i++) {\n target_pairs.push_back({targets[i], i});\n }\n sort(target_pairs.begin(), target_pairs.end());\n \n // Get top 5% and bottom 5% (approximately 5 employees each)\n int extreme_count = max(1, N / 20);\n vector low_targets, high_targets, medium_targets;\n \n for (int i = 0; i < extreme_count; i++) {\n low_targets.push_back(target_pairs[i].second);\n }\n for (int i = N - extreme_count; i < N; i++) {\n high_targets.push_back(target_pairs[i].second);\n }\n for (int i = extreme_count; i < N - extreme_count; i++) {\n medium_targets.push_back(target_pairs[i].second);\n }\n \n // Assign low target employees to point to high target employees (to balance)\n for (int emp : low_targets) {\n if (!high_targets.empty()) {\n result[emp].first = high_targets[dist(rng) % high_targets.size()];\n result[emp].second = high_targets[dist(rng) % high_targets.size()];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n }\n \n // Assign high target employees to point to low target employees\n for (int emp : high_targets) {\n if (!low_targets.empty()) {\n result[emp].first = low_targets[dist(rng) % low_targets.size()];\n result[emp].second = low_targets[dist(rng) % low_targets.size()];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n }\n \n // Assign medium target employees to point to mixed targets\n for (int emp : medium_targets) {\n if (dist(rng) < 50) {\n // Point to random employee from any group\n vector all_targets = low_targets;\n all_targets.insert(all_targets.end(), high_targets.begin(), high_targets.end());\n all_targets.insert(all_targets.end(), medium_targets.begin(), medium_targets.end());\n if (!all_targets.empty()) {\n result[emp].first = all_targets[dist(rng) % all_targets.size()];\n result[emp].second = all_targets[dist(rng) % all_targets.size()];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n } else {\n // Point to other medium target employees\n if (!medium_targets.empty()) {\n int idx1 = dist(rng) % medium_targets.size();\n int idx2 = dist(rng) % medium_targets.size();\n result[emp].first = medium_targets[idx1];\n result[emp].second = medium_targets[idx2];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n }\n }\n \n return result;\n}\n\n// Specialized solution for cases with extreme values\nvector> createExtremeValueSolution(const vector& targets) {\n TargetAnalysis analysis = analyzeTargets(targets);\n vector> result(N);\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n \n // Identify extreme employees (top and bottom 10%)\n int extreme_threshold = max(1, N / 10);\n vector very_low, very_high, normal;\n \n for (int i = 0; i < extreme_threshold; i++) {\n very_low.push_back(analysis.sorted_indices[i]);\n }\n for (int i = N - extreme_threshold; i < N; i++) {\n very_high.push_back(analysis.sorted_indices[i]);\n }\n for (int i = extreme_threshold; i < N - extreme_threshold; i++) {\n normal.push_back(analysis.sorted_indices[i]);\n }\n \n // Create a balancing strategy\n // Very low target employees should point to very high target employees\n for (int emp : very_low) {\n if (!very_high.empty()) {\n result[emp].first = very_high[dist(rng) % very_high.size()];\n result[emp].second = very_high[dist(rng) % very_high.size()];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n }\n \n // Very high target employees should point to very low target employees\n for (int emp : very_high) {\n if (!very_low.empty()) {\n result[emp].first = very_low[dist(rng) % very_low.size()];\n result[emp].second = very_low[dist(rng) % very_low.size()];\n } else {\n result[emp].first = dist(rng);\n result[emp].second = dist(rng);\n }\n }\n \n // Normal employees create a cycle among themselves\n for (int i = 0; i < normal.size(); i++) {\n int emp = normal[i];\n int next_idx = (i + 1) % normal.size();\n int prev_idx = (i - 1 + normal.size()) % normal.size();\n \n result[emp].first = normal[prev_idx];\n result[emp].second = normal[next_idx];\n }\n \n // If no normal employees, assign randomly\n if (normal.empty()) {\n for (int i = 0; i < N; i++) {\n if (find(very_low.begin(), very_low.end(), i) == very_low.end() && \n find(very_high.begin(), very_high.end(), i) == very_high.end()) {\n result[i].first = dist(rng);\n result[i].second = dist(rng);\n }\n }\n }\n \n return result;\n}\n\n// Enhanced local search with focused refinement\nvector> improveSolution(const vector>& initial, const vector& targets) {\n vector a(N), b(N);\n for (int i = 0; i < N; i++) {\n a[i] = initial[i].first;\n b[i] = initial[i].second;\n }\n \n long long best_error = calculateErrorUltraFast(a, b, targets);\n vector best_a = a, best_b = b;\n vector current_assignments = calculateAssignmentsFast(a, b);\n \n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, N - 1);\n uniform_real_distribution prob_dist(0.0, 1.0);\n \n // Analyze targets for adaptive strategy\n TargetAnalysis analysis = analyzeTargets(targets);\n \n // Adaptive iteration count\n int base_iterations = 280;\n long long initial_error = best_error;\n int max_iterations = base_iterations;\n \n if (initial_error > 50000) {\n max_iterations = min(350, base_iterations + 40);\n } else if (initial_error < 20000) {\n max_iterations = 180;\n }\n \n // Increase iterations for extreme value cases\n if (analysis.has_extreme_values) {\n max_iterations = min(400, max_iterations + 50);\n }\n \n // Main local search phase\n for (int iter = 0; iter < max_iterations; iter++) {\n // Early termination for excellent solutions\n if (best_error < 3000 && iter > 30) {\n break;\n }\n \n vector high_error_emps = getHighErrorEmployees(current_assignments, targets, 8);\n \n double p = prob_dist(rng);\n vector new_a = a, new_b = b;\n \n if (p < 0.6) {\n // Single employee modification (more focused)\n int emp;\n if (!high_error_emps.empty() && prob_dist(rng) < 0.95) {\n emp = high_error_emps[dist(rng) % high_error_emps.size()];\n } else {\n emp = dist(rng);\n }\n \n int target_diff = targets[emp] - current_assignments[emp];\n \n if (prob_dist(rng) < 0.85) {\n vector> sorted_by_diff;\n for (int i = 0; i < N; i++) {\n sorted_by_diff.push_back({targets[i] - current_assignments[i], i});\n }\n \n if (target_diff > 0) {\n sort(sorted_by_diff.begin(), sorted_by_diff.end());\n if (sorted_by_diff.size() > 0) {\n int choice = 0;\n if (sorted_by_diff.size() > 3 && prob_dist(rng) < 0.2) {\n choice = dist(rng) % min(3, (int)sorted_by_diff.size());\n }\n if (dist(rng) % 2 == 0) {\n new_a[emp] = sorted_by_diff[choice].second;\n } else {\n new_b[emp] = sorted_by_diff[choice].second;\n }\n } else {\n if (dist(rng) % 2 == 0) {\n new_a[emp] = dist(rng);\n } else {\n new_b[emp] = dist(rng);\n }\n }\n } else {\n sort(sorted_by_diff.rbegin(), sorted_by_diff.rend());\n if (sorted_by_diff.size() > 0) {\n int choice = 0;\n if (sorted_by_diff.size() > 3 && prob_dist(rng) < 0.2) {\n choice = dist(rng) % min(3, (int)sorted_by_diff.size());\n }\n if (dist(rng) % 2 == 0) {\n new_a[emp] = sorted_by_diff[choice].second;\n } else {\n new_b[emp] = sorted_by_diff[choice].second;\n }\n } else {\n if (dist(rng) % 2 == 0) {\n new_a[emp] = dist(rng);\n } else {\n new_b[emp] = dist(rng);\n }\n }\n }\n } else {\n if (dist(rng) % 2 == 0) {\n new_a[emp] = dist(rng);\n } else {\n new_b[emp] = dist(rng);\n }\n }\n } else if (p < 0.8) {\n // Two related changes with better coordination\n if (high_error_emps.size() >= 2) {\n int idx1 = dist(rng) % high_error_emps.size();\n int idx2 = (idx1 + 1 + dist(rng) % (high_error_emps.size() - 1)) % high_error_emps.size();\n int emp1 = high_error_emps[idx1];\n int emp2 = high_error_emps[idx2];\n \n int target_diff1 = targets[emp1] - current_assignments[emp1];\n int target_diff2 = targets[emp2] - current_assignments[emp2];\n \n // Create more sophisticated coordination\n if (target_diff1 * target_diff2 > 0) {\n // Both need same direction - create a cycle between them\n new_a[emp1] = emp2;\n new_b[emp2] = emp1;\n } else {\n // Need opposite directions - point to appropriate types\n vector> sorted_by_diff;\n for (int i = 0; i < N; i++) {\n sorted_by_diff.push_back({targets[i] - current_assignments[i], i});\n }\n \n if (target_diff1 > 0) {\n sort(sorted_by_diff.begin(), sorted_by_diff.end());\n if (!sorted_by_diff.empty()) {\n new_a[emp1] = sorted_by_diff[0].second;\n new_b[emp2] = sorted_by_diff[0].second;\n }\n } else {\n sort(sorted_by_diff.rbegin(), sorted_by_diff.rend());\n if (!sorted_by_diff.empty()) {\n new_a[emp1] = sorted_by_diff[0].second;\n new_b[emp2] = sorted_by_diff[0].second;\n }\n }\n }\n } else {\n int emp1 = dist(rng);\n int emp2 = dist(rng);\n new_a[emp1] = dist(rng);\n new_b[emp2] = dist(rng);\n }\n } else {\n // Enhanced swap strategy\n int emp1 = dist(rng);\n int emp2 = dist(rng);\n if (emp1 != emp2) {\n if (prob_dist(rng) < 0.6) {\n swap(new_a[emp1], new_a[emp2]);\n swap(new_b[emp1], new_b[emp2]);\n } else if (prob_dist(rng) < 0.8) {\n // Cross-swap\n int temp = new_a[emp1];\n new_a[emp1] = new_b[emp2];\n new_b[emp2] = temp;\n } else {\n // Point to each other\n new_a[emp1] = emp2;\n new_b[emp2] = emp1;\n }\n } else {\n if (dist(rng) % 2 == 0) {\n new_a[emp1] = dist(rng);\n } else {\n new_b[emp1] = dist(rng);\n }\n }\n }\n \n long long new_error = calculateErrorUltraFast(new_a, new_b, targets);\n \n if (new_error < best_error) {\n best_error = new_error;\n best_a = new_a;\n best_b = new_b;\n a = new_a;\n b = new_b;\n current_assignments = calculateAssignmentsFast(a, b);\n }\n }\n \n // Enhanced focused refinement phase\n vector final_a = best_a, final_b = best_b;\n vector final_assignments = calculateAssignmentsFast(final_a, final_b);\n long long final_error = best_error;\n \n // Try focused improvements on high-error employees\n vector high_error_final = getHighErrorEmployees(final_assignments, targets, 5);\n const int REFINEMENT_ATTEMPTS = 60;\n \n for (int attempt = 0; attempt < REFINEMENT_ATTEMPTS && high_error_final.size() > 0; attempt++) {\n int emp = high_error_final[attempt % high_error_final.size()];\n int target_diff = targets[emp] - final_assignments[emp];\n \n vector backup_a = final_a, backup_b = final_b;\n \n // Try several specific modifications for this employee\n for (int trial = 0; trial < 3; trial++) {\n vector> sorted_by_diff;\n for (int i = 0; i < N; i++) {\n sorted_by_diff.push_back({targets[i] - final_assignments[i], i});\n }\n \n if (target_diff > 0) {\n sort(sorted_by_diff.begin(), sorted_by_diff.end());\n if ((int)sorted_by_diff.size() > trial) {\n if (trial % 2 == 0) {\n final_a[emp] = sorted_by_diff[trial].second;\n } else {\n final_b[emp] = sorted_by_diff[trial].second;\n }\n }\n } else {\n sort(sorted_by_diff.rbegin(), sorted_by_diff.rend());\n if ((int)sorted_by_diff.size() > trial) {\n if (trial % 2 == 0) {\n final_a[emp] = sorted_by_diff[trial].second;\n } else {\n final_b[emp] = sorted_by_diff[trial].second;\n }\n }\n }\n \n long long trial_error = calculateErrorUltraFast(final_a, final_b, targets);\n if (trial_error < final_error) {\n final_error = trial_error;\n final_assignments = calculateAssignmentsFast(final_a, final_b);\n break; // Keep the improvement\n } else {\n // Revert and try next option\n final_a = backup_a;\n final_b = backup_b;\n }\n }\n }\n \n // Special refinement for extreme cases\n if (analysis.has_extreme_values && final_error > 20000) {\n // Try to specifically address the extreme employees\n vector extreme_emps;\n for (int i = 0; i < N; i++) {\n if (abs(targets[i] - analysis.avg_target) > 2 * analysis.std_dev) {\n extreme_emps.push_back(i);\n }\n }\n \n if (!extreme_emps.empty()) {\n vector current_a = final_a, current_b = final_b;\n vector current_assign = final_assignments;\n long long current_err = final_error;\n \n // Try targeted modifications for extreme employees\n for (int emp : extreme_emps) {\n int target_diff = targets[emp] - current_assign[emp];\n vector backup_a = current_a, backup_b = current_b;\n \n for (int trial = 0; trial < 5; trial++) {\n vector> sorted_by_diff;\n for (int i = 0; i < N; i++) {\n sorted_by_diff.push_back({targets[i] - current_assign[i], i});\n }\n \n if (target_diff > 0) {\n sort(sorted_by_diff.begin(), sorted_by_diff.end());\n if ((int)sorted_by_diff.size() > min(trial, 2)) {\n if (trial % 2 == 0) {\n current_a[emp] = sorted_by_diff[min(trial, 2)].second;\n } else {\n current_b[emp] = sorted_by_diff[min(trial, 2)].second;\n }\n } else {\n if (trial % 2 == 0) {\n current_a[emp] = dist(rng);\n } else {\n current_b[emp] = dist(rng);\n }\n }\n } else {\n sort(sorted_by_diff.rbegin(), sorted_by_diff.rend());\n if ((int)sorted_by_diff.size() > min(trial, 2)) {\n if (trial % 2 == 0) {\n current_a[emp] = sorted_by_diff[min(trial, 2)].second;\n } else {\n current_b[emp] = sorted_by_diff[min(trial, 2)].second;\n }\n } else {\n if (trial % 2 == 0) {\n current_a[emp] = dist(rng);\n } else {\n current_b[emp] = dist(rng);\n }\n }\n }\n \n long long trial_error = calculateErrorUltraFast(current_a, current_b, targets);\n if (trial_error < current_err) {\n current_err = trial_error;\n current_assign = calculateAssignmentsFast(current_a, current_b);\n final_a = current_a;\n final_b = current_b;\n final_assignments = current_assign;\n final_error = current_err;\n break;\n } else {\n current_a = backup_a;\n current_b = backup_b;\n }\n }\n }\n }\n }\n \n // Convert back to result format\n vector> result(N);\n for (int i = 0; i < N; i++) {\n result[i] = {final_a[i], final_b[i]};\n }\n \n return result;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int n, l;\n cin >> n >> l;\n \n vector targets(n);\n for (int i = 0; i < n; i++) {\n cin >> targets[i];\n }\n \n // Analyze the target distribution\n TargetAnalysis analysis = analyzeTargets(targets);\n \n // Try multiple initial solutions\n vector>, long long>> solutions;\n \n // Solution type 1: Sorted order\n vector> solution1 = createInitialSolutionType1(targets);\n vector a1(N), b1(N);\n for (int i = 0; i < N; i++) {\n a1[i] = solution1[i].first;\n b1[i] = solution1[i].second;\n }\n long long error1 = calculateErrorUltraFast(a1, b1, targets);\n solutions.push_back(make_pair(solution1, error1));\n \n // Solution type 2: Biased random\n vector> solution2 = createInitialSolutionType2(targets);\n vector a2(N), b2(N);\n for (int i = 0; i < N; i++) {\n a2[i] = solution2[i].first;\n b2[i] = solution2[i].second;\n }\n long long error2 = calculateErrorUltraFast(a2, b2, targets);\n solutions.push_back(make_pair(solution2, error2));\n \n // Solution type 3: Cluster-based\n vector> solution3 = createInitialSolutionType3(targets);\n vector a3(N), b3(N);\n for (int i = 0; i < N; i++) {\n a3[i] = solution3[i].first;\n b3[i] = solution3[i].second;\n }\n long long error3 = calculateErrorUltraFast(a3, b3, targets);\n solutions.push_back(make_pair(solution3, error3));\n \n // Solution type 4: Extremes handling\n vector> solution4 = createInitialSolutionType4(targets);\n vector a4(N), b4(N);\n for (int i = 0; i < N; i++) {\n a4[i] = solution4[i].first;\n b4[i] = solution4[i].second;\n }\n long long error4 = calculateErrorUltraFast(a4, b4, targets);\n solutions.push_back(make_pair(solution4, error4));\n \n // Specialized solution for extreme values\n if (analysis.has_extreme_values) {\n vector> solution5 = createExtremeValueSolution(targets);\n vector a5(N), b5(N);\n for (int i = 0; i < N; i++) {\n a5[i] = solution5[i].first;\n b5[i] = solution5[i].second;\n }\n long long error5 = calculateErrorUltraFast(a5, b5, targets);\n solutions.push_back(make_pair(solution5, error5));\n }\n \n // Pick the best initial solution\n sort(solutions.begin(), solutions.end(), [](const auto& a, const auto& b) {\n return a.second < b.second;\n });\n \n vector> best_solution = solutions[0].first;\n long long best_initial_error = solutions[0].second;\n \n // Improve the best initial solution\n vector> final_solution = improveSolution(best_solution, targets);\n \n // Output the solution\n for (int i = 0; i < n; i++) {\n cout << final_solution[i].first << \" \" << final_solution[i].second << \"\\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#include \n\nusing namespace std;\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy; // center coordinates\n \n City() : id(-1), lx(0), rx(0), ly(0), ry(0), cx(0), cy(0) {}\n \n City(int id, int lx, int rx, int ly, int ry) : id(id), lx(lx), rx(rx), ly(ly), ry(ry) {\n cx = (lx + rx) / 2.0;\n cy = (ly + ry) / 2.0;\n }\n};\n\nstruct Edge {\n int u, v;\n double estimated_dist;\n int true_dist = -1; // -1 means unknown\n \n Edge() : u(-1), v(-1), estimated_dist(0) {}\n \n Edge(int u, int v, double dist) : u(u), v(v), estimated_dist(dist) {}\n \n bool operator<(const Edge& other) const {\n if (abs(estimated_dist - other.estimated_dist) > 1e-9) {\n return estimated_dist < other.estimated_dist;\n }\n if (u != other.u) return u < other.u;\n return v < other.v;\n }\n};\n\n// Calculate estimated distance between city centers\ndouble estimate_distance(const City& a, const City& b) {\n double dx = a.cx - b.cx;\n double dy = a.cy - b.cy;\n return sqrt(dx*dx + dy*dy);\n}\n\n// Calculate minimum possible distance between two bounding boxes\ndouble min_possible_distance(const City& a, const City& b) {\n double dx1 = static_cast(a.lx - b.rx);\n double dx2 = static_cast(b.lx - a.rx);\n double min_dx = max(0.0, max(dx1, dx2));\n \n double dy1 = static_cast(a.ly - b.ry);\n double dy2 = static_cast(b.ly - a.ry);\n double min_dy = max(0.0, max(dy1, dy2));\n \n return sqrt(min_dx*min_dx + min_dy*min_dy);\n}\n\n// Calculate maximum possible distance between two bounding boxes\ndouble max_possible_distance(const City& a, const City& b) {\n double dx1 = abs(static_cast(a.lx - b.rx));\n double dx2 = abs(static_cast(a.rx - b.lx));\n double max_dx = max(dx1, dx2);\n \n double dy1 = abs(static_cast(a.ly - b.ry));\n double dy2 = abs(static_cast(a.ry - b.ly));\n double max_dy = max(dy1, dy2);\n \n return sqrt(max_dx*max_dx + max_dy*max_dy);\n}\n\n// Calculate a conservative estimate of distance (upper bound for MST pruning)\ndouble conservative_estimate(const City& a, const City& b) {\n return max_possible_distance(a, b);\n}\n\n// Calculate an optimistic estimate of distance (lower bound)\ndouble optimistic_estimate(const City& a, const City& b) {\n return min_possible_distance(a, b);\n}\n\n// Query result structure\nstruct QueryResult {\n vector> edges;\n vector cities;\n};\n\nclass Solution {\nprivate:\n int N, M, Q, L, W;\n vector G;\n vector cities;\n mt19937 rng;\n \n // Store results of queries\n map, int> known_distances; // true distances between pairs\n vector query_results;\n \n // For building final solution\n vector> final_groups;\n vector>> final_edges;\n \n // Track which city pairs we've queried\n set> queried_pairs;\n \npublic:\n Solution() : rng(random_device{}()) {}\n \n void read_input() {\n cin >> N >> M >> Q >> L >> W;\n G.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> G[i];\n }\n \n cities.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].id = i;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2.0;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2.0;\n }\n }\n \n QueryResult make_query(const vector& city_ids) {\n int k = city_ids.size();\n if (k < 2 || k > L) {\n cerr << \"Invalid query size: \" << k << endl;\n return {};\n }\n \n cout << \"? \" << k;\n for (int id : city_ids) {\n cout << \" \" << id;\n }\n cout << endl;\n cout.flush();\n \n QueryResult result;\n result.cities = city_ids;\n \n for (int i = 0; i < k - 1; i++) {\n int u, v;\n cin >> u >> v;\n if (u > v) swap(u, v);\n result.edges.push_back({u, v});\n \n // Store this known edge\n queried_pairs.insert({u, v});\n queried_pairs.insert({v, u});\n }\n \n query_results.push_back(result);\n return result;\n }\n \n // Calculate overlap between two bounding boxes (higher = more likely to be close)\n double calculate_overlap_score(const City& a, const City& b) {\n // Calculate intersection area\n int inter_lx = max(a.lx, b.lx);\n int inter_rx = min(a.rx, b.rx);\n int inter_ly = max(a.ly, b.ly);\n int inter_ry = min(a.ry, b.ry);\n \n double inter_area = 0.0;\n if (inter_lx < inter_rx && inter_ly < inter_ry) {\n inter_area = (inter_rx - inter_lx) * (inter_ry - inter_ly);\n }\n \n // Calculate union area\n double area_a = (a.rx - a.lx) * (a.ry - a.ly);\n double area_b = (b.rx - b.lx) * (b.ry - b.ly);\n double union_area = area_a + area_b - inter_area;\n \n if (union_area == 0) return 0.0;\n return inter_area / union_area;\n }\n \n // Better initial grouping using k-means like clustering\n void improved_initial_grouping() {\n // Create initial groups based on estimated distances\n final_groups.resize(M);\n \n // Sort group sizes in descending order for better assignment\n vector> sorted_groups; // (size, original_index)\n for (int i = 0; i < M; i++) {\n sorted_groups.push_back({G[i], i});\n }\n sort(sorted_groups.rbegin(), sorted_groups.rend()); // descending order\n \n // Track assigned cities\n vector assigned(N, false);\n \n // For each group (largest first)\n for (auto& group_info : sorted_groups) {\n int group_size = group_info.first;\n int original_idx = group_info.second;\n \n // Find the best starting city (least connected to others)\n int start_city = -1;\n double min_avg_dist = 1e18;\n \n for (int i = 0; i < N; i++) {\n if (assigned[i]) continue;\n \n double avg_dist = 0.0;\n int count = 0;\n for (int j = 0; j < N; j++) {\n if (i != j && !assigned[j]) {\n avg_dist += estimate_distance(cities[i], cities[j]);\n count++;\n }\n }\n \n if (count > 0) avg_dist /= count;\n \n if (start_city == -1 || avg_dist < min_avg_dist) {\n min_avg_dist = avg_dist;\n start_city = i;\n }\n }\n \n if (start_city == -1) {\n // Assign remaining cities\n for (int i = 0; i < N && final_groups[original_idx].size() < group_size; i++) {\n if (!assigned[i]) {\n final_groups[original_idx].push_back(i);\n assigned[i] = true;\n }\n }\n continue;\n }\n \n // Start with the selected city\n final_groups[original_idx].push_back(start_city);\n assigned[start_city] = true;\n \n // Greedily add closest cities\n while (final_groups[original_idx].size() < group_size) {\n int best_city = -1;\n double min_dist = 1e18;\n \n for (int i = 0; i < N; i++) {\n if (assigned[i]) continue;\n \n // Calculate average distance to cities in current group\n double avg_dist = 0.0;\n for (int city_in_group : final_groups[original_idx]) {\n avg_dist += estimate_distance(cities[i], cities[city_in_group]);\n }\n avg_dist /= final_groups[original_idx].size();\n \n if (best_city == -1 || avg_dist < min_dist) {\n min_dist = avg_dist;\n best_city = i;\n }\n }\n \n if (best_city != -1) {\n final_groups[original_idx].push_back(best_city);\n assigned[best_city] = true;\n } else {\n // Fallback: add any remaining city\n for (int i = 0; i < N && final_groups[original_idx].size() < group_size; i++) {\n if (!assigned[i]) {\n final_groups[original_idx].push_back(i);\n assigned[i] = true;\n }\n }\n }\n }\n }\n \n // Restore original group order\n vector> temp_groups = final_groups;\n for (int i = 0; i < M; i++) {\n final_groups[i] = temp_groups[i];\n }\n }\n \n // Select best subset for query based on uncertainty\n vector select_query_subset() {\n // Find cities with high position uncertainty\n vector> uncertainty_scores;\n for (int i = 0; i < N; i++) {\n double uncertainty = (cities[i].rx - cities[i].lx) + (cities[i].ry - cities[i].ly);\n uncertainty_scores.push_back({-uncertainty, i}); // negative for sorting\n }\n sort(uncertainty_scores.begin(), uncertainty_scores.end());\n \n // Create candidate sets\n vector> candidate_sets;\n \n // Candidate 1: Highest uncertainty cities\n vector high_uncertainty_set;\n for (int i = 0; i < min(L, (int)uncertainty_scores.size()); i++) {\n high_uncertainty_set.push_back(uncertainty_scores[i].second);\n }\n candidate_sets.push_back(high_uncertainty_set);\n \n // Candidate 2: Cities with overlapping bounding boxes\n for (int i = 0; i < N && candidate_sets.size() < 3; i++) {\n vector overlap_set;\n overlap_set.push_back(i);\n \n for (int j = 0; j < N && overlap_set.size() < L; j++) {\n if (i != j) {\n double overlap = calculate_overlap_score(cities[i], cities[j]);\n if (overlap > 0.1) { // if significant overlap\n overlap_set.push_back(j);\n }\n }\n }\n \n if (overlap_set.size() >= 2) {\n candidate_sets.push_back(overlap_set);\n }\n }\n \n // Candidate 3: Random sampling\n vector random_set;\n vector all_cities(N);\n for (int i = 0; i < N; i++) all_cities[i] = i;\n shuffle(all_cities.begin(), all_cities.end(), rng);\n for (int i = 0; i < min(L, N); i++) {\n random_set.push_back(all_cities[i]);\n }\n candidate_sets.push_back(random_set);\n \n // Select the best candidate (prioritize ones with overlapping boxes)\n for (auto& candidate : candidate_sets) {\n if (candidate.size() >= 2 && candidate.size() <= L) {\n return candidate;\n }\n }\n \n // Fallback\n vector fallback;\n for (int i = 0; i < min(L, N); i++) {\n fallback.push_back(i);\n }\n return fallback;\n }\n \n // Strategic querying to improve grouping\n void strategic_querying() {\n int queries_used = 0;\n \n // First, query some promising subsets for information\n while (queries_used < min(Q / 2, 50)) { // Use half of queries for exploration\n vector subset = select_query_subset();\n \n // Ensure we don't query the exact same set twice\n sort(subset.begin(), subset.end());\n static set> queried_subsets;\n if (queried_subsets.find(subset) != queried_subsets.end()) {\n // Add some variation\n if (subset.size() > 2) {\n subset.pop_back();\n subset.push_back((subset.back() + 1) % N);\n }\n }\n queried_subsets.insert(subset);\n \n QueryResult result = make_query(subset);\n queries_used++;\n }\n \n // Use remaining queries to validate and improve groups\n int group_idx = 0;\n while (queries_used < Q && group_idx < M) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size <= L) {\n // Query the entire group for verification\n QueryResult result = make_query(group);\n queries_used++;\n } else {\n // Query the most uncertain part of the group\n vector> city_uncertainties;\n for (int i = 0; i < group_size; i++) {\n int city_id = group[i];\n double uncertainty = (cities[city_id].rx - cities[city_id].lx) + \n (cities[city_id].ry - cities[city_id].ly);\n city_uncertainties.push_back({-uncertainty, i}); // negative for sorting\n }\n sort(city_uncertainties.begin(), city_uncertainties.end());\n \n // Take up to L cities with highest uncertainty\n vector uncertain_subset;\n for (int i = 0; i < min(L, (int)city_uncertainties.size()); i++) {\n uncertain_subset.push_back(group[city_uncertainties[i].second]);\n }\n \n if (uncertain_subset.size() >= 2) {\n QueryResult result = make_query(uncertain_subset);\n queries_used++;\n }\n }\n \n group_idx++;\n }\n }\n \n // Build MST for each group using known edges and better distance estimates\n void build_better_msts() {\n final_edges.clear();\n final_edges.resize(M);\n \n for (int group_idx = 0; group_idx < M; group_idx++) {\n vector& group = final_groups[group_idx];\n int group_size = group.size();\n \n if (group_size == 1) {\n continue;\n }\n \n // Create a graph with all possible edges in the group\n vector edges;\n for (int i = 0; i < group_size; i++) {\n for (int j = i + 1; j < group_size; j++) {\n int u = group[i];\n int v = group[j];\n if (u > v) swap(u, v);\n \n // Use known distance if available\n double estimated_dist;\n if (known_distances.find({u, v}) != known_distances.end()) {\n // We know this edge exists in some MST, so prioritize it\n estimated_dist = 0;\n } else {\n // Use a weighted estimate based on bounding box information\n double center_dist = estimate_distance(cities[u], cities[v]);\n double min_dist = min_possible_distance(cities[u], cities[v]);\n double max_dist = max_possible_distance(cities[u], cities[v]);\n \n // Weighted estimate: favor lower bounds for MST\n estimated_dist = min_dist * 0.7 + center_dist * 0.3;\n }\n \n edges.push_back(Edge(u, v, estimated_dist));\n }\n }\n \n // Sort edges by estimated distance\n sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {\n if (abs(a.estimated_dist - b.estimated_dist) > 1e-9) {\n return a.estimated_dist < b.estimated_dist;\n }\n if (a.u != b.u) return a.u < b.u;\n return a.v < b.v;\n });\n \n // Use Kruskal's algorithm to build MST\n vector parent(group_size);\n for (int i = 0; i < group_size; i++) {\n parent[i] = i;\n }\n \n function find_root = [&](int x) {\n if (parent[x] != x) {\n parent[x] = find_root(parent[x]);\n }\n return parent[x];\n };\n \n auto unite = [&](int x, int y) {\n int rx = find_root(x);\n int ry = find_root(y);\n if (rx != ry) {\n parent[rx] = ry;\n return true;\n }\n return false;\n };\n \n // Build MST\n for (const Edge& e : edges) {\n int u_idx = -1, v_idx = -1;\n for (int i = 0; i < group_size; i++) {\n if (group[i] == e.u) u_idx = i;\n if (group[i] == e.v) v_idx = i;\n }\n \n if (u_idx != -1 && v_idx != -1 && unite(u_idx, v_idx)) {\n final_edges[group_idx].push_back({e.u, e.v});\n if (final_edges[group_idx].size() == (size_t)(group_size - 1)) {\n break;\n }\n }\n }\n }\n }\n \n void output_answer() {\n cout << \"!\" << endl;\n \n for (int i = 0; i < M; i++) {\n // Output group members\n for (int j = 0; j < (int)final_groups[i].size(); j++) {\n if (j > 0) cout << \" \";\n cout << final_groups[i][j];\n }\n cout << endl;\n \n // Output edges for this group\n for (auto& edge : final_edges[i]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n cout.flush();\n }\n \n void solve() {\n read_input();\n \n // Use improved initial grouping\n improved_initial_grouping();\n \n // Use strategic querying to gather information and validate groups\n strategic_querying();\n \n // Build final MSTs with better distance estimates\n build_better_msts();\n \n // Output answer\n output_answer();\n }\n};\n\nint main() {\n Solution solution;\n solution.solve();\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Pos {\n int i, j;\n Pos(int i = 0, int j = 0) : i(i), j(j) {}\n bool operator==(const Pos& other) const {\n return i == other.i && j == other.j;\n }\n bool operator<(const Pos& other) const {\n if (i != other.i) return i < other.i;\n return j < other.j;\n }\n};\n\n// Manhattan distance helper\nint manhattan(const Pos& a, const Pos& b) {\n return abs(a.i - b.i) + abs(a.j - b.j);\n}\n\n// Direction vectors\nconst int di[4] = {-1, 1, 0, 0};\nconst int dj[4] = {0, 0, -1, 1};\nconst char dirChar[4] = {'U', 'D', 'L', 'R'};\n\n// Check if position is valid\nbool isValid(const Pos& p, int N) {\n return p.i >= 0 && p.i < N && p.j >= 0 && p.j < N;\n}\n\n// Check if can move to position\nbool canMoveTo(const Pos& to, const vector>& blocks, int N) {\n if (!isValid(to, N)) return false;\n if (blocks[to.i][to.j]) return false;\n return true;\n}\n\n// Sliding in a direction until hitting a block\nPos slide(const Pos& start, int dir, const vector>& blocks, int N) {\n Pos current = start;\n Pos next = {current.i + di[dir], current.j + dj[dir]};\n \n while (isValid(next, N) && !blocks[next.i][next.j]) {\n current = next;\n next = {current.i + di[dir], current.j + dj[dir]};\n }\n \n return current;\n}\n\n// Validate if an action is legal\nbool isValidAction(const Pos& currentPos, char action, char direction, const vector>& blocks, int N) {\n if (direction != 'U' && direction != 'D' && direction != 'L' && direction != 'R') {\n return false;\n }\n \n int dir = (direction == 'U') ? 0 : \n (direction == 'D') ? 1 :\n (direction == 'L') ? 2 : 3;\n \n if (action == 'A') {\n Pos alterPos = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n return isValid(alterPos, N);\n } else if (action == 'M') {\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n return canMoveTo(next, blocks, N);\n } else if (action == 'S') {\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n return isValid(next, N) && !blocks[next.i][next.j];\n }\n \n return false;\n}\n\n// Simple BFS to find shortest path (considering only moves)\nvector> bfsPath(const Pos& start, const Pos& target, vector> blocks, int N) {\n if (start == target) return {};\n \n queue>>> q;\n set visited;\n \n q.push({start, {}});\n visited.insert(start);\n \n while (!q.empty()) {\n auto [pos, path] = q.front();\n q.pop();\n \n // Try moves in 4 directions\n for (int d = 0; d < 4; d++) {\n Pos next = {pos.i + di[d], pos.j + dj[d]};\n if (canMoveTo(next, blocks, N) && visited.find(next) == visited.end()) {\n auto newPath = path;\n newPath.push_back({'M', dirChar[d]});\n \n if (next == target) {\n return newPath;\n }\n \n visited.insert(next);\n q.push({next, newPath});\n }\n }\n }\n \n return {}; // No path found\n}\n\n// Simple greedy approach as fallback\nvector> greedyPath(const Pos& start, const Pos& target, vector> blocks, int N) {\n vector> actions;\n Pos current = start;\n \n while (current != target && actions.size() < 1000) {\n // Try to move in direction that reduces distance to target\n int bestDir = -1;\n int minDist = manhattan(current, target) + 1;\n \n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(next, blocks, N)) {\n int dist = manhattan(next, target);\n if (dist < minDist) {\n minDist = dist;\n bestDir = d;\n }\n }\n }\n \n // If no improving move, take any valid move\n if (bestDir == -1) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (canMoveTo(next, blocks, N)) {\n bestDir = d;\n break;\n }\n }\n }\n \n // If still no valid move, remove a blocking block\n if (bestDir == -1) {\n for (int d = 0; d < 4; d++) {\n Pos next = {current.i + di[d], current.j + dj[d]};\n if (isValid(next, N) && blocks[next.i][next.j]) {\n actions.push_back({'A', dirChar[d]});\n blocks[next.i][next.j] = false;\n bestDir = -2;\n break;\n }\n }\n \n if (bestDir == -2) continue;\n else break;\n }\n \n if (bestDir >= 0) {\n actions.push_back({'M', dirChar[bestDir]});\n current = {current.i + di[bestDir], current.j + dj[bestDir]};\n }\n }\n \n return actions;\n}\n\n// Enhanced path optimization: replace 2+ consecutive moves with slides when safe\nvector> enhancedOptimizePath(const vector>& path, Pos startPos, vector> blocks, int N) {\n if (path.size() < 2) return path;\n \n vector> optimized;\n Pos current = startPos;\n \n for (int i = 0; i < path.size(); i++) {\n // Look for consecutive moves in the same direction (2 or more)\n if (path[i].first == 'M') {\n int currentDir = (path[i].second == 'U') ? 0 : \n (path[i].second == 'D') ? 1 :\n (path[i].second == 'L') ? 2 : 3;\n \n // Count consecutive moves in the same direction\n int count = 1;\n for (int j = i + 1; j < path.size(); j++) {\n if (path[j].first == 'M') {\n int nextDir = (path[j].second == 'U') ? 0 : \n (path[j].second == 'D') ? 1 :\n (path[j].second == 'L') ? 2 : 3;\n if (nextDir == currentDir) {\n count++;\n } else {\n break;\n }\n } else {\n break;\n }\n }\n \n // If we have 2 or more consecutive moves, try to replace with slide\n if (count >= 2) {\n // Check if slide is valid\n if (isValidAction(current, 'S', path[i].second, blocks, N)) {\n // Calculate position after original moves\n Pos afterMoves = current;\n int actualMoves = 0;\n for (int k = 0; k < count; k++) {\n Pos nextPos = {afterMoves.i + di[currentDir], afterMoves.j + dj[currentDir]};\n if (canMoveTo(nextPos, blocks, N)) {\n afterMoves = nextPos;\n actualMoves++;\n } else {\n break;\n }\n }\n \n // Calculate position after slide\n Pos afterSlide = slide(current, currentDir, blocks, N);\n \n // Use slide if it lands at exactly the same position as the moves\n // and we actually executed at least 2 moves\n if (afterSlide == afterMoves && actualMoves >= 2) {\n optimized.push_back({'S', path[i].second});\n current = afterSlide;\n i += actualMoves - 1; // Skip the moves we replaced\n continue;\n }\n }\n }\n }\n \n // If not optimized, add original action\n optimized.push_back(path[i]);\n \n // Update current position\n if (path[i].first == 'M') {\n int dir = (path[i].second == 'U') ? 0 : \n (path[i].second == 'D') ? 1 :\n (path[i].second == 'L') ? 2 : 3;\n Pos next = {current.i + di[dir], current.j + dj[dir]};\n if (canMoveTo(next, blocks, N)) {\n current = next;\n }\n } else if (path[i].first == 'S') {\n int dir = (path[i].second == 'U') ? 0 : \n (path[i].second == 'D') ? 1 :\n (path[i].second == 'L') ? 2 : 3;\n current = slide(current, dir, blocks, N);\n } else if (path[i].first == 'A') {\n int dir = (path[i].second == 'U') ? 0 : \n (path[i].second == 'D') ? 1 :\n (path[i].second == 'L') ? 2 : 3;\n Pos alterPos = {current.i + di[dir], current.j + dj[dir]};\n if (isValid(alterPos, N)) {\n blocks[alterPos.i][alterPos.j] = !blocks[alterPos.i][alterPos.j];\n }\n }\n }\n \n return optimized;\n}\n\n// Simple path finding with enhanced optimizations\nvector> findPath(const Pos& start, const Pos& target, vector>& blocks, int N) {\n // Handle blocked target\n if (blocks[target.i][target.j]) {\n vector> actions;\n Pos current = start;\n \n // Find adjacent position to target\n Pos adj;\n bool found = false;\n \n for (int d = 0; d < 4; d++) {\n adj = {target.i + di[d], target.j + dj[d]};\n if (isValid(adj, N) && !blocks[adj.i][adj.j]) {\n found = true;\n break;\n }\n }\n \n if (!found) {\n // If no adjacent position is free, try to clear one\n for (int d = 0; d < 4; d++) {\n adj = {target.i + di[d], target.j + dj[d]};\n if (isValid(adj, N)) {\n // Path to this adjacent position\n auto pathToAdj = bfsPath(current, adj, blocks, N);\n if (pathToAdj.empty()) {\n pathToAdj = greedyPath(current, adj, blocks, N);\n }\n \n actions.insert(actions.end(), pathToAdj.begin(), pathToAdj.end());\n current = adj;\n \n // Remove block at target\n int dirToTarget = -1;\n if (current.i == target.i - 1) dirToTarget = 1; // Down\n else if (current.i == target.i + 1) dirToTarget = 0; // Up\n else if (current.j == target.j - 1) dirToTarget = 3; // Right\n else if (current.j == target.j + 1) dirToTarget = 2; // Left\n \n if (dirToTarget != -1) {\n actions.push_back({'A', dirChar[dirToTarget]});\n blocks[target.i][target.j] = false;\n \n // Move to target\n actions.push_back({'M', dirChar[dirToTarget]});\n return actions;\n }\n }\n }\n }\n \n if (found) {\n // Path to adjacent position\n auto pathToAdj = bfsPath(current, adj, blocks, N);\n if (pathToAdj.empty()) {\n pathToAdj = greedyPath(current, adj, blocks, N);\n }\n \n actions.insert(actions.end(), pathToAdj.begin(), pathToAdj.end());\n current = adj;\n \n // Remove block at target\n int dirToTarget = -1;\n if (current.i == target.i - 1) dirToTarget = 1; // Down\n else if (current.i == target.i + 1) dirToTarget = 0; // Up\n else if (current.j == target.j - 1) dirToTarget = 3; // Right\n else if (current.j == target.j + 1) dirToTarget = 2; // Left\n \n if (dirToTarget != -1) {\n actions.push_back({'A', dirChar[dirToTarget]});\n blocks[target.i][target.j] = false;\n \n // Move to target\n actions.push_back({'M', dirChar[dirToTarget]});\n return actions;\n }\n }\n }\n \n // Try simple slide if target is in straight line and path is clear\n for (int d = 0; d < 4; d++) {\n bool inLine = false;\n if (d == 0 && start.i > target.i && start.j == target.j) inLine = true; // Up\n else if (d == 1 && start.i < target.i && start.j == target.j) inLine = true; // Down\n else if (d == 2 && start.j > target.j && start.i == target.i) inLine = true; // Left\n else if (d == 3 && start.j < target.j && start.i == target.i) inLine = true; // Right\n \n if (inLine) {\n bool clearPath = true;\n Pos check = start;\n while (check != target) {\n check = {check.i + di[d], check.j + dj[d]};\n if (check == target) break;\n if (!isValid(check, N) || blocks[check.i][check.j]) {\n clearPath = false;\n break;\n }\n }\n \n if (clearPath) {\n Pos end = slide(start, d, blocks, N);\n if (end == target && isValidAction(start, 'S', dirChar[d], blocks, N)) {\n return {{'S', dirChar[d]}};\n }\n }\n }\n }\n \n // Try BFS\n auto path = bfsPath(start, target, blocks, N);\n if (path.empty()) {\n // Fallback to greedy\n path = greedyPath(start, target, blocks, N);\n }\n \n // Apply enhanced optimization (replace 2+ consecutive moves with slide)\n auto optimizedPath = enhancedOptimizePath(path, start, blocks, N);\n \n return optimizedPath;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N = 20, M = 40;\n cin >> N >> M;\n \n vector targets(M);\n for (int i = 0; i < M; i++) {\n cin >> targets[i].i >> targets[i].j;\n }\n \n // Initialize board with no blocks\n vector> blocks(N, vector(N, false));\n Pos currentPos = targets[0];\n vector> allActions;\n \n // Visit each target in order\n for (int targetIdx = 1; targetIdx < M; targetIdx++) {\n const Pos& target = targets[targetIdx];\n \n // Get path to target\n auto path = findPath(currentPos, target, blocks, N);\n \n // Execute path with validation\n for (auto& action : path) {\n // Safety check\n if (!isValidAction(currentPos, action.first, action.second, blocks, N)) {\n continue;\n }\n \n allActions.push_back(action);\n \n if (action.first == 'M') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos next = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (canMoveTo(next, blocks, N)) {\n currentPos = next;\n }\n } else if (action.first == 'S') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n currentPos = slide(currentPos, dir, blocks, N);\n } else if (action.first == 'A') {\n int dir = (action.second == 'U') ? 0 : \n (action.second == 'D') ? 1 :\n (action.second == 'L') ? 2 : 3;\n Pos alterPos = {currentPos.i + di[dir], currentPos.j + dj[dir]};\n if (isValid(alterPos, N)) {\n blocks[alterPos.i][alterPos.j] = !blocks[alterPos.i][alterPos.j];\n }\n }\n }\n \n // Final safety check - if not at target, try direct move\n if (currentPos != target) {\n for (int d = 0; d < 4; d++) {\n Pos next = {currentPos.i + di[d], currentPos.j + dj[d]};\n if (next == target && canMoveTo(next, blocks, N)) {\n if (isValidAction(currentPos, 'M', dirChar[d], blocks, N)) {\n allActions.push_back({'M', dirChar[d]});\n currentPos = next;\n break;\n }\n }\n }\n }\n }\n \n // Output all actions\n for (auto& action : allActions) {\n cout << action.first << \" \" << action.second << \"\\n\";\n }\n \n return 0;\n}"}}}