{"model_name":"nova-2-lite-v1","codes":{"1":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2;\n long long area() const { return (long long)(x2 - x1) * (y2 - y1); }\n bool contains(double x, double y) const {\n return x > x1 && x < x2 && y > y1 && y < y2;\n }\n};\n\nint n;\nvector> input;\nvector rects;\nvector r_desired;\nvector> desired_points;\n\ndouble satisfaction(int i, const Rect& r) {\n double x = get<0>(input[i]) + 0.5, y = get<1>(input[i]) + 0.5;\n if (!r.contains(x, y)) return 0.0;\n long long s = r.area();\n long long r_val = get<2>(input[i]);\n double ratio = min(r_val, (long long)s) * 1.0 / max(r_val, (long long)s);\n return 1.0 - pow(1.0 - ratio, 2.0);\n}\n\ndouble total_satisfaction() {\n double total = 0.0;\n for (int i = 0; i < n; ++i) {\n total += satisfaction(i, rects[i]);\n }\n return total;\n}\n\nbool intersects(const Rect& a, const Rect& b) {\n return !(a.x2 <= b.x1 || a.x1 >= b.x2 || a.y2 <= b.y1 || a.y1 >= b.y2);\n}\n\nvoid init_rects() {\n rects.clear();\n for (int i = 0; i < n; ++i) {\n int x = get<0>(input[i]), y = get<1>(input[i]);\n int r = get<2>(input[i]);\n int half = max(1, (int)sqrt(r));\n rects.push_back({x, y, x + half, y + half});\n }\n}\n\nbool expand_rect(int i, int dx, int dy) {\n Rect& r = rects[i];\n Rect new_r = {r.x1 - dx, r.y1 - dy, r.x2 + dx, r.y2 + dy};\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n return false;\n }\n }\n if (new_r.x1 < 0 || new_r.y1 < 0 || new_r.x2 > 10000 || new_r.y2 > 10000) {\n return false;\n }\n rects[i] = new_r;\n return true;\n}\n\nvoid greedy_expansion() {\n for (int iter = 0; iter < 1000; ++iter) {\n for (int i = 0; i < n; ++i) {\n int dx = 1, dy = 1;\n while (expand_rect(i, dx, dy)) {\n dx++;\n dy++;\n }\n }\n }\n}\n\ndouble simulated_annealing(double T, double alpha, int steps) {\n double best_score = total_satisfaction();\n vector best_rects = rects;\n\n for (int step = 0; step < steps; ++step) {\n int i = rand() % n;\n int dx = (rand() % 5) - 2;\n int dy = (rand() % 5) - 2;\n\n Rect old_r = rects[i];\n Rect new_r = {old_r.x1 + dx, old_r.y1 + dy, old_r.x2 + dx, old_r.y2 + dy};\n\n bool valid = true;\n if (new_r.x1 < 0 || new_r.x1 >= 10000 || new_r.x2 < 0 || new_r.x2 >= 10000 ||\n new_r.y1 < 0 || new_r.y1 >= 10000 || new_r.y2 < 0 || new_r.y2 >= 10000) {\n valid = false;\n } else {\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n valid = false;\n break;\n }\n }\n }\n\n if (!valid) {\n swap(new_r, old_r);\n }\n\n double old_score = satisfaction(i, old_r);\n double new_score = satisfaction(i, new_r);\n double delta = new_score - old_score;\n\n if (delta > 0 || exp(delta / T) > (double)rand() / RAND_MAX) {\n rects[i] = new_r;\n } else {\n rects[i] = old_r;\n }\n\n double current_score = total_satisfaction();\n if (current_score > best_score) {\n best_score = current_score;\n best_rects = rects;\n }\n\n T *= alpha;\n }\n\n rects = best_rects;\n return best_score;\n}\n\nint main() {\n srand(time(nullptr));\n cin >> n;\n input.resize(n);\n r_desired.resize(n);\n desired_points.resize(n);\n\n for (int i = 0; i < n; ++i) {\n int x, y, r;\n cin >> x >> y >> r;\n input[i] = {x, y, r};\n desired_points[i] = {x + 0.5, y + 0.5};\n r_desired[i] = r;\n }\n\n init_rects();\n greedy_expansion();\n\n double T = 10000.0;\n double alpha = 0.99;\n int steps = 100000;\n\n simulated_annealing(T, alpha, steps);\n\n for (const auto& r : rects) {\n cout << r.x1 << \" \" << r.y1 << \" \" << r.x2 << \" \" << r.y2 << endl;\n }\n\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj;\n cin >> si >> sj;\n \n vector> t(50, vector(50));\n vector> p(50, vector(50));\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n }\n }\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> p[i][j];\n }\n }\n \n // Identify tiles: map from tile id to list of positions\n map>> tiles;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n tiles[t[i][j]].emplace_back(i, j);\n }\n }\n \n // For each tile, check if it's horizontal or vertical\n // and store the positions in a sorted manner\n vector>> tilePositions;\n tilePositions.reserve(tiles.size());\n for (auto &entry : tiles) {\n auto &posList = entry.second;\n sort(posList.begin(), posList.end());\n tilePositions.push_back(set>(posList.begin(), posList.end()));\n }\n \n // Create a map from position to tile index\n vector> posToTile(50, vector(50, -1));\n for (size_t ti = 0; ti < tilePositions.size(); ++ti) {\n for (auto &pos : tilePositions[ti]) {\n posToTile[pos.first][pos.second] = ti;\n }\n }\n \n // Directions: up, down, left, right\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n vector dirChar = {'U', 'D', 'L', 'R'};\n \n // BFS to find a path\n vector> visited(50, vector(50, false));\n vector> path(50, vector(50, '\\0'));\n queue> q;\n \n q.emplace(si, sj);\n visited[si][sj] = true;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (size_t d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited[ni][nj]) continue;\n \n // Check if the new position is on the same tile as the current one\n if (posToTile[i][j] == posToTile[ni][nj]) continue;\n \n visited[ni][nj] = true;\n path[ni][nj] = dirChar[d];\n q.emplace(ni, nj);\n }\n }\n \n // Reconstruct the path from si, sj to the furthest point\n string output;\n pair current = {si, sj};\n while (true) {\n bool found = false;\n for (size_t d = 0; d < 4; ++d) {\n int ni = current.first + dirs[d].first;\n int nj = current.second + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (path[ni][nj] == '\\0') continue;\n // Check tile uniqueness\n if (posToTile[current.first][current.second] == posToTile[ni][nj]) continue;\n output += dirChar[d];\n current = {ni, nj};\n found = true;\n break;\n }\n if (!found) break;\n }\n \n cout << output << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint H, W; // 30x30 grid\nvector> h_est, v_est; // estimated horizontal and vertical edge weights\nvector> h_cnt, v_cnt; // count of usage for each edge\n\nvector dirs = {\"U\", \"D\", \"L\", \"R\"};\n\n// BFS to generate a path\nstring bfs_path(int si, int sj, int ti, int tj) {\n vector> dist(H, vector(W, -1));\n vector> prev(H, vector

(W, {-1, -1}));\n queue

q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break;\n vector

ns;\n if (i > 0) ns.emplace_back(i-1, j);\n if (i < H-1) ns.emplace_back(i+1, j);\n if (j > 0) ns.emplace_back(i, j-1);\n if (j < W-1) ns.emplace_back(i, j+1);\n for (auto [ni, nj] : ns) {\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n q.emplace(ni, nj);\n }\n }\n }\n if (dist[ti][tj] == -1) return \"\";\n string path;\n P cur = {ti, tj};\n while (cur != P(si, sj)) {\n P p = prev[cur.first][cur.second];\n int di = cur.first - p.first;\n int dj = cur.second - p.second;\n if (di == -1) path += 'U';\n else if (di == 1) path += 'D';\n else if (dj == -1) path += 'L';\n else if (dj == 1) path += 'R';\n cur = p;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Random walk to generate a path\nstring random_walk(int si, int sj, int ti, int tj, int max_steps) {\n string path;\n int i = si, j = sj;\n while (max_steps-- > 0 && (i != ti || j != tj)) {\n vector possible;\n if (i > 0) possible.push_back('U');\n if (i < H-1) possible.push_back('D');\n if (j > 0) possible.push_back('L');\n if (j < W-1) possible.push_back('R');\n char move = possible[rand() % possible.size()];\n path += move;\n if (move == 'U') i--;\n else if (move == 'D') i++;\n else if (move == 'L') j--;\n else if (move == 'R') j++;\n }\n return path;\n}\n\n// Estimate edge weight from observed lengths\ndouble estimate_edge_weight(int i, int j, char dir) {\n if (dir == 'L' || dir == 'R') {\n if (h_cnt[i][j] == 0) return 1500.0;\n return h_est[i][j] * 1.0 / h_cnt[i][j];\n } else {\n if (v_cnt[i][j] == 0) return 1500.0;\n return v_est[i][j] * 1.0 / v_cnt[i][j];\n }\n}\n\nint main() {\n H = 30, W = 30;\n h_est.assign(H, vector(W, 0));\n v_est.assign(H, vector(W, 0));\n h_cnt.assign(H, vector(W, 0));\n v_cnt.assign(H, vector(W, 0));\n \n srand(time(nullptr));\n \n int query_count = 0;\n while (true) {\n int si, sj, ti, tj;\n if (query_count == 0) {\n cin >> si >> sj >> ti >> tj;\n } else {\n // Read the previous result (b_k)\n ll b_prev;\n cin >> b_prev;\n // Update the estimates based on the path taken in the previous query\n // This is a placeholder; actual implementation would track the path\n }\n \n // Generate multiple candidate paths\n string path1 = bfs_path(si, sj, ti, tj);\n string path2 = random_walk(si, sj, ti, tj, abs(si - ti) + abs(sj - tj) * 2);\n string path3 = random_walk(si, sj, ti, tj, abs(si - ti) * 2 + abs(sj - tj));\n \n vector candidates = {path1, path2, path3};\n if (candidates[0].empty()) candidates.erase(candidates.begin());\n \n // Select a path based on estimated weights\n double scores[3] = {0.0};\n for (int idx = 0; idx < candidates.size(); idx++) {\n string& p = candidates[idx];\n double score = 0.0;\n int pi = si, pj = sj;\n for (char c : p) {\n if (c == 'U' || c == 'D') {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n } else {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n scores[idx] = 1.0 / score;\n }\n \n // Choose the best candidate\n double max_score = -1.0;\n int best_idx = 0;\n for (int idx = 0; idx < candidates.size(); idx++) {\n if (scores[idx] > max_score) {\n max_score = scores[idx];\n best_idx = idx;\n }\n }\n \n string path = candidates[best_idx];\n \n // Output the path\n cout << path << endl;\n cout.flush();\n \n // Read the result (b_k)\n ll b_k;\n cin >> b_k;\n \n // Update estimates based on the path taken\n int pi = si, pj = sj;\n for (char c : path) {\n if (c == 'L' || c == 'R') {\n h_est[pi][pj] += b_k; // placeholder update\n h_cnt[pi][pj]++;\n } else {\n v_est[pi][pj] += b_k;\n v_cnt[pi][pj]++;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n \n query_count++;\n }\n \n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 20;\n int M;\n cin >> N >> M;\n vector strings(M);\n for (int i = 0; i < M; ++i) {\n cin >> strings[i];\n }\n\n vector> matrix(N, vector(N, '.'));\n\n for (const auto& s : strings) {\n int len = s.size();\n bool placed = false;\n\n // Try horizontal placement\n for (int i = 0; i < N && !placed; ++i) {\n for (int j = 0; j <= N - len && !placed; ++j) {\n bool can_place = true;\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % N;\n if (matrix[i][col] != '.' && matrix[i][col] != s[k]) {\n can_place = false;\n break;\n }\n }\n if (can_place) {\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % N;\n matrix[i][col] = s[k];\n }\n placed = true;\n }\n }\n }\n\n // Try vertical placement\n if (!placed) {\n for (int j = 0; j < N && !placed; ++j) {\n for (int i = 0; i <= N - len && !placed; ++i) {\n bool can_place = true;\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % N;\n if (matrix[row][j] != '.' && matrix[row][j] != s[k]) {\n can_place = false;\n break;\n }\n }\n if (can_place) {\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % N;\n matrix[row][j] = s[k];\n }\n placed = true;\n }\n }\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << matrix[i][j];\n }\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector> time(N, vector(N, 0));\n vector> is_road(N, vector(N, false));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n is_road[i][j] = true;\n time[i][j] = grid[i][j] - '0';\n }\n }\n }\n \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.emplace_back(i, j);\n }\n }\n }\n \n vector directions = {\"U\", \"D\", \"L\", \"R\"};\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n \n vector>> adjacency(N, vector>(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 for (int d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && is_road[ni][nj]) {\n adjacency[i][j].emplace_back(ni, nj);\n }\n }\n }\n }\n \n vector path;\n set> visited;\n vector> seen(N, vector(N, false));\n \n function dfs = [&](int i, int j) {\n stack> st;\n st.emplace(i, j);\n visited.insert({i, j});\n seen[i][j] = true;\n vector> points = {i, j};\n \n while (!st.empty()) {\n auto [x, y] = st.top();\n st.pop();\n points.push_back({x, y});\n for (auto [nx, ny] : adjacency[x][y]) {\n if (!seen[nx][ny]) {\n seen[nx][ny] = true;\n st.emplace(nx, ny);\n }\n }\n }\n \n for (auto [x, y] : points) {\n path.push_back(\"D\");\n }\n };\n \n dfs(si, sj);\n \n string result;\n int curr_i = si, curr_j = sj;\n for (char move : path) {\n int di = 0, dj = 0;\n if (move == 'U') di = -1;\n if (move == 'D') di = 1;\n if (move == 'L') dj = -1;\n if (move == 'R') dj = 1;\n curr_i += di;\n curr_j += dj;\n result += move;\n }\n \n cout << result << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct Task {\n vector d; // required skills\n vector deps; // dependencies\n int index;\n int earliest_start_day = 0; // Earliest possible start day based on dependencies\n int assigned_to = -1; // Which team member is assigned (-1 if not assigned)\n int start_day = -1; // Actual start day (-1 if not started)\n int completion_day = -1; // Completion day (-1 if not completed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].d.resize(K);\n for (int j = 0; j < K; ++j) {\n cin >> tasks[i].d[j];\n }\n tasks[i].index = i;\n }\n\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].deps.push_back(u);\n }\n\n // Build adjacency list for dependency graph\n vector> dep_graph(N);\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int dep : tasks[i].deps) {\n dep_graph[dep].push_back(i);\n in_degree[i]++;\n }\n }\n\n // Initial skill estimates for each team member (initialized to zero)\n vector> skillestimates(M, vector(K, 0.0));\n\n // Track completion times for each team member (for skill update)\n vector completion_times(M, 0.0); // Cumulative completion time\n vector task_count(M, 0); // Number of tasks completed by each member\n\n // Track which team members are busy (assigned a task)\n vector busy(M, false);\n\n // Track completed tasks\n vector completed(N, false);\n\n // Track available tasks (tasks with all dependencies completed)\n queue available_tasks;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n available_tasks.push(i);\n }\n }\n\n // Process days until all tasks are completed or day 2000\n for (int day = 1; day <= 2000; ++day) {\n // Collect tasks to assign today\n vector> assignments;\n\n // For each available team member, assign the \"best\" available task\n for (int member = 0; member < M; ++member) {\n if (busy[member]) continue; // Skip if busy\n\n // Find the best task for this member from available tasks\n int best_task = -1;\n double min_estimated_time = INFINITY;\n // We need to consider tasks that are available and not completed\n // For simplicity, we'll iterate through all tasks and check if available\n for (int t = 0; t < N; ++t) {\n if (completed[t]) continue;\n if (in_degree[t] > 0) continue; // Not available yet\n\n // Estimate time for this member to do this task\n double w = 0.0;\n for (int k = 0; k < K; ++k) {\n w += max(0.0, tasks[t].d[k] - skillestimates[member][k]);\n }\n double estimated_time = (w == 0) ? 1.0 : max(1.0, w + uniform_real_distribution(-3.0, 3.0).operator()());\n\n if (estimated_time < min_estimated_time) {\n min_estimated_time = estimated_time;\n best_task = t;\n }\n }\n\n if (best_task != -1) {\n assignments.emplace_back(member, best_task);\n busy[member] = true;\n tasks[best_task].assigned_to = member;\n tasks[best_task].start_day = day;\n }\n }\n\n // Output assignments\n cout << assignments.size();\n for (auto& [member, task] : assignments) {\n cout << \" \" << member + 1 << \" \" << task + 1;\n }\n cout << endl;\n cout.flush();\n\n // Read input: either -1 or list of completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n\n vector completed_members;\n for (int i = 0; i < n_completed; ++i) {\n int member;\n cin >> member;\n member--;\n completed_members.push_back(member);\n }\n\n // Update skill estimates and mark tasks as completed\n for (int member : completed_members) {\n if (busy[member]) {\n // Find which task this member completed\n for (int t = 0; t < N; ++t) {\n if (tasks[t].assigned_to == member && tasks[t].completion_day == -1) {\n // Assume we get the actual completion time from the problem, but here we simulate\n // For real submission, we don't have actual time, so we cannot update skills.\n // In a real scenario, we would need to get actual completion time from the judge.\n // Since we don't have it, we skip skill update for now.\n tasks[t].completion_day = day;\n completed[t] = true;\n busy[member] = false;\n\n // Update dependency graph: this task's dependents may now be available\n for (int next_task : dep_graph[t]) {\n in_degree[next_task]--;\n if (in_degree[next_task] == 0) {\n available_tasks.push(next_task);\n }\n }\n break;\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read all orders\n vector> orders(1000);\n for(int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n orders[i] = {a, b, c, d};\n }\n \n // Select the first 50 orders (just as a placeholder)\n vector selected(50);\n iota(selected.begin(), selected.end(), 0);\n \n // Create a simple route that goes from center to each pickup and then delivery\n vector> route;\n route.emplace_back(400, 400); // Start at center\n \n for(int i = 0; i < 50; i++) {\n auto [a,b,c,d] = orders[i];\n route.emplace_back(a, b); // Go to pickup\n route.emplace_back(c, d); // Then to delivery\n }\n \n // Return to center\n route.emplace_back(400, 400);\n \n // Output\n cout << \"50\";\n for(int i: selected) cout << \" \" << (i+1);\n cout << \"\\n\" << route.size();\n for(auto [x,y] : route) cout << \" \" << x << \" \" << y;\n cout << endl;\n \n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\nint round_sqrt(long long x) {\n long long s = sqrt(x);\n if ((s + 1) * (s + 1) <= x) s++;\n return (int)s;\n}\n\nint distance(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return round_sqrt(dx * dx + dy * dy);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 400, M = 1995;\n vector points(N);\n vector> edges(M);\n\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n int u = edges[i].first, v = edges[i].second;\n d[i] = distance(points[u], points[v]);\n }\n\n vector added(M, false);\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n \n function find = [&](int u) {\n while (parent[u] != u) {\n parent[u] = parent[parent[u]];\n u = parent[u];\n }\n return u;\n };\n\n auto unite = [&](int u, int v) {\n u = find(u);\n v = find(v);\n if (u == v) return false;\n parent[v] = u;\n return true;\n };\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n int u = edges[i].first, v = edges[i].second;\n if (unite(u, v)) {\n cout << \"1\\n\";\n added[i] = true;\n } else {\n cout << \"0\\n\";\n }\n cout.flush();\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N;\n vector> pets(N);\n for (int i = 0; i < N; ++i) {\n int x, y, t;\n cin >> x >> y >> t;\n pets[i] = {x - 1, y - 1, t};\n }\n cin >> M;\n vector> humans(M);\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n humans[i] = {x - 1, y - 1};\n }\n\n vector> grid(30, vector(30, false));\n vector> blocked(30, vector(30, false));\n for (auto [x, y, _] : pets) grid[x][y] = true;\n for (auto [x, y] : humans) grid[x][y] = true;\n\n for (int turn = 0; turn < 300; ++turn) {\n string action;\n for (int i = 0; i < M; ++i) {\n int x = humans[i].first;\n int y = humans[i].second;\n\n vector> moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n vector dirs = {'D', 'U', 'R', 'L'};\n int best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n humans[i] = {moves[best].first, moves[best].second};\n grid[x][y] = false;\n grid[moves[best].first][moves[best].second] = true;\n } else {\n moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n dirs = {'r', 'l', 'd', 'u'};\n best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n blocked[moves[best].first][moves[best].second] = true;\n } else {\n action += '.';\n }\n }\n }\n cout << action << endl;\n cout.flush();\n\n string pet_moves;\n for (int i = 0; i < N; ++i) pet_moves += '.';\n cin >> pet_moves;\n for (int i = 0; i < N; ++i) {\n auto [x, y, type] = pets[i];\n if (pet_moves[i] != '.') {\n char move = pet_moves[i];\n if (move == 'U') x--;\n else if (move == 'D') x++;\n else if (move == 'L') y--;\n else if (move == 'R') y++;\n pets[i] = {x, y, type};\n grid[x][y] = true;\n }\n }\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n cout << \"R\" << endl;\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Direction transition table: to[tile][enter_dir] = exit_dir or -1\nint 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\nvector> grid(30, vector(30));\nvector> rotation(30, vector(30, 0));\n\nint computeLength(int si, int sj, int sd, const vector>& rot) {\n int i = si, j = sj;\n int d = sd;\n int length = 0;\n vector> visited(30, vector(30, -1));\n int visit_id = abs(hash>(rot)) % 1000; // Just a dummy unique\n\n while (true) {\n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n int tile = grid[i][j] + 4 * rotation[i][j];\n d = to[tile][d];\n if (d == -1) return 0;\n int ni = i + di[d];\n int nj = j + dj[d];\n d = (d + 2) % 4;\n length++;\n if (ni == si && nj == sj && d == sd) {\n return length;\n }\n if (visited[i][j] == visit_id) {\n // Detect cycle but not closed properly\n return 0;\n }\n visited[i][j] = visit_id;\n i = ni;\n j = nj;\n }\n}\n\npair getTwoMaxLengths(const vector>& rot) {\n priority_queue pq;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int len = computeLength(i, j, d, rot);\n if (len > 0) pq.push(len);\n }\n }\n }\n if (pq.size() < 2) {\n return {0, 0};\n }\n int max1 = pq.top(); pq.pop();\n int max2 = pq.top(); pq.pop();\n return {max1, max2};\n}\n\nint score(const vector>& rot) {\n auto [l1, l2] = getTwoMaxLengths(rot);\n if (l1 == 0 || l2 == 0) return 0;\n return l1 * l2;\n}\n\nvector> rotateRandom() {\n vector> rot(30, vector(30));\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rot[i][j] = rand() % 4;\n }\n }\n return rot;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cin >> grid[i][j];\n }\n }\n\n // Initialize with random rotations\n vector> best_rot = rotateRandom();\n int best_score = score(best_rot);\n\n // Simple hill climbing\n const int iterations = 2000;\n for (int iter = 0; iter < iterations; iter++) {\n // Pick a random tile\n int i = rand() % 30;\n int j = rand() % 30;\n int old_rot = best_rot[i][j];\n for (int delta = 1; delta <= 3; delta++) {\n int new_rot = (old_rot + delta) % 4;\n best_rot[i][j] = new_rot;\n int current_score = score(best_rot);\n if (current_score > best_score) {\n best_score = current_score;\n } else {\n best_rot[i][j] = old_rot;\n }\n }\n }\n\n // Output the best rotations found\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n if (j < 29) cout << \" \";\n }\n cout << endl;\n }\n\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint N;\nvector board;\nmap hex_to_int = {\n {'0', 0}, {'1', 1}, {'2', 2}, {'3', 3},\n {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7},\n {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11},\n {'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}\n};\n\nint int_to_dir(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 -1;\n}\n\nchar dir_to_char(int d) {\n if (d == 0) return 'U';\n if (d == 1) return 'D';\n if (d == 2) return 'L';\n if (d == 3) return 'R';\n return 'X';\n}\n\nbool is_valid(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n}\n\nint get_bit(int mask, int pos) {\n return (mask >> pos) & 1;\n}\n\nint get_connection(int i, int j, int dir) {\n int mask = hex_to_int[board[i][j]];\n if (dir == 0) return get_bit(mask, 1); // up\n if (dir == 1) return get_bit(mask, 3); // down\n if (dir == 2) return get_bit(mask, 0); // left\n if (dir == 3) return get_bit(mask, 2); // right\n return 0;\n}\n\nvector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n\npair move_empty(int i, int j, int dir) {\n int ni = i + dirs[dir].first;\n int nj = j + dirs[dir].second;\n if (!is_valid(ni, nj) || board[ni][nj] == '0') return {-1, -1};\n return {ni, nj};\n}\n\nint count_components() {\n vector> visited(N, vector(N, false));\n int components = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == '0') continue;\n if (!visited[i][j]) {\n components++;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n int mask = hex_to_int[board[x][y]];\n for (int d = 0; d < 4; ++d) {\n if (get_connection(x, y, d)) {\n int nx = x + dirs[d].first, ny = y + dirs[d].second;\n if (is_valid(nx, ny) && board[nx][ny] != '0' && !visited[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n }\n }\n }\n return components;\n}\n\nvector solve() {\n int empty_i = -1, empty_j = -1;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == '0') {\n empty_i = i;\n empty_j = j;\n }\n vector result;\n vector> history;\n history.emplace_back(empty_i, empty_j);\n\n for (int step = 0; step < 2 * N * N * N; ++step) {\n int best_components = count_components();\n char best_move = 0;\n vector> best_pos = {empty_i, empty_j};\n\n for (int d = 0; d < 4; ++d) {\n auto [ni, nj] = move_empty(empty_i, empty_j, d);\n if (ni == -1) continue;\n swap(board[empty_i][empty_j], board[ni][nj]);\n int components = count_components();\n swap(board[empty_i][empty_j], board[ni][nj]);\n\n if (components < best_components) {\n best_components = components;\n best_move = dir_to_char(d);\n best_pos = {ni, nj};\n }\n }\n\n if (best_move == 0) break;\n\n result.push_back(best_move);\n swap(board[empty_i][empty_j], board[best_pos.first][best_pos.second]);\n empty_i = best_pos.first;\n empty_j = best_pos.second;\n history.emplace_back(empty_i, empty_j);\n }\n\n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n int T = 2 * N * N * N;\n board.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n auto result = solve();\n\n cout << string(result.begin(), result.end()) << endl;\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\n// Compute cross product of vectors (p1 - o) and (p2 - o)\nlong long cross(const Point& o, const Point& p1, const Point& p2) {\n return (long long)(p1.x - o.x) * (p2.y - o.y) - (long long)(p1.y - o.y) * (p2.x - o.x);\n}\n\n// Check if point p is on the left side of the directed line (a, b)\nbool isLeft(const Point& a, const Point& b, const Point& p) {\n return cross(a, b, p) > 0;\n}\n\n// Compute orientation of three points (clockwise, counterclockwise, or collinear)\nint orientation(const Point& p, const Point& q, const Point& r) {\n long long val = (long long)(q.y - p.y) * (r.x - q.x) - (long long)(q.x - p.x) * (r.y - q.y);\n if (val == 0) return 0; // Collinear\n return (val > 0) ? 1 : 2; // Clockwise or Counterclockwise\n}\n\n// Graham scan to compute convex hull\nvector convexHull(vector points) {\n int n = points.size(), i = 0;\n if (n <= 1) return points;\n\n // Find the lowest point\n for (int j = 1; j < n; j++)\n if (points[j].y < points[i].y || (points[j].y == points[i].y && points[j].x < points[i].x))\n i = j;\n\n // Sort points angularly around the pivot\n sort(points.begin(), points.end(), [&](const Point& a, const Point& b) {\n int o = orientation(points[i], a, b);\n if (o == 0) return (dist(points[i], a) < dist(points[i], b));\n return o == 1;\n });\n\n vector hull;\n hull.push_back(points[i]);\n\n for (int j = 1; j < n; j++) {\n while (hull.size() >= 2 && orientation(hull[hull.size()-2], hull.back(), points[j]) != 2)\n hull.pop_back();\n hull.push_back(points[j]);\n }\n\n return hull;\n}\n\n// Compute Euclidean distance squared between two points\nlong long dist(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\n// Compute centroid of a set of points\nPoint centroid(const vector& points) {\n long long cx = 0, cy = 0;\n for (const auto& p : points) {\n cx += p.x;\n cy += p.y;\n }\n return Point(cx / points.size(), cy / points.size());\n}\n\n// Generate a line that separates cluster from others using PCA on angles\nvector> separateClusters(const vector>& clusters) {\n vector> lines;\n for (int i = 0; i < clusters.size(); ++i) {\n const auto& cluster = clusters[i];\n if (cluster.empty()) continue;\n\n // Compute centroid of the cluster\n Point c = centroid(cluster);\n\n // Collect vectors from centroid to points\n vector vectors;\n for (const auto& p : cluster) {\n vectors.emplace_back(p.x - c.x, p.y - c.y);\n }\n\n // Compute PCA to find principal direction\n double sum_x2 = 0, sum_y2 = 0, sum_xy = 0;\n for (const auto& v : vectors) {\n sum_x2 += (double)v.x * v.x;\n sum_y2 += (double)v.y * v.y;\n sum_xy += (double)v.x * v.y;\n }\n\n int n = vectors.size();\n double eigen_val1, eigen_val2;\n double trace = sum_x2 + sum_y2;\n double det = sum_x2 * sum_y2 - sum_xy * sum_xy;\n\n // Skip if degenerate\n if (abs(det) < 1e-9) continue;\n\n // Compute eigenvalues\n eigen_val1 = (trace + sqrt(trace * trace - 4 * det)) / 2;\n eigen_val2 = (trace - sqrt(trace * trace - 4 * det)) / 2;\n\n // Find eigenvector for smaller eigenvalue (minor component)\n double eigen_val = eigen_val2;\n double discriminant = sqrt((sum_x2 - eigen_val) * (sum_y2 - eigen_val) - sum_xy * sum_xy);\n double cos_theta = (sum_x2 - eigen_val) / discriminant;\n double sin_theta = sum_xy / discriminant;\n\n // Rotate to find perpendicular direction for cut line\n double nx = -sin_theta, ny = cos_theta;\n\n // Create line far enough to pass through centroid\n Point p1(c.x + 1000 * nx, c.y + 1000 * ny);\n Point p2(c.x - 1000 * nx, c.y - 1000 * ny);\n\n lines.emplace_back(p1, p2);\n }\n return lines;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n cin >> N >> K;\n vector a(10);\n for (int i = 0; i < 10; ++i) cin >> a[i];\n vector strawberries(N);\n for (int i = 0; i < N; ++i) cin >> strawberries[i].x >> strawberries[i].y;\n\n // Simple clustering: assign to clusters of size close to target sizes\n vector> clusters(10);\n vector target(10);\n for (int d = 0; d < 10; ++d) target[d] = a[d] * (d + 1);\n\n // Greedy assignment\n for (int d = 0; d < 10; ++d) {\n int need = target[d];\n while (need > 0) {\n int best = -1;\n int best_count = 0;\n for (int i = 0; i < N; ++i) {\n bool found = false;\n for (const auto& clust : clusters) {\n if (find(clust.begin(), clust.end(), strawberries[i]) != clust.end()) {\n found = true;\n break;\n }\n }\n if (found) continue;\n\n int cnt = 0;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (dist(p, strawberries[i]) <= 100) ++cnt;\n }\n }\n if (cnt > best_count) {\n best_count = cnt;\n best = i;\n }\n }\n if (best == -1) break;\n clusters[d].push_back(strawberries[best]);\n --need;\n }\n }\n\n // Flatten clusters and generate separating lines\n vector> lines = separateClusters(clusters);\n\n // Output\n cout << lines.size() << \"\\n\";\n for (const auto& line : lines) {\n cout << line.first.x << \" \" << line.first.y << \" \"\n << line.second.x << \" \" << line.second.y << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint N;\nvector> grid;\nvector

dots;\nmap dot_map;\nset

drawn_rects;\nset

new_dots;\n\nstruct Rect {\n P p1, p2, p3, p4;\n int score;\n};\n\nvector candidates;\n\nbool is_valid_rect(const P& p1, const P& p2, const P& p3, const P& p4) {\n vector

perimeter;\n perimeter.push_back(p1);\n perimeter.push_back(p2);\n perimeter.push_back(p3);\n perimeter.push_back(p4);\n if (p1.x == p2.x && p2.x == p3.x && p3.x == p4.x) return false;\n if (p1.y == p2.y && p2.y == p3.y && p3.y == p4.y) return false;\n\n for (const auto& pt : perimeter) {\n if (pt.x < 0 || pt.x >= N || pt.y < 0 || pt.y >= N) return false;\n }\n\n for (int i = 0; i < 4; ++i) {\n for (int j = i + 1; j < 4; ++j) {\n for (int k = j + 1; k < 4; ++k) {\n if ((perimeter[i].x == perimeter[j].x && perimeter[i].y == perimeter[j].y) ||\n (perimeter[i].x == perimeter[k].x && perimeter[i].y == perimeter[k].y) ||\n (perimeter[j].x == perimeter[k].x && perimeter[j].y == perimeter[k].y)) {\n return false;\n }\n }\n }\n }\n\n for (const auto& pt : perimeter) {\n if (dot_map.count(pt)) continue;\n if (new_dots.count(pt)) continue;\n if (grid[pt.x][pt.y] == 0) continue;\n return false;\n }\n\n for (const auto& pt : perimeter) {\n for (const auto& d : dots) {\n if (d == pt) continue;\n if (grid[d.x][d.y] == 0) continue;\n if (pt.x == d.x && pt.y == d.y) return false;\n }\n if (new_dots.count(pt)) {\n for (const auto& d : dots) {\n if (d == pt) continue;\n if (grid[d.x][d.y] == 0) continue;\n if (pt.x == d.x && pt.y == d.y) return false;\n }\n }\n }\n\n for (const auto& pt : perimeter) {\n for (const auto& rect : drawn_rects) {\n if (pt.x == rect.x && pt.y == rect.y) return false;\n }\n }\n\n int min_x = min({p1.x, p2.x, p3.x, p4.x});\n int max_x = max({p1.x, p2.x, p3.x, p4.x});\n int min_y = min({p1.y, p2.y, p3.y, p4.y});\n int max_y = max({p1.y, p2.y, p3.y, p4.y});\n\n for (int x = min_x; x <= max_x; ++x) {\n for (int y = min_y; y <= max_y; ++y) {\n if (x == p1.x && y == p1.y) continue;\n if (x == p2.x && y == p2.y) continue;\n if (x == p3.x && y == p3.y) continue;\n if (x == p4.x && y == p4.y) continue;\n if (grid[x][y] != 0) return false;\n }\n }\n\n return true;\n}\n\nint calculate_score(const P& p) {\n ll c = (N - 1) / 2;\n ll dx = p.x - c;\n ll dy = p.y - c;\n return (dx * dx + dy * dy + 1);\n}\n\nvoid generate_candidates() {\n candidates.clear();\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n if (dot_map.count({x, y})) continue;\n if (new_dots.count({x, y})) continue;\n\n for (int dx : {1, -1}) {\n for (int dy : {1, -1}) {\n if (dx == 0 || dy == 0) continue;\n int x2 = x + dx, y2 = y + dy;\n int x3 = x - dx, y3 = y + dy;\n int x4 = x - dx, y4 = y - dy;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n }\n\n for (int dx : {1, -1}) {\n int x2 = x + dx, y2 = y;\n int x3 = x, y3 = y + dx;\n int x4 = x + dx, y4 = y - dx;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n\n for (int dy : {1, -1}) {\n int y2 = y + dy, x2 = x;\n int y3 = y, x3 = x + dy;\n int y4 = y + dy, x4 = x - dy;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n grid.assign(N, vector(N, 0));\n dots.clear();\n dot_map.clear();\n\n int M;\n cin >> M;\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n dots.emplace_back(x, y);\n dot_map[{x, y}] = 1;\n grid[x][y] = 1;\n }\n\n vector solutions;\n\n while (true) {\n generate_candidates();\n if (candidates.empty()) break;\n\n sort(candidates.begin(), candidates.end(), [](const Rect& a, const Rect& b) {\n return a.score > b.score;\n });\n\n auto best = candidates[0];\n solutions.push_back(best);\n\n grid[best.p1.x][best.p1.y] = 1;\n new_dots.insert({best.p1.x, best.p1.y});\n\n P p2 = best.p2, p3 = best.p3, p4 = best.p4;\n drawn_rects.insert(p2);\n drawn_rects.insert(p3);\n drawn_rects.insert(p4);\n drawn_rects.insert(best.p1);\n }\n\n cout << solutions.size() << \"\\n\";\n for (const auto& sol : solutions) {\n cout << sol.p1.x << \" \" << sol.p1.y << \" \"\n << sol.p2.x << \" \" << sol.p2.y << \" \"\n << sol.p3.x << \" \" << sol.p3.y << \" \"\n << sol.p4.x << \" \" << sol.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstruct Cell {\n int flavor = 0; // 0: empty\n};\n\nconst int SIZE = 10;\nCell grid[SIZE][SIZE];\nint empty_cells[SIZE][SIZE];\n\nvoid reset_empty() {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n empty_cells[i][j] = 1;\n }\n }\n}\n\nvector> get_empty_cells() {\n vector> empty;\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) {\n empty.emplace_back(i, j);\n }\n }\n }\n return empty;\n}\n\nvoid place_candy(int t, int p, int flavor) {\n vector> empty = get_empty_cells();\n auto [i, j] = empty[p - 1];\n grid[i][j].flavor = flavor;\n}\n\nvoid tilt(int dir) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) continue;\n if (dir == 'F') {\n for (int k = i - 1; k >= 0; --k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k+1][j].flavor == 0) {\n swap(grid[i][j], grid[k+1][j]);\n }\n break;\n }\n }\n } else if (dir == 'B') {\n for (int k = i + 1; k < SIZE; ++k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k-1][j].flavor == 0) {\n swap(grid[i][j], grid[k-1][j]);\n }\n break;\n }\n }\n } else if (dir == 'L') {\n for (int k = j - 1; k >= 0; --k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k+1].flavor == 0) {\n swap(grid[i][j], grid[i][k+1]);\n }\n break;\n }\n }\n } else if (dir == 'R') {\n for (int k = j + 1; k < SIZE; ++k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k-1].flavor == 0) {\n swap(grid[i][j], grid[i][k-1]);\n }\n break;\n }\n }\n }\n }\n }\n}\n\nvector calculate_components() {\n vector> visited(SIZE, vector(SIZE, false));\n vector component_sizes(3, 0);\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (visited[i][j] || grid[i][j].flavor == 0) continue;\n int flavor = grid[i][j].flavor;\n queue> q;\n q.emplace(i, j);\n visited[i][j] = true;\n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (nx >= 0 && nx < SIZE && ny >= 0 && ny < SIZE &&\n !visited[nx][ny] && grid[nx][ny].flavor == flavor) {\n visited[nx][ny] = true;\n q.emplace(nx, ny);\n }\n }\n }\n component_sizes[flavor - 1] += size * size;\n }\n }\n return component_sizes;\n}\n\nchar decide_tilt(const vector& flavors) {\n reset_empty();\n vector> empty = get_empty_cells();\n int p;\n cout << flush;\n cin >> p;\n int flavor = flavors[0];\n flavors.erase(flavors.begin());\n place_candy(0, p, flavor);\n\n vector dirs = {'F', 'B', 'L', 'R'};\n vector scores(4, 0);\n vector backup[SIZE][SIZE];\n\n for (int d = 0; d < 4; ++d) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup[i][j] = grid[i][j];\n }\n }\n tilt(dirs[d]);\n scores[d] = calculate_components()[flavor - 1];\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup[i][j];\n }\n }\n }\n\n int max_score = -1;\n char best_dir = 'F';\n for (int d = 0; d < 4; ++d) {\n if (scores[d] > max_score) {\n max_score = scores[d];\n best_dir = dirs[d];\n }\n }\n\n cout << best_dir << '\\n' << flush;\n tilt(best_dir);\n\n return best_dir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector flavors(100);\n for (int i = 0; i < 100; ++i) {\n cin >> flavors[i];\n }\n\n for (int t = 0; t < 100; ++t) {\n if (t == 99) {\n cout << '\\n' << flush;\n break;\n }\n decide_tilt({flavors.begin() + t, flavors.end()});\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double eps;\n cin >> M >> eps;\n \n // Choose N based on M and epsilon\n int N = 20;\n if (M > 50) N = 30;\n if (eps > 0.2) N = 40;\n \n // Generate M distinct graphs with increasing edge density\n cout << N << \"\\n\";\n int total_edges = N * (N - 1) / 2;\n \n for (int k = 0; k < M; ++k) {\n string g(total_edges, '0');\n // Use a pattern that ensures distinct graphs\n int edges_to_add = (k * total_edges) / M;\n for (int i = 0; i < edges_to_add; ++i) {\n g[i] = '1';\n }\n // Add some variation to avoid identical prefixes\n if (k > 0) {\n g[edges_to_add % total_edges] = \n (g[edges_to_add % total_edges] == '1') ? '0' : '1';\n }\n cout << g << \"\\n\";\n }\n cout << flush;\n \n // Process 100 queries\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n // Simple classifier: count edges and map to nearest graph\n int edge_count = count(H.begin(), H.end(), '1');\n int predicted = edge_count * (M - 1) / total_edges;\n predicted = min(max(predicted, 0), M - 1);\n \n cout << predicted << \"\\n\";\n cout << flush;\n }\n \n return 0;\n}","ahc017":"#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, D, K;\n cin >> N >> M >> D >> K;\n\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n edges[i] = {u - 1, v - 1, w};\n }\n\n // Read and ignore vertex coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Sort edges by weight (ascending)\n sort(edges.begin(), edges.end(), [](const auto& a, const auto& b) {\n return get<2>(a) < get<2>(b);\n });\n\n // Assign days to edges\n vector result(M);\n for (int i = 0; i < M; ++i) {\n result[i] = (i % D) + 1;\n }\n\n // Output the result\n for (int i = 0; i < M; ++i) {\n cout << result[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), f2(D), r1(D), r2(D);\n \n for (int i = 0; i < 2; ++i) {\n for (int j = 0; j < D; ++j) cin >> f1[j];\n for (int j = 0; j < D; ++j) cin >> r1[j];\n for (int j = 0; j < D; ++j) cin >> f2[j];\n for (int j = 0; j < D; ++j) cin >> r2[j];\n }\n\n // Initialize 3D array to store which block is placed where\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n // Identify regions where both silhouettes need material\n vector>> common_region(D, vector>(D, vector(D, false)));\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool f_needed1 = (f1[z][x] == '1');\n bool r_needed1 = (r1[z][y] == '1');\n bool f_needed2 = (f2[z][x] == '1');\n bool r_needed2 = (r2[z][y] == '1');\n common_region[z][x][y] = f_needed1 && f_needed2 && r_needed1 && r_needed2;\n }\n }\n }\n\n // Create blocks for common region (shared between both objects)\n int block_id = 1;\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 (block_id == 1000005) break;\n if (common_region[z][x][y]) {\n b1[z][x][y] = block_id;\n b2[z][x][y] = block_id;\n ++block_id;\n }\n }\n if (block_id == 1000005) break;\n }\n if (block_id == 1000005) break;\n }\n\n // Fill remaining regions with unique 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 (b1[z][x][y] == 0 && f1[z][x] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && f2[z][x] == '1') {\n b2[z][x][y] = block_id++;\n }\n if (b1[z][x][y] == 0 && r1[z][y] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && r2[z][y] == '1') {\n b2[z][x][y] = block_id++;\n }\n }\n }\n }\n\n // Output\n cout << block_id - 1 << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b1[z][x][y];\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b2[z][x][y];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \nusing namespace std;\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);\n for (int i = 0; i < N; i++) {\n cin >> stations[i].first >> stations[i].second;\n }\n \n vector> edges(M);\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n u--; v--;\n edges[i] = {u, v, w};\n }\n \n vector> residents(K);\n for (int i = 0; i < K; i++) {\n cin >> residents[i].first >> residents[i].second;\n }\n \n // Output: all edges off, each station with P_i calculated as min(5000, dist to nearest resident + 1)\n vector P(N, 0);\n for (int i = 0; i < N; i++) {\n int min_dist = 1e9;\n for (int j = 0; j < K; j++) {\n int dx = stations[i].first - residents[j].first;\n int dy = stations[i].second - residents[j].second;\n int dist = sqrt(dx*dx + dy*dy);\n if (dist < min_dist) min_dist = dist;\n }\n P[i] = min(min_dist + 1, 5000);\n }\n \n vector B(M, 0);\n \n cout << endl;\n for (int i = 0; i < N; i++) {\n cout << P[i] << (i == N-1 ? \"\\n\" : \" \");\n }\n for (int i = 0; i < M; i++) {\n cout << B[i] << (i == M-1 ? \"\\n\" : \" \");\n }\n \n return 0;\n}","ahc021":"#include \n#include \n#include \nusing namespace std;\n\nstruct Ball {\n int number;\n int x, y;\n Ball(int n, int x, int y) : number(n), x(x), y(y) {}\n};\n\nvector> pyramid;\nvector, pair>>> swaps;\n\nbool isAdjacent(int x1, int y1, int x2, int y2) {\n if (x1 == x2 - 1 && y1 == y2 - 1) return true;\n if (x1 == x2 - 1 && y1 == y2) return true;\n if (x1 == x2 && y1 == y2 - 1) return true;\n if (x1 == x2 && y1 == y2 + 1) return true;\n if (x1 == x2 + 1 && y1 == y2) return true;\n if (x1 == x2 + 1 && y1 == y2 + 1) return true;\n return false;\n}\n\nvoid swapBalls(int x1, int y1, int x2, int y2) {\n if (!isAdjacent(x1, y1, x2, y2)) return;\n swaps.push_back({{x1, y1}, {x2, y2}});\n swap(pyramid[x1][y1].number, pyramid[x2][y2].number);\n}\n\nvoid processTier(int tier) {\n int rows = tier + 1;\n for (int y = 0; y <= tier; ++y) {\n int x = tier;\n Ball& current = pyramid[x][y];\n if (x + 1 >= rows) continue;\n bool valid = true;\n if (y < rows - 1 && current.number > pyramid[x+1][y].number) valid = false;\n if (y + 1 < rows && current.number > pyramid[x+1][y+1].number) valid = false;\n if (!valid) {\n for (int ny = 0; ny < rows - 1; ++ny) {\n if (pyramid[x+1][ny].number < current.number) {\n swapBalls(x, y, x+1, ny);\n break;\n }\n }\n }\n }\n}\n\nint main() {\n int N = 30;\n pyramid.resize(N);\n for (int x = 0; x < N; ++x) {\n int count = (x * (x + 1)) / 2;\n pyramid[x].reserve(x + 1);\n for (int y = 0; y <= x; ++y) {\n int num;\n cin >> num;\n pyramid[x].emplace_back(num, x, y);\n }\n }\n\n for (int tier = 0; tier < N - 1; ++tier) {\n processTier(tier);\n }\n\n cout << swaps.size() << endl;\n for (auto& sw : swaps) {\n cout << sw.first.first << \" \" << sw.first.second << \" \"\n << sw.second.first << \" \" << sw.second.second << endl;\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint D = 9;\nint N;\nvector> grid;\nvector> dist;\nvector> obstacles;\nvector> empty_cells;\nvector> visited;\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nvoid bfs(int sx, int sy) {\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n visited[sx][sy] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i], ny = y + dy[i];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D) continue;\n if (grid[nx][ny] || visited[nx][ny]) continue;\n dist[nx][ny] = dist[x][y] + 1;\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D >> N;\n grid.assign(D, vector(D, false));\n dist.assign(D, vector(D, -1));\n visited.assign(D, vector(D, false));\n\n int entrance_x = 0, entrance_y = (D - 1) / 2;\n grid[entrance_x][entrance_y] = true;\n\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = true;\n obstacles.emplace_back(r, c);\n }\n\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (grid[i][j]) continue;\n empty_cells.emplace_back(i, j);\n }\n }\n\n bfs(entrance_x, entrance_y);\n\n vector>> candidates;\n for (auto [x, y] : empty_cells) {\n if (dist[x][y] == -1) continue;\n candidates.emplace_back(-dist[x][y], make_pair(x, y));\n }\n sort(candidates.begin(), candidates.end());\n\n vector> storage_order;\n vector>> input;\n\n cout << flush;\n\n for (int d = 0; d < D * D - 1 - N; d++) {\n int t;\n cin >> t;\n input.emplace_back(t, make_pair(-1, -1));\n\n int best_idx = -1;\n int best_dist = -1;\n for (auto &[prio, pos] : candidates) {\n int x = pos.first, y = pos.second;\n if (dist[x][y] >= 0) {\n best_idx = pos.first;\n best_dist = pos.second;\n break;\n }\n }\n\n cout << best_idx << \" \" << best_dist << \"\\n\" << flush;\n\n for (auto &[prio, pos] : candidates) {\n if (pos.first == best_idx && pos.second == best_dist) {\n prio = 1e9;\n break;\n }\n }\n }\n\n for (auto &[t, pos] : input) {\n cout << pos.first << \" \" << pos.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n = 50, m = 100;\n vector> c(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> c[i][j];\n }\n }\n\n vector> adj(m + 1);\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int color = c[i][j];\n // Check up\n if (i > 0) {\n int up = c[i - 1][j];\n if (up != 0 && up != color) {\n adj[color].insert(up);\n adj[up].insert(color);\n }\n }\n // Check left\n if (j > 0) {\n int left = c[i][j - 1];\n if (left != 0 && left != color) {\n adj[color].insert(left);\n adj[left].insert(color);\n }\n }\n }\n }\n\n vector> d(n, vector(n, 0));\n\n // Place each color in a unique position, ensuring adjacency\n vector> positions;\n for (int color = 1; color <= m; ++color) {\n // Find a position not already occupied and on the border to maximize adjacency\n bool placed = false;\n for (int i = 0; i < n && !placed; ++i) {\n for (int j = 0; j < n && !placed; ++j) {\n if (d[i][j] == 0) {\n // Check if this position can satisfy adjacency requirements\n bool valid = true;\n for (int other : adj[color]) {\n // Check adjacent positions for other colors\n bool found = false;\n for (int dx = -1; dx <= 1; ++dx) {\n for (int dy = -1; dy <= 1; ++dy) {\n if (abs(dx) + abs(dy) != 1) continue;\n int ni = i + dx, nj = j + dy;\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n if (d[ni][nj] == other) {\n found = true;\n break;\n }\n } else {\n // Outside is considered color 0, so no adjacency\n }\n }\n if (found) break;\n }\n if (!found) {\n valid = false;\n break;\n }\n }\n if (valid) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n }\n }\n }\n }\n if (!placed) {\n // Fallback: place in the first available spot\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n break;\n }\n }\n if (placed) break;\n }\n }\n }\n\n // Now, fill the remaining area with 0, but ensure connectivity\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n // Check if surrounding is all 0 or out of bounds, then keep as 0\n // Otherwise, might need to assign a color, but for simplicity, keep 0\n d[i][j] = 0;\n }\n }\n }\n\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j > 0) cout << \" \";\n cout << d[i][j];\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector> queries;\n vector results;\n\n // Simulate the input for the example; in real scenario, this would be interactive\n // For the purpose of this example, we'll simulate the input based on the problem statement\n // Note: In actual contest, you would read from stdin and write to stdout for each query\n\n // Since the problem requires interactive input, we need to handle the queries\n // However, for the sake of this example, we'll simulate a few queries and then output a division\n\n // We'll simulate the queries here. In real code, you would output queries and read results.\n for (int q = 0; q < Q; ++q) {\n // Example query: compare item 6 vs 22, then 11 and 22 vs 0 and 1, etc.\n // For simplicity, we'll just output a dummy query and read the result\n int nL = 2, nR = 1;\n vector L = {6, 22};\n vector R = {11};\n \n cout << nL << \" \" << nR << \" \";\n for (int x : L) cout << x << \" \";\n for (int x : R) cout << x << \"\\n\";\n cout.flush();\n\n string res;\n cin >> res;\n results.push_back(res);\n\n // Next query\n nL = 2; nR = 2;\n L = {11, 22};\n R = {0, 1};\n cout << nL << \" \" << nR << \" \";\n for (int x : L) cout << x << \" \";\n for (int x : R) cout << x << \"\\n\";\n cout.flush();\n\n cin >> res;\n results.push_back(res);\n }\n\n // After Q queries, output the division\n // For the example, we'll output a simple division: assign first N/D items to each group\n vector assignment(N, 0);\n for (int i = 0; i < N; ++i) {\n assignment[i] = i % D;\n }\n\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << assignment[i];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n = 200, m = 10;\n vector> stacks(m);\n vector pos(n + 1); // pos[v] = {stack_index, position_from_bottom}\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int v;\n cin >> v;\n stacks[i].push_back(v);\n pos[v] = {i, j};\n }\n }\n\n vector removed(n + 1, false);\n vector> operations;\n\n auto current_pos = pos; // Copy initial positions\n\n for (int target = 1; target <= n; ++target) {\n if (removed[target]) continue;\n auto [si, pos_in_stack] = current_pos[target];\n if (pos_in_stack == stacks[si].size() - 1) {\n // Already on top, remove it\n operations.emplace_back(target, 0);\n removed[target] = true;\n stacks[si].pop_back();\n // Update positions of remaining boxes in this stack\n for (int j = pos_in_stack - 1; j >= 0; --j) {\n int v = stacks[si][j];\n current_pos[v] = {si, j};\n }\n stacks[si].pop_back();\n } else {\n // Need to move this box to the top of some stack\n // Find a stack where this box can be moved to the top\n int best_stack = si;\n int min_boxes_moved = n; // Upper bound\n for (int dest = 0; dest < m; ++dest) {\n if (dest == si) continue;\n // Calculate how many boxes we need to move from current stack si to get target to top\n int boxes_moved = pos_in_stack + 1; // All boxes from pos_in_stack down to bottom\n // Check if target is at the top after moving to dest stack\n // After moving, target becomes top of dest stack\n // Energy cost is boxes_moved + 1\n if (boxes_moved + 1 < min_boxes_moved) {\n min_boxes_moved = boxes_moved + 1;\n best_stack = dest;\n }\n }\n // Move target and above to best_stack\n vector to_move;\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n to_move.push_back(stacks[si][j]);\n }\n // Update stacks\n stacks[best_stack].insert(stacks[best_stack].end(), to_move.begin(), to_move.end());\n // Update positions\n for (int j = 0; j < to_move.size(); ++j) {\n int v = to_move[j];\n current_pos[v] = {best_stack, (int)stacks[best_stack].size() - to_move.size() + j};\n }\n // Update the original stack\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n stacks[si].pop_back();\n }\n // Record operation\n operations.emplace_back(target, best_stack + 1);\n }\n }\n\n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if(!(cin >> N)) return 0;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> d[i][j];\n }\n }\n \n vector> visited(N, vector(N, false));\n vector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n vector dir_char = {'R', 'D', 'L', 'U'};\n \n function dfs = [&](int i, int j, int parent_dir) {\n visited[i][j] = true;\n vector> candidates;\n for (int di = 0; di < 4; ++di) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || visited[ni][nj]) continue;\n bool wall = false;\n if (dirs[di].first == 0) {\n if (v[i][min(j, nj)] == '1') wall = true;\n } else {\n if (h[min(i, ni)][j] == '1') wall = true;\n }\n if (!wall) {\n candidates.emplace_back(di, parent_dir);\n }\n }\n sort(candidates.begin(), candidates.end(), [&](const auto& a, const auto& b) {\n int di1 = a.first, pdi1 = a.second;\n int di2 = b.first, pdi2 = b.second;\n int ni1 = i + dirs[di1].first;\n int nj1 = j + dirs[di1].second;\n int ni2 = i + dirs[di2].first;\n int nj2 = j + dirs[di2].second;\n return d[ni1][nj1] > d[ni2][nj2];\n });\n for (auto [di, pdir] : candidates) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n cout << dir_char[di];\n dfs(ni, nj, di);\n cout << dir_char[(di + 2) % 4];\n }\n };\n \n dfs(0, 0, -1);\n cout << endl;\n \n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector t(M);\n for (int k = 0; k < M; ++k) {\n cin >> t[k];\n }\n \n vector>> charPositions(N, map>());\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = grid[i][j];\n charPositions[i][c].emplace_back(i, j);\n }\n }\n \n vector path;\n path.emplace_back(si, sj);\n \n set remaining;\n for (auto& str : t) remaining.insert(str);\n \n string current = \"\";\n int covered = 0;\n const int MAX_STEPS = 5000;\n \n while (!remaining.empty() && path.size() < MAX_STEPS) {\n map candidates;\n for (const auto& str : remaining) {\n candidates[str] = 0;\n }\n \n string S = current;\n S += grid[path.back().i][path.back().j];\n \n for (const auto& str : remaining) {\n if (S.find(str) != string::npos) {\n candidates.erase(str);\n }\n }\n \n if (candidates.empty()) {\n current += grid[path.back().i][path.back().j];\n continue;\n }\n \n string bestStr;\n int bestScore = -1;\n for (const auto& [str, _] : candidates) {\n int score = 0;\n for (size_t pos = 0; pos < str.size(); ++pos) {\n char needed = str[pos];\n for (int di = -2; di <= 2; ++di) {\n for (int dj = -2; dj <= 2; ++dj) {\n int ni = path.back().i + di, nj = path.back().j + dj;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (grid[ni][nj] == needed) {\n score++;\n break;\n }\n }\n }\n }\n if (score > bestScore) {\n bestScore = score;\n bestStr = str;\n }\n }\n \n if (bestStr.empty()) {\n current += grid[path.back().i][path.back().j];\n continue;\n }\n \n int bestCost = INT_MAX;\n Point bestPos(-1, -1);\n for (size_t pos = 0; pos < bestStr.size(); ++pos) {\n char needed = bestStr[pos];\n const auto& positions = charPositions[path.back().i][needed];\n for (const auto& p : positions) {\n int cost = abs(p.i - path.back().i) + abs(p.j - path.back().j) + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestPos = p;\n }\n }\n }\n \n if (bestPos.i == -1) {\n bestPos = path.back();\n bestCost = 1;\n }\n \n path.emplace_back(bestPos);\n current += grid[bestPos.i][bestPos.j];\n \n set toRemove;\n for (const auto& str : remaining) {\n if (current.find(str) != string::npos) {\n toRemove.insert(str);\n }\n }\n for (const auto& str : toRemove) {\n remaining.erase(str);\n }\n }\n \n for (const auto& p : path) {\n cout << p.i << \" \" << p.j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct OilField {\n vector> cells;\n int minI, minJ;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector fields(M);\n for (int idx = 0; idx < M; ++idx) {\n int d;\n cin >> d;\n fields[idx].cells.resize(d);\n for (int i = 0; i < d; ++i) {\n cin >> fields[idx].cells[i].first >> fields[idx].cells[i].second;\n }\n int minI = fields[idx].cells[0].first;\n int minJ = fields[idx].cells[0].second;\n for (auto &p : fields[idx].cells) {\n minI = min(minI, p.first);\n minJ = min(minJ, p.second);\n }\n fields[idx].minI = minI;\n fields[idx].minJ = minJ;\n for (auto &p : fields[idx].cells) {\n p.first -= minI;\n p.second -= minJ;\n }\n }\n\n vector> v(N, vector(N, -1));\n vector> positive;\n\n // Step 1: Drill some key points to get initial information\n // We can start by drilling corners and centers\n vector> drillCandidates = {\n {N/2, N/2}, {0, 0}, {N-1, 0}, {0, N-1}, {N-1, N-1}\n };\n\n for (auto &p : drillCandidates) {\n int i = p.first, j = p.second;\n if (i >= N || j >= N) continue;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n cin >> v[i][j];\n if (v[i][j] > 0) {\n positive.emplace_back(i, j);\n }\n }\n\n // Step 2: Try to guess based on current positive cells\n // For each oil field shape, try to match with positive cells\n // This is a heuristic; we might need to refine further\n\n set> posSet(positive.begin(), positive.end());\n\n // Try to find candidate positions for each oil field\n vector> placements;\n for (const auto &field : fields) {\n int size = field.cells.size();\n for (int i = 0; i <= N - field.minI - 1; ++i) {\n for (int j = 0; j <= N - field.minJ - 1; ++j) {\n bool valid = true;\n for (auto &cell : field.cells) {\n int x = i + cell.first;\n int y = j + cell.second;\n if (x >= N || y >= N) {\n valid = false;\n break;\n }\n if (v[x][y] == 0) {\n valid = false;\n break;\n }\n }\n if (valid) {\n placements.emplace_back(i, j);\n }\n }\n }\n }\n\n // For now, just output all positive cells found by drilling\n cout << \"a \" << positive.size();\n for (auto &p : positive) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n cout.flush();\n\n int result;\n cin >> result;\n if (result == 1) {\n return 0;\n }\n\n // If failed, we might need to do more work, but for this example, we just exit\n // In a real solution, you would refine the strategy here\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n \n int W, D, N;\n cin >> W >> D >> N;\n \n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++d) {\n cin >> a[d][k];\n }\n }\n\n // Output rectangles\n for (int d = 0; d < D; ++d) {\n // Try to place rectangles in rows, sequentially\n vector> used(W, vector(W, false));\n for (int k = 0; k < N; ++k) {\n int area_needed = a[d][k];\n \n // Try to find the smallest rectangle large enough\n int best_i0 = -1, best_j0 = -1, best_i1 = -1, best_j1 = -1;\n int min_area = INT_MAX;\n for (int i0 = 0; i0 < W; ++i0) {\n for (int i1 = i0+1; i1 <= W; ++i1) {\n for (int j0 = 0; j0 < W; ++j0) {\n for (int j1 = j0+1; j1 <= W; ++j1) {\n int area = (i1 - i0) * (j1 - j0);\n if (area < area_needed) continue;\n // Check if all cells in the rectangle are unused\n bool ok = true;\n for (int i = i0; i < i1 && ok; ++i) {\n for (int j = j0; j < j1 && ok; ++j) {\n if (used[i][j]) {\n ok = false;\n break;\n }\n }\n }\n if (!ok) continue;\n if (area < min_area) {\n min_area = area;\n best_i0 = i0;\n best_j0 = j0;\n best_i1 = i1;\n best_j1 = j1;\n }\n }\n }\n }\n }\n // Mark the rectangle as used\n for (int i = best_i0; i < best_i1; ++i) {\n for (int j = best_j0; j < best_j1; ++j) {\n used[i][j] = true;\n }\n }\n cout << best_i0 << \" \" << best_j0 << \" \" << best_i1 << \" \" << best_j1 << \"\\n\";\n }\n }\n \n return 0;\n}","ahc032":"#include \nusing namespace std;\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> 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 vector>> s(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 >> s[m][i][j];\n }\n }\n }\n\n // Simple greedy approach: Try to maximize each cell's mod value by applying stamps\n vector> operations;\n\n // We'll try to apply stamps to improve each cell's value mod 998244353\n const int MOD = 998244353;\n\n // For each possible position (p, q), try each stamp and see how it affects the mod values\n // We'll apply the best improvement we can find up to K times\n\n for (int step = 0; step < K; ++step) {\n int best_delta = -1;\n int best_m = -1, best_p = -1, best_q = -1;\n\n // Try all stamps and positions\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 the total delta this stamp would add to all cells in its area\n int delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int ni = p + i;\n int nj = q + j;\n int current_val = a[ni][nj];\n int new_val = (current_val + s[m][i][j]) % MOD;\n delta += new_val - current_val;\n }\n }\n\n if (delta > best_delta) {\n best_delta = delta;\n best_m = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n\n // Apply the best stamp we found\n if (best_delta > 0) {\n operations.emplace_back(best_m, best_p, best_q);\n // Update the board\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int ni = best_p + i;\n int nj = best_q + j;\n a[ni][nj] = (a[ni][nj] + s[best_m][i][j]) % MOD;\n }\n }\n } else {\n // No more improvements possible\n break;\n }\n }\n\n // Output\n cout << operations.size() << \"\\n\";\n for (auto [m, p, q] : operations) {\n cout << m << \" \" << p << \" \" << q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int x, y;\n bool holding;\n int id;\n};\n\nint N;\nvector> A;\nvector cranes;\nvector> grid;\nvector> occupied;\nvector actions;\n\nvector> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\nchar dir_char[4] = {'R', 'D', 'L', 'U'};\n\nbool is_valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nvoid place_container(int x, int y, int cont) {\n grid[x][y] = cont;\n occupied[x][y] = true;\n}\n\nvoid pickup(Crane& crane, int cont) {\n crane.holding = cont;\n occupied[crane.x][crane.y] = false;\n grid[crane.x][crane.y] = -1;\n}\n\nvoid release(Crane& crane, int x, int y) {\n grid[x][y] = crane.holding;\n occupied[x][y] = true;\n crane.holding = -1;\n}\n\nbool move_crane(Crane& crane, int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!is_valid(nx, ny)) return false;\n if (crane.holding != -1 && occupied[nx][ny]) return false;\n if (crane.holding == -1 && grid[nx][ny] != -1 && nx == N - 1 && ny == N - 1) return false;\n if (occupied[nx][ny] && crane.holding == -1) {\n if (grid[nx][ny] != -1) return false;\n }\n occupied[crane.x][crane.y] = false;\n crane.x = nx;\n crane.y = ny;\n occupied[crane.x][crane.y] = true;\n return true;\n}\n\nvoid simulate_turn(vector& moves) {\n for (int i = 0; i < N; ++i) {\n if (A[i][0] != -1 && !occupied[i][0] && cranes[i].holding == -1) {\n place_container(i, 0, A[i][0]);\n A[i][0] = A[i][1];\n for (int j = 1; j < N; ++j) A[i][j] = A[i][j + 1];\n A[i][N - 1] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n Crane& crane = cranes[i];\n char move = moves[i][actions.size()];\n if (move == 'P') {\n if (crane.holding != -1 || grid[crane.x][crane.y] == -1) continue;\n pickup(crane, grid[crane.x][crane.y]);\n } else if (move == 'Q') {\n if (crane.holding == -1 || occupied[crane.x][crane.y]) continue;\n release(crane, crane.x, crane.y);\n } else if (move == 'B') {\n if (crane.holding != -1) continue;\n crane.holding = -2;\n } else {\n int dx = 0, dy = 0;\n switch (move) {\n case 'U': dx = -1; break;\n case 'D': dx = 1; break;\n case 'L': dy = -1; break;\n case 'R': dy = 1; break;\n default: break;\n }\n if (dx != 0 || dy != 0) {\n move_crane(crane, dx, dy);\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1 && grid[N - 1][N - 1] != -1 && cranes[i].holding == -1) {\n int cont = grid[N - 1][N - 1];\n occupied[N - 1][N - 1] = false;\n grid[N - 1][N - 1] = -1;\n }\n }\n}\n\nvector solve() {\n actions.resize(N);\n fill(grid.begin(), grid.end(), vector(N, -1));\n fill(occupied.begin(), occupied.end(), vector(N, false));\n cranes.resize(N);\n for (int i = 0; i < N; ++i) {\n cranes[i] = {i, 0, false, -1, i};\n actions[i].clear();\n }\n\n vector target;\n for (int i = 0; i < N * N; ++i) target.push_back(i);\n vector dispatch_order;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dispatch_order.push_back(i * N + j);\n\n int steps = 0;\n while (steps < 10000) {\n vector moves(N, string(1, '.'));\n bool progress = false;\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].holding != -1) continue;\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1) continue;\n int target_x = N - 1, target_y = N - 1;\n vector> path;\n int dx = 0, dy = 0;\n\n if (grid[cranes[i].x][cranes[i].y] != -1) {\n moves[i][steps] = 'P';\n progress = true;\n continue;\n }\n\n if (cranes[i].x == target_x && cranes[i].y == target_y) {\n continue;\n }\n\n int nx = cranes[i].x, ny = cranes[i].y;\n while (nx != target_x || ny != target_y) {\n int best = -1;\n for (int d = 0; d < 4; ++d) {\n int nx2 = nx + directions[d].first;\n int ny2 = ny + directions[d].second;\n if (!is_valid(nx2, ny2)) continue;\n if (occupied[nx2][ny2] && grid[nx2][ny2] != -1) continue;\n if (d == 0 && ny == N - 1) continue;\n if (d == 1 && nx == N - 1) continue;\n if (d == 2 && ny == 0) continue;\n if (d == 3 && nx == 0) continue;\n best = d;\n break;\n }\n if (best == -1) break;\n path.emplace_back(nx, ny);\n nx += directions[best].first;\n ny += directions[best].second;\n }\n if (!path.empty()) {\n moves[i][steps] = dir_char[directions[best].first == 1 ? 1 :\n directions[best].second == 1 ? 0 :\n directions[best].first == -1 ? 3 : 2];\n progress = true;\n }\n }\n\n vector current_moves = moves;\n simulate_turn(current_moves);\n for (int i = 0; i < N; ++i)\n actions[i].push_back(current_moves[i].back());\n\n if (!progress) break;\n steps++;\n }\n\n return actions;\n}\n\nint main() {\n cin >> N;\n A = vector>(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 grid = vector>(N, vector(N, -1));\n occupied = vector>(N, vector(N, false));\n\n auto result = solve();\n for (const auto& s : result)\n cout << s << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\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 vector> changes; // (i, j, delta)\n vector> current_h = h;\n\n vector> operations;\n\n int di[] = {1, -1, 0, 0};\n int dj[] = {0, 0, 1, -1};\n vector dir = {\"D\", \"U\", \"R\", \"L\"};\n\n auto manhattan = [](int i1, int j1, int i2, int j2) {\n return abs(i1 - i2) + abs(j1 - j2);\n };\n\n auto get_best_target = [&](int current_i, int current_j, int current_load) -> tuple {\n int best_i = -1, best_j = -1, best_val = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int val = abs(current_h[i][j]);\n if (val == 0) continue;\n int dist = manhattan(current_i, current_j, i, j);\n if (best_i == -1 || val > best_val) {\n best_val = val;\n best_i = i;\n best_j = j;\n } else if (val == best_val) {\n if (dist < manhattan(best_i, best_j, current_i, current_j)) {\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n if (best_i == -1) return {-1, -1, 0, 0};\n int needed = current_h[best_i][best_j];\n if (needed > 0) {\n return {best_i, best_j, 1, needed};\n } else {\n return {best_i, best_j, -1, -needed};\n }\n };\n\n int current_i = 0, current_j = 0;\n int current_load = 0;\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 (current_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 auto [target_i, target_j, type, amount] = get_best_target(current_i, current_j, current_load);\n if (target_i == -1) break;\n\n vector> path;\n int steps = 0;\n while (true) {\n if (current_i == target_i && current_j == target_j) break;\n for (int d = 0; d < 4; ++d) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (ni == target_i && nj == target_j) {\n path.emplace_back(dir[d], 0);\n current_i = ni;\n current_j = nj;\n operations.emplace_back(dir[d]);\n steps++;\n break;\n }\n }\n if (steps > 0) break;\n }\n\n for (auto& [op, _] : path) {\n if (op == \"D\") {\n current_i++;\n } else if (op == \"U\") {\n current_i--;\n } else if (op == \"R\") {\n current_j++;\n } else if (op == \"L\") {\n current_j--;\n }\n }\n\n if (type == 1) {\n int d = min(amount, 10000000);\n current_load += d;\n current_h[current_i][current_j] -= d;\n operations.emplace_back(\u201c+\u201d + to_string(d));\n } else {\n int d = min(current_load, amount);\n current_load -= d;\n current_h[current_i][current_j] += d;\n operations.emplace_back(\u201c-\u201d + to_string(d));\n }\n }\n\n for (const auto& op : operations) {\n cout << op << endl;\n }\n return 0;\n}","ahc035":"#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, T;\n cin >> N >> M >> T;\n\n int seed_count = 2 * N * (N - 1);\n vector> seeds(seed_count, vector(M));\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n }\n\n vector total_values(seed_count);\n for (int i = 0; i < seed_count; ++i) {\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n\n for (int turn = 0; turn < T; ++turn) {\n vector> grid(N, vector(N));\n vector used(seed_count, false);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int best_index = -1;\n int best_value = -1;\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k] && total_values[k] > best_value) {\n best_value = total_values[k];\n best_index = k;\n }\n }\n grid[i][j] = best_index;\n used[best_index] = true;\n }\n }\n\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) cout << \" \";\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n vector> sources, targets;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (s[i][j] == '1') sources.emplace_back(i, j);\n if (t[i][j] == '1') targets.emplace_back(i, j);\n }\n \n // Design tree: linear chain of length min(V, something reasonable)\n int Vp = min(V, 2); // Use just 2 vertices: root and one fingertip\n cout << Vp << \"\\n\";\n if (Vp > 1) cout << \"0 1\\n\";\n \n // Initial position of root\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n // Precompute directions: assume fingertip is to the right of root\n // We'll move around and rotate as needed\n \n // Simple strategy: move to each source, grab, move to target, release\n // We'll simulate positions and orientations\n \n struct Pos { int x, y; };\n struct State {\n Pos root;\n int dir; // direction of edge from root to child: 0=R,1=D,2=L,3=U\n vector fingertips; // positions of fingertips relative to root\n };\n \n State st;\n st.root = {0, 0};\n st.dir = 0; // right\n if (Vp >= 2) {\n st.fingertips.push_back({st.root.x + 1, st.root.y}); // child at (1,0)\n }\n \n // Precompute all moves\n vector moves;\n \n for (int i = 0; i < M; ++i) {\n // Move to source i\n auto [sx, sy] = sources[i];\n // First, move root close to source\n int dx = sx - st.root.x;\n int dy = sy - st.root.y;\n // Move root to (sx, st.root.y) then adjust y\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\"; // no rotate\n op += \".\\n\"; // no action for fingertip\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Now root is at (sx, st.root.y), need to align fingertip to (sx, sy)\n dx = sy - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dx > 0) ? 1 : -1;\n st.fingertips[0].y += (dx > 0) ? 1 : -1;\n }\n \n // Rotate to make fingertip point to the source\n // Currently fingertip is at (root.x+1, root.y) if dir=0\n // We want it to point to (sx, sy). Since we are already at (sx, sy) for root, just grab\n // Grab\n string op;\n op += \".\\n\"; // no move\n op += \".\\n\"; // no rotate\n op += \"P\\n\"; // grab\n moves.push_back(op);\n \n // Move to target i\n auto [tx, ty] = targets[i];\n dx = tx - st.root.x;\n dy = ty - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Release\n op = \".\\n.\\nP\\n\";\n moves.push_back(op);\n }\n \n // Output moves\n for (const auto& mv : moves) {\n cout << mv;\n }\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector mackerels(N), sardines(N);\n for (int i = 0; i < N; ++i) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n for (int i = 0; i < N; ++i) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n\n const int GRID_SIZE = 100;\n const int CELL_SIZE = 1000;\n vector> grid_score(GRID_SIZE, vector(GRID_SIZE, 0));\n\n for (const auto& p : mackerels) {\n int gx = p.x / CELL_SIZE;\n int gy = p.y / CELL_SIZE;\n if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {\n grid_score[gx][gy]++;\n }\n }\n\n for (const auto& p : sardines) {\n int gx = p.x / CELL_SIZE;\n int gy = p.y / CELL_SIZE;\n if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {\n grid_score[gx][gy]--;\n }\n }\n\n int best_gx = 0, best_gy = 0;\n int best_score = grid_score[0][0];\n for (int x = 0; x < GRID_SIZE; ++x) {\n for (int y = 0; y < GRID_SIZE; ++y) {\n if (grid_score[x][y] > best_score) {\n best_score = grid_score[x][y];\n best_gx = x;\n best_gy = y;\n }\n }\n }\n\n int min_x = best_gx * CELL_SIZE;\n int min_y = best_gy * CELL_SIZE;\n int max_x = (best_gx + 1) * CELL_SIZE - 1;\n int max_y = (best_gy + 1) * CELL_SIZE - 1;\n\n vector polygon = {\n Point(min_x, min_y),\n Point(max_x, min_y),\n Point(max_x, max_y),\n Point(min_x, max_y)\n };\n\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 \nusing namespace std;\n\n#include \n\nusing namespace cg3;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, T;\n double sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector> wh(N);\n for (int i = 0; i < N; ++i) {\n cin >> wh[i].first >> wh[i].second;\n }\n \n // Simulate true dimensions based on observed values and sigma\n vector> true_wh(N);\n default_random_engine gen;\n normal_distribution dist(0.0, sigma);\n for (int i = 0; i < N; ++i) {\n double dw = dist(gen);\n double dh = dist(gen);\n true_wh[i].first = max(1, static_cast(round(wh[i].first + dw)));\n true_wh[i].second = max(1, static_cast(round(wh[i].second + dh)));\n }\n \n vector> best placements.\n vector> current_placement;\n \n for (int t = 0; t < T; ++t) {\n vector> placement;\n vector> placed_rects;\n map used;\n \n if (t == 0) {\n // First turn: Place the largest rectangles greedily\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int a, int b) {\n return (true_wh[a].first * true_wh[a].second) > (true_wh[b].first * true_wh[b].second);\n });\n \n int rot0 = 0;\n rectangle2d rect0;\n if (rot0) {\n rect0 = rectangle2d(0, true_wh[0].second, true_wh[0].first, 0);\n } else {\n rect0 = rectangle2d(0, 0, true_wh[0].first, true_wh[0].second);\n }\n placement.emplace_back(indices[0], rot0, 'U', -1);\n placed_rects.push_back(rect0);\n used[indices[0]] = 0;\n \n for (int i = 1; i < N; ++i) {\n int idx = indices[i];\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n double best_score = 1e18;\n \n for (int rot : {0, 1}) {\n rectangle2d rect;\n if (rot) {\n rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, 0);\n } else {\n rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second);\n }\n \n for (char dir : {'U', 'L'}) {\n double score = 0.0;\n rectangle2d new_rect = rect;\n if (dir == 'U') {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(0, existing.y2());\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n } else {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(existing.x2(), 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n }\n }\n }\n \n if (best_dir == 'U') {\n if (best_b == -1) {\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, 0);\n } else {\n new_rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second);\n }\n placed_rects.push_back(new_rect);\n } else {\n rectangle2d existing = placed_rects[best_b];\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, existing.y2());\n } else {\n new_rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second + existing.y2());\n }\n new_rect.move(0, existing.y2());\n placed_rects.push_back(new_rect);\n }\n } else {\n if (best_b == -1) {\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, 0);\n } else {\n new_rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second);\n }\n new_rect.move(0, 0);\n placed_rects.push_back(new_rect);\n } else {\n rectangle2d existing = placed_rects[best_b];\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(existing.x2(), 0, true_wh[idx].first, true_wh[idx].second);\n } else {\n new_rect = rectangle2d(existing.x2(), 0, true_wh[idx].first, true_wh[idx].second);\n }\n placed_rects.push_back(new_rect);\n }\n }\n placement.emplace_back(idx, best_rot, best_dir, best_b);\n used[idx] = placement.size() - 1;\n }\n } else {\n // Simple greedy for subsequent turns\n placement.emplace_back(0, 0, 'U', -1);\n placed_rects.emplace_back(rectangle2d(0, 0, true_wh[0].first, true_wh[0].second));\n \n for (int i = 1; i < N; ++i) {\n int best_idx = i;\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n double best_score = 1e18;\n \n for (int rot : {0, 1}) {\n rectangle2d rect;\n if (rot) {\n rect = rectangle2d(0, true_wh[i].second, true_wh[i].first, 0);\n } else {\n rect = rectangle2d(0, 0, true_wh[i].first, true_wh[i].second);\n }\n \n for (char dir : {'U', 'L'}) {\n double score = 0.0;\n rectangle2d new_rect = rect;\n if (dir == 'U') {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(0, existing.y2());\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n } else {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(existing.x2(), 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n }\n }\n }\n \n placement.emplace_back(best_idx, best_rot, best_dir, best_b);\n if (best_dir == 'U') {\n if (best_b == -1) {\n placed_rects.emplace_back(rectangle2d(0, 0, true_wh[best_idx].first, true_wh[best_idx].second));\n } else {\n rectangle2d existing = placed_rects[best_b];\n placed_rects.emplace_back(rectangle2d(0, existing.y2(), true_wh[best_idx].first, true_wh[best_idx].second));\n }\n } else {\n if (best_b == -1) {\n placed_rects.emplace_back(rectangle2d(0, 0, true_wh[best_idx].first, true_wh[best_idx].second));\n } else {\n rectangle2d existing = placed_rects[best_b];\n placed_rects.emplace_back(rectangle2d(existing.x2(), 0, true_wh[best_idx].first, true_wh[best_idx].second));\n }\n }\n }\n }\n \n cout << placement.size() << \"\\n\";\n for (const auto& p : placement) {\n cout << get<0>(p) << \" \" << get<1>(p) << \" \" << get<2>(p) << \" \" << get<3>(p) << \"\\n\";\n }\n cout.flush();\n \n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n if (!cin) return 0;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n }\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n vector parent(N, -1);\n\n // Simple greedy: assign each node as root if it has high beauty\n // and try to build a tree of height <= H\n\n vector> adj(N);\n for (auto [u, v] : edges) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n vector visited(N, false);\n // For each node, try to be a root and build a BFS tree up to height H\n vector degree(N, 0);\n for (auto [u, v] : edges) {\n degree[u]++;\n degree[v]++;\n }\n\n // Choose roots as nodes with highest beauty and lowest degree\n vector> candidates;\n for (int i = 0; i < N; ++i) {\n candidates.emplace_back(-A[i] - degree[i], i);\n }\n sort(candidates.begin(), candidates.end());\n\n queue q;\n for (auto [_, i] : candidates) {\n if (visited[i]) continue;\n visited[i] = true;\n parent[i] = -1;\n q.push(i);\n int height = 0;\n vector level = {i};\n while (height < H && !level.empty()) {\n height++;\n vector next_level;\n for (int u : level) {\n for (int v : adj[u]) {\n if (!visited[v] && parent[v] == -1) {\n visited[v] = true;\n parent[v] = u;\n next_level.push_back(v);\n }\n }\n }\n level = next_level;\n }\n }\n\n // Fill any unassigned nodes (should not happen in valid input)\n for (int i = 0; i < N; ++i) {\n if (parent[i] == -1) {\n parent[i] = (i + 1) % N;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << '\\n';\n\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector> moves;\n\n auto add_moves = [&](int i, int j, bool is_row, bool left_or_up) {\n if (is_row) {\n if (left_or_up) {\n for (int k = 0; k <= j; ++k) {\n moves.emplace_back('L', i);\n }\n } else {\n for (int k = 0; k <= N - 1 - j; ++k) {\n moves.emplace_back('R', i);\n }\n }\n } else {\n if (left_or_up) {\n for (int k = 0; k <= i; ++k) {\n moves.emplace_back('U', j);\n }\n } else {\n for (int k = 0; k <= N - 1 - i; ++k) {\n moves.emplace_back('D', j);\n }\n }\n }\n };\n\n vector> removed(N, vector(N, false));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] != 'x') continue;\n bool can_left = true, can_right = true, can_up = true, can_down = true;\n for (int dj = 0; dj < j; ++dj) {\n if (board[i][dj] == 'o') {\n can_right = false;\n break;\n }\n }\n for (int dj = j + 1; dj < N; ++dj) {\n if (board[i][dj] == 'o') {\n can_left = false;\n break;\n }\n }\n for (int di = 0; di < i; ++di) {\n if (board[di][j] == 'o') {\n can_down = false;\n break;\n }\n }\n for (int di = i + 1; di < N; ++di) {\n if (board[di][j] == 'o') {\n can_up = false;\n break;\n }\n }\n\n if (can_left) {\n add_moves(i, j, true, true);\n removed[i][j] = true;\n } else if (can_right) {\n add_moves(i, j, true, false);\n removed[i][j] = true;\n } else if (can_up) {\n add_moves(i, j, false, true);\n removed[i][j] = true;\n } else if (can_down) {\n add_moves(i, j, false, false);\n removed[i][j] = true;\n }\n }\n }\n\n for (const auto& [d, p] : moves) {\n cout << d << \" \" << p << endl;\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\nvector t(N); // target times\nvector> assignments(N); // a_i, b_i for each employee\n\nvector simulate(const vector>& assign) {\n vector count(N, 0);\n int current = 0;\n int times = 0;\n count[0]++; // first week\n times = 1; // count for employee 0\n\n for (int week = 1; week < L; ++week) {\n if (times % 2 == 1) { // odd\n current = assign[current].first;\n } else { // even\n current = assign[current].second;\n }\n count[current]++;\n times++; // increment the count for the previous employee (current before update)\n }\n return count;\n}\n\nlong long calculate_error(const vector& actual) {\n long long error = 0;\n for (int i = 0; i < N; ++i) {\n error += abs(actual[i] - t[i]);\n }\n return error;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n int dummy_n, dummy_l;\n cin >> dummy_n >> dummy_l; // should be 100 and 500000\n for (int i = 0; i < N; ++i) {\n cin >> t[i];\n }\n\n // Initialize assignments: each employee points to themselves\n for (int i = 0; i < N; ++i) {\n assignments[i] = {i, i};\n }\n\n // Simulate initial assignments\n vector current_count = simulate(assignments);\n long long current_error = calculate_error(current_count);\n\n // Simple local search: try changing each employee's a and b to others\n mt19937 rng(0); // fixed seed for deterministic behavior\n for (int iter = 0; iter < 10000; ++iter) {\n int i = uniform_int_distribution(0, N-1)(rng);\n int a_candidate = uniform_int_distribution(0, N-1)(rng);\n int b_candidate = uniform_int_distribution(0, N-1)(rng);\n\n // Try new assignments for employee i\n pair old_assign = assignments[i];\n assignments[i] = {a_candidate, b_candidate};\n\n // Simulate\n vector new_count = simulate(assignments);\n long long new_error = calculate_error(new_count);\n\n if (new_error < current_error) {\n current_error = new_error;\n current_count = new_count;\n } else {\n assignments[i] = old_assign; // revert\n }\n }\n\n // Output the assignments\n for (const auto& p : assignments) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\n\n#define OVERRIDE 0\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy;\n};\n\n// Simple DBSCAN-like clustering based on center coordinates\nvector> clusterCities(const vector& cities, double eps = 200.0, int min_pts = 1) {\n int n = cities.size();\n vector visited(n, false);\n vector> clusters;\n\n for (int i = 0; i < n; ++i) {\n if (visited[i]) continue;\n visited[i] = true;\n queue q;\n q.push(i);\n vector cluster;\n\n cluster.push_back(i);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int nxt = 0; nxt < n; ++nxt) {\n if (visited[nxt]) continue;\n double dx = cities[cur].cx - cities[nxt].cx;\n double dy = cities[cur].cy - cities[nxt].cy;\n double dist = sqrt(dx*dx + dy*dy);\n if (dist <= eps) {\n visited[nxt] = true;\n q.push(nxt);\n cluster.push_back(nxt);\n }\n }\n }\n if (!cluster.empty()) {\n clusters.push_back(cluster);\n }\n }\n return clusters;\n}\n\n// Divide a cluster into groups of sizes specified in G\nvector> assignGroups(const vector& cluster, const vector& G, const vector& cities) {\n vector> groups;\n int n = cluster.size();\n int group_idx = 0;\n int start = 0;\n\n for (int g : G) {\n vector group;\n int end = start + g;\n if (end > n) {\n end = n;\n }\n for (int i = start; i < end; ++i) {\n group.push_back(cluster[i]);\n }\n groups.push_back(group);\n start = end;\n }\n return groups;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n vector cities(N);\n for (int i = 0; i < N; ++i) {\n 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 // Cluster cities based on center coordinates\n vector> clusters = clusterCities(cities);\n\n // Assign cities to groups\n vector> groups;\n vector group_sizes = G;\n\n // Try to assign groups from clusters\n for (const auto& cluster : clusters) {\n vector> cluster_groups = assignGroups(cluster, group_sizes, cities);\n for (const auto& g : cluster_groups) {\n if (g.empty()) continue;\n groups.push_back(g);\n // Decrease the corresponding group size\n for (size_t i = 0; i < group_sizes.size(); ++i) {\n if (group_sizes[i] >= (int)g.size()) {\n group_sizes[i] -= (int)g.size();\n break;\n }\n }\n }\n }\n\n // Handle remaining group sizes\n int remaining = N;\n for (const auto& g : groups) remaining -= g.size();\n if (remaining > 0) {\n // Add remaining cities to the last group\n if (!groups.empty()) {\n groups.back().resize(remaining + groups.back().size());\n } else {\n groups.push_back(vector(remaining));\n }\n }\n\n // Ensure we have exactly M groups\n while ((int)groups.size() < M) {\n groups.push_back({});\n }\n\n // Prepare queries for each group\n vector>> all_edges(M);\n\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n int sz = group.size();\n if (sz < 2) continue;\n\n // If group size is small enough, query the entire group\n if (sz <= L) {\n cout << \"? \" << sz;\n for (int id : group) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int i = 0; i < sz - 1; ++i) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n } else {\n // Break into subsets of size L\n for (int i = 0; i < sz; i += L - 1) {\n int subset_size = min(L, sz - i);\n if (subset_size < 2) break;\n\n vector subset;\n for (int j = i; j < i + subset_size; ++j) {\n subset.push_back(group[j]);\n }\n\n cout << \"? \" << subset_size;\n for (int id : subset) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int j = 0; j < subset_size - 1; ++j) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n }\n }\n }\n\n // Output the answer\n cout << \"!\" << endl;\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n cout << group.size();\n for (int id : group) cout << \" \" << id;\n cout << endl;\n\n // Output edges for this group\n for (const auto& edge : all_edges[k]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> targets(M);\n for (int i = 0; i < M; ++i) {\n cin >> targets[i].first >> targets[i].second;\n }\n\n vector> actions;\n\n // Example strategy: move to each target directly, ignoring blocks for simplicity\n // This is a placeholder and will not solve the problem correctly but serves as a starting point.\n // In a real submission, you would implement a more sophisticated pathfinding algorithm.\n\n pair current = targets[0];\n for (int i = 1; i < M; ++i) {\n int dx = targets[i].first - current.first;\n int dy = targets[i].second - current.second;\n\n if (dx > 0) {\n for (int j = 0; j < dx; ++j) {\n actions.emplace_back('M', \"D\");\n }\n } else if (dx < 0) {\n for (int j = 0; j < -dx; ++j) {\n actions.emplace_back('M', \"U\");\n }\n }\n\n if (dy > 0) {\n for (int j = 0; j < dy; ++j) {\n actions.emplace_back('M', \"R\");\n }\n } else if (dy < 0) {\n for (int j = 0; j < -dy; ++j) {\n actions.emplace_back('M', \"L\");\n }\n }\n current = targets[i];\n }\n\n for (auto& [a, d] : actions) {\n cout << a << \" \" << d << endl;\n }\n\n return 0;\n}"},"2":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2;\n long long area() const { return (long long)(x2 - x1) * (y2 - y1); }\n bool contains(double x, double y) const {\n return x > x1 && x < x2 && y > y1 && y < y2;\n }\n};\n\nint n;\nvector> input;\nvector rects;\nvector r_desired;\nvector> desired_points;\n\ndouble satisfaction(int i, const Rect& r) {\n double x = get<0>(input[i]) + 0.5, y = get<1>(input[i]) + 0.5;\n if (!r.contains(x, y)) return 0.0;\n long long s = r.area();\n long long r_val = get<2>(input[i]);\n double ratio = min(r_val, (long long)s) * 1.0 / max(r_val, (long long)s);\n return 1.0 - pow(1.0 - ratio, 2.0);\n}\n\ndouble total_satisfaction() {\n double total = 0.0;\n for (int i = 0; i < n; ++i) {\n total += satisfaction(i, rects[i]);\n }\n return total;\n}\n\nbool intersects(const Rect& a, const Rect& b) {\n return !(a.x2 <= b.x1 || a.x1 >= b.x2 || a.y2 <= b.y1 || a.y1 >= b.y2);\n}\n\nvoid init_rects() {\n rects.clear();\n for (int i = 0; i < n; ++i) {\n int x = get<0>(input[i]), y = get<1>(input[i]);\n int r = get<2>(input[i]);\n int half = max(1, (int)sqrt(r));\n rects.push_back({x, y, x + half, y + half});\n }\n}\n\nbool expand_rect(int i, int dx, int dy) {\n Rect& r = rects[i];\n Rect new_r = {r.x1 - dx, r.y1 - dy, r.x2 + dx, r.y2 + dy};\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n return false;\n }\n }\n if (new_r.x1 < 0 || new_r.y1 < 0 || new_r.x2 > 10000 || new_r.y2 > 10000) {\n return false;\n }\n rects[i] = new_r;\n return true;\n}\n\nvoid greedy_expansion() {\n for (int iter = 0; iter < 1000; ++iter) {\n for (int i = 0; i < n; ++i) {\n int dx = 1, dy = 1;\n while (expand_rect(i, dx, dy)) {\n dx++;\n dy++;\n }\n }\n }\n}\n\ndouble simulated_annealing(double T, double alpha, int steps) {\n double best_score = total_satisfaction();\n vector best_rects = rects;\n\n for (int step = 0; step < steps; ++step) {\n int i = rand() % n;\n int dx = (rand() % 5) - 2;\n int dy = (rand() % 5) - 2;\n\n Rect old_r = rects[i];\n Rect new_r = {old_r.x1 + dx, old_r.y1 + dy, old_r.x2 + dx, old_r.y2 + dy};\n\n bool valid = true;\n if (new_r.x1 < 0 || new_r.x1 >= 10000 || new_r.x2 < 0 || new_r.x2 >= 10000 ||\n new_r.y1 < 0 || new_r.y1 >= 10000 || new_r.y2 < 0 || new_r.y2 >= 10000) {\n valid = false;\n } else {\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n valid = false;\n break;\n }\n }\n }\n\n if (!valid) {\n swap(new_r, old_r);\n }\n\n double old_score = satisfaction(i, old_r);\n double new_score = satisfaction(i, new_r);\n double delta = new_score - old_score;\n\n if (delta > 0 || exp(delta / T) > (double)rand() / RAND_MAX) {\n rects[i] = new_r;\n } else {\n rects[i] = old_r;\n }\n\n double current_score = total_satisfaction();\n if (current_score > best_score) {\n best_score = current_score;\n best_rects = rects;\n }\n\n T *= alpha;\n }\n\n rects = best_rects;\n return best_score;\n}\n\nint main() {\n srand(time(nullptr));\n cin >> n;\n input.resize(n);\n r_desired.resize(n);\n desired_points.resize(n);\n\n for (int i = 0; i < n; ++i) {\n int x, y, r;\n cin >> x >> y >> r;\n input[i] = {x, y, r};\n desired_points[i] = {x + 0.5, y + 0.5};\n r_desired[i] = r;\n }\n\n init_rects();\n greedy_expansion();\n\n double T = 10000.0;\n double alpha = 0.99;\n int steps = 100000;\n\n simulated_annealing(T, alpha, steps);\n\n for (const auto& r : rects) {\n cout << r.x1 << \" \" << r.y1 << \" \" << r.x2 << \" \" << r.y2 << endl;\n }\n\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj;\n cin >> si >> sj;\n \n vector> t(50, vector(50));\n vector> p(50, vector(50));\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n }\n }\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> p[i][j];\n }\n }\n \n // Identify tiles: map from tile id to list of positions\n map>> tiles;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n tiles[t[i][j]].emplace_back(i, j);\n }\n }\n \n // For each tile, check if it's horizontal or vertical\n // and store the positions in a sorted manner\n vector>> tilePositions;\n tilePositions.reserve(tiles.size());\n for (auto &entry : tiles) {\n auto &posList = entry.second;\n sort(posList.begin(), posList.end());\n tilePositions.push_back(set>(posList.begin(), posList.end()));\n }\n \n // Create a map from position to tile index\n vector> posToTile(50, vector(50, -1));\n for (size_t ti = 0; ti < tilePositions.size(); ++ti) {\n for (auto &pos : tilePositions[ti]) {\n posToTile[pos.first][pos.second] = ti;\n }\n }\n \n // Directions: up, down, left, right\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n vector dirChar = {'U', 'D', 'L', 'R'};\n \n // BFS to find a path\n vector> visited(50, vector(50, false));\n vector> path(50, vector(50, '\\0'));\n queue> q;\n \n q.emplace(si, sj);\n visited[si][sj] = true;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (size_t d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited[ni][nj]) continue;\n \n // Check if the new position is on the same tile as the current one\n if (posToTile[i][j] == posToTile[ni][nj]) continue;\n \n visited[ni][nj] = true;\n path[ni][nj] = dirChar[d];\n q.emplace(ni, nj);\n }\n }\n \n // Reconstruct the path from si, sj to the furthest point\n string output;\n pair current = {si, sj};\n while (true) {\n bool found = false;\n for (size_t d = 0; d < 4; ++d) {\n int ni = current.first + dirs[d].first;\n int nj = current.second + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (path[ni][nj] == '\\0') continue;\n // Check tile uniqueness\n if (posToTile[current.first][current.second] == posToTile[ni][nj]) continue;\n output += dirChar[d];\n current = {ni, nj};\n found = true;\n break;\n }\n if (!found) break;\n }\n \n cout << output << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint H, W; // 30x30 grid\nvector> h_est, v_est; // estimated horizontal and vertical edge weights\nvector> h_cnt, v_cnt; // count of usage for each edge\n\nvector dirs = {\"U\", \"D\", \"L\", \"R\"};\n\n// BFS to generate a path\nstring bfs_path(int si, int sj, int ti, int tj) {\n vector> dist(H, vector(W, -1));\n vector> prev(H, vector

(W, {-1, -1}));\n queue

q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break;\n vector

ns;\n if (i > 0) ns.emplace_back(i-1, j);\n if (i < H-1) ns.emplace_back(i+1, j);\n if (j > 0) ns.emplace_back(i, j-1);\n if (j < W-1) ns.emplace_back(i, j+1);\n for (auto [ni, nj] : ns) {\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n q.emplace(ni, nj);\n }\n }\n }\n if (dist[ti][tj] == -1) return \"\";\n string path;\n P cur = {ti, tj};\n while (cur != P(si, sj)) {\n P p = prev[cur.first][cur.second];\n int di = cur.first - p.first;\n int dj = cur.second - p.second;\n if (di == -1) path += 'U';\n else if (di == 1) path += 'D';\n else if (dj == -1) path += 'L';\n else if (dj == 1) path += 'R';\n cur = p;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Random walk to generate a path\nstring random_walk(int si, int sj, int ti, int tj, int max_steps) {\n string path;\n int i = si, j = sj;\n while (max_steps-- > 0 && (i != ti || j != tj)) {\n vector possible;\n if (i > 0) possible.push_back('U');\n if (i < H-1) possible.push_back('D');\n if (j > 0) possible.push_back('L');\n if (j < W-1) possible.push_back('R');\n char move = possible[rand() % possible.size()];\n path += move;\n if (move == 'U') i--;\n else if (move == 'D') i++;\n else if (move == 'L') j--;\n else if (move == 'R') j++;\n }\n return path;\n}\n\n// Estimate edge weight from observed lengths\ndouble estimate_edge_weight(int i, int j, char dir) {\n if (dir == 'L' || dir == 'R') {\n if (h_cnt[i][j] == 0) return 1500.0;\n return h_est[i][j] * 1.0 / h_cnt[i][j];\n } else {\n if (v_cnt[i][j] == 0) return 1500.0;\n return v_est[i][j] * 1.0 / v_cnt[i][j];\n }\n}\n\nint main() {\n H = 30, W = 30;\n h_est.assign(H, vector(W, 0));\n v_est.assign(H, vector(W, 0));\n h_cnt.assign(H, vector(W, 0));\n v_cnt.assign(H, vector(W, 0));\n \n srand(time(nullptr));\n \n int query_count = 0;\n while (true) {\n int si, sj, ti, tj;\n if (query_count == 0) {\n cin >> si >> sj >> ti >> tj;\n } else {\n // Read the previous result (b_k)\n ll b_prev;\n cin >> b_prev;\n // Update the estimates based on the path taken in the previous query\n // This is a placeholder; actual implementation would track the path\n }\n \n // Generate multiple candidate paths\n string path1 = bfs_path(si, sj, ti, tj);\n string path2 = random_walk(si, sj, ti, tj, abs(si - ti) + abs(sj - tj) * 2);\n string path3 = random_walk(si, sj, ti, tj, abs(si - ti) * 2 + abs(sj - tj));\n \n vector candidates = {path1, path2, path3};\n if (candidates[0].empty()) candidates.erase(candidates.begin());\n \n // Select a path based on estimated weights\n double scores[3] = {0.0};\n for (int idx = 0; idx < candidates.size(); idx++) {\n string& p = candidates[idx];\n double score = 0.0;\n int pi = si, pj = sj;\n for (char c : p) {\n if (c == 'U' || c == 'D') {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n } else {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n scores[idx] = 1.0 / score;\n }\n \n // Choose the best candidate\n double max_score = -1.0;\n int best_idx = 0;\n for (int idx = 0; idx < candidates.size(); idx++) {\n if (scores[idx] > max_score) {\n max_score = scores[idx];\n best_idx = idx;\n }\n }\n \n string path = candidates[best_idx];\n \n // Output the path\n cout << path << endl;\n cout.flush();\n \n // Read the result (b_k)\n ll b_k;\n cin >> b_k;\n \n // Update estimates based on the path taken\n int pi = si, pj = sj;\n for (char c : path) {\n if (c == 'L' || c == 'R') {\n h_est[pi][pj] += b_k; // placeholder update\n h_cnt[pi][pj]++;\n } else {\n v_est[pi][pj] += b_k;\n v_cnt[pi][pj]++;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n \n query_count++;\n }\n \n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 20;\n int M;\n cin >> N >> M;\n vector strings(M);\n for (int i = 0; i < M; ++i) {\n cin >> strings[i];\n }\n\n // Sort strings by length in descending order\n sort(strings.begin(), strings.end(), [](const string& a, const string& b) {\n return a.size() > b.size();\n });\n\n vector> matrix(N, vector(N, '.'));\n\n for (const auto& s : strings) {\n int len = s.size();\n bool placed = false;\n\n // Try horizontal placement\n for (int i = 0; i < N && !placed; ++i) {\n for (int j = 0; j <= N - len && !placed; ++j) {\n bool can_place = true;\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % N;\n if (matrix[i][col] != '.' && matrix[i][col] != s[k]) {\n can_place = false;\n break;\n }\n }\n if (can_place) {\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % N;\n matrix[i][col] = s[k];\n }\n placed = true;\n }\n }\n }\n\n // Try vertical placement\n if (!placed) {\n for (int j = 0; j < N && !placed; ++j) {\n for (int i = 0; i <= N - len && !placed; ++i) {\n bool can_place = true;\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % N;\n if (matrix[row][j] != '.' && matrix[row][j] != s[k]) {\n can_place = false;\n break;\n }\n }\n if (can_place) {\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % N;\n matrix[row][j] = s[k];\n }\n placed = true;\n }\n }\n }\n }\n }\n\n // Minimize empty cells by filling with a default character (e.g., 'A')\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] == '.') {\n matrix[i][j] = 'A'; // Choose a character that is least likely to conflict\n }\n }\n }\n\n // Output the matrix\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << matrix[i][j];\n }\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector> time(N, vector(N, 0));\n vector> is_road(N, vector(N, false));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n is_road[i][j] = true;\n time[i][j] = grid[i][j] - '0';\n }\n }\n }\n \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.emplace_back(i, j);\n }\n }\n }\n \n vector directions = {\"U\", \"D\", \"L\", \"R\"};\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n \n vector>> adjacency(N, vector>(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 for (int d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && is_road[ni][nj]) {\n adjacency[i][j].emplace_back(ni, nj);\n }\n }\n }\n }\n \n vector path;\n set> visited;\n vector> seen(N, vector(N, false));\n \n function dfs = [&](int i, int j) {\n stack> st;\n st.emplace(i, j);\n visited.insert({i, j});\n seen[i][j] = true;\n vector> points = {i, j};\n \n while (!st.empty()) {\n auto [x, y] = st.top();\n st.pop();\n points.push_back({x, y});\n for (auto [nx, ny] : adjacency[x][y]) {\n if (!seen[nx][ny]) {\n seen[nx][ny] = true;\n st.emplace(nx, ny);\n }\n }\n }\n \n for (auto [x, y] : points) {\n path.push_back(\"D\");\n }\n };\n \n dfs(si, sj);\n \n string result;\n int curr_i = si, curr_j = sj;\n for (char move : path) {\n int di = 0, dj = 0;\n if (move == 'U') di = -1;\n if (move == 'D') di = 1;\n if (move == 'L') dj = -1;\n if (move == 'R') dj = 1;\n curr_i += di;\n curr_j += dj;\n result += move;\n }\n \n cout << result << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct Task {\n vector d; // required skills\n vector deps; // dependencies\n int index;\n int earliest_start_day = 0; // Earliest possible start day based on dependencies\n int assigned_to = -1; // Which team member is assigned (-1 if not assigned)\n int start_day = -1; // Actual start day (-1 if not started)\n int completion_day = -1; // Completion day (-1 if not completed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].d.resize(K);\n for (int j = 0; j < K; ++j) {\n cin >> tasks[i].d[j];\n }\n tasks[i].index = i;\n }\n\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].deps.push_back(u);\n }\n\n // Build adjacency list for dependency graph\n vector> dep_graph(N);\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int dep : tasks[i].deps) {\n dep_graph[dep].push_back(i);\n in_degree[i]++;\n }\n }\n\n // Initial skill estimates for each team member (initialized to zero)\n vector> skillestimates(M, vector(K, 0.0));\n\n // Track completion times for each team member (for skill update)\n vector completion_times(M, 0.0); // Cumulative completion time\n vector task_count(M, 0); // Number of tasks completed by each member\n\n // Track which team members are busy (assigned a task)\n vector busy(M, false);\n\n // Track completed tasks\n vector completed(N, false);\n\n // Track available tasks (tasks with all dependencies completed)\n queue available_tasks;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n available_tasks.push(i);\n }\n }\n\n // Process days until all tasks are completed or day 2000\n for (int day = 1; day <= 2000; ++day) {\n // Collect tasks to assign today\n vector> assignments;\n\n // For each available team member, assign the \"best\" available task\n for (int member = 0; member < M; ++member) {\n if (busy[member]) continue; // Skip if busy\n\n // Find the best task for this member from available tasks\n int best_task = -1;\n double min_estimated_time = INFINITY;\n // We need to consider tasks that are available and not completed\n // For simplicity, we'll iterate through all tasks and check if available\n for (int t = 0; t < N; ++t) {\n if (completed[t]) continue;\n if (in_degree[t] > 0) continue; // Not available yet\n\n // Estimate time for this member to do this task\n double w = 0.0;\n for (int k = 0; k < K; ++k) {\n w += max(0.0, tasks[t].d[k] - skillestimates[member][k]);\n }\n double estimated_time = (w == 0) ? 1.0 : max(1.0, w + uniform_real_distribution(-3.0, 3.0).operator()());\n\n if (estimated_time < min_estimated_time) {\n min_estimated_time = estimated_time;\n best_task = t;\n }\n }\n\n if (best_task != -1) {\n assignments.emplace_back(member, best_task);\n busy[member] = true;\n tasks[best_task].assigned_to = member;\n tasks[best_task].start_day = day;\n }\n }\n\n // Output assignments\n cout << assignments.size();\n for (auto& [member, task] : assignments) {\n cout << \" \" << member + 1 << \" \" << task + 1;\n }\n cout << endl;\n cout.flush();\n\n // Read input: either -1 or list of completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n\n vector completed_members;\n for (int i = 0; i < n_completed; ++i) {\n int member;\n cin >> member;\n member--;\n completed_members.push_back(member);\n }\n\n // Update skill estimates and mark tasks as completed\n for (int member : completed_members) {\n if (busy[member]) {\n // Find which task this member completed\n for (int t = 0; t < N; ++t) {\n if (tasks[t].assigned_to == member && tasks[t].completion_day == -1) {\n // Assume we get the actual completion time from the problem, but here we simulate\n // For real submission, we don't have actual time, so we cannot update skills.\n // In a real scenario, we would need to get actual completion time from the judge.\n // Since we don't have it, we skip skill update for now.\n tasks[t].completion_day = day;\n completed[t] = true;\n busy[member] = false;\n\n // Update dependency graph: this task's dependents may now be available\n for (int next_task : dep_graph[t]) {\n in_degree[next_task]--;\n if (in_degree[next_task] == 0) {\n available_tasks.push(next_task);\n }\n }\n break;\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int a, b, c, d;\n Order(int a_=0, int b_=0, int c_=0, int d_=0) : a(a_), b(b_), c(c_), d(d_) {}\n};\n\n// Manhattan distance\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Heuristic: Choose orders that are close to the center and have short total distance\nvector select_orders(const vector& orders) {\n vector> scores;\n for(int i = 0; i < orders.size(); i++) {\n const auto& o = orders[i];\n int dist_to_center = dist(o.a, o.b, 400, 400) + dist(o.c, o.d, 400, 400);\n int dist_total = dist(o.a, o.b, o.c, o.d);\n scores.emplace_back(dist_to_center + dist_total, i);\n }\n sort(scores.begin(), scores.end());\n vector selected;\n for(int i = 0; i < 50; i++) {\n selected.push_back(scores[i].second);\n }\n return selected;\n}\n\nvector> construct_route(const vector& orders, const vector& selected) {\n vector> route;\n route.emplace_back(400, 400); // Start at center\n \n for(int idx : selected) {\n const auto& o = orders[idx];\n route.emplace_back(o.a, o.b); // Go to pickup\n route.emplace_back(o.c, o.d); // Then to delivery\n }\n \n // Return to center at the end\n route.emplace_back(400, 400);\n return route;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read all orders\n vector orders(1000);\n for(int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n orders[i] = Order(a, b, c, d);\n }\n \n // Select 50 orders based on heuristic\n vector selected = select_orders(orders);\n \n // Construct route\n vector> route = construct_route(orders, selected);\n \n // Output\n cout << \"50\";\n for(int idx : selected) cout << \" \" << (idx+1);\n cout << \"\\n\" << route.size();\n for(auto [x,y] : route) cout << \" \" << x << \" \" << y;\n cout << endl;\n \n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\nint round_sqrt(long long x) {\n long long s = sqrt(x);\n if ((s + 1) * (s + 1) <= x) s++;\n return (int)s;\n}\n\nint distance(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return round_sqrt(dx * dx + dy * dy);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 400, M = 1995;\n vector points(N);\n vector> edges(M);\n\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n int u = edges[i].first, v = edges[i].second;\n d[i] = distance(points[u], points[v]);\n }\n\n vector added(M, false);\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n \n function find = [&](int u) {\n while (parent[u] != u) {\n parent[u] = parent[parent[u]];\n u = parent[u];\n }\n return u;\n };\n\n auto unite = [&](int u, int v) {\n u = find(u);\n v = find(v);\n if (u == v) return false;\n parent[v] = u;\n return true;\n };\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n int u = edges[i].first, v = edges[i].second;\n if (unite(u, v)) {\n cout << \"1\\n\";\n added[i] = true;\n } else {\n cout << \"0\\n\";\n }\n cout.flush();\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N;\n vector> pets(N);\n for (int i = 0; i < N; ++i) {\n int x, y, t;\n cin >> x >> y >> t;\n pets[i] = {x - 1, y - 1, t};\n }\n cin >> M;\n vector> humans(M);\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n humans[i] = {x - 1, y - 1};\n }\n\n vector> grid(30, vector(30, false));\n vector> blocked(30, vector(30, false));\n for (auto [x, y, _] : pets) grid[x][y] = true;\n for (auto [x, y] : humans) grid[x][y] = true;\n\n for (int turn = 0; turn < 300; ++turn) {\n string action;\n for (int i = 0; i < M; ++i) {\n int x = humans[i].first;\n int y = humans[i].second;\n\n vector> moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n vector dirs = {'D', 'U', 'R', 'L'};\n int best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n humans[i] = {moves[best].first, moves[best].second};\n grid[x][y] = false;\n grid[moves[best].first][moves[best].second] = true;\n } else {\n moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n dirs = {'r', 'l', 'd', 'u'};\n best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n blocked[moves[best].first][moves[best].second] = true;\n } else {\n action += '.';\n }\n }\n }\n cout << action << endl;\n cout.flush();\n\n string pet_moves;\n for (int i = 0; i < N; ++i) pet_moves += '.';\n cin >> pet_moves;\n for (int i = 0; i < N; ++i) {\n auto [x, y, type] = pets[i];\n if (pet_moves[i] != '.') {\n char move = pet_moves[i];\n if (move == 'U') x--;\n else if (move == 'D') x++;\n else if (move == 'L') y--;\n else if (move == 'R') y++;\n pets[i] = {x, y, type};\n grid[x][y] = true;\n }\n }\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n cout << \"R\" << endl;\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Direction transition table: to[tile][enter_dir] = exit_dir or -1\nint 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\nvector> grid(30, vector(30));\nvector> rotation(30, vector(30, 0));\n\nint computeLength(int si, int sj, int sd, const vector>& rot) {\n int i = si, j = sj;\n int d = sd;\n int length = 0;\n vector> visited(30, vector(30, -1));\n int visit_id = abs(hash>(rot)) % 1000; // Just a dummy unique\n\n while (true) {\n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n int tile = grid[i][j] + 4 * rotation[i][j];\n d = to[tile][d];\n if (d == -1) return 0;\n int ni = i + di[d];\n int nj = j + dj[d];\n d = (d + 2) % 4;\n length++;\n if (ni == si && nj == sj && d == sd) {\n return length;\n }\n if (visited[i][j] == visit_id) {\n // Detect cycle but not closed properly\n return 0;\n }\n visited[i][j] = visit_id;\n i = ni;\n j = nj;\n }\n}\n\npair getTwoMaxLengths(const vector>& rot) {\n priority_queue pq;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int len = computeLength(i, j, d, rot);\n if (len > 0) pq.push(len);\n }\n }\n }\n if (pq.size() < 2) {\n return {0, 0};\n }\n int max1 = pq.top(); pq.pop();\n int max2 = pq.top(); pq.pop();\n return {max1, max2};\n}\n\nint score(const vector>& rot) {\n auto [l1, l2] = getTwoMaxLengths(rot);\n if (l1 == 0 || l2 == 0) return 0;\n return l1 * l2;\n}\n\nvector> rotateRandom() {\n vector> rot(30, vector(30));\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rot[i][j] = rand() % 4;\n }\n }\n return rot;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cin >> grid[i][j];\n }\n }\n\n // Initialize with random rotations\n vector> best_rot = rotateRandom();\n int best_score = score(best_rot);\n\n // Simple hill climbing\n const int iterations = 2000;\n for (int iter = 0; iter < iterations; iter++) {\n // Pick a random tile\n int i = rand() % 30;\n int j = rand() % 30;\n int old_rot = best_rot[i][j];\n for (int delta = 1; delta <= 3; delta++) {\n int new_rot = (old_rot + delta) % 4;\n best_rot[i][j] = new_rot;\n int current_score = score(best_rot);\n if (current_score > best_score) {\n best_score = current_score;\n } else {\n best_rot[i][j] = old_rot;\n }\n }\n }\n\n // Output the best rotations found\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n if (j < 29) cout << \" \";\n }\n cout << endl;\n }\n\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint N;\nvector board;\nmap hex_to_int = {\n {'0', 0}, {'1', 1}, {'2', 2}, {'3', 3},\n {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7},\n {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11},\n {'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}\n};\n\nint int_to_dir(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 -1;\n}\n\nchar dir_to_char(int d) {\n if (d == 0) return 'U';\n if (d == 1) return 'D';\n if (d == 2) return 'L';\n if (d == 3) return 'R';\n return 'X';\n}\n\nbool is_valid(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n}\n\nint get_bit(int mask, int pos) {\n return (mask >> pos) & 1;\n}\n\nint get_connection(int i, int j, int dir) {\n int mask = hex_to_int[board[i][j]];\n if (dir == 0) return get_bit(mask, 1); // up\n if (dir == 1) return get_bit(mask, 3); // down\n if (dir == 2) return get_bit(mask, 0); // left\n if (dir == 3) return get_bit(mask, 2); // right\n return 0;\n}\n\nvector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n\npair move_empty(int i, int j, int dir) {\n int ni = i + dirs[dir].first;\n int nj = j + dirs[dir].second;\n if (!is_valid(ni, nj) || board[ni][nj] == '0') return {-1, -1};\n return {ni, nj};\n}\n\nint count_components() {\n vector> visited(N, vector(N, false));\n int components = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == '0') continue;\n if (!visited[i][j]) {\n components++;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n int mask = hex_to_int[board[x][y]];\n for (int d = 0; d < 4; ++d) {\n if (get_connection(x, y, d)) {\n int nx = x + dirs[d].first, ny = y + dirs[d].second;\n if (is_valid(nx, ny) && board[nx][ny] != '0' && !visited[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n }\n }\n }\n return components;\n}\n\nvector solve() {\n int empty_i = -1, empty_j = -1;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == '0') {\n empty_i = i;\n empty_j = j;\n }\n vector result;\n vector> history;\n history.emplace_back(empty_i, empty_j);\n\n for (int step = 0; step < 2 * N * N * N; ++step) {\n int best_components = count_components();\n char best_move = 0;\n vector> best_pos = {empty_i, empty_j};\n\n for (int d = 0; d < 4; ++d) {\n auto [ni, nj] = move_empty(empty_i, empty_j, d);\n if (ni == -1) continue;\n swap(board[empty_i][empty_j], board[ni][nj]);\n int components = count_components();\n swap(board[empty_i][empty_j], board[ni][nj]);\n\n if (components < best_components) {\n best_components = components;\n best_move = dir_to_char(d);\n best_pos = {ni, nj};\n }\n }\n\n if (best_move == 0) break;\n\n result.push_back(best_move);\n swap(board[empty_i][empty_j], board[best_pos.first][best_pos.second]);\n empty_i = best_pos.first;\n empty_j = best_pos.second;\n history.emplace_back(empty_i, empty_j);\n }\n\n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n int T = 2 * N * N * N;\n board.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n auto result = solve();\n\n cout << string(result.begin(), result.end()) << endl;\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\n// Define Point structure\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n \n // Overload equality operator for Point\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\n// Compute cross product of vectors (p1 - o) and (p2 - o)\nlong long cross(const Point& o, const Point& p1, const Point& p2) {\n return (long long)(p1.x - o.x) * (p2.y - o.y) - (long long)(p1.y - o.y) * (p2.x - o.x);\n}\n\n// Check if point p is on the left side of the directed line (a, b)\nbool isLeft(const Point& a, const Point& b, const Point& p) {\n return cross(a, b, p) > 0;\n}\n\n// Compute orientation of three points (clockwise, counterclockwise, or collinear)\nint orientation(const Point& p, const Point& q, const Point& r) {\n long long val = (long long)(q.y - p.y) * (r.x - q.x) - (long long)(q.x - p.x) * (r.y - q.y);\n if (val == 0) return 0; // Collinear\n return (val > 0) ? 1 : 2; // Clockwise or Counterclockwise\n}\n\n// Compute Euclidean distance squared between two points\nlong long dist(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\n// Graham scan to compute convex hull\nvector convexHull(vector points) {\n int n = points.size();\n if (n <= 1) return points;\n\n // Find the lowest point\n int i = 0;\n for (int j = 1; j < n; j++)\n if (points[j].y < points[i].y || (points[j].y == points[i].y && points[j].x < points[i].x))\n i = j;\n\n // Sort points angularly around the pivot\n sort(points.begin(), points.end(), [&](const Point& a, const Point& b) {\n int o = orientation(points[i], a, b);\n if (o == 0) return (dist(points[i], a) < dist(points[i], b));\n return o == 1;\n });\n\n vector hull;\n hull.push_back(points[i]);\n\n for (int j = 1; j < n; j++) {\n while (hull.size() >= 2 && orientation(hull[hull.size()-2], hull.back(), points[j]) != 2)\n hull.pop_back();\n hull.push_back(points[j]);\n }\n\n return hull;\n}\n\n// Compute centroid of a set of points\nPoint centroid(const vector& points) {\n if (points.empty()) return Point(0, 0);\n long long cx = 0, cy = 0;\n for (const auto& p : points) {\n cx += p.x;\n cy += p.y;\n }\n return Point(cx / points.size(), cy / points.size());\n}\n\n// Generate a line that separates cluster from others using PCA on angles\nvector> separateClusters(const vector>& clusters) {\n vector> lines;\n for (size_t i = 0; i < clusters.size(); ++i) { // Use size_t to match clusters.size()\n const auto& cluster = clusters[i];\n if (cluster.empty()) continue;\n\n // Compute centroid of the cluster\n Point c = centroid(cluster);\n\n // Collect vectors from centroid to points\n vector vectors;\n for (const auto& p : cluster) {\n vectors.emplace_back(p.x - c.x, p.y - c.y);\n }\n\n // Compute PCA to find principal direction\n double sum_x2 = 0, sum_y2 = 0, sum_xy = 0;\n for (const auto& v : vectors) {\n sum_x2 += (double)v.x * v.x;\n sum_y2 += (double)v.y * v.y;\n sum_xy += (double)v.x * v.y;\n }\n\n int n = vectors.size();\n if (n == 0) continue;\n\n double trace = sum_x2 + sum_y2;\n double det = sum_x2 * sum_y2 - sum_xy * sum_xy;\n\n // Skip if degenerate\n if (abs(det) < 1e-9) continue;\n\n // Compute eigenvalues\n double eigen_val1 = (trace + sqrt(trace * trace - 4 * det)) / 2;\n double eigen_val2 = (trace - sqrt(trace * trace - 4 * det)) / 2;\n\n // Find eigenvector for smaller eigenvalue (minor component)\n double eigen_val = eigen_val2;\n double discriminant = sqrt((sum_x2 - eigen_val) * (sum_y2 - eigen_val) - sum_xy * sum_xy);\n if (abs(discriminant) < 1e-9) continue;\n\n double cos_theta = (sum_x2 - eigen_val) / discriminant;\n double sin_theta = sum_xy / discriminant;\n\n // Rotate to find perpendicular direction for cut line\n double nx = -sin_theta, ny = cos_theta;\n\n // Create line far enough to pass through centroid\n Point p1(c.x + 100000 * nx, c.y + 100000 * ny);\n Point p2(c.x - 100000 * nx, c.y - 100000 * ny);\n\n lines.emplace_back(p1, p2);\n }\n return lines;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n if(!(cin >> N >> K)) return 0; // Handle input errors gracefully\n vector a(10);\n for (int i = 0; i < 10; ++i) {\n if (!(cin >> a[i])) return 0;\n }\n\n vector strawberries(N);\n for (int i = 0; i < N; ++i) {\n if (!(cin >> strawberries[i].x >> strawberries[i].y)) return 0;\n }\n\n // Simple clustering: assign to clusters of size close to target sizes\n vector> clusters(10);\n vector target(10);\n for (int d = 0; d < 10; ++d) target[d] = a[d] * (d + 1);\n\n // Greedy assignment\n vector used(N, false); // Track which strawberries have been used\n for (int d = 0; d < 10; ++d) {\n int need = target[d];\n while (need > 0) {\n int best = -1;\n int best_count = 0;\n for (int i = 0; i < N; ++i) {\n if (used[i]) continue; // Skip if already used\n bool found = false;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (p == strawberries[i]) {\n found = true;\n break;\n }\n }\n if (found) break;\n }\n if (found) continue;\n\n int cnt = 0;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (dist(p, strawberries[i]) <= 100) ++cnt;\n }\n }\n if (cnt > best_count) {\n best_count = cnt;\n best = i;\n }\n }\n if (best == -1) break;\n clusters[d].push_back(strawberries[best]);\n used[best] = true; // Mark as used\n --need;\n }\n }\n\n // Flatten clusters and generate separating lines\n vector> lines = separateClusters(clusters);\n\n // Output\n cout << lines.size() << \"\\n\";\n for (const auto& line : lines) {\n cout << line.first.x << \" \" << line.first.y << \" \"\n << line.second.x << \" \" << line.second.y << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint N;\nvector> grid;\nvector

dots;\nmap dot_map;\nset

drawn_rects;\nset

new_dots;\n\nstruct Rect {\n P p1, p2, p3, p4;\n int score;\n};\n\nvector candidates;\n\nbool is_valid_rect(const P& p1, const P& p2, const P& p3, const P& p4) {\n vector

perimeter;\n perimeter.push_back(p1);\n perimeter.push_back(p2);\n perimeter.push_back(p3);\n perimeter.push_back(p4);\n if (p1.x == p2.x && p2.x == p3.x && p3.x == p4.x) return false;\n if (p1.y == p2.y && p2.y == p3.y && p3.y == p4.y) return false;\n\n for (const auto& pt : perimeter) {\n if (pt.x < 0 || pt.x >= N || pt.y < 0 || pt.y >= N) return false;\n }\n\n for (int i = 0; i < 4; ++i) {\n for (int j = i + 1; j < 4; ++j) {\n for (int k = j + 1; k < 4; ++k) {\n if ((perimeter[i].x == perimeter[j].x && perimeter[i].y == perimeter[j].y) ||\n (perimeter[i].x == perimeter[k].x && perimeter[i].y == perimeter[k].y) ||\n (perimeter[j].x == perimeter[k].x && perimeter[j].y == perimeter[k].y)) {\n return false;\n }\n }\n }\n }\n\n for (const auto& pt : perimeter) {\n if (dot_map.count(pt)) continue;\n if (new_dots.count(pt)) continue;\n if (grid[pt.x][pt.y] == 0) continue;\n return false;\n }\n\n for (const auto& pt : perimeter) {\n for (const auto& d : dots) {\n if (d == pt) continue;\n if (grid[d.x][d.y] == 0) continue;\n if (pt.x == d.x && pt.y == d.y) return false;\n }\n if (new_dots.count(pt)) {\n for (const auto& d : dots) {\n if (d == pt) continue;\n if (grid[d.x][d.y] == 0) continue;\n if (pt.x == d.x && pt.y == d.y) return false;\n }\n }\n }\n\n for (const auto& pt : perimeter) {\n for (const auto& rect : drawn_rects) {\n if (pt.x == rect.x && pt.y == rect.y) return false;\n }\n }\n\n int min_x = min({p1.x, p2.x, p3.x, p4.x});\n int max_x = max({p1.x, p2.x, p3.x, p4.x});\n int min_y = min({p1.y, p2.y, p3.y, p4.y});\n int max_y = max({p1.y, p2.y, p3.y, p4.y});\n\n for (int x = min_x; x <= max_x; ++x) {\n for (int y = min_y; y <= max_y; ++y) {\n if (x == p1.x && y == p1.y) continue;\n if (x == p2.x && y == p2.y) continue;\n if (x == p3.x && y == p3.y) continue;\n if (x == p4.x && y == p4.y) continue;\n if (grid[x][y] != 0) return false;\n }\n }\n\n return true;\n}\n\nint calculate_score(const P& p) {\n ll c = (N - 1) / 2;\n ll dx = p.x - c;\n ll dy = p.y - c;\n return (dx * dx + dy * dy + 1);\n}\n\nvoid generate_candidates() {\n candidates.clear();\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n if (dot_map.count({x, y})) continue;\n if (new_dots.count({x, y})) continue;\n\n for (int dx : {1, -1}) {\n for (int dy : {1, -1}) {\n if (dx == 0 || dy == 0) continue;\n int x2 = x + dx, y2 = y + dy;\n int x3 = x - dx, y3 = y + dy;\n int x4 = x - dx, y4 = y - dy;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n }\n\n for (int dx : {1, -1}) {\n int x2 = x + dx, y2 = y;\n int x3 = x, y3 = y + dx;\n int x4 = x + dx, y4 = y - dx;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n\n for (int dy : {1, -1}) {\n int y2 = y + dy, x2 = x;\n int y3 = y, x3 = x + dy;\n int y4 = y + dy, x4 = x - dy;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n grid.assign(N, vector(N, 0));\n dots.clear();\n dot_map.clear();\n\n int M;\n cin >> M;\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n dots.emplace_back(x, y);\n dot_map[{x, y}] = 1;\n grid[x][y] = 1;\n }\n\n vector solutions;\n\n while (true) {\n generate_candidates();\n if (candidates.empty()) break;\n\n sort(candidates.begin(), candidates.end(), [](const Rect& a, const Rect& b) {\n return a.score > b.score;\n });\n\n auto best = candidates[0];\n solutions.push_back(best);\n\n grid[best.p1.x][best.p1.y] = 1;\n new_dots.insert({best.p1.x, best.p1.y});\n\n P p2 = best.p2, p3 = best.p3, p4 = best.p4;\n drawn_rects.insert(p2);\n drawn_rects.insert(p3);\n drawn_rects.insert(p4);\n drawn_rects.insert(best.p1);\n }\n\n cout << solutions.size() << \"\\n\";\n for (const auto& sol : solutions) {\n cout << sol.p1.x << \" \" << sol.p1.y << \" \"\n << sol.p2.x << \" \" << sol.p2.y << \" \"\n << sol.p3.x << \" \" << sol.p3.y << \" \"\n << sol.p4.x << \" \" << sol.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstruct Cell {\n int flavor = 0; // 0: empty\n};\n\nconst int SIZE = 10;\nCell grid[SIZE][SIZE];\nint empty_cells[SIZE][SIZE];\n\nvoid reset_empty() {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n empty_cells[i][j] = 1;\n }\n }\n}\n\nvector> get_empty_cells() {\n vector> empty;\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) {\n empty.emplace_back(i, j);\n }\n }\n }\n return empty;\n}\n\nvoid place_candy(int t, int p, int flavor) {\n vector> empty = get_empty_cells();\n auto [i, j] = empty[p - 1];\n grid[i][j].flavor = flavor;\n}\n\nvoid tilt(int dir) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) continue;\n if (dir == 'F') {\n for (int k = i - 1; k >= 0; --k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k+1][j].flavor == 0) {\n swap(grid[i][j], grid[k+1][j]);\n }\n break;\n }\n }\n } else if (dir == 'B') {\n for (int k = i + 1; k < SIZE; ++k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k-1][j].flavor == 0) {\n swap(grid[i][j], grid[k-1][j]);\n }\n break;\n }\n }\n } else if (dir == 'L') {\n for (int k = j - 1; k >= 0; --k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k+1].flavor == 0) {\n swap(grid[i][j], grid[i][k+1]);\n }\n break;\n }\n }\n } else if (dir == 'R') {\n for (int k = j + 1; k < SIZE; ++k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k-1].flavor == 0) {\n swap(grid[i][j], grid[i][k-1]);\n }\n break;\n }\n }\n }\n }\n }\n}\n\nvector calculate_components() {\n vector> visited(SIZE, vector(SIZE, false));\n vector component_sizes(3, 0);\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (visited[i][j] || grid[i][j].flavor == 0) continue;\n int flavor = grid[i][j].flavor;\n queue> q;\n q.emplace(i, j);\n visited[i][j] = true;\n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (nx >= 0 && nx < SIZE && ny >= 0 && ny < SIZE &&\n !visited[nx][ny] && grid[nx][ny].flavor == flavor) {\n visited[nx][ny] = true;\n q.emplace(nx, ny);\n }\n }\n }\n component_sizes[flavor - 1] += size * size;\n }\n }\n return component_sizes;\n}\n\nchar decide_tilt(const vector& flavors) {\n reset_empty();\n vector> empty = get_empty_cells();\n int p;\n cout << flush;\n cin >> p;\n int flavor = flavors[0];\n flavors.erase(flavors.begin());\n place_candy(0, p, flavor);\n\n vector dirs = {'F', 'B', 'L', 'R'};\n vector scores(4, 0);\n vector backup[SIZE][SIZE];\n\n for (int d = 0; d < 4; ++d) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup[i][j] = grid[i][j];\n }\n }\n tilt(dirs[d]);\n scores[d] = calculate_components()[flavor - 1];\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup[i][j];\n }\n }\n }\n\n int max_score = -1;\n char best_dir = 'F';\n for (int d = 0; d < 4; ++d) {\n if (scores[d] > max_score) {\n max_score = scores[d];\n best_dir = dirs[d];\n }\n }\n\n cout << best_dir << '\\n' << flush;\n tilt(best_dir);\n\n return best_dir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector flavors(100);\n for (int i = 0; i < 100; ++i) {\n cin >> flavors[i];\n }\n\n for (int t = 0; t < 100; ++t) {\n if (t == 99) {\n cout << '\\n' << flush;\n break;\n }\n decide_tilt({flavors.begin() + t, flavors.end()});\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double eps;\n cin >> M >> eps;\n \n // Dynamic N selection based on M and epsilon\n int N = 20;\n if (M > 70) N = 35;\n else if (M > 40) N = 28;\n else if (M > 20) N = 22;\n \n if (eps > 0.3) N += 10;\n else if (eps > 0.2) N += 5;\n \n N = min(max(N, 4), 100);\n \n // Generate M distinct graphs with controlled edge distribution\n cout << N << \"\\n\";\n int total_edges = N * (N - 1) / 2;\n \n vector graphs(M);\n for (int k = 0; k < M; ++k) {\n // Use exponential distribution for edge density\n double density = exp(log(0.8) * (1.0 - k * 1.0 / (M - 1)));\n int target_edges = static_cast(density * total_edges + 0.5);\n \n string g(total_edges, '0');\n // Fill edges in a way that preserves structure under noise\n for (int i = 0; i < target_edges; ++i) {\n int pos = (i * 7) % total_edges; // Simple perturbation\n g[pos] = '1';\n }\n graphs[k] = g;\n cout << g << \"\\n\";\n }\n cout << flush;\n \n // Process queries with improved classification\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n // Enhanced edge counting with noise robustness\n int edge_count = count(H.begin(), H.end(), '1');\n \n // Dynamic threshold based on epsilon\n double noise_factor = 1.0 + eps * 2.5;\n int adjusted_count = static_cast(edge_count / noise_factor + 0.5);\n \n // Map to nearest graph using precomputed densities\n double best_error = 1e9;\n int best_k = 0;\n for (int k = 0; k < M; ++k) {\n int expected_edges = count(graphs[k].begin(), graphs[k].end(), '1');\n double error = abs(adjusted_count - expected_edges);\n if (error < best_error) {\n best_error = error;\n best_k = k;\n }\n }\n \n cout << best_k << \"\\n\";\n cout << flush;\n }\n \n return 0;\n}","ahc017":"#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, D, K;\n cin >> N >> M >> D >> K;\n\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n edges[i] = {u - 1, v - 1, w};\n }\n\n // Read and ignore vertex coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Sort edges by weight (ascending)\n sort(edges.begin(), edges.end(), [](const auto& a, const auto& b) {\n return get<2>(a) < get<2>(b);\n });\n\n // Assign days to edges\n vector result(M);\n for (int i = 0; i < M; ++i) {\n result[i] = (i % D) + 1;\n }\n\n // Output the result\n for (int i = 0; i < M; ++i) {\n cout << result[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), f2(D), r1(D), r2(D);\n \n for (int i = 0; i < 2; ++i) {\n for (int j = 0; j < D; ++j) cin >> f1[j];\n for (int j = 0; j < D; ++j) cin >> r1[j];\n for (int j = 0; j < D; ++j) cin >> f2[j];\n for (int j = 0; j < D; ++j) cin >> r2[j];\n }\n\n // Initialize 3D array to store which block is placed where\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n // Identify regions where both silhouettes need material\n vector>> common_region(D, vector>(D, vector(D, false)));\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool f_needed1 = (f1[z][x] == '1');\n bool r_needed1 = (r1[z][y] == '1');\n bool f_needed2 = (f2[z][x] == '1');\n bool r_needed2 = (r2[z][y] == '1');\n common_region[z][x][y] = f_needed1 && f_needed2 && r_needed1 && r_needed2;\n }\n }\n }\n\n // Create blocks for common region (shared between both objects)\n int block_id = 1;\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 (block_id == 1000005) break;\n if (common_region[z][x][y]) {\n b1[z][x][y] = block_id;\n b2[z][x][y] = block_id;\n ++block_id;\n }\n }\n if (block_id == 1000005) break;\n }\n if (block_id == 1000005) break;\n }\n\n // Fill remaining regions with unique 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 (b1[z][x][y] == 0 && f1[z][x] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && f2[z][x] == '1') {\n b2[z][x][y] = block_id++;\n }\n if (b1[z][x][y] == 0 && r1[z][y] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && r2[z][y] == '1') {\n b2[z][x][y] = block_id++;\n }\n }\n }\n }\n\n // Output\n cout << block_id - 1 << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b1[z][x][y];\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b2[z][x][y];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \nusing namespace std;\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);\n for (int i = 0; i < N; i++) {\n cin >> stations[i].first >> stations[i].second;\n }\n \n vector> edges(M);\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n u--; v--;\n edges[i] = {u, v, w};\n }\n \n vector> residents(K);\n for (int i = 0; i < K; i++) {\n cin >> residents[i].first >> residents[i].second;\n }\n \n vector P(N, 0);\n vector B(M, 0);\n \n // Connect all stations to station 0 (index 0) using MST-like approach\n vector>> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v, w;\n tie(u, v, w) = edges[i];\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n vector parent(N, -1);\n priority_queue, vector>, greater>> pq;\n pq.push({0, 0});\n vector visited(N, false);\n \n while (!pq.empty()) {\n auto [cost, u] = pq.top(); pq.pop();\n if (visited[u]) continue;\n visited[u] = true;\n \n for (auto [v, w] : adj[u]) {\n if (!visited[v]) {\n pq.push({w, v});\n parent[v] = u;\n }\n }\n }\n \n // Turn on edges in the MST\n for (int v = 1; v < N; v++) {\n int u = parent[v];\n for (int i = 0; i < M; i++) {\n int a, b, w;\n tie(a, b, w) = edges[i];\n if ((a == u && b == v) || (a == v && b == u)) {\n B[i] = 1;\n break;\n }\n }\n }\n \n // Calculate P_i as min distance to any resident\n for (int i = 0; i < N; i++) {\n int min_dist = 1e9;\n for (int j = 0; j < K; j++) {\n int dx = stations[i].first - residents[j].first;\n int dy = stations[i].second - residents[j].second;\n int dist = sqrt(dx*dx + dy*dy);\n if (dist < min_dist) min_dist = dist;\n }\n P[i] = min(min_dist + 1, 5000);\n }\n \n cout << endl;\n for (int i = 0; i < N; i++) {\n cout << P[i] << (i == N-1 ? \"\\n\" : \" \");\n }\n for (int i = 0; i < M; i++) {\n cout << B[i] << (i == M-1 ? \"\\n\" : \" \");\n }\n \n return 0;\n}","ahc021":"#include \n#include \n#include \nusing namespace std;\n\nstruct Ball {\n int number;\n int x, y;\n Ball(int n, int x, int y) : number(n), x(x), y(y) {}\n};\n\nvector> pyramid;\nvector, pair>> swaps;\n\nbool isAdjacent(int x1, int y1, int x2, int y2) {\n if (x1 == x2 - 1 && y1 == y2 - 1) return true;\n if (x1 == x2 - 1 && y1 == y2) return true;\n if (x1 == x2 && y1 == y2 - 1) return true;\n if (x1 == x2 && y1 == y2 + 1) return true;\n if (x1 == x2 + 1 && y1 == y2) return true;\n if (x1 == x2 + 1 && y1 == y2 + 1) return true;\n return false;\n}\n\nvoid swapBalls(int x1, int y1, int x2, int y2) {\n if (!isAdjacent(x1, y1, x2, y2)) return;\n swaps.push_back({{x1, y1}, {x2, y2}});\n swap(pyramid[x1][y1].number, pyramid[x2][y2].number);\n}\n\nvoid processTier(int tier) {\n int rows = tier + 1;\n for (int y = 0; y <= tier; ++y) {\n int x = tier;\n Ball& current = pyramid[x][y];\n if (x + 1 >= rows) continue;\n bool valid = true;\n if (y < rows - 1 && current.number > pyramid[x+1][y].number) valid = false;\n if (y + 1 < rows && current.number > pyramid[x+1][y+1].number) valid = false;\n if (!valid) {\n for (int ny = 0; ny < rows - 1; ++ny) {\n if (pyramid[x+1][ny].number < current.number) {\n swapBalls(x, y, x+1, ny);\n break;\n }\n }\n }\n }\n}\n\nint main() {\n int N = 30;\n pyramid.resize(N);\n for (int x = 0; x < N; ++x) {\n // int count = (x * (x + 1)) / 2; // Unused variable, removed\n pyramid[x].reserve(x + 1);\n for (int y = 0; y <= x; ++y) {\n int num;\n cin >> num;\n pyramid[x].emplace_back(num, x, y);\n }\n }\n\n for (int tier = 0; tier < N - 1; ++tier) {\n processTier(tier);\n }\n\n cout << swaps.size() << endl;\n for (auto& sw : swaps) {\n cout << sw.first.first << \" \" << sw.first.second << \" \"\n << sw.second.first << \" \" << sw.second.second << endl;\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint D = 9;\nint N;\nvector> grid;\nvector> dist;\nvector> obstacles;\nvector> empty_cells;\nvector> visited;\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nvoid bfs(int sx, int sy) {\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n visited[sx][sy] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i], ny = y + dy[i];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D) continue;\n if (grid[nx][ny] || visited[nx][ny]) continue;\n dist[nx][ny] = dist[x][y] + 1;\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D >> N;\n grid.assign(D, vector(D, false));\n dist.assign(D, vector(D, -1));\n visited.assign(D, vector(D, false));\n\n int entrance_x = 0, entrance_y = (D - 1) / 2;\n grid[entrance_x][entrance_y] = true;\n\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = true;\n obstacles.emplace_back(r, c);\n }\n\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (grid[i][j]) continue;\n empty_cells.emplace_back(i, j);\n }\n }\n\n bfs(entrance_x, entrance_y);\n\n vector>> candidates;\n for (auto [x, y] : empty_cells) {\n if (dist[x][y] == -1) continue;\n candidates.emplace_back(-dist[x][y], make_pair(x, y));\n }\n sort(candidates.begin(), candidates.end());\n\n vector> storage_order;\n vector>> input;\n\n cout << flush;\n\n for (int d = 0; d < D * D - 1 - N; d++) {\n int t;\n cin >> t;\n input.emplace_back(t, make_pair(-1, -1));\n\n int best_idx = -1;\n int best_dist = -1;\n for (auto &[prio, pos] : candidates) {\n int x = pos.first, y = pos.second;\n if (dist[x][y] >= 0) {\n best_idx = pos.first;\n best_dist = pos.second;\n break;\n }\n }\n\n cout << best_idx << \" \" << best_dist << \"\\n\" << flush;\n\n for (auto &[prio, pos] : candidates) {\n if (pos.first == best_idx && pos.second == best_dist) {\n prio = 1e9;\n break;\n }\n }\n }\n\n for (auto &[t, pos] : input) {\n cout << pos.first << \" \" << pos.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n = 50, m = 100;\n vector> c(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> c[i][j];\n }\n }\n\n vector> adj(m + 1);\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int color = c[i][j];\n // Check up\n if (i > 0) {\n int up = c[i - 1][j];\n if (up != 0 && up != color) {\n adj[color].insert(up);\n adj[up].insert(color);\n }\n }\n // Check left\n if (j > 0) {\n int left = c[i][j - 1];\n if (left != 0 && left != color) {\n adj[color].insert(left);\n adj[left].insert(color);\n }\n }\n }\n }\n\n vector> d(n, vector(n, 0));\n\n // Place each color in a unique position, ensuring adjacency\n vector> positions;\n for (int color = 1; color <= m; ++color) {\n // Find a position not already occupied and on the border to maximize adjacency\n bool placed = false;\n for (int i = 0; i < n && !placed; ++i) {\n for (int j = 0; j < n && !placed; ++j) {\n if (d[i][j] == 0) {\n // Check if this position can satisfy adjacency requirements\n bool valid = true;\n for (int other : adj[color]) {\n // Check adjacent positions for other colors\n bool found = false;\n for (int dx = -1; dx <= 1; ++dx) {\n for (int dy = -1; dy <= 1; ++dy) {\n if (abs(dx) + abs(dy) != 1) continue;\n int ni = i + dx, nj = j + dy;\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n if (d[ni][nj] == other) {\n found = true;\n break;\n }\n } else {\n // Outside is considered color 0, so no adjacency\n }\n }\n if (found) break;\n }\n if (!found) {\n valid = false;\n break;\n }\n }\n if (valid) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n }\n }\n }\n }\n if (!placed) {\n // Fallback: place in the first available spot\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n break;\n }\n }\n if (placed) break;\n }\n }\n }\n\n // Now, fill the remaining area with 0, but ensure connectivity\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n // Check if surrounding is all 0 or out of bounds, then keep as 0\n // Otherwise, might need to assign a color, but for simplicity, keep 0\n d[i][j] = 0;\n }\n }\n }\n\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j > 0) cout << \" \";\n cout << d[i][j];\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector results;\n\n // Perform Q queries\n for (int q = 0; q < Q; ++q) {\n // Example query: compare two items\n // For simplicity, compare item 0 with item 1\n int nL = 1, nR = 1;\n vector L = {0};\n vector R = {1};\n\n // Output the query\n cout << nL << \" \" << nR << \" \" << L[0] << \" \" << R[0] << \"\\n\";\n cout.flush();\n\n // Read the result\n string res;\n cin >> res;\n results.push_back(res);\n }\n\n // After Q queries, output a simple division\n // Assign items to groups in a round-robin fashion\n vector assignment(N);\n for (int i = 0; i < N; ++i) {\n assignment[i] = i % D;\n }\n\n // Output the division\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << assignment[i];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n = 200, m = 10;\n vector> stacks(m);\n vector pos(n + 1); // pos[v] = {stack_index, position_from_bottom}\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int v;\n cin >> v;\n stacks[i].push_back(v);\n pos[v] = {i, j};\n }\n }\n\n vector removed(n + 1, false);\n vector> operations;\n\n auto current_pos = pos; // Copy initial positions\n\n for (int target = 1; target <= n; ++target) {\n if (removed[target]) continue;\n auto [si, pos_in_stack] = current_pos[target];\n if (pos_in_stack == stacks[si].size() - 1) {\n // Already on top, remove it\n operations.emplace_back(target, 0);\n removed[target] = true;\n stacks[si].pop_back();\n // Update positions of remaining boxes in this stack\n for (int j = pos_in_stack - 1; j >= 0; --j) {\n int v = stacks[si][j];\n current_pos[v] = {si, j};\n }\n stacks[si].pop_back();\n } else {\n // Need to move this box to the top of some stack\n // Find a stack where this box can be moved to the top\n int best_stack = si;\n int min_boxes_moved = n; // Upper bound\n for (int dest = 0; dest < m; ++dest) {\n if (dest == si) continue;\n // Calculate how many boxes we need to move from current stack si to get target to top\n int boxes_moved = pos_in_stack + 1; // All boxes from pos_in_stack down to bottom\n // Check if target is at the top after moving to dest stack\n // After moving, target becomes top of dest stack\n // Energy cost is boxes_moved + 1\n if (boxes_moved + 1 < min_boxes_moved) {\n min_boxes_moved = boxes_moved + 1;\n best_stack = dest;\n }\n }\n // Move target and above to best_stack\n vector to_move;\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n to_move.push_back(stacks[si][j]);\n }\n // Update stacks\n stacks[best_stack].insert(stacks[best_stack].end(), to_move.begin(), to_move.end());\n // Update positions\n for (int j = 0; j < to_move.size(); ++j) {\n int v = to_move[j];\n current_pos[v] = {best_stack, (int)stacks[best_stack].size() - to_move.size() + j};\n }\n // Update the original stack\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n stacks[si].pop_back();\n }\n // Record operation\n operations.emplace_back(target, best_stack + 1);\n }\n }\n\n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if(!(cin >> N)) return 0;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> d[i][j];\n }\n }\n \n vector> visited(N, vector(N, false));\n vector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n vector dir_char = {'R', 'D', 'L', 'U'};\n \n function dfs = [&](int i, int j, int parent_dir) {\n visited[i][j] = true;\n vector> candidates;\n for (int di = 0; di < 4; ++di) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || visited[ni][nj]) continue;\n bool wall = false;\n if (dirs[di].first == 0) {\n if (v[i][min(j, nj)] == '1') wall = true;\n } else {\n if (h[min(i, ni)][j] == '1') wall = true;\n }\n if (!wall) {\n candidates.emplace_back(di, parent_dir);\n }\n }\n sort(candidates.begin(), candidates.end(), [&](const auto& a, const auto& b) {\n int di1 = a.first, pdi1 = a.second;\n int di2 = b.first, pdi2 = b.second;\n int ni1 = i + dirs[di1].first;\n int nj1 = j + dirs[di1].second;\n int ni2 = i + dirs[di2].first;\n int nj2 = j + dirs[di2].second;\n return d[ni1][nj1] > d[ni2][nj2];\n });\n for (auto [di, pdir] : candidates) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n cout << dir_char[di];\n dfs(ni, nj, di);\n cout << dir_char[(di + 2) % 4];\n }\n };\n \n dfs(0, 0, -1);\n cout << endl;\n \n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector t(M);\n for (int k = 0; k < M; ++k) {\n cin >> t[k];\n }\n \n vector>> charPositions(N, map>());\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = grid[i][j];\n charPositions[i][c].emplace_back(i, j);\n }\n }\n \n vector path;\n path.emplace_back(si, sj);\n \n set remaining;\n for (auto& str : t) remaining.insert(str);\n \n string current = \"\";\n int covered = 0;\n const int MAX_STEPS = 5000;\n \n while (!remaining.empty() && path.size() < MAX_STEPS) {\n map candidates;\n for (const auto& str : remaining) {\n candidates[str] = 0;\n }\n \n string S = current;\n S += grid[path.back().i][path.back().j];\n \n for (const auto& str : remaining) {\n if (S.find(str) != string::npos) {\n candidates.erase(str);\n }\n }\n \n if (candidates.empty()) {\n current += grid[path.back().i][path.back().j];\n continue;\n }\n \n string bestStr;\n int bestScore = -1;\n for (const auto& [str, _] : candidates) {\n int score = 0;\n for (size_t pos = 0; pos < str.size(); ++pos) {\n char needed = str[pos];\n for (int di = -2; di <= 2; ++di) {\n for (int dj = -2; dj <= 2; ++dj) {\n int ni = path.back().i + di, nj = path.back().j + dj;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (grid[ni][nj] == needed) {\n score++;\n break;\n }\n }\n }\n }\n if (score > bestScore) {\n bestScore = score;\n bestStr = str;\n }\n }\n \n if (bestStr.empty()) {\n current += grid[path.back().i][path.back().j];\n continue;\n }\n \n int bestCost = INT_MAX;\n Point bestPos(-1, -1);\n for (size_t pos = 0; pos < bestStr.size(); ++pos) {\n char needed = bestStr[pos];\n const auto& positions = charPositions[path.back().i][needed];\n for (const auto& p : positions) {\n int cost = abs(p.i - path.back().i) + abs(p.j - path.back().j) + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestPos = p;\n }\n }\n }\n \n if (bestPos.i == -1) {\n bestPos = path.back();\n bestCost = 1;\n }\n \n path.emplace_back(bestPos);\n current += grid[bestPos.i][bestPos.j];\n \n set toRemove;\n for (const auto& str : remaining) {\n if (current.find(str) != string::npos) {\n toRemove.insert(str);\n }\n }\n for (const auto& str : toRemove) {\n remaining.erase(str);\n }\n }\n \n for (const auto& p : path) {\n cout << p.i << \" \" << p.j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct OilField {\n vector> cells;\n int minI, minJ;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector fields(M);\n for (int idx = 0; idx < M; ++idx) {\n int d;\n cin >> d;\n fields[idx].cells.resize(d);\n for (int i = 0; i < d; ++i) {\n cin >> fields[idx].cells[i].first >> fields[idx].cells[i].second;\n }\n int minI = fields[idx].cells[0].first;\n int minJ = fields[idx].cells[0].second;\n for (auto &p : fields[idx].cells) {\n minI = min(minI, p.first);\n minJ = min(minJ, p.second);\n }\n fields[idx].minI = minI;\n fields[idx].minJ = minJ;\n for (auto &p : fields[idx].cells) {\n p.first -= minI;\n p.second -= minJ;\n }\n }\n\n vector> v(N, vector(N, -1));\n vector> positive;\n\n // Step 1: Drill some key points to get initial information\n // We can start by drilling corners and centers\n vector> drillCandidates = {\n {N/2, N/2}, {0, 0}, {N-1, 0}, {0, N-1}, {N-1, N-1}\n };\n\n for (auto &p : drillCandidates) {\n int i = p.first, j = p.second;\n if (i >= N || j >= N) continue;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n cin >> v[i][j];\n if (v[i][j] > 0) {\n positive.emplace_back(i, j);\n }\n }\n\n // Step 2: Try to guess based on current positive cells\n // For each oil field shape, try to match with positive cells\n // This is a heuristic; we might need to refine further\n\n set> posSet(positive.begin(), positive.end());\n\n // Try to find candidate positions for each oil field\n vector> placements;\n for (const auto &field : fields) {\n int size = field.cells.size();\n for (int i = 0; i <= N - field.minI - 1; ++i) {\n for (int j = 0; j <= N - field.minJ - 1; ++j) {\n bool valid = true;\n for (auto &cell : field.cells) {\n int x = i + cell.first;\n int y = j + cell.second;\n if (x >= N || y >= N) {\n valid = false;\n break;\n }\n if (v[x][y] == 0) {\n valid = false;\n break;\n }\n }\n if (valid) {\n placements.emplace_back(i, j);\n }\n }\n }\n }\n\n // For now, just output all positive cells found by drilling\n cout << \"a \" << positive.size();\n for (auto &p : positive) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n cout.flush();\n\n int result;\n cin >> result;\n if (result == 1) {\n return 0;\n }\n\n // If failed, we might need to do more work, but for this example, we just exit\n // In a real solution, you would refine the strategy here\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n cin >> a[d][k];\n }\n }\n\n // For each day, output rectangles\n for (int d = 0; d < D; ++d) {\n int row = 0;\n for (int k = 0; k < N; ++k) {\n int area = a[d][k];\n // Assign rectangle of height 1 and width = area\n int j0 = 0;\n int j1 = area;\n\n // Ensure width does not exceed W\n while (j1 > W) {\n j1 = W;\n row++;\n j0 = 0;\n }\n\n cout << row << \" \" << j0 << \" \" << row + 1 << \" \" << j1 << \"\\n\";\n row++;\n }\n }\n\n return 0;\n}","ahc032":"#include \nusing namespace std;\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> 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 vector>> s(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 >> s[m][i][j];\n }\n }\n }\n\n // Simple greedy approach: Try to maximize each cell's mod value by applying stamps\n vector> operations;\n\n // We'll try to apply stamps to improve each cell's value mod 998244353\n const int MOD = 998244353;\n\n // For each possible position (p, q), try each stamp and see how it affects the mod values\n // We'll apply the best improvement we can find up to K times\n\n for (int step = 0; step < K; ++step) {\n int best_delta = -1;\n int best_m = -1, best_p = -1, best_q = -1;\n\n // Try all stamps and positions\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 the total delta this stamp would add to all cells in its area\n int delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int ni = p + i;\n int nj = q + j;\n int current_val = a[ni][nj];\n int new_val = (current_val + s[m][i][j]) % MOD;\n delta += new_val - current_val;\n }\n }\n\n if (delta > best_delta) {\n best_delta = delta;\n best_m = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n\n // Apply the best stamp we found\n if (best_delta > 0) {\n operations.emplace_back(best_m, best_p, best_q);\n // Update the board\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int ni = best_p + i;\n int nj = best_q + j;\n a[ni][nj] = (a[ni][nj] + s[best_m][i][j]) % MOD;\n }\n }\n } else {\n // No more improvements possible\n break;\n }\n }\n\n // Output\n cout << operations.size() << \"\\n\";\n for (auto [m, p, q] : operations) {\n cout << m << \" \" << p << \" \" << q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int x, y;\n bool holding;\n int id;\n};\n\nint N;\nvector> A;\nvector cranes;\nvector> grid;\nvector> occupied;\nvector actions;\n\nvector> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\nchar dir_char[4] = {'R', 'D', 'L', 'U'};\n\nbool is_valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nvoid place_container(int x, int y, int cont) {\n grid[x][y] = cont;\n occupied[x][y] = true;\n}\n\nvoid pickup(Crane& crane, int cont) {\n crane.holding = cont;\n occupied[crane.x][crane.y] = false;\n grid[crane.x][crane.y] = -1;\n}\n\nvoid release(Crane& crane, int x, int y) {\n grid[x][y] = crane.holding;\n occupied[x][y] = true;\n crane.holding = -1;\n}\n\nbool move_crane(Crane& crane, int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!is_valid(nx, ny)) return false;\n if (crane.holding != -1 && occupied[nx][ny]) return false;\n if (crane.holding == -1 && grid[nx][ny] != -1 && nx == N - 1 && ny == N - 1) return false;\n if (occupied[nx][ny] && crane.holding == -1) {\n if (grid[nx][ny] != -1) return false;\n }\n occupied[crane.x][crane.y] = false;\n crane.x = nx;\n crane.y = ny;\n occupied[crane.x][crane.y] = true;\n return true;\n}\n\nvoid simulate_turn(vector& moves) {\n for (int i = 0; i < N; ++i) {\n if (A[i][0] != -1 && !occupied[i][0] && cranes[i].holding == -1) {\n place_container(i, 0, A[i][0]);\n A[i][0] = A[i][1];\n for (int j = 1; j < N; ++j) A[i][j] = A[i][j + 1];\n A[i][N - 1] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n Crane& crane = cranes[i];\n char move = moves[i][actions.size()];\n if (move == 'P') {\n if (crane.holding != -1 || grid[crane.x][crane.y] == -1) continue;\n pickup(crane, grid[crane.x][crane.y]);\n } else if (move == 'Q') {\n if (crane.holding == -1 || occupied[crane.x][crane.y]) continue;\n release(crane, crane.x, crane.y);\n } else if (move == 'B') {\n if (crane.holding != -1) continue;\n crane.holding = -2;\n } else {\n int dx = 0, dy = 0;\n switch (move) {\n case 'U': dx = -1; break;\n case 'D': dx = 1; break;\n case 'L': dy = -1; break;\n case 'R': dy = 1; break;\n default: break;\n }\n if (dx != 0 || dy != 0) {\n move_crane(crane, dx, dy);\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1 && grid[N - 1][N - 1] != -1 && cranes[i].holding == -1) {\n int cont = grid[N - 1][N - 1];\n occupied[N - 1][N - 1] = false;\n grid[N - 1][N - 1] = -1;\n }\n }\n}\n\nvector solve() {\n actions.resize(N);\n fill(grid.begin(), grid.end(), vector(N, -1));\n fill(occupied.begin(), occupied.end(), vector(N, false));\n cranes.resize(N);\n for (int i = 0; i < N; ++i) {\n cranes[i] = {i, 0, false, -1, i};\n actions[i].clear();\n }\n\n vector target;\n for (int i = 0; i < N * N; ++i) target.push_back(i);\n vector dispatch_order;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dispatch_order.push_back(i * N + j);\n\n int steps = 0;\n while (steps < 10000) {\n vector moves(N, string(1, '.'));\n bool progress = false;\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].holding != -1) continue;\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1) continue;\n int target_x = N - 1, target_y = N - 1;\n vector> path;\n int dx = 0, dy = 0;\n\n if (grid[cranes[i].x][cranes[i].y] != -1) {\n moves[i][steps] = 'P';\n progress = true;\n continue;\n }\n\n if (cranes[i].x == target_x && cranes[i].y == target_y) {\n continue;\n }\n\n int nx = cranes[i].x, ny = cranes[i].y;\n while (nx != target_x || ny != target_y) {\n int best = -1;\n for (int d = 0; d < 4; ++d) {\n int nx2 = nx + directions[d].first;\n int ny2 = ny + directions[d].second;\n if (!is_valid(nx2, ny2)) continue;\n if (occupied[nx2][ny2] && grid[nx2][ny2] != -1) continue;\n if (d == 0 && ny == N - 1) continue;\n if (d == 1 && nx == N - 1) continue;\n if (d == 2 && ny == 0) continue;\n if (d == 3 && nx == 0) continue;\n best = d;\n break;\n }\n if (best == -1) break;\n path.emplace_back(nx, ny);\n nx += directions[best].first;\n ny += directions[best].second;\n }\n if (!path.empty()) {\n moves[i][steps] = dir_char[directions[best].first == 1 ? 1 :\n directions[best].second == 1 ? 0 :\n directions[best].first == -1 ? 3 : 2];\n progress = true;\n }\n }\n\n vector current_moves = moves;\n simulate_turn(current_moves);\n for (int i = 0; i < N; ++i)\n actions[i].push_back(current_moves[i].back());\n\n if (!progress) break;\n steps++;\n }\n\n return actions;\n}\n\nint main() {\n cin >> N;\n A = vector>(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 grid = vector>(N, vector(N, -1));\n occupied = vector>(N, vector(N, false));\n\n auto result = solve();\n for (const auto& s : result)\n cout << s << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\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 vector> changes; // (i, j, delta)\n vector> current_h = h;\n\n vector> operations;\n\n int di[] = {1, -1, 0, 0};\n int dj[] = {0, 0, 1, -1};\n vector dir = {\"D\", \"U\", \"R\", \"L\"};\n\n auto manhattan = [](int i1, int j1, int i2, int j2) {\n return abs(i1 - i2) + abs(j1 - j2);\n };\n\n auto get_best_target = [&](int current_i, int current_j, int current_load) -> tuple {\n int best_i = -1, best_j = -1, best_val = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int val = abs(current_h[i][j]);\n if (val == 0) continue;\n int dist = manhattan(current_i, current_j, i, j);\n if (best_i == -1 || val > best_val) {\n best_val = val;\n best_i = i;\n best_j = j;\n } else if (val == best_val) {\n if (dist < manhattan(best_i, best_j, current_i, current_j)) {\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n if (best_i == -1) return {-1, -1, 0, 0};\n int needed = current_h[best_i][best_j];\n if (needed > 0) {\n return {best_i, best_j, 1, needed};\n } else {\n return {best_i, best_j, -1, -needed};\n }\n };\n\n int current_i = 0, current_j = 0;\n int current_load = 0;\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 (current_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 auto [target_i, target_j, type, amount] = get_best_target(current_i, current_j, current_load);\n if (target_i == -1) break;\n\n vector> path;\n int steps = 0;\n while (true) {\n if (current_i == target_i && current_j == target_j) break;\n for (int d = 0; d < 4; ++d) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (ni == target_i && nj == target_j) {\n path.emplace_back(dir[d], 0);\n current_i = ni;\n current_j = nj;\n operations.emplace_back(dir[d]);\n steps++;\n break;\n }\n }\n if (steps > 0) break;\n }\n\n for (auto& [op, _] : path) {\n if (op == \"D\") {\n current_i++;\n } else if (op == \"U\") {\n current_i--;\n } else if (op == \"R\") {\n current_j++;\n } else if (op == \"L\") {\n current_j--;\n }\n }\n\n if (type == 1) {\n int d = min(amount, 10000000);\n current_load += d;\n current_h[current_i][current_j] -= d;\n operations.emplace_back(\u201c+\u201d + to_string(d));\n } else {\n int d = min(current_load, amount);\n current_load -= d;\n current_h[current_i][current_j] += d;\n operations.emplace_back(\u201c-\u201d + to_string(d));\n }\n }\n\n for (const auto& op : operations) {\n cout << op << endl;\n }\n return 0;\n}","ahc035":"#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, T;\n cin >> N >> M >> T;\n\n int seed_count = 2 * N * (N - 1);\n vector> seeds(seed_count, vector(M));\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n }\n\n vector total_values(seed_count);\n for (int i = 0; i < seed_count; ++i) {\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n\n for (int turn = 0; turn < T; ++turn) {\n vector> grid(N, vector(N));\n vector used(seed_count, false);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int best_index = -1;\n int best_value = -1;\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k] && total_values[k] > best_value) {\n best_value = total_values[k];\n best_index = k;\n }\n }\n grid[i][j] = best_index;\n used[best_index] = true;\n }\n }\n\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) cout << \" \";\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n vector> sources, targets;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (s[i][j] == '1') sources.emplace_back(i, j);\n if (t[i][j] == '1') targets.emplace_back(i, j);\n }\n \n // Design tree: linear chain of length min(V, something reasonable)\n int Vp = min(V, 2); // Use just 2 vertices: root and one fingertip\n cout << Vp << \"\\n\";\n if (Vp > 1) cout << \"0 1\\n\";\n \n // Initial position of root\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n // Precompute directions: assume fingertip is to the right of root\n // We'll move around and rotate as needed\n \n // Simple strategy: move to each source, grab, move to target, release\n // We'll simulate positions and orientations\n \n struct Pos { int x, y; };\n struct State {\n Pos root;\n int dir; // direction of edge from root to child: 0=R,1=D,2=L,3=U\n vector fingertips; // positions of fingertips relative to root\n };\n \n State st;\n st.root = {0, 0};\n st.dir = 0; // right\n if (Vp >= 2) {\n st.fingertips.push_back({st.root.x + 1, st.root.y}); // child at (1,0)\n }\n \n // Precompute all moves\n vector moves;\n \n for (int i = 0; i < M; ++i) {\n // Move to source i\n auto [sx, sy] = sources[i];\n // First, move root close to source\n int dx = sx - st.root.x;\n int dy = sy - st.root.y;\n // Move root to (sx, st.root.y) then adjust y\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\"; // no rotate\n op += \".\\n\"; // no action for fingertip\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Now root is at (sx, st.root.y), need to align fingertip to (sx, sy)\n dx = sy - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dx > 0) ? 1 : -1;\n st.fingertips[0].y += (dx > 0) ? 1 : -1;\n }\n \n // Rotate to make fingertip point to the source\n // Currently fingertip is at (root.x+1, root.y) if dir=0\n // We want it to point to (sx, sy). Since we are already at (sx, sy) for root, just grab\n // Grab\n string op;\n op += \".\\n\"; // no move\n op += \".\\n\"; // no rotate\n op += \"P\\n\"; // grab\n moves.push_back(op);\n \n // Move to target i\n auto [tx, ty] = targets[i];\n dx = tx - st.root.x;\n dy = ty - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Release\n op = \".\\n.\\nP\\n\";\n moves.push_back(op);\n }\n \n // Output moves\n for (const auto& mv : moves) {\n cout << mv;\n }\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\n// Function to compute the score for a given rectangle\nint compute_score(const vector& mackerels, const vector& sardines,\n int min_x, int min_y, int max_x, int max_y) {\n int a = 0, b = 0;\n for (const auto& p : mackerels) {\n if (p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y) {\n a++;\n }\n }\n for (const auto& p : sardines) {\n if (p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y) {\n b++;\n }\n }\n return a - b;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector mackerels(N), sardines(N);\n for (int i = 0; i < N; ++i) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n for (int i = 0; i < N; ++i) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n\n // Dynamic grid size: start with a coarse grid and refine\n const int GRID_SIZE = 50; // Coarser grid to cover larger areas\n const int CELL_SIZE = 2000; // Larger cells\n\n vector> grid_score(GRID_SIZE, vector(GRID_SIZE, 0));\n\n for (const auto& p : mackerels) {\n int gx = p.x / CELL_SIZE;\n int gy = p.y / CELL_SIZE;\n if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {\n grid_score[gx][gy]++;\n }\n }\n\n for (const auto& p : sardines) {\n int gx = p.x / CELL_SIZE;\n int gy = p.y / CELL_SIZE;\n if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {\n grid_score[gx][gy]--;\n }\n }\n\n // Find the best cell\n int best_gx = 0, best_gy = 0;\n int best_score = grid_score[0][0];\n for (int x = 0; x < GRID_SIZE; ++x) {\n for (int y = 0; y < GRID_SIZE; ++y) {\n if (grid_score[x][y] > best_score) {\n best_score = grid_score[x][y];\n best_gx = x;\n best_gy = y;\n }\n }\n }\n\n // Expand the best cell greedily\n int min_x = best_gx * CELL_SIZE;\n int min_y = best_gy * CELL_SIZE;\n int max_x = (best_gx + 1) * CELL_SIZE - 1;\n int max_y = (best_gy + 1) * CELL_SIZE - 1;\n\n // Try to expand to neighboring cells if it improves the score\n for (int dx = -1; dx <= 1; ++dx) {\n for (int dy = -1; dy <= 1; ++dy) {\n if (dx == 0 && dy == 0) continue;\n int new_min_x = min_x + dx * CELL_SIZE;\n int new_min_y = min_y + dy * CELL_SIZE;\n int new_max_x = max_x + dx * CELL_SIZE;\n int new_max_y = max_y + dy * CELL_SIZE;\n\n if (new_min_x < 0) new_min_x = 0;\n if (new_min_y < 0) new_min_y = 0;\n if (new_max_x > 100000) new_max_x = 100000;\n if (new_max_y > 100000) new_max_y = 100000;\n\n int new_score = compute_score(mackerels, sardines, new_min_x, new_min_y, new_max_x, new_max_y);\n if (new_score > compute_score(mackerels, sardines, min_x, min_y, max_x, max_y)) {\n min_x = new_min_x;\n min_y = new_min_y;\n max_x = new_max_x;\n max_y = new_max_y;\n }\n }\n }\n\n // Ensure the polygon is valid (at least 4 vertices and no self-intersection)\n vector polygon = {\n Point(min_x, min_y),\n Point(max_x, min_y),\n Point(max_x, max_y),\n Point(min_x, max_y)\n };\n\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 \nusing namespace std;\n\n#include \n\nusing namespace cg3;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, T;\n double sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector> wh(N);\n for (int i = 0; i < N; ++i) {\n cin >> wh[i].first >> wh[i].second;\n }\n \n // Simulate true dimensions based on observed values and sigma\n vector> true_wh(N);\n default_random_engine gen;\n normal_distribution dist(0.0, sigma);\n for (int i = 0; i < N; ++i) {\n double dw = dist(gen);\n double dh = dist(gen);\n true_wh[i].first = max(1, static_cast(round(wh[i].first + dw)));\n true_wh[i].second = max(1, static_cast(round(wh[i].second + dh)));\n }\n \n vector> best placements.\n vector> current_placement;\n \n for (int t = 0; t < T; ++t) {\n vector> placement;\n vector> placed_rects;\n map used;\n \n if (t == 0) {\n // First turn: Place the largest rectangles greedily\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int a, int b) {\n return (true_wh[a].first * true_wh[a].second) > (true_wh[b].first * true_wh[b].second);\n });\n \n int rot0 = 0;\n rectangle2d rect0;\n if (rot0) {\n rect0 = rectangle2d(0, true_wh[0].second, true_wh[0].first, 0);\n } else {\n rect0 = rectangle2d(0, 0, true_wh[0].first, true_wh[0].second);\n }\n placement.emplace_back(indices[0], rot0, 'U', -1);\n placed_rects.push_back(rect0);\n used[indices[0]] = 0;\n \n for (int i = 1; i < N; ++i) {\n int idx = indices[i];\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n double best_score = 1e18;\n \n for (int rot : {0, 1}) {\n rectangle2d rect;\n if (rot) {\n rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, 0);\n } else {\n rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second);\n }\n \n for (char dir : {'U', 'L'}) {\n double score = 0.0;\n rectangle2d new_rect = rect;\n if (dir == 'U') {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(0, existing.y2());\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n } else {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(existing.x2(), 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n }\n }\n }\n \n if (best_dir == 'U') {\n if (best_b == -1) {\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, 0);\n } else {\n new_rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second);\n }\n placed_rects.push_back(new_rect);\n } else {\n rectangle2d existing = placed_rects[best_b];\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, existing.y2());\n } else {\n new_rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second + existing.y2());\n }\n new_rect.move(0, existing.y2());\n placed_rects.push_back(new_rect);\n }\n } else {\n if (best_b == -1) {\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(0, true_wh[idx].second, true_wh[idx].first, 0);\n } else {\n new_rect = rectangle2d(0, 0, true_wh[idx].first, true_wh[idx].second);\n }\n new_rect.move(0, 0);\n placed_rects.push_back(new_rect);\n } else {\n rectangle2d existing = placed_rects[best_b];\n rectangle2d new_rect;\n if (best_rot) {\n new_rect = rectangle2d(existing.x2(), 0, true_wh[idx].first, true_wh[idx].second);\n } else {\n new_rect = rectangle2d(existing.x2(), 0, true_wh[idx].first, true_wh[idx].second);\n }\n placed_rects.push_back(new_rect);\n }\n }\n placement.emplace_back(idx, best_rot, best_dir, best_b);\n used[idx] = placement.size() - 1;\n }\n } else {\n // Simple greedy for subsequent turns\n placement.emplace_back(0, 0, 'U', -1);\n placed_rects.emplace_back(rectangle2d(0, 0, true_wh[0].first, true_wh[0].second));\n \n for (int i = 1; i < N; ++i) {\n int best_idx = i;\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n double best_score = 1e18;\n \n for (int rot : {0, 1}) {\n rectangle2d rect;\n if (rot) {\n rect = rectangle2d(0, true_wh[i].second, true_wh[i].first, 0);\n } else {\n rect = rectangle2d(0, 0, true_wh[i].first, true_wh[i].second);\n }\n \n for (char dir : {'U', 'L'}) {\n double score = 0.0;\n rectangle2d new_rect = rect;\n if (dir == 'U') {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(0, existing.y2());\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n } else {\n for (const auto& existing : placed_rects) {\n rectangle2d candidate = new_rect;\n candidate.move(existing.x2(), 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = &existing - &placed_rects[0];\n }\n }\n candidate = new_rect;\n candidate.move(0, 0);\n score = candidate.x2() + candidate.y2();\n if (score < best_score) {\n best_score = score;\n best_rot = rot;\n best_dir = dir;\n best_b = -1;\n }\n }\n }\n }\n \n placement.emplace_back(best_idx, best_rot, best_dir, best_b);\n if (best_dir == 'U') {\n if (best_b == -1) {\n placed_rects.emplace_back(rectangle2d(0, 0, true_wh[best_idx].first, true_wh[best_idx].second));\n } else {\n rectangle2d existing = placed_rects[best_b];\n placed_rects.emplace_back(rectangle2d(0, existing.y2(), true_wh[best_idx].first, true_wh[best_idx].second));\n }\n } else {\n if (best_b == -1) {\n placed_rects.emplace_back(rectangle2d(0, 0, true_wh[best_idx].first, true_wh[best_idx].second));\n } else {\n rectangle2d existing = placed_rects[best_b];\n placed_rects.emplace_back(rectangle2d(existing.x2(), 0, true_wh[best_idx].first, true_wh[best_idx].second));\n }\n }\n }\n }\n \n cout << placement.size() << \"\\n\";\n for (const auto& p : placement) {\n cout << get<0>(p) << \" \" << get<1>(p) << \" \" << get<2>(p) << \" \" << get<3>(p) << \"\\n\";\n }\n cout.flush();\n \n int W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n if (!cin) return 0;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n }\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n vector parent(N, -1);\n\n // Simple greedy: assign each node as root if it has high beauty\n // and try to build a tree of height <= H\n\n vector> adj(N);\n for (auto [u, v] : edges) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n vector visited(N, false);\n // For each node, try to be a root and build a BFS tree up to height H\n vector degree(N, 0);\n for (auto [u, v] : edges) {\n degree[u]++;\n degree[v]++;\n }\n\n // Choose roots as nodes with highest beauty and lowest degree\n vector> candidates;\n for (int i = 0; i < N; ++i) {\n candidates.emplace_back(-A[i] - degree[i], i);\n }\n sort(candidates.begin(), candidates.end());\n\n queue q;\n for (auto [_, i] : candidates) {\n if (visited[i]) continue;\n visited[i] = true;\n parent[i] = -1;\n q.push(i);\n int height = 0;\n vector level = {i};\n while (height < H && !level.empty()) {\n height++;\n vector next_level;\n for (int u : level) {\n for (int v : adj[u]) {\n if (!visited[v] && parent[v] == -1) {\n visited[v] = true;\n parent[v] = u;\n next_level.push_back(v);\n }\n }\n }\n level = next_level;\n }\n }\n\n // Fill any unassigned nodes (should not happen in valid input)\n for (int i = 0; i < N; ++i) {\n if (parent[i] == -1) {\n parent[i] = (i + 1) % N;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << '\\n';\n\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint main() {\n int N = 20;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector> moves;\n\n auto add_moves = [&](int i, int j, bool is_row, bool left_or_up) {\n if (is_row) {\n if (left_or_up) {\n for (int k = 0; k <= j; ++k) {\n moves.emplace_back('L', i);\n }\n } else {\n for (int k = 0; k <= N - 1 - j; ++k) {\n moves.emplace_back('R', i);\n }\n }\n } else {\n if (left_or_up) {\n for (int k = 0; k <= i; ++k) {\n moves.emplace_back('U', j);\n }\n } else {\n for (int k = 0; k <= N - 1 - i; ++k) {\n moves.emplace_back('D', j);\n }\n }\n }\n };\n\n vector> removed(N, vector(N, false));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] != 'x') continue;\n bool can_left = true, can_right = true, can_up = true, can_down = true;\n for (int dj = 0; dj < j; ++dj) {\n if (board[i][dj] == 'o') {\n can_right = false;\n break;\n }\n }\n for (int dj = j + 1; dj < N; ++dj) {\n if (board[i][dj] == 'o') {\n can_left = false;\n break;\n }\n }\n for (int di = 0; di < i; ++di) {\n if (board[di][j] == 'o') {\n can_down = false;\n break;\n }\n }\n for (int di = i + 1; di < N; ++di) {\n if (board[di][j] == 'o') {\n can_up = false;\n break;\n }\n }\n\n if (can_left) {\n add_moves(i, j, true, true);\n removed[i][j] = true;\n } else if (can_right) {\n add_moves(i, j, true, false);\n removed[i][j] = true;\n } else if (can_up) {\n add_moves(i, j, false, true);\n removed[i][j] = true;\n } else if (can_down) {\n add_moves(i, j, false, false);\n removed[i][j] = true;\n }\n }\n }\n\n for (const auto& [d, p] : moves) {\n cout << d << \" \" << p << endl;\n }\n\n return 0;\n}","ahc044":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\n\nvector t(N); // target times\nvector> assignments(N); // a_i, b_i for each employee\n\nvector simulate(const vector>& assign) {\n vector count(N, 0);\n int current = 0;\n int times = 0;\n count[0]++; // first week\n times = 1; // count for employee 0\n\n for (int week = 1; week < L; ++week) {\n if (times % 2 == 1) { // odd\n current = assign[current].first;\n } else { // even\n current = assign[current].second;\n }\n count[current]++;\n times++; // increment the count for the previous employee (current before update)\n }\n return count;\n}\n\nlong long calculate_error(const vector& actual) {\n long long error = 0;\n for (int i = 0; i < N; ++i) {\n error += abs(actual[i] - t[i]);\n }\n return error;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n int dummy_n, dummy_l;\n cin >> dummy_n >> dummy_l; // should be 100 and 500000\n for (int i = 0; i < N; ++i) {\n cin >> t[i];\n }\n\n // Initialize assignments: each employee points to themselves\n for (int i = 0; i < N; ++i) {\n assignments[i] = {i, i};\n }\n\n // Simulate initial assignments\n vector current_count = simulate(assignments);\n long long current_error = calculate_error(current_count);\n\n // Local search with reduced iterations\n mt19937 rng(0); // fixed seed for deterministic behavior\n const int MAX_ITERATIONS = 200; // Reduced from 10,000 to 200\n\n for (int iter = 0; iter < MAX_ITERATIONS; ++iter) {\n int i = uniform_int_distribution(0, N-1)(rng);\n int a_candidate = uniform_int_distribution(0, N-1)(rng);\n int b_candidate = uniform_int_distribution(0, N-1)(rng);\n\n // Try new assignments for employee i\n pair old_assign = assignments[i];\n assignments[i] = {a_candidate, b_candidate};\n\n // Simulate\n vector new_count = simulate(assignments);\n long long new_error = calculate_error(new_count);\n\n if (new_error < current_error) {\n current_error = new_error;\n current_count = new_count;\n } else {\n assignments[i] = old_assign; // revert\n }\n }\n\n // Output the assignments\n for (const auto& p : assignments) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\n\n#define OVERRIDE 0\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy;\n};\n\n// Simple DBSCAN-like clustering based on center coordinates\nvector> clusterCities(const vector& cities, double eps = 200.0, int min_pts = 1) {\n int n = cities.size();\n vector visited(n, false);\n vector> clusters;\n\n for (int i = 0; i < n; ++i) {\n if (visited[i]) continue;\n visited[i] = true;\n queue q;\n q.push(i);\n vector cluster;\n\n cluster.push_back(i);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int nxt = 0; nxt < n; ++nxt) {\n if (visited[nxt]) continue;\n double dx = cities[cur].cx - cities[nxt].cx;\n double dy = cities[cur].cy - cities[nxt].cy;\n double dist = sqrt(dx*dx + dy*dy);\n if (dist <= eps) {\n visited[nxt] = true;\n q.push(nxt);\n cluster.push_back(nxt);\n }\n }\n }\n if (!cluster.empty()) {\n clusters.push_back(cluster);\n }\n }\n return clusters;\n}\n\n// Divide a cluster into groups of sizes specified in G\nvector> assignGroups(const vector& cluster, const vector& G, const vector& cities) {\n vector> groups;\n int n = cluster.size();\n int group_idx = 0;\n int start = 0;\n\n for (int g : G) {\n vector group;\n int end = start + g;\n if (end > n) {\n end = n;\n }\n for (int i = start; i < end; ++i) {\n group.push_back(cluster[i]);\n }\n groups.push_back(group);\n start = end;\n }\n return groups;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n vector cities(N);\n for (int i = 0; i < N; ++i) {\n 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 // Cluster cities based on center coordinates\n vector> clusters = clusterCities(cities);\n\n // Assign cities to groups\n vector> groups;\n vector group_sizes = G;\n\n // Try to assign groups from clusters\n for (const auto& cluster : clusters) {\n vector> cluster_groups = assignGroups(cluster, group_sizes, cities);\n for (const auto& g : cluster_groups) {\n if (g.empty()) continue;\n groups.push_back(g);\n // Decrease the corresponding group size\n for (size_t i = 0; i < group_sizes.size(); ++i) {\n if (group_sizes[i] >= (int)g.size()) {\n group_sizes[i] -= (int)g.size();\n break;\n }\n }\n }\n }\n\n // Handle remaining group sizes\n int remaining = N;\n for (const auto& g : groups) remaining -= g.size();\n if (remaining > 0) {\n // Add remaining cities to the last group\n if (!groups.empty()) {\n groups.back().resize(remaining + groups.back().size());\n } else {\n groups.push_back(vector(remaining));\n }\n }\n\n // Ensure we have exactly M groups\n while ((int)groups.size() < M) {\n groups.push_back({});\n }\n\n // Prepare queries for each group\n vector>> all_edges(M);\n\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n int sz = group.size();\n if (sz < 2) continue;\n\n // If group size is small enough, query the entire group\n if (sz <= L) {\n cout << \"? \" << sz;\n for (int id : group) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int i = 0; i < sz - 1; ++i) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n } else {\n // Break into subsets of size L\n for (int i = 0; i < sz; i += L - 1) {\n int subset_size = min(L, sz - i);\n if (subset_size < 2) break;\n\n vector subset;\n for (int j = i; j < i + subset_size; ++j) {\n subset.push_back(group[j]);\n }\n\n cout << \"? \" << subset_size;\n for (int id : subset) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int j = 0; j < subset_size - 1; ++j) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n }\n }\n }\n\n // Output the answer\n cout << \"!\" << endl;\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n cout << group.size();\n for (int id : group) cout << \" \" << id;\n cout << endl;\n\n // Output edges for this group\n for (const auto& edge : all_edges[k]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> targets(M);\n for (int i = 0; i < M; ++i) {\n cin >> targets[i].first >> targets[i].second;\n }\n\n vector> actions;\n\n // Example strategy: move to each target directly, ignoring blocks for simplicity\n // This is a placeholder and will not solve the problem correctly but serves as a starting point.\n // In a real submission, you would implement a more sophisticated pathfinding algorithm.\n\n pair current = targets[0];\n for (int i = 1; i < M; ++i) {\n int dx = targets[i].first - current.first;\n int dy = targets[i].second - current.second;\n\n if (dx > 0) {\n for (int j = 0; j < dx; ++j) {\n actions.emplace_back('M', \"D\");\n }\n } else if (dx < 0) {\n for (int j = 0; j < -dx; ++j) {\n actions.emplace_back('M', \"U\");\n }\n }\n\n if (dy > 0) {\n for (int j = 0; j < dy; ++j) {\n actions.emplace_back('M', \"R\");\n }\n } else if (dy < 0) {\n for (int j = 0; j < -dy; ++j) {\n actions.emplace_back('M', \"L\");\n }\n }\n current = targets[i];\n }\n\n for (auto& [a, d] : actions) {\n cout << a << \" \" << d << endl;\n }\n\n return 0;\n}"},"4":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2;\n long long area() const { return (long long)(x2 - x1) * (y2 - y1); }\n bool contains(double x, double y) const {\n return x > x1 && x < x2 && y > y1 && y < y2;\n }\n};\n\nint n;\nvector> input;\nvector rects;\nvector r_desired;\nvector> desired_points;\n\ndouble satisfaction(int i, const Rect& r) {\n double x = get<0>(input[i]) + 0.5, y = get<1>(input[i]) + 0.5;\n if (!r.contains(x, y)) return 0.0;\n long long s = r.area();\n long long r_val = get<2>(input[i]);\n double ratio = min(r_val, (long long)s) * 1.0 / max(r_val, (long long)s);\n return 1.0 - pow(1.0 - ratio, 2.0);\n}\n\ndouble total_satisfaction() {\n double total = 0.0;\n for (int i = 0; i < n; ++i) {\n total += satisfaction(i, rects[i]);\n }\n return total;\n}\n\nbool intersects(const Rect& a, const Rect& b) {\n return !(a.x2 <= b.x1 || a.x1 >= b.x2 || a.y2 <= b.y1 || a.y1 >= b.y2);\n}\n\nvoid init_rects() {\n rects.clear();\n for (int i = 0; i < n; ++i) {\n int x = get<0>(input[i]), y = get<1>(input[i]);\n int r = get<2>(input[i]);\n int half = max(1, (int)sqrt(r));\n rects.push_back({x, y, x + half, y + half});\n }\n}\n\nbool expand_rect(int i, int dx, int dy) {\n Rect& r = rects[i];\n Rect new_r = {r.x1 - dx, r.y1 - dy, r.x2 + dx, r.y2 + dy};\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n return false;\n }\n }\n if (new_r.x1 < 0 || new_r.y1 < 0 || new_r.x2 > 10000 || new_r.y2 > 10000) {\n return false;\n }\n rects[i] = new_r;\n return true;\n}\n\nvoid greedy_expansion() {\n for (int iter = 0; iter < 1000; ++iter) {\n for (int i = 0; i < n; ++i) {\n int dx = 1, dy = 1;\n while (expand_rect(i, dx, dy)) {\n dx++;\n dy++;\n }\n }\n }\n}\n\ndouble simulated_annealing(double T, double alpha, int steps) {\n double best_score = total_satisfaction();\n vector best_rects = rects;\n\n for (int step = 0; step < steps; ++step) {\n int i = rand() % n;\n int dx = (rand() % 5) - 2;\n int dy = (rand() % 5) - 2;\n\n Rect old_r = rects[i];\n Rect new_r = {old_r.x1 + dx, old_r.y1 + dy, old_r.x2 + dx, old_r.y2 + dy};\n\n bool valid = true;\n if (new_r.x1 < 0 || new_r.x1 >= 10000 || new_r.x2 < 0 || new_r.x2 >= 10000 ||\n new_r.y1 < 0 || new_r.y1 >= 10000 || new_r.y2 < 0 || new_r.y2 >= 10000) {\n valid = false;\n } else {\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n valid = false;\n break;\n }\n }\n }\n\n if (!valid) {\n swap(new_r, old_r);\n }\n\n double old_score = satisfaction(i, old_r);\n double new_score = satisfaction(i, new_r);\n double delta = new_score - old_score;\n\n if (delta > 0 || exp(delta / T) > (double)rand() / RAND_MAX) {\n rects[i] = new_r;\n } else {\n rects[i] = old_r;\n }\n\n double current_score = total_satisfaction();\n if (current_score > best_score) {\n best_score = current_score;\n best_rects = rects;\n }\n\n T *= alpha;\n }\n\n rects = best_rects;\n return best_score;\n}\n\nint main() {\n srand(time(nullptr));\n cin >> n;\n input.resize(n);\n r_desired.resize(n);\n desired_points.resize(n);\n\n for (int i = 0; i < n; ++i) {\n int x, y, r;\n cin >> x >> y >> r;\n input[i] = {x, y, r};\n desired_points[i] = {x + 0.5, y + 0.5};\n r_desired[i] = r;\n }\n\n init_rects();\n greedy_expansion();\n\n double T = 10000.0;\n double alpha = 0.99;\n int steps = 100000;\n\n simulated_annealing(T, alpha, steps);\n\n for (const auto& r : rects) {\n cout << r.x1 << \" \" << r.y1 << \" \" << r.x2 << \" \" << r.y2 << endl;\n }\n\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj;\n cin >> si >> sj;\n \n vector> t(50, vector(50));\n vector> p(50, vector(50));\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n }\n }\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> p[i][j];\n }\n }\n \n // Identify tiles: map from tile id to list of positions\n map>> tiles;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n tiles[t[i][j]].emplace_back(i, j);\n }\n }\n \n // For each tile, check if it's horizontal or vertical\n // and store the positions in a sorted manner\n vector>> tilePositions;\n tilePositions.reserve(tiles.size());\n for (auto &entry : tiles) {\n auto &posList = entry.second;\n sort(posList.begin(), posList.end());\n tilePositions.push_back(set>(posList.begin(), posList.end()));\n }\n \n // Create a map from position to tile index\n vector> posToTile(50, vector(50, -1));\n for (size_t ti = 0; ti < tilePositions.size(); ++ti) {\n for (auto &pos : tilePositions[ti]) {\n posToTile[pos.first][pos.second] = ti;\n }\n }\n \n // Directions: up, down, left, right\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n vector dirChar = {'U', 'D', 'L', 'R'};\n \n // BFS to find a path\n vector> visited(50, vector(50, false));\n vector> path(50, vector(50, '\\0'));\n queue> q;\n \n q.emplace(si, sj);\n visited[si][sj] = true;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (size_t d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited[ni][nj]) continue;\n \n // Check if the new position is on the same tile as the current one\n if (posToTile[i][j] == posToTile[ni][nj]) continue;\n \n visited[ni][nj] = true;\n path[ni][nj] = dirChar[d];\n q.emplace(ni, nj);\n }\n }\n \n // Reconstruct the path from si, sj to the furthest point\n string output;\n pair current = {si, sj};\n while (true) {\n bool found = false;\n for (size_t d = 0; d < 4; ++d) {\n int ni = current.first + dirs[d].first;\n int nj = current.second + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (path[ni][nj] == '\\0') continue;\n // Check tile uniqueness\n if (posToTile[current.first][current.second] == posToTile[ni][nj]) continue;\n output += dirChar[d];\n current = {ni, nj};\n found = true;\n break;\n }\n if (!found) break;\n }\n \n cout << output << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint H, W; // 30x30 grid\nvector> h_est, v_est; // estimated horizontal and vertical edge weights\nvector> h_cnt, v_cnt; // count of usage for each edge\n\nvector dirs = {\"U\", \"D\", \"L\", \"R\"};\n\n// BFS to generate a path\nstring bfs_path(int si, int sj, int ti, int tj) {\n vector> dist(H, vector(W, -1));\n vector> prev(H, vector

(W, {-1, -1}));\n queue

q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break;\n vector

ns;\n if (i > 0) ns.emplace_back(i-1, j);\n if (i < H-1) ns.emplace_back(i+1, j);\n if (j > 0) ns.emplace_back(i, j-1);\n if (j < W-1) ns.emplace_back(i, j+1);\n for (auto [ni, nj] : ns) {\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n q.emplace(ni, nj);\n }\n }\n }\n if (dist[ti][tj] == -1) return \"\";\n string path;\n P cur = {ti, tj};\n while (cur != P(si, sj)) {\n P p = prev[cur.first][cur.second];\n int di = cur.first - p.first;\n int dj = cur.second - p.second;\n if (di == -1) path += 'U';\n else if (di == 1) path += 'D';\n else if (dj == -1) path += 'L';\n else if (dj == 1) path += 'R';\n cur = p;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Random walk to generate a path\nstring random_walk(int si, int sj, int ti, int tj, int max_steps) {\n string path;\n int i = si, j = sj;\n while (max_steps-- > 0 && (i != ti || j != tj)) {\n vector possible;\n if (i > 0) possible.push_back('U');\n if (i < H-1) possible.push_back('D');\n if (j > 0) possible.push_back('L');\n if (j < W-1) possible.push_back('R');\n char move = possible[rand() % possible.size()];\n path += move;\n if (move == 'U') i--;\n else if (move == 'D') i++;\n else if (move == 'L') j--;\n else if (move == 'R') j++;\n }\n return path;\n}\n\n// Estimate edge weight from observed lengths\ndouble estimate_edge_weight(int i, int j, char dir) {\n if (dir == 'L' || dir == 'R') {\n if (h_cnt[i][j] == 0) return 1500.0;\n return h_est[i][j] * 1.0 / h_cnt[i][j];\n } else {\n if (v_cnt[i][j] == 0) return 1500.0;\n return v_est[i][j] * 1.0 / v_cnt[i][j];\n }\n}\n\nint main() {\n H = 30, W = 30;\n h_est.assign(H, vector(W, 0));\n v_est.assign(H, vector(W, 0));\n h_cnt.assign(H, vector(W, 0));\n v_cnt.assign(H, vector(W, 0));\n \n srand(time(nullptr));\n \n int query_count = 0;\n while (true) {\n int si, sj, ti, tj;\n if (query_count == 0) {\n cin >> si >> sj >> ti >> tj;\n } else {\n // Read the previous result (b_k)\n ll b_prev;\n cin >> b_prev;\n // Update the estimates based on the path taken in the previous query\n // This is a placeholder; actual implementation would track the path\n }\n \n // Generate multiple candidate paths\n string path1 = bfs_path(si, sj, ti, tj);\n string path2 = random_walk(si, sj, ti, tj, abs(si - ti) + abs(sj - tj) * 2);\n string path3 = random_walk(si, sj, ti, tj, abs(si - ti) * 2 + abs(sj - tj));\n \n vector candidates = {path1, path2, path3};\n if (candidates[0].empty()) candidates.erase(candidates.begin());\n \n // Select a path based on estimated weights\n double scores[3] = {0.0};\n for (int idx = 0; idx < candidates.size(); idx++) {\n string& p = candidates[idx];\n double score = 0.0;\n int pi = si, pj = sj;\n for (char c : p) {\n if (c == 'U' || c == 'D') {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n } else {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n scores[idx] = 1.0 / score;\n }\n \n // Choose the best candidate\n double max_score = -1.0;\n int best_idx = 0;\n for (int idx = 0; idx < candidates.size(); idx++) {\n if (scores[idx] > max_score) {\n max_score = scores[idx];\n best_idx = idx;\n }\n }\n \n string path = candidates[best_idx];\n \n // Output the path\n cout << path << endl;\n cout.flush();\n \n // Read the result (b_k)\n ll b_k;\n cin >> b_k;\n \n // Update estimates based on the path taken\n int pi = si, pj = sj;\n for (char c : path) {\n if (c == 'L' || c == 'R') {\n h_est[pi][pj] += b_k; // placeholder update\n h_cnt[pi][pj]++;\n } else {\n v_est[pi][pj] += b_k;\n v_cnt[pi][pj]++;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n \n query_count++;\n }\n \n return 0;\n}","ahc004":"#include \nusing namespace std;\n\n// Helper function to check if a string can be placed horizontally or vertically\nbool canPlaceHorizontal(const vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % 20;\n if (matrix[i][col] != '.' && matrix[i][col] != s[k]) {\n return false;\n }\n }\n return true;\n}\n\nbool canPlaceVertical(const vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % 20;\n if (matrix[row][j] != '.' && matrix[row][j] != s[k]) {\n return false;\n }\n }\n return true;\n}\n\n// Function to place a string horizontally or vertically\nvoid placeHorizontal(vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % 20;\n matrix[i][col] = s[k];\n }\n}\n\nvoid placeVertical(vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % 20;\n matrix[row][j] = s[k];\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 20;\n int M;\n cin >> N >> M;\n vector strings(M);\n for (int i = 0; i < M; ++i) {\n cin >> strings[i];\n }\n\n // Sort strings by length in descending order\n sort(strings.begin(), strings.end(), [](const string& a, const string& b) {\n return a.size() > b.size();\n });\n\n vector> matrix(N, vector(N, '.'));\n\n // Place strings with enhanced placement strategy\n for (const auto& s : strings) {\n int len = s.size();\n bool placed = false;\n\n // Try horizontal placement with enhanced strategy\n for (int i = 0; i < N && !placed; ++i) {\n for (int j = 0; j <= N - len && !placed; ++j) {\n if (canPlaceHorizontal(matrix, i, j, s)) {\n placeHorizontal(matrix, i, j, s);\n placed = true;\n }\n }\n }\n\n // Try vertical placement with enhanced strategy\n if (!placed) {\n for (int j = 0; j < N && !placed; ++j) {\n for (int i = 0; i <= N - len && !placed; ++i) {\n if (canPlaceVertical(matrix, i, j, s)) {\n placeVertical(matrix, i, j, s);\n placed = true;\n }\n }\n }\n }\n }\n\n // Character frequency analysis for filling empty cells\n vector charFreq(8, 0);\n for (const auto& s : strings) {\n for (char c : s) {\n charFreq[c - 'A']++;\n }\n }\n\n // Fill empty cells with the most frequent character\n char mostFrequentChar = 'A';\n int maxFreq = charFreq[0];\n for (int i = 0; i < 8; ++i) {\n if (charFreq[i] > maxFreq) {\n maxFreq = charFreq[i];\n mostFrequentChar = 'A' + i;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] == '.') {\n matrix[i][j] = mostFrequentChar;\n }\n }\n }\n\n // Local search to minimize empty cells and conflicts\n // This is a simple version where we try to swap characters to reduce conflicts\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] != '.') {\n for (int k = 0; k < N; ++k) {\n for (int l = 0; l < N; ++l) {\n if (i != k || j != l) {\n swap(matrix[i][j], matrix[k][l]);\n // Check if the swap improved the placement\n // (This is a placeholder for a more sophisticated check)\n swap(matrix[i][j], matrix[k][l]); // Revert the swap\n }\n }\n }\n }\n }\n }\n\n // Output the matrix\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << matrix[i][j];\n }\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector> time(N, vector(N, 0));\n vector> is_road(N, vector(N, false));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n is_road[i][j] = true;\n time[i][j] = grid[i][j] - '0';\n }\n }\n }\n \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.emplace_back(i, j);\n }\n }\n }\n \n vector directions = {\"U\", \"D\", \"L\", \"R\"};\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n \n vector>> adjacency(N, vector>(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 for (int d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && is_road[ni][nj]) {\n adjacency[i][j].emplace_back(ni, nj);\n }\n }\n }\n }\n \n vector path;\n set> visited;\n vector> seen(N, vector(N, false));\n \n function dfs = [&](int i, int j) {\n stack> st;\n st.emplace(i, j);\n visited.insert({i, j});\n seen[i][j] = true;\n vector> points = {i, j};\n \n while (!st.empty()) {\n auto [x, y] = st.top();\n st.pop();\n points.push_back({x, y});\n for (auto [nx, ny] : adjacency[x][y]) {\n if (!seen[nx][ny]) {\n seen[nx][ny] = true;\n st.emplace(nx, ny);\n }\n }\n }\n \n for (auto [x, y] : points) {\n path.push_back(\"D\");\n }\n };\n \n dfs(si, sj);\n \n string result;\n int curr_i = si, curr_j = sj;\n for (char move : path) {\n int di = 0, dj = 0;\n if (move == 'U') di = -1;\n if (move == 'D') di = 1;\n if (move == 'L') dj = -1;\n if (move == 'R') dj = 1;\n curr_i += di;\n curr_j += dj;\n result += move;\n }\n \n cout << result << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct Task {\n vector d; // required skills\n vector deps; // dependencies\n int index;\n int earliest_start_day = 0; // Earliest possible start day based on dependencies\n int assigned_to = -1; // Which team member is assigned (-1 if not assigned)\n int start_day = -1; // Actual start day (-1 if not started)\n int completion_day = -1; // Completion day (-1 if not completed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].d.resize(K);\n for (int j = 0; j < K; ++j) {\n cin >> tasks[i].d[j];\n }\n tasks[i].index = i;\n }\n\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].deps.push_back(u);\n }\n\n // Build adjacency list for dependency graph\n vector> dep_graph(N);\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int dep : tasks[i].deps) {\n dep_graph[dep].push_back(i);\n in_degree[i]++;\n }\n }\n\n // Initial skill estimates for each team member (initialized to zero)\n vector> skillestimates(M, vector(K, 0.0));\n\n // Track completion times for each team member (for skill update)\n vector completion_times(M, 0.0); // Cumulative completion time\n vector task_count(M, 0); // Number of tasks completed by each member\n\n // Track which team members are busy (assigned a task)\n vector busy(M, false);\n\n // Track completed tasks\n vector completed(N, false);\n\n // Track available tasks (tasks with all dependencies completed)\n queue available_tasks;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n available_tasks.push(i);\n }\n }\n\n // Process days until all tasks are completed or day 2000\n for (int day = 1; day <= 2000; ++day) {\n // Collect tasks to assign today\n vector> assignments;\n\n // For each available team member, assign the \"best\" available task\n for (int member = 0; member < M; ++member) {\n if (busy[member]) continue; // Skip if busy\n\n // Find the best task for this member from available tasks\n int best_task = -1;\n double min_estimated_time = INFINITY;\n // We need to consider tasks that are available and not completed\n // For simplicity, we'll iterate through all tasks and check if available\n for (int t = 0; t < N; ++t) {\n if (completed[t]) continue;\n if (in_degree[t] > 0) continue; // Not available yet\n\n // Estimate time for this member to do this task\n double w = 0.0;\n for (int k = 0; k < K; ++k) {\n w += max(0.0, tasks[t].d[k] - skillestimates[member][k]);\n }\n double estimated_time = (w == 0) ? 1.0 : max(1.0, w + uniform_real_distribution(-3.0, 3.0).operator()());\n\n if (estimated_time < min_estimated_time) {\n min_estimated_time = estimated_time;\n best_task = t;\n }\n }\n\n if (best_task != -1) {\n assignments.emplace_back(member, best_task);\n busy[member] = true;\n tasks[best_task].assigned_to = member;\n tasks[best_task].start_day = day;\n }\n }\n\n // Output assignments\n cout << assignments.size();\n for (auto& [member, task] : assignments) {\n cout << \" \" << member + 1 << \" \" << task + 1;\n }\n cout << endl;\n cout.flush();\n\n // Read input: either -1 or list of completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n\n vector completed_members;\n for (int i = 0; i < n_completed; ++i) {\n int member;\n cin >> member;\n member--;\n completed_members.push_back(member);\n }\n\n // Update skill estimates and mark tasks as completed\n for (int member : completed_members) {\n if (busy[member]) {\n // Find which task this member completed\n for (int t = 0; t < N; ++t) {\n if (tasks[t].assigned_to == member && tasks[t].completion_day == -1) {\n // Assume we get the actual completion time from the problem, but here we simulate\n // For real submission, we don't have actual time, so we cannot update skills.\n // In a real scenario, we would need to get actual completion time from the judge.\n // Since we don't have it, we skip skill update for now.\n tasks[t].completion_day = day;\n completed[t] = true;\n busy[member] = false;\n\n // Update dependency graph: this task's dependents may now be available\n for (int next_task : dep_graph[t]) {\n in_degree[next_task]--;\n if (in_degree[next_task] == 0) {\n available_tasks.push(next_task);\n }\n }\n break;\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int a, b, c, d;\n Order(int a_=0, int b_=0, int c_=0, int d_=0) : a(a_), b(b_), c(c_), d(d_) {}\n};\n\n// Manhattan distance\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Heuristic: Choose orders that are close to the center and have short total distance\nvector select_orders(const vector& orders) {\n vector> scores;\n for(int i = 0; i < orders.size(); i++) {\n const auto& o = orders[i];\n int dist_to_center = dist(o.a, o.b, 400, 400) + dist(o.c, o.d, 400, 400);\n int dist_total = dist(o.a, o.b, o.c, o.d);\n scores.emplace_back(dist_to_center + dist_total, i);\n }\n sort(scores.begin(), scores.end());\n vector selected;\n for(int i = 0; i < 50; i++) {\n selected.push_back(scores[i].second);\n }\n return selected;\n}\n\nvector> construct_route(const vector& orders, const vector& selected) {\n vector> route;\n route.emplace_back(400, 400); // Start at center\n \n for(int idx : selected) {\n const auto& o = orders[idx];\n route.emplace_back(o.a, o.b); // Go to pickup\n route.emplace_back(o.c, o.d); // Then to delivery\n }\n \n // Return to center at the end\n route.emplace_back(400, 400);\n return route;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read all orders\n vector orders(1000);\n for(int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n orders[i] = Order(a, b, c, d);\n }\n \n // Select 50 orders based on heuristic\n vector selected = select_orders(orders);\n \n // Construct route\n vector> route = construct_route(orders, selected);\n \n // Output\n cout << \"50\";\n for(int idx : selected) cout << \" \" << (idx+1);\n cout << \"\\n\" << route.size();\n for(auto [x,y] : route) cout << \" \" << x << \" \" << y;\n cout << endl;\n \n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\nint round_sqrt(long long x) {\n long long s = sqrt(x);\n if ((s + 1) * (s + 1) <= x) s++;\n return (int)s;\n}\n\nint distance(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return round_sqrt(dx * dx + dy * dy);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 400, M = 1995;\n vector points(N);\n vector> edges(M);\n\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n int u = edges[i].first, v = edges[i].second;\n d[i] = distance(points[u], points[v]);\n }\n\n vector added(M, false);\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n \n function find = [&](int u) {\n while (parent[u] != u) {\n parent[u] = parent[parent[u]];\n u = parent[u];\n }\n return u;\n };\n\n auto unite = [&](int u, int v) {\n u = find(u);\n v = find(v);\n if (u == v) return false;\n parent[v] = u;\n return true;\n };\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n int u = edges[i].first, v = edges[i].second;\n if (unite(u, v)) {\n cout << \"1\\n\";\n added[i] = true;\n } else {\n cout << \"0\\n\";\n }\n cout.flush();\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N;\n vector> pets(N);\n for (int i = 0; i < N; ++i) {\n int x, y, t;\n cin >> x >> y >> t;\n pets[i] = {x - 1, y - 1, t};\n }\n cin >> M;\n vector> humans(M);\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n humans[i] = {x - 1, y - 1};\n }\n\n vector> grid(30, vector(30, false));\n vector> blocked(30, vector(30, false));\n for (auto [x, y, _] : pets) grid[x][y] = true;\n for (auto [x, y] : humans) grid[x][y] = true;\n\n for (int turn = 0; turn < 300; ++turn) {\n string action;\n for (int i = 0; i < M; ++i) {\n int x = humans[i].first;\n int y = humans[i].second;\n\n // Try to move first\n vector> moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n vector dirs = {'D', 'U', 'R', 'L'};\n int best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n // Check if adjacent to any pet\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n humans[i] = {moves[best].first, moves[best].second};\n grid[x][y] = false;\n grid[moves[best].first][moves[best].second] = true;\n } else {\n // Try to block\n best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n // Check if adjacent to any pet\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += tolower(dirs[best]);\n blocked[moves[best].first][moves[best].second] = true;\n } else {\n action += '.';\n }\n }\n }\n cout << action << endl;\n cout.flush();\n\n // Read pet moves\n string pet_moves_line;\n getline(cin >> ws, pet_moves_line); // Ensure we read the entire line\n istringstream iss(pet_moves_line);\n for (int i = 0; i < N; ++i) {\n string move;\n iss >> move;\n auto& [x, y, type] = pets[i]; // Correctly access tuple elements\n if (!move.empty()) {\n for (char c : move) {\n if (c == 'U') x--;\n else if (c == 'D') x++;\n else if (c == 'L') y--;\n else if (c == 'R') y++;\n }\n }\n }\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n cout << \"R\" << endl;\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Direction transition table: to[tile][enter_dir] = exit_dir or -1\nint 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\nvector> grid(30, vector(30));\nvector> rotation(30, vector(30, 0));\n\nint computeLength(int si, int sj, int sd, const vector>& rot) {\n int i = si, j = sj;\n int d = sd;\n int length = 0;\n vector> visited(30, vector(30, -1));\n int visit_id = abs(hash>(rot)) % 1000; // Just a dummy unique\n\n while (true) {\n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n int tile = grid[i][j] + 4 * rotation[i][j];\n d = to[tile][d];\n if (d == -1) return 0;\n int ni = i + di[d];\n int nj = j + dj[d];\n d = (d + 2) % 4;\n length++;\n if (ni == si && nj == sj && d == sd) {\n return length;\n }\n if (visited[i][j] == visit_id) {\n // Detect cycle but not closed properly\n return 0;\n }\n visited[i][j] = visit_id;\n i = ni;\n j = nj;\n }\n}\n\npair getTwoMaxLengths(const vector>& rot) {\n priority_queue pq;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int len = computeLength(i, j, d, rot);\n if (len > 0) pq.push(len);\n }\n }\n }\n if (pq.size() < 2) {\n return {0, 0};\n }\n int max1 = pq.top(); pq.pop();\n int max2 = pq.top(); pq.pop();\n return {max1, max2};\n}\n\nint score(const vector>& rot) {\n auto [l1, l2] = getTwoMaxLengths(rot);\n if (l1 == 0 || l2 == 0) return 0;\n return l1 * l2;\n}\n\nvector> rotateRandom() {\n vector> rot(30, vector(30));\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rot[i][j] = rand() % 4;\n }\n }\n return rot;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cin >> grid[i][j];\n }\n }\n\n // Initialize with random rotations\n vector> best_rot = rotateRandom();\n int best_score = score(best_rot);\n\n // Simple hill climbing\n const int iterations = 2000;\n for (int iter = 0; iter < iterations; iter++) {\n // Pick a random tile\n int i = rand() % 30;\n int j = rand() % 30;\n int old_rot = best_rot[i][j];\n for (int delta = 1; delta <= 3; delta++) {\n int new_rot = (old_rot + delta) % 4;\n best_rot[i][j] = new_rot;\n int current_score = score(best_rot);\n if (current_score > best_score) {\n best_score = current_score;\n } else {\n best_rot[i][j] = old_rot;\n }\n }\n }\n\n // Output the best rotations found\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n if (j < 29) cout << \" \";\n }\n cout << endl;\n }\n\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint N;\nvector board;\nmap hex_to_int = {\n {'0', 0}, {'1', 1}, {'2', 2}, {'3', 3},\n {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7},\n {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11},\n {'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}\n};\n\nint int_to_dir(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 -1;\n}\n\nchar dir_to_char(int d) {\n if (d == 0) return 'U';\n if (d == 1) return 'D';\n if (d == 2) return 'L';\n if (d == 3) return 'R';\n return 'X';\n}\n\nbool is_valid(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n}\n\nint get_bit(int mask, int pos) {\n return (mask >> pos) & 1;\n}\n\nint get_connection(int i, int j, int dir) {\n int mask = hex_to_int[board[i][j]];\n if (dir == 0) return get_bit(mask, 1); // up\n if (dir == 1) return get_bit(mask, 3); // down\n if (dir == 2) return get_bit(mask, 0); // left\n if (dir == 3) return get_bit(mask, 2); // right\n return 0;\n}\n\nvector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n\npair move_empty(int i, int j, int dir) {\n int ni = i + dirs[dir].first;\n int nj = j + dirs[dir].second;\n if (!is_valid(ni, nj) || board[ni][nj] == '0') return {-1, -1};\n return {ni, nj};\n}\n\nint count_components() {\n vector> visited(N, vector(N, false));\n int components = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == '0') continue;\n if (!visited[i][j]) {\n components++;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n int mask = hex_to_int[board[x][y]];\n for (int d = 0; d < 4; ++d) {\n if (get_connection(x, y, d)) {\n int nx = x + dirs[d].first, ny = y + dirs[d].second;\n if (is_valid(nx, ny) && board[nx][ny] != '0' && !visited[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n }\n }\n }\n return components;\n}\n\nvector solve() {\n int empty_i = -1, empty_j = -1;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == '0') {\n empty_i = i;\n empty_j = j;\n }\n vector result;\n vector> history;\n history.emplace_back(empty_i, empty_j);\n\n for (int step = 0; step < 2 * N * N * N; ++step) {\n int best_components = count_components();\n char best_move = 0;\n vector> best_pos = {empty_i, empty_j};\n\n for (int d = 0; d < 4; ++d) {\n auto [ni, nj] = move_empty(empty_i, empty_j, d);\n if (ni == -1) continue;\n swap(board[empty_i][empty_j], board[ni][nj]);\n int components = count_components();\n swap(board[empty_i][empty_j], board[ni][nj]);\n\n if (components < best_components) {\n best_components = components;\n best_move = dir_to_char(d);\n best_pos = {ni, nj};\n }\n }\n\n if (best_move == 0) break;\n\n result.push_back(best_move);\n swap(board[empty_i][empty_j], board[best_pos.first][best_pos.second]);\n empty_i = best_pos.first;\n empty_j = best_pos.second;\n history.emplace_back(empty_i, empty_j);\n }\n\n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n int T = 2 * N * N * N;\n board.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n auto result = solve();\n\n cout << string(result.begin(), result.end()) << endl;\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\n// Define Point structure\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n \n // Overload equality operator for Point\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\n// Compute cross product of vectors (p1 - o) and (p2 - o)\nlong long cross(const Point& o, const Point& p1, const Point& p2) {\n return (long long)(p1.x - o.x) * (p2.y - o.y) - (long long)(p1.y - o.y) * (p2.x - o.x);\n}\n\n// Check if point p is on the left side of the directed line (a, b)\nbool isLeft(const Point& a, const Point& b, const Point& p) {\n return cross(a, b, p) > 0;\n}\n\n// Compute orientation of three points (clockwise, counterclockwise, or collinear)\nint orientation(const Point& p, const Point& q, const Point& r) {\n long long val = (long long)(q.y - p.y) * (r.x - q.x) - (long long)(q.x - p.x) * (r.y - q.y);\n if (val == 0) return 0; // Collinear\n return (val > 0) ? 1 : 2; // Clockwise or Counterclockwise\n}\n\n// Compute Euclidean distance squared between two points\nlong long dist(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\n// Graham scan to compute convex hull\nvector convexHull(vector points) {\n int n = points.size();\n if (n <= 1) return points;\n\n // Find the lowest point\n int i = 0;\n for (int j = 1; j < n; j++)\n if (points[j].y < points[i].y || (points[j].y == points[i].y && points[j].x < points[i].x))\n i = j;\n\n // Sort points angularly around the pivot\n sort(points.begin(), points.end(), [&](const Point& a, const Point& b) {\n int o = orientation(points[i], a, b);\n if (o == 0) return (dist(points[i], a) < dist(points[i], b));\n return o == 1;\n });\n\n vector hull;\n hull.push_back(points[i]);\n\n for (int j = 1; j < n; j++) {\n while (hull.size() >= 2 && orientation(hull[hull.size()-2], hull.back(), points[j]) != 2)\n hull.pop_back();\n hull.push_back(points[j]);\n }\n\n return hull;\n}\n\n// Compute centroid of a set of points\nPoint centroid(const vector& points) {\n if (points.empty()) return Point(0, 0);\n long long cx = 0, cy = 0;\n for (const auto& p : points) {\n cx += p.x;\n cy += p.y;\n }\n return Point(cx / points.size(), cy / points.size());\n}\n\n// Generate a line that separates cluster from others using PCA on angles\nvector> separateClusters(const vector>& clusters) {\n vector> lines;\n for (size_t i = 0; i < clusters.size(); ++i) { // Use size_t to match clusters.size()\n const auto& cluster = clusters[i];\n if (cluster.empty()) continue;\n\n // Compute centroid of the cluster\n Point c = centroid(cluster);\n\n // Collect vectors from centroid to points\n vector vectors;\n for (const auto& p : cluster) {\n vectors.emplace_back(p.x - c.x, p.y - c.y);\n }\n\n // Compute PCA to find principal direction\n double sum_x2 = 0, sum_y2 = 0, sum_xy = 0;\n for (const auto& v : vectors) {\n sum_x2 += (double)v.x * v.x;\n sum_y2 += (double)v.y * v.y;\n sum_xy += (double)v.x * v.y;\n }\n\n int n = vectors.size();\n if (n == 0) continue;\n\n double trace = sum_x2 + sum_y2;\n double det = sum_x2 * sum_y2 - sum_xy * sum_xy;\n\n // Skip if degenerate\n if (abs(det) < 1e-9) continue;\n\n // Compute eigenvalues\n double eigen_val1 = (trace + sqrt(trace * trace - 4 * det)) / 2;\n double eigen_val2 = (trace - sqrt(trace * trace - 4 * det)) / 2;\n\n // Find eigenvector for smaller eigenvalue (minor component)\n double eigen_val = eigen_val2;\n double discriminant = sqrt((sum_x2 - eigen_val) * (sum_y2 - eigen_val) - sum_xy * sum_xy);\n if (abs(discriminant) < 1e-9) continue;\n\n double cos_theta = (sum_x2 - eigen_val) / discriminant;\n double sin_theta = sum_xy / discriminant;\n\n // Rotate to find perpendicular direction for cut line\n double nx = -sin_theta, ny = cos_theta;\n\n // Create line far enough to pass through centroid\n Point p1(c.x + 100000 * nx, c.y + 100000 * ny);\n Point p2(c.x - 100000 * nx, c.y - 100000 * ny);\n\n lines.emplace_back(p1, p2);\n }\n return lines;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n if(!(cin >> N >> K)) return 0; // Handle input errors gracefully\n vector a(10);\n for (int i = 0; i < 10; ++i) {\n if (!(cin >> a[i])) return 0;\n }\n\n vector strawberries(N);\n for (int i = 0; i < N; ++i) {\n if (!(cin >> strawberries[i].x >> strawberries[i].y)) return 0;\n }\n\n // Simple clustering: assign to clusters of size close to target sizes\n vector> clusters(10);\n vector target(10);\n for (int d = 0; d < 10; ++d) target[d] = a[d] * (d + 1);\n\n // Greedy assignment\n vector used(N, false); // Track which strawberries have been used\n for (int d = 0; d < 10; ++d) {\n int need = target[d];\n while (need > 0) {\n int best = -1;\n int best_count = 0;\n for (int i = 0; i < N; ++i) {\n if (used[i]) continue; // Skip if already used\n bool found = false;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (p == strawberries[i]) {\n found = true;\n break;\n }\n }\n if (found) break;\n }\n if (found) continue;\n\n int cnt = 0;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (dist(p, strawberries[i]) <= 100) ++cnt;\n }\n }\n if (cnt > best_count) {\n best_count = cnt;\n best = i;\n }\n }\n if (best == -1) break;\n clusters[d].push_back(strawberries[best]);\n used[best] = true; // Mark as used\n --need;\n }\n }\n\n // Flatten clusters and generate separating lines\n vector> lines = separateClusters(clusters);\n\n // Output\n cout << lines.size() << \"\\n\";\n for (const auto& line : lines) {\n cout << line.first.x << \" \" << line.first.y << \" \"\n << line.second.x << \" \" << line.second.y << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint N;\nvector> grid;\nvector

dots;\nmap dot_map;\nset

drawn_rects;\nset

new_dots;\n\nstruct Rect {\n P p1, p2, p3, p4;\n int score;\n};\n\nvector candidates;\n\nbool is_valid_rect(const P& p1, const P& p2, const P& p3, const P& p4) {\n vector

perimeter;\n perimeter.push_back(p1);\n perimeter.push_back(p2);\n perimeter.push_back(p3);\n perimeter.push_back(p4);\n if (p1.x == p2.x && p2.x == p3.x && p3.x == p4.x) return false;\n if (p1.y == p2.y && p2.y == p3.y && p3.y == p4.y) return false;\n\n for (const auto& pt : perimeter) {\n if (pt.x < 0 || pt.x >= N || pt.y < 0 || pt.y >= N) return false;\n }\n\n for (int i = 0; i < 4; ++i) {\n for (int j = i + 1; j < 4; ++j) {\n for (int k = j + 1; k < 4; ++k) {\n if ((perimeter[i].x == perimeter[j].x && perimeter[i].y == perimeter[j].y) ||\n (perimeter[i].x == perimeter[k].x && perimeter[i].y == perimeter[k].y) ||\n (perimeter[j].x == perimeter[k].x && perimeter[j].y == perimeter[k].y)) {\n return false;\n }\n }\n }\n }\n\n for (const auto& pt : perimeter) {\n if (dot_map.count(pt)) continue;\n if (new_dots.count(pt)) continue;\n if (grid[pt.x][pt.y] == 0) continue;\n return false;\n }\n\n for (const auto& pt : perimeter) {\n for (const auto& d : dots) {\n if (d == pt) continue;\n if (grid[d.x][d.y] == 0) continue;\n if (pt.x == d.x && pt.y == d.y) return false;\n }\n if (new_dots.count(pt)) {\n for (const auto& d : dots) {\n if (d == pt) continue;\n if (grid[d.x][d.y] == 0) continue;\n if (pt.x == d.x && pt.y == d.y) return false;\n }\n }\n }\n\n for (const auto& pt : perimeter) {\n for (const auto& rect : drawn_rects) {\n if (pt.x == rect.x && pt.y == rect.y) return false;\n }\n }\n\n int min_x = min({p1.x, p2.x, p3.x, p4.x});\n int max_x = max({p1.x, p2.x, p3.x, p4.x});\n int min_y = min({p1.y, p2.y, p3.y, p4.y});\n int max_y = max({p1.y, p2.y, p3.y, p4.y});\n\n for (int x = min_x; x <= max_x; ++x) {\n for (int y = min_y; y <= max_y; ++y) {\n if (x == p1.x && y == p1.y) continue;\n if (x == p2.x && y == p2.y) continue;\n if (x == p3.x && y == p3.y) continue;\n if (x == p4.x && y == p4.y) continue;\n if (grid[x][y] != 0) return false;\n }\n }\n\n return true;\n}\n\nint calculate_score(const P& p) {\n ll c = (N - 1) / 2;\n ll dx = p.x - c;\n ll dy = p.y - c;\n return (dx * dx + dy * dy + 1);\n}\n\nvoid generate_candidates() {\n candidates.clear();\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n if (dot_map.count({x, y})) continue;\n if (new_dots.count({x, y})) continue;\n\n for (int dx : {1, -1}) {\n for (int dy : {1, -1}) {\n if (dx == 0 || dy == 0) continue;\n int x2 = x + dx, y2 = y + dy;\n int x3 = x - dx, y3 = y + dy;\n int x4 = x - dx, y4 = y - dy;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n }\n\n for (int dx : {1, -1}) {\n int x2 = x + dx, y2 = y;\n int x3 = x, y3 = y + dx;\n int x4 = x + dx, y4 = y - dx;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n\n for (int dy : {1, -1}) {\n int y2 = y + dy, x2 = x;\n int y3 = y, x3 = x + dy;\n int y4 = y + dy, x4 = x - dy;\n\n if (x2 < 0 || x2 >= N || y2 < 0 || y2 >= N) continue;\n if (x3 < 0 || x3 >= N || y3 < 0 || y3 >= N) continue;\n if (x4 < 0 || x4 >= N || y4 < 0 || y4 >= N) continue;\n\n if (!dot_map.count({x2, y2}) && !new_dots.count({x2, y2})) continue;\n if (!dot_map.count({x3, y3}) && !new_dots.count({x3, y3})) continue;\n if (!dot_map.count({x4, y4}) && !new_dots.count({x4, y4})) continue;\n\n if (is_valid_rect({x, y}, {x2, y2}, {x3, y3}, {x4, y4})) {\n int score = calculate_score({x, y});\n candidates.push_back({ {x, y}, {x2, y2}, {x3, y3}, {x4, y4}, score });\n }\n }\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n grid.assign(N, vector(N, 0));\n dots.clear();\n dot_map.clear();\n\n int M;\n cin >> M;\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n dots.emplace_back(x, y);\n dot_map[{x, y}] = 1;\n grid[x][y] = 1;\n }\n\n vector solutions;\n\n while (true) {\n generate_candidates();\n if (candidates.empty()) break;\n\n sort(candidates.begin(), candidates.end(), [](const Rect& a, const Rect& b) {\n return a.score > b.score;\n });\n\n auto best = candidates[0];\n solutions.push_back(best);\n\n grid[best.p1.x][best.p1.y] = 1;\n new_dots.insert({best.p1.x, best.p1.y});\n\n P p2 = best.p2, p3 = best.p3, p4 = best.p4;\n drawn_rects.insert(p2);\n drawn_rects.insert(p3);\n drawn_rects.insert(p4);\n drawn_rects.insert(best.p1);\n }\n\n cout << solutions.size() << \"\\n\";\n for (const auto& sol : solutions) {\n cout << sol.p1.x << \" \" << sol.p1.y << \" \"\n << sol.p2.x << \" \" << sol.p2.y << \" \"\n << sol.p3.x << \" \" << sol.p3.y << \" \"\n << sol.p4.x << \" \" << sol.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstruct Cell {\n int flavor = 0; // 0: empty\n};\n\nconst int SIZE = 10;\nCell grid[SIZE][SIZE];\n\nvoid reset_empty() {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j].flavor = 0;\n }\n }\n}\n\nvector> get_empty_cells() {\n vector> empty;\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) {\n empty.emplace_back(i, j);\n }\n }\n }\n return empty;\n}\n\nvoid place_candy(int t, int p, int flavor) {\n vector> empty = get_empty_cells();\n auto [i, j] = empty[p - 1];\n grid[i][j].flavor = flavor;\n}\n\nvoid tilt(const char dir) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) continue;\n if (dir == 'F') {\n for (int k = i - 1; k >= 0; --k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k+1][j].flavor == 0) {\n swap(grid[i][j], grid[k+1][j]);\n }\n break;\n }\n }\n } else if (dir == 'B') {\n for (int k = i + 1; k < SIZE; ++k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k-1][j].flavor == 0) {\n swap(grid[i][j], grid[k-1][j]);\n }\n break;\n }\n }\n } else if (dir == 'L') {\n for (int k = j - 1; k >= 0; --k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k+1].flavor == 0) {\n swap(grid[i][j], grid[i][k+1]);\n }\n break;\n }\n }\n } else if (dir == 'R') {\n for (int k = j + 1; k < SIZE; ++k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k-1].flavor == 0) {\n swap(grid[i][j], grid[i][k-1]);\n }\n break;\n }\n }\n }\n }\n }\n}\n\nvector calculate_components() {\n vector> visited(SIZE, vector(SIZE, false));\n vector component_sizes(3, 0);\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (visited[i][j] || grid[i][j].flavor == 0) continue;\n int flavor = grid[i][j].flavor;\n queue> q;\n q.emplace(i, j);\n visited[i][j] = true;\n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (nx >= 0 && nx < SIZE && ny >= 0 && ny < SIZE &&\n !visited[nx][ny] && grid[nx][ny].flavor == flavor) {\n visited[nx][ny] = true;\n q.emplace(nx, ny);\n }\n }\n }\n component_sizes[flavor - 1] += size * size;\n }\n }\n return component_sizes;\n}\n\nchar decide_tilt(const vector& flavors_input) {\n reset_empty();\n vector flavors = flavors_input; // Create a copy to avoid const issues\n int p;\n cout << flush;\n cin >> p;\n int flavor = flavors[0];\n flavors.erase(flavors.begin());\n place_candy(0, p, flavor);\n\n vector dirs = {'F', 'B', 'L', 'R'};\n vector scores(4, 0);\n Cell backup_grid[SIZE][SIZE];\n\n // Backup current grid state\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup_grid[i][j] = grid[i][j];\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n // Restore backup grid for each direction test\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n\n tilt(dirs[d]);\n scores[d] = calculate_components()[flavor - 1];\n }\n\n // Restore original grid\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n\n int max_score = -1;\n char best_dir = 'F';\n for (int d = 0; d < 4; ++d) {\n if (scores[d] > max_score) {\n max_score = scores[d];\n best_dir = dirs[d];\n }\n }\n\n cout << best_dir << '\\n' << flush;\n tilt(best_dir);\n\n return best_dir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector flavors(100);\n for (int i = 0; i < 100; ++i) {\n cin >> flavors[i];\n }\n\n for (int t = 0; t < 100; ++t) {\n if (t == 99) {\n cout << '\\n' << flush;\n break;\n }\n decide_tilt({flavors.begin() + t, flavors.end()});\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double eps;\n cin >> M >> eps;\n \n // Dynamic N selection based on M and epsilon\n int N = 20;\n if (M > 70) N = 35;\n else if (M > 40) N = 28;\n else if (M > 20) N = 22;\n \n if (eps > 0.3) N += 10;\n else if (eps > 0.2) N += 5;\n \n N = min(max(N, 4), 100);\n \n // Generate M distinct graphs with controlled edge distribution\n cout << N << \"\\n\";\n int total_edges = N * (N - 1) / 2;\n \n vector graphs(M);\n for (int k = 0; k < M; ++k) {\n // Use exponential distribution for edge density\n double density = exp(log(0.8) * (1.0 - k * 1.0 / (M - 1)));\n int target_edges = static_cast(density * total_edges + 0.5);\n \n string g(total_edges, '0');\n // Fill edges in a way that preserves structure under noise\n for (int i = 0; i < target_edges; ++i) {\n int pos = (i * 7) % total_edges; // Simple perturbation\n g[pos] = '1';\n }\n graphs[k] = g;\n cout << g << \"\\n\";\n }\n cout << flush;\n \n // Process queries with improved classification\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n // Enhanced edge counting with noise robustness\n int edge_count = count(H.begin(), H.end(), '1');\n \n // Dynamic threshold based on epsilon\n double noise_factor = 1.0 + eps * 2.5;\n int adjusted_count = static_cast(edge_count / noise_factor + 0.5);\n \n // Map to nearest graph using precomputed densities\n double best_error = 1e9;\n int best_k = 0;\n for (int k = 0; k < M; ++k) {\n int expected_edges = count(graphs[k].begin(), graphs[k].end(), '1');\n double error = abs(adjusted_count - expected_edges);\n if (error < best_error) {\n best_error = error;\n best_k = k;\n }\n }\n \n cout << best_k << \"\\n\";\n cout << flush;\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include // Required for std::iota\n\nusing namespace std;\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 vector u(M), v(M), w(M);\n for (int i = 0; i < M; ++i) {\n cin >> u[i] >> v[i] >> w[i];\n u[i]--; // convert to 0-based indexing\n v[i]--; // convert to 0-based indexing\n }\n\n // Read and ignore vertex coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Create index array and sort based on edge weights\n vector indices(M);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(), [&](int i, int j) {\n return w[i] < w[j];\n });\n\n // Assign days to edges\n vector result(M);\n for (int i = 0; i < M; ++i) {\n result[indices[i]] = (i % D) + 1;\n }\n\n // Output the result\n for (int i = 0; i < M; ++i) {\n cout << result[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), f2(D), r1(D), r2(D);\n \n for (int i = 0; i < 2; ++i) {\n for (int j = 0; j < D; ++j) cin >> f1[j];\n for (int j = 0; j < D; ++j) cin >> r1[j];\n for (int j = 0; j < D; ++j) cin >> f2[j];\n for (int j = 0; j < D; ++j) cin >> r2[j];\n }\n\n // Initialize 3D array to store which block is placed where\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n // Identify regions where both silhouettes need material\n vector>> common_region(D, vector>(D, vector(D, false)));\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool f_needed1 = (f1[z][x] == '1');\n bool r_needed1 = (r1[z][y] == '1');\n bool f_needed2 = (f2[z][x] == '1');\n bool r_needed2 = (r2[z][y] == '1');\n common_region[z][x][y] = f_needed1 && f_needed2 && r_needed1 && r_needed2;\n }\n }\n }\n\n // Create blocks for common region (shared between both objects)\n int block_id = 1;\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 (block_id == 1000005) break;\n if (common_region[z][x][y]) {\n b1[z][x][y] = block_id;\n b2[z][x][y] = block_id;\n ++block_id;\n }\n }\n if (block_id == 1000005) break;\n }\n if (block_id == 1000005) break;\n }\n\n // Fill remaining regions with unique 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 (b1[z][x][y] == 0 && f1[z][x] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && f2[z][x] == '1') {\n b2[z][x][y] = block_id++;\n }\n if (b1[z][x][y] == 0 && r1[z][y] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && r2[z][y] == '1') {\n b2[z][x][y] = block_id++;\n }\n }\n }\n }\n\n // Output\n cout << block_id - 1 << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b1[z][x][y];\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b2[z][x][y];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \nusing namespace std;\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);\n for (int i = 0; i < N; i++) {\n cin >> stations[i].first >> stations[i].second;\n }\n \n vector> edges(M);\n for (int i = 0; i < M; i++) {\n int u, v, w;\n cin >> u >> v >> w;\n u--; v--;\n edges[i] = {u, v, w};\n }\n \n vector> residents(K);\n for (int i = 0; i < K; i++) {\n cin >> residents[i].first >> residents[i].second;\n }\n \n vector P(N);\n vector B(M, 0);\n \n // Build MST to connect all stations\n vector>> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v, w;\n tie(u, v, w) = edges[i];\n adj[u].emplace_back(v, w);\n adj[v].emplace_back(u, w);\n }\n \n vector parent(N, -1);\n priority_queue, vector>, greater>> pq;\n pq.push({0, 0});\n vector visited(N, false);\n \n while (!pq.empty()) {\n auto [cost, u] = pq.top(); pq.pop();\n if (visited[u]) continue;\n visited[u] = true;\n for (auto [v, w] : adj[u]) {\n if (!visited[v]) {\n pq.push({w, v});\n parent[v] = u;\n }\n }\n }\n \n // Turn on MST edges\n for (int v = 1; v < N; v++) {\n int u = parent[v];\n for (int i = 0; i < M; i++) {\n int a, b, w;\n tie(a, b, w) = edges[i];\n if ((a == u && b == v) || (a == v && b == u)) {\n B[i] = 1;\n break;\n }\n }\n }\n \n // Optimize P_i values\n for (int i = 0; i < N; i++) {\n vector dists;\n for (int j = 0; j < K; j++) {\n int dx = stations[i].first - residents[j].first;\n int dy = stations[i].second - residents[j].second;\n dists.push_back(sqrt(dx*dx + dy*dy));\n }\n sort(dists.begin(), dists.end());\n \n int optimalP = 0;\n int covered = 0;\n for (int p = 0; p <= 5000; p++) {\n if (p*p >= dists[0]) covered++;\n if (covered == K) {\n optimalP = p;\n break;\n }\n }\n P[i] = optimalP;\n }\n \n cout << endl;\n for (int i = 0; i < N; i++) {\n cout << P[i] << (i == N-1 ? \"\\n\" : \" \");\n }\n for (int i = 0; i < M; i++) {\n cout << B[i] << (i == M-1 ? \"\\n\" : \" \");\n }\n \n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Ball {\n int number;\n int x, y;\n Ball(int n, int x, int y) : number(n), x(x), y(y) {}\n};\n\nvector> pyramid;\nvector, pair>> swaps;\n\nbool isAdjacent(int x1, int y1, int x2, int y2) {\n if (x1 == x2 - 1 && y1 == y2 - 1) return true;\n if (x1 == x2 - 1 && y1 == y2) return true;\n if (x1 == x2 && y1 == y2 - 1) return true;\n if (x1 == x2 && y1 == y2 + 1) return true;\n if (x1 == x2 + 1 && y1 == y2) return true;\n if (x1 == x2 + 1 && y1 == y2 + 1) return true;\n return false;\n}\n\nvoid swapBalls(int x1, int y1, int x2, int y2) {\n if (!isAdjacent(x1, y1, x2, y2)) return;\n swaps.push_back({{x1, y1}, {x2, y2}});\n swap(pyramid[x1][y1].number, pyramid[x2][y2].number);\n}\n\nint findMinBallBelow(int x, int y, int N) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int nx = x + 1; nx < N; ++nx) {\n for (int ny = 0; ny <= nx; ++ny) {\n if (pyramid[nx][ny].number < minVal) {\n minVal = pyramid[nx][ny].number;\n minX = nx;\n minY = ny;\n }\n }\n }\n if (minX != -1) return pyramid[minX][minY].number;\n return INT_MAX;\n}\n\nvoid processTier(int tier, int N) {\n int rows = tier + 1;\n for (int y = 0; y <= tier; ++y) {\n int x = tier;\n Ball& current = pyramid[x][y];\n if (x + 1 >= N) continue;\n bool valid = true;\n if (y < rows - 1 && current.number > pyramid[x+1][y].number) valid = false;\n if (y + 1 < rows && current.number > pyramid[x+1][y+1].number) valid = false;\n if (!valid) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < rows - 1; ++ny) {\n if (pyramid[x+1][ny].number < current.number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n int futureMin = findMinBallBelow(x + 1, minY, N);\n if (futureMin < current.number) {\n swapBalls(x, y, minX, minY);\n }\n }\n }\n }\n}\n\nvoid dynamicPostProcess(int N) {\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (x + 1 >= N) continue;\n if (pyramid[x][y].number > pyramid[x+1][y].number) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < x + 2; ++ny) {\n if (pyramid[x+1][ny].number < pyramid[x][y].number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n swapBalls(x, y, minX, minY);\n }\n }\n if (y + 1 <= x && pyramid[x][y].number > pyramid[x+1][y+1].number) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < x + 2; ++ny) {\n if (pyramid[x+1][ny].number < pyramid[x][y].number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n swapBalls(x, y, minX, minY);\n }\n }\n }\n }\n}\n\nint main() {\n int N = 30;\n pyramid.resize(N);\n for (int x = 0; x < N; ++x) {\n pyramid[x].reserve(x + 1);\n for (int y = 0; y <= x; ++y) {\n int num;\n cin >> num;\n pyramid[x].emplace_back(num, x, y);\n }\n }\n\n for (int tier = 0; tier < N - 1; ++tier) {\n processTier(tier, N);\n }\n\n dynamicPostProcess(N);\n\n cout << swaps.size() << endl;\n for (auto& sw : swaps) {\n cout << sw.first.first << \" \" << sw.first.second << \" \"\n << sw.second.first << \" \" << sw.second.second << endl;\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint D = 9;\nint N;\nvector> grid;\nvector> dist;\nvector> obstacles;\nvector> empty_cells;\nvector> visited;\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nvoid bfs(int sx, int sy) {\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n visited[sx][sy] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i], ny = y + dy[i];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D) continue;\n if (grid[nx][ny] || visited[nx][ny]) continue;\n dist[nx][ny] = dist[x][y] + 1;\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D >> N;\n grid.assign(D, vector(D, false));\n dist.assign(D, vector(D, -1));\n visited.assign(D, vector(D, false));\n\n int entrance_x = 0, entrance_y = (D - 1) / 2;\n grid[entrance_x][entrance_y] = true;\n\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = true;\n obstacles.emplace_back(r, c);\n }\n\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (grid[i][j]) continue;\n empty_cells.emplace_back(i, j);\n }\n }\n\n bfs(entrance_x, entrance_y);\n\n vector>> candidates;\n for (auto [x, y] : empty_cells) {\n if (dist[x][y] == -1) continue;\n candidates.emplace_back(-dist[x][y], make_pair(x, y));\n }\n sort(candidates.begin(), candidates.end());\n\n vector> storage_order;\n vector>> input;\n\n cout << flush;\n\n for (int d = 0; d < D * D - 1 - N; d++) {\n int t;\n cin >> t;\n input.emplace_back(t, make_pair(-1, -1));\n\n int best_idx = -1;\n int best_dist = -1;\n for (auto &[prio, pos] : candidates) {\n int x = pos.first, y = pos.second;\n if (dist[x][y] >= 0) {\n best_idx = pos.first;\n best_dist = pos.second;\n break;\n }\n }\n\n cout << best_idx << \" \" << best_dist << \"\\n\" << flush;\n\n for (auto &[prio, pos] : candidates) {\n if (pos.first == best_idx && pos.second == best_dist) {\n prio = 1e9;\n break;\n }\n }\n }\n\n for (auto &[t, pos] : input) {\n cout << pos.first << \" \" << pos.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n = 50, m = 100;\n vector> c(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> c[i][j];\n }\n }\n\n vector> adj(m + 1);\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int color = c[i][j];\n // Check up\n if (i > 0) {\n int up = c[i - 1][j];\n if (up != 0 && up != color) {\n adj[color].insert(up);\n adj[up].insert(color);\n }\n }\n // Check left\n if (j > 0) {\n int left = c[i][j - 1];\n if (left != 0 && left != color) {\n adj[color].insert(left);\n adj[left].insert(color);\n }\n }\n }\n }\n\n vector> d(n, vector(n, 0));\n\n // Place each color in a unique position, ensuring adjacency\n vector> positions;\n for (int color = 1; color <= m; ++color) {\n // Find a position not already occupied and on the border to maximize adjacency\n bool placed = false;\n for (int i = 0; i < n && !placed; ++i) {\n for (int j = 0; j < n && !placed; ++j) {\n if (d[i][j] == 0) {\n // Check if this position can satisfy adjacency requirements\n bool valid = true;\n for (int other : adj[color]) {\n // Check adjacent positions for other colors\n bool found = false;\n for (int dx = -1; dx <= 1; ++dx) {\n for (int dy = -1; dy <= 1; ++dy) {\n if (abs(dx) + abs(dy) != 1) continue;\n int ni = i + dx, nj = j + dy;\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n if (d[ni][nj] == other) {\n found = true;\n break;\n }\n } else {\n // Outside is considered color 0, so no adjacency\n }\n }\n if (found) break;\n }\n if (!found) {\n valid = false;\n break;\n }\n }\n if (valid) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n }\n }\n }\n }\n if (!placed) {\n // Fallback: place in the first available spot\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n break;\n }\n }\n if (placed) break;\n }\n }\n }\n\n // Now, fill the remaining area with 0, but ensure connectivity\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n // Check if surrounding is all 0 or out of bounds, then keep as 0\n // Otherwise, might need to assign a color, but for simplicity, keep 0\n d[i][j] = 0;\n }\n }\n }\n\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j > 0) cout << \" \";\n cout << d[i][j];\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector results;\n\n // Perform Q queries\n for (int q = 0; q < Q; ++q) {\n // Example query: compare two items\n // For simplicity, compare item 0 with item 1\n int nL = 1, nR = 1;\n vector L = {0};\n vector R = {1};\n\n // Output the query\n cout << nL << \" \" << nR << \" \" << L[0] << \" \" << R[0] << \"\\n\";\n cout.flush();\n\n // Read the result\n string res;\n cin >> res;\n results.push_back(res);\n }\n\n // After Q queries, output a simple division\n // Assign items to groups in a round-robin fashion\n vector assignment(N);\n for (int i = 0; i < N; ++i) {\n assignment[i] = i % D;\n }\n\n // Output the division\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << assignment[i];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n = 200, m = 10;\n vector> stacks(m);\n vector pos(n + 1); // pos[v] = {stack_index, position_from_bottom}\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int v;\n cin >> v;\n stacks[i].push_back(v);\n pos[v] = {i, j};\n }\n }\n\n vector removed(n + 1, false);\n vector> operations;\n\n auto current_pos = pos; // Copy initial positions\n\n for (int target = 1; target <= n; ++target) {\n if (removed[target]) continue;\n auto [si, pos_in_stack] = current_pos[target];\n if (pos_in_stack == stacks[si].size() - 1) {\n // Already on top, remove it\n operations.emplace_back(target, 0);\n removed[target] = true;\n stacks[si].pop_back();\n // Update positions of remaining boxes in this stack\n for (int j = pos_in_stack - 1; j >= 0; --j) {\n int v = stacks[si][j];\n current_pos[v] = {si, j};\n }\n stacks[si].pop_back();\n } else {\n // Need to move this box to the top of some stack\n // Find a stack where this box can be moved to the top\n int best_stack = si;\n int min_boxes_moved = n; // Upper bound\n for (int dest = 0; dest < m; ++dest) {\n if (dest == si) continue;\n // Calculate how many boxes we need to move from current stack si to get target to top\n int boxes_moved = pos_in_stack + 1; // All boxes from pos_in_stack down to bottom\n // Check if target is at the top after moving to dest stack\n // After moving, target becomes top of dest stack\n // Energy cost is boxes_moved + 1\n if (boxes_moved + 1 < min_boxes_moved) {\n min_boxes_moved = boxes_moved + 1;\n best_stack = dest;\n }\n }\n // Move target and above to best_stack\n vector to_move;\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n to_move.push_back(stacks[si][j]);\n }\n // Update stacks\n stacks[best_stack].insert(stacks[best_stack].end(), to_move.begin(), to_move.end());\n // Update positions\n for (int j = 0; j < to_move.size(); ++j) {\n int v = to_move[j];\n current_pos[v] = {best_stack, (int)stacks[best_stack].size() - to_move.size() + j};\n }\n // Update the original stack\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n stacks[si].pop_back();\n }\n // Record operation\n operations.emplace_back(target, best_stack + 1);\n }\n }\n\n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if(!(cin >> N)) return 0;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> d[i][j];\n }\n }\n \n vector> visited(N, vector(N, false));\n vector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n vector dir_char = {'R', 'D', 'L', 'U'};\n \n function dfs = [&](int i, int j, int parent_dir) {\n visited[i][j] = true;\n vector> candidates;\n for (int di = 0; di < 4; ++di) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || visited[ni][nj]) continue;\n bool wall = false;\n if (dirs[di].first == 0) {\n if (v[i][min(j, nj)] == '1') wall = true;\n } else {\n if (h[min(i, ni)][j] == '1') wall = true;\n }\n if (!wall) {\n candidates.emplace_back(di, parent_dir);\n }\n }\n sort(candidates.begin(), candidates.end(), [&](const auto& a, const auto& b) {\n int di1 = a.first, pdi1 = a.second;\n int di2 = b.first, pdi2 = b.second;\n int ni1 = i + dirs[di1].first;\n int nj1 = j + dirs[di1].second;\n int ni2 = i + dirs[di2].first;\n int nj2 = j + dirs[di2].second;\n return d[ni1][nj1] > d[ni2][nj2];\n });\n for (auto [di, pdir] : candidates) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n cout << dir_char[di];\n dfs(ni, nj, di);\n cout << dir_char[(di + 2) % 4];\n }\n };\n \n dfs(0, 0, -1);\n cout << endl;\n \n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n \n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector t(M);\n for (int k = 0; k < M; ++k) {\n cin >> t[k];\n }\n \n vector>> charPositions(N, map>());\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n char c = grid[i][j];\n charPositions[i][c].emplace_back(i, j);\n }\n }\n \n vector path;\n path.emplace_back(si, sj);\n \n set remaining;\n for (auto& str : t) remaining.insert(str);\n \n string current = \"\";\n int covered = 0;\n const int MAX_STEPS = 5000;\n \n while (!remaining.empty() && path.size() < MAX_STEPS) {\n map candidates;\n for (const auto& str : remaining) {\n candidates[str] = 0;\n }\n \n string S = current;\n S += grid[path.back().i][path.back().j];\n \n for (const auto& str : remaining) {\n if (S.find(str) != string::npos) {\n candidates.erase(str);\n }\n }\n \n if (candidates.empty()) {\n current += grid[path.back().i][path.back().j];\n continue;\n }\n \n string bestStr;\n int bestScore = -1;\n for (const auto& [str, _] : candidates) {\n int score = 0;\n for (size_t pos = 0; pos < str.size(); ++pos) {\n char needed = str[pos];\n for (int di = -2; di <= 2; ++di) {\n for (int dj = -2; dj <= 2; ++dj) {\n int ni = path.back().i + di, nj = path.back().j + dj;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (grid[ni][nj] == needed) {\n score++;\n break;\n }\n }\n }\n }\n if (score > bestScore) {\n bestScore = score;\n bestStr = str;\n }\n }\n \n if (bestStr.empty()) {\n current += grid[path.back().i][path.back().j];\n continue;\n }\n \n int bestCost = INT_MAX;\n Point bestPos(-1, -1);\n for (size_t pos = 0; pos < bestStr.size(); ++pos) {\n char needed = bestStr[pos];\n const auto& positions = charPositions[path.back().i][needed];\n for (const auto& p : positions) {\n int cost = abs(p.i - path.back().i) + abs(p.j - path.back().j) + 1;\n if (cost < bestCost) {\n bestCost = cost;\n bestPos = p;\n }\n }\n }\n \n if (bestPos.i == -1) {\n bestPos = path.back();\n bestCost = 1;\n }\n \n path.emplace_back(bestPos);\n current += grid[bestPos.i][bestPos.j];\n \n set toRemove;\n for (const auto& str : remaining) {\n if (current.find(str) != string::npos) {\n toRemove.insert(str);\n }\n }\n for (const auto& str : toRemove) {\n remaining.erase(str);\n }\n }\n \n for (const auto& p : path) {\n cout << p.i << \" \" << p.j << \"\\n\";\n }\n \n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct OilField {\n vector> cells;\n int minI, minJ;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector fields(M);\n for (int idx = 0; idx < M; ++idx) {\n int d;\n cin >> d;\n fields[idx].cells.resize(d);\n for (int i = 0; i < d; ++i) {\n cin >> fields[idx].cells[i].first >> fields[idx].cells[i].second;\n }\n int minI = fields[idx].cells[0].first;\n int minJ = fields[idx].cells[0].second;\n for (auto &p : fields[idx].cells) {\n minI = min(minI, p.first);\n minJ = min(minJ, p.second);\n }\n fields[idx].minI = minI;\n fields[idx].minJ = minJ;\n for (auto &p : fields[idx].cells) {\n p.first -= minI;\n p.second -= minJ;\n }\n }\n\n vector> v(N, vector(N, -1));\n vector> positive;\n\n // Step 1: Drill some key points to get initial information\n // We can start by drilling corners and centers\n vector> drillCandidates = {\n {N/2, N/2}, {0, 0}, {N-1, 0}, {0, N-1}, {N-1, N-1}\n };\n\n for (auto &p : drillCandidates) {\n int i = p.first, j = p.second;\n if (i >= N || j >= N) continue;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n cin >> v[i][j];\n if (v[i][j] > 0) {\n positive.emplace_back(i, j);\n }\n }\n\n // Step 2: Try to guess based on current positive cells\n // For each oil field shape, try to match with positive cells\n // This is a heuristic; we might need to refine further\n\n set> posSet(positive.begin(), positive.end());\n\n // Try to find candidate positions for each oil field\n vector> placements;\n for (const auto &field : fields) {\n int size = field.cells.size();\n for (int i = 0; i <= N - field.minI - 1; ++i) {\n for (int j = 0; j <= N - field.minJ - 1; ++j) {\n bool valid = true;\n for (auto &cell : field.cells) {\n int x = i + cell.first;\n int y = j + cell.second;\n if (x >= N || y >= N) {\n valid = false;\n break;\n }\n if (v[x][y] == 0) {\n valid = false;\n break;\n }\n }\n if (valid) {\n placements.emplace_back(i, j);\n }\n }\n }\n }\n\n // For now, just output all positive cells found by drilling\n cout << \"a \" << positive.size();\n for (auto &p : positive) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n cout.flush();\n\n int result;\n cin >> result;\n if (result == 1) {\n return 0;\n }\n\n // If failed, we might need to do more work, but for this example, we just exit\n // In a real solution, you would refine the strategy here\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nstruct Rect {\n int i0, j0, i1, j1;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n cin >> a[d][k];\n }\n }\n\n for (int d = 0; d < D; ++d) {\n int row = 0;\n for (int k = 0; k < N; ++k) {\n int needed = a[d][k];\n // Assign one full row with width = needed if fits\n int width = needed;\n if (width > W) width = W;\n\n int j0 = 0, j1 = j0 + width;\n int i0 = row, i1 = row + 1;\n\n cout << i0 << \" \" << j0 << \" \" << i1 << \" \" << j1 << \"\\n\";\n row++;\n }\n }\n\n return 0;\n}","ahc032":"#include \nusing namespace std;\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> 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 vector>> s(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 >> s[m][i][j];\n }\n }\n }\n\n // Simple greedy approach: Try to maximize each cell's mod value by applying stamps\n vector> operations;\n\n // We'll try to apply stamps to improve each cell's value mod 998244353\n const int MOD = 998244353;\n\n // For each possible position (p, q), try each stamp and see how it affects the mod values\n // We'll apply the best improvement we can find up to K times\n\n for (int step = 0; step < K; ++step) {\n int best_delta = -1;\n int best_m = -1, best_p = -1, best_q = -1;\n\n // Try all stamps and positions\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 the total delta this stamp would add to all cells in its area\n int delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int ni = p + i;\n int nj = q + j;\n int current_val = a[ni][nj];\n int new_val = (current_val + s[m][i][j]) % MOD;\n delta += new_val - current_val;\n }\n }\n\n if (delta > best_delta) {\n best_delta = delta;\n best_m = m;\n best_p = p;\n best_q = q;\n }\n }\n }\n }\n\n // Apply the best stamp we found\n if (best_delta > 0) {\n operations.emplace_back(best_m, best_p, best_q);\n // Update the board\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int ni = best_p + i;\n int nj = best_q + j;\n a[ni][nj] = (a[ni][nj] + s[best_m][i][j]) % MOD;\n }\n }\n } else {\n // No more improvements possible\n break;\n }\n }\n\n // Output\n cout << operations.size() << \"\\n\";\n for (auto [m, p, q] : operations) {\n cout << m << \" \" << p << \" \" << q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int x, y;\n bool holding;\n int id;\n};\n\nint N;\nvector> A;\nvector cranes;\nvector> grid;\nvector> occupied;\nvector actions;\n\nvector> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\nchar dir_char[4] = {'R', 'D', 'L', 'U'};\n\nbool is_valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nvoid place_container(int x, int y, int cont) {\n grid[x][y] = cont;\n occupied[x][y] = true;\n}\n\nvoid pickup(Crane& crane, int cont) {\n crane.holding = cont;\n occupied[crane.x][crane.y] = false;\n grid[crane.x][crane.y] = -1;\n}\n\nvoid release(Crane& crane, int x, int y) {\n grid[x][y] = crane.holding;\n occupied[x][y] = true;\n crane.holding = -1;\n}\n\nbool move_crane(Crane& crane, int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!is_valid(nx, ny)) return false;\n if (crane.holding != -1 && occupied[nx][ny]) return false;\n if (crane.holding == -1 && grid[nx][ny] != -1 && nx == N - 1 && ny == N - 1) return false;\n if (occupied[nx][ny] && crane.holding == -1) {\n if (grid[nx][ny] != -1) return false;\n }\n occupied[crane.x][crane.y] = false;\n crane.x = nx;\n crane.y = ny;\n occupied[crane.x][crane.y] = true;\n return true;\n}\n\nvoid simulate_turn(vector& moves) {\n for (int i = 0; i < N; ++i) {\n if (A[i][0] != -1 && !occupied[i][0] && cranes[i].holding == -1) {\n place_container(i, 0, A[i][0]);\n A[i][0] = A[i][1];\n for (int j = 1; j < N; ++j) A[i][j] = A[i][j + 1];\n A[i][N - 1] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n Crane& crane = cranes[i];\n char move = moves[i][actions.size()];\n if (move == 'P') {\n if (crane.holding != -1 || grid[crane.x][crane.y] == -1) continue;\n pickup(crane, grid[crane.x][crane.y]);\n } else if (move == 'Q') {\n if (crane.holding == -1 || occupied[crane.x][crane.y]) continue;\n release(crane, crane.x, crane.y);\n } else if (move == 'B') {\n if (crane.holding != -1) continue;\n crane.holding = -2;\n } else {\n int dx = 0, dy = 0;\n switch (move) {\n case 'U': dx = -1; break;\n case 'D': dx = 1; break;\n case 'L': dy = -1; break;\n case 'R': dy = 1; break;\n default: break;\n }\n if (dx != 0 || dy != 0) {\n move_crane(crane, dx, dy);\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1 && grid[N - 1][N - 1] != -1 && cranes[i].holding == -1) {\n int cont = grid[N - 1][N - 1];\n occupied[N - 1][N - 1] = false;\n grid[N - 1][N - 1] = -1;\n }\n }\n}\n\nvector solve() {\n actions.resize(N);\n fill(grid.begin(), grid.end(), vector(N, -1));\n fill(occupied.begin(), occupied.end(), vector(N, false));\n cranes.resize(N);\n for (int i = 0; i < N; ++i) {\n cranes[i] = {i, 0, false, -1, i};\n actions[i].clear();\n }\n\n vector target;\n for (int i = 0; i < N * N; ++i) target.push_back(i);\n vector dispatch_order;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dispatch_order.push_back(i * N + j);\n\n int steps = 0;\n while (steps < 10000) {\n vector moves(N, string(1, '.'));\n bool progress = false;\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].holding != -1) continue;\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1) continue;\n int target_x = N - 1, target_y = N - 1;\n vector> path;\n int dx = 0, dy = 0;\n\n if (grid[cranes[i].x][cranes[i].y] != -1) {\n moves[i][steps] = 'P';\n progress = true;\n continue;\n }\n\n if (cranes[i].x == target_x && cranes[i].y == target_y) {\n continue;\n }\n\n int nx = cranes[i].x, ny = cranes[i].y;\n while (nx != target_x || ny != target_y) {\n int best = -1;\n for (int d = 0; d < 4; ++d) {\n int nx2 = nx + directions[d].first;\n int ny2 = ny + directions[d].second;\n if (!is_valid(nx2, ny2)) continue;\n if (occupied[nx2][ny2] && grid[nx2][ny2] != -1) continue;\n if (d == 0 && ny == N - 1) continue;\n if (d == 1 && nx == N - 1) continue;\n if (d == 2 && ny == 0) continue;\n if (d == 3 && nx == 0) continue;\n best = d;\n break;\n }\n if (best == -1) break;\n path.emplace_back(nx, ny);\n nx += directions[best].first;\n ny += directions[best].second;\n }\n if (!path.empty()) {\n moves[i][steps] = dir_char[directions[best].first == 1 ? 1 :\n directions[best].second == 1 ? 0 :\n directions[best].first == -1 ? 3 : 2];\n progress = true;\n }\n }\n\n vector current_moves = moves;\n simulate_turn(current_moves);\n for (int i = 0; i < N; ++i)\n actions[i].push_back(current_moves[i].back());\n\n if (!progress) break;\n steps++;\n }\n\n return actions;\n}\n\nint main() {\n cin >> N;\n A = vector>(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 grid = vector>(N, vector(N, -1));\n occupied = vector>(N, vector(N, false));\n\n auto result = solve();\n for (const auto& s : result)\n cout << s << '\\n';\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\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 vector> changes; // (i, j, delta)\n vector> current_h = h;\n\n vector> operations;\n\n int di[] = {1, -1, 0, 0};\n int dj[] = {0, 0, 1, -1};\n vector dir = {\"D\", \"U\", \"R\", \"L\"};\n\n auto manhattan = [](int i1, int j1, int i2, int j2) {\n return abs(i1 - i2) + abs(j1 - j2);\n };\n\n auto get_best_target = [&](int current_i, int current_j, int current_load) -> tuple {\n int best_i = -1, best_j = -1, best_val = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int val = abs(current_h[i][j]);\n if (val == 0) continue;\n int dist = manhattan(current_i, current_j, i, j);\n if (best_i == -1 || val > best_val) {\n best_val = val;\n best_i = i;\n best_j = j;\n } else if (val == best_val) {\n if (dist < manhattan(best_i, best_j, current_i, current_j)) {\n best_i = i;\n best_j = j;\n }\n }\n }\n }\n if (best_i == -1) return {-1, -1, 0, 0};\n int needed = current_h[best_i][best_j];\n if (needed > 0) {\n return {best_i, best_j, 1, needed};\n } else {\n return {best_i, best_j, -1, -needed};\n }\n };\n\n int current_i = 0, current_j = 0;\n int current_load = 0;\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 (current_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 auto [target_i, target_j, type, amount] = get_best_target(current_i, current_j, current_load);\n if (target_i == -1) break;\n\n vector> path;\n int steps = 0;\n while (true) {\n if (current_i == target_i && current_j == target_j) break;\n for (int d = 0; d < 4; ++d) {\n int ni = current_i + di[d];\n int nj = current_j + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (ni == target_i && nj == target_j) {\n path.emplace_back(dir[d], 0);\n current_i = ni;\n current_j = nj;\n operations.emplace_back(dir[d]);\n steps++;\n break;\n }\n }\n if (steps > 0) break;\n }\n\n for (auto& [op, _] : path) {\n if (op == \"D\") {\n current_i++;\n } else if (op == \"U\") {\n current_i--;\n } else if (op == \"R\") {\n current_j++;\n } else if (op == \"L\") {\n current_j--;\n }\n }\n\n if (type == 1) {\n int d = min(amount, 10000000);\n current_load += d;\n current_h[current_i][current_j] -= d;\n operations.emplace_back(\u201c+\u201d + to_string(d));\n } else {\n int d = min(current_load, amount);\n current_load -= d;\n current_h[current_i][current_j] += d;\n operations.emplace_back(\u201c-\u201d + to_string(d));\n }\n }\n\n for (const auto& op : operations) {\n cout << op << endl;\n }\n return 0;\n}","ahc035":"#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, T;\n cin >> N >> M >> T;\n\n int seed_count = 2 * N * (N - 1);\n vector> seeds(seed_count, vector(M));\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n }\n\n vector total_values(seed_count);\n for (int i = 0; i < seed_count; ++i) {\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n\n for (int turn = 0; turn < T; ++turn) {\n vector> grid(N, vector(N));\n vector used(seed_count, false);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int best_index = -1;\n int best_value = -1;\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k] && total_values[k] > best_value) {\n best_value = total_values[k];\n best_index = k;\n }\n }\n grid[i][j] = best_index;\n used[best_index] = true;\n }\n }\n\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) cout << \" \";\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n vector> sources, targets;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (s[i][j] == '1') sources.emplace_back(i, j);\n if (t[i][j] == '1') targets.emplace_back(i, j);\n }\n \n // Design tree: linear chain of length min(V, something reasonable)\n int Vp = min(V, 2); // Use just 2 vertices: root and one fingertip\n cout << Vp << \"\\n\";\n if (Vp > 1) cout << \"0 1\\n\";\n \n // Initial position of root\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n // Precompute directions: assume fingertip is to the right of root\n // We'll move around and rotate as needed\n \n // Simple strategy: move to each source, grab, move to target, release\n // We'll simulate positions and orientations\n \n struct Pos { int x, y; };\n struct State {\n Pos root;\n int dir; // direction of edge from root to child: 0=R,1=D,2=L,3=U\n vector fingertips; // positions of fingertips relative to root\n };\n \n State st;\n st.root = {0, 0};\n st.dir = 0; // right\n if (Vp >= 2) {\n st.fingertips.push_back({st.root.x + 1, st.root.y}); // child at (1,0)\n }\n \n // Precompute all moves\n vector moves;\n \n for (int i = 0; i < M; ++i) {\n // Move to source i\n auto [sx, sy] = sources[i];\n // First, move root close to source\n int dx = sx - st.root.x;\n int dy = sy - st.root.y;\n // Move root to (sx, st.root.y) then adjust y\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\"; // no rotate\n op += \".\\n\"; // no action for fingertip\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Now root is at (sx, st.root.y), need to align fingertip to (sx, sy)\n dx = sy - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dx > 0) ? 1 : -1;\n st.fingertips[0].y += (dx > 0) ? 1 : -1;\n }\n \n // Rotate to make fingertip point to the source\n // Currently fingertip is at (root.x+1, root.y) if dir=0\n // We want it to point to (sx, sy). Since we are already at (sx, sy) for root, just grab\n // Grab\n string op;\n op += \".\\n\"; // no move\n op += \".\\n\"; // no rotate\n op += \"P\\n\"; // grab\n moves.push_back(op);\n \n // Move to target i\n auto [tx, ty] = targets[i];\n dx = tx - st.root.x;\n dy = ty - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Release\n op = \".\\n.\\nP\\n\";\n moves.push_back(op);\n }\n \n // Output moves\n for (const auto& mv : moves) {\n cout << mv;\n }\n \n return 0;\n}","ahc039":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\n// Function to compute the score for a given rectangle\nint compute_score(const vector& mackerels, const vector& sardines,\n int min_x, int min_y, int max_x, int max_y) {\n int a = 0, b = 0;\n for (const auto& p : mackerels) {\n if (p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y) {\n a++;\n }\n }\n for (const auto& p : sardines) {\n if (p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y) {\n b++;\n }\n }\n return a - b;\n}\n\n// Function to expand the rectangle in all directions\nvoid expand_rectangle(int& min_x, int& min_y, int& max_x, int& max_y,\n const vector& mackerels, const vector& sardines) {\n bool expanded;\n do {\n expanded = false;\n // Expand right\n int new_max_x = max_x + 1;\n if (new_max_x <= 100000) {\n int new_score = compute_score(mackerels, sardines, min_x, min_y, new_max_x, max_y);\n if (new_score > compute_score(mackerels, sardines, min_x, min_y, max_x, max_y)) {\n max_x = new_max_x;\n expanded = true;\n }\n }\n // Expand left\n int new_min_x = min_x - 1;\n if (new_min_x >= 0) {\n int new_score = compute_score(mackerels, sardines, new_min_x, min_y, max_x, max_y);\n if (new_score > compute_score(mackerels, sardines, min_x, min_y, max_x, max_y)) {\n min_x = new_min_x;\n expanded = true;\n }\n }\n // Expand top\n int new_max_y = max_y + 1;\n if (new_max_y <= 100000) {\n int new_score = compute_score(mackerels, sardines, min_x, min_y, max_x, new_max_y);\n if (new_score > compute_score(mackerels, sardines, min_x, min_y, max_x, max_y)) {\n max_y = new_max_y;\n expanded = true;\n }\n }\n // Expand bottom\n int new_min_y = min_y - 1;\n if (new_min_y >= 0) {\n int new_score = compute_score(mackerels, sardines, min_x, new_min_y, max_x, max_y);\n if (new_score > compute_score(mackerels, sardines, min_x, min_y, max_x, max_y)) {\n min_y = new_min_y;\n expanded = true;\n }\n }\n } while (expanded);\n}\n\n// Function to trim the rectangle based on edge scores\nvoid trim_rectangle(int& min_x, int& min_y, int& max_x, int& max_y,\n const vector& mackerels, const vector& sardines) {\n // Trim right edge\n while (max_x > min_x) {\n int score_without_last = compute_score(mackerels, sardines, min_x, min_y, max_x - 1, max_y);\n int score_with_last = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y);\n if (score_without_last >= score_with_last) {\n max_x--;\n } else {\n break;\n }\n }\n // Trim left edge\n while (max_x > min_x) {\n int score_without_first = compute_score(mackerels, sardines, min_x + 1, min_y, max_x, max_y);\n int score_with_first = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y);\n if (score_without_first >= score_with_first) {\n min_x++;\n } else {\n break;\n }\n }\n // Trim top edge\n while (max_y > min_y) {\n int score_without_last = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y - 1);\n int score_with_last = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y);\n if (score_without_last >= score_with_last) {\n max_y--;\n } else {\n break;\n }\n }\n // Trim bottom edge\n while (max_y > min_y) {\n int score_without_first = compute_score(mackerels, sardines, min_x, min_y + 1, max_x, max_y);\n int score_with_first = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y);\n if (score_without_first >= score_with_first) {\n min_y++;\n } else {\n break;\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector mackerels(N), sardines(N);\n for (int i = 0; i < N; ++i) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n for (int i = 0; i < N; ++i) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n\n // Dynamic grid size: start with a coarse grid and refine\n const int GRID_SIZE = 50; // Coarser grid to cover larger areas\n const int CELL_SIZE = 2000; // Larger cells\n\n vector> grid_score(GRID_SIZE, vector(GRID_SIZE, 0));\n\n for (const auto& p : mackerels) {\n int gx = p.x / CELL_SIZE;\n int gy = p.y / CELL_SIZE;\n if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {\n grid_score[gx][gy]++;\n }\n }\n\n for (const auto& p : sardines) {\n int gx = p.x / CELL_SIZE;\n int gy = p.y / CELL_SIZE;\n if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {\n grid_score[gx][gy]--;\n }\n }\n\n // Find the best cell\n int best_gx = 0, best_gy = 0;\n int best_score = grid_score[0][0];\n for (int x = 0; x < GRID_SIZE; ++x) {\n for (int y = 0; y < GRID_SIZE; ++y) {\n if (grid_score[x][y] > best_score) {\n best_score = grid_score[x][y];\n best_gx = x;\n best_gy = y;\n }\n }\n }\n\n // Initialize the rectangle\n int min_x = best_gx * CELL_SIZE;\n int min_y = best_gy * CELL_SIZE;\n int max_x = (best_gx + 1) * CELL_SIZE - 1;\n int max_y = (best_gy + 1) * CELL_SIZE - 1;\n\n // Expand the rectangle in all directions\n expand_rectangle(min_x, min_y, max_x, max_y, mackerels, sardines);\n\n // Trim the rectangle based on edge scores\n trim_rectangle(min_x, min_y, max_x, max_y, mackerels, sardines);\n\n // Ensure the polygon is valid (at least 4 vertices and no self-intersection)\n vector polygon = {\n Point(min_x, min_y),\n Point(max_x, min_y),\n Point(max_x, max_y),\n Point(min_x, max_y)\n };\n\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 \nusing namespace std;\n\nusing ll = long long;\nusing Point = pair;\nusing Rect = tuple; // x1, y1, x2, y2\n\nRect place_rect(const Rect& existing, const Rect& new_rect, char dir, int b_idx) {\n ll x1, y1, x2, y2;\n if (b_idx == -1) {\n if (dir == 'U') {\n x1 = get<0>(new_rect);\n y1 = get<1>(new_rect);\n x2 = get<2>(new_rect);\n y2 = get<3>(new_rect);\n } else {\n x1 = get<0>(new_rect);\n y1 = get<1>(new_rect);\n x2 = get<2>(new_rect);\n y2 = get<3>(new_rect);\n }\n } else {\n ll ex2 = get<2>(existing);\n ll ey2 = get<3>(existing);\n if (dir == 'U') {\n x1 = get<0>(new_rect);\n y1 = ey2;\n x2 = get<2>(new_rect);\n y2 = ey2 + get<3>(new_rect);\n } else {\n x1 = ex2;\n y1 = get<1>(new_rect);\n x2 = ex2 + get<2>(new_rect);\n y2 = get<3>(new_rect);\n }\n }\n return make_tuple(x1, y1, x2, y2);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, T;\n double sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector> wh(N);\n for (int i = 0; i < N; ++i) {\n cin >> wh[i].first >> wh[i].second;\n }\n \n // Simulate true dimensions based on observed values and sigma\n default_random_engine gen;\n normal_distribution dist(0.0, sigma);\n vector> true_wh(N);\n for (int i = 0; i < N; ++i) {\n double dw = dist(gen);\n double dh = dist(gen);\n true_wh[i].first = max(1, static_cast(round(wh[i].first + dw)));\n true_wh[i].second = max(1, static_cast(round(wh[i].second + dh)));\n }\n \n vector> placements;\n \n for (int t = 0; t < T; ++t) {\n vector> placement;\n vector placed_rects;\n \n // Place the first rectangle at origin without rotation\n placement.emplace_back(0, 0, 'U', -1);\n placed_rects.emplace_back(\n 0, 0,\n static_cast(true_wh[0].first),\n static_cast(true_wh[0].second)\n );\n \n // Place subsequent rectangles\n for (int i = 1; i < N; ++i) {\n int best_idx = i;\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n ll best_width = 0, best_height = 0;\n \n for (int rot : {0, 1}) {\n ll w, h;\n if (rot == 0) {\n w = true_wh[i].first;\n h = true_wh[i].second;\n } else {\n w = true_wh[i].second;\n h = true_wh[i].first;\n }\n \n Rect new_rect = make_tuple(0, 0, static_cast(w), static_cast(h));\n \n for (char dir : {'U', 'L'}) {\n for (size_t b_idx = 0; b_idx <= placed_rects.size(); ++b_idx) {\n int idx = -1;\n if (b_idx != placed_rects.size()) idx = b_idx;\n Rect placed = place_rect(\n b_idx < placed_rects.size() ? placed_rects[b_idx] : make_tuple(0LL, 0LL, 0LL, 0LL),\n new_rect, dir, idx\n );\n ll width = get<2>(placed) - get<0>(placed);\n ll height = get<3>(placed) - get<1>(placed);\n if (width + height < best_width + best_height) {\n best_width = width;\n best_height = height;\n best_idx = i;\n best_rot = rot;\n best_dir = dir;\n best_b = idx;\n }\n }\n }\n }\n \n placement.emplace_back(best_idx, best_rot, best_dir, best_b);\n Rect new_rect = make_tuple(0, 0, static_cast(true_wh[best_idx].first), static_cast(true_wh[best_idx].second));\n if (best_rot) {\n swap(get<2>(new_rect), get<3>(new_rect));\n }\n Rect placed = place_rect(\n best_b >= 0 ? placed_rects[best_b] : make_tuple(0LL, 0LL, 0LL, 0LL),\n new_rect, best_dir, best_b\n );\n placed_rects.push_back(placed);\n }\n \n cout << placement.size() << \"\\n\";\n for (const auto& p : placement) {\n cout << get<0>(p) << \" \" << get<1>(p) << \" \" << get<2>(p) << \" \" << get<3>(p) << \"\\n\";\n }\n cout.flush();\n \n ll W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n if (!cin) return 0;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n }\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n vector parent(N, -1);\n\n // Simple greedy: assign each node as root if it has high beauty\n // and try to build a tree of height <= H\n\n vector> adj(N);\n for (auto [u, v] : edges) {\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n vector visited(N, false);\n // For each node, try to be a root and build a BFS tree up to height H\n vector degree(N, 0);\n for (auto [u, v] : edges) {\n degree[u]++;\n degree[v]++;\n }\n\n // Choose roots as nodes with highest beauty and lowest degree\n vector> candidates;\n for (int i = 0; i < N; ++i) {\n candidates.emplace_back(-A[i] - degree[i], i);\n }\n sort(candidates.begin(), candidates.end());\n\n queue q;\n for (auto [_, i] : candidates) {\n if (visited[i]) continue;\n visited[i] = true;\n parent[i] = -1;\n q.push(i);\n int height = 0;\n vector level = {i};\n while (height < H && !level.empty()) {\n height++;\n vector next_level;\n for (int u : level) {\n for (int v : adj[u]) {\n if (!visited[v] && parent[v] == -1) {\n visited[v] = true;\n parent[v] = u;\n next_level.push_back(v);\n }\n }\n }\n level = next_level;\n }\n }\n\n // Fill any unassigned nodes (should not happen in valid input)\n for (int i = 0; i < N; ++i) {\n if (parent[i] == -1) {\n parent[i] = (i + 1) % N;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << '\\n';\n\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstruct Move {\n char dir;\n int pos;\n};\n\nint main() {\n int N = 20;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector moves;\n\n auto add_moves = [&](int i, int j, bool is_row, bool left_or_up) {\n if (is_row) {\n if (left_or_up) {\n for (int k = 0; k <= j; ++k) {\n moves.push_back({'L', i});\n }\n } else {\n for (int k = 0; k <= N - 1 - j; ++k) {\n moves.push_back({'R', i});\n }\n }\n } else {\n if (left_or_up) {\n for (int k = 0; k <= i; ++k) {\n moves.push_back({'U', j});\n }\n } else {\n for (int k = 0; k <= N - 1 - i; ++k) {\n moves.push_back({'D', j});\n }\n }\n }\n };\n\n vector> removed(N, vector(N, false));\n vector> oni_positions;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n oni_positions.emplace_back(i, j);\n }\n }\n }\n\n sort(oni_positions.begin(), oni_positions.end(), [](const pair& a, const pair& b) {\n return (a.second + a.first) > (b.second + b.first);\n });\n\n for (const auto& [i, j] : oni_positions) {\n if (removed[i][j]) continue;\n\n bool can_left = true, can_right = true, can_up = true, can_down = true;\n for (int dj = 0; dj < j; ++dj) {\n if (board[i][dj] == 'o') {\n can_right = false;\n break;\n }\n }\n for (int dj = j + 1; dj < N; ++dj) {\n if (board[i][dj] == 'o') {\n can_left = false;\n break;\n }\n }\n for (int di = 0; di < i; ++di) {\n if (board[di][j] == 'o') {\n can_down = false;\n break;\n }\n }\n for (int di = i + 1; di < N; ++di) {\n if (board[di][j] == 'o') {\n can_up = false;\n break;\n }\n }\n\n if (can_left) {\n add_moves(i, j, true, true);\n removed[i][j] = true;\n } else if (can_right) {\n add_moves(i, j, true, false);\n removed[i][j] = true;\n } else if (can_up) {\n add_moves(i, j, false, true);\n removed[i][j] = true;\n } else if (can_down) {\n add_moves(i, j, false, false);\n removed[i][j] = true;\n }\n }\n\n for (const auto& mv : moves) {\n cout << mv.dir << \" \" << mv.pos << endl;\n }\n\n return 0;\n}","ahc044":"#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\nvector t(N); // target times\nvector> assignments(N); // a_i, b_i for each employee\n\nvector simulate(const vector>& assign) {\n vector count(N, 0);\n int current = 0;\n int times = 0;\n count[0]++; // first week\n times = 1; // count for employee 0\n\n for (int week = 1; week < L; ++week) {\n if (times % 2 == 1) { // odd\n current = assign[current].first;\n } else { // even\n current = assign[current].second;\n }\n count[current]++;\n times++; // increment the count for previous employee\n }\n return count;\n}\n\nlong long calculate_error(const vector& actual) {\n long long error = 0;\n for (int i = 0; i < N; ++i) {\n error += abs(actual[i] - t[i]);\n }\n return error;\n}\n\n// Simulated Annealing with limited iterations\nvoid simulated_annealing(vector>& assign, long long& best_error, vector& best_count) {\n mt19937 rng(0); // fixed seed for reproducibility\n const int MAX_ITERATIONS = 50; // Reduced from previous value\n\n long long current_error = calculate_error(simulate(assign));\n vector current_count = simulate(assign);\n best_error = current_error;\n best_count = current_count;\n\n double temperature = 1000.0;\n const double cooling_rate = 0.995;\n\n for (int iter = 0; iter < MAX_ITERATIONS; ++iter) {\n // Choose two distinct employees\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n while (j == i) {\n j = uniform_int_distribution(0, N-1)(rng);\n }\n\n // Save old assignments\n auto old_i = assign[i];\n auto old_j = assign[j];\n\n // Randomly change assignments for i and j\n int a_candidate = uniform_int_distribution(0, N-1)(rng);\n int b_candidate = uniform_int_distribution(0, N-1)(rng);\n assign[i] = {a_candidate, b_candidate};\n\n a_candidate = uniform_int_distribution(0, N-1)(rng);\n b_candidate = uniform_int_distribution(0, N-1)(rng);\n assign[j] = {a_candidate, b_candidate};\n\n // Simulate and compute new error\n vector new_count = simulate(assign);\n long long new_error = calculate_error(new_count);\n\n // Acceptance probability\n double ap = exp((current_error - new_error) / temperature);\n if (new_error < current_error || uniform_real_distribution(0, 1)(rng) < ap) {\n current_error = new_error;\n current_count = new_count;\n if (new_error < best_error) {\n best_error = new_error;\n best_count = new_count;\n }\n } else {\n // Revert changes\n assign[i] = old_i;\n assign[j] = old_j;\n }\n\n // Cool down\n temperature *= cooling_rate;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n int dummy_n, dummy_l;\n cin >> dummy_n >> dummy_l; // should be 100 and 500000\n for (int i = 0; i < N; ++i) {\n cin >> t[i];\n }\n\n // Initial assignment: cyclic pattern\n for (int i = 0; i < N; ++i) {\n assignments[i] = {(i + 1) % N, (i + 1) % N};\n }\n\n long long best_error;\n vector best_count;\n simulated_annealing(assignments, best_error, best_count);\n\n // Output the assignments\n for (const auto& p : assignments) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\n\n#define OVERRIDE 0\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy;\n};\n\n// Simple DBSCAN-like clustering based on center coordinates\nvector> clusterCities(const vector& cities, double eps = 200.0, int min_pts = 1) {\n int n = cities.size();\n vector visited(n, false);\n vector> clusters;\n\n for (int i = 0; i < n; ++i) {\n if (visited[i]) continue;\n visited[i] = true;\n queue q;\n q.push(i);\n vector cluster;\n\n cluster.push_back(i);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int nxt = 0; nxt < n; ++nxt) {\n if (visited[nxt]) continue;\n double dx = cities[cur].cx - cities[nxt].cx;\n double dy = cities[cur].cy - cities[nxt].cy;\n double dist = sqrt(dx*dx + dy*dy);\n if (dist <= eps) {\n visited[nxt] = true;\n q.push(nxt);\n cluster.push_back(nxt);\n }\n }\n }\n if (!cluster.empty()) {\n clusters.push_back(cluster);\n }\n }\n return clusters;\n}\n\n// Divide a cluster into groups of sizes specified in G\nvector> assignGroups(const vector& cluster, const vector& G, const vector& cities) {\n vector> groups;\n int n = cluster.size();\n int group_idx = 0;\n int start = 0;\n\n for (int g : G) {\n vector group;\n int end = start + g;\n if (end > n) {\n end = n;\n }\n for (int i = start; i < end; ++i) {\n group.push_back(cluster[i]);\n }\n groups.push_back(group);\n start = end;\n }\n return groups;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n vector cities(N);\n for (int i = 0; i < N; ++i) {\n 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 // Cluster cities based on center coordinates\n vector> clusters = clusterCities(cities);\n\n // Assign cities to groups\n vector> groups;\n vector group_sizes = G;\n\n // Try to assign groups from clusters\n for (const auto& cluster : clusters) {\n vector> cluster_groups = assignGroups(cluster, group_sizes, cities);\n for (const auto& g : cluster_groups) {\n if (g.empty()) continue;\n groups.push_back(g);\n // Decrease the corresponding group size\n for (size_t i = 0; i < group_sizes.size(); ++i) {\n if (group_sizes[i] >= (int)g.size()) {\n group_sizes[i] -= (int)g.size();\n break;\n }\n }\n }\n }\n\n // Handle remaining group sizes\n int remaining = N;\n for (const auto& g : groups) remaining -= g.size();\n if (remaining > 0) {\n // Add remaining cities to the last group\n if (!groups.empty()) {\n groups.back().resize(remaining + groups.back().size());\n } else {\n groups.push_back(vector(remaining));\n }\n }\n\n // Ensure we have exactly M groups\n while ((int)groups.size() < M) {\n groups.push_back({});\n }\n\n // Prepare queries for each group\n vector>> all_edges(M);\n\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n int sz = group.size();\n if (sz < 2) continue;\n\n // If group size is small enough, query the entire group\n if (sz <= L) {\n cout << \"? \" << sz;\n for (int id : group) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int i = 0; i < sz - 1; ++i) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n } else {\n // Break into subsets of size L\n for (int i = 0; i < sz; i += L - 1) {\n int subset_size = min(L, sz - i);\n if (subset_size < 2) break;\n\n vector subset;\n for (int j = i; j < i + subset_size; ++j) {\n subset.push_back(group[j]);\n }\n\n cout << \"? \" << subset_size;\n for (int id : subset) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int j = 0; j < subset_size - 1; ++j) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n }\n }\n }\n\n // Output the answer\n cout << \"!\" << endl;\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n cout << group.size();\n for (int id : group) cout << \" \" << id;\n cout << endl;\n\n // Output edges for this group\n for (const auto& edge : all_edges[k]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint N, M;\nvector> targets;\nvector> grid; // true if block exists\npair current;\n\n// Directions: U, D, L, R\nconst int dx[] = {-1, 1, 0, 0};\nconst int dy[] = {0, 0, -1, 1};\nconst char dir[] = {'U', 'D', 'L', 'R'};\n\n// BFS to find the shortest path to target from current position, avoiding blocks and staying inside grid\nvector> bfs(const pair& start, const pair& target, const vector>& blocks) {\n queue> q;\n vector>> parent(N, vector>(N, {-2, -2}));\n vector> dist(N, vector(N, -1));\n\n q.push(start);\n dist[start.first][start.second] = 0;\n\n while (!q.empty()) {\n auto [x, y] = q.front(); \n q.pop();\n\n if (x == target.first && y == target.second) {\n // Reconstruct path\n vector> path;\n pair curr = {x, y};\n while (curr.first != -2 || curr.second != -2) {\n path.push_back(curr);\n int px, py;\n // Examine all four directions to find the predecessor stored in parent\n bool found = false;\n for (int d = 0; d < 4; d++) {\n px = x + dx[d];\n py = y + dy[d];\n // Only consider in-bounds predecessors\n if (px >= 0 && px < N && py >= 0 && py < N) {\n if (parent[px][py] == curr) {\n curr = {px, py};\n found = true;\n break;\n }\n }\n }\n if (!found) break;\n }\n reverse(path.begin(), path.end());\n return path;\n }\n\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d], ny = y + dy[d];\n // Only enqueue if the neighbor is inside the grid\n if (nx >= 0 && nx < N && ny >= 0 && ny < N) {\n if (!blocks[nx][ny] && dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n }\n return {}; // no path found\n}\n\n// Attempt to move to next target, using alter if necessary\nvector> moveToTarget(const pair& target) {\n vector> actions;\n vector> blocks = grid;\n\n auto path = bfs(current, target, blocks);\n if (!path.empty()) {\n // Path exists without altering blocks\n for (size_t i = 1; i < path.size(); i++) { // skip first element because it is current\n auto next = path[i];\n int dx_move = next.first - current.first;\n int dy_move = next.second - current.second;\n \n // Ensure move stays inside grid boundaries\n if (dx_move != 0 || dy_move != 0) {\n if (dx_move > 0) {\n if (current.first < N - 1) {\n actions.emplace_back('M', \"D\");\n } else {\n // Skip this move as it goes out of bounds\n continue;\n }\n } else if (dx_move < 0) {\n if (current.first > 0) {\n actions.emplace_back('M', \"U\");\n } else {\n // Skip this move as it goes out of bounds\n continue;\n }\n } else if (dy_move > 0) {\n if (current.second < N - 1) {\n actions.emplace_back('M', \"R\");\n } else {\n // Skip this move as it goes out of bounds\n continue;\n }\n } else if (dy_move < 0) {\n if (current.second > 0) {\n actions.emplace_back('M', \"L\");\n } else {\n // Skip this move as it goes out of bounds\n continue;\n }\n }\n current = next;\n }\n }\n return actions;\n }\n\n // No path found, try altering blocks\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n if (blocks[x][y] == false) {\n blocks[x][y] = true; // place block\n actions.emplace_back('A', (x > current.first) ? \"D\" : (x < current.first) ? \"U\" : (y > current.second) ? \"R\" : \"L\");\n // Now retry BFS\n path = bfs(current, target, blocks);\n if (!path.empty()) {\n // Path found after altering\n for (size_t i = 1; i < path.size(); i++) {\n auto next = path[i];\n int dx_move = next.first - current.first;\n int dy_move = next.second - current.second;\n // Verify move safety before adding to actions\n if (dx_move > 0 && current.first < N - 1) {\n actions.emplace_back('M', \"D\");\n } else if (dx_move < 0 && current.first > 0) {\n actions.emplace_back('M', \"U\");\n } else if (dy_move > 0 && current.second < N - 1) {\n actions.emplace_back('M', \"R\");\n } else if (dy_move < 0 && current.second > 0) {\n actions.emplace_back('M', \"L\");\n } else {\n // This should never be reached if BFSStayInGrid works correctly\n continue;\n }\n current = next;\n }\n return actions;\n }\n blocks[x][y] = false; // remove block for next try\n }\n }\n }\n\n // Fallback: empty actions vector signaling failure\n return {};\n}\n\nint main() {\n cin >> N >> M;\n targets.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> targets[i].first >> targets[i].second;\n }\n current = targets[0];\n grid = vector>(N, vector(N, false));\n\n vector> actions;\n\n for (int i = 1; i < M; ++i) {\n auto step_actions = moveToTarget(targets[i]);\n actions.insert(actions.end(), step_actions.begin(), step_actions.end());\n }\n\n // Output actions\n for (auto& [a, d] : actions) {\n cout << a << \" \" << d << endl;\n }\n\n return 0;\n}"},"8":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2;\n long long area() const { return (long long)(x2 - x1) * (y2 - y1); }\n bool contains(double x, double y) const {\n return x > x1 && x < x2 && y > y1 && y < y2;\n }\n};\n\nint n;\nvector> input;\nvector rects;\nvector r_desired;\nvector> desired_points;\n\ndouble satisfaction(int i, const Rect& r) {\n double x = get<0>(input[i]) + 0.5, y = get<1>(input[i]) + 0.5;\n if (!r.contains(x, y)) return 0.0;\n long long s = r.area();\n long long r_val = get<2>(input[i]);\n double ratio = min(r_val, (long long)s) * 1.0 / max(r_val, (long long)s);\n return 1.0 - pow(1.0 - ratio, 2.0);\n}\n\ndouble total_satisfaction() {\n double total = 0.0;\n for (int i = 0; i < n; ++i) {\n total += satisfaction(i, rects[i]);\n }\n return total;\n}\n\nbool intersects(const Rect& a, const Rect& b) {\n return !(a.x2 <= b.x1 || a.x1 >= b.x2 || a.y2 <= b.y1 || a.y1 >= b.y2);\n}\n\nvoid init_rects() {\n rects.clear();\n for (int i = 0; i < n; ++i) {\n int x = get<0>(input[i]), y = get<1>(input[i]);\n int r = get<2>(input[i]);\n int half = max(1, (int)sqrt(r));\n rects.push_back({x, y, x + half, y + half});\n }\n}\n\nbool expand_rect(int i, int dx, int dy) {\n Rect& r = rects[i];\n Rect new_r = {r.x1 - dx, r.y1 - dy, r.x2 + dx, r.y2 + dy};\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n return false;\n }\n }\n if (new_r.x1 < 0 || new_r.y1 < 0 || new_r.x2 > 10000 || new_r.y2 > 10000) {\n return false;\n }\n rects[i] = new_r;\n return true;\n}\n\nvoid greedy_expansion() {\n for (int iter = 0; iter < 1000; ++iter) {\n for (int i = 0; i < n; ++i) {\n int dx = 1, dy = 1;\n while (expand_rect(i, dx, dy)) {\n dx++;\n dy++;\n }\n }\n }\n}\n\ndouble simulated_annealing(double T, double alpha, int steps) {\n double best_score = total_satisfaction();\n vector best_rects = rects;\n\n for (int step = 0; step < steps; ++step) {\n int i = rand() % n;\n int dx = (rand() % 5) - 2;\n int dy = (rand() % 5) - 2;\n\n Rect old_r = rects[i];\n Rect new_r = {old_r.x1 + dx, old_r.y1 + dy, old_r.x2 + dx, old_r.y2 + dy};\n\n bool valid = true;\n if (new_r.x1 < 0 || new_r.x1 >= 10000 || new_r.x2 < 0 || new_r.x2 >= 10000 ||\n new_r.y1 < 0 || new_r.y1 >= 10000 || new_r.y2 < 0 || new_r.y2 >= 10000) {\n valid = false;\n } else {\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n valid = false;\n break;\n }\n }\n }\n\n if (!valid) {\n swap(new_r, old_r);\n }\n\n double old_score = satisfaction(i, old_r);\n double new_score = satisfaction(i, new_r);\n double delta = new_score - old_score;\n\n if (delta > 0 || exp(delta / T) > (double)rand() / RAND_MAX) {\n rects[i] = new_r;\n } else {\n rects[i] = old_r;\n }\n\n double current_score = total_satisfaction();\n if (current_score > best_score) {\n best_score = current_score;\n best_rects = rects;\n }\n\n T *= alpha;\n }\n\n rects = best_rects;\n return best_score;\n}\n\nint main() {\n srand(time(nullptr));\n cin >> n;\n input.resize(n);\n r_desired.resize(n);\n desired_points.resize(n);\n\n for (int i = 0; i < n; ++i) {\n int x, y, r;\n cin >> x >> y >> r;\n input[i] = {x, y, r};\n desired_points[i] = {x + 0.5, y + 0.5};\n r_desired[i] = r;\n }\n\n init_rects();\n greedy_expansion();\n\n double T = 10000.0;\n double alpha = 0.99;\n int steps = 100000;\n\n simulated_annealing(T, alpha, steps);\n\n for (const auto& r : rects) {\n cout << r.x1 << \" \" << r.y1 << \" \" << r.x2 << \" \" << r.y2 << endl;\n }\n\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj;\n cin >> si >> sj;\n \n vector> t(50, vector(50));\n vector> p(50, vector(50));\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n }\n }\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> p[i][j];\n }\n }\n \n // Identify tiles: map from tile id to list of positions\n map>> tiles;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n tiles[t[i][j]].emplace_back(i, j);\n }\n }\n \n // For each tile, check if it's horizontal or vertical\n // and store the positions in a sorted manner\n vector>> tilePositions;\n tilePositions.reserve(tiles.size());\n for (auto &entry : tiles) {\n auto &posList = entry.second;\n sort(posList.begin(), posList.end());\n tilePositions.push_back(set>(posList.begin(), posList.end()));\n }\n \n // Create a map from position to tile index\n vector> posToTile(50, vector(50, -1));\n for (size_t ti = 0; ti < tilePositions.size(); ++ti) {\n for (auto &pos : tilePositions[ti]) {\n posToTile[pos.first][pos.second] = ti;\n }\n }\n \n // Directions: up, down, left, right\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n vector dirChar = {'U', 'D', 'L', 'R'};\n \n // BFS to find a path\n vector> visited(50, vector(50, false));\n vector> path(50, vector(50, '\\0'));\n queue> q;\n \n q.emplace(si, sj);\n visited[si][sj] = true;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (size_t d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited[ni][nj]) continue;\n \n // Check if the new position is on the same tile as the current one\n if (posToTile[i][j] == posToTile[ni][nj]) continue;\n \n visited[ni][nj] = true;\n path[ni][nj] = dirChar[d];\n q.emplace(ni, nj);\n }\n }\n \n // Reconstruct the path from si, sj to the furthest point\n string output;\n pair current = {si, sj};\n while (true) {\n bool found = false;\n for (size_t d = 0; d < 4; ++d) {\n int ni = current.first + dirs[d].first;\n int nj = current.second + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (path[ni][nj] == '\\0') continue;\n // Check tile uniqueness\n if (posToTile[current.first][current.second] == posToTile[ni][nj]) continue;\n output += dirChar[d];\n current = {ni, nj};\n found = true;\n break;\n }\n if (!found) break;\n }\n \n cout << output << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint H, W; // 30x30 grid\nvector> h_est, v_est; // estimated horizontal and vertical edge weights\nvector> h_cnt, v_cnt; // count of usage for each edge\n\nvector dirs = {\"U\", \"D\", \"L\", \"R\"};\n\n// BFS to generate a path\nstring bfs_path(int si, int sj, int ti, int tj) {\n vector> dist(H, vector(W, -1));\n vector> prev(H, vector

(W, {-1, -1}));\n queue

q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break;\n vector

ns;\n if (i > 0) ns.emplace_back(i-1, j);\n if (i < H-1) ns.emplace_back(i+1, j);\n if (j > 0) ns.emplace_back(i, j-1);\n if (j < W-1) ns.emplace_back(i, j+1);\n for (auto [ni, nj] : ns) {\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n q.emplace(ni, nj);\n }\n }\n }\n if (dist[ti][tj] == -1) return \"\";\n string path;\n P cur = {ti, tj};\n while (cur != P(si, sj)) {\n P p = prev[cur.first][cur.second];\n int di = cur.first - p.first;\n int dj = cur.second - p.second;\n if (di == -1) path += 'U';\n else if (di == 1) path += 'D';\n else if (dj == -1) path += 'L';\n else if (dj == 1) path += 'R';\n cur = p;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Random walk to generate a path\nstring random_walk(int si, int sj, int ti, int tj, int max_steps) {\n string path;\n int i = si, j = sj;\n while (max_steps-- > 0 && (i != ti || j != tj)) {\n vector possible;\n if (i > 0) possible.push_back('U');\n if (i < H-1) possible.push_back('D');\n if (j > 0) possible.push_back('L');\n if (j < W-1) possible.push_back('R');\n char move = possible[rand() % possible.size()];\n path += move;\n if (move == 'U') i--;\n else if (move == 'D') i++;\n else if (move == 'L') j--;\n else if (move == 'R') j++;\n }\n return path;\n}\n\n// Estimate edge weight from observed lengths\ndouble estimate_edge_weight(int i, int j, char dir) {\n if (dir == 'L' || dir == 'R') {\n if (h_cnt[i][j] == 0) return 1500.0;\n return h_est[i][j] * 1.0 / h_cnt[i][j];\n } else {\n if (v_cnt[i][j] == 0) return 1500.0;\n return v_est[i][j] * 1.0 / v_cnt[i][j];\n }\n}\n\nint main() {\n H = 30, W = 30;\n h_est.assign(H, vector(W, 0));\n v_est.assign(H, vector(W, 0));\n h_cnt.assign(H, vector(W, 0));\n v_cnt.assign(H, vector(W, 0));\n \n srand(time(nullptr));\n \n int query_count = 0;\n while (true) {\n int si, sj, ti, tj;\n if (query_count == 0) {\n cin >> si >> sj >> ti >> tj;\n } else {\n // Read the previous result (b_k)\n ll b_prev;\n cin >> b_prev;\n // Update the estimates based on the path taken in the previous query\n // This is a placeholder; actual implementation would track the path\n }\n \n // Generate multiple candidate paths\n string path1 = bfs_path(si, sj, ti, tj);\n string path2 = random_walk(si, sj, ti, tj, abs(si - ti) + abs(sj - tj) * 2);\n string path3 = random_walk(si, sj, ti, tj, abs(si - ti) * 2 + abs(sj - tj));\n \n vector candidates = {path1, path2, path3};\n if (candidates[0].empty()) candidates.erase(candidates.begin());\n \n // Select a path based on estimated weights\n double scores[3] = {0.0};\n for (int idx = 0; idx < candidates.size(); idx++) {\n string& p = candidates[idx];\n double score = 0.0;\n int pi = si, pj = sj;\n for (char c : p) {\n if (c == 'U' || c == 'D') {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n } else {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n scores[idx] = 1.0 / score;\n }\n \n // Choose the best candidate\n double max_score = -1.0;\n int best_idx = 0;\n for (int idx = 0; idx < candidates.size(); idx++) {\n if (scores[idx] > max_score) {\n max_score = scores[idx];\n best_idx = idx;\n }\n }\n \n string path = candidates[best_idx];\n \n // Output the path\n cout << path << endl;\n cout.flush();\n \n // Read the result (b_k)\n ll b_k;\n cin >> b_k;\n \n // Update estimates based on the path taken\n int pi = si, pj = sj;\n for (char c : path) {\n if (c == 'L' || c == 'R') {\n h_est[pi][pj] += b_k; // placeholder update\n h_cnt[pi][pj]++;\n } else {\n v_est[pi][pj] += b_k;\n v_cnt[pi][pj]++;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n \n query_count++;\n }\n \n return 0;\n}","ahc004":"#include \nusing namespace std;\n\n// Helper function to check if a string can be placed horizontally or vertically\nbool canPlaceHorizontal(const vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % 20;\n if (matrix[i][col] != '.' && matrix[i][col] != s[k]) {\n return false;\n }\n }\n return true;\n}\n\nbool canPlaceVertical(const vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % 20;\n if (matrix[row][j] != '.' && matrix[row][j] != s[k]) {\n return false;\n }\n }\n return true;\n}\n\n// Function to place a string horizontally or vertically\nvoid placeHorizontal(vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % 20;\n matrix[i][col] = s[k];\n }\n}\n\nvoid placeVertical(vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % 20;\n matrix[row][j] = s[k];\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 20;\n int M;\n cin >> N >> M;\n vector strings(M);\n for (int i = 0; i < M; ++i) {\n cin >> strings[i];\n }\n\n // Sort strings by length in descending order\n sort(strings.begin(), strings.end(), [](const string& a, const string& b) {\n return a.size() > b.size();\n });\n\n vector> matrix(N, vector(N, '.'));\n\n // Place strings with enhanced placement strategy\n for (const auto& s : strings) {\n int len = s.size();\n bool placed = false;\n\n // Try horizontal placement with enhanced strategy\n for (int i = 0; i < N && !placed; ++i) {\n for (int j = 0; j <= N - len && !placed; ++j) {\n if (canPlaceHorizontal(matrix, i, j, s)) {\n placeHorizontal(matrix, i, j, s);\n placed = true;\n }\n }\n }\n\n // Try vertical placement with enhanced strategy\n if (!placed) {\n for (int j = 0; j < N && !placed; ++j) {\n for (int i = 0; i <= N - len && !placed; ++i) {\n if (canPlaceVertical(matrix, i, j, s)) {\n placeVertical(matrix, i, j, s);\n placed = true;\n }\n }\n }\n }\n }\n\n // Character frequency analysis for filling empty cells\n vector charFreq(8, 0);\n for (const auto& s : strings) {\n for (char c : s) {\n charFreq[c - 'A']++;\n }\n }\n\n // Fill empty cells with the most frequent character\n char mostFrequentChar = 'A';\n int maxFreq = charFreq[0];\n for (int i = 0; i < 8; ++i) {\n if (charFreq[i] > maxFreq) {\n maxFreq = charFreq[i];\n mostFrequentChar = 'A' + i;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] == '.') {\n matrix[i][j] = mostFrequentChar;\n }\n }\n }\n\n // Local search to minimize empty cells and conflicts\n // This is a simple version where we try to swap characters to reduce conflicts\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] != '.') {\n for (int k = 0; k < N; ++k) {\n for (int l = 0; l < N; ++l) {\n if (i != k || j != l) {\n swap(matrix[i][j], matrix[k][l]);\n // Check if the swap improved the placement\n // (This is a placeholder for a more sophisticated check)\n swap(matrix[i][j], matrix[k][l]); // Revert the swap\n }\n }\n }\n }\n }\n }\n\n // Output the matrix\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << matrix[i][j];\n }\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n \n vector> time(N, vector(N, 0));\n vector> is_road(N, vector(N, false));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n is_road[i][j] = true;\n time[i][j] = grid[i][j] - '0';\n }\n }\n }\n \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.emplace_back(i, j);\n }\n }\n }\n \n vector directions = {\"U\", \"D\", \"L\", \"R\"};\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n \n vector>> adjacency(N, vector>(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 for (int d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && is_road[ni][nj]) {\n adjacency[i][j].emplace_back(ni, nj);\n }\n }\n }\n }\n \n vector path;\n set> visited;\n vector> seen(N, vector(N, false));\n \n function dfs = [&](int i, int j) {\n stack> st;\n st.emplace(i, j);\n visited.insert({i, j});\n seen[i][j] = true;\n vector> points = {i, j};\n \n while (!st.empty()) {\n auto [x, y] = st.top();\n st.pop();\n points.push_back({x, y});\n for (auto [nx, ny] : adjacency[x][y]) {\n if (!seen[nx][ny]) {\n seen[nx][ny] = true;\n st.emplace(nx, ny);\n }\n }\n }\n \n for (auto [x, y] : points) {\n path.push_back(\"D\");\n }\n };\n \n dfs(si, sj);\n \n string result;\n int curr_i = si, curr_j = sj;\n for (char move : path) {\n int di = 0, dj = 0;\n if (move == 'U') di = -1;\n if (move == 'D') di = 1;\n if (move == 'L') dj = -1;\n if (move == 'R') dj = 1;\n curr_i += di;\n curr_j += dj;\n result += move;\n }\n \n cout << result << endl;\n \n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct Task {\n vector d; // required skills\n vector deps; // dependencies\n int index;\n int earliest_start_day = 0; // Earliest possible start day based on dependencies\n int assigned_to = -1; // Which team member is assigned (-1 if not assigned)\n int start_day = -1; // Actual start day (-1 if not started)\n int completion_day = -1; // Completion day (-1 if not completed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].d.resize(K);\n for (int j = 0; j < K; ++j) {\n cin >> tasks[i].d[j];\n }\n tasks[i].index = i;\n }\n\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].deps.push_back(u);\n }\n\n // Build adjacency list for dependency graph\n vector> dep_graph(N);\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int dep : tasks[i].deps) {\n dep_graph[dep].push_back(i);\n in_degree[i]++;\n }\n }\n\n // Initial skill estimates for each team member (initialized to zero)\n vector> skillestimates(M, vector(K, 0.0));\n\n // Track completion times for each team member (for skill update)\n vector completion_times(M, 0.0); // Cumulative completion time\n vector task_count(M, 0); // Number of tasks completed by each member\n\n // Track which team members are busy (assigned a task)\n vector busy(M, false);\n\n // Track completed tasks\n vector completed(N, false);\n\n // Track available tasks (tasks with all dependencies completed)\n queue available_tasks;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n available_tasks.push(i);\n }\n }\n\n // Process days until all tasks are completed or day 2000\n for (int day = 1; day <= 2000; ++day) {\n // Collect tasks to assign today\n vector> assignments;\n\n // For each available team member, assign the \"best\" available task\n for (int member = 0; member < M; ++member) {\n if (busy[member]) continue; // Skip if busy\n\n // Find the best task for this member from available tasks\n int best_task = -1;\n double min_estimated_time = INFINITY;\n // We need to consider tasks that are available and not completed\n // For simplicity, we'll iterate through all tasks and check if available\n for (int t = 0; t < N; ++t) {\n if (completed[t]) continue;\n if (in_degree[t] > 0) continue; // Not available yet\n\n // Estimate time for this member to do this task\n double w = 0.0;\n for (int k = 0; k < K; ++k) {\n w += max(0.0, tasks[t].d[k] - skillestimates[member][k]);\n }\n double estimated_time = (w == 0) ? 1.0 : max(1.0, w + uniform_real_distribution(-3.0, 3.0).operator()());\n\n if (estimated_time < min_estimated_time) {\n min_estimated_time = estimated_time;\n best_task = t;\n }\n }\n\n if (best_task != -1) {\n assignments.emplace_back(member, best_task);\n busy[member] = true;\n tasks[best_task].assigned_to = member;\n tasks[best_task].start_day = day;\n }\n }\n\n // Output assignments\n cout << assignments.size();\n for (auto& [member, task] : assignments) {\n cout << \" \" << member + 1 << \" \" << task + 1;\n }\n cout << endl;\n cout.flush();\n\n // Read input: either -1 or list of completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n\n vector completed_members;\n for (int i = 0; i < n_completed; ++i) {\n int member;\n cin >> member;\n member--;\n completed_members.push_back(member);\n }\n\n // Update skill estimates and mark tasks as completed\n for (int member : completed_members) {\n if (busy[member]) {\n // Find which task this member completed\n for (int t = 0; t < N; ++t) {\n if (tasks[t].assigned_to == member && tasks[t].completion_day == -1) {\n // Assume we get the actual completion time from the problem, but here we simulate\n // For real submission, we don't have actual time, so we cannot update skills.\n // In a real scenario, we would need to get actual completion time from the judge.\n // Since we don't have it, we skip skill update for now.\n tasks[t].completion_day = day;\n completed[t] = true;\n busy[member] = false;\n\n // Update dependency graph: this task's dependents may now be available\n for (int next_task : dep_graph[t]) {\n in_degree[next_task]--;\n if (in_degree[next_task] == 0) {\n available_tasks.push(next_task);\n }\n }\n break;\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int a, b, c, d;\n Order(int a_=0, int b_=0, int c_=0, int d_=0) : a(a_), b(b_), c(c_), d(d_) {}\n};\n\n// Manhattan distance\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Heuristic: Choose orders that are close to the center and have short total distance\nvector select_orders(const vector& orders) {\n vector> scores;\n for(int i = 0; i < orders.size(); i++) {\n const auto& o = orders[i];\n int dist_to_center = dist(o.a, o.b, 400, 400) + dist(o.c, o.d, 400, 400);\n int dist_total = dist(o.a, o.b, o.c, o.d);\n scores.emplace_back(dist_to_center + dist_total, i);\n }\n sort(scores.begin(), scores.end());\n vector selected;\n for(int i = 0; i < 50; i++) {\n selected.push_back(scores[i].second);\n }\n return selected;\n}\n\nvector> construct_route(const vector& orders, const vector& selected) {\n vector> route;\n route.emplace_back(400, 400); // Start at center\n \n for(int idx : selected) {\n const auto& o = orders[idx];\n route.emplace_back(o.a, o.b); // Go to pickup\n route.emplace_back(o.c, o.d); // Then to delivery\n }\n \n // Return to center at the end\n route.emplace_back(400, 400);\n return route;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read all orders\n vector orders(1000);\n for(int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n orders[i] = Order(a, b, c, d);\n }\n \n // Select 50 orders based on heuristic\n vector selected = select_orders(orders);\n \n // Construct route\n vector> route = construct_route(orders, selected);\n \n // Output\n cout << \"50\";\n for(int idx : selected) cout << \" \" << (idx+1);\n cout << \"\\n\" << route.size();\n for(auto [x,y] : route) cout << \" \" << x << \" \" << y;\n cout << endl;\n \n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\nint round_sqrt(long long x) {\n long long s = sqrt(x);\n if ((s + 1) * (s + 1) <= x) s++;\n return (int)s;\n}\n\nint distance(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return round_sqrt(dx * dx + dy * dy);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 400, M = 1995;\n vector points(N);\n vector> edges(M);\n\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n int u = edges[i].first, v = edges[i].second;\n d[i] = distance(points[u], points[v]);\n }\n\n vector added(M, false);\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n \n function find = [&](int u) {\n while (parent[u] != u) {\n parent[u] = parent[parent[u]];\n u = parent[u];\n }\n return u;\n };\n\n auto unite = [&](int u, int v) {\n u = find(u);\n v = find(v);\n if (u == v) return false;\n parent[v] = u;\n return true;\n };\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n int u = edges[i].first, v = edges[i].second;\n if (unite(u, v)) {\n cout << \"1\\n\";\n added[i] = true;\n } else {\n cout << \"0\\n\";\n }\n cout.flush();\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N;\n vector> pets(N);\n for (int i = 0; i < N; ++i) {\n int x, y, t;\n cin >> x >> y >> t;\n pets[i] = {x - 1, y - 1, t};\n }\n cin >> M;\n vector> humans(M);\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n humans[i] = {x - 1, y - 1};\n }\n\n vector> grid(30, vector(30, false));\n vector> blocked(30, vector(30, false));\n for (auto [x, y, _] : pets) grid[x][y] = true;\n for (auto [x, y] : humans) grid[x][y] = true;\n\n for (int turn = 0; turn < 300; ++turn) {\n string action;\n for (int i = 0; i < M; ++i) {\n int x = humans[i].first;\n int y = humans[i].second;\n\n // Try to move first\n vector> moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n vector dirs = {'D', 'U', 'R', 'L'};\n int best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n // Check if adjacent to any pet\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n humans[i] = {moves[best].first, moves[best].second};\n grid[x][y] = false;\n grid[moves[best].first][moves[best].second] = true;\n } else {\n // Try to block\n best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n // Check if adjacent to any pet\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += tolower(dirs[best]);\n blocked[moves[best].first][moves[best].second] = true;\n } else {\n action += '.';\n }\n }\n }\n cout << action << endl;\n cout.flush();\n\n // Read pet moves\n string pet_moves_line;\n getline(cin >> ws, pet_moves_line); // Ensure we read the entire line\n istringstream iss(pet_moves_line);\n for (int i = 0; i < N; ++i) {\n string move;\n iss >> move;\n auto& [x, y, type] = pets[i]; // Correctly access tuple elements\n if (!move.empty()) {\n for (char c : move) {\n if (c == 'U') x--;\n else if (c == 'D') x++;\n else if (c == 'L') y--;\n else if (c == 'R') y++;\n }\n }\n }\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n cout << \"R\" << endl;\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Direction transition table: to[tile][enter_dir] = exit_dir or -1\nint 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\nvector> grid(30, vector(30));\nvector> rotation(30, vector(30, 0));\n\nint computeLength(int si, int sj, int sd, const vector>& rot) {\n int i = si, j = sj;\n int d = sd;\n int length = 0;\n vector> visited(30, vector(30, -1));\n int visit_id = abs(hash>(rot)) % 1000; // Just a dummy unique\n\n while (true) {\n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n int tile = grid[i][j] + 4 * rotation[i][j];\n d = to[tile][d];\n if (d == -1) return 0;\n int ni = i + di[d];\n int nj = j + dj[d];\n d = (d + 2) % 4;\n length++;\n if (ni == si && nj == sj && d == sd) {\n return length;\n }\n if (visited[i][j] == visit_id) {\n // Detect cycle but not closed properly\n return 0;\n }\n visited[i][j] = visit_id;\n i = ni;\n j = nj;\n }\n}\n\npair getTwoMaxLengths(const vector>& rot) {\n priority_queue pq;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int len = computeLength(i, j, d, rot);\n if (len > 0) pq.push(len);\n }\n }\n }\n if (pq.size() < 2) {\n return {0, 0};\n }\n int max1 = pq.top(); pq.pop();\n int max2 = pq.top(); pq.pop();\n return {max1, max2};\n}\n\nint score(const vector>& rot) {\n auto [l1, l2] = getTwoMaxLengths(rot);\n if (l1 == 0 || l2 == 0) return 0;\n return l1 * l2;\n}\n\nvector> rotateRandom() {\n vector> rot(30, vector(30));\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rot[i][j] = rand() % 4;\n }\n }\n return rot;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cin >> grid[i][j];\n }\n }\n\n // Initialize with random rotations\n vector> best_rot = rotateRandom();\n int best_score = score(best_rot);\n\n // Simple hill climbing\n const int iterations = 2000;\n for (int iter = 0; iter < iterations; iter++) {\n // Pick a random tile\n int i = rand() % 30;\n int j = rand() % 30;\n int old_rot = best_rot[i][j];\n for (int delta = 1; delta <= 3; delta++) {\n int new_rot = (old_rot + delta) % 4;\n best_rot[i][j] = new_rot;\n int current_score = score(best_rot);\n if (current_score > best_score) {\n best_score = current_score;\n } else {\n best_rot[i][j] = old_rot;\n }\n }\n }\n\n // Output the best rotations found\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n if (j < 29) cout << \" \";\n }\n cout << endl;\n }\n\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint N;\nvector board;\nmap hex_to_int = {\n {'0', 0}, {'1', 1}, {'2', 2}, {'3', 3},\n {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7},\n {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11},\n {'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}\n};\n\nint int_to_dir(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 -1;\n}\n\nchar dir_to_char(int d) {\n if (d == 0) return 'U';\n if (d == 1) return 'D';\n if (d == 2) return 'L';\n if (d == 3) return 'R';\n return 'X';\n}\n\nbool is_valid(int i, int j) {\n return i >= 0 && i < N && j >= 0 && j < N;\n}\n\nint get_bit(int mask, int pos) {\n return (mask >> pos) & 1;\n}\n\nint get_connection(int i, int j, int dir) {\n int mask = hex_to_int[board[i][j]];\n if (dir == 0) return get_bit(mask, 1); // up\n if (dir == 1) return get_bit(mask, 3); // down\n if (dir == 2) return get_bit(mask, 0); // left\n if (dir == 3) return get_bit(mask, 2); // right\n return 0;\n}\n\nvector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n\npair move_empty(int i, int j, int dir) {\n int ni = i + dirs[dir].first;\n int nj = j + dirs[dir].second;\n if (!is_valid(ni, nj) || board[ni][nj] == '0') return {-1, -1};\n return {ni, nj};\n}\n\nint count_components() {\n vector> visited(N, vector(N, false));\n int components = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == '0') continue;\n if (!visited[i][j]) {\n components++;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n int mask = hex_to_int[board[x][y]];\n for (int d = 0; d < 4; ++d) {\n if (get_connection(x, y, d)) {\n int nx = x + dirs[d].first, ny = y + dirs[d].second;\n if (is_valid(nx, ny) && board[nx][ny] != '0' && !visited[nx][ny]) {\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n }\n }\n }\n }\n }\n return components;\n}\n\nvector solve() {\n int empty_i = -1, empty_j = -1;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n if (board[i][j] == '0') {\n empty_i = i;\n empty_j = j;\n }\n vector result;\n vector> history;\n history.emplace_back(empty_i, empty_j);\n\n for (int step = 0; step < 2 * N * N * N; ++step) {\n int best_components = count_components();\n char best_move = 0;\n vector> best_pos = {empty_i, empty_j};\n\n for (int d = 0; d < 4; ++d) {\n auto [ni, nj] = move_empty(empty_i, empty_j, d);\n if (ni == -1) continue;\n swap(board[empty_i][empty_j], board[ni][nj]);\n int components = count_components();\n swap(board[empty_i][empty_j], board[ni][nj]);\n\n if (components < best_components) {\n best_components = components;\n best_move = dir_to_char(d);\n best_pos = {ni, nj};\n }\n }\n\n if (best_move == 0) break;\n\n result.push_back(best_move);\n swap(board[empty_i][empty_j], board[best_pos.first][best_pos.second]);\n empty_i = best_pos.first;\n empty_j = best_pos.second;\n history.emplace_back(empty_i, empty_j);\n }\n\n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n int T = 2 * N * N * N;\n board.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n auto result = solve();\n\n cout << string(result.begin(), result.end()) << endl;\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\n// Define Point structure\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n \n // Overload equality operator for Point\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n};\n\n// Compute cross product of vectors (p1 - o) and (p2 - o)\nlong long cross(const Point& o, const Point& p1, const Point& p2) {\n return (long long)(p1.x - o.x) * (p2.y - o.y) - (long long)(p1.y - o.y) * (p2.x - o.x);\n}\n\n// Check if point p is on the left side of the directed line (a, b)\nbool isLeft(const Point& a, const Point& b, const Point& p) {\n return cross(a, b, p) > 0;\n}\n\n// Compute orientation of three points (clockwise, counterclockwise, or collinear)\nint orientation(const Point& p, const Point& q, const Point& r) {\n long long val = (long long)(q.y - p.y) * (r.x - q.x) - (long long)(q.x - p.x) * (r.y - q.y);\n if (val == 0) return 0; // Collinear\n return (val > 0) ? 1 : 2; // Clockwise or Counterclockwise\n}\n\n// Compute Euclidean distance squared between two points\nlong long dist(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\n// Graham scan to compute convex hull\nvector convexHull(vector points) {\n int n = points.size();\n if (n <= 1) return points;\n\n // Find the lowest point\n int i = 0;\n for (int j = 1; j < n; j++)\n if (points[j].y < points[i].y || (points[j].y == points[i].y && points[j].x < points[i].x))\n i = j;\n\n // Sort points angularly around the pivot\n sort(points.begin(), points.end(), [&](const Point& a, const Point& b) {\n int o = orientation(points[i], a, b);\n if (o == 0) return (dist(points[i], a) < dist(points[i], b));\n return o == 1;\n });\n\n vector hull;\n hull.push_back(points[i]);\n\n for (int j = 1; j < n; j++) {\n while (hull.size() >= 2 && orientation(hull[hull.size()-2], hull.back(), points[j]) != 2)\n hull.pop_back();\n hull.push_back(points[j]);\n }\n\n return hull;\n}\n\n// Compute centroid of a set of points\nPoint centroid(const vector& points) {\n if (points.empty()) return Point(0, 0);\n long long cx = 0, cy = 0;\n for (const auto& p : points) {\n cx += p.x;\n cy += p.y;\n }\n return Point(cx / points.size(), cy / points.size());\n}\n\n// Generate a line that separates cluster from others using PCA on angles\nvector> separateClusters(const vector>& clusters) {\n vector> lines;\n for (size_t i = 0; i < clusters.size(); ++i) { // Use size_t to match clusters.size()\n const auto& cluster = clusters[i];\n if (cluster.empty()) continue;\n\n // Compute centroid of the cluster\n Point c = centroid(cluster);\n\n // Collect vectors from centroid to points\n vector vectors;\n for (const auto& p : cluster) {\n vectors.emplace_back(p.x - c.x, p.y - c.y);\n }\n\n // Compute PCA to find principal direction\n double sum_x2 = 0, sum_y2 = 0, sum_xy = 0;\n for (const auto& v : vectors) {\n sum_x2 += (double)v.x * v.x;\n sum_y2 += (double)v.y * v.y;\n sum_xy += (double)v.x * v.y;\n }\n\n int n = vectors.size();\n if (n == 0) continue;\n\n double trace = sum_x2 + sum_y2;\n double det = sum_x2 * sum_y2 - sum_xy * sum_xy;\n\n // Skip if degenerate\n if (abs(det) < 1e-9) continue;\n\n // Compute eigenvalues\n double eigen_val1 = (trace + sqrt(trace * trace - 4 * det)) / 2;\n double eigen_val2 = (trace - sqrt(trace * trace - 4 * det)) / 2;\n\n // Find eigenvector for smaller eigenvalue (minor component)\n double eigen_val = eigen_val2;\n double discriminant = sqrt((sum_x2 - eigen_val) * (sum_y2 - eigen_val) - sum_xy * sum_xy);\n if (abs(discriminant) < 1e-9) continue;\n\n double cos_theta = (sum_x2 - eigen_val) / discriminant;\n double sin_theta = sum_xy / discriminant;\n\n // Rotate to find perpendicular direction for cut line\n double nx = -sin_theta, ny = cos_theta;\n\n // Create line far enough to pass through centroid\n Point p1(c.x + 100000 * nx, c.y + 100000 * ny);\n Point p2(c.x - 100000 * nx, c.y - 100000 * ny);\n\n lines.emplace_back(p1, p2);\n }\n return lines;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, K;\n if(!(cin >> N >> K)) return 0; // Handle input errors gracefully\n vector a(10);\n for (int i = 0; i < 10; ++i) {\n if (!(cin >> a[i])) return 0;\n }\n\n vector strawberries(N);\n for (int i = 0; i < N; ++i) {\n if (!(cin >> strawberries[i].x >> strawberries[i].y)) return 0;\n }\n\n // Simple clustering: assign to clusters of size close to target sizes\n vector> clusters(10);\n vector target(10);\n for (int d = 0; d < 10; ++d) target[d] = a[d] * (d + 1);\n\n // Greedy assignment\n vector used(N, false); // Track which strawberries have been used\n for (int d = 0; d < 10; ++d) {\n int need = target[d];\n while (need > 0) {\n int best = -1;\n int best_count = 0;\n for (int i = 0; i < N; ++i) {\n if (used[i]) continue; // Skip if already used\n bool found = false;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (p == strawberries[i]) {\n found = true;\n break;\n }\n }\n if (found) break;\n }\n if (found) continue;\n\n int cnt = 0;\n for (const auto& clust : clusters) {\n for (const auto& p : clust) {\n if (dist(p, strawberries[i]) <= 100) ++cnt;\n }\n }\n if (cnt > best_count) {\n best_count = cnt;\n best = i;\n }\n }\n if (best == -1) break;\n clusters[d].push_back(strawberries[best]);\n used[best] = true; // Mark as used\n --need;\n }\n }\n\n // Flatten clusters and generate separating lines\n vector> lines = separateClusters(clusters);\n\n // Output\n cout << lines.size() << \"\\n\";\n for (const auto& line : lines) {\n cout << line.first.x << \" \" << line.first.y << \" \"\n << line.second.x << \" \" << line.second.y << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint N;\nvector

dots;\nmap dot_map;\n\n/* Rectangle structure */\nstruct Rect {\n P p1, p2, p3, p4;\n int score;\n};\n\nset> drawn_edges;\nset

new_dots_set;\nvector solutions; \n\n/* Helper: normalize for edge storage */\npair normalize_edge(const P& a, const P& b) {\n if (a < b) return {a, b};\n else return {b, a};\n}\n\n/* Point in bounds */\nbool in_bounds(const P& p) {\n return p.first >= 0 && p.first < N && p.second >= 0 && p.second < N;\n}\n\n/* Perpendicularity of vectors */\nbool is_perpendicular_slope(ll dx1, ll dy1, ll dx2, ll dy2) {\n return dx1 * dy2 + dx2 * dy1 == 0;\n}\n\n/* Rectangle shape check */\nbool is_valid_rectangle_shape(const P& p1, const P& p2, const P& p3, const P& p4) {\n if (abs(p1.first - p2.first) == abs(p1.second - p2.second) &&\n abs(p2.first - p3.first) == abs(p2.second - p3.second) &&\n abs(p3.first - p4.first) == abs(p3.second - p4.second) &&\n abs(p4.first - p1.first) == abs(p4.second - p1.second)) {\n return true;\n }\n if (p1.first == p2.first && p2.second == p3.second &&\n p3.first == p4.first && p4.second == p1.second &&\n p1.first == p3.first && p2.first == p4.first) {\n return true;\n }\n return false;\n}\n\n/* Check if any interior edge points are occupied */\nbool interior_occupied_on_edges(const P& a, const P& b, const vector>& grid, const P& p1) {\n if (a.first == b.first) {\n for (int y = min(a.second, b.second) + 1; y < max(a.second, b.second); ++y) {\n P pt = {a.first, y};\n if (grid[pt.first][pt.second] == 1 && !(pt == p1)) return true;\n }\n } else if (a.second == b.second) {\n for (int x = min(a.first, b.first) + 1; x < max(a.first, b.first); ++x) {\n P pt = {x, a.second};\n if (grid[pt.first][pt.second] == 1 && !(pt == p1)) return true;\n }\n } else if (abs(a.first - b.first) == abs(a.second - b.second)) {\n int dx = (b.first - a.first) / abs(b.first - a.first);\n int dy = (b.second - a.second) / abs(b.second - a.second);\n for (int i = 1; i < abs(a.first - b.first); ++i) {\n P pt = {a.first + dx * i, a.second + dy * i};\n if (grid[pt.first][pt.second] == 1 && !(pt == p1)) return true;\n }\n }\n return false;\n}\n\nbool is_valid_rect(const P& p1, const P& p2, const P& n1, const P& n2, const vector>& grid) {\n if (!is_valid_rectangle_shape(p1, p2, n1, n2)) return false;\n\n vector

corners = {p1, p2, n1, n2};\n vector

perimeter_edges[4] = { {p1, p2}, {p2, n1}, {n1, n2}, {n2, p1} };\n\n for (const auto& e : perimeter_edges) {\n if (interior_occupied_on_edges(e[0], e[1], grid, p1)) return false;\n }\n return true;\n}\n\nint calculate_score(const P& p) {\n ll c = (N - 1) / 2;\n ll dx = p.first - c, dy = p.second - c;\n return (dx * dx + dy * dy + 1);\n}\n\nvoid generate_candidates(\n const set

& unoccupied,\n vector& candidates,\n const map& dot_map,\n const set

& new_dots,\n const vector>& grid\n) {\n candidates.clear();\n for (const auto& p1 : unoccupied) {\n for (int dx : {1, -1}) {\n for (int dy : {1, -1}) {\n if (dx == 0 || dy == 0) continue;\n\n P p2(p1.first + dx, p1.second + dy);\n P n1(p1.first - dx, p1.second + dy);\n P n2(p1.first - dx, p1.second - dy);\n\n if (!in_bounds(p2) || !in_bounds(n1) || !in_bounds(n2)) continue;\n if (!(dot_map.count(p2) || new_dots.count(p2))) continue;\n if (!(dot_map.count(n1) || new_dots.count(n1))) continue;\n if (!(dot_map.count(n2) || new_dots.count(n2))) continue;\n\n if (is_valid_rect(p1, p2, n1, n2, grid)) {\n candidates.push_back({p1, p2, n1, n2, calculate_score(p1)});\n }\n }\n }\n // the rest of the function remains unchanged from previous version\n // Axis-aligned and other variants were already handled above\n\n for (int dx : {1, -1}) {\n P p2(p1.first + dx, p1.second);\n P n1(p1.first, p1.second + dx);\n P n2(p1.first + dx, p1.second - dx);\n\n if (!in_bounds(p2) || !in_bounds(n1) || !in_bounds(n2)) continue;\n if (!(dot_map.count(p2) || new_dots.count(p2))) continue;\n if (!(dot_map.count(n1) || new_dots.count(n1))) continue;\n if (!(dot_map.count(n2) || new_dots.count(n2))) continue;\n\n if (is_valid_rect(p1, p2, n1, n2, grid)) {\n candidates.push_back({p1, p2, n1, n2, calculate_score(p1)});\n }\n }\n\n for (int dy : {1, -1}) {\n P p2(p1.first, p1.second + dy);\n P n1(p1.first + dy, p1.second);\n P n2(p1.first - dy, p1.second + dy);\n\n if (!in_bounds(p2) || !in_bounds(n1) || !in_bounds(n2)) continue;\n if (!(dot_map.count(p2) || new_dots.count(p2))) continue;\n if (!(dot_map.count(n1) || new_dots.count(n1))) continue;\n if (!(dot_map.count(n2) || new_dots.count(n2))) continue;\n\n if (is_valid_rect(p1, p2, n1, n2, grid)) {\n candidates.push_back({p1, p2, n1, n2, calculate_score(p1)});\n }\n }\n }\n}\n\n/* Main execution function */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n\n vector> grid(N, vector(N, 0));\n dots.clear();\n dot_map.clear();\n\n int M; cin >> M;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dots.push_back({x, y});\n dot_map[{x, y}] = 1;\n grid[x][y] = 1;\n }\n\n /* Track unoccupied grid points */\n set

unoccupied;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!dot_map.count({i, j}) && !new_dots_set.count({i, j})) {\n unoccupied.insert({i, j});\n }\n }\n }\n\n while (true) {\n vector candidates;\n generate_candidates(unoccupied, candidates, dot_map, new_dots_set, grid);\n if (candidates.empty()) break;\n\n sort(candidates.begin(), candidates.end(),\n [](const Rect& a, const Rect& b) { return a.score > b.score; });\n Rect best = candidates[0];\n solutions.push_back(best);\n grid[best.p1.first][best.p1.second] = 1;\n unoccupied.erase(best.p1);\n new_dots_set.insert(best.p1);\n\n drawn_edges.insert(normalize_edge(best.p1, best.p2));\n drawn_edges.insert(normalize_edge(best.p2, best.p3));\n drawn_edges.insert(normalize_edge(best.p3, best.p4));\n drawn_edges.insert(normalize_edge(best.p4, best.p1));\n }\n\n cout << solutions.size() << endl;\n for (const Rect& sol : solutions) {\n cout << sol.p1.first << \" \" << sol.p1.second << \" \"\n << sol.p2.first << \" \" << sol.p2.second << \" \"\n << sol.p3.first << \" \" << sol.p3.second << \" \"\n << sol.p4.first << \" \" << sol.p4.second << endl;\n }\n\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstruct Cell {\n int flavor = 0; // 0: empty\n};\n\nconst int SIZE = 10;\nCell grid[SIZE][SIZE];\n\nvoid reset_empty() {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j].flavor = 0;\n }\n }\n}\n\nvector> get_empty_cells() {\n vector> empty;\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) {\n empty.emplace_back(i, j);\n }\n }\n }\n return empty;\n}\n\nvoid place_candy(int t, int p, int flavor) {\n vector> empty = get_empty_cells();\n auto [i, j] = empty[p - 1];\n grid[i][j].flavor = flavor;\n}\n\nvoid tilt(const char dir) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) continue;\n if (dir == 'F') {\n for (int k = i - 1; k >= 0; --k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k+1][j].flavor == 0) {\n swap(grid[i][j], grid[k+1][j]);\n }\n break;\n }\n }\n } else if (dir == 'B') {\n for (int k = i + 1; k < SIZE; ++k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k-1][j].flavor == 0) {\n swap(grid[i][j], grid[k-1][j]);\n }\n break;\n }\n }\n } else if (dir == 'L') {\n for (int k = j - 1; k >= 0; --k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k+1].flavor == 0) {\n swap(grid[i][j], grid[i][k+1]);\n }\n break;\n }\n }\n } else if (dir == 'R') {\n for (int k = j + 1; k < SIZE; ++k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k-1].flavor == 0) {\n swap(grid[i][j], grid[i][k-1]);\n }\n break;\n }\n }\n }\n }\n }\n}\n\nvector calculate_components() {\n vector> visited(SIZE, vector(SIZE, false));\n vector component_sizes(3, 0);\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (visited[i][j] || grid[i][j].flavor == 0) continue;\n int flavor = grid[i][j].flavor;\n queue> q;\n q.emplace(i, j);\n visited[i][j] = true;\n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (nx >= 0 && nx < SIZE && ny >= 0 && ny < SIZE &&\n !visited[nx][ny] && grid[nx][ny].flavor == flavor) {\n visited[nx][ny] = true;\n q.emplace(nx, ny);\n }\n }\n }\n component_sizes[flavor - 1] += size * size;\n }\n }\n return component_sizes;\n}\n\nchar decide_tilt(const vector& flavors_input) {\n reset_empty();\n vector flavors = flavors_input; // Create a copy to avoid const issues\n int p;\n cout << flush;\n cin >> p;\n int flavor = flavors[0];\n flavors.erase(flavors.begin());\n place_candy(0, p, flavor);\n\n vector dirs = {'F', 'B', 'L', 'R'};\n vector scores(4, 0);\n Cell backup_grid[SIZE][SIZE];\n\n // Backup current grid state\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup_grid[i][j] = grid[i][j];\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n // Restore backup grid for each direction test\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n\n tilt(dirs[d]);\n scores[d] = calculate_components()[flavor - 1];\n }\n\n // Restore original grid\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n\n int max_score = -1;\n char best_dir = 'F';\n for (int d = 0; d < 4; ++d) {\n if (scores[d] > max_score) {\n max_score = scores[d];\n best_dir = dirs[d];\n }\n }\n\n cout << best_dir << '\\n' << flush;\n tilt(best_dir);\n\n return best_dir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector flavors(100);\n for (int i = 0; i < 100; ++i) {\n cin >> flavors[i];\n }\n\n for (int t = 0; t < 100; ++t) {\n if (t == 99) {\n cout << '\\n' << flush;\n break;\n }\n decide_tilt({flavors.begin() + t, flavors.end()});\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double eps;\n cin >> M >> eps;\n \n // Dynamic N selection based on M and epsilon\n int N = 20;\n if (M > 70) N = 35;\n else if (M > 40) N = 28;\n else if (M > 20) N = 22;\n \n if (eps > 0.3) N += 10;\n else if (eps > 0.2) N += 5;\n \n N = min(max(N, 4), 100);\n \n // Generate M distinct graphs with controlled edge distribution\n cout << N << \"\\n\";\n int total_edges = N * (N - 1) / 2;\n \n vector graphs(M);\n for (int k = 0; k < M; ++k) {\n // Use exponential distribution for edge density\n double density = exp(log(0.8) * (1.0 - k * 1.0 / (M - 1)));\n int target_edges = static_cast(density * total_edges + 0.5);\n \n string g(total_edges, '0');\n // Fill edges in a way that preserves structure under noise\n for (int i = 0; i < target_edges; ++i) {\n int pos = (i * 7) % total_edges; // Simple perturbation\n g[pos] = '1';\n }\n graphs[k] = g;\n cout << g << \"\\n\";\n }\n cout << flush;\n \n // Process queries with improved classification\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n // Enhanced edge counting with noise robustness\n int edge_count = count(H.begin(), H.end(), '1');\n \n // Dynamic threshold based on epsilon\n double noise_factor = 1.0 + eps * 2.5;\n int adjusted_count = static_cast(edge_count / noise_factor + 0.5);\n \n // Map to nearest graph using precomputed densities\n double best_error = 1e9;\n int best_k = 0;\n for (int k = 0; k < M; ++k) {\n int expected_edges = count(graphs[k].begin(), graphs[k].end(), '1');\n double error = abs(adjusted_count - expected_edges);\n if (error < best_error) {\n best_error = error;\n best_k = k;\n }\n }\n \n cout << best_k << \"\\n\";\n cout << flush;\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long INF = 1e9;\n\nvoid floydWarshall(int N, vector>& dist) {\n for (int k = 0; k < N; ++k)\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);\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 vector u(M), v(M), w(M);\n for (int i = 0; i < M; ++i) {\n cin >> u[i] >> v[i] >> w[i];\n u[i]--; v[i]--;\n }\n\n // Ignore vertex coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Initialize distance matrix for APSP\n vector> dist(N, vector(N, INF));\n for (int i = 0; i < N; ++i) dist[i][i] = 0;\n\n for (int i = 0; i < M; ++i) {\n dist[u[i]][v[i]] = min(dist[u[i]][v[i]], (long long)w[i]);\n dist[v[i]][u[i]] = min(dist[v[i]][u[i]], (long long)w[i]);\n }\n\n floydWarshall(N, dist);\n\n // Estimate impact of each edge by counting shortest paths through it\n vector> edge_impacts;\n for (int i = 0; i < M; ++i) {\n int a = u[i], b = v[i];\n long long count = 0;\n\n for (int src = 0; src < N; ++src) {\n for (int dst = 0; dst < N; ++dst) {\n if (src == dst) continue;\n if (dist[src][a] + w[i] + dist[b][dst] == dist[src][dst]) {\n count++;\n }\n if (dist[src][b] + w[i] + dist[a][dst] == dist[src][dst]) {\n count++;\n }\n }\n }\n\n edge_impacts.emplace_back(count, i);\n }\n\n // Sort edges by impact (ascending, repair edges with small impact later)\n sort(edge_impacts.begin(), edge_impacts.end());\n\n // Assign repair days\n vector result(M);\n for (int i = 0; i < M; ++i) {\n int idx = edge_impacts[i].second;\n result[idx] = (i % D) + 1;\n }\n\n // Output result\n for (int i = 0; i < M; ++i) {\n cout << result[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), f2(D), r1(D), r2(D);\n \n for (int i = 0; i < 2; ++i) {\n for (int j = 0; j < D; ++j) cin >> f1[j];\n for (int j = 0; j < D; ++j) cin >> r1[j];\n for (int j = 0; j < D; ++j) cin >> f2[j];\n for (int j = 0; j < D; ++j) cin >> r2[j];\n }\n\n // Initialize 3D array to store which block is placed where\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n // Identify regions where both silhouettes need material\n vector>> common_region(D, vector>(D, vector(D, false)));\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool f_needed1 = (f1[z][x] == '1');\n bool r_needed1 = (r1[z][y] == '1');\n bool f_needed2 = (f2[z][x] == '1');\n bool r_needed2 = (r2[z][y] == '1');\n common_region[z][x][y] = f_needed1 && f_needed2 && r_needed1 && r_needed2;\n }\n }\n }\n\n // Create blocks for common region (shared between both objects)\n int block_id = 1;\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 (block_id == 1000005) break;\n if (common_region[z][x][y]) {\n b1[z][x][y] = block_id;\n b2[z][x][y] = block_id;\n ++block_id;\n }\n }\n if (block_id == 1000005) break;\n }\n if (block_id == 1000005) break;\n }\n\n // Fill remaining regions with unique 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 (b1[z][x][y] == 0 && f1[z][x] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && f2[z][x] == '1') {\n b2[z][x][y] = block_id++;\n }\n if (b1[z][x][y] == 0 && r1[z][y] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && r2[z][y] == '1') {\n b2[z][x][y] = block_id++;\n }\n }\n }\n }\n\n // Output\n cout << block_id - 1 << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b1[z][x][y];\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b2[z][x][y];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \nusing namespace std;\n\ndouble dist(const pair& a, const pair& b) {\n long long dx = a.first - b.first;\n long long dy = a.second - b.second;\n return sqrt(dx * dx + dy * dy);\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);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].first >> stations[i].second;\n }\n\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n u--; v--;\n edges[i] = {u, v, w};\n }\n\n vector> residents(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].first >> residents[i].second;\n }\n\n // Step 1: MST via Kruskal\u2019s\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n auto find = [&](int x) {\n while (parent[x] != x) {\n parent[x] = parent[parent[x]];\n x = parent[x];\n }\n return x;\n };\n\n auto unite = [&](int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n parent[y] = x;\n return true;\n };\n\n vector> sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end(), [](const auto& a, const auto& b) {\n return get<2>(a) < get<2>(b);\n });\n\n vector B(M, 0);\n for (auto& [u, v, w] : sorted_edges) {\n if (unite(u, v)) {\n for (int i = 0; i < M; ++i) {\n int a, b, weight;\n tie(a, b, weight) = edges[i];\n if ((a == u && b == v) || (a == v && b == u)) {\n B[i] = 1;\n break;\n }\n }\n }\n }\n\n // Step 2: Assign residents to nearest node, then compute minimal P_i via binary search\n vector P(N, 0);\n vector> dists(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n dists[i][j] = dist(stations[i], residents[j]);\n }\n }\n\n // For each resident, assign to nearest node and note required radius\n vector required(N, 0.0);\n for (int j = 0; j < K; ++j) {\n int best_node = -1;\n double best_dist = 1e18;\n for (int i = 0; i < N; ++i) {\n if (dists[i][j] < best_dist) {\n best_dist = dists[i][j];\n best_node = i;\n }\n }\n required[best_node] = max(required[best_node], best_dist);\n }\n\n // Binary search for minimal P_i for each node\n for (int i = 0; i < N; ++i) {\n double lo = 0.0, hi = required[i];\n for (int iter = 0; iter < 60; ++iter) {\n double mid = (lo + hi) / 2;\n bool ok = false;\n for (int j = 0; j < K; ++j) {\n if (dists[i][j] <= mid) continue;\n // Try to cover this resident via other nodes\n bool covered = false;\n for (int k = 0; k < N; ++k) {\n if (k == i) continue;\n if (dists[k][j] <= P[k]) {\n covered = true;\n break;\n }\n }\n if (!covered) {\n ok = false;\n break;\n }\n ok = true;\n }\n if (ok) hi = mid;\n else lo = mid;\n }\n P[i] = min((int)ceil(hi), 5000);\n }\n\n // Post-optimization: Try to reduce P_i by checking neighbors\n for (int i = 0; i < N; ++i) {\n if (P[i] == 0) continue;\n // Try reducing by 1 and check if still valid\n P[i]--;\n vector covered(K, false);\n for (int j = 0; j < K; ++j) {\n for (int k = 0; k < N; ++k) {\n if (dists[k][j] <= P[k]) {\n covered[j] = true;\n break;\n }\n }\n }\n if (!all_of(covered.begin(), covered.end(), [](bool x) { return x; })) {\n P[i]++;\n }\n }\n\n cout << endl;\n for (int i = 0; i < N; ++i) {\n cout << P[i] << (i == N - 1 ? \"\\n\" : \" \");\n }\n for (int i = 0; i < M; ++i) {\n cout << B[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Ball {\n int number;\n int x, y;\n Ball(int n, int x, int y) : number(n), x(x), y(y) {}\n};\n\nvector> pyramid;\nvector, pair>> swaps;\n\nbool isAdjacent(int x1, int y1, int x2, int y2) {\n if (x1 == x2 - 1 && y1 == y2 - 1) return true;\n if (x1 == x2 - 1 && y1 == y2) return true;\n if (x1 == x2 && y1 == y2 - 1) return true;\n if (x1 == x2 && y1 == y2 + 1) return true;\n if (x1 == x2 + 1 && y1 == y2) return true;\n if (x1 == x2 + 1 && y1 == y2 + 1) return true;\n return false;\n}\n\nvoid swapBalls(int x1, int y1, int x2, int y2) {\n if (!isAdjacent(x1, y1, x2, y2)) return;\n swaps.push_back({{x1, y1}, {x2, y2}});\n swap(pyramid[x1][y1].number, pyramid[x2][y2].number);\n}\n\nint findMinBallBelow(int x, int y, int N) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int nx = x + 1; nx < N; ++nx) {\n for (int ny = 0; ny <= nx; ++ny) {\n if (pyramid[nx][ny].number < minVal) {\n minVal = pyramid[nx][ny].number;\n minX = nx;\n minY = ny;\n }\n }\n }\n if (minX != -1) return pyramid[minX][minY].number;\n return INT_MAX;\n}\n\nvoid processTier(int tier, int N) {\n int rows = tier + 1;\n for (int y = 0; y <= tier; ++y) {\n int x = tier;\n Ball& current = pyramid[x][y];\n if (x + 1 >= N) continue;\n bool valid = true;\n if (y < rows - 1 && current.number > pyramid[x+1][y].number) valid = false;\n if (y + 1 < rows && current.number > pyramid[x+1][y+1].number) valid = false;\n if (!valid) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < rows - 1; ++ny) {\n if (pyramid[x+1][ny].number < current.number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n int futureMin = findMinBallBelow(x + 1, minY, N);\n if (futureMin < current.number) {\n swapBalls(x, y, minX, minY);\n }\n }\n }\n }\n}\n\nvoid dynamicPostProcess(int N) {\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (x + 1 >= N) continue;\n if (pyramid[x][y].number > pyramid[x+1][y].number) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < x + 2; ++ny) {\n if (pyramid[x+1][ny].number < pyramid[x][y].number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n swapBalls(x, y, minX, minY);\n }\n }\n if (y + 1 <= x && pyramid[x][y].number > pyramid[x+1][y+1].number) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < x + 2; ++ny) {\n if (pyramid[x+1][ny].number < pyramid[x][y].number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n swapBalls(x, y, minX, minY);\n }\n }\n }\n }\n}\n\nint main() {\n int N = 30;\n pyramid.resize(N);\n for (int x = 0; x < N; ++x) {\n pyramid[x].reserve(x + 1);\n for (int y = 0; y <= x; ++y) {\n int num;\n cin >> num;\n pyramid[x].emplace_back(num, x, y);\n }\n }\n\n for (int tier = 0; tier < N - 1; ++tier) {\n processTier(tier, N);\n }\n\n dynamicPostProcess(N);\n\n cout << swaps.size() << endl;\n for (auto& sw : swaps) {\n cout << sw.first.first << \" \" << sw.first.second << \" \"\n << sw.second.first << \" \" << sw.second.second << endl;\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint D = 9;\nint N;\nvector> grid;\nvector> dist;\nvector> obstacles;\nvector> empty_cells;\nvector> visited;\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nvoid bfs(int sx, int sy) {\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n visited[sx][sy] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i], ny = y + dy[i];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D) continue;\n if (grid[nx][ny] || visited[nx][ny]) continue;\n dist[nx][ny] = dist[x][y] + 1;\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D >> N;\n grid.assign(D, vector(D, false));\n dist.assign(D, vector(D, -1));\n visited.assign(D, vector(D, false));\n\n int entrance_x = 0, entrance_y = (D - 1) / 2;\n grid[entrance_x][entrance_y] = true;\n\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = true;\n obstacles.emplace_back(r, c);\n }\n\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (grid[i][j]) continue;\n empty_cells.emplace_back(i, j);\n }\n }\n\n bfs(entrance_x, entrance_y);\n\n vector>> candidates;\n for (auto [x, y] : empty_cells) {\n if (dist[x][y] == -1) continue;\n candidates.emplace_back(-dist[x][y], make_pair(x, y));\n }\n sort(candidates.begin(), candidates.end());\n\n vector> storage_order;\n vector>> input;\n\n cout << flush;\n\n for (int d = 0; d < D * D - 1 - N; d++) {\n int t;\n cin >> t;\n input.emplace_back(t, make_pair(-1, -1));\n\n int best_idx = -1;\n int best_dist = -1;\n for (auto &[prio, pos] : candidates) {\n int x = pos.first, y = pos.second;\n if (dist[x][y] >= 0) {\n best_idx = pos.first;\n best_dist = pos.second;\n break;\n }\n }\n\n cout << best_idx << \" \" << best_dist << \"\\n\" << flush;\n\n for (auto &[prio, pos] : candidates) {\n if (pos.first == best_idx && pos.second == best_dist) {\n prio = 1e9;\n break;\n }\n }\n }\n\n for (auto &[t, pos] : input) {\n cout << pos.first << \" \" << pos.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n = 50, m = 100;\n vector> c(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> c[i][j];\n }\n }\n\n vector> adj(m + 1);\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int color = c[i][j];\n // Check up\n if (i > 0) {\n int up = c[i - 1][j];\n if (up != 0 && up != color) {\n adj[color].insert(up);\n adj[up].insert(color);\n }\n }\n // Check left\n if (j > 0) {\n int left = c[i][j - 1];\n if (left != 0 && left != color) {\n adj[color].insert(left);\n adj[left].insert(color);\n }\n }\n }\n }\n\n vector> d(n, vector(n, 0));\n\n // Place each color in a unique position, ensuring adjacency\n vector> positions;\n for (int color = 1; color <= m; ++color) {\n // Find a position not already occupied and on the border to maximize adjacency\n bool placed = false;\n for (int i = 0; i < n && !placed; ++i) {\n for (int j = 0; j < n && !placed; ++j) {\n if (d[i][j] == 0) {\n // Check if this position can satisfy adjacency requirements\n bool valid = true;\n for (int other : adj[color]) {\n // Check adjacent positions for other colors\n bool found = false;\n for (int dx = -1; dx <= 1; ++dx) {\n for (int dy = -1; dy <= 1; ++dy) {\n if (abs(dx) + abs(dy) != 1) continue;\n int ni = i + dx, nj = j + dy;\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n if (d[ni][nj] == other) {\n found = true;\n break;\n }\n } else {\n // Outside is considered color 0, so no adjacency\n }\n }\n if (found) break;\n }\n if (!found) {\n valid = false;\n break;\n }\n }\n if (valid) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n }\n }\n }\n }\n if (!placed) {\n // Fallback: place in the first available spot\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n break;\n }\n }\n if (placed) break;\n }\n }\n }\n\n // Now, fill the remaining area with 0, but ensure connectivity\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n // Check if surrounding is all 0 or out of bounds, then keep as 0\n // Otherwise, might need to assign a color, but for simplicity, keep 0\n d[i][j] = 0;\n }\n }\n }\n\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j > 0) cout << \" \";\n cout << d[i][j];\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n cin >> N >> D >> Q;\n\n vector results;\n\n // Perform Q queries\n for (int q = 0; q < Q; ++q) {\n // Example query: compare two items\n // For simplicity, compare item 0 with item 1\n int nL = 1, nR = 1;\n vector L = {0};\n vector R = {1};\n\n // Output the query\n cout << nL << \" \" << nR << \" \" << L[0] << \" \" << R[0] << \"\\n\";\n cout.flush();\n\n // Read the result\n string res;\n cin >> res;\n results.push_back(res);\n }\n\n // After Q queries, output a simple division\n // Assign items to groups in a round-robin fashion\n vector assignment(N);\n for (int i = 0; i < N; ++i) {\n assignment[i] = i % D;\n }\n\n // Output the division\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << assignment[i];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n = 200, m = 10;\n vector> stacks(m);\n vector pos(n + 1); // pos[v] = {stack_index, position_from_bottom}\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int v;\n cin >> v;\n stacks[i].push_back(v);\n pos[v] = {i, j};\n }\n }\n\n vector removed(n + 1, false);\n vector> operations;\n\n auto current_pos = pos; // Copy initial positions\n\n for (int target = 1; target <= n; ++target) {\n if (removed[target]) continue;\n auto [si, pos_in_stack] = current_pos[target];\n if (pos_in_stack == stacks[si].size() - 1) {\n // Already on top, remove it\n operations.emplace_back(target, 0);\n removed[target] = true;\n stacks[si].pop_back();\n // Update positions of remaining boxes in this stack\n for (int j = pos_in_stack - 1; j >= 0; --j) {\n int v = stacks[si][j];\n current_pos[v] = {si, j};\n }\n stacks[si].pop_back();\n } else {\n // Need to move this box to the top of some stack\n // Find a stack where this box can be moved to the top\n int best_stack = si;\n int min_boxes_moved = n; // Upper bound\n for (int dest = 0; dest < m; ++dest) {\n if (dest == si) continue;\n // Calculate how many boxes we need to move from current stack si to get target to top\n int boxes_moved = pos_in_stack + 1; // All boxes from pos_in_stack down to bottom\n // Check if target is at the top after moving to dest stack\n // After moving, target becomes top of dest stack\n // Energy cost is boxes_moved + 1\n if (boxes_moved + 1 < min_boxes_moved) {\n min_boxes_moved = boxes_moved + 1;\n best_stack = dest;\n }\n }\n // Move target and above to best_stack\n vector to_move;\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n to_move.push_back(stacks[si][j]);\n }\n // Update stacks\n stacks[best_stack].insert(stacks[best_stack].end(), to_move.begin(), to_move.end());\n // Update positions\n for (int j = 0; j < to_move.size(); ++j) {\n int v = to_move[j];\n current_pos[v] = {best_stack, (int)stacks[best_stack].size() - to_move.size() + j};\n }\n // Update the original stack\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n stacks[si].pop_back();\n }\n // Record operation\n operations.emplace_back(target, best_stack + 1);\n }\n }\n\n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if(!(cin >> N)) return 0;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> d[i][j];\n }\n }\n \n vector> visited(N, vector(N, false));\n vector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n vector dir_char = {'R', 'D', 'L', 'U'};\n \n function dfs = [&](int i, int j, int parent_dir) {\n visited[i][j] = true;\n vector> candidates;\n for (int di = 0; di < 4; ++di) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || visited[ni][nj]) continue;\n bool wall = false;\n if (dirs[di].first == 0) {\n if (v[i][min(j, nj)] == '1') wall = true;\n } else {\n if (h[min(i, ni)][j] == '1') wall = true;\n }\n if (!wall) {\n candidates.emplace_back(di, parent_dir);\n }\n }\n sort(candidates.begin(), candidates.end(), [&](const auto& a, const auto& b) {\n int di1 = a.first, pdi1 = a.second;\n int di2 = b.first, pdi2 = b.second;\n int ni1 = i + dirs[di1].first;\n int nj1 = j + dirs[di1].second;\n int ni2 = i + dirs[di2].first;\n int nj2 = j + dirs[di2].second;\n return d[ni1][nj1] > d[ni2][nj2];\n });\n for (auto [di, pdir] : candidates) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n cout << dir_char[di];\n dfs(ni, nj, di);\n cout << dir_char[(di + 2) % 4];\n }\n };\n \n dfs(0, 0, -1);\n cout << endl;\n \n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct Point {\n int i, j;\n\n Point(int i_ = -1, int j_ = -1) : i(i_), j(j_) {}\n};\n\nbool checkCoverage(const string& window, const unordered_set& rem) {\n for (const auto& s : rem) {\n // Only check if pattern length <= window length\n if (s.size() > window.size()) continue;\n if (window.substr(window.size() - s.size(), s.size()) == s) {\n return true;\n }\n }\n return false;\n}\n\nPoint greedyStep(const Point& curPos, const vector& grid,\n unordered_set rem, string window) {\n const int N = grid.size();\n const int radius = 3;\n\n // Try immediate neighbor moves first\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int ni = curPos.i + dx[d], nj = curPos.j + dy[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n string candidate(1, grid[ni][nj]); // Fix: using string(1, char)\n if (!rem.empty() && window.size() >= 5 && checkCoverage(window + candidate, rem)) {\n return Point(ni, nj);\n }\n }\n\n // Explore within radius neighborhood\n for (int r = 1; r <= radius; ++r) {\n for (int dx = -r; dx <= r; ++dx) {\n for (int dy = -r; dy <= r; ++dy) {\n if (abs(dx) == r || abs(dy) == r) {\n int ni = curPos.i + dx, nj = curPos.j + dy;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n string candidate(1, grid[ni][nj]); // Fix: using string(1, char)\n string trial = window + candidate;\n if (!rem.empty() && trial.size() >= 5 && checkCoverage(trial, rem)) {\n return Point(ni, nj);\n }\n }\n }\n }\n }\n\n // Fallback: stay in place\n return curPos;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0;\n int si, sj;\n cin >> si >> sj;\n\n vector grid(N);\n for (auto& row : grid) cin >> row;\n\n vector t(M);\n for (auto& tt : t) cin >> tt;\n\n unordered_set rem(t.begin(), t.end());\n\n string window;\n vector path;\n Point cur(si, sj);\n path.emplace_back(cur);\n window += grid[si][sj];\n\n const int MAX_STEPS = 5000;\n for (int step = 0; step < MAX_STEPS && !rem.empty(); ++step) {\n Point nxt = greedyStep(cur, grid, rem, window);\n if (nxt.i == cur.i && nxt.j == cur.j) continue; // Skip if no progress\n cur = nxt;\n window += grid[cur.i][cur.j];\n if (window.size() > 5) {\n window = window.substr(window.size() - 5, 5);\n }\n\n // Clean up covered substrings\n auto it = rem.begin();\n while (it != rem.end()) {\n if (window.size() >= it->size() &&\n window.substr(window.size() - it->size(), it->size()) == *it) {\n it = rem.erase(it);\n } else {\n ++it;\n }\n }\n path.push_back(cur);\n }\n\n for (const auto& p : path) {\n cout << p.i << \" \" << p.j << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct OilField {\n vector> cells;\n int minI, minJ;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector fields(M);\n for (int idx = 0; idx < M; ++idx) {\n int d;\n cin >> d;\n fields[idx].cells.resize(d);\n for (int i = 0; i < d; ++i) {\n cin >> fields[idx].cells[i].first >> fields[idx].cells[i].second;\n }\n int minI = fields[idx].cells[0].first;\n int minJ = fields[idx].cells[0].second;\n for (auto &p : fields[idx].cells) {\n minI = min(minI, p.first);\n minJ = min(minJ, p.second);\n }\n fields[idx].minI = minI;\n fields[idx].minJ = minJ;\n for (auto &p : fields[idx].cells) {\n p.first -= minI;\n p.second -= minJ;\n }\n }\n\n vector> v(N, vector(N, -1));\n vector> positive;\n\n // Step 1: Drill some key points to get initial information\n // We can start by drilling corners and centers\n vector> drillCandidates = {\n {N/2, N/2}, {0, 0}, {N-1, 0}, {0, N-1}, {N-1, N-1}\n };\n\n for (auto &p : drillCandidates) {\n int i = p.first, j = p.second;\n if (i >= N || j >= N) continue;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n cin >> v[i][j];\n if (v[i][j] > 0) {\n positive.emplace_back(i, j);\n }\n }\n\n // Step 2: Try to guess based on current positive cells\n // For each oil field shape, try to match with positive cells\n // This is a heuristic; we might need to refine further\n\n set> posSet(positive.begin(), positive.end());\n\n // Try to find candidate positions for each oil field\n vector> placements;\n for (const auto &field : fields) {\n int size = field.cells.size();\n for (int i = 0; i <= N - field.minI - 1; ++i) {\n for (int j = 0; j <= N - field.minJ - 1; ++j) {\n bool valid = true;\n for (auto &cell : field.cells) {\n int x = i + cell.first;\n int y = j + cell.second;\n if (x >= N || y >= N) {\n valid = false;\n break;\n }\n if (v[x][y] == 0) {\n valid = false;\n break;\n }\n }\n if (valid) {\n placements.emplace_back(i, j);\n }\n }\n }\n }\n\n // For now, just output all positive cells found by drilling\n cout << \"a \" << positive.size();\n for (auto &p : positive) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n cout.flush();\n\n int result;\n cin >> result;\n if (result == 1) {\n return 0;\n }\n\n // If failed, we might need to do more work, but for this example, we just exit\n // In a real solution, you would refine the strategy here\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nstruct Rect {\n int i0, j0, i1, j1;\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n vector> a(D, vector(N));\n for (int d = 0; d < D; ++d) {\n for (int k = 0; k < N; ++k) {\n cin >> a[d][k];\n }\n }\n\n for (int d = 0; d < D; ++d) {\n int row = 0;\n for (int k = 0; k < N; ++k) {\n int needed = a[d][k];\n // Assign one full row with width = needed if fits\n int width = needed;\n if (width > W) width = W;\n\n int j0 = 0, j1 = j0 + width;\n int i0 = row, i1 = row + 1;\n\n cout << i0 << \" \" << j0 << \" \" << i1 << \" \" << j1 << \"\\n\";\n row++;\n }\n }\n\n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst int MOD = 998244353;\n\nstruct Operation {\n int m, p, q;\n};\n\n\nvector greedy(const vector>& a, const vector>>& s, int K) {\n vector operations;\n vector> board = a;\n\n for (int step = 0; step < K; ++step) {\n // Track best improvement\n int best_improve = -1;\n Operation best_op;\n\n for (int m = 0; m < (int)s.size(); ++m) {\n for (int p = 0; p <= 9 - 3; ++p) {\n for (int q = 0; q <= 9 - 3; ++q) {\n // Local board state before stamp application\n vector> temp_board = board;\n\n // Apply stamp to obtain improvement\n int improve = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int x = p + i;\n int y = q + j;\n int current = temp_board[x][y];\n temp_board[x][y] = (current + s[m][i][j]) % MOD;\n // Calculate improvement\n improve += (temp_board[x][y] - current + MOD) % MOD;\n }\n }\n\n // Store best option\n if (improve > best_improve) {\n best_improve = improve;\n best_op = {m, p, q};\n }\n }\n }\n }\n\n if (best_improve > 0) {\n // Apply the chosen best option to board\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int x = best_op.p + i;\n int y = best_op.q + j;\n board[x][y] = (board[x][y] + s[best_op.m][i][j]) % MOD;\n }\n }\n operations.push_back(best_op);\n } else {\n // No improvement possible, break\n break;\n }\n }\n\n return operations;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n int N, M, K;\n cin >> N >> M >> K;\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 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 // Run greedy\n auto ops = greedy(a, stamps, K);\n\n // Ensure within K\n if (ops.size() > K) {\n ops.resize(K);\n }\n\n // Output\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int x, y;\n bool holding;\n int id;\n};\n\nint N;\nvector> A;\nvector cranes;\nvector> grid;\nvector> occupied;\nvector actions;\n\nvector> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\nchar dir_char[4] = {'R', 'D', 'L', 'U'};\n\nbool is_valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nvoid place_container(int x, int y, int cont) {\n grid[x][y] = cont;\n occupied[x][y] = true;\n}\n\nvoid pickup(Crane& crane, int cont) {\n crane.holding = cont;\n occupied[crane.x][crane.y] = false;\n grid[crane.x][crane.y] = -1;\n}\n\nvoid release(Crane& crane, int x, int y) {\n grid[x][y] = crane.holding;\n occupied[x][y] = true;\n crane.holding = -1;\n}\n\nbool move_crane(Crane& crane, int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!is_valid(nx, ny)) return false;\n if (crane.holding != -1 && occupied[nx][ny]) return false;\n if (crane.holding == -1 && grid[nx][ny] != -1 && nx == N - 1 && ny == N - 1) return false;\n if (occupied[nx][ny] && crane.holding == -1) {\n if (grid[nx][ny] != -1) return false;\n }\n occupied[crane.x][crane.y] = false;\n crane.x = nx;\n crane.y = ny;\n occupied[crane.x][crane.y] = true;\n return true;\n}\n\nvoid simulate_turn(vector& moves) {\n for (int i = 0; i < N; ++i) {\n if (A[i][0] != -1 && !occupied[i][0] && cranes[i].holding == -1) {\n place_container(i, 0, A[i][0]);\n A[i][0] = A[i][1];\n for (int j = 1; j < N; ++j) A[i][j] = A[i][j + 1];\n A[i][N - 1] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n Crane& crane = cranes[i];\n char move = moves[i][actions.size()];\n if (move == 'P') {\n if (crane.holding != -1 || grid[crane.x][crane.y] == -1) continue;\n pickup(crane, grid[crane.x][crane.y]);\n } else if (move == 'Q') {\n if (crane.holding == -1 || occupied[crane.x][crane.y]) continue;\n release(crane, crane.x, crane.y);\n } else if (move == 'B') {\n if (crane.holding != -1) continue;\n crane.holding = -2;\n } else {\n int dx = 0, dy = 0;\n switch (move) {\n case 'U': dx = -1; break;\n case 'D': dx = 1; break;\n case 'L': dy = -1; break;\n case 'R': dy = 1; break;\n default: break;\n }\n if (dx != 0 || dy != 0) {\n move_crane(crane, dx, dy);\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1 && grid[N - 1][N - 1] != -1 && cranes[i].holding == -1) {\n int cont = grid[N - 1][N - 1];\n occupied[N - 1][N - 1] = false;\n grid[N - 1][N - 1] = -1;\n }\n }\n}\n\nvector solve() {\n actions.resize(N);\n fill(grid.begin(), grid.end(), vector(N, -1));\n fill(occupied.begin(), occupied.end(), vector(N, false));\n cranes.resize(N);\n for (int i = 0; i < N; ++i) {\n cranes[i] = {i, 0, false, -1, i};\n actions[i].clear();\n }\n\n vector target;\n for (int i = 0; i < N * N; ++i) target.push_back(i);\n vector dispatch_order;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dispatch_order.push_back(i * N + j);\n\n int steps = 0;\n while (steps < 10000) {\n vector moves(N, string(1, '.'));\n bool progress = false;\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].holding != -1) continue;\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1) continue;\n int target_x = N - 1, target_y = N - 1;\n vector> path;\n int dx = 0, dy = 0;\n\n if (grid[cranes[i].x][cranes[i].y] != -1) {\n moves[i][steps] = 'P';\n progress = true;\n continue;\n }\n\n if (cranes[i].x == target_x && cranes[i].y == target_y) {\n continue;\n }\n\n int nx = cranes[i].x, ny = cranes[i].y;\n while (nx != target_x || ny != target_y) {\n int best = -1;\n for (int d = 0; d < 4; ++d) {\n int nx2 = nx + directions[d].first;\n int ny2 = ny + directions[d].second;\n if (!is_valid(nx2, ny2)) continue;\n if (occupied[nx2][ny2] && grid[nx2][ny2] != -1) continue;\n if (d == 0 && ny == N - 1) continue;\n if (d == 1 && nx == N - 1) continue;\n if (d == 2 && ny == 0) continue;\n if (d == 3 && nx == 0) continue;\n best = d;\n break;\n }\n if (best == -1) break;\n path.emplace_back(nx, ny);\n nx += directions[best].first;\n ny += directions[best].second;\n }\n if (!path.empty()) {\n moves[i][steps] = dir_char[directions[best].first == 1 ? 1 :\n directions[best].second == 1 ? 0 :\n directions[best].first == -1 ? 3 : 2];\n progress = true;\n }\n }\n\n vector current_moves = moves;\n simulate_turn(current_moves);\n for (int i = 0; i < N; ++i)\n actions[i].push_back(current_moves[i].back());\n\n if (!progress) break;\n steps++;\n }\n\n return actions;\n}\n\nint main() {\n cin >> N;\n A = vector>(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 grid = vector>(N, vector(N, -1));\n occupied = vector>(N, vector(N, false));\n\n auto result = solve();\n for (const auto& s : result)\n cout << s << '\\n';\n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Cell {\n int i, j, val;\n Cell(int i_, int j_, int val_) : i(i_), j(j_), val(val_) {}\n bool operator<(const Cell& other) const {\n return abs(val) < abs(other.val); // max-heap based on magnitude\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector> h(N, vector(N));\n \n priority_queue max_heap;\n unordered_map> present;\n\n // Initialization: push all non-zero cells to heap, recording their presence\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (h[i][j] != 0) {\n max_heap.emplace(i, j, h[i][j]);\n present[i][j] = true;\n }\n }\n }\n\n const vector dirs = {\"D\", \"U\", \"R\", \"L\"};\n const vector> deltas = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};\n\n vector output;\n int cur_i = 0, cur_j = 0, cur_load = 0;\n\n while (!max_heap.empty()) {\n Cell top = max_heap.top(); max_heap.pop();\n int ti = top.i, tj = top.j, target_val = top.val;\n\n if (!present[ti][tj]) continue; // already handled\n\n // Compute moves for vertical direction\n int di_needed = ti - cur_i;\n if (di_needed > 0) {\n for (int m = 0; m < di_needed; ++m) output.push_back(\"D\");\n } else if (di_needed < 0) {\n for (int m = 0; m < -di_needed; ++m) output.push_back(\"U\");\n }\n\n // Compute moves for horizontal direction\n int dj_needed = tj - cur_j;\n if (dj_needed > 0) {\n for (int m = 0; m < dj_needed; ++m) output.push_back(\"R\");\n } else if (dj_needed < 0) {\n for (int m = 0; m < -dj_needed; ++m) output.push_back(\"L\");\n }\n\n // Update current position\n cur_i = ti;\n cur_j = tj;\n\n if (target_val > 0 && cur_load < 1'000'000) {\n int load = min(target_val, 1'000'000 - cur_load);\n output.push_back(\"+\" + to_string(load));\n cur_load += load;\n h[ti][tj] -= load;\n } else if (target_val < 0 && cur_load > 0) {\n int unload = min(-target_val, cur_load);\n output.push_back(\"-\" + to_string(unload));\n cur_load -= unload;\n h[ti][tj] += unload;\n } else {\n continue; // unchanged, skip further processing\n }\n\n // Update heap and presence: if height becomes zero, remove entry\n if (h[ti][tj] == 0) {\n present[ti].erase(tj);\n } else {\n // Push new value, maintaining heap property\n max_heap.emplace(ti, tj, h[ti][tj]);\n }\n }\n\n // Flush output\n for (const auto& cmd : output) {\n cout << cmd << '\\n';\n }\n\n return 0;\n}","ahc035":"#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, T;\n cin >> N >> M >> T;\n\n int seed_count = 2 * N * (N - 1);\n vector> seeds(seed_count, vector(M));\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n }\n\n vector total_values(seed_count);\n for (int i = 0; i < seed_count; ++i) {\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n\n for (int turn = 0; turn < T; ++turn) {\n vector> grid(N, vector(N));\n vector used(seed_count, false);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int best_index = -1;\n int best_value = -1;\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k] && total_values[k] > best_value) {\n best_value = total_values[k];\n best_index = k;\n }\n }\n grid[i][j] = best_index;\n used[best_index] = true;\n }\n }\n\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) cout << \" \";\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n }\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n vector> sources, targets;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (s[i][j] == '1') sources.emplace_back(i, j);\n if (t[i][j] == '1') targets.emplace_back(i, j);\n }\n \n // Design tree: linear chain of length min(V, something reasonable)\n int Vp = min(V, 2); // Use just 2 vertices: root and one fingertip\n cout << Vp << \"\\n\";\n if (Vp > 1) cout << \"0 1\\n\";\n \n // Initial position of root\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n // Precompute directions: assume fingertip is to the right of root\n // We'll move around and rotate as needed\n \n // Simple strategy: move to each source, grab, move to target, release\n // We'll simulate positions and orientations\n \n struct Pos { int x, y; };\n struct State {\n Pos root;\n int dir; // direction of edge from root to child: 0=R,1=D,2=L,3=U\n vector fingertips; // positions of fingertips relative to root\n };\n \n State st;\n st.root = {0, 0};\n st.dir = 0; // right\n if (Vp >= 2) {\n st.fingertips.push_back({st.root.x + 1, st.root.y}); // child at (1,0)\n }\n \n // Precompute all moves\n vector moves;\n \n for (int i = 0; i < M; ++i) {\n // Move to source i\n auto [sx, sy] = sources[i];\n // First, move root close to source\n int dx = sx - st.root.x;\n int dy = sy - st.root.y;\n // Move root to (sx, st.root.y) then adjust y\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\"; // no rotate\n op += \".\\n\"; // no action for fingertip\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Now root is at (sx, st.root.y), need to align fingertip to (sx, sy)\n dx = sy - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dx > 0) ? 1 : -1;\n st.fingertips[0].y += (dx > 0) ? 1 : -1;\n }\n \n // Rotate to make fingertip point to the source\n // Currently fingertip is at (root.x+1, root.y) if dir=0\n // We want it to point to (sx, sy). Since we are already at (sx, sy) for root, just grab\n // Grab\n string op;\n op += \".\\n\"; // no move\n op += \".\\n\"; // no rotate\n op += \"P\\n\"; // grab\n moves.push_back(op);\n \n // Move to target i\n auto [tx, ty] = targets[i];\n dx = tx - st.root.x;\n dy = ty - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Release\n op = \".\\n.\\nP\\n\";\n moves.push_back(op);\n }\n \n // Output moves\n for (const auto& mv : moves) {\n cout << mv;\n }\n \n return 0;\n}","ahc039":"#include \n#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\n// Function to compute the score for a given rectangle\nint compute_score(const vector& mackerels, const vector& sardines,\n int min_x, int min_y, int max_x, int max_y) {\n int a = 0, b = 0;\n for (const auto& p : mackerels) {\n if (p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y) {\n a++;\n }\n }\n for (const auto& p : sardines) {\n if (p.x >= min_x && p.x <= max_x && p.y >= min_y && p.y <= max_y) {\n b++;\n }\n }\n return a - b;\n}\n\n// Function to perform a local search to refine the polygon boundaries\nvoid local_search(int& min_x, int& min_y, int& max_x, int& max_y,\n const vector& mackerels, const vector& sardines) {\n // Define a small range for local search\n const int STEP = 1;\n const int RADIUS = 2;\n\n for (int dx = -RADIUS; dx <= RADIUS; ++dx) {\n for (int dy = -RADIUS; dy <= RADIUS; ++dy) {\n int new_min_x = min_x + dx;\n int new_min_y = min_y + dy;\n int new_max_x = max_x + dx;\n int new_max_y = max_y + dy;\n\n if (new_min_x < 0) new_min_x = 0;\n if (new_min_y < 0) new_min_y = 0;\n if (new_max_x > 100000) new_max_x = 100000;\n if (new_max_y > 100000) new_max_y = 100000;\n\n int new_score = compute_score(mackerels, sardines, new_min_x, new_min_y, new_max_x, new_max_y);\n int current_score = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y);\n\n if (new_score > current_score) {\n min_x = new_min_x;\n min_y = new_min_y;\n max_x = new_max_x;\n max_y = new_max_y;\n // Reset the search range to explore further from the new position\n dx = -RADIUS;\n dy = -RADIUS;\n }\n }\n }\n}\n\n// Function to run the algorithm with a given grid size\npair> run_algorithm(const vector& mackerels, const vector& sardines, int grid_size, int cell_size) {\n vector> grid_score(grid_size, vector(grid_size, 0));\n\n for (const auto& p : mackerels) {\n int gx = p.x / cell_size;\n int gy = p.y / cell_size;\n if (gx >= 0 && gx < grid_size && gy >= 0 && gy < grid_size) {\n grid_score[gx][gy]++;\n }\n }\n\n for (const auto& p : sardines) {\n int gx = p.x / cell_size;\n int gy = p.y / cell_size;\n if (gx >= 0 && gx < grid_size && gy >= 0 && gy < grid_size) {\n grid_score[gx][gy]--;\n }\n }\n\n // Find the best cells\n vector> best_cells;\n for (int x = 0; x < grid_size; ++x) {\n for (int y = 0; y < grid_size; ++y) {\n if (grid_score[x][y] > 0) {\n best_cells.emplace_back(x, y);\n }\n }\n }\n\n // Select the best rectangle from the best cells\n int best_min_x = 0, best_min_y = 0, best_max_x = 0, best_max_y = 0;\n int best_score = -1e9;\n for (const auto& cell : best_cells) {\n int min_x = cell.first * cell_size;\n int min_y = cell.second * cell_size;\n int max_x = (cell.first + 1) * cell_size - 1;\n int max_y = (cell.second + 1) * cell_size - 1;\n int score = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y);\n if (score > best_score) {\n best_score = score;\n best_min_x = min_x;\n best_min_y = min_y;\n best_max_x = max_x;\n best_max_y = max_y;\n }\n }\n\n // If no positive-scoring cells, fallback to the best single cell\n if (best_score == -1e9) {\n int best_gx = 0, best_gy = 0;\n best_score = grid_score[0][0];\n for (int x = 0; x < grid_size; ++x) {\n for (int y = 0; y < grid_size; ++y) {\n if (grid_score[x][y] > best_score) {\n best_score = grid_score[x][y];\n best_gx = x;\n best_gy = y;\n }\n }\n }\n best_min_x = best_gx * cell_size;\n best_min_y = best_gy * cell_size;\n best_max_x = (best_gx + 1) * cell_size - 1;\n best_max_y = (best_gy + 1) * cell_size - 1;\n }\n\n // Local search to refine the polygon boundaries\n local_search(best_min_x, best_min_y, best_max_x, best_max_y, mackerels, sardines);\n\n vector polygon = {\n Point(best_min_x, best_min_y),\n Point(best_max_x, best_min_y),\n Point(best_max_x, best_max_y),\n Point(best_min_x, best_max_y)\n };\n\n return {best_score, polygon};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector mackerels(N), sardines(N);\n for (int i = 0; i < N; ++i) {\n cin >> mackerels[i].x >> mackerels[i].y;\n }\n for (int i = 0; i < N; ++i) {\n cin >> sardines[i].x >> sardines[i].y;\n }\n\n // Run the algorithm with different grid sizes and select the best result\n vector grid_sizes = {50, 60, 70};\n vector cell_sizes = {2000, 1800, 1600};\n\n int best_overall_score = -1e9;\n vector best_polygon;\n\n for (int i = 0; i < grid_sizes.size(); ++i) {\n auto [score, polygon] = run_algorithm(mackerels, sardines, grid_sizes[i], cell_sizes[i]);\n if (score > best_overall_score) {\n best_overall_score = score;\n best_polygon = polygon;\n }\n }\n\n // Ensure the polygon is valid (at least 4 vertices and no self-intersection)\n cout << best_polygon.size() << \"\\n\";\n for (const auto& p : best_polygon) {\n cout << p.x << \" \" << p.y << \"\\n\";\n }\n\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\nusing Point = pair;\nusing Rect = tuple; // x1, y1, x2, y2\n\nRect place_rect(const Rect& existing, const Rect& new_rect, char dir, int b_idx) {\n ll x1, y1, x2, y2;\n if (b_idx == -1) {\n if (dir == 'U') {\n x1 = get<0>(new_rect);\n y1 = get<1>(new_rect);\n x2 = get<2>(new_rect);\n y2 = get<3>(new_rect);\n } else {\n x1 = get<0>(new_rect);\n y1 = get<1>(new_rect);\n x2 = get<2>(new_rect);\n y2 = get<3>(new_rect);\n }\n } else {\n ll ex2 = get<2>(existing);\n ll ey2 = get<3>(existing);\n if (dir == 'U') {\n x1 = get<0>(new_rect);\n y1 = ey2;\n x2 = get<2>(new_rect);\n y2 = ey2 + get<3>(new_rect);\n } else {\n x1 = ex2;\n y1 = get<1>(new_rect);\n x2 = ex2 + get<2>(new_rect);\n y2 = get<3>(new_rect);\n }\n }\n return make_tuple(x1, y1, x2, y2);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, T;\n double sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector> wh(N);\n for (int i = 0; i < N; ++i) {\n cin >> wh[i].first >> wh[i].second;\n }\n \n // Simulate true dimensions based on observed values and sigma\n default_random_engine gen;\n normal_distribution dist(0.0, sigma);\n vector> true_wh(N);\n for (int i = 0; i < N; ++i) {\n double dw = dist(gen);\n double dh = dist(gen);\n true_wh[i].first = max(1, static_cast(round(wh[i].first + dw)));\n true_wh[i].second = max(1, static_cast(round(wh[i].second + dh)));\n }\n \n vector> placements;\n \n for (int t = 0; t < T; ++t) {\n vector> placement;\n vector placed_rects;\n \n // Place the first rectangle at origin without rotation\n placement.emplace_back(0, 0, 'U', -1);\n placed_rects.emplace_back(\n 0, 0,\n static_cast(true_wh[0].first),\n static_cast(true_wh[0].second)\n );\n \n // Place subsequent rectangles\n for (int i = 1; i < N; ++i) {\n int best_idx = i;\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n ll best_width = 0, best_height = 0;\n \n for (int rot : {0, 1}) {\n ll w, h;\n if (rot == 0) {\n w = true_wh[i].first;\n h = true_wh[i].second;\n } else {\n w = true_wh[i].second;\n h = true_wh[i].first;\n }\n \n Rect new_rect = make_tuple(0, 0, static_cast(w), static_cast(h));\n \n for (char dir : {'U', 'L'}) {\n for (size_t b_idx = 0; b_idx <= placed_rects.size(); ++b_idx) {\n int idx = -1;\n if (b_idx != placed_rects.size()) idx = b_idx;\n Rect placed = place_rect(\n b_idx < placed_rects.size() ? placed_rects[b_idx] : make_tuple(0LL, 0LL, 0LL, 0LL),\n new_rect, dir, idx\n );\n ll width = get<2>(placed) - get<0>(placed);\n ll height = get<3>(placed) - get<1>(placed);\n if (width + height < best_width + best_height) {\n best_width = width;\n best_height = height;\n best_idx = i;\n best_rot = rot;\n best_dir = dir;\n best_b = idx;\n }\n }\n }\n }\n \n placement.emplace_back(best_idx, best_rot, best_dir, best_b);\n Rect new_rect = make_tuple(0, 0, static_cast(true_wh[best_idx].first), static_cast(true_wh[best_idx].second));\n if (best_rot) {\n swap(get<2>(new_rect), get<3>(new_rect));\n }\n Rect placed = place_rect(\n best_b >= 0 ? placed_rects[best_b] : make_tuple(0LL, 0LL, 0LL, 0LL),\n new_rect, best_dir, best_b\n );\n placed_rects.push_back(placed);\n }\n \n cout << placement.size() << \"\\n\";\n for (const auto& p : placement) {\n cout << get<0>(p) << \" \" << get<1>(p) << \" \" << get<2>(p) << \" \" << get<3>(p) << \"\\n\";\n }\n cout.flush();\n \n ll W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n vector A(N);\n for (int i = 0; i < N; ++i) {\n cin >> A[i];\n }\n vector> edges(M);\n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n adj[u].insert(v);\n adj[v].insert(u);\n }\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n vector parent(N, -1);\n vector used(N, false);\n\n // Iterate over nodes sorted by beauty in descending order\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(),\n [&](int a, int b) { return A[a] > A[b]; });\n\n for (int i : indices) {\n if (used[i]) continue;\n used[i] = true;\n parent[i] = -1;\n // Try to build a tree of height <= H rooted at i\n queue> q; // (node, height)\n q.emplace(i, 0);\n while (!q.empty()) {\n auto [u, depth] = q.front(); q.pop();\n if (depth >= H) continue;\n for (int v : adj[u]) {\n if (!used[v]) {\n used[v] = true;\n parent[v] = u;\n q.emplace(v, depth + 1);\n }\n }\n }\n }\n\n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << '\\n';\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstruct Move {\n char dir;\n int pos;\n};\n\nint main() {\n int N = 20;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector moves;\n\n auto add_moves = [&](int i, int j, bool is_row, bool left_or_up) {\n if (is_row) {\n if (left_or_up) {\n for (int k = 0; k <= j; ++k) {\n moves.push_back({'L', i});\n }\n } else {\n for (int k = 0; k <= N - 1 - j; ++k) {\n moves.push_back({'R', i});\n }\n }\n } else {\n if (left_or_up) {\n for (int k = 0; k <= i; ++k) {\n moves.push_back({'U', j});\n }\n } else {\n for (int k = 0; k <= N - 1 - i; ++k) {\n moves.push_back({'D', j});\n }\n }\n }\n };\n\n vector> removed(N, vector(N, false));\n vector> oni_positions;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n oni_positions.emplace_back(i, j);\n }\n }\n }\n\n auto prioritize_oni = [&](const pair& a, const pair& b, const vector& board) {\n int dist_a = a.first + a.second;\n int dist_b = b.first + b.second;\n int fuku_a = 0, fuku_b = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'o') {\n if (i == a.first || j == a.second) fuku_a++;\n if (i == b.first || j == b.second) fuku_b++;\n }\n }\n }\n // Prioritize Oni closer to the center and with fewer Fukunokami nearby\n int center_dist_a = abs(N / 2 - a.first) + abs(N / 2 - a.second);\n int center_dist_b = abs(N / 2 - b.first) + abs(N / 2 - b.second);\n return make_pair(center_dist_a, -fuku_a) < make_pair(center_dist_b, -fuku_b);\n };\n\n sort(oni_positions.begin(), oni_positions.end(), [&](const pair& a, const pair& b) {\n return prioritize_oni(a, b, board);\n });\n\n for (const auto& [i, j] : oni_positions) {\n if (removed[i][j]) continue;\n\n bool can_left = true, can_right = true, can_up = true, can_down = true;\n for (int dj = 0; dj < j; ++dj) {\n if (board[i][dj] == 'o') {\n can_right = false;\n break;\n }\n }\n for (int dj = j + 1; dj < N; ++dj) {\n if (board[i][dj] == 'o') {\n can_left = false;\n break;\n }\n }\n for (int di = 0; di < i; ++di) {\n if (board[di][j] == 'o') {\n can_down = false;\n break;\n }\n }\n for (int di = i + 1; di < N; ++di) {\n if (board[di][j] == 'o') {\n can_up = false;\n break;\n }\n }\n\n if (can_left) {\n add_moves(i, j, true, true);\n removed[i][j] = true;\n } else if (can_right) {\n add_moves(i, j, true, false);\n removed[i][j] = true;\n } else if (can_up) {\n add_moves(i, j, false, true);\n removed[i][j] = true;\n } else if (can_down) {\n add_moves(i, j, false, false);\n removed[i][j] = true;\n }\n }\n\n for (const auto& mv : moves) {\n cout << mv.dir << \" \" << mv.pos << endl;\n }\n\n return 0;\n}","ahc044":"#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\nvector t(N); // target times\nvector> assignments(N); // a_i, b_i for each employee\n\nvector simulate(const vector>& assign) {\n vector count(N, 0);\n int current = 0;\n int times = 0;\n count[0]++; // first week\n times = 1; // count for employee 0\n\n for (int week = 1; week < L; ++week) {\n if (times % 2 == 1) { // odd\n current = assign[current].first;\n } else { // even\n current = assign[current].second;\n }\n count[current]++;\n times++; // increment the count for previous employee\n }\n return count;\n}\n\nlong long calculate_error(const vector& actual) {\n long long error = 0;\n for (int i = 0; i < N; ++i) {\n error += abs(actual[i] - t[i]);\n }\n return error;\n}\n\n// Simulated Annealing with limited iterations\nvoid simulated_annealing(vector>& assign, long long& best_error, vector& best_count) {\n mt19937 rng(0); // fixed seed for reproducibility\n const int MAX_ITERATIONS = 50; // Reduced from previous value\n\n long long current_error = calculate_error(simulate(assign));\n vector current_count = simulate(assign);\n best_error = current_error;\n best_count = current_count;\n\n double temperature = 1000.0;\n const double cooling_rate = 0.995;\n\n for (int iter = 0; iter < MAX_ITERATIONS; ++iter) {\n // Choose two distinct employees\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n while (j == i) {\n j = uniform_int_distribution(0, N-1)(rng);\n }\n\n // Save old assignments\n auto old_i = assign[i];\n auto old_j = assign[j];\n\n // Randomly change assignments for i and j\n int a_candidate = uniform_int_distribution(0, N-1)(rng);\n int b_candidate = uniform_int_distribution(0, N-1)(rng);\n assign[i] = {a_candidate, b_candidate};\n\n a_candidate = uniform_int_distribution(0, N-1)(rng);\n b_candidate = uniform_int_distribution(0, N-1)(rng);\n assign[j] = {a_candidate, b_candidate};\n\n // Simulate and compute new error\n vector new_count = simulate(assign);\n long long new_error = calculate_error(new_count);\n\n // Acceptance probability\n double ap = exp((current_error - new_error) / temperature);\n if (new_error < current_error || uniform_real_distribution(0, 1)(rng) < ap) {\n current_error = new_error;\n current_count = new_count;\n if (new_error < best_error) {\n best_error = new_error;\n best_count = new_count;\n }\n } else {\n // Revert changes\n assign[i] = old_i;\n assign[j] = old_j;\n }\n\n // Cool down\n temperature *= cooling_rate;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n int dummy_n, dummy_l;\n cin >> dummy_n >> dummy_l; // should be 100 and 500000\n for (int i = 0; i < N; ++i) {\n cin >> t[i];\n }\n\n // Initial assignment: cyclic pattern\n for (int i = 0; i < N; ++i) {\n assignments[i] = {(i + 1) % N, (i + 1) % N};\n }\n\n long long best_error;\n vector best_count;\n simulated_annealing(assignments, best_error, best_count);\n\n // Output the assignments\n for (const auto& p : assignments) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\n\n#define OVERRIDE 0\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy;\n};\n\n// Simple DBSCAN-like clustering based on center coordinates\nvector> clusterCities(const vector& cities, double eps = 200.0, int min_pts = 1) {\n int n = cities.size();\n vector visited(n, false);\n vector> clusters;\n\n for (int i = 0; i < n; ++i) {\n if (visited[i]) continue;\n visited[i] = true;\n queue q;\n q.push(i);\n vector cluster;\n\n cluster.push_back(i);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int nxt = 0; nxt < n; ++nxt) {\n if (visited[nxt]) continue;\n double dx = cities[cur].cx - cities[nxt].cx;\n double dy = cities[cur].cy - cities[nxt].cy;\n double dist = sqrt(dx*dx + dy*dy);\n if (dist <= eps) {\n visited[nxt] = true;\n q.push(nxt);\n cluster.push_back(nxt);\n }\n }\n }\n if (!cluster.empty()) {\n clusters.push_back(cluster);\n }\n }\n return clusters;\n}\n\n// Divide a cluster into groups of sizes specified in G\nvector> assignGroups(const vector& cluster, const vector& G, const vector& cities) {\n vector> groups;\n int n = cluster.size();\n int group_idx = 0;\n int start = 0;\n\n for (int g : G) {\n vector group;\n int end = start + g;\n if (end > n) {\n end = n;\n }\n for (int i = start; i < end; ++i) {\n group.push_back(cluster[i]);\n }\n groups.push_back(group);\n start = end;\n }\n return groups;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n vector cities(N);\n for (int i = 0; i < N; ++i) {\n 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 // Cluster cities based on center coordinates\n vector> clusters = clusterCities(cities);\n\n // Assign cities to groups\n vector> groups;\n vector group_sizes = G;\n\n // Try to assign groups from clusters\n for (const auto& cluster : clusters) {\n vector> cluster_groups = assignGroups(cluster, group_sizes, cities);\n for (const auto& g : cluster_groups) {\n if (g.empty()) continue;\n groups.push_back(g);\n // Decrease the corresponding group size\n for (size_t i = 0; i < group_sizes.size(); ++i) {\n if (group_sizes[i] >= (int)g.size()) {\n group_sizes[i] -= (int)g.size();\n break;\n }\n }\n }\n }\n\n // Handle remaining group sizes\n int remaining = N;\n for (const auto& g : groups) remaining -= g.size();\n if (remaining > 0) {\n // Add remaining cities to the last group\n if (!groups.empty()) {\n groups.back().resize(remaining + groups.back().size());\n } else {\n groups.push_back(vector(remaining));\n }\n }\n\n // Ensure we have exactly M groups\n while ((int)groups.size() < M) {\n groups.push_back({});\n }\n\n // Prepare queries for each group\n vector>> all_edges(M);\n\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n int sz = group.size();\n if (sz < 2) continue;\n\n // If group size is small enough, query the entire group\n if (sz <= L) {\n cout << \"? \" << sz;\n for (int id : group) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int i = 0; i < sz - 1; ++i) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n } else {\n // Break into subsets of size L\n for (int i = 0; i < sz; i += L - 1) {\n int subset_size = min(L, sz - i);\n if (subset_size < 2) break;\n\n vector subset;\n for (int j = i; j < i + subset_size; ++j) {\n subset.push_back(group[j]);\n }\n\n cout << \"? \" << subset_size;\n for (int id : subset) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int j = 0; j < subset_size - 1; ++j) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n }\n }\n }\n\n // Output the answer\n cout << \"!\" << endl;\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n cout << group.size();\n for (int id : group) cout << \" \" << id;\n cout << endl;\n\n // Output edges for this group\n for (const auto& edge : all_edges[k]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint N, M;\nvector> targets;\nvector> grid; // true if block exists\npair current;\n\n// Directions: U, D, L, R\nconst int dx[] = {-1, 1, 0, 0};\nconst int dy[] = {0, 0, -1, 1};\nconst char dir[] = {'U', 'D', 'L', 'R'};\n\n// Function to check if a position is within grid bounds\nbool inBounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// BFS to find the shortest path to a target, considering both move and slide actions\nvector> bfs(const pair& start, const pair& target, const vector>& blocks) {\n queue> q;\n vector>> parent(N, vector>(N, {-2, -2}));\n vector> dist(N, vector(N, -1));\n\n q.push(start);\n dist[start.first][start.second] = 0;\n\n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n\n if (x == target.first && y == target.second) {\n vector> path;\n pair curr = {x, y};\n while (curr.first != -2 || curr.second != -2) {\n path.push_back(curr);\n int px = parent[curr.first][curr.second].first;\n int py = parent[curr.first][curr.second].second;\n curr = {px, py};\n }\n reverse(path.begin(), path.end());\n return path;\n }\n\n // Try move actions\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d], ny = y + dy[d];\n if (inBounds(nx, ny) && !blocks[nx][ny] && dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n\n // Try slide actions\n for (int d = 0; d < 4; ++d) {\n int nx = x, ny = y;\n int steps = 0;\n while (true) {\n int next_x = nx + dx[d];\n int next_y = ny + dy[d];\n if (!inBounds(next_x, next_y) || blocks[next_x][next_y]) break;\n nx = next_x;\n ny = next_y;\n steps++;\n if (dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1; // Sliding counts as one action\n parent[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n }\n return {};\n}\n\n// Attempt to move to next target using an optimized strategy\nvector> moveToTarget(const pair& target) {\n vector> actions;\n vector> blocks = grid;\n\n // First, try sliding directly to the target if possible\n for (int d = 0; d < 4; ++d) {\n int nx = current.first, ny = current.second;\n bool canSlide = true;\n while (true) {\n int next_x = nx + dx[d];\n int next_y = ny + dy[d];\n if (!inBounds(next_x, next_y) || blocks[next_x][next_y]) {\n break;\n }\n nx = next_x;\n ny = next_y;\n if (nx == target.first && ny == target.second) {\n // Slide to target\n actions.emplace_back('S', string(1, dir[d]));\n current = {nx, ny};\n return actions;\n }\n }\n }\n\n // If sliding fails, use BFS to find an optimized path\n auto path = bfs(current, target, blocks);\n if (!path.empty()) {\n for (size_t i = 1; i < path.size(); ++i) {\n auto next = path[i];\n // Determine the direction from current to next\n int dx_move = next.first - current.first;\n int dy_move = next.second - current.second;\n\n if (dx_move > 0) {\n // Try sliding down as far as possible\n int slide_to = current.first;\n while (slide_to + 1 < N && !grid[slide_to + 1][current.second]) {\n slide_to++;\n }\n if (slide_to > current.first) {\n actions.emplace_back('S', \"D\");\n current.first = slide_to;\n } else {\n actions.emplace_back('M', \"D\");\n current.first += dx_move;\n }\n } else if (dx_move < 0) {\n int slide_to = current.first;\n while (slide_to - 1 >= 0 && !grid[slide_to - 1][current.second]) {\n slide_to--;\n }\n if (slide_to < current.first) {\n actions.emplace_back('S', \"U\");\n current.first = slide_to;\n } else {\n actions.emplace_back('M', \"U\");\n current.first += dx_move;\n }\n } else if (dy_move > 0) {\n int slide_to = current.second;\n while (slide_to + 1 < N && !grid[current.first][slide_to + 1]) {\n slide_to++;\n }\n if (slide_to > current.second) {\n actions.emplace_back('S', \"R\");\n current.second = slide_to;\n } else {\n actions.emplace_back('M', \"R\");\n current.second += dy_move;\n }\n } else if (dy_move < 0) {\n int slide_to = current.second;\n while (slide_to - 1 >= 0 && !grid[current.first][slide_to - 1]) {\n slide_to--;\n }\n if (slide_to < current.second) {\n actions.emplace_back('S', \"L\");\n current.second = slide_to;\n } else {\n actions.emplace_back('M', \"L\");\n current.second += dy_move;\n }\n }\n }\n return actions;\n }\n\n // If no path found, try altering blocks (same as before but with improved logic)\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n if (!blocks[x][y]) {\n blocks[x][y] = true;\n actions.emplace_back('A', (x > current.first) ? \"D\" : (x < current.first) ? \"U\" : (y > current.second) ? \"R\" : \"L\");\n auto new_path = bfs(current, target, blocks);\n if (!new_path.empty()) {\n for (size_t i = 1; i < new_path.size(); ++i) {\n auto next = new_path[i];\n int dx_move = next.first - current.first;\n int dy_move = next.second - current.second;\n if (dx_move > 0) {\n actions.emplace_back('M', \"D\");\n } else if (dx_move < 0) {\n actions.emplace_back('M', \"U\");\n } else if (dy_move > 0) {\n actions.emplace_back('M', \"R\");\n } else if (dy_move < 0) {\n actions.emplace_back('M', \"L\");\n }\n current = next;\n }\n blocks[x][y] = false; // Remove the block after use\n actions.emplace_back('A', (x > current.first) ? \"D\" : (x < current.first) ? \"U\" : (y > current.second) ? \"R\" : \"L\");\n return actions;\n }\n blocks[x][y] = false;\n }\n }\n }\n\n return {}; // No viable path found\n}\n\nint main() {\n cin >> N >> M;\n targets.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> targets[i].first >> targets[i].second;\n }\n current = targets[0];\n grid = vector>(N, vector(N, false));\n\n vector> actions;\n\n for (int i = 1; i < M; ++i) {\n auto step_actions = moveToTarget(targets[i]);\n actions.insert(actions.end(), step_actions.begin(), step_actions.end());\n }\n\n // Output actions\n for (auto& [a, d] : actions) {\n cout << a << \" \" << d << endl;\n }\n\n return 0;\n}"},"16":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int x1, y1, x2, y2;\n long long area() const { return (long long)(x2 - x1) * (y2 - y1); }\n bool contains(double x, double y) const {\n return x > x1 && x < x2 && y > y1 && y < y2;\n }\n};\n\nint n;\nvector> input;\nvector rects;\nvector r_desired;\nvector> desired_points;\n\ndouble satisfaction(int i, const Rect& r) {\n double x = get<0>(input[i]) + 0.5, y = get<1>(input[i]) + 0.5;\n if (!r.contains(x, y)) return 0.0;\n long long s = r.area();\n long long r_val = get<2>(input[i]);\n double ratio = min(r_val, (long long)s) * 1.0 / max(r_val, (long long)s);\n return 1.0 - pow(1.0 - ratio, 2.0);\n}\n\ndouble total_satisfaction() {\n double total = 0.0;\n for (int i = 0; i < n; ++i) {\n total += satisfaction(i, rects[i]);\n }\n return total;\n}\n\nbool intersects(const Rect& a, const Rect& b) {\n return !(a.x2 <= b.x1 || a.x1 >= b.x2 || a.y2 <= b.y1 || a.y1 >= b.y2);\n}\n\nvoid init_rects() {\n rects.clear();\n for (int i = 0; i < n; ++i) {\n int x = get<0>(input[i]), y = get<1>(input[i]);\n int r = get<2>(input[i]);\n int half = max(1, (int)sqrt(r));\n rects.push_back({x, y, x + half, y + half});\n }\n}\n\nbool expand_rect(int i, int dx, int dy) {\n Rect& r = rects[i];\n Rect new_r = {r.x1 - dx, r.y1 - dy, r.x2 + dx, r.y2 + dy};\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n return false;\n }\n }\n if (new_r.x1 < 0 || new_r.y1 < 0 || new_r.x2 > 10000 || new_r.y2 > 10000) {\n return false;\n }\n rects[i] = new_r;\n return true;\n}\n\nvoid greedy_expansion() {\n for (int iter = 0; iter < 1000; ++iter) {\n for (int i = 0; i < n; ++i) {\n int dx = 1, dy = 1;\n while (expand_rect(i, dx, dy)) {\n dx++;\n dy++;\n }\n }\n }\n}\n\ndouble simulated_annealing(double T, double alpha, int steps) {\n double best_score = total_satisfaction();\n vector best_rects = rects;\n\n for (int step = 0; step < steps; ++step) {\n int i = rand() % n;\n int dx = (rand() % 5) - 2;\n int dy = (rand() % 5) - 2;\n\n Rect old_r = rects[i];\n Rect new_r = {old_r.x1 + dx, old_r.y1 + dy, old_r.x2 + dx, old_r.y2 + dy};\n\n bool valid = true;\n if (new_r.x1 < 0 || new_r.x1 >= 10000 || new_r.x2 < 0 || new_r.x2 >= 10000 ||\n new_r.y1 < 0 || new_r.y1 >= 10000 || new_r.y2 < 0 || new_r.y2 >= 10000) {\n valid = false;\n } else {\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (intersects(new_r, rects[j])) {\n valid = false;\n break;\n }\n }\n }\n\n if (!valid) {\n swap(new_r, old_r);\n }\n\n double old_score = satisfaction(i, old_r);\n double new_score = satisfaction(i, new_r);\n double delta = new_score - old_score;\n\n if (delta > 0 || exp(delta / T) > (double)rand() / RAND_MAX) {\n rects[i] = new_r;\n } else {\n rects[i] = old_r;\n }\n\n double current_score = total_satisfaction();\n if (current_score > best_score) {\n best_score = current_score;\n best_rects = rects;\n }\n\n T *= alpha;\n }\n\n rects = best_rects;\n return best_score;\n}\n\nint main() {\n srand(time(nullptr));\n cin >> n;\n input.resize(n);\n r_desired.resize(n);\n desired_points.resize(n);\n\n for (int i = 0; i < n; ++i) {\n int x, y, r;\n cin >> x >> y >> r;\n input[i] = {x, y, r};\n desired_points[i] = {x + 0.5, y + 0.5};\n r_desired[i] = r;\n }\n\n init_rects();\n greedy_expansion();\n\n double T = 10000.0;\n double alpha = 0.99;\n int steps = 100000;\n\n simulated_annealing(T, alpha, steps);\n\n for (const auto& r : rects) {\n cout << r.x1 << \" \" << r.y1 << \" \" << r.x2 << \" \" << r.y2 << endl;\n }\n\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int si, sj;\n cin >> si >> sj;\n \n vector> t(50, vector(50));\n vector> p(50, vector(50));\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n }\n }\n \n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> p[i][j];\n }\n }\n \n // Identify tiles: map from tile id to list of positions\n map>> tiles;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n tiles[t[i][j]].emplace_back(i, j);\n }\n }\n \n // For each tile, check if it's horizontal or vertical\n // and store the positions in a sorted manner\n vector>> tilePositions;\n tilePositions.reserve(tiles.size());\n for (auto &entry : tiles) {\n auto &posList = entry.second;\n sort(posList.begin(), posList.end());\n tilePositions.push_back(set>(posList.begin(), posList.end()));\n }\n \n // Create a map from position to tile index\n vector> posToTile(50, vector(50, -1));\n for (size_t ti = 0; ti < tilePositions.size(); ++ti) {\n for (auto &pos : tilePositions[ti]) {\n posToTile[pos.first][pos.second] = ti;\n }\n }\n \n // Directions: up, down, left, right\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n vector dirChar = {'U', 'D', 'L', 'R'};\n \n // BFS to find a path\n vector> visited(50, vector(50, false));\n vector> path(50, vector(50, '\\0'));\n queue> q;\n \n q.emplace(si, sj);\n visited[si][sj] = true;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n \n for (size_t d = 0; d < 4; ++d) {\n int ni = i + dirs[d].first;\n int nj = j + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (visited[ni][nj]) continue;\n \n // Check if the new position is on the same tile as the current one\n if (posToTile[i][j] == posToTile[ni][nj]) continue;\n \n visited[ni][nj] = true;\n path[ni][nj] = dirChar[d];\n q.emplace(ni, nj);\n }\n }\n \n // Reconstruct the path from si, sj to the furthest point\n string output;\n pair current = {si, sj};\n while (true) {\n bool found = false;\n for (size_t d = 0; d < 4; ++d) {\n int ni = current.first + dirs[d].first;\n int nj = current.second + dirs[d].second;\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n if (path[ni][nj] == '\\0') continue;\n // Check tile uniqueness\n if (posToTile[current.first][current.second] == posToTile[ni][nj]) continue;\n output += dirChar[d];\n current = {ni, nj};\n found = true;\n break;\n }\n if (!found) break;\n }\n \n cout << output << endl;\n \n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint H, W; // 30x30 grid\nvector> h_est, v_est; // estimated horizontal and vertical edge weights\nvector> h_cnt, v_cnt; // count of usage for each edge\n\nvector dirs = {\"U\", \"D\", \"L\", \"R\"};\n\n// BFS to generate a path\nstring bfs_path(int si, int sj, int ti, int tj) {\n vector> dist(H, vector(W, -1));\n vector> prev(H, vector

(W, {-1, -1}));\n queue

q;\n dist[si][sj] = 0;\n q.emplace(si, sj);\n while (!q.empty()) {\n auto [i, j] = q.front(); q.pop();\n if (i == ti && j == tj) break;\n vector

ns;\n if (i > 0) ns.emplace_back(i-1, j);\n if (i < H-1) ns.emplace_back(i+1, j);\n if (j > 0) ns.emplace_back(i, j-1);\n if (j < W-1) ns.emplace_back(i, j+1);\n for (auto [ni, nj] : ns) {\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[i][j] + 1;\n prev[ni][nj] = {i, j};\n q.emplace(ni, nj);\n }\n }\n }\n if (dist[ti][tj] == -1) return \"\";\n string path;\n P cur = {ti, tj};\n while (cur != P(si, sj)) {\n P p = prev[cur.first][cur.second];\n int di = cur.first - p.first;\n int dj = cur.second - p.second;\n if (di == -1) path += 'U';\n else if (di == 1) path += 'D';\n else if (dj == -1) path += 'L';\n else if (dj == 1) path += 'R';\n cur = p;\n }\n reverse(path.begin(), path.end());\n return path;\n}\n\n// Random walk to generate a path\nstring random_walk(int si, int sj, int ti, int tj, int max_steps) {\n string path;\n int i = si, j = sj;\n while (max_steps-- > 0 && (i != ti || j != tj)) {\n vector possible;\n if (i > 0) possible.push_back('U');\n if (i < H-1) possible.push_back('D');\n if (j > 0) possible.push_back('L');\n if (j < W-1) possible.push_back('R');\n char move = possible[rand() % possible.size()];\n path += move;\n if (move == 'U') i--;\n else if (move == 'D') i++;\n else if (move == 'L') j--;\n else if (move == 'R') j++;\n }\n return path;\n}\n\n// Estimate edge weight from observed lengths\ndouble estimate_edge_weight(int i, int j, char dir) {\n if (dir == 'L' || dir == 'R') {\n if (h_cnt[i][j] == 0) return 1500.0;\n return h_est[i][j] * 1.0 / h_cnt[i][j];\n } else {\n if (v_cnt[i][j] == 0) return 1500.0;\n return v_est[i][j] * 1.0 / v_cnt[i][j];\n }\n}\n\nint main() {\n H = 30, W = 30;\n h_est.assign(H, vector(W, 0));\n v_est.assign(H, vector(W, 0));\n h_cnt.assign(H, vector(W, 0));\n v_cnt.assign(H, vector(W, 0));\n \n srand(time(nullptr));\n \n int query_count = 0;\n while (true) {\n int si, sj, ti, tj;\n if (query_count == 0) {\n cin >> si >> sj >> ti >> tj;\n } else {\n // Read the previous result (b_k)\n ll b_prev;\n cin >> b_prev;\n // Update the estimates based on the path taken in the previous query\n // This is a placeholder; actual implementation would track the path\n }\n \n // Generate multiple candidate paths\n string path1 = bfs_path(si, sj, ti, tj);\n string path2 = random_walk(si, sj, ti, tj, abs(si - ti) + abs(sj - tj) * 2);\n string path3 = random_walk(si, sj, ti, tj, abs(si - ti) * 2 + abs(sj - tj));\n \n vector candidates = {path1, path2, path3};\n if (candidates[0].empty()) candidates.erase(candidates.begin());\n \n // Select a path based on estimated weights\n double scores[3] = {0.0};\n for (int idx = 0; idx < candidates.size(); idx++) {\n string& p = candidates[idx];\n double score = 0.0;\n int pi = si, pj = sj;\n for (char c : p) {\n if (c == 'U' || c == 'D') {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n } else {\n double w = estimate_edge_weight(pi, pj, c);\n score += w;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n scores[idx] = 1.0 / score;\n }\n \n // Choose the best candidate\n double max_score = -1.0;\n int best_idx = 0;\n for (int idx = 0; idx < candidates.size(); idx++) {\n if (scores[idx] > max_score) {\n max_score = scores[idx];\n best_idx = idx;\n }\n }\n \n string path = candidates[best_idx];\n \n // Output the path\n cout << path << endl;\n cout.flush();\n \n // Read the result (b_k)\n ll b_k;\n cin >> b_k;\n \n // Update estimates based on the path taken\n int pi = si, pj = sj;\n for (char c : path) {\n if (c == 'L' || c == 'R') {\n h_est[pi][pj] += b_k; // placeholder update\n h_cnt[pi][pj]++;\n } else {\n v_est[pi][pj] += b_k;\n v_cnt[pi][pj]++;\n }\n if (c == 'U') pi--;\n else if (c == 'D') pi++;\n else if (c == 'L') pj--;\n else if (c == 'R') pj++;\n }\n \n query_count++;\n }\n \n return 0;\n}","ahc004":"#include \nusing namespace std;\n\n// Helper function to check if a string can be placed horizontally or vertically\nbool canPlaceHorizontal(const vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % 20;\n if (matrix[i][col] != '.' && matrix[i][col] != s[k]) {\n return false;\n }\n }\n return true;\n}\n\nbool canPlaceVertical(const vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % 20;\n if (matrix[row][j] != '.' && matrix[row][j] != s[k]) {\n return false;\n }\n }\n return true;\n}\n\n// Function to place a string horizontally or vertically\nvoid placeHorizontal(vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int col = (j + k) % 20;\n matrix[i][col] = s[k];\n }\n}\n\nvoid placeVertical(vector>& matrix, int i, int j, const string& s) {\n int len = s.size();\n for (int k = 0; k < len; ++k) {\n int row = (i + k) % 20;\n matrix[row][j] = s[k];\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 20;\n int M;\n cin >> N >> M;\n vector strings(M);\n for (int i = 0; i < M; ++i) {\n cin >> strings[i];\n }\n\n // Sort strings by length in descending order\n sort(strings.begin(), strings.end(), [](const string& a, const string& b) {\n return a.size() > b.size();\n });\n\n vector> matrix(N, vector(N, '.'));\n\n // Place strings with enhanced placement strategy\n for (const auto& s : strings) {\n int len = s.size();\n bool placed = false;\n\n // Try horizontal placement with enhanced strategy\n for (int i = 0; i < N && !placed; ++i) {\n for (int j = 0; j <= N - len && !placed; ++j) {\n if (canPlaceHorizontal(matrix, i, j, s)) {\n placeHorizontal(matrix, i, j, s);\n placed = true;\n }\n }\n }\n\n // Try vertical placement with enhanced strategy\n if (!placed) {\n for (int j = 0; j < N && !placed; ++j) {\n for (int i = 0; i <= N - len && !placed; ++i) {\n if (canPlaceVertical(matrix, i, j, s)) {\n placeVertical(matrix, i, j, s);\n placed = true;\n }\n }\n }\n }\n }\n\n // Character frequency analysis for filling empty cells\n vector charFreq(8, 0);\n for (const auto& s : strings) {\n for (char c : s) {\n charFreq[c - 'A']++;\n }\n }\n\n // Fill empty cells with the most frequent character\n char mostFrequentChar = 'A';\n int maxFreq = charFreq[0];\n for (int i = 0; i < 8; ++i) {\n if (charFreq[i] > maxFreq) {\n maxFreq = charFreq[i];\n mostFrequentChar = 'A' + i;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] == '.') {\n matrix[i][j] = mostFrequentChar;\n }\n }\n }\n\n // Local search to minimize empty cells and conflicts\n // This is a simple version where we try to swap characters to reduce conflicts\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (matrix[i][j] != '.') {\n for (int k = 0; k < N; ++k) {\n for (int l = 0; l < N; ++l) {\n if (i != k || j != l) {\n swap(matrix[i][j], matrix[k][l]);\n // Check if the swap improved the placement\n // (This is a placeholder for a more sophisticated check)\n swap(matrix[i][j], matrix[k][l]); // Revert the swap\n }\n }\n }\n }\n }\n }\n\n // Output the matrix\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cout << matrix[i][j];\n }\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // --- Input reading ---\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n // Valid movement: up, down, left, right\n vector> dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n vector dir_names = {\"U\", \"D\", \"L\", \"R\"};\n\n // Return true if moving from (x,y) to (nx,ny) is legal\n auto isValidMove = [&](int x, int y, int nx, int ny) {\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) return false;\n if (grid[nx][ny] == '#') return false;\n\n int dx = nx - x;\n int dy = ny - y;\n if (dx && dy) return false; // Must move straight (horizontal or vertical)\n\n // Check intermediate cells along straight line\n if (dx != 0) {\n int step = dx > 0 ? 1 : -1;\n for (int i = x + step; i != nx; i += step) {\n if (grid[i][y] == '#') return false;\n }\n } else {\n int step = dy > 0 ? 1 : -1;\n for (int j = y + step; j != ny; j += step) {\n if (grid[x][j] == '#') return false;\n }\n }\n return true;\n };\n\n // BFS queue: store current position and path\n queue, string>> q;\n q.push({{si, sj}, \"\"});\n\n set> visited_positions;\n visited_positions.insert({si, sj});\n\n // Variables for best path (shortest valid one that ends at start)\n string best_path;\n bool found_solution = false;\n\n while (!q.empty() && !found_solution) {\n auto current = q.front(); q.pop();\n pair pos = current.first;\n string path = current.second;\n\n int x = pos.first;\n int y = pos.second;\n\n // Check condition: all roads are visited AND we are back at the start.\n bool full_visited = true;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#' && !visited_positions.count({i, j})) {\n full_visited = false;\n break;\n }\n }\n if (!full_visited) break;\n }\n\n // If we're back at the start and map fully visited, record solution.\n if (full_visited && x == si && y == sj) {\n best_path = path;\n found_solution = true;\n break;\n }\n\n // Explore neighbors\n for (int d = 0; d < 4; d++) {\n int nx = x + dirs[d].first;\n int ny = y + dirs[d].second;\n\n if (isValidMove(x, y, nx, ny) && !visited_positions.count({nx, ny})) {\n visited_positions.insert({nx, ny});\n string next_path = path + dir_names[d];\n q.push({{nx, ny}, next_path});\n }\n }\n }\n\n // Output best valid path that ends at the start point.\n cout << best_path << endl;\n\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct Task {\n vector d; // required skills\n vector deps; // dependencies\n int index;\n int earliest_start_day = 0; // Earliest possible start day based on dependencies\n int assigned_to = -1; // Which team member is assigned (-1 if not assigned)\n int start_day = -1; // Actual start day (-1 if not started)\n int completion_day = -1; // Completion day (-1 if not completed)\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].d.resize(K);\n for (int j = 0; j < K; ++j) {\n cin >> tasks[i].d[j];\n }\n tasks[i].index = i;\n }\n\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n u--; v--;\n tasks[v].deps.push_back(u);\n }\n\n // Build adjacency list for dependency graph\n vector> dep_graph(N);\n vector in_degree(N, 0);\n for (int i = 0; i < N; ++i) {\n for (int dep : tasks[i].deps) {\n dep_graph[dep].push_back(i);\n in_degree[i]++;\n }\n }\n\n // Initial skill estimates for each team member (initialized to zero)\n vector> skillestimates(M, vector(K, 0.0));\n\n // Track completion times for each team member (for skill update)\n vector completion_times(M, 0.0); // Cumulative completion time\n vector task_count(M, 0); // Number of tasks completed by each member\n\n // Track which team members are busy (assigned a task)\n vector busy(M, false);\n\n // Track completed tasks\n vector completed(N, false);\n\n // Track available tasks (tasks with all dependencies completed)\n queue available_tasks;\n for (int i = 0; i < N; ++i) {\n if (in_degree[i] == 0) {\n available_tasks.push(i);\n }\n }\n\n // Process days until all tasks are completed or day 2000\n for (int day = 1; day <= 2000; ++day) {\n // Collect tasks to assign today\n vector> assignments;\n\n // For each available team member, assign the \"best\" available task\n for (int member = 0; member < M; ++member) {\n if (busy[member]) continue; // Skip if busy\n\n // Find the best task for this member from available tasks\n int best_task = -1;\n double min_estimated_time = INFINITY;\n // We need to consider tasks that are available and not completed\n // For simplicity, we'll iterate through all tasks and check if available\n for (int t = 0; t < N; ++t) {\n if (completed[t]) continue;\n if (in_degree[t] > 0) continue; // Not available yet\n\n // Estimate time for this member to do this task\n double w = 0.0;\n for (int k = 0; k < K; ++k) {\n w += max(0.0, tasks[t].d[k] - skillestimates[member][k]);\n }\n double estimated_time = (w == 0) ? 1.0 : max(1.0, w + uniform_real_distribution(-3.0, 3.0).operator()());\n\n if (estimated_time < min_estimated_time) {\n min_estimated_time = estimated_time;\n best_task = t;\n }\n }\n\n if (best_task != -1) {\n assignments.emplace_back(member, best_task);\n busy[member] = true;\n tasks[best_task].assigned_to = member;\n tasks[best_task].start_day = day;\n }\n }\n\n // Output assignments\n cout << assignments.size();\n for (auto& [member, task] : assignments) {\n cout << \" \" << member + 1 << \" \" << task + 1;\n }\n cout << endl;\n cout.flush();\n\n // Read input: either -1 or list of completed members\n int n_completed;\n cin >> n_completed;\n if (n_completed == -1) {\n // All tasks completed or day limit reached\n break;\n }\n\n vector completed_members;\n for (int i = 0; i < n_completed; ++i) {\n int member;\n cin >> member;\n member--;\n completed_members.push_back(member);\n }\n\n // Update skill estimates and mark tasks as completed\n for (int member : completed_members) {\n if (busy[member]) {\n // Find which task this member completed\n for (int t = 0; t < N; ++t) {\n if (tasks[t].assigned_to == member && tasks[t].completion_day == -1) {\n // Assume we get the actual completion time from the problem, but here we simulate\n // For real submission, we don't have actual time, so we cannot update skills.\n // In a real scenario, we would need to get actual completion time from the judge.\n // Since we don't have it, we skip skill update for now.\n tasks[t].completion_day = day;\n completed[t] = true;\n busy[member] = false;\n\n // Update dependency graph: this task's dependents may now be available\n for (int next_task : dep_graph[t]) {\n in_degree[next_task]--;\n if (in_degree[next_task] == 0) {\n available_tasks.push(next_task);\n }\n }\n break;\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int a, b, c, d;\n Order(int a_=0, int b_=0, int c_=0, int d_=0) : a(a_), b(b_), c(c_), d(d_) {}\n};\n\n// Manhattan distance\nint dist(int x1, int y1, int x2, int y2) {\n return abs(x1 - x2) + abs(y1 - y2);\n}\n\n// Heuristic: Choose orders that are close to the center and have short total distance\nvector select_orders(const vector& orders) {\n vector> scores;\n for(int i = 0; i < orders.size(); i++) {\n const auto& o = orders[i];\n int dist_to_center = dist(o.a, o.b, 400, 400) + dist(o.c, o.d, 400, 400);\n int dist_total = dist(o.a, o.b, o.c, o.d);\n scores.emplace_back(dist_to_center + dist_total, i);\n }\n sort(scores.begin(), scores.end());\n vector selected;\n for(int i = 0; i < 50; i++) {\n selected.push_back(scores[i].second);\n }\n return selected;\n}\n\nvector> construct_route(const vector& orders, const vector& selected) {\n vector> route;\n route.emplace_back(400, 400); // Start at center\n \n for(int idx : selected) {\n const auto& o = orders[idx];\n route.emplace_back(o.a, o.b); // Go to pickup\n route.emplace_back(o.c, o.d); // Then to delivery\n }\n \n // Return to center at the end\n route.emplace_back(400, 400);\n return route;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n // Read all orders\n vector orders(1000);\n for(int i = 0; i < 1000; i++) {\n int a,b,c,d;\n cin >> a >> b >> c >> d;\n orders[i] = Order(a, b, c, d);\n }\n \n // Select 50 orders based on heuristic\n vector selected = select_orders(orders);\n \n // Construct route\n vector> route = construct_route(orders, selected);\n \n // Output\n cout << \"50\";\n for(int idx : selected) cout << \" \" << (idx+1);\n cout << \"\\n\" << route.size();\n for(auto [x,y] : route) cout << \" \" << x << \" \" << y;\n cout << endl;\n \n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n};\n\nint round_sqrt(long long x) {\n long long s = sqrt(x);\n if ((s + 1) * (s + 1) <= x) s++;\n return (int)s;\n}\n\nint distance(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return round_sqrt(dx * dx + dy * dy);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N = 400, M = 1995;\n vector points(N);\n vector> edges(M);\n\n for (int i = 0; i < N; ++i) {\n cin >> points[i].x >> points[i].y;\n }\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].first >> edges[i].second;\n }\n\n vector d(M);\n for (int i = 0; i < M; ++i) {\n int u = edges[i].first, v = edges[i].second;\n d[i] = distance(points[u], points[v]);\n }\n\n vector added(M, false);\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n \n function find = [&](int u) {\n while (parent[u] != u) {\n parent[u] = parent[parent[u]];\n u = parent[u];\n }\n return u;\n };\n\n auto unite = [&](int u, int v) {\n u = find(u);\n v = find(v);\n if (u == v) return false;\n parent[v] = u;\n return true;\n };\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n int u = edges[i].first, v = edges[i].second;\n if (unite(u, v)) {\n cout << \"1\\n\";\n added[i] = true;\n } else {\n cout << \"0\\n\";\n }\n cout.flush();\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n cin >> N;\n vector> pets(N);\n for (int i = 0; i < N; ++i) {\n int x, y, t;\n cin >> x >> y >> t;\n pets[i] = {x - 1, y - 1, t};\n }\n cin >> M;\n vector> humans(M);\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n humans[i] = {x - 1, y - 1};\n }\n\n vector> grid(30, vector(30, false));\n vector> blocked(30, vector(30, false));\n for (auto [x, y, _] : pets) grid[x][y] = true;\n for (auto [x, y] : humans) grid[x][y] = true;\n\n for (int turn = 0; turn < 300; ++turn) {\n string action;\n for (int i = 0; i < M; ++i) {\n int x = humans[i].first;\n int y = humans[i].second;\n\n // Try to move first\n vector> moves = {{x+1, y}, {x-1, y}, {x, y+1}, {x, y-1}};\n vector dirs = {'D', 'U', 'R', 'L'};\n int best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n // Check if adjacent to any pet\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += dirs[best];\n humans[i] = {moves[best].first, moves[best].second};\n grid[x][y] = false;\n grid[moves[best].first][moves[best].second] = true;\n } else {\n // Try to block\n best = -1;\n for (int j = 0; j < 4; ++j) {\n int nx = moves[j].first;\n int ny = moves[j].second;\n if (nx < 0 || nx >= 30 || ny < 0 || ny >= 30) continue;\n if (blocked[nx][ny]) continue;\n if (grid[nx][ny]) continue;\n // Check if adjacent to any pet\n bool adjacent_pet = false;\n for (auto [px, py, _] : pets) {\n if (abs(px - nx) + abs(py - ny) == 1) {\n adjacent_pet = true;\n break;\n }\n }\n if (adjacent_pet) continue;\n best = j;\n break;\n }\n if (best != -1) {\n action += tolower(dirs[best]);\n blocked[moves[best].first][moves[best].second] = true;\n } else {\n action += '.';\n }\n }\n }\n cout << action << endl;\n cout.flush();\n\n // Read pet moves\n string pet_moves_line;\n getline(cin >> ws, pet_moves_line); // Ensure we read the entire line\n istringstream iss(pet_moves_line);\n for (int i = 0; i < N; ++i) {\n string move;\n iss >> move;\n auto& [x, y, type] = pets[i]; // Correctly access tuple elements\n if (!move.empty()) {\n for (char c : move) {\n if (c == 'U') x--;\n else if (c == 'D') x++;\n else if (c == 'L') y--;\n else if (c == 'R') y++;\n }\n }\n }\n }\n\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\nint main() {\n cout << \"R\" << endl;\n return 0;\n}","ahc010":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n Point(int i_, int j_) : i(i_), j(j_) {}\n};\n\nconst int di[] = {0, -1, 0, 1};\nconst int dj[] = {-1, 0, 1, 0};\n\n// Direction transition table: to[tile][enter_dir] = exit_dir or -1\nint 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\nvector> grid(30, vector(30));\nvector> rotation(30, vector(30, 0));\n\nint computeLength(int si, int sj, int sd, const vector>& rot) {\n int i = si, j = sj;\n int d = sd;\n int length = 0;\n vector> visited(30, vector(30, -1));\n int visit_id = abs(hash>(rot)) % 1000; // Just a dummy unique\n\n while (true) {\n if (i < 0 || i >= 30 || j < 0 || j >= 30) return 0;\n int tile = grid[i][j] + 4 * rotation[i][j];\n d = to[tile][d];\n if (d == -1) return 0;\n int ni = i + di[d];\n int nj = j + dj[d];\n d = (d + 2) % 4;\n length++;\n if (ni == si && nj == sj && d == sd) {\n return length;\n }\n if (visited[i][j] == visit_id) {\n // Detect cycle but not closed properly\n return 0;\n }\n visited[i][j] = visit_id;\n i = ni;\n j = nj;\n }\n}\n\npair getTwoMaxLengths(const vector>& rot) {\n priority_queue pq;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n int len = computeLength(i, j, d, rot);\n if (len > 0) pq.push(len);\n }\n }\n }\n if (pq.size() < 2) {\n return {0, 0};\n }\n int max1 = pq.top(); pq.pop();\n int max2 = pq.top(); pq.pop();\n return {max1, max2};\n}\n\nint score(const vector>& rot) {\n auto [l1, l2] = getTwoMaxLengths(rot);\n if (l1 == 0 || l2 == 0) return 0;\n return l1 * l2;\n}\n\nvector> rotateRandom() {\n vector> rot(30, vector(30));\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n rot[i][j] = rand() % 4;\n }\n }\n return rot;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cin >> grid[i][j];\n }\n }\n\n // Initialize with random rotations\n vector> best_rot = rotateRandom();\n int best_score = score(best_rot);\n\n // Simple hill climbing\n const int iterations = 2000;\n for (int iter = 0; iter < iterations; iter++) {\n // Pick a random tile\n int i = rand() % 30;\n int j = rand() % 30;\n int old_rot = best_rot[i][j];\n for (int delta = 1; delta <= 3; delta++) {\n int new_rot = (old_rot + delta) % 4;\n best_rot[i][j] = new_rot;\n int current_score = score(best_rot);\n if (current_score > best_score) {\n best_score = current_score;\n } else {\n best_rot[i][j] = old_rot;\n }\n }\n }\n\n // Output the best rotations found\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n if (j < 29) cout << \" \";\n }\n cout << endl;\n }\n\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nstruct Position {\n int i, j;\n Position(int i, int j) : i(i), j(j) {}\n};\n\nvector get_safe_moves(int N, const vector& board) {\n vector result;\n int empty_i = -1, empty_j = -1;\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (board[i][j] == '0') {\n empty_i = i, empty_j = j;\n }\n }\n }\n\n if (empty_i == 0) return {}; // On the **top**: disallow U\n if (empty_i == N - 1) return {}; // On the **bottom**: disallow D\n if (empty_j == 0) return {}; // On the **left**: disallow L\n if (empty_j == N - 1) return {}; // On the **right**: disallow R\n\n vector dirs;\n vector candidate_chars = {'U', 'D', 'L', 'R'};\n vector> dir_moves = {{ -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 }};\n\n for (int d = 0; d < 4; d++) {\n int ni = empty_i + dir_moves[d].first;\n int nj = empty_j + dir_moves[d].second;\n\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && board[ni][nj] != '0') {\n result.push_back(string(1, candidate_chars[d]));\n }\n }\n\n return result;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n if(!(cin >> N)) return 0;\n vector board(N);\n for (int i = 0; i < N; i++) {\n cin >> board[i];\n }\n\n auto moves = get_safe_moves(N, board);\n\n if (!moves.empty()) {\n cout << moves.back() << \"\\n\"; // Just output something safe\n } else {\n // If all directions disallowed (e.g., empty tile at board's extreme),\n // return empty string which is legal on many judging systems.\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc012":"#include \nusing namespace std;\n\n// Define Point structure\nstruct Point {\n int x, y;\n Point(int x_ = 0, int y_ = 0) : x(x_), y(y_) {}\n \n // Overload equality operator for Point\n bool operator==(const Point& other) const {\n return x == other.x && y == other.y;\n }\n \n // Overload subtraction operator for Point\n Point operator-(const Point& other) const {\n return Point(x - other.x, y - other.y);\n }\n};\n\n// Compute cross product of vectors (p1 - o) and (p2 - o)\nlong long cross(const Point& o, const Point& p1, const Point& p2) {\n return (long long)(p1.x - o.x) * (p2.y - o.y) - (long long)(p1.y - o.y) * (p2.x - o.x);\n}\n\n// Check if point p is on the left side of the directed line (a, b)\nbool isLeft(const Point& a, const Point& b, const Point& p) {\n return cross(a, b, p) > 0;\n}\n\n// Compute orientation of three points (clockwise, counterclockwise, or collinear)\nint orientation(const Point& p, const Point& q, const Point& r) {\n long long val = (long long)(q.y - p.y) * (r.x - q.x) - (long long)(q.x - p.x) * (r.y - q.y);\n if (val == 0) return 0; // Collinear\n return (val > 0) ? 1 : 2; // Clockwise or Counterclockwise\n}\n\n// Compute Euclidean distance squared between two points\nlong long dist(const Point& a, const Point& b) {\n long long dx = a.x - b.x, dy = a.y - b.y;\n return dx * dx + dy * dy;\n}\n\n// Compute centroid of a set of points\nPoint centroid(const vector& points) {\n if (points.empty()) return Point(0, 0);\n long long cx = 0, cy = 0;\n for (const auto& p : points) {\n cx += p.x;\n cy += p.y;\n }\n int n = points.size();\n if (n == 0) return Point(0, 0);\n return Point(cx / n, cy / n);\n}\n\n// Optimized line generation using k-means clustering to group strawberries\nvector> optimizedLineGeneration(const vector& strawberries, const vector& a) {\n int k = 10; // Number of clusters\n vector centroids;\n for (int i = 0; i < k; ++i) {\n centroids.push_back(strawberries[rand() % strawberries.size()]);\n }\n\n // K-means clustering\n for (int iter = 0; iter < 100; ++iter) {\n vector> clusters(k);\n for (const auto& p : strawberries) {\n int bestCluster = -1;\n long long bestDist = numeric_limits::max();\n for (int j = 0; j < k; ++j) {\n long long distSq = ::dist(p, centroids[j]);\n if (distSq < bestDist) {\n bestDist = distSq;\n bestCluster = j;\n }\n }\n clusters[bestCluster].push_back(p);\n }\n\n // Update centroids\n for (int j = 0; j < k; ++j) {\n centroids[j] = centroid(clusters[j]);\n }\n }\n\n // Generate lines from clusters with additional constraints\n vector> lines;\n for (int i = 0; i < k; ++i) {\n // Ensure centroids are not at the origin to avoid degenerate lines\n if (centroids[i].x == 0 && centroids[i].y == 0) {\n // Try to find a non-zero centroid by shifting slightly\n int offset = 1;\n centroids[i].x = offset;\n centroids[i].y = offset;\n }\n lines.emplace_back(Point(0, 0), centroids[i]);\n }\n\n // Additional heuristic: Ensure lines are not too close to each other\n for (size_t i = 0; i < lines.size(); ++i) {\n for (size_t j = i + 1; j < lines.size(); ++j) {\n if (dist(lines[i].second, lines[j].second) < 100) {\n // Adjust one of the lines to avoid overlap\n lines[j].second.x += 100;\n lines[j].second.y += 100;\n }\n }\n }\n\n return lines;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n srand(time(0)); // Seed the random number generator\n\n int N, K;\n if(!(cin >> N >> K)) return 0; // Handle input errors gracefully\n vector a(10);\n for (int i = 0; i < 10; ++i) {\n if (!(cin >> a[i])) return 0;\n }\n\n vector strawberries(N);\n for (int i = 0; i < N; ++i) {\n if (!(cin >> strawberries[i].x >> strawberries[i].y)) return 0;\n }\n\n // Generate optimized lines using k-means clustering\n vector> lines = optimizedLineGeneration(strawberries, a);\n\n // Output\n cout << lines.size() << \"\\n\";\n for (const auto& line : lines) {\n cout << line.first.x << \" \" << line.first.y << \" \"\n << line.second.x << \" \" << line.second.y << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nusing ll = long long;\nusing P = pair;\n\nint N;\nvector

dots;\nmap dot_map;\n\n/* Rectangle structure */\nstruct Rect {\n P p1, p2, p3, p4;\n int score;\n};\n\nset> drawn_edges;\nset

new_dots_set;\nvector solutions; \n\n/* Helper: normalize for edge storage */\npair normalize_edge(const P& a, const P& b) {\n if (a < b) return {a, b};\n else return {b, a};\n}\n\n/* Point in bounds */\nbool in_bounds(const P& p) {\n return p.first >= 0 && p.first < N && p.second >= 0 && p.second < N;\n}\n\n/* Perpendicularity of vectors */\nbool is_perpendicular_slope(ll dx1, ll dy1, ll dx2, ll dy2) {\n return dx1 * dy2 + dx2 * dy1 == 0;\n}\n\n/* Rectangle shape check */\nbool is_valid_rectangle_shape(const P& p1, const P& p2, const P& p3, const P& p4) {\n if (abs(p1.first - p2.first) == abs(p1.second - p2.second) &&\n abs(p2.first - p3.first) == abs(p2.second - p3.second) &&\n abs(p3.first - p4.first) == abs(p3.second - p4.second) &&\n abs(p4.first - p1.first) == abs(p4.second - p1.second)) {\n return true;\n }\n if (p1.first == p2.first && p2.second == p3.second &&\n p3.first == p4.first && p4.second == p1.second &&\n p1.first == p3.first && p2.first == p4.first) {\n return true;\n }\n return false;\n}\n\n/* Check if any interior edge points are occupied */\nbool interior_occupied_on_edges(const P& a, const P& b, const vector>& grid, const P& p1) {\n if (a.first == b.first) {\n for (int y = min(a.second, b.second) + 1; y < max(a.second, b.second); ++y) {\n P pt = {a.first, y};\n if (grid[pt.first][pt.second] == 1 && !(pt == p1)) return true;\n }\n } else if (a.second == b.second) {\n for (int x = min(a.first, b.first) + 1; x < max(a.first, b.first); ++x) {\n P pt = {x, a.second};\n if (grid[pt.first][pt.second] == 1 && !(pt == p1)) return true;\n }\n } else if (abs(a.first - b.first) == abs(a.second - b.second)) {\n int dx = (b.first - a.first) / abs(b.first - a.first);\n int dy = (b.second - a.second) / abs(b.second - a.second);\n for (int i = 1; i < abs(a.first - b.first); ++i) {\n P pt = {a.first + dx * i, a.second + dy * i};\n if (grid[pt.first][pt.second] == 1 && !(pt == p1)) return true;\n }\n }\n return false;\n}\n\nbool is_valid_rect(const P& p1, const P& p2, const P& n1, const P& n2, const vector>& grid) {\n if (!is_valid_rectangle_shape(p1, p2, n1, n2)) return false;\n\n vector

corners = {p1, p2, n1, n2};\n vector

perimeter_edges[4] = { {p1, p2}, {p2, n1}, {n1, n2}, {n2, p1} };\n\n for (const auto& e : perimeter_edges) {\n if (interior_occupied_on_edges(e[0], e[1], grid, p1)) return false;\n }\n return true;\n}\n\nint calculate_score(const P& p) {\n ll c = (N - 1) / 2;\n ll dx = p.first - c, dy = p.second - c;\n return (dx * dx + dy * dy + 1);\n}\n\nvoid generate_candidates(\n const set

& unoccupied,\n vector& candidates,\n const map& dot_map,\n const set

& new_dots,\n const vector>& grid\n) {\n candidates.clear();\n for (const auto& p1 : unoccupied) {\n for (int dx : {1, -1}) {\n for (int dy : {1, -1}) {\n if (dx == 0 || dy == 0) continue;\n\n P p2(p1.first + dx, p1.second + dy);\n P n1(p1.first - dx, p1.second + dy);\n P n2(p1.first - dx, p1.second - dy);\n\n if (!in_bounds(p2) || !in_bounds(n1) || !in_bounds(n2)) continue;\n if (!(dot_map.count(p2) || new_dots.count(p2))) continue;\n if (!(dot_map.count(n1) || new_dots.count(n1))) continue;\n if (!(dot_map.count(n2) || new_dots.count(n2))) continue;\n\n if (is_valid_rect(p1, p2, n1, n2, grid)) {\n candidates.push_back({p1, p2, n1, n2, calculate_score(p1)});\n }\n }\n }\n // the rest of the function remains unchanged from previous version\n // Axis-aligned and other variants were already handled above\n\n for (int dx : {1, -1}) {\n P p2(p1.first + dx, p1.second);\n P n1(p1.first, p1.second + dx);\n P n2(p1.first + dx, p1.second - dx);\n\n if (!in_bounds(p2) || !in_bounds(n1) || !in_bounds(n2)) continue;\n if (!(dot_map.count(p2) || new_dots.count(p2))) continue;\n if (!(dot_map.count(n1) || new_dots.count(n1))) continue;\n if (!(dot_map.count(n2) || new_dots.count(n2))) continue;\n\n if (is_valid_rect(p1, p2, n1, n2, grid)) {\n candidates.push_back({p1, p2, n1, n2, calculate_score(p1)});\n }\n }\n\n for (int dy : {1, -1}) {\n P p2(p1.first, p1.second + dy);\n P n1(p1.first + dy, p1.second);\n P n2(p1.first - dy, p1.second + dy);\n\n if (!in_bounds(p2) || !in_bounds(n1) || !in_bounds(n2)) continue;\n if (!(dot_map.count(p2) || new_dots.count(p2))) continue;\n if (!(dot_map.count(n1) || new_dots.count(n1))) continue;\n if (!(dot_map.count(n2) || new_dots.count(n2))) continue;\n\n if (is_valid_rect(p1, p2, n1, n2, grid)) {\n candidates.push_back({p1, p2, n1, n2, calculate_score(p1)});\n }\n }\n }\n}\n\n/* Main execution function */\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N;\n\n vector> grid(N, vector(N, 0));\n dots.clear();\n dot_map.clear();\n\n int M; cin >> M;\n for (int i = 0; i < M; ++i) {\n int x, y; cin >> x >> y;\n dots.push_back({x, y});\n dot_map[{x, y}] = 1;\n grid[x][y] = 1;\n }\n\n /* Track unoccupied grid points */\n set

unoccupied;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (!dot_map.count({i, j}) && !new_dots_set.count({i, j})) {\n unoccupied.insert({i, j});\n }\n }\n }\n\n while (true) {\n vector candidates;\n generate_candidates(unoccupied, candidates, dot_map, new_dots_set, grid);\n if (candidates.empty()) break;\n\n sort(candidates.begin(), candidates.end(),\n [](const Rect& a, const Rect& b) { return a.score > b.score; });\n Rect best = candidates[0];\n solutions.push_back(best);\n grid[best.p1.first][best.p1.second] = 1;\n unoccupied.erase(best.p1);\n new_dots_set.insert(best.p1);\n\n drawn_edges.insert(normalize_edge(best.p1, best.p2));\n drawn_edges.insert(normalize_edge(best.p2, best.p3));\n drawn_edges.insert(normalize_edge(best.p3, best.p4));\n drawn_edges.insert(normalize_edge(best.p4, best.p1));\n }\n\n cout << solutions.size() << endl;\n for (const Rect& sol : solutions) {\n cout << sol.p1.first << \" \" << sol.p1.second << \" \"\n << sol.p2.first << \" \" << sol.p2.second << \" \"\n << sol.p3.first << \" \" << sol.p3.second << \" \"\n << sol.p4.first << \" \" << sol.p4.second << endl;\n }\n\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nstruct Cell {\n int flavor = 0; // 0: empty\n};\n\nconst int SIZE = 10;\nCell grid[SIZE][SIZE];\n\nvoid reset_empty() {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j].flavor = 0;\n }\n }\n}\n\nvector> get_empty_cells() {\n vector> empty;\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) {\n empty.emplace_back(i, j);\n }\n }\n }\n return empty;\n}\n\nvoid place_candy(int t, int p, int flavor) {\n vector> empty = get_empty_cells();\n auto [i, j] = empty[p - 1];\n grid[i][j].flavor = flavor;\n}\n\nvoid tilt(const char dir) {\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor == 0) continue;\n if (dir == 'F') {\n for (int k = i - 1; k >= 0; --k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k+1][j].flavor == 0) {\n swap(grid[i][j], grid[k+1][j]);\n }\n break;\n }\n }\n } else if (dir == 'B') {\n for (int k = i + 1; k < SIZE; ++k) {\n if (grid[k][j].flavor != 0) {\n if (grid[k-1][j].flavor == 0) {\n swap(grid[i][j], grid[k-1][j]);\n }\n break;\n }\n }\n } else if (dir == 'L') {\n for (int k = j - 1; k >= 0; --k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k+1].flavor == 0) {\n swap(grid[i][j], grid[i][k+1]);\n }\n break;\n }\n }\n } else if (dir == 'R') {\n for (int k = j + 1; k < SIZE; ++k) {\n if (grid[i][k].flavor != 0) {\n if (grid[i][k-1].flavor == 0) {\n swap(grid[i][j], grid[i][k-1]);\n }\n break;\n }\n }\n }\n }\n }\n}\n\nvector calculate_components() {\n vector> visited(SIZE, vector(SIZE, false));\n vector component_sizes(3, 0);\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (visited[i][j] || grid[i][j].flavor == 0) continue;\n int flavor = grid[i][j].flavor;\n queue> q;\n q.emplace(i, j);\n visited[i][j] = true;\n int size = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n size++;\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (nx >= 0 && nx < SIZE && ny >= 0 && ny < SIZE &&\n !visited[nx][ny] && grid[nx][ny].flavor == flavor) {\n visited[nx][ny] = true;\n q.emplace(nx, ny);\n }\n }\n }\n component_sizes[flavor - 1] += size * size;\n }\n }\n return component_sizes;\n}\n\nint evaluate_tilt(const char dir, const vector& flavors) {\n Cell backup_grid[SIZE][SIZE];\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup_grid[i][j] = grid[i][j];\n }\n }\n\n tilt(dir);\n int score = calculate_components()[flavors[0] - 1];\n\n // Restore the grid\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n\n return score;\n}\n\n// Function to evaluate the potential of a tilt direction based on future grouping and immediate score\nint evaluate_future_grouping(const char dir, const vector& flavors) {\n Cell backup_grid[SIZE][SIZE];\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup_grid[i][j] = grid[i][j];\n }\n }\n\n tilt(dir);\n\n // Count the number of adjacent cells of the same flavor\n int adj_count = 0;\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n if (grid[i][j].flavor != 0) {\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int ni = i + dx[d];\n int nj = j + dy[d];\n if (ni >= 0 && ni < SIZE && nj >= 0 && nj < SIZE &&\n grid[ni][nj].flavor == grid[i][j].flavor) {\n adj_count++;\n }\n }\n }\n }\n }\n\n // Calculate the immediate score\n int score = calculate_components()[flavors[0] - 1];\n\n // Restore the grid\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n\n // Weight the adjacency count more to prioritize future grouping\n return score + adj_count * 100;\n}\n\n// Function to evaluate multiple steps ahead and choose the best direction based on future grouping\nchar evaluate_multiple_steps(const vector& flavors, int steps) {\n vector dirs = {'F', 'B', 'L', 'R'};\n vector future_scores(4, 0);\n\n for (int d = 0; d < 4; ++d) {\n Cell backup_grid[SIZE][SIZE];\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n backup_grid[i][j] = grid[i][j];\n }\n }\n\n // Simulate multiple steps in the same direction\n for (int s = 0; s < steps; ++s) {\n tilt(dirs[d]);\n }\n\n future_scores[d] = evaluate_future_grouping(dirs[d], flavors);\n\n // Restore the grid\n for (int i = 0; i < SIZE; ++i) {\n for (int j = 0; j < SIZE; ++j) {\n grid[i][j] = backup_grid[i][j];\n }\n }\n }\n\n int best_score = *max_element(future_scores.begin(), future_scores.end());\n vector best_dirs;\n for (int d = 0; d < 4; ++d) {\n if (future_scores[d] == best_score) {\n best_dirs.push_back(d);\n }\n }\n\n // Randomly choose among the best directions\n random_device rd;\n mt19937 gen(rd());\n uniform_int_distribution<> distrib(0, best_dirs.size() - 1);\n int chosen_dir_index = distrib(gen);\n return dirs[best_dirs[chosen_dir_index]];\n}\n\nchar decide_tilt(const vector& flavors_input) {\n reset_empty();\n vector flavors = flavors_input; // Create a copy to avoid const issues\n int p;\n cout << flush;\n cin >> p;\n int flavor = flavors[0];\n flavors.erase(flavors.begin());\n place_candy(0, p, flavor);\n\n vector dirs = {'F', 'B', 'L', 'R'};\n char best_dir;\n\n // Enhanced heuristic: Combine multi-step evaluation with fallback to single-step\n best_dir = evaluate_multiple_steps(flavors, 3); // Simulate 3 steps ahead\n\n cout << best_dir << '\\n' << flush;\n tilt(best_dir);\n\n return best_dir;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n vector flavors(100);\n for (int i = 0; i < 100; ++i) {\n cin >> flavors[i];\n }\n\n for (int t = 0; t < 100; ++t) {\n if (t == 99) {\n cout << '\\n' << flush;\n break;\n }\n decide_tilt({flavors.begin() + t, flavors.end()});\n }\n\n return 0;\n}","ahc016":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int M;\n double eps;\n cin >> M >> eps;\n \n // Dynamic N selection based on M and epsilon\n int N = 20;\n if (M > 70) N = 35;\n else if (M > 40) N = 28;\n else if (M > 20) N = 22;\n \n if (eps > 0.3) N += 10;\n else if (eps > 0.2) N += 5;\n \n N = min(max(N, 4), 100);\n \n // Generate M distinct graphs with controlled edge distribution\n cout << N << \"\\n\";\n int total_edges = N * (N - 1) / 2;\n \n vector graphs(M);\n for (int k = 0; k < M; ++k) {\n // Use exponential distribution for edge density\n double density = exp(log(0.8) * (1.0 - k * 1.0 / (M - 1)));\n int target_edges = static_cast(density * total_edges + 0.5);\n \n string g(total_edges, '0');\n // Fill edges in a way that preserves structure under noise\n for (int i = 0; i < target_edges; ++i) {\n int pos = (i * 7) % total_edges; // Simple perturbation\n g[pos] = '1';\n }\n graphs[k] = g;\n cout << g << \"\\n\";\n }\n cout << flush;\n \n // Process queries with improved classification\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n // Enhanced edge counting with noise robustness\n int edge_count = count(H.begin(), H.end(), '1');\n \n // Dynamic threshold based on epsilon\n double noise_factor = 1.0 + eps * 2.5;\n int adjusted_count = static_cast(edge_count / noise_factor + 0.5);\n \n // Map to nearest graph using precomputed densities\n double best_error = 1e9;\n int best_k = 0;\n for (int k = 0; k < M; ++k) {\n int expected_edges = count(graphs[k].begin(), graphs[k].end(), '1');\n double error = abs(adjusted_count - expected_edges);\n if (error < best_error) {\n best_error = error;\n best_k = k;\n }\n }\n \n cout << best_k << \"\\n\";\n cout << flush;\n }\n \n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long INF = 1e9;\n\nvoid floydWarshall(int N, vector>& dist) {\n for (int k = 0; k < N; ++k)\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);\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 vector u(M), v(M), w(M);\n for (int i = 0; i < M; ++i) {\n cin >> u[i] >> v[i] >> w[i];\n u[i]--; v[i]--;\n }\n\n // Ignore vertex coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n // Initialize distance matrix for APSP\n vector> dist(N, vector(N, INF));\n for (int i = 0; i < N; ++i) dist[i][i] = 0;\n\n for (int i = 0; i < M; ++i) {\n dist[u[i]][v[i]] = min(dist[u[i]][v[i]], (long long)w[i]);\n dist[v[i]][u[i]] = min(dist[v[i]][u[i]], (long long)w[i]);\n }\n\n floydWarshall(N, dist);\n\n // Estimate impact of each edge by counting shortest paths through it\n vector> edge_impacts;\n for (int i = 0; i < M; ++i) {\n int a = u[i], b = v[i];\n long long count = 0;\n\n for (int src = 0; src < N; ++src) {\n for (int dst = 0; dst < N; ++dst) {\n if (src == dst) continue;\n if (dist[src][a] + w[i] + dist[b][dst] == dist[src][dst]) {\n count++;\n }\n if (dist[src][b] + w[i] + dist[a][dst] == dist[src][dst]) {\n count++;\n }\n }\n }\n\n edge_impacts.emplace_back(count, i);\n }\n\n // Sort edges by impact (ascending, repair edges with small impact later)\n sort(edge_impacts.begin(), edge_impacts.end());\n\n // Assign repair days\n vector result(M);\n for (int i = 0; i < M; ++i) {\n int idx = edge_impacts[i].second;\n result[idx] = (i % D) + 1;\n }\n\n // Output result\n for (int i = 0; i < M; ++i) {\n cout << result[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int D;\n cin >> D;\n vector f1(D), f2(D), r1(D), r2(D);\n \n for (int i = 0; i < 2; ++i) {\n for (int j = 0; j < D; ++j) cin >> f1[j];\n for (int j = 0; j < D; ++j) cin >> r1[j];\n for (int j = 0; j < D; ++j) cin >> f2[j];\n for (int j = 0; j < D; ++j) cin >> r2[j];\n }\n\n // Initialize 3D array to store which block is placed where\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n // Identify regions where both silhouettes need material\n vector>> common_region(D, vector>(D, vector(D, false)));\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n bool f_needed1 = (f1[z][x] == '1');\n bool r_needed1 = (r1[z][y] == '1');\n bool f_needed2 = (f2[z][x] == '1');\n bool r_needed2 = (r2[z][y] == '1');\n common_region[z][x][y] = f_needed1 && f_needed2 && r_needed1 && r_needed2;\n }\n }\n }\n\n // Create blocks for common region (shared between both objects)\n int block_id = 1;\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 (block_id == 1000005) break;\n if (common_region[z][x][y]) {\n b1[z][x][y] = block_id;\n b2[z][x][y] = block_id;\n ++block_id;\n }\n }\n if (block_id == 1000005) break;\n }\n if (block_id == 1000005) break;\n }\n\n // Fill remaining regions with unique 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 (b1[z][x][y] == 0 && f1[z][x] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && f2[z][x] == '1') {\n b2[z][x][y] = block_id++;\n }\n if (b1[z][x][y] == 0 && r1[z][y] == '1') {\n b1[z][x][y] = block_id++;\n }\n if (b2[z][x][y] == 0 && r2[z][y] == '1') {\n b2[z][x][y] = block_id++;\n }\n }\n }\n }\n\n // Output\n cout << block_id - 1 << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b1[z][x][y];\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n int z = i / (D * D);\n int xy = i % (D * D);\n int x = xy / D;\n int y = xy % D;\n if (i > 0) cout << \" \";\n cout << b2[z][x][y];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \nusing namespace std;\n\ndouble dist(const pair& a, const pair& b) {\n long long dx = a.first - b.first;\n long long dy = a.second - b.second;\n return sqrt(dx * dx + dy * dy);\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);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].first >> stations[i].second;\n }\n\n vector> edges(M);\n for (int i = 0; i < M; ++i) {\n int u, v, w;\n cin >> u >> v >> w;\n u--; v--;\n edges[i] = {u, v, w};\n }\n\n vector> residents(K);\n for (int i = 0; i < K; ++i) {\n cin >> residents[i].first >> residents[i].second;\n }\n\n // Step 1: MST via Kruskal\u2019s\n vector parent(N);\n iota(parent.begin(), parent.end(), 0);\n auto find = [&](int x) {\n while (parent[x] != x) {\n parent[x] = parent[parent[x]];\n x = parent[x];\n }\n return x;\n };\n\n auto unite = [&](int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n parent[y] = x;\n return true;\n };\n\n vector> sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end(), [](const auto& a, const auto& b) {\n return get<2>(a) < get<2>(b);\n });\n\n vector B(M, 0);\n for (auto& [u, v, w] : sorted_edges) {\n if (unite(u, v)) {\n for (int i = 0; i < M; ++i) {\n int a, b, weight;\n tie(a, b, weight) = edges[i];\n if ((a == u && b == v) || (a == v && b == u)) {\n B[i] = 1;\n break;\n }\n }\n }\n }\n\n // Step 2: Assign residents to nearest node, then compute minimal P_i via binary search\n vector P(N, 0);\n vector> dists(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < K; ++j) {\n dists[i][j] = dist(stations[i], residents[j]);\n }\n }\n\n // For each resident, assign to nearest node and note required radius\n vector required(N, 0.0);\n for (int j = 0; j < K; ++j) {\n int best_node = -1;\n double best_dist = 1e18;\n for (int i = 0; i < N; ++i) {\n if (dists[i][j] < best_dist) {\n best_dist = dists[i][j];\n best_node = i;\n }\n }\n required[best_node] = max(required[best_node], best_dist);\n }\n\n // Binary search for minimal P_i for each node\n for (int i = 0; i < N; ++i) {\n double lo = 0.0, hi = required[i];\n for (int iter = 0; iter < 60; ++iter) {\n double mid = (lo + hi) / 2;\n bool ok = false;\n for (int j = 0; j < K; ++j) {\n if (dists[i][j] <= mid) continue;\n // Try to cover this resident via other nodes\n bool covered = false;\n for (int k = 0; k < N; ++k) {\n if (k == i) continue;\n if (dists[k][j] <= P[k]) {\n covered = true;\n break;\n }\n }\n if (!covered) {\n ok = false;\n break;\n }\n ok = true;\n }\n if (ok) hi = mid;\n else lo = mid;\n }\n P[i] = min((int)ceil(hi), 5000);\n }\n\n // Post-optimization: Try to reduce P_i by checking neighbors\n for (int i = 0; i < N; ++i) {\n if (P[i] == 0) continue;\n // Try reducing by 1 and check if still valid\n P[i]--;\n vector covered(K, false);\n for (int j = 0; j < K; ++j) {\n for (int k = 0; k < N; ++k) {\n if (dists[k][j] <= P[k]) {\n covered[j] = true;\n break;\n }\n }\n }\n if (!all_of(covered.begin(), covered.end(), [](bool x) { return x; })) {\n P[i]++;\n }\n }\n\n cout << endl;\n for (int i = 0; i < N; ++i) {\n cout << P[i] << (i == N - 1 ? \"\\n\" : \" \");\n }\n for (int i = 0; i < M; ++i) {\n cout << B[i] << (i == M - 1 ? \"\\n\" : \" \");\n }\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Ball {\n int number;\n int x, y;\n Ball(int n, int x, int y) : number(n), x(x), y(y) {}\n};\n\nvector> pyramid;\nvector, pair>> swaps;\n\nbool isAdjacent(int x1, int y1, int x2, int y2) {\n if (x1 == x2 - 1 && y1 == y2 - 1) return true;\n if (x1 == x2 - 1 && y1 == y2) return true;\n if (x1 == x2 && y1 == y2 - 1) return true;\n if (x1 == x2 && y1 == y2 + 1) return true;\n if (x1 == x2 + 1 && y1 == y2) return true;\n if (x1 == x2 + 1 && y1 == y2 + 1) return true;\n return false;\n}\n\nvoid swapBalls(int x1, int y1, int x2, int y2) {\n if (!isAdjacent(x1, y1, x2, y2)) return;\n swaps.push_back({{x1, y1}, {x2, y2}});\n swap(pyramid[x1][y1].number, pyramid[x2][y2].number);\n}\n\nint findMinBallBelow(int x, int y, int N) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int nx = x + 1; nx < N; ++nx) {\n for (int ny = 0; ny <= nx; ++ny) {\n if (pyramid[nx][ny].number < minVal) {\n minVal = pyramid[nx][ny].number;\n minX = nx;\n minY = ny;\n }\n }\n }\n if (minX != -1) return pyramid[minX][minY].number;\n return INT_MAX;\n}\n\nvoid processTier(int tier, int N) {\n int rows = tier + 1;\n for (int y = 0; y <= tier; ++y) {\n int x = tier;\n Ball& current = pyramid[x][y];\n if (x + 1 >= N) continue;\n bool valid = true;\n if (y < rows - 1 && current.number > pyramid[x+1][y].number) valid = false;\n if (y + 1 < rows && current.number > pyramid[x+1][y+1].number) valid = false;\n if (!valid) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < rows - 1; ++ny) {\n if (pyramid[x+1][ny].number < current.number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n int futureMin = findMinBallBelow(x + 1, minY, N);\n if (futureMin < current.number) {\n swapBalls(x, y, minX, minY);\n }\n }\n }\n }\n}\n\nvoid dynamicPostProcess(int N) {\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (x + 1 >= N) continue;\n if (pyramid[x][y].number > pyramid[x+1][y].number) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < x + 2; ++ny) {\n if (pyramid[x+1][ny].number < pyramid[x][y].number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n swapBalls(x, y, minX, minY);\n }\n }\n if (y + 1 <= x && pyramid[x][y].number > pyramid[x+1][y+1].number) {\n int minVal = INT_MAX;\n int minX = -1, minY = -1;\n for (int ny = 0; ny < x + 2; ++ny) {\n if (pyramid[x+1][ny].number < pyramid[x][y].number && pyramid[x+1][ny].number < minVal) {\n minVal = pyramid[x+1][ny].number;\n minX = x + 1;\n minY = ny;\n }\n }\n if (minX != -1) {\n swapBalls(x, y, minX, minY);\n }\n }\n }\n }\n}\n\nint main() {\n int N = 30;\n pyramid.resize(N);\n for (int x = 0; x < N; ++x) {\n pyramid[x].reserve(x + 1);\n for (int y = 0; y <= x; ++y) {\n int num;\n cin >> num;\n pyramid[x].emplace_back(num, x, y);\n }\n }\n\n for (int tier = 0; tier < N - 1; ++tier) {\n processTier(tier, N);\n }\n\n dynamicPostProcess(N);\n\n cout << swaps.size() << endl;\n for (auto& sw : swaps) {\n cout << sw.first.first << \" \" << sw.first.second << \" \"\n << sw.second.first << \" \" << sw.second.second << endl;\n }\n\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint D = 9;\nint N;\nvector> grid;\nvector> dist;\nvector> obstacles;\nvector> empty_cells;\nvector> visited;\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nvoid bfs(int sx, int sy) {\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n visited[sx][sy] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int i = 0; i < 4; i++) {\n int nx = x + dx[i], ny = y + dy[i];\n if (nx < 0 || nx >= D || ny < 0 || ny >= D) continue;\n if (grid[nx][ny] || visited[nx][ny]) continue;\n dist[nx][ny] = dist[x][y] + 1;\n visited[nx][ny] = true;\n q.push({nx, ny});\n }\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> D >> N;\n grid.assign(D, vector(D, false));\n dist.assign(D, vector(D, -1));\n visited.assign(D, vector(D, false));\n\n int entrance_x = 0, entrance_y = (D - 1) / 2;\n grid[entrance_x][entrance_y] = true;\n\n for (int i = 0; i < N; i++) {\n int r, c;\n cin >> r >> c;\n grid[r][c] = true;\n obstacles.emplace_back(r, c);\n }\n\n for (int i = 0; i < D; i++) {\n for (int j = 0; j < D; j++) {\n if (grid[i][j]) continue;\n empty_cells.emplace_back(i, j);\n }\n }\n\n bfs(entrance_x, entrance_y);\n\n vector>> candidates;\n for (auto [x, y] : empty_cells) {\n if (dist[x][y] == -1) continue;\n candidates.emplace_back(-dist[x][y], make_pair(x, y));\n }\n sort(candidates.begin(), candidates.end());\n\n vector> storage_order;\n vector>> input;\n\n cout << flush;\n\n for (int d = 0; d < D * D - 1 - N; d++) {\n int t;\n cin >> t;\n input.emplace_back(t, make_pair(-1, -1));\n\n int best_idx = -1;\n int best_dist = -1;\n for (auto &[prio, pos] : candidates) {\n int x = pos.first, y = pos.second;\n if (dist[x][y] >= 0) {\n best_idx = pos.first;\n best_dist = pos.second;\n break;\n }\n }\n\n cout << best_idx << \" \" << best_dist << \"\\n\" << flush;\n\n for (auto &[prio, pos] : candidates) {\n if (pos.first == best_idx && pos.second == best_dist) {\n prio = 1e9;\n break;\n }\n }\n }\n\n for (auto &[t, pos] : input) {\n cout << pos.first << \" \" << pos.second << \"\\n\";\n }\n\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n = 50, m = 100;\n vector> c(n, vector(n));\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> c[i][j];\n }\n }\n\n vector> adj(m + 1);\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int color = c[i][j];\n // Check up\n if (i > 0) {\n int up = c[i - 1][j];\n if (up != 0 && up != color) {\n adj[color].insert(up);\n adj[up].insert(color);\n }\n }\n // Check left\n if (j > 0) {\n int left = c[i][j - 1];\n if (left != 0 && left != color) {\n adj[color].insert(left);\n adj[left].insert(color);\n }\n }\n }\n }\n\n vector> d(n, vector(n, 0));\n\n // Place each color in a unique position, ensuring adjacency\n vector> positions;\n for (int color = 1; color <= m; ++color) {\n // Find a position not already occupied and on the border to maximize adjacency\n bool placed = false;\n for (int i = 0; i < n && !placed; ++i) {\n for (int j = 0; j < n && !placed; ++j) {\n if (d[i][j] == 0) {\n // Check if this position can satisfy adjacency requirements\n bool valid = true;\n for (int other : adj[color]) {\n // Check adjacent positions for other colors\n bool found = false;\n for (int dx = -1; dx <= 1; ++dx) {\n for (int dy = -1; dy <= 1; ++dy) {\n if (abs(dx) + abs(dy) != 1) continue;\n int ni = i + dx, nj = j + dy;\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n if (d[ni][nj] == other) {\n found = true;\n break;\n }\n } else {\n // Outside is considered color 0, so no adjacency\n }\n }\n if (found) break;\n }\n if (!found) {\n valid = false;\n break;\n }\n }\n if (valid) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n }\n }\n }\n }\n if (!placed) {\n // Fallback: place in the first available spot\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n d[i][j] = color;\n positions.emplace_back(i, j);\n placed = true;\n break;\n }\n }\n if (placed) break;\n }\n }\n }\n\n // Now, fill the remaining area with 0, but ensure connectivity\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (d[i][j] == 0) {\n // Check if surrounding is all 0 or out of bounds, then keep as 0\n // Otherwise, might need to assign a color, but for simplicity, keep 0\n d[i][j] = 0;\n }\n }\n }\n\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n if (j > 0) cout << \" \";\n cout << d[i][j];\n }\n cout << \"\\n\";\n }\n\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nstruct Item {\n int id;\n double estimatedWeight;\n double weight() const {\n return estimatedWeight;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, D, Q;\n if (!(cin >> N >> D >> Q)) return 0;\n\n vector items(N);\n for (int i = 0; i < N; ++i) {\n items[i].id = i;\n items[i].estimatedWeight = 1.0; \n }\n\n vector results;\n\n // Compare each item with Item 0 to estimate weights\n for (int i = 1; i < N && Q > 0; ++i) {\n int nL = 1, nR = 1;\n vector L = {i};\n vector R = {0}; \n\n cout << nL << \" \" << nR << \" \" << L[0] << \" \" << R[0] << \"\\n\";\n cout.flush();\n\n string res;\n cin >> res;\n results.push_back(res);\n\n if (res == \">\") {\n items[i].estimatedWeight = items[0].estimatedWeight * 1.1;\n } else if (res == \"<\") {\n items[i].estimatedWeight = items[0].estimatedWeight * 0.9;\n } else {\n items[i].estimatedWeight = items[0].estimatedWeight;\n }\n\n Q--; \n }\n\n // Safeguard: skip any remaining unused queries\n while (Q > 0) {\n cout << \"1 1 0 1\\n\"; \n cout.flush();\n string dummy;\n cin >> dummy;\n Q--; \n }\n\n // Safeguard: Ensure there are D groups\n if (D == 0) D = 1;\n\n // Sort items by estimated weight in descending order\n sort(items.begin(), items.end(), [](const Item& a, const Item& b) {\n return a.estimatedWeight > b.estimatedWeight;\n });\n\n // Greedy group balancing by weight\n vector groupTotals(D, 0.0);\n vector groupAssignments(N, 0);\n\n for (const auto& item : items) {\n if (item.id < 0 || item.id >= N) {\n continue; \n }\n\n int bestGroup = 0;\n double minTotal = groupTotals[0];\n for (int g = 1; g < D; ++g) {\n if (groupTotals[g] < minTotal) {\n minTotal = groupTotals[g];\n bestGroup = g;\n }\n }\n\n groupAssignments[item.id] = bestGroup;\n groupTotals[bestGroup] += item.estimatedWeight;\n }\n\n // Output the division\n for (int i = 0; i < N; ++i) {\n if (i) cout << \" \";\n cout << groupAssignments[i];\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n = 200, m = 10;\n vector> stacks(m);\n vector pos(n + 1); // pos[v] = {stack_index, position_from_bottom}\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < n / m; ++j) {\n int v;\n cin >> v;\n stacks[i].push_back(v);\n pos[v] = {i, j};\n }\n }\n\n vector removed(n + 1, false);\n vector> operations;\n\n auto current_pos = pos; // Copy initial positions\n\n for (int target = 1; target <= n; ++target) {\n if (removed[target]) continue;\n auto [si, pos_in_stack] = current_pos[target];\n if (pos_in_stack == stacks[si].size() - 1) {\n // Already on top, remove it\n operations.emplace_back(target, 0);\n removed[target] = true;\n stacks[si].pop_back();\n // Update positions of remaining boxes in this stack\n for (int j = pos_in_stack - 1; j >= 0; --j) {\n int v = stacks[si][j];\n current_pos[v] = {si, j};\n }\n stacks[si].pop_back();\n } else {\n // Need to move this box to the top of some stack\n // Find a stack where this box can be moved to the top\n int best_stack = si;\n int min_boxes_moved = n; // Upper bound\n for (int dest = 0; dest < m; ++dest) {\n if (dest == si) continue;\n // Calculate how many boxes we need to move from current stack si to get target to top\n int boxes_moved = pos_in_stack + 1; // All boxes from pos_in_stack down to bottom\n // Check if target is at the top after moving to dest stack\n // After moving, target becomes top of dest stack\n // Energy cost is boxes_moved + 1\n if (boxes_moved + 1 < min_boxes_moved) {\n min_boxes_moved = boxes_moved + 1;\n best_stack = dest;\n }\n }\n // Move target and above to best_stack\n vector to_move;\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n to_move.push_back(stacks[si][j]);\n }\n // Update stacks\n stacks[best_stack].insert(stacks[best_stack].end(), to_move.begin(), to_move.end());\n // Update positions\n for (int j = 0; j < to_move.size(); ++j) {\n int v = to_move[j];\n current_pos[v] = {best_stack, (int)stacks[best_stack].size() - to_move.size() + j};\n }\n // Update the original stack\n for (int j = pos_in_stack; j < stacks[si].size(); ++j) {\n stacks[si].pop_back();\n }\n // Record operation\n operations.emplace_back(target, best_stack + 1);\n }\n }\n\n // Output operations\n for (auto [v, i] : operations) {\n cout << v << \" \" << i << \"\\n\";\n }\n return 0;\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N;\n if(!(cin >> N)) return 0;\n vector h(N - 1);\n for (int i = 0; i < N - 1; ++i) cin >> h[i];\n vector v(N);\n for (int i = 0; i < N; ++i) cin >> v[i];\n vector> d(N, vector(N));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> d[i][j];\n }\n }\n \n vector> visited(N, vector(N, false));\n vector> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n vector dir_char = {'R', 'D', 'L', 'U'};\n \n function dfs = [&](int i, int j, int parent_dir) {\n visited[i][j] = true;\n vector> candidates;\n for (int di = 0; di < 4; ++di) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || visited[ni][nj]) continue;\n bool wall = false;\n if (dirs[di].first == 0) {\n if (v[i][min(j, nj)] == '1') wall = true;\n } else {\n if (h[min(i, ni)][j] == '1') wall = true;\n }\n if (!wall) {\n candidates.emplace_back(di, parent_dir);\n }\n }\n sort(candidates.begin(), candidates.end(), [&](const auto& a, const auto& b) {\n int di1 = a.first, pdi1 = a.second;\n int di2 = b.first, pdi2 = b.second;\n int ni1 = i + dirs[di1].first;\n int nj1 = j + dirs[di1].second;\n int ni2 = i + dirs[di2].first;\n int nj2 = j + dirs[di2].second;\n return d[ni1][nj1] > d[ni2][nj2];\n });\n for (auto [di, pdir] : candidates) {\n int ni = i + dirs[di].first;\n int nj = j + dirs[di].second;\n cout << dir_char[di];\n dfs(ni, nj, di);\n cout << dir_char[(di + 2) % 4];\n }\n };\n \n dfs(0, 0, -1);\n cout << endl;\n \n return 0;\n}","ahc028":"#include \nusing namespace std;\n\nstruct Point {\n int i, j;\n\n Point(int i_ = -1, int j_ = -1) : i(i_), j(j_) {}\n};\n\nbool checkCoverage(const string& window, const unordered_set& rem) {\n for (const auto& s : rem) {\n // Only check if pattern length <= window length\n if (s.size() > window.size()) continue;\n if (window.substr(window.size() - s.size(), s.size()) == s) {\n return true;\n }\n }\n return false;\n}\n\nPoint greedyStep(const Point& curPos, const vector& grid,\n unordered_set rem, string window) {\n const int N = grid.size();\n const int radius = 3;\n\n // Try immediate neighbor moves first\n const int dx[] = {1, -1, 0, 0};\n const int dy[] = {0, 0, 1, -1};\n for (int d = 0; d < 4; ++d) {\n int ni = curPos.i + dx[d], nj = curPos.j + dy[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n string candidate(1, grid[ni][nj]); // Fix: using string(1, char)\n if (!rem.empty() && window.size() >= 5 && checkCoverage(window + candidate, rem)) {\n return Point(ni, nj);\n }\n }\n\n // Explore within radius neighborhood\n for (int r = 1; r <= radius; ++r) {\n for (int dx = -r; dx <= r; ++dx) {\n for (int dy = -r; dy <= r; ++dy) {\n if (abs(dx) == r || abs(dy) == r) {\n int ni = curPos.i + dx, nj = curPos.j + dy;\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n string candidate(1, grid[ni][nj]); // Fix: using string(1, char)\n string trial = window + candidate;\n if (!rem.empty() && trial.size() >= 5 && checkCoverage(trial, rem)) {\n return Point(ni, nj);\n }\n }\n }\n }\n }\n\n // Fallback: stay in place\n return curPos;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n if (!(cin >> N >> M)) return 0;\n int si, sj;\n cin >> si >> sj;\n\n vector grid(N);\n for (auto& row : grid) cin >> row;\n\n vector t(M);\n for (auto& tt : t) cin >> tt;\n\n unordered_set rem(t.begin(), t.end());\n\n string window;\n vector path;\n Point cur(si, sj);\n path.emplace_back(cur);\n window += grid[si][sj];\n\n const int MAX_STEPS = 5000;\n for (int step = 0; step < MAX_STEPS && !rem.empty(); ++step) {\n Point nxt = greedyStep(cur, grid, rem, window);\n if (nxt.i == cur.i && nxt.j == cur.j) continue; // Skip if no progress\n cur = nxt;\n window += grid[cur.i][cur.j];\n if (window.size() > 5) {\n window = window.substr(window.size() - 5, 5);\n }\n\n // Clean up covered substrings\n auto it = rem.begin();\n while (it != rem.end()) {\n if (window.size() >= it->size() &&\n window.substr(window.size() - it->size(), it->size()) == *it) {\n it = rem.erase(it);\n } else {\n ++it;\n }\n }\n path.push_back(cur);\n }\n\n for (const auto& p : path) {\n cout << p.i << \" \" << p.j << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \nusing namespace std;\n\nstruct OilField {\n vector> cells;\n int minI, minJ;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n\n vector fields(M);\n for (int idx = 0; idx < M; ++idx) {\n int d;\n cin >> d;\n fields[idx].cells.resize(d);\n for (int i = 0; i < d; ++i) {\n cin >> fields[idx].cells[i].first >> fields[idx].cells[i].second;\n }\n int minI = fields[idx].cells[0].first;\n int minJ = fields[idx].cells[0].second;\n for (auto &p : fields[idx].cells) {\n minI = min(minI, p.first);\n minJ = min(minJ, p.second);\n }\n fields[idx].minI = minI;\n fields[idx].minJ = minJ;\n for (auto &p : fields[idx].cells) {\n p.first -= minI;\n p.second -= minJ;\n }\n }\n\n vector> v(N, vector(N, -1));\n vector> positive;\n\n // Step 1: Drill some key points to get initial information\n // We can start by drilling corners and centers\n vector> drillCandidates = {\n {N/2, N/2}, {0, 0}, {N-1, 0}, {0, N-1}, {N-1, N-1}\n };\n\n for (auto &p : drillCandidates) {\n int i = p.first, j = p.second;\n if (i >= N || j >= N) continue;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n cin >> v[i][j];\n if (v[i][j] > 0) {\n positive.emplace_back(i, j);\n }\n }\n\n // Step 2: Try to guess based on current positive cells\n // For each oil field shape, try to match with positive cells\n // This is a heuristic; we might need to refine further\n\n set> posSet(positive.begin(), positive.end());\n\n // Try to find candidate positions for each oil field\n vector> placements;\n for (const auto &field : fields) {\n int size = field.cells.size();\n for (int i = 0; i <= N - field.minI - 1; ++i) {\n for (int j = 0; j <= N - field.minJ - 1; ++j) {\n bool valid = true;\n for (auto &cell : field.cells) {\n int x = i + cell.first;\n int y = j + cell.second;\n if (x >= N || y >= N) {\n valid = false;\n break;\n }\n if (v[x][y] == 0) {\n valid = false;\n break;\n }\n }\n if (valid) {\n placements.emplace_back(i, j);\n }\n }\n }\n }\n\n // For now, just output all positive cells found by drilling\n cout << \"a \" << positive.size();\n for (auto &p : positive) {\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n cout.flush();\n\n int result;\n cin >> result;\n if (result == 1) {\n return 0;\n }\n\n // If failed, we might need to do more work, but for this example, we just exit\n // In a real solution, you would refine the strategy here\n\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main()\n{\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int W, D, N;\n if (!(cin >> W >> D >> N)) return 0;\n\n for (int d = 0; d < D; ++d) {\n // Read and discard a_d,k values\n for (int k = 0; k < N; ++k) {\n int temp;\n cin >> temp;\n }\n\n // Place each reservation in its own row\n for (int k = 0; k < N; ++k) {\n // Row k starts at k and ends at k+1\n cout << k << \" 0 \" << k + 1 << \" \" << W << \"\\n\";\n }\n }\n \n return 0;\n}","ahc032":"#include \nusing namespace std;\n\nconst int MOD = 998244353;\n\nstruct Operation {\n int m, p, q;\n};\n\n// Apply stamp operation to the board\nvoid apply_operation(const Operation& op, vector>& board, const vector>>& stamps) {\n const auto& stamp = stamps[op.m];\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int x = op.p + i;\n int y = op.q + j;\n board[x][y] = (board[x][y] + stamp[i][j]) % MOD;\n }\n }\n}\n\n// Greedy selection with dynamic stamp efficiency tracking\nvector greedy_selector(\n const vector>& initial_board,\n const vector>>& stamps,\n int K,\n vector& stamp_efficiency //tracks efficiency per stamp \n) {\n int N = initial_board.size();\n vector> board = initial_board;\n vector result;\n\n for (int step = 0; step < K && result.size() < K; ++step) {\n int best_improve = -1;\n Operation best_op{};\n\n for (int m = 0; m < (int)stamps.size(); ++m) {\n const auto& stamp = stamps[m];\n for (int p = 0; p <= N - 3; ++p) {\n for (int q = 0; q <= N - 3; ++q) {\n int improve = 0;\n // Evaluate improvement using true board deltas\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int curr = board[p + i][q + j];\n int updated_val = (curr + stamp[i][j]) % MOD;\n improve += (updated_val - curr + MOD) % MOD;\n }\n }\n // Consider stamp efficiency weighted impact\n if (improve > best_improve) {\n best_improve = improve;\n best_op = {m, p, q};\n }\n }\n }\n }\n\n // Permit greedy moves if improvement seen\n if (best_improve > 0) {\n apply_operation(best_op, board, stamps);\n result.push_back(best_op);\n \n // Update dynamic stamp efficiency\n stamp_efficiency[best_op.m] += best_improve;\n } else {\n // If greedy improvements exhausted, break early\n break;\n }\n }\n\n return result;\n}\n\n// Simulated annealing with slower temperature decay and adaptive acceptance\nvector simulated_annealing_pass(\n vector> board,\n const vector>>& stamps,\n int remaining_ops,\n double initial_temp // starting temperature \n) {\n vector result;\n double temp = initial_temp;\n const double decay = 0.98; // slower temperature cooling\n\n while (remaining_ops-- && temp > 1e-4) {\n // Randomly choose stamp and position\n int m = rand() % stamps.size();\n int p = rand() % (board.size() - 2);\n int q = rand() % (board[0].size() - 2);\n\n // Measure delta of applying this operation\n int delta = 0;\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int x = p + i;\n int y = q + j;\n delta += (stamps[m][i][j] + board[x][y]) % MOD - board[x][y];\n }\n }\n\n // Acceptance Probability: softmax-inspired for balanced improvement probability\n double acceptance_prob = exp(delta / temp) / (1.0 + exp(delta / temp));\n\n if (delta > 0 || (rand() / static_cast(RAND_MAX)) < acceptance_prob) {\n apply_operation({m, p, q}, board, stamps);\n result.push_back({m, p, q});\n }\n\n // slow cooling \n temp *= decay;\n }\n\n return result;\n}\n\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Reading input\n int N, M, K;\n cin >> N >> M >> K;\n\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 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 // Dynamic stamp efficiency tracking for greedy session\n vector stamp_efficiency(M, 0.0);\n\n // Step 1: Greedy selection (70% of the steps approx.)\n auto greedy_ops = greedy_selector(board, stamps, K * 7 / 10, stamp_efficiency);\n\n // Step 2: Extended Simulated Annealing Pass (with slower cooling) for remaining ops.\n auto simulated_ops = simulated_annealing_pass(board, stamps, K - greedy_ops.size(), 80.0);\n\n // Combine both phases, ensuring no overflow beyond K\n vector total_ops;\n total_ops.insert(total_ops.end(), greedy_ops.begin(), greedy_ops.end());\n total_ops.insert(total_ops.end(), simulated_ops.begin(), simulated_ops.end());\n if ((int)total_ops.size() > K) {\n total_ops.resize(K);\n }\n\n // Output final solution\n cout << total_ops.size() << '\\n';\n for (const Operation& op : total_ops) {\n cout << op.m << ' ' << op.p << ' ' << op.q << '\\n';\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\n\nstruct Crane {\n int x, y;\n bool holding;\n int id;\n};\n\nint N;\nvector> A;\nvector cranes;\nvector> grid;\nvector> occupied;\nvector actions;\n\nvector> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\nchar dir_char[4] = {'R', 'D', 'L', 'U'};\n\nbool is_valid(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nvoid place_container(int x, int y, int cont) {\n grid[x][y] = cont;\n occupied[x][y] = true;\n}\n\nvoid pickup(Crane& crane, int cont) {\n crane.holding = cont;\n occupied[crane.x][crane.y] = false;\n grid[crane.x][crane.y] = -1;\n}\n\nvoid release(Crane& crane, int x, int y) {\n grid[x][y] = crane.holding;\n occupied[x][y] = true;\n crane.holding = -1;\n}\n\nbool move_crane(Crane& crane, int dx, int dy) {\n int nx = crane.x + dx, ny = crane.y + dy;\n if (!is_valid(nx, ny)) return false;\n if (crane.holding != -1 && occupied[nx][ny]) return false;\n if (crane.holding == -1 && grid[nx][ny] != -1 && nx == N - 1 && ny == N - 1) return false;\n if (occupied[nx][ny] && crane.holding == -1) {\n if (grid[nx][ny] != -1) return false;\n }\n occupied[crane.x][crane.y] = false;\n crane.x = nx;\n crane.y = ny;\n occupied[crane.x][crane.y] = true;\n return true;\n}\n\nvoid simulate_turn(vector& moves) {\n for (int i = 0; i < N; ++i) {\n if (A[i][0] != -1 && !occupied[i][0] && cranes[i].holding == -1) {\n place_container(i, 0, A[i][0]);\n A[i][0] = A[i][1];\n for (int j = 1; j < N; ++j) A[i][j] = A[i][j + 1];\n A[i][N - 1] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n Crane& crane = cranes[i];\n char move = moves[i][actions.size()];\n if (move == 'P') {\n if (crane.holding != -1 || grid[crane.x][crane.y] == -1) continue;\n pickup(crane, grid[crane.x][crane.y]);\n } else if (move == 'Q') {\n if (crane.holding == -1 || occupied[crane.x][crane.y]) continue;\n release(crane, crane.x, crane.y);\n } else if (move == 'B') {\n if (crane.holding != -1) continue;\n crane.holding = -2;\n } else {\n int dx = 0, dy = 0;\n switch (move) {\n case 'U': dx = -1; break;\n case 'D': dx = 1; break;\n case 'L': dy = -1; break;\n case 'R': dy = 1; break;\n default: break;\n }\n if (dx != 0 || dy != 0) {\n move_crane(crane, dx, dy);\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1 && grid[N - 1][N - 1] != -1 && cranes[i].holding == -1) {\n int cont = grid[N - 1][N - 1];\n occupied[N - 1][N - 1] = false;\n grid[N - 1][N - 1] = -1;\n }\n }\n}\n\nvector solve() {\n actions.resize(N);\n fill(grid.begin(), grid.end(), vector(N, -1));\n fill(occupied.begin(), occupied.end(), vector(N, false));\n cranes.resize(N);\n for (int i = 0; i < N; ++i) {\n cranes[i] = {i, 0, false, -1, i};\n actions[i].clear();\n }\n\n vector target;\n for (int i = 0; i < N * N; ++i) target.push_back(i);\n vector dispatch_order;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dispatch_order.push_back(i * N + j);\n\n int steps = 0;\n while (steps < 10000) {\n vector moves(N, string(1, '.'));\n bool progress = false;\n\n for (int i = 0; i < N; ++i) {\n if (cranes[i].holding != -1) continue;\n if (cranes[i].x == N - 1 && cranes[i].y == N - 1) continue;\n int target_x = N - 1, target_y = N - 1;\n vector> path;\n int dx = 0, dy = 0;\n\n if (grid[cranes[i].x][cranes[i].y] != -1) {\n moves[i][steps] = 'P';\n progress = true;\n continue;\n }\n\n if (cranes[i].x == target_x && cranes[i].y == target_y) {\n continue;\n }\n\n int nx = cranes[i].x, ny = cranes[i].y;\n while (nx != target_x || ny != target_y) {\n int best = -1;\n for (int d = 0; d < 4; ++d) {\n int nx2 = nx + directions[d].first;\n int ny2 = ny + directions[d].second;\n if (!is_valid(nx2, ny2)) continue;\n if (occupied[nx2][ny2] && grid[nx2][ny2] != -1) continue;\n if (d == 0 && ny == N - 1) continue;\n if (d == 1 && nx == N - 1) continue;\n if (d == 2 && ny == 0) continue;\n if (d == 3 && nx == 0) continue;\n best = d;\n break;\n }\n if (best == -1) break;\n path.emplace_back(nx, ny);\n nx += directions[best].first;\n ny += directions[best].second;\n }\n if (!path.empty()) {\n moves[i][steps] = dir_char[directions[best].first == 1 ? 1 :\n directions[best].second == 1 ? 0 :\n directions[best].first == -1 ? 3 : 2];\n progress = true;\n }\n }\n\n vector current_moves = moves;\n simulate_turn(current_moves);\n for (int i = 0; i < N; ++i)\n actions[i].push_back(current_moves[i].back());\n\n if (!progress) break;\n steps++;\n }\n\n return actions;\n}\n\nint main() {\n cin >> N;\n A = vector>(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 grid = vector>(N, vector(N, -1));\n occupied = vector>(N, vector(N, false));\n\n auto result = solve();\n for (const auto& s : result)\n cout << s << '\\n';\n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Cell {\n int i, j, val;\n Cell(int i_, int j_, int val_) : i(i_), j(j_), val(val_) {}\n // Max-heap based on abs value of the cell \n bool operator<(const Cell& other) const {\n return abs(val) < abs(other.val);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector> h(N, vector(N));\n\n // Priority queue for max extraction by absolute height\n priority_queue max_heap;\n // Use single-key hash for fast presence checks: key=k*i + j\n unordered_map present;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> h[i][j];\n if (h[i][j] != 0) {\n max_heap.emplace(i, j, h[i][j]);\n present[i * N + j] = true;\n }\n }\n }\n\n const vector dirs = {\"D\", \"U\", \"R\", \"L\"};\n const vector> deltas = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};\n\n vector output;\n int cur_i = 0, cur_j = 0, cur_load = 0;\n\n // ------------- Optimized Move Generation Helper -------------\n auto generate_moves = [&](int di_needed, int dj_needed) {\n // Vertical movement\n if (di_needed > 0) {\n for (int m = 0; m < di_needed; ++m) output.push_back(\"D\");\n } else if (di_needed < 0) {\n for (int m = 0; m < -di_needed; ++m) output.push_back(\"U\");\n }\n // Horizontal movement\n if (dj_needed > 0) {\n for (int m = 0; m < dj_needed; ++m) output.push_back(\"R\");\n } else if (dj_needed < 0) {\n for (int m = 0; m < -dj_needed; ++m) output.push_back(\"L\");\n }\n };\n\n while (!max_heap.empty()) {\n Cell top = max_heap.top(); max_heap.pop();\n int ti = top.i, tj = top.j, target_val = top.val;\n\n if (!present[ti * N + tj]) continue; // Skip if already handled\n\n // --- Generate moves to target cell ---\n generate_moves(ti - cur_i, tj - cur_j);\n cur_i = ti; cur_j = tj;\n\n // --- Determine load/unload action ---\n if (target_val > 0 && cur_load < 1000000) {\n int load = min(target_val, 1000000 - cur_load);\n output.push_back(\"+\" + to_string(load));\n cur_load += load;\n h[ti][tj] -= load;\n } else if (target_val < 0 && cur_load > 0) {\n int unload = min(-target_val, cur_load);\n output.push_back(\"-\" + to_string(unload));\n cur_load -= unload;\n h[ti][tj] += unload;\n } else {\n continue;\n }\n\n // Update presence and possibly re-insert cell\n if (h[ti][tj] == 0) {\n present.erase(ti * N + tj);\n } else {\n max_heap.emplace(ti, tj, h[ti][tj]);\n }\n }\n\n // ------------- Flush batched output all at once -------------\n for (const auto& cmd : output) {\n cout << cmd << '\\n';\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, T;\n cin >> N >> M >> T;\n\n int seed_count = 2 * N * (N - 1);\n vector> seeds(seed_count, vector(M));\n vector max_criteria(M, 0);\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n if (seeds[i][j] > max_criteria[j]) {\n max_criteria[j] = seeds[i][j];\n }\n }\n }\n\n vector total_values(seed_count);\n for (int i = 0; i < seed_count; ++i) {\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n\n mt19937 rng(123);\n uniform_real_distribution dist(0.0, 1.0);\n\n // Store historical maximums, sums, variances, and moments for adaptive weight adjustment\n vector historical_max_criteria(M, 0);\n vector historical_sum_criteria(M, 0);\n vector historical_sum_sq_criteria(M, 0);\n vector historical_sum_cu_criteria(M, 0);\n vector historical_sum_qu_criteria(M, 0);\n int historical_count = 0;\n\n for (int turn = 0; turn < T; ++turn) {\n vector> grid(N, vector(N));\n vector used(seed_count, false);\n\n // Dynamic weight adjustment based on max criteria, historical sums, variances, and moments with refined scaling\n vector criterion_weights(M, 1.0);\n for (int j = 0; j < M; ++j) {\n if (max_criteria[j] > historical_max_criteria[j]) {\n historical_max_criteria[j] = max_criteria[j];\n }\n historical_sum_criteria[j] += max_criteria[j];\n historical_sum_sq_criteria[j] += static_cast(max_criteria[j]) * max_criteria[j];\n historical_sum_cu_criteria[j] += static_cast(max_criteria[j]) * max_criteria[j] * max_criteria[j];\n historical_sum_qu_criteria[j] += static_cast(max_criteria[j]) * max_criteria[j] * max_criteria[j] * max_criteria[j];\n historical_count++;\n\n if (historical_max_criteria[j] > 0) {\n double avg_value = static_cast(historical_sum_criteria[j]) / historical_count;\n double variance = static_cast(historical_sum_sq_criteria[j]) / historical_count - avg_value * avg_value;\n double std_dev = sqrt(variance);\n\n // Calculate skewness and kurtosis\n double skewness = (static_cast(historical_sum_cu_criteria[j]) / historical_count - 3 * avg_value * std_dev * std_dev - avg_value * avg_value) / (std_dev * std_dev * std_dev);\n double kurtosis = (static_cast(historical_sum_qu_criteria[j]) / historical_count - 4 * avg_value * std_dev * std_dev * std_dev - 6 * avg_value * avg_value * std_dev * std_dev - avg_value * avg_value * avg_value) / (std_dev * std_dev * std_dev * std_dev) - 3;\n\n // Use a refined scaling that considers skewness and kurtosis\n criterion_weights[j] = 1.0 + (historical_max_criteria[j] - max_criteria[j]) / (std_dev * (1 + abs(skewness)) + 1e-9);\n }\n }\n\n // More aggressive adaptive exploration rate with performance-based adjustment\n double exploration_rate = 0.05 * pow(0.9, turn * 1.5);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int best_index = -1;\n double best_score = -1e9;\n\n if (dist(rng) < exploration_rate) {\n vector candidates;\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k]) {\n candidates.push_back(k);\n }\n }\n if (!candidates.empty()) {\n best_index = candidates[rand() % candidates.size()];\n }\n } else {\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k]) {\n double score = 0.0;\n for (int l = 0; l < M; ++l) {\n score += seeds[k][l] * criterion_weights[l];\n }\n if (score > best_score) {\n best_score = score;\n best_index = k;\n }\n }\n }\n }\n\n // Fallback mechanism to ensure a valid seed is always selected\n if (best_index == -1) {\n for (int k = 0; k < seed_count; ++k) {\n if (!used[k]) {\n best_index = k;\n break;\n }\n }\n }\n\n grid[i][j] = best_index;\n used[best_index] = true;\n\n // Update max_criteria for next turn\n for (int l = 0; l < M; ++l) {\n if (seeds[best_index][l] > max_criteria[l]) {\n max_criteria[l] = seeds[best_index][l];\n }\n }\n }\n }\n\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) cout << \" \";\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n // Reset max_criteria for the next turn\n fill(max_criteria.begin(), max_criteria.end(), 0);\n\n for (int i = 0; i < seed_count; ++i) {\n for (int j = 0; j < M; ++j) {\n cin >> seeds[i][j];\n if (seeds[i][j] > max_criteria[j]) {\n max_criteria[j] = seeds[i][j];\n }\n }\n total_values[i] = accumulate(seeds[i].begin(), seeds[i].end(), 0);\n }\n }\n\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, M, V;\n cin >> N >> M >> V;\n vector s(N), t(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n vector> sources, targets;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j) {\n if (s[i][j] == '1') sources.emplace_back(i, j);\n if (t[i][j] == '1') targets.emplace_back(i, j);\n }\n \n // Design tree: linear chain of length min(V, something reasonable)\n int Vp = min(V, 2); // Use just 2 vertices: root and one fingertip\n cout << Vp << \"\\n\";\n if (Vp > 1) cout << \"0 1\\n\";\n \n // Initial position of root\n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n // Precompute directions: assume fingertip is to the right of root\n // We'll move around and rotate as needed\n \n // Simple strategy: move to each source, grab, move to target, release\n // We'll simulate positions and orientations\n \n struct Pos { int x, y; };\n struct State {\n Pos root;\n int dir; // direction of edge from root to child: 0=R,1=D,2=L,3=U\n vector fingertips; // positions of fingertips relative to root\n };\n \n State st;\n st.root = {0, 0};\n st.dir = 0; // right\n if (Vp >= 2) {\n st.fingertips.push_back({st.root.x + 1, st.root.y}); // child at (1,0)\n }\n \n // Precompute all moves\n vector moves;\n \n for (int i = 0; i < M; ++i) {\n // Move to source i\n auto [sx, sy] = sources[i];\n // First, move root close to source\n int dx = sx - st.root.x;\n int dy = sy - st.root.y;\n // Move root to (sx, st.root.y) then adjust y\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\"; // no rotate\n op += \".\\n\"; // no action for fingertip\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Now root is at (sx, st.root.y), need to align fingertip to (sx, sy)\n dx = sy - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dx > 0) ? 1 : -1;\n st.fingertips[0].y += (dx > 0) ? 1 : -1;\n }\n \n // Rotate to make fingertip point to the source\n // Currently fingertip is at (root.x+1, root.y) if dir=0\n // We want it to point to (sx, sy). Since we are already at (sx, sy) for root, just grab\n // Grab\n string op;\n op += \".\\n\"; // no move\n op += \".\\n\"; // no rotate\n op += \"P\\n\"; // grab\n moves.push_back(op);\n \n // Move to target i\n auto [tx, ty] = targets[i];\n dx = tx - st.root.x;\n dy = ty - st.root.y;\n for (int step = 0; step < abs(dx); ++step) {\n char mv = (dx > 0) ? 'D' : 'U';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.x += (dx > 0) ? 1 : -1;\n st.fingertips[0].x += (dx > 0) ? 1 : -1;\n }\n for (int step = 0; step < abs(dy); ++step) {\n char mv = (dy > 0) ? 'R' : 'L';\n string op = string(1, mv) + \".\\n\";\n op += \".\\n\";\n moves.push_back(op);\n st.root.y += (dy > 0) ? 1 : -1;\n st.fingertips[0].y += (dy > 0) ? 1 : -1;\n }\n \n // Release\n op = \".\\n.\\nP\\n\";\n moves.push_back(op);\n }\n \n // Output moves\n for (const auto& mv : moves) {\n cout << mv;\n }\n \n return 0;\n}","ahc039":"#include \n#include \nusing namespace std;\n\n// Function to compute the score for a given rectangle\nint compute_score(const vector>& points, const vector>& sardines,\n int min_x, int min_y, int max_x, int max_y, bool is_mackerel) {\n int count = 0;\n auto points_list = is_mackerel ? points : sardines;\n for (const auto& p : points_list) {\n if (p.first >= min_x && p.first <= max_x && p.second >= min_y && p.second <= max_y) {\n count++;\n }\n }\n return count;\n}\n\n// Function to perform a weighted expansion based on density\ntuple weighted_expand(int min_x, int min_y, int max_x, int max_y,\n const vector>& mackerels, const vector>& sardines) {\n const int STEP = 1;\n int best_score = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y, true) - compute_score(mackerels, sardines, min_x, min_y, max_x, max_y, false);\n int best_min_x = min_x, best_min_y = min_y, best_max_x = max_x, best_max_y = max_y;\n\n // Define directions for potential shifts\n vector> directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; // right, left, down, up\n\n for (int iter = 0; iter < 100; ++iter) {\n int max_improvement = 0;\n pair best_dir = {0, 0};\n\n for (const auto& dir : directions) {\n int dx = dir.first, dy = dir.second;\n int new_min_x = min_x + dx * STEP;\n int new_min_y = min_y + dy * STEP;\n int new_max_x = max_x + dx * STEP;\n int new_max_y = max_y + dy * STEP;\n\n if (new_min_x < 0) new_min_x = 0;\n if (new_min_y < 0) new_min_y = 0;\n if (new_max_x > 100000) new_max_x = 100000;\n if (new_max_y > 100000) new_max_y = 100000;\n\n int score = compute_score(mackerels, sardines, new_min_x, new_min_y, new_max_x, new_max_y, true) - \n compute_score(mackerels, sardines, new_min_x, new_min_y, new_max_x, new_max_y, false);\n int improvement = score - best_score;\n if (improvement > max_improvement) {\n max_improvement = improvement;\n best_dir = dir;\n }\n }\n\n if (max_improvement > 0) {\n min_x += best_dir.first * STEP;\n min_y += best_dir.second * STEP;\n max_x += best_dir.first * STEP;\n max_y += best_dir.second * STEP;\n best_score = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y, true) - \n compute_score(mackerels, sardines, min_x, min_y, max_x, max_y, false);\n } else {\n break;\n }\n }\n\n return make_tuple(min_x, min_y, max_x, max_y);\n}\n\n// Function to run the algorithm with a given grid size\npair>> run_algorithm(const vector>& mackerels, const vector>& sardines, int grid_size, int cell_size) {\n vector> grid_score(grid_size, vector(grid_size, 0));\n\n for (const auto& p : mackerels) {\n int gx = p.first / cell_size;\n int gy = p.second / cell_size;\n if (gx >= 0 && gx < grid_size && gy >= 0 && gy < grid_size) {\n grid_score[gx][gy]++;\n }\n }\n\n for (const auto& p : sardines) {\n int gx = p.first / cell_size;\n int gy = p.second / cell_size;\n if (gx >= 0 && gx < grid_size && gy >= 0 && gy < grid_size) {\n grid_score[gx][gy]--;\n }\n }\n\n // Find the best cells\n vector> best_cells;\n for (int x = 0; x < grid_size; ++x) {\n for (int y = 0; y < grid_size; ++y) {\n if (grid_score[x][y] > 0) {\n best_cells.emplace_back(x, y);\n }\n }\n }\n\n // Select the best rectangle from the best cells\n int best_min_x = 0, best_min_y = 0, best_max_x = 0, best_max_y = 0;\n int best_score = -1e9;\n for (const auto& cell : best_cells) {\n int min_x = cell.first * cell_size;\n int min_y = cell.second * cell_size;\n int max_x = (cell.first + 1) * cell_size - 1;\n int max_y = (cell.second + 1) * cell_size - 1;\n int score = compute_score(mackerels, sardines, min_x, min_y, max_x, max_y, true) - \n compute_score(mackerels, sardines, min_x, min_y, max_x, max_y, false);\n if (score > best_score) {\n best_score = score;\n best_min_x = min_x;\n best_min_y = min_y;\n best_max_x = max_x;\n best_max_y = max_y;\n }\n }\n\n // If no positive-scoring cells, fallback to the best single cell\n if (best_score == -1e9) {\n int best_gx = 0, best_gy = 0;\n best_score = grid_score[0][0];\n for (int x = 0; x < grid_size; ++x) {\n for (int y = 0; y < grid_size; ++y) {\n if (grid_score[x][y] > best_score) {\n best_score = grid_score[x][y];\n best_gx = x;\n best_gy = y;\n }\n }\n }\n best_min_x = best_gx * cell_size;\n best_min_y = best_gy * cell_size;\n best_max_x = (best_gx + 1) * cell_size - 1;\n best_max_y = (best_gy + 1) * cell_size - 1;\n }\n\n // Weighted expansion based on density\n tie(best_min_x, best_min_y, best_max_x, best_max_y) = weighted_expand(best_min_x, best_min_y, best_max_x, best_max_y, mackerels, sardines);\n\n vector> polygon = {\n {best_min_x, best_min_y},\n {best_max_x, best_min_y},\n {best_max_x, best_max_y},\n {best_min_x, best_max_y}\n };\n\n return {best_score, polygon};\n}\n\n// Function to generate random grid sizes and cell sizes\nvector> generate_random_grid_sizes(int seed, int num_samples) {\n mt19937 rng(seed);\n uniform_int_distribution<> grid_dist(40, 70);\n uniform_int_distribution<> cell_dist(1500, 2000);\n vector> samples;\n for (int i = 0; i < num_samples; ++i) {\n int grid_size = grid_dist(rng);\n int cell_size = cell_dist(rng);\n samples.emplace_back(grid_size, cell_size);\n }\n return samples;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N;\n cin >> N;\n vector> mackerels(N), sardines(N);\n for (int i = 0; i < N; ++i) {\n cin >> mackerels[i].first >> mackerels[i].second;\n }\n for (int i = 0; i < N; ++i) {\n cin >> sardines[i].first >> sardines[i].second;\n }\n\n // Generate random grid sizes and cell sizes\n const int NUM_RANDOM_SAMPLES = 10;\n auto random_samples = generate_random_grid_sizes(123, NUM_RANDOM_SAMPLES);\n\n int best_overall_score = -1e9;\n vector> best_polygon;\n\n // Run the algorithm with different grid sizes and select the best result\n for (const auto& [grid_size, cell_size] : random_samples) {\n auto [score, polygon] = run_algorithm(mackerels, sardines, grid_size, cell_size);\n if (score > best_overall_score) {\n best_overall_score = score;\n best_polygon = polygon;\n }\n }\n\n // Also run with fixed grid sizes as a fallback\n vector> fixed_grid_sizes = {{50, 2000}, {60, 1800}, {70, 1600}};\n for (const auto& [grid_size, cell_size] : fixed_grid_sizes) {\n auto [score, polygon] = run_algorithm(mackerels, sardines, grid_size, cell_size);\n if (score > best_overall_score) {\n best_overall_score = score;\n best_polygon = polygon;\n }\n }\n\n // Ensure the polygon is valid (at least 4 vertices and no self-intersection)\n cout << best_polygon.size() << \"\\n\";\n for (const auto& p : best_polygon) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc040":"#include \nusing namespace std;\n\nusing ll = long long;\nusing Point = pair;\nusing Rect = tuple; // x1, y1, x2, y2\n\nRect place_rect(const Rect& existing, const Rect& new_rect, char dir, int b_idx) {\n ll x1, y1, x2, y2;\n if (b_idx == -1) {\n if (dir == 'U') {\n x1 = get<0>(new_rect);\n y1 = get<1>(new_rect);\n x2 = get<2>(new_rect);\n y2 = get<3>(new_rect);\n } else {\n x1 = get<0>(new_rect);\n y1 = get<1>(new_rect);\n x2 = get<2>(new_rect);\n y2 = get<3>(new_rect);\n }\n } else {\n ll ex2 = get<2>(existing);\n ll ey2 = get<3>(existing);\n if (dir == 'U') {\n x1 = get<0>(new_rect);\n y1 = ey2;\n x2 = get<2>(new_rect);\n y2 = ey2 + get<3>(new_rect);\n } else {\n x1 = ex2;\n y1 = get<1>(new_rect);\n x2 = ex2 + get<2>(new_rect);\n y2 = get<3>(new_rect);\n }\n }\n return make_tuple(x1, y1, x2, y2);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n \n int N, T;\n double sigma;\n if (!(cin >> N >> T >> sigma)) return 0;\n vector> wh(N);\n for (int i = 0; i < N; ++i) {\n cin >> wh[i].first >> wh[i].second;\n }\n \n // Simulate true dimensions based on observed values and sigma\n default_random_engine gen;\n normal_distribution dist(0.0, sigma);\n vector> true_wh(N);\n for (int i = 0; i < N; ++i) {\n double dw = dist(gen);\n double dh = dist(gen);\n true_wh[i].first = max(1, static_cast(round(wh[i].first + dw)));\n true_wh[i].second = max(1, static_cast(round(wh[i].second + dh)));\n }\n \n vector> placements;\n \n for (int t = 0; t < T; ++t) {\n vector> placement;\n vector placed_rects;\n \n // Place the first rectangle at origin without rotation\n placement.emplace_back(0, 0, 'U', -1);\n placed_rects.emplace_back(\n 0, 0,\n static_cast(true_wh[0].first),\n static_cast(true_wh[0].second)\n );\n \n // Place subsequent rectangles\n for (int i = 1; i < N; ++i) {\n int best_idx = i;\n int best_rot = 0;\n char best_dir = 'U';\n int best_b = -1;\n ll best_width = 0, best_height = 0;\n \n for (int rot : {0, 1}) {\n ll w, h;\n if (rot == 0) {\n w = true_wh[i].first;\n h = true_wh[i].second;\n } else {\n w = true_wh[i].second;\n h = true_wh[i].first;\n }\n \n Rect new_rect = make_tuple(0, 0, static_cast(w), static_cast(h));\n \n for (char dir : {'U', 'L'}) {\n for (size_t b_idx = 0; b_idx <= placed_rects.size(); ++b_idx) {\n int idx = -1;\n if (b_idx != placed_rects.size()) idx = b_idx;\n Rect placed = place_rect(\n b_idx < placed_rects.size() ? placed_rects[b_idx] : make_tuple(0LL, 0LL, 0LL, 0LL),\n new_rect, dir, idx\n );\n ll width = get<2>(placed) - get<0>(placed);\n ll height = get<3>(placed) - get<1>(placed);\n if (width + height < best_width + best_height) {\n best_width = width;\n best_height = height;\n best_idx = i;\n best_rot = rot;\n best_dir = dir;\n best_b = idx;\n }\n }\n }\n }\n \n placement.emplace_back(best_idx, best_rot, best_dir, best_b);\n Rect new_rect = make_tuple(0, 0, static_cast(true_wh[best_idx].first), static_cast(true_wh[best_idx].second));\n if (best_rot) {\n swap(get<2>(new_rect), get<3>(new_rect));\n }\n Rect placed = place_rect(\n best_b >= 0 ? placed_rects[best_b] : make_tuple(0LL, 0LL, 0LL, 0LL),\n new_rect, best_dir, best_b\n );\n placed_rects.push_back(placed);\n }\n \n cout << placement.size() << \"\\n\";\n for (const auto& p : placement) {\n cout << get<0>(p) << \" \" << get<1>(p) << \" \" << get<2>(p) << \" \" << get<3>(p) << \"\\n\";\n }\n cout.flush();\n \n ll W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n \n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, H;\n if (!(cin >> N >> M >> H)) return 0;\n vector A(N);\n for (int i = 0; i < N; ++i) {\n cin >> A[i];\n }\n vector> edges(M);\n vector> adj(N);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n edges[i] = {u, v};\n adj[u].insert(v);\n adj[v].insert(u);\n }\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n vector parent(N, -1);\n vector used(N, false);\n\n // Iterate over nodes sorted by beauty in descending order\n vector indices(N);\n iota(indices.begin(), indices.end(), 0);\n sort(indices.begin(), indices.end(),\n [&](int a, int b) { return A[a] > A[b]; });\n\n for (int i : indices) {\n if (used[i]) continue;\n used[i] = true;\n parent[i] = -1;\n // Try to build a tree of height <= H rooted at i\n queue> q; // (node, height)\n q.emplace(i, 0);\n while (!q.empty()) {\n auto [u, depth] = q.front(); q.pop();\n if (depth >= H) continue;\n for (int v : adj[u]) {\n if (!used[v]) {\n used[v] = true;\n parent[v] = u;\n q.emplace(v, depth + 1);\n }\n }\n }\n }\n\n // Output\n for (int i = 0; i < N; ++i) {\n if (i) cout << ' ';\n cout << parent[i];\n }\n cout << '\\n';\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nstruct Move {\n char dir;\n int pos;\n};\n\nint main() {\n int N = 20;\n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n\n vector moves;\n\n auto add_moves = [&](int i, int j, bool is_row, bool left_or_up) {\n if (is_row) {\n if (left_or_up) {\n for (int k = 0; k <= j; ++k) {\n moves.push_back({'L', i});\n }\n } else {\n for (int k = 0; k <= N - 1 - j; ++k) {\n moves.push_back({'R', i});\n }\n }\n } else {\n if (left_or_up) {\n for (int k = 0; k <= i; ++k) {\n moves.push_back({'U', j});\n }\n } else {\n for (int k = 0; k <= N - 1 - i; ++k) {\n moves.push_back({'D', j});\n }\n }\n }\n };\n\n vector> removed(N, vector(N, false));\n vector> oni_positions;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') {\n oni_positions.emplace_back(i, j);\n }\n }\n }\n\n auto prioritize_oni = [&](const pair& a, const pair& b, const vector& board) {\n int dist_a = a.first + a.second;\n int dist_b = b.first + b.second;\n int fuku_a = 0, fuku_b = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'o') {\n if (i == a.first || j == a.second) fuku_a++;\n if (i == b.first || j == b.second) fuku_b++;\n }\n }\n }\n // Prioritize Oni closer to the center and with fewer Fukunokami nearby\n int center_dist_a = abs(N / 2 - a.first) + abs(N / 2 - a.second);\n int center_dist_b = abs(N / 2 - b.first) + abs(N / 2 - b.second);\n return make_pair(center_dist_a, -fuku_a) < make_pair(center_dist_b, -fuku_b);\n };\n\n sort(oni_positions.begin(), oni_positions.end(), [&](const pair& a, const pair& b) {\n return prioritize_oni(a, b, board);\n });\n\n for (const auto& [i, j] : oni_positions) {\n if (removed[i][j]) continue;\n\n bool can_left = true, can_right = true, can_up = true, can_down = true;\n for (int dj = 0; dj < j; ++dj) {\n if (board[i][dj] == 'o') {\n can_right = false;\n break;\n }\n }\n for (int dj = j + 1; dj < N; ++dj) {\n if (board[i][dj] == 'o') {\n can_left = false;\n break;\n }\n }\n for (int di = 0; di < i; ++di) {\n if (board[di][j] == 'o') {\n can_down = false;\n break;\n }\n }\n for (int di = i + 1; di < N; ++di) {\n if (board[di][j] == 'o') {\n can_up = false;\n break;\n }\n }\n\n if (can_left) {\n add_moves(i, j, true, true);\n removed[i][j] = true;\n } else if (can_right) {\n add_moves(i, j, true, false);\n removed[i][j] = true;\n } else if (can_up) {\n add_moves(i, j, false, true);\n removed[i][j] = true;\n } else if (can_down) {\n add_moves(i, j, false, false);\n removed[i][j] = true;\n }\n }\n\n for (const auto& mv : moves) {\n cout << mv.dir << \" \" << mv.pos << endl;\n }\n\n return 0;\n}","ahc044":"#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\nvector t(N); // target times\nvector> assignments(N); // a_i, b_i for each employee\n\nvector simulate(const vector>& assign) {\n vector count(N, 0);\n int current = 0;\n int times = 0;\n count[0]++; // first week\n times = 1; // count for employee 0\n\n for (int week = 1; week < L; ++week) {\n if (times % 2 == 1) { // odd\n current = assign[current].first;\n } else { // even\n current = assign[current].second;\n }\n count[current]++;\n times++; // increment the count for previous employee\n }\n return count;\n}\n\nlong long calculate_error(const vector& actual) {\n long long error = 0;\n for (int i = 0; i < N; ++i) {\n error += abs(actual[i] - t[i]);\n }\n return error;\n}\n\n// Simulated Annealing with limited iterations\nvoid simulated_annealing(vector>& assign, long long& best_error, vector& best_count) {\n mt19937 rng(0); // fixed seed for reproducibility\n const int MAX_ITERATIONS = 50; // Reduced from previous value\n\n long long current_error = calculate_error(simulate(assign));\n vector current_count = simulate(assign);\n best_error = current_error;\n best_count = current_count;\n\n double temperature = 1000.0;\n const double cooling_rate = 0.995;\n\n for (int iter = 0; iter < MAX_ITERATIONS; ++iter) {\n // Choose two distinct employees\n int i = uniform_int_distribution(0, N-1)(rng);\n int j = uniform_int_distribution(0, N-1)(rng);\n while (j == i) {\n j = uniform_int_distribution(0, N-1)(rng);\n }\n\n // Save old assignments\n auto old_i = assign[i];\n auto old_j = assign[j];\n\n // Randomly change assignments for i and j\n int a_candidate = uniform_int_distribution(0, N-1)(rng);\n int b_candidate = uniform_int_distribution(0, N-1)(rng);\n assign[i] = {a_candidate, b_candidate};\n\n a_candidate = uniform_int_distribution(0, N-1)(rng);\n b_candidate = uniform_int_distribution(0, N-1)(rng);\n assign[j] = {a_candidate, b_candidate};\n\n // Simulate and compute new error\n vector new_count = simulate(assign);\n long long new_error = calculate_error(new_count);\n\n // Acceptance probability\n double ap = exp((current_error - new_error) / temperature);\n if (new_error < current_error || uniform_real_distribution(0, 1)(rng) < ap) {\n current_error = new_error;\n current_count = new_count;\n if (new_error < best_error) {\n best_error = new_error;\n best_count = new_count;\n }\n } else {\n // Revert changes\n assign[i] = old_i;\n assign[j] = old_j;\n }\n\n // Cool down\n temperature *= cooling_rate;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Read input\n int dummy_n, dummy_l;\n cin >> dummy_n >> dummy_l; // should be 100 and 500000\n for (int i = 0; i < N; ++i) {\n cin >> t[i];\n }\n\n // Initial assignment: cyclic pattern\n for (int i = 0; i < N; ++i) {\n assignments[i] = {(i + 1) % N, (i + 1) % N};\n }\n\n long long best_error;\n vector best_count;\n simulated_annealing(assignments, best_error, best_count);\n\n // Output the assignments\n for (const auto& p : assignments) {\n cout << p.first << ' ' << p.second << '\\n';\n }\n\n return 0;\n}","ahc045":"#include \n#include \nusing namespace std;\n\n#define OVERRIDE 0\n\nstruct City {\n int id;\n int lx, rx, ly, ry;\n double cx, cy;\n};\n\n// Simple DBSCAN-like clustering based on center coordinates\nvector> clusterCities(const vector& cities, double eps = 200.0, int min_pts = 1) {\n int n = cities.size();\n vector visited(n, false);\n vector> clusters;\n\n for (int i = 0; i < n; ++i) {\n if (visited[i]) continue;\n visited[i] = true;\n queue q;\n q.push(i);\n vector cluster;\n\n cluster.push_back(i);\n\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int nxt = 0; nxt < n; ++nxt) {\n if (visited[nxt]) continue;\n double dx = cities[cur].cx - cities[nxt].cx;\n double dy = cities[cur].cy - cities[nxt].cy;\n double dist = sqrt(dx*dx + dy*dy);\n if (dist <= eps) {\n visited[nxt] = true;\n q.push(nxt);\n cluster.push_back(nxt);\n }\n }\n }\n if (!cluster.empty()) {\n clusters.push_back(cluster);\n }\n }\n return clusters;\n}\n\n// Divide a cluster into groups of sizes specified in G\nvector> assignGroups(const vector& cluster, const vector& G, const vector& cities) {\n vector> groups;\n int n = cluster.size();\n int group_idx = 0;\n int start = 0;\n\n for (int g : G) {\n vector group;\n int end = start + g;\n if (end > n) {\n end = n;\n }\n for (int i = start; i < end; ++i) {\n group.push_back(cluster[i]);\n }\n groups.push_back(group);\n start = end;\n }\n return groups;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n vector cities(N);\n for (int i = 0; i < N; ++i) {\n 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 // Cluster cities based on center coordinates\n vector> clusters = clusterCities(cities);\n\n // Assign cities to groups\n vector> groups;\n vector group_sizes = G;\n\n // Try to assign groups from clusters\n for (const auto& cluster : clusters) {\n vector> cluster_groups = assignGroups(cluster, group_sizes, cities);\n for (const auto& g : cluster_groups) {\n if (g.empty()) continue;\n groups.push_back(g);\n // Decrease the corresponding group size\n for (size_t i = 0; i < group_sizes.size(); ++i) {\n if (group_sizes[i] >= (int)g.size()) {\n group_sizes[i] -= (int)g.size();\n break;\n }\n }\n }\n }\n\n // Handle remaining group sizes\n int remaining = N;\n for (const auto& g : groups) remaining -= g.size();\n if (remaining > 0) {\n // Add remaining cities to the last group\n if (!groups.empty()) {\n groups.back().resize(remaining + groups.back().size());\n } else {\n groups.push_back(vector(remaining));\n }\n }\n\n // Ensure we have exactly M groups\n while ((int)groups.size() < M) {\n groups.push_back({});\n }\n\n // Prepare queries for each group\n vector>> all_edges(M);\n\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n int sz = group.size();\n if (sz < 2) continue;\n\n // If group size is small enough, query the entire group\n if (sz <= L) {\n cout << \"? \" << sz;\n for (int id : group) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int i = 0; i < sz - 1; ++i) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n } else {\n // Break into subsets of size L\n for (int i = 0; i < sz; i += L - 1) {\n int subset_size = min(L, sz - i);\n if (subset_size < 2) break;\n\n vector subset;\n for (int j = i; j < i + subset_size; ++j) {\n subset.push_back(group[j]);\n }\n\n cout << \"? \" << subset_size;\n for (int id : subset) cout << \" \" << id;\n cout << endl;\n fflush(stdout);\n\n for (int j = 0; j < subset_size - 1; ++j) {\n int a, b;\n cin >> a >> b;\n all_edges[k].emplace_back(a, b);\n }\n }\n }\n }\n\n // Output the answer\n cout << \"!\" << endl;\n for (int k = 0; k < M; ++k) {\n const auto& group = groups[k];\n cout << group.size();\n for (int id : group) cout << \" \" << id;\n cout << endl;\n\n // Output edges for this group\n for (const auto& edge : all_edges[k]) {\n cout << edge.first << \" \" << edge.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint N, M;\nvector> targets;\nvector> grid; // true if block exists\npair current;\n\n// Directions: U, D, L, R\nconst int dx[] = {-1, 1, 0, 0};\nconst int dy[] = {0, 0, -1, 1};\nconst char dir[] = {'U', 'D', 'L', 'R'};\n\n// Function to check if a position is within grid bounds\nbool inBounds(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// BFS to find the shortest path to a target, considering both move and slide actions\nvector> bfs(const pair& start, const pair& target, const vector>& blocks) {\n queue> q;\n vector>> parent(N, vector>(N, {-2, -2}));\n vector> dist(N, vector(N, -1));\n\n q.push(start);\n dist[start.first][start.second] = 0;\n\n while (!q.empty()) {\n auto [x, y] = q.front(); q.pop();\n\n if (x == target.first && y == target.second) {\n vector> path;\n pair curr = {x, y};\n while (curr.first != -2 || curr.second != -2) {\n path.push_back(curr);\n int px = parent[curr.first][curr.second].first;\n int py = parent[curr.first][curr.second].second;\n curr = {px, py};\n }\n reverse(path.begin(), path.end());\n return path;\n }\n\n // Try move actions\n for (int d = 0; d < 4; ++d) {\n int nx = x + dx[d], ny = y + dy[d];\n if (inBounds(nx, ny) && !blocks[nx][ny] && dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n\n // Try slide actions\n for (int d = 0; d < 4; ++d) {\n int nx = x, ny = y;\n int steps = 0;\n while (true) {\n int next_x = nx + dx[d];\n int next_y = ny + dy[d];\n if (!inBounds(next_x, next_y) || blocks[next_x][next_y]) break;\n nx = next_x;\n ny = next_y;\n steps++;\n if (dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1; // Sliding counts as one action\n parent[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n }\n return {};\n}\n\n// Attempt to move to next target using an optimized strategy\nvector> moveToTarget(const pair& target) {\n vector> actions;\n vector> blocks = grid;\n\n // First, try sliding directly to the target if possible\n for (int d = 0; d < 4; ++d) {\n int nx = current.first, ny = current.second;\n bool canSlide = true;\n while (true) {\n int next_x = nx + dx[d];\n int next_y = ny + dy[d];\n if (!inBounds(next_x, next_y) || blocks[next_x][next_y]) {\n break;\n }\n nx = next_x;\n ny = next_y;\n if (nx == target.first && ny == target.second) {\n // Slide to target\n actions.emplace_back('S', string(1, dir[d]));\n current = {nx, ny};\n return actions;\n }\n }\n }\n\n // If sliding fails, use BFS to find an optimized path\n auto path = bfs(current, target, blocks);\n if (!path.empty()) {\n for (size_t i = 1; i < path.size(); ++i) {\n auto next = path[i];\n // Determine the direction from current to next\n int dx_move = next.first - current.first;\n int dy_move = next.second - current.second;\n\n if (dx_move > 0) {\n // Try sliding down as far as possible\n int slide_to = current.first;\n while (slide_to + 1 < N && !grid[slide_to + 1][current.second]) {\n slide_to++;\n }\n if (slide_to > current.first) {\n actions.emplace_back('S', \"D\");\n current.first = slide_to;\n } else {\n actions.emplace_back('M', \"D\");\n current.first += dx_move;\n }\n } else if (dx_move < 0) {\n int slide_to = current.first;\n while (slide_to - 1 >= 0 && !grid[slide_to - 1][current.second]) {\n slide_to--;\n }\n if (slide_to < current.first) {\n actions.emplace_back('S', \"U\");\n current.first = slide_to;\n } else {\n actions.emplace_back('M', \"U\");\n current.first += dx_move;\n }\n } else if (dy_move > 0) {\n int slide_to = current.second;\n while (slide_to + 1 < N && !grid[current.first][slide_to + 1]) {\n slide_to++;\n }\n if (slide_to > current.second) {\n actions.emplace_back('S', \"R\");\n current.second = slide_to;\n } else {\n actions.emplace_back('M', \"R\");\n current.second += dy_move;\n }\n } else if (dy_move < 0) {\n int slide_to = current.second;\n while (slide_to - 1 >= 0 && !grid[current.first][slide_to - 1]) {\n slide_to--;\n }\n if (slide_to < current.second) {\n actions.emplace_back('S', \"L\");\n current.second = slide_to;\n } else {\n actions.emplace_back('M', \"L\");\n current.second += dy_move;\n }\n }\n }\n return actions;\n }\n\n // If no path found, try altering blocks (same as before but with improved logic)\n for (int x = 0; x < N; ++x) {\n for (int y = 0; y < N; ++y) {\n if (!blocks[x][y]) {\n blocks[x][y] = true;\n actions.emplace_back('A', (x > current.first) ? \"D\" : (x < current.first) ? \"U\" : (y > current.second) ? \"R\" : \"L\");\n auto new_path = bfs(current, target, blocks);\n if (!new_path.empty()) {\n for (size_t i = 1; i < new_path.size(); ++i) {\n auto next = new_path[i];\n int dx_move = next.first - current.first;\n int dy_move = next.second - current.second;\n if (dx_move > 0) {\n actions.emplace_back('M', \"D\");\n } else if (dx_move < 0) {\n actions.emplace_back('M', \"U\");\n } else if (dy_move > 0) {\n actions.emplace_back('M', \"R\");\n } else if (dy_move < 0) {\n actions.emplace_back('M', \"L\");\n }\n current = next;\n }\n blocks[x][y] = false; // Remove the block after use\n actions.emplace_back('A', (x > current.first) ? \"D\" : (x < current.first) ? \"U\" : (y > current.second) ? \"R\" : \"L\");\n return actions;\n }\n blocks[x][y] = false;\n }\n }\n }\n\n return {}; // No viable path found\n}\n\nint main() {\n cin >> N >> M;\n targets.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> targets[i].first >> targets[i].second;\n }\n current = targets[0];\n grid = vector>(N, vector(N, false));\n\n vector> actions;\n\n for (int i = 1; i < M; ++i) {\n auto step_actions = moveToTarget(targets[i]);\n actions.insert(actions.end(), step_actions.begin(), step_actions.end());\n }\n\n // Output actions\n for (auto& [a, d] : actions) {\n cout << a << \" \" << d << endl;\n }\n\n return 0;\n}"}}}