{"model_name":"gemini-3.1-pro-preview-low","codes":{"1":{"ahc001":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst double TIME_LIMIT = 4.8; // Leave a small margin\n\nstruct Rect {\n int x1, y1, x2, y2;\n int px, py;\n long long r;\n \n long long area() const {\n return 1LL * (x2 - x1) * (y2 - y1);\n }\n \n double score() const {\n long long s = area();\n if (s == 0) return 0.0;\n double mn = min(r, s);\n double mx = max(r, s);\n double val = 1.0 - mn / mx;\n return 1.0 - val * val;\n }\n \n bool contains(int x, int y) const {\n return x >= x1 && x < x2 && y >= y1 && y < y2;\n }\n \n bool intersects(const Rect& o) const {\n return max(x1, o.x1) < min(x2, o.x2) && max(y1, o.y1) < min(y2, o.y2);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n int n;\n if (!(cin >> n)) return 0;\n \n vector rects(n);\n for (int i = 0; i < n; ++i) {\n cin >> rects[i].px >> rects[i].py >> rects[i].r;\n rects[i].x1 = rects[i].px;\n rects[i].y1 = rects[i].py;\n rects[i].x2 = rects[i].px + 1;\n rects[i].y2 = rects[i].py + 1;\n }\n \n mt19937 rng(42);\n \n auto get_time = [&]() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n };\n \n double initial_temp = 0.1;\n double final_temp = 0.0001;\n \n int iterations = 0;\n while (true) {\n if ((iterations & 255) == 0) {\n double elapsed = get_time();\n if (elapsed > TIME_LIMIT) break;\n }\n iterations++;\n \n double elapsed = get_time();\n double progress = elapsed / TIME_LIMIT;\n double temp = initial_temp * pow(final_temp / initial_temp, progress);\n \n int i = rng() % n;\n int dir = rng() % 4;\n \n Rect old_i = rects[i];\n Rect new_i = old_i;\n \n if (dir == 0) { // left\n int delta = rng() % 100 - 50;\n new_i.x1 += delta;\n if (new_i.x1 < 0) new_i.x1 = 0;\n if (new_i.x1 > old_i.px) new_i.x1 = old_i.px;\n } else if (dir == 1) { // right\n int delta = rng() % 100 - 50;\n new_i.x2 += delta;\n if (new_i.x2 > 10000) new_i.x2 = 10000;\n if (new_i.x2 <= old_i.px) new_i.x2 = old_i.px + 1;\n } else if (dir == 2) { // bottom\n int delta = rng() % 100 - 50;\n new_i.y1 += delta;\n if (new_i.y1 < 0) new_i.y1 = 0;\n if (new_i.y1 > old_i.py) new_i.y1 = old_i.py;\n } else { // top\n int delta = rng() % 100 - 50;\n new_i.y2 += delta;\n if (new_i.y2 > 10000) new_i.y2 = 10000;\n if (new_i.y2 <= old_i.py) new_i.y2 = old_i.py + 1;\n }\n \n if (new_i.x1 == old_i.x1 && new_i.x2 == old_i.x2 && new_i.y1 == old_i.y1 && new_i.y2 == old_i.y2) continue;\n \n int overlap_idx = -1;\n bool valid = true;\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (new_i.intersects(rects[j])) {\n if (overlap_idx == -1) {\n overlap_idx = j;\n } else {\n valid = false;\n break;\n }\n }\n }\n \n if (!valid) continue;\n \n Rect old_j;\n Rect new_j;\n if (overlap_idx != -1) {\n old_j = rects[overlap_idx];\n new_j = old_j;\n \n if (dir == 0) new_j.x2 = new_i.x1;\n else if (dir == 1) new_j.x1 = new_i.x2;\n else if (dir == 2) new_j.y2 = new_i.y1;\n else new_j.y1 = new_i.y2;\n \n if (new_j.x1 > new_j.px || new_j.x2 <= new_j.px || new_j.y1 > new_j.py || new_j.y2 <= new_j.py) {\n continue;\n }\n }\n \n double old_score = old_i.score() + (overlap_idx != -1 ? old_j.score() : 0.0);\n double new_score = new_i.score() + (overlap_idx != -1 ? new_j.score() : 0.0);\n \n if (new_score > old_score || exp((new_score - old_score) / temp) > uniform_real_distribution(0.0, 1.0)(rng)) {\n rects[i] = new_i;\n if (overlap_idx != -1) rects[overlap_idx] = new_j;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n cout << rects[i].x1 << \" \" << rects[i].y1 << \" \" << rects[i].x2 << \" \" << rects[i].y2 << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint t[50][50];\nint p[50][50];\nbool visited[2500];\nint best_score = -1;\nstring best_path = \"\";\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n \n int max_t = 0;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n max_t = max(max_t, t[i][j]);\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 mt19937 rng(1337);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n // Stop exactly before the 2.0-second limit\n if (chrono::duration_cast(now - start_time).count() > 1950) {\n break;\n }\n\n for (int i = 0; i <= max_t; ++i) visited[i] = false;\n\n int r = si;\n int c = sj;\n visited[t[r][c]] = true;\n int current_score = p[r][c];\n string current_path = \"\";\n \n // Reserve memory roughly equivalent to maximum possible path to avoid reallocation delays\n current_path.reserve(2500);\n\n while (true) {\n int order[4] = {0, 1, 2, 3};\n shuffle(order, order + 4, rng);\n \n int best_k = -1;\n int max_s = -1;\n \n // Greedily seek the best possible neighbor\n for(int i = 0; i < 4; ++i) {\n int k = order[i];\n int nr = r + di[k];\n int nc = c + dj[k];\n \n if(nr >= 0 && nr < 50 && nc >= 0 && nc < 50) {\n if(!visited[t[nr][nc]]) {\n if(p[nr][nc] > max_s) {\n max_s = p[nr][nc];\n best_k = k;\n }\n }\n }\n }\n \n // Introduce entropy (15% chance to pick a random valid move instead)\n if(rng() % 100 < 15) { \n for(int i = 0; i < 4; ++i) {\n int k = order[i];\n int nr = r + di[k];\n int nc = c + dj[k];\n if(nr >= 0 && nr < 50 && nc >= 0 && nc < 50) {\n if(!visited[t[nr][nc]]) {\n best_k = k;\n break;\n }\n }\n }\n }\n\n // Halt current walk if boxed-in/no valid unvisited moves\n if(best_k == -1) break;\n\n r += di[best_k];\n c += dj[best_k];\n visited[t[r][c]] = true;\n current_score += p[r][c];\n current_path += dir_char[best_k];\n }\n\n if (current_score > best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n }\n\n cout << best_path << \"\\n\";\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_VAL = 9000;\nconst int MIN_VAL = 1000;\n\n// Edge indices:\n// Horizontal edges: 0 to 30*29-1\n// Vertical edges: 30*29 to 30*29 + 29*30 - 1\n\nint get_h_edge(int r, int c) {\n return r * 29 + c;\n}\n\nint get_v_edge(int r, int c) {\n return 30 * 29 + r * 30 + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int num_edges = 30 * 29 + 29 * 30;\n vector weights(num_edges, 5000.0);\n\n double learning_rate = 0.5;\n\n for (int q = 0; q < 1000; ++q) {\n int sr, sc, tr, tc;\n if (!(cin >> sr >> sc >> tr >> tc)) break;\n\n // Dijkstra\n vector> dist(N, vector(N, 1e18));\n vector>> parent(N, vector>(N, {-1, -1}));\n vector> dir(N, vector(N, ' '));\n \n priority_queue>, vector>>, greater>>> pq;\n \n dist[sr][sc] = 0;\n pq.push({0, {sr, sc}});\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dch[] = {'U', 'D', 'L', 'R'};\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n int r = u.first;\n int c = u.second;\n \n if (d > dist[r][c]) continue;\n if (r == tr && c == tc) break;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int edge_idx = -1;\n if (i == 0) edge_idx = get_v_edge(nr, nc); // U\n else if (i == 1) edge_idx = get_v_edge(r, c); // D\n else if (i == 2) edge_idx = get_h_edge(nr, nc); // L\n else if (i == 3) edge_idx = get_h_edge(r, c); // R\n \n double w = weights[edge_idx];\n if (dist[r][c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n dir[nr][nc] = dch[i];\n pq.push({dist[nr][nc], {nr, nc}});\n }\n }\n }\n }\n \n string path = \"\";\n int cr = tr, cc = tc;\n vector path_edges;\n \n while (cr != sr || cc != sc) {\n path += dir[cr][cc];\n int pr = parent[cr][cc].first;\n int pc = parent[cr][cc].second;\n \n int edge_idx = -1;\n if (dir[cr][cc] == 'U') edge_idx = get_v_edge(cr, cc);\n else if (dir[cr][cc] == 'D') edge_idx = get_v_edge(pr, pc);\n else if (dir[cr][cc] == 'L') edge_idx = get_h_edge(cr, cc);\n else if (dir[cr][cc] == 'R') edge_idx = get_h_edge(pr, pc);\n \n path_edges.push_back(edge_idx);\n cr = pr;\n cc = pc;\n }\n \n reverse(path.begin(), path.end());\n cout << path << endl;\n \n int L;\n cin >> L;\n \n double current_est = 0;\n for (int e : path_edges) {\n current_est += weights[e];\n }\n \n double error = L - current_est;\n double update = (error / path_edges.size()) * learning_rate;\n \n for (int e : path_edges) {\n weights[e] += update;\n if (weights[e] < MIN_VAL) weights[e] = MIN_VAL;\n if (weights[e] > MAX_VAL) weights[e] = MAX_VAL;\n }\n \n learning_rate *= 0.998;\n if (learning_rate < 0.05) learning_rate = 0.05;\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint M;\nstring S[805];\n\nconst int HASH_SIZE = 8192;\nint head[HASH_SIZE];\nuint64_t keys[805];\nint vals[805];\nint nxt[805];\nint sz = 0;\n\nvoid insert_hash(uint64_t key, int val) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n keys[sz] = key;\n vals[sz] = val;\n nxt[sz] = head[h];\n head[h] = sz++;\n}\n\ninline int get_id(uint64_t key) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n for(int i = head[h]; i != -1; i = nxt[i]) {\n if (keys[i] == key) return vals[i];\n }\n return -1;\n}\n\nint grid[N][N];\nint counts[805];\nint max_len = 0;\n\ninline int remove_row(int r) {\n int diff = 0;\n for(int c = 0; c < N; ++c) {\n uint64_t val = 0;\n for(int l = 1; l <= max_len; ++l) {\n val = (val << 3) | grid[r][(c + l - 1) % N];\n if (l >= 2) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n return diff;\n}\n\ninline int add_row(int r) {\n int diff = 0;\n for(int c = 0; c < N; ++c) {\n uint64_t val = 0;\n for(int l = 1; l <= max_len; ++l) {\n val = (val << 3) | grid[r][(c + l - 1) % N];\n if (l >= 2) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n }\n }\n }\n }\n return diff;\n}\n\ninline int remove_col(int c) {\n int diff = 0;\n for(int r = 0; r < N; ++r) {\n uint64_t val = 0;\n for(int l = 1; l <= max_len; ++l) {\n val = (val << 3) | grid[(r + l - 1) % N][c];\n if (l >= 2) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n return diff;\n}\n\ninline int add_col(int c) {\n int diff = 0;\n for(int r = 0; r < N; ++r) {\n uint64_t val = 0;\n for(int l = 1; l <= max_len; ++l) {\n val = (val << 3) | grid[(r + l - 1) % N][c];\n if (l >= 2) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n }\n }\n }\n }\n return diff;\n}\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n memset(head, -1, sizeof(head));\n\n if (!(cin >> M >> M)) return 0; // Read N and M, N is always 20\n \n for(int i = 0; i < M; ++i) {\n cin >> S[i];\n max_len = max(max_len, (int)S[i].length());\n uint64_t val = 0;\n for(char c : S[i]) {\n val = (val << 3) | (c - 'A');\n }\n uint64_t key = ((uint64_t)S[i].length() << 36) | val;\n insert_hash(key, i);\n }\n\n mt19937 rng(42);\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n grid[r][c] = rng() % 8;\n }\n }\n\n int current_score = 0;\n for(int r = 0; r < N; ++r) current_score += add_row(r);\n for(int c = 0; c < N; ++c) current_score += add_col(c);\n\n double start_temp = 2.0;\n double end_temp = 0.05;\n double time_limit = 2.9;\n \n int best_grid[N][N];\n int best_score = -1;\n\n int iter = 0;\n while(true) {\n if ((iter & 1023) == 0) {\n double t = get_time();\n if (t > time_limit) break;\n }\n iter++;\n\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val = rng() % 7;\n if (new_val >= old_val) new_val++;\n\n int diff = 0;\n diff += remove_row(r);\n diff += remove_col(c);\n grid[r][c] = new_val;\n diff += add_row(r);\n diff += add_col(c);\n\n double t = get_time() / time_limit;\n double temp = start_temp * pow(end_temp / start_temp, t);\n\n if (diff > 0 || exp(diff / temp) > (double)(rng() % 1000000) / 1000000.0) {\n current_score += diff;\n if (current_score > best_score) {\n best_score = current_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n remove_row(r);\n remove_col(c);\n grid[r][c] = old_val;\n add_row(r);\n add_col(c);\n }\n }\n\n for(int r = 0; r < N; ++r) {\n string out = \"\";\n for(int c = 0; c < N; ++c) {\n out += (char)('A' + best_grid[r][c]);\n }\n cout << out << \"\\n\";\n }\n\n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint N, si, sj;\nvector grid;\nvector> visible;\nvector is_road;\nvector seen;\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nint get_id(int r, int c) {\n return r * N + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> si >> sj)) return 0;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n int num_cells = N * N;\n visible.resize(num_cells);\n is_road.assign(num_cells, false);\n int total_roads = 0;\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != '#') {\n is_road[get_id(r, c)] = true;\n total_roads++;\n }\n }\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (!is_road[get_id(r, c)]) continue;\n int u = get_id(r, c);\n \n for (int r2 = r; r2 >= 0; --r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int r2 = r + 1; r2 < N; ++r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int c2 = c - 1; c2 >= 0; --c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n for (int c2 = c + 1; c2 < N; ++c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n }\n }\n\n seen.assign(num_cells, false);\n int curr_r = si, curr_c = sj;\n int seen_count = 0;\n\n auto mark_seen = [&](int r, int c) {\n int u = get_id(r, c);\n for (int v : visible[u]) {\n if (!seen[v]) {\n seen[v] = true;\n seen_count++;\n }\n }\n };\n\n mark_seen(curr_r, curr_c);\n string ans = \"\";\n\n while (seen_count < total_roads) {\n vector dist(num_cells, INF);\n vector parent(num_cells, -1);\n vector move_dir(num_cells, ' ');\n \n priority_queue, vector>, greater>> pq;\n int start_id = get_id(curr_r, curr_c);\n dist[start_id] = 0;\n pq.push({0, start_id});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d > dist[u]) continue;\n\n int r = u / N;\n int c = u % N;\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int v = get_id(nr, nc);\n if (is_road[v]) {\n int cost = grid[nr][nc] - '0';\n if (dist[u] + cost < dist[v]) {\n dist[v] = dist[u] + cost;\n parent[v] = u;\n move_dir[v] = dir_char[i];\n pq.push({dist[v], v});\n }\n }\n }\n }\n }\n\n double best_score = -1.0;\n int best_target = -1;\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = get_id(r, c);\n if (is_road[u] && dist[u] < INF) {\n int unseen = 0;\n for (int v : visible[u]) {\n if (!seen[v]) unseen++;\n }\n if (unseen > 0) {\n double score = (double)unseen / (dist[u] + 1.0);\n if (score > best_score) {\n best_score = score;\n best_target = u;\n }\n }\n }\n }\n }\n\n if (best_target == -1) break;\n\n vector path;\n int curr = best_target;\n while (curr != start_id) {\n path.push_back(move_dir[curr]);\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_r--;\n else if (dir == 'D') curr_r++;\n else if (dir == 'L') curr_c--;\n else if (dir == 'R') curr_c++;\n mark_seen(curr_r, curr_c);\n }\n }\n\n vector dist(num_cells, INF);\n vector parent(num_cells, -1);\n vector move_dir(num_cells, ' ');\n priority_queue, vector>, greater>> pq;\n \n int start_id = get_id(curr_r, curr_c);\n dist[start_id] = 0;\n pq.push({0, start_id});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d > dist[u]) continue;\n\n int r = u / N;\n int c = u % N;\n\n if (r == si && c == sj) break;\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int v = get_id(nr, nc);\n if (is_road[v]) {\n int cost = grid[nr][nc] - '0';\n if (dist[u] + cost < dist[v]) {\n dist[v] = dist[u] + cost;\n parent[v] = u;\n move_dir[v] = dir_char[i];\n pq.push({dist[v], v});\n }\n }\n }\n }\n }\n\n vector path;\n int curr = get_id(si, sj);\n while (curr != start_id) {\n path.push_back(move_dir[curr]);\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n }\n\n cout << ans << \"\\n\";\n\n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector deps;\n vector rev_deps;\n int priority = 0;\n int status = -1; // -1: not started, 0: in progress, 1: completed\n};\n\nstruct Member {\n int id;\n vector s;\n int current_task = -1;\n int start_day = -1;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> tasks[i].d[k];\n }\n }\n\n vector in_degree(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n tasks[u].rev_deps.push_back(v);\n tasks[v].deps.push_back(u);\n in_degree[v]++;\n }\n\n // Calculate task priorities (longest path to any sink)\n vector dp(N, 0);\n vector topo_order;\n queue q;\n vector in_deg_temp = in_degree;\n for (int i = 0; i < N; ++i) {\n if (in_deg_temp[i] == 0) {\n q.push(i);\n }\n }\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n topo_order.push_back(u);\n for (int v : tasks[u].rev_deps) {\n if (--in_deg_temp[v] == 0) {\n q.push(v);\n }\n }\n }\n for (int i = N - 1; i >= 0; --i) {\n int u = topo_order[i];\n dp[u] = 1;\n for (int v : tasks[u].rev_deps) {\n dp[u] = max(dp[u], dp[v] + 1);\n }\n tasks[u].priority = dp[u];\n }\n\n vector members(M);\n for (int i = 0; i < M; ++i) {\n members[i].id = i;\n members[i].s.assign(K, 0.0);\n }\n\n int day = 0;\n int completed_tasks = 0;\n\n while (completed_tasks < N) {\n day++;\n \n vector assign_m;\n vector assign_t;\n\n vector available_tasks;\n for (int i = 0; i < N; ++i) {\n if (tasks[i].status == -1 && in_degree[i] == 0) {\n available_tasks.push_back(i);\n }\n }\n\n sort(available_tasks.begin(), available_tasks.end(), [&](int a, int b) {\n return tasks[a].priority > tasks[b].priority;\n });\n\n for (int i = 0; i < M; ++i) {\n if (members[i].current_task == -1 && !available_tasks.empty()) {\n int best_t = available_tasks.front();\n available_tasks.erase(available_tasks.begin());\n \n members[i].current_task = best_t;\n members[i].start_day = day;\n tasks[best_t].status = 0;\n \n assign_m.push_back(i + 1);\n assign_t.push_back(best_t + 1);\n }\n }\n\n cout << assign_m.size();\n for (size_t i = 0; i < assign_m.size(); ++i) {\n cout << \" \" << assign_m[i] << \" \" << assign_t[i];\n }\n cout << \"\\n\";\n cout.flush();\n\n int n_finished;\n cin >> n_finished;\n if (n_finished == -1) {\n break;\n }\n\n for (int i = 0; i < n_finished; ++i) {\n int f;\n cin >> f;\n --f;\n \n int t_id = members[f].current_task;\n int actual_time = day - members[f].start_day + 1;\n \n tasks[t_id].status = 1;\n completed_tasks++;\n members[f].current_task = -1;\n \n for (int v : tasks[t_id].rev_deps) {\n in_degree[v]--;\n }\n \n // Simple skill update logic\n double diff = actual_time - 1;\n if (diff > 0) {\n double total_d = 0;\n for (int k = 0; k < K; ++k) total_d += tasks[t_id].d[k];\n if (total_d > 0) {\n for (int k = 0; k < K; ++k) {\n if (tasks[t_id].d[k] > members[f].s[k]) {\n members[f].s[k] += 0.1 * (tasks[t_id].d[k] - members[f].s[k]);\n }\n }\n }\n } else {\n for (int k = 0; k < K; ++k) {\n members[f].s[k] = max(members[f].s[k], (double)tasks[t_id].d[k]);\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Order {\n int id;\n int a, b, c, d;\n int dist_to_center;\n};\n\nstruct Point {\n int x, y;\n};\n\nint manhattan(Point p1, Point p2) {\n return abs(p1.x - p2.x) + abs(p1.y - p2.y);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n vector orders(1000);\n for (int i = 0; i < 1000; ++i) {\n orders[i].id = i + 1;\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].dist_to_center = abs(orders[i].a - 400) + abs(orders[i].b - 400) + \n abs(orders[i].c - 400) + abs(orders[i].d - 400);\n }\n\n // Sort by proximity to the center\n sort(orders.begin(), orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_to_center < o2.dist_to_center;\n });\n\n int pool_size = 80;\n mt19937 rng(42);\n\n int best_dist = 2e9;\n vector best_order_ids;\n vector best_route;\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.9) break;\n\n // Randomly select 50 orders from the pool\n vector selected_orders;\n vector indices(pool_size);\n for (int i = 0; i < pool_size; ++i) indices[i] = i;\n shuffle(indices.begin(), indices.end(), rng);\n \n for (int i = 0; i < 50; ++i) {\n selected_orders.push_back(orders[indices[i]]);\n }\n\n vector order_ids;\n for (const auto& o : selected_orders) {\n order_ids.push_back(o.id);\n }\n\n Point current_pos = {400, 400};\n vector route;\n route.push_back(current_pos);\n\n vector picked_up(50, false);\n vector dropped_off(50, false);\n int dropped_count = 0;\n int current_dist = 0;\n\n while (dropped_count < 50) {\n struct Move {\n int id_idx;\n bool is_pickup;\n Point p;\n int dist;\n };\n vector valid_moves;\n\n for (int i = 0; i < 50; ++i) {\n if (!picked_up[i]) {\n valid_moves.push_back({i, true, {selected_orders[i].a, selected_orders[i].b}, \n manhattan(current_pos, {selected_orders[i].a, selected_orders[i].b})});\n } else if (!dropped_off[i]) {\n valid_moves.push_back({i, false, {selected_orders[i].c, selected_orders[i].d}, \n manhattan(current_pos, {selected_orders[i].c, selected_orders[i].d})});\n }\n }\n\n sort(valid_moves.begin(), valid_moves.end(), [](const Move& m1, const Move& m2) {\n return m1.dist < m2.dist;\n });\n\n // Randomized greedy selection\n int selected_idx = 0;\n double r = uniform_real_distribution(0.0, 1.0)(rng);\n if (valid_moves.size() > 1 && r > 0.7) selected_idx = 1;\n if (valid_moves.size() > 2 && r > 0.9) selected_idx = 2;\n\n Move best_move = valid_moves[selected_idx];\n \n if (best_move.is_pickup) {\n picked_up[best_move.id_idx] = true;\n } else {\n dropped_off[best_move.id_idx] = true;\n dropped_count++;\n }\n\n current_dist += best_move.dist;\n current_pos = best_move.p;\n route.push_back(current_pos);\n }\n\n current_dist += manhattan(current_pos, {400, 400});\n route.push_back({400, 400});\n\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_order_ids = order_ids;\n best_route = route;\n }\n }\n\n // Output best orders\n cout << best_order_ids.size();\n for (int id : best_order_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n\n // Output best route\n cout << best_route.size();\n for (const auto& p : best_route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc007":"","ahc008":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector px(N), py(N), pt(N);\n for (int i = 0; i < N; ++i) {\n cin >> px[i] >> py[i] >> pt[i];\n }\n\n int M;\n cin >> M;\n vector hx(M), hy(M);\n for (int i = 0; i < M; ++i) {\n cin >> hx[i] >> hy[i];\n }\n\n for (int turn = 0; turn < 300; ++turn) {\n string action = \"\";\n for (int i = 0; i < M; ++i) {\n // A simple dummy strategy: stay in place or random valid action\n // In a real heuristic approach, we would build walls to divide the room.\n action += \".\";\n }\n cout << action << endl;\n\n for (int i = 0; i < N; ++i) {\n string pet_move;\n cin >> pet_move;\n }\n }\n\n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint si, sj, ti, tj;\ndouble p;\nstring h[N], v[N - 1];\nint dist[N][N];\ndouble prob[N][N];\ndouble next_prob[N][N];\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nbool can_move(int i, int j, int d) {\n if (d == 0) return i > 0 && v[i - 1][j] == '0';\n if (d == 1) return i < N - 1 && v[i][j] == '0';\n if (d == 2) return j > 0 && h[i][j - 1] == '0';\n if (d == 3) return j < N - 1 && h[i][j] == '0';\n return false;\n}\n\nvoid compute_dist() {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dist[i][j] = 1e9;\n \n queue> q;\n q.push({ti, tj});\n dist[ti][tj] = 0;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n if (can_move(ni, nj, d ^ 1) && dist[ni][nj] > dist[i][j] + 1) {\n dist[ni][nj] = dist[i][j] + 1;\n q.push({ni, nj});\n }\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n for (int i = 0; i < N; ++i) cin >> h[i];\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n compute_dist();\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n prob[i][j] = 0.0;\n prob[si][sj] = 1.0;\n\n string ans = \"\";\n for (int step = 0; step < 200; ++step) {\n int best_i = -1, best_j = -1;\n double max_p = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == ti && j == tj) continue;\n if (prob[i][j] > max_p) {\n max_p = prob[i][j];\n best_i = i;\n best_j = j;\n }\n }\n }\n\n if (max_p < 1e-9) break;\n\n int best_d = -1;\n int min_d = 1e9;\n for (int d = 0; d < 4; ++d) {\n if (can_move(best_i, best_j, d)) {\n int ni = best_i + di[d];\n int nj = best_j + dj[d];\n if (dist[ni][nj] < min_d) {\n min_d = dist[ni][nj];\n best_d = d;\n }\n }\n }\n\n if (best_d == -1) break;\n\n ans += dir_char[best_d];\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n next_prob[i][j] = 0.0;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == ti && j == tj) {\n next_prob[i][j] += prob[i][j];\n continue;\n }\n if (can_move(i, j, best_d)) {\n int ni = i + di[best_d];\n int nj = j + dj[best_d];\n next_prob[ni][nj] += prob[i][j] * (1.0 - p);\n next_prob[i][j] += prob[i][j] * p;\n } else {\n next_prob[i][j] += prob[i][j];\n }\n }\n }\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n prob[i][j] = next_prob[i][j];\n }\n\n cout << ans << \"\\n\";\n return 0;\n}","ahc010":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Direction deltas: 0: Left, 1: Up, 2: Right, 3: Down\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\n// to[tile][d] gives the direction to the next tile when entering 'tile' from 'd'\nconst int TO[8][4] = {\n\t{1, 0, -1, -1},\n\t{3, -1, -1, 0},\n\t{-1, -1, 3, 2},\n\t{-1, 2, 1, -1},\n\t{1, 0, 3, 2},\n\t{3, 2, 1, 0},\n\t{2, -1, 0, -1},\n\t{-1, 3, -1, 1}\n};\n\n// Compute the new tile ID after applying `r` 90-degree counter-clockwise rotations\nint rot(int t, int r) {\n\tif (t >= 0 && t <= 3) return (t + r) % 4;\n\tif (t >= 4 && t <= 5) return 4 + (t - 4 + r) % 2;\n\tif (t >= 6 && t <= 7) return 6 + (t - 6 + r) % 2;\n\treturn t;\n}\n\nint base_grid[30][30];\nint cur_grid[30][30];\nint cur_rot[30][30];\n\nint vis[30][30][4];\nint vis_id = 0;\n\n// Evaluates the board score, resolving all valid loops on the board\nlong long evaluate() {\n vis_id++;\n int l1 = 0, l2 = 0;\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n if (vis[i][j][d] == vis_id) continue;\n if (TO[cur_grid[i][j]][d] == -1) continue;\n \n int ci = i, cj = j, cd = d;\n int len = 0;\n bool is_loop = false;\n \n while (true) {\n if (vis[ci][cj][cd] == vis_id) {\n if (ci == i && cj == j && cd == d) {\n is_loop = true;\n }\n break;\n }\n vis[ci][cj][cd] = vis_id;\n int nd = TO[cur_grid[ci][cj]][cd];\n if (nd == -1) break;\n \n int ni = ci + di[nd], nj = cj + dj[nd];\n if (ni < 0 || ni >= 30 || nj < 0 || nj >= 30) break;\n \n int ncd = (nd + 2) % 4;\n ci = ni; cj = nj; cd = ncd;\n len++;\n }\n \n if (is_loop) {\n if (len > l1) {\n l2 = l1;\n l1 = len;\n } else if (len > l2) {\n l2 = len;\n }\n }\n }\n }\n }\n return (long long)l1 * l2;\n}\n\n// Xorshift fast RNG\nuint32_t xor128() {\n static uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start = chrono::high_resolution_clock::now();\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n base_grid[i][j] = s[j] - '0';\n cur_grid[i][j] = base_grid[i][j];\n cur_rot[i][j] = 0;\n }\n }\n\n long long best_score = evaluate();\n\n int iters = 0;\n while (true) {\n if ((iters & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > 1.95) break; // Close off roughly 50ms before the actual time bounds\n }\n iters++;\n\n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) % 4;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n long long score = evaluate();\n \n // Standard Hill Climbing approach: Acceptance evaluation\n if (score >= best_score) {\n best_score = score;\n } else {\n // Rollback change\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n }\n\n // Output formatting \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << cur_rot[i][j];\n }\n }\n cout << \"\\n\";\n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nint N, T;\nvector> board;\nint empty_r, empty_c;\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dir_char[] = {'D', 'U', 'R', 'L'};\n\nint time_limit_ms = 2800;\n\nint get_tree_size(const vector>& b) {\n int max_size = 0;\n vector> visited(N, vector(N, false));\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (b[i][j] == 0 || visited[i][j]) continue;\n\n int size = 0;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n bool has_cycle = false;\n int edges = 0;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n size++;\n\n if (r > 0 && (b[r][c] & 2) && (b[r - 1][c] & 8)) {\n edges++;\n if (!visited[r - 1][c]) {\n visited[r - 1][c] = true;\n q.push({r - 1, c});\n }\n }\n if (r < N - 1 && (b[r][c] & 8) && (b[r + 1][c] & 2)) {\n edges++;\n if (!visited[r + 1][c]) {\n visited[r + 1][c] = true;\n q.push({r + 1, c});\n }\n }\n if (c > 0 && (b[r][c] & 1) && (b[r][c - 1] & 4)) {\n edges++;\n if (!visited[r][c - 1]) {\n visited[r][c - 1] = true;\n q.push({r, c - 1});\n }\n }\n if (c < N - 1 && (b[r][c] & 4) && (b[r][c + 1] & 1)) {\n edges++;\n if (!visited[r][c + 1]) {\n visited[r][c + 1] = true;\n q.push({r, c + 1});\n }\n }\n }\n\n if (edges / 2 == size - 1) {\n max_size = max(max_size, size);\n }\n }\n }\n return max_size;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n if (!(cin >> N >> T)) return 0;\n\n board.assign(N, vector(N));\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n if (s[j] >= '0' && s[j] <= '9') board[i][j] = s[j] - '0';\n else board[i][j] = s[j] - 'a' + 10;\n if (board[i][j] == 0) {\n empty_r = i;\n empty_c = j;\n }\n }\n }\n\n string best_moves = \"\";\n int best_score = get_tree_size(board);\n\n // Random walk heuristic\n string current_moves = \"\";\n vector> current_board = board;\n int cr = empty_r, cc = empty_c;\n\n srand(1337);\n\n while (true) {\n auto current_time = high_resolution_clock::now();\n if (duration_cast(current_time - start_time).count() > time_limit_ms) {\n break;\n }\n\n int d = rand() % 4;\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n swap(current_board[cr][cc], current_board[nr][nc]);\n current_moves += dir_char[d];\n cr = nr;\n cc = nc;\n\n int score = get_tree_size(current_board);\n if (score > best_score) {\n best_score = score;\n best_moves = current_moves;\n }\n\n if (current_moves.length() == T) {\n current_moves = \"\";\n current_board = board;\n cr = empty_r;\n cc = empty_c;\n }\n }\n }\n\n cout << best_moves << \"\\n\";\n\n return 0;\n}","ahc012":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int K = 100;\nint N;\nint a[11];\nint x_coords[10005];\nint y_coords[10005];\n\nstruct Line {\n double theta;\n double r;\n};\n\nLine lines[K];\nuint64_t hashes0[10005];\nuint64_t hashes1[10005];\n\npair, pair> get_points(const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n double px = l.r * cos_t - 20000.0 * sin_t;\n double py = l.r * sin_t + 20000.0 * cos_t;\n double qx = l.r * cos_t + 20000.0 * sin_t;\n double qy = l.r * sin_t - 20000.0 * cos_t;\n return {{round(px), round(py)}, {round(qx), round(qy)}};\n}\n\nint evaluate() {\n vector> h(N);\n for (int i = 0; i < N; ++i) {\n h[i] = {hashes0[i], hashes1[i]};\n }\n sort(h.begin(), h.end());\n\n int b[11] = {0};\n int current_count = 1;\n for (int i = 1; i < N; ++i) {\n if (h[i] == h[i - 1]) {\n current_count++;\n } else {\n if (current_count <= 10) {\n b[current_count]++;\n }\n current_count = 1;\n }\n }\n if (current_count <= 10) {\n b[current_count]++;\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(a[d], b[d]);\n }\n return score;\n}\n\nvoid update_line_hash(int line_idx, const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n for (int i = 0; i < N; ++i) {\n double val = x_coords[i] * cos_t + y_coords[i] * sin_t - l.r;\n bool bit = (val > 0);\n if (line_idx < 64) {\n if (bit) hashes0[i] |= (1ULL << line_idx);\n else hashes0[i] &= ~(1ULL << line_idx);\n } else {\n int shift = line_idx - 64;\n if (bit) hashes1[i] |= (1ULL << shift);\n else hashes1[i] &= ~(1ULL << shift);\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int max_k;\n if (!(cin >> N >> max_k)) return 0;\n\n int total_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n total_a += a[i];\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> x_coords[i] >> y_coords[i];\n }\n\n mt19937 rng(42);\n uniform_real_distribution dist_theta(0.0, M_PI);\n uniform_real_distribution dist_r(-9900.0, 9900.0);\n\n for (int i = 0; i < K; ++i) {\n lines[i].theta = dist_theta(rng);\n lines[i].r = dist_r(rng);\n update_line_hash(i, lines[i]);\n }\n\n int best_score = evaluate();\n\n auto start_time = chrono::high_resolution_clock::now();\n\n int iter = 0;\n while (true) {\n if ((iter & 63) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.8) break;\n }\n iter++;\n\n int idx = rng() % K;\n Line old_line = lines[idx];\n\n lines[idx].theta = dist_theta(rng);\n lines[idx].r = dist_r(rng);\n \n update_line_hash(idx, lines[idx]);\n \n int new_score = evaluate();\n\n if (new_score >= best_score) {\n best_score = new_score;\n } else {\n lines[idx] = old_line;\n update_line_hash(idx, lines[idx]);\n }\n }\n\n cout << K << \"\\n\";\n for (int i = 0; i < K; ++i) {\n auto pts = get_points(lines[i]);\n cout << pts.first.first << \" \" << pts.first.second << \" \" \n << pts.second.first << \" \" << pts.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int MAXN = 65;\n\nstruct Point {\n int x, y;\n bool operator==(const Point& o) const { return x == o.x && y == o.y; }\n};\n\nstruct Move {\n Point p1, p2, p3, p4;\n};\n\nint N, M;\nPoint center;\nvector initial_dots;\nint weight[MAXN][MAXN];\n\ndouble get_time() {\n static auto start = high_resolution_clock::now();\n return duration(high_resolution_clock::now() - start).count();\n}\n\nstruct State {\n bool has_dot[MAXN][MAXN];\n int edges[4][MAXN][MAXN]; \n // 0: dx=1, dy=0\n // 1: dx=0, dy=1\n // 2: dx=1, dy=1\n // 3: dx=1, dy=-1\n vector dots;\n vector moves;\n int score;\n\n State() {\n for (int i = 0; i < MAXN; ++i) {\n for (int j = 0; j < MAXN; ++j) {\n has_dot[i][j] = false;\n for (int k = 0; k < 4; ++k) edges[k][i][j] = 0;\n }\n }\n score = 0;\n }\n\n void add_dot(Point p) {\n has_dot[p.x][p.y] = true;\n dots.push_back(p);\n score += weight[p.x][p.y];\n }\n\n bool check_edge(Point p1, Point p2) const {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = -1;\n if (step_y == 0) type = 0;\n else if (step_x == 0) type = 1;\n else if (step_x == step_y) type = 2;\n else type = 3;\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n if (edges[type][ex][ey]) return false;\n if ((cx != p1.x || cy != p1.y) && has_dot[cx][cy]) return false;\n cx = nx; cy = ny;\n }\n return true;\n }\n\n void mark_edge(Point p1, Point p2, int val) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = -1;\n if (step_y == 0) type = 0;\n else if (step_x == 0) type = 1;\n else if (step_x == step_y) type = 2;\n else type = 3;\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n edges[type][ex][ey] += val;\n cx = nx; cy = ny;\n }\n }\n\n bool is_valid_rect(Point p1, Point p2, Point p3, Point p4) const {\n if (has_dot[p1.x][p1.y]) return false;\n if (!has_dot[p2.x][p2.y] || !has_dot[p3.x][p3.y] || !has_dot[p4.x][p4.y]) return false;\n if (!check_edge(p1, p2)) return false;\n if (!check_edge(p2, p3)) return false;\n if (!check_edge(p3, p4)) return false;\n if (!check_edge(p4, p1)) return false;\n return true;\n }\n\n void apply_move(const Move& m) {\n add_dot(m.p1);\n mark_edge(m.p1, m.p2, 1);\n mark_edge(m.p2, m.p3, 1);\n mark_edge(m.p3, m.p4, 1);\n mark_edge(m.p4, m.p1, 1);\n moves.push_back(m);\n }\n \n bool inside(int x, int y) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n center = {(N - 1) / 2, (N - 1) / 2};\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n weight[i][j] = (i - center.x) * (i - center.x) + (j - center.y) * (j - center.y) + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_dots.push_back({x, y});\n }\n\n State best_state;\n best_state.score = -1;\n\n // Fast randomized greedy search\n while (get_time() < 4.8) {\n State state;\n for (auto p : initial_dots) state.add_dot(p);\n\n bool moved = true;\n while (moved && get_time() < 4.8) {\n moved = false;\n vector candidates;\n\n for (int i = 0; i < state.dots.size(); ++i) {\n for (int j = 0; j < state.dots.size(); ++j) {\n if (i == j) continue;\n Point p2 = state.dots[i];\n Point p4 = state.dots[j];\n \n int mx = p2.x + p4.x;\n int my = p2.y + p4.y;\n int dx = p4.x - p2.x;\n int dy = p4.y - p2.y;\n\n if ((mx + dy) % 2 != 0 || (my - dx) % 2 != 0) continue;\n\n Point p1 = {(mx - dy) / 2, (my + dx) / 2};\n Point p3 = {(mx + dy) / 2, (my - dx) / 2};\n\n if (!state.inside(p1.x, p1.y) || !state.inside(p3.x, p3.y)) continue;\n \n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n }\n }\n\n if (!candidates.empty()) {\n Move best_m = candidates[0];\n int best_val = -1;\n for (const auto& m : candidates) {\n int val = weight[m.p1.x][m.p1.y] + (rand() % 10); // tie breaker with slight randomness\n if (val > best_val) {\n best_val = val;\n best_m = m;\n }\n }\n state.apply_move(best_m);\n moved = true;\n }\n }\n\n if (state.score > best_state.score) {\n best_state = state;\n }\n }\n\n cout << best_state.moves.size() << \"\\n\";\n for (const auto& m : best_state.moves) {\n cout << m.p1.x << \" \" << m.p1.y << \" \" \n << m.p2.x << \" \" << m.p2.y << \" \" \n << m.p3.x << \" \" << m.p3.y << \" \" \n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Board {\n int grid[10][10] = {0};\n\n void add_candy(int flavor, int p) {\n int empty_count = 0;\n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] == 0) {\n empty_count++;\n if (empty_count == p) {\n grid[r][c] = flavor;\n return;\n }\n }\n }\n }\n }\n\n // 0: F, 1: B, 2: L, 3: R\n bool tilt(int dir) {\n bool changed = false;\n if (dir == 0) { // F\n for (int c = 0; c < 10; ++c) {\n int write_idx = 0;\n for (int r = 0; r < 10; ++r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 1) { // B\n for (int c = 0; c < 10; ++c) {\n int write_idx = 9;\n for (int r = 9; r >= 0; --r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n } else if (dir == 2) { // L\n for (int r = 0; r < 10; ++r) {\n int write_idx = 0;\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 3) { // R\n for (int r = 0; r < 10; ++r) {\n int write_idx = 9;\n for (int c = 9; c >= 0; --c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n }\n return changed;\n }\n\n int calc_score() const {\n bool vis[10][10] = {false};\n int score = 0;\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n\n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0 && !vis[r][c]) {\n int flavor = grid[r][c];\n int sz = 0;\n vector> q;\n q.push_back({r, c});\n vis[r][c] = true;\n int head = 0;\n while (head < q.size()) {\n auto [cr, cc] = q[head++];\n sz++;\n for (int i = 0; i < 4; ++i) {\n int nr = cr + dr[i], nc = cc + dc[i];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !vis[nr][nc] && grid[nr][nc] == flavor) {\n vis[nr][nc] = true;\n q.push_back({nr, nc});\n }\n }\n }\n score += sz * sz;\n }\n }\n }\n return score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n vector f(100);\n for (int i = 0; i < 100; ++i) {\n cin >> f[i];\n }\n\n Board b;\n mt19937 rng(42);\n char dir_chars[] = {'F', 'B', 'L', 'R'};\n\n for (int t = 1; t <= 100; ++t) {\n int p;\n cin >> p;\n b.add_candy(f[t - 1], p);\n\n if (t == 100) break;\n\n auto start_time = high_resolution_clock::now();\n \n long long total_score[4] = {0};\n int playouts[4] = {0};\n bool valid[4] = {false};\n Board next_b[4];\n\n for (int d = 0; d < 4; ++d) {\n next_b[d] = b;\n valid[d] = next_b[d].tilt(d);\n }\n\n int loop_count = 0;\n while (true) {\n if ((++loop_count & 15) == 0) {\n auto now = high_resolution_clock::now();\n if (duration_cast(now - start_time).count() > 15) {\n break;\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n if (!valid[d]) continue;\n Board sim_b = next_b[d];\n for (int sim_t = t + 1; sim_t <= 100; ++sim_t) {\n int empty_cells = 100 - sim_t + 1;\n int sim_p = uniform_int_distribution(1, empty_cells)(rng);\n sim_b.add_candy(f[sim_t - 1], sim_p);\n if (sim_t < 100) {\n int r_move = uniform_int_distribution(0, 3)(rng);\n sim_b.tilt(r_move);\n }\n }\n total_score[d] += sim_b.calc_score();\n playouts[d]++;\n }\n }\n\n int best_dir = 0;\n double best_avg = -1.0;\n for (int d = 0; d < 4; ++d) {\n if (playouts[d] > 0) {\n double avg = (double)total_score[d] / playouts[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_dir = d;\n }\n }\n }\n\n if (best_avg < 0) {\n best_dir = uniform_int_distribution(0, 3)(rng);\n }\n\n b.tilt(best_dir);\n cout << dir_chars[best_dir] << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n\n int N = 100;\n int V = N * (N - 1) / 2;\n \n // Choose edge counts for each of the M graphs evenly spaced from 0 to V\n vector target_edges(M);\n for (int i = 0; i < M; ++i) {\n if (M == 1) {\n target_edges[i] = V / 2;\n } else {\n target_edges[i] = (long long)i * V / (M - 1);\n }\n }\n\n // Output N and the graphs\n cout << N << \"\\n\";\n for (int i = 0; i < M; ++i) {\n string g = \"\";\n for (int j = 0; j < target_edges[i]; ++j) {\n g += \"1\";\n }\n for (int j = target_edges[i]; j < V; ++j) {\n g += \"0\";\n }\n cout << g << \"\\n\";\n }\n cout << flush;\n\n // Process the 100 queries\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n int edges = 0;\n for (char c : H) {\n if (c == '1') edges++;\n }\n \n int best_guess = 0;\n double best_diff = 1e9;\n \n for (int i = 0; i < M; ++i) {\n double expected_edges = target_edges[i] * (1.0 - eps) + (V - target_edges[i]) * eps;\n double diff = abs(edges - expected_edges);\n if (diff < best_diff) {\n best_diff = diff;\n best_guess = i;\n }\n }\n \n cout << best_guess << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Edge {\n int id;\n int u, v;\n long long w;\n double x, y; // midpoint\n};\n\nstruct GraphEdge {\n int to;\n long long w;\n int id;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n\n vector edges(M);\n vector> adj(N);\n\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; \n edges[i].v--;\n edges[i].id = i;\n adj[edges[i].u].push_back({edges[i].v, edges[i].w, i});\n adj[edges[i].v].push_back({edges[i].u, edges[i].w, i});\n }\n\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n for (int i = 0; i < M; ++i) {\n edges[i].x = (coords[edges[i].u].first + coords[edges[i].v].first) / 2.0;\n edges[i].y = (coords[edges[i].u].second + coords[edges[i].v].second) / 2.0;\n }\n\n mt19937 rng(42);\n vector eval_sources(min(N, 40));\n iota(eval_sources.begin(), eval_sources.end(), 0);\n shuffle(eval_sources.begin(), eval_sources.end(), rng);\n\n auto evaluate = [&](const vector& ans) -> long long {\n long long score = 0;\n for (int day = 1; day <= D; ++day) {\n for (int src : eval_sources) {\n vector dist(N, 1e9);\n priority_queue, vector>, greater>> pq;\n \n dist[src] = 0;\n pq.push({0, src});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (const auto& edge : adj[u]) {\n if (ans[edge.id] == day) continue;\n if (dist[edge.to] > d + edge.w) {\n dist[edge.to] = d + edge.w;\n pq.push({dist[edge.to], edge.to});\n }\n }\n }\n for (int i = 0; i < N; ++i) {\n score += dist[i];\n }\n }\n }\n return score;\n };\n\n vector best_ans(M, 1);\n long long best_score = -1;\n\n int num_candidates = 50;\n for (int iter = 0; iter < num_candidates; ++iter) {\n double angle = uniform_real_distribution(0, 2 * M_PI)(rng);\n double cos_a = cos(angle);\n double sin_a = sin(angle);\n\n vector> proj(M);\n for (int i = 0; i < M; ++i) {\n proj[i] = {edges[i].x * cos_a + edges[i].y * sin_a, i};\n }\n\n sort(proj.begin(), proj.end());\n\n vector current_ans(M);\n for (int i = 0; i < M; ++i) {\n current_ans[proj[i].second] = (i % D) + 1;\n }\n\n long long current_score = evaluate(current_ans);\n if (best_score == -1 || current_score < best_score) {\n best_score = current_score;\n best_ans = current_ans;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n cout << best_ans[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc019":"#include \n#include \n#include \n\nusing namespace std;\n\nint D;\nvector f1, r1, f2, r2;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> D)) return 0;\n\n auto read_grid = [&]() {\n vector grid(D);\n for (int i = 0; i < D; ++i) cin >> grid[i];\n return grid;\n };\n\n f1 = read_grid();\n r1 = read_grid();\n f2 = read_grid();\n r2 = read_grid();\n\n vector b1(D * D * D, 0);\n vector b2(D * D * D, 0);\n\n int n = 0;\n\n for (int i = 0; i < 2; ++i) {\n const auto& f = (i == 0) ? f1 : f2;\n const auto& r = (i == 0) ? r1 : r2;\n auto& b = (i == 0) ? b1 : b2;\n\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (f[z][x] == '1' && r[z][y] == '1') {\n n++;\n b[x * D * D + y * D + z] = n;\n }\n }\n }\n }\n }\n\n cout << n << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n cout << b1[i] << (i + 1 == D * D * D ? \"\" : \" \");\n }\n cout << \"\\n\";\n for (int i = 0; i < D * D * D; ++i) {\n cout << b2[i] << (i + 1 == D * D * D ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Edge {\n int id;\n int u, v;\n long long w;\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n void unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n }\n }\n};\n\nlong long dist_sq(long long x1, long long y1, long long x2, long long y2) {\n return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n\n vector> stations(N);\n for (int i = 0; i < N; ++i) {\n cin >> stations[i].first >> stations[i].second;\n }\n\n vector edges(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; \n edges[i].v--;\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 for (int i = 0; i < K; ++i) {\n long long min_d = -1;\n int best_station = -1;\n for (int j = 0; j < N; ++j) {\n long long d = dist_sq(residents[i].first, residents[i].second, stations[j].first, stations[j].second);\n if (min_d == -1 || d < min_d) {\n min_d = d;\n best_station = j;\n }\n }\n long long req_p = ceil(sqrt(min_d));\n while (req_p * req_p < min_d) req_p++;\n P[best_station] = max(P[best_station], req_p);\n }\n\n vector sorted_edges = edges;\n sort(sorted_edges.begin(), sorted_edges.end());\n\n DSU dsu(N);\n vector>> adj(N);\n vector degree(N, 0);\n vector edge_used(M, 0);\n\n for (const auto& e : sorted_edges) {\n if (dsu.find(e.u) != dsu.find(e.v)) {\n dsu.unite(e.u, e.v);\n adj[e.u].push_back({e.v, e.id});\n adj[e.v].push_back({e.u, e.id});\n degree[e.u]++;\n degree[e.v]++;\n edge_used[e.id] = 1;\n }\n }\n\n // Prune useless leaves\n vector leaves;\n for (int i = 1; i < N; ++i) {\n if (degree[i] == 1 && P[i] == 0) {\n leaves.push_back(i);\n }\n }\n\n while (!leaves.empty()) {\n int u = leaves.back();\n leaves.pop_back();\n if (u == 0 || P[u] > 0 || degree[u] != 1) continue;\n\n for (auto& edge_info : adj[u]) {\n int v = edge_info.first;\n int e_id = edge_info.second;\n if (edge_used[e_id]) {\n edge_used[e_id] = 0;\n degree[u]--;\n degree[v]--;\n if (v != 0 && degree[v] == 1 && P[v] == 0) {\n leaves.push_back(v);\n }\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << P[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n for (int i = 0; i < M; ++i) {\n cout << edge_used[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n\nusing namespace std;\n\nstruct Swap {\n int x1, y1, x2, y2;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = 30;\n vector> b(N, vector(N, 0));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> b[i][j];\n }\n }\n\n vector ops;\n\n bool changed = true;\n while (changed) {\n changed = false;\n \n // Bottom-up pass\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n if (b[x][y] > b[x + 1][y] || b[x][y] > b[x + 1][y + 1]) {\n int ny = y;\n if (b[x + 1][y + 1] < b[x + 1][y]) {\n ny = y + 1;\n }\n if (b[x][y] > b[x + 1][ny]) {\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n }\n \n // Top-down pass\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n if (b[x][y] > b[x + 1][y] || b[x][y] > b[x + 1][y + 1]) {\n int ny = y;\n if (b[x + 1][y + 1] < b[x + 1][y]) {\n ny = y + 1;\n }\n if (b[x][y] > b[x + 1][ny]) {\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n }\n }\n\n // Since the maximum operations limit is 10000, we trim it just in case,\n // though this simple bubbling strategy typically finishes well below the threshold.\n if (ops.size() > 10000) {\n ops.resize(10000);\n }\n\n cout << ops.size() << \"\\n\";\n for (const auto& op : ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nint N;\nbool obstacle[D][D];\nint grid[D][D];\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n \n // D is always 9\n int dummyD;\n if (N == 9) {\n dummyD = 9;\n } else {\n dummyD = N; // actually D is read first\n cin >> N;\n }\n\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n obstacle[i][j] = false;\n grid[i][j] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n int total_containers = D * D - 1 - N;\n vector> placement;\n vector t_vals;\n\n for (int d = 0; d < total_containers; ++d) {\n int t;\n cin >> t;\n t_vals.push_back(t);\n\n // Simple strategy: place as far as possible from the entrance (0, 4)\n // using BFS to find reachable empty spots\n queue> q;\n vector> dist(D, vector(D, -1));\n q.push({0, 4});\n dist[0][4] = 0;\n\n vector> reachable_empty;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable_empty.push_back({r, c});\n }\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && dist[nr][nc] == -1) {\n if (grid[r][c] == -1 || (r == 0 && c == 4)) {\n dist[nr][nc] = dist[r][c] + 1;\n q.push({nr, nc});\n }\n }\n }\n }\n\n // Pick the furthest reachable empty square\n int best_r = -1, best_c = -1;\n int max_d = -1;\n for (auto [r, c] : reachable_empty) {\n if (dist[r][c] > max_d) {\n max_d = dist[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n grid[best_r][best_c] = t;\n placement.push_back({best_r, best_c});\n cout << best_r << \" \" << best_c << endl;\n }\n\n // Transport out phase\n // Simple greedy: always pick the reachable container with the smallest number\n for (int d = 0; d < total_containers; ++d) {\n queue> q;\n vector> visited(D, vector(D, false));\n q.push({0, 4});\n visited[0][4] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] != -1) {\n reachable_containers.push_back({r, c});\n } else {\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int best_r = -1, best_c = -1;\n int min_val = 1e9;\n for (auto [r, c] : reachable_containers) {\n if (grid[r][c] < min_val) {\n min_val = grid[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n grid[best_r][best_c] = -1;\n cout << best_r << \" \" << best_c << endl;\n }\n\n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nint M;\nint grid[N][N];\nint adj_count[105][105];\nbool target_adj[105][105];\nint color_count[105];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint get_color(int r, int c) {\n if (is_valid(r, c)) return grid[r][c];\n return 0;\n}\n\nbool check_connectivity(int r, int c, int color) {\n if (color_count[color] <= 1) return false;\n \n int start_r = -1, start_c = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if ((i != r || j != c) && grid[i][j] == color) {\n start_r = i; start_c = j;\n break;\n }\n }\n if (start_r != -1) break;\n }\n \n if (start_r == -1) return false;\n \n vector> visited(N, vector(N, false));\n queue> q;\n q.push({start_r, start_c});\n visited[start_r][start_c] = true;\n int count = 1;\n \n while (!q.empty()) {\n auto [curr_r, curr_c] = q.front();\n q.pop();\n \n for (int i = 0; i < 4; ++i) {\n int nr = curr_r + dx[i];\n int nc = curr_c + dy[i];\n \n if (is_valid(nr, nc) && (nr != r || nc != c) && grid[nr][nc] == color && !visited[nr][nc]) {\n visited[nr][nc] = true;\n count++;\n q.push({nr, nc});\n }\n }\n }\n \n return count == color_count[color] - 1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> M >> M)) return 0; // M is used as dummy for N here since N=50 is fixed\n int n = 50;\n M = 100;\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n color_count[grid[i][j]]++;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int c1 = grid[i][j];\n for (int k = 0; k < 4; ++k) {\n int c2 = get_color(i + dx[k], j + dy[k]);\n if (c1 != c2) {\n adj_count[c1][c2]++;\n target_adj[c1][c2] = true;\n }\n }\n }\n }\n \n mt19937 rng(42);\n \n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break;\n \n int r = rng() % n;\n int c = rng() % n;\n \n int old_color = grid[r][c];\n \n vector possible_colors;\n possible_colors.push_back(0);\n for (int k = 0; k < 4; ++k) {\n possible_colors.push_back(get_color(r + dx[k], c + dy[k]));\n }\n \n int new_color = possible_colors[rng() % possible_colors.size()];\n if (old_color == new_color) continue;\n \n set neighbors;\n for (int k = 0; k < 4; ++k) {\n neighbors.insert(get_color(r + dx[k], c + dy[k]));\n }\n \n bool possible = true;\n for (int neighbor_color : neighbors) {\n if (neighbor_color != old_color) {\n if (adj_count[old_color][neighbor_color] <= 1) {\n possible = false;\n break;\n }\n }\n if (neighbor_color != new_color) {\n if (!target_adj[new_color][neighbor_color]) {\n possible = false;\n break;\n }\n }\n }\n \n if (!possible) continue;\n if (!check_connectivity(r, c, old_color)) continue;\n \n // Apply changes\n for (int neighbor_color : neighbors) {\n if (neighbor_color != old_color) {\n adj_count[old_color][neighbor_color]--;\n adj_count[neighbor_color][old_color]--;\n }\n if (neighbor_color != new_color) {\n adj_count[new_color][neighbor_color]++;\n adj_count[neighbor_color][new_color]++;\n }\n }\n \n grid[r][c] = new_color;\n color_count[old_color]--;\n color_count[new_color]++;\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cout << grid[i][j] << (j == n - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, D, Q;\nint queries_used = 0;\n\n// Query the balance scale\nchar query(const vector& L, const vector& R) {\n if (L.empty() || R.empty()) {\n if (L.empty() && R.empty()) return '=';\n return L.empty() ? '<' : '>';\n }\n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << endl;\n \n char res;\n cin >> res;\n queries_used++;\n return res;\n}\n\nchar compare_items(int u, int v) {\n return query({u}, {v});\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> D >> Q)) return 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n\n // Initial sorting of items using available queries\n // We limit sorting queries to save some for refinement\n int max_sort_queries = min(Q / 2, N * 6);\n \n // Sort items based on weight (heaviest to lightest)\n // We use a simple randomized quicksort limited by queries\n mt19937 rng(42);\n \n auto partition = [&](auto& self, int l, int r) -> void {\n if (l >= r || queries_used >= max_sort_queries) return;\n int pivot_idx = l + rng() % (r - l + 1);\n int pivot = items[pivot_idx];\n swap(items[pivot_idx], items[r]);\n \n int i = l;\n for (int j = l; j < r; ++j) {\n if (queries_used >= max_sort_queries) break;\n char res = compare_items(items[j], pivot);\n if (res == '>') { // items[j] > pivot, we want descending\n swap(items[i], items[j]);\n i++;\n }\n }\n swap(items[i], items[r]);\n if (queries_used < max_sort_queries) self(self, l, i - 1);\n if (queries_used < max_sort_queries) self(self, i + 1, r);\n };\n \n partition(partition, 0, N - 1);\n\n // Estimate weights based on rank (exponential distribution assumption)\n vector est_weight(N);\n for (int i = 0; i < N; ++i) {\n est_weight[items[i]] = exp(-i * 3.0 / N); // Heuristic decay\n }\n\n // Initialize groups\n vector> groups(D);\n vector group_weights(D, 0.0);\n vector ans(N);\n\n // Greedy assignment\n for (int i = 0; i < N; ++i) {\n int item = items[i];\n int best_group = 0;\n for (int d = 1; d < D; ++d) {\n if (group_weights[d] < group_weights[best_group]) {\n best_group = d;\n }\n }\n groups[best_group].push_back(item);\n group_weights[best_group] += est_weight[item];\n ans[item] = best_group;\n }\n\n // Refinement phase using remaining queries\n while (queries_used < Q) {\n int g1 = rng() % D;\n int g2 = rng() % D;\n if (g1 == g2) continue;\n if (groups[g1].empty() || groups[g2].empty()) continue;\n\n int idx1 = rng() % groups[g1].size();\n int idx2 = rng() % groups[g2].size();\n int u = groups[g1][idx1];\n int v = groups[g2][idx2];\n\n // Compare the two groups without the elements to see which remainder is heavier\n // Then we can decide if swapping u and v helps balance them.\n // For simplicity, directly compare u and v if we haven't exhausted queries\n if (queries_used < Q) {\n char res = query(groups[g1], groups[g2]);\n if (res == '>') {\n // g1 is heavier, try moving u to g2 and v to g1 if u > v\n char comp = query({u}, {v});\n if (comp == '>') {\n swap(groups[g1][idx1], groups[g2][idx2]);\n ans[u] = g2;\n ans[v] = g1;\n }\n } else if (res == '<') {\n char comp = query({u}, {v});\n if (comp == '<') {\n swap(groups[g1][idx1], groups[g2][idx2]);\n ans[u] = g2;\n ans[v] = g1;\n }\n }\n }\n }\n\n // Output final assignments\n for (int i = 0; i < N; ++i) {\n cout << ans[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << endl;\n\n return 0;\n}","ahc026":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> stacks(m);\n for (int i = 0; i < m; ++i) {\n int count = n / m;\n stacks[i].resize(count);\n for (int j = 0; j < count; ++j) {\n cin >> stacks[i][j];\n }\n }\n\n // Process each box from 1 to n\n for (int v = 1; v <= n; ++v) {\n // Find which stack contains box v\n int s = -1;\n for (int i = 0; i < m; ++i) {\n for (int box : stacks[i]) {\n if (box == v) {\n s = i;\n break;\n }\n }\n if (s != -1) break;\n }\n\n // Move boxes on top of v to other stacks\n while (stacks[s].back() != v) {\n int u = stacks[s].back();\n stacks[s].pop_back();\n\n int best_j = -1;\n int min_diff = INF;\n int fallback_j = -1;\n int max_top = -1;\n\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n \n int top_val = stacks[i].empty() ? INF : stacks[i].back();\n \n if (top_val > u) {\n if (top_val - u < min_diff) {\n min_diff = top_val - u;\n best_j = i;\n }\n }\n \n if (top_val > max_top) {\n max_top = top_val;\n fallback_j = i;\n }\n }\n\n int target_stack = (best_j != -1) ? best_j : fallback_j;\n stacks[target_stack].push_back(u);\n cout << u << \" \" << target_stack + 1 << \"\\n\";\n }\n\n // Carry out box v\n stacks[s].pop_back();\n cout << v << \" 0\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h;\nvector v;\nvector> d;\nvector> visited;\nvector DIJ_R = {0, 1, 0, -1};\nvector DIJ_C = {1, 0, -1, 0};\nstring DIR = \"RDLU\";\nstring ans = \"\";\n\nvoid dfs(int r, int c) {\n visited[r][c] = true;\n for (int dir = 0; dir < 4; ++dir) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = r + dr;\n int c2 = c + dc;\n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N && !visited[r2][c2]) {\n bool can_move = false;\n if (dr == 0) {\n if (v[r][min(c, c2)] == '0') can_move = true;\n } else {\n if (h[min(r, r2)][c] == '0') can_move = true;\n }\n \n if (can_move) {\n ans += DIR[dir];\n dfs(r2, c2);\n ans += DIR[(dir + 2) % 4];\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n\n h.resize(N - 1);\n for (int i = 0; i < N - 1; ++i) {\n cin >> h[i];\n }\n\n v.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> v[i];\n }\n\n d.assign(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 visited.assign(N, vector(N, false));\n dfs(0, 0);\n\n cout << ans << \"\\n\";\n\n return 0;\n}","ahc028":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\nint N, M;\nint start_i, start_j;\nvector grid;\nvector words;\nvector> pos[26];\nint min_dist[26][26];\n\nint manhattan(pair a, pair b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint get_overlap(const string& S, const string& word) {\n if (S.empty()) return 0;\n int max_k = min(5, (int)S.length());\n for (int k = max_k; k >= 1; --k) {\n if (S.substr(S.length() - k) == word.substr(0, k)) {\n return k;\n }\n }\n return 0;\n}\n\nint approx_cost(char last_char, const string& add) {\n int cost = 0;\n char c = last_char;\n for (char nxt : add) {\n cost += min_dist[c - 'A'][nxt - 'A'] + 1;\n c = nxt;\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M)) return 0;\n cin >> start_i >> start_j;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n for (int j = 0; j < N; ++j) {\n pos[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n words.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> words[i];\n }\n\n for (int i = 0; i < 26; ++i) {\n for (int j = 0; j < 26; ++j) {\n min_dist[i][j] = INF;\n if (pos[i].empty() || pos[j].empty()) continue;\n for (auto p1 : pos[i]) {\n for (auto p2 : pos[j]) {\n min_dist[i][j] = min(min_dist[i][j], manhattan(p1, p2));\n }\n }\n }\n }\n\n int best_total_cost = INF;\n vector> best_path;\n\n srand(1337);\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.85) break;\n\n vector remaining(M);\n for (int i = 0; i < M; ++i) remaining[i] = i;\n\n string S = \"\";\n \n while (!remaining.empty()) {\n vector> cands;\n for (int i = 0; i < remaining.size(); ++i) {\n int w_idx = remaining[i];\n if (!S.empty() && S.find(words[w_idx]) != string::npos) {\n cands.push_back({-10000, i});\n continue;\n }\n int k = get_overlap(S, words[w_idx]);\n string add = words[w_idx].substr(k);\n int cost = S.empty() ? 0 : approx_cost(S.back(), add);\n cands.push_back({cost - k * 12, i});\n }\n sort(cands.begin(), cands.end());\n \n int pick_idx = cands[rand() % min((int)cands.size(), 3)].second;\n int w_idx = remaining[pick_idx];\n \n if (S.empty() || S.find(words[w_idx]) == string::npos) {\n int k = get_overlap(S, words[w_idx]);\n S += words[w_idx].substr(k);\n }\n \n remaining.erase(remaining.begin() + pick_idx);\n }\n\n int len = S.length();\n if (len > 5000) continue;\n\n vector> dp(len, vector(225, INF));\n vector> parent(len, vector(225, -1));\n\n for (int k = 0; k < pos[S[0] - 'A'].size(); ++k) {\n auto p = pos[S[0] - 'A'][k];\n int idx = p.first * N + p.second;\n dp[0][idx] = manhattan({start_i, start_j}, p) + 1;\n }\n\n for (int i = 1; i < len; ++i) {\n char prev_c = S[i - 1];\n char curr_c = S[i];\n for (int p_k = 0; p_k < pos[prev_c - 'A'].size(); ++p_k) {\n auto p_prev = pos[prev_c - 'A'][p_k];\n int p_idx = p_prev.first * N + p_prev.second;\n if (dp[i - 1][p_idx] == INF) continue;\n\n for (int c_k = 0; c_k < pos[curr_c - 'A'].size(); ++c_k) {\n auto p_curr = pos[curr_c - 'A'][c_k];\n int c_idx = p_curr.first * N + p_curr.second;\n int cost = dp[i - 1][p_idx] + manhattan(p_prev, p_curr) + 1;\n if (cost < dp[i][c_idx]) {\n dp[i][c_idx] = cost;\n parent[i][c_idx] = p_idx;\n }\n }\n }\n }\n\n int min_cost = INF;\n int last_idx = -1;\n for (int k = 0; k < pos[S.back() - 'A'].size(); ++k) {\n auto p = pos[S.back() - 'A'][k];\n int idx = p.first * N + p.second;\n if (dp[len - 1][idx] < min_cost) {\n min_cost = dp[len - 1][idx];\n last_idx = idx;\n }\n }\n\n if (min_cost < best_total_cost) {\n best_total_cost = min_cost;\n best_path.clear();\n int curr_idx = last_idx;\n for (int i = len - 1; i >= 0; --i) {\n best_path.push_back({curr_idx / N, curr_idx % N});\n curr_idx = parent[i][curr_idx];\n }\n reverse(best_path.begin(), best_path.end());\n }\n }\n\n for (auto p : best_path) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n};\n\nstruct Polyomino {\n int d;\n vector pts;\n int max_i, max_j;\n};\n\nint N, M;\ndouble eps;\nvector fields;\n\nint query_single(int i, int j) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n int res;\n cin >> res;\n return res;\n}\n\nvoid answer(const vector& ans) {\n cout << \"a \" << ans.size();\n for (auto p : ans) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n int res;\n cin >> res;\n if (res == 1) {\n exit(0);\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> eps)) return 0;\n\n fields.resize(M);\n for (int k = 0; k < M; ++k) {\n cin >> fields[k].d;\n fields[k].pts.resize(fields[k].d);\n fields[k].max_i = 0;\n fields[k].max_j = 0;\n for (int p = 0; p < fields[k].d; ++p) {\n cin >> fields[k].pts[p].i >> fields[k].pts[p].j;\n fields[k].max_i = max(fields[k].max_i, fields[k].pts[p].i);\n fields[k].max_j = max(fields[k].max_j, fields[k].pts[p].j);\n }\n }\n\n // A simple approach for demonstration: drill every cell\n // In a competitive implementation, we would use Bayes filtering, MCMC, and noisy subset queries.\n vector has_oil;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int v = query_single(i, j);\n if (v > 0) {\n has_oil.push_back({i, j});\n }\n }\n }\n\n answer(has_oil);\n\n return 0;\n}","ahc031":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int W = 1000;\n\nstruct Rect {\n int i0, j0, i1, j1;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int d_days, n_res;\n int w_input;\n if (!(cin >> w_input >> d_days >> n_res)) return 0;\n\n vector> a(d_days, vector(n_res));\n vector max_a(n_res, 0);\n\n for (int d = 0; d < d_days; ++d) {\n for (int k = 0; k < n_res; ++k) {\n cin >> a[d][k];\n max_a[k] = max(max_a[k], a[d][k]);\n }\n }\n\n // Determine fixed row heights based on maximum required areas across all days\n long long sum_max = 0;\n for (int k = 0; k < n_res; ++k) {\n sum_max += max_a[k];\n }\n\n vector row_height(n_res);\n int current_i = 0;\n vector i0(n_res), i1(n_res);\n\n for (int k = 0; k < n_res; ++k) {\n long long h = (long long)max_a[k] * W / sum_max;\n if (h == 0) h = 1;\n if (k == n_res - 1) {\n h = W - current_i;\n }\n i0[k] = current_i;\n current_i += h;\n if (current_i > W) current_i = W;\n i1[k] = current_i;\n row_height[k] = i1[k] - i0[k];\n }\n\n // Allocate widths within each row\n for (int d = 0; d < d_days; ++d) {\n for (int k = 0; k < n_res; ++k) {\n int area_needed = a[d][k];\n int height = row_height[k];\n int width = (area_needed + height - 1) / height;\n if (width > W) width = W;\n if (width == 0) width = 1;\n \n cout << i0[k] << \" \" << 0 << \" \" << i1[k] << \" \" << width << \"\\n\";\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\nlong long A[9][9];\nlong long S[20][3][3];\nlong long V[9][9];\nOp ops[81];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A[i][j];\n V[i][j] = A[i][j];\n }\n }\n\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 for (int i = 0; i < K; ++i) {\n ops[i] = {-1, -1, -1};\n }\n\n mt19937_64 rng(1337);\n uniform_int_distribution dist_idx(0, K - 1);\n uniform_int_distribution dist_m(-1, M - 1);\n uniform_int_distribution dist_p(0, N - 3);\n uniform_int_distribution dist_q(0, N - 3);\n uniform_real_distribution dist_prob(0.0, 1.0);\n\n double T0 = 2e9;\n double T1 = 1e6;\n double time_limit = 1.95;\n\n long long current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += V[i][j] % MOD;\n }\n }\n\n long long best_score = current_score;\n Op best_ops[81];\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n\n int iter = 0;\n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n double T = T0 * pow(T1 / T0, progress);\n\n int idx = dist_idx(rng);\n Op old_op = ops[idx];\n Op new_op;\n new_op.m = dist_m(rng);\n if (new_op.m == -1) {\n new_op.p = -1;\n new_op.q = -1;\n } else {\n new_op.p = dist_p(rng);\n new_op.q = dist_q(rng);\n }\n\n long long delta = 0;\n \n if (old_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = old_op.p + i;\n int c = old_op.q + j;\n delta -= V[r][c] % MOD;\n V[r][c] -= S[old_op.m][i][j];\n delta += V[r][c] % MOD;\n }\n }\n }\n \n if (new_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = new_op.p + i;\n int c = new_op.q + j;\n delta -= V[r][c] % MOD;\n V[r][c] += S[new_op.m][i][j];\n delta += V[r][c] % MOD;\n }\n }\n }\n\n if (delta >= 0 || dist_prob(rng) < exp(delta / T)) {\n current_score += delta;\n ops[idx] = new_op;\n if (current_score > best_score) {\n best_score = current_score;\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n }\n } else {\n // Rollback\n if (new_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n V[new_op.p + i][new_op.q + j] -= S[new_op.m][i][j];\n }\n }\n }\n if (old_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n V[old_op.p + i][old_op.q + j] += S[old_op.m][i][j];\n }\n }\n }\n }\n }\n iter++;\n }\n\n vector final_ops;\n for (int i = 0; i < K; ++i) {\n if (best_ops[i].m != -1) {\n final_ops.push_back(best_ops[i]);\n }\n }\n\n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_ops) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 // The large crane's operations string. \n // We start with a '.' (wait) for the first turn to safely let the small cranes detonate.\n string ans0 = \".\";\n \n int cr = 0, cc = 0;\n vector taken(N, 0);\n \n // There are N * N containers to transport\n for (int step = 0; step < N * N; ++step) {\n int best_r = -1;\n int min_val = 1e9;\n \n // Greedily pick the smallest available container at the Receiving Gates\n for (int r = 0; r < N; ++r) {\n if (taken[r] < N) {\n if (A[r][taken[r]] < min_val) {\n min_val = A[r][taken[r]];\n best_r = r;\n }\n }\n }\n \n int r = best_r;\n \n // Move to the container\n while (cr > r) { ans0 += 'U'; cr--; }\n while (cr < r) { ans0 += 'D'; cr++; }\n while (cc > 0) { ans0 += 'L'; cc--; }\n while (cc < 0) { ans0 += 'R'; cc++; }\n \n ans0 += 'P'; // Pick up\n \n int c = A[r][taken[r]];\n taken[r]++;\n \n int dst_r = c / N;\n \n // Move to the correct Dispatch Gate\n while (cr > dst_r) { ans0 += 'U'; cr--; }\n while (cr < dst_r) { ans0 += 'D'; cr++; }\n while (cc > N - 1) { ans0 += 'L'; cc--; }\n while (cc < N - 1) { ans0 += 'R'; cc++; }\n \n ans0 += 'Q'; // Drop off\n }\n \n // Output operations for the large crane\n cout << ans0 << \"\\n\";\n \n // Output operations for the small cranes: they all detonate on the first turn\n for (int i = 1; i < N; ++i) {\n cout << \"B\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 int x = 0, y = 0;\n long long load = 0;\n\n while (true) {\n // Process current cell first\n if (load == 0 && h[x][y] > 0) {\n int amt = h[x][y];\n cout << \"+\" << amt << \"\\n\";\n load += amt;\n h[x][y] -= amt;\n continue;\n }\n if (load > 0 && h[x][y] < 0) {\n long long amt = min(load, (long long)-h[x][y]);\n cout << \"-\" << amt << \"\\n\";\n load -= amt;\n h[x][y] += amt;\n continue;\n }\n\n // Check if we are done\n bool done = true;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (h[i][j] != 0) {\n done = false;\n break;\n }\n }\n if (!done) break;\n }\n if (done) break;\n\n // Find the nearest target\n int best_dist = 1e9;\n pair target = {-1, -1};\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (load == 0 && h[i][j] > 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n } else if (load > 0 && h[i][j] < 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n }\n }\n }\n\n // If for some reason we cannot find a target, terminate safely.\n if (target.first == -1) break;\n\n // Move 1 step towards target\n if (x < target.first) {\n x++;\n cout << \"D\\n\";\n } else if (x > target.first) {\n x--;\n cout << \"U\\n\";\n } else if (y < target.second) {\n y++;\n cout << \"R\\n\";\n } else if (y > target.second) {\n y--;\n cout << \"L\\n\";\n }\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Seed {\n int id;\n vector x;\n int sum;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, T;\n if (!(cin >> N >> M >> T)) return 0;\n\n int seed_count = 2 * N * (N - 1);\n vector seeds(seed_count);\n\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].x.resize(M);\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n\n // Precompute a spiral order for placing the best seeds in the center\n vector> placement_order;\n int center_r = N / 2, center_c = N / 2;\n vector> cells;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n cells.push_back({r, c});\n }\n }\n // Sort cells by Manhattan distance to the center\n sort(cells.begin(), cells.end(), [&](const pair& a, const pair& b) {\n int distA = abs(a.first - center_r) + abs(a.second - center_c);\n int distB = abs(b.first - center_r) + abs(b.second - center_c);\n if (distA != distB) return distA < distB;\n return a < b;\n });\n\n for (int t = 0; t < T; t++) {\n // Sort seeds by sum descending\n sort(seeds.begin(), seeds.end(), [](const Seed& a, const Seed& b) {\n return a.sum > b.sum;\n });\n\n vector> A(N, vector(N, 0));\n\n for (int i = 0; i < N * N; i++) {\n A[cells[i].first][cells[i].second] = seeds[i].id;\n }\n\n // Output the grid\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << A[i][j] << (j == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n // Read the new seeds\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N, M, V;\n if (!(cin >> N >> M >> V)) return 0;\n \n vector s(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n \n vector t(N);\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n // A simple single-edge arm as a baseline.\n cout << 2 << endl;\n cout << 0 << \" \" << 1 << endl;\n \n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << endl;\n \n return 0;\n}","ahc039":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n // Optimize standard I/O operations for better performance\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n // Discretize the 100000x100000 space into a BxB grid\n const int B = 400;\n const int MAX_COORD = 100000;\n vector> grid(B, vector(B, 0));\n\n // Read Mackerels (+1)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n if (x == MAX_COORD) x--;\n if (y == MAX_COORD) y--;\n grid[x * B / MAX_COORD][y * B / MAX_COORD]++;\n }\n\n // Read Sardines (-1)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n if (x == MAX_COORD) x--;\n if (y == MAX_COORD) y--;\n grid[x * B / MAX_COORD][y * B / MAX_COORD]--;\n }\n\n int max_sum = -1e9;\n int best_r1 = 0, best_r2 = 0, best_c1 = 0, best_c2 = 0;\n\n // 2D Kadane's Algorithm to find the maximum sum rectangle\n for (int r1 = 0; r1 < B; r1++) {\n vector temp(B, 0);\n for (int r2 = r1; r2 < B; r2++) {\n for (int c = 0; c < B; c++) {\n temp[c] += grid[r2][c];\n }\n int current_sum = 0;\n int c1 = 0;\n for (int c = 0; c < B; c++) {\n current_sum += temp[c];\n if (current_sum > max_sum) {\n max_sum = current_sum;\n best_r1 = r1;\n best_r2 = r2;\n best_c1 = c1;\n best_c2 = c;\n }\n if (current_sum < 0) {\n current_sum = 0;\n c1 = c + 1;\n }\n }\n }\n }\n\n // Re-map the grid coordinates back to the original space\n int x_min = best_r1 * MAX_COORD / B;\n int x_max = (best_r2 + 1) * MAX_COORD / B;\n int y_min = best_c1 * MAX_COORD / B;\n int y_max = (best_c2 + 1) * MAX_COORD / B;\n\n // Output the resulting valid polygon (a rectangle)\n cout << 4 << \"\\n\";\n cout << x_min << \" \" << y_min << \"\\n\";\n cout << x_max << \" \" << y_min << \"\\n\";\n cout << x_max << \" \" << y_max << \"\\n\";\n cout << x_min << \" \" << y_max << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n int r;\n char d;\n int b;\n};\n\nint N, T;\nlong long sigma;\nvector rects;\n\nmt19937 rng(1337);\n\nlong long simulate(const vector& p, long long& out_W, long long& out_H) {\n vector X(N, 0), Y(N, 0), W(N, 0), H(N, 0);\n long long max_X = 0, max_Y = 0;\n\n for (int i = 0; i < N; ++i) {\n if (p[i].r == 1) {\n W[i] = rects[i].h;\n H[i] = rects[i].w;\n } else {\n W[i] = rects[i].w;\n H[i] = rects[i].h;\n }\n\n if (p[i].d == 'U') {\n if (p[i].b == -1) {\n X[i] = 0;\n } else {\n X[i] = X[p[i].b] + W[p[i].b];\n }\n long long cur_y = 0;\n for (int j = 0; j < i; ++j) {\n if (X[i] < X[j] + W[j] && X[j] < X[i] + W[i]) {\n cur_y = max(cur_y, Y[j] + H[j]);\n }\n }\n Y[i] = cur_y;\n } else {\n if (p[i].b == -1) {\n Y[i] = 0;\n } else {\n Y[i] = Y[p[i].b] + H[p[i].b];\n }\n long long cur_x = 0;\n for (int j = 0; j < i; ++j) {\n if (Y[i] < Y[j] + H[j] && Y[j] < Y[i] + H[i]) {\n cur_x = max(cur_x, X[j] + W[j]);\n }\n }\n X[i] = cur_x;\n }\n max_X = max(max_X, X[i] + W[i]);\n max_Y = max(max_Y, Y[i] + H[i]);\n }\n out_W = max_X;\n out_H = max_Y;\n return max_X + max_Y;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> T >> sigma)) return 0;\n\n rects.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> rects[i].w >> rects[i].h;\n }\n\n auto start_time = chrono::steady_clock::now();\n\n for (int t = 0; t < T; ++t) {\n vector best_p(N);\n long long best_score = 4e18;\n\n int iters = 2000; \n for (int it = 0; it < iters; ++it) {\n vector current_p(N);\n for (int i = 0; i < N; ++i) {\n current_p[i].r = rng() % 2;\n current_p[i].d = (rng() % 2 == 0) ? 'U' : 'L';\n if (i == 0) {\n current_p[i].b = -1;\n } else {\n current_p[i].b = (rng() % (i + 1)) - 1;\n }\n }\n\n long long W, H;\n long long score = simulate(current_p, W, H);\n if (score < best_score) {\n best_score = score;\n best_p = current_p;\n }\n }\n\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << \" \" << best_p[i].r << \" \" << best_p[i].d << \" \" << best_p[i].b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_H = 10;\nint N, M, H;\nvector A;\nvector> adj;\n\nstruct State {\n vector p;\n vector> children;\n vector depth;\n vector max_rel_height;\n vector subtree_A;\n long long score;\n\n State() {\n p.assign(N, -1);\n children.resize(N);\n depth.assign(N, 0);\n max_rel_height.assign(N, 0);\n subtree_A.assign(N, 0);\n score = 0;\n for (int i = 0; i < N; ++i) {\n subtree_A[i] = A[i];\n score += A[i];\n }\n }\n\n void dfs(int u) {\n max_rel_height[u] = 0;\n subtree_A[u] = A[u];\n for (int v : children[u]) {\n depth[v] = depth[u] + 1;\n dfs(v);\n max_rel_height[u] = max(max_rel_height[u], max_rel_height[v] + 1);\n subtree_A[u] += subtree_A[v];\n }\n }\n\n void recompute_tree(int root) {\n if (root == -1) return;\n while (p[root] != -1) {\n root = p[root];\n }\n depth[root] = 0;\n dfs(root);\n }\n\n long long compute_total_score() {\n long long total = 0;\n for (int i = 0; i < N; ++i) {\n total += (long long)(depth[i] + 1) * A[i];\n }\n return total + 1;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> M >> H)) return 0;\n\n A.resize(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n\n adj.resize(N);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n State state;\n \n mt19937 rng(42);\n \n double T0 = 100.0;\n double T1 = 0.1;\n long long iter = 0;\n \n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.9) break;\n }\n iter++;\n \n double elapsed = chrono::duration(chrono::steady_clock::now() - start_time).count();\n double progress = elapsed / 1.9;\n if (progress > 1.0) progress = 1.0;\n double temp = T0 * pow(T1 / T0, progress);\n\n int v = rng() % N;\n int num_options = adj[v].size() + 1;\n int opt = rng() % num_options;\n int u = (opt == adj[v].size()) ? -1 : adj[v][opt];\n\n if (state.p[v] == u) continue;\n\n bool cycle = false;\n int curr = u;\n while (curr != -1) {\n if (curr == v) {\n cycle = true;\n break;\n }\n curr = state.p[curr];\n }\n if (cycle) continue;\n\n int new_v_depth = (u == -1) ? 0 : state.depth[u] + 1;\n if (new_v_depth + state.max_rel_height[v] > H) continue;\n\n long long delta_score = (long long)(new_v_depth - state.depth[v]) * state.subtree_A[v];\n\n if (delta_score >= 0 || uniform_real_distribution(0.0, 1.0)(rng) < exp(delta_score / temp)) {\n int old_p = state.p[v];\n if (old_p != -1) {\n for (auto it = state.children[old_p].begin(); it != state.children[old_p].end(); ++it) {\n if (*it == v) {\n state.children[old_p].erase(it);\n break;\n }\n }\n }\n if (u != -1) {\n state.children[u].push_back(v);\n }\n state.p[v] = u;\n\n state.recompute_tree(old_p);\n state.recompute_tree(u);\n state.score += delta_score;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << state.p[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n // Optimize input/output operations\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n \n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n \n vector> moves;\n \n // Helper lambda to apply a move and update the board state\n auto apply = [&](char d, int p) {\n moves.push_back({d, p});\n if (d == 'L') {\n for (int j = 0; j < N - 1; ++j) board[p][j] = board[p][j+1];\n board[p][N-1] = '.';\n } else if (d == 'R') {\n for (int j = N - 1; j > 0; --j) board[p][j] = board[p][j-1];\n board[p][0] = '.';\n } else if (d == 'U') {\n for (int i = 0; i < N - 1; ++i) board[i][p] = board[i+1][p];\n board[N-1][p] = '.';\n } else if (d == 'D') {\n for (int i = N - 1; i > 0; --i) board[i][p] = board[i-1][p];\n board[0][p] = '.';\n }\n };\n\n // Keep removing Oni until the board is clear of them\n while (true) {\n int best_cost = 1e9;\n int best_r = -1, best_c = -1;\n char best_dir = ' ';\n int best_k = 0;\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (board[r][c] != 'x') continue;\n \n // Try Up\n bool ok_u = true;\n for (int i = 0; i < r; ++i) if (board[i][c] == 'o') ok_u = false;\n if (ok_u && 2 * (r + 1) < best_cost) {\n best_cost = 2 * (r + 1); best_r = r; best_c = c; best_dir = 'U'; best_k = r + 1;\n }\n \n // Try Down\n bool ok_d = true;\n for (int i = r + 1; i < N; ++i) if (board[i][c] == 'o') ok_d = false;\n if (ok_d && 2 * (N - r) < best_cost) {\n best_cost = 2 * (N - r); best_r = r; best_c = c; best_dir = 'D'; best_k = N - r;\n }\n \n // Try Left\n bool ok_l = true;\n for (int j = 0; j < c; ++j) if (board[r][j] == 'o') ok_l = false;\n if (ok_l && 2 * (c + 1) < best_cost) {\n best_cost = 2 * (c + 1); best_r = r; best_c = c; best_dir = 'L'; best_k = c + 1;\n }\n \n // Try Right\n bool ok_r = true;\n for (int j = c + 1; j < N; ++j) if (board[r][j] == 'o') ok_r = false;\n if (ok_r && 2 * (N - c) < best_cost) {\n best_cost = 2 * (N - c); best_r = r; best_c = c; best_dir = 'R'; best_k = N - c;\n }\n }\n }\n\n // Break if all Oni 'x' are cleared out\n if (best_cost == 1e9) break;\n\n // Perform the safest minimum action to push and restore \n if (best_dir == 'U') {\n for (int i = 0; i < best_k; ++i) apply('U', best_c);\n for (int i = 0; i < best_k; ++i) apply('D', best_c);\n } else if (best_dir == 'D') {\n for (int i = 0; i < best_k; ++i) apply('D', best_c);\n for (int i = 0; i < best_k; ++i) apply('U', best_c);\n } else if (best_dir == 'L') {\n for (int i = 0; i < best_k; ++i) apply('L', best_r);\n for (int i = 0; i < best_k; ++i) apply('R', best_r);\n } else if (best_dir == 'R') {\n for (int i = 0; i < best_k; ++i) apply('R', best_r);\n for (int i = 0; i < best_k; ++i) apply('L', best_r);\n }\n }\n \n for (auto p : moves) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}","ahc044":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\nint T[N];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, l_input;\n if (!(cin >> n_input >> l_input)) return 0;\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector a(N), b(N);\n vector W0(N), W1(N);\n for (int i = 0; i < N; ++i) {\n W0[i] = (T[i] + 1) / 2;\n W1[i] = T[i] / 2;\n a[i] = i; \n b[i] = i;\n }\n\n vector I(N, 0);\n for (int i = 0; i < N; ++i) {\n I[a[i]] += W0[i];\n I[b[i]] += W1[i];\n }\n\n auto get_cost = [&]() {\n int cost = 0;\n for (int i = 0; i < N; ++i) {\n cost += abs(I[i] - T[i]);\n }\n return cost;\n };\n\n int current_cost = get_cost();\n int best_cost = current_cost;\n vector best_a = a, best_b = b;\n\n mt19937 rng(1337);\n auto start_time = chrono::steady_clock::now();\n\n double t0 = 100.0;\n double t1 = 0.1;\n int iter = 0;\n const int MAX_FAST_ITER = 3000000;\n\n // Fast SA based on expected degrees\n while (true) {\n if ((iter & 16383) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.7) break;\n }\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n \n if (old_v == new_v) continue;\n\n int weight = is_a ? W0[u] : W1[u];\n \n int old_I_old = I[old_v];\n int old_I_new = I[new_v];\n \n int delta = -abs(old_I_old - T[old_v]) - abs(old_I_new - T[new_v])\n + abs((old_I_old - weight) - T[old_v]) + abs((old_I_new + weight) - T[new_v]);\n\n double temp = t0 * pow(t1 / t0, (double)iter / MAX_FAST_ITER); // simple decay\n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_cost += delta;\n I[old_v] -= weight;\n I[new_v] += weight;\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_a = a;\n best_b = b;\n }\n }\n iter++;\n }\n\n auto simulate = [&](const vector& sa, const vector& sb) {\n vector t(N, 0);\n int curr = 0;\n for (int step = 0; step < L; ++step) {\n t[curr]++;\n int next_node = (t[curr] % 2 != 0) ? sa[curr] : sb[curr];\n curr = next_node;\n }\n int diff = 0;\n for (int i = 0; i < N; ++i) {\n diff += abs(t[i] - T[i]);\n }\n return diff;\n };\n\n a = best_a;\n b = best_b;\n current_cost = simulate(a, b);\n best_cost = current_cost;\n \n // Fine-tuning using exact simulation for the remainder of the time\n t0 = 10.0;\n t1 = 0.1;\n iter = 0;\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.95) break;\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n if (old_v == new_v) continue;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_cost = simulate(a, b);\n int delta = new_cost - current_cost;\n\n double temp = t0 * pow(t1 / t0, elapsed / 2.0);\n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_a = a;\n best_b = b;\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct City {\n int lx, rx, ly, ry;\n long long cx, cy;\n};\n\nint N, M, Q, L, W;\nvector G;\nvector cities;\n\nlong long dist_city(int u, int v) {\n long long dx = cities[u].cx - cities[v].cx;\n long long dy = cities[u].cy - cities[v].cy;\n return std::floor(std::sqrt(dx * dx + dy * dy));\n}\n\nlong long calc_mst(const vector& nodes) {\n int k = nodes.size();\n if (k <= 1) return 0;\n vector min_e(k, 1e18);\n vector vis(k, false);\n min_e[0] = 0;\n long long total = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && (v == -1 || min_e[j] < min_e[v])) {\n v = j;\n }\n }\n if (min_e[v] >= 1e18) break;\n vis[v] = true;\n total += min_e[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = dist_city(nodes[v], nodes[j]);\n if (d < min_e[j]) min_e[j] = d;\n }\n }\n }\n return total;\n}\n\nvector> get_mst_edges(const vector& nodes) {\n int k = nodes.size();\n vector> edges;\n if (k <= 1) return edges;\n vector min_e(k, 1e18);\n vector parent(k, -1);\n vector vis(k, false);\n min_e[0] = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && (v == -1 || min_e[j] < min_e[v])) {\n v = j;\n }\n }\n vis[v] = true;\n if (parent[v] != -1) {\n edges.push_back({nodes[parent[v]], nodes[v]});\n }\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = dist_city(nodes[v], nodes[j]);\n if (d < min_e[j]) {\n min_e[j] = d;\n parent[j] = v;\n }\n }\n }\n }\n return edges;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n G.resize(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n cities.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2;\n }\n\n vector assign(N, -1);\n vector> grps(M);\n vector used(N, false);\n vector g_idx(M);\n iota(g_idx.begin(), g_idx.end(), 0);\n sort(g_idx.begin(), g_idx.end(), [&](int a, int b) { return G[a] > G[b]; });\n\n // Greedy Initialization\n for (int k : g_idx) {\n int start = -1;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) { start = i; break; }\n }\n used[start] = true;\n grps[k].push_back(start);\n assign[start] = k;\n \n while ((int)grps[k].size() < G[k]) {\n int best_c = -1;\n long long best_d = 2e18;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n long long d = 0;\n for (int u : grps[k]) {\n long long dx = cities[u].cx - cities[i].cx;\n long long dy = cities[u].cy - cities[i].cy;\n d += dx * dx + dy * dy;\n }\n if (d < best_d) {\n best_d = d;\n best_c = i;\n }\n }\n }\n used[best_c] = true;\n grps[k].push_back(best_c);\n assign[best_c] = k;\n }\n }\n\n vector mst_cost(M);\n for (int i = 0; i < M; ++i) mst_cost[i] = calc_mst(grps[i]);\n\n // Simulated Annealing\n auto start_time = chrono::steady_clock::now();\n double max_time = 1.8;\n int iter = 0;\n mt19937 rng(42);\n uniform_int_distribution dist_N(0, N - 1);\n uniform_real_distribution dist_01(0.0, 1.0);\n \n double t0 = 1000.0, t1 = 1.0;\n\n while (true) {\n if ((iter & 127) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n }\n iter++;\n\n int u = dist_N(rng);\n int v = dist_N(rng);\n if (assign[u] == assign[v]) continue;\n\n int gu = assign[u];\n int gv = assign[v];\n long long old_cost = mst_cost[gu] + mst_cost[gv];\n\n // Swap cities between the two different groups\n for (int& x : grps[gu]) if (x == u) x = v;\n for (int& x : grps[gv]) if (x == v) x = u;\n\n long long new_u_cost = calc_mst(grps[gu]);\n long long new_v_cost = calc_mst(grps[gv]);\n long long new_cost = new_u_cost + new_v_cost;\n\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n double temp = t0 * pow(t1 / t0, elapsed / max_time);\n\n if (new_cost <= old_cost || exp((old_cost - new_cost) / temp) > dist_01(rng)) {\n mst_cost[gu] = new_u_cost;\n mst_cost[gv] = new_v_cost;\n assign[u] = gv;\n assign[v] = gu;\n } else {\n // Revert changes\n for (int& x : grps[gu]) if (x == v) x = u;\n for (int& x : grps[gv]) if (x == u) x = v;\n }\n }\n\n // Since we omit fortune telling querying altogether directly output answers\n cout << \"!\" << endl;\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < G[i]; ++j) {\n cout << grps[i][j] << (j + 1 == G[i] ? \"\" : \" \");\n }\n cout << endl;\n auto edges = get_mst_edges(grps[i]);\n for (auto& e : edges) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& o) const {\n return r == o.r && c == o.c;\n }\n bool operator!=(const Point& o) const {\n return r != o.r || c != o.c;\n }\n};\n\nstruct StateInfo {\n int prev_r, prev_c;\n char action_type;\n char dir;\n};\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_chars[] = {'U', 'D', 'L', 'R'};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, m_input;\n if (!(cin >> n_input >> m_input)) return 0;\n\n vector targets(m_input);\n for (int i = 0; i < m_input; ++i) {\n cin >> targets[i].r >> targets[i].c;\n }\n\n Point curr = targets[0];\n vector> total_actions;\n\n for (int i = 1; i < m_input; ++i) {\n Point target = targets[i];\n \n vector> dist(N, vector(N, 1e9));\n vector> parent(N, vector(N));\n \n queue q;\n q.push(curr);\n dist[curr.r][curr.c] = 0;\n \n while (!q.empty()) {\n Point u = q.front();\n q.pop();\n \n if (u == target) break;\n \n for (int d = 0; d < 4; ++d) {\n // Try Move\n int nr = u.r + dr[d];\n int nc = u.c + dc[d];\n if (is_valid(nr, nc)) {\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'M', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n \n // Try Slide\n nr = u.r;\n nc = u.c;\n while (is_valid(nr + dr[d], nc + dc[d])) {\n nr += dr[d];\n nc += dc[d];\n }\n if (nr != u.r || nc != u.c) { // actually moved\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'S', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n }\n }\n \n // Reconstruct path\n vector> path;\n Point step = target;\n while (step != curr) {\n StateInfo info = parent[step.r][step.c];\n path.push_back({info.action_type, info.dir});\n step = {info.prev_r, info.prev_c};\n }\n \n reverse(path.begin(), path.end());\n for (auto p : path) {\n total_actions.push_back(p);\n }\n \n curr = target;\n }\n\n for (auto p : total_actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}"},"2":{"ahc001":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst double TIME_LIMIT = 4.8; // Leave a small margin\n\nstruct Rect {\n int x1, y1, x2, y2;\n int px, py;\n long long r;\n \n long long area() const {\n return 1LL * (x2 - x1) * (y2 - y1);\n }\n \n double score() const {\n long long s = area();\n if (s == 0) return 0.0;\n double mn = min(r, s);\n double mx = max(r, s);\n double val = 1.0 - mn / mx;\n return 1.0 - val * val;\n }\n \n bool contains(int x, int y) const {\n return x >= x1 && x < x2 && y >= y1 && y < y2;\n }\n \n bool intersects(const Rect& o) const {\n return max(x1, o.x1) < min(x2, o.x2) && max(y1, o.y1) < min(y2, o.y2);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n int n;\n if (!(cin >> n)) return 0;\n \n vector rects(n);\n for (int i = 0; i < n; ++i) {\n cin >> rects[i].px >> rects[i].py >> rects[i].r;\n rects[i].x1 = rects[i].px;\n rects[i].y1 = rects[i].py;\n rects[i].x2 = rects[i].px + 1;\n rects[i].y2 = rects[i].py + 1;\n }\n \n mt19937 rng(42);\n \n auto get_time = [&]() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n };\n \n double initial_temp = 0.1;\n double final_temp = 0.0001;\n \n int iterations = 0;\n while (true) {\n if ((iterations & 255) == 0) {\n double elapsed = get_time();\n if (elapsed > TIME_LIMIT) break;\n }\n iterations++;\n \n double elapsed = get_time();\n double progress = elapsed / TIME_LIMIT;\n double temp = initial_temp * pow(final_temp / initial_temp, progress);\n \n int i = rng() % n;\n int dir = rng() % 4;\n \n Rect old_i = rects[i];\n Rect new_i = old_i;\n \n if (dir == 0) { // left\n int delta = rng() % 100 - 50;\n new_i.x1 += delta;\n if (new_i.x1 < 0) new_i.x1 = 0;\n if (new_i.x1 > old_i.px) new_i.x1 = old_i.px;\n } else if (dir == 1) { // right\n int delta = rng() % 100 - 50;\n new_i.x2 += delta;\n if (new_i.x2 > 10000) new_i.x2 = 10000;\n if (new_i.x2 <= old_i.px) new_i.x2 = old_i.px + 1;\n } else if (dir == 2) { // bottom\n int delta = rng() % 100 - 50;\n new_i.y1 += delta;\n if (new_i.y1 < 0) new_i.y1 = 0;\n if (new_i.y1 > old_i.py) new_i.y1 = old_i.py;\n } else { // top\n int delta = rng() % 100 - 50;\n new_i.y2 += delta;\n if (new_i.y2 > 10000) new_i.y2 = 10000;\n if (new_i.y2 <= old_i.py) new_i.y2 = old_i.py + 1;\n }\n \n if (new_i.x1 == old_i.x1 && new_i.x2 == old_i.x2 && new_i.y1 == old_i.y1 && new_i.y2 == old_i.y2) continue;\n \n int overlap_idx = -1;\n bool valid = true;\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (new_i.intersects(rects[j])) {\n if (overlap_idx == -1) {\n overlap_idx = j;\n } else {\n valid = false;\n break;\n }\n }\n }\n \n if (!valid) continue;\n \n Rect old_j;\n Rect new_j;\n if (overlap_idx != -1) {\n old_j = rects[overlap_idx];\n new_j = old_j;\n \n if (dir == 0) new_j.x2 = new_i.x1;\n else if (dir == 1) new_j.x1 = new_i.x2;\n else if (dir == 2) new_j.y2 = new_i.y1;\n else new_j.y1 = new_i.y2;\n \n if (new_j.x1 > new_j.px || new_j.x2 <= new_j.px || new_j.y1 > new_j.py || new_j.y2 <= new_j.py) {\n continue;\n }\n }\n \n double old_score = old_i.score() + (overlap_idx != -1 ? old_j.score() : 0.0);\n double new_score = new_i.score() + (overlap_idx != -1 ? new_j.score() : 0.0);\n \n if (new_score > old_score || exp((new_score - old_score) / temp) > uniform_real_distribution(0.0, 1.0)(rng)) {\n rects[i] = new_i;\n if (overlap_idx != -1) rects[overlap_idx] = new_j;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n cout << rects[i].x1 << \" \" << rects[i].y1 << \" \" << rects[i].x2 << \" \" << rects[i].y2 << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint t[50][50];\nint p[50][50];\nbool visited[2500];\nint best_score = -1;\nstring best_path = \"\";\nstring current_path = \"\";\nint current_score = 0;\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nauto start_time = chrono::high_resolution_clock::now();\n\nvoid dfs(int r, int c) {\n // Check time limit every 1024 iterations\n static int iter = 0;\n if ((++iter & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1950) {\n return;\n }\n }\n\n if (current_score > best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n\n // Identify valid neighbors\n struct Move {\n int r, c, k, score;\n };\n Move moves[4];\n int num_moves = 0;\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + di[k];\n int nc = c + dj[k];\n if (nr >= 0 && nr < 50 && nc >= 0 && nc < 50) {\n if (!visited[t[nr][nc]]) {\n moves[num_moves++] = {nr, nc, k, p[nr][nc]};\n }\n }\n }\n\n // Sort moves by score in descending order to explore best paths first\n if (num_moves > 1) {\n sort(moves, moves + num_moves, [](const Move& a, const Move& b) {\n return a.score > b.score;\n });\n }\n\n for (int i = 0; i < num_moves; ++i) {\n int nr = moves[i].r;\n int nc = moves[i].c;\n int k = moves[i].k;\n int tile_id = t[nr][nc];\n\n visited[tile_id] = true;\n current_score += p[nr][nc];\n current_path.push_back(dir_char[k]);\n\n dfs(nr, nc);\n\n // Time limit break propagation\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1950) {\n return;\n }\n\n // Backtrack\n current_path.pop_back();\n current_score -= p[nr][nc];\n visited[tile_id] = false;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n \n int max_t = 0;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n max_t = max(max_t, t[i][j]);\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 for (int i = 0; i <= max_t; ++i) visited[i] = false;\n \n current_path.reserve(2500);\n visited[t[si][sj]] = true;\n current_score = p[si][sj];\n \n dfs(si, sj);\n\n cout << best_path << \"\\n\";\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_VAL = 9000;\nconst int MIN_VAL = 1000;\n\nint get_h_edge(int r, int c) {\n return r * 29 + c;\n}\n\nint get_v_edge(int r, int c) {\n return 30 * 29 + r * 30 + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int num_edges = 30 * 29 + 29 * 30;\n vector weights(num_edges, 5000.0);\n vector times_traversed(num_edges, 0);\n\n for (int q = 0; q < 1000; ++q) {\n int sr, sc, tr, tc;\n if (!(cin >> sr >> sc >> tr >> tc)) break;\n\n // Dijkstra's Algorithm\n vector> dist(N, vector(N, 1e18));\n vector>> parent(N, vector>(N, {-1, -1}));\n vector> dir(N, vector(N, ' '));\n \n priority_queue>, vector>>, greater>>> pq;\n \n dist[sr][sc] = 0;\n pq.push({0, {sr, sc}});\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dch[] = {'U', 'D', 'L', 'R'};\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n int r = u.first;\n int c = u.second;\n \n if (d > dist[r][c]) continue;\n if (r == tr && c == tc) break;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int edge_idx = -1;\n if (i == 0) edge_idx = get_v_edge(nr, nc); // U\n else if (i == 1) edge_idx = get_v_edge(r, c); // D\n else if (i == 2) edge_idx = get_h_edge(nr, nc); // L\n else if (i == 3) edge_idx = get_h_edge(r, c); // R\n \n double w = weights[edge_idx];\n if (dist[r][c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n dir[nr][nc] = dch[i];\n pq.push({dist[nr][nc], {nr, nc}});\n }\n }\n }\n }\n \n string path = \"\";\n int cr = tr, cc = tc;\n vector path_edges;\n \n while (cr != sr || cc != sc) {\n path += dir[cr][cc];\n int pr = parent[cr][cc].first;\n int pc = parent[cr][cc].second;\n \n int edge_idx = -1;\n if (dir[cr][cc] == 'U') edge_idx = get_v_edge(cr, cc);\n else if (dir[cr][cc] == 'D') edge_idx = get_v_edge(pr, pc);\n else if (dir[cr][cc] == 'L') edge_idx = get_h_edge(cr, cc);\n else if (dir[cr][cc] == 'R') edge_idx = get_h_edge(pr, pc);\n \n path_edges.push_back(edge_idx);\n cr = pr;\n cc = pc;\n }\n \n reverse(path.begin(), path.end());\n cout << path << endl;\n \n int L;\n cin >> L;\n \n double current_est = 0;\n for (int e : path_edges) {\n current_est += weights[e];\n }\n \n double error = L - current_est;\n \n // Update weights with count-based learning rate decay\n for (int e : path_edges) {\n times_traversed[e]++;\n // Base learning rate modified by 1/sqrt(visits) to ensure convergence\n double lr = 1.0 / sqrt(times_traversed[e] + 1);\n \n double update = (error / path_edges.size()) * lr * 1.5;\n weights[e] += update;\n \n if (weights[e] < MIN_VAL) weights[e] = MIN_VAL;\n if (weights[e] > MAX_VAL) weights[e] = MAX_VAL;\n }\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint M;\nstring S[805];\n\nconst int HASH_SIZE = 16384;\nint head[HASH_SIZE];\nuint64_t keys[805];\nint vals[805];\nint nxt[805];\nint sz = 0;\n\nvoid insert_hash(uint64_t key, int val) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n keys[sz] = key;\n vals[sz] = val;\n nxt[sz] = head[h];\n head[h] = sz++;\n}\n\ninline int get_id(uint64_t key) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n for(int i = head[h]; i != -1; i = nxt[i]) {\n if (keys[i] == key) return vals[i];\n }\n return -1;\n}\n\nint grid[N][N];\nint counts[805];\nbool valid_len[15];\n\ninline int evaluate_cell_change(int r, int c, int old_val, int new_val) {\n int diff = 0;\n \n // Remove old strings\n grid[r][c] = old_val;\n for(int l = 2; l <= 12; ++l) {\n if (!valid_len[l]) continue;\n \n // Horizontal\n for(int start_c = c - l + 1; start_c <= c; ++start_c) {\n uint64_t val = 0;\n int sc = (start_c % N + N) % N;\n bool has_empty = false;\n for(int i = 0; i < l; ++i) {\n int ch = grid[r][(sc + i) % N];\n if (ch == 8) { has_empty = true; break; }\n val = (val << 3) | ch;\n }\n if (!has_empty) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n \n // Vertical\n for(int start_r = r - l + 1; start_r <= r; ++start_r) {\n uint64_t val = 0;\n int sr = (start_r % N + N) % N;\n bool has_empty = false;\n for(int i = 0; i < l; ++i) {\n int ch = grid[(sr + i) % N][c];\n if (ch == 8) { has_empty = true; break; }\n val = (val << 3) | ch;\n }\n if (!has_empty) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n \n // Add new strings\n grid[r][c] = new_val;\n for(int l = 2; l <= 12; ++l) {\n if (!valid_len[l]) continue;\n \n // Horizontal\n for(int start_c = c - l + 1; start_c <= c; ++start_c) {\n uint64_t val = 0;\n int sc = (start_c % N + N) % N;\n bool has_empty = false;\n for(int i = 0; i < l; ++i) {\n int ch = grid[r][(sc + i) % N];\n if (ch == 8) { has_empty = true; break; }\n val = (val << 3) | ch;\n }\n if (!has_empty) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n }\n }\n }\n \n // Vertical\n for(int start_r = r - l + 1; start_r <= r; ++start_r) {\n uint64_t val = 0;\n int sr = (start_r % N + N) % N;\n bool has_empty = false;\n for(int i = 0; i < l; ++i) {\n int ch = grid[(sr + i) % N][c];\n if (ch == 8) { has_empty = true; break; }\n val = (val << 3) | ch;\n }\n if (!has_empty) {\n uint64_t key = ((uint64_t)l << 36) | val;\n int id = get_id(key);\n if (id != -1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n }\n }\n }\n }\n \n return diff;\n}\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n memset(head, -1, sizeof(head));\n memset(valid_len, 0, sizeof(valid_len));\n\n if (!(cin >> M >> M)) return 0;\n \n for(int i = 0; i < M; ++i) {\n cin >> S[i];\n valid_len[S[i].length()] = true;\n uint64_t val = 0;\n for(char c : S[i]) {\n val = (val << 3) | (c - 'A');\n }\n uint64_t key = ((uint64_t)S[i].length() << 36) | val;\n insert_hash(key, i);\n }\n\n mt19937 rng(1337);\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n grid[r][c] = rng() % 8;\n }\n }\n\n memset(counts, 0, sizeof(counts));\n int current_score = 0;\n \n // Initial evaluation\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n for(int l = 2; l <= 12; ++l) {\n if (!valid_len[l]) continue;\n \n // Horizontal starting at (r, c)\n uint64_t val_h = 0;\n for(int i = 0; i < l; ++i) val_h = (val_h << 3) | grid[r][(c + i) % N];\n uint64_t key_h = ((uint64_t)l << 36) | val_h;\n int id_h = get_id(key_h);\n if (id_h != -1) {\n if (counts[id_h] == 0) current_score++;\n counts[id_h]++;\n }\n \n // Vertical starting at (r, c)\n uint64_t val_v = 0;\n for(int i = 0; i < l; ++i) val_v = (val_v << 3) | grid[(r + i) % N][c];\n uint64_t key_v = ((uint64_t)l << 36) | val_v;\n int id_v = get_id(key_v);\n if (id_v != -1) {\n if (counts[id_v] == 0) current_score++;\n counts[id_v]++;\n }\n }\n }\n }\n\n double start_temp = 2.0;\n double end_temp = 0.05;\n double time_limit = 2.9;\n \n int best_grid[N][N];\n int best_score = -1;\n\n int iter = 0;\n while(true) {\n if ((iter & 2047) == 0) {\n double t = get_time();\n if (t > time_limit) break;\n }\n iter++;\n\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val = rng() % 8; \n \n // If all matched, try adding empty cells (represented by 8)\n if (current_score == M && (rng() % 10) == 0) {\n new_val = 8;\n }\n \n if (new_val == old_val) {\n new_val = (new_val + 1) % 8;\n }\n\n int diff = evaluate_cell_change(r, c, old_val, new_val);\n\n double t = get_time() / time_limit;\n double temp = start_temp * pow(end_temp / start_temp, t);\n\n if (diff > 0 || exp(diff / temp) > (double)(rng() % 1000000) / 1000000.0) {\n current_score += diff;\n int empty_count = 0;\n if (current_score == M) {\n for(int ir = 0; ir < N; ++ir)\n for(int ic = 0; ic < N; ++ic)\n if (grid[ir][ic] == 8) empty_count++;\n }\n int actual_score = current_score == M ? M + empty_count : current_score;\n if (actual_score > best_score) {\n best_score = actual_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n // Revert\n evaluate_cell_change(r, c, new_val, old_val);\n }\n }\n\n for(int r = 0; r < N; ++r) {\n string out = \"\";\n for(int c = 0; c < N; ++c) {\n if (best_grid[r][c] == 8) out += '.';\n else out += (char)('A' + best_grid[r][c]);\n }\n cout << out << \"\\n\";\n }\n\n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint N, si, sj;\nvector grid;\nvector> visible;\nvector is_road;\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\ninline int get_id(int r, int c) {\n return r * N + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> si >> sj)) return 0;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n int num_cells = N * N;\n visible.resize(num_cells);\n is_road.assign(num_cells, false);\n int total_roads = 0;\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != '#') {\n is_road[get_id(r, c)] = true;\n total_roads++;\n }\n }\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (!is_road[get_id(r, c)]) continue;\n int u = get_id(r, c);\n \n for (int r2 = r; r2 >= 0; --r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int r2 = r + 1; r2 < N; ++r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int c2 = c - 1; c2 >= 0; --c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n for (int c2 = c + 1; c2 < N; ++c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n }\n }\n\n mt19937 rng(1337);\n uniform_real_distribution dist_rnd(0.5, 1.5);\n\n string best_ans = \"\";\n int best_cost = INF;\n\n vector seen(num_cells, false);\n vector dist(num_cells, INF);\n vector parent(num_cells, -1);\n vector move_dir(num_cells, ' ');\n\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.8) break;\n\n fill(seen.begin(), seen.end(), false);\n int curr_r = si, curr_c = sj;\n int seen_count = 0;\n int current_cost = 0;\n string ans = \"\";\n\n auto mark_seen = [&](int r, int c) {\n int u = get_id(r, c);\n for (int v : visible[u]) {\n if (!seen[v]) {\n seen[v] = true;\n seen_count++;\n }\n }\n };\n\n mark_seen(curr_r, curr_c);\n\n while (seen_count < total_roads) {\n fill(dist.begin(), dist.end(), INF);\n fill(parent.begin(), parent.end(), -1);\n \n priority_queue, vector>, greater>> pq;\n int start_id = get_id(curr_r, curr_c);\n dist[start_id] = 0;\n pq.push({0, start_id});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d > dist[u]) continue;\n\n int r = u / N;\n int c = u % N;\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int v = get_id(nr, nc);\n if (is_road[v]) {\n int cost = grid[nr][nc] - '0';\n if (dist[u] + cost < dist[v]) {\n dist[v] = dist[u] + cost;\n parent[v] = u;\n move_dir[v] = dir_char[i];\n pq.push({dist[v], v});\n }\n }\n }\n }\n }\n\n double best_score = -1.0;\n int best_target = -1;\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = get_id(r, c);\n if (is_road[u] && dist[u] < INF) {\n int unseen = 0;\n for (int v : visible[u]) {\n if (!seen[v]) unseen++;\n }\n if (unseen > 0) {\n double rand_factor = dist_rnd(rng);\n double score = (double)unseen / (dist[u] + 1.0) * rand_factor;\n if (score > best_score) {\n best_score = score;\n best_target = u;\n }\n }\n }\n }\n }\n\n if (best_target == -1) break;\n\n vector path;\n int curr = best_target;\n while (curr != start_id) {\n path.push_back(move_dir[curr]);\n int pr = parent[curr] / N;\n int pc = parent[curr] % N;\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_r--;\n else if (dir == 'D') curr_r++;\n else if (dir == 'L') curr_c--;\n else if (dir == 'R') curr_c++;\n current_cost += grid[curr_r][curr_c] - '0';\n mark_seen(curr_r, curr_c);\n }\n }\n\n fill(dist.begin(), dist.end(), INF);\n fill(parent.begin(), parent.end(), -1);\n priority_queue, vector>, greater>> pq;\n \n int start_id = get_id(curr_r, curr_c);\n dist[start_id] = 0;\n pq.push({0, start_id});\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n\n if (d > dist[u]) continue;\n\n int r = u / N;\n int c = u % N;\n\n if (r == si && c == sj) break;\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int v = get_id(nr, nc);\n if (is_road[v]) {\n int cost = grid[nr][nc] - '0';\n if (dist[u] + cost < dist[v]) {\n dist[v] = dist[u] + cost;\n parent[v] = u;\n move_dir[v] = dir_char[i];\n pq.push({dist[v], v});\n }\n }\n }\n }\n }\n\n vector path;\n int curr = get_id(si, sj);\n while (curr != start_id) {\n path.push_back(move_dir[curr]);\n curr = parent[curr];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_r--;\n else if (dir == 'D') curr_r++;\n else if (dir == 'L') curr_c--;\n else if (dir == 'R') curr_c++;\n current_cost += grid[curr_r][curr_c] - '0';\n }\n\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_ans = ans;\n }\n }\n\n if (best_ans.empty()) {\n cout << \"\" << \"\\n\";\n } else {\n cout << best_ans << \"\\n\";\n }\n\n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector deps;\n vector rev_deps;\n int priority = 0;\n int status = -1; // -1: not started, 0: in progress, 1: completed\n};\n\nstruct Member {\n int id;\n vector s;\n int current_task = -1;\n int start_day = -1;\n};\n\nint main() {\n // Optimize standard I/O operations for performance\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> tasks[i].d[k];\n }\n }\n\n vector in_degree(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n tasks[u].rev_deps.push_back(v);\n tasks[v].deps.push_back(u);\n in_degree[v]++;\n }\n\n // Calculate task priorities (longest path to any sink in the dependency DAG)\n vector dp(N, 0);\n vector topo_order;\n queue q;\n vector in_deg_temp = in_degree;\n for (int i = 0; i < N; ++i) {\n if (in_deg_temp[i] == 0) {\n q.push(i);\n }\n }\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n topo_order.push_back(u);\n for (int v : tasks[u].rev_deps) {\n if (--in_deg_temp[v] == 0) {\n q.push(v);\n }\n }\n }\n \n for (int i = N - 1; i >= 0; --i) {\n int u = topo_order[i];\n dp[u] = 1;\n for (int v : tasks[u].rev_deps) {\n dp[u] = max(dp[u], dp[v] + 1);\n }\n tasks[u].priority = dp[u];\n }\n\n vector members(M);\n for (int i = 0; i < M; ++i) {\n members[i].id = i;\n members[i].s.assign(K, 0.0);\n }\n\n int day = 0;\n int completed_tasks = 0;\n\n while (completed_tasks < N) {\n day++;\n \n vector available_members;\n for (int i = 0; i < M; ++i) {\n if (members[i].current_task == -1) {\n available_members.push_back(i);\n }\n }\n\n vector available_tasks;\n for (int i = 0; i < N; ++i) {\n if (tasks[i].status == -1 && in_degree[i] == 0) {\n available_tasks.push_back(i);\n }\n }\n\n // Sort tasks descending by priority\n sort(available_tasks.begin(), available_tasks.end(), [&](int a, int b) {\n return tasks[a].priority > tasks[b].priority;\n });\n\n vector assign_m;\n vector assign_t;\n\n // Greedily match available members to top available tasks\n while (!available_members.empty() && !available_tasks.empty()) {\n int best_m_idx = -1;\n int best_t_idx = -1;\n double best_score = -1e9;\n\n // Limit the task search pool to ensure high priority tasks are picked\n int search_limit = min((int)available_tasks.size(), (int)available_members.size() + 5);\n\n for (size_t i = 0; i < available_members.size(); ++i) {\n int m_id = available_members[i];\n for (int j = 0; j < search_limit; ++j) {\n int t_id = available_tasks[j];\n \n double expected_w = 0;\n for (int k = 0; k < K; ++k) {\n expected_w += max(0.0, tasks[t_id].d[k] - members[m_id].s[k]);\n }\n double expected_time = max(1.0, expected_w);\n \n // Score balances priority and the estimated time to finish\n double score = tasks[t_id].priority * 10.0 - expected_time;\n \n if (score > best_score) {\n best_score = score;\n best_m_idx = i;\n best_t_idx = j;\n }\n }\n }\n\n int m_id = available_members[best_m_idx];\n int t_id = available_tasks[best_t_idx];\n\n members[m_id].current_task = t_id;\n members[m_id].start_day = day;\n tasks[t_id].status = 0;\n \n assign_m.push_back(m_id + 1);\n assign_t.push_back(t_id + 1);\n\n available_members.erase(available_members.begin() + best_m_idx);\n available_tasks.erase(available_tasks.begin() + best_t_idx);\n }\n\n cout << assign_m.size();\n for (size_t i = 0; i < assign_m.size(); ++i) {\n cout << \" \" << assign_m[i] << \" \" << assign_t[i];\n }\n cout << \"\\n\";\n cout.flush();\n\n int n_finished;\n cin >> n_finished;\n if (n_finished == -1) {\n break;\n }\n\n for (int i = 0; i < n_finished; ++i) {\n int f;\n cin >> f;\n --f;\n \n int t_id = members[f].current_task;\n int actual_time = day - members[f].start_day + 1;\n \n tasks[t_id].status = 1;\n completed_tasks++;\n members[f].current_task = -1;\n \n for (int v : tasks[t_id].rev_deps) {\n in_degree[v]--;\n }\n \n // Skill estimation update\n if (actual_time == 1) {\n for (int k = 0; k < K; ++k) {\n members[f].s[k] = max(members[f].s[k], (double)tasks[t_id].d[k]);\n }\n } else {\n double target_w = max(1.0, (double)actual_time - 1.0);\n double current_w = 0;\n vector active_k;\n for (int k = 0; k < K; ++k) {\n if (tasks[t_id].d[k] > members[f].s[k]) {\n current_w += (tasks[t_id].d[k] - members[f].s[k]);\n active_k.push_back(k);\n }\n }\n \n // Adjust active skills to match target target_w\n if (!active_k.empty()) {\n double diff = current_w - target_w;\n double adjustment = diff / active_k.size();\n \n // Learning rate factor to stabilize updates\n double lr = 0.3; \n for (int k : active_k) {\n members[f].s[k] += lr * adjustment;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n } else if (target_w > 0) {\n // Overestimated skills significantly; uniformly degrade\n double lr = 0.1;\n for (int k = 0; k < K; ++k) {\n if (tasks[t_id].d[k] > 0) {\n members[f].s[k] -= lr * target_w / K;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Order {\n int id;\n int a, b, c, d;\n int dist_to_center;\n};\n\nstruct Point {\n int x, y;\n};\n\nint manhattan(Point p1, Point p2) {\n return abs(p1.x - p2.x) + abs(p1.y - p2.y);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n vector orders(1000);\n for (int i = 0; i < 1000; ++i) {\n orders[i].id = i + 1;\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].dist_to_center = abs(orders[i].a - 400) + abs(orders[i].b - 400) + \n abs(orders[i].c - 400) + abs(orders[i].d - 400);\n }\n\n // Sort by proximity to the center\n sort(orders.begin(), orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_to_center < o2.dist_to_center;\n });\n\n int pool_size = 80;\n mt19937 rng(42);\n\n int best_dist = 2e9;\n vector best_order_ids;\n vector best_route;\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.9) break;\n\n // Randomly select 50 orders from the pool\n vector selected_orders;\n vector indices(pool_size);\n for (int i = 0; i < pool_size; ++i) indices[i] = i;\n shuffle(indices.begin(), indices.end(), rng);\n \n for (int i = 0; i < 50; ++i) {\n selected_orders.push_back(orders[indices[i]]);\n }\n\n vector order_ids;\n for (const auto& o : selected_orders) {\n order_ids.push_back(o.id);\n }\n\n Point current_pos = {400, 400};\n vector route;\n route.push_back(current_pos);\n\n vector picked_up(50, false);\n vector dropped_off(50, false);\n int dropped_count = 0;\n int current_dist = 0;\n\n while (dropped_count < 50) {\n struct Move {\n int id_idx;\n bool is_pickup;\n Point p;\n int dist;\n };\n vector valid_moves;\n\n for (int i = 0; i < 50; ++i) {\n if (!picked_up[i]) {\n valid_moves.push_back({i, true, {selected_orders[i].a, selected_orders[i].b}, \n manhattan(current_pos, {selected_orders[i].a, selected_orders[i].b})});\n } else if (!dropped_off[i]) {\n valid_moves.push_back({i, false, {selected_orders[i].c, selected_orders[i].d}, \n manhattan(current_pos, {selected_orders[i].c, selected_orders[i].d})});\n }\n }\n\n sort(valid_moves.begin(), valid_moves.end(), [](const Move& m1, const Move& m2) {\n return m1.dist < m2.dist;\n });\n\n // Randomized greedy selection\n int selected_idx = 0;\n double r = uniform_real_distribution(0.0, 1.0)(rng);\n if (valid_moves.size() > 1 && r > 0.7) selected_idx = 1;\n if (valid_moves.size() > 2 && r > 0.9) selected_idx = 2;\n\n Move best_move = valid_moves[selected_idx];\n \n if (best_move.is_pickup) {\n picked_up[best_move.id_idx] = true;\n } else {\n dropped_off[best_move.id_idx] = true;\n dropped_count++;\n }\n\n current_dist += best_move.dist;\n current_pos = best_move.p;\n route.push_back(current_pos);\n }\n\n current_dist += manhattan(current_pos, {400, 400});\n route.push_back({400, 400});\n\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_order_ids = order_ids;\n best_route = route;\n }\n }\n\n // Output best orders\n cout << best_order_ids.size();\n for (int id : best_order_ids) {\n cout << \" \" << id;\n }\n cout << \"\\n\";\n\n // Output best route\n cout << best_route.size();\n for (const auto& p : best_route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Disjoint Set Union (DSU) to manage connected components\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\nstruct Edge {\n int id;\n int u;\n int v;\n int expected_d;\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = 400;\n int M = 1995;\n\n vector> points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n\n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v;\n edges[i].id = i;\n double dist = sqrt(pow(points[edges[i].u].first - points[edges[i].v].first, 2) + \n pow(points[edges[i].u].second - points[edges[i].v].second, 2));\n // The length l_i is uniformly distributed between d_i and 3*d_i, so the expected length is 2*d_i.\n edges[i].expected_d = 2 * round(dist);\n }\n\n DSU current_dsu(N);\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n\n // Collect the current edge with its known length, and future edges with their expected lengths\n vector> future_edges;\n future_edges.reserve(M - i);\n future_edges.push_back({l, i});\n for (int j = i + 1; j < M; ++j) {\n future_edges.push_back({edges[j].expected_d, j});\n }\n\n // Sort edges by length to simulate Kruskal's algorithm\n sort(future_edges.begin(), future_edges.end());\n\n DSU temp_dsu = current_dsu;\n bool use_current = false;\n\n // Run Kruskal's to see if the current edge is selected in the MST\n for (auto& edge : future_edges) {\n int e_id = edge.second;\n int u = edges[e_id].u;\n int v = edges[e_id].v;\n\n if (temp_dsu.find(u) != temp_dsu.find(v)) {\n temp_dsu.unite(u, v);\n if (e_id == i) {\n use_current = true;\n break;\n }\n } else if (e_id == i) {\n break;\n }\n }\n\n // Adopt the edge if it's part of the simulated MST\n if (use_current) {\n current_dsu.unite(edges[i].u, edges[i].v);\n cout << 1 << endl;\n } else {\n cout << 0 << endl;\n }\n }\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector px(N), py(N), pt(N);\n for (int i = 0; i < N; ++i) {\n cin >> px[i] >> py[i] >> pt[i];\n }\n\n int M;\n cin >> M;\n vector hx(M), hy(M);\n for (int i = 0; i < M; ++i) {\n cin >> hx[i] >> hy[i];\n }\n\n for (int turn = 0; turn < 300; ++turn) {\n string action = \"\";\n for (int i = 0; i < M; ++i) {\n // A simple dummy strategy: stay in place or random valid action\n // In a real heuristic approach, we would build walls to divide the room.\n action += \".\";\n }\n cout << action << endl;\n\n for (int i = 0; i < N; ++i) {\n string pet_move;\n cin >> pet_move;\n }\n }\n\n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint si, sj, ti, tj;\ndouble p;\nstring h[N], v[N - 1];\nint dist[N][N];\ndouble E[N][N];\ndouble prob[N][N];\ndouble next_prob[N][N];\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nbool can_move(int i, int j, int d) {\n if (d == 0) return i > 0 && v[i - 1][j] == '0';\n if (d == 1) return i < N - 1 && v[i][j] == '0';\n if (d == 2) return j > 0 && h[i][j - 1] == '0';\n if (d == 3) return j < N - 1 && h[i][j] == '0';\n return false;\n}\n\nvoid compute_dist() {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dist[i][j] = 1e9;\n \n queue> q;\n q.push({ti, tj});\n dist[ti][tj] = 0;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n if (can_move(ni, nj, d ^ 1) && dist[ni][nj] > dist[i][j] + 1) {\n dist[ni][nj] = dist[i][j] + 1;\n q.push({ni, nj});\n }\n }\n }\n }\n}\n\nvoid compute_E() {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (dist[i][j] < 1e9) E[i][j] = dist[i][j] / (1.0 - p);\n else E[i][j] = 1e9;\n }\n }\n E[ti][tj] = 0.0;\n \n // Value iteration to find the expected number of turns from each cell\n for (int iter = 0; iter < 1000; ++iter) {\n double max_diff = 0.0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == ti && j == tj) continue;\n double min_val = 1e9;\n for (int d = 0; d < 4; ++d) {\n if (can_move(i, j, d)) {\n int ni = i + di[d];\n int nj = j + dj[d];\n double val = (1.0 + (1.0 - p) * E[ni][nj]) / (1.0 - p);\n if (val < min_val) min_val = val;\n }\n }\n if (min_val < 1e9) {\n max_diff = max(max_diff, abs(E[i][j] - min_val));\n E[i][j] = min_val;\n }\n }\n }\n if (max_diff < 1e-6) break;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n for (int i = 0; i < N; ++i) cin >> h[i];\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n compute_dist();\n compute_E();\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n prob[i][j] = 0.0;\n prob[si][sj] = 1.0;\n\n string ans = \"\";\n for (int step = 0; step < 200; ++step) {\n // Check if we have already mostly reached the target\n if (prob[ti][tj] > 0.9999) break;\n\n int best_d = 0;\n double min_expected_E = 1e18;\n\n for (int d = 0; d < 4; ++d) {\n double expected_E = 0.0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (prob[i][j] < 1e-9) continue;\n \n if (i == ti && j == tj) {\n // Already at target\n } else if (can_move(i, j, d)) {\n int ni = i + di[d];\n int nj = j + dj[d];\n expected_E += prob[i][j] * (p * E[i][j] + (1.0 - p) * E[ni][nj]);\n } else {\n expected_E += prob[i][j] * E[i][j];\n }\n }\n }\n if (expected_E < min_expected_E) {\n min_expected_E = expected_E;\n best_d = d;\n }\n }\n\n ans += dir_char[best_d];\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n next_prob[i][j] = 0.0;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (prob[i][j] == 0) continue;\n \n if (i == ti && j == tj) {\n next_prob[i][j] += prob[i][j];\n continue;\n }\n if (can_move(i, j, best_d)) {\n int ni = i + di[best_d];\n int nj = j + dj[best_d];\n next_prob[ni][nj] += prob[i][j] * (1.0 - p);\n next_prob[i][j] += prob[i][j] * p;\n } else {\n next_prob[i][j] += prob[i][j];\n }\n }\n }\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n prob[i][j] = next_prob[i][j];\n }\n\n cout << ans << \"\\n\";\n return 0;\n}","ahc010":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nconst int TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\n\nint rot(int t, int r) {\n if (t >= 0 && t <= 3) return (t + r) % 4;\n if (t >= 4 && t <= 5) return 4 + (t - 4 + r) % 2;\n if (t >= 6 && t <= 7) return 6 + (t - 6 + r) % 2;\n return t;\n}\n\nint base_grid[30][30];\nint cur_grid[30][30];\nint cur_rot[30][30];\n\nint vis[30][30][4];\nint vis_id = 0;\n\nlong long evaluate() {\n vis_id++;\n int l1 = 0, l2 = 0;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n if (vis[i][j][d] == vis_id) continue;\n int nd = TO[cur_grid[i][j]][d];\n if (nd == -1) continue;\n \n int ci = i, cj = j, cd = d;\n int len = 0;\n \n while (true) {\n if (vis[ci][cj][cd] == vis_id) {\n if (ci == i && cj == j && cd == d) {\n if (len > l1) {\n l2 = l1;\n l1 = len;\n } else if (len > l2) {\n l2 = len;\n }\n }\n break;\n }\n vis[ci][cj][cd] = vis_id;\n int nxt_d = TO[cur_grid[ci][cj]][cd];\n if (nxt_d == -1) break;\n \n int ni = ci + di[nxt_d];\n int nj = cj + dj[nxt_d];\n if (ni < 0 || ni >= 30 || nj < 0 || nj >= 30) break;\n \n ci = ni; \n cj = nj; \n cd = (nxt_d + 2) % 4;\n len++;\n }\n }\n }\n }\n return (long long)l1 * l2;\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ndouble rnd() {\n return (double)(xor128() & 0xFFFFFF) / 16777216.0;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start = chrono::high_resolution_clock::now();\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n base_grid[i][j] = s[j] - '0';\n cur_grid[i][j] = base_grid[i][j];\n cur_rot[i][j] = 0;\n }\n }\n\n long long best_score = evaluate();\n long long current_score = best_score;\n \n int best_rot[30][30];\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n best_rot[i][j] = cur_rot[i][j];\n }\n }\n\n double T0 = 200.0;\n double T1 = 0.1;\n double time_limit = 1.95;\n\n int iters = 0;\n while (true) {\n if ((iters & 255) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n double T = T0 * pow(T1 / T0, progress);\n \n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) % 4;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n long long score = evaluate();\n \n bool accept = false;\n if (score >= current_score) {\n accept = true;\n } else {\n double prob = exp((score - current_score) / T);\n if (rnd() < prob) accept = true;\n }\n \n if (accept) {\n current_score = score;\n if (score > best_score) {\n best_score = score;\n for (int r = 0; r < 30; r++) {\n for (int c = 0; c < 30; c++) {\n best_rot[r][c] = cur_rot[r][c];\n }\n }\n }\n } else {\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n } else {\n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) % 4;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n long long score = evaluate();\n \n if (score >= current_score) {\n current_score = score;\n if (score > best_score) {\n best_score = score;\n for (int r = 0; r < 30; r++) {\n for (int c = 0; c < 30; c++) {\n best_rot[r][c] = cur_rot[r][c];\n }\n }\n }\n } else {\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n }\n iters++;\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n }\n }\n cout << \"\\n\";\n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nint N, T;\nvector> board;\nint empty_r, empty_c;\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dir_char[] = {'U', 'D', 'L', 'R'};\n\nint time_limit_ms = 2800;\n\nint get_tree_size(const vector>& b) {\n int max_size = 0;\n vector> visited(N, vector(N, false));\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (b[i][j] == 0 || visited[i][j]) continue;\n\n int size = 0;\n int edges = 0;\n queue> q;\n q.push({i, j});\n visited[i][j] = true;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n size++;\n\n // Up\n if (r > 0 && (b[r][c] & 2) && (b[r - 1][c] & 8)) {\n edges++;\n if (!visited[r - 1][c]) {\n visited[r - 1][c] = true;\n q.push({r - 1, c});\n }\n }\n // Down\n if (r < N - 1 && (b[r][c] & 8) && (b[r + 1][c] & 2)) {\n edges++;\n if (!visited[r + 1][c]) {\n visited[r + 1][c] = true;\n q.push({r + 1, c});\n }\n }\n // Left\n if (c > 0 && (b[r][c] & 1) && (b[r][c - 1] & 4)) {\n edges++;\n if (!visited[r][c - 1]) {\n visited[r][c - 1] = true;\n q.push({r, c - 1});\n }\n }\n // Right\n if (c < N - 1 && (b[r][c] & 4) && (b[r][c + 1] & 1)) {\n edges++;\n if (!visited[r][c + 1]) {\n visited[r][c + 1] = true;\n q.push({r, c + 1});\n }\n }\n }\n\n // A valid tree has edges / 2 == size - 1 and no cycles in the connected component\n if (edges / 2 == size - 1) {\n max_size = max(max_size, size);\n }\n }\n }\n return max_size;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n if (!(cin >> N >> T)) return 0;\n\n board.assign(N, vector(N));\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n if (s[j] >= '0' && s[j] <= '9') board[i][j] = s[j] - '0';\n else board[i][j] = s[j] - 'a' + 10;\n if (board[i][j] == 0) {\n empty_r = i;\n empty_c = j;\n }\n }\n }\n\n string best_moves = \"\";\n int best_score = get_tree_size(board);\n\n string current_moves = \"\";\n vector> current_board = board;\n int cr = empty_r, cc = empty_c;\n\n srand(1337);\n int iter = 0;\n\n while (true) {\n if ((iter & 1023) == 0) {\n auto current_time = high_resolution_clock::now();\n if (duration_cast(current_time - start_time).count() > time_limit_ms) {\n break;\n }\n }\n iter++;\n\n int d = rand() % 4;\n int nr = cr + dr[d];\n int nc = cc + dc[d];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n swap(current_board[cr][cc], current_board[nr][nc]);\n current_moves += dir_char[d];\n cr = nr;\n cc = nc;\n\n int score = get_tree_size(current_board);\n if (score > best_score) {\n best_score = score;\n best_moves = current_moves;\n }\n\n if (current_moves.length() >= T || (rand() % 1000 == 0)) {\n current_moves = \"\";\n current_board = board;\n cr = empty_r;\n cc = empty_c;\n }\n }\n }\n\n cout << best_moves << \"\\n\";\n\n return 0;\n}","ahc012":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int K = 100;\nint N;\nint a[11];\nint x_coords[10005];\nint y_coords[10005];\n\nstruct Line {\n double theta;\n double r;\n};\n\nLine lines[K];\nuint64_t hashes0[10005];\nuint64_t hashes1[10005];\n\npair, pair> get_points(const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n double px = l.r * cos_t - 20000.0 * sin_t;\n double py = l.r * sin_t + 20000.0 * cos_t;\n double qx = l.r * cos_t + 20000.0 * sin_t;\n double qy = l.r * sin_t - 20000.0 * cos_t;\n return {{round(px), round(py)}, {round(qx), round(qy)}};\n}\n\n// Global buffer for sorting to avoid re-allocations\nstruct HashVal {\n uint64_t h0, h1;\n bool operator<(const HashVal& o) const {\n if (h0 != o.h0) return h0 < o.h0;\n return h1 < o.h1;\n }\n bool operator==(const HashVal& o) const {\n return h0 == o.h0 && h1 == o.h1;\n }\n};\nHashVal h_arr[10005];\n\nint evaluate() {\n for (int i = 0; i < N; ++i) {\n h_arr[i].h0 = hashes0[i];\n h_arr[i].h1 = hashes1[i];\n }\n sort(h_arr, h_arr + N);\n\n int b[11] = {0};\n int current_count = 1;\n for (int i = 1; i < N; ++i) {\n if (h_arr[i] == h_arr[i - 1]) {\n current_count++;\n } else {\n if (current_count <= 10) {\n b[current_count]++;\n }\n current_count = 1;\n }\n }\n if (current_count <= 10) {\n b[current_count]++;\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(a[d], b[d]);\n }\n return score;\n}\n\nvoid update_line_hash(int line_idx, const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n if (line_idx < 64) {\n uint64_t mask = 1ULL << line_idx;\n uint64_t not_mask = ~mask;\n for (int i = 0; i < N; ++i) {\n if (x_coords[i] * cos_t + y_coords[i] * sin_t > l.r) hashes0[i] |= mask;\n else hashes0[i] &= not_mask;\n }\n } else {\n int shift = line_idx - 64;\n uint64_t mask = 1ULL << shift;\n uint64_t not_mask = ~mask;\n for (int i = 0; i < N; ++i) {\n if (x_coords[i] * cos_t + y_coords[i] * sin_t > l.r) hashes1[i] |= mask;\n else hashes1[i] &= not_mask;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int max_k;\n if (!(cin >> N >> max_k)) return 0;\n\n int total_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n total_a += a[i];\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> x_coords[i] >> y_coords[i];\n }\n\n mt19937 rng(42);\n uniform_real_distribution dist_theta(0.0, M_PI);\n uniform_real_distribution dist_r(-9900.0, 9900.0);\n normal_distribution delta_theta(0.0, 0.05);\n normal_distribution delta_r(0.0, 200.0);\n uniform_real_distribution dist_prob(0.0, 1.0);\n\n for (int i = 0; i < K; ++i) {\n lines[i].theta = dist_theta(rng);\n lines[i].r = dist_r(rng);\n update_line_hash(i, lines[i]);\n }\n\n int current_score = evaluate();\n int best_score = current_score;\n \n Line best_lines[K];\n for(int i=0; i(current_time - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n double temp = t0 * pow(t1 / t0, progress);\n \n // Generate neighbor\n int idx = rng() % K;\n Line old_line = lines[idx];\n\n if (rng() % 5 == 0) {\n lines[idx].theta = dist_theta(rng);\n lines[idx].r = dist_r(rng);\n } else {\n lines[idx].theta += delta_theta(rng);\n lines[idx].r += delta_r(rng);\n }\n \n update_line_hash(idx, lines[idx]);\n int new_score = evaluate();\n\n bool accept = false;\n if (new_score >= current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (dist_prob(rng) < prob) accept = true;\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n for(int i=0; i= current_score) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n for(int i=0; i\n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int MAXN = 65;\n\nstruct Point {\n int x, y;\n bool operator==(const Point& o) const { return x == o.x && y == o.y; }\n};\n\nstruct Move {\n Point p1, p2, p3, p4;\n};\n\nint N, M;\nPoint center;\nvector initial_dots;\nint weight[MAXN][MAXN];\n\ndouble get_time() {\n static auto start = high_resolution_clock::now();\n return duration(high_resolution_clock::now() - start).count();\n}\n\nstruct State {\n bool has_dot[MAXN][MAXN];\n int edges[4][MAXN][MAXN]; \n // 0: dx=1, dy=0\n // 1: dx=0, dy=1\n // 2: dx=1, dy=1\n // 3: dx=1, dy=-1\n vector dots;\n vector moves;\n int score;\n\n State() {\n for (int i = 0; i < MAXN; ++i) {\n for (int j = 0; j < MAXN; ++j) {\n has_dot[i][j] = false;\n for (int k = 0; k < 4; ++k) edges[k][i][j] = 0;\n }\n }\n score = 0;\n }\n\n void add_dot(Point p) {\n has_dot[p.x][p.y] = true;\n dots.push_back(p);\n score += weight[p.x][p.y];\n }\n\n bool check_edge(Point p1, Point p2) const {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = -1;\n if (step_y == 0) type = 0;\n else if (step_x == 0) type = 1;\n else if (step_x == step_y) type = 2;\n else type = 3;\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n if (edges[type][ex][ey]) return false;\n if ((cx != p1.x || cy != p1.y) && has_dot[cx][cy]) return false;\n cx = nx; cy = ny;\n }\n return true;\n }\n\n void mark_edge(Point p1, Point p2, int val) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = -1;\n if (step_y == 0) type = 0;\n else if (step_x == 0) type = 1;\n else if (step_x == step_y) type = 2;\n else type = 3;\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n edges[type][ex][ey] += val;\n cx = nx; cy = ny;\n }\n }\n\n bool is_valid_rect(Point p1, Point p2, Point p3, Point p4) const {\n if (has_dot[p1.x][p1.y]) return false;\n if (!has_dot[p2.x][p2.y] || !has_dot[p3.x][p3.y] || !has_dot[p4.x][p4.y]) return false;\n if (!check_edge(p1, p2)) return false;\n if (!check_edge(p2, p3)) return false;\n if (!check_edge(p3, p4)) return false;\n if (!check_edge(p4, p1)) return false;\n return true;\n }\n\n void apply_move(const Move& m) {\n add_dot(m.p1);\n mark_edge(m.p1, m.p2, 1);\n mark_edge(m.p2, m.p3, 1);\n mark_edge(m.p3, m.p4, 1);\n mark_edge(m.p4, m.p1, 1);\n moves.push_back(m);\n }\n \n bool inside(int x, int y) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n center = {(N - 1) / 2, (N - 1) / 2};\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n weight[i][j] = (i - center.x) * (i - center.x) + (j - center.y) * (j - center.y) + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_dots.push_back({x, y});\n }\n\n State best_state;\n best_state.score = -1;\n\n // Fast randomized greedy search\n while (get_time() < 4.8) {\n State state;\n for (auto p : initial_dots) state.add_dot(p);\n\n bool moved = true;\n while (moved && get_time() < 4.8) {\n moved = false;\n vector candidates;\n\n for (int i = 0; i < state.dots.size(); ++i) {\n for (int j = 0; j < state.dots.size(); ++j) {\n if (i == j) continue;\n Point p2 = state.dots[i];\n Point p4 = state.dots[j];\n \n int mx = p2.x + p4.x;\n int my = p2.y + p4.y;\n int dx = p4.x - p2.x;\n int dy = p4.y - p2.y;\n\n if ((mx + dy) % 2 != 0 || (my - dx) % 2 != 0) continue;\n\n Point p1 = {(mx - dy) / 2, (my + dx) / 2};\n Point p3 = {(mx + dy) / 2, (my - dx) / 2};\n\n if (!state.inside(p1.x, p1.y) || !state.inside(p3.x, p3.y)) continue;\n \n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n }\n }\n\n if (!candidates.empty()) {\n Move best_m = candidates[0];\n int best_val = -1;\n for (const auto& m : candidates) {\n int val = weight[m.p1.x][m.p1.y] + (rand() % 10); // tie breaker with slight randomness\n if (val > best_val) {\n best_val = val;\n best_m = m;\n }\n }\n state.apply_move(best_m);\n moved = true;\n }\n }\n\n if (state.score > best_state.score) {\n best_state = state;\n }\n }\n\n cout << best_state.moves.size() << \"\\n\";\n for (const auto& m : best_state.moves) {\n cout << m.p1.x << \" \" << m.p1.y << \" \" \n << m.p2.x << \" \" << m.p2.y << \" \" \n << m.p3.x << \" \" << m.p3.y << \" \" \n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Board {\n int grid[10][10] = {0};\n\n void add_candy(int flavor, int p) {\n int empty_count = 0;\n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] == 0) {\n empty_count++;\n if (empty_count == p) {\n grid[r][c] = flavor;\n return;\n }\n }\n }\n }\n }\n\n // 0: F, 1: B, 2: L, 3: R\n bool tilt(int dir) {\n bool changed = false;\n if (dir == 0) { // F\n for (int c = 0; c < 10; ++c) {\n int write_idx = 0;\n for (int r = 0; r < 10; ++r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 1) { // B\n for (int c = 0; c < 10; ++c) {\n int write_idx = 9;\n for (int r = 9; r >= 0; --r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n } else if (dir == 2) { // L\n for (int r = 0; r < 10; ++r) {\n int write_idx = 0;\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 3) { // R\n for (int r = 0; r < 10; ++r) {\n int write_idx = 9;\n for (int c = 9; c >= 0; --c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n }\n return changed;\n }\n\n int calc_score() const {\n bool vis[10][10] = {false};\n int score = 0;\n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n\n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0 && !vis[r][c]) {\n int flavor = grid[r][c];\n int sz = 0;\n vector> q;\n q.push_back({r, c});\n vis[r][c] = true;\n int head = 0;\n while (head < q.size()) {\n auto [cr, cc] = q[head++];\n sz++;\n for (int i = 0; i < 4; ++i) {\n int nr = cr + dr[i], nc = cc + dc[i];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !vis[nr][nc] && grid[nr][nc] == flavor) {\n vis[nr][nc] = true;\n q.push_back({nr, nc});\n }\n }\n }\n score += sz * sz;\n }\n }\n }\n return score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n vector f(100);\n for (int i = 0; i < 100; ++i) {\n cin >> f[i];\n }\n\n Board b;\n mt19937 rng(42);\n char dir_chars[] = {'F', 'B', 'L', 'R'};\n\n for (int t = 1; t <= 100; ++t) {\n int p;\n cin >> p;\n b.add_candy(f[t - 1], p);\n\n if (t == 100) break;\n\n auto start_time = high_resolution_clock::now();\n \n long long total_score[4] = {0};\n int playouts[4] = {0};\n bool valid[4] = {false};\n Board next_b[4];\n\n for (int d = 0; d < 4; ++d) {\n next_b[d] = b;\n valid[d] = next_b[d].tilt(d);\n }\n\n int loop_count = 0;\n while (true) {\n if ((++loop_count & 15) == 0) {\n auto now = high_resolution_clock::now();\n if (duration_cast(now - start_time).count() > 15) {\n break;\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n if (!valid[d]) continue;\n Board sim_b = next_b[d];\n for (int sim_t = t + 1; sim_t <= 100; ++sim_t) {\n int empty_cells = 100 - sim_t + 1;\n int sim_p = uniform_int_distribution(1, empty_cells)(rng);\n sim_b.add_candy(f[sim_t - 1], sim_p);\n if (sim_t < 100) {\n int r_move = uniform_int_distribution(0, 3)(rng);\n sim_b.tilt(r_move);\n }\n }\n total_score[d] += sim_b.calc_score();\n playouts[d]++;\n }\n }\n\n int best_dir = 0;\n double best_avg = -1.0;\n for (int d = 0; d < 4; ++d) {\n if (playouts[d] > 0) {\n double avg = (double)total_score[d] / playouts[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_dir = d;\n }\n }\n }\n\n if (best_avg < 0) {\n best_dir = uniform_int_distribution(0, 3)(rng);\n }\n\n b.tilt(best_dir);\n cout << dir_chars[best_dir] << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n\n int N = 100;\n \n // Find the smallest N that provides enough separation\n for (int n = 4; n <= 100; ++n) {\n int v = n * (n - 1) / 2;\n if (eps == 0.0) {\n if (v >= M - 1) {\n N = n;\n break;\n }\n } else {\n double gap = (double)v / max(1, M - 1);\n double stddev = sqrt(v * eps * (1.0 - eps));\n // Require the gap to be at least ~5 standard deviations for safety\n if (gap >= 5.0 * stddev) {\n N = n;\n break;\n }\n }\n }\n\n int V = N * (N - 1) / 2;\n \n // Choose edge counts for each of the M graphs evenly spaced from 0 to V\n vector target_edges(M);\n for (int i = 0; i < M; ++i) {\n if (M == 1) {\n target_edges[i] = V / 2;\n } else {\n target_edges[i] = round((double)i * V / (M - 1));\n }\n }\n\n // Output N and the graphs\n cout << N << \"\\n\";\n for (int i = 0; i < M; ++i) {\n string g = \"\";\n for (int j = 0; j < target_edges[i]; ++j) {\n g += \"1\";\n }\n for (int j = target_edges[i]; j < V; ++j) {\n g += \"0\";\n }\n cout << g << \"\\n\";\n }\n cout << flush;\n\n // Process the 100 queries\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n int edges = 0;\n for (char c : H) {\n if (c == '1') edges++;\n }\n \n int best_guess = 0;\n double best_diff = 1e9;\n \n for (int i = 0; i < M; ++i) {\n double expected_edges = target_edges[i] * (1.0 - eps) + (V - target_edges[i]) * eps;\n double diff = abs(edges - expected_edges);\n if (diff < best_diff) {\n best_diff = diff;\n best_guess = i;\n }\n }\n \n cout << best_guess << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Edge {\n int id;\n int u, v;\n long long w;\n double x, y; // midpoint\n};\n\nstruct GraphEdge {\n int to;\n long long w;\n int id;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n\n vector edges(M);\n vector> adj(N);\n\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; \n edges[i].v--;\n edges[i].id = i;\n adj[edges[i].u].push_back({edges[i].v, edges[i].w, i});\n adj[edges[i].v].push_back({edges[i].u, edges[i].w, i});\n }\n\n vector> coords(N);\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n for (int i = 0; i < M; ++i) {\n edges[i].x = (coords[edges[i].u].first + coords[edges[i].v].first) / 2.0;\n edges[i].y = (coords[edges[i].u].second + coords[edges[i].v].second) / 2.0;\n }\n\n mt19937 rng(42);\n vector eval_sources(min(N, 40));\n iota(eval_sources.begin(), eval_sources.end(), 0);\n shuffle(eval_sources.begin(), eval_sources.end(), rng);\n\n auto evaluate = [&](const vector& ans) -> long long {\n long long score = 0;\n for (int day = 1; day <= D; ++day) {\n for (int src : eval_sources) {\n vector dist(N, 1e9);\n priority_queue, vector>, greater>> pq;\n \n dist[src] = 0;\n pq.push({0, src});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (const auto& edge : adj[u]) {\n if (ans[edge.id] == day) continue;\n if (dist[edge.to] > d + edge.w) {\n dist[edge.to] = d + edge.w;\n pq.push({dist[edge.to], edge.to});\n }\n }\n }\n for (int i = 0; i < N; ++i) {\n score += dist[i];\n }\n }\n }\n return score;\n };\n\n vector best_ans(M, 1);\n long long best_score = -1;\n\n int num_candidates = 50;\n for (int iter = 0; iter < num_candidates; ++iter) {\n double angle = uniform_real_distribution(0, 2 * M_PI)(rng);\n double cos_a = cos(angle);\n double sin_a = sin(angle);\n\n vector> proj(M);\n for (int i = 0; i < M; ++i) {\n proj[i] = {edges[i].x * cos_a + edges[i].y * sin_a, i};\n }\n\n sort(proj.begin(), proj.end());\n\n vector current_ans(M);\n for (int i = 0; i < M; ++i) {\n current_ans[proj[i].second] = (i % D) + 1;\n }\n\n long long current_score = evaluate(current_ans);\n if (best_score == -1 || current_score < best_score) {\n best_score = current_score;\n best_ans = current_ans;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n cout << best_ans[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint D;\n\nstruct Point {\n int x, y, z;\n bool operator==(const Point& o) const { return x == o.x && y == o.y && z == o.z; }\n bool operator<(const Point& o) const {\n if (x != o.x) return x < o.x;\n if (y != o.y) return y < o.y;\n return z < o.z;\n }\n Point operator+(const Point& o) const { return {x + o.x, y + o.y, z + o.z}; }\n Point operator-(const Point& o) const { return {x - o.x, y - o.y, z - o.z}; }\n};\n\nvector get_neighbors(Point p) {\n return {\n {p.x + 1, p.y, p.z}, {p.x - 1, p.y, p.z},\n {p.x, p.y + 1, p.z}, {p.x, p.y - 1, p.z},\n {p.x, p.y, p.z + 1}, {p.x, p.y, p.z - 1}\n };\n}\n\n// 24 rotations\nPoint rotate(Point p, int rot) {\n int x = p.x, y = p.y, z = p.z;\n int nx, ny, nz;\n // 6 faces\n int face = rot / 4;\n if (face == 0) { nx = x; ny = y; nz = z; }\n else if (face == 1) { nx = x; ny = -z; nz = y; }\n else if (face == 2) { nx = x; ny = -y; nz = -z; }\n else if (face == 3) { nx = x; ny = z; nz = -y; }\n else if (face == 4) { nx = y; ny = -x; nz = z; }\n else if (face == 5) { nx = -y; ny = x; nz = z; }\n \n // 4 rotations around X axis equivalent\n int roll = rot % 4;\n for (int i = 0; i < roll; ++i) {\n int tx = nx;\n nx = -nz;\n nz = tx;\n }\n return {nx, ny, nz};\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> D)) return 0;\n\n auto read_grid = [&]() {\n vector grid(D);\n for (int i = 0; i < D; ++i) cin >> grid[i];\n return grid;\n };\n\n vector f1 = read_grid();\n vector r1 = read_grid();\n vector f2 = read_grid();\n vector r2 = read_grid();\n\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n vector c1, c2;\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (f1[z][x] == '1' && r1[z][y] == '1') c1.push_back({x, y, z});\n if (f2[z][x] == '1' && r2[z][y] == '1') c2.push_back({x, y, z});\n }\n }\n }\n\n mt19937 rng(42);\n\n int block_id = 0;\n while (!c1.empty() && !c2.empty()) {\n shuffle(c1.begin(), c1.end(), rng);\n shuffle(c2.begin(), c2.end(), rng);\n\n Point start1 = c1.back();\n Point start2 = c2.back();\n int rot = uniform_int_distribution(0, 23)(rng);\n\n vector b1_pts = {start1};\n vector b2_pts = {start2};\n \n c1.pop_back();\n c2.pop_back();\n\n b1[start1.x][start1.y][start1.z] = -1;\n b2[start2.x][start2.y][start2.z] = -1;\n\n bool grown = true;\n while (grown) {\n grown = false;\n for (Point p1 : b1_pts) {\n vector n1s = get_neighbors(p1);\n shuffle(n1s.begin(), n1s.end(), rng);\n for (Point n1 : n1s) {\n if (n1.x < 0 || n1.x >= D || n1.y < 0 || n1.y >= D || n1.z < 0 || n1.z >= D) continue;\n \n auto it1 = find(c1.begin(), c1.end(), n1);\n if (it1 != c1.end()) {\n Point offset1 = n1 - start1;\n Point offset2 = rotate(offset1, rot);\n Point n2 = start2 + offset2;\n \n if (n2.x >= 0 && n2.x < D && n2.y >= 0 && n2.y < D && n2.z >= 0 && n2.z < D) {\n auto it2 = find(c2.begin(), c2.end(), n2);\n if (it2 != c2.end()) {\n b1_pts.push_back(n1);\n b2_pts.push_back(n2);\n b1[n1.x][n1.y][n1.z] = -1;\n b2[n2.x][n2.y][n2.z] = -1;\n c1.erase(it1);\n c2.erase(it2);\n grown = true;\n break;\n }\n }\n }\n }\n if (grown) break;\n }\n }\n\n block_id++;\n for (Point p : b1_pts) b1[p.x][p.y][p.z] = block_id;\n for (Point p : b2_pts) b2[p.x][p.y][p.z] = block_id;\n }\n\n for (Point p : c1) {\n block_id++;\n b1[p.x][p.y][p.z] = block_id;\n }\n for (Point p : c2) {\n block_id++;\n b2[p.x][p.y][p.z] = block_id;\n }\n\n cout << block_id << \"\\n\";\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n cout << b1[x][y][z] << (x == D - 1 && y == D - 1 && z == D - 1 ? \"\" : \" \");\n }\n }\n }\n cout << \"\\n\";\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n cout << b2[x][y][z] << (x == D - 1 && y == D - 1 && z == D - 1 ? \"\" : \" \");\n }\n }\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nlong long dist_sq(long long x1, long long y1, long long x2, long long y2) {\n return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n}\n\nstruct Edge {\n int id, u, v;\n long long w;\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = find(parent[i]);\n }\n void unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n }\n }\n};\n\nint N, M, K;\nvector> stations;\nvector edges;\nvector> residents;\nvector> dist_sr; // distance squared between station and resident\n\n// Precomputed closest stations for each resident\nvector> closest_stations;\n\nlong long compute_cost(const vector& P, vector& edge_used) {\n long long cost = 0;\n for (int i = 0; i < N; ++i) cost += P[i] * P[i];\n\n DSU dsu(N);\n vector>> adj(N);\n vector degree(N, 0);\n edge_used.assign(M, 0);\n\n for (const auto& e : edges) {\n if (dsu.find(e.u) != dsu.find(e.v)) {\n dsu.unite(e.u, e.v);\n adj[e.u].push_back({e.v, e.id});\n adj[e.v].push_back({e.u, e.id});\n degree[e.u]++;\n degree[e.v]++;\n edge_used[e.id] = 1;\n }\n }\n\n vector leaves;\n for (int i = 1; i < N; ++i) {\n if (degree[i] == 1 && P[i] == 0) leaves.push_back(i);\n }\n\n while (!leaves.empty()) {\n int u = leaves.back();\n leaves.pop_back();\n if (u == 0 || P[u] > 0 || degree[u] != 1) continue;\n\n for (auto& edge_info : adj[u]) {\n int v = edge_info.first;\n int e_id = edge_info.second;\n if (edge_used[e_id]) {\n edge_used[e_id] = 0;\n degree[u]--;\n degree[v]--;\n if (v != 0 && degree[v] == 1 && P[v] == 0) {\n leaves.push_back(v);\n }\n }\n }\n }\n\n for (int i = 0; i < M; ++i) {\n if (edge_used[i]) cost += edges[i].w;\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M >> K)) return 0;\n\n stations.resize(N);\n for (int i = 0; i < N; ++i) cin >> stations[i].first >> stations[i].second;\n\n edges.resize(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; edges[i].v--;\n }\n sort(edges.begin(), edges.end()); // Keep edges sorted for Kruskal\n\n residents.resize(K);\n for (int i = 0; i < K; ++i) cin >> residents[i].first >> residents[i].second;\n\n dist_sr.assign(N, vector(K));\n closest_stations.assign(K, vector());\n\n for (int i = 0; i < K; ++i) {\n vector> dists;\n for (int j = 0; j < N; ++j) {\n long long d = dist_sq(residents[i].first, residents[i].second, stations[j].first, stations[j].second);\n dist_sr[j][i] = d;\n dists.push_back({d, j});\n }\n sort(dists.begin(), dists.end());\n for (int j = 0; j < min(15, N); ++j) {\n closest_stations[i].push_back(dists[j].second);\n }\n }\n\n vector assignment(K);\n vector> station_dists(N);\n vector P(N, 0);\n\n for (int i = 0; i < K; ++i) {\n int best_station = closest_stations[i][0];\n assignment[i] = best_station;\n station_dists[best_station].insert(dist_sr[best_station][i]);\n }\n\n auto get_P = [&](int u) {\n if (station_dists[u].empty()) return 0LL;\n long long max_d = *station_dists[u].rbegin();\n long long req_p = ceil(sqrt(max_d));\n while (req_p * req_p < max_d) req_p++;\n return req_p;\n };\n\n for (int i = 0; i < N; ++i) P[i] = get_P(i);\n\n vector best_edge_used;\n long long current_cost = compute_cost(P, best_edge_used);\n long long best_cost = current_cost;\n vector best_P = P;\n\n mt19937 rng(42);\n uniform_int_distribution rand_res(0, K - 1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n\n double T0 = 1e6;\n double T1 = 1e2;\n int iter = 0;\n\n while (true) {\n if ((iter & 127) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.90) break;\n }\n iter++;\n\n double progress = iter / 30000.0; // rough max iterations estimate\n if (progress > 1.0) progress = 1.0;\n double T = T0 * pow(T1 / T0, progress);\n\n int r = rand_res(rng);\n int old_s = assignment[r];\n \n uniform_int_distribution rand_cand(0, closest_stations[r].size() - 1);\n int new_s = closest_stations[r][rand_cand(rng)];\n\n if (old_s == new_s) continue;\n\n long long old_d = dist_sr[old_s][r];\n long long new_d = dist_sr[new_s][r];\n\n station_dists[old_s].erase(station_dists[old_s].find(old_d));\n station_dists[new_s].insert(new_d);\n assignment[r] = new_s;\n\n long long old_P_old = P[old_s], old_P_new = P[new_s];\n P[old_s] = get_P(old_s);\n P[new_s] = get_P(new_s);\n\n vector temp_edge_used;\n long long new_cost = compute_cost(P, temp_edge_used);\n\n if (new_cost < current_cost || rand_prob(rng) < exp((current_cost - new_cost) / T)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_P = P;\n best_edge_used = temp_edge_used;\n }\n } else {\n // Revert\n station_dists[old_s].insert(old_d);\n station_dists[new_s].erase(station_dists[new_s].find(new_d));\n assignment[r] = old_s;\n P[old_s] = old_P_old;\n P[new_s] = old_P_new;\n }\n }\n\n vector final_edge_used(M, 0);\n compute_cost(best_P, final_edge_used); // Update one last time with the best parameters\n\n for (int i = 0; i < N; ++i) cout << best_P[i] << (i == N - 1 ? \"\" : \" \");\n cout << \"\\n\";\n for (int i = 0; i < M; ++i) cout << final_edge_used[i] << (i == M - 1 ? \"\" : \" \");\n cout << \"\\n\";\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Swap {\n int x1, y1, x2, y2;\n};\n\nint main() {\n // Optimize standard I/O operations for performance\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::steady_clock::now();\n\n int N = 30;\n vector> orig_b(N, vector(N, 0));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> orig_b[i][j];\n }\n }\n\n vector best_ops;\n int best_ops_size = 1e9; // Initialize with a large number\n\n mt19937 rng(42);\n\n int iter = 0;\n // Run the randomized multi-start algorithm within a safe time limit (1.85 seconds)\n while (true) {\n if ((iter & 63) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.85) break;\n }\n iter++;\n\n vector> b = orig_b;\n vector ops;\n ops.reserve(4000); // Reserve memory to prevent reallocations\n\n bool changed = true;\n while (changed) {\n changed = false;\n \n // Randomly choose pass direction\n bool bottom_up = rng() % 2;\n \n if (bottom_up) {\n for (int x = N - 2; x >= 0; --x) {\n for (int y = 0; y <= x; ++y) {\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n // Mostly pick the smaller child to maintain good progress, \n // but occasionally pick a random child to explore different state paths\n if (rng() % 100 < 90) { \n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (rng() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n } else {\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (rng() % 100 < 90) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (rng() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n }\n }\n \n // Update the best sequence found\n if (ops.size() < best_ops_size) {\n best_ops_size = ops.size();\n best_ops = std::move(ops);\n }\n }\n\n // Safety constraint to satisfy problem limits\n if (best_ops.size() > 10000) {\n best_ops.resize(10000);\n }\n\n // Output results\n cout << best_ops.size() << \"\\n\";\n for (const auto& op : best_ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nint N;\nbool obstacle[D][D];\nint grid[D][D];\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nint main() {\n // Optimize standard I/O operations for performance\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int d_in;\n // Read D and N properly.\n if (!(cin >> d_in >> N)) return 0;\n \n // Initialize the warehouse state\n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n obstacle[i][j] = false;\n grid[i][j] = -1;\n }\n }\n\n // Process obstacles\n for (int i = 0; i < N; ++i) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n int total_containers = D * D - 1 - N;\n\n // Phase 1: Storage / Bringing in containers\n for (int d = 0; d < total_containers; ++d) {\n int t;\n cin >> t;\n\n queue> q;\n vector> dist(D, vector(D, -1));\n \n // The entrance is always located at (0, 4)\n q.push({0, 4});\n dist[0][4] = 0;\n\n vector> reachable_empty;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n // Store reachable and available empty squares\n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable_empty.push_back({r, c});\n }\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n // Ensure boundaries and obstacle-free\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && dist[nr][nc] == -1) {\n // Can only route through strictly empty spaces or the entrance\n if (grid[r][c] == -1 || (r == 0 && c == 4)) {\n dist[nr][nc] = dist[r][c] + 1;\n q.push({nr, nc});\n }\n }\n }\n }\n\n // Target the furthest reachable empty square to prevent blocking the entrance\n int best_r = -1, best_c = -1;\n int max_d = -1;\n for (auto [r, c] : reachable_empty) {\n if (dist[r][c] > max_d) {\n max_d = dist[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n // Store the container\n grid[best_r][best_c] = t;\n cout << best_r << \" \" << best_c << \"\\n\";\n cout << flush;\n }\n\n // Phase 2: Transportation out\n // Greedily pick the reachable container with the smallest transportation order number\n for (int d = 0; d < total_containers; ++d) {\n queue> q;\n vector> visited(D, vector(D, false));\n \n q.push({0, 4});\n visited[0][4] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n // Track any container found that can be directly extracted\n if (grid[r][c] != -1 && (r != 0 || c != 4)) {\n reachable_containers.push_back({r, c});\n } else {\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int best_r = -1, best_c = -1;\n int min_val = 1e9;\n \n for (auto [r, c] : reachable_containers) {\n if (grid[r][c] < min_val) {\n min_val = grid[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n // Remove the container from the grid and transport it\n grid[best_r][best_c] = -1;\n cout << best_r << \" \" << best_c << \"\\n\";\n }\n \n cout << flush;\n\n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nint M;\nint grid[N][N];\nint adj_count[105][105];\nbool target_adj[105][105];\nint color_count[105];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint get_color(int r, int c) {\n if (is_valid(r, c)) return grid[r][c];\n return 0;\n}\n\nbool check_connectivity(int r, int c, int color) {\n if (color_count[color] <= 1) return false;\n \n int start_r = -1, start_c = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if ((i != r || j != c) && grid[i][j] == color) {\n start_r = i; start_c = j;\n break;\n }\n }\n if (start_r != -1) break;\n }\n \n if (start_r == -1) return false;\n \n vector> visited(N, vector(N, false));\n queue> q;\n q.push({start_r, start_c});\n visited[start_r][start_c] = true;\n int count = 1;\n \n while (!q.empty()) {\n auto [curr_r, curr_c] = q.front();\n q.pop();\n \n for (int i = 0; i < 4; ++i) {\n int nr = curr_r + dx[i];\n int nc = curr_c + dy[i];\n \n if (is_valid(nr, nc) && (nr != r || nc != c) && grid[nr][nc] == color && !visited[nr][nc]) {\n visited[nr][nc] = true;\n count++;\n q.push({nr, nc});\n }\n }\n }\n \n return count == color_count[color] - 1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> M >> M)) return 0; // M is used as dummy for N here since N=50 is fixed\n int n = 50;\n M = 100;\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n color_count[grid[i][j]]++;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int c1 = grid[i][j];\n for (int k = 0; k < 4; ++k) {\n int c2 = get_color(i + dx[k], j + dy[k]);\n if (c1 != c2) {\n adj_count[c1][c2]++;\n target_adj[c1][c2] = true;\n }\n }\n }\n }\n \n mt19937 rng(42);\n \n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break;\n \n int r = rng() % n;\n int c = rng() % n;\n \n int old_color = grid[r][c];\n \n vector possible_colors;\n possible_colors.push_back(0);\n for (int k = 0; k < 4; ++k) {\n possible_colors.push_back(get_color(r + dx[k], c + dy[k]));\n }\n \n int new_color = possible_colors[rng() % possible_colors.size()];\n if (old_color == new_color) continue;\n \n set neighbors;\n for (int k = 0; k < 4; ++k) {\n neighbors.insert(get_color(r + dx[k], c + dy[k]));\n }\n \n bool possible = true;\n for (int neighbor_color : neighbors) {\n if (neighbor_color != old_color) {\n if (adj_count[old_color][neighbor_color] <= 1) {\n possible = false;\n break;\n }\n }\n if (neighbor_color != new_color) {\n if (!target_adj[new_color][neighbor_color]) {\n possible = false;\n break;\n }\n }\n }\n \n if (!possible) continue;\n if (!check_connectivity(r, c, old_color)) continue;\n \n // Apply changes\n for (int neighbor_color : neighbors) {\n if (neighbor_color != old_color) {\n adj_count[old_color][neighbor_color]--;\n adj_count[neighbor_color][old_color]--;\n }\n if (neighbor_color != new_color) {\n adj_count[new_color][neighbor_color]++;\n adj_count[neighbor_color][new_color]++;\n }\n }\n \n grid[r][c] = new_color;\n color_count[old_color]--;\n color_count[new_color]++;\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cout << grid[i][j] << (j == n - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, D, Q;\nint queries_used = 0;\n\n// Wrapper to safely query the balance scale\nchar query(const vector& L, const vector& R) {\n if (queries_used >= Q) return '='; // Prevent exceeding limits\n \n if (L.empty() || R.empty()) {\n if (L.empty() && R.empty()) return '=';\n return L.empty() ? '<' : '>';\n }\n \n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << endl;\n \n char res;\n cin >> res;\n queries_used++;\n return res;\n}\n\nchar compare_items(int u, int v) {\n return query({u}, {v});\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> D >> Q)) return 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n\n int max_sort_queries = min(Q / 2, N * 6);\n mt19937 rng(42);\n \n // QuickSort adapted for interactive comparisons\n auto partition = [&](auto& self, int l, int r) -> void {\n if (l >= r || queries_used >= max_sort_queries) return;\n int pivot_idx = l + rng() % (r - l + 1);\n int pivot = items[pivot_idx];\n swap(items[pivot_idx], items[r]);\n \n int i = l;\n for (int j = l; j < r; ++j) {\n if (queries_used >= max_sort_queries) break;\n char res = compare_items(items[j], pivot);\n if (res == '>') { // Descending order\n swap(items[i], items[j]);\n i++;\n }\n }\n swap(items[i], items[r]);\n if (queries_used < max_sort_queries) self(self, l, i - 1);\n if (queries_used < max_sort_queries) self(self, i + 1, r);\n };\n \n partition(partition, 0, N - 1);\n\n // Initial estimation modeled after exponential distribution decay\n vector est_weight(N);\n for (int i = 0; i < N; ++i) {\n est_weight[items[i]] = exp(-i * 3.0 / N);\n }\n\n vector> groups(D);\n vector group_weights(D, 0.0);\n vector ans(N);\n\n // Initial Greedy Assignment\n for (int i = 0; i < N; ++i) {\n int item = items[i];\n int best_group = 0;\n for (int d = 1; d < D; ++d) {\n if (group_weights[d] < group_weights[best_group]) {\n best_group = d;\n }\n }\n groups[best_group].push_back(item);\n group_weights[best_group] += est_weight[item];\n ans[item] = best_group;\n }\n\n // Refinement phase using Random Swaps\n while (queries_used < Q) {\n int g1 = rng() % D;\n int g2 = rng() % D;\n while (g1 == g2) g2 = rng() % D;\n \n if (groups[g1].empty() || groups[g2].empty()) continue;\n\n int idx1 = rng() % groups[g1].size();\n int idx2 = rng() % groups[g2].size();\n int u = groups[g1][idx1];\n int v = groups[g2][idx2];\n\n char res = query(groups[g1], groups[g2]);\n if (queries_used >= Q) break;\n\n if (res == '>') {\n char comp = query({u}, {v});\n if (comp == '>') {\n swap(groups[g1][idx1], groups[g2][idx2]);\n ans[u] = g2;\n ans[v] = g1;\n }\n } else if (res == '<') {\n char comp = query({u}, {v});\n if (comp == '<') {\n swap(groups[g1][idx1], groups[g2][idx2]);\n ans[u] = g2;\n ans[v] = g1;\n }\n }\n }\n\n // Fallback: If any queries remain unused, exhaust them symmetrically\n while (queries_used < Q) {\n query({0}, {0});\n }\n\n // Output final group divisions\n for (int i = 0; i < N; ++i) {\n cout << ans[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << endl;\n\n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint main() {\n // Optimize standard I/O operations for performance\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> initial_stacks(m);\n for (int i = 0; i < m; ++i) {\n int count = n / m;\n initial_stacks[i].resize(count);\n for (int j = 0; j < count; ++j) {\n cin >> initial_stacks[i][j];\n }\n }\n\n int best_energy = INF;\n vector> best_ops;\n\n // Fixed seed for reproducibility, can be time-based\n mt19937 rng(42);\n\n // Run randomized simulations to find a better configuration\n for (int iter = 0; iter < 2000; ++iter) {\n vector> stacks = initial_stacks;\n vector> ops;\n int energy = 0;\n bool possible = true;\n\n for (int v = 1; v <= n; ++v) {\n // Find which stack contains box v\n int s = -1;\n for (int i = 0; i < m; ++i) {\n for (int box : stacks[i]) {\n if (box == v) {\n s = i;\n break;\n }\n }\n if (s != -1) break;\n }\n\n // Move boxes on top of v to other stacks\n while (stacks[s].back() != v) {\n int u = stacks[s].back();\n stacks[s].pop_back();\n\n vector valids;\n int best_j = -1;\n int min_diff = INF;\n int max_top = -1;\n int fallback_j = -1;\n\n // Evaluate valid placement stacks\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n \n int top_val = stacks[i].empty() ? INF : stacks[i].back();\n \n if (top_val > u) {\n valids.push_back(i);\n if (top_val - u < min_diff) {\n min_diff = top_val - u;\n best_j = i;\n }\n }\n \n if (top_val > max_top) {\n max_top = top_val;\n fallback_j = i;\n }\n }\n\n int target_stack = -1;\n if (!valids.empty()) {\n // 80% chance to pick the tightest fit, 20% to pick another valid one\n if (rng() % 100 < 80) {\n target_stack = best_j;\n } else {\n target_stack = valids[rng() % valids.size()];\n }\n } else {\n target_stack = fallback_j;\n }\n\n stacks[target_stack].push_back(u);\n ops.push_back({u, target_stack + 1});\n energy += 2; // Moving 1 box costs 2 energy (k+1 where k=1)\n }\n\n // Carry out box v\n stacks[s].pop_back();\n ops.push_back({v, 0});\n \n if (ops.size() > 5000) {\n possible = false;\n break;\n }\n }\n\n // Keep track of the best sequence of moves across all simulations\n if (possible && energy < best_energy) {\n best_energy = energy;\n best_ops = ops;\n }\n }\n\n // Output the overall best sequence\n for (auto& op : best_ops) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h;\nvector v;\nvector> d;\nvector DIJ_R = {0, 1, 0, -1};\nvector DIJ_C = {1, 0, -1, 0};\nstring DIR = \"RDLU\";\n\ndouble evaluate(const string& path) {\n int L = path.length();\n vector>> visits(N, vector>(N));\n int r = 0, c = 0;\n \n for (int t = 0; t < L; ++t) {\n visits[r][c].push_back(t);\n char move = path[t];\n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n double total_avg = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (visits[i][j].empty()) return 1e18; // Should not happen for a valid full tour\n long long sum_w2 = 0;\n const auto& v_times = visits[i][j];\n for (size_t k = 0; k < v_times.size(); ++k) {\n long long w;\n if (k + 1 < v_times.size()) {\n w = v_times[k+1] - v_times[k];\n } else {\n w = L - v_times[k] + v_times[0];\n }\n sum_w2 += w * (w - 1) / 2;\n }\n total_avg += (double)d[i][j] * sum_w2 / L;\n }\n }\n return total_avg;\n}\n\nvoid dfs(int r, int c, vector>& visited, string& current_path, mt19937& rng) {\n visited[r][c] = true;\n \n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n \n for (int dir : dirs) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = r + dr;\n int c2 = c + dc;\n \n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N && !visited[r2][c2]) {\n bool can_move = false;\n if (dr == 0) {\n if (v[r][min(c, c2)] == '0') can_move = true;\n } else {\n if (h[min(r, r2)][c] == '0') can_move = true;\n }\n \n if (can_move) {\n current_path += DIR[dir];\n dfs(r2, c2, visited, current_path, rng);\n current_path += DIR[(dir + 2) % 4];\n }\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N)) return 0;\n\n h.resize(N - 1);\n for (int i = 0; i < N - 1; ++i) {\n cin >> h[i];\n }\n\n v.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> v[i];\n }\n\n d.assign(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 mt19937 rng(42);\n string best_path = \"\";\n double best_score = 1e18;\n\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.85) break;\n\n vector> visited(N, vector(N, false));\n string current_path = \"\";\n dfs(0, 0, visited, current_path, rng);\n \n double score = evaluate(current_path);\n if (score < best_score) {\n best_score = score;\n best_path = current_path;\n }\n }\n\n cout << best_path << \"\\n\";\n\n return 0;\n}","ahc028":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\nint N, M;\nint start_i, start_j;\nvector grid;\nvector words;\nvector> pos[26];\nint min_dist[26][26];\n\nint manhattan(pair a, pair b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint get_overlap(const string& S, const string& word) {\n if (S.empty()) return 0;\n int max_k = min(5, (int)S.length());\n for (int k = max_k; k >= 1; --k) {\n if (S.substr(S.length() - k) == word.substr(0, k)) {\n return k;\n }\n }\n return 0;\n}\n\nint approx_cost(char last_char, const string& add) {\n int cost = 0;\n char c = last_char;\n for (char nxt : add) {\n cost += min_dist[c - 'A'][nxt - 'A'] + 1;\n c = nxt;\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M)) return 0;\n cin >> start_i >> start_j;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n for (int j = 0; j < N; ++j) {\n pos[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n words.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> words[i];\n }\n\n for (int i = 0; i < 26; ++i) {\n for (int j = 0; j < 26; ++j) {\n min_dist[i][j] = INF;\n if (pos[i].empty() || pos[j].empty()) continue;\n for (auto p1 : pos[i]) {\n for (auto p2 : pos[j]) {\n min_dist[i][j] = min(min_dist[i][j], manhattan(p1, p2));\n }\n }\n }\n }\n\n int best_total_cost = INF;\n vector> best_path;\n\n srand(1337);\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.85) break;\n\n vector remaining(M);\n for (int i = 0; i < M; ++i) remaining[i] = i;\n\n string S = \"\";\n \n while (!remaining.empty()) {\n vector> cands;\n for (int i = 0; i < remaining.size(); ++i) {\n int w_idx = remaining[i];\n if (!S.empty() && S.find(words[w_idx]) != string::npos) {\n cands.push_back({-10000, i});\n continue;\n }\n int k = get_overlap(S, words[w_idx]);\n string add = words[w_idx].substr(k);\n int cost = S.empty() ? 0 : approx_cost(S.back(), add);\n cands.push_back({cost - k * 12, i});\n }\n sort(cands.begin(), cands.end());\n \n int pick_idx = cands[rand() % min((int)cands.size(), 3)].second;\n int w_idx = remaining[pick_idx];\n \n if (S.empty() || S.find(words[w_idx]) == string::npos) {\n int k = get_overlap(S, words[w_idx]);\n S += words[w_idx].substr(k);\n }\n \n remaining.erase(remaining.begin() + pick_idx);\n }\n\n int len = S.length();\n if (len > 5000) continue;\n\n vector> dp(len, vector(225, INF));\n vector> parent(len, vector(225, -1));\n\n for (int k = 0; k < pos[S[0] - 'A'].size(); ++k) {\n auto p = pos[S[0] - 'A'][k];\n int idx = p.first * N + p.second;\n dp[0][idx] = manhattan({start_i, start_j}, p) + 1;\n }\n\n for (int i = 1; i < len; ++i) {\n char prev_c = S[i - 1];\n char curr_c = S[i];\n for (int p_k = 0; p_k < pos[prev_c - 'A'].size(); ++p_k) {\n auto p_prev = pos[prev_c - 'A'][p_k];\n int p_idx = p_prev.first * N + p_prev.second;\n if (dp[i - 1][p_idx] == INF) continue;\n\n for (int c_k = 0; c_k < pos[curr_c - 'A'].size(); ++c_k) {\n auto p_curr = pos[curr_c - 'A'][c_k];\n int c_idx = p_curr.first * N + p_curr.second;\n int cost = dp[i - 1][p_idx] + manhattan(p_prev, p_curr) + 1;\n if (cost < dp[i][c_idx]) {\n dp[i][c_idx] = cost;\n parent[i][c_idx] = p_idx;\n }\n }\n }\n }\n\n int min_cost = INF;\n int last_idx = -1;\n for (int k = 0; k < pos[S.back() - 'A'].size(); ++k) {\n auto p = pos[S.back() - 'A'][k];\n int idx = p.first * N + p.second;\n if (dp[len - 1][idx] < min_cost) {\n min_cost = dp[len - 1][idx];\n last_idx = idx;\n }\n }\n\n if (min_cost < best_total_cost) {\n best_total_cost = min_cost;\n best_path.clear();\n int curr_idx = last_idx;\n for (int i = len - 1; i >= 0; --i) {\n best_path.push_back({curr_idx / N, curr_idx % N});\n curr_idx = parent[i][curr_idx];\n }\n reverse(best_path.begin(), best_path.end());\n }\n }\n\n for (auto p : best_path) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Point {\n int i, j;\n};\n\nstruct Polyomino {\n int d;\n vector pts;\n int max_i, max_j;\n};\n\nint N, M;\ndouble eps;\nvector fields;\n\nint query_single(int i, int j) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n int res;\n cin >> res;\n return res;\n}\n\nvoid answer(const vector& ans) {\n cout << \"a \" << ans.size();\n for (auto p : ans) {\n cout << \" \" << p.i << \" \" << p.j;\n }\n cout << endl;\n int res;\n cin >> res;\n if (res == 1) {\n exit(0);\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> eps)) return 0;\n\n fields.resize(M);\n for (int k = 0; k < M; ++k) {\n cin >> fields[k].d;\n fields[k].pts.resize(fields[k].d);\n fields[k].max_i = 0;\n fields[k].max_j = 0;\n for (int p = 0; p < fields[k].d; ++p) {\n cin >> fields[k].pts[p].i >> fields[k].pts[p].j;\n fields[k].max_i = max(fields[k].max_i, fields[k].pts[p].i);\n fields[k].max_j = max(fields[k].max_j, fields[k].pts[p].j);\n }\n }\n\n // A simple approach for demonstration: drill every cell\n // In a competitive implementation, we would use Bayes filtering, MCMC, and noisy subset queries.\n vector has_oil;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int v = query_single(i, j);\n if (v > 0) {\n has_oil.push_back({i, j});\n }\n }\n }\n\n answer(has_oil);\n\n return 0;\n}","ahc031":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int W = 1000;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int w_input, d_days, n_res;\n if (!(cin >> w_input >> d_days >> n_res)) return 0;\n\n vector> a(d_days, vector(n_res));\n for (int d = 0; d < d_days; ++d) {\n for (int k = 0; k < n_res; ++k) {\n cin >> a[d][k];\n }\n }\n\n for (int d = 0; d < d_days; ++d) {\n vector w(n_res, 1);\n int remaining = W - n_res;\n\n // Greedily distribute the remaining width to minimize area penalties\n while (remaining > 0) {\n int best_k = -1;\n int max_benefit = -1;\n\n for (int k = 0; k < n_res; ++k) {\n int current_area = W * w[k];\n if (current_area < a[d][k]) {\n int benefit = min(W, a[d][k] - current_area);\n if (benefit > max_benefit) {\n max_benefit = benefit;\n best_k = k;\n }\n }\n }\n\n if (best_k != -1) {\n w[best_k]++;\n remaining--;\n } else {\n // If all requirements are met, distribute the rest arbitrarily\n w[n_res - 1] += remaining;\n break;\n }\n }\n\n // Output the vertical strips for the current day\n int current_x = 0;\n for (int k = 0; k < n_res; ++k) {\n int next_x = current_x + w[k];\n cout << 0 << \" \" << current_x << \" \" << W << \" \" << next_x << \"\\n\";\n current_x = next_x;\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\nlong long A[9][9];\nlong long S[20][3][3];\nlong long V[9][9];\nOp ops[81];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A[i][j];\n V[i][j] = A[i][j];\n }\n }\n\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 for (int i = 0; i < K; ++i) {\n ops[i] = {-1, -1, -1};\n }\n\n mt19937_64 rng(1337);\n uniform_int_distribution dist_idx(0, K - 1);\n uniform_int_distribution dist_m(-1, M - 1);\n uniform_int_distribution dist_p(0, N - 3);\n uniform_int_distribution dist_q(0, N - 3);\n uniform_real_distribution dist_prob(0.0, 1.0);\n\n double T0 = 2e9;\n double T1 = 1e6;\n double time_limit = 1.95;\n double T = T0;\n\n long long current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += V[i][j] % MOD;\n }\n }\n\n long long best_score = current_score;\n Op best_ops[81];\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n\n int iter = 0;\n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n T = T0 * pow(T1 / T0, progress);\n }\n\n int idx = dist_idx(rng);\n Op old_op = ops[idx];\n Op new_op;\n new_op.m = dist_m(rng);\n if (new_op.m == -1) {\n new_op.p = -1;\n new_op.q = -1;\n } else {\n new_op.p = dist_p(rng);\n new_op.q = dist_q(rng);\n }\n\n long long delta = 0;\n \n if (old_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = old_op.p + i;\n int c = old_op.q + j;\n delta -= V[r][c] % MOD;\n V[r][c] -= S[old_op.m][i][j];\n delta += V[r][c] % MOD;\n }\n }\n }\n \n if (new_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = new_op.p + i;\n int c = new_op.q + j;\n delta -= V[r][c] % MOD;\n V[r][c] += S[new_op.m][i][j];\n delta += V[r][c] % MOD;\n }\n }\n }\n\n if (delta >= 0 || dist_prob(rng) < exp(delta / T)) {\n current_score += delta;\n ops[idx] = new_op;\n if (current_score > best_score) {\n best_score = current_score;\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n }\n } else {\n // Rollback\n if (new_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n V[new_op.p + i][new_op.q + j] -= S[new_op.m][i][j];\n }\n }\n }\n if (old_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n V[old_op.p + i][old_op.q + j] += S[old_op.m][i][j];\n }\n }\n }\n }\n iter++;\n }\n\n vector final_ops;\n for (int i = 0; i < K; ++i) {\n if (best_ops[i].m != -1) {\n final_ops.push_back(best_ops[i]);\n }\n }\n\n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_ops) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 // The large crane's operations string. \n // We start with a '.' (wait) for the first turn to safely let the small cranes detonate.\n string ans0 = \".\";\n \n int cr = 0, cc = 0;\n vector taken(N, 0);\n \n // There are N * N containers to transport\n for (int step = 0; step < N * N; ++step) {\n int best_r = -1;\n int min_val = 1e9;\n \n // Greedily pick the smallest available container at the Receiving Gates\n for (int r = 0; r < N; ++r) {\n if (taken[r] < N) {\n if (A[r][taken[r]] < min_val) {\n min_val = A[r][taken[r]];\n best_r = r;\n }\n }\n }\n \n int r = best_r;\n \n // Move to the container\n while (cr > r) { ans0 += 'U'; cr--; }\n while (cr < r) { ans0 += 'D'; cr++; }\n while (cc > 0) { ans0 += 'L'; cc--; }\n while (cc < 0) { ans0 += 'R'; cc++; }\n \n ans0 += 'P'; // Pick up\n \n int c = A[r][taken[r]];\n taken[r]++;\n \n int dst_r = c / N;\n \n // Move to the correct Dispatch Gate\n while (cr > dst_r) { ans0 += 'U'; cr--; }\n while (cr < dst_r) { ans0 += 'D'; cr++; }\n while (cc > N - 1) { ans0 += 'L'; cc--; }\n while (cc < N - 1) { ans0 += 'R'; cc++; }\n \n ans0 += 'Q'; // Drop off\n }\n \n // Output operations for the large crane\n cout << ans0 << \"\\n\";\n \n // Output operations for the small cranes: they all detonate on the first turn\n for (int i = 1; i < N; ++i) {\n cout << \"B\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 int x = 0, y = 0;\n long long load = 0;\n\n while (true) {\n // Process current cell first\n if (load == 0 && h[x][y] > 0) {\n int amt = h[x][y];\n cout << \"+\" << amt << \"\\n\";\n load += amt;\n h[x][y] -= amt;\n continue;\n }\n if (load > 0 && h[x][y] < 0) {\n long long amt = min(load, (long long)-h[x][y]);\n cout << \"-\" << amt << \"\\n\";\n load -= amt;\n h[x][y] += amt;\n continue;\n }\n\n // Check if we are done\n bool done = true;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (h[i][j] != 0) {\n done = false;\n break;\n }\n }\n if (!done) break;\n }\n if (done) break;\n\n // Find the nearest target\n int best_dist = 1e9;\n pair target = {-1, -1};\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (load == 0 && h[i][j] > 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n } else if (load > 0 && h[i][j] < 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n }\n }\n }\n\n // If for some reason we cannot find a target, terminate safely.\n if (target.first == -1) break;\n\n // Move 1 step towards target\n if (x < target.first) {\n x++;\n cout << \"D\\n\";\n } else if (x > target.first) {\n x--;\n cout << \"U\\n\";\n } else if (y < target.second) {\n y++;\n cout << \"R\\n\";\n } else if (y > target.second) {\n y--;\n cout << \"L\\n\";\n }\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Seed {\n int id;\n vector x;\n int sum;\n};\n\nint N, M, T;\nint seed_count;\nvector seeds;\n\n// Calculate the score of a pair of seeds\ninline int pair_score(const Seed& a, const Seed& b) {\n int score = 0;\n for (int l = 0; l < M; ++l) {\n score += max(a.x[l], b.x[l]);\n }\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> T)) return 0;\n seed_count = 2 * N * (N - 1);\n seeds.resize(seed_count);\n\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].x.resize(M);\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n\n mt19937 rng(42);\n auto start_time = steady_clock::now();\n\n for (int t = 0; t < T; t++) {\n vector selected_ids;\n vector used(seed_count, false);\n\n // Select the top 1 seed for each criterion to maintain diversity\n for (int l = 0; l < M; ++l) {\n int best_id = -1;\n int best_val = -1;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i] && seeds[i].x[l] > best_val) {\n best_val = seeds[i].x[l];\n best_id = i;\n }\n }\n if (best_id != -1) {\n selected_ids.push_back(best_id);\n used[best_id] = true;\n }\n }\n\n // Fill the rest with the highest sum seeds\n vector remaining;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i]) remaining.push_back(i);\n }\n sort(remaining.begin(), remaining.end(), [&](int a, int b) {\n return seeds[a].sum > seeds[b].sum;\n });\n\n for (int i = 0; selected_ids.size() < N * N; ++i) {\n selected_ids.push_back(remaining[i]);\n }\n\n // Initialize grid randomly\n shuffle(selected_ids.begin(), selected_ids.end(), rng);\n vector> grid(N, vector(N));\n int idx = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n grid[r][c] = selected_ids[idx++];\n }\n }\n\n // Calculate initial score\n int current_score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (r + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r+1][c]]);\n if (c + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r][c+1]]);\n }\n }\n\n // Simulated Annealing\n double time_limit_per_turn = 1.9 / T; \n auto turn_start = steady_clock::now();\n double start_temp = 20.0;\n double end_temp = 0.1;\n int iter = 0;\n\n while (true) {\n if ((iter & 255) == 0) {\n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n if (elapsed >= time_limit_per_turn) break;\n }\n iter++;\n\n int r1 = uniform_int_distribution(0, N - 1)(rng);\n int c1 = uniform_int_distribution(0, N - 1)(rng);\n int r2 = uniform_int_distribution(0, N - 1)(rng);\n int c2 = uniform_int_distribution(0, N - 1)(rng);\n if (r1 == r2 && c1 == c2) continue;\n\n int old_contrib = 0;\n int new_contrib = 0;\n \n int s1 = grid[r1][c1];\n int s2 = grid[r2][c2];\n\n const int dr[] = {-1, 1, 0, 0};\n const int dc[] = {0, 0, -1, 1};\n\n for (int d = 0; d < 4; ++d) {\n int nr1 = r1 + dr[d], nc1 = c1 + dc[d];\n if (nr1 >= 0 && nr1 < N && nc1 >= 0 && nc1 < N) {\n if (nr1 != r2 || nc1 != c2) {\n old_contrib += pair_score(seeds[s1], seeds[grid[nr1][nc1]]);\n new_contrib += pair_score(seeds[s2], seeds[grid[nr1][nc1]]);\n }\n }\n int nr2 = r2 + dr[d], nc2 = c2 + dc[d];\n if (nr2 >= 0 && nr2 < N && nc2 >= 0 && nc2 < N) {\n if (nr2 != r1 || nc2 != c1) {\n old_contrib += pair_score(seeds[s2], seeds[grid[nr2][nc2]]);\n new_contrib += pair_score(seeds[s1], seeds[grid[nr2][nc2]]);\n }\n }\n }\n\n int diff = new_contrib - old_contrib;\n \n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n double temp = start_temp * pow(end_temp / start_temp, elapsed / time_limit_per_turn);\n\n if (diff >= 0 || uniform_real_distribution(0.0, 1.0)(rng) < exp(diff / temp)) {\n current_score += diff;\n swap(grid[r1][c1], grid[r2][c2]);\n }\n }\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n cout << grid[r][c] << (c == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n if (t < T - 1) {\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n int N, M, V;\n if (!(cin >> N >> M >> V)) return 0;\n \n vector s(N);\n for (int i = 0; i < N; ++i) cin >> s[i];\n \n vector t(N);\n for (int i = 0; i < N; ++i) cin >> t[i];\n \n // A simple single-edge arm as a baseline.\n cout << 2 << endl;\n cout << 0 << \" \" << 1 << endl;\n \n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << endl;\n \n return 0;\n}","ahc039":"#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n // Optimize standard I/O operations for better performance\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n\n // Discretize the 100000x100000 space into a BxB grid\n const int B = 400;\n const int MAX_COORD = 100000;\n vector> grid(B, vector(B, 0));\n\n // Read Mackerels (+1)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n if (x == MAX_COORD) x--;\n if (y == MAX_COORD) y--;\n grid[x * B / MAX_COORD][y * B / MAX_COORD]++;\n }\n\n // Read Sardines (-1)\n for (int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n if (x == MAX_COORD) x--;\n if (y == MAX_COORD) y--;\n grid[x * B / MAX_COORD][y * B / MAX_COORD]--;\n }\n\n int max_sum = -1e9;\n int best_r1 = 0, best_r2 = 0, best_c1 = 0, best_c2 = 0;\n\n // 2D Kadane's Algorithm to find the maximum sum rectangle\n for (int r1 = 0; r1 < B; r1++) {\n vector temp(B, 0);\n for (int r2 = r1; r2 < B; r2++) {\n for (int c = 0; c < B; c++) {\n temp[c] += grid[r2][c];\n }\n int current_sum = 0;\n int c1 = 0;\n for (int c = 0; c < B; c++) {\n current_sum += temp[c];\n if (current_sum > max_sum) {\n max_sum = current_sum;\n best_r1 = r1;\n best_r2 = r2;\n best_c1 = c1;\n best_c2 = c;\n }\n if (current_sum < 0) {\n current_sum = 0;\n c1 = c + 1;\n }\n }\n }\n }\n\n // Re-map the grid coordinates back to the original space\n int x_min = best_r1 * MAX_COORD / B;\n int x_max = (best_r2 + 1) * MAX_COORD / B;\n int y_min = best_c1 * MAX_COORD / B;\n int y_max = (best_c2 + 1) * MAX_COORD / B;\n\n // Output the resulting valid polygon (a rectangle)\n cout << 4 << \"\\n\";\n cout << x_min << \" \" << y_min << \"\\n\";\n cout << x_max << \" \" << y_min << \"\\n\";\n cout << x_max << \" \" << y_max << \"\\n\";\n cout << x_min << \" \" << y_max << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n int r;\n char d;\n int b;\n};\n\nint N, T;\nlong long sigma;\nvector rects;\n\nmt19937 rng(1337);\n\nlong long simulate(const vector& p, long long& out_W, long long& out_H) {\n vector X(N, 0), Y(N, 0), W(N, 0), H(N, 0);\n long long max_X = 0, max_Y = 0;\n\n for (int i = 0; i < N; ++i) {\n if (p[i].r == 1) {\n W[i] = rects[i].h;\n H[i] = rects[i].w;\n } else {\n W[i] = rects[i].w;\n H[i] = rects[i].h;\n }\n\n if (p[i].d == 'U') {\n if (p[i].b == -1) {\n X[i] = 0;\n } else {\n X[i] = X[p[i].b] + W[p[i].b];\n }\n long long cur_y = 0;\n for (int j = 0; j < i; ++j) {\n if (X[i] < X[j] + W[j] && X[j] < X[i] + W[i]) {\n cur_y = max(cur_y, Y[j] + H[j]);\n }\n }\n Y[i] = cur_y;\n } else {\n if (p[i].b == -1) {\n Y[i] = 0;\n } else {\n Y[i] = Y[p[i].b] + H[p[i].b];\n }\n long long cur_x = 0;\n for (int j = 0; j < i; ++j) {\n if (Y[i] < Y[j] + H[j] && Y[j] < Y[i] + H[i]) {\n cur_x = max(cur_x, X[j] + W[j]);\n }\n }\n X[i] = cur_x;\n }\n max_X = max(max_X, X[i] + W[i]);\n max_Y = max(max_Y, Y[i] + H[i]);\n }\n out_W = max_X;\n out_H = max_Y;\n return max_X + max_Y;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> T >> sigma)) return 0;\n\n rects.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> rects[i].w >> rects[i].h;\n }\n\n auto start_time = chrono::steady_clock::now();\n // Leave a small margin before the 3.0 sec limit\n auto max_time = start_time + chrono::milliseconds(2850);\n\n for (int t = 0; t < T; ++t) {\n auto now = chrono::steady_clock::now();\n double remaining_time = chrono::duration(max_time - now).count();\n double time_for_this_turn = remaining_time / (T - t);\n auto turn_end_time = now + chrono::duration(time_for_this_turn);\n\n vector best_p(N);\n long long best_score = 4e18;\n\n // Initialize with a default valid state\n for (int i = 0; i < N; ++i) {\n best_p[i] = {0, 'U', -1};\n }\n\n while (true) {\n bool time_up = false;\n // Run a batch of iterations before checking the clock to reduce overhead\n for (int it = 0; it < 50; ++it) {\n vector current_p(N);\n for (int i = 0; i < N; ++i) {\n current_p[i].r = rng() % 2;\n current_p[i].d = (rng() % 2 == 0) ? 'U' : 'L';\n if (i == 0) {\n current_p[i].b = -1;\n } else {\n current_p[i].b = (rng() % (i + 1)) - 1;\n }\n }\n\n long long W, H;\n long long score = simulate(current_p, W, H);\n if (score < best_score) {\n best_score = score;\n best_p = current_p;\n }\n }\n if (chrono::steady_clock::now() >= turn_end_time) {\n break;\n }\n }\n\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << \" \" << best_p[i].r << \" \" << best_p[i].d << \" \" << best_p[i].b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_H = 10;\nint N, M, H;\nvector A;\nvector> adj;\n\nstruct State {\n vector p;\n vector> children;\n vector depth;\n vector max_rel_height;\n vector subtree_A;\n long long score;\n\n State() {\n p.assign(N, -1);\n children.resize(N);\n depth.assign(N, 0);\n max_rel_height.assign(N, 0);\n subtree_A.assign(N, 0);\n score = 0;\n for (int i = 0; i < N; ++i) {\n subtree_A[i] = A[i];\n score += A[i];\n }\n }\n\n void dfs(int u) {\n max_rel_height[u] = 0;\n subtree_A[u] = A[u];\n for (int v : children[u]) {\n depth[v] = depth[u] + 1;\n dfs(v);\n max_rel_height[u] = max(max_rel_height[u], max_rel_height[v] + 1);\n subtree_A[u] += subtree_A[v];\n }\n }\n\n void recompute_tree(int root) {\n if (root == -1) return;\n while (p[root] != -1) {\n root = p[root];\n }\n depth[root] = 0;\n dfs(root);\n }\n\n long long compute_total_score() {\n long long total = 0;\n for (int i = 0; i < N; ++i) {\n total += (long long)(depth[i] + 1) * A[i];\n }\n return total + 1;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> M >> H)) return 0;\n\n A.resize(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n\n adj.resize(N);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n State state;\n \n mt19937 rng(42);\n \n double T0 = 100.0;\n double T1 = 0.1;\n long long iter = 0;\n \n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.9) break;\n }\n iter++;\n \n double elapsed = chrono::duration(chrono::steady_clock::now() - start_time).count();\n double progress = elapsed / 1.9;\n if (progress > 1.0) progress = 1.0;\n double temp = T0 * pow(T1 / T0, progress);\n\n int v = rng() % N;\n int num_options = adj[v].size() + 1;\n int opt = rng() % num_options;\n int u = (opt == adj[v].size()) ? -1 : adj[v][opt];\n\n if (state.p[v] == u) continue;\n\n bool cycle = false;\n int curr = u;\n while (curr != -1) {\n if (curr == v) {\n cycle = true;\n break;\n }\n curr = state.p[curr];\n }\n if (cycle) continue;\n\n int new_v_depth = (u == -1) ? 0 : state.depth[u] + 1;\n if (new_v_depth + state.max_rel_height[v] > H) continue;\n\n long long delta_score = (long long)(new_v_depth - state.depth[v]) * state.subtree_A[v];\n\n if (delta_score >= 0 || uniform_real_distribution(0.0, 1.0)(rng) < exp(delta_score / temp)) {\n int old_p = state.p[v];\n if (old_p != -1) {\n for (auto it = state.children[old_p].begin(); it != state.children[old_p].end(); ++it) {\n if (*it == v) {\n state.children[old_p].erase(it);\n break;\n }\n }\n }\n if (u != -1) {\n state.children[u].push_back(v);\n }\n state.p[v] = u;\n\n state.recompute_tree(old_p);\n state.recompute_tree(u);\n state.score += delta_score;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << state.p[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\n \n vector board(N);\n int oni_count = 0;\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') oni_count++;\n }\n }\n \n vector> moves;\n \n auto apply = [&](char d, int p) {\n moves.push_back({d, p});\n if (d == 'L') {\n for (int j = 0; j < N - 1; ++j) board[p][j] = board[p][j+1];\n board[p][N-1] = '.';\n } else if (d == 'R') {\n for (int j = N - 1; j > 0; --j) board[p][j] = board[p][j-1];\n board[p][0] = '.';\n } else if (d == 'U') {\n for (int i = 0; i < N - 1; ++i) board[i][p] = board[i+1][p];\n board[N-1][p] = '.';\n } else if (d == 'D') {\n for (int i = N - 1; i > 0; --i) board[i][p] = board[i-1][p];\n board[0][p] = '.';\n }\n };\n\n while (oni_count > 0) {\n double best_score = -1.0;\n int best_cost = 1e9;\n char best_dir = ' ';\n int best_idx = -1;\n int best_k = 0;\n\n // Check rows for L and R\n for (int r = 0; r < N; ++r) {\n // Left\n int dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[r][k - 1] == 'o') break;\n if (board[r][k - 1] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / (2.0 * k);\n if (score > best_score || (score == best_score && 2 * k < best_cost)) {\n best_score = score;\n best_cost = 2 * k;\n best_dir = 'L';\n best_idx = r;\n best_k = k;\n }\n }\n }\n // Right\n dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[r][N - k] == 'o') break;\n if (board[r][N - k] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / (2.0 * k);\n if (score > best_score || (score == best_score && 2 * k < best_cost)) {\n best_score = score;\n best_cost = 2 * k;\n best_dir = 'R';\n best_idx = r;\n best_k = k;\n }\n }\n }\n }\n\n // Check columns for U and D\n for (int c = 0; c < N; ++c) {\n // Up\n int dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[k - 1][c] == 'o') break;\n if (board[k - 1][c] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / (2.0 * k);\n if (score > best_score || (score == best_score && 2 * k < best_cost)) {\n best_score = score;\n best_cost = 2 * k;\n best_dir = 'U';\n best_idx = c;\n best_k = k;\n }\n }\n }\n // Down\n dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[N - k][c] == 'o') break;\n if (board[N - k][c] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / (2.0 * k);\n if (score > best_score || (score == best_score && 2 * k < best_cost)) {\n best_score = score;\n best_cost = 2 * k;\n best_dir = 'D';\n best_idx = c;\n best_k = k;\n }\n }\n }\n }\n\n if (best_score < 0) break; // Should not happen given problem constraints\n\n // Apply best move sequence (push and pull back immediately)\n if (best_dir == 'U') {\n for (int i = 0; i < best_k; ++i) apply('U', best_idx);\n for (int i = 0; i < best_k; ++i) apply('D', best_idx);\n } else if (best_dir == 'D') {\n for (int i = 0; i < best_k; ++i) apply('D', best_idx);\n for (int i = 0; i < best_k; ++i) apply('U', best_idx);\n } else if (best_dir == 'L') {\n for (int i = 0; i < best_k; ++i) apply('L', best_idx);\n for (int i = 0; i < best_k; ++i) apply('R', best_idx);\n } else if (best_dir == 'R') {\n for (int i = 0; i < best_k; ++i) apply('R', best_idx);\n for (int i = 0; i < best_k; ++i) apply('L', best_idx);\n }\n \n // Count remaining oni\n oni_count = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') oni_count++;\n }\n }\n }\n \n for (auto p : moves) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}","ahc044":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\nint T[N];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, l_input;\n if (!(cin >> n_input >> l_input)) return 0;\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n vector a(N), b(N);\n vector W0(N), W1(N);\n for (int i = 0; i < N; ++i) {\n W0[i] = (T[i] + 1) / 2;\n W1[i] = T[i] / 2;\n a[i] = i; \n b[i] = i;\n }\n\n vector I(N, 0);\n for (int i = 0; i < N; ++i) {\n I[a[i]] += W0[i];\n I[b[i]] += W1[i];\n }\n\n auto get_cost = [&]() {\n int cost = 0;\n for (int i = 0; i < N; ++i) {\n cost += abs(I[i] - T[i]);\n }\n return cost;\n };\n\n int current_cost = get_cost();\n int best_cost = current_cost;\n vector best_a = a, best_b = b;\n\n mt19937 rng(1337);\n auto start_time = chrono::steady_clock::now();\n\n double t0 = 100.0;\n double t1 = 0.1;\n int iter = 0;\n const int MAX_FAST_ITER = 3000000;\n\n // Fast SA based on expected degrees\n while (true) {\n if ((iter & 16383) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.7) break;\n }\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n \n if (old_v == new_v) continue;\n\n int weight = is_a ? W0[u] : W1[u];\n \n int old_I_old = I[old_v];\n int old_I_new = I[new_v];\n \n int delta = -abs(old_I_old - T[old_v]) - abs(old_I_new - T[new_v])\n + abs((old_I_old - weight) - T[old_v]) + abs((old_I_new + weight) - T[new_v]);\n\n double temp = t0 * pow(t1 / t0, (double)iter / MAX_FAST_ITER); // simple decay\n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_cost += delta;\n I[old_v] -= weight;\n I[new_v] += weight;\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_a = a;\n best_b = b;\n }\n }\n iter++;\n }\n\n auto simulate = [&](const vector& sa, const vector& sb) {\n vector t(N, 0);\n int curr = 0;\n for (int step = 0; step < L; ++step) {\n t[curr]++;\n int next_node = (t[curr] % 2 != 0) ? sa[curr] : sb[curr];\n curr = next_node;\n }\n int diff = 0;\n for (int i = 0; i < N; ++i) {\n diff += abs(t[i] - T[i]);\n }\n return diff;\n };\n\n a = best_a;\n b = best_b;\n current_cost = simulate(a, b);\n best_cost = current_cost;\n \n // Fine-tuning using exact simulation for the remainder of the time\n t0 = 10.0;\n t1 = 0.1;\n iter = 0;\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.95) break;\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n if (old_v == new_v) continue;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_cost = simulate(a, b);\n int delta = new_cost - current_cost;\n\n double temp = t0 * pow(t1 / t0, elapsed / 2.0);\n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_a = a;\n best_b = b;\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct City {\n int lx, rx, ly, ry;\n long long cx, cy;\n};\n\nint N, M, Q, L, W;\nvector G;\nvector cities;\n\nlong long dist_city(int u, int v) {\n long long dx = cities[u].cx - cities[v].cx;\n long long dy = cities[u].cy - cities[v].cy;\n return std::floor(std::sqrt(dx * dx + dy * dy));\n}\n\nlong long calc_mst(const vector& nodes) {\n int k = nodes.size();\n if (k <= 1) return 0;\n vector min_e(k, 1e18);\n vector vis(k, false);\n min_e[0] = 0;\n long long total = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && (v == -1 || min_e[j] < min_e[v])) {\n v = j;\n }\n }\n if (min_e[v] >= 1e18) break;\n vis[v] = true;\n total += min_e[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = dist_city(nodes[v], nodes[j]);\n if (d < min_e[j]) min_e[j] = d;\n }\n }\n }\n return total;\n}\n\nvector> get_mst_edges(const vector& nodes) {\n int k = nodes.size();\n vector> edges;\n if (k <= 1) return edges;\n vector min_e(k, 1e18);\n vector parent(k, -1);\n vector vis(k, false);\n min_e[0] = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && (v == -1 || min_e[j] < min_e[v])) {\n v = j;\n }\n }\n vis[v] = true;\n if (parent[v] != -1) {\n edges.push_back({nodes[parent[v]], nodes[v]});\n }\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = dist_city(nodes[v], nodes[j]);\n if (d < min_e[j]) {\n min_e[j] = d;\n parent[j] = v;\n }\n }\n }\n }\n return edges;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n G.resize(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n cities.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2;\n }\n\n vector assign(N, -1);\n vector> grps(M);\n vector used(N, false);\n vector g_idx(M);\n iota(g_idx.begin(), g_idx.end(), 0);\n sort(g_idx.begin(), g_idx.end(), [&](int a, int b) { return G[a] > G[b]; });\n\n // Greedy Initialization\n for (int k : g_idx) {\n int start = -1;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) { start = i; break; }\n }\n used[start] = true;\n grps[k].push_back(start);\n assign[start] = k;\n \n while ((int)grps[k].size() < G[k]) {\n int best_c = -1;\n long long best_d = 2e18;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n long long d = 0;\n for (int u : grps[k]) {\n long long dx = cities[u].cx - cities[i].cx;\n long long dy = cities[u].cy - cities[i].cy;\n d += dx * dx + dy * dy;\n }\n if (d < best_d) {\n best_d = d;\n best_c = i;\n }\n }\n }\n used[best_c] = true;\n grps[k].push_back(best_c);\n assign[best_c] = k;\n }\n }\n\n vector mst_cost(M);\n for (int i = 0; i < M; ++i) mst_cost[i] = calc_mst(grps[i]);\n\n // Simulated Annealing\n auto start_time = chrono::steady_clock::now();\n double max_time = 1.8;\n int iter = 0;\n mt19937 rng(42);\n uniform_int_distribution dist_N(0, N - 1);\n uniform_real_distribution dist_01(0.0, 1.0);\n \n double t0 = 1000.0, t1 = 1.0;\n\n while (true) {\n if ((iter & 127) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n }\n iter++;\n\n int u = dist_N(rng);\n int v = dist_N(rng);\n if (assign[u] == assign[v]) continue;\n\n int gu = assign[u];\n int gv = assign[v];\n long long old_cost = mst_cost[gu] + mst_cost[gv];\n\n // Swap cities between the two different groups\n for (int& x : grps[gu]) if (x == u) x = v;\n for (int& x : grps[gv]) if (x == v) x = u;\n\n long long new_u_cost = calc_mst(grps[gu]);\n long long new_v_cost = calc_mst(grps[gv]);\n long long new_cost = new_u_cost + new_v_cost;\n\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n double temp = t0 * pow(t1 / t0, elapsed / max_time);\n\n if (new_cost <= old_cost || exp((old_cost - new_cost) / temp) > dist_01(rng)) {\n mst_cost[gu] = new_u_cost;\n mst_cost[gv] = new_v_cost;\n assign[u] = gv;\n assign[v] = gu;\n } else {\n // Revert changes\n for (int& x : grps[gu]) if (x == v) x = u;\n for (int& x : grps[gv]) if (x == u) x = v;\n }\n }\n\n // Since we omit fortune telling querying altogether directly output answers\n cout << \"!\" << endl;\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < G[i]; ++j) {\n cout << grps[i][j] << (j + 1 == G[i] ? \"\" : \" \");\n }\n cout << endl;\n auto edges = get_mst_edges(grps[i]);\n for (auto& e : edges) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& o) const {\n return r == o.r && c == o.c;\n }\n bool operator!=(const Point& o) const {\n return r != o.r || c != o.c;\n }\n};\n\nstruct StateInfo {\n int prev_r, prev_c;\n char action_type;\n char dir;\n};\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_chars[] = {'U', 'D', 'L', 'R'};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, m_input;\n if (!(cin >> n_input >> m_input)) return 0;\n\n vector targets(m_input);\n for (int i = 0; i < m_input; ++i) {\n cin >> targets[i].r >> targets[i].c;\n }\n\n Point curr = targets[0];\n vector> total_actions;\n\n for (int i = 1; i < m_input; ++i) {\n Point target = targets[i];\n \n vector> dist(N, vector(N, 1e9));\n vector> parent(N, vector(N));\n \n queue q;\n q.push(curr);\n dist[curr.r][curr.c] = 0;\n \n while (!q.empty()) {\n Point u = q.front();\n q.pop();\n \n if (u == target) break;\n \n for (int d = 0; d < 4; ++d) {\n // Try Move\n int nr = u.r + dr[d];\n int nc = u.c + dc[d];\n if (is_valid(nr, nc)) {\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'M', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n \n // Try Slide\n nr = u.r;\n nc = u.c;\n while (is_valid(nr + dr[d], nc + dc[d])) {\n nr += dr[d];\n nc += dc[d];\n }\n if (nr != u.r || nc != u.c) { // actually moved\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'S', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n }\n }\n \n // Reconstruct path\n vector> path;\n Point step = target;\n while (step != curr) {\n StateInfo info = parent[step.r][step.c];\n path.push_back({info.action_type, info.dir});\n step = {info.prev_r, info.prev_c};\n }\n \n reverse(path.begin(), path.end());\n for (auto p : path) {\n total_actions.push_back(p);\n }\n \n curr = target;\n }\n\n for (auto p : total_actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}"},"4":{"ahc001":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst double TIME_LIMIT = 4.85; \n\n// Fast random number generator\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double next_double() {\n return (xor128() & 0xFFFFFF) / (double)0x1000000;\n}\n\nstruct Rect {\n int x1, y1, x2, y2;\n int px, py;\n long long r;\n \n inline long long area() const {\n return 1LL * (x2 - x1) * (y2 - y1);\n }\n \n inline double score() const {\n long long s = area();\n if (s == 0) return 0.0;\n double mn = min(r, s);\n double mx = max(r, s);\n double val = 1.0 - mn / mx;\n return 1.0 - val * val;\n }\n \n inline bool intersects(const Rect& o) const {\n return max(x1, o.x1) < min(x2, o.x2) && max(y1, o.y1) < min(y2, o.y2);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n int n;\n if (!(cin >> n)) return 0;\n \n vector rects(n);\n for (int i = 0; i < n; ++i) {\n cin >> rects[i].px >> rects[i].py >> rects[i].r;\n rects[i].x1 = rects[i].px;\n rects[i].y1 = rects[i].py;\n rects[i].x2 = rects[i].px + 1;\n rects[i].y2 = rects[i].py + 1;\n }\n \n auto get_time = [&]() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n };\n \n double initial_temp = 0.1;\n double final_temp = 0.0001;\n \n int iterations = 0;\n while (true) {\n if ((iterations & 511) == 0) {\n double elapsed = get_time();\n if (elapsed > TIME_LIMIT) break;\n }\n iterations++;\n \n double elapsed = get_time();\n double progress = elapsed / TIME_LIMIT;\n double temp = initial_temp * pow(final_temp / initial_temp, progress);\n \n int i = xor128() % n;\n int dir = xor128() % 4;\n \n Rect old_i = rects[i];\n Rect new_i = old_i;\n \n if (dir == 0) { \n int delta = (xor128() % 100) - 50;\n new_i.x1 += delta;\n if (new_i.x1 < 0) new_i.x1 = 0;\n if (new_i.x1 > old_i.px) new_i.x1 = old_i.px;\n } else if (dir == 1) { \n int delta = (xor128() % 100) - 50;\n new_i.x2 += delta;\n if (new_i.x2 > 10000) new_i.x2 = 10000;\n if (new_i.x2 <= old_i.px) new_i.x2 = old_i.px + 1;\n } else if (dir == 2) { \n int delta = (xor128() % 100) - 50;\n new_i.y1 += delta;\n if (new_i.y1 < 0) new_i.y1 = 0;\n if (new_i.y1 > old_i.py) new_i.y1 = old_i.py;\n } else { \n int delta = (xor128() % 100) - 50;\n new_i.y2 += delta;\n if (new_i.y2 > 10000) new_i.y2 = 10000;\n if (new_i.y2 <= old_i.py) new_i.y2 = old_i.py + 1;\n }\n \n if (new_i.x1 == old_i.x1 && new_i.x2 == old_i.x2 && new_i.y1 == old_i.y1 && new_i.y2 == old_i.y2) continue;\n \n int overlap_idx = -1;\n bool valid = true;\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n if (new_i.intersects(rects[j])) {\n if (overlap_idx == -1) {\n overlap_idx = j;\n } else {\n valid = false;\n break;\n }\n }\n }\n \n if (!valid) continue;\n \n Rect old_j;\n Rect new_j;\n if (overlap_idx != -1) {\n old_j = rects[overlap_idx];\n new_j = old_j;\n \n if (dir == 0) new_j.x2 = new_i.x1;\n else if (dir == 1) new_j.x1 = new_i.x2;\n else if (dir == 2) new_j.y2 = new_i.y1;\n else new_j.y1 = new_i.y2;\n \n if (new_j.x1 > new_j.px || new_j.x2 <= new_j.px || new_j.y1 > new_j.py || new_j.y2 <= new_j.py) {\n continue;\n }\n }\n \n double old_score = old_i.score() + (overlap_idx != -1 ? old_j.score() : 0.0);\n double new_score = new_i.score() + (overlap_idx != -1 ? new_j.score() : 0.0);\n \n if (new_score > old_score || exp((new_score - old_score) / temp) > next_double()) {\n rects[i] = new_i;\n if (overlap_idx != -1) rects[overlap_idx] = new_j;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n cout << rects[i].x1 << \" \" << rects[i].y1 << \" \" << rects[i].x2 << \" \" << rects[i].y2 << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint t[50][50];\nint p[50][50];\nbool visited[2500];\nint best_score = -1;\nstring best_path = \"\";\nstring current_path = \"\";\nint current_score = 0;\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nauto start_time = chrono::high_resolution_clock::now();\nmt19937 rng(42);\n\nint steps_taken = 0;\nconst int MAX_STEPS_PER_DFS = 30000;\nbool time_up = false;\n\nvoid dfs(int r, int c) {\n if (time_up || steps_taken > MAX_STEPS_PER_DFS) return;\n \n steps_taken++;\n\n if ((steps_taken & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1950) {\n time_up = true;\n return;\n }\n }\n\n if (current_score > best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n\n struct Move {\n int r, c, k, score;\n };\n Move moves[4];\n int num_moves = 0;\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + di[k];\n int nc = c + dj[k];\n if (nr >= 0 && nr < 50 && nc >= 0 && nc < 50) {\n if (!visited[t[nr][nc]]) {\n // Add some random noise to avoid getting stuck in the same deterministic branch\n int perturbed_score = p[nr][nc] * 10 + (rng() % 200);\n moves[num_moves++] = {nr, nc, k, perturbed_score};\n }\n }\n }\n\n if (num_moves > 1) {\n sort(moves, moves + num_moves, [](const Move& a, const Move& b) {\n return a.score > b.score;\n });\n }\n\n for (int i = 0; i < num_moves; ++i) {\n if (time_up || steps_taken > MAX_STEPS_PER_DFS) break;\n\n int nr = moves[i].r;\n int nc = moves[i].c;\n int k = moves[i].k;\n int tile_id = t[nr][nc];\n\n visited[tile_id] = true;\n current_score += p[nr][nc];\n current_path.push_back(dir_char[k]);\n\n dfs(nr, nc);\n\n current_path.pop_back();\n current_score -= p[nr][nc];\n visited[tile_id] = false;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n \n int max_t = 0;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n max_t = max(max_t, t[i][j]);\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 current_path.reserve(2500);\n\n while (!time_up) {\n for (int i = 0; i <= max_t; ++i) visited[i] = false;\n \n visited[t[si][sj]] = true;\n current_score = p[si][sj];\n current_path.clear();\n steps_taken = 0;\n \n dfs(si, sj);\n }\n\n cout << best_path << \"\\n\";\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_VAL = 9000;\nconst int MIN_VAL = 1000;\n\nint get_h_edge(int r, int c) {\n return r * 29 + c;\n}\n\nint get_v_edge(int r, int c) {\n return 30 * 29 + r * 30 + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int num_edges = 30 * 29 + 29 * 30;\n vector weights(num_edges, 5000.0);\n vector times_traversed(num_edges, 0);\n\n // Track averages for horizontal edges per row and vertical edges per column\n vector row_h_sum(N, 5000.0 * 29);\n vector row_h_cnt(N, 29);\n \n vector col_v_sum(N, 5000.0 * 29);\n vector col_v_cnt(N, 29);\n\n for (int q = 0; q < 1000; ++q) {\n int sr, sc, tr, tc;\n if (!(cin >> sr >> sc >> tr >> tc)) break;\n\n vector> dist(N, vector(N, 1e18));\n vector>> parent(N, vector>(N, {-1, -1}));\n vector> dir(N, vector(N, ' '));\n \n priority_queue>, vector>>, greater>>> pq;\n \n dist[sr][sc] = 0;\n pq.push({0, {sr, sc}});\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dch[] = {'U', 'D', 'L', 'R'};\n \n double exploration_factor = max(0.0, 1500.0 * (1.0 - q / 400.0));\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n int r = u.first;\n int c = u.second;\n \n if (d > dist[r][c]) continue;\n if (r == tr && c == tc) break;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int edge_idx = -1;\n double group_avg = 5000.0;\n \n if (i == 0) { // U\n edge_idx = get_v_edge(nr, nc);\n group_avg = col_v_sum[nc] / col_v_cnt[nc];\n } else if (i == 1) { // D\n edge_idx = get_v_edge(r, c);\n group_avg = col_v_sum[c] / col_v_cnt[c];\n } else if (i == 2) { // L\n edge_idx = get_h_edge(nr, nc);\n group_avg = row_h_sum[nr] / row_h_cnt[nr];\n } else if (i == 3) { // R\n edge_idx = get_h_edge(r, c);\n group_avg = row_h_sum[r] / row_h_cnt[r];\n }\n \n // Blend individual estimate with group average based on confidence\n double w = weights[edge_idx];\n if (times_traversed[edge_idx] < 3) {\n double alpha = times_traversed[edge_idx] / 3.0;\n w = alpha * weights[edge_idx] + (1.0 - alpha) * group_avg;\n }\n \n w -= exploration_factor / (1.0 + times_traversed[edge_idx]);\n if (w < 1.0) w = 1.0;\n \n if (dist[r][c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n dir[nr][nc] = dch[i];\n pq.push({dist[nr][nc], {nr, nc}});\n }\n }\n }\n }\n \n string path = \"\";\n int cr = tr, cc = tc;\n vector> path_edge_info; // {edge_idx, type (0=H, 1=V), row/col index}\n \n while (cr != sr || cc != sc) {\n path += dir[cr][cc];\n int pr = parent[cr][cc].first;\n int pc = parent[cr][cc].second;\n \n if (dir[cr][cc] == 'U') path_edge_info.push_back({get_v_edge(cr, cc), 1 + (cc << 1)}); // V, col\n else if (dir[cr][cc] == 'D') path_edge_info.push_back({get_v_edge(pr, pc), 1 + (pc << 1)});\n else if (dir[cr][cc] == 'L') path_edge_info.push_back({get_h_edge(cr, cc), 0 + (cr << 1)}); // H, row\n else if (dir[cr][cc] == 'R') path_edge_info.push_back({get_h_edge(pr, pc), 0 + (pr << 1)});\n \n cr = pr;\n cc = pc;\n }\n \n reverse(path.begin(), path.end());\n cout << path << endl;\n \n int L;\n cin >> L;\n \n double current_est = 0;\n for (auto p : path_edge_info) {\n current_est += weights[p.first];\n }\n \n double error = L - current_est;\n \n for (auto p : path_edge_info) {\n int e = p.first;\n int type = p.second & 1;\n int idx = p.second >> 1;\n \n times_traversed[e]++;\n double lr = 1.0 / sqrt(times_traversed[e] + 1);\n \n double old_w = weights[e];\n double update = (error / path_edge_info.size()) * lr * 1.5;\n weights[e] += update;\n \n if (weights[e] < MIN_VAL) weights[e] = MIN_VAL;\n if (weights[e] > MAX_VAL) weights[e] = MAX_VAL;\n \n // Update group averages\n if (type == 0) {\n row_h_sum[idx] += weights[e] - old_w;\n } else {\n col_v_sum[idx] += weights[e] - old_w;\n }\n }\n }\n \n return 0;\n}","ahc004":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint M;\nstring S[805];\n\nconst int HASH_SIZE = 16384;\nint head[HASH_SIZE];\nuint64_t keys[805];\nint vals[805];\nint nxt[805];\nint sz = 0;\n\nvoid insert_hash(uint64_t key, int val) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n keys[sz] = key;\n vals[sz] = val;\n nxt[sz] = head[h];\n head[h] = sz++;\n}\n\ninline int get_id(uint64_t key) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n for(int i = head[h]; i != -1; i = nxt[i]) {\n if (keys[i] == key) return vals[i];\n }\n return -1;\n}\n\nint grid[N][N];\nint counts[805];\nbool valid_len[15];\n\ninline int evaluate_cell_change(int r, int c, int old_val, int new_val) {\n int diff = 0;\n int buf_h[24];\n int buf_v[24];\n \n // Buffer contiguous memory\n for (int i = 0; i < 23; ++i) {\n buf_h[i] = grid[r][(c - 11 + i + N) % N];\n buf_v[i] = grid[(r - 11 + i + N) % N][c];\n }\n \n auto process = [&](int val, int sign) {\n buf_h[11] = val;\n buf_v[11] = val;\n \n // Horizontal rolling hash\n for(int start = 0; start <= 11; ++start) {\n uint64_t v = 0;\n for(int l = 1; l <= 12; ++l) {\n int ch = buf_h[start + l - 1];\n if (ch == 8) break; // empty cell, no valid strings\n v = (v << 3) | ch;\n if (l >= 2 && start + l - 1 >= 11 && valid_len[l]) {\n uint64_t key = ((uint64_t)l << 36) | v;\n int id = get_id(key);\n if (id != -1) {\n if (sign == 1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n } else {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n }\n \n // Vertical rolling hash\n for(int start = 0; start <= 11; ++start) {\n uint64_t v = 0;\n for(int l = 1; l <= 12; ++l) {\n int ch = buf_v[start + l - 1];\n if (ch == 8) break; // empty cell, no valid strings\n v = (v << 3) | ch;\n if (l >= 2 && start + l - 1 >= 11 && valid_len[l]) {\n uint64_t key = ((uint64_t)l << 36) | v;\n int id = get_id(key);\n if (id != -1) {\n if (sign == 1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n } else {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n }\n };\n \n process(old_val, -1);\n process(new_val, 1);\n grid[r][c] = new_val;\n return diff;\n}\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n memset(head, -1, sizeof(head));\n memset(valid_len, 0, sizeof(valid_len));\n\n if (!(cin >> M >> M)) return 0;\n \n for(int i = 0; i < M; ++i) {\n cin >> S[i];\n valid_len[S[i].length()] = true;\n uint64_t val = 0;\n for(char c : S[i]) {\n val = (val << 3) | (c - 'A');\n }\n uint64_t key = ((uint64_t)S[i].length() << 36) | val;\n insert_hash(key, i);\n }\n\n mt19937 rng(4242);\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n grid[r][c] = rng() % 8;\n }\n }\n\n memset(counts, 0, sizeof(counts));\n int current_score = 0;\n \n // Initial evaluation using rolling hash approach\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n for(int l = 2; l <= 12; ++l) {\n if (!valid_len[l]) continue;\n \n uint64_t val_h = 0;\n for(int i = 0; i < l; ++i) val_h = (val_h << 3) | grid[r][(c + i) % N];\n uint64_t key_h = ((uint64_t)l << 36) | val_h;\n int id_h = get_id(key_h);\n if (id_h != -1) {\n if (counts[id_h] == 0) current_score++;\n counts[id_h]++;\n }\n \n uint64_t val_v = 0;\n for(int i = 0; i < l; ++i) val_v = (val_v << 3) | grid[(r + i) % N][c];\n uint64_t key_v = ((uint64_t)l << 36) | val_v;\n int id_v = get_id(key_v);\n if (id_v != -1) {\n if (counts[id_v] == 0) current_score++;\n counts[id_v]++;\n }\n }\n }\n }\n\n double start_temp = 2.0;\n double end_temp = 0.01;\n double time_limit = 2.9;\n \n int best_grid[N][N];\n int best_score = -1;\n\n int iter = 0;\n while(true) {\n if ((iter & 2047) == 0) {\n double t = get_time();\n if (t > time_limit) break;\n }\n iter++;\n\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val = rng() % 8; \n \n if (current_score == M && (rng() % 5) == 0) {\n new_val = 8;\n }\n \n if (new_val == old_val) {\n new_val = (new_val + 1) % 8;\n }\n\n int diff = evaluate_cell_change(r, c, old_val, new_val);\n\n double t = get_time() / time_limit;\n double temp = start_temp * pow(end_temp / start_temp, t);\n\n if (diff > 0 || exp(diff / temp) > (double)(rng() % 1000000) / 1000000.0) {\n current_score += diff;\n int empty_count = 0;\n if (current_score == M) {\n for(int ir = 0; ir < N; ++ir)\n for(int ic = 0; ic < N; ++ic)\n if (grid[ir][ic] == 8) empty_count++;\n }\n int actual_score = current_score == M ? M + empty_count : current_score;\n if (actual_score > best_score) {\n best_score = actual_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n // Revert\n evaluate_cell_change(r, c, new_val, old_val);\n }\n }\n\n for(int r = 0; r < N; ++r) {\n string out = \"\";\n for(int c = 0; c < N; ++c) {\n if (best_grid[r][c] == 8) out += '.';\n else out += (char)('A' + best_grid[r][c]);\n }\n cout << out << \"\\n\";\n }\n\n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint N, si, sj;\nvector grid;\nvector> visible;\nvector road_cells;\nbool is_road[5000];\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\ninline int get_id(int r, int c) {\n return r * N + c;\n}\n\nint dist_mat[5000][5000];\nint parent_mat[5000][5000];\nchar move_mat[5000][5000];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> si >> sj)) return 0;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n int num_cells = N * N;\n visible.resize(num_cells);\n fill(is_road, is_road + num_cells, false);\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != '#') {\n int u = get_id(r, c);\n is_road[u] = true;\n road_cells.push_back(u);\n }\n }\n }\n\n int total_roads = road_cells.size();\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (!is_road[get_id(r, c)]) continue;\n int u = get_id(r, c);\n \n for (int r2 = r; r2 >= 0; --r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int r2 = r + 1; r2 < N; ++r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int c2 = c - 1; c2 >= 0; --c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n for (int c2 = c + 1; c2 < N; ++c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n }\n }\n\n // Precompute All-Pairs Shortest Path (APSP) using Dijkstra\n for (int u : road_cells) {\n for (int v : road_cells) {\n dist_mat[u][v] = INF;\n parent_mat[u][v] = -1;\n }\n dist_mat[u][u] = 0;\n \n priority_queue, vector>, greater>> pq;\n pq.push({0, u});\n \n while(!pq.empty()) {\n auto [d, curr] = pq.top();\n pq.pop();\n \n if (d > dist_mat[u][curr]) continue;\n \n int r = curr / N;\n int c = curr % N;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int nxt = get_id(nr, nc);\n if (is_road[nxt]) {\n int cost = grid[nr][nc] - '0';\n if (dist_mat[u][curr] + cost < dist_mat[u][nxt]) {\n dist_mat[u][nxt] = dist_mat[u][curr] + cost;\n parent_mat[u][nxt] = curr;\n move_mat[u][nxt] = dir_char[i];\n pq.push({dist_mat[u][nxt], nxt});\n }\n }\n }\n }\n }\n }\n\n mt19937 rng(1337);\n uniform_real_distribution dist_rnd(0.5, 1.5);\n uniform_real_distribution alpha_rnd(0.5, 4.0);\n uniform_real_distribution beta_rnd(0.5, 4.0);\n uniform_real_distribution c_rnd(0.1, 10.0);\n\n string best_ans = \"\";\n int best_cost = INF;\n\n vector seen(num_cells, false);\n\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.85) break;\n\n fill(seen.begin(), seen.end(), false);\n int curr_node = get_id(si, sj);\n int seen_count = 0;\n int current_cost = 0;\n string ans = \"\";\n \n double alpha = alpha_rnd(rng);\n double beta = beta_rnd(rng);\n double c_val = c_rnd(rng);\n\n auto mark_seen = [&](int u) {\n for (int v : visible[u]) {\n if (!seen[v]) {\n seen[v] = true;\n seen_count++;\n }\n }\n };\n\n mark_seen(curr_node);\n\n while (seen_count < total_roads) {\n double best_score = -1.0;\n int best_target = -1;\n\n for (int u : road_cells) {\n if (dist_mat[curr_node][u] == INF || dist_mat[curr_node][u] == 0) continue;\n int unseen = 0;\n for (int v : visible[u]) {\n if (!seen[v]) unseen++;\n }\n \n if (unseen > 0) {\n double rand_factor = dist_rnd(rng);\n double score = (pow(unseen, alpha) / pow(dist_mat[curr_node][u] + c_val, beta)) * rand_factor;\n if (score > best_score) {\n best_score = score;\n best_target = u;\n }\n }\n }\n\n if (best_target == -1) break;\n\n vector path;\n int temp = best_target;\n while (temp != curr_node) {\n path.push_back(move_mat[curr_node][temp]);\n temp = parent_mat[curr_node][temp];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_node -= N;\n else if (dir == 'D') curr_node += N;\n else if (dir == 'L') curr_node -= 1;\n else if (dir == 'R') curr_node += 1;\n \n current_cost += grid[curr_node / N][curr_node % N] - '0';\n mark_seen(curr_node);\n }\n }\n\n int start_id = get_id(si, sj);\n if (curr_node != start_id) {\n vector path;\n int temp = start_id;\n while (temp != curr_node) {\n path.push_back(move_mat[curr_node][temp]);\n temp = parent_mat[curr_node][temp];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_node -= N;\n else if (dir == 'D') curr_node += N;\n else if (dir == 'L') curr_node -= 1;\n else if (dir == 'R') curr_node += 1;\n \n current_cost += grid[curr_node / N][curr_node % N] - '0';\n }\n }\n\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_ans = ans;\n }\n }\n\n if (best_ans.empty()) {\n cout << \"\" << \"\\n\";\n } else {\n cout << best_ans << \"\\n\";\n }\n\n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector deps;\n vector rev_deps;\n int priority = 0;\n int status = -1; // -1: not started, 0: in progress, 1: completed\n};\n\nstruct Member {\n int id;\n vector s;\n int current_task = -1;\n int start_day = -1;\n \n // History for SGD\n struct History {\n int task_id;\n int actual_time;\n };\n vector history;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; ++k) {\n cin >> tasks[i].d[k];\n }\n }\n\n vector in_degree(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n tasks[u].rev_deps.push_back(v);\n tasks[v].deps.push_back(u);\n in_degree[v]++;\n }\n\n // Calculate task priorities (longest path)\n vector dp(N, 0);\n vector topo_order;\n queue q;\n vector in_deg_temp = in_degree;\n for (int i = 0; i < N; ++i) {\n if (in_deg_temp[i] == 0) {\n q.push(i);\n }\n }\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n topo_order.push_back(u);\n for (int v : tasks[u].rev_deps) {\n if (--in_deg_temp[v] == 0) {\n q.push(v);\n }\n }\n }\n \n for (int i = N - 1; i >= 0; --i) {\n int u = topo_order[i];\n dp[u] = 1;\n for (int v : tasks[u].rev_deps) {\n dp[u] = max(dp[u], dp[v] + 1);\n }\n tasks[u].priority = dp[u];\n }\n\n vector members(M);\n for (int i = 0; i < M; ++i) {\n members[i].id = i;\n members[i].s.assign(K, 0.0);\n }\n\n int day = 0;\n int completed_tasks = 0;\n\n while (completed_tasks < N) {\n day++;\n \n vector available_members;\n for (int i = 0; i < M; ++i) {\n if (members[i].current_task == -1) {\n available_members.push_back(i);\n }\n }\n\n vector available_tasks;\n for (int i = 0; i < N; ++i) {\n if (tasks[i].status == -1 && in_degree[i] == 0) {\n available_tasks.push_back(i);\n }\n }\n\n // Greedy matching\n vector assign_m;\n vector assign_t;\n\n while (!available_members.empty() && !available_tasks.empty()) {\n int best_m_idx = -1;\n int best_t_idx = -1;\n double best_score = -1e9;\n\n for (size_t i = 0; i < available_members.size(); ++i) {\n int m_id = available_members[i];\n for (size_t j = 0; j < available_tasks.size(); ++j) {\n int t_id = available_tasks[j];\n \n double expected_w = 0;\n for (int k = 0; k < K; ++k) {\n expected_w += max(0.0, tasks[t_id].d[k] - members[m_id].s[k]);\n }\n double expected_time = max(1.0, expected_w);\n \n // Improved scoring function\n double score = tasks[t_id].priority * 20.0 - expected_time * 2.0;\n \n if (score > best_score) {\n best_score = score;\n best_m_idx = i;\n best_t_idx = j;\n }\n }\n }\n\n int m_id = available_members[best_m_idx];\n int t_id = available_tasks[best_t_idx];\n\n members[m_id].current_task = t_id;\n members[m_id].start_day = day;\n tasks[t_id].status = 0;\n \n assign_m.push_back(m_id + 1);\n assign_t.push_back(t_id + 1);\n\n available_members.erase(available_members.begin() + best_m_idx);\n available_tasks.erase(available_tasks.begin() + best_t_idx);\n }\n\n cout << assign_m.size();\n for (size_t i = 0; i < assign_m.size(); ++i) {\n cout << \" \" << assign_m[i] << \" \" << assign_t[i];\n }\n cout << \"\\n\";\n cout.flush();\n\n int n_finished;\n cin >> n_finished;\n if (n_finished == -1) {\n break;\n }\n\n for (int i = 0; i < n_finished; ++i) {\n int f;\n cin >> f;\n --f;\n \n int t_id = members[f].current_task;\n int actual_time = day - members[f].start_day + 1;\n \n tasks[t_id].status = 1;\n completed_tasks++;\n members[f].current_task = -1;\n \n for (int v : tasks[t_id].rev_deps) {\n in_degree[v]--;\n }\n \n members[f].history.push_back({t_id, actual_time});\n \n // Run SGD on history for this member\n double lr = 0.05;\n for (int iter = 0; iter < 20; ++iter) {\n for (const auto& hist : members[f].history) {\n int hid = hist.task_id;\n int htime = hist.actual_time;\n \n if (htime == 1) {\n for (int k = 0; k < K; ++k) {\n members[f].s[k] = max(members[f].s[k], (double)tasks[hid].d[k]);\n }\n continue;\n }\n \n double current_w = 0;\n vector active_k;\n for (int k = 0; k < K; ++k) {\n if (tasks[hid].d[k] > members[f].s[k]) {\n current_w += (tasks[hid].d[k] - members[f].s[k]);\n active_k.push_back(k);\n }\n }\n \n double target_w = max(1.0, (double)htime - 1.0);\n if (!active_k.empty()) {\n double error = current_w - target_w; // Positive if we underestimated skill\n double grad = error / active_k.size();\n for (int k : active_k) {\n members[f].s[k] += lr * grad;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n } else {\n // All skills exceed difficulty, but time > 1. Means we overestimated skills.\n for (int k = 0; k < K; ++k) {\n if (tasks[hid].d[k] > 0) {\n members[f].s[k] -= lr * target_w / K;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n }\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int NUM_ORDERS = 1000;\nconst int SELECTED_SIZE = 50;\n\nstruct Order {\n int id;\n int a, b, c, d;\n int dist_to_center;\n};\n\nstruct Point {\n int x, y;\n};\n\nint manhattan(Point p1, Point p2) {\n return abs(p1.x - p2.x) + abs(p1.y - p2.y);\n}\n\nvector orders(NUM_ORDERS);\nmt19937 rng(42);\n\ndouble get_time(chrono::time_point& start) {\n auto current_time = chrono::high_resolution_clock::now();\n return chrono::duration(current_time - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n for (int i = 0; i < NUM_ORDERS; ++i) {\n orders[i].id = i + 1;\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].dist_to_center = abs(orders[i].a - 400) + abs(orders[i].b - 400) + \n abs(orders[i].c - 400) + abs(orders[i].d - 400);\n }\n\n vector sorted_orders = orders;\n sort(sorted_orders.begin(), sorted_orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_to_center < o2.dist_to_center;\n });\n\n vector active_orders(SELECTED_SIZE);\n vector inactive_orders(NUM_ORDERS - SELECTED_SIZE);\n \n for (int i = 0; i < SELECTED_SIZE; ++i) active_orders[i] = sorted_orders[i].id - 1;\n for (int i = SELECTED_SIZE; i < NUM_ORDERS; ++i) inactive_orders[i - SELECTED_SIZE] = sorted_orders[i].id - 1;\n\n vector path; // 0..49 for pickup, 50..99 for dropoff\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n path.push_back(i);\n path.push_back(i + SELECTED_SIZE);\n }\n\n auto eval_path = [&](const vector& p, const vector& act) {\n int dist = 0;\n Point curr = {400, 400};\n for (int node : p) {\n Point next;\n if (node < SELECTED_SIZE) next = {orders[act[node]].a, orders[act[node]].b};\n else next = {orders[act[node - SELECTED_SIZE]].c, orders[act[node - SELECTED_SIZE]].d};\n dist += manhattan(curr, next);\n curr = next;\n }\n dist += manhattan(curr, {400, 400});\n return dist;\n };\n\n int best_dist = eval_path(path, active_orders);\n vector best_path = path;\n vector best_active = active_orders;\n\n int current_dist = best_dist;\n\n double time_limit = 1.95;\n double t = 0;\n int iter = 0;\n\n uniform_real_distribution dist01(0.0, 1.0);\n\n while (true) {\n if ((iter & 127) == 0) {\n t = get_time(start_time);\n if (t >= time_limit) break;\n }\n iter++;\n \n double temp = 500.0 * (1.0 - t / time_limit);\n \n int type = rng() % 3;\n \n if (type == 0) { // Relocate\n int u = rng() % 100;\n int v = rng() % 100;\n if (u == v) continue;\n \n vector new_path = path;\n int val = new_path[u];\n new_path.erase(new_path.begin() + u);\n new_path.insert(new_path.begin() + v, val);\n \n // Check validity\n bool valid = true;\n vector pos(100);\n for (int i = 0; i < 100; ++i) pos[new_path[i]] = i;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n if (pos[i] >= pos[i + SELECTED_SIZE]) {\n valid = false;\n break;\n }\n }\n if (!valid) continue;\n \n int new_dist = eval_path(new_path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n path = new_path;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n }\n } else if (type == 1) { // Swap in path\n int u = rng() % 100;\n int v = rng() % 100;\n if (u == v) continue;\n \n vector new_path = path;\n swap(new_path[u], new_path[v]);\n \n // Check validity\n bool valid = true;\n vector pos(100);\n for (int i = 0; i < 100; ++i) pos[new_path[i]] = i;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n if (pos[i] >= pos[i + SELECTED_SIZE]) {\n valid = false;\n break;\n }\n }\n if (!valid) continue;\n \n int new_dist = eval_path(new_path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n path = new_path;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n }\n } else { // Order swap\n int act_idx = rng() % SELECTED_SIZE;\n int inact_idx = rng() % inactive_orders.size();\n \n // new_path size will temporarily become 98, valid insertion limits are 0 to 98 and 0 to 99\n int u = rng() % 99;\n int v = rng() % 100;\n if (u > v) swap(u, v);\n \n vector new_active = active_orders;\n swap(new_active[act_idx], inactive_orders[inact_idx]);\n \n vector new_path;\n new_path.reserve(100);\n for (int x : path) {\n if (x != act_idx && x != act_idx + SELECTED_SIZE) {\n new_path.push_back(x);\n }\n }\n \n new_path.insert(new_path.begin() + u, act_idx);\n new_path.insert(new_path.begin() + v, act_idx + SELECTED_SIZE);\n \n int new_dist = eval_path(new_path, new_active);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n path = new_path;\n active_orders = new_active;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n // backtrack the inactive order swap\n swap(inactive_orders[inact_idx], new_active[act_idx]);\n }\n }\n }\n\n // Output best orders\n cout << SELECTED_SIZE;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n cout << \" \" << orders[best_active[i]].id;\n }\n cout << \"\\n\";\n\n // Output best route\n vector final_route;\n final_route.push_back({400, 400});\n for (int node : best_path) {\n if (node < SELECTED_SIZE) final_route.push_back({orders[best_active[node]].a, orders[best_active[node]].b});\n else final_route.push_back({orders[best_active[node - SELECTED_SIZE]].c, orders[best_active[node - SELECTED_SIZE]].d});\n }\n final_route.push_back({400, 400});\n\n cout << final_route.size();\n for (const auto& p : final_route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Disjoint Set Union (DSU) to manage connected components\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\nstruct Edge {\n int id;\n int u;\n int v;\n int expected_d;\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = 400;\n int M = 1995;\n\n vector> points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n\n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v;\n edges[i].id = i;\n double dist = sqrt(pow(points[edges[i].u].first - points[edges[i].v].first, 2) + \n pow(points[edges[i].u].second - points[edges[i].v].second, 2));\n // The length l_i is uniformly distributed between d_i and 3*d_i, so the expected length is 2*d_i.\n edges[i].expected_d = 2 * round(dist);\n }\n\n DSU current_dsu(N);\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n\n // Collect the current edge with its known length, and future edges with their expected lengths\n vector> future_edges;\n future_edges.reserve(M - i);\n future_edges.push_back({l, i});\n for (int j = i + 1; j < M; ++j) {\n future_edges.push_back({edges[j].expected_d, j});\n }\n\n // Sort edges by length to simulate Kruskal's algorithm\n sort(future_edges.begin(), future_edges.end());\n\n DSU temp_dsu = current_dsu;\n bool use_current = false;\n\n // Run Kruskal's to see if the current edge is selected in the MST\n for (auto& edge : future_edges) {\n int e_id = edge.second;\n int u = edges[e_id].u;\n int v = edges[e_id].v;\n\n if (temp_dsu.find(u) != temp_dsu.find(v)) {\n temp_dsu.unite(u, v);\n if (e_id == i) {\n use_current = true;\n break;\n }\n } else if (e_id == i) {\n break;\n }\n }\n\n // Adopt the edge if it's part of the simulated MST\n if (use_current) {\n current_dsu.unite(edges[i].u, edges[i].v);\n cout << 1 << endl;\n } else {\n cout << 0 << endl;\n }\n }\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nbool grid_passable[GRID_SIZE + 2][GRID_SIZE + 2];\nint pet_count[GRID_SIZE + 2][GRID_SIZE + 2];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\nchar move_dir[] = {'U', 'D', 'L', 'R'};\nchar block_dir[] = {'u', 'd', 'l', 'r'};\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y;\n};\n\nbool is_safe_to_block(int x, int y, const vector>& start_human_count, const vector>& next_human_count) {\n if (x < 1 || x > GRID_SIZE || y < 1 || y > GRID_SIZE) return false;\n if (!grid_passable[x][y]) return false;\n // Cannot block if there was a human at the start of the turn, or if another human is moving there\n if (pet_count[x][y] > 0 || start_human_count[x][y] > 0 || next_human_count[x][y] > 0) return false;\n \n // Cannot block if any adjacent square contains a pet\n for (int i = 0; i < 4; ++i) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n if (nx >= 1 && nx <= GRID_SIZE && ny >= 1 && ny <= GRID_SIZE) {\n if (pet_count[nx][ny] > 0) return false;\n }\n }\n return true;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n grid_passable[i][j] = true;\n }\n }\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector pets(N);\n for (int i = 0; i < N; ++i) {\n cin >> pets[i].x >> pets[i].y >> pets[i].type;\n pet_count[pets[i].x][pets[i].y]++;\n }\n\n int M;\n cin >> M;\n vector humans(M);\n for (int i = 0; i < M; ++i) {\n cin >> humans[i].x >> humans[i].y;\n }\n\n mt19937 rng(42);\n\n for (int turn = 0; turn < 300; ++turn) {\n vector> start_human_count(GRID_SIZE + 2, vector(GRID_SIZE + 2, 0));\n for (int i = 0; i < M; ++i) {\n start_human_count[humans[i].x][humans[i].y]++;\n }\n \n vector> next_human_count(GRID_SIZE + 2, vector(GRID_SIZE + 2, 0));\n string action = \"\";\n\n for (int i = 0; i < M; ++i) {\n bool acted = false;\n \n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n \n // Try to block randomly\n for (int d : dirs) {\n int nx = humans[i].x + dx[d];\n int ny = humans[i].y + dy[d];\n if (is_safe_to_block(nx, ny, start_human_count, next_human_count)) {\n action += block_dir[d];\n grid_passable[nx][ny] = false;\n next_human_count[humans[i].x][humans[i].y]++; // Human stays in place\n acted = true;\n break;\n }\n }\n \n // Try to move\n if (!acted) {\n for (int d : dirs) {\n int nx = humans[i].x + dx[d];\n int ny = humans[i].y + dy[d];\n if (nx >= 1 && nx <= GRID_SIZE && ny >= 1 && ny <= GRID_SIZE && grid_passable[nx][ny]) {\n humans[i].x = nx;\n humans[i].y = ny;\n next_human_count[nx][ny]++;\n action += move_dir[d];\n acted = true;\n break;\n }\n }\n }\n \n if (!acted) {\n next_human_count[humans[i].x][humans[i].y]++;\n action += \".\";\n }\n }\n cout << action << \"\\n\";\n cout.flush();\n\n // Reset pet counts\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n pet_count[i][j] = 0;\n }\n }\n\n // Read pet moves\n for (int i = 0; i < N; ++i) {\n string pet_move;\n cin >> pet_move;\n if (pet_move != \".\") {\n for (char c : pet_move) {\n if (c == 'U') pets[i].x--;\n else if (c == 'D') pets[i].x++;\n else if (c == 'L') pets[i].y--;\n else if (c == 'R') pets[i].y++;\n }\n }\n pet_count[pets[i].x][pets[i].y]++;\n }\n }\n\n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint si, sj, ti, tj;\ndouble p;\nstring h[N], v[N - 1];\nint dist[N][N];\ndouble E[N][N];\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nbool can_move(int i, int j, int d) {\n if (d == 0) return i > 0 && v[i - 1][j] == '0';\n if (d == 1) return i < N - 1 && v[i][j] == '0';\n if (d == 2) return j > 0 && h[i][j - 1] == '0';\n if (d == 3) return j < N - 1 && h[i][j] == '0';\n return false;\n}\n\nvoid compute_dist() {\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n dist[i][j] = 1e9;\n \n queue> q;\n q.push({ti, tj});\n dist[ti][tj] = 0;\n \n while (!q.empty()) {\n auto [i, j] = q.front();\n q.pop();\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d];\n int nj = j + dj[d];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N) {\n if (can_move(ni, nj, d ^ 1) && dist[ni][nj] > dist[i][j] + 1) {\n dist[ni][nj] = dist[i][j] + 1;\n q.push({ni, nj});\n }\n }\n }\n }\n}\n\nvoid compute_E() {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (dist[i][j] < 1e9) E[i][j] = dist[i][j] / (1.0 - p);\n else E[i][j] = 1e9;\n }\n }\n E[ti][tj] = 0.0;\n \n for (int iter = 0; iter < 1000; ++iter) {\n double max_diff = 0.0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == ti && j == tj) continue;\n double min_val = 1e9;\n for (int d = 0; d < 4; ++d) {\n if (can_move(i, j, d)) {\n int ni = i + di[d];\n int nj = j + dj[d];\n double val = (1.0 + (1.0 - p) * E[ni][nj]) / (1.0 - p);\n if (val < min_val) min_val = val;\n }\n }\n if (min_val < 1e9) {\n max_diff = max(max_diff, abs(E[i][j] - min_val));\n E[i][j] = min_val;\n }\n }\n }\n if (max_diff < 1e-6) break;\n }\n}\n\nstruct State {\n double prob[N][N];\n string path;\n double score;\n\n bool operator<(const State& other) const {\n return score < other.score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n for (int i = 0; i < N; ++i) cin >> h[i];\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n compute_dist();\n compute_E();\n\n vector beam;\n State initial_state;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n initial_state.prob[i][j] = 0.0;\n initial_state.prob[si][sj] = 1.0;\n initial_state.path = \"\";\n initial_state.score = E[si][sj];\n beam.push_back(initial_state);\n\n int beam_width = 200;\n\n for (int step = 0; step < 200; ++step) {\n if (beam.empty() || beam[0].prob[ti][tj] > 0.9999) break;\n\n vector next_beam;\n next_beam.reserve(beam.size() * 4);\n\n for (const auto& state : beam) {\n for (int d = 0; d < 4; ++d) {\n State next_state;\n next_state.path = state.path + dir_char[d];\n next_state.score = 0.0;\n\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n next_state.prob[i][j] = 0.0;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n double pr = state.prob[i][j];\n if (pr < 1e-9) continue;\n\n if (i == ti && j == tj) {\n next_state.prob[i][j] += pr;\n } else if (can_move(i, j, d)) {\n int ni = i + di[d];\n int nj = j + dj[d];\n next_state.prob[ni][nj] += pr * (1.0 - p);\n next_state.prob[i][j] += pr * p;\n } else {\n next_state.prob[i][j] += pr;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (next_state.prob[i][j] > 1e-9) {\n next_state.score += next_state.prob[i][j] * E[i][j];\n }\n }\n }\n next_beam.push_back(next_state);\n }\n }\n\n int keep = min((int)next_beam.size(), beam_width);\n partial_sort(next_beam.begin(), next_beam.begin() + keep, next_beam.end());\n next_beam.resize(keep);\n beam = move(next_beam);\n }\n\n cout << beam[0].path << \"\\n\";\n return 0;\n}","ahc010":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int di[4] = {0, -1, 0, 1};\nconst int dj[4] = {-1, 0, 1, 0};\n\nconst int TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\n\nint rot(int t, int r) {\n if (t >= 0 && t <= 3) return (t + r) % 4;\n if (t >= 4 && t <= 5) return 4 + (t - 4 + r) % 2;\n if (t >= 6 && t <= 7) return 6 + (t - 6 + r) % 2;\n return t;\n}\n\nint base_grid[30][30];\nint cur_grid[30][30];\nint cur_rot[30][30];\n\nint vis[30][30][4];\nint vis_id = 0;\n\nlong long evaluate() {\n vis_id++;\n int l1 = 0, l2 = 0;\n \n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) {\n if (vis[i][j][d] == vis_id) continue;\n int nd = TO[cur_grid[i][j]][d];\n if (nd == -1) continue;\n \n int ci = i, cj = j, cd = d;\n int len = 0;\n \n while (true) {\n if (vis[ci][cj][cd] == vis_id) {\n if (ci == i && cj == j && cd == d) {\n if (len > l1) {\n l2 = l1;\n l1 = len;\n } else if (len > l2) {\n l2 = len;\n }\n }\n break;\n }\n vis[ci][cj][cd] = vis_id;\n int nxt_d = TO[cur_grid[ci][cj]][cd];\n if (nxt_d == -1) break;\n \n int ni = ci + di[nxt_d];\n int nj = cj + dj[nxt_d];\n if (ni < 0 || ni >= 30 || nj < 0 || nj >= 30) break;\n \n ci = ni; \n cj = nj; \n cd = (nxt_d + 2) % 4;\n len++;\n }\n }\n }\n }\n return (long long)l1 * l2;\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ndouble rnd() {\n return (double)(xor128() & 0xFFFFFF) / 16777216.0;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start = chrono::high_resolution_clock::now();\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n base_grid[i][j] = s[j] - '0';\n cur_grid[i][j] = base_grid[i][j];\n cur_rot[i][j] = 0;\n }\n }\n\n long long best_score = evaluate();\n long long current_score = best_score;\n \n int best_rot[30][30];\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n best_rot[i][j] = cur_rot[i][j];\n }\n }\n\n double T0 = 200.0;\n double T1 = 0.1;\n double time_limit = 1.95;\n\n int iters = 0;\n while (true) {\n if ((iters & 255) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n double T = T0 * pow(T1 / T0, progress);\n \n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) % 4;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n long long score = evaluate();\n \n bool accept = false;\n if (score >= current_score) {\n accept = true;\n } else {\n double prob = exp((score - current_score) / T);\n if (rnd() < prob) accept = true;\n }\n \n if (accept) {\n current_score = score;\n if (score > best_score) {\n best_score = score;\n for (int r = 0; r < 30; r++) {\n for (int c = 0; c < 30; c++) {\n best_rot[r][c] = cur_rot[r][c];\n }\n }\n }\n } else {\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n } else {\n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) % 4;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n long long score = evaluate();\n \n if (score >= current_score) {\n current_score = score;\n if (score > best_score) {\n best_score = score;\n for (int r = 0; r < 30; r++) {\n for (int c = 0; c < 30; c++) {\n best_rot[r][c] = cur_rot[r][c];\n }\n }\n }\n } else {\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n }\n iters++;\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n }\n }\n cout << \"\\n\";\n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nint N, T;\nuint8_t initial_board[100];\nint init_empty_r, init_empty_c;\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dir_char[] = {'U', 'D', 'L', 'R'};\nconst char opp_dir[] = {'D', 'U', 'R', 'L'};\n\nint time_limit_ms = 2800;\n\nuint64_t zobrist[100][16];\n\nvoid init_zobrist() {\n mt19937_64 rng(1337);\n for (int i = 0; i < 100; ++i) {\n for (int j = 0; j < 16; ++j) {\n zobrist[i][j] = rng();\n }\n }\n}\n\nint get_eval(const uint8_t* b, int& max_tree_size) {\n int parent[100];\n int sz[100];\n int edges_cnt[100];\n int broken = 0;\n int valid = 0;\n\n int N2 = N * N;\n for (int i = 0; i < N2; ++i) {\n parent[i] = i;\n sz[i] = 1;\n edges_cnt[i] = 0;\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = r * N + c;\n if (b[u] == 0) continue;\n\n if (r < N - 1 && b[u + N] != 0) {\n bool down = b[u] & 8;\n bool up = b[u + N] & 2;\n if (down && up) {\n valid++;\n int root_u = u, root_v = u + N;\n while (parent[root_u] != root_u) root_u = parent[root_u];\n while (parent[root_v] != root_v) root_v = parent[root_v];\n if (root_u != root_v) {\n parent[root_u] = root_v;\n sz[root_v] += sz[root_u];\n edges_cnt[root_v] += edges_cnt[root_u] + 1;\n } else {\n edges_cnt[root_u]++;\n }\n } else if (down || up) {\n broken++;\n }\n }\n if (c < N - 1 && b[u + 1] != 0) {\n bool right = b[u] & 4;\n bool left = b[u + 1] & 1;\n if (right && left) {\n valid++;\n int root_u = u, root_v = u + 1;\n while (parent[root_u] != root_u) root_u = parent[root_u];\n while (parent[root_v] != root_v) root_v = parent[root_v];\n if (root_u != root_v) {\n parent[root_u] = root_v;\n sz[root_v] += sz[root_u];\n edges_cnt[root_v] += edges_cnt[root_u] + 1;\n } else {\n edges_cnt[root_u]++;\n }\n } else if (right || left) {\n broken++;\n }\n }\n }\n }\n\n max_tree_size = 0;\n for (int i = 0; i < N2; ++i) {\n if (parent[i] == i && b[i] != 0) {\n if (edges_cnt[i] == sz[i] - 1) {\n if (sz[i] > max_tree_size) {\n max_tree_size = sz[i];\n }\n }\n }\n }\n\n return max_tree_size * 10000 + valid * 10 - broken;\n}\n\nstruct State {\n uint8_t b[100];\n uint8_t er, ec;\n int score;\n int tree_size;\n uint64_t hash;\n string moves;\n\n bool operator<(const State& o) const {\n return score > o.score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n init_zobrist();\n\n if (!(cin >> N >> T)) return 0;\n\n uint64_t init_hash = 0;\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (s[j] >= '0' && s[j] <= '9') initial_board[idx] = s[j] - '0';\n else initial_board[idx] = s[j] - 'a' + 10;\n \n init_hash ^= zobrist[idx][initial_board[idx]];\n \n if (initial_board[idx] == 0) {\n init_empty_r = i;\n init_empty_c = j;\n }\n }\n }\n\n int best_tree_size = 0;\n string best_moves = \"\";\n\n int initial_tree_size = 0;\n int initial_score = get_eval(initial_board, initial_tree_size);\n best_tree_size = initial_tree_size;\n\n vector beam;\n State init_state;\n copy(initial_board, initial_board + 100, init_state.b);\n init_state.er = init_empty_r;\n init_state.ec = init_empty_c;\n init_state.score = initial_score;\n init_state.tree_size = initial_tree_size;\n init_state.hash = init_hash;\n init_state.moves = \"\";\n beam.push_back(init_state);\n\n int beam_width = (N <= 7) ? 1000 : 500;\n unordered_set visited;\n visited.insert(init_hash);\n\n for (int step = 0; step < T; ++step) {\n if ((step & 15) == 0) {\n auto current_time = high_resolution_clock::now();\n if (duration_cast(current_time - start_time).count() > time_limit_ms) {\n break;\n }\n }\n\n vector next_beam;\n next_beam.reserve(beam.size() * 4);\n\n for (const auto& state : beam) {\n char last_move = state.moves.empty() ? 'X' : state.moves.back();\n\n for (int d = 0; d < 4; ++d) {\n if (last_move == opp_dir[d]) continue;\n\n int nr = state.er + dr[d];\n int nc = state.ec + dc[d];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int u = state.er * N + state.ec;\n int v = nr * N + nc;\n \n uint64_t next_hash = state.hash;\n next_hash ^= zobrist[u][state.b[u]] ^ zobrist[u][state.b[v]];\n next_hash ^= zobrist[v][state.b[v]] ^ zobrist[v][state.b[u]];\n\n if (visited.find(next_hash) != visited.end()) continue;\n\n State next_state = state;\n swap(next_state.b[u], next_state.b[v]);\n next_state.er = nr;\n next_state.ec = nc;\n next_state.hash = next_hash;\n next_state.moves += dir_char[d];\n\n next_state.score = get_eval(next_state.b, next_state.tree_size);\n next_beam.push_back(move(next_state));\n visited.insert(next_hash);\n }\n }\n }\n\n sort(next_beam.begin(), next_beam.end());\n if (next_beam.size() > beam_width) {\n next_beam.resize(beam_width);\n }\n\n beam = move(next_beam);\n\n if (!beam.empty() && beam[0].tree_size > best_tree_size) {\n best_tree_size = beam[0].tree_size;\n best_moves = beam[0].moves;\n }\n \n // Prevent unbounded memory growth of visited states\n if (visited.size() > 500000) {\n visited.clear();\n }\n }\n\n cout << best_moves << \"\\n\";\n\n return 0;\n}","ahc012":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int K = 100;\nint N;\nint a[11];\nint x_coords[10005];\nint y_coords[10005];\n\nstruct Line {\n double theta;\n double r;\n};\n\nLine lines[K];\nuint64_t hashes0[10005];\nuint64_t hashes1[10005];\n\npair, pair> get_points(const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n double px = l.r * cos_t - 20000.0 * sin_t;\n double py = l.r * sin_t + 20000.0 * cos_t;\n double qx = l.r * cos_t + 20000.0 * sin_t;\n double qy = l.r * sin_t - 20000.0 * cos_t;\n return {{round(px), round(py)}, {round(qx), round(qy)}};\n}\n\nstruct alignas(16) HashVal {\n uint64_t h0, h1;\n bool operator<(const HashVal& o) const {\n if (h0 != o.h0) return h0 < o.h0;\n return h1 < o.h1;\n }\n bool operator==(const HashVal& o) const {\n return h0 == o.h0 && h1 == o.h1;\n }\n};\n\nHashVal h_arr[10005];\n\n// Fast PRNG\nuint64_t xorshift64_state = 0x8817264546332525ULL;\ninline uint64_t xorshift64() {\n xorshift64_state ^= xorshift64_state << 13;\n xorshift64_state ^= xorshift64_state >> 7;\n xorshift64_state ^= xorshift64_state << 17;\n return xorshift64_state;\n}\n\ninline double fast_rand_double() {\n return (xorshift64() >> 11) * (1.0 / 9007199254740992.0);\n}\n\nint evaluate() {\n for (int i = 0; i < N; ++i) {\n h_arr[i].h0 = hashes0[i];\n h_arr[i].h1 = hashes1[i];\n }\n \n std::sort(h_arr, h_arr + N);\n\n int b[11] = {0};\n int current_count = 1;\n for (int i = 1; i < N; ++i) {\n if (h_arr[i] == h_arr[i - 1]) {\n current_count++;\n } else {\n if (current_count <= 10) {\n b[current_count]++;\n }\n current_count = 1;\n }\n }\n if (current_count <= 10) {\n b[current_count]++;\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n score += min(a[d], b[d]);\n }\n return score;\n}\n\nvoid update_line_hash(int line_idx, const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n if (line_idx < 64) {\n uint64_t mask = 1ULL << line_idx;\n uint64_t not_mask = ~mask;\n for (int i = 0; i < N; ++i) {\n if (x_coords[i] * cos_t + y_coords[i] * sin_t > l.r) hashes0[i] |= mask;\n else hashes0[i] &= not_mask;\n }\n } else {\n int shift = line_idx - 64;\n uint64_t mask = 1ULL << shift;\n uint64_t not_mask = ~mask;\n for (int i = 0; i < N; ++i) {\n if (x_coords[i] * cos_t + y_coords[i] * sin_t > l.r) hashes1[i] |= mask;\n else hashes1[i] &= not_mask;\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int max_k;\n if (!(cin >> N >> max_k)) return 0;\n\n int total_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n total_a += a[i];\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> x_coords[i] >> y_coords[i];\n }\n\n for (int i = 0; i < K; ++i) {\n lines[i].theta = fast_rand_double() * M_PI;\n lines[i].r = fast_rand_double() * 19800.0 - 9900.0;\n update_line_hash(i, lines[i]);\n }\n\n int current_score = evaluate();\n int best_score = current_score;\n \n Line best_lines[K];\n for(int i = 0; i < K; ++i) best_lines[i] = lines[i];\n\n auto start_time = chrono::high_resolution_clock::now();\n double time_limit = 2.85;\n\n double t0 = 1.5;\n double t1 = 0.05;\n double temp = t0;\n \n int iter = 0;\n while (true) {\n if ((iter & 127) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n temp = t0 * pow(t1 / t0, progress);\n }\n\n int idx = xorshift64() % K;\n Line old_line = lines[idx];\n\n if (xorshift64() % 5 == 0) {\n lines[idx].theta = fast_rand_double() * M_PI;\n lines[idx].r = fast_rand_double() * 19800.0 - 9900.0;\n } else {\n // Gaussian-like approximation for small delta\n double d_theta = (fast_rand_double() + fast_rand_double() - 1.0) * 0.1;\n double d_r = (fast_rand_double() + fast_rand_double() - 1.0) * 400.0;\n lines[idx].theta += d_theta;\n lines[idx].r += d_r;\n }\n \n update_line_hash(idx, lines[idx]);\n int new_score = evaluate();\n\n bool accept = false;\n if (new_score >= current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (fast_rand_double() < prob) accept = true;\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n for(int i = 0; i < K; ++i) best_lines[i] = lines[i];\n }\n } else {\n lines[idx] = old_line;\n update_line_hash(idx, lines[idx]);\n }\n \n iter++;\n }\n\n cout << K << \"\\n\";\n for (int i = 0; i < K; ++i) {\n auto pts = get_points(best_lines[i]);\n cout << pts.first.first << \" \" << pts.first.second << \" \" \n << pts.second.first << \" \" << pts.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int MAXN = 65;\n\nstruct Point {\n int x, y;\n bool operator==(const Point& o) const { return x == o.x && y == o.y; }\n};\n\nstruct Move {\n Point p1, p2, p3, p4;\n};\n\nint N, M;\nPoint center;\nvector initial_dots;\nint weight[MAXN][MAXN];\n\ndouble get_time() {\n static auto start = high_resolution_clock::now();\n return duration(high_resolution_clock::now() - start).count();\n}\n\nstruct State {\n bool has_dot[MAXN][MAXN];\n int edges[4][MAXN][MAXN]; \n vector dots;\n vector moves;\n int score;\n\n State() {\n for (int i = 0; i < MAXN; ++i) {\n for (int j = 0; j < MAXN; ++j) {\n has_dot[i][j] = false;\n for (int k = 0; k < 4; ++k) edges[k][i][j] = 0;\n }\n }\n score = 0;\n }\n\n void add_dot(Point p) {\n has_dot[p.x][p.y] = true;\n dots.push_back(p);\n score += weight[p.x][p.y];\n }\n\n bool inside(int x, int y) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n\n bool check_edge(Point p1, Point p2) const {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = (step_y == 0) ? 0 : ((step_x == 0) ? 1 : ((step_x == step_y) ? 2 : 3));\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n if (edges[type][ex][ey]) return false;\n if ((cx != p1.x || cy != p1.y) && has_dot[cx][cy]) return false;\n cx = nx; cy = ny;\n }\n return true;\n }\n\n void mark_edge(Point p1, Point p2, int val) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = (step_y == 0) ? 0 : ((step_x == 0) ? 1 : ((step_x == step_y) ? 2 : 3));\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n edges[type][ex][ey] += val;\n cx = nx; cy = ny;\n }\n }\n\n bool is_valid_rect(Point p1, Point p2, Point p3, Point p4) const {\n if (!inside(p1.x, p1.y) || !inside(p2.x, p2.y) || !inside(p3.x, p3.y) || !inside(p4.x, p4.y)) return false;\n if (has_dot[p1.x][p1.y]) return false;\n if (!has_dot[p2.x][p2.y] || !has_dot[p3.x][p3.y] || !has_dot[p4.x][p4.y]) return false;\n if (!check_edge(p1, p2) || !check_edge(p2, p3) || !check_edge(p3, p4) || !check_edge(p4, p1)) return false;\n return true;\n }\n\n void apply_move(const Move& m) {\n add_dot(m.p1);\n mark_edge(m.p1, m.p2, 1);\n mark_edge(m.p2, m.p3, 1);\n mark_edge(m.p3, m.p4, 1);\n mark_edge(m.p4, m.p1, 1);\n moves.push_back(m);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n center = {(N - 1) / 2, (N - 1) / 2};\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n weight[i][j] = (i - center.x) * (i - center.x) + (j - center.y) * (j - center.y) + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_dots.push_back({x, y});\n }\n\n State best_state;\n best_state.score = -1;\n \n uint32_t seed = 987654321;\n auto rand_u32 = [&]() -> uint32_t {\n seed ^= seed << 13;\n seed ^= seed >> 17;\n seed ^= seed << 5;\n return seed;\n };\n\n while (get_time() < 4.8) {\n State state;\n for (auto p : initial_dots) state.add_dot(p);\n\n bool moved = true;\n while (moved && get_time() < 4.8) {\n moved = false;\n vector candidates;\n\n // Iterate over pairs to find squares like the original, but properly\n for (int i = 0; i < (int)state.dots.size(); ++i) {\n for (int j = i + 1; j < (int)state.dots.size(); ++j) {\n Point p2 = state.dots[i];\n Point p4 = state.dots[j];\n \n int mx = p2.x + p4.x;\n int my = p2.y + p4.y;\n int dx = p4.x - p2.x;\n int dy = p4.y - p2.y;\n\n if ((mx + dy) % 2 != 0 || (my - dx) % 2 != 0) continue;\n\n Point p1 = {(mx - dy) / 2, (my + dx) / 2};\n Point p3 = {(mx + dy) / 2, (my - dx) / 2};\n\n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n if (state.is_valid_rect(p1, p4, p3, p2)) candidates.push_back({p1, p4, p3, p2});\n if (state.is_valid_rect(p3, p4, p1, p2)) candidates.push_back({p3, p4, p1, p2});\n }\n }\n\n if (!candidates.empty()) {\n Move best_m = candidates[0];\n int best_val = -1;\n for (const auto& m : candidates) {\n // Slight randomness prevents getting stuck in bad local maxima\n int val = weight[m.p1.x][m.p1.y] * 10 + (rand_u32() % 100); \n if (val > best_val) {\n best_val = val;\n best_m = m;\n }\n }\n state.apply_move(best_m);\n moved = true;\n }\n }\n\n if (state.score > best_state.score) {\n best_state = state;\n }\n }\n\n cout << best_state.moves.size() << \"\\n\";\n for (const auto& m : best_state.moves) {\n cout << m.p1.x << \" \" << m.p1.y << \" \" \n << m.p2.x << \" \" << m.p2.y << \" \" \n << m.p3.x << \" \" << m.p3.y << \" \" \n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Board {\n uint8_t grid[10][10] = {0};\n\n inline void add_candy(uint8_t flavor, int p) {\n int empty_count = 0;\n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] == 0) {\n empty_count++;\n if (empty_count == p) {\n grid[r][c] = flavor;\n return;\n }\n }\n }\n }\n }\n\n // 0: F, 1: B, 2: L, 3: R\n inline bool tilt(int dir) {\n bool changed = false;\n if (dir == 0) { // F\n for (int c = 0; c < 10; ++c) {\n int write_idx = 0;\n for (int r = 0; r < 10; ++r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 1) { // B\n for (int c = 0; c < 10; ++c) {\n int write_idx = 9;\n for (int r = 9; r >= 0; --r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n } else if (dir == 2) { // L\n for (int r = 0; r < 10; ++r) {\n int write_idx = 0;\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 3) { // R\n for (int r = 0; r < 10; ++r) {\n int write_idx = 9;\n for (int c = 9; c >= 0; --c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n }\n return changed;\n }\n\n inline int calc_score() const {\n bool vis[10][10] = {false};\n int score = 0;\n int q[100];\n \n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0 && !vis[r][c]) {\n uint8_t flavor = grid[r][c];\n int sz = 0;\n int head = 0, tail = 0;\n \n q[tail++] = r * 10 + c;\n vis[r][c] = true;\n \n while (head < tail) {\n int pos = q[head++];\n int cr = pos / 10;\n int cc = pos % 10;\n sz++;\n \n if (cr > 0 && !vis[cr - 1][cc] && grid[cr - 1][cc] == flavor) {\n vis[cr - 1][cc] = true;\n q[tail++] = (cr - 1) * 10 + cc;\n }\n if (cr < 9 && !vis[cr + 1][cc] && grid[cr + 1][cc] == flavor) {\n vis[cr + 1][cc] = true;\n q[tail++] = (cr + 1) * 10 + cc;\n }\n if (cc > 0 && !vis[cr][cc - 1] && grid[cr][cc - 1] == flavor) {\n vis[cr][cc - 1] = true;\n q[tail++] = cr * 10 + (cc - 1);\n }\n if (cc < 9 && !vis[cr][cc + 1] && grid[cr][cc + 1] == flavor) {\n vis[cr][cc + 1] = true;\n q[tail++] = cr * 10 + (cc + 1);\n }\n }\n score += sz * sz;\n }\n }\n }\n return score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto global_start = high_resolution_clock::now();\n\n uint8_t f[100];\n for (int i = 0; i < 100; ++i) {\n int temp;\n cin >> temp;\n f[i] = temp;\n }\n\n Board b;\n uint32_t rng_state = 42;\n auto rand_int = [&rng_state](uint32_t max_val) -> uint32_t {\n rng_state ^= rng_state << 13;\n rng_state ^= rng_state >> 17;\n rng_state ^= rng_state << 5;\n return rng_state % max_val;\n };\n\n char dir_chars[] = {'F', 'B', 'L', 'R'};\n\n for (int t = 1; t <= 100; ++t) {\n int p;\n cin >> p;\n b.add_candy(f[t - 1], p);\n\n if (t == 100) break;\n\n auto step_start = high_resolution_clock::now();\n double elapsed_total = duration_cast(step_start - global_start).count();\n double time_limit = (1950.0 - elapsed_total) / (101 - t);\n \n long long total_score[4] = {0};\n int playouts[4] = {0};\n bool valid[4] = {false};\n Board next_b[4];\n\n for (int d = 0; d < 4; ++d) {\n next_b[d] = b;\n valid[d] = next_b[d].tilt(d);\n }\n\n int loop_count = 0;\n while (true) {\n if ((++loop_count & 63) == 0) {\n auto now = high_resolution_clock::now();\n if (duration_cast(now - step_start).count() > time_limit) {\n break;\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n if (!valid[d]) continue;\n Board sim_b = next_b[d];\n for (int sim_t = t + 1; sim_t <= 100; ++sim_t) {\n int empty_cells = 100 - sim_t + 1;\n int sim_p = rand_int(empty_cells) + 1;\n sim_b.add_candy(f[sim_t - 1], sim_p);\n if (sim_t < 100) {\n sim_b.tilt(rand_int(4));\n }\n }\n total_score[d] += sim_b.calc_score();\n playouts[d]++;\n }\n }\n\n int best_dir = -1;\n double best_avg = -1.0;\n for (int d = 0; d < 4; ++d) {\n if (playouts[d] > 0) {\n double avg = (double)total_score[d] / playouts[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_dir = d;\n }\n }\n }\n\n if (best_dir == -1) {\n best_dir = rand_int(4);\n }\n\n b.tilt(best_dir);\n cout << dir_chars[best_dir] << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Function to compute the standard normal CDF\ndouble normal_cdf(double x) {\n return 0.5 * erfc(-x / sqrt(2.0));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n\n int best_N = 100;\n double best_expected_score = -1.0;\n\n // Search for the optimal N that maximizes expected score\n for (int n = 4; n <= 100; ++n) {\n int v = n * (n - 1) / 2;\n double expected_errors = 0.0;\n \n if (eps == 0.0) {\n if (v >= M - 1) {\n expected_errors = 0.0;\n } else {\n expected_errors = 100.0; // Complete failure if not enough states\n }\n } else {\n double gap = (double)v * (1.0 - 2.0 * eps) / max(1, M - 1);\n double stddev = sqrt(v * eps * (1.0 - eps));\n \n // Expected error rate for an inner distribution (has neighbors on both sides)\n // Error happens if noise moves it more than gap/2 away\n double p_error = 2.0 * (1.0 - normal_cdf((gap / 2.0) / stddev));\n \n // Adjust for boundary elements which only have 1 neighbor\n double boundary_p_error = 1.0 - normal_cdf((gap / 2.0) / stddev);\n \n double total_p_error = (2.0 * boundary_p_error + max(0, M - 2) * p_error) / M;\n expected_errors = 100.0 * total_p_error;\n }\n\n double expected_score = pow(0.9, expected_errors) / n;\n \n if (expected_score > best_expected_score) {\n best_expected_score = expected_score;\n best_N = n;\n }\n }\n\n int N = best_N;\n int V = N * (N - 1) / 2;\n \n // Choose edge counts for each of the M graphs evenly spaced from 0 to V\n vector target_edges(M);\n for (int i = 0; i < M; ++i) {\n if (M == 1) {\n target_edges[i] = V / 2;\n } else {\n target_edges[i] = round((double)i * V / (M - 1));\n }\n }\n\n // Output N and the graphs\n cout << N << \"\\n\";\n for (int i = 0; i < M; ++i) {\n string g = \"\";\n for (int j = 0; j < target_edges[i]; ++j) {\n g += \"1\";\n }\n for (int j = target_edges[i]; j < V; ++j) {\n g += \"0\";\n }\n cout << g << \"\\n\";\n }\n cout << flush;\n\n // Process the 100 queries\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n int edges = 0;\n for (char c : H) {\n if (c == '1') edges++;\n }\n \n int best_guess = 0;\n double best_diff = 1e9;\n \n for (int i = 0; i < M; ++i) {\n double expected_edges = target_edges[i] * (1.0 - eps) + (V - target_edges[i]) * eps;\n double diff = abs(edges - expected_edges);\n if (diff < best_diff) {\n best_diff = diff;\n best_guess = i;\n }\n }\n \n cout << best_guess << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Edge {\n int id;\n int u, v;\n long long w;\n double x, y;\n};\n\nstruct GraphEdge {\n int to;\n long long w;\n int id;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n\n vector edges(M);\n vector> adj(N);\n vector> coords(N);\n\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; \n edges[i].v--;\n edges[i].id = i;\n adj[edges[i].u].push_back({edges[i].v, edges[i].w, i});\n adj[edges[i].v].push_back({edges[i].u, edges[i].w, i});\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n for (int i = 0; i < M; ++i) {\n edges[i].x = (coords[edges[i].u].first + coords[edges[i].v].first) / 2.0;\n edges[i].y = (coords[edges[i].u].second + coords[edges[i].v].second) / 2.0;\n }\n\n mt19937 rng(42);\n // Use a fixed set of sources for consistent delta evaluation\n int num_eval_sources = min(N, 20);\n vector eval_sources(N);\n iota(eval_sources.begin(), eval_sources.end(), 0);\n shuffle(eval_sources.begin(), eval_sources.end(), rng);\n eval_sources.resize(num_eval_sources);\n\n auto compute_day_score = [&](const vector& ans, int day) -> long long {\n long long score = 0;\n for (int src : eval_sources) {\n vector dist(N, 1e15); // Large initial distance\n priority_queue, vector>, greater>> pq;\n \n dist[src] = 0;\n pq.push({0, src});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (const auto& edge : adj[u]) {\n if (ans[edge.id] == day) continue;\n if (dist[edge.to] > d + edge.w) {\n dist[edge.to] = d + edge.w;\n pq.push({dist[edge.to], edge.to});\n }\n }\n }\n \n for (int i = 0; i < N; ++i) {\n if (dist[i] > 1e14) {\n score += 1000000000LL; // Soft penalty for unreached nodes\n } else {\n score += dist[i];\n }\n }\n }\n return score;\n };\n\n vector best_ans(M, 1);\n long long best_total_score = -1;\n\n // Initialization: test random projection angles to spread out edges geographically\n for (int iter = 0; iter < 20; ++iter) {\n double angle = uniform_real_distribution(0, 2 * M_PI)(rng);\n double cos_a = cos(angle);\n double sin_a = sin(angle);\n\n vector> proj(M);\n for (int i = 0; i < M; ++i) {\n proj[i] = {edges[i].x * cos_a + edges[i].y * sin_a, i};\n }\n\n sort(proj.begin(), proj.end());\n\n vector current_ans(M);\n for (int i = 0; i < M; ++i) {\n current_ans[proj[i].second] = (i % D) + 1;\n }\n\n long long current_score = 0;\n for (int d = 1; d <= D; ++d) {\n current_score += compute_day_score(current_ans, d);\n }\n\n if (best_total_score == -1 || current_score < best_total_score) {\n best_total_score = current_score;\n best_ans = current_ans;\n }\n }\n\n // Prepare for Simulated Annealing\n vector current_ans = best_ans;\n vector day_scores(D + 1, 0);\n long long current_total_score = 0;\n \n for (int d = 1; d <= D; ++d) {\n day_scores[d] = compute_day_score(current_ans, d);\n current_total_score += day_scores[d];\n }\n \n uniform_int_distribution edge_dist(0, M - 1);\n \n double t0 = 2e6;\n double t1 = 1e2;\n double max_time = 5.8;\n\n while (true) {\n auto now = high_resolution_clock::now();\n double elapsed = duration_cast(now - start_time).count() / 1000.0;\n if (elapsed > max_time) break;\n\n double temp = t0 * pow(t1 / t0, elapsed / max_time);\n\n int e1 = edge_dist(rng);\n int e2 = edge_dist(rng);\n \n int d1 = current_ans[e1];\n int d2 = current_ans[e2];\n if (d1 == d2) continue;\n\n long long old_sub_score = day_scores[d1] + day_scores[d2];\n\n // Swap\n current_ans[e1] = d2;\n current_ans[e2] = d1;\n \n long long new_d1_score = compute_day_score(current_ans, d1);\n long long new_d2_score = compute_day_score(current_ans, d2);\n long long new_sub_score = new_d1_score + new_d2_score;\n \n long long delta = new_sub_score - old_sub_score;\n \n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_total_score += delta;\n day_scores[d1] = new_d1_score;\n day_scores[d2] = new_d2_score;\n \n if (current_total_score < best_total_score) {\n best_total_score = current_total_score;\n best_ans = current_ans;\n }\n } else {\n // Revert swap\n current_ans[e1] = d1;\n current_ans[e2] = d2;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n cout << best_ans[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint D;\n\nstruct Point {\n int x, y, z;\n bool operator==(const Point& o) const { return x == o.x && y == o.y && z == o.z; }\n Point operator+(const Point& o) const { return {x + o.x, y + o.y, z + o.z}; }\n Point operator-(const Point& o) const { return {x - o.x, y - o.y, z - o.z}; }\n};\n\nvector get_neighbors(Point p) {\n return {\n {p.x + 1, p.y, p.z}, {p.x - 1, p.y, p.z},\n {p.x, p.y + 1, p.z}, {p.x, p.y - 1, p.z},\n {p.x, p.y, p.z + 1}, {p.x, p.y, p.z - 1}\n };\n}\n\nPoint rotate(Point p, int rot) {\n int x = p.x, y = p.y, z = p.z;\n int nx, ny, nz;\n int face = rot / 4;\n if (face == 0) { nx = x; ny = y; nz = z; }\n else if (face == 1) { nx = x; ny = -z; nz = y; }\n else if (face == 2) { nx = x; ny = -y; nz = -z; }\n else if (face == 3) { nx = x; ny = z; nz = -y; }\n else if (face == 4) { nx = y; ny = -x; nz = z; }\n else if (face == 5) { nx = -y; ny = x; nz = z; }\n \n int roll = rot % 4;\n for (int i = 0; i < roll; ++i) {\n int tx = nx;\n nx = -nz;\n nz = tx;\n }\n return {nx, ny, nz};\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> D)) return 0;\n\n auto read_grid = [&]() {\n vector grid(D);\n for (int i = 0; i < D; ++i) cin >> grid[i];\n return grid;\n };\n\n vector f1 = read_grid();\n vector r1 = read_grid();\n vector f2 = read_grid();\n vector r2 = read_grid();\n\n vector init_c1, init_c2;\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (f1[z][x] == '1' && r1[z][y] == '1') init_c1.push_back({x, y, z});\n if (f2[z][x] == '1' && r2[z][y] == '1') init_c2.push_back({x, y, z});\n }\n }\n }\n\n mt19937 rng(1337);\n double best_score = 1e18;\n \n vector>> best_b1;\n vector>> best_b2;\n int best_n = 0;\n\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 5.8) break;\n\n vector c1 = init_c1;\n vector c2 = init_c2;\n\n vector>> b1(D, vector>(D, vector(D, 0)));\n vector>> b2(D, vector>(D, vector(D, 0)));\n\n int block_id = 0;\n double current_score = 0;\n\n while (!c1.empty() && !c2.empty()) {\n shuffle(c1.begin(), c1.end(), rng);\n shuffle(c2.begin(), c2.end(), rng);\n\n Point start1 = c1.back();\n Point start2 = c2.back();\n int rot = uniform_int_distribution(0, 23)(rng);\n\n vector b1_pts = {start1};\n vector b2_pts = {start2};\n \n c1.pop_back();\n c2.pop_back();\n\n b1[start1.x][start1.y][start1.z] = -1;\n b2[start2.x][start2.y][start2.z] = -1;\n\n bool grown = true;\n while (grown) {\n grown = false;\n for (Point p1 : b1_pts) {\n vector n1s = get_neighbors(p1);\n shuffle(n1s.begin(), n1s.end(), rng);\n for (Point n1 : n1s) {\n if (n1.x < 0 || n1.x >= D || n1.y < 0 || n1.y >= D || n1.z < 0 || n1.z >= D) continue;\n \n auto it1 = find(c1.begin(), c1.end(), n1);\n if (it1 != c1.end()) {\n Point offset1 = n1 - start1;\n Point offset2 = rotate(offset1, rot);\n Point n2 = start2 + offset2;\n \n if (n2.x >= 0 && n2.x < D && n2.y >= 0 && n2.y < D && n2.z >= 0 && n2.z < D) {\n auto it2 = find(c2.begin(), c2.end(), n2);\n if (it2 != c2.end()) {\n b1_pts.push_back(n1);\n b2_pts.push_back(n2);\n b1[n1.x][n1.y][n1.z] = -1;\n b2[n2.x][n2.y][n2.z] = -1;\n c1.erase(it1);\n c2.erase(it2);\n grown = true;\n break;\n }\n }\n }\n }\n if (grown) break;\n }\n }\n\n block_id++;\n for (Point p : b1_pts) b1[p.x][p.y][p.z] = block_id;\n for (Point p : b2_pts) b2[p.x][p.y][p.z] = block_id;\n current_score += 1.0 / b1_pts.size();\n }\n\n // Penalty for leftover isolated blocks\n current_score += c1.size() + c2.size();\n\n for (Point p : c1) {\n block_id++;\n b1[p.x][p.y][p.z] = block_id;\n }\n for (Point p : c2) {\n block_id++;\n b2[p.x][p.y][p.z] = block_id;\n }\n\n if (current_score < best_score) {\n best_score = current_score;\n best_b1 = move(b1);\n best_b2 = move(b2);\n best_n = block_id;\n }\n }\n\n cout << best_n << \"\\n\";\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n cout << best_b1[x][y][z] << (x == D - 1 && y == D - 1 && z == D - 1 ? \"\" : \" \");\n }\n }\n }\n cout << \"\\n\";\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n cout << best_b2[x][y][z] << (x == D - 1 && y == D - 1 && z == D - 1 ? \"\" : \" \");\n }\n }\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nlong long dist_sq(long long x1, long long y1, long long x2, long long y2) {\n return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n}\n\nstruct Edge {\n int id, u, v;\n long long w;\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = find(parent[i]);\n }\n void unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n }\n }\n};\n\nint N, M, K;\nvector> stations;\nvector edges;\nvector> residents;\nvector> dist_sr; \nvector> closest_stations;\n\n// MST precomputations\nvector parent_node;\nvector parent_weight;\nvector parent_edge_id;\nvector post_order;\n\nvoid build_mst() {\n DSU dsu(N);\n vector>> adj(N);\n vector> adj_w(N);\n \n for (const auto& e : edges) {\n if (dsu.find(e.u) != dsu.find(e.v)) {\n dsu.unite(e.u, e.v);\n adj[e.u].push_back({e.v, e.id});\n adj_w[e.u].push_back(e.w);\n adj[e.v].push_back({e.u, e.id});\n adj_w[e.v].push_back(e.w);\n }\n }\n\n parent_node.assign(N, -1);\n parent_weight.assign(N, 0);\n parent_edge_id.assign(N, -1);\n \n vector q;\n q.push_back(0);\n int head = 0;\n parent_node[0] = 0; // root\n\n while (head < (int)q.size()) {\n int u = q[head++];\n post_order.push_back(u);\n for (size_t i = 0; i < adj[u].size(); ++i) {\n int v = adj[u][i].first;\n int e_id = adj[u][i].second;\n long long w = adj_w[u][i];\n if (parent_node[v] == -1) {\n parent_node[v] = u;\n parent_weight[v] = w;\n parent_edge_id[v] = e_id;\n q.push_back(v);\n }\n }\n }\n reverse(post_order.begin(), post_order.end());\n // remove root (0) from post_order since it has no parent edge\n post_order.pop_back(); \n}\n\nlong long compute_cost(const vector& P, vector& edge_used) {\n long long cost = 0;\n for (int i = 0; i < N; ++i) cost += P[i] * P[i];\n\n vector active(N, 0);\n fill(edge_used.begin(), edge_used.end(), 0);\n\n for (int u : post_order) {\n if (P[u] > 0) active[u] = 1;\n if (active[u]) {\n active[parent_node[u]] = 1;\n cost += parent_weight[u];\n edge_used[parent_edge_id[u]] = 1;\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M >> K)) return 0;\n\n stations.resize(N);\n for (int i = 0; i < N; ++i) cin >> stations[i].first >> stations[i].second;\n\n edges.resize(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; edges[i].v--;\n }\n sort(edges.begin(), edges.end()); \n\n build_mst();\n\n residents.resize(K);\n for (int i = 0; i < K; ++i) cin >> residents[i].first >> residents[i].second;\n\n dist_sr.assign(N, vector(K));\n closest_stations.assign(K, vector());\n\n for (int i = 0; i < K; ++i) {\n vector> dists;\n for (int j = 0; j < N; ++j) {\n long long d = dist_sq(residents[i].first, residents[i].second, stations[j].first, stations[j].second);\n dist_sr[j][i] = d;\n dists.push_back({d, j});\n }\n sort(dists.begin(), dists.end());\n for (int j = 0; j < min(15, N); ++j) {\n closest_stations[i].push_back(dists[j].second);\n }\n }\n\n vector assignment(K);\n vector> station_residents(N);\n vector P(N, 0);\n\n for (int i = 0; i < K; ++i) {\n int best_station = closest_stations[i][0];\n assignment[i] = best_station;\n station_residents[best_station].push_back(i);\n }\n\n auto get_P = [&](int u) {\n if (station_residents[u].empty()) return 0LL;\n long long max_d = 0;\n for (int r : station_residents[u]) {\n if (dist_sr[u][r] > max_d) max_d = dist_sr[u][r];\n }\n long long req_p = ceil(sqrt(max_d));\n while (req_p * req_p < max_d) req_p++;\n return req_p;\n };\n\n for (int i = 0; i < N; ++i) P[i] = get_P(i);\n\n vector best_edge_used(M, 0);\n vector temp_edge_used(M, 0);\n long long current_cost = compute_cost(P, best_edge_used);\n long long best_cost = current_cost;\n vector best_P = P;\n\n mt19937 rng(42);\n uniform_int_distribution rand_res(0, K - 1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n uniform_int_distribution rand_any_station(0, N - 1);\n\n double T0 = 2e6;\n double T1 = 1e2;\n int iter = 0;\n\n while (true) {\n if ((iter & 4095) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break;\n }\n iter++;\n\n double progress = iter / 3000000.0; \n if (progress > 1.0) progress = 1.0;\n double T = T0 * pow(T1 / T0, progress);\n\n int r = rand_res(rng);\n int old_s = assignment[r];\n int new_s;\n \n if (rand_prob(rng) < 0.05) {\n new_s = rand_any_station(rng);\n } else {\n uniform_int_distribution rand_cand(0, closest_stations[r].size() - 1);\n new_s = closest_stations[r][rand_cand(rng)];\n }\n\n if (old_s == new_s) continue;\n\n auto it = find(station_residents[old_s].begin(), station_residents[old_s].end(), r);\n swap(*it, station_residents[old_s].back());\n station_residents[old_s].pop_back();\n \n station_residents[new_s].push_back(r);\n assignment[r] = new_s;\n\n long long old_P_old = P[old_s], old_P_new = P[new_s];\n P[old_s] = get_P(old_s);\n P[new_s] = get_P(new_s);\n\n long long new_cost = compute_cost(P, temp_edge_used);\n\n if (new_cost < current_cost || rand_prob(rng) < exp((current_cost - new_cost) / T)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_P = P;\n best_edge_used = temp_edge_used;\n }\n } else {\n station_residents[new_s].pop_back();\n station_residents[old_s].push_back(r);\n assignment[r] = old_s;\n P[old_s] = old_P_old;\n P[new_s] = old_P_new;\n }\n }\n\n compute_cost(best_P, best_edge_used);\n\n for (int i = 0; i < N; ++i) cout << best_P[i] << (i == N - 1 ? \"\" : \" \");\n cout << \"\\n\";\n for (int i = 0; i < M; ++i) cout << best_edge_used[i] << (i == M - 1 ? \"\" : \" \");\n cout << \"\\n\";\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Swap {\n int x1, y1, x2, y2;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::steady_clock::now();\n\n int N = 30;\n vector> orig_b(N, vector(N, 0));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> orig_b[i][j];\n }\n }\n\n // Precompute all parent cell coordinates\n vector> all_cells;\n all_cells.reserve(N * (N - 1) / 2);\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n all_cells.push_back({x, y});\n }\n }\n\n vector best_ops;\n int best_ops_size = 1e9;\n\n mt19937 rng(42);\n\n int iter = 0;\n while (true) {\n if ((iter & 63) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.85) break;\n }\n iter++;\n\n vector> b = orig_b;\n vector ops;\n ops.reserve(4000);\n\n bool changed = true;\n int p_greedy = 75 + (rng() % 25); \n\n // Choose between structured passes and completely shuffled passes\n int strategy = rng() % 3;\n\n while (changed) {\n changed = false;\n \n if (strategy == 2) {\n // Completely random order traversal\n shuffle(all_cells.begin(), all_cells.end(), rng);\n for (auto& cell : all_cells) {\n int x = cell.first;\n int y = cell.second;\n \n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (rng() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (rng() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n } else {\n // Alternating structured top-down / bottom-up\n int pass_type = rng() % 4;\n if (pass_type < 2) { // Bottom-up\n for (int x = N - 2; x >= 0; --x) {\n bool ltr = (pass_type == 0);\n for (int i = 0; i <= x; ++i) {\n int y = ltr ? i : x - i;\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (rng() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (rng() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n } else { // Top-down\n for (int x = 0; x < N - 1; ++x) {\n bool ltr = (pass_type == 2);\n for (int i = 0; i <= x; ++i) {\n int y = ltr ? i : x - i;\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (rng() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (rng() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n }\n }\n }\n \n if (ops.size() < best_ops_size) {\n best_ops_size = ops.size();\n best_ops = std::move(ops);\n }\n }\n\n if (best_ops.size() > 10000) {\n best_ops.resize(10000);\n }\n\n cout << best_ops.size() << \"\\n\";\n for (const auto& op : best_ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nint N;\nbool obstacle[D][D];\nint grid[D][D];\nint static_dist[D][D];\nint max_static_dist = 0;\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\n// Check if all remaining empty cells are reachable from the entrance (0, 4)\nbool check_connectivity(int empty_count) {\n if (empty_count == 0) return true;\n \n vector> visited(D, vector(D, false));\n queue> q;\n \n q.push({0, 4});\n visited[0][4] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n \n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable++;\n }\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n if (grid[nr][nc] == -1 || (nr == 0 && nc == 4)) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n \n return reachable == empty_count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int d_in;\n if (!(cin >> d_in >> N)) return 0;\n \n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n obstacle[i][j] = false;\n grid[i][j] = -1;\n static_dist[i][j] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n // Precompute static distances to establish the target values map\n queue> sq;\n sq.push({0, 4});\n static_dist[0][4] = 0;\n while (!sq.empty()) {\n auto [r, c] = sq.front();\n sq.pop();\n \n max_static_dist = max(max_static_dist, static_dist[r][c]);\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && static_dist[nr][nc] == -1) {\n static_dist[nr][nc] = static_dist[r][c] + 1;\n sq.push({nr, nc});\n }\n }\n }\n\n int total_containers = D * D - 1 - N;\n\n // Phase 1: Storage / Bringing in containers\n for (int d = 0; d < total_containers; ++d) {\n int t;\n cin >> t;\n\n queue> q;\n vector> dist(D, vector(D, -1));\n \n q.push({0, 4});\n dist[0][4] = 0;\n\n vector> reachable_empty;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable_empty.push_back({r, c});\n }\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && dist[nr][nc] == -1) {\n if (grid[r][c] == -1 || (r == 0 && c == 4)) {\n dist[nr][nc] = dist[r][c] + 1;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int best_r = -1, best_c = -1;\n double min_cost = 1e18;\n int remaining_empty = total_containers - d - 1;\n\n for (auto [r, c] : reachable_empty) {\n grid[r][c] = t; // Try placement\n \n if (check_connectivity(remaining_empty)) {\n // Determine ideal t for this cell based on its static depth\n double expected_t = ((double)static_dist[r][c] / max_static_dist) * total_containers;\n \n // Primary goal: match the container t with the cell's expected t\n double cost = abs(t - expected_t);\n \n // Secondary goal: use the dynamically further cells as a tie breaker \n // to maintain better structural progression from the back to the front\n cost -= dist[r][c] * 0.05;\n \n if (cost < min_cost) {\n min_cost = cost;\n best_r = r;\n best_c = c;\n }\n }\n \n grid[r][c] = -1; // Revert\n }\n\n // Fallback constraint logic (picks furthest if somehow blocked, mostly theoretical fail-safe)\n if (best_r == -1) {\n int max_d = -1;\n for (auto [r, c] : reachable_empty) {\n if (dist[r][c] > max_d) {\n max_d = dist[r][c];\n best_r = r;\n best_c = c;\n }\n }\n }\n\n grid[best_r][best_c] = t;\n cout << best_r << \" \" << best_c << \"\\n\";\n cout << flush;\n }\n\n // Phase 2: Transportation out\n for (int d = 0; d < total_containers; ++d) {\n queue> q;\n vector> visited(D, vector(D, false));\n \n q.push({0, 4});\n visited[0][4] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] != -1 && (r != 0 || c != 4)) {\n reachable_containers.push_back({r, c});\n } else {\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int best_r = -1, best_c = -1;\n int min_val = 1e9;\n \n for (auto [r, c] : reachable_containers) {\n if (grid[r][c] < min_val) {\n min_val = grid[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n grid[best_r][best_c] = -1;\n cout << best_r << \" \" << best_c << \"\\n\";\n }\n \n cout << flush;\n\n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nint M;\nint grid[N][N];\nint adj_count[105][105];\nbool target_adj[105][105];\nint color_count[105];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\n\nint visited[N][N];\nint visit_id = 0;\n\ninline bool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\ninline int get_color(int r, int c) {\n if (is_valid(r, c)) return grid[r][c];\n return 0; // Outside the grid is strictly color 0\n}\n\nbool check_connectivity(int r, int c, int color) {\n if (color_count[color] <= 1) return true; // Final cell removal is handled safely by adjacency checks\n \n int start_r = -1, start_c = -1;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if ((i != r || j != c) && grid[i][j] == color) {\n start_r = i; start_c = j;\n break;\n }\n }\n if (start_r != -1) break;\n }\n \n if (start_r == -1) return true;\n \n visit_id++;\n queue> q;\n q.push({start_r, start_c});\n visited[start_r][start_c] = visit_id;\n int count = 1;\n \n while (!q.empty()) {\n auto [curr_r, curr_c] = q.front();\n q.pop();\n \n for (int i = 0; i < 4; ++i) {\n int nr = curr_r + dx[i];\n int nc = curr_c + dy[i];\n \n if (is_valid(nr, nc)) {\n if ((nr != r || nc != c) && grid[nr][nc] == color && visited[nr][nc] != visit_id) {\n visited[nr][nc] = visit_id;\n count++;\n q.push({nr, nc});\n }\n }\n }\n }\n \n return count == color_count[color] - 1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> M >> M)) return 0; // The first parameter N is fixed as 50\n int n = 50;\n M = 100;\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n color_count[grid[i][j]]++;\n }\n }\n \n // Accurately initialize the global undirected adjacency counters\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int c1 = grid[i][j];\n \n int right_c = get_color(i, j + 1);\n if (c1 != right_c) {\n adj_count[c1][right_c]++;\n adj_count[right_c][c1]++;\n target_adj[c1][right_c] = target_adj[right_c][c1] = true;\n }\n \n int down_c = get_color(i + 1, j);\n if (c1 != down_c) {\n adj_count[c1][down_c]++;\n adj_count[down_c][c1]++;\n target_adj[c1][down_c] = target_adj[down_c][c1] = true;\n }\n \n // Explicitly track the top boundary\n if (i == 0) {\n if (c1 != 0) {\n adj_count[c1][0]++;\n adj_count[0][c1]++;\n target_adj[c1][0] = target_adj[0][c1] = true;\n }\n }\n // Explicitly track the left boundary\n if (j == 0) {\n if (c1 != 0) {\n adj_count[c1][0]++;\n adj_count[0][c1]++;\n target_adj[c1][0] = target_adj[0][c1] = true;\n }\n }\n }\n }\n \n mt19937 rng(1337);\n int iter = 0;\n \n while (true) {\n if ((iter++ & 127) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break; // Terminate exactly before standard 2.0s limit\n }\n \n int r = rng() % n;\n int c = rng() % n;\n \n int old_color = grid[r][c];\n \n // Only select new colors from immediate neighbors guaranteeing valid connected components\n vector possible_colors;\n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n if (nc != old_color) {\n possible_colors.push_back(nc);\n }\n }\n \n if (possible_colors.empty()) continue;\n int new_color = possible_colors[rng() % possible_colors.size()];\n \n int local_adj_loss[105] = {0};\n int local_adj_gain[105] = {0};\n \n for (int k = 0; k < 4; ++k) {\n int neighbor_color = get_color(r + dx[k], c + dy[k]);\n if (neighbor_color != old_color) {\n local_adj_loss[neighbor_color]++;\n }\n if (neighbor_color != new_color) {\n local_adj_gain[neighbor_color]++;\n }\n }\n \n bool possible = true;\n for (int i = 0; i <= M; ++i) {\n if (local_adj_loss[i] > 0) {\n // Changing this cell destroys the very last adjacency segment\n if (adj_count[old_color][i] - local_adj_loss[i] == 0) {\n possible = false;\n break;\n }\n }\n if (local_adj_gain[i] > 0) {\n // Changing this cell introduces an illegally unauthorized adjacency\n if (!target_adj[new_color][i]) {\n possible = false;\n break;\n }\n }\n }\n \n if (!possible) continue;\n \n // Execute fast connection validation\n if (!check_connectivity(r, c, old_color)) continue;\n \n // Update global adjacencies tracking\n for (int i = 0; i <= M; ++i) {\n if (local_adj_loss[i] > 0) {\n adj_count[old_color][i] -= local_adj_loss[i];\n adj_count[i][old_color] -= local_adj_loss[i];\n }\n if (local_adj_gain[i] > 0) {\n adj_count[new_color][i] += local_adj_gain[i];\n adj_count[i][new_color] += local_adj_gain[i];\n }\n }\n \n grid[r][c] = new_color;\n color_count[old_color]--;\n color_count[new_color]++;\n }\n \n // Export resulting grid map\n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cout << grid[i][j] << (j == n - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, D, Q;\nint queries_used = 0;\n\n// Query the balance safely\nchar query(const vector& L, const vector& R) {\n if (queries_used >= Q) return '=';\n if (L.empty() || R.empty()) {\n if (L.empty() && R.empty()) return '=';\n return L.empty() ? '<' : '>';\n }\n \n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\";\n cout.flush();\n \n char res;\n cin >> res;\n queries_used++;\n return res;\n}\n\nchar compare_items(int u, int v) {\n return query({u}, {v});\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> D >> Q)) return 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n\n // Sort items using stable_sort and our custom comparator\n // std::stable_sort will use around N log N comparisons.\n stable_sort(items.begin(), items.end(), [](int a, int b) {\n if (queries_used >= Q) return a < b; // Fallback if out of queries\n char res = compare_items(a, b);\n return res == '<';\n });\n\n // Estimate weights based on expected order statistics for exponential distribution\n vector est_weight(N);\n vector order_expected(N, 0.0);\n double current_sum = 0.0;\n for (int i = 0; i < N; ++i) {\n current_sum += 1.0 / (N - i);\n order_expected[i] = current_sum;\n }\n\n // Map sorted estimates back to items\n for (int i = 0; i < N; ++i) {\n est_weight[items[i]] = order_expected[i];\n }\n\n // Initialize groups\n vector> groups(D);\n vector group_weights(D, 0.0);\n vector ans(N);\n\n // Greedy assignment: LPT (Longest Processing Time first)\n // Traverse from heaviest to lightest\n for (int i = N - 1; i >= 0; --i) {\n int item = items[i];\n int best_group = 0;\n for (int d = 1; d < D; ++d) {\n if (group_weights[d] < group_weights[best_group]) {\n best_group = d;\n }\n }\n groups[best_group].push_back(item);\n group_weights[best_group] += est_weight[item];\n ans[item] = best_group;\n }\n\n mt19937 rng(1337);\n\n // Refinement phase using remaining queries\n while (queries_used < Q) {\n int g1 = rng() % D;\n int g2 = rng() % D;\n while (g1 == g2) g2 = rng() % D;\n\n if (groups[g1].empty() || groups[g2].empty()) {\n query({0}, {0}); // dummy\n continue;\n }\n\n char res = query(groups[g1], groups[g2]);\n if (queries_used > Q) break;\n\n int heavy = (res == '>') ? g1 : ((res == '<') ? g2 : -1);\n int light = (res == '>') ? g2 : ((res == '<') ? g1 : -1);\n\n if (heavy != -1 && light != -1) {\n // Find a pair of items to swap to balance the groups based on estimates\n double diff = group_weights[heavy] - group_weights[light];\n double target_swap_diff = diff / 2.0;\n\n int best_u = -1, best_v = -1, best_u_idx = -1, best_v_idx = -1;\n double best_gap = 1e9;\n\n for (size_t i = 0; i < groups[heavy].size(); ++i) {\n for (size_t j = 0; j < groups[light].size(); ++j) {\n int u = groups[heavy][i];\n int v = groups[light][j];\n double swap_diff = est_weight[u] - est_weight[v];\n \n if (swap_diff > 0) {\n double gap = abs(swap_diff - target_swap_diff);\n if (gap < best_gap) {\n best_gap = gap;\n best_u = u;\n best_v = v;\n best_u_idx = i;\n best_v_idx = j;\n }\n }\n }\n }\n\n // Execute the best estimated swap\n if (best_u != -1 && best_v != -1) {\n swap(groups[heavy][best_u_idx], groups[light][best_v_idx]);\n ans[best_u] = light;\n ans[best_v] = heavy;\n \n group_weights[heavy] -= est_weight[best_u];\n group_weights[heavy] += est_weight[best_v];\n \n group_weights[light] -= est_weight[best_v];\n group_weights[light] += est_weight[best_u];\n }\n }\n }\n\n // Exhaust remaining unused queries if any\n while (queries_used < Q) {\n query({0}, {0});\n }\n\n // Output final assignments\n for (int i = 0; i < N; ++i) {\n cout << ans[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n cout.flush();\n\n return 0;\n}","ahc026":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int INF = 1e9;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = steady_clock::now();\n\n int n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> initial_stacks(m);\n for (int i = 0; i < m; ++i) {\n int count = n / m;\n initial_stacks[i].resize(count);\n for (int j = 0; j < count; ++j) {\n cin >> initial_stacks[i][j];\n }\n }\n\n int best_energy = INF;\n vector> best_ops;\n\n mt19937 rng(42);\n\n int iter = 0;\n while (true) {\n if ((iter & 63) == 0) {\n auto current_time = steady_clock::now();\n double elapsed = duration_cast>(current_time - start_time).count();\n if (elapsed > 1.8) break;\n }\n iter++;\n\n vector> stacks = initial_stacks;\n vector> ops;\n int energy = 0;\n bool possible = true;\n\n for (int v = 1; v <= n; ++v) {\n int s = -1;\n int v_idx = -1;\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < (int)stacks[i].size(); ++j) {\n if (stacks[i][j] == v) {\n s = i;\n v_idx = j;\n break;\n }\n }\n if (s != -1) break;\n }\n\n while ((int)stacks[s].size() > v_idx + 1) {\n // Decide a chunk size to move\n int max_chunk = stacks[s].size() - (v_idx + 1);\n int chunk_size = 1;\n \n // Randomly try to move more than 1 box to save energy\n if (max_chunk > 1 && rng() % 100 < 40) {\n chunk_size = 1 + rng() % max_chunk;\n }\n\n int chunk_bottom_idx = stacks[s].size() - chunk_size;\n int u = stacks[s][chunk_bottom_idx]; // The bottom box of the chunk\n\n vector valids;\n int best_j = -1;\n int min_diff = INF;\n int max_top = -1;\n int fallback_j = -1;\n\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n \n int top_val = stacks[i].empty() ? INF : stacks[i].back();\n \n if (top_val > u) {\n valids.push_back(i);\n if (top_val - u < min_diff) {\n min_diff = top_val - u;\n best_j = i;\n }\n }\n \n if (top_val > max_top) {\n max_top = top_val;\n fallback_j = i;\n }\n }\n\n int target_stack = -1;\n if (!valids.empty()) {\n int r = rng() % 100;\n if (r < 80 || valids.size() == 1) {\n target_stack = best_j;\n } else {\n target_stack = valids[rng() % valids.size()];\n }\n } else {\n target_stack = fallback_j;\n }\n\n // Move the chunk\n for (int j = chunk_bottom_idx; j < (int)stacks[s].size(); ++j) {\n stacks[target_stack].push_back(stacks[s][j]);\n }\n stacks[s].resize(chunk_bottom_idx);\n \n ops.push_back({u, target_stack + 1});\n energy += (chunk_size + 1);\n }\n\n stacks[s].pop_back();\n ops.push_back({v, 0});\n \n if (ops.size() > 5000) {\n possible = false;\n break;\n }\n }\n\n if (possible && energy < best_energy) {\n best_energy = energy;\n best_ops = ops;\n }\n }\n\n for (auto& op : best_ops) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h;\nvector v;\nvector> d;\nvector DIJ_R = {0, 1, 0, -1};\nvector DIJ_C = {1, 0, -1, 0};\nstring DIR = \"RDLU\";\n\ndouble evaluate(const string& path) {\n int L = path.length();\n int r = 0, c = 0;\n vector last_visit(N * N, -1);\n vector sum_w2(N * N, 0);\n vector first_visit(N * N, -1);\n\n for (int t = 0; t < L; ++t) {\n int idx = r * N + c;\n if (last_visit[idx] == -1) {\n first_visit[idx] = t;\n } else {\n long long w = t - last_visit[idx];\n sum_w2[idx] += w * (w - 1) / 2;\n }\n last_visit[idx] = t;\n\n char move = path[t];\n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n double total_avg = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (last_visit[idx] != -1) {\n long long w = L - last_visit[idx] + first_visit[idx];\n sum_w2[idx] += w * (w - 1) / 2;\n total_avg += (double)d[i][j] * sum_w2[idx] / L;\n } else {\n return 1e18; // Unvisited cell\n }\n }\n }\n return total_avg;\n}\n\nvoid dfs(int r, int c, vector>& visited, string& current_path, mt19937& rng) {\n visited[r][c] = true;\n \n vector> valid_dirs;\n for (int dir = 0; dir < 4; ++dir) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = r + dr;\n int c2 = c + dc;\n \n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N && !visited[r2][c2]) {\n bool can_move = false;\n if (dr == 0) {\n if (v[r][min(c, c2)] == '0') can_move = true;\n } else {\n if (h[min(r, r2)][c] == '0') can_move = true;\n }\n \n if (can_move) {\n // Weight is a combination of cell dirtiness and some random noise\n int weight = d[r2][c2] * 10 + (rng() % 10000);\n valid_dirs.push_back({weight, dir});\n }\n }\n }\n \n // Sort directions by descending weight\n sort(valid_dirs.rbegin(), valid_dirs.rend());\n \n for (auto& p : valid_dirs) {\n int dir = p.second;\n int r2 = r + DIJ_R[dir];\n int c2 = c + DIJ_C[dir];\n if (!visited[r2][c2]) {\n current_path += DIR[dir];\n dfs(r2, c2, visited, current_path, rng);\n current_path += DIR[(dir + 2) % 4];\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N)) return 0;\n\n h.resize(N - 1);\n for (int i = 0; i < N - 1; ++i) {\n cin >> h[i];\n }\n\n v.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> v[i];\n }\n\n d.assign(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 mt19937 rng(1337);\n string best_path = \"\";\n double best_score = 1e18;\n\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.85) break;\n\n vector> visited(N, vector(N, false));\n string current_path = \"\";\n dfs(0, 0, visited, current_path, rng);\n \n double score = evaluate(current_path);\n if (score < best_score) {\n best_score = score;\n best_path = current_path;\n }\n }\n\n cout << best_path << \"\\n\";\n\n return 0;\n}","ahc028":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\nint N, M;\nint start_i, start_j;\nvector grid;\nvector words;\nvector> pos[26];\nint min_dist[26][26];\n\nint manhattan(pair a, pair b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint get_overlap(const string& S, const string& word) {\n if (S.empty()) return 0;\n int max_k = min(5, (int)S.length());\n for (int k = max_k; k >= 1; --k) {\n if (S.substr(S.length() - k) == word.substr(0, k)) {\n return k;\n }\n }\n return 0;\n}\n\nint approx_cost(char last_char, const string& add) {\n int cost = 0;\n char c = last_char;\n for (char nxt : add) {\n cost += min_dist[c - 'A'][nxt - 'A'] + 1;\n c = nxt;\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M)) return 0;\n cin >> start_i >> start_j;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n for (int j = 0; j < N; ++j) {\n pos[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n words.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> words[i];\n }\n\n for (int i = 0; i < 26; ++i) {\n for (int j = 0; j < 26; ++j) {\n min_dist[i][j] = INF;\n if (pos[i].empty() || pos[j].empty()) continue;\n for (auto p1 : pos[i]) {\n for (auto p2 : pos[j]) {\n min_dist[i][j] = min(min_dist[i][j], manhattan(p1, p2));\n }\n }\n }\n }\n\n int best_total_cost = INF;\n vector> best_path;\n\n srand(1337);\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.85) break;\n\n vector remaining(M);\n for (int i = 0; i < M; ++i) remaining[i] = i;\n\n string S = \"\";\n \n while (!remaining.empty()) {\n vector> cands;\n for (int i = 0; i < remaining.size(); ++i) {\n int w_idx = remaining[i];\n if (!S.empty() && S.find(words[w_idx]) != string::npos) {\n cands.push_back({-10000, i});\n continue;\n }\n int k = get_overlap(S, words[w_idx]);\n string add = words[w_idx].substr(k);\n int cost = S.empty() ? 0 : approx_cost(S.back(), add);\n cands.push_back({cost - k * 12, i});\n }\n sort(cands.begin(), cands.end());\n \n int pick_idx = cands[rand() % min((int)cands.size(), 3)].second;\n int w_idx = remaining[pick_idx];\n \n if (S.empty() || S.find(words[w_idx]) == string::npos) {\n int k = get_overlap(S, words[w_idx]);\n S += words[w_idx].substr(k);\n }\n \n remaining.erase(remaining.begin() + pick_idx);\n }\n\n int len = S.length();\n if (len > 5000) continue;\n\n vector> dp(len, vector(225, INF));\n vector> parent(len, vector(225, -1));\n\n for (int k = 0; k < pos[S[0] - 'A'].size(); ++k) {\n auto p = pos[S[0] - 'A'][k];\n int idx = p.first * N + p.second;\n dp[0][idx] = manhattan({start_i, start_j}, p) + 1;\n }\n\n for (int i = 1; i < len; ++i) {\n char prev_c = S[i - 1];\n char curr_c = S[i];\n for (int p_k = 0; p_k < pos[prev_c - 'A'].size(); ++p_k) {\n auto p_prev = pos[prev_c - 'A'][p_k];\n int p_idx = p_prev.first * N + p_prev.second;\n if (dp[i - 1][p_idx] == INF) continue;\n\n for (int c_k = 0; c_k < pos[curr_c - 'A'].size(); ++c_k) {\n auto p_curr = pos[curr_c - 'A'][c_k];\n int c_idx = p_curr.first * N + p_curr.second;\n int cost = dp[i - 1][p_idx] + manhattan(p_prev, p_curr) + 1;\n if (cost < dp[i][c_idx]) {\n dp[i][c_idx] = cost;\n parent[i][c_idx] = p_idx;\n }\n }\n }\n }\n\n int min_cost = INF;\n int last_idx = -1;\n for (int k = 0; k < pos[S.back() - 'A'].size(); ++k) {\n auto p = pos[S.back() - 'A'][k];\n int idx = p.first * N + p.second;\n if (dp[len - 1][idx] < min_cost) {\n min_cost = dp[len - 1][idx];\n last_idx = idx;\n }\n }\n\n if (min_cost < best_total_cost) {\n best_total_cost = min_cost;\n best_path.clear();\n int curr_idx = last_idx;\n for (int i = len - 1; i >= 0; --i) {\n best_path.push_back({curr_idx / N, curr_idx % N});\n curr_idx = parent[i][curr_idx];\n }\n reverse(best_path.begin(), best_path.end());\n }\n }\n\n for (auto p : best_path) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#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};\n\nstruct Polyomino {\n int d;\n vector pts;\n int max_i, max_j;\n};\n\nint N, M;\ndouble eps;\nvector fields;\n\nint obs[25][25];\nstruct Pt { int r, c; };\nvector placements[25][405];\nint num_placements[25];\n\nint current_p[25];\nint pred[25][25];\n\nint query_single(int i, int j) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n int res;\n cin >> res;\n return res;\n}\n\nvoid answer(const vector& ans) {\n cout << \"a \" << ans.size();\n for (auto p : ans) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int res;\n cin >> res;\n if (res == 1) {\n exit(0);\n }\n}\n\nvoid init_placements() {\n for (int m = 0; m < M; ++m) {\n num_placements[m] = 0;\n for (int r = 0; r <= N - fields[m].max_i; ++r) {\n for (int c = 0; c <= N - fields[m].max_j; ++c) {\n for (auto& pt : fields[m].pts) {\n placements[m][num_placements[m]].push_back({r + pt.i, c + pt.j});\n }\n num_placements[m]++;\n }\n }\n }\n}\n\nmt19937 rng(42);\n\nbool run_SA() {\n for (int attempt = 0; attempt < 5; ++attempt) {\n memset(pred, 0, sizeof(pred));\n for (int m = 0; m < M; ++m) {\n current_p[m] = rng() % num_placements[m];\n for (auto& pt : placements[m][current_p[m]]) {\n pred[pt.r][pt.c]++;\n }\n }\n \n int E = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (obs[r][c] != -1) {\n E += abs(pred[r][c] - obs[r][c]);\n }\n }\n }\n if (E == 0) return true;\n \n double T = 10.0;\n for (int step = 0; step < 10000; ++step) {\n int m = rng() % M;\n int old_p = current_p[m];\n int new_p = rng() % num_placements[m];\n if (old_p == new_p) continue;\n \n int delta = 0;\n for (auto& pt : placements[m][old_p]) {\n if (obs[pt.r][pt.c] != -1) {\n delta -= abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n pred[pt.r][pt.c]--;\n delta += abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n } else {\n pred[pt.r][pt.c]--;\n }\n }\n for (auto& pt : placements[m][new_p]) {\n if (obs[pt.r][pt.c] != -1) {\n delta -= abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n pred[pt.r][pt.c]++;\n delta += abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n } else {\n pred[pt.r][pt.c]++;\n }\n }\n \n if (delta <= 0 || (exp(-delta / T) > (rng() % 10000) / 10000.0)) {\n E += delta;\n current_p[m] = new_p;\n if (E == 0) return true;\n } else {\n for (auto& pt : placements[m][new_p]) pred[pt.r][pt.c]--;\n for (auto& pt : placements[m][old_p]) pred[pt.r][pt.c]++;\n }\n T *= 0.999;\n }\n }\n return false;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> eps)) return 0;\n\n fields.resize(M);\n for (int k = 0; k < M; ++k) {\n cin >> fields[k].d;\n fields[k].pts.resize(fields[k].d);\n fields[k].max_i = 0;\n fields[k].max_j = 0;\n for (int p = 0; p < fields[k].d; ++p) {\n cin >> fields[k].pts[p].i >> fields[k].pts[p].j;\n fields[k].max_i = max(fields[k].max_i, fields[k].pts[p].i);\n fields[k].max_j = max(fields[k].max_j, fields[k].pts[p].j);\n }\n }\n\n init_placements();\n memset(obs, -1, sizeof(obs));\n\n vector unqueried;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n unqueried.push_back({r, c});\n }\n }\n shuffle(unqueried.begin(), unqueried.end(), rng);\n\n while (!unqueried.empty()) {\n bool sa_success = run_SA();\n bool queried_pred = false;\n\n if (sa_success) {\n // Find an unqueried cell that is predicted to have oil\n for (int r = 0; r < N && !queried_pred; ++r) {\n for (int c = 0; c < N && !queried_pred; ++c) {\n if (pred[r][c] > 0 && obs[r][c] == -1) {\n obs[r][c] = query_single(r, c);\n queried_pred = true;\n \n // Remove from unqueried list\n auto it = find_if(unqueried.begin(), unqueried.end(), [r, c](const Pt& pt) {\n return pt.r == r && pt.c == c;\n });\n if (it != unqueried.end()) {\n unqueried.erase(it);\n }\n }\n }\n }\n\n if (!queried_pred) {\n // All predicted positives are already queried and verified\n vector guess_set;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (pred[r][c] > 0) {\n guess_set.push_back({r, c});\n }\n }\n }\n answer(guess_set);\n }\n } \n \n if (!queried_pred && !unqueried.empty()) {\n // SA failed to find 0-energy state, or guessed and got rejected\n Pt next_q = unqueried.back();\n unqueried.pop_back();\n obs[next_q.r][next_q.c] = query_single(next_q.r, next_q.c);\n }\n }\n\n // Fallback: If all cells have been queried, formulate guess based on definitive observations\n vector final_ans;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (obs[r][c] > 0) {\n final_ans.push_back({r, c});\n }\n }\n }\n answer(final_ans);\n\n return 0;\n}","ahc031":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int W = 1000;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int w_input, d_days, n_res;\n if (!(cin >> w_input >> d_days >> n_res)) return 0;\n\n vector> a(d_days, vector(n_res));\n for (int d = 0; d < d_days; ++d) {\n for (int k = 0; k < n_res; ++k) {\n cin >> a[d][k];\n }\n }\n\n for (int d = 0; d < d_days; ++d) {\n vector w(n_res, 1);\n int remaining = W - n_res;\n\n // Greedily distribute the remaining width to minimize area penalties\n while (remaining > 0) {\n int best_k = -1;\n int max_benefit = -1;\n\n for (int k = 0; k < n_res; ++k) {\n int current_area = W * w[k];\n if (current_area < a[d][k]) {\n int benefit = min(W, a[d][k] - current_area);\n if (benefit > max_benefit) {\n max_benefit = benefit;\n best_k = k;\n }\n }\n }\n\n if (best_k != -1) {\n w[best_k]++;\n remaining--;\n } else {\n // If all requirements are met, distribute the rest arbitrarily\n w[n_res - 1] += remaining;\n break;\n }\n }\n\n // Output the vertical strips for the current day\n int current_x = 0;\n for (int k = 0; k < n_res; ++k) {\n int next_x = current_x + w[k];\n cout << 0 << \" \" << current_x << \" \" << W << \" \" << next_x << \"\\n\";\n current_x = next_x;\n }\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\nlong long A[9][9];\nlong long S[20][3][3];\nlong long V[9][9];\nOp ops[81];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n cin >> A[i][j];\n V[i][j] = A[i][j];\n }\n }\n\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 for (int i = 0; i < K; ++i) {\n ops[i] = {-1, -1, -1};\n }\n\n mt19937_64 rng(1337);\n uniform_int_distribution dist_idx(0, K - 1);\n uniform_int_distribution dist_m(-1, M - 1);\n uniform_int_distribution dist_p(0, N - 3);\n uniform_int_distribution dist_q(0, N - 3);\n uniform_real_distribution dist_prob(0.0, 1.0);\n\n double T0 = 2e9;\n double T1 = 1e6;\n double time_limit = 1.95;\n double T = T0;\n\n long long current_score = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n current_score += V[i][j] % MOD;\n }\n }\n\n long long best_score = current_score;\n Op best_ops[81];\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n\n int iter = 0;\n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n T = T0 * pow(T1 / T0, progress);\n }\n\n int idx = dist_idx(rng);\n Op old_op = ops[idx];\n Op new_op;\n new_op.m = dist_m(rng);\n if (new_op.m == -1) {\n new_op.p = -1;\n new_op.q = -1;\n } else {\n new_op.p = dist_p(rng);\n new_op.q = dist_q(rng);\n }\n\n long long delta = 0;\n \n if (old_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = old_op.p + i;\n int c = old_op.q + j;\n delta -= V[r][c] % MOD;\n V[r][c] -= S[old_op.m][i][j];\n delta += V[r][c] % MOD;\n }\n }\n }\n \n if (new_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n int r = new_op.p + i;\n int c = new_op.q + j;\n delta -= V[r][c] % MOD;\n V[r][c] += S[new_op.m][i][j];\n delta += V[r][c] % MOD;\n }\n }\n }\n\n if (delta >= 0 || dist_prob(rng) < exp(delta / T)) {\n current_score += delta;\n ops[idx] = new_op;\n if (current_score > best_score) {\n best_score = current_score;\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n }\n } else {\n // Rollback\n if (new_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n V[new_op.p + i][new_op.q + j] -= S[new_op.m][i][j];\n }\n }\n }\n if (old_op.m != -1) {\n for (int i = 0; i < 3; ++i) {\n for (int j = 0; j < 3; ++j) {\n V[old_op.p + i][old_op.q + j] += S[old_op.m][i][j];\n }\n }\n }\n }\n iter++;\n }\n\n vector final_ops;\n for (int i = 0; i < K; ++i) {\n if (best_ops[i].m != -1) {\n final_ops.push_back(best_ops[i]);\n }\n }\n\n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_ops) {\n cout << op.m << \" \" << op.p << \" \" << op.q << \"\\n\";\n }\n\n return 0;\n}","ahc033":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 5;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input;\n if (!(cin >> n_input)) return 0;\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 string ans0 = \".\";\n int cr = 0, cc = 0;\n \n int ptr[N] = {0};\n int grid[N][N];\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) grid[r][c] = -1;\n }\n \n bool is_delivered[25] = {false};\n int next_needed[N];\n for (int i = 0; i < N; ++i) next_needed[i] = i * N;\n\n auto move_crane = [&](int tr, int tc) {\n while (cr > tr) { ans0 += 'U'; cr--; }\n while (cr < tr) { ans0 += 'D'; cr++; }\n while (cc > tc) { ans0 += 'L'; cc--; }\n while (cc < tc) { ans0 += 'R'; cc++; }\n };\n\n int delivered = 0;\n while (delivered < 25) {\n // Update next_needed for all gates\n for (int i = 0; i < N; ++i) {\n while (next_needed[i] < i * N + N && is_delivered[next_needed[i]]) {\n next_needed[i]++;\n }\n }\n\n // Collect all currently accessible containers\n // They are at col 0 (if ptr < N) and in cols 1..3 (if grid != -1)\n struct Container {\n int val, r, c;\n };\n vector accessible;\n for (int r = 0; r < N; ++r) {\n if (ptr[r] < N) accessible.push_back({A[r][ptr[r]], r, 0});\n for (int c = 1; c < N - 1; ++c) {\n if (grid[r][c] != -1) accessible.push_back({grid[r][c], r, c});\n }\n }\n\n bool found_exact = false;\n Container best_c = {-1, -1, -1};\n\n // 1. Check if any accessible container is exactly next_needed\n for (auto& cont : accessible) {\n int gate = cont.val / N;\n if (cont.val == next_needed[gate]) {\n found_exact = true;\n best_c = cont;\n break;\n }\n }\n\n if (found_exact) {\n // Deliver it\n move_crane(best_c.r, best_c.c);\n ans0 += 'P';\n \n if (best_c.c == 0) ptr[best_c.r]++;\n else grid[best_c.r][best_c.c] = -1;\n\n int gate = best_c.val / N;\n move_crane(gate, N - 1);\n ans0 += 'Q';\n \n is_delivered[best_c.val] = true;\n delivered++;\n } else {\n // 2. Find empty temporary storage cell\n int temp_r = -1, temp_c = -1;\n for (int c = 1; c < N - 1; ++c) {\n for (int r = 0; r < N; ++r) {\n if (grid[r][c] == -1) {\n temp_r = r;\n temp_c = c;\n break;\n }\n }\n if (temp_r != -1) break;\n }\n\n if (temp_r != -1) {\n // We have temp space. Pick the best container from col 0 to move to temp.\n // \"Best\" is the one closest to its next_needed\n Container move_c = {-1, -1, -1};\n int min_diff = 1000;\n for (int r = 0; r < N; ++r) {\n if (ptr[r] < N) {\n int val = A[r][ptr[r]];\n int diff = val - next_needed[val / N];\n if (diff < min_diff) {\n min_diff = diff;\n move_c = {val, r, 0};\n }\n }\n }\n\n if (move_c.r != -1) {\n move_crane(move_c.r, move_c.c);\n ans0 += 'P';\n ptr[move_c.r]++;\n\n move_crane(temp_r, temp_c);\n ans0 += 'Q';\n grid[temp_r][temp_c] = move_c.val;\n }\n } else {\n // Temp storage is completely full. We must force-deliver an out-of-order container.\n // Pick the one with the smallest difference from its next_needed.\n Container force_c = {-1, -1, -1};\n int min_diff = 1000;\n for (auto& cont : accessible) {\n int diff = cont.val - next_needed[cont.val / N];\n if (diff < min_diff) {\n min_diff = diff;\n force_c = cont;\n }\n }\n\n move_crane(force_c.r, force_c.c);\n ans0 += 'P';\n \n if (force_c.c == 0) ptr[force_c.r]++;\n else grid[force_c.r][force_c.c] = -1;\n\n int gate = force_c.val / N;\n move_crane(gate, N - 1);\n ans0 += 'Q';\n \n is_delivered[force_c.val] = true;\n delivered++;\n }\n }\n }\n \n cout << ans0 << \"\\n\";\n // Detonate small cranes safely on turn 1\n for (int i = 1; i < N; ++i) {\n cout << \"B\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 int x = 0, y = 0;\n long long load = 0;\n\n while (true) {\n // Process current cell first\n if (load == 0 && h[x][y] > 0) {\n int amt = h[x][y];\n cout << \"+\" << amt << \"\\n\";\n load += amt;\n h[x][y] -= amt;\n continue;\n }\n if (load > 0 && h[x][y] < 0) {\n long long amt = min(load, (long long)-h[x][y]);\n cout << \"-\" << amt << \"\\n\";\n load -= amt;\n h[x][y] += amt;\n continue;\n }\n\n // Check if we are done\n bool done = true;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (h[i][j] != 0) {\n done = false;\n break;\n }\n }\n if (!done) break;\n }\n if (done) break;\n\n // Find the nearest target\n int best_dist = 1e9;\n pair target = {-1, -1};\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (load == 0 && h[i][j] > 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n } else if (load > 0 && h[i][j] < 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n }\n }\n }\n\n // If for some reason we cannot find a target, terminate safely.\n if (target.first == -1) break;\n\n // Move 1 step towards target\n if (x < target.first) {\n x++;\n cout << \"D\\n\";\n } else if (x > target.first) {\n x--;\n cout << \"U\\n\";\n } else if (y < target.second) {\n y++;\n cout << \"R\\n\";\n } else if (y > target.second) {\n y--;\n cout << \"L\\n\";\n }\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Seed {\n int id;\n vector x;\n int sum;\n};\n\nint N, M, T;\nint seed_count;\nvector seeds;\n\n// Calculate the score of a pair of seeds\ninline int pair_score(const Seed& a, const Seed& b) {\n int score = 0;\n for (int l = 0; l < M; ++l) {\n score += max(a.x[l], b.x[l]);\n }\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> T)) return 0;\n seed_count = 2 * N * (N - 1);\n seeds.resize(seed_count);\n\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].x.resize(M);\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n\n mt19937 rng(42);\n auto start_time = steady_clock::now();\n\n for (int t = 0; t < T; t++) {\n vector selected_ids;\n vector used(seed_count, false);\n\n // Select the top 1 seed for each criterion to maintain diversity\n for (int l = 0; l < M; ++l) {\n int best_id = -1;\n int best_val = -1;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i] && seeds[i].x[l] > best_val) {\n best_val = seeds[i].x[l];\n best_id = i;\n }\n }\n if (best_id != -1) {\n selected_ids.push_back(best_id);\n used[best_id] = true;\n }\n }\n\n // Fill the rest with the highest sum seeds\n vector remaining;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i]) remaining.push_back(i);\n }\n sort(remaining.begin(), remaining.end(), [&](int a, int b) {\n return seeds[a].sum > seeds[b].sum;\n });\n\n for (int i = 0; selected_ids.size() < N * N; ++i) {\n selected_ids.push_back(remaining[i]);\n }\n\n // Initialize grid randomly\n shuffle(selected_ids.begin(), selected_ids.end(), rng);\n vector> grid(N, vector(N));\n int idx = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n grid[r][c] = selected_ids[idx++];\n }\n }\n\n // Calculate initial score\n int current_score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (r + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r+1][c]]);\n if (c + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r][c+1]]);\n }\n }\n\n // Simulated Annealing\n double time_limit_per_turn = 1.9 / T; \n auto turn_start = steady_clock::now();\n double start_temp = 20.0;\n double end_temp = 0.1;\n int iter = 0;\n\n while (true) {\n if ((iter & 255) == 0) {\n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n if (elapsed >= time_limit_per_turn) break;\n }\n iter++;\n\n int r1 = uniform_int_distribution(0, N - 1)(rng);\n int c1 = uniform_int_distribution(0, N - 1)(rng);\n int r2 = uniform_int_distribution(0, N - 1)(rng);\n int c2 = uniform_int_distribution(0, N - 1)(rng);\n if (r1 == r2 && c1 == c2) continue;\n\n int old_contrib = 0;\n int new_contrib = 0;\n \n int s1 = grid[r1][c1];\n int s2 = grid[r2][c2];\n\n const int dr[] = {-1, 1, 0, 0};\n const int dc[] = {0, 0, -1, 1};\n\n for (int d = 0; d < 4; ++d) {\n int nr1 = r1 + dr[d], nc1 = c1 + dc[d];\n if (nr1 >= 0 && nr1 < N && nc1 >= 0 && nc1 < N) {\n if (nr1 != r2 || nc1 != c2) {\n old_contrib += pair_score(seeds[s1], seeds[grid[nr1][nc1]]);\n new_contrib += pair_score(seeds[s2], seeds[grid[nr1][nc1]]);\n }\n }\n int nr2 = r2 + dr[d], nc2 = c2 + dc[d];\n if (nr2 >= 0 && nr2 < N && nc2 >= 0 && nc2 < N) {\n if (nr2 != r1 || nc2 != c1) {\n old_contrib += pair_score(seeds[s2], seeds[grid[nr2][nc2]]);\n new_contrib += pair_score(seeds[s1], seeds[grid[nr2][nc2]]);\n }\n }\n }\n\n int diff = new_contrib - old_contrib;\n \n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n double temp = start_temp * pow(end_temp / start_temp, elapsed / time_limit_per_turn);\n\n if (diff >= 0 || uniform_real_distribution(0.0, 1.0)(rng) < exp(diff / temp)) {\n current_score += diff;\n swap(grid[r1][c1], grid[r2][c2]);\n }\n }\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n cout << grid[r][c] << (c == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n if (t < T - 1) {\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int dx[4] = {0, 1, 0, -1}; // R, D, L, U\nconst int dy[4] = {1, 0, -1, 0};\nconst char move_char[4] = {'R', 'D', 'L', 'U'};\n\nstruct State {\n int rx, ry, dir;\n};\n\nint N, M, V;\nvector s_grid, t_grid;\n\nbool is_valid_root(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\n// BFS to find the shortest path to place the leaf at (target_x, target_y)\nstring navigate(int& rx, int& ry, int& dir, int target_x, int target_y) {\n int dist[35][35][4];\n pair parent_action[35][35][4];\n tuple parent_state[35][35][4];\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n for (int d = 0; d < 4; ++d)\n dist[i][j][d] = 1e9;\n \n queue q;\n q.push({rx, ry, dir});\n dist[rx][ry][dir] = 0;\n \n int end_rx = -1, end_ry = -1, end_dir = -1;\n \n while (!q.empty()) {\n auto [cx, cy, cd] = q.front();\n q.pop();\n \n int lx = cx + dx[cd];\n int ly = cy + dy[cd];\n if (lx == target_x && ly == target_y) {\n end_rx = cx; end_ry = cy; end_dir = cd;\n break;\n }\n \n for (int i = 0; i < 4; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n if (is_valid_root(nx, ny) && dist[nx][ny][cd] > dist[cx][cy][cd] + 1) {\n dist[nx][ny][cd] = dist[cx][cy][cd] + 1;\n parent_action[nx][ny][cd] = {0, i};\n parent_state[nx][ny][cd] = {cx, cy, cd};\n q.push({nx, ny, cd});\n }\n }\n \n int nd_r = (cd + 1) % 4; // Clockwise\n if (dist[cx][cy][nd_r] > dist[cx][cy][cd] + 1) {\n dist[cx][cy][nd_r] = dist[cx][cy][cd] + 1;\n parent_action[cx][cy][nd_r] = {1, 1}; // 1 = R\n parent_state[cx][cy][nd_r] = {cx, cy, cd};\n q.push({cx, cy, nd_r});\n }\n \n int nd_l = (cd + 3) % 4; // Counterclockwise\n if (dist[cx][cy][nd_l] > dist[cx][cy][cd] + 1) {\n dist[cx][cy][nd_l] = dist[cx][cy][cd] + 1;\n parent_action[cx][cy][nd_l] = {1, -1}; // -1 = L\n parent_state[cx][cy][nd_l] = {cx, cy, cd};\n q.push({cx, cy, nd_l});\n }\n }\n \n if (end_rx == -1) return \"\"; \n \n vector commands;\n int cx = end_rx, cy = end_ry, cd = end_dir;\n while (cx != rx || cy != ry || cd != dir) {\n auto [atype, aval] = parent_action[cx][cy][cd];\n auto [px, py, pd] = parent_state[cx][cy][cd];\n \n string cmd = \"....\";\n if (atype == 0) {\n cmd[0] = move_char[aval];\n } else {\n cmd[1] = (aval == 1) ? 'R' : 'L';\n }\n commands.push_back(cmd);\n cx = px; cy = py; cd = pd;\n }\n \n string final_commands = \"\";\n for (int i = (int)commands.size() - 1; i >= 0; --i) {\n final_commands += commands[i] + \"\\n\";\n }\n \n rx = end_rx; ry = end_ry; dir = end_dir;\n return final_commands;\n}\n\nint get_cost(const vector& order, const vector& target_of, const vector>& sources, const vector>& targets) {\n int cost = 0;\n pair cur = {0, 1}; // Initial leaf position\n for (int i = 0; i < (int)order.size(); ++i) {\n int s_idx = order[i];\n int t_idx = target_of[s_idx];\n \n cost += abs(cur.first - sources[s_idx].first) + abs(cur.second - sources[s_idx].second);\n cur = sources[s_idx];\n \n cost += abs(cur.first - targets[t_idx].first) + abs(cur.second - targets[t_idx].second);\n cur = targets[t_idx];\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> N >> M >> V)) return 0;\n \n s_grid.resize(N);\n t_grid.resize(N);\n for (int i = 0; i < N; ++i) cin >> s_grid[i];\n for (int i = 0; i < N; ++i) cin >> t_grid[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_grid[i][j] == '1' && t_grid[i][j] == '0') sources.push_back({i, j});\n if (s_grid[i][j] == '0' && t_grid[i][j] == '1') targets.push_back({i, j});\n }\n }\n \n int num_t = sources.size();\n vector target_of(num_t);\n vector order(num_t);\n for (int i = 0; i < num_t; ++i) {\n target_of[i] = i;\n order[i] = i;\n }\n \n mt19937 rng(42);\n int current_cost = get_cost(order, target_of, sources, targets);\n \n // Simulated Annealing\n double temp_start = 50.0;\n double temp_end = 0.1;\n double max_time = 1.5; // seconds\n \n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n \n double temp = temp_start * pow(temp_end / temp_start, elapsed / max_time);\n \n int type = uniform_int_distribution<>(0, 1)(rng);\n if (type == 0 && num_t >= 2) {\n // Swap order\n int i = uniform_int_distribution<>(0, num_t - 1)(rng);\n int j = uniform_int_distribution<>(0, num_t - 1)(rng);\n swap(order[i], order[j]);\n \n int new_cost = get_cost(order, target_of, sources, targets);\n if (new_cost < current_cost || uniform_real_distribution<>(0.0, 1.0)(rng) < exp((current_cost - new_cost) / temp)) {\n current_cost = new_cost;\n } else {\n swap(order[i], order[j]); // rollback\n }\n } else if (type == 1 && num_t >= 2) {\n // Swap targets\n int i = uniform_int_distribution<>(0, num_t - 1)(rng);\n int j = uniform_int_distribution<>(0, num_t - 1)(rng);\n swap(target_of[i], target_of[j]);\n \n int new_cost = get_cost(order, target_of, sources, targets);\n if (new_cost < current_cost || uniform_real_distribution<>(0.0, 1.0)(rng) < exp((current_cost - new_cost) / temp)) {\n current_cost = new_cost;\n } else {\n swap(target_of[i], target_of[j]); // rollback\n }\n }\n }\n \n cout << 2 << \"\\n\";\n cout << 0 << \" \" << 1 << \"\\n\";\n \n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n int dir = 0; \n \n for (int i = 0; i < num_t; ++i) {\n int s_idx = order[i];\n int t_idx = target_of[s_idx];\n \n cout << navigate(rx, ry, dir, sources[s_idx].first, sources[s_idx].second);\n cout << \"...P\\n\"; \n \n cout << navigate(rx, ry, dir, targets[t_idx].first, targets[t_idx].second);\n cout << \"...P\\n\"; \n }\n \n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_COORD = 100000;\nconst int B_COARSE = 200; \nconst int CELL = MAX_COORD / B_COARSE;\n\nstruct Point {\n int x, y;\n};\n\n// Evaluate the net score of a rectangle efficiently using 2D prefix sums could be complex, \n// so we do it in O(N) since N=5000 is small enough for many iterations.\nint eval_score(const vector& mackerels, const vector& sardines, int x_min, int x_max, int y_min, int y_max) {\n int score = 0;\n for (const auto& p : mackerels) {\n if (p.x >= x_min && p.x <= x_max && p.y >= y_min && p.y <= y_max) score++;\n }\n for (const auto& p : sardines) {\n if (p.x >= x_min && p.x <= x_max && p.y >= y_min && p.y <= y_max) score--;\n }\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector mackerels(N);\n vector sardines(N);\n vector> grid(B_COARSE, vector(B_COARSE, 0));\n\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n int gx = min(mackerels[i].x / CELL, B_COARSE - 1);\n int gy = min(mackerels[i].y / CELL, B_COARSE - 1);\n grid[gx][gy]++;\n }\n\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n int gx = min(sardines[i].x / CELL, B_COARSE - 1);\n int gy = min(sardines[i].y / CELL, B_COARSE - 1);\n grid[gx][gy]--;\n }\n\n // 1. Initial guess: 2D Kadane's algorithm\n int max_sum = -1e9;\n int best_r1 = 0, best_r2 = 0, best_c1 = 0, best_c2 = 0;\n\n for (int r1 = 0; r1 < B_COARSE; r1++) {\n vector temp(B_COARSE, 0);\n for (int r2 = r1; r2 < B_COARSE; r2++) {\n for (int c = 0; c < B_COARSE; c++) temp[c] += grid[r2][c];\n int current_sum = 0, c1 = 0;\n for (int c = 0; c < B_COARSE; c++) {\n current_sum += temp[c];\n if (current_sum > max_sum) {\n max_sum = current_sum;\n best_r1 = r1; best_r2 = r2;\n best_c1 = c1; best_c2 = c;\n }\n if (current_sum < 0) { current_sum = 0; c1 = c + 1; }\n }\n }\n }\n\n int init_x1 = best_r1 * CELL;\n int init_x2 = min((best_r2 + 1) * CELL, MAX_COORD);\n int init_y1 = best_c1 * CELL;\n int init_y2 = min((best_c2 + 1) * CELL, MAX_COORD);\n\n // Optimize the basic rectangle bounds slightly first\n int best_rect_score = eval_score(mackerels, sardines, init_x1, init_x2, init_y1, init_y2);\n mt19937 rng(1337);\n\n for (int iter = 0; iter < 1000; iter++) {\n int choice = uniform_int_distribution(0, 3)(rng);\n int delta = uniform_int_distribution(-2000, 2000)(rng);\n int nx1 = init_x1, nx2 = init_x2, ny1 = init_y1, ny2 = init_y2;\n\n if (choice == 0) nx1 = clamp(nx1 + delta, 0, nx2 - 1);\n else if (choice == 1) nx2 = clamp(nx2 + delta, nx1 + 1, MAX_COORD);\n else if (choice == 2) ny1 = clamp(ny1 + delta, 0, ny2 - 1);\n else if (choice == 3) ny2 = clamp(ny2 + delta, ny1 + 1, MAX_COORD);\n\n if (2LL * (nx2 - nx1 + ny2 - ny1) > 400000LL) continue;\n int new_score = eval_score(mackerels, sardines, nx1, nx2, ny1, ny2);\n if (new_score >= best_rect_score) {\n best_rect_score = new_score;\n init_x1 = nx1; init_x2 = nx2; init_y1 = ny1; init_y2 = ny2;\n }\n }\n\n // 2. Y-Monotone Polygon Expansion\n const int STRIPS = 100; // Limits vertices to <= 400 (well below 1000 max)\n int strip_height = MAX_COORD / STRIPS;\n \n int start_strip = init_y1 / strip_height;\n int end_strip = init_y2 / strip_height;\n if (end_strip >= STRIPS) end_strip = STRIPS - 1;\n if (start_strip > end_strip) start_strip = end_strip;\n\n vector L(STRIPS, init_x1);\n vector R(STRIPS, init_x2);\n\n auto get_poly_score = [&]() {\n int score = 0;\n for (const auto& p : mackerels) {\n int strip = clamp(p.y / strip_height, 0, STRIPS - 1);\n if (strip >= start_strip && strip <= end_strip && p.x >= L[strip] && p.x <= R[strip]) score++;\n }\n for (const auto& p : sardines) {\n int strip = clamp(p.y / strip_height, 0, STRIPS - 1);\n if (strip >= start_strip && strip <= end_strip && p.x >= L[strip] && p.x <= R[strip]) score--;\n }\n return score;\n };\n\n auto get_perimeter = [&]() {\n long long perim = (R[start_strip] - L[start_strip]) + (R[end_strip] - L[end_strip]);\n perim += 2LL * (end_strip - start_strip + 1) * strip_height;\n for (int i = start_strip; i < end_strip; i++) {\n perim += abs(L[i+1] - L[i]) + abs(R[i+1] - R[i]);\n }\n return perim;\n };\n\n int best_poly_score = get_poly_score();\n\n // Local Search on Y-Monotone Strips\n int iterations = 0;\n while (true) {\n if ((iterations & 63) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n if (chrono::duration(current_time - start_time).count() > 1.90) break;\n }\n iterations++;\n\n int strip = uniform_int_distribution(start_strip, end_strip)(rng);\n bool is_L = uniform_int_distribution(0, 1)(rng);\n int delta = uniform_int_distribution(-3000, 3000)(rng);\n\n int old_val = is_L ? L[strip] : R[strip];\n int new_val = clamp(old_val + delta, 0, MAX_COORD);\n\n if (is_L) {\n if (new_val >= R[strip] - 1) continue; // Must be strictly smaller\n if (strip > start_strip && new_val >= R[strip - 1]) continue; // Ensure overlap\n if (strip < end_strip && new_val >= R[strip + 1]) continue;\n L[strip] = new_val;\n } else {\n if (new_val <= L[strip] + 1) continue; // Must be strictly larger\n if (strip > start_strip && new_val <= L[strip - 1]) continue;\n if (strip < end_strip && new_val <= L[strip + 1]) continue;\n R[strip] = new_val;\n }\n\n if (get_perimeter() > 400000LL) {\n if (is_L) L[strip] = old_val; else R[strip] = old_val;\n continue;\n }\n\n int new_score = get_poly_score();\n if (new_score >= best_poly_score) {\n best_poly_score = new_score;\n } else {\n if (is_L) L[strip] = old_val; else R[strip] = old_val;\n }\n }\n\n // 3. Assemble and Simplify the Vertices strictly adhering to orthogonal constraints\n vector vertices;\n\n // Left boundary (top to bottom)\n vertices.push_back({L[start_strip], start_strip * strip_height});\n for (int i = start_strip; i <= end_strip; i++) {\n if (i > start_strip) {\n vertices.push_back({L[i-1], i * strip_height});\n vertices.push_back({L[i], i * strip_height});\n }\n }\n vertices.push_back({L[end_strip], (end_strip + 1) * strip_height});\n\n // Right boundary (bottom to top)\n vertices.push_back({R[end_strip], (end_strip + 1) * strip_height});\n for (int i = end_strip; i >= start_strip; i--) {\n if (i < end_strip) {\n vertices.push_back({R[i+1], (i + 1) * strip_height});\n vertices.push_back({R[i], (i + 1) * strip_height});\n }\n }\n vertices.push_back({R[start_strip], start_strip * strip_height});\n\n // Remove collinear points\n vector simplified;\n for (size_t i = 0; i < vertices.size(); i++) {\n Point prev = vertices[(i + vertices.size() - 1) % vertices.size()];\n Point curr = vertices[i];\n Point next = vertices[(i + 1) % vertices.size()];\n if ((prev.x == curr.x && curr.x == next.x) || (prev.y == curr.y && curr.y == next.y)) {\n continue; \n }\n simplified.push_back(curr);\n }\n\n if (simplified.size() < 4) {\n simplified = {{init_x1, init_y1}, {init_x2, init_y1}, {init_x2, init_y2}, {init_x1, init_y2}};\n }\n\n cout << simplified.size() << \"\\n\";\n for (const auto& v : simplified) cout << v.x << \" \" << v.y << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n int r;\n char d;\n int b;\n};\n\nint N, T;\nlong long sigma;\nvector rects;\n\nmt19937 rng(1337);\n\nlong long X_pos[105];\nlong long Y_pos[105];\nlong long W_arr[105];\nlong long H_arr[105];\n\nlong long simulate(const vector& p, long long& out_W, long long& out_H) {\n long long max_X = 0, max_Y = 0;\n\n for (int i = 0; i < N; ++i) {\n if (p[i].r == 1) {\n W_arr[i] = rects[i].h;\n H_arr[i] = rects[i].w;\n } else {\n W_arr[i] = rects[i].w;\n H_arr[i] = rects[i].h;\n }\n\n if (p[i].d == 'U') {\n if (p[i].b == -1) {\n X_pos[i] = 0;\n } else {\n X_pos[i] = X_pos[p[i].b] + W_arr[p[i].b];\n }\n long long cur_y = 0;\n for (int j = 0; j < i; ++j) {\n if (X_pos[i] < X_pos[j] + W_arr[j] && X_pos[j] < X_pos[i] + W_arr[i]) {\n cur_y = max(cur_y, Y_pos[j] + H_arr[j]);\n }\n }\n Y_pos[i] = cur_y;\n } else {\n if (p[i].b == -1) {\n Y_pos[i] = 0;\n } else {\n Y_pos[i] = Y_pos[p[i].b] + H_arr[p[i].b];\n }\n long long cur_x = 0;\n for (int j = 0; j < i; ++j) {\n if (Y_pos[i] < Y_pos[j] + H_arr[j] && Y_pos[j] < Y_pos[i] + H_arr[i]) {\n cur_x = max(cur_x, X_pos[j] + W_arr[j]);\n }\n }\n X_pos[i] = cur_x;\n }\n max_X = max(max_X, X_pos[i] + W_arr[i]);\n max_Y = max(max_Y, Y_pos[i] + H_arr[i]);\n }\n out_W = max_X;\n out_H = max_Y;\n return max_X + max_Y;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> T >> sigma)) return 0;\n\n rects.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> rects[i].w >> rects[i].h;\n }\n\n auto start_time = chrono::steady_clock::now();\n auto max_time = start_time + chrono::milliseconds(2850);\n\n vector best_overall_p(N);\n for (int i = 0; i < N; ++i) {\n best_overall_p[i] = {0, 'U', -1};\n }\n long long overall_W, overall_H;\n long long best_overall_score = simulate(best_overall_p, overall_W, overall_H);\n\n for (int t = 0; t < T; ++t) {\n auto now = chrono::steady_clock::now();\n double remaining_time = chrono::duration(max_time - now).count();\n double time_for_this_turn = remaining_time / (T - t);\n auto turn_end_time = now + chrono::duration(time_for_this_turn);\n\n vector current_p = best_overall_p;\n long long current_score = best_overall_score;\n\n double temp_start = 100000.0;\n double temp_end = 100.0;\n int iters_per_check = 200; \n \n while (true) {\n auto current_time = chrono::steady_clock::now();\n if (current_time >= turn_end_time) break;\n \n double elapsed_ratio = chrono::duration(current_time - now).count() / time_for_this_turn;\n double temp = temp_start * pow(temp_end / temp_start, elapsed_ratio);\n\n for (int it = 0; it < iters_per_check; ++it) {\n int i = rng() % N;\n Placement old_pl = current_p[i];\n \n int r_type = rng() % 3;\n if (r_type == 0) {\n current_p[i].r ^= 1;\n } else if (r_type == 1) {\n current_p[i].d = (current_p[i].d == 'U') ? 'L' : 'U';\n } else {\n if (i == 0) current_p[i].b = -1;\n else current_p[i].b = (rng() % (i + 1)) - 1;\n }\n\n long long W, H;\n long long new_score = simulate(current_p, W, H);\n \n bool accept = false;\n if (new_score < current_score) {\n accept = true;\n } else {\n double prob = exp((current_score - new_score) / temp);\n if (generate_canonical(rng) < prob) {\n accept = true;\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score < best_overall_score) {\n best_overall_score = current_score;\n best_overall_p = current_p;\n }\n } else {\n current_p[i] = old_pl;\n }\n }\n }\n\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << \" \" << best_overall_p[i].r << \" \" << best_overall_p[i].d << \" \" << best_overall_p[i].b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nuint64_t xorshift64() {\n static uint64_t x = 88172645463325252ULL;\n x ^= x << 13;\n x ^= x >> 7;\n x ^= x << 17;\n return x;\n}\n\ndouble next_double() {\n return (xorshift64() >> 11) * (1.0 / 9007199254740992.0);\n}\n\nconst int MAX_H = 10;\nint N, M, H;\nvector A;\nvector> adj;\n\nstruct FastTreeState {\n vector p;\n vector first_child;\n vector next_sibling;\n vector prev_sibling;\n vector depth;\n vector max_rel_height;\n vector subtree_A;\n long long score;\n\n FastTreeState() {\n p.assign(N, -1);\n first_child.assign(N, -1);\n next_sibling.assign(N, -1);\n prev_sibling.assign(N, -1);\n depth.assign(N, 0);\n max_rel_height.assign(N, 0);\n subtree_A.assign(N, 0);\n score = 0;\n for (int i = 0; i < N; ++i) {\n subtree_A[i] = A[i];\n score += A[i];\n }\n }\n\n inline void add_child(int parent, int child) {\n if (parent == -1) return;\n int head = first_child[parent];\n next_sibling[child] = head;\n if (head != -1) prev_sibling[head] = child;\n prev_sibling[child] = -1;\n first_child[parent] = child;\n }\n\n inline void remove_child(int parent, int child) {\n if (parent == -1) return;\n int prev = prev_sibling[child];\n int next = next_sibling[child];\n if (prev != -1) next_sibling[prev] = next;\n else first_child[parent] = next;\n if (next != -1) prev_sibling[next] = prev;\n prev_sibling[child] = -1;\n next_sibling[child] = -1;\n }\n\n void update_up(int node) {\n while (node != -1) {\n long long sum_A = A[node];\n int max_h = 0;\n int c = first_child[node];\n while (c != -1) {\n sum_A += subtree_A[c];\n if (max_rel_height[c] + 1 > max_h) {\n max_h = max_rel_height[c] + 1;\n }\n c = next_sibling[c];\n }\n subtree_A[node] = sum_A;\n max_rel_height[node] = max_h;\n node = p[node];\n }\n }\n\n void update_depth(int u) {\n int c = first_child[u];\n while (c != -1) {\n depth[c] = depth[u] + 1;\n update_depth(c);\n c = next_sibling[c];\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> M >> H)) return 0;\n\n A.resize(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n\n adj.resize(N);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n FastTreeState state;\n \n double T0 = 200.0;\n double T1 = 0.01;\n long long iter = 0;\n \n while (true) {\n if ((iter & 8191) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.95) break;\n }\n iter++;\n \n int v = xorshift64() % N;\n int num_options = adj[v].size() + 1;\n int opt = xorshift64() % num_options;\n int u = (opt == (int)adj[v].size()) ? -1 : adj[v][opt];\n\n if (state.p[v] == u) continue;\n\n bool cycle = false;\n int curr = u;\n while (curr != -1) {\n if (curr == v) {\n cycle = true;\n break;\n }\n curr = state.p[curr];\n }\n if (cycle) continue;\n\n int new_v_depth = (u == -1) ? 0 : state.depth[u] + 1;\n if (new_v_depth + state.max_rel_height[v] > H) continue;\n\n long long delta_score = (long long)(new_v_depth - state.depth[v]) * state.subtree_A[v];\n\n if (delta_score >= 0) {\n int old_p = state.p[v];\n state.remove_child(old_p, v);\n state.add_child(u, v);\n state.p[v] = u;\n state.depth[v] = new_v_depth;\n \n state.update_depth(v);\n state.update_up(old_p);\n state.update_up(u);\n state.score += delta_score;\n } else {\n double elapsed = chrono::duration(chrono::steady_clock::now() - start_time).count();\n double progress = elapsed / 1.95;\n if (progress > 1.0) progress = 1.0;\n double temp = T0 * pow(T1 / T0, progress);\n\n if (next_double() < exp(delta_score / temp)) {\n int old_p = state.p[v];\n state.remove_child(old_p, v);\n state.add_child(u, v);\n state.p[v] = u;\n state.depth[v] = new_v_depth;\n \n state.update_depth(v);\n state.update_up(old_p);\n state.update_up(u);\n state.score += delta_score;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << state.p[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\n\nvector> solve(vector board, double alpha, double noise_level, mt19937& rng) {\n int oni_count = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') oni_count++;\n }\n }\n \n vector> moves;\n \n auto apply = [&](char d, int p) {\n moves.push_back({d, p});\n if (d == 'L') {\n for (int j = 0; j < N - 1; ++j) board[p][j] = board[p][j+1];\n board[p][N-1] = '.';\n } else if (d == 'R') {\n for (int j = N - 1; j > 0; --j) board[p][j] = board[p][j-1];\n board[p][0] = '.';\n } else if (d == 'U') {\n for (int i = 0; i < N - 1; ++i) board[i][p] = board[i+1][p];\n board[N-1][p] = '.';\n } else if (d == 'D') {\n for (int i = N - 1; i > 0; --i) board[i][p] = board[i-1][p];\n board[0][p] = '.';\n }\n };\n\n uniform_real_distribution dist(0.0, noise_level);\n\n while (oni_count > 0) {\n double best_score = -1.0;\n char best_dir = ' ';\n int best_idx = -1;\n int best_k = 0;\n\n for (int r = 0; r < N; ++r) {\n // Left\n int dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[r][k - 1] == 'o') break;\n if (board[r][k - 1] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'L'; best_idx = r; best_k = k;\n }\n }\n }\n // Right\n dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[r][N - k] == 'o') break;\n if (board[r][N - k] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'R'; best_idx = r; best_k = k;\n }\n }\n }\n }\n\n for (int c = 0; c < N; ++c) {\n // Up\n int dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[k - 1][c] == 'o') break;\n if (board[k - 1][c] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'U'; best_idx = c; best_k = k;\n }\n }\n }\n // Down\n dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[N - k][c] == 'o') break;\n if (board[N - k][c] == 'x') dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'D'; best_idx = c; best_k = k;\n }\n }\n }\n }\n\n if (best_score < 0) break; // Should not trigger\n\n if (best_dir == 'U') {\n for (int i = 0; i < best_k; ++i) apply('U', best_idx);\n for (int i = 0; i < best_k; ++i) apply('D', best_idx);\n } else if (best_dir == 'D') {\n for (int i = 0; i < best_k; ++i) apply('D', best_idx);\n for (int i = 0; i < best_k; ++i) apply('U', best_idx);\n } else if (best_dir == 'L') {\n for (int i = 0; i < best_k; ++i) apply('L', best_idx);\n for (int i = 0; i < best_k; ++i) apply('R', best_idx);\n } else if (best_dir == 'R') {\n for (int i = 0; i < best_k; ++i) apply('R', best_idx);\n for (int i = 0; i < best_k; ++i) apply('L', best_idx);\n }\n \n oni_count = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (board[i][j] == 'x') oni_count++;\n }\n }\n }\n \n return moves;\n}\n\nint main() {\n auto start_time = chrono::high_resolution_clock::now();\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n \n vector initial_board(N);\n for (int i = 0; i < N; ++i) {\n cin >> initial_board[i];\n }\n \n mt19937 rng(1337);\n vector> best_moves;\n int best_moves_size = 1e9;\n\n uniform_real_distribution alpha_dist(0.1, 3.0);\n uniform_real_distribution noise_dist(1e-6, 0.05);\n\n int iterations = 0;\n while (true) {\n iterations++;\n // Check time every 10 iterations to save clock() overhead\n if (iterations % 10 == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.9) break; \n }\n\n double alpha = alpha_dist(rng);\n double noise_level = noise_dist(rng);\n \n vector> current_moves = solve(initial_board, alpha, noise_level, rng);\n \n if (current_moves.size() < best_moves_size && !current_moves.empty()) {\n best_moves_size = current_moves.size();\n best_moves = current_moves;\n }\n }\n \n for (auto p : best_moves) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}","ahc044":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\nint T[N];\n\ninline int simulate(const int* sa, const int* sb) {\n int t[N] = {0};\n int curr = 0;\n for (int step = 0; step < L; ++step) {\n int count = t[curr]++;\n curr = (count & 1) ? sa[curr] : sb[curr];\n }\n int diff = 0;\n for (int i = 0; i < N; ++i) {\n int d = t[i] - T[i];\n diff += (d > 0 ? d : -d);\n }\n return diff;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, l_input;\n if (!(cin >> n_input >> l_input)) return 0;\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n int a[N], b[N];\n for (int i = 0; i < N; ++i) {\n a[i] = (i + 1) % N;\n b[i] = (i + 1) % N;\n }\n\n int best_cost = simulate(a, b);\n int current_cost = best_cost;\n int best_a[N], best_b[N];\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n\n mt19937 rng(42);\n auto start_time = chrono::steady_clock::now();\n\n double t0 = 5000.0;\n double t1 = 10.0;\n \n uniform_real_distribution dist01(0.0, 1.0);\n\n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.95) break;\n \n double temp = t0 * pow(t1 / t0, elapsed / 1.95);\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n \n if (old_v == new_v) continue;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_cost = simulate(a, b);\n int delta = new_cost - current_cost;\n\n if (delta <= 0 || dist01(rng) < exp(-delta / temp)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct City {\n int lx, rx, ly, ry;\n long long cx, cy;\n};\n\nint N, M, Q, L, W;\nvector G;\nvector cities;\n\nlong long dist_city(int u, int v) {\n long long dx = cities[u].cx - cities[v].cx;\n long long dy = cities[u].cy - cities[v].cy;\n return std::floor(std::sqrt(dx * dx + dy * dy));\n}\n\nlong long calc_mst(const vector& nodes) {\n int k = nodes.size();\n if (k <= 1) return 0;\n vector min_e(k, 1e18);\n vector vis(k, false);\n min_e[0] = 0;\n long long total = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && (v == -1 || min_e[j] < min_e[v])) {\n v = j;\n }\n }\n if (min_e[v] >= 1e18) break;\n vis[v] = true;\n total += min_e[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = dist_city(nodes[v], nodes[j]);\n if (d < min_e[j]) min_e[j] = d;\n }\n }\n }\n return total;\n}\n\nvector> get_mst_edges(const vector& nodes) {\n int k = nodes.size();\n vector> edges;\n if (k <= 1) return edges;\n vector min_e(k, 1e18);\n vector parent(k, -1);\n vector vis(k, false);\n min_e[0] = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && (v == -1 || min_e[j] < min_e[v])) {\n v = j;\n }\n }\n vis[v] = true;\n if (parent[v] != -1) {\n edges.push_back({nodes[parent[v]], nodes[v]});\n }\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = dist_city(nodes[v], nodes[j]);\n if (d < min_e[j]) {\n min_e[j] = d;\n parent[j] = v;\n }\n }\n }\n }\n return edges;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n G.resize(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n cities.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2;\n }\n\n vector assign(N, -1);\n vector> grps(M);\n vector used(N, false);\n vector g_idx(M);\n iota(g_idx.begin(), g_idx.end(), 0);\n sort(g_idx.begin(), g_idx.end(), [&](int a, int b) { return G[a] > G[b]; });\n\n // Greedy Initialization\n for (int k : g_idx) {\n int start = -1;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) { start = i; break; }\n }\n used[start] = true;\n grps[k].push_back(start);\n assign[start] = k;\n \n while ((int)grps[k].size() < G[k]) {\n int best_c = -1;\n long long best_d = 2e18;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n long long d = 0;\n for (int u : grps[k]) {\n long long dx = cities[u].cx - cities[i].cx;\n long long dy = cities[u].cy - cities[i].cy;\n d += dx * dx + dy * dy;\n }\n if (d < best_d) {\n best_d = d;\n best_c = i;\n }\n }\n }\n used[best_c] = true;\n grps[k].push_back(best_c);\n assign[best_c] = k;\n }\n }\n\n vector mst_cost(M);\n for (int i = 0; i < M; ++i) mst_cost[i] = calc_mst(grps[i]);\n\n // Simulated Annealing\n auto start_time = chrono::steady_clock::now();\n double max_time = 1.8;\n int iter = 0;\n mt19937 rng(42);\n uniform_int_distribution dist_N(0, N - 1);\n uniform_real_distribution dist_01(0.0, 1.0);\n \n double t0 = 1000.0, t1 = 1.0;\n\n while (true) {\n if ((iter & 127) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n }\n iter++;\n\n int u = dist_N(rng);\n int v = dist_N(rng);\n if (assign[u] == assign[v]) continue;\n\n int gu = assign[u];\n int gv = assign[v];\n long long old_cost = mst_cost[gu] + mst_cost[gv];\n\n // Swap cities between the two different groups\n for (int& x : grps[gu]) if (x == u) x = v;\n for (int& x : grps[gv]) if (x == v) x = u;\n\n long long new_u_cost = calc_mst(grps[gu]);\n long long new_v_cost = calc_mst(grps[gv]);\n long long new_cost = new_u_cost + new_v_cost;\n\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n double temp = t0 * pow(t1 / t0, elapsed / max_time);\n\n if (new_cost <= old_cost || exp((old_cost - new_cost) / temp) > dist_01(rng)) {\n mst_cost[gu] = new_u_cost;\n mst_cost[gv] = new_v_cost;\n assign[u] = gv;\n assign[v] = gu;\n } else {\n // Revert changes\n for (int& x : grps[gu]) if (x == v) x = u;\n for (int& x : grps[gv]) if (x == u) x = v;\n }\n }\n\n // Since we omit fortune telling querying altogether directly output answers\n cout << \"!\" << endl;\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < G[i]; ++j) {\n cout << grps[i][j] << (j + 1 == G[i] ? \"\" : \" \");\n }\n cout << endl;\n auto edges = get_mst_edges(grps[i]);\n for (auto& e : edges) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& o) const {\n return r == o.r && c == o.c;\n }\n bool operator!=(const Point& o) const {\n return r != o.r || c != o.c;\n }\n};\n\nstruct StateInfo {\n int prev_r, prev_c;\n char action_type;\n char dir;\n};\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_chars[] = {'U', 'D', 'L', 'R'};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, m_input;\n if (!(cin >> n_input >> m_input)) return 0;\n\n vector targets(m_input);\n for (int i = 0; i < m_input; ++i) {\n cin >> targets[i].r >> targets[i].c;\n }\n\n Point curr = targets[0];\n vector> total_actions;\n\n for (int i = 1; i < m_input; ++i) {\n Point target = targets[i];\n \n vector> dist(N, vector(N, 1e9));\n vector> parent(N, vector(N));\n \n queue q;\n q.push(curr);\n dist[curr.r][curr.c] = 0;\n \n while (!q.empty()) {\n Point u = q.front();\n q.pop();\n \n if (u == target) break;\n \n for (int d = 0; d < 4; ++d) {\n // Try Move\n int nr = u.r + dr[d];\n int nc = u.c + dc[d];\n if (is_valid(nr, nc)) {\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'M', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n \n // Try Slide\n nr = u.r;\n nc = u.c;\n while (is_valid(nr + dr[d], nc + dc[d])) {\n nr += dr[d];\n nc += dc[d];\n }\n if (nr != u.r || nc != u.c) { // actually moved\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'S', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n }\n }\n \n // Reconstruct path\n vector> path;\n Point step = target;\n while (step != curr) {\n StateInfo info = parent[step.r][step.c];\n path.push_back({info.action_type, info.dir});\n step = {info.prev_r, info.prev_c};\n }\n \n reverse(path.begin(), path.end());\n for (auto p : path) {\n total_actions.push_back(p);\n }\n \n curr = target;\n }\n\n for (auto p : total_actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}"},"8":{"ahc001":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst double TIME_LIMIT = 4.85; \n\n// Fast random number generator\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double next_double() {\n return (xor128() & 0xFFFFFF) / (double)0x1000000;\n}\n\nstruct Rect {\n int x1, y1, x2, y2;\n int px, py;\n long long r;\n \n inline long long area() const {\n return 1LL * (x2 - x1) * (y2 - y1);\n }\n \n inline double score() const {\n long long s = area();\n if (s == 0) return 0.0;\n double mn = min(r, s);\n double mx = max(r, s);\n double val = 1.0 - mn / mx;\n return 1.0 - val * val;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n int n;\n if (!(cin >> n)) return 0;\n \n vector rects(n);\n for (int i = 0; i < n; ++i) {\n cin >> rects[i].px >> rects[i].py >> rects[i].r;\n rects[i].x1 = rects[i].px;\n rects[i].y1 = rects[i].py;\n rects[i].x2 = rects[i].px + 1;\n rects[i].y2 = rects[i].py + 1;\n }\n \n auto get_time = [&]() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n };\n \n double initial_temp = 0.1;\n double final_temp = 0.00001;\n \n int iterations = 0;\n while (true) {\n if ((iterations & 511) == 0) {\n double elapsed = get_time();\n if (elapsed > TIME_LIMIT) break;\n }\n iterations++;\n \n double elapsed = get_time();\n double progress = elapsed / TIME_LIMIT;\n double temp = initial_temp * pow(final_temp / initial_temp, progress);\n \n uint32_t r_val = xor128();\n int i = r_val % n;\n int dir = (r_val >> 8) % 4;\n \n // Variable step size\n int step_range;\n uint32_t type = (r_val >> 16) & 7;\n if (type == 0) step_range = 400; // 1/8 chance for large step\n else if (type <= 2) step_range = 100; // 2/8 chance for medium step\n else step_range = 20; // 5/8 chance for small step\n \n int delta = (xor128() % step_range) - (step_range / 2);\n if (delta == 0) continue;\n \n Rect old_i = rects[i];\n Rect new_i = old_i;\n \n if (dir == 0) { \n new_i.x1 += delta;\n if (new_i.x1 < 0) new_i.x1 = 0;\n if (new_i.x1 > old_i.px) new_i.x1 = old_i.px;\n } else if (dir == 1) { \n new_i.x2 += delta;\n if (new_i.x2 > 10000) new_i.x2 = 10000;\n if (new_i.x2 <= old_i.px) new_i.x2 = old_i.px + 1;\n } else if (dir == 2) { \n new_i.y1 += delta;\n if (new_i.y1 < 0) new_i.y1 = 0;\n if (new_i.y1 > old_i.py) new_i.y1 = old_i.py;\n } else { \n new_i.y2 += delta;\n if (new_i.y2 > 10000) new_i.y2 = 10000;\n if (new_i.y2 <= old_i.py) new_i.y2 = old_i.py + 1;\n }\n \n if (new_i.x1 == old_i.x1 && new_i.x2 == old_i.x2 && new_i.y1 == old_i.y1 && new_i.y2 == old_i.y2) continue;\n \n int overlap_idx = -1;\n bool valid = true;\n \n // Manual inline overlap check\n int nx1 = new_i.x1, nx2 = new_i.x2, ny1 = new_i.y1, ny2 = new_i.y2;\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n int rx1 = rects[j].x1, rx2 = rects[j].x2, ry1 = rects[j].y1, ry2 = rects[j].y2;\n if (max(nx1, rx1) < min(nx2, rx2) && max(ny1, ry1) < min(ny2, ry2)) {\n if (overlap_idx == -1) {\n overlap_idx = j;\n } else {\n valid = false;\n break;\n }\n }\n }\n \n if (!valid) continue;\n \n Rect old_j;\n Rect new_j;\n if (overlap_idx != -1) {\n old_j = rects[overlap_idx];\n new_j = old_j;\n \n if (dir == 0) new_j.x2 = new_i.x1;\n else if (dir == 1) new_j.x1 = new_i.x2;\n else if (dir == 2) new_j.y2 = new_i.y1;\n else new_j.y1 = new_i.y2;\n \n if (new_j.x1 > new_j.px || new_j.x2 <= new_j.px || new_j.y1 > new_j.py || new_j.y2 <= new_j.py) {\n continue;\n }\n }\n \n double old_score = old_i.score() + (overlap_idx != -1 ? old_j.score() : 0.0);\n double new_score = new_i.score() + (overlap_idx != -1 ? new_j.score() : 0.0);\n \n if (new_score > old_score || exp((new_score - old_score) / temp) > next_double()) {\n rects[i] = new_i;\n if (overlap_idx != -1) rects[overlap_idx] = new_j;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n cout << rects[i].x1 << \" \" << rects[i].y1 << \" \" << rects[i].x2 << \" \" << rects[i].y2 << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint t[50][50];\nint p[50][50];\nbool visited[2500];\nint best_score = -1;\nstring best_path = \"\";\nstring current_path = \"\";\nint current_score = 0;\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nauto start_time = chrono::high_resolution_clock::now();\nmt19937 rng(42);\n\nint steps_taken = 0;\n// Reduced max steps to encourage more restarts and broader tree exploration\nconst int MAX_STEPS_PER_DFS = 15000; \nbool time_up = false;\n\nstruct Move {\n int r, c, k, score;\n};\n\nvoid dfs(int r, int c) {\n if (time_up || steps_taken > MAX_STEPS_PER_DFS) return;\n \n steps_taken++;\n\n if ((steps_taken & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1950) {\n time_up = true;\n return;\n }\n }\n\n if (current_score > best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n\n Move moves[4];\n int num_moves = 0;\n\n for (int k = 0; k < 4; ++k) {\n int nr = r + di[k];\n int nc = c + dj[k];\n if (nr >= 0 && nr < 50 && nc >= 0 && nc < 50) {\n if (!visited[t[nr][nc]]) {\n // Return to the fast, simple score evaluation with light noise\n int perturbed_score = p[nr][nc] * 10 + (rng() % 200);\n moves[num_moves++] = {nr, nc, k, perturbed_score};\n }\n }\n }\n\n // Fast sort for tiny arrays (at most 4 elements)\n if (num_moves > 1) {\n for (int i = 1; i < num_moves; ++i) {\n Move key = moves[i];\n int j = i - 1;\n while (j >= 0 && moves[j].score < key.score) {\n moves[j + 1] = moves[j];\n j = j - 1;\n }\n moves[j + 1] = key;\n }\n }\n\n for (int i = 0; i < num_moves; ++i) {\n if (time_up || steps_taken > MAX_STEPS_PER_DFS) break;\n\n int nr = moves[i].r;\n int nc = moves[i].c;\n int k = moves[i].k;\n int tile_id = t[nr][nc];\n\n visited[tile_id] = true;\n current_score += p[nr][nc];\n current_path.push_back(dir_char[k]);\n\n dfs(nr, nc);\n\n current_path.pop_back();\n current_score -= p[nr][nc];\n visited[tile_id] = false;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n \n int max_t = 0;\n for (int i = 0; i < 50; ++i) {\n for (int j = 0; j < 50; ++j) {\n cin >> t[i][j];\n max_t = max(max_t, t[i][j]);\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 current_path.reserve(2500);\n\n while (!time_up) {\n for (int i = 0; i <= max_t; ++i) visited[i] = false;\n \n visited[t[si][sj]] = true;\n current_score = p[si][sj];\n current_path.clear();\n steps_taken = 0;\n \n dfs(si, sj);\n }\n\n cout << best_path << \"\\n\";\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_VAL = 9000;\nconst int MIN_VAL = 1000;\n\nint get_h_edge(int r, int c) {\n return r * 29 + c;\n}\n\nint get_v_edge(int r, int c) {\n return 30 * 29 + r * 30 + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int num_edges = 30 * 29 + 29 * 30;\n vector weights(num_edges, 4500.0);\n vector times_traversed(num_edges, 0);\n\n vector row_h_sum(N, 4500.0 * 29);\n vector col_v_sum(N, 4500.0 * 29);\n\n for (int q = 0; q < 1000; ++q) {\n int sr, sc, tr, tc;\n if (!(cin >> sr >> sc >> tr >> tc)) break;\n\n vector> dist(N, vector(N, 1e18));\n vector>> parent(N, vector>(N, {-1, -1}));\n vector> dir(N, vector(N, ' '));\n \n priority_queue>, vector>>, greater>>> pq;\n \n dist[sr][sc] = 0;\n pq.push({0, {sr, sc}});\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dch[] = {'U', 'D', 'L', 'R'};\n \n // Slightly extended exploration decay to encourage discovery a bit longer\n double exploration_factor = max(0.0, 1200.0 * (1.0 - q / 600.0));\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n int r = u.first;\n int c = u.second;\n \n if (d > dist[r][c]) continue;\n if (r == tr && c == tc) break;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int edge_idx = -1;\n double group_avg = 4500.0;\n \n if (i == 0) {\n edge_idx = get_v_edge(nr, nc);\n group_avg = col_v_sum[nc] / 29.0;\n } else if (i == 1) {\n edge_idx = get_v_edge(r, c);\n group_avg = col_v_sum[c] / 29.0;\n } else if (i == 2) {\n edge_idx = get_h_edge(nr, nc);\n group_avg = row_h_sum[nr] / 29.0;\n } else if (i == 3) {\n edge_idx = get_h_edge(r, c);\n group_avg = row_h_sum[r] / 29.0;\n }\n \n double w = weights[edge_idx];\n // Transition to trusting individual edges faster (from 4 down to 3)\n if (times_traversed[edge_idx] < 3) {\n double alpha = times_traversed[edge_idx] / 3.0;\n w = alpha * weights[edge_idx] + (1.0 - alpha) * group_avg;\n }\n \n w -= exploration_factor / (1.0 + times_traversed[edge_idx]);\n if (w < 1.0) w = 1.0;\n \n if (dist[r][c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n dir[nr][nc] = dch[i];\n pq.push({dist[nr][nc], {nr, nc}});\n }\n }\n }\n }\n \n string path = \"\";\n int cr = tr, cc = tc;\n vector> path_edge_info; \n \n while (cr != sr || cc != sc) {\n path += dir[cr][cc];\n int pr = parent[cr][cc].first;\n int pc = parent[cr][cc].second;\n \n if (dir[cr][cc] == 'U') path_edge_info.push_back({get_v_edge(cr, cc), 1 + (cc << 1)});\n else if (dir[cr][cc] == 'D') path_edge_info.push_back({get_v_edge(pr, pc), 1 + (pc << 1)});\n else if (dir[cr][cc] == 'L') path_edge_info.push_back({get_h_edge(cr, cc), 0 + (cr << 1)});\n else if (dir[cr][cc] == 'R') path_edge_info.push_back({get_h_edge(pr, pc), 0 + (pr << 1)});\n \n cr = pr;\n cc = pc;\n }\n \n reverse(path.begin(), path.end());\n cout << path << endl;\n \n int L;\n cin >> L;\n \n double current_est = 0;\n for (auto p : path_edge_info) {\n current_est += weights[p.first];\n }\n \n if (current_est < 1e-9) current_est = 1e-9;\n double error = L - current_est;\n \n for (auto p : path_edge_info) {\n int e = p.first;\n int type = p.second & 1;\n int idx = p.second >> 1;\n \n times_traversed[e]++;\n // Slightly reduced base learning rate to prevent overshoot when distributing error proportionally\n double lr = 1.0 / sqrt(times_traversed[e] + 1);\n \n double old_w = weights[e];\n double update = error * (weights[e] / current_est) * lr * 1.35;\n weights[e] += update;\n \n if (weights[e] < MIN_VAL) weights[e] = MIN_VAL;\n if (weights[e] > MAX_VAL) weights[e] = MAX_VAL;\n \n if (type == 0) {\n row_h_sum[idx] += weights[e] - old_w;\n } else {\n col_v_sum[idx] += weights[e] - old_w;\n }\n }\n }\n \n return 0;\n}","ahc004":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint M;\nstring S[805];\n\nconst int HASH_SIZE = 16384;\nint head[HASH_SIZE];\nuint64_t keys[805];\nint vals[805];\nint nxt[805];\nint sz = 0;\n\nvoid insert_hash(uint64_t key, int val) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n keys[sz] = key;\n vals[sz] = val;\n nxt[sz] = head[h];\n head[h] = sz++;\n}\n\ninline int get_id(uint64_t key) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n for(int i = head[h]; i != -1; i = nxt[i]) {\n if (keys[i] == key) return vals[i];\n }\n return -1;\n}\n\nint grid[N][N];\nint counts[805];\nbool valid_len[15];\n\ninline int evaluate_cell_change(int r, int c, int old_val, int new_val) {\n int diff = 0;\n int buf_h[24];\n int buf_v[24];\n \n for (int i = 0; i < 23; ++i) {\n buf_h[i] = grid[r][(c - 11 + i + N) % N];\n buf_v[i] = grid[(r - 11 + i + N) % N][c];\n }\n \n auto process = [&](int val, int sign) {\n buf_h[11] = val;\n buf_v[11] = val;\n \n for(int start = 0; start <= 11; ++start) {\n uint64_t v = 0;\n for(int l = 1; l <= 12; ++l) {\n int ch = buf_h[start + l - 1];\n if (ch == 8) break; \n v = (v << 3) | ch;\n if (l >= 2 && start + l - 1 >= 11 && valid_len[l]) {\n uint64_t key = ((uint64_t)l << 36) | v;\n int id = get_id(key);\n if (id != -1) {\n if (sign == 1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n } else {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n }\n \n for(int start = 0; start <= 11; ++start) {\n uint64_t v = 0;\n for(int l = 1; l <= 12; ++l) {\n int ch = buf_v[start + l - 1];\n if (ch == 8) break; \n v = (v << 3) | ch;\n if (l >= 2 && start + l - 1 >= 11 && valid_len[l]) {\n uint64_t key = ((uint64_t)l << 36) | v;\n int id = get_id(key);\n if (id != -1) {\n if (sign == 1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n } else {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n }\n };\n \n process(old_val, -1);\n process(new_val, 1);\n grid[r][c] = new_val;\n return diff;\n}\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n memset(head, -1, sizeof(head));\n memset(valid_len, 0, sizeof(valid_len));\n\n if (!(cin >> M >> M)) return 0;\n \n for(int i = 0; i < M; ++i) {\n cin >> S[i];\n valid_len[S[i].length()] = true;\n uint64_t val = 0;\n for(char c : S[i]) {\n val = (val << 3) | (c - 'A');\n }\n uint64_t key = ((uint64_t)S[i].length() << 36) | val;\n insert_hash(key, i);\n }\n\n mt19937 rng(42);\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n grid[r][c] = rng() % 8;\n }\n }\n\n memset(counts, 0, sizeof(counts));\n int current_score = 0;\n \n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n for(int l = 2; l <= 12; ++l) {\n if (!valid_len[l]) continue;\n \n uint64_t val_h = 0;\n for(int i = 0; i < l; ++i) val_h = (val_h << 3) | grid[r][(c + i) % N];\n uint64_t key_h = ((uint64_t)l << 36) | val_h;\n int id_h = get_id(key_h);\n if (id_h != -1) {\n if (counts[id_h] == 0) current_score++;\n counts[id_h]++;\n }\n \n uint64_t val_v = 0;\n for(int i = 0; i < l; ++i) val_v = (val_v << 3) | grid[(r + i) % N][c];\n uint64_t key_v = ((uint64_t)l << 36) | val_v;\n int id_v = get_id(key_v);\n if (id_v != -1) {\n if (counts[id_v] == 0) current_score++;\n counts[id_v]++;\n }\n }\n }\n }\n\n double start_temp = 1.0; \n double end_temp = 0.001;\n double time_limit = 2.9;\n \n int best_grid[N][N];\n int best_score = -1;\n\n int iter = 0;\n while(true) {\n if ((iter & 2047) == 0) {\n double t = get_time();\n if (t > time_limit) break;\n }\n iter++;\n\n int r = rng() % N;\n int c = rng() % N;\n int old_val = grid[r][c];\n int new_val = rng() % 8; \n \n // Increase probability of testing empty cells if M strings are mapped\n if (current_score == M && (rng() % 2) == 0) {\n new_val = 8;\n }\n \n if (new_val == old_val) {\n new_val = (new_val + 1) % 8;\n }\n\n int diff = evaluate_cell_change(r, c, old_val, new_val);\n\n double t = get_time() / time_limit;\n double temp = start_temp * pow(end_temp / start_temp, t);\n\n if (diff > 0 || exp(diff / temp) > (double)(rng() % 1000000) / 1000000.0) {\n current_score += diff;\n int empty_count = 0;\n if (current_score == M) {\n for(int ir = 0; ir < N; ++ir)\n for(int ic = 0; ic < N; ++ic)\n if (grid[ir][ic] == 8) empty_count++;\n }\n int actual_score = current_score == M ? M + empty_count : current_score;\n if (actual_score > best_score) {\n best_score = actual_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n evaluate_cell_change(r, c, new_val, old_val);\n }\n }\n\n for(int r = 0; r < N; ++r) {\n string out = \"\";\n for(int c = 0; c < N; ++c) {\n if (best_grid[r][c] == 8) out += '.';\n else out += (char)('A' + best_grid[r][c]);\n }\n cout << out << \"\\n\";\n }\n\n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint N, si, sj;\nvector grid;\nvector> visible;\nvector road_cells;\nbool is_road[5000];\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\ninline int get_id(int r, int c) {\n return r * N + c;\n}\n\nint dist_mat[5000][5000];\nint parent_mat[5000][5000];\nchar move_mat[5000][5000];\n\n// Fast XOR-shift RNG\nuint32_t xor128() {\n static uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double fast_rand(double L, double R) {\n return L + (R - L) * (xor128() * (1.0 / 4294967296.0));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> si >> sj)) return 0;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n int num_cells = N * N;\n visible.resize(num_cells);\n fill(is_road, is_road + num_cells, false);\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != '#') {\n int u = get_id(r, c);\n is_road[u] = true;\n road_cells.push_back(u);\n }\n }\n }\n\n int total_roads = road_cells.size();\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (!is_road[get_id(r, c)]) continue;\n int u = get_id(r, c);\n \n for (int r2 = r; r2 >= 0; --r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int r2 = r + 1; r2 < N; ++r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int c2 = c - 1; c2 >= 0; --c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n for (int c2 = c + 1; c2 < N; ++c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n }\n }\n\n int max_distance = 0;\n // Precompute All-Pairs Shortest Path (APSP) using Dijkstra\n for (int u : road_cells) {\n for (int v : road_cells) {\n dist_mat[u][v] = INF;\n parent_mat[u][v] = -1;\n }\n dist_mat[u][u] = 0;\n \n priority_queue, vector>, greater>> pq;\n pq.push({0, u});\n \n while(!pq.empty()) {\n auto [d, curr] = pq.top();\n pq.pop();\n \n if (d > dist_mat[u][curr]) continue;\n \n int r = curr / N;\n int c = curr % N;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int nxt = get_id(nr, nc);\n if (is_road[nxt]) {\n int cost = grid[nr][nc] - '0';\n if (dist_mat[u][curr] + cost < dist_mat[u][nxt]) {\n dist_mat[u][nxt] = dist_mat[u][curr] + cost;\n if (dist_mat[u][nxt] > max_distance) max_distance = dist_mat[u][nxt];\n parent_mat[u][nxt] = curr;\n move_mat[u][nxt] = dir_char[i];\n pq.push({dist_mat[u][nxt], nxt});\n }\n }\n }\n }\n }\n }\n\n string best_ans = \"\";\n int best_cost = INF;\n\n vector seen(num_cells, false);\n vector unseen_count(num_cells, 0);\n vector pow_unseen(400, 0.0);\n vector inv_pow_dist(max_distance + 2, 0.0);\n\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.85) break;\n\n fill(seen.begin(), seen.end(), false);\n for (int u : road_cells) {\n unseen_count[u] = visible[u].size();\n }\n\n int curr_node = get_id(si, sj);\n int seen_count = 0;\n int current_cost = 0;\n string ans = \"\";\n \n double alpha = fast_rand(0.5, 4.0);\n double beta = fast_rand(0.5, 4.0);\n double c_val = fast_rand(0.1, 10.0);\n\n for (int i = 0; i < 400; ++i) {\n pow_unseen[i] = pow(i, alpha);\n }\n for (int d = 0; d <= max_distance; ++d) {\n inv_pow_dist[d] = 1.0 / pow(d + c_val, beta);\n }\n\n auto mark_seen = [&](int u) {\n for (int v : visible[u]) {\n if (!seen[v]) {\n seen[v] = true;\n seen_count++;\n for (int w : visible[v]) {\n unseen_count[w]--;\n }\n }\n }\n };\n\n mark_seen(curr_node);\n\n while (seen_count < total_roads) {\n double best_score = -1.0;\n int best_target = -1;\n\n for (int u : road_cells) {\n int u_count = unseen_count[u];\n int d = dist_mat[curr_node][u];\n if (u_count > 0 && d != INF && d > 0) {\n double rand_factor = fast_rand(0.5, 1.5);\n double score = pow_unseen[u_count] * inv_pow_dist[d] * rand_factor;\n if (score > best_score) {\n best_score = score;\n best_target = u;\n }\n }\n }\n\n if (best_target == -1) break;\n\n vector path;\n int temp = best_target;\n while (temp != curr_node) {\n path.push_back(move_mat[curr_node][temp]);\n temp = parent_mat[curr_node][temp];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_node -= N;\n else if (dir == 'D') curr_node += N;\n else if (dir == 'L') curr_node -= 1;\n else if (dir == 'R') curr_node += 1;\n \n current_cost += grid[curr_node / N][curr_node % N] - '0';\n mark_seen(curr_node);\n \n // Early abort\n if (unseen_count[best_target] == 0) {\n break;\n }\n }\n }\n\n int start_id = get_id(si, sj);\n if (curr_node != start_id) {\n vector path;\n int temp = start_id;\n while (temp != curr_node) {\n path.push_back(move_mat[curr_node][temp]);\n temp = parent_mat[curr_node][temp];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_node -= N;\n else if (dir == 'D') curr_node += N;\n else if (dir == 'L') curr_node -= 1;\n else if (dir == 'R') curr_node += 1;\n \n current_cost += grid[curr_node / N][curr_node % N] - '0';\n }\n }\n\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_ans = ans;\n }\n }\n\n if (best_ans.empty()) {\n cout << \"\" << \"\\n\";\n } else {\n cout << best_ans << \"\\n\";\n }\n\n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector deps;\n vector rev_deps;\n int priority = 0;\n int status = -1; // -1: not started, 0: in progress, 1: completed\n};\n\nstruct Member {\n int id;\n vector s;\n int current_task = -1;\n int start_day = -1;\n \n struct History {\n int task_id;\n int actual_time;\n };\n vector history;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; ++k) cin >> tasks[i].d[k];\n }\n\n vector in_degree(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n tasks[u].rev_deps.push_back(v);\n tasks[v].deps.push_back(u);\n in_degree[v]++;\n }\n\n // Calculate reliable priority using longest path\n vector dp(N, 0);\n vector topo_order;\n queue q;\n vector in_deg_temp = in_degree;\n for (int i = 0; i < N; ++i) {\n if (in_deg_temp[i] == 0) q.push(i);\n }\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n topo_order.push_back(u);\n for (int v : tasks[u].rev_deps) {\n if (--in_deg_temp[v] == 0) q.push(v);\n }\n }\n \n for (int i = N - 1; i >= 0; --i) {\n int u = topo_order[i];\n dp[u] = 1;\n for (int v : tasks[u].rev_deps) {\n dp[u] = max(dp[u], dp[v] + 1);\n }\n tasks[u].priority = dp[u];\n }\n\n vector members(M);\n for (int i = 0; i < M; ++i) {\n members[i].id = i;\n members[i].s.assign(K, 0.0);\n }\n\n int day = 0;\n int completed_tasks = 0;\n\n while (completed_tasks < N) {\n day++;\n \n vector available_members;\n for (int i = 0; i < M; ++i) {\n if (members[i].current_task == -1) available_members.push_back(i);\n }\n\n vector available_tasks;\n for (int i = 0; i < N; ++i) {\n if (tasks[i].status == -1 && in_degree[i] == 0) available_tasks.push_back(i);\n }\n\n vector assign_m;\n vector assign_t;\n\n while (!available_members.empty() && !available_tasks.empty()) {\n int best_m_idx = 0; // Default to 0 to prevent -1 out of bounds\n int best_t_idx = 0;\n double best_score = -1e15; // Set to very low bound\n\n for (size_t i = 0; i < available_members.size(); ++i) {\n int m_id = available_members[i];\n for (size_t j = 0; j < available_tasks.size(); ++j) {\n int t_id = available_tasks[j];\n \n double expected_w = 0;\n for (int k = 0; k < K; ++k) {\n expected_w += max(0.0, tasks[t_id].d[k] - members[m_id].s[k]);\n }\n double expected_time = max(1.0, expected_w);\n \n double score = tasks[t_id].priority * 20.0 - expected_time * 2.0;\n \n if (score > best_score) {\n best_score = score;\n best_m_idx = i;\n best_t_idx = j;\n }\n }\n }\n\n int m_id = available_members[best_m_idx];\n int t_id = available_tasks[best_t_idx];\n\n members[m_id].current_task = t_id;\n members[m_id].start_day = day;\n tasks[t_id].status = 0;\n \n assign_m.push_back(m_id + 1);\n assign_t.push_back(t_id + 1);\n\n available_members.erase(available_members.begin() + best_m_idx);\n available_tasks.erase(available_tasks.begin() + best_t_idx);\n }\n\n cout << assign_m.size();\n for (size_t i = 0; i < assign_m.size(); ++i) cout << \" \" << assign_m[i] << \" \" << assign_t[i];\n cout << \"\\n\";\n cout.flush();\n\n int n_finished;\n cin >> n_finished;\n if (n_finished == -1) break;\n\n for (int i = 0; i < n_finished; ++i) {\n int f;\n cin >> f;\n --f;\n \n int t_id = members[f].current_task;\n int actual_time = day - members[f].start_day + 1;\n \n tasks[t_id].status = 1;\n completed_tasks++;\n members[f].current_task = -1;\n \n for (int v : tasks[t_id].rev_deps) in_degree[v]--;\n \n members[f].history.push_back({t_id, actual_time});\n \n double lr = 0.05;\n for (int iter = 0; iter < 30; ++iter) {\n for (const auto& hist : members[f].history) {\n int hid = hist.task_id;\n int htime = hist.actual_time;\n \n if (htime == 1) {\n for (int k = 0; k < K; ++k) members[f].s[k] = max(members[f].s[k], (double)tasks[hid].d[k]);\n continue;\n }\n \n double current_w = 0;\n vector active_k;\n for (int k = 0; k < K; ++k) {\n if (tasks[hid].d[k] > members[f].s[k]) {\n current_w += (tasks[hid].d[k] - members[f].s[k]);\n active_k.push_back(k);\n }\n }\n \n // Slightly correct bias\n double target_w = max(1.0, (double)htime - 1.0);\n if (htime <= 4) target_w *= 0.85;\n\n if (!active_k.empty()) {\n double error = current_w - target_w;\n double grad = error / active_k.size();\n for (int k : active_k) {\n members[f].s[k] += lr * grad;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n } else {\n for (int k = 0; k < K; ++k) {\n if (tasks[hid].d[k] > 0) {\n members[f].s[k] -= lr * target_w / K;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n }\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#pragma GCC optimize(\"O3\")\n#pragma GCC optimize(\"unroll-loops\")\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int NUM_ORDERS = 1000;\nconst int SELECTED_SIZE = 50;\nconst int PATH_SIZE = 100;\n\nstruct Order {\n int id;\n int a, b, c, d;\n int dist_to_center;\n};\n\nstruct Point {\n int x, y;\n};\n\ninline int manhattan(const Point& p1, const Point& p2) {\n return abs(p1.x - p2.x) + abs(p1.y - p2.y);\n}\n\nvector orders(NUM_ORDERS);\nmt19937 rng(42);\n\ndouble get_time(const chrono::time_point& start) {\n auto current_time = chrono::high_resolution_clock::now();\n return chrono::duration(current_time - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n for (int i = 0; i < NUM_ORDERS; ++i) {\n orders[i].id = i + 1;\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].dist_to_center = abs(orders[i].a - 400) + abs(orders[i].b - 400) + \n abs(orders[i].c - 400) + abs(orders[i].d - 400);\n }\n\n vector sorted_orders = orders;\n sort(sorted_orders.begin(), sorted_orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_to_center < o2.dist_to_center;\n });\n\n array active_orders;\n vector inactive_orders(NUM_ORDERS - SELECTED_SIZE);\n \n for (int i = 0; i < SELECTED_SIZE; ++i) active_orders[i] = sorted_orders[i].id - 1;\n for (int i = SELECTED_SIZE; i < NUM_ORDERS; ++i) inactive_orders[i - SELECTED_SIZE] = sorted_orders[i].id - 1;\n\n array path;\n array pos;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n path[2 * i] = i;\n path[2 * i + 1] = i + SELECTED_SIZE;\n pos[i] = 2 * i;\n pos[i + SELECTED_SIZE] = 2 * i + 1;\n }\n\n const Point center = {400, 400};\n\n auto get_point = [&](int node, const array& act) {\n if (node < SELECTED_SIZE) return Point{orders[act[node]].a, orders[act[node]].b};\n return Point{orders[act[node - SELECTED_SIZE]].c, orders[act[node - SELECTED_SIZE]].d};\n };\n\n auto eval_path = [&](const array& p, const array& act) {\n int dist = 0;\n Point curr = center;\n for (int i = 0; i < PATH_SIZE; ++i) {\n Point next = get_point(p[i], act);\n dist += manhattan(curr, next);\n curr = next;\n }\n dist += manhattan(curr, center);\n return dist;\n };\n\n int current_dist = eval_path(path, active_orders);\n int best_dist = current_dist;\n auto best_path = path;\n auto best_active = active_orders;\n\n double time_limit = 1.95;\n double t = 0;\n int iter = 0;\n\n uniform_real_distribution dist01(0.0, 1.0);\n\n auto check_valid = [&](int node) {\n if (node < SELECTED_SIZE) return pos[node] < pos[node + SELECTED_SIZE];\n else return pos[node - SELECTED_SIZE] < pos[node];\n };\n\n while (true) {\n if ((iter & 1023) == 0) {\n t = get_time(start_time);\n if (t >= time_limit) break;\n }\n iter++;\n \n double temp = 200.0 * (1.0 - t / time_limit);\n int type = rng() % 4;\n \n if (type == 0) { // Swap random\n int u = rng() % PATH_SIZE;\n int v = rng() % PATH_SIZE;\n if (u == v) continue;\n \n int n1 = path[u], n2 = path[v];\n swap(path[u], path[v]);\n pos[n1] = v; pos[n2] = u;\n \n if (check_valid(n1) && check_valid(n2)) {\n int new_dist = eval_path(path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n swap(path[u], path[v]);\n pos[n1] = u; pos[n2] = v;\n }\n } else {\n swap(path[u], path[v]);\n pos[n1] = u; pos[n2] = v;\n }\n } else if (type == 1) { // Order swap (Delta evaluated roughly)\n int act_idx = rng() % SELECTED_SIZE;\n int inact_idx = rng() % inactive_orders.size();\n \n int p_idx = pos[act_idx];\n int d_idx = pos[act_idx + SELECTED_SIZE];\n \n Point old_p = {orders[active_orders[act_idx]].a, orders[active_orders[act_idx]].b};\n Point old_d = {orders[active_orders[act_idx]].c, orders[active_orders[act_idx]].d};\n \n Point new_p = {orders[inactive_orders[inact_idx]].a, orders[inactive_orders[inact_idx]].b};\n Point new_d = {orders[inactive_orders[inact_idx]].c, orders[inactive_orders[inact_idx]].d};\n \n int old_order = active_orders[act_idx];\n active_orders[act_idx] = inactive_orders[inact_idx];\n \n int new_dist = eval_path(path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n inactive_orders[inact_idx] = old_order;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n active_orders[act_idx] = old_order;\n }\n } else if (type == 2) { // 2-opt\n int u = rng() % (PATH_SIZE - 1);\n int v = rng() % PATH_SIZE;\n if (u >= v) continue;\n \n bool valid = true;\n for (int i = u; i <= v; ++i) {\n int node = path[i];\n if (node < SELECTED_SIZE) {\n if (pos[node + SELECTED_SIZE] >= u && pos[node + SELECTED_SIZE] <= v) {\n valid = false;\n break;\n }\n }\n }\n if (!valid) continue;\n \n reverse(path.begin() + u, path.begin() + v + 1);\n for (int i = u; i <= v; ++i) pos[path[i]] = i;\n \n int new_dist = eval_path(path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n reverse(path.begin() + u, path.begin() + v + 1);\n for (int i = u; i <= v; ++i) pos[path[i]] = i;\n }\n } else { // Relocate (Insert)\n int u = rng() % PATH_SIZE;\n int v = rng() % PATH_SIZE;\n if (u == v) continue;\n \n int val = path[u];\n \n // Check validity before doing the shift\n int new_pos_val = v;\n int other = (val < SELECTED_SIZE) ? (val + SELECTED_SIZE) : (val - SELECTED_SIZE);\n int pos_other = pos[other];\n \n if (pos_other > u && pos_other <= v) pos_other--;\n else if (pos_other >= v && pos_other < u) pos_other++;\n \n if ((val < SELECTED_SIZE && new_pos_val > pos_other) ||\n (val >= SELECTED_SIZE && new_pos_val < pos_other)) {\n continue;\n }\n \n auto new_path = path;\n if (u < v) {\n for (int i = u; i < v; ++i) new_path[i] = new_path[i + 1];\n } else {\n for (int i = u; i > v; --i) new_path[i] = new_path[i - 1];\n }\n new_path[v] = val;\n \n int new_dist = eval_path(new_path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > dist01(rng)) {\n current_dist = new_dist;\n path = new_path;\n for (int i = min(u, v); i <= max(u, v); ++i) pos[path[i]] = i;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n }\n }\n }\n\n cout << SELECTED_SIZE;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n cout << \" \" << orders[best_active[i]].id;\n }\n cout << \"\\n\";\n\n vector final_route;\n final_route.push_back(center);\n for (int node : best_path) {\n final_route.push_back(get_point(node, best_active));\n }\n final_route.push_back(center);\n\n cout << final_route.size();\n for (const auto& p : final_route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Fast XorShift Random Number Generator\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline int rand_range(int L, int R) {\n return L + xor128() % (R - L + 1);\n}\n\n// Ultra-fast Array-based Disjoint Set Union\nstruct DSU {\n int parent[400];\n \n void init() {\n for (int i = 0; i < 400; ++i) {\n parent[i] = i;\n }\n }\n \n inline int find(int i) {\n int root = i;\n while (root != parent[root]) {\n root = parent[root];\n }\n int curr = i;\n while (curr != root) {\n int nxt = parent[curr];\n parent[curr] = root;\n curr = nxt;\n }\n return root;\n }\n \n inline bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\nstruct Edge {\n int id;\n int u;\n int v;\n int d; \n};\n\nstruct SimEdge {\n int weight;\n int id;\n int u;\n int v;\n bool operator<(const SimEdge& other) const {\n return weight < other.weight;\n }\n};\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = 400;\n int M = 1995;\n\n vector> points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n\n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v;\n edges[i].id = i;\n double dist = sqrt(pow(points[edges[i].u].first - points[edges[i].v].first, 2) + \n pow(points[edges[i].u].second - points[edges[i].v].second, 2));\n edges[i].d = round(dist);\n }\n\n DSU current_dsu;\n current_dsu.init();\n \n // Decreased simulation count to safely guarantee execution within 2.0s\n const int K = 8; \n\n vector future_edges;\n vector valid_future;\n future_edges.reserve(M);\n valid_future.reserve(M);\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n\n if (current_dsu.find(edges[i].u) == current_dsu.find(edges[i].v)) {\n cout << 0 << endl;\n continue;\n }\n\n // Pre-filter valid future edges to minimize sorting and processing overhead inside simulations\n valid_future.clear();\n for (int j = i + 1; j < M; ++j) {\n if (current_dsu.find(edges[j].u) != current_dsu.find(edges[j].v)) {\n valid_future.push_back(edges[j]);\n }\n }\n\n int accept_count = 0;\n \n for (int sim = 0; sim < K; ++sim) {\n future_edges.clear();\n future_edges.push_back({l, i, edges[i].u, edges[i].v});\n \n for (const auto& vf : valid_future) {\n future_edges.push_back({rand_range(vf.d, 3 * vf.d), vf.id, vf.u, vf.v});\n }\n\n sort(future_edges.begin(), future_edges.end());\n\n DSU temp_dsu;\n memcpy(temp_dsu.parent, current_dsu.parent, sizeof(int) * N);\n \n bool use_current = false;\n\n for (const auto& edge : future_edges) {\n if (temp_dsu.find(edge.u) != temp_dsu.find(edge.v)) {\n temp_dsu.unite(edge.u, edge.v);\n if (edge.id == i) {\n use_current = true;\n break; \n }\n } else if (edge.id == i) {\n break; \n }\n }\n if (use_current) accept_count++;\n }\n\n // Majority voting\n if (accept_count * 2 >= K) {\n current_dsu.unite(edges[i].u, edges[i].v);\n cout << 1 << endl;\n } else {\n cout << 0 << endl;\n }\n }\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nbool grid_passable[GRID_SIZE + 2][GRID_SIZE + 2];\nint pet_count[GRID_SIZE + 2][GRID_SIZE + 2];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\nchar move_dir[] = {'U', 'D', 'L', 'R'};\nchar block_dir[] = {'u', 'd', 'l', 'r'};\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y;\n};\n\nbool is_safe_to_block(int x, int y, const vector>& start_human_count, const vector>& next_human_count) {\n if (x < 1 || x > GRID_SIZE || y < 1 || y > GRID_SIZE) return false;\n if (!grid_passable[x][y]) return false;\n \n // Restrict wall building to a predefined grid pattern to avoid chaotic mazes\n if (x % 6 != 0 && y % 6 != 0) return false;\n\n // Cannot block if there was a human at the start of the turn, or if another human is moving there\n if (pet_count[x][y] > 0 || start_human_count[x][y] > 0 || next_human_count[x][y] > 0) return false;\n \n // Cannot block if any adjacent square contains a pet\n for (int i = 0; i < 4; ++i) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n if (nx >= 1 && nx <= GRID_SIZE && ny >= 1 && ny <= GRID_SIZE) {\n if (pet_count[nx][ny] > 0) return false;\n }\n }\n return true;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n grid_passable[i][j] = true;\n }\n }\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector pets(N);\n for (int i = 0; i < N; ++i) {\n cin >> pets[i].x >> pets[i].y >> pets[i].type;\n pet_count[pets[i].x][pets[i].y]++;\n }\n\n int M;\n cin >> M;\n vector humans(M);\n for (int i = 0; i < M; ++i) {\n cin >> humans[i].x >> humans[i].y;\n }\n\n mt19937 rng(42);\n\n for (int turn = 0; turn < 300; ++turn) {\n vector> start_human_count(GRID_SIZE + 2, vector(GRID_SIZE + 2, 0));\n for (int i = 0; i < M; ++i) {\n start_human_count[humans[i].x][humans[i].y]++;\n }\n \n vector> next_human_count(GRID_SIZE + 2, vector(GRID_SIZE + 2, 0));\n string action = \"\";\n\n for (int i = 0; i < M; ++i) {\n bool acted = false;\n \n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n \n // Try to block randomly\n for (int d : dirs) {\n int nx = humans[i].x + dx[d];\n int ny = humans[i].y + dy[d];\n if (is_safe_to_block(nx, ny, start_human_count, next_human_count)) {\n action += block_dir[d];\n grid_passable[nx][ny] = false;\n next_human_count[humans[i].x][humans[i].y]++; // Human stays in place\n acted = true;\n break;\n }\n }\n \n // Try to move\n if (!acted) {\n for (int d : dirs) {\n int nx = humans[i].x + dx[d];\n int ny = humans[i].y + dy[d];\n if (nx >= 1 && nx <= GRID_SIZE && ny >= 1 && ny <= GRID_SIZE && grid_passable[nx][ny]) {\n humans[i].x = nx;\n humans[i].y = ny;\n next_human_count[nx][ny]++;\n action += move_dir[d];\n acted = true;\n break;\n }\n }\n }\n \n if (!acted) {\n next_human_count[humans[i].x][humans[i].y]++;\n action += \".\";\n }\n }\n cout << action << \"\\n\";\n cout.flush();\n\n // Reset pet counts\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n pet_count[i][j] = 0;\n }\n }\n\n // Read pet moves\n for (int i = 0; i < N; ++i) {\n string pet_move;\n cin >> pet_move;\n if (pet_move != \".\") {\n for (char c : pet_move) {\n if (c == 'U') pets[i].x--;\n else if (c == 'D') pets[i].x++;\n else if (c == 'L') pets[i].y--;\n else if (c == 'R') pets[i].y++;\n }\n }\n pet_count[pets[i].x][pets[i].y]++;\n }\n }\n\n return 0;\n}","ahc009":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint si, sj, ti, tj;\ndouble p;\nstring h[N], v[N - 1];\n\ndouble V[205][400];\nint adj[400][4];\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nbool can_move(int i, int j, int d) {\n if (d == 0) return i > 0 && v[i - 1][j] == '0';\n if (d == 1) return i < N - 1 && v[i][j] == '0';\n if (d == 2) return j > 0 && h[i][j - 1] == '0';\n if (d == 3) return j < N - 1 && h[i][j] == '0';\n return false;\n}\n\nvoid precompute() {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = i * N + j;\n for (int d = 0; d < 4; ++d) {\n if (can_move(i, j, d)) {\n adj[u][d] = (i + di[d]) * N + (j + dj[d]);\n } else {\n adj[u][d] = u;\n }\n }\n }\n }\n\n int target = ti * N + tj;\n\n for (int u = 0; u < 400; ++u) V[0][u] = 0.0;\n\n for (int rem = 1; rem <= 200; ++rem) {\n for (int u = 0; u < 400; ++u) {\n if (u == target) {\n V[rem][u] = 0.0;\n continue;\n }\n double best_val = -1.0;\n for (int d = 0; d < 4; ++d) {\n double val = 0.0;\n int nxt = adj[u][d];\n if (nxt == target) {\n val = p * V[rem - 1][u] + (1.0 - p) * (200 + rem);\n } else {\n val = p * V[rem - 1][u] + (1.0 - p) * V[rem - 1][nxt];\n }\n if (val > best_val) best_val = val;\n }\n V[rem][u] = best_val;\n }\n }\n}\n\nstruct State {\n double prob[400];\n vector active;\n int parent;\n char move;\n double current_score;\n double eval_score;\n\n bool operator<(const State& other) const {\n return eval_score > other.eval_score; \n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n for (int i = 0; i < N; ++i) cin >> h[i];\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n precompute();\n\n vector> history(201);\n \n State initial_state;\n int start_u = si * N + sj;\n initial_state.prob[start_u] = 1.0;\n initial_state.active.push_back(start_u);\n initial_state.parent = -1;\n initial_state.move = ' ';\n initial_state.current_score = 0.0;\n initial_state.eval_score = V[200][start_u];\n \n history[0].push_back(initial_state);\n\n int beam_width = 350; \n int target = ti * N + tj;\n bool in_active[400] = {false};\n\n for (int step = 1; step <= 200; ++step) {\n vector& prev_beam = history[step - 1];\n vector& curr_beam = history[step];\n curr_beam.reserve(prev_beam.size() * 4);\n\n for (int p_idx = 0; p_idx < prev_beam.size(); ++p_idx) {\n const auto& state = prev_beam[p_idx];\n for (int d = 0; d < 4; ++d) {\n State next_state;\n next_state.parent = p_idx;\n next_state.move = dir_char[d];\n next_state.current_score = state.current_score;\n \n for (int u : state.active) {\n next_state.prob[u] = 0.0;\n next_state.prob[adj[u][d]] = 0.0;\n }\n\n for (int u : state.active) {\n double pr = state.prob[u];\n int nxt = adj[u][d];\n \n if (nxt == target && u != target) {\n next_state.current_score += pr * (1.0 - p) * (401 - step);\n next_state.prob[u] += pr * p;\n } else if (nxt == u) {\n next_state.prob[u] += pr;\n } else {\n next_state.prob[nxt] += pr * (1.0 - p);\n next_state.prob[u] += pr * p;\n }\n }\n\n next_state.eval_score = next_state.current_score;\n for (int u : state.active) {\n if (next_state.prob[u] > 1e-9 && !in_active[u]) {\n next_state.active.push_back(u);\n in_active[u] = true;\n }\n int nxt = adj[u][d];\n if (nxt != u && next_state.prob[nxt] > 1e-9 && !in_active[nxt]) {\n next_state.active.push_back(nxt);\n in_active[nxt] = true;\n }\n }\n \n for (int u : next_state.active) {\n next_state.eval_score += next_state.prob[u] * V[200 - step][u];\n in_active[u] = false; \n }\n \n curr_beam.push_back(next_state);\n }\n }\n\n int keep = min((int)curr_beam.size(), beam_width);\n partial_sort(curr_beam.begin(), curr_beam.begin() + keep, curr_beam.end());\n curr_beam.resize(keep);\n }\n\n string ans = \"\";\n int curr_step = 200;\n int curr_idx = 0;\n\n while (curr_step > 0) {\n ans += history[curr_step][curr_idx].move;\n curr_idx = history[curr_step][curr_idx].parent;\n curr_step--;\n }\n \n reverse(ans.begin(), ans.end());\n cout << ans << \"\\n\";\n \n return 0;\n}","ahc010":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst vector> TILE_EDGES[8] = {\n {{0, 1}},\n {{0, 3}},\n {{2, 3}},\n {{1, 2}},\n {{0, 1}, {2, 3}},\n {{0, 3}, {1, 2}},\n {{0, 2}},\n {{1, 3}}\n};\n\nint rot(int t, int r) {\n if (t >= 0 && t <= 3) return (t + r) % 4;\n if (t >= 4 && t <= 5) return 4 + (t - 4 + r) % 2;\n if (t >= 6 && t <= 7) return 6 + (t - 6 + r) % 2;\n return t;\n}\n\nint base_grid[30][30];\nint cur_grid[30][30];\nint cur_rot[30][30];\n\nint port_id[30][30][4];\nint total_ports = 0;\n\nint dsu_parent[2000];\nint dsu_sz[2000];\nbool dsu_cycle[2000];\n\nint find_set(int v) {\n if (v == dsu_parent[v]) return v;\n return dsu_parent[v] = find_set(dsu_parent[v]);\n}\n\nstruct EvalResult {\n long long real_score;\n double search_score;\n};\n\nEvalResult evaluate() {\n for (int i = 0; i < total_ports; i++) {\n dsu_parent[i] = i;\n dsu_sz[i] = 0;\n dsu_cycle[i] = false;\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n int t = cur_grid[i][j];\n for (auto edge : TILE_EDGES[t]) {\n int p1 = port_id[i][j][edge.first];\n int p2 = port_id[i][j][edge.second];\n int r1 = find_set(p1);\n int r2 = find_set(p2);\n\n if (r1 == r2) {\n dsu_cycle[r1] = true;\n dsu_sz[r1]++;\n } else {\n dsu_parent[r1] = r2;\n dsu_sz[r2] += dsu_sz[r1] + 1;\n dsu_cycle[r2] |= dsu_cycle[r1];\n }\n }\n }\n }\n\n int l1 = 0, l2 = 0;\n vector vals;\n double sum_sq = 0.0;\n\n for (int i = 0; i < total_ports; i++) {\n if (dsu_parent[i] == i && dsu_sz[i] > 0) {\n long long s = dsu_sz[i];\n double v;\n if (dsu_cycle[i]) {\n if (s > l1) {\n l2 = l1;\n l1 = s;\n } else if (s > l2) {\n l2 = s;\n }\n v = (double)s;\n } else {\n v = (double)s * 0.5;\n }\n vals.push_back(v);\n sum_sq += v * v;\n }\n }\n\n long long real_score = (long long)l1 * l2;\n\n double v0 = 0, v1 = 0;\n if (vals.size() >= 1) {\n // Find top 2 values manually for speed\n for (double v : vals) {\n if (v > v0) {\n v1 = v0;\n v0 = v;\n } else if (v > v1) {\n v1 = v;\n }\n }\n }\n\n double search_score = (v0 * v1) + (0.0001 * sum_sq);\n\n return {real_score, search_score};\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ndouble rnd() {\n return (double)(xor128() & 0xFFFFFF) / 16777216.0;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start = chrono::high_resolution_clock::now();\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n base_grid[i][j] = s[j] - '0';\n cur_grid[i][j] = base_grid[i][j];\n cur_rot[i][j] = 0;\n }\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) port_id[i][j][d] = -1;\n }\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n if (j < 29) {\n port_id[i][j][2] = total_ports;\n port_id[i][j + 1][0] = total_ports;\n total_ports++;\n } else port_id[i][j][2] = total_ports++;\n if (j == 0) port_id[i][j][0] = total_ports++;\n\n if (i < 29) {\n port_id[i][j][3] = total_ports;\n port_id[i + 1][j][1] = total_ports;\n total_ports++;\n } else port_id[i][j][3] = total_ports++;\n if (i == 0) port_id[i][j][1] = total_ports++;\n }\n }\n\n EvalResult initial_eval = evaluate();\n long long best_real_score = initial_eval.real_score;\n double current_search_score = initial_eval.search_score;\n \n int best_rot[30][30];\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n best_rot[i][j] = cur_rot[i][j];\n }\n }\n\n double time_limit = 1.95;\n double T0 = 50.0;\n double T1 = 0.5;\n double T = T0;\n int iters = 0;\n \n while (true) {\n if ((iters & 255) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > time_limit) break;\n double progress = elapsed / time_limit;\n T = T0 * pow(T1 / T0, progress);\n }\n iters++;\n\n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) % 4;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n EvalResult res = evaluate();\n \n bool accept = false;\n if (res.search_score >= current_search_score) {\n accept = true;\n } else {\n double diff = res.search_score - current_search_score;\n if (rnd() < exp(diff / T)) {\n accept = true;\n }\n }\n\n if (accept) {\n current_search_score = res.search_score;\n if (res.real_score > best_real_score) {\n best_real_score = res.real_score;\n for (int r_idx = 0; r_idx < 30; r_idx++) {\n for (int c_idx = 0; c_idx < 30; c_idx++) {\n best_rot[r_idx][c_idx] = cur_rot[r_idx][c_idx];\n }\n }\n }\n } else {\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n }\n }\n cout << \"\\n\";\n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nint N, T;\nuint8_t initial_board[100];\nint init_empty_r, init_empty_c;\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dir_char[] = {'U', 'D', 'L', 'R'};\nconst char opp_dir[] = {'D', 'U', 'R', 'L'};\n\nint time_limit_ms = 2850;\n\nuint64_t zobrist[100][16];\n\nvoid init_zobrist() {\n mt19937_64 rng(1337);\n for (int i = 0; i < 100; ++i) {\n for (int j = 0; j < 16; ++j) {\n zobrist[i][j] = rng();\n }\n }\n}\n\nint get_eval(const uint8_t* b, int& max_tree_size) {\n int parent[100];\n int sz[100];\n int edges_cnt[100];\n int broken = 0;\n int valid = 0;\n\n int N2 = N * N;\n for (int i = 0; i < N2; ++i) {\n parent[i] = i;\n sz[i] = 1;\n edges_cnt[i] = 0;\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = r * N + c;\n if (b[u] == 0) continue;\n\n // Penalize branches pointing outside the board\n if (r == 0 && (b[u] & 2)) broken += 3;\n if (r == N - 1 && (b[u] & 8)) broken += 3;\n if (c == 0 && (b[u] & 1)) broken += 3;\n if (c == N - 1 && (b[u] & 4)) broken += 3;\n\n if (r < N - 1 && b[u + N] != 0) {\n bool down = b[u] & 8;\n bool up = b[u + N] & 2;\n if (down && up) {\n valid++;\n int root_u = u, root_v = u + N;\n while (parent[root_u] != root_u) root_u = parent[root_u];\n while (parent[root_v] != root_v) root_v = parent[root_v];\n if (root_u != root_v) {\n parent[root_u] = root_v;\n sz[root_v] += sz[root_u];\n edges_cnt[root_v] += edges_cnt[root_u] + 1;\n } else {\n edges_cnt[root_u]++;\n }\n } else if (down || up) {\n broken++;\n }\n }\n if (c < N - 1 && b[u + 1] != 0) {\n bool right = b[u] & 4;\n bool left = b[u + 1] & 1;\n if (right && left) {\n valid++;\n int root_u = u, root_v = u + 1;\n while (parent[root_u] != root_u) root_u = parent[root_u];\n while (parent[root_v] != root_v) root_v = parent[root_v];\n if (root_u != root_v) {\n parent[root_u] = root_v;\n sz[root_v] += sz[root_u];\n edges_cnt[root_v] += edges_cnt[root_u] + 1;\n } else {\n edges_cnt[root_u]++;\n }\n } else if (right || left) {\n broken++;\n }\n }\n }\n }\n\n max_tree_size = 0;\n for (int i = 0; i < N2; ++i) {\n if (parent[i] == i && b[i] != 0) {\n if (edges_cnt[i] == sz[i] - 1) {\n if (sz[i] > max_tree_size) {\n max_tree_size = sz[i];\n }\n }\n }\n }\n\n return max_tree_size * 10000 + valid * 20 - broken * 6;\n}\n\nstruct State {\n uint8_t b[100];\n uint8_t er, ec;\n int score;\n int tree_size;\n uint64_t hash;\n int hist_id;\n\n bool operator<(const State& o) const {\n return score > o.score;\n }\n};\n\nstruct HistNode {\n int parent;\n char move;\n};\nvector history;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n init_zobrist();\n\n if (!(cin >> N >> T)) return 0;\n\n history.reserve(2000000);\n\n uint64_t init_hash = 0;\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (s[j] >= '0' && s[j] <= '9') initial_board[idx] = s[j] - '0';\n else initial_board[idx] = s[j] - 'a' + 10;\n \n init_hash ^= zobrist[idx][initial_board[idx]];\n \n if (initial_board[idx] == 0) {\n init_empty_r = i;\n init_empty_c = j;\n }\n }\n }\n\n int best_tree_size = 0;\n int best_hist_id = -1;\n\n int initial_tree_size = 0;\n int initial_score = get_eval(initial_board, initial_tree_size);\n best_tree_size = initial_tree_size;\n\n vector beam;\n State init_state;\n copy(initial_board, initial_board + 100, init_state.b);\n init_state.er = init_empty_r;\n init_state.ec = init_empty_c;\n init_state.score = initial_score;\n init_state.tree_size = initial_tree_size;\n init_state.hash = init_hash;\n init_state.hist_id = -1;\n beam.push_back(init_state);\n\n int beam_width = (N <= 7) ? 2500 : 1500;\n unordered_set visited;\n visited.insert(init_hash);\n\n for (int step = 0; step < T; ++step) {\n if ((step & 15) == 0) {\n auto current_time = high_resolution_clock::now();\n if (duration_cast(current_time - start_time).count() > time_limit_ms) {\n break;\n }\n }\n\n vector next_beam;\n next_beam.reserve(beam.size() * 4);\n\n for (const auto& state : beam) {\n char last_move = (state.hist_id == -1) ? 'X' : history[state.hist_id].move;\n\n for (int d = 0; d < 4; ++d) {\n if (last_move == opp_dir[d]) continue;\n\n int nr = state.er + dr[d];\n int nc = state.ec + dc[d];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int u = state.er * N + state.ec;\n int v = nr * N + nc;\n \n uint64_t next_hash = state.hash;\n next_hash ^= zobrist[u][state.b[u]] ^ zobrist[u][state.b[v]];\n next_hash ^= zobrist[v][state.b[v]] ^ zobrist[v][state.b[u]];\n\n if (visited.find(next_hash) != visited.end()) continue;\n\n State next_state = state;\n swap(next_state.b[u], next_state.b[v]);\n next_state.er = nr;\n next_state.ec = nc;\n next_state.hash = next_hash;\n \n int new_hist_id = history.size();\n history.push_back({state.hist_id, dir_char[d]});\n next_state.hist_id = new_hist_id;\n\n next_state.score = get_eval(next_state.b, next_state.tree_size);\n next_beam.push_back(move(next_state));\n visited.insert(next_hash);\n }\n }\n }\n\n sort(next_beam.begin(), next_beam.end());\n if (next_beam.size() > beam_width) {\n next_beam.resize(beam_width);\n }\n\n beam = move(next_beam);\n\n if (!beam.empty() && beam[0].tree_size > best_tree_size) {\n best_tree_size = beam[0].tree_size;\n best_hist_id = beam[0].hist_id;\n }\n \n if (visited.size() > 800000) {\n visited.clear();\n }\n }\n\n string best_moves = \"\";\n int curr = best_hist_id;\n while (curr != -1) {\n best_moves += history[curr].move;\n curr = history[curr].parent;\n }\n reverse(best_moves.begin(), best_moves.end());\n\n cout << best_moves << \"\\n\";\n\n return 0;\n}","ahc012":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef unsigned __int128 u128;\n\nconst int K = 100;\nint N;\nint a[11];\nint x_coords[10005];\nint y_coords[10005];\n\nstruct Line {\n double theta;\n double r;\n};\n\nLine lines[K];\nu128 hashes[10005];\nu128 sorted_hashes[10005];\n\npair, pair> get_points(const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n double px = l.r * cos_t - 20000.0 * sin_t;\n double py = l.r * sin_t + 20000.0 * cos_t;\n double qx = l.r * cos_t + 20000.0 * sin_t;\n double qy = l.r * sin_t - 20000.0 * cos_t;\n return {{round(px), round(py)}, {round(qx), round(qy)}};\n}\n\n// Fast PRNG\nuint64_t xorshift64_state = 0x8817264546332525ULL;\ninline uint64_t xorshift64() {\n xorshift64_state ^= xorshift64_state << 13;\n xorshift64_state ^= xorshift64_state >> 7;\n xorshift64_state ^= xorshift64_state << 17;\n return xorshift64_state;\n}\n\ninline double fast_rand_double() {\n return (xorshift64() >> 11) * (1.0 / 9007199254740992.0);\n}\n\nint evaluate() {\n memcpy(sorted_hashes, hashes, N * sizeof(u128));\n std::sort(sorted_hashes, sorted_hashes + N);\n\n int b[11] = {0};\n int current_count = 1;\n for (int i = 1; i < N; ++i) {\n if (sorted_hashes[i] == sorted_hashes[i - 1]) {\n current_count++;\n } else {\n if (current_count <= 10) {\n b[current_count]++;\n }\n current_count = 1;\n }\n }\n if (current_count <= 10) {\n b[current_count]++;\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n // Base score mapped to 1000\n score += min(a[d], b[d]) * 1000;\n // Secondary tie-breaker: slight reward for making ANY pieces of size <= 10\n // even if we already exceeded the requirement a[d]\n if (b[d] > a[d]) {\n score += 2;\n }\n }\n return score;\n}\n\nvoid update_line_hash(int line_idx, const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n u128 mask = ((u128)1) << line_idx;\n u128 not_mask = ~mask;\n \n for (int i = 0; i < N; ++i) {\n if (x_coords[i] * cos_t + y_coords[i] * sin_t > l.r) hashes[i] |= mask;\n else hashes[i] &= not_mask;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int max_k;\n if (!(cin >> N >> max_k)) return 0;\n\n int total_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n total_a += a[i];\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> x_coords[i] >> y_coords[i];\n }\n\n for (int i = 0; i < K; ++i) {\n lines[i].theta = fast_rand_double() * M_PI;\n lines[i].r = fast_rand_double() * 19800.0 - 9900.0;\n update_line_hash(i, lines[i]);\n }\n\n int current_score = evaluate();\n int best_score = current_score;\n \n Line best_lines[K];\n for(int i = 0; i < K; ++i) best_lines[i] = lines[i];\n\n auto start_time = chrono::high_resolution_clock::now();\n double time_limit = 2.95;\n\n // Temperatures scaled up by 1000 to match the new objective scaling\n double t0 = 1200.0;\n double t1 = 10.0;\n double temp = t0;\n \n int iter = 0;\n while (true) {\n if ((iter & 255) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n temp = t0 * pow(t1 / t0, progress);\n }\n\n int idx = xorshift64() % K;\n Line old_line = lines[idx];\n\n if (xorshift64() % 6 == 0) {\n lines[idx].theta = fast_rand_double() * M_PI;\n lines[idx].r = fast_rand_double() * 19800.0 - 9900.0;\n } else {\n double d_theta = (fast_rand_double() + fast_rand_double() - 1.0) * 0.05;\n double d_r = (fast_rand_double() + fast_rand_double() - 1.0) * 200.0;\n lines[idx].theta += d_theta;\n lines[idx].r += d_r;\n }\n \n update_line_hash(idx, lines[idx]);\n int new_score = evaluate();\n\n bool accept = false;\n if (new_score >= current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (fast_rand_double() < prob) accept = true;\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n for(int i = 0; i < K; ++i) best_lines[i] = lines[i];\n }\n } else {\n lines[idx] = old_line;\n update_line_hash(idx, lines[idx]);\n }\n \n iter++;\n }\n\n cout << K << \"\\n\";\n for (int i = 0; i < K; ++i) {\n auto pts = get_points(best_lines[i]);\n cout << pts.first.first << \" \" << pts.first.second << \" \" \n << pts.second.first << \" \" << pts.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int MAXN = 65;\n\nstruct Point {\n int x, y;\n bool operator==(const Point& o) const { return x == o.x && y == o.y; }\n};\n\nstruct Move {\n Point p1, p2, p3, p4;\n};\n\nint N, M;\nPoint center;\nvector initial_dots;\nint weight[MAXN][MAXN];\n\ndouble get_time() {\n static auto start = high_resolution_clock::now();\n return duration(high_resolution_clock::now() - start).count();\n}\n\nstruct State {\n bool has_dot[MAXN][MAXN];\n int edges[4][MAXN][MAXN]; \n vector dots;\n vector moves;\n int score;\n\n State() {\n for (int i = 0; i < MAXN; ++i) {\n for (int j = 0; j < MAXN; ++j) {\n has_dot[i][j] = false;\n for (int k = 0; k < 4; ++k) edges[k][i][j] = 0;\n }\n }\n score = 0;\n }\n\n void add_dot(Point p) {\n has_dot[p.x][p.y] = true;\n dots.push_back(p);\n score += weight[p.x][p.y];\n }\n\n bool inside(int x, int y) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n\n bool check_edge(Point p1, Point p2) const {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n if (dx != 0 && dy != 0 && abs(dx) != abs(dy)) return false;\n \n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = (step_y == 0) ? 0 : ((step_x == 0) ? 1 : ((step_x == step_y) ? 2 : 3));\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n if (edges[type][ex][ey]) return false;\n if ((cx != p1.x || cy != p1.y) && has_dot[cx][cy]) return false;\n cx = nx; cy = ny;\n }\n return true;\n }\n\n void mark_edge(Point p1, Point p2, int val) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = (step_y == 0) ? 0 : ((step_x == 0) ? 1 : ((step_x == step_y) ? 2 : 3));\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = min(cx, nx), ey = min(cy, ny);\n if (type == 3) { ex = min(cx, nx); ey = max(cy, ny); }\n edges[type][ex][ey] += val;\n cx = nx; cy = ny;\n }\n }\n\n bool is_valid_rect(Point p1, Point p2, Point p3, Point p4) const {\n if (!inside(p1.x, p1.y) || !inside(p2.x, p2.y) || !inside(p3.x, p3.y) || !inside(p4.x, p4.y)) return false;\n if (has_dot[p1.x][p1.y]) return false;\n if (!has_dot[p2.x][p2.y] || !has_dot[p3.x][p3.y] || !has_dot[p4.x][p4.y]) return false;\n if (!check_edge(p1, p2) || !check_edge(p2, p3) || !check_edge(p3, p4) || !check_edge(p4, p1)) return false;\n return true;\n }\n\n void apply_move(const Move& m) {\n add_dot(m.p1);\n mark_edge(m.p1, m.p2, 1);\n mark_edge(m.p2, m.p3, 1);\n mark_edge(m.p3, m.p4, 1);\n mark_edge(m.p4, m.p1, 1);\n moves.push_back(m);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n center = {(N - 1) / 2, (N - 1) / 2};\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n weight[i][j] = (i - center.x) * (i - center.x) + (j - center.y) * (j - center.y) + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_dots.push_back({x, y});\n }\n\n State best_state;\n best_state.score = -1;\n \n uint32_t seed = 987654321;\n auto rand_u32 = [&]() -> uint32_t {\n seed ^= seed << 13;\n seed ^= seed >> 17;\n seed ^= seed << 5;\n return seed;\n };\n\n while (get_time() < 4.8) {\n State state;\n for (auto p : initial_dots) state.add_dot(p);\n\n bool moved = true;\n while (moved && get_time() < 4.8) {\n moved = false;\n vector candidates;\n\n int num_dots = state.dots.size();\n for (int i = 0; i < num_dots; ++i) {\n for (int j = i + 1; j < num_dots; ++j) {\n Point p2 = state.dots[i];\n Point p4 = state.dots[j];\n \n if (p2.x != p4.x && p2.y != p4.y) {\n Point p1 = {p2.x, p4.y};\n Point p3 = {p4.x, p2.y};\n \n if (state.inside(p1.x, p1.y) && state.inside(p3.x, p3.y)) {\n if (!state.has_dot[p1.x][p1.y] && state.has_dot[p3.x][p3.y]) {\n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n }\n if (state.has_dot[p1.x][p1.y] && !state.has_dot[p3.x][p3.y]) {\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n }\n }\n }\n\n int sum2 = p2.x + p2.y;\n int diff4 = p4.x - p4.y;\n int sum4 = p4.x + p4.y;\n int diff2 = p2.x - p2.y;\n\n if ((sum2 + diff4) % 2 == 0 && (sum4 + diff2) % 2 == 0) {\n Point p1 = {(sum2 + diff4) / 2, (sum2 - diff4) / 2};\n Point p3 = {(sum4 + diff2) / 2, (sum4 - diff2) / 2};\n\n if (!(p1 == p2) && !(p1 == p4) && !(p3 == p2) && !(p3 == p4)) {\n if (state.inside(p1.x, p1.y) && state.inside(p3.x, p3.y)) {\n if (!state.has_dot[p1.x][p1.y] && state.has_dot[p3.x][p3.y]) {\n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n }\n if (state.has_dot[p1.x][p1.y] && !state.has_dot[p3.x][p3.y]) {\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n }\n }\n }\n }\n }\n }\n\n if (!candidates.empty()) {\n Move best_m = candidates[0];\n int best_val = -1;\n for (const auto& m : candidates) {\n int val = weight[m.p1.x][m.p1.y] * 10 + (rand_u32() % 100); \n if (val > best_val) {\n best_val = val;\n best_m = m;\n }\n }\n state.apply_move(best_m);\n moved = true;\n }\n }\n\n if (state.score > best_state.score) {\n best_state = state;\n }\n }\n\n cout << best_state.moves.size() << \"\\n\";\n for (const auto& m : best_state.moves) {\n cout << m.p1.x << \" \" << m.p1.y << \" \" \n << m.p2.x << \" \" << m.p2.y << \" \" \n << m.p3.x << \" \" << m.p3.y << \" \" \n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Board {\n uint8_t grid[10][10] = {0};\n\n inline void add_candy(uint8_t flavor, int p) {\n int empty_count = 0;\n uint8_t* ptr = &grid[0][0];\n for (int i = 0; i < 100; ++i) {\n if (ptr[i] == 0) {\n empty_count++;\n if (empty_count == p) {\n ptr[i] = flavor;\n return;\n }\n }\n }\n }\n\n inline void add_random_candy(uint8_t flavor, uint32_t rnd_val) {\n int empty_pos[100];\n int empty_cnt = 0;\n uint8_t* ptr = &grid[0][0];\n for (int i = 0; i < 100; ++i) {\n if (ptr[i] == 0) {\n empty_pos[empty_cnt++] = i;\n }\n }\n if (empty_cnt > 0) {\n ptr[empty_pos[rnd_val % empty_cnt]] = flavor;\n }\n }\n\n // 0: F, 1: B, 2: L, 3: R\n inline bool tilt(int dir) {\n bool changed = false;\n if (dir == 0) { // F\n for (int c = 0; c < 10; ++c) {\n int write_idx = 0;\n for (int r = 0; r < 10; ++r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 1) { // B\n for (int c = 0; c < 10; ++c) {\n int write_idx = 9;\n for (int r = 9; r >= 0; --r) {\n if (grid[r][c] != 0) {\n if (r != write_idx) {\n grid[write_idx][c] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n } else if (dir == 2) { // L\n for (int r = 0; r < 10; ++r) {\n int write_idx = 0;\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 3) { // R\n for (int r = 0; r < 10; ++r) {\n int write_idx = 9;\n for (int c = 9; c >= 0; --c) {\n if (grid[r][c] != 0) {\n if (c != write_idx) {\n grid[r][write_idx] = grid[r][c];\n grid[r][c] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n }\n return changed;\n }\n\n inline int calc_score() const {\n bool vis[10][10] = {false};\n int score = 0;\n int q[100];\n \n for (int r = 0; r < 10; ++r) {\n for (int c = 0; c < 10; ++c) {\n if (grid[r][c] != 0 && !vis[r][c]) {\n uint8_t flavor = grid[r][c];\n int sz = 0;\n int head = 0, tail = 0;\n \n q[tail++] = r * 10 + c;\n vis[r][c] = true;\n \n while (head < tail) {\n int pos = q[head++];\n int cr = pos / 10;\n int cc = pos % 10;\n sz++;\n \n if (cr > 0 && !vis[cr - 1][cc] && grid[cr - 1][cc] == flavor) {\n vis[cr - 1][cc] = true;\n q[tail++] = (cr - 1) * 10 + cc;\n }\n if (cr < 9 && !vis[cr + 1][cc] && grid[cr + 1][cc] == flavor) {\n vis[cr + 1][cc] = true;\n q[tail++] = (cr + 1) * 10 + cc;\n }\n if (cc > 0 && !vis[cr][cc - 1] && grid[cr][cc - 1] == flavor) {\n vis[cr][cc - 1] = true;\n q[tail++] = cr * 10 + (cc - 1);\n }\n if (cc < 9 && !vis[cr][cc + 1] && grid[cr][cc + 1] == flavor) {\n vis[cr][cc + 1] = true;\n q[tail++] = cr * 10 + (cc + 1);\n }\n }\n score += sz * sz;\n }\n }\n }\n return score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto global_start = high_resolution_clock::now();\n\n uint8_t f[100];\n for (int i = 0; i < 100; ++i) {\n int temp;\n cin >> temp;\n f[i] = temp;\n }\n\n Board b;\n uint32_t rng_state = 123456789;\n auto rand_int = [&rng_state]() -> uint32_t {\n rng_state ^= rng_state << 13;\n rng_state ^= rng_state >> 17;\n rng_state ^= rng_state << 5;\n return rng_state;\n };\n\n char dir_chars[] = {'F', 'B', 'L', 'R'};\n\n for (int t = 1; t <= 100; ++t) {\n int p;\n cin >> p;\n b.add_candy(f[t - 1], p);\n\n if (t == 100) break;\n\n auto step_start = high_resolution_clock::now();\n double elapsed_total = duration_cast(step_start - global_start).count();\n double time_limit = (1950.0 - elapsed_total) / (101 - t);\n \n long long total_score[4] = {0};\n int playouts[4] = {0};\n bool valid[4] = {false};\n Board next_b[4];\n\n for (int d = 0; d < 4; ++d) {\n next_b[d] = b;\n valid[d] = next_b[d].tilt(d);\n }\n\n int loop_count = 0;\n while (true) {\n if ((++loop_count & 127) == 0) {\n auto now = high_resolution_clock::now();\n if (duration_cast(now - step_start).count() > time_limit) {\n break;\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n if (!valid[d]) continue;\n Board sim_b = next_b[d];\n for (int sim_t = t + 1; sim_t <= 100; ++sim_t) {\n sim_b.add_random_candy(f[sim_t - 1], rand_int());\n if (sim_t < 100) {\n sim_b.tilt(rand_int() % 4);\n }\n }\n total_score[d] += sim_b.calc_score();\n playouts[d]++;\n }\n }\n\n int best_dir = -1;\n double best_avg = -1.0;\n for (int d = 0; d < 4; ++d) {\n if (playouts[d] > 0) {\n double avg = (double)total_score[d] / playouts[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_dir = d;\n }\n }\n }\n\n if (best_dir == -1) {\n best_dir = rand_int() % 4;\n }\n\n b.tilt(best_dir);\n cout << dir_chars[best_dir] << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc016":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Function to compute the standard normal CDF\ndouble normal_cdf(double x) {\n return 0.5 * erfc(-x / sqrt(2.0));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n\n int best_N = 100;\n double best_expected_score = -1.0;\n\n // Search for the optimal N that maximizes expected score\n for (int n = 4; n <= 100; ++n) {\n int v = n * (n - 1) / 2;\n double expected_errors = 0.0;\n \n if (eps == 0.0) {\n if (v >= M - 1) {\n expected_errors = 0.0;\n } else {\n expected_errors = 100.0; // Complete failure if not enough states\n }\n } else {\n double gap = (double)v * (1.0 - 2.0 * eps) / max(1, M - 1);\n double stddev = sqrt(v * eps * (1.0 - eps));\n \n // Expected error rate for an inner distribution (has neighbors on both sides)\n // Error happens if noise moves it more than gap/2 away\n double p_error = 2.0 * (1.0 - normal_cdf((gap / 2.0) / stddev));\n \n // Adjust for boundary elements which only have 1 neighbor\n double boundary_p_error = 1.0 - normal_cdf((gap / 2.0) / stddev);\n \n double total_p_error = (2.0 * boundary_p_error + max(0, M - 2) * p_error) / M;\n expected_errors = 100.0 * total_p_error;\n }\n\n double expected_score = pow(0.9, expected_errors) / n;\n \n if (expected_score > best_expected_score) {\n best_expected_score = expected_score;\n best_N = n;\n }\n }\n\n int N = best_N;\n int V = N * (N - 1) / 2;\n \n // Choose edge counts for each of the M graphs evenly spaced from 0 to V\n vector target_edges(M);\n for (int i = 0; i < M; ++i) {\n if (M == 1) {\n target_edges[i] = V / 2;\n } else {\n target_edges[i] = round((double)i * V / (M - 1));\n }\n }\n\n // Output N and the graphs\n cout << N << \"\\n\";\n for (int i = 0; i < M; ++i) {\n string g = \"\";\n for (int j = 0; j < target_edges[i]; ++j) {\n g += \"1\";\n }\n for (int j = target_edges[i]; j < V; ++j) {\n g += \"0\";\n }\n cout << g << \"\\n\";\n }\n cout << flush;\n\n // Process the 100 queries\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n int edges = 0;\n for (char c : H) {\n if (c == '1') edges++;\n }\n \n int best_guess = 0;\n double best_diff = 1e9;\n \n for (int i = 0; i < M; ++i) {\n double expected_edges = target_edges[i] * (1.0 - eps) + (V - target_edges[i]) * eps;\n double diff = abs(edges - expected_edges);\n if (diff < best_diff) {\n best_diff = diff;\n best_guess = i;\n }\n }\n \n cout << best_guess << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Edge {\n int id;\n int u, v;\n long long w;\n double x, y;\n};\n\nstruct GraphEdge {\n int to;\n long long w;\n int id;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n\n vector edges(M);\n vector> adj(N);\n vector> coords(N);\n\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; \n edges[i].v--;\n edges[i].id = i;\n adj[edges[i].u].push_back({edges[i].v, edges[i].w, i});\n adj[edges[i].v].push_back({edges[i].u, edges[i].w, i});\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n for (int i = 0; i < M; ++i) {\n edges[i].x = (coords[edges[i].u].first + coords[edges[i].v].first) / 2.0;\n edges[i].y = (coords[edges[i].u].second + coords[edges[i].v].second) / 2.0;\n }\n\n mt19937 rng(42);\n \n // Farthest Point Sampling for evaluation sources\n int num_eval_sources = min(N, 12);\n vector eval_sources;\n eval_sources.push_back(uniform_int_distribution(0, N - 1)(rng));\n for (int i = 1; i < num_eval_sources; ++i) {\n int best_v = -1;\n long long max_dist = -1;\n for (int v = 0; v < N; ++v) {\n long long min_d = 2e18;\n for (int s : eval_sources) {\n long long dx = coords[v].first - coords[s].first;\n long long dy = coords[v].second - coords[s].second;\n long long d = dx * dx + dy * dy;\n min_d = min(min_d, d);\n }\n if (min_d > max_dist) {\n max_dist = min_d;\n best_v = v;\n }\n }\n eval_sources.push_back(best_v);\n }\n\n // Pre-allocate distance array to avoid allocation overhead in hot loop\n vector dist(N);\n\n auto compute_day_score = [&](const vector& ans, int day) -> long long {\n long long score = 0;\n for (int src : eval_sources) {\n fill(dist.begin(), dist.end(), 1e15);\n priority_queue, vector>, greater>> pq;\n \n dist[src] = 0;\n pq.push({0, src});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (const auto& edge : adj[u]) {\n if (ans[edge.id] == day) continue;\n if (dist[edge.to] > d + edge.w) {\n dist[edge.to] = d + edge.w;\n pq.push({dist[edge.to], edge.to});\n }\n }\n }\n \n for (int i = 0; i < N; ++i) {\n if (dist[i] > 1e14) {\n score += 1000000000LL; // Soft penalty\n } else {\n score += dist[i];\n }\n }\n }\n return score;\n };\n\n vector best_ans(M, 1);\n long long best_total_score = -1;\n\n // Initialization: test random projection angles\n for (int iter = 0; iter < 20; ++iter) {\n double angle = uniform_real_distribution(0, 2 * M_PI)(rng);\n double cos_a = cos(angle);\n double sin_a = sin(angle);\n\n vector> proj(M);\n for (int i = 0; i < M; ++i) {\n proj[i] = {edges[i].x * cos_a + edges[i].y * sin_a, i};\n }\n\n sort(proj.begin(), proj.end());\n\n vector current_ans(M);\n for (int i = 0; i < M; ++i) {\n current_ans[proj[i].second] = (i % D) + 1;\n }\n\n long long current_score = 0;\n for (int d = 1; d <= D; ++d) {\n current_score += compute_day_score(current_ans, d);\n }\n\n if (best_total_score == -1 || current_score < best_total_score) {\n best_total_score = current_score;\n best_ans = current_ans;\n }\n }\n\n // Simulated Annealing\n vector current_ans = best_ans;\n vector day_scores(D + 1, 0);\n long long current_total_score = 0;\n \n for (int d = 1; d <= D; ++d) {\n day_scores[d] = compute_day_score(current_ans, d);\n current_total_score += day_scores[d];\n }\n \n uniform_int_distribution edge_dist(0, M - 1);\n \n double t0 = 2e6;\n double t1 = 1e2;\n double max_time = 5.8;\n\n while (true) {\n auto now = high_resolution_clock::now();\n double elapsed = duration_cast(now - start_time).count() / 1000.0;\n if (elapsed > max_time) break;\n\n double temp = t0 * pow(t1 / t0, elapsed / max_time);\n\n int e1 = edge_dist(rng);\n int e2 = edge_dist(rng);\n \n int d1 = current_ans[e1];\n int d2 = current_ans[e2];\n if (d1 == d2) continue;\n\n long long old_sub_score = day_scores[d1] + day_scores[d2];\n\n // Swap\n current_ans[e1] = d2;\n current_ans[e2] = d1;\n \n long long new_d1_score = compute_day_score(current_ans, d1);\n long long new_d2_score = compute_day_score(current_ans, d2);\n long long new_sub_score = new_d1_score + new_d2_score;\n \n long long delta = new_sub_score - old_sub_score;\n \n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_total_score += delta;\n day_scores[d1] = new_d1_score;\n day_scores[d2] = new_d2_score;\n \n if (current_total_score < best_total_score) {\n best_total_score = current_total_score;\n best_ans = current_ans;\n }\n } else {\n // Revert swap\n current_ans[e1] = d1;\n current_ans[e2] = d2;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n cout << best_ans[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint D;\n\nstruct Point {\n int x, y, z;\n bool operator==(const Point& o) const { return x == o.x && y == o.y && z == o.z; }\n};\n\ninline int get_idx(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nPoint rotate(Point p, int rot) {\n int x = p.x, y = p.y, z = p.z;\n int nx, ny, nz;\n int face = rot / 4;\n if (face == 0) { nx = x; ny = y; nz = z; }\n else if (face == 1) { nx = x; ny = -z; nz = y; }\n else if (face == 2) { nx = x; ny = -y; nz = -z; }\n else if (face == 3) { nx = x; ny = z; nz = -y; }\n else if (face == 4) { nx = y; ny = -x; nz = z; }\n else if (face == 5) { nx = -y; ny = x; nz = z; }\n \n int roll = rot % 4;\n for (int i = 0; i < roll; ++i) {\n int tx = nx;\n nx = -nz;\n nz = tx;\n }\n return {nx, ny, nz};\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline int next_int(int max_val) {\n return xor128() % max_val;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> D)) return 0;\n\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; ++i) cin >> f1[i];\n for (int i = 0; i < D; ++i) cin >> r1[i];\n for (int i = 0; i < D; ++i) cin >> f2[i];\n for (int i = 0; i < D; ++i) cin >> r2[i];\n\n vector init_c1, init_c2;\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (f1[z][x] == '1' && r1[z][y] == '1') init_c1.push_back({x, y, z});\n if (f2[z][x] == '1' && r2[z][y] == '1') init_c2.push_back({x, y, z});\n }\n }\n }\n\n double best_score = 1e18;\n int num_cells = D * D * D;\n vector best_b1(num_cells, 0);\n vector best_b2(num_cells, 0);\n int best_n = 0;\n\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n\n int iter = 0;\n while (true) {\n if (++iter % 32 == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 5.6) break;\n }\n\n vector c1 = init_c1;\n vector c2 = init_c2;\n\n vector avail1(num_cells, false);\n vector avail2(num_cells, false);\n for (auto p : c1) avail1[get_idx(p.x, p.y, p.z)] = true;\n for (auto p : c2) avail2[get_idx(p.x, p.y, p.z)] = true;\n\n vector b1(num_cells, 0);\n vector b2(num_cells, 0);\n\n int block_id = 0;\n double current_score = 0;\n\n int rem1 = c1.size();\n int rem2 = c2.size();\n\n while (rem1 > 0 && rem2 > 0) {\n Point start1;\n bool found1 = false;\n while (rem1 > 0) {\n int idx1 = next_int(rem1);\n start1 = c1[idx1];\n if (avail1[get_idx(start1.x, start1.y, start1.z)]) {\n found1 = true;\n break;\n } else {\n swap(c1[idx1], c1[rem1 - 1]);\n rem1--;\n }\n }\n if (!found1) break;\n\n Point start2;\n bool found2 = false;\n while (rem2 > 0) {\n int idx2 = next_int(rem2);\n start2 = c2[idx2];\n if (avail2[get_idx(start2.x, start2.y, start2.z)]) {\n found2 = true;\n break;\n } else {\n swap(c2[idx2], c2[rem2 - 1]);\n rem2--;\n }\n }\n if (!found2) break;\n \n int rot = next_int(24);\n vector b1_pts = {start1};\n vector b2_pts = {start2};\n \n avail1[get_idx(start1.x, start1.y, start1.z)] = false;\n avail2[get_idx(start2.x, start2.y, start2.z)] = false;\n\n bool grown = true;\n while (grown) {\n grown = false;\n vector p_idx(b1_pts.size());\n for (size_t i = 0; i < b1_pts.size(); ++i) p_idx[i] = i;\n for (size_t i = 1; i < p_idx.size(); ++i) swap(p_idx[i], p_idx[next_int(i + 1)]);\n\n for (int i : p_idx) {\n Point p1 = b1_pts[i];\n int order[6] = {0, 1, 2, 3, 4, 5};\n for (int k = 1; k < 6; ++k) swap(order[k], order[next_int(k + 1)]);\n\n for (int dir : order) {\n int nx1 = p1.x + dx[dir];\n int ny1 = p1.y + dy[dir];\n int nz1 = p1.z + dz[dir];\n \n if (nx1 >= 0 && nx1 < D && ny1 >= 0 && ny1 < D && nz1 >= 0 && nz1 < D) {\n int n1_idx = get_idx(nx1, ny1, nz1);\n if (avail1[n1_idx]) {\n Point offset1 = {nx1 - start1.x, ny1 - start1.y, nz1 - start1.z};\n Point offset2 = rotate(offset1, rot);\n int nx2 = start2.x + offset2.x;\n int ny2 = start2.y + offset2.y;\n int nz2 = start2.z + offset2.z;\n \n if (nx2 >= 0 && nx2 < D && ny2 >= 0 && ny2 < D && nz2 >= 0 && nz2 < D) {\n int n2_idx = get_idx(nx2, ny2, nz2);\n if (avail2[n2_idx]) {\n b1_pts.push_back({nx1, ny1, nz1});\n b2_pts.push_back({nx2, ny2, nz2});\n avail1[n1_idx] = false;\n avail2[n2_idx] = false;\n grown = true;\n break;\n }\n }\n }\n }\n }\n if (grown) break;\n }\n }\n\n block_id++;\n for (Point p : b1_pts) b1[get_idx(p.x, p.y, p.z)] = block_id;\n for (Point p : b2_pts) b2[get_idx(p.x, p.y, p.z)] = block_id;\n current_score += 1.0 / b1_pts.size();\n }\n\n // Only add minimum required isolated blocks to fulfill silhouettes\n int leftover = 0;\n for (int i = 0; i < 2; ++i) {\n const auto& f = (i == 0) ? f1 : f2;\n const auto& r = (i == 0) ? r1 : r2;\n auto& b = (i == 0) ? b1 : b2;\n\n vector> f_cov(D, vector(D, false));\n vector> r_cov(D, vector(D, false));\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n if (b[get_idx(x, y, z)] > 0) {\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n }\n }\n }\n }\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n if (f[z][x] == '1' && !f_cov[z][x]) {\n for (int y = 0; y < D; ++y) {\n if (r[z][y] == '1' && !r_cov[z][y]) {\n block_id++;\n b[get_idx(x, y, z)] = block_id;\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n leftover++;\n break;\n }\n }\n if (!f_cov[z][x]) {\n for (int y = 0; y < D; ++y) {\n if (r[z][y] == '1') {\n block_id++;\n b[get_idx(x, y, z)] = block_id;\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n leftover++;\n break;\n }\n }\n }\n }\n }\n for (int y = 0; y < D; ++y) {\n if (r[z][y] == '1' && !r_cov[z][y]) {\n for (int x = 0; x < D; ++x) {\n if (f[z][x] == '1') {\n block_id++;\n b[get_idx(x, y, z)] = block_id;\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n leftover++;\n break;\n }\n }\n }\n }\n }\n }\n current_score += leftover;\n\n if (current_score < best_score) {\n best_score = current_score;\n best_b1 = b1;\n best_b2 = b2;\n best_n = block_id;\n }\n }\n\n cout << best_n << \"\\n\";\n for (int i = 0; i < num_cells; ++i) {\n cout << best_b1[i] << (i == num_cells - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n for (int i = 0; i < num_cells; ++i) {\n cout << best_b2[i] << (i == num_cells - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nlong long dist_sq(long long x1, long long y1, long long x2, long long y2) {\n return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n}\n\nstruct Edge {\n int id, u, v;\n long long w;\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = find(parent[i]);\n }\n void unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n }\n }\n};\n\nint N, M, K;\nvector> stations;\nvector edges;\nvector> residents;\nvector> dist_sr; \nvector> closest_stations;\n\nvector parent_node;\nvector parent_weight;\nvector parent_edge_id;\nvector post_order;\n\nconst long long MAX_DIST_SQ = 25000000LL; // 5000^2\n\nvoid build_mst() {\n DSU dsu(N);\n vector>> adj(N);\n vector> adj_w(N);\n \n for (const auto& e : edges) {\n if (dsu.find(e.u) != dsu.find(e.v)) {\n dsu.unite(e.u, e.v);\n adj[e.u].push_back({e.v, e.id});\n adj_w[e.u].push_back(e.w);\n adj[e.v].push_back({e.u, e.id});\n adj_w[e.v].push_back(e.w);\n }\n }\n\n parent_node.assign(N, -1);\n parent_weight.assign(N, 0);\n parent_edge_id.assign(N, -1);\n \n vector q;\n q.push_back(0);\n int head = 0;\n parent_node[0] = 0; \n\n while (head < (int)q.size()) {\n int u = q[head++];\n post_order.push_back(u);\n for (size_t i = 0; i < adj[u].size(); ++i) {\n int v = adj[u][i].first;\n int e_id = adj[u][i].second;\n long long w = adj_w[u][i];\n if (parent_node[v] == -1) {\n parent_node[v] = u;\n parent_weight[v] = w;\n parent_edge_id[v] = e_id;\n q.push_back(v);\n }\n }\n }\n reverse(post_order.begin(), post_order.end());\n post_order.pop_back(); \n}\n\nlong long compute_cost(const vector& P, vector& edge_used) {\n long long cost = 0;\n for (int i = 0; i < N; ++i) {\n cost += P[i] * P[i];\n }\n\n vector active(N, 0);\n fill(edge_used.begin(), edge_used.end(), 0);\n\n for (int u : post_order) {\n if (P[u] > 0) active[u] = 1;\n if (active[u]) {\n active[parent_node[u]] = 1;\n cost += parent_weight[u];\n edge_used[parent_edge_id[u]] = 1;\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M >> K)) return 0;\n\n stations.resize(N);\n for (int i = 0; i < N; ++i) cin >> stations[i].first >> stations[i].second;\n\n edges.resize(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; edges[i].v--;\n }\n sort(edges.begin(), edges.end()); \n\n build_mst();\n\n residents.resize(K);\n for (int i = 0; i < K; ++i) cin >> residents[i].first >> residents[i].second;\n\n dist_sr.assign(N, vector(K));\n closest_stations.assign(K, vector());\n\n for (int i = 0; i < K; ++i) {\n vector> dists;\n for (int j = 0; j < N; ++j) {\n long long d = dist_sq(residents[i].first, residents[i].second, stations[j].first, stations[j].second);\n dist_sr[j][i] = d;\n if (d <= MAX_DIST_SQ) {\n dists.push_back({d, j});\n }\n }\n sort(dists.begin(), dists.end());\n for (int j = 0; j < min(15, (int)dists.size()); ++j) {\n closest_stations[i].push_back(dists[j].second);\n }\n }\n\n vector assignment(K);\n vector> station_residents(N);\n vector P(N, 0);\n\n for (int i = 0; i < K; ++i) {\n int best_station = closest_stations[i][0];\n assignment[i] = best_station;\n station_residents[best_station].push_back(i);\n }\n\n auto get_P = [&](int u) {\n if (station_residents[u].empty()) return 0LL;\n long long max_d = 0;\n for (int r : station_residents[u]) {\n if (dist_sr[u][r] > max_d) max_d = dist_sr[u][r];\n }\n long long req_p = ceil(sqrt(max_d));\n while (req_p * req_p < max_d) req_p++;\n return min(req_p, 5000LL); // Strictly cap at 5000 to avoid WA\n };\n\n for (int i = 0; i < N; ++i) P[i] = get_P(i);\n\n vector best_edge_used(M, 0);\n vector temp_edge_used(M, 0);\n long long current_cost = compute_cost(P, best_edge_used);\n long long best_cost = current_cost;\n vector best_P = P;\n\n mt19937 rng(42);\n uniform_int_distribution rand_res(0, K - 1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n uniform_int_distribution rand_any_station(0, N - 1);\n\n double T0 = 2e6;\n double T1 = 1e2;\n int iter = 0;\n\n while (true) {\n if ((iter & 511) == 0) { // Check more frequently\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.90) break;\n }\n iter++;\n\n double progress = iter / 2000000.0; \n if (progress > 1.0) progress = 1.0;\n double T = T0 * pow(T1 / T0, progress);\n\n if (rand_prob(rng) < 0.01) { // Station power-down mutation\n int s = rand_any_station(rng);\n if (station_residents[s].empty() || s == 0) continue;\n \n vector old_assignments;\n bool valid = true;\n for(int r : station_residents[s]) {\n old_assignments.push_back(assignment[r]);\n \n int new_s = s;\n for(int cand : closest_stations[r]) {\n if(cand != s) { new_s = cand; break; }\n }\n if (new_s == s) { // Couldn't find valid alternative\n valid = false;\n break;\n }\n \n assignment[r] = new_s;\n }\n\n if (!valid) {\n for (size_t i = 0; i < old_assignments.size(); ++i) {\n assignment[station_residents[s][i]] = old_assignments[i];\n }\n continue;\n }\n\n vector moved_res = station_residents[s];\n station_residents[s].clear();\n \n for(int r : moved_res) {\n station_residents[assignment[r]].push_back(r);\n }\n\n vector old_P = P;\n P[s] = 0;\n for(int r : moved_res) {\n P[assignment[r]] = get_P(assignment[r]);\n }\n \n long long new_cost = compute_cost(P, temp_edge_used);\n if (new_cost < current_cost || rand_prob(rng) < exp((current_cost - new_cost) / T)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_P = P;\n best_edge_used = temp_edge_used;\n }\n } else {\n for(size_t i = 0; i < moved_res.size(); ++i) {\n int r = moved_res[i];\n int new_s = assignment[r];\n station_residents[new_s].pop_back(); \n assignment[r] = old_assignments[i];\n }\n station_residents[s] = moved_res;\n P = old_P;\n }\n } else { // Single resident mutation\n int r = rand_res(rng);\n int old_s = assignment[r];\n int new_s;\n \n uniform_int_distribution rand_cand(0, closest_stations[r].size() - 1);\n new_s = closest_stations[r][rand_cand(rng)];\n\n if (old_s == new_s) continue;\n\n auto it = find(station_residents[old_s].begin(), station_residents[old_s].end(), r);\n swap(*it, station_residents[old_s].back());\n station_residents[old_s].pop_back();\n \n station_residents[new_s].push_back(r);\n assignment[r] = new_s;\n\n long long old_P_old = P[old_s], old_P_new = P[new_s];\n P[old_s] = get_P(old_s);\n P[new_s] = get_P(new_s);\n\n long long new_cost = compute_cost(P, temp_edge_used);\n\n if (new_cost < current_cost || rand_prob(rng) < exp((current_cost - new_cost) / T)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_P = P;\n best_edge_used = temp_edge_used;\n }\n } else {\n station_residents[new_s].pop_back();\n station_residents[old_s].push_back(r);\n assignment[r] = old_s;\n P[old_s] = old_P_old;\n P[new_s] = old_P_new;\n }\n }\n }\n\n compute_cost(best_P, best_edge_used);\n\n for (int i = 0; i < N; ++i) cout << best_P[i] << (i == N - 1 ? \"\" : \" \");\n cout << \"\\n\";\n for (int i = 0; i < M; ++i) cout << best_edge_used[i] << (i == M - 1 ? \"\" : \" \");\n cout << \"\\n\";\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Swap {\n int x1, y1, x2, y2;\n};\n\n// Fast XorShift PRNG\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::steady_clock::now();\n\n int N = 30;\n vector> orig_b(N, vector(N, 0));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> orig_b[i][j];\n }\n }\n\n vector> all_cells;\n all_cells.reserve(N * (N - 1) / 2);\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n all_cells.push_back({x, y});\n }\n }\n\n vector best_ops;\n int best_ops_size = 1e9;\n\n int iter = 0;\n while (true) {\n if ((iter & 255) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.85) break;\n }\n iter++;\n\n vector> b = orig_b;\n vector ops;\n ops.reserve(min(4000, best_ops_size));\n\n bool changed = true;\n \n // Increase base greediness slightly\n int p_greedy = 80 + (xor128() % 20); \n\n // 60% top-down, 30% bottom-up, 10% random\n int r_strat = xor128() % 100;\n int strategy = (r_strat < 60) ? 1 : ((r_strat < 90) ? 0 : 2);\n \n bool abandoned = false;\n\n while (changed) {\n if (ops.size() >= best_ops_size) {\n abandoned = true;\n break;\n }\n\n changed = false;\n \n if (strategy == 2) {\n for (int i = (int)all_cells.size() - 1; i > 0; --i) {\n int j = xor128() % (i + 1);\n swap(all_cells[i], all_cells[j]);\n }\n \n for (auto& cell : all_cells) {\n int x = cell.first;\n int y = cell.second;\n \n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (xor128() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (xor128() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n } else if (strategy == 0) {\n // Bottom-up\n int pass_type = xor128() % 2;\n for (int x = N - 2; x >= 0; --x) {\n bool ltr = (pass_type == 0);\n for (int i = 0; i <= x; ++i) {\n int y = ltr ? i : x - i;\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (xor128() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (xor128() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n } else {\n // Top-down\n int pass_type = xor128() % 2;\n for (int x = 0; x < N - 1; ++x) {\n bool ltr = (pass_type == 0);\n for (int i = 0; i <= x; ++i) {\n int y = ltr ? i : x - i;\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (xor128() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (xor128() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n }\n }\n \n if (!abandoned && ops.size() < best_ops_size) {\n best_ops_size = ops.size();\n best_ops = std::move(ops);\n }\n }\n\n if (best_ops.size() > 10000) {\n best_ops.resize(10000);\n }\n\n cout << best_ops.size() << \"\\n\";\n for (const auto& op : best_ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nint N;\nbool obstacle[D][D];\nint grid[D][D];\nint static_dist[D][D];\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\n// Check if all remaining empty cells are reachable from the entrance (0, 4)\nbool check_connectivity(int empty_count) {\n if (empty_count <= 0) return true;\n \n vector> visited(D, vector(D, false));\n queue> q;\n \n q.push({0, 4});\n visited[0][4] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n \n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable++;\n }\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n if (grid[nr][nc] == -1 || (nr == 0 && nc == 4)) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n \n return reachable == empty_count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int d_in;\n if (!(cin >> d_in >> N)) return 0;\n \n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n obstacle[i][j] = false;\n grid[i][j] = -1;\n static_dist[i][j] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n queue> sq;\n sq.push({0, 4});\n static_dist[0][4] = 0;\n while (!sq.empty()) {\n auto [r, c] = sq.front();\n sq.pop();\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && static_dist[nr][nc] == -1) {\n static_dist[nr][nc] = static_dist[r][c] + 1;\n sq.push({nr, nc});\n }\n }\n }\n\n int total_containers = D * D - 1 - N;\n set remaining_t;\n for (int i = 0; i < total_containers; ++i) {\n remaining_t.insert(i);\n }\n\n for (int d = 0; d < total_containers; ++d) {\n int t;\n cin >> t;\n remaining_t.erase(t);\n\n int rank_t = 0;\n for (int val : remaining_t) {\n if (val < t) rank_t++;\n }\n double t_ratio = remaining_t.empty() ? 0.0 : (double)rank_t / remaining_t.size();\n\n queue> q;\n vector> dist(D, vector(D, -1));\n \n q.push({0, 4});\n dist[0][4] = 0;\n\n vector> reachable_empty;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable_empty.push_back({r, c});\n }\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && dist[nr][nc] == -1) {\n if (grid[r][c] == -1 || (r == 0 && c == 4)) {\n dist[nr][nc] = dist[r][c] + 1;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int remaining_empty = total_containers - d - 1;\n vector> valid_cells;\n \n for (auto [r, c] : reachable_empty) {\n grid[r][c] = t;\n if (check_connectivity(remaining_empty)) {\n valid_cells.push_back({r, c});\n }\n grid[r][c] = -1;\n }\n\n sort(valid_cells.begin(), valid_cells.end(), [&](pair a, pair b) {\n return static_dist[a.first][a.second] < static_dist[b.first][b.second];\n });\n\n int best_r = -1, best_c = -1;\n double min_cost = 1e18;\n\n for (size_t i = 0; i < valid_cells.size(); ++i) {\n int r = valid_cells[i].first;\n int c = valid_cells[i].second;\n \n double cell_ratio = valid_cells.size() <= 1 ? 0.0 : (double)i / (valid_cells.size() - 1);\n \n // Primary rank matching cost\n double cost = abs(t_ratio - cell_ratio) * 100.0;\n \n // Proportional Monotonicity Penalties\n for (int k = 0; k < 4; ++k) {\n int nr = r + dx[k];\n int nc = c + dy[k];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && grid[nr][nc] != -1) {\n if (static_dist[nr][nc] < static_dist[r][c] && grid[nr][nc] > t) {\n cost += 20.0 + 1.5 * (grid[nr][nc] - t);\n } else if (static_dist[nr][nc] > static_dist[r][c] && grid[nr][nc] < t) {\n cost += 20.0 + 1.5 * (t - grid[nr][nc]);\n }\n }\n }\n \n // Tie breaking\n cost -= dist[r][c] * 0.1;\n\n if (cost < min_cost) {\n min_cost = cost;\n best_r = r;\n best_c = c;\n }\n }\n\n if (best_r == -1) {\n best_r = reachable_empty.back().first;\n best_c = reachable_empty.back().second;\n }\n\n grid[best_r][best_c] = t;\n cout << best_r << \" \" << best_c << \"\\n\";\n cout << flush;\n }\n\n for (int d = 0; d < total_containers; ++d) {\n queue> q;\n vector> visited(D, vector(D, false));\n \n q.push({0, 4});\n visited[0][4] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] != -1 && (r != 0 || c != 4)) {\n reachable_containers.push_back({r, c});\n } else {\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int best_r = -1, best_c = -1;\n int min_val = 1e9;\n \n for (auto [r, c] : reachable_containers) {\n if (grid[r][c] < min_val) {\n min_val = grid[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n grid[best_r][best_c] = -1;\n cout << best_r << \" \" << best_c << \"\\n\";\n }\n \n cout << flush;\n\n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nint M;\nint grid[N][N];\nint adj_count[105][105];\nbool target_adj[105][105];\nint color_count[105];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\n\nint visited[N][N];\nint visit_id = 0;\n\n// Fast static queue for BFS\nint q_r[3000];\nint q_c[3000];\n\ninline bool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\ninline int get_color(int r, int c) {\n if (is_valid(r, c)) return grid[r][c];\n return 0; \n}\n\nbool check_connectivity(int r, int c, int color) {\n if (color != 0 && color_count[color] <= 1) return true;\n \n int same_color_neighbors = 0;\n for (int k = 0; k < 4; ++k) {\n int nr = r + dx[k], nc = c + dy[k];\n if (!is_valid(nr, nc)) {\n if (color == 0) same_color_neighbors++;\n } else {\n if (grid[nr][nc] == color) same_color_neighbors++;\n }\n }\n if (same_color_neighbors <= 1) return true;\n \n visit_id++;\n int count = 0;\n int head = 0, tail = 0;\n \n if (color == 0) {\n q_r[tail] = -1;\n q_c[tail] = -1;\n tail++;\n } else {\n int start_r = -1, start_c = -1;\n for (int k = 0; k < 4; ++k) {\n int nr = r + dx[k], nc = c + dy[k];\n if (is_valid(nr, nc) && grid[nr][nc] == color) {\n start_r = nr; start_c = nc;\n break;\n }\n }\n if (start_r == -1) return true;\n \n q_r[tail] = start_r;\n q_c[tail] = start_c;\n tail++;\n visited[start_r][start_c] = visit_id;\n count = 1;\n }\n \n while (head < tail) {\n int curr_r = q_r[head];\n int curr_c = q_c[head];\n head++;\n \n if (curr_r == -1) {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == 0 || i == N - 1 || j == 0 || j == N - 1) { \n if ((i != r || j != c) && grid[i][j] == 0 && visited[i][j] != visit_id) {\n visited[i][j] = visit_id;\n count++;\n q_r[tail] = i;\n q_c[tail] = j;\n tail++;\n }\n }\n }\n }\n } else {\n for (int i = 0; i < 4; ++i) {\n int nr = curr_r + dx[i];\n int nc = curr_c + dy[i];\n \n if (is_valid(nr, nc)) {\n if ((nr != r || nc != c) && grid[nr][nc] == color && visited[nr][nc] != visit_id) {\n visited[nr][nc] = visit_id;\n count++;\n q_r[tail] = nr;\n q_c[tail] = nc;\n tail++;\n }\n }\n }\n }\n }\n \n return count == color_count[color] - 1;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> M >> M)) return 0;\n int n = 50;\n M = 100;\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cin >> grid[i][j];\n color_count[grid[i][j]]++;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int c1 = grid[i][j];\n int right_c = get_color(i, j + 1);\n if (c1 != right_c) {\n adj_count[c1][right_c]++; adj_count[right_c][c1]++;\n target_adj[c1][right_c] = target_adj[right_c][c1] = true;\n }\n int down_c = get_color(i + 1, j);\n if (c1 != down_c) {\n adj_count[c1][down_c]++; adj_count[down_c][c1]++;\n target_adj[c1][down_c] = target_adj[down_c][c1] = true;\n }\n if (i == 0 && c1 != 0) {\n adj_count[c1][0]++; adj_count[0][c1]++;\n target_adj[c1][0] = target_adj[0][c1] = true;\n }\n if (j == 0 && c1 != 0) {\n adj_count[c1][0]++; adj_count[0][c1]++;\n target_adj[c1][0] = target_adj[0][c1] = true;\n }\n }\n }\n \n mt19937 rng(1337);\n int iter = 0;\n uniform_real_distribution dist(0.0, 1.0);\n \n double T0 = 2.0;\n double T1 = 0.05;\n double time_limit = 1.95;\n double elapsed = 0.0;\n \n while (true) {\n if ((iter++ & 255) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > time_limit) break;\n }\n \n int r = rng() % n;\n int c = rng() % n;\n int old_color = grid[r][c];\n \n vector possible_colors;\n bool has_zero = false;\n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n if (nc != old_color) possible_colors.push_back(nc);\n if (nc == 0) has_zero = true;\n }\n \n if (possible_colors.empty()) continue;\n \n int new_color;\n if (has_zero && old_color != 0 && dist(rng) < 0.9) {\n new_color = 0;\n } else {\n new_color = possible_colors[rng() % possible_colors.size()];\n }\n \n int delta_score = 0;\n if (new_color == 0 && old_color != 0) delta_score = 1;\n else if (new_color != 0 && old_color == 0) delta_score = -1;\n \n double temp = T0 * pow(T1 / T0, elapsed / time_limit);\n if (delta_score < 0) {\n if (dist(rng) > exp(delta_score / temp)) continue;\n }\n \n int local_adj_loss[105] = {0};\n int local_adj_gain[105] = {0};\n \n for (int k = 0; k < 4; ++k) {\n int neighbor_color = get_color(r + dx[k], c + dy[k]);\n if (neighbor_color != old_color) local_adj_loss[neighbor_color]++;\n if (neighbor_color != new_color) local_adj_gain[neighbor_color]++;\n }\n \n bool possible = true;\n for (int i = 0; i <= M; ++i) {\n if (local_adj_loss[i] > 0 && adj_count[old_color][i] - local_adj_loss[i] == 0) {\n possible = false; break;\n }\n if (local_adj_gain[i] > 0 && !target_adj[new_color][i]) {\n possible = false; break;\n }\n }\n \n if (!possible) continue;\n if (!check_connectivity(r, c, old_color)) continue;\n \n for (int i = 0; i <= M; ++i) {\n if (local_adj_loss[i] > 0) {\n adj_count[old_color][i] -= local_adj_loss[i];\n adj_count[i][old_color] -= local_adj_loss[i];\n }\n if (local_adj_gain[i] > 0) {\n adj_count[new_color][i] += local_adj_gain[i];\n adj_count[i][new_color] += local_adj_gain[i];\n }\n }\n \n grid[r][c] = new_color;\n color_count[old_color]--;\n color_count[new_color]++;\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cout << grid[i][j] << (j == n - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, D, Q;\nint queries_used = 0;\n\n// Query the balance safely\nchar query(const vector& L, const vector& R) {\n if (queries_used >= Q) return '=';\n if (L.empty() || R.empty()) {\n if (L.empty() && R.empty()) return '=';\n return L.empty() ? '<' : '>';\n }\n \n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\";\n cout.flush();\n \n char res;\n cin >> res;\n queries_used++;\n return res;\n}\n\nchar compare_items(int u, int v) {\n return query({u}, {v});\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> D >> Q)) return 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n\n // Sort items using stable_sort and our custom comparator\n // std::stable_sort will use around N log N comparisons.\n stable_sort(items.begin(), items.end(), [](int a, int b) {\n if (queries_used >= Q) return a < b; // Fallback if out of queries\n char res = compare_items(a, b);\n return res == '<';\n });\n\n // Estimate weights based on expected order statistics for exponential distribution\n vector est_weight(N);\n vector order_expected(N, 0.0);\n double current_sum = 0.0;\n for (int i = 0; i < N; ++i) {\n current_sum += 1.0 / (N - i);\n order_expected[i] = current_sum;\n }\n\n // Map sorted estimates back to items\n for (int i = 0; i < N; ++i) {\n est_weight[items[i]] = order_expected[i];\n }\n\n // Initialize groups\n vector> groups(D);\n vector group_weights(D, 0.0);\n vector ans(N);\n\n // Greedy assignment: LPT (Longest Processing Time first)\n // Traverse from heaviest to lightest\n for (int i = N - 1; i >= 0; --i) {\n int item = items[i];\n int best_group = 0;\n for (int d = 1; d < D; ++d) {\n if (group_weights[d] < group_weights[best_group]) {\n best_group = d;\n }\n }\n groups[best_group].push_back(item);\n group_weights[best_group] += est_weight[item];\n ans[item] = best_group;\n }\n\n mt19937 rng(1337);\n\n // Refinement phase using remaining queries\n while (queries_used < Q) {\n int g1 = rng() % D;\n int g2 = rng() % D;\n while (g1 == g2) g2 = rng() % D;\n\n if (groups[g1].empty() || groups[g2].empty()) {\n query({0}, {0}); // dummy\n continue;\n }\n\n char res = query(groups[g1], groups[g2]);\n if (queries_used > Q) break;\n\n int heavy = (res == '>') ? g1 : ((res == '<') ? g2 : -1);\n int light = (res == '>') ? g2 : ((res == '<') ? g1 : -1);\n\n if (heavy != -1 && light != -1) {\n // Find a pair of items to swap to balance the groups based on estimates\n double diff = group_weights[heavy] - group_weights[light];\n double target_swap_diff = diff / 2.0;\n\n int best_u = -1, best_v = -1, best_u_idx = -1, best_v_idx = -1;\n double best_gap = 1e9;\n\n for (size_t i = 0; i < groups[heavy].size(); ++i) {\n for (size_t j = 0; j < groups[light].size(); ++j) {\n int u = groups[heavy][i];\n int v = groups[light][j];\n double swap_diff = est_weight[u] - est_weight[v];\n \n if (swap_diff > 0) {\n double gap = abs(swap_diff - target_swap_diff);\n if (gap < best_gap) {\n best_gap = gap;\n best_u = u;\n best_v = v;\n best_u_idx = i;\n best_v_idx = j;\n }\n }\n }\n }\n\n // Execute the best estimated swap\n if (best_u != -1 && best_v != -1) {\n swap(groups[heavy][best_u_idx], groups[light][best_v_idx]);\n ans[best_u] = light;\n ans[best_v] = heavy;\n \n group_weights[heavy] -= est_weight[best_u];\n group_weights[heavy] += est_weight[best_v];\n \n group_weights[light] -= est_weight[best_v];\n group_weights[light] += est_weight[best_u];\n }\n }\n }\n\n // Exhaust remaining unused queries if any\n while (queries_used < Q) {\n query({0}, {0});\n }\n\n // Output final assignments\n for (int i = 0; i < N; ++i) {\n cout << ans[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n cout.flush();\n\n return 0;\n}","ahc026":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int INF = 1e9;\n\n// Fast xorshift RNG\nuint32_t xorshift32(uint32_t& state) {\n state ^= state << 13;\n state ^= state >> 17;\n state ^= state << 5;\n return state;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = steady_clock::now();\n\n int n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> initial_stacks(m);\n for (int i = 0; i < m; ++i) {\n int count = n / m;\n initial_stacks[i].resize(count);\n for (int j = 0; j < count; ++j) {\n cin >> initial_stacks[i][j];\n }\n }\n\n int best_energy = INF;\n vector> best_ops;\n\n uint32_t rng_state = 1337;\n int iter = 0;\n\n // Fast arrays for the simulation\n int stacks[10][205];\n int stack_sizes[10];\n pair ops[5005];\n\n while (true) {\n if ((iter & 255) == 0) {\n auto current_time = steady_clock::now();\n double elapsed = duration_cast>(current_time - start_time).count();\n if (elapsed > 1.85) break;\n }\n iter++;\n\n for (int i = 0; i < m; ++i) {\n stack_sizes[i] = initial_stacks[i].size();\n for (int j = 0; j < stack_sizes[i]; ++j) {\n stacks[i][j] = initial_stacks[i][j];\n }\n }\n\n int ops_count = 0;\n int energy = 0;\n bool possible = true;\n\n for (int v = 1; v <= n; ++v) {\n int s = -1;\n int v_idx = -1;\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < stack_sizes[i]; ++j) {\n if (stacks[i][j] == v) {\n s = i;\n v_idx = j;\n break;\n }\n }\n if (s != -1) break;\n }\n\n while (stack_sizes[s] > v_idx + 1) {\n int max_chunk = stack_sizes[s] - (v_idx + 1);\n int chunk_size = 1;\n \n if (max_chunk > 1) {\n uint32_t r_chunk = xorshift32(rng_state) % 100;\n if (r_chunk < 10) {\n chunk_size = max_chunk;\n } else if (r_chunk < 40) {\n chunk_size = 1 + (xorshift32(rng_state) % max_chunk);\n }\n }\n\n int chunk_bottom_idx = stack_sizes[s] - chunk_size;\n int u = stacks[s][chunk_bottom_idx];\n\n int best_j = -1;\n int min_diff = INF;\n int max_top = -1;\n int fallback_j = -1;\n \n int valids[10];\n int valids_count = 0;\n\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n \n int top_val = (stack_sizes[i] == 0) ? INF : stacks[i][stack_sizes[i] - 1];\n \n if (top_val > u) {\n valids[valids_count++] = i;\n if (top_val - u < min_diff) {\n min_diff = top_val - u;\n best_j = i;\n }\n }\n \n if (top_val > max_top) {\n max_top = top_val;\n fallback_j = i;\n }\n }\n\n int target_stack = -1;\n if (valids_count > 0) {\n uint32_t r = xorshift32(rng_state) % 100;\n if (r < 85 || valids_count == 1) {\n target_stack = best_j;\n } else {\n target_stack = valids[xorshift32(rng_state) % valids_count];\n }\n } else {\n target_stack = fallback_j;\n }\n\n // Move the chunk\n for (int j = chunk_bottom_idx; j < stack_sizes[s]; ++j) {\n stacks[target_stack][stack_sizes[target_stack]++] = stacks[s][j];\n }\n stack_sizes[s] -= chunk_size;\n \n ops[ops_count++] = {u, target_stack + 1};\n energy += (chunk_size + 1);\n }\n\n stack_sizes[s]--;\n ops[ops_count++] = {v, 0};\n \n if (ops_count > 5000) {\n possible = false;\n break;\n }\n }\n\n if (possible && energy < best_energy) {\n best_energy = energy;\n best_ops.assign(ops, ops + ops_count);\n }\n }\n\n for (auto& op : best_ops) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h;\nvector v;\nvector> d;\nvector DIJ_R = {0, 1, 0, -1};\nvector DIJ_C = {1, 0, -1, 0};\nstring DIR = \"RDLU\";\nstring INV_DIR = \"LURD\"; \n\nint last_visit_arr[1605];\nlong long sum_w2_arr[1605];\nint first_visit_arr[1605];\n\ndouble evaluate(const string& path) {\n int L = path.length();\n if (L == 0) return 1e18;\n int r = 0, c = 0;\n \n fill(last_visit_arr, last_visit_arr + N * N, -1);\n fill(sum_w2_arr, sum_w2_arr + N * N, 0);\n fill(first_visit_arr, first_visit_arr + N * N, -1);\n\n for (int t = 0; t < L; ++t) {\n int idx = r * N + c;\n if (last_visit_arr[idx] == -1) {\n first_visit_arr[idx] = t;\n } else {\n long long w = t - last_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n }\n last_visit_arr[idx] = t;\n\n char move = path[t];\n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n double total_avg = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (last_visit_arr[idx] != -1) {\n long long w = L - last_visit_arr[idx] + first_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n total_avg += (double)d[i][j] * sum_w2_arr[idx] / L;\n } else {\n return 1e18; \n }\n }\n }\n return total_avg;\n}\n\ndouble evaluate_with_detour(const string& path, int insert_idx, char m1, char m2) {\n int L = path.length() + 2;\n int r = 0, c = 0;\n \n fill(last_visit_arr, last_visit_arr + N * N, -1);\n fill(sum_w2_arr, sum_w2_arr + N * N, 0);\n fill(first_visit_arr, first_visit_arr + N * N, -1);\n\n for (int t = 0; t < L; ++t) {\n int idx = r * N + c;\n if (last_visit_arr[idx] == -1) {\n first_visit_arr[idx] = t;\n } else {\n long long w = t - last_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n }\n last_visit_arr[idx] = t;\n\n char move;\n if (t < insert_idx) {\n move = path[t];\n } else if (t == insert_idx) {\n move = m1;\n } else if (t == insert_idx + 1) {\n move = m2;\n } else {\n move = path[t - 2];\n }\n\n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n double total_avg = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (last_visit_arr[idx] != -1) {\n long long w = L - last_visit_arr[idx] + first_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n total_avg += (double)d[i][j] * sum_w2_arr[idx] / L;\n } else {\n return 1e18;\n }\n }\n }\n return total_avg;\n}\n\nvoid dfs(int r, int c, vector>& visited, string& current_path, mt19937& rng) {\n visited[r][c] = true;\n \n vector> valid_dirs;\n for (int dir = 0; dir < 4; ++dir) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = r + dr;\n int c2 = c + dc;\n \n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N && !visited[r2][c2]) {\n bool can_move = false;\n if (dr == 0) {\n if (v[r][min(c, c2)] == '0') can_move = true;\n } else {\n if (h[min(r, r2)][c] == '0') can_move = true;\n }\n \n if (can_move) {\n // Slightly broader noise to find varied trees\n int weight = d[r2][c2] * (rng() % 100) + (rng() % 500);\n valid_dirs.push_back({weight, dir});\n }\n }\n }\n \n sort(valid_dirs.rbegin(), valid_dirs.rend());\n \n for (auto& p : valid_dirs) {\n int dir = p.second;\n int r2 = r + DIJ_R[dir];\n int c2 = c + DIJ_C[dir];\n if (!visited[r2][c2]) {\n current_path += DIR[dir];\n dfs(r2, c2, visited, current_path, rng);\n current_path += DIR[(dir + 2) % 4];\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N)) return 0;\n\n h.resize(N - 1);\n for (int i = 0; i < N - 1; ++i) {\n cin >> h[i];\n }\n\n v.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> v[i];\n }\n\n d.assign(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 mt19937 rng(1337);\n string best_path = \"\";\n double best_score = 1e18;\n\n // Phase 1: Randomized DFS tree search - Further reduced time to 0.5s\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 0.5) break; \n\n vector> visited(N, vector(N, false));\n string current_path = \"\";\n dfs(0, 0, visited, current_path, rng);\n \n double score = evaluate(current_path);\n if (score < best_score) {\n best_score = score;\n best_path = current_path;\n }\n }\n\n // Phase 2: Heuristic Detour Insertion\n bool improved = true;\n while (improved) {\n improved = false;\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95 || best_path.length() >= 99990) break;\n\n int L = best_path.length();\n int best_insert_idx = -1;\n char best_m1 = ' ', best_m2 = ' ';\n double best_detour_score = best_score;\n\n int r = 0, c = 0;\n vector> candidates; \n \n for (int i = 0; i < L; ++i) {\n char move = best_path[i];\n \n int max_d_around = 0;\n for (int dir = 0; dir < 4; ++dir) {\n int r2 = r + DIJ_R[dir];\n int c2 = c + DIJ_C[dir];\n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N) {\n max_d_around = max(max_d_around, d[r2][c2]);\n }\n }\n \n candidates.push_back({max_d_around + (rng() % 100), i});\n \n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n sort(candidates.rbegin(), candidates.rend());\n \n // Throttled to 600 checks max to maintain iteration speed on long paths\n int checks = min(L, 600); \n \n r = 0; c = 0;\n vector> positions(L);\n for (int i = 0; i < L; ++i) {\n positions[i] = {r, c};\n char move = best_path[i];\n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n\n for (int i = 0; i < checks; ++i) {\n int idx = candidates[i].second;\n int cr = positions[idx].first;\n int cc = positions[idx].second;\n\n for (int dir = 0; dir < 4; ++dir) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = cr + dr;\n int c2 = cc + dc;\n\n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N) {\n bool can_move = false;\n if (dr == 0) {\n if (v[cr][min(cc, c2)] == '0') can_move = true;\n } else {\n if (h[min(cr, r2)][cc] == '0') can_move = true;\n }\n\n if (can_move) {\n char m1 = DIR[dir];\n char m2 = INV_DIR[dir];\n double s = evaluate_with_detour(best_path, idx, m1, m2);\n if (s < best_detour_score) {\n best_detour_score = s;\n best_insert_idx = idx;\n best_m1 = m1;\n best_m2 = m2;\n }\n }\n }\n }\n }\n\n if (best_insert_idx != -1) {\n string detour = \"\";\n detour += best_m1;\n detour += best_m2;\n best_path = best_path.substr(0, best_insert_idx) + detour + best_path.substr(best_insert_idx);\n best_score = best_detour_score;\n improved = true;\n }\n }\n\n cout << best_path << \"\\n\";\n\n return 0;\n}","ahc028":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\nint N, M;\nint start_i, start_j;\nvector grid;\nvector words;\nvector> pos[26];\nint min_dist[26][26];\nint min_start_dist[26];\n\nint overlap_precalc[205][205];\nint append_cost_precalc[205][205];\n\nint manhattan(pair a, pair b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint calc_overlap(const string& a, const string& b) {\n for (int k = 4; k >= 1; --k) {\n if (a.substr(5 - k) == b.substr(0, k)) {\n return k;\n }\n }\n return 0;\n}\n\nint approx_cost(char last_char, const string& add) {\n int cost = 0;\n char c = last_char;\n for (char nxt : add) {\n cost += min_dist[c - 'A'][nxt - 'A'] + 1;\n c = nxt;\n }\n return cost;\n}\n\nuint32_t xor_shift() {\n static uint32_t y = 2463534242;\n y = y ^ (y << 13);\n y = y ^ (y >> 17);\n return y = y ^ (y << 5);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M)) return 0;\n cin >> start_i >> start_j;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n for (int j = 0; j < N; ++j) {\n pos[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n words.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> words[i];\n }\n\n for (int i = 0; i < 26; ++i) {\n min_start_dist[i] = INF;\n for (auto p : pos[i]) {\n min_start_dist[i] = min(min_start_dist[i], manhattan({start_i, start_j}, p));\n }\n for (int j = 0; j < 26; ++j) {\n min_dist[i][j] = INF;\n if (pos[i].empty() || pos[j].empty()) continue;\n for (auto p1 : pos[i]) {\n for (auto p2 : pos[j]) {\n min_dist[i][j] = min(min_dist[i][j], manhattan(p1, p2));\n }\n }\n }\n }\n\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) {\n if (i == j) continue;\n overlap_precalc[i][j] = calc_overlap(words[i], words[j]);\n string add = words[j].substr(overlap_precalc[i][j]);\n append_cost_precalc[i][j] = approx_cost(words[i].back(), add);\n }\n }\n\n int best_total_cost = INF;\n vector> best_path;\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.92) break;\n\n vector remaining(M);\n for (int i = 0; i < M; ++i) remaining[i] = i;\n\n string S = \"\";\n int last_w_idx = -1;\n \n int overlap_weight = 9 + (xor_shift() % 8); \n\n while (!remaining.empty()) {\n pair cand1 = {INF, -1};\n pair cand2 = {INF, -1};\n\n for (int i = 0; i < remaining.size(); ++i) {\n int w_idx = remaining[i];\n if (!S.empty() && S.find(words[w_idx]) != string::npos) {\n cand1 = {-100000, i};\n break;\n }\n \n int cost, k;\n if (last_w_idx == -1) {\n k = 0;\n cost = 0;\n } else {\n k = overlap_precalc[last_w_idx][w_idx];\n cost = append_cost_precalc[last_w_idx][w_idx];\n }\n \n int score = cost - k * overlap_weight;\n if (score < cand1.first) {\n cand2 = cand1;\n cand1 = {score, i};\n } else if (score < cand2.first) {\n cand2 = {score, i};\n }\n }\n \n int chosen_idx = cand1.second;\n if (cand2.second != -1 && (xor_shift() % 100) < 15) {\n chosen_idx = cand2.second;\n }\n\n int w_idx = remaining[chosen_idx];\n \n if (S.empty() || S.find(words[w_idx]) == string::npos) {\n int k = (last_w_idx == -1) ? 0 : overlap_precalc[last_w_idx][w_idx];\n S += words[w_idx].substr(k);\n last_w_idx = w_idx;\n }\n \n remaining.erase(remaining.begin() + chosen_idx);\n }\n\n int len = S.length();\n if (len > 5000) continue;\n\n // Strict lower bound prune\n int lower_bound = min_start_dist[S[0] - 'A'] + 1;\n for (int i = 1; i < len; ++i) {\n lower_bound += min_dist[S[i - 1] - 'A'][S[i] - 'A'] + 1;\n }\n if (lower_bound >= best_total_cost) continue;\n\n vector> dp(len, vector(225, INF));\n vector> parent(len, vector(225, -1));\n\n for (int k = 0; k < pos[S[0] - 'A'].size(); ++k) {\n auto p = pos[S[0] - 'A'][k];\n int idx = p.first * N + p.second;\n dp[0][idx] = manhattan({start_i, start_j}, p) + 1;\n }\n\n for (int i = 1; i < len; ++i) {\n char prev_c = S[i - 1];\n char curr_c = S[i];\n for (int p_k = 0; p_k < pos[prev_c - 'A'].size(); ++p_k) {\n auto p_prev = pos[prev_c - 'A'][p_k];\n int p_idx = p_prev.first * N + p_prev.second;\n if (dp[i - 1][p_idx] == INF) continue;\n\n for (int c_k = 0; c_k < pos[curr_c - 'A'].size(); ++c_k) {\n auto p_curr = pos[curr_c - 'A'][c_k];\n int c_idx = p_curr.first * N + p_curr.second;\n int cost = dp[i - 1][p_idx] + manhattan(p_prev, p_curr) + 1;\n if (cost < dp[i][c_idx]) {\n dp[i][c_idx] = cost;\n parent[i][c_idx] = p_idx;\n }\n }\n }\n }\n\n int min_cost = INF;\n int last_idx = -1;\n for (int k = 0; k < pos[S.back() - 'A'].size(); ++k) {\n auto p = pos[S.back() - 'A'][k];\n int idx = p.first * N + p.second;\n if (dp[len - 1][idx] < min_cost) {\n min_cost = dp[len - 1][idx];\n last_idx = idx;\n }\n }\n\n if (min_cost < best_total_cost) {\n best_total_cost = min_cost;\n best_path.clear();\n int curr_idx = last_idx;\n for (int i = len - 1; i >= 0; --i) {\n best_path.push_back({curr_idx / N, curr_idx % N});\n curr_idx = parent[i][curr_idx];\n }\n reverse(best_path.begin(), best_path.end());\n }\n }\n\n for (auto p : best_path) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nstruct Point {\n int i, j;\n};\n\nstruct Polyomino {\n int d;\n vector pts;\n int max_i, max_j;\n};\n\nint N, M;\ndouble eps;\nvector fields;\n\nint obs[25][25];\nbool is_queried[25][25];\nstruct Pt { int r, c; };\nvector placements[25][405];\nint num_placements[25];\n\nint current_p[25];\nint pred[25][25];\n\nint query_single(int i, int j) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n int res;\n cin >> res;\n return res;\n}\n\nvoid answer(const vector& ans) {\n cout << \"a \" << ans.size();\n for (auto p : ans) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int res;\n cin >> res;\n if (res == 1) {\n exit(0);\n }\n}\n\nvoid init_placements() {\n for (int m = 0; m < M; ++m) {\n num_placements[m] = 0;\n for (int r = 0; r <= N - fields[m].max_i; ++r) {\n for (int c = 0; c <= N - fields[m].max_j; ++c) {\n for (auto& pt : fields[m].pts) {\n placements[m][num_placements[m]].push_back({r + pt.i, c + pt.j});\n }\n num_placements[m]++;\n }\n }\n }\n}\n\nmt19937 rng(42);\n\nbool run_SA() {\n for (int attempt = 0; attempt < 12; ++attempt) {\n if (get_time() > 2.85) return false;\n\n memset(pred, 0, sizeof(pred));\n for (int m = 0; m < M; ++m) {\n current_p[m] = rng() % num_placements[m];\n for (auto& pt : placements[m][current_p[m]]) {\n pred[pt.r][pt.c]++;\n }\n }\n \n int E = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (obs[r][c] != -1) {\n E += abs(pred[r][c] - obs[r][c]);\n }\n }\n }\n if (E == 0) return true;\n \n double T = 15.0;\n for (int step = 0; step < 15000; ++step) {\n int m = rng() % M;\n int old_p = current_p[m];\n int new_p = rng() % num_placements[m];\n if (old_p == new_p) continue;\n \n int delta = 0;\n for (auto& pt : placements[m][old_p]) {\n if (obs[pt.r][pt.c] != -1) {\n delta -= abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n pred[pt.r][pt.c]--;\n delta += abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n } else {\n pred[pt.r][pt.c]--;\n }\n }\n for (auto& pt : placements[m][new_p]) {\n if (obs[pt.r][pt.c] != -1) {\n delta -= abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n pred[pt.r][pt.c]++;\n delta += abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n } else {\n pred[pt.r][pt.c]++;\n }\n }\n \n if (delta <= 0 || (exp(-delta / T) > (rng() % 10000) / 10000.0)) {\n E += delta;\n current_p[m] = new_p;\n if (E == 0) return true;\n } else {\n for (auto& pt : placements[m][new_p]) pred[pt.r][pt.c]--;\n for (auto& pt : placements[m][old_p]) pred[pt.r][pt.c]++;\n }\n T *= 0.999;\n }\n }\n return false;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n get_time();\n\n if (!(cin >> N >> M >> eps)) return 0;\n\n fields.resize(M);\n for (int k = 0; k < M; ++k) {\n cin >> fields[k].d;\n fields[k].pts.resize(fields[k].d);\n fields[k].max_i = 0;\n fields[k].max_j = 0;\n for (int p = 0; p < fields[k].d; ++p) {\n cin >> fields[k].pts[p].i >> fields[k].pts[p].j;\n fields[k].max_i = max(fields[k].max_i, fields[k].pts[p].i);\n fields[k].max_j = max(fields[k].max_j, fields[k].pts[p].j);\n }\n }\n\n init_placements();\n memset(obs, -1, sizeof(obs));\n memset(is_queried, 0, sizeof(is_queried));\n\n vector unqueried;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n unqueried.push_back({r, c});\n }\n }\n \n // Sort so that cells closer to the center are at the end of the vector\n // (since we pop_back to get the next element)\n double center = (N - 1) / 2.0;\n sort(unqueried.begin(), unqueried.end(), [center](const Pt& a, const Pt& b) {\n double da = (a.r - center) * (a.r - center) + (a.c - center) * (a.c - center);\n double db = (b.r - center) * (b.r - center) + (b.c - center) * (b.c - center);\n return da > db;\n });\n\n int queried_count = 0;\n\n while (queried_count < N * N) {\n bool sa_success = false;\n if (get_time() < 2.85) {\n sa_success = run_SA();\n }\n bool queried_pred = false;\n\n if (sa_success) {\n int best_r = -1, best_c = -1, max_p = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (pred[r][c] > max_p && obs[r][c] == -1) {\n max_p = pred[r][c];\n best_r = r;\n best_c = c;\n }\n }\n }\n\n if (best_r != -1) {\n obs[best_r][best_c] = query_single(best_r, best_c);\n is_queried[best_r][best_c] = true;\n queried_count++;\n queried_pred = true;\n } else {\n vector guess_set;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (pred[r][c] > 0) {\n guess_set.push_back({r, c});\n }\n }\n }\n answer(guess_set);\n }\n } \n \n if (!queried_pred && queried_count < N * N) {\n while (!unqueried.empty()) {\n Pt next_q = unqueried.back();\n unqueried.pop_back();\n if (!is_queried[next_q.r][next_q.c]) {\n obs[next_q.r][next_q.c] = query_single(next_q.r, next_q.c);\n is_queried[next_q.r][next_q.c] = true;\n queried_count++;\n break;\n }\n }\n }\n }\n\n vector final_ans;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (obs[r][c] > 0) {\n final_ans.push_back({r, c});\n }\n }\n }\n answer(final_ans);\n\n return 0;\n}","ahc031":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int W = 1000;\nconst long long INF = 1e18;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int w_input, d_days, n_res;\n if (!(cin >> w_input >> d_days >> n_res)) return 0;\n\n vector> a(d_days, vector(n_res));\n for (int d = 0; d < d_days; ++d) {\n for (int k = 0; k < n_res; ++k) {\n cin >> a[d][k];\n }\n }\n\n vector prev_B(n_res + 1, 0);\n\n for (int d = 0; d < d_days; ++d) {\n vector dp(W + 1, INF);\n dp[0] = 0;\n \n vector> parent(n_res, vector(W + 1, -1));\n\n for (int k = 0; k < n_res; ++k) {\n vector next_dp(W + 1, INF);\n \n for (int x = k + 1; x <= W - (n_res - 1 - k); ++x) {\n long long change_cost = 0;\n // If the boundary changes, we pay to remove the old W segments and add W new segments.\n if (k + 1 < n_res && d > 0) {\n if (x != prev_B[k + 1]) {\n change_cost = 2 * W; \n }\n }\n\n long long min_cost = INF;\n int best_y = -1;\n \n for (int y = k; y < x; ++y) {\n if (dp[y] == INF) continue;\n \n long long area = (long long)W * (x - y);\n long long penalty = 0;\n if (area < a[d][k]) {\n penalty = 100LL * (a[d][k] - area);\n }\n \n long long cost = dp[y] + penalty;\n if (cost < min_cost) {\n min_cost = cost;\n best_y = y;\n }\n }\n \n if (min_cost != INF) {\n next_dp[x] = min_cost + change_cost;\n parent[k][x] = best_y;\n }\n }\n dp = move(next_dp);\n }\n\n vector curr_B(n_res + 1, 0);\n curr_B[n_res] = W;\n int curr_x = W;\n \n for (int k = n_res - 1; k >= 0; --k) {\n curr_x = parent[k][curr_x];\n curr_B[k] = curr_x;\n }\n\n for (int k = 0; k < n_res; ++k) {\n cout << 0 << \" \" << curr_B[k] << \" \" << W << \" \" << curr_B[k + 1] << \"\\n\";\n }\n prev_B = curr_B;\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\nlong long A[81];\nlong long S[20][9];\nlong long rem_val[81];\nOp ops[81];\n\n// Fast PRNG\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double next_double() {\n return (xor128() & 0xFFFFFF) / (double)(0x1000000);\n}\n\ninline int next_int(int max_val) {\n return xor128() % max_val;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n\n for (int i = 0; i < 81; ++i) {\n cin >> A[i];\n rem_val[i] = A[i] % MOD;\n }\n\n for (int m = 0; m < M; ++m) {\n for (int i = 0; i < 9; ++i) {\n cin >> S[m][i];\n }\n }\n\n for (int i = 0; i < K; ++i) {\n ops[i] = {-1, -1, -1};\n }\n\n double T0 = 2e9;\n double T1 = 1e6;\n double time_limit = 1.95;\n double T = T0;\n\n long long current_score = 0;\n for (int i = 0; i < 81; ++i) {\n current_score += rem_val[i];\n }\n\n long long best_score = current_score;\n Op best_ops[81];\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n\n int iter = 0;\n int offsets[9] = {0, 1, 2, N, N + 1, N + 2, 2 * N, 2 * N + 1, 2 * N + 2};\n\n while (true) {\n if ((iter & 2047) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n T = T0 * pow(T1 / T0, progress);\n }\n\n int idx = next_int(K);\n Op old_op = ops[idx];\n Op new_op;\n int m_val = (xor128() % (M + 1)) - 1; // -1 to M-1\n new_op.m = m_val;\n if (new_op.m == -1) {\n new_op.p = -1;\n new_op.q = -1;\n } else {\n new_op.p = next_int(N - 2);\n new_op.q = next_int(N - 2);\n }\n\n long long delta = 0;\n \n if (old_op.m != -1) {\n int base_idx = old_op.p * N + old_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long old_v = rem_val[cell];\n long long new_v = old_v - S[old_op.m][i];\n if (new_v < 0) new_v += MOD;\n delta += new_v - old_v;\n rem_val[cell] = new_v;\n }\n }\n \n if (new_op.m != -1) {\n int base_idx = new_op.p * N + new_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long old_v = rem_val[cell];\n long long new_v = old_v + S[new_op.m][i];\n if (new_v >= MOD) new_v -= MOD;\n delta += new_v - old_v;\n rem_val[cell] = new_v;\n }\n }\n\n if (delta >= 0 || next_double() < exp(delta / T)) {\n current_score += delta;\n ops[idx] = new_op;\n if (current_score > best_score) {\n best_score = current_score;\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n }\n } else {\n // Rollback\n if (new_op.m != -1) {\n int base_idx = new_op.p * N + new_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long val = rem_val[cell] - S[new_op.m][i];\n if (val < 0) val += MOD;\n rem_val[cell] = val;\n }\n }\n if (old_op.m != -1) {\n int base_idx = old_op.p * N + old_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long val = rem_val[cell] + S[old_op.m][i];\n if (val >= MOD) val -= MOD;\n rem_val[cell] = val;\n }\n }\n }\n iter++;\n }\n\n vector final_ops;\n for (int i = 0; i < K; ++i) {\n if (best_ops[i].m != -1) {\n final_ops.push_back(best_ops[i]);\n }\n }\n\n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_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\nusing namespace std;\n\nconst int N = 5;\n\nstruct Container {\n int val, r, c;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input;\n if (!(cin >> n_input)) return 0;\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 string ans0 = \".\";\n int cr = 0, cc = 0;\n \n int ptr[N] = {0};\n int grid[N][N];\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) grid[r][c] = -1;\n }\n \n bool is_delivered[25] = {false};\n int next_needed[N];\n for (int i = 0; i < N; ++i) next_needed[i] = i * N;\n\n auto move_crane = [&](int tr, int tc) {\n while (cr > tr) { ans0 += 'U'; cr--; }\n while (cr < tr) { ans0 += 'D'; cr++; }\n while (cc > tc) { ans0 += 'L'; cc--; }\n while (cc < tc) { ans0 += 'R'; cc++; }\n };\n\n int delivered = 0;\n while (delivered < 25) {\n for (int i = 0; i < N; ++i) {\n while (next_needed[i] < i * N + N && is_delivered[next_needed[i]]) {\n next_needed[i]++;\n }\n }\n\n vector accessible;\n for (int r = 0; r < N; ++r) {\n if (ptr[r] < N) accessible.push_back({A[r][ptr[r]], r, 0});\n for (int c = 1; c < N - 1; ++c) {\n if (grid[r][c] != -1) accessible.push_back({grid[r][c], r, c});\n }\n }\n\n bool found_exact = false;\n Container best_c = {-1, -1, -1};\n int min_cost = 10000;\n\n // 1. Pick the exact needed container that is CLOSEST to the crane's current position\n for (auto& cont : accessible) {\n int gate = cont.val / N;\n if (cont.val == next_needed[gate]) {\n found_exact = true;\n int cost = abs(cr - cont.r) + abs(cc - cont.c);\n if (cost < min_cost) {\n min_cost = cost;\n best_c = cont;\n }\n }\n }\n\n if (found_exact) {\n move_crane(best_c.r, best_c.c);\n ans0 += 'P';\n \n if (best_c.c == 0) ptr[best_c.r]++;\n else grid[best_c.r][best_c.c] = -1;\n\n int gate = best_c.val / N;\n move_crane(gate, N - 1);\n ans0 += 'Q';\n \n is_delivered[best_c.val] = true;\n delivered++;\n } else {\n // 2. Dig for the needed container with the lowest depth penalty + travel cost\n int best_dig_r = -1;\n int min_dig_cost = 10000;\n \n for (int i = 0; i < N; ++i) {\n int target = next_needed[i];\n if (target >= i * N + N) continue; \n \n for (int r = 0; r < N; ++r) {\n for (int j = ptr[r]; j < N; ++j) {\n if (A[r][j] == target) {\n int depth = j - ptr[r]; // Number of blocking containers\n int cost = depth * 15 + abs(cr - r); // Heavily penalize depth, break ties by distance\n if (cost < min_dig_cost) {\n min_dig_cost = cost;\n best_dig_r = r;\n }\n }\n }\n }\n }\n\n int move_r = -1;\n if (best_dig_r != -1) {\n move_r = best_dig_r;\n } else {\n for (int r = 0; r < N; ++r) {\n if (ptr[r] < N) {\n move_r = r;\n break;\n }\n }\n }\n\n int val = A[move_r][ptr[move_r]];\n int dest_gate = val / N;\n\n // 3. Find the optimal empty temp cell: minimize the vertical detour\n // Ideal 'r' is exactly between 'move_r' and 'dest_gate'\n int best_dist = 10000;\n int temp_r = -1, temp_c = -1;\n for (int c = 1; c < N - 1; ++c) {\n for (int r = 0; r < N; ++r) {\n if (grid[r][c] == -1) {\n int vertical_travel = abs(move_r - r) + abs(r - dest_gate);\n int distance_from_crane = abs(cr - move_r) + abs(0 - c); // secondary tie-breaker\n int cost = vertical_travel * 10 + c; \n \n if (cost < best_dist) {\n best_dist = cost;\n temp_r = r;\n temp_c = c;\n }\n }\n }\n }\n\n if (temp_r != -1) {\n move_crane(move_r, 0);\n ans0 += 'P';\n ptr[move_r]++;\n\n move_crane(temp_r, temp_c);\n ans0 += 'Q';\n grid[temp_r][temp_c] = val;\n } else {\n // Fallback Force deliver\n Container force_c = {-1, -1, -1};\n int min_diff = 1000;\n for (auto& cont : accessible) {\n int diff = cont.val - next_needed[cont.val / N];\n if (diff >= 0 && diff < min_diff) {\n min_diff = diff;\n force_c = cont;\n }\n }\n\n move_crane(force_c.r, force_c.c);\n ans0 += 'P';\n \n if (force_c.c == 0) ptr[force_c.r]++;\n else grid[force_c.r][force_c.c] = -1;\n\n int gate = force_c.val / N;\n move_crane(gate, N - 1);\n ans0 += 'Q';\n \n is_delivered[force_c.val] = true;\n delivered++;\n }\n }\n }\n \n cout << ans0 << \"\\n\";\n for (int i = 1; i < N; ++i) {\n cout << \"B\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 int x = 0, y = 0;\n long long load = 0;\n\n while (true) {\n bool action_taken = false;\n\n // Opportunistic pickup\n if (h[x][y] > 0) {\n int amt = h[x][y];\n cout << \"+\" << amt << \"\\n\";\n load += amt;\n h[x][y] -= amt;\n action_taken = true;\n } \n // Opportunistic dropoff\n else if (load > 0 && h[x][y] < 0) {\n long long amt = min(load, (long long)-h[x][y]);\n cout << \"-\" << amt << \"\\n\";\n load -= amt;\n h[x][y] += amt;\n action_taken = true;\n }\n\n if (action_taken) continue;\n\n // Check completion\n bool done = true;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (h[i][j] != 0) {\n done = false;\n break;\n }\n }\n if (!done) break;\n }\n if (done) break;\n\n // Target selection (Pure shortest distance)\n int best_dist = 1e9;\n pair target = {-1, -1};\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (load == 0 && h[i][j] > 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n } else if (load > 0 && h[i][j] < 0) {\n int d = abs(i - x) + abs(j - y);\n if (d < best_dist) {\n best_dist = d;\n target = {i, j};\n }\n }\n }\n }\n\n if (target.first == -1) break;\n\n // Smart Pathfinding: choose the best immediate step among shortest paths\n int nx1 = x, ny1 = y; char move1 = ' ';\n int nx2 = x, ny2 = y; char move2 = ' ';\n\n if (x < target.first) { nx1 = x + 1; move1 = 'D'; }\n else if (x > target.first) { nx1 = x - 1; move1 = 'U'; }\n\n if (y < target.second) { ny2 = y + 1; move2 = 'R'; }\n else if (y > target.second) { ny2 = y - 1; move2 = 'L'; }\n\n if (move1 != ' ' && move2 != ' ') {\n // Both vertical and horizontal moves are valid. Evaluate utility.\n bool utility1 = (h[nx1][ny1] > 0) || (load > 0 && h[nx1][ny1] < 0);\n bool utility2 = (h[nx2][ny2] > 0) || (load > 0 && h[nx2][ny2] < 0);\n\n if (utility2 && !utility1) {\n y = ny2;\n cout << move2 << \"\\n\";\n } else {\n x = nx1;\n cout << move1 << \"\\n\";\n }\n } else if (move1 != ' ') {\n x = nx1;\n cout << move1 << \"\\n\";\n } else if (move2 != ' ') {\n y = ny2;\n cout << move2 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Seed {\n int id;\n vector x;\n int sum;\n};\n\nint N, M, T;\nint seed_count;\nvector seeds;\n\n// Calculate the score of a pair of seeds\ninline int pair_score(const Seed& a, const Seed& b) {\n int score = 0;\n for (int l = 0; l < M; ++l) {\n score += max(a.x[l], b.x[l]);\n }\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> T)) return 0;\n seed_count = 2 * N * (N - 1);\n seeds.resize(seed_count);\n\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].x.resize(M);\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n\n mt19937 rng(42);\n auto start_time = steady_clock::now();\n\n for (int t = 0; t < T; t++) {\n vector selected_ids;\n vector used(seed_count, false);\n\n // Select the top 1 seed for each criterion to maintain diversity\n for (int l = 0; l < M; ++l) {\n int best_id = -1;\n int best_val = -1;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i] && seeds[i].x[l] > best_val) {\n best_val = seeds[i].x[l];\n best_id = i;\n }\n }\n if (best_id != -1) {\n selected_ids.push_back(best_id);\n used[best_id] = true;\n }\n }\n\n // Fill the rest with the highest sum seeds\n vector remaining;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i]) remaining.push_back(i);\n }\n sort(remaining.begin(), remaining.end(), [&](int a, int b) {\n return seeds[a].sum > seeds[b].sum;\n });\n\n for (int i = 0; selected_ids.size() < N * N; ++i) {\n selected_ids.push_back(remaining[i]);\n }\n\n // Initialize grid randomly\n shuffle(selected_ids.begin(), selected_ids.end(), rng);\n vector> grid(N, vector(N));\n int idx = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n grid[r][c] = selected_ids[idx++];\n }\n }\n\n // Calculate initial score\n int current_score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (r + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r+1][c]]);\n if (c + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r][c+1]]);\n }\n }\n\n // Simulated Annealing\n double time_limit_per_turn = 1.9 / T; \n auto turn_start = steady_clock::now();\n double start_temp = 20.0;\n double end_temp = 0.1;\n int iter = 0;\n\n while (true) {\n if ((iter & 255) == 0) {\n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n if (elapsed >= time_limit_per_turn) break;\n }\n iter++;\n\n int r1 = uniform_int_distribution(0, N - 1)(rng);\n int c1 = uniform_int_distribution(0, N - 1)(rng);\n int r2 = uniform_int_distribution(0, N - 1)(rng);\n int c2 = uniform_int_distribution(0, N - 1)(rng);\n if (r1 == r2 && c1 == c2) continue;\n\n int old_contrib = 0;\n int new_contrib = 0;\n \n int s1 = grid[r1][c1];\n int s2 = grid[r2][c2];\n\n const int dr[] = {-1, 1, 0, 0};\n const int dc[] = {0, 0, -1, 1};\n\n for (int d = 0; d < 4; ++d) {\n int nr1 = r1 + dr[d], nc1 = c1 + dc[d];\n if (nr1 >= 0 && nr1 < N && nc1 >= 0 && nc1 < N) {\n if (nr1 != r2 || nc1 != c2) {\n old_contrib += pair_score(seeds[s1], seeds[grid[nr1][nc1]]);\n new_contrib += pair_score(seeds[s2], seeds[grid[nr1][nc1]]);\n }\n }\n int nr2 = r2 + dr[d], nc2 = c2 + dc[d];\n if (nr2 >= 0 && nr2 < N && nc2 >= 0 && nc2 < N) {\n if (nr2 != r1 || nc2 != c1) {\n old_contrib += pair_score(seeds[s2], seeds[grid[nr2][nc2]]);\n new_contrib += pair_score(seeds[s1], seeds[grid[nr2][nc2]]);\n }\n }\n }\n\n int diff = new_contrib - old_contrib;\n \n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n double temp = start_temp * pow(end_temp / start_temp, elapsed / time_limit_per_turn);\n\n if (diff >= 0 || uniform_real_distribution(0.0, 1.0)(rng) < exp(diff / temp)) {\n current_score += diff;\n swap(grid[r1][c1], grid[r2][c2]);\n }\n }\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n cout << grid[r][c] << (c == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n if (t < T - 1) {\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int dx[4] = {0, 1, 0, -1};\nconst int dy[4] = {1, 0, -1, 0};\nconst char move_char[4] = {'R', 'D', 'L', 'U'};\n\nstruct State {\n int rx, ry, dir;\n};\n\nint N, M, V;\nvector s_grid, t_grid;\n\nbool is_valid_root(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nstring navigate(int& rx, int& ry, int& dir, int target_x, int target_y) {\n int dist[35][35][4];\n pair parent_action[35][35][4];\n tuple parent_state[35][35][4];\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n for (int d = 0; d < 4; ++d)\n dist[i][j][d] = 1e9;\n \n queue q;\n q.push({rx, ry, dir});\n dist[rx][ry][dir] = 0;\n \n int end_rx = -1, end_ry = -1, end_dir = -1;\n \n while (!q.empty()) {\n auto [cx, cy, cd] = q.front();\n q.pop();\n \n int lx = cx + dx[cd];\n int ly = cy + dy[cd];\n if (lx == target_x && ly == target_y) {\n end_rx = cx; end_ry = cy; end_dir = cd;\n break;\n }\n \n for (int i = 0; i < 4; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n if (is_valid_root(nx, ny) && dist[nx][ny][cd] > dist[cx][cy][cd] + 1) {\n dist[nx][ny][cd] = dist[cx][cy][cd] + 1;\n parent_action[nx][ny][cd] = {0, i};\n parent_state[nx][ny][cd] = {cx, cy, cd};\n q.push({nx, ny, cd});\n }\n }\n \n int nd_r = (cd + 1) % 4;\n if (dist[cx][cy][nd_r] > dist[cx][cy][cd] + 1) {\n dist[cx][cy][nd_r] = dist[cx][cy][cd] + 1;\n parent_action[cx][cy][nd_r] = {1, 1};\n parent_state[cx][cy][nd_r] = {cx, cy, cd};\n q.push({cx, cy, nd_r});\n }\n \n int nd_l = (cd + 3) % 4;\n if (dist[cx][cy][nd_l] > dist[cx][cy][cd] + 1) {\n dist[cx][cy][nd_l] = dist[cx][cy][cd] + 1;\n parent_action[cx][cy][nd_l] = {1, -1};\n parent_state[cx][cy][nd_l] = {cx, cy, cd};\n q.push({cx, cy, nd_l});\n }\n }\n \n if (end_rx == -1) return \"\"; \n \n vector commands;\n int cx = end_rx, cy = end_ry, cd = end_dir;\n while (cx != rx || cy != ry || cd != dir) {\n auto [atype, aval] = parent_action[cx][cy][cd];\n auto [px, py, pd] = parent_state[cx][cy][cd];\n \n string cmd = \"....\";\n if (atype == 0) {\n cmd[0] = move_char[aval];\n } else {\n cmd[1] = (aval == 1) ? 'R' : 'L';\n }\n commands.push_back(cmd);\n cx = px; cy = py; cd = pd;\n }\n \n string final_commands = \"\";\n for (int i = (int)commands.size() - 1; i >= 0; --i) {\n final_commands += commands[i] + \"\\n\";\n }\n \n rx = end_rx; ry = end_ry; dir = end_dir;\n return final_commands;\n}\n\ninline int dist_manhattan(const pair& a, const pair& b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint get_cost(const vector& order, const vector& target_of, const vector>& sources, const vector>& targets) {\n int cost = 0;\n pair cur = {0, 1}; \n for (int i = 0; i < (int)order.size(); ++i) {\n int s_idx = order[i];\n int t_idx = target_of[s_idx];\n cost += dist_manhattan(cur, sources[s_idx]);\n cost += dist_manhattan(sources[s_idx], targets[t_idx]);\n cur = targets[t_idx];\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> N >> M >> V)) return 0;\n \n s_grid.resize(N);\n t_grid.resize(N);\n for (int i = 0; i < N; ++i) cin >> s_grid[i];\n for (int i = 0; i < N; ++i) cin >> t_grid[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_grid[i][j] == '1' && t_grid[i][j] == '0') sources.push_back({i, j});\n if (s_grid[i][j] == '0' && t_grid[i][j] == '1') targets.push_back({i, j});\n }\n }\n \n int num_t = sources.size();\n vector target_of(num_t);\n vector order(num_t);\n \n // Greedy Initialization\n vector used_s(num_t, false);\n vector used_t(num_t, false);\n pair cur = {0, 1}; // Initial leaf position\n for (int i = 0; i < num_t; ++i) {\n int best_s = -1, min_ds = 1e9;\n for (int j = 0; j < num_t; ++j) {\n if (!used_s[j]) {\n int d = dist_manhattan(cur, sources[j]);\n if (d < min_ds) {\n min_ds = d;\n best_s = j;\n }\n }\n }\n order[i] = best_s;\n used_s[best_s] = true;\n \n int best_t = -1, min_dt = 1e9;\n for (int j = 0; j < num_t; ++j) {\n if (!used_t[j]) {\n int d = dist_manhattan(sources[best_s], targets[j]);\n if (d < min_dt) {\n min_dt = d;\n best_t = j;\n }\n }\n }\n target_of[best_s] = best_t;\n used_t[best_t] = true;\n cur = targets[best_t];\n }\n \n mt19937 rng(42);\n int current_cost = get_cost(order, target_of, sources, targets);\n \n double temp_start = 50.0;\n double temp_end = 0.1;\n double max_time = 2.0; \n \n int iterations = 0;\n while (true) {\n if ((iterations & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n }\n iterations++;\n \n double elapsed = chrono::duration(chrono::high_resolution_clock::now() - start_time).count();\n double temp = temp_start * pow(temp_end / temp_start, elapsed / max_time);\n \n int type = uniform_int_distribution<>(0, 1)(rng);\n \n if (type == 0 && num_t >= 2) {\n // Swap order with exact delta\n int i = uniform_int_distribution<>(0, num_t - 1)(rng);\n int j = uniform_int_distribution<>(0, num_t - 1)(rng);\n if (i == j) continue;\n if (i > j) swap(i, j);\n \n int delta = 0;\n auto get_pos_before = [&](int idx) { return (idx == 0) ? make_pair(0, 1) : targets[target_of[order[idx-1]]]; };\n \n if (j == i + 1) {\n delta -= dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta -= dist_manhattan(targets[target_of[order[i]]], sources[order[j]]);\n if (j + 1 < num_t) delta -= dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n \n swap(order[i], order[j]);\n \n delta += dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta += dist_manhattan(targets[target_of[order[i]]], sources[order[j]]);\n if (j + 1 < num_t) delta += dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n } else {\n delta -= dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta -= dist_manhattan(targets[target_of[order[i]]], sources[order[i+1]]);\n delta -= dist_manhattan(get_pos_before(j), sources[order[j]]);\n if (j + 1 < num_t) delta -= dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n \n swap(order[i], order[j]);\n \n delta += dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta += dist_manhattan(targets[target_of[order[i]]], sources[order[i+1]]);\n delta += dist_manhattan(get_pos_before(j), sources[order[j]]);\n if (j + 1 < num_t) delta += dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n }\n \n if (delta <= 0 || uniform_real_distribution<>(0.0, 1.0)(rng) < exp(-delta / temp)) {\n current_cost += delta;\n } else {\n swap(order[i], order[j]); // rollback\n }\n \n } else if (type == 1 && num_t >= 2) {\n // Swap targets with exact delta\n int i = uniform_int_distribution<>(0, num_t - 1)(rng);\n int j = uniform_int_distribution<>(0, num_t - 1)(rng);\n if (i == j) continue;\n \n int s1 = order[i], s2 = order[j];\n int t1 = target_of[s1], t2 = target_of[s2];\n \n int delta = 0;\n delta -= dist_manhattan(sources[s1], targets[t1]);\n if (i + 1 < num_t) delta -= dist_manhattan(targets[t1], sources[order[i+1]]);\n delta -= dist_manhattan(sources[s2], targets[t2]);\n if (j + 1 < num_t) delta -= dist_manhattan(targets[t2], sources[order[j+1]]);\n \n swap(target_of[s1], target_of[s2]);\n \n delta += dist_manhattan(sources[s1], targets[t2]);\n if (i + 1 < num_t) delta += dist_manhattan(targets[t2], sources[order[i+1]]);\n delta += dist_manhattan(sources[s2], targets[t1]);\n if (j + 1 < num_t) delta += dist_manhattan(targets[t1], sources[order[j+1]]);\n \n if (delta <= 0 || uniform_real_distribution<>(0.0, 1.0)(rng) < exp(-delta / temp)) {\n current_cost += delta;\n } else {\n swap(target_of[s1], target_of[s2]); // rollback\n }\n }\n }\n \n cout << 2 << \"\\n\";\n cout << 0 << \" \" << 1 << \"\\n\";\n \n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n int dir = 0; \n \n for (int i = 0; i < num_t; ++i) {\n int s_idx = order[i];\n int t_idx = target_of[s_idx];\n \n cout << navigate(rx, ry, dir, sources[s_idx].first, sources[s_idx].second);\n cout << \"...P\\n\"; \n \n cout << navigate(rx, ry, dir, targets[t_idx].first, targets[t_idx].second);\n cout << \"...P\\n\"; \n }\n \n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_COORD = 100000;\nconst int B_COARSE = 200; \nconst int CELL = MAX_COORD / B_COARSE;\nconst int STRIPS = 250; \n\nstruct Point {\n int x, y;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector mackerels(N);\n vector sardines(N);\n vector> grid(B_COARSE, vector(B_COARSE, 0));\n\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n int gx = min(mackerels[i].x / CELL, B_COARSE - 1);\n int gy = min(mackerels[i].y / CELL, B_COARSE - 1);\n grid[gx][gy]++;\n }\n\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n int gx = min(sardines[i].x / CELL, B_COARSE - 1);\n int gy = min(sardines[i].y / CELL, B_COARSE - 1);\n grid[gx][gy]--;\n }\n\n // Initial guess: 2D Kadane's algorithm\n int max_sum = -1e9;\n int best_r1 = 0, best_r2 = 0, best_c1 = 0, best_c2 = 0;\n\n for (int r1 = 0; r1 < B_COARSE; r1++) {\n vector temp(B_COARSE, 0);\n for (int r2 = r1; r2 < B_COARSE; r2++) {\n for (int c = 0; c < B_COARSE; c++) temp[c] += grid[r2][c];\n int current_sum = 0, c1 = 0;\n for (int c = 0; c < B_COARSE; c++) {\n current_sum += temp[c];\n if (current_sum > max_sum) {\n max_sum = current_sum;\n best_r1 = r1; best_r2 = r2;\n best_c1 = c1; best_c2 = c;\n }\n if (current_sum < 0) { current_sum = 0; c1 = c + 1; }\n }\n }\n }\n\n int init_x1 = best_r1 * CELL;\n int init_x2 = min((best_r2 + 1) * CELL, MAX_COORD);\n int init_y1 = best_c1 * CELL;\n int init_y2 = min((best_c2 + 1) * CELL, MAX_COORD);\n\n int strip_height = (MAX_COORD + STRIPS - 1) / STRIPS;\n \n int start_strip = init_y1 / strip_height;\n int end_strip = init_y2 / strip_height;\n if (end_strip >= STRIPS) end_strip = STRIPS - 1;\n if (start_strip > end_strip) start_strip = end_strip;\n\n vector L(STRIPS, init_x1);\n vector R(STRIPS, init_x2);\n\n vector> mack_x(STRIPS);\n vector> sard_x(STRIPS);\n\n for (const auto& p : mackerels) {\n int s = min(p.y / strip_height, STRIPS - 1);\n mack_x[s].push_back(p.x);\n }\n for (const auto& p : sardines) {\n int s = min(p.y / strip_height, STRIPS - 1);\n sard_x[s].push_back(p.x);\n }\n\n auto get_strip_score = [&](int strip, int l, int r) {\n int s = 0;\n for (int x : mack_x[strip]) if (x >= l && x <= r) s++;\n for (int x : sard_x[strip]) if (x >= l && x <= r) s--;\n return s;\n };\n\n int current_score = 0;\n vector strip_scores(STRIPS, 0);\n for (int i = start_strip; i <= end_strip; i++) {\n strip_scores[i] = get_strip_score(i, L[i], R[i]);\n current_score += strip_scores[i];\n }\n\n long long current_perim = (R[start_strip] - L[start_strip]) + (R[end_strip] - L[end_strip]);\n current_perim += 2LL * (end_strip - start_strip + 1) * strip_height;\n for (int i = start_strip; i < end_strip; i++) {\n current_perim += abs(L[i+1] - L[i]) + abs(R[i+1] - R[i]);\n }\n\n mt19937 rng(42);\n int iterations = 0;\n double T0 = 10.0;\n double T1 = 0.05;\n\n while (true) {\n if ((iterations & 4095) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.90) break;\n }\n iterations++;\n\n int strip = uniform_int_distribution(start_strip, end_strip)(rng);\n bool is_L = uniform_int_distribution(0, 1)(rng);\n int delta = uniform_int_distribution(-6000, 6000)(rng);\n\n int old_val = is_L ? L[strip] : R[strip];\n int new_val = clamp(old_val + delta, 0, MAX_COORD);\n\n if (is_L) {\n if (new_val >= R[strip] - 1) continue;\n if (strip > start_strip && new_val > R[strip - 1]) continue;\n if (strip < end_strip && new_val > R[strip + 1]) continue;\n } else {\n if (new_val <= L[strip] + 1) continue;\n if (strip > start_strip && new_val < L[strip - 1]) continue;\n if (strip < end_strip && new_val < L[strip + 1]) continue;\n }\n\n long long diff_perim = 0;\n if (is_L) {\n if (strip == start_strip) diff_perim += (old_val - new_val);\n if (strip == end_strip) diff_perim += (old_val - new_val);\n if (strip > start_strip) diff_perim += abs(new_val - L[strip - 1]) - abs(old_val - L[strip - 1]);\n if (strip < end_strip) diff_perim += abs(L[strip + 1] - new_val) - abs(L[strip + 1] - old_val);\n } else {\n if (strip == start_strip) diff_perim += (new_val - old_val);\n if (strip == end_strip) diff_perim += (new_val - old_val);\n if (strip > start_strip) diff_perim += abs(new_val - R[strip - 1]) - abs(old_val - R[strip - 1]);\n if (strip < end_strip) diff_perim += abs(R[strip + 1] - new_val) - abs(R[strip + 1] - old_val);\n }\n\n if (current_perim + diff_perim > 400000LL) continue;\n\n int new_strip_score = get_strip_score(strip, is_L ? new_val : L[strip], is_L ? R[strip] : new_val);\n int diff = new_strip_score - strip_scores[strip];\n\n double elapsed = chrono::duration(chrono::high_resolution_clock::now() - start_time).count();\n double temp = T0 * pow(T1 / T0, elapsed / 1.90);\n\n if (diff >= 0 || uniform_real_distribution(0, 1)(rng) < exp(diff / temp)) {\n current_score += diff;\n strip_scores[strip] = new_strip_score;\n current_perim += diff_perim;\n if (is_L) L[strip] = new_val;\n else R[strip] = new_val;\n }\n }\n\n vector vertices;\n vertices.push_back({L[start_strip], start_strip * strip_height});\n for (int i = start_strip; i <= end_strip; i++) {\n if (i > start_strip) {\n vertices.push_back({L[i-1], i * strip_height});\n vertices.push_back({L[i], i * strip_height});\n }\n }\n vertices.push_back({L[end_strip], min((end_strip + 1) * strip_height, MAX_COORD)});\n\n vertices.push_back({R[end_strip], min((end_strip + 1) * strip_height, MAX_COORD)});\n for (int i = end_strip; i >= start_strip; i--) {\n if (i < end_strip) {\n vertices.push_back({R[i+1], (i + 1) * strip_height});\n vertices.push_back({R[i], (i + 1) * strip_height});\n }\n }\n vertices.push_back({R[start_strip], start_strip * strip_height});\n\n vector simplified;\n for (size_t i = 0; i < vertices.size(); i++) {\n Point prev = vertices[(i + vertices.size() - 1) % vertices.size()];\n Point curr = vertices[i];\n Point next = vertices[(i + 1) % vertices.size()];\n if ((prev.x == curr.x && curr.x == next.x) || (prev.y == curr.y && curr.y == next.y)) continue; \n simplified.push_back(curr);\n }\n\n if (simplified.size() < 4) simplified = {{init_x1, init_y1}, {init_x2, init_y1}, {init_x2, init_y2}, {init_x1, init_y2}};\n if (simplified.size() > 1000) simplified = {{init_x1, init_y1}, {init_x2, init_y1}, {init_x2, init_y2}, {init_x1, init_y2}};\n\n cout << simplified.size() << \"\\n\";\n for (const auto& v : simplified) cout << v.x << \" \" << v.y << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n int r;\n char d;\n int b;\n};\n\nint N, T;\nlong long sigma;\nvector rects;\n\nmt19937 rng(1337);\n\nlong long X_pos[105];\nlong long Y_pos[105];\nlong long W_arr[105];\nlong long H_arr[105];\n\ninline long long simulate(const vector& p, long long& out_W, long long& out_H) {\n long long max_X = 0, max_Y = 0;\n\n for (int i = 0; i < N; ++i) {\n if (p[i].r == 1) {\n W_arr[i] = rects[i].h;\n H_arr[i] = rects[i].w;\n } else {\n W_arr[i] = rects[i].w;\n H_arr[i] = rects[i].h;\n }\n\n if (p[i].d == 'U') {\n long long cur_x = (p[i].b == -1) ? 0 : (X_pos[p[i].b] + W_arr[p[i].b]);\n X_pos[i] = cur_x;\n \n long long cur_y = 0;\n long long right_x = cur_x + W_arr[i];\n \n for (int j = 0; j < i; ++j) {\n if (cur_x < X_pos[j] + W_arr[j] && X_pos[j] < right_x) {\n long long top_y = Y_pos[j] + H_arr[j];\n if (top_y > cur_y) cur_y = top_y;\n }\n }\n Y_pos[i] = cur_y;\n } else {\n long long cur_y = (p[i].b == -1) ? 0 : (Y_pos[p[i].b] + H_arr[p[i].b]);\n Y_pos[i] = cur_y;\n \n long long cur_x = 0;\n long long bottom_y = cur_y + H_arr[i];\n \n for (int j = 0; j < i; ++j) {\n if (cur_y < Y_pos[j] + H_arr[j] && Y_pos[j] < bottom_y) {\n long long right_x = X_pos[j] + W_arr[j];\n if (right_x > cur_x) cur_x = right_x;\n }\n }\n X_pos[i] = cur_x;\n }\n \n long long end_x = X_pos[i] + W_arr[i];\n long long end_y = Y_pos[i] + H_arr[i];\n \n if (end_x > max_X) max_X = end_x;\n if (end_y > max_Y) max_Y = end_y;\n }\n \n out_W = max_X;\n out_H = max_Y;\n return max_X + max_Y;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> T >> sigma)) return 0;\n\n rects.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> rects[i].w >> rects[i].h;\n }\n\n auto start_time = chrono::steady_clock::now();\n auto max_time = start_time + chrono::milliseconds(2850);\n\n vector best_overall_p(N);\n for (int i = 0; i < N; ++i) {\n best_overall_p[i] = {0, 'U', -1};\n }\n long long overall_W, overall_H;\n long long best_overall_score = simulate(best_overall_p, overall_W, overall_H);\n\n double temp_start = 20000.0;\n double temp_end = 1.0;\n\n for (int t = 0; t < T; ++t) {\n auto now = chrono::steady_clock::now();\n double remaining_time = chrono::duration(max_time - now).count();\n double time_for_this_turn = remaining_time / (T - t);\n auto turn_end_time = now + chrono::duration(time_for_this_turn);\n\n vector current_p = best_overall_p;\n long long current_score = best_overall_score;\n\n int iters_per_check = 150;\n \n while (true) {\n auto current_time = chrono::steady_clock::now();\n if (current_time >= turn_end_time) break;\n \n double elapsed_ratio = chrono::duration(current_time - now).count() / time_for_this_turn;\n double temp = temp_start * pow(temp_end / temp_start, elapsed_ratio);\n\n for (int it = 0; it < iters_per_check; ++it) {\n int i = rng() % N;\n Placement old_pl = current_p[i];\n \n int r_type = rng() % 3;\n if (r_type == 0) {\n current_p[i].r ^= 1;\n } else if (r_type == 1) {\n current_p[i].d = (current_p[i].d == 'U') ? 'L' : 'U';\n } else {\n current_p[i].b = (i == 0) ? -1 : ((int)(rng() % (i + 1)) - 1);\n }\n\n long long W, H;\n long long new_score = simulate(current_p, W, H);\n \n bool accept = false;\n if (new_score <= current_score) {\n accept = true;\n } else {\n double prob = exp((current_score - new_score) / temp);\n if (generate_canonical(rng) < prob) {\n accept = true;\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score < best_overall_score) {\n best_overall_score = current_score;\n best_overall_p = current_p;\n }\n } else {\n current_p[i] = old_pl;\n }\n }\n }\n\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << \" \" << best_overall_p[i].r << \" \" << best_overall_p[i].d << \" \" << best_overall_p[i].b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nuint64_t xorshift64() {\n static uint64_t x = 88172645463325252ULL;\n x ^= x << 13;\n x ^= x >> 7;\n x ^= x << 17;\n return x;\n}\n\ndouble next_double() {\n return (xorshift64() >> 11) * (1.0 / 9007199254740992.0);\n}\n\ninline uint32_t fast_rand(uint32_t range) {\n return (uint32_t)((xorshift64() & 0xFFFFFFFFull) * range >> 32);\n}\n\nconst int MAX_H = 10;\nint N, M, H;\nvector A;\nvector> adj;\n\nstruct FastTreeState {\n vector p;\n vector first_child;\n vector next_sibling;\n vector prev_sibling;\n vector depth;\n vector max_rel_height;\n vector subtree_A;\n long long score;\n\n FastTreeState() {\n p.assign(N, -1);\n first_child.assign(N, -1);\n next_sibling.assign(N, -1);\n prev_sibling.assign(N, -1);\n depth.assign(N, 0);\n max_rel_height.assign(N, 0);\n subtree_A.assign(N, 0);\n score = 0;\n for (int i = 0; i < N; ++i) {\n subtree_A[i] = A[i];\n score += A[i];\n }\n }\n\n inline void add_child(int parent, int child) {\n if (parent == -1) return;\n int head = first_child[parent];\n next_sibling[child] = head;\n if (head != -1) prev_sibling[head] = child;\n prev_sibling[child] = -1;\n first_child[parent] = child;\n }\n\n inline void remove_child(int parent, int child) {\n if (parent == -1) return;\n int prev = prev_sibling[child];\n int next = next_sibling[child];\n if (prev != -1) next_sibling[prev] = next;\n else first_child[parent] = next;\n if (next != -1) prev_sibling[next] = prev;\n prev_sibling[child] = -1;\n next_sibling[child] = -1;\n }\n\n void update_up(int node) {\n while (node != -1) {\n long long sum_A = A[node];\n int max_h = 0;\n int c = first_child[node];\n while (c != -1) {\n sum_A += subtree_A[c];\n if (max_rel_height[c] + 1 > max_h) {\n max_h = max_rel_height[c] + 1;\n }\n c = next_sibling[c];\n }\n subtree_A[node] = sum_A;\n max_rel_height[node] = max_h;\n node = p[node];\n }\n }\n\n void update_depth(int u) {\n int c = first_child[u];\n while (c != -1) {\n depth[c] = depth[u] + 1;\n update_depth(c);\n c = next_sibling[c];\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> M >> H)) return 0;\n\n A.resize(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n\n adj.resize(N);\n for (int i = 0; i < M; ++i) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n\n // Skip coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n FastTreeState state;\n \n vector visited(N, false);\n for (int i = 0; i < N; ++i) {\n if (!visited[i]) {\n visited[i] = true;\n vector q;\n q.push_back(i);\n int head = 0;\n while (head < (int)q.size()) {\n int u = q[head++];\n if (state.depth[u] >= H) continue;\n for (int v : adj[u]) {\n if (!visited[v]) {\n visited[v] = true;\n state.add_child(u, v);\n state.p[v] = u;\n state.depth[v] = state.depth[u] + 1;\n q.push_back(v);\n }\n }\n }\n for (int j = (int)q.size() - 1; j >= 0; --j) {\n int u = q[j];\n long long sum_A = A[u];\n int max_h = 0;\n int c = state.first_child[u];\n while (c != -1) {\n sum_A += state.subtree_A[c];\n if (state.max_rel_height[c] + 1 > max_h) {\n max_h = state.max_rel_height[c] + 1;\n }\n c = state.next_sibling[c];\n }\n state.subtree_A[u] = sum_A;\n state.max_rel_height[u] = max_h;\n }\n }\n }\n\n long long best_score = state.score;\n vector best_p = state.p;\n\n double T0 = 200.0;\n double T1 = 0.01;\n long long iter = 0;\n double temp = T0;\n \n while (true) {\n if ((iter & 8191) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.95) break;\n double progress = elapsed / 1.95;\n if (progress > 1.0) progress = 1.0;\n temp = T0 * pow(T1 / T0, progress);\n }\n iter++;\n \n int v = fast_rand(N);\n int num_options = adj[v].size() + 1;\n int opt = fast_rand(num_options);\n int u = (opt == (int)adj[v].size()) ? -1 : adj[v][opt];\n\n if (state.p[v] == u) continue;\n\n // Depth-based optimization for cycle check\n bool cycle = false;\n if (u != -1 && state.depth[u] >= state.depth[v]) {\n int curr = u;\n while (curr != -1) {\n if (curr == v) {\n cycle = true;\n break;\n }\n curr = state.p[curr];\n }\n }\n if (cycle) continue;\n\n int new_v_depth = (u == -1) ? 0 : state.depth[u] + 1;\n if (new_v_depth + state.max_rel_height[v] > H) continue;\n\n long long delta_score = (long long)(new_v_depth - state.depth[v]) * state.subtree_A[v];\n\n if (delta_score >= 0 || next_double() < exp(delta_score / temp)) {\n int old_p = state.p[v];\n state.remove_child(old_p, v);\n state.add_child(u, v);\n state.p[v] = u;\n state.depth[v] = new_v_depth;\n \n state.update_depth(v);\n state.update_up(old_p);\n state.update_up(u);\n state.score += delta_score;\n\n if (state.score > best_score) {\n best_score = state.score;\n best_p = state.p;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_p[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\n\nstruct State {\n uint32_t oni[20];\n uint32_t fuku[20];\n int oni_count;\n};\n\nvector> solve(State initial_state, double alpha, double noise_level, mt19937& rng, int current_best_size) {\n State state = initial_state;\n vector> moves;\n moves.reserve(current_best_size);\n \n uniform_real_distribution dist(0.0, noise_level);\n\n while (state.oni_count > 0) {\n if ((int)moves.size() >= current_best_size) return {}; // Early abort\n\n double best_score = -1.0;\n char best_dir = ' ';\n int best_idx = -1;\n int best_k = 0;\n\n for (int r = 0; r < N; ++r) {\n // Left\n int dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if ((state.fuku[r] >> (20 - k)) & 1) break;\n if ((state.oni[r] >> (20 - k)) & 1) dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'L'; best_idx = r; best_k = k;\n }\n }\n }\n // Right\n dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if ((state.fuku[r] >> (k - 1)) & 1) break;\n if ((state.oni[r] >> (k - 1)) & 1) dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'R'; best_idx = r; best_k = k;\n }\n }\n }\n }\n\n for (int c = 0; c < N; ++c) {\n // Up\n int dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if ((state.fuku[k - 1] >> (19 - c)) & 1) break;\n if ((state.oni[k - 1] >> (19 - c)) & 1) dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'U'; best_idx = c; best_k = k;\n }\n }\n }\n // Down\n dropped_oni = 0;\n for (int k = 1; k <= N; ++k) {\n if ((state.fuku[N - k] >> (19 - c)) & 1) break;\n if ((state.oni[N - k] >> (19 - c)) & 1) dropped_oni++;\n \n if (dropped_oni > 0) {\n double score = (double)dropped_oni / pow(2.0 * k, alpha) + dist(rng);\n if (score > best_score) {\n best_score = score; best_dir = 'D'; best_idx = c; best_k = k;\n }\n }\n }\n }\n\n if (best_score < 0) break; \n\n // Apply chosen moves to state\n if (best_dir == 'U') {\n for (int i = 0; i < best_k; ++i) { moves.push_back({'U', best_idx}); }\n for (int i = 0; i < best_k; ++i) { moves.push_back({'D', best_idx}); }\n // Since we push and immediately pull, only the dropped elements are modified\n for (int k = 1; k <= best_k; ++k) {\n if ((state.oni[k - 1] >> (19 - best_idx)) & 1) {\n state.oni[k - 1] &= ~(1U << (19 - best_idx));\n state.oni_count--;\n }\n }\n } else if (best_dir == 'D') {\n for (int i = 0; i < best_k; ++i) { moves.push_back({'D', best_idx}); }\n for (int i = 0; i < best_k; ++i) { moves.push_back({'U', best_idx}); }\n for (int k = 1; k <= best_k; ++k) {\n if ((state.oni[N - k] >> (19 - best_idx)) & 1) {\n state.oni[N - k] &= ~(1U << (19 - best_idx));\n state.oni_count--;\n }\n }\n } else if (best_dir == 'L') {\n for (int i = 0; i < best_k; ++i) { moves.push_back({'L', best_idx}); }\n for (int i = 0; i < best_k; ++i) { moves.push_back({'R', best_idx}); }\n for (int k = 1; k <= best_k; ++k) {\n if ((state.oni[best_idx] >> (20 - k)) & 1) {\n state.oni[best_idx] &= ~(1U << (20 - k));\n state.oni_count--;\n }\n }\n } else if (best_dir == 'R') {\n for (int i = 0; i < best_k; ++i) { moves.push_back({'R', best_idx}); }\n for (int i = 0; i < best_k; ++i) { moves.push_back({'L', best_idx}); }\n for (int k = 1; k <= best_k; ++k) {\n if ((state.oni[best_idx] >> (k - 1)) & 1) {\n state.oni[best_idx] &= ~(1U << (k - 1));\n state.oni_count--;\n }\n }\n }\n }\n \n return moves;\n}\n\nint main() {\n auto start_time = chrono::high_resolution_clock::now();\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n \n State initial_state;\n initial_state.oni_count = 0;\n for (int i = 0; i < N; ++i) {\n initial_state.oni[i] = 0;\n initial_state.fuku[i] = 0;\n }\n\n for (int i = 0; i < N; ++i) {\n string row;\n cin >> row;\n for (int j = 0; j < N; ++j) {\n if (row[j] == 'x') {\n initial_state.oni[i] |= (1U << (19 - j));\n initial_state.oni_count++;\n } else if (row[j] == 'o') {\n initial_state.fuku[i] |= (1U << (19 - j));\n }\n }\n }\n \n mt19937 rng(42);\n vector> best_moves;\n int best_moves_size = 1e9;\n\n uniform_real_distribution alpha_dist(0.1, 4.0);\n uniform_real_distribution noise_dist(1e-6, 0.1);\n\n int iterations = 0;\n while (true) {\n iterations++;\n if ((iterations & 255) == 0) { // Check time every 256 iterations\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.9) break; \n }\n\n double alpha = alpha_dist(rng);\n double noise_level = noise_dist(rng);\n \n vector> current_moves = solve(initial_state, alpha, noise_level, rng, best_moves_size);\n \n if (!current_moves.empty() && current_moves.size() < best_moves_size) {\n best_moves_size = current_moves.size();\n best_moves = current_moves;\n }\n }\n \n for (auto p : best_moves) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}","ahc044":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\nint T[N];\n\ninline int simulate(const int* sa, const int* sb) {\n int t[N] = {0};\n int curr = 0;\n for (int step = 0; step < L; ++step) {\n int count = t[curr]++;\n curr = (count & 1) ? sa[curr] : sb[curr];\n }\n int diff = 0;\n for (int i = 0; i < N; ++i) {\n int d = t[i] - T[i];\n diff += (d > 0 ? d : -d);\n }\n return diff;\n}\n\ninline int count_reachable(const int* sa, const int* sb) {\n bool visited[N] = {false};\n int q[N];\n int head = 0, tail = 0;\n \n visited[0] = true;\n q[tail++] = 0;\n \n int count = 0;\n while (head < tail) {\n int u = q[head++];\n count++;\n \n int v1 = sa[u];\n if (!visited[v1]) {\n visited[v1] = true;\n q[tail++] = v1;\n }\n int v2 = sb[u];\n if (!visited[v2]) {\n visited[v2] = true;\n q[tail++] = v2;\n }\n }\n return count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, l_input;\n if (!(cin >> n_input >> l_input)) return 0;\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n int a[N], b[N];\n int W0[N], W1[N];\n int I[N] = {0};\n\n for (int i = 0; i < N; ++i) {\n a[i] = (i + 1) % N;\n b[i] = (i + 1) % N;\n // CORRECTED: b transitions happen on even t (0, 2, 4...), so it gets the ceil\n // a transitions happen on odd t (1, 3, 5...), so it gets the floor\n W0[i] = T[i] / 2; // expected weight for a\n W1[i] = (T[i] + 1) / 2; // expected weight for b\n }\n\n int current_cost_I = 0;\n for (int i = 0; i < N; ++i) {\n I[a[i]] += W0[i];\n I[b[i]] += W1[i];\n }\n for (int i = 0; i < N; ++i) {\n current_cost_I += abs(I[i] - T[i]);\n }\n \n int current_reach = count_reachable(a, b);\n int current_cost = current_cost_I + (N - current_reach) * 20000;\n \n int best_cost = current_cost;\n int best_a[N], best_b[N];\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n\n mt19937 rng(1337);\n auto start_time = chrono::steady_clock::now();\n uniform_real_distribution dist01(0.0, 1.0);\n\n // Phase 1: Fast SA\n double t0 = 5000.0;\n double t1 = 10.0;\n int iter = 0;\n double temp = t0;\n \n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.0) break;\n temp = t0 * pow(t1 / t0, elapsed / 1.0);\n }\n iter++;\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n \n if (old_v == new_v) continue;\n\n int weight = is_a ? W0[u] : W1[u];\n \n int old_I_cost = abs(I[old_v] - T[old_v]) + abs(I[new_v] - T[new_v]);\n I[old_v] -= weight;\n I[new_v] += weight;\n int new_I_cost = abs(I[old_v] - T[old_v]) + abs(I[new_v] - T[new_v]);\n \n int delta_I = new_I_cost - old_I_cost;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_reach = count_reachable(a, b);\n int delta_reach = (N - new_reach) * 20000 - (N - current_reach) * 20000;\n \n int delta = delta_I + delta_reach;\n\n if (delta <= 0 || dist01(rng) < exp(-delta / temp)) {\n current_cost += delta;\n current_cost_I += delta_I;\n current_reach = new_reach;\n \n if (current_cost < best_cost) {\n best_cost = current_cost;\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n I[old_v] += weight;\n I[new_v] -= weight;\n }\n }\n\n // Phase 2: Full Simulation Fine-Tuning\n for (int i = 0; i < N; ++i) {\n a[i] = best_a[i];\n b[i] = best_b[i];\n }\n \n current_cost = simulate(a, b);\n best_cost = current_cost;\n \n t0 = 200.0;\n t1 = 1.0;\n iter = 0;\n temp = t0;\n \n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.95) break;\n\n if ((iter & 63) == 0) {\n temp = t0 * pow(t1 / t0, (elapsed - 1.0) / 0.95);\n }\n iter++;\n\n int u = rng() % N;\n bool is_a = rng() % 2;\n int old_v = is_a ? a[u] : b[u];\n int new_v = rng() % N;\n \n if (old_v == new_v) continue;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_cost = simulate(a, b);\n int delta = new_cost - current_cost;\n\n if (delta <= 0 || dist01(rng) < exp(-delta / temp)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct City {\n int lx, rx, ly, ry;\n long long cx, cy;\n};\n\nint N, M, Q, L, W;\nvector G;\nvector cities;\nlong long D[805][805];\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\nlong long calc_mst(const vector& nodes) {\n int k = nodes.size();\n if (k <= 1) return 0;\n vector min_e(k, 1e18);\n vector vis(k, false);\n min_e[0] = 0;\n long long total = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n long long best_min = 1e18;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && min_e[j] < best_min) {\n best_min = min_e[j];\n v = j;\n }\n }\n if (best_min >= 1e18) break;\n vis[v] = true;\n total += best_min;\n int u_node = nodes[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = D[u_node][nodes[j]];\n if (d < min_e[j]) min_e[j] = d;\n }\n }\n }\n return total;\n}\n\nvector> get_mst_edges(const vector& nodes) {\n int k = nodes.size();\n vector> edges;\n if (k <= 1) return edges;\n vector min_e(k, 1e18);\n vector parent(k, -1);\n vector vis(k, false);\n min_e[0] = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n long long best_min = 1e18;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && min_e[j] < best_min) {\n best_min = min_e[j];\n v = j;\n }\n }\n vis[v] = true;\n if (parent[v] != -1) {\n edges.push_back({nodes[parent[v]], nodes[v]});\n }\n int u_node = nodes[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = D[u_node][nodes[j]];\n if (d < min_e[j]) {\n min_e[j] = d;\n parent[j] = v;\n }\n }\n }\n }\n return edges;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n G.resize(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n cities.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2;\n }\n\n // Precompute approximate distances\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == j) D[i][j] = 0;\n else {\n long long dx = cities[i].cx - cities[j].cx;\n long long dy = cities[i].cy - cities[j].cy;\n D[i][j] = std::floor(std::sqrt(dx * dx + dy * dy));\n }\n }\n }\n\n vector assign(N, -1);\n vector> grps(M);\n vector used(N, false);\n vector g_idx(M);\n iota(g_idx.begin(), g_idx.end(), 0);\n // Sort groups by size descending\n sort(g_idx.begin(), g_idx.end(), [&](int a, int b) { return G[a] > G[b]; });\n\n // Greedy Initialization using sum of squared distances to maintain spherical clusters\n for (int k : g_idx) {\n int start = -1;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) { start = i; break; }\n }\n used[start] = true;\n grps[k].push_back(start);\n assign[start] = k;\n \n while ((int)grps[k].size() < G[k]) {\n int best_c = -1;\n long long best_d = 2e18;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n long long d = 0;\n for (int u : grps[k]) {\n long long dx = cities[u].cx - cities[i].cx;\n long long dy = cities[u].cy - cities[i].cy;\n d += dx * dx + dy * dy;\n }\n if (d < best_d) {\n best_d = d;\n best_c = i;\n }\n }\n }\n used[best_c] = true;\n grps[k].push_back(best_c);\n assign[best_c] = k;\n }\n }\n\n vector mst_cost(M);\n for (int i = 0; i < M; ++i) mst_cost[i] = calc_mst(grps[i]);\n\n // Simulated Annealing\n auto start_time = chrono::steady_clock::now();\n double max_time = 0.40; // Intentionally limited to prevent overfitting\n int iter = 0;\n mt19937 rng(42);\n uniform_int_distribution dist_N(0, N - 1);\n uniform_real_distribution dist_01(0.0, 1.0);\n \n double t0 = 1000.0, t1 = 10.0;\n double temp = t0;\n\n vector> nn(N);\n for(int i = 0; i < N; ++i){\n vector> dists;\n for(int j = 0; j < N; ++j) if(i != j) dists.push_back({D[i][j], j});\n sort(dists.begin(), dists.end());\n for(int j = 0; j < min(N - 1, 50); ++j) nn[i].push_back(dists[j].second);\n }\n\n while (true) {\n if ((iter & 127) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n temp = t0 * pow(t1 / t0, elapsed / max_time);\n }\n iter++;\n\n int u = dist_N(rng);\n int v;\n if (dist_01(rng) < 0.7 && !nn[u].empty()) {\n v = nn[u][rng() % nn[u].size()];\n } else {\n v = dist_N(rng);\n }\n\n if (assign[u] == assign[v]) continue;\n\n int gu = assign[u];\n int gv = assign[v];\n long long old_cost = mst_cost[gu] + mst_cost[gv];\n\n // Swap\n for (int& x : grps[gu]) if (x == u) x = v;\n for (int& x : grps[gv]) if (x == v) x = u;\n\n long long new_u_cost = calc_mst(grps[gu]);\n long long new_v_cost = calc_mst(grps[gv]);\n long long new_cost = new_u_cost + new_v_cost;\n\n if (new_cost <= old_cost || exp((old_cost - new_cost) / temp) > dist_01(rng)) {\n mst_cost[gu] = new_u_cost;\n mst_cost[gv] = new_v_cost;\n assign[u] = gv;\n assign[v] = gu;\n } else {\n // Revert\n for (int& x : grps[gu]) if (x == v) x = u;\n for (int& x : grps[gv]) if (x == u) x = v;\n }\n }\n\n // Query Phase to retrieve exact MST edges\n vector>> final_group_edges(M);\n \n for (int k = 0; k < M; ++k) {\n auto approx_edges = get_mst_edges(grps[k]);\n \n vector> adj(N);\n for (auto& e : approx_edges) {\n adj[e.first].push_back(e.second);\n adj[e.second].push_back(e.first);\n }\n \n vector seq;\n vector vis2(N, false);\n auto dfs = [&](auto& self, int u) -> void {\n vis2[u] = true;\n seq.push_back(u);\n for (int v : adj[u]) {\n if (!vis2[v]) self(self, v);\n }\n };\n if (!grps[k].empty()) dfs(dfs, grps[k][0]);\n\n DSU dsu(N);\n int idx = 0;\n \n while (idx + 1 < (int)seq.size() && Q > 0) {\n int take = min((int)seq.size() - idx, L);\n cout << \"? \" << take;\n for(int i = 0; i < take; ++i) cout << \" \" << seq[idx + i];\n cout << endl; // Auto flushes in C++\n Q--;\n \n for(int i = 0; i < take - 1; ++i) {\n int u, v; \n cin >> u >> v;\n if (dsu.unite(u, v)) {\n final_group_edges[k].push_back({u, v});\n }\n }\n idx += take - 1;\n }\n \n // Fill remaining missing edges using the approximate MST\n for (auto& e : approx_edges) {\n if (dsu.unite(e.first, e.second)) {\n final_group_edges[k].push_back(e);\n }\n }\n }\n\n cout << \"!\" << endl;\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < G[i]; ++j) {\n cout << grps[i][j] << (j + 1 == G[i] ? \"\" : \" \");\n }\n cout << endl;\n for (auto& e : final_group_edges[i]) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& o) const {\n return r == o.r && c == o.c;\n }\n bool operator!=(const Point& o) const {\n return r != o.r || c != o.c;\n }\n};\n\nstruct StateInfo {\n int prev_r, prev_c;\n char action_type;\n char dir;\n};\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_chars[] = {'U', 'D', 'L', 'R'};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, m_input;\n if (!(cin >> n_input >> m_input)) return 0;\n\n vector targets(m_input);\n for (int i = 0; i < m_input; ++i) {\n cin >> targets[i].r >> targets[i].c;\n }\n\n Point curr = targets[0];\n vector> total_actions;\n\n for (int i = 1; i < m_input; ++i) {\n Point target = targets[i];\n \n vector> dist(N, vector(N, 1e9));\n vector> parent(N, vector(N));\n \n queue q;\n q.push(curr);\n dist[curr.r][curr.c] = 0;\n \n while (!q.empty()) {\n Point u = q.front();\n q.pop();\n \n if (u == target) break;\n \n for (int d = 0; d < 4; ++d) {\n // Try Move\n int nr = u.r + dr[d];\n int nc = u.c + dc[d];\n if (is_valid(nr, nc)) {\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'M', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n \n // Try Slide\n nr = u.r;\n nc = u.c;\n while (is_valid(nr + dr[d], nc + dc[d])) {\n nr += dr[d];\n nc += dc[d];\n }\n if (nr != u.r || nc != u.c) { // actually moved\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'S', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n }\n }\n \n // Reconstruct path\n vector> path;\n Point step = target;\n while (step != curr) {\n StateInfo info = parent[step.r][step.c];\n path.push_back({info.action_type, info.dir});\n step = {info.prev_r, info.prev_c};\n }\n \n reverse(path.begin(), path.end());\n for (auto p : path) {\n total_actions.push_back(p);\n }\n \n curr = target;\n }\n\n for (auto p : total_actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}"},"16":{"ahc001":"#pragma GCC optimize(\"O3,unroll-loops,omit-frame-pointer\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst double TIME_LIMIT = 4.95; \n\n// Fast random number generator\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double next_double() {\n return (xor128() & 0xFFFFFF) / (double)0x1000000;\n}\n\nstruct Rect {\n int x1, y1, x2, y2;\n int px, py;\n long long r;\n \n inline double score() const {\n long long s = 1LL * (x2 - x1) * (y2 - y1);\n if (s == 0) return 0.0;\n double mn, mx;\n if (s < r) { mn = s; mx = r; }\n else { mn = r; mx = s; }\n double val = 1.0 - mn / mx;\n return 1.0 - val * val;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n int n;\n if (!(cin >> n)) return 0;\n \n vector rects(n);\n for (int i = 0; i < n; ++i) {\n cin >> rects[i].px >> rects[i].py >> rects[i].r;\n rects[i].x1 = rects[i].px;\n rects[i].y1 = rects[i].py;\n rects[i].x2 = rects[i].px + 1;\n rects[i].y2 = rects[i].py + 1;\n }\n \n auto get_time = [&]() {\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start_time).count();\n };\n \n double initial_temp = 0.15; \n double final_temp = 0.00001;\n double temp_decay = log(final_temp / initial_temp);\n \n int iterations = 0;\n while (true) {\n if ((iterations & 1023) == 0) {\n double elapsed = get_time();\n if (elapsed > TIME_LIMIT) break;\n }\n iterations++;\n \n double elapsed = get_time();\n double progress = elapsed / TIME_LIMIT;\n double temp = initial_temp * exp(temp_decay * progress);\n \n uint32_t r_val = xor128();\n int i = r_val % n;\n int dir = (r_val >> 8) % 4;\n \n // Variable step size with rare mega-steps\n int step_range;\n uint32_t type = (r_val >> 16) & 15;\n if (type == 0) step_range = 1000; // 1/16 chance\n else if (type <= 3) step_range = 500; // 3/16 chance\n else if (type <= 8) step_range = 100; // 5/16 chance\n else step_range = 20; // 7/16 chance\n \n int delta = (xor128() % step_range) - (step_range / 2);\n if (delta == 0) continue;\n \n Rect old_i = rects[i];\n Rect new_i = old_i;\n \n if (dir == 0) { \n new_i.x1 += delta;\n if (new_i.x1 < 0) new_i.x1 = 0;\n if (new_i.x1 > old_i.px) new_i.x1 = old_i.px;\n } else if (dir == 1) { \n new_i.x2 += delta;\n if (new_i.x2 > 10000) new_i.x2 = 10000;\n if (new_i.x2 <= old_i.px) new_i.x2 = old_i.px + 1;\n } else if (dir == 2) { \n new_i.y1 += delta;\n if (new_i.y1 < 0) new_i.y1 = 0;\n if (new_i.y1 > old_i.py) new_i.y1 = old_i.py;\n } else { \n new_i.y2 += delta;\n if (new_i.y2 > 10000) new_i.y2 = 10000;\n if (new_i.y2 <= old_i.py) new_i.y2 = old_i.py + 1;\n }\n \n if (new_i.x1 == old_i.x1 && new_i.x2 == old_i.x2 && new_i.y1 == old_i.y1 && new_i.y2 == old_i.y2) continue;\n \n int overlap_idx = -1;\n bool valid = true;\n \n int nx1 = new_i.x1, nx2 = new_i.x2, ny1 = new_i.y1, ny2 = new_i.y2;\n for (int j = 0; j < n; ++j) {\n if (i == j) continue;\n int rx1 = rects[j].x1, rx2 = rects[j].x2, ry1 = rects[j].y1, ry2 = rects[j].y2;\n if (nx1 < rx2 && nx2 > rx1 && ny1 < ry2 && ny2 > ry1) {\n if (overlap_idx == -1) {\n overlap_idx = j;\n } else {\n valid = false;\n break;\n }\n }\n }\n \n if (!valid) continue;\n \n Rect old_j;\n Rect new_j;\n if (overlap_idx != -1) {\n old_j = rects[overlap_idx];\n new_j = old_j;\n \n if (dir == 0) new_j.x2 = new_i.x1;\n else if (dir == 1) new_j.x1 = new_i.x2;\n else if (dir == 2) new_j.y2 = new_i.y1;\n else new_j.y1 = new_i.y2;\n \n if (new_j.x1 > new_j.px || new_j.x2 <= new_j.px || new_j.y1 > new_j.py || new_j.y2 <= new_j.py) {\n continue;\n }\n }\n \n double old_score = old_i.score() + (overlap_idx != -1 ? old_j.score() : 0.0);\n double new_score = new_i.score() + (overlap_idx != -1 ? new_j.score() : 0.0);\n \n if (new_score > old_score || exp((new_score - old_score) / temp) > next_double()) {\n rects[i] = new_i;\n if (overlap_idx != -1) rects[overlap_idx] = new_j;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n cout << rects[i].x1 << \" \" << rects[i].y1 << \" \" << rects[i].x2 << \" \" << rects[i].y2 << \"\\n\";\n }\n \n return 0;\n}","ahc002":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Padded grid: 52 x 52 to avoid boundary checks\nint t[2704];\nint p[2704];\nbool visited[2704]; \nint best_score = -1;\nstring best_path = \"\";\nstring current_path = \"\";\nint current_score = 0;\n\nint dpos[4] = {-52, 52, -1, 1}; // U, D, L, R in 1D\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nauto start_time = chrono::high_resolution_clock::now();\n\n// Ultra-fast RNG\nuint32_t xor_state = 1337;\ninline uint32_t xorshift32() {\n xor_state ^= xor_state << 13;\n xor_state ^= xor_state >> 17;\n xor_state ^= xor_state << 5;\n return xor_state;\n}\n\nint steps_taken = 0;\n// Increased step limit now that iterations are significantly faster\nconst int MAX_STEPS_PER_DFS = 25000;\nbool time_up = false;\n\nstruct Move {\n int pos, k, score;\n};\n\nvoid dfs(int pos) {\n if (time_up || steps_taken > MAX_STEPS_PER_DFS) return;\n \n steps_taken++;\n\n if ((steps_taken & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n if (chrono::duration_cast(now - start_time).count() > 1950) {\n time_up = true;\n return;\n }\n }\n\n if (current_score > best_score) {\n best_score = current_score;\n best_path = current_path;\n }\n\n Move moves[4];\n int num_moves = 0;\n\n for (int k = 0; k < 4; ++k) {\n int npos = pos + dpos[k];\n int tile_id = t[npos];\n if (!visited[tile_id]) {\n // Optimal noise distribution\n int perturbed_score = p[npos] * 10 + (xorshift32() % 200);\n moves[num_moves++] = {npos, k, perturbed_score};\n }\n }\n\n // Fast inline insertion sort\n if (num_moves > 1) {\n for (int i = 1; i < num_moves; ++i) {\n Move key = moves[i];\n int j = i - 1;\n while (j >= 0 && moves[j].score < key.score) {\n moves[j + 1] = moves[j];\n j = j - 1;\n }\n moves[j + 1] = key;\n }\n }\n\n for (int i = 0; i < num_moves; ++i) {\n if (time_up || steps_taken > MAX_STEPS_PER_DFS) break;\n\n int npos = moves[i].pos;\n int k = moves[i].k;\n int tile_id = t[npos];\n\n visited[tile_id] = true;\n current_score += p[npos];\n current_path.push_back(dir_char[k]);\n\n dfs(npos);\n\n current_path.pop_back();\n current_score -= p[npos];\n visited[tile_id] = false;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n int si, sj;\n if (!(cin >> si >> sj)) return 0;\n \n int max_t = 0;\n \n // Initialize padded boundaries with a sentinel tile ID\n int sentinel_tile = 2600; \n for(int i=0; i<2704; ++i) {\n t[i] = sentinel_tile;\n p[i] = -1000; \n visited[i] = false;\n }\n\n for (int i = 1; i <= 50; ++i) {\n for (int j = 1; j <= 50; ++j) {\n int pos = i * 52 + j;\n cin >> t[pos];\n if (t[pos] > max_t) max_t = t[pos];\n }\n }\n for (int i = 1; i <= 50; ++i) {\n for (int j = 1; j <= 50; ++j) {\n int pos = i * 52 + j;\n cin >> p[pos];\n }\n }\n\n current_path.reserve(2500);\n int start_pos = (si + 1) * 52 + (sj + 1);\n \n // Set static conditions exactly once outside the loop\n visited[sentinel_tile] = true;\n\n while (!time_up) {\n visited[t[start_pos]] = true;\n current_score = p[start_pos];\n current_path.clear();\n steps_taken = 0;\n \n dfs(start_pos);\n \n // Clean up the start position for the next restart\n visited[t[start_pos]] = false; \n }\n\n cout << best_path << \"\\n\";\n return 0;\n}","ahc003":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 30;\nconst int MAX_VAL = 9000;\nconst int MIN_VAL = 1000;\n\nint get_h_edge(int r, int c) {\n return r * 29 + c;\n}\n\nint get_v_edge(int r, int c) {\n return 30 * 29 + r * 30 + c;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int num_edges = 30 * 29 + 29 * 30;\n vector weights(num_edges, 4500.0);\n vector times_traversed(num_edges, 0);\n\n vector row_h_sum(N, 4500.0 * 29);\n vector col_v_sum(N, 4500.0 * 29);\n\n for (int q = 0; q < 1000; ++q) {\n int sr, sc, tr, tc;\n if (!(cin >> sr >> sc >> tr >> tc)) break;\n\n vector> dist(N, vector(N, 1e18));\n vector>> parent(N, vector>(N, {-1, -1}));\n vector> dir(N, vector(N, ' '));\n \n priority_queue>, vector>>, greater>>> pq;\n \n dist[sr][sc] = 0;\n pq.push({0, {sr, sc}});\n \n int dr[] = {-1, 1, 0, 0};\n int dc[] = {0, 0, -1, 1};\n char dch[] = {'U', 'D', 'L', 'R'};\n \n // Slightly increased initial exploration factor\n double exploration_factor = max(0.0, 1250.0 * (1.0 - q / 750.0));\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n int r = u.first;\n int c = u.second;\n \n if (d > dist[r][c]) continue;\n if (r == tr && c == tc) break;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n \n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int edge_idx = -1;\n double group_avg = 4500.0;\n \n if (i == 0) {\n edge_idx = get_v_edge(nr, nc);\n group_avg = col_v_sum[nc] / 29.0;\n } else if (i == 1) {\n edge_idx = get_v_edge(r, c);\n group_avg = col_v_sum[c] / 29.0;\n } else if (i == 2) {\n edge_idx = get_h_edge(nr, nc);\n group_avg = row_h_sum[nr] / 29.0;\n } else if (i == 3) {\n edge_idx = get_h_edge(r, c);\n group_avg = row_h_sum[r] / 29.0;\n }\n \n double w = weights[edge_idx];\n \n if (times_traversed[edge_idx] < 3) {\n double alpha = times_traversed[edge_idx] / 3.0;\n w = alpha * weights[edge_idx] + (1.0 - alpha) * group_avg;\n }\n \n w -= exploration_factor / (1.0 + times_traversed[edge_idx]);\n if (w < 1.0) w = 1.0;\n \n if (dist[r][c] + w < dist[nr][nc]) {\n dist[nr][nc] = dist[r][c] + w;\n parent[nr][nc] = {r, c};\n dir[nr][nc] = dch[i];\n pq.push({dist[nr][nc], {nr, nc}});\n }\n }\n }\n }\n \n string path = \"\";\n int cr = tr, cc = tc;\n vector> path_edge_info; \n \n while (cr != sr || cc != sc) {\n path += dir[cr][cc];\n int pr = parent[cr][cc].first;\n int pc = parent[cr][cc].second;\n \n if (dir[cr][cc] == 'U') path_edge_info.push_back({get_v_edge(cr, cc), 1 + (cc << 1)});\n else if (dir[cr][cc] == 'D') path_edge_info.push_back({get_v_edge(pr, pc), 1 + (pc << 1)});\n else if (dir[cr][cc] == 'L') path_edge_info.push_back({get_h_edge(cr, cc), 0 + (cr << 1)});\n else if (dir[cr][cc] == 'R') path_edge_info.push_back({get_h_edge(pr, pc), 0 + (pr << 1)});\n \n cr = pr;\n cc = pc;\n }\n \n reverse(path.begin(), path.end());\n cout << path << endl;\n \n int L;\n cin >> L;\n \n double current_est = 0;\n for (auto p : path_edge_info) {\n current_est += weights[p.first];\n }\n \n if (current_est < 1e-9) current_est = 1e-9;\n double error = L - current_est;\n \n for (auto p : path_edge_info) {\n int e = p.first;\n int type = p.second & 1;\n int idx = p.second >> 1;\n \n times_traversed[e]++;\n double lr = 1.0 / sqrt(times_traversed[e] + 1);\n \n double old_w = weights[e];\n // Slightly increased learning multiplier\n double update = error * (weights[e] / current_est) * lr * 1.45;\n weights[e] += update;\n \n if (weights[e] < MIN_VAL) weights[e] = MIN_VAL;\n if (weights[e] > MAX_VAL) weights[e] = MAX_VAL;\n \n if (type == 0) {\n row_h_sum[idx] += weights[e] - old_w;\n } else {\n col_v_sum[idx] += weights[e] - old_w;\n }\n }\n }\n \n return 0;\n}","ahc004":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint M;\nstring S[805];\n\nconst int HASH_SIZE = 16384;\nuint64_t keys_hash[HASH_SIZE];\nint vals_hash[HASH_SIZE];\n\nvoid insert_hash(uint64_t key, int val) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n while (keys_hash[h] != 0) {\n h = (h + 1) & (HASH_SIZE - 1);\n }\n keys_hash[h] = key;\n vals_hash[h] = val;\n}\n\ninline int get_id(uint64_t key) {\n int h = (key ^ (key >> 16) ^ (key >> 32)) & (HASH_SIZE - 1);\n while (keys_hash[h] != 0) {\n if (keys_hash[h] == key) return vals_hash[h];\n h = (h + 1) & (HASH_SIZE - 1);\n }\n return -1;\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double fast_rand_double() {\n return (xor128() & 0xFFFFFF) / (double)0x1000000;\n}\n\nint grid[N][N];\nint counts[805];\nbool valid_len[15];\nint min_len = 15;\nint max_len = 0;\n\nint wrap[60]; // Precomputed modulo array\n\ninline int evaluate_cell_change(int r, int c, int old_val, int new_val) {\n int diff = 0;\n int buf_h[24];\n int buf_v[24];\n \n int start_c = c - 11 + N;\n int start_r = r - 11 + N;\n for (int i = 0; i < 23; ++i) {\n buf_h[i] = grid[r][wrap[start_c + i]];\n buf_v[i] = grid[wrap[start_r + i]][c];\n }\n \n auto process = [&](int val, int sign) {\n buf_h[11] = val;\n buf_v[11] = val;\n \n for(int start = 12 - max_len; start <= 11; ++start) {\n uint64_t v = 0;\n for(int l = 1; l <= max_len; ++l) {\n int ch = buf_h[start + l - 1];\n if (ch == 8) break; \n v = (v << 3) | ch;\n if (l >= min_len && start + l - 1 >= 11 && valid_len[l]) {\n uint64_t key = ((uint64_t)l << 36) | v;\n int id = get_id(key);\n if (id != -1) {\n if (sign == 1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n } else {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n }\n \n for(int start = 12 - max_len; start <= 11; ++start) {\n uint64_t v = 0;\n for(int l = 1; l <= max_len; ++l) {\n int ch = buf_v[start + l - 1];\n if (ch == 8) break; \n v = (v << 3) | ch;\n if (l >= min_len && start + l - 1 >= 11 && valid_len[l]) {\n uint64_t key = ((uint64_t)l << 36) | v;\n int id = get_id(key);\n if (id != -1) {\n if (sign == 1) {\n if (counts[id] == 0) diff++;\n counts[id]++;\n } else {\n if (counts[id] == 1) diff--;\n counts[id]--;\n }\n }\n }\n }\n }\n };\n \n process(old_val, -1);\n process(new_val, 1);\n grid[r][c] = new_val;\n return diff;\n}\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n memset(keys_hash, 0, sizeof(keys_hash));\n memset(valid_len, 0, sizeof(valid_len));\n\n for(int i = 0; i < 60; ++i) wrap[i] = i % N;\n\n if (!(cin >> M >> M)) return 0;\n \n for(int i = 0; i < M; ++i) {\n cin >> S[i];\n int len = S[i].length();\n valid_len[len] = true;\n min_len = min(min_len, len);\n max_len = max(max_len, len);\n \n uint64_t val = 0;\n for(char c : S[i]) {\n val = (val << 3) | (c - 'A');\n }\n uint64_t key = ((uint64_t)len << 36) | val;\n insert_hash(key, i);\n }\n\n int current_empty = 0;\n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n grid[r][c] = xor128() % 8;\n }\n }\n\n memset(counts, 0, sizeof(counts));\n int current_score = 0;\n \n for(int r = 0; r < N; ++r) {\n for(int c = 0; c < N; ++c) {\n for(int l = min_len; l <= max_len; ++l) {\n if (!valid_len[l]) continue;\n \n uint64_t val_h = 0;\n for(int i = 0; i < l; ++i) val_h = (val_h << 3) | grid[r][(c + i) % N];\n uint64_t key_h = ((uint64_t)l << 36) | val_h;\n int id_h = get_id(key_h);\n if (id_h != -1) {\n if (counts[id_h] == 0) current_score++;\n counts[id_h]++;\n }\n \n uint64_t val_v = 0;\n for(int i = 0; i < l; ++i) val_v = (val_v << 3) | grid[(r + i) % N][c];\n uint64_t key_v = ((uint64_t)l << 36) | val_v;\n int id_v = get_id(key_v);\n if (id_v != -1) {\n if (counts[id_v] == 0) current_score++;\n counts[id_v]++;\n }\n }\n }\n }\n\n double start_temp = 1.5; \n double end_temp = 0.05;\n double time_limit = 2.9;\n \n int best_grid[N][N];\n int best_score = -1;\n\n int iter = 0;\n while(true) {\n if ((iter & 4095) == 0) {\n double t = get_time();\n if (t > time_limit) break;\n }\n iter++;\n\n int r = xor128() % N;\n int c = xor128() % N;\n int old_val = grid[r][c];\n int new_val = xor128() % 8; \n \n if (current_score == M && (xor128() % 2) == 0) {\n new_val = 8;\n }\n \n if (new_val == old_val) {\n new_val = (new_val == 8) ? (xor128() % 8) : ((new_val + 1) % 8);\n }\n\n int diff = evaluate_cell_change(r, c, old_val, new_val);\n int delta_empty = (new_val == 8 ? 1 : 0) - (old_val == 8 ? 1 : 0);\n \n double delta = diff;\n if (current_score == M || current_score + diff == M) {\n delta += delta_empty / 1000.0;\n }\n\n double t = get_time() / time_limit;\n double temp = start_temp * pow(end_temp / start_temp, t);\n\n if (delta > 0 || exp(delta / temp) > fast_rand_double()) {\n current_score += diff;\n current_empty += delta_empty;\n \n int actual_score = current_score == M ? M + current_empty : current_score;\n if (actual_score > best_score) {\n best_score = actual_score;\n memcpy(best_grid, grid, sizeof(grid));\n }\n } else {\n evaluate_cell_change(r, c, new_val, old_val);\n }\n }\n\n for(int r = 0; r < N; ++r) {\n string out = \"\";\n for(int c = 0; c < N; ++c) {\n if (best_grid[r][c] == 8) out += '.';\n else out += (char)('A' + best_grid[r][c]);\n }\n cout << out << \"\\n\";\n }\n\n return 0;\n}","ahc005":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\n\nint N, si, sj;\nvector grid;\nvector> visible;\nvector road_cells;\nbool is_road[5000];\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\ninline int get_id(int r, int c) {\n return r * N + c;\n}\n\nint dist_mat[5000][5000];\nint parent_mat[5000][5000];\nchar move_mat[5000][5000];\n\n// Fast XOR-shift RNG\nstatic uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\ninline uint32_t xor128() {\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double fast_rand(double L, double R) {\n return L + (R - L) * (xor128() * (1.0 / 4294967296.0));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> si >> sj)) return 0;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n }\n\n int num_cells = N * N;\n visible.resize(num_cells);\n fill(is_road, is_road + num_cells, false);\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (grid[r][c] != '#') {\n int u = get_id(r, c);\n is_road[u] = true;\n road_cells.push_back(u);\n }\n }\n }\n\n int total_roads = road_cells.size();\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (!is_road[get_id(r, c)]) continue;\n int u = get_id(r, c);\n \n for (int r2 = r; r2 >= 0; --r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int r2 = r + 1; r2 < N; ++r2) {\n if (!is_road[get_id(r2, c)]) break;\n visible[u].push_back(get_id(r2, c));\n }\n for (int c2 = c - 1; c2 >= 0; --c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n for (int c2 = c + 1; c2 < N; ++c2) {\n if (!is_road[get_id(r, c2)]) break;\n visible[u].push_back(get_id(r, c2));\n }\n }\n }\n\n int max_distance = 0;\n // Precompute All-Pairs Shortest Path (APSP) using Dijkstra\n for (int u : road_cells) {\n for (int v : road_cells) {\n dist_mat[u][v] = INF;\n parent_mat[u][v] = -1;\n }\n dist_mat[u][u] = 0;\n \n priority_queue, vector>, greater>> pq;\n pq.push({0, u});\n \n while(!pq.empty()) {\n auto [d, curr] = pq.top();\n pq.pop();\n \n if (d > dist_mat[u][curr]) continue;\n \n int r = curr / N;\n int c = curr % N;\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dr[i];\n int nc = c + dc[i];\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int nxt = get_id(nr, nc);\n if (is_road[nxt]) {\n int cost = grid[nr][nc] - '0';\n if (dist_mat[u][curr] + cost < dist_mat[u][nxt]) {\n dist_mat[u][nxt] = dist_mat[u][curr] + cost;\n if (dist_mat[u][nxt] > max_distance) max_distance = dist_mat[u][nxt];\n parent_mat[u][nxt] = curr;\n move_mat[u][nxt] = dir_char[i];\n pq.push({dist_mat[u][nxt], nxt});\n }\n }\n }\n }\n }\n }\n\n string best_ans = \"\";\n int best_cost = INF;\n\n vector seen(num_cells, false);\n vector unseen_count(num_cells, 0);\n vector pow_unseen(400, 0.0);\n vector inv_pow_dist(max_distance + 2, 0.0);\n\n int iter_count = 0;\n while (true) {\n if ((iter_count++ & 15) == 0) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 2.96) break; \n }\n\n fill(seen.begin(), seen.end(), false);\n for (int u : road_cells) {\n unseen_count[u] = visible[u].size();\n }\n\n int curr_node = get_id(si, sj);\n int seen_count = 0;\n int current_cost = 0;\n string ans = \"\";\n \n // Slightly tightened exponent bounds to prevent excessive greediness\n double alpha = fast_rand(0.5, 3.5);\n double beta = fast_rand(0.5, 3.5);\n double c_val = fast_rand(0.1, 10.0);\n\n for (int i = 0; i < 400; ++i) {\n pow_unseen[i] = pow(i, alpha);\n }\n for (int d = 0; d <= max_distance; ++d) {\n inv_pow_dist[d] = 1.0 / pow(d + c_val, beta);\n }\n\n auto mark_seen = [&](int u) {\n for (int v : visible[u]) {\n if (!seen[v]) {\n seen[v] = true;\n seen_count++;\n for (int w : visible[v]) {\n unseen_count[w]--;\n }\n }\n }\n };\n\n mark_seen(curr_node);\n vector active_cells = road_cells;\n\n while (seen_count < total_roads) {\n double best_score = -1.0;\n int best_target = -1;\n\n for (int i = 0; i < (int)active_cells.size(); ) {\n int u = active_cells[i];\n int u_count = unseen_count[u];\n \n if (u_count == 0) {\n active_cells[i] = active_cells.back();\n active_cells.pop_back();\n continue;\n }\n \n int d = dist_mat[curr_node][u];\n if (d != INF) {\n double rand_factor = fast_rand(0.5, 1.5);\n double score = pow_unseen[u_count] * inv_pow_dist[d] * rand_factor;\n if (score > best_score) {\n best_score = score;\n best_target = u;\n }\n }\n i++;\n }\n\n if (best_target == -1) break;\n\n vector path;\n int temp = best_target;\n while (temp != curr_node) {\n path.push_back(move_mat[curr_node][temp]);\n temp = parent_mat[curr_node][temp];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_node -= N;\n else if (dir == 'D') curr_node += N;\n else if (dir == 'L') curr_node -= 1;\n else if (dir == 'R') curr_node += 1;\n \n current_cost += grid[curr_node / N][curr_node % N] - '0';\n mark_seen(curr_node);\n \n if (unseen_count[best_target] == 0) {\n break;\n }\n }\n }\n\n int start_id = get_id(si, sj);\n if (curr_node != start_id) {\n vector path;\n int temp = start_id;\n while (temp != curr_node) {\n path.push_back(move_mat[curr_node][temp]);\n temp = parent_mat[curr_node][temp];\n }\n reverse(path.begin(), path.end());\n\n for (char dir : path) {\n ans += dir;\n if (dir == 'U') curr_node -= N;\n else if (dir == 'D') curr_node += N;\n else if (dir == 'L') curr_node -= 1;\n else if (dir == 'R') curr_node += 1;\n \n current_cost += grid[curr_node / N][curr_node % N] - '0';\n }\n }\n\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_ans = ans;\n }\n }\n\n if (best_ans.empty()) {\n cout << \"\" << \"\\n\";\n } else {\n cout << best_ans << \"\\n\";\n }\n\n return 0;\n}","future-contest-2022-qual":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Task {\n int id;\n vector d;\n vector deps;\n vector rev_deps;\n int priority = 0;\n int status = -1; // -1: not started, 0: in progress, 1: completed\n};\n\nstruct Member {\n int id;\n vector s;\n int current_task = -1;\n int start_day = -1;\n \n struct History {\n int task_id;\n int actual_time;\n };\n vector history;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n vector tasks(N);\n for (int i = 0; i < N; ++i) {\n tasks[i].id = i;\n tasks[i].d.resize(K);\n for (int k = 0; k < K; ++k) cin >> tasks[i].d[k];\n }\n\n vector in_degree(N, 0);\n for (int i = 0; i < R; ++i) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n tasks[u].rev_deps.push_back(v);\n tasks[v].deps.push_back(u);\n in_degree[v]++;\n }\n\n vector dp(N, 0);\n vector topo_order;\n queue q;\n vector in_deg_temp = in_degree;\n for (int i = 0; i < N; ++i) {\n if (in_deg_temp[i] == 0) q.push(i);\n }\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n topo_order.push_back(u);\n for (int v : tasks[u].rev_deps) {\n if (--in_deg_temp[v] == 0) q.push(v);\n }\n }\n \n for (int i = N - 1; i >= 0; --i) {\n int u = topo_order[i];\n dp[u] = 1;\n for (int v : tasks[u].rev_deps) {\n dp[u] = max(dp[u], dp[v] + 1);\n }\n tasks[u].priority = dp[u] * 10 + (int)tasks[u].rev_deps.size();\n }\n\n vector members(M);\n for (int i = 0; i < M; ++i) {\n members[i].id = i;\n members[i].s.assign(K, 0.0);\n }\n\n int day = 0;\n int completed_tasks = 0;\n\n while (completed_tasks < N) {\n day++;\n \n vector available_members;\n for (int i = 0; i < M; ++i) {\n if (members[i].current_task == -1) available_members.push_back(i);\n }\n\n vector available_tasks;\n for (int i = 0; i < N; ++i) {\n if (tasks[i].status == -1 && in_degree[i] == 0) available_tasks.push_back(i);\n }\n\n vector assign_m;\n vector assign_t;\n\n while (!available_members.empty() && !available_tasks.empty()) {\n int best_m_idx = 0;\n int best_t_idx = 0;\n double best_score = -1e15;\n\n for (size_t i = 0; i < available_members.size(); ++i) {\n int m_id = available_members[i];\n for (size_t j = 0; j < available_tasks.size(); ++j) {\n int t_id = available_tasks[j];\n \n double expected_w = 0;\n double wasted_w = 0;\n double total_d = 0;\n for (int k = 0; k < K; ++k) {\n expected_w += max(0.0, tasks[t_id].d[k] - members[m_id].s[k]);\n wasted_w += max(0.0, members[m_id].s[k] - tasks[t_id].d[k]);\n total_d += tasks[t_id].d[k];\n }\n double expected_time = max(1.0, expected_w);\n \n // The optimal balanced scoring formula with a micro tie-breaker\n double score = tasks[t_id].priority * 2.5 - expected_time * 1.5 - wasted_w * 0.12 - total_d * 0.001;\n \n if (score > best_score) {\n best_score = score;\n best_m_idx = i;\n best_t_idx = j;\n }\n }\n }\n\n int m_id = available_members[best_m_idx];\n int t_id = available_tasks[best_t_idx];\n\n members[m_id].current_task = t_id;\n members[m_id].start_day = day;\n tasks[t_id].status = 0;\n \n assign_m.push_back(m_id + 1);\n assign_t.push_back(t_id + 1);\n\n available_members.erase(available_members.begin() + best_m_idx);\n available_tasks.erase(available_tasks.begin() + best_t_idx);\n }\n\n cout << assign_m.size();\n for (size_t i = 0; i < assign_m.size(); ++i) cout << \" \" << assign_m[i] << \" \" << assign_t[i];\n cout << \"\\n\";\n cout.flush();\n\n int n_finished;\n cin >> n_finished;\n if (n_finished == -1) break;\n\n for (int i = 0; i < n_finished; ++i) {\n int f;\n cin >> f;\n --f;\n \n int t_id = members[f].current_task;\n int actual_time = day - members[f].start_day + 1;\n \n tasks[t_id].status = 1;\n completed_tasks++;\n members[f].current_task = -1;\n \n for (int v : tasks[t_id].rev_deps) in_degree[v]--;\n \n members[f].history.push_back({t_id, actual_time});\n \n double lr = 0.1;\n for (int iter = 0; iter < 40; ++iter) {\n lr *= 0.95; \n for (const auto& hist : members[f].history) {\n int hid = hist.task_id;\n int htime = hist.actual_time;\n \n if (htime == 1) {\n for (int k = 0; k < K; ++k) members[f].s[k] = max(members[f].s[k], (double)tasks[hid].d[k]);\n continue;\n }\n \n double current_w = 0;\n vector active_k;\n for (int k = 0; k < K; ++k) {\n if (tasks[hid].d[k] > members[f].s[k]) {\n current_w += (tasks[hid].d[k] - members[f].s[k]);\n active_k.push_back(k);\n }\n }\n \n double target_w = max(1.0, (double)htime - 1.0);\n if (htime <= 4) target_w *= 0.85; \n\n if (!active_k.empty()) {\n double error = current_w - target_w;\n double grad = error / active_k.size();\n for (int k : active_k) {\n members[f].s[k] += lr * grad;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n } else {\n for (int k = 0; k < K; ++k) {\n if (tasks[hid].d[k] > 0) {\n members[f].s[k] -= lr * target_w / K;\n members[f].s[k] = max(0.0, members[f].s[k]);\n }\n }\n }\n }\n }\n }\n }\n\n return 0;\n}","ahc006":"#pragma GCC optimize(\"O3\")\n#pragma GCC optimize(\"unroll-loops\")\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int NUM_ORDERS = 1000;\nconst int SELECTED_SIZE = 50;\nconst int PATH_SIZE = 100;\n\nstruct Order {\n int id;\n int a, b, c, d;\n int dist_to_center;\n};\n\nstruct Point {\n int x, y;\n};\n\ninline int manhattan(const Point& p1, const Point& p2) {\n return abs(p1.x - p2.x) + abs(p1.y - p2.y);\n}\n\nvector orders(NUM_ORDERS);\n\n// Fast random number generator\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double fast_rand01() {\n return (xor128() & 0xFFFFFF) / (double)0x1000000;\n}\n\ninline int fast_rand(int max_val) {\n return xor128() % max_val;\n}\n\ndouble get_time(const chrono::time_point& start) {\n auto current_time = chrono::high_resolution_clock::now();\n return chrono::duration(current_time - start).count();\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n for (int i = 0; i < NUM_ORDERS; ++i) {\n orders[i].id = i + 1;\n cin >> orders[i].a >> orders[i].b >> orders[i].c >> orders[i].d;\n orders[i].dist_to_center = abs(orders[i].a - 400) + abs(orders[i].b - 400) + \n abs(orders[i].c - 400) + abs(orders[i].d - 400);\n }\n\n vector sorted_orders = orders;\n sort(sorted_orders.begin(), sorted_orders.end(), [](const Order& o1, const Order& o2) {\n return o1.dist_to_center < o2.dist_to_center;\n });\n\n const Point center = {400, 400};\n\n auto get_point = [&](int node, const array& act) {\n if (node < SELECTED_SIZE) return Point{orders[act[node]].a, orders[act[node]].b};\n return Point{orders[act[node - SELECTED_SIZE]].c, orders[act[node - SELECTED_SIZE]].d};\n };\n\n int best_initial_dist = 1e9;\n array best_initial_path;\n array best_initial_active;\n\n int pool_size = min(200, NUM_ORDERS);\n\n // Multi-start greedy initialization\n for (int trial = 0; trial < 1000; ++trial) {\n array cur_active;\n if (trial == 0) {\n for (int i = 0; i < SELECTED_SIZE; ++i) cur_active[i] = sorted_orders[i].id - 1;\n } else {\n vector cands(pool_size);\n for(int i = 0; i < pool_size; ++i) cands[i] = sorted_orders[i].id - 1;\n for(int i = 0; i < SELECTED_SIZE; ++i) {\n int idx = i + fast_rand(pool_size - i);\n swap(cands[i], cands[idx]);\n cur_active[i] = cands[i];\n }\n }\n\n array path;\n vector picked(SELECTED_SIZE, false);\n vector dropped(SELECTED_SIZE, false);\n Point curr_pt = center;\n int dist = 0;\n\n for (int step = 0; step < PATH_SIZE; ++step) {\n int best_node = -1;\n int min_d = 1e9;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n if (!picked[i]) {\n int d = manhattan(curr_pt, get_point(i, cur_active));\n if (d < min_d) { min_d = d; best_node = i; }\n } else if (!dropped[i]) {\n int d = manhattan(curr_pt, get_point(i + SELECTED_SIZE, cur_active));\n if (d < min_d) { min_d = d; best_node = i + SELECTED_SIZE; }\n }\n }\n path[step] = best_node;\n dist += min_d;\n curr_pt = get_point(best_node, cur_active);\n if (best_node < SELECTED_SIZE) picked[best_node] = true;\n else dropped[best_node - SELECTED_SIZE] = true;\n }\n dist += manhattan(curr_pt, center);\n \n if (dist < best_initial_dist) {\n best_initial_dist = dist;\n best_initial_path = path;\n best_initial_active = cur_active;\n }\n }\n\n array active_orders = best_initial_active;\n array path = best_initial_path;\n array pos;\n for (int i = 0; i < PATH_SIZE; ++i) pos[path[i]] = i;\n\n vector inactive_orders;\n inactive_orders.reserve(NUM_ORDERS - SELECTED_SIZE);\n vector is_active(NUM_ORDERS, false);\n for (int i = 0; i < SELECTED_SIZE; ++i) is_active[active_orders[i]] = true;\n for (int i = 0; i < NUM_ORDERS; ++i) {\n if (!is_active[i]) inactive_orders.push_back(i);\n }\n\n auto eval_path = [&](const array& p, const array& act) {\n int dist = 0;\n Point curr = center;\n for (int i = 0; i < PATH_SIZE; ++i) {\n Point next = get_point(p[i], act);\n dist += manhattan(curr, next);\n curr = next;\n }\n dist += manhattan(curr, center);\n return dist;\n };\n\n int current_dist = eval_path(path, active_orders);\n int best_dist = current_dist;\n auto best_path = path;\n auto best_active = active_orders;\n\n double time_limit = 1.95;\n double t = 0;\n int iter = 0;\n\n double t0 = 300.0;\n double t1 = 1.0;\n\n auto check_valid = [&](int node) {\n if (node < SELECTED_SIZE) return pos[node] < pos[node + SELECTED_SIZE];\n else return pos[node - SELECTED_SIZE] < pos[node];\n };\n\n while (true) {\n if ((iter & 2047) == 0) {\n t = get_time(start_time);\n if (t >= time_limit) break;\n }\n iter++;\n \n double temp = t0 * pow(t1 / t0, t / time_limit);\n int type = fast_rand(10);\n \n if (type < 4) { // 2-opt\n int u = fast_rand(PATH_SIZE - 1);\n int v = fast_rand(PATH_SIZE);\n if (u >= v) continue;\n \n bool valid = true;\n for (int i = u; i <= v; ++i) {\n int node = path[i];\n if (node < SELECTED_SIZE) {\n if (pos[node + SELECTED_SIZE] >= u && pos[node + SELECTED_SIZE] <= v) {\n valid = false;\n break;\n }\n }\n }\n if (!valid) continue;\n \n reverse(path.begin() + u, path.begin() + v + 1);\n \n int new_dist = eval_path(path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > fast_rand01()) {\n current_dist = new_dist;\n for (int i = u; i <= v; ++i) pos[path[i]] = i;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n reverse(path.begin() + u, path.begin() + v + 1);\n }\n } else if (type < 7) { // Relocate\n int u = fast_rand(PATH_SIZE);\n int v = fast_rand(PATH_SIZE);\n if (u == v) continue;\n \n int val = path[u];\n int new_pos_val = v;\n int other = (val < SELECTED_SIZE) ? (val + SELECTED_SIZE) : (val - SELECTED_SIZE);\n int pos_other = pos[other];\n \n if (pos_other > u && pos_other <= v) pos_other--;\n else if (pos_other >= v && pos_other < u) pos_other++;\n \n if ((val < SELECTED_SIZE && new_pos_val > pos_other) ||\n (val >= SELECTED_SIZE && new_pos_val < pos_other)) {\n continue;\n }\n \n auto new_path = path;\n if (u < v) {\n for (int i = u; i < v; ++i) new_path[i] = new_path[i + 1];\n } else {\n for (int i = u; i > v; --i) new_path[i] = new_path[i - 1];\n }\n new_path[v] = val;\n \n int new_dist = eval_path(new_path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > fast_rand01()) {\n current_dist = new_dist;\n path = new_path;\n for (int i = min(u, v); i <= max(u, v); ++i) pos[path[i]] = i;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n }\n } else if (type < 9) { // Order swap\n int act_idx = fast_rand(SELECTED_SIZE);\n int inact_idx = fast_rand(inactive_orders.size());\n \n int old_order = active_orders[act_idx];\n active_orders[act_idx] = inactive_orders[inact_idx];\n \n int u = fast_rand(PATH_SIZE - 1);\n int v = fast_rand(PATH_SIZE);\n if (u == v) v++; \n if (u > v) swap(u, v);\n \n array new_path;\n int ptr = 0;\n for (int i = 0; i < PATH_SIZE; ++i) {\n if (i == u) new_path[i] = act_idx;\n else if (i == v) new_path[i] = act_idx + SELECTED_SIZE;\n else {\n while (path[ptr] == act_idx || path[ptr] == act_idx + SELECTED_SIZE) ptr++;\n new_path[i] = path[ptr++];\n }\n }\n \n int new_dist = eval_path(new_path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > fast_rand01()) {\n current_dist = new_dist;\n path = new_path;\n for (int i = 0; i < PATH_SIZE; ++i) pos[path[i]] = i;\n inactive_orders[inact_idx] = old_order;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n active_orders[act_idx] = old_order;\n }\n } else { // Swap\n int u = fast_rand(PATH_SIZE);\n int v = fast_rand(PATH_SIZE);\n if (u == v) continue;\n \n int n1 = path[u], n2 = path[v];\n swap(path[u], path[v]);\n pos[n1] = v; pos[n2] = u;\n \n if (check_valid(n1) && check_valid(n2)) {\n int new_dist = eval_path(path, active_orders);\n if (new_dist < current_dist || exp((current_dist - new_dist) / temp) > fast_rand01()) {\n current_dist = new_dist;\n if (current_dist < best_dist) {\n best_dist = current_dist;\n best_path = path;\n best_active = active_orders;\n }\n } else {\n swap(path[u], path[v]);\n pos[n1] = u; pos[n2] = v;\n }\n } else {\n swap(path[u], path[v]);\n pos[n1] = u; pos[n2] = v;\n }\n }\n }\n\n cout << SELECTED_SIZE;\n for (int i = 0; i < SELECTED_SIZE; ++i) {\n cout << \" \" << orders[best_active[i]].id;\n }\n cout << \"\\n\";\n\n vector final_route;\n final_route.push_back(center);\n for (int node : best_path) {\n final_route.push_back(get_point(node, best_active));\n }\n final_route.push_back(center);\n\n cout << final_route.size();\n for (const auto& p : final_route) {\n cout << \" \" << p.x << \" \" << p.y;\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc007":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n// Fast XorShift Random Number Generator\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline int rand_range(int L, int R) {\n return L + xor128() % (R - L + 1);\n}\n\n// Ultra-fast Array-based Disjoint Set Union\nstruct DSU {\n int parent[400];\n \n void init() {\n for (int i = 0; i < 400; ++i) {\n parent[i] = i;\n }\n }\n \n inline int find(int i) {\n int root = i;\n while (root != parent[root]) {\n root = parent[root];\n }\n int curr = i;\n while (curr != root) {\n int nxt = parent[curr];\n parent[curr] = root;\n curr = nxt;\n }\n return root;\n }\n \n inline bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\nstruct Edge {\n int id;\n int u;\n int v;\n int d; \n};\n\nstruct SimEdge {\n int weight;\n int id;\n int u;\n int v;\n};\n\n// Global arrays for Counting Sort to prevent re-allocation\nint counts[4005];\nSimEdge sorted_edges[2005];\n\nint main() {\n // Fast I/O\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N = 400;\n int M = 1995;\n\n vector> points(N);\n for (int i = 0; i < N; ++i) {\n cin >> points[i].first >> points[i].second;\n }\n\n vector edges(M);\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v;\n edges[i].id = i;\n double dist = sqrt(pow(points[edges[i].u].first - points[edges[i].v].first, 2) + \n pow(points[edges[i].u].second - points[edges[i].v].second, 2));\n edges[i].d = round(dist);\n }\n\n DSU current_dsu;\n current_dsu.init();\n\n vector future_edges;\n vector valid_future;\n future_edges.reserve(M);\n valid_future.reserve(M);\n\n for (int i = 0; i < M; ++i) {\n int l;\n cin >> l;\n\n if (current_dsu.find(edges[i].u) == current_dsu.find(edges[i].v)) {\n cout << 0 << endl;\n continue;\n }\n\n valid_future.clear();\n for (int j = i + 1; j < M; ++j) {\n if (current_dsu.find(edges[j].u) != current_dsu.find(edges[j].v)) {\n valid_future.push_back(edges[j]);\n }\n }\n\n // Dynamic K: Start safely at 20, scale up to 60 as the graph simplifies\n int current_K = 20 + (40 * i) / M;\n int required_accepts = (current_K + 1) / 2;\n\n int accept_count = 0;\n int reject_count = 0;\n \n for (int sim = 0; sim < current_K; ++sim) {\n if (accept_count >= required_accepts || reject_count > current_K - required_accepts) {\n break;\n }\n\n future_edges.clear();\n future_edges.push_back({l, i, edges[i].u, edges[i].v});\n \n for (const auto& vf : valid_future) {\n future_edges.push_back({rand_range(vf.d, 3 * vf.d), vf.id, vf.u, vf.v});\n }\n\n // O(N) Counting Sort with dynamic limits instead of static memset\n int max_w = 0;\n for (const auto& edge : future_edges) {\n counts[edge.weight]++;\n if (edge.weight > max_w) {\n max_w = edge.weight;\n }\n }\n for (int w = 1; w <= max_w; ++w) {\n counts[w] += counts[w - 1];\n }\n for (int j = (int)future_edges.size() - 1; j >= 0; --j) {\n sorted_edges[--counts[future_edges[j].weight]] = future_edges[j];\n }\n // Explicitly clear exactly the memory we used for the next iteration\n for (int w = 0; w <= max_w; ++w) {\n counts[w] = 0;\n }\n\n DSU temp_dsu;\n memcpy(temp_dsu.parent, current_dsu.parent, sizeof(int) * N);\n \n bool use_current = false;\n int num_edges = future_edges.size();\n\n for (int j = 0; j < num_edges; ++j) {\n const auto& edge = sorted_edges[j];\n if (temp_dsu.find(edge.u) != temp_dsu.find(edge.v)) {\n temp_dsu.unite(edge.u, edge.v);\n if (edge.id == i) {\n use_current = true;\n break; \n }\n } else if (edge.id == i) {\n break; \n }\n }\n \n if (use_current) {\n accept_count++;\n } else {\n reject_count++;\n }\n }\n\n if (accept_count >= required_accepts) {\n current_dsu.unite(edges[i].u, edges[i].v);\n cout << 1 << endl;\n } else {\n cout << 0 << endl;\n }\n }\n\n return 0;\n}","ahc008":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int GRID_SIZE = 30;\nbool grid_passable[GRID_SIZE + 2][GRID_SIZE + 2];\nint pet_count[GRID_SIZE + 2][GRID_SIZE + 2];\nint start_human_count[GRID_SIZE + 2][GRID_SIZE + 2];\nint next_human_count[GRID_SIZE + 2][GRID_SIZE + 2];\n\nconst int dx[] = {-1, 1, 0, 0};\nconst int dy[] = {0, 0, -1, 1};\nconst char move_dir[] = {'U', 'D', 'L', 'R'};\nconst char block_dir[] = {'u', 'd', 'l', 'r'};\n\nstruct Pet {\n int x, y, type;\n};\n\nstruct Human {\n int x, y;\n};\n\ninline bool is_safe_to_block(int x, int y) {\n if (x < 1 || x > GRID_SIZE || y < 1 || y > GRID_SIZE) return false;\n if (!grid_passable[x][y]) return false;\n \n // The 6x6 grid is the optimal sweet spot for 300 turns.\n if (x % 6 != 0 && y % 6 != 0) return false;\n\n // Cannot block if there was a human at the start of the turn, or if another human is moving there\n if (pet_count[x][y] > 0 || start_human_count[x][y] > 0 || next_human_count[x][y] > 0) return false;\n \n // Cannot block if any adjacent square contains a pet\n for (int i = 0; i < 4; ++i) {\n int nx = x + dx[i];\n int ny = y + dy[i];\n if (nx >= 1 && nx <= GRID_SIZE && ny >= 1 && ny <= GRID_SIZE) {\n if (pet_count[nx][ny] > 0) return false;\n }\n }\n return true;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n grid_passable[i][j] = true;\n }\n }\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector pets(N);\n for (int i = 0; i < N; ++i) {\n cin >> pets[i].x >> pets[i].y >> pets[i].type;\n pet_count[pets[i].x][pets[i].y]++;\n }\n\n int M;\n cin >> M;\n vector humans(M);\n for (int i = 0; i < M; ++i) {\n cin >> humans[i].x >> humans[i].y;\n }\n\n // Maintaining the optimal random seed to ensure robust exploration paths\n mt19937 rng(42);\n int dirs[4] = {0, 1, 2, 3};\n\n for (int turn = 0; turn < 300; ++turn) {\n // Clear counts\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n start_human_count[i][j] = 0;\n next_human_count[i][j] = 0;\n }\n }\n \n for (int i = 0; i < M; ++i) {\n start_human_count[humans[i].x][humans[i].y]++;\n }\n \n string action = \"\";\n action.reserve(M);\n\n for (int i = 0; i < M; ++i) {\n bool acted = false;\n \n shuffle(dirs, dirs + 4, rng);\n \n // Try to block randomly on grid lines\n for (int k = 0; k < 4; ++k) {\n int d = dirs[k];\n int nx = humans[i].x + dx[d];\n int ny = humans[i].y + dy[d];\n if (is_safe_to_block(nx, ny)) {\n action += block_dir[d];\n grid_passable[nx][ny] = false;\n next_human_count[humans[i].x][humans[i].y]++; // Human stays in place\n acted = true;\n break;\n }\n }\n \n // Try to move randomly\n if (!acted) {\n for (int k = 0; k < 4; ++k) {\n int d = dirs[k];\n int nx = humans[i].x + dx[d];\n int ny = humans[i].y + dy[d];\n if (nx >= 1 && nx <= GRID_SIZE && ny >= 1 && ny <= GRID_SIZE && grid_passable[nx][ny]) {\n humans[i].x = nx;\n humans[i].y = ny;\n next_human_count[nx][ny]++;\n action += move_dir[d];\n acted = true;\n break;\n }\n }\n }\n \n // Do nothing if no valid moves\n if (!acted) {\n next_human_count[humans[i].x][humans[i].y]++;\n action += '.';\n }\n }\n cout << action << \"\\n\";\n cout.flush();\n\n // Reset pet counts\n for (int i = 1; i <= GRID_SIZE; ++i) {\n for (int j = 1; j <= GRID_SIZE; ++j) {\n pet_count[i][j] = 0;\n }\n }\n\n // Read pet moves\n for (int i = 0; i < N; ++i) {\n string pet_move;\n cin >> pet_move;\n if (pet_move != \".\") {\n for (char c : pet_move) {\n if (c == 'U') pets[i].x--;\n else if (c == 'D') pets[i].x++;\n else if (c == 'L') pets[i].y--;\n else if (c == 'R') pets[i].y++;\n }\n }\n pet_count[pets[i].x][pets[i].y]++;\n }\n }\n\n return 0;\n}","ahc009":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\nint si, sj, ti, tj;\ndouble p;\nstring h[N], v[N - 1];\n\ndouble V[205][400];\nint adj[400][4];\n\nint di[] = {-1, 1, 0, 0};\nint dj[] = {0, 0, -1, 1};\nchar dir_char[] = {'U', 'D', 'L', 'R'};\n\nbool can_move(int i, int j, int d) {\n if (d == 0) return i > 0 && v[i - 1][j] == '0';\n if (d == 1) return i < N - 1 && v[i][j] == '0';\n if (d == 2) return j > 0 && h[i][j - 1] == '0';\n if (d == 3) return j < N - 1 && h[i][j] == '0';\n return false;\n}\n\nvoid precompute() {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int u = i * N + j;\n for (int d = 0; d < 4; ++d) {\n if (can_move(i, j, d)) {\n adj[u][d] = (i + di[d]) * N + (j + dj[d]);\n } else {\n adj[u][d] = u;\n }\n }\n }\n }\n\n int target = ti * N + tj;\n for (int u = 0; u < 400; ++u) V[0][u] = 0.0;\n\n for (int rem = 1; rem <= 200; ++rem) {\n for (int u = 0; u < 400; ++u) {\n if (u == target) {\n V[rem][u] = 0.0;\n continue;\n }\n double best_val = -1.0;\n for (int d = 0; d < 4; ++d) {\n double val = 0.0;\n int nxt = adj[u][d];\n if (nxt == target) {\n val = p * V[rem - 1][u] + (1.0 - p) * (200 + rem);\n } else {\n val = p * V[rem - 1][u] + (1.0 - p) * V[rem - 1][nxt];\n }\n if (val > best_val) best_val = val;\n }\n V[rem][u] = best_val;\n }\n }\n}\n\nstruct State {\n double prob[400];\n short active[400];\n short num_active;\n int parent;\n char move;\n double current_score;\n double eval_score;\n double target_prob;\n\n bool operator<(const State& other) const {\n return eval_score > other.eval_score; \n }\n};\n\nstruct HistoryNode {\n int parent;\n char move;\n};\n\nState beam_array[2][1600]; \n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> si >> sj >> ti >> tj >> p)) return 0;\n\n for (int i = 0; i < N; ++i) cin >> h[i];\n for (int i = 0; i < N - 1; ++i) cin >> v[i];\n\n precompute();\n\n vector> history(201);\n \n int start_u = si * N + sj;\n beam_array[0][0].prob[start_u] = 1.0;\n beam_array[0][0].active[0] = start_u;\n beam_array[0][0].num_active = 1;\n beam_array[0][0].parent = -1;\n beam_array[0][0].move = ' ';\n beam_array[0][0].current_score = 0.0;\n beam_array[0][0].eval_score = V[200][start_u];\n beam_array[0][0].target_prob = 0.0;\n \n int beam_size = 1;\n int beam_width = 400; // Safely reduced beam width to comfortably pass within 2.0s\n int target = ti * N + tj;\n bool in_active[400] = {false};\n \n int final_step = 200;\n int current_idx = 0;\n int next_idx = 1;\n\n for (int step = 1; step <= 200; ++step) {\n if (beam_array[current_idx][0].target_prob > 0.9999) {\n final_step = step - 1;\n break;\n }\n\n int next_size = 0;\n\n for (int p_idx = 0; p_idx < beam_size; ++p_idx) {\n const auto& state = beam_array[current_idx][p_idx];\n for (int d = 0; d < 4; ++d) {\n State& next_state = beam_array[next_idx][next_size++];\n next_state.parent = p_idx;\n next_state.move = dir_char[d];\n next_state.current_score = state.current_score;\n next_state.target_prob = state.target_prob;\n next_state.num_active = 0;\n \n for (int i = 0; i < state.num_active; ++i) {\n int u = state.active[i];\n next_state.prob[u] = 0.0;\n next_state.prob[adj[u][d]] = 0.0;\n }\n\n for (int i = 0; i < state.num_active; ++i) {\n int u = state.active[i];\n double pr = state.prob[u];\n int nxt = adj[u][d];\n \n if (nxt == target && u != target) {\n next_state.current_score += pr * (1.0 - p) * (401 - step);\n next_state.prob[u] += pr * p;\n next_state.target_prob += pr * (1.0 - p);\n } else if (nxt == u) {\n next_state.prob[u] += pr;\n } else {\n next_state.prob[nxt] += pr * (1.0 - p);\n next_state.prob[u] += pr * p;\n }\n }\n\n next_state.eval_score = next_state.current_score;\n \n for (int i = 0; i < state.num_active; ++i) {\n int u = state.active[i];\n if (next_state.prob[u] > 1e-9 && !in_active[u]) {\n next_state.active[next_state.num_active++] = u;\n in_active[u] = true;\n }\n int nxt = adj[u][d];\n if (nxt != u && next_state.prob[nxt] > 1e-9 && !in_active[nxt]) {\n next_state.active[next_state.num_active++] = nxt;\n in_active[nxt] = true;\n }\n }\n \n for (int i = 0; i < next_state.num_active; ++i) {\n int u = next_state.active[i];\n next_state.eval_score += next_state.prob[u] * V[200 - step][u];\n in_active[u] = false; \n }\n }\n }\n\n int keep = min(next_size, beam_width);\n partial_sort(beam_array[next_idx], beam_array[next_idx] + keep, beam_array[next_idx] + next_size);\n beam_size = keep;\n\n history[step].resize(keep);\n for (int i = 0; i < keep; ++i) {\n history[step][i] = {beam_array[next_idx][i].parent, beam_array[next_idx][i].move};\n }\n\n swap(current_idx, next_idx);\n }\n\n string ans = \"\";\n int curr_step = final_step;\n int curr_idx = 0;\n\n while (curr_step > 0) {\n ans += history[curr_step][curr_idx].move;\n curr_idx = history[curr_step][curr_idx].parent;\n curr_step--;\n }\n \n reverse(ans.begin(), ans.end());\n cout << ans << \"\\n\";\n \n return 0;\n}","ahc010":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int TILE_EDGES[8][4] = {\n {0, 1, -1, -1}, // 0: {0,1}\n {0, 3, -1, -1}, // 1: {0,3}\n {2, 3, -1, -1}, // 2: {2,3}\n {1, 2, -1, -1}, // 3: {1,2}\n {0, 1, 2, 3}, // 4: {0,1}, {2,3}\n {0, 3, 1, 2}, // 5: {0,3}, {1,2}\n {0, 2, -1, -1}, // 6: {0,2}\n {1, 3, -1, -1} // 7: {1,3}\n};\n\ninline int rot(int t, int r) {\n if (t <= 3) return (t + r) & 3;\n if (t <= 5) return 4 + ((t - 4 + r) & 1);\n return 6 + ((t - 6 + r) & 1);\n}\n\nint base_grid[30][30];\nint cur_grid[30][30];\nint cur_rot[30][30];\n\nint port_id[30][30][4];\nint total_ports = 0;\n\nint dsu_parent[2000];\nint dsu_sz[2000];\nbool dsu_cycle[2000];\n\ninline int find_set(int v) {\n int root = v;\n while (root != dsu_parent[root]) {\n root = dsu_parent[root];\n }\n int curr = v;\n while (curr != root) {\n int nxt = dsu_parent[curr];\n dsu_parent[curr] = root;\n curr = nxt;\n }\n return root;\n}\n\nstruct EvalResult {\n long long real_score;\n double search_score;\n};\n\ninline EvalResult evaluate() {\n for (int i = 0; i < total_ports; i++) {\n dsu_parent[i] = i;\n dsu_sz[i] = 0;\n dsu_cycle[i] = false;\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n int t = cur_grid[i][j];\n int e0 = TILE_EDGES[t][0];\n int e1 = TILE_EDGES[t][1];\n if (e0 != -1) {\n int r1 = find_set(port_id[i][j][e0]);\n int r2 = find_set(port_id[i][j][e1]);\n if (r1 == r2) {\n dsu_cycle[r1] = true;\n dsu_sz[r1]++;\n } else {\n dsu_parent[r1] = r2;\n dsu_sz[r2] += dsu_sz[r1] + 1;\n dsu_cycle[r2] |= dsu_cycle[r1];\n }\n }\n int e2 = TILE_EDGES[t][2];\n int e3 = TILE_EDGES[t][3];\n if (e2 != -1) {\n int r1 = find_set(port_id[i][j][e2]);\n int r2 = find_set(port_id[i][j][e3]);\n if (r1 == r2) {\n dsu_cycle[r1] = true;\n dsu_sz[r1]++;\n } else {\n dsu_parent[r1] = r2;\n dsu_sz[r2] += dsu_sz[r1] + 1;\n dsu_cycle[r2] |= dsu_cycle[r1];\n }\n }\n }\n }\n\n int l1 = 0, l2 = 0;\n double v0 = 0.0, v1 = 0.0;\n double sum_sq = 0.0;\n\n for (int i = 0; i < total_ports; i++) {\n if (dsu_parent[i] == i && dsu_sz[i] > 0) {\n int s = dsu_sz[i];\n double v;\n if (dsu_cycle[i]) {\n if (s > l1) {\n l2 = l1;\n l1 = s;\n } else if (s > l2) {\n l2 = s;\n }\n v = (double)s;\n } else {\n v = (double)s * 0.55; \n }\n sum_sq += v * v;\n \n if (v > v0) {\n v1 = v0;\n v0 = v;\n } else if (v > v1) {\n v1 = v;\n }\n }\n }\n\n long long real_score = (long long)l1 * l2;\n double search_score = (v0 * v1) + (0.001 * sum_sq); \n\n return {real_score, search_score};\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789, y = 362436069, z = 521288629, w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ndouble rnd() {\n return (double)(xor128() & 0xFFFFFF) / 16777216.0;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start = chrono::high_resolution_clock::now();\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n base_grid[i][j] = s[j] - '0';\n cur_grid[i][j] = base_grid[i][j];\n cur_rot[i][j] = 0;\n }\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n for (int d = 0; d < 4; d++) port_id[i][j][d] = -1;\n }\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n if (j < 29) {\n port_id[i][j][2] = total_ports;\n port_id[i][j + 1][0] = total_ports;\n total_ports++;\n } else port_id[i][j][2] = total_ports++;\n if (j == 0) port_id[i][j][0] = total_ports++;\n\n if (i < 29) {\n port_id[i][j][3] = total_ports;\n port_id[i + 1][j][1] = total_ports;\n total_ports++;\n } else port_id[i][j][3] = total_ports++;\n if (i == 0) port_id[i][j][1] = total_ports++;\n }\n }\n\n EvalResult initial_eval = evaluate();\n long long best_real_score = initial_eval.real_score;\n double current_search_score = initial_eval.search_score;\n \n int best_rot[30][30];\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n best_rot[i][j] = cur_rot[i][j];\n }\n }\n\n double time_limit = 1.95;\n double T0 = 50.0;\n double T1 = 0.5;\n double T = T0;\n int iters = 0;\n \n while (true) {\n if ((iters & 255) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start).count();\n if (elapsed > time_limit) break;\n double progress = elapsed / time_limit;\n T = T0 * pow(T1 / T0, progress);\n }\n iters++;\n\n int i = xor128() % 30;\n int j = xor128() % 30;\n int r = (xor128() % 3) + 1;\n \n int old_rot = cur_rot[i][j];\n int new_rot = (old_rot + r) & 3;\n \n cur_rot[i][j] = new_rot;\n cur_grid[i][j] = rot(base_grid[i][j], new_rot);\n \n EvalResult res = evaluate();\n \n bool accept = false;\n if (res.search_score >= current_search_score) {\n accept = true;\n } else {\n double diff = res.search_score - current_search_score;\n if (rnd() < exp(diff / T)) {\n accept = true;\n }\n }\n\n if (accept) {\n current_search_score = res.search_score;\n if (res.real_score > best_real_score) {\n best_real_score = res.real_score;\n for (int r_idx = 0; r_idx < 30; r_idx++) {\n for (int c_idx = 0; c_idx < 30; c_idx++) {\n best_rot[r_idx][c_idx] = cur_rot[r_idx][c_idx];\n }\n }\n }\n } else {\n cur_rot[i][j] = old_rot;\n cur_grid[i][j] = rot(base_grid[i][j], old_rot);\n }\n }\n\n for (int i = 0; i < 30; i++) {\n for (int j = 0; j < 30; j++) {\n cout << best_rot[i][j];\n }\n }\n cout << \"\\n\";\n return 0;\n}","ahc011":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nint N, T;\nuint8_t initial_board[100];\nint init_empty_r, init_empty_c;\n\nconst int dr[] = {-1, 1, 0, 0};\nconst int dc[] = {0, 0, -1, 1};\nconst char dir_char[] = {'U', 'D', 'L', 'R'};\nconst char opp_dir[] = {'D', 'U', 'R', 'L'};\n\nint time_limit_ms = 2850;\n\nuint64_t zobrist[100][16];\n\nvoid init_zobrist() {\n mt19937_64 rng(1337);\n for (int i = 0; i < 100; ++i) {\n for (int j = 0; j < 16; ++j) {\n zobrist[i][j] = rng();\n }\n }\n}\n\nint get_eval(const uint8_t* b, int& max_tree_size) {\n int parent[100];\n int sz[100];\n int edges_cnt[100];\n int broken = 0;\n int valid = 0;\n\n int N2 = N * N;\n for (int i = 0; i < N2; ++i) {\n parent[i] = i;\n sz[i] = 1;\n edges_cnt[i] = 0;\n }\n\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n int u = r * N + c;\n if (b[u] == 0) continue;\n\n if (r == 0 && (b[u] & 2)) broken += 4;\n if (r == N - 1 && (b[u] & 8)) broken += 4;\n if (c == 0 && (b[u] & 1)) broken += 4;\n if (c == N - 1 && (b[u] & 4)) broken += 4;\n\n if (r < N - 1 && b[u + N] != 0) {\n bool down = b[u] & 8;\n bool up = b[u + N] & 2;\n if (down && up) {\n valid++;\n int root_u = u, root_v = u + N;\n while (parent[root_u] != root_u) root_u = parent[root_u];\n while (parent[root_v] != root_v) root_v = parent[root_v];\n if (root_u != root_v) {\n parent[root_u] = root_v;\n sz[root_v] += sz[root_u];\n edges_cnt[root_v] += edges_cnt[root_u] + 1;\n } else {\n edges_cnt[root_u]++;\n }\n } else if (down || up) {\n broken++;\n }\n }\n if (c < N - 1 && b[u + 1] != 0) {\n bool right = b[u] & 4;\n bool left = b[u + 1] & 1;\n if (right && left) {\n valid++;\n int root_u = u, root_v = u + 1;\n while (parent[root_u] != root_u) root_u = parent[root_u];\n while (parent[root_v] != root_v) root_v = parent[root_v];\n if (root_u != root_v) {\n parent[root_u] = root_v;\n sz[root_v] += sz[root_u];\n edges_cnt[root_v] += edges_cnt[root_u] + 1;\n } else {\n edges_cnt[root_u]++;\n }\n } else if (right || left) {\n broken++;\n }\n }\n }\n }\n\n max_tree_size = 0;\n for (int i = 0; i < N2; ++i) {\n if (parent[i] == i && b[i] != 0) {\n if (edges_cnt[i] == sz[i] - 1) {\n if (sz[i] > max_tree_size) {\n max_tree_size = sz[i];\n }\n }\n }\n }\n\n return max_tree_size * 10000 + valid * 35 - broken * 12;\n}\n\nstruct State {\n uint8_t b[100];\n uint8_t er, ec;\n int score;\n int tree_size;\n uint64_t hash;\n int hist_id;\n\n bool operator<(const State& o) const {\n return score > o.score;\n }\n};\n\nstruct HistNode {\n int parent;\n char move;\n};\nvector history;\n\nconst int HASH_SIZE = 4194304; // 2^22\nuint64_t hash_table[HASH_SIZE];\n\nbool insert_hash(uint64_t hash) {\n if (hash == 0) return false;\n uint32_t idx = hash & (HASH_SIZE - 1);\n while (true) {\n if (hash_table[idx] == 0) {\n hash_table[idx] = hash;\n return true;\n }\n if (hash_table[idx] == hash) {\n return false;\n }\n idx = (idx + 1) & (HASH_SIZE - 1);\n }\n}\n\nvoid clear_hash() {\n fill(hash_table, hash_table + HASH_SIZE, 0);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n init_zobrist();\n\n if (!(cin >> N >> T)) return 0;\n\n history.reserve(8000000);\n\n uint64_t init_hash = 0;\n for (int i = 0; i < N; ++i) {\n string s;\n cin >> s;\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (s[j] >= '0' && s[j] <= '9') initial_board[idx] = s[j] - '0';\n else initial_board[idx] = s[j] - 'a' + 10;\n \n init_hash ^= zobrist[idx][initial_board[idx]];\n \n if (initial_board[idx] == 0) {\n init_empty_r = i;\n init_empty_c = j;\n }\n }\n }\n\n int best_tree_size = 0;\n int best_hist_id = -1;\n\n int initial_tree_size = 0;\n int initial_score = get_eval(initial_board, initial_tree_size);\n best_tree_size = initial_tree_size;\n\n vector beam;\n State init_state;\n copy(initial_board, initial_board + 100, init_state.b);\n init_state.er = init_empty_r;\n init_state.ec = init_empty_c;\n init_state.score = initial_score;\n init_state.tree_size = initial_tree_size;\n init_state.hash = init_hash;\n init_state.hist_id = -1;\n beam.push_back(init_state);\n\n int beam_width = (N <= 7) ? 6000 : 4500;\n clear_hash();\n insert_hash(init_hash);\n\n bool perfect_found = false;\n int visited_count = 1;\n\n for (int step = 0; step < T; ++step) {\n auto current_time = high_resolution_clock::now();\n if (duration_cast(current_time - start_time).count() > time_limit_ms) {\n break;\n }\n\n vector next_beam;\n next_beam.reserve(beam.size() * 4);\n\n for (const auto& state : beam) {\n char last_move = (state.hist_id == -1) ? 'X' : history[state.hist_id].move;\n\n for (int d = 0; d < 4; ++d) {\n if (last_move == opp_dir[d]) continue;\n\n int nr = state.er + dr[d];\n int nc = state.ec + dc[d];\n\n if (nr >= 0 && nr < N && nc >= 0 && nc < N) {\n int u = state.er * N + state.ec;\n int v = nr * N + nc;\n \n uint64_t next_hash = state.hash;\n next_hash ^= zobrist[u][state.b[u]] ^ zobrist[u][state.b[v]];\n next_hash ^= zobrist[v][state.b[v]] ^ zobrist[v][state.b[u]];\n\n if (!insert_hash(next_hash)) continue;\n visited_count++;\n\n State next_state = state;\n swap(next_state.b[u], next_state.b[v]);\n next_state.er = nr;\n next_state.ec = nc;\n next_state.hash = next_hash;\n \n int new_hist_id = history.size();\n history.push_back({state.hist_id, dir_char[d]});\n next_state.hist_id = new_hist_id;\n\n next_state.score = get_eval(next_state.b, next_state.tree_size);\n next_beam.push_back(move(next_state));\n \n if (next_state.tree_size == N * N - 1) {\n best_tree_size = next_state.tree_size;\n best_hist_id = next_state.hist_id;\n perfect_found = true;\n break;\n }\n }\n }\n if (perfect_found) break;\n }\n\n if (perfect_found) break;\n\n sort(next_beam.begin(), next_beam.end());\n if (next_beam.size() > beam_width) {\n next_beam.resize(beam_width);\n }\n\n beam = move(next_beam);\n\n if (!beam.empty() && beam[0].tree_size > best_tree_size) {\n best_tree_size = beam[0].tree_size;\n best_hist_id = beam[0].hist_id;\n }\n \n if (visited_count > 2000000) {\n clear_hash();\n visited_count = 0;\n for (const auto& s : beam) {\n insert_hash(s.hash);\n visited_count++;\n }\n }\n }\n\n string best_moves = \"\";\n int curr = best_hist_id;\n while (curr != -1) {\n best_moves += history[curr].move;\n curr = history[curr].parent;\n }\n reverse(best_moves.begin(), best_moves.end());\n\n cout << best_moves << \"\\n\";\n\n return 0;\n}","ahc012":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ntypedef unsigned __int128 u128;\n\nconst int K = 100;\nint N;\nint a[11];\nint x_coords[10005];\nint y_coords[10005];\n\nstruct Line {\n double theta;\n double r;\n};\n\nLine lines[K];\nu128 hashes[10005];\nu128 sorted_hashes[10005];\n\npair, pair> get_points(const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n double px = l.r * cos_t - 20000.0 * sin_t;\n double py = l.r * sin_t + 20000.0 * cos_t;\n double qx = l.r * cos_t + 20000.0 * sin_t;\n double qy = l.r * sin_t - 20000.0 * cos_t;\n return {{round(px), round(py)}, {round(qx), round(qy)}};\n}\n\n// Fast PRNG\nuint64_t xorshift64_state = 0x8817264546332525ULL;\ninline uint64_t xorshift64() {\n xorshift64_state ^= xorshift64_state << 13;\n xorshift64_state ^= xorshift64_state >> 7;\n xorshift64_state ^= xorshift64_state << 17;\n return xorshift64_state;\n}\n\ninline double fast_rand_double() {\n return (xorshift64() >> 11) * (1.0 / 9007199254740992.0);\n}\n\nint evaluate() {\n memcpy(sorted_hashes, hashes, N * sizeof(u128));\n std::sort(sorted_hashes, sorted_hashes + N);\n\n int b[11] = {0};\n int current_count = 1;\n for (int i = 1; i < N; ++i) {\n if (sorted_hashes[i] == sorted_hashes[i - 1]) {\n current_count++;\n } else {\n if (current_count <= 10) {\n b[current_count]++;\n }\n current_count = 1;\n }\n }\n if (current_count <= 10) {\n b[current_count]++;\n }\n\n int score = 0;\n for (int d = 1; d <= 10; ++d) {\n // Base score mapped to 1000\n score += min(a[d], b[d]) * 1000;\n // Secondary tie-breaker: slight reward for making ANY pieces of size <= 10\n // even if we already exceeded the requirement a[d]\n if (b[d] > a[d]) {\n score += 2;\n }\n }\n return score;\n}\n\nvoid update_line_hash(int line_idx, const Line& l) {\n double cos_t = cos(l.theta);\n double sin_t = sin(l.theta);\n u128 mask = ((u128)1) << line_idx;\n u128 not_mask = ~mask;\n \n for (int i = 0; i < N; ++i) {\n if (x_coords[i] * cos_t + y_coords[i] * sin_t > l.r) hashes[i] |= mask;\n else hashes[i] &= not_mask;\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int max_k;\n if (!(cin >> N >> max_k)) return 0;\n\n int total_a = 0;\n for (int i = 1; i <= 10; ++i) {\n cin >> a[i];\n total_a += a[i];\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> x_coords[i] >> y_coords[i];\n }\n\n for (int i = 0; i < K; ++i) {\n lines[i].theta = fast_rand_double() * M_PI;\n lines[i].r = fast_rand_double() * 19800.0 - 9900.0;\n update_line_hash(i, lines[i]);\n }\n\n int current_score = evaluate();\n int best_score = current_score;\n \n Line best_lines[K];\n for(int i = 0; i < K; ++i) best_lines[i] = lines[i];\n\n auto start_time = chrono::high_resolution_clock::now();\n double time_limit = 2.95;\n\n // Temperatures scaled up by 1000 to match the new objective scaling\n double t0 = 1200.0;\n double t1 = 10.0;\n double temp = t0;\n \n int iter = 0;\n while (true) {\n if ((iter & 255) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n temp = t0 * pow(t1 / t0, progress);\n }\n\n int idx = xorshift64() % K;\n Line old_line = lines[idx];\n\n if (xorshift64() % 6 == 0) {\n lines[idx].theta = fast_rand_double() * M_PI;\n lines[idx].r = fast_rand_double() * 19800.0 - 9900.0;\n } else {\n double d_theta = (fast_rand_double() + fast_rand_double() - 1.0) * 0.05;\n double d_r = (fast_rand_double() + fast_rand_double() - 1.0) * 200.0;\n lines[idx].theta += d_theta;\n lines[idx].r += d_r;\n }\n \n update_line_hash(idx, lines[idx]);\n int new_score = evaluate();\n\n bool accept = false;\n if (new_score >= current_score) {\n accept = true;\n } else {\n double prob = exp((new_score - current_score) / temp);\n if (fast_rand_double() < prob) accept = true;\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score > best_score) {\n best_score = current_score;\n for(int i = 0; i < K; ++i) best_lines[i] = lines[i];\n }\n } else {\n lines[idx] = old_line;\n update_line_hash(idx, lines[idx]);\n }\n \n iter++;\n }\n\n cout << K << \"\\n\";\n for (int i = 0; i < K; ++i) {\n auto pts = get_points(best_lines[i]);\n cout << pts.first.first << \" \" << pts.first.second << \" \" \n << pts.second.first << \" \" << pts.second.second << \"\\n\";\n }\n\n return 0;\n}","ahc014":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int MAXN = 65;\n\nstruct Point {\n int x, y;\n bool operator==(const Point& o) const { return x == o.x && y == o.y; }\n};\n\nstruct Move {\n Point p1, p2, p3, p4;\n};\n\nint N, M;\nPoint center;\nvector initial_dots;\nint weight[MAXN][MAXN];\n\ndouble get_time() {\n static auto start = high_resolution_clock::now();\n return duration(high_resolution_clock::now() - start).count();\n}\n\nstruct State {\n bool has_dot[MAXN][MAXN];\n int edges[4][MAXN][MAXN]; \n vector dots;\n vector moves;\n int score;\n\n State() {\n for (int i = 0; i < MAXN; ++i) {\n for (int j = 0; j < MAXN; ++j) {\n has_dot[i][j] = false;\n for (int k = 0; k < 4; ++k) edges[k][i][j] = 0;\n }\n }\n score = 0;\n }\n\n void add_dot(Point p) {\n has_dot[p.x][p.y] = true;\n dots.push_back(p);\n score += weight[p.x][p.y];\n }\n\n bool inside(int x, int y) const {\n return x >= 0 && x < N && y >= 0 && y < N;\n }\n\n bool check_edge(Point p1, Point p2) const {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n if (dx != 0 && dy != 0 && abs(dx) != abs(dy)) return false;\n \n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = (step_y == 0) ? 0 : ((step_x == 0) ? 1 : ((step_x == step_y) ? 2 : 3));\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = cx, ey = cy;\n if (step_x < 0) ex = nx;\n if (step_y < 0) ey = ny;\n if (type == 3) {\n ex = (step_x > 0) ? cx : nx;\n ey = (step_y > 0) ? ny : cy;\n }\n if (edges[type][ex][ey]) return false;\n if ((cx != p1.x || cy != p1.y) && has_dot[cx][cy]) return false;\n cx = nx; cy = ny;\n }\n return true;\n }\n\n void mark_edge(Point p1, Point p2, int val) {\n int dx = p2.x - p1.x;\n int dy = p2.y - p1.y;\n int step_x = (dx == 0) ? 0 : (dx > 0 ? 1 : -1);\n int step_y = (dy == 0) ? 0 : (dy > 0 ? 1 : -1);\n int type = (step_y == 0) ? 0 : ((step_x == 0) ? 1 : ((step_x == step_y) ? 2 : 3));\n\n int cx = p1.x, cy = p1.y;\n while (cx != p2.x || cy != p2.y) {\n int nx = cx + step_x, ny = cy + step_y;\n int ex = cx, ey = cy;\n if (step_x < 0) ex = nx;\n if (step_y < 0) ey = ny;\n if (type == 3) {\n ex = (step_x > 0) ? cx : nx;\n ey = (step_y > 0) ? ny : cy;\n }\n edges[type][ex][ey] += val;\n cx = nx; cy = ny;\n }\n }\n\n bool is_valid_rect(Point p1, Point p2, Point p3, Point p4) const {\n if (!check_edge(p1, p2)) return false;\n if (!check_edge(p2, p3)) return false;\n if (!check_edge(p3, p4)) return false;\n if (!check_edge(p4, p1)) return false;\n return true;\n }\n\n void apply_move(const Move& m) {\n add_dot(m.p1);\n mark_edge(m.p1, m.p2, 1);\n mark_edge(m.p2, m.p3, 1);\n mark_edge(m.p3, m.p4, 1);\n mark_edge(m.p4, m.p1, 1);\n moves.push_back(m);\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M)) return 0;\n\n center = {(N - 1) / 2, (N - 1) / 2};\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n weight[i][j] = (i - center.x) * (i - center.x) + (j - center.y) * (j - center.y) + 1;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n int x, y;\n cin >> x >> y;\n initial_dots.push_back({x, y});\n }\n\n State best_state;\n best_state.score = -1;\n \n uint32_t seed = 42;\n auto rand_u32 = [&]() -> uint32_t {\n seed ^= seed << 13;\n seed ^= seed >> 17;\n seed ^= seed << 5;\n return seed;\n };\n\n while (get_time() < 4.8) { \n State state;\n for (auto p : initial_dots) state.add_dot(p);\n\n bool moved = true;\n while (moved) {\n if (get_time() > 4.8) break;\n\n moved = false;\n vector candidates;\n\n int num_dots = state.dots.size();\n for (int i = 0; i < num_dots; ++i) {\n Point p2 = state.dots[i];\n for (int j = i + 1; j < num_dots; ++j) {\n Point p4 = state.dots[j];\n \n // 1. Axis-aligned\n if (p2.x != p4.x && p2.y != p4.y) {\n Point p1 = {p2.x, p4.y};\n Point p3 = {p4.x, p2.y};\n \n if (state.inside(p1.x, p1.y) && state.inside(p3.x, p3.y)) {\n bool has_p1 = state.has_dot[p1.x][p1.y];\n bool has_p3 = state.has_dot[p3.x][p3.y];\n \n if (has_p1 != has_p3) {\n if (!has_p1) {\n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n } else {\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n }\n }\n }\n }\n\n // 2. 45-degree\n int sum2 = p2.x + p2.y;\n int diff4 = p4.x - p4.y;\n int sum4 = p4.x + p4.y;\n int diff2 = p2.x - p2.y;\n\n if ((sum2 + diff4) % 2 == 0 && (sum4 + diff2) % 2 == 0) {\n Point p1 = {(sum2 + diff4) / 2, (sum2 - diff4) / 2};\n Point p3 = {(sum4 + diff2) / 2, (sum4 - diff2) / 2};\n\n if (state.inside(p1.x, p1.y) && state.inside(p3.x, p3.y)) {\n if (!(p1 == p2) && !(p1 == p4) && !(p3 == p2) && !(p3 == p4)) {\n bool has_p1 = state.has_dot[p1.x][p1.y];\n bool has_p3 = state.has_dot[p3.x][p3.y];\n \n if (has_p1 != has_p3) {\n if (!has_p1) {\n if (state.is_valid_rect(p1, p2, p3, p4)) candidates.push_back({p1, p2, p3, p4});\n } else {\n if (state.is_valid_rect(p3, p2, p1, p4)) candidates.push_back({p3, p2, p1, p4});\n }\n }\n }\n }\n }\n }\n }\n\n if (!candidates.empty()) {\n Move best_m = candidates[0];\n int best_val = -1;\n for (const auto& m : candidates) {\n // Slight penalty for longer edges to encourage dense packing\n int edge_len = max(abs(m.p2.x - m.p1.x), abs(m.p2.y - m.p1.y));\n int val = weight[m.p1.x][m.p1.y] * 10 - edge_len + (rand_u32() % 100); \n if (val > best_val) {\n best_val = val;\n best_m = m;\n }\n }\n state.apply_move(best_m);\n moved = true;\n }\n }\n\n if (state.score > best_state.score) {\n best_state = state;\n }\n }\n\n cout << best_state.moves.size() << \"\\n\";\n for (const auto& m : best_state.moves) {\n cout << m.p1.x << \" \" << m.p1.y << \" \" \n << m.p2.x << \" \" << m.p2.y << \" \" \n << m.p3.x << \" \" << m.p3.y << \" \" \n << m.p4.x << \" \" << m.p4.y << \"\\n\";\n }\n\n return 0;\n}","ahc015":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n\n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Board {\n uint8_t grid[100] = {0};\n\n inline void add_candy(uint8_t flavor, int p) {\n int empty_count = 0;\n for (int i = 0; i < 100; ++i) {\n if (grid[i] == 0) {\n empty_count++;\n if (empty_count == p) {\n grid[i] = flavor;\n return;\n }\n }\n }\n }\n\n inline void add_random_candy(uint8_t flavor, uint32_t rnd_val) {\n int empty_pos[100];\n int empty_cnt = 0;\n for (int i = 0; i < 100; ++i) {\n if (grid[i] == 0) {\n empty_pos[empty_cnt++] = i;\n }\n }\n if (empty_cnt > 0) {\n grid[empty_pos[rnd_val % empty_cnt]] = flavor;\n }\n }\n\n // 0: F, 1: B, 2: L, 3: R\n inline bool tilt(int dir) {\n bool changed = false;\n if (dir == 0) { // F\n for (int c = 0; c < 10; ++c) {\n int write_idx = 0;\n for (int r = 0; r < 10; ++r) {\n int idx = r * 10 + c;\n if (grid[idx] != 0) {\n if (r != write_idx) {\n grid[write_idx * 10 + c] = grid[idx];\n grid[idx] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 1) { // B\n for (int c = 0; c < 10; ++c) {\n int write_idx = 9;\n for (int r = 9; r >= 0; --r) {\n int idx = r * 10 + c;\n if (grid[idx] != 0) {\n if (r != write_idx) {\n grid[write_idx * 10 + c] = grid[idx];\n grid[idx] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n } else if (dir == 2) { // L\n for (int r = 0; r < 10; ++r) {\n int write_idx = 0;\n int row_offset = r * 10;\n for (int c = 0; c < 10; ++c) {\n int idx = row_offset + c;\n if (grid[idx] != 0) {\n if (c != write_idx) {\n grid[row_offset + write_idx] = grid[idx];\n grid[idx] = 0;\n changed = true;\n }\n write_idx++;\n }\n }\n }\n } else if (dir == 3) { // R\n for (int r = 0; r < 10; ++r) {\n int write_idx = 9;\n int row_offset = r * 10;\n for (int c = 9; c >= 0; --c) {\n int idx = row_offset + c;\n if (grid[idx] != 0) {\n if (c != write_idx) {\n grid[row_offset + write_idx] = grid[idx];\n grid[idx] = 0;\n changed = true;\n }\n write_idx--;\n }\n }\n }\n }\n return changed;\n }\n\n inline int calc_score() const {\n bool vis[100] = {false};\n int score = 0;\n int q[100];\n \n for (int i = 0; i < 100; ++i) {\n if (grid[i] != 0 && !vis[i]) {\n uint8_t flavor = grid[i];\n int sz = 0;\n int head = 0, tail = 0;\n \n q[tail++] = i;\n vis[i] = true;\n \n while (head < tail) {\n int pos = q[head++];\n sz++;\n \n int cr = pos / 10;\n int cc = pos % 10;\n \n if (cr > 0 && !vis[pos - 10] && grid[pos - 10] == flavor) {\n vis[pos - 10] = true;\n q[tail++] = pos - 10;\n }\n if (cr < 9 && !vis[pos + 10] && grid[pos + 10] == flavor) {\n vis[pos + 10] = true;\n q[tail++] = pos + 10;\n }\n if (cc > 0 && !vis[pos - 1] && grid[pos - 1] == flavor) {\n vis[pos - 1] = true;\n q[tail++] = pos - 1;\n }\n if (cc < 9 && !vis[pos + 1] && grid[pos + 1] == flavor) {\n vis[pos + 1] = true;\n q[tail++] = pos + 1;\n }\n }\n score += sz * sz;\n }\n }\n return score;\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto global_start = high_resolution_clock::now();\n\n uint8_t f[100];\n for (int i = 0; i < 100; ++i) {\n int temp;\n cin >> temp;\n f[i] = temp;\n }\n\n Board b;\n uint32_t rng_state = 123456789;\n auto rand_int = [&rng_state]() -> uint32_t {\n rng_state ^= rng_state << 13;\n rng_state ^= rng_state >> 17;\n rng_state ^= rng_state << 5;\n return rng_state;\n };\n\n char dir_chars[] = {'F', 'B', 'L', 'R'};\n\n for (int t = 1; t <= 100; ++t) {\n int p;\n cin >> p;\n b.add_candy(f[t - 1], p);\n\n if (t == 100) break;\n\n auto step_start = high_resolution_clock::now();\n double elapsed_total = duration_cast(step_start - global_start).count();\n double time_limit = (1950.0 - elapsed_total) / (101 - t);\n \n long long total_score[4] = {0};\n int playouts[4] = {0};\n bool valid[4] = {false};\n Board next_b[4];\n\n for (int d = 0; d < 4; ++d) {\n next_b[d] = b;\n valid[d] = next_b[d].tilt(d);\n }\n\n int loop_count = 0;\n while (true) {\n if ((++loop_count & 255) == 0) {\n auto now = high_resolution_clock::now();\n if (duration_cast(now - step_start).count() > time_limit) {\n break;\n }\n }\n\n for (int d = 0; d < 4; ++d) {\n if (!valid[d]) continue;\n Board sim_b = next_b[d];\n for (int sim_t = t + 1; sim_t <= 100; ++sim_t) {\n sim_b.add_random_candy(f[sim_t - 1], rand_int());\n if (sim_t < 100) {\n sim_b.tilt(rand_int() & 3);\n }\n }\n total_score[d] += sim_b.calc_score();\n playouts[d]++;\n }\n }\n\n int best_dir = -1;\n double best_avg = -1.0;\n for (int d = 0; d < 4; ++d) {\n if (playouts[d] > 0) {\n double avg = (double)total_score[d] / playouts[d];\n if (avg > best_avg) {\n best_avg = avg;\n best_dir = d;\n }\n }\n }\n\n if (best_dir == -1) {\n best_dir = rand_int() & 3;\n }\n\n b.tilt(best_dir);\n cout << dir_chars[best_dir] << \"\\n\";\n cout.flush();\n }\n\n return 0;\n}","ahc016":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ndouble normal_cdf(double x) {\n return 0.5 * erfc(-x / sqrt(2.0));\n}\n\ndouble eval_score(const vector& edges, int M, int v, double eps) {\n if (eps == 0.0) return 0.0;\n \n double total_p_error = 0.0;\n double stddev = sqrt(v * eps * (1.0 - eps));\n \n for (int i = 0; i < M; ++i) {\n double mu_i = edges[i] * (1.0 - eps) + (v - edges[i]) * eps;\n \n double left_bound = -1e9;\n if (i > 0) {\n double mu_prev = edges[i - 1] * (1.0 - eps) + (v - edges[i - 1]) * eps;\n left_bound = (mu_i + mu_prev) / 2.0;\n }\n \n double right_bound = 1e9;\n if (i < M - 1) {\n double mu_next = edges[i + 1] * (1.0 - eps) + (v - edges[i + 1]) * eps;\n right_bound = (mu_i + mu_next) / 2.0;\n }\n \n double p_correct = normal_cdf((right_bound - mu_i) / stddev) - normal_cdf((left_bound - mu_i) / stddev);\n total_p_error += (1.0 - p_correct);\n }\n return 100.0 * (total_p_error / M);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int M;\n double eps;\n if (!(cin >> M >> eps)) return 0;\n\n int best_N = 100;\n double best_expected_score = -1.0;\n vector best_edges;\n\n for (int n = 4; n <= 100; ++n) {\n int v = n * (n - 1) / 2;\n if (v < M - 1) continue;\n\n vector edges(M);\n for (int i = 0; i < M; ++i) {\n edges[i] = round((double)i * v / (M - 1));\n }\n\n double expected_errors = eval_score(edges, M, v, eps);\n \n bool improved = true;\n int max_iters = 100;\n while (improved && eps > 0.0 && max_iters-- > 0) {\n improved = false;\n for (int i = 1; i < M - 1; ++i) {\n for (int delta : {-1, 1}) {\n edges[i] += delta;\n if (edges[i] <= edges[i - 1] || edges[i] >= edges[i + 1]) {\n edges[i] -= delta;\n continue;\n }\n double new_errors = eval_score(edges, M, v, eps);\n if (new_errors < expected_errors) {\n expected_errors = new_errors;\n improved = true;\n } else {\n edges[i] -= delta;\n }\n }\n }\n }\n\n // We use an even slightly steeper penalty base (0.88 instead of 0.89) \n // to courageously push for smaller N.\n double expected_score = pow(0.88, expected_errors) / n;\n \n if (expected_score > best_expected_score) {\n best_expected_score = expected_score;\n best_N = n;\n best_edges = edges;\n }\n }\n\n int N = best_N;\n int V = N * (N - 1) / 2;\n vector target_edges = best_edges;\n\n cout << N << \"\\n\";\n for (int i = 0; i < M; ++i) {\n string g = \"\";\n for (int j = 0; j < target_edges[i]; ++j) g += \"1\";\n for (int j = target_edges[i]; j < V; ++j) g += \"0\";\n cout << g << \"\\n\";\n }\n cout << flush;\n\n for (int q = 0; q < 100; ++q) {\n string H;\n cin >> H;\n \n int edges = 0;\n for (char c : H) {\n if (c == '1') edges++;\n }\n \n int best_guess = 0;\n double best_diff = 1e9;\n \n for (int i = 0; i < M; ++i) {\n double expected = target_edges[i] * (1.0 - eps) + (V - target_edges[i]) * eps;\n double diff = abs((double)edges - expected);\n if (diff < best_diff) {\n best_diff = diff;\n best_guess = i;\n }\n }\n \n cout << best_guess << \"\\n\" << flush;\n }\n\n return 0;\n}","ahc017":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Edge {\n int id;\n int u, v;\n long long w;\n double x, y;\n};\n\nstruct GraphEdge {\n int to;\n long long w;\n int id;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = high_resolution_clock::now();\n\n int N, M, D, K;\n if (!(cin >> N >> M >> D >> K)) return 0;\n\n vector edges(M);\n vector> adj(N);\n vector> coords(N);\n\n for (int i = 0; i < M; ++i) {\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; \n edges[i].v--;\n edges[i].id = i;\n adj[edges[i].u].push_back({edges[i].v, edges[i].w, i});\n adj[edges[i].v].push_back({edges[i].u, edges[i].w, i});\n }\n\n for (int i = 0; i < N; ++i) {\n cin >> coords[i].first >> coords[i].second;\n }\n\n for (int i = 0; i < M; ++i) {\n edges[i].x = (coords[edges[i].u].first + coords[edges[i].v].first) / 2.0;\n edges[i].y = (coords[edges[i].u].second + coords[edges[i].v].second) / 2.0;\n }\n\n mt19937 rng(42);\n \n // Farthest Point Sampling for evaluation sources\n int num_eval_sources = min(N, 12);\n vector eval_sources;\n eval_sources.push_back(uniform_int_distribution(0, N - 1)(rng));\n for (int i = 1; i < num_eval_sources; ++i) {\n int best_v = -1;\n long long max_dist = -1;\n for (int v = 0; v < N; ++v) {\n long long min_d = 2e18;\n for (int s : eval_sources) {\n long long dx = coords[v].first - coords[s].first;\n long long dy = coords[v].second - coords[s].second;\n long long d = dx * dx + dy * dy;\n min_d = min(min_d, d);\n }\n if (min_d > max_dist) {\n max_dist = min_d;\n best_v = v;\n }\n }\n eval_sources.push_back(best_v);\n }\n\n // Pre-allocate distance array to avoid allocation overhead in hot loop\n vector dist(N);\n\n auto compute_day_score = [&](const vector& ans, int day) -> long long {\n long long score = 0;\n for (int src : eval_sources) {\n fill(dist.begin(), dist.end(), 1e15);\n priority_queue, vector>, greater>> pq;\n \n dist[src] = 0;\n pq.push({0, src});\n \n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n \n if (d > dist[u]) continue;\n \n for (const auto& edge : adj[u]) {\n if (ans[edge.id] == day) continue;\n if (dist[edge.to] > d + edge.w) {\n dist[edge.to] = d + edge.w;\n pq.push({dist[edge.to], edge.to});\n }\n }\n }\n \n for (int i = 0; i < N; ++i) {\n if (dist[i] > 1e14) {\n score += 1000000000LL; // Soft penalty\n } else {\n score += dist[i];\n }\n }\n }\n return score;\n };\n\n vector best_ans(M, 1);\n long long best_total_score = -1;\n\n // Initialization: test random projection angles\n for (int iter = 0; iter < 20; ++iter) {\n double angle = uniform_real_distribution(0, 2 * M_PI)(rng);\n double cos_a = cos(angle);\n double sin_a = sin(angle);\n\n vector> proj(M);\n for (int i = 0; i < M; ++i) {\n proj[i] = {edges[i].x * cos_a + edges[i].y * sin_a, i};\n }\n\n sort(proj.begin(), proj.end());\n\n vector current_ans(M);\n for (int i = 0; i < M; ++i) {\n current_ans[proj[i].second] = (i % D) + 1;\n }\n\n long long current_score = 0;\n for (int d = 1; d <= D; ++d) {\n current_score += compute_day_score(current_ans, d);\n }\n\n if (best_total_score == -1 || current_score < best_total_score) {\n best_total_score = current_score;\n best_ans = current_ans;\n }\n }\n\n // Simulated Annealing\n vector current_ans = best_ans;\n vector day_scores(D + 1, 0);\n long long current_total_score = 0;\n \n for (int d = 1; d <= D; ++d) {\n day_scores[d] = compute_day_score(current_ans, d);\n current_total_score += day_scores[d];\n }\n \n uniform_int_distribution edge_dist(0, M - 1);\n \n double t0 = 2e6;\n double t1 = 1e2;\n double max_time = 5.8;\n\n while (true) {\n auto now = high_resolution_clock::now();\n double elapsed = duration_cast(now - start_time).count() / 1000.0;\n if (elapsed > max_time) break;\n\n double temp = t0 * pow(t1 / t0, elapsed / max_time);\n\n int e1 = edge_dist(rng);\n int e2 = edge_dist(rng);\n \n int d1 = current_ans[e1];\n int d2 = current_ans[e2];\n if (d1 == d2) continue;\n\n long long old_sub_score = day_scores[d1] + day_scores[d2];\n\n // Swap\n current_ans[e1] = d2;\n current_ans[e2] = d1;\n \n long long new_d1_score = compute_day_score(current_ans, d1);\n long long new_d2_score = compute_day_score(current_ans, d2);\n long long new_sub_score = new_d1_score + new_d2_score;\n \n long long delta = new_sub_score - old_sub_score;\n \n if (delta <= 0 || uniform_real_distribution(0, 1)(rng) < exp(-delta / temp)) {\n current_total_score += delta;\n day_scores[d1] = new_d1_score;\n day_scores[d2] = new_d2_score;\n \n if (current_total_score < best_total_score) {\n best_total_score = current_total_score;\n best_ans = current_ans;\n }\n } else {\n // Revert swap\n current_ans[e1] = d1;\n current_ans[e2] = d2;\n }\n }\n\n for (int i = 0; i < M; ++i) {\n cout << best_ans[i] << (i == M - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc019":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint D;\n\nstruct Point {\n int x, y, z;\n bool operator==(const Point& o) const { return x == o.x && y == o.y && z == o.z; }\n};\n\ninline int get_idx(int x, int y, int z) {\n return x * D * D + y * D + z;\n}\n\nPoint rotate(Point p, int rot) {\n int x = p.x, y = p.y, z = p.z;\n int nx, ny, nz;\n int face = rot / 4;\n if (face == 0) { nx = x; ny = y; nz = z; }\n else if (face == 1) { nx = x; ny = -z; nz = y; }\n else if (face == 2) { nx = x; ny = -y; nz = -z; }\n else if (face == 3) { nx = x; ny = z; nz = -y; }\n else if (face == 4) { nx = y; ny = -x; nz = z; }\n else if (face == 5) { nx = -y; ny = x; nz = z; }\n \n int roll = rot % 4;\n for (int i = 0; i < roll; ++i) {\n int tx = nx;\n nx = -nz;\n nz = tx;\n }\n return {nx, ny, nz};\n}\n\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline int next_int(int max_val) {\n return xor128() % max_val;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> D)) return 0;\n\n vector f1(D), r1(D), f2(D), r2(D);\n for (int i = 0; i < D; ++i) cin >> f1[i];\n for (int i = 0; i < D; ++i) cin >> r1[i];\n for (int i = 0; i < D; ++i) cin >> f2[i];\n for (int i = 0; i < D; ++i) cin >> r2[i];\n\n vector init_c1, init_c2;\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n for (int z = 0; z < D; ++z) {\n if (f1[z][x] == '1' && r1[z][y] == '1') init_c1.push_back({x, y, z});\n if (f2[z][x] == '1' && r2[z][y] == '1') init_c2.push_back({x, y, z});\n }\n }\n }\n\n double best_score = 1e18;\n int num_cells = D * D * D;\n vector best_b1(num_cells, 0);\n vector best_b2(num_cells, 0);\n int best_n = 0;\n\n int dx[] = {1, -1, 0, 0, 0, 0};\n int dy[] = {0, 0, 1, -1, 0, 0};\n int dz[] = {0, 0, 0, 0, 1, -1};\n\n int iter = 0;\n while (true) {\n if (++iter % 16 == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 5.6) break;\n }\n\n vector c1 = init_c1;\n vector c2 = init_c2;\n\n vector avail1(num_cells, false);\n vector avail2(num_cells, false);\n for (auto p : c1) avail1[get_idx(p.x, p.y, p.z)] = true;\n for (auto p : c2) avail2[get_idx(p.x, p.y, p.z)] = true;\n\n vector b1(num_cells, 0);\n vector b2(num_cells, 0);\n\n int block_id = 0;\n vector block_v;\n block_v.push_back(0);\n\n vector> block_pts1;\n vector> block_pts2;\n block_pts1.push_back({});\n block_pts2.push_back({});\n\n int rem1 = c1.size();\n int rem2 = c2.size();\n\n while (rem1 > 0 && rem2 > 0) {\n Point start1;\n bool found1 = false;\n while (rem1 > 0) {\n int idx1 = next_int(rem1);\n start1 = c1[idx1];\n if (avail1[get_idx(start1.x, start1.y, start1.z)]) {\n found1 = true;\n break;\n } else {\n swap(c1[idx1], c1[rem1 - 1]);\n rem1--;\n }\n }\n if (!found1) break;\n\n Point start2;\n bool found2 = false;\n while (rem2 > 0) {\n int idx2 = next_int(rem2);\n start2 = c2[idx2];\n if (avail2[get_idx(start2.x, start2.y, start2.z)]) {\n found2 = true;\n break;\n } else {\n swap(c2[idx2], c2[rem2 - 1]);\n rem2--;\n }\n }\n if (!found2) break;\n \n int rot = next_int(24);\n vector b1_pts = {start1};\n vector b2_pts = {start2};\n \n avail1[get_idx(start1.x, start1.y, start1.z)] = false;\n avail2[get_idx(start2.x, start2.y, start2.z)] = false;\n\n bool grown = true;\n while (grown) {\n grown = false;\n vector p_idx(b1_pts.size());\n for (size_t i = 0; i < b1_pts.size(); ++i) p_idx[i] = i;\n for (size_t i = 1; i < p_idx.size(); ++i) swap(p_idx[i], p_idx[next_int(i + 1)]);\n\n for (int i : p_idx) {\n Point p1 = b1_pts[i];\n int order[6] = {0, 1, 2, 3, 4, 5};\n for (int k = 1; k < 6; ++k) swap(order[k], order[next_int(k + 1)]);\n\n for (int dir : order) {\n int nx1 = p1.x + dx[dir];\n int ny1 = p1.y + dy[dir];\n int nz1 = p1.z + dz[dir];\n \n if (nx1 >= 0 && nx1 < D && ny1 >= 0 && ny1 < D && nz1 >= 0 && nz1 < D) {\n int n1_idx = get_idx(nx1, ny1, nz1);\n if (avail1[n1_idx]) {\n Point offset1 = {nx1 - start1.x, ny1 - start1.y, nz1 - start1.z};\n Point offset2 = rotate(offset1, rot);\n int nx2 = start2.x + offset2.x;\n int ny2 = start2.y + offset2.y;\n int nz2 = start2.z + offset2.z;\n \n if (nx2 >= 0 && nx2 < D && ny2 >= 0 && ny2 < D && nz2 >= 0 && nz2 < D) {\n int n2_idx = get_idx(nx2, ny2, nz2);\n if (avail2[n2_idx]) {\n b1_pts.push_back({nx1, ny1, nz1});\n b2_pts.push_back({nx2, ny2, nz2});\n avail1[n1_idx] = false;\n avail2[n2_idx] = false;\n grown = true;\n break;\n }\n }\n }\n }\n }\n if (grown) break;\n }\n }\n\n block_id++;\n block_v.push_back(b1_pts.size());\n block_pts1.push_back(b1_pts);\n block_pts2.push_back(b2_pts);\n for (Point p : b1_pts) b1[get_idx(p.x, p.y, p.z)] = block_id;\n for (Point p : b2_pts) b2[get_idx(p.x, p.y, p.z)] = block_id;\n }\n\n vector L1, L2;\n\n auto solve_leftover = [&](const vector& f, const vector& r, const vector& b, vector& L) {\n vector> f_cov(D, vector(D, false));\n vector> r_cov(D, vector(D, false));\n vector used_cell(num_cells, false);\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n if (b[get_idx(x, y, z)] > 0) {\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n used_cell[get_idx(x, y, z)] = true;\n }\n }\n }\n }\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n if (f[z][x] == '1' && !f_cov[z][x]) {\n for (int y = 0; y < D; ++y) {\n if (r[z][y] == '1' && !r_cov[z][y] && !used_cell[get_idx(x, y, z)]) {\n L.push_back({x, y, z});\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n used_cell[get_idx(x, y, z)] = true;\n break;\n }\n }\n }\n }\n for (int x = 0; x < D; ++x) {\n if (f[z][x] == '1' && !f_cov[z][x]) {\n for (int y = 0; y < D; ++y) {\n if (r[z][y] == '1' && !used_cell[get_idx(x, y, z)]) {\n L.push_back({x, y, z});\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n used_cell[get_idx(x, y, z)] = true;\n break;\n }\n }\n }\n }\n for (int y = 0; y < D; ++y) {\n if (r[z][y] == '1' && !r_cov[z][y]) {\n for (int x = 0; x < D; ++x) {\n if (f[z][x] == '1' && !used_cell[get_idx(x, y, z)]) {\n L.push_back({x, y, z});\n f_cov[z][x] = true;\n r_cov[z][y] = true;\n used_cell[get_idx(x, y, z)] = true;\n break;\n }\n }\n }\n }\n }\n };\n\n solve_leftover(f1, r1, b1, L1);\n solve_leftover(f2, r2, b2, L2);\n\n vector used1(num_cells, false), used2(num_cells, false);\n for(int i = 0; i < num_cells; ++i) {\n if(b1[i] > 0) used1[i] = true;\n if(b2[i] > 0) used2[i] = true;\n }\n for(auto p : L1) used1[get_idx(p.x, p.y, p.z)] = true;\n for(auto p : L2) used2[get_idx(p.x, p.y, p.z)] = true;\n\n for (int z = 0; z < D && L1.size() < L2.size(); ++z) {\n for (int x = 0; x < D && L1.size() < L2.size(); ++x) {\n for (int y = 0; y < D && L1.size() < L2.size(); ++y) {\n int idx = get_idx(x, y, z);\n if (f1[z][x] == '1' && r1[z][y] == '1' && !used1[idx]) {\n L1.push_back({x, y, z});\n used1[idx] = true;\n }\n }\n }\n }\n for (int z = 0; z < D && L2.size() < L1.size(); ++z) {\n for (int x = 0; x < D && L2.size() < L1.size(); ++x) {\n for (int y = 0; y < D && L2.size() < L1.size(); ++y) {\n int idx = get_idx(x, y, z);\n if (f2[z][x] == '1' && r2[z][y] == '1' && !used2[idx]) {\n L2.push_back({x, y, z});\n used2[idx] = true;\n }\n }\n }\n }\n\n int paired = max(L1.size(), L2.size());\n for (int i = 0; i < paired; ++i) {\n block_id++;\n block_v.push_back(1);\n vector p1, p2;\n if (i < (int)L1.size()) {\n p1.push_back(L1[i]);\n b1[get_idx(L1[i].x, L1[i].y, L1[i].z)] = block_id;\n }\n if (i < (int)L2.size()) {\n p2.push_back(L2[i]);\n b2[get_idx(L2[i].x, L2[i].y, L2[i].z)] = block_id;\n }\n block_pts1.push_back(p1);\n block_pts2.push_back(p2);\n }\n\n // --- Optimized Pruning Phase ---\n vector> f_cnt1(D, vector(D, 0)), r_cnt1(D, vector(D, 0));\n vector> f_cnt2(D, vector(D, 0)), r_cnt2(D, vector(D, 0));\n\n for (int z = 0; z < D; ++z) {\n for (int x = 0; x < D; ++x) {\n for (int y = 0; y < D; ++y) {\n if (b1[get_idx(x, y, z)] > 0) { f_cnt1[z][x]++; r_cnt1[z][y]++; }\n if (b2[get_idx(x, y, z)] > 0) { f_cnt2[z][x]++; r_cnt2[z][y]++; }\n }\n }\n }\n\n vector active(block_id + 1, true);\n vector check_order(block_id);\n iota(check_order.begin(), check_order.end(), 1);\n \n sort(check_order.begin(), check_order.end(), [&](int a, int b) {\n if (block_v[a] != block_v[b]) return block_v[a] < block_v[b];\n return a < b;\n });\n\n bool changed = true;\n while (changed) {\n changed = false;\n \n for (int id : check_order) {\n if (!active[id]) continue;\n \n int f1_rem[15][15] = {0}, r1_rem[15][15] = {0};\n int f2_rem[15][15] = {0}, r2_rem[15][15] = {0};\n \n for (auto& p : block_pts1[id]) {\n f1_rem[p.z][p.x]++;\n r1_rem[p.z][p.y]++;\n }\n for (auto& p : block_pts2[id]) {\n f2_rem[p.z][p.x]++;\n r2_rem[p.z][p.y]++;\n }\n \n bool can_remove = true;\n for (auto& p : block_pts1[id]) {\n if (f1_rem[p.z][p.x] > 0 && f_cnt1[p.z][p.x] == f1_rem[p.z][p.x]) { can_remove = false; break; }\n if (r1_rem[p.z][p.y] > 0 && r_cnt1[p.z][p.y] == r1_rem[p.z][p.y]) { can_remove = false; break; }\n }\n if (can_remove) {\n for (auto& p : block_pts2[id]) {\n if (f2_rem[p.z][p.x] > 0 && f_cnt2[p.z][p.x] == f2_rem[p.z][p.x]) { can_remove = false; break; }\n if (r2_rem[p.z][p.y] > 0 && r_cnt2[p.z][p.y] == r2_rem[p.z][p.y]) { can_remove = false; break; }\n }\n }\n\n if (can_remove) {\n active[id] = false;\n changed = true;\n for (auto& p : block_pts1[id]) {\n f_cnt1[p.z][p.x]--; r_cnt1[p.z][p.y]--;\n b1[get_idx(p.x, p.y, p.z)] = 0;\n }\n for (auto& p : block_pts2[id]) {\n f_cnt2[p.z][p.x]--; r_cnt2[p.z][p.y]--;\n b2[get_idx(p.x, p.y, p.z)] = 0;\n }\n }\n }\n }\n\n double score = 0;\n int unshared1 = 0, unshared2 = 0;\n for (int id = 1; id <= block_id; ++id) {\n if (active[id]) {\n score += 1.0 / block_v[id];\n bool in1 = !block_pts1[id].empty();\n bool in2 = !block_pts2[id].empty();\n if (in1 && !in2) unshared1 += block_v[id];\n if (in2 && !in1) unshared2 += block_v[id];\n }\n }\n score += unshared1 + unshared2;\n\n if (score < best_score) {\n best_score = score;\n \n int new_id = 0;\n vector id_map(block_id + 1, 0);\n for (int i = 0; i < num_cells; ++i) {\n if (b1[i] > 0) {\n if (id_map[b1[i]] == 0) id_map[b1[i]] = ++new_id;\n b1[i] = id_map[b1[i]];\n }\n if (b2[i] > 0) {\n if (id_map[b2[i]] == 0) id_map[b2[i]] = ++new_id;\n b2[i] = id_map[b2[i]];\n }\n }\n \n best_b1 = b1;\n best_b2 = b2;\n best_n = new_id;\n }\n }\n\n cout << best_n << \"\\n\";\n for (int i = 0; i < num_cells; ++i) {\n cout << best_b1[i] << (i == num_cells - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n for (int i = 0; i < num_cells; ++i) {\n cout << best_b2[i] << (i == num_cells - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc020":"#pragma GCC optimize(\"O3\")\n#pragma GCC optimize(\"unroll-loops\")\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nlong long dist_sq(long long x1, long long y1, long long x2, long long y2) {\n return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);\n}\n\nstruct Edge {\n int id, u, v;\n long long w;\n bool operator<(const Edge& other) const {\n return w < other.w;\n }\n};\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i) return i;\n return parent[i] = find(parent[i]);\n }\n void unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n }\n }\n};\n\nint N, M, K;\nvector> stations;\nvector edges;\nvector> residents;\nvector> P_req; \nvector> closest_stations;\n\nvector parent_node;\nvector parent_weight;\nvector parent_edge_id;\nvector post_order;\n\nconst long long MAX_DIST_SQ = 25000000LL;\n\nvoid build_mst() {\n DSU dsu(N);\n vector>> adj(N);\n vector> adj_w(N);\n \n for (const auto& e : edges) {\n if (dsu.find(e.u) != dsu.find(e.v)) {\n dsu.unite(e.u, e.v);\n adj[e.u].push_back({e.v, e.id});\n adj_w[e.u].push_back(e.w);\n adj[e.v].push_back({e.u, e.id});\n adj_w[e.v].push_back(e.w);\n }\n }\n\n parent_node.assign(N, -1);\n parent_weight.assign(N, 0);\n parent_edge_id.assign(N, -1);\n \n vector q;\n q.push_back(0);\n int head = 0;\n parent_node[0] = 0; \n\n while (head < (int)q.size()) {\n int u = q[head++];\n post_order.push_back(u);\n for (size_t i = 0; i < adj[u].size(); ++i) {\n int v = adj[u][i].first;\n int e_id = adj[u][i].second;\n long long w = adj_w[u][i];\n if (parent_node[v] == -1) {\n parent_node[v] = u;\n parent_weight[v] = w;\n parent_edge_id[v] = e_id;\n q.push_back(v);\n }\n }\n }\n reverse(post_order.begin(), post_order.end());\n post_order.pop_back(); \n}\n\ninline long long compute_cost(const vector& P, vector& edge_used) {\n long long cost = 0;\n for (int i = 0; i < N; ++i) {\n cost += P[i] * P[i];\n }\n\n vector active(N, 0);\n fill(edge_used.begin(), edge_used.end(), 0);\n\n for (int u : post_order) {\n if (P[u] > 0) active[u] = 1;\n if (active[u]) {\n active[parent_node[u]] = 1;\n cost += parent_weight[u];\n edge_used[parent_edge_id[u]] = 1;\n }\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M >> K)) return 0;\n\n stations.resize(N);\n for (int i = 0; i < N; ++i) cin >> stations[i].first >> stations[i].second;\n\n edges.resize(M);\n for (int i = 0; i < M; ++i) {\n edges[i].id = i;\n cin >> edges[i].u >> edges[i].v >> edges[i].w;\n edges[i].u--; edges[i].v--;\n }\n sort(edges.begin(), edges.end()); \n\n build_mst();\n\n residents.resize(K);\n for (int i = 0; i < K; ++i) cin >> residents[i].first >> residents[i].second;\n\n P_req.assign(N, vector(K));\n closest_stations.assign(K, vector());\n\n for (int i = 0; i < K; ++i) {\n vector> dists;\n for (int j = 0; j < N; ++j) {\n long long d = dist_sq(residents[i].first, residents[i].second, stations[j].first, stations[j].second);\n long long req_p = ceil(sqrt(d));\n while (req_p * req_p < d) req_p++;\n P_req[j][i] = min(req_p, 5000LL);\n \n if (d <= MAX_DIST_SQ) {\n dists.push_back({d, j});\n }\n }\n sort(dists.begin(), dists.end());\n for (int j = 0; j < min(15, (int)dists.size()); ++j) {\n closest_stations[i].push_back(dists[j].second);\n }\n }\n\n vector assignment(K);\n vector> station_residents(N);\n vector P(N, 0);\n\n for (int i = 0; i < K; ++i) {\n int best_station = closest_stations[i][0];\n assignment[i] = best_station;\n station_residents[best_station].push_back(i);\n }\n\n auto get_P = [&](int u) {\n long long max_p = 0;\n for (int r : station_residents[u]) {\n if (P_req[u][r] > max_p) max_p = P_req[u][r];\n }\n return max_p;\n };\n\n for (int i = 0; i < N; ++i) P[i] = get_P(i);\n\n vector best_edge_used(M, 0);\n vector temp_edge_used(M, 0);\n long long current_cost = compute_cost(P, best_edge_used);\n long long best_cost = current_cost;\n vector best_P = P;\n\n mt19937 rng(42);\n uniform_int_distribution rand_res(0, K - 1);\n uniform_real_distribution rand_prob(0.0, 1.0);\n uniform_int_distribution rand_any_station(0, N - 1);\n\n double T0 = 2e6;\n double T1 = 1e2;\n int iter = 0;\n\n while (true) {\n if ((iter & 511) == 0) { \n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break;\n }\n iter++;\n\n double progress = iter / 2500000.0; \n if (progress > 1.0) progress = 1.0;\n double T = T0 * pow(T1 / T0, progress);\n\n if (rand_prob(rng) < 0.01) { \n int s = rand_any_station(rng);\n if (station_residents[s].empty() || s == 0) continue;\n \n vector old_assignments;\n bool valid = true;\n for(int r : station_residents[s]) {\n old_assignments.push_back(assignment[r]);\n \n int new_s = s;\n for(int cand : closest_stations[r]) {\n if(cand != s) { new_s = cand; break; }\n }\n if (new_s == s) { \n valid = false;\n break;\n }\n \n assignment[r] = new_s;\n }\n\n if (!valid) {\n for (size_t i = 0; i < old_assignments.size(); ++i) {\n assignment[station_residents[s][i]] = old_assignments[i];\n }\n continue;\n }\n\n vector moved_res = station_residents[s];\n station_residents[s].clear();\n \n for(int r : moved_res) {\n station_residents[assignment[r]].push_back(r);\n }\n\n vector old_P = P;\n P[s] = 0;\n for(int r : moved_res) {\n P[assignment[r]] = get_P(assignment[r]);\n }\n \n long long new_cost = compute_cost(P, temp_edge_used);\n if (new_cost < current_cost || rand_prob(rng) < exp((current_cost - new_cost) / T)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_P = P;\n best_edge_used = temp_edge_used;\n }\n } else {\n for(size_t i = 0; i < moved_res.size(); ++i) {\n int r = moved_res[i];\n int new_s = assignment[r];\n station_residents[new_s].pop_back(); \n assignment[r] = old_assignments[i];\n }\n station_residents[s] = moved_res;\n P = old_P;\n }\n } else { \n int r = rand_res(rng);\n int old_s = assignment[r];\n int new_s;\n \n uniform_int_distribution rand_cand(0, closest_stations[r].size() - 1);\n new_s = closest_stations[r][rand_cand(rng)];\n\n if (old_s == new_s) continue;\n\n auto it = find(station_residents[old_s].begin(), station_residents[old_s].end(), r);\n swap(*it, station_residents[old_s].back());\n station_residents[old_s].pop_back();\n \n station_residents[new_s].push_back(r);\n assignment[r] = new_s;\n\n long long old_P_old = P[old_s], old_P_new = P[new_s];\n P[old_s] = get_P(old_s);\n P[new_s] = get_P(new_s);\n\n long long new_cost = compute_cost(P, temp_edge_used);\n\n if (new_cost < current_cost || rand_prob(rng) < exp((current_cost - new_cost) / T)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_P = P;\n best_edge_used = temp_edge_used;\n }\n } else {\n station_residents[new_s].pop_back();\n station_residents[old_s].push_back(r);\n assignment[r] = old_s;\n P[old_s] = old_P_old;\n P[new_s] = old_P_new;\n }\n }\n }\n\n compute_cost(best_P, best_edge_used);\n\n for (int i = 0; i < N; ++i) cout << best_P[i] << (i == N - 1 ? \"\" : \" \");\n cout << \"\\n\";\n for (int i = 0; i < M; ++i) cout << best_edge_used[i] << (i == M - 1 ? \"\" : \" \");\n cout << \"\\n\";\n\n return 0;\n}","ahc021":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Swap {\n int x1, y1, x2, y2;\n};\n\n// Fast XorShift PRNG\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::steady_clock::now();\n\n int N = 30;\n vector> orig_b(N, vector(N, 0));\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j <= i; ++j) {\n cin >> orig_b[i][j];\n }\n }\n\n vector> all_cells;\n all_cells.reserve(N * (N - 1) / 2);\n for (int x = 0; x < N - 1; ++x) {\n for (int y = 0; y <= x; ++y) {\n all_cells.push_back({x, y});\n }\n }\n\n vector best_ops;\n int best_ops_size = 1e9;\n\n int iter = 0;\n while (true) {\n if ((iter & 255) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.85) break;\n }\n iter++;\n\n vector> b = orig_b;\n vector ops;\n ops.reserve(min(4000, best_ops_size));\n\n bool changed = true;\n \n // Increase base greediness slightly\n int p_greedy = 80 + (xor128() % 20); \n\n // 60% top-down, 30% bottom-up, 10% random\n int r_strat = xor128() % 100;\n int strategy = (r_strat < 60) ? 1 : ((r_strat < 90) ? 0 : 2);\n \n bool abandoned = false;\n\n while (changed) {\n if (ops.size() >= best_ops_size) {\n abandoned = true;\n break;\n }\n\n changed = false;\n \n if (strategy == 2) {\n for (int i = (int)all_cells.size() - 1; i > 0; --i) {\n int j = xor128() % (i + 1);\n swap(all_cells[i], all_cells[j]);\n }\n \n for (auto& cell : all_cells) {\n int x = cell.first;\n int y = cell.second;\n \n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (xor128() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (xor128() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n } else if (strategy == 0) {\n // Bottom-up\n int pass_type = xor128() % 2;\n for (int x = N - 2; x >= 0; --x) {\n bool ltr = (pass_type == 0);\n for (int i = 0; i <= x; ++i) {\n int y = ltr ? i : x - i;\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (xor128() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (xor128() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n } else {\n // Top-down\n int pass_type = xor128() % 2;\n for (int x = 0; x < N - 1; ++x) {\n bool ltr = (pass_type == 0);\n for (int i = 0; i <= x; ++i) {\n int y = ltr ? i : x - i;\n bool c0 = b[x][y] > b[x + 1][y];\n bool c1 = b[x][y] > b[x + 1][y + 1];\n if (c0 || c1) {\n int ny = y;\n if (c0 && c1) {\n if (xor128() % 100 < p_greedy) {\n ny = (b[x + 1][y] < b[x + 1][y + 1]) ? y : y + 1;\n } else {\n ny = (xor128() % 2 == 0) ? y : y + 1;\n }\n } else if (c1) {\n ny = y + 1;\n }\n ops.push_back({x, y, x + 1, ny});\n swap(b[x][y], b[x + 1][ny]);\n changed = true;\n }\n }\n }\n }\n }\n \n if (!abandoned && ops.size() < best_ops_size) {\n best_ops_size = ops.size();\n best_ops = std::move(ops);\n }\n }\n\n if (best_ops.size() > 10000) {\n best_ops.resize(10000);\n }\n\n cout << best_ops.size() << \"\\n\";\n for (const auto& op : best_ops) {\n cout << op.x1 << \" \" << op.y1 << \" \" << op.x2 << \" \" << op.y2 << \"\\n\";\n }\n\n return 0;\n}","toyota2023summer-final":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int D = 9;\nint N;\nbool obstacle[D][D];\nint grid[D][D];\nint static_dist[D][D];\n\nint dx[] = {1, -1, 0, 0};\nint dy[] = {0, 0, 1, -1};\n\nbool check_connectivity(int empty_count) {\n if (empty_count <= 0) return true;\n \n vector> visited(D, vector(D, false));\n queue> q;\n \n q.push({0, 4});\n visited[0][4] = true;\n \n int reachable = 0;\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n \n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable++;\n }\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n if (grid[nr][nc] == -1 || (nr == 0 && nc == 4)) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n \n return reachable == empty_count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int d_in;\n if (!(cin >> d_in >> N)) return 0;\n \n for (int i = 0; i < D; ++i) {\n for (int j = 0; j < D; ++j) {\n obstacle[i][j] = false;\n grid[i][j] = -1;\n static_dist[i][j] = -1;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n int r, c;\n cin >> r >> c;\n obstacle[r][c] = true;\n }\n\n queue> sq;\n sq.push({0, 4});\n static_dist[0][4] = 0;\n while (!sq.empty()) {\n auto [r, c] = sq.front();\n sq.pop();\n \n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && static_dist[nr][nc] == -1) {\n static_dist[nr][nc] = static_dist[r][c] + 1;\n sq.push({nr, nc});\n }\n }\n }\n\n int total_containers = D * D - 1 - N;\n set remaining_t;\n for (int i = 0; i < total_containers; ++i) {\n remaining_t.insert(i);\n }\n\n for (int d = 0; d < total_containers; ++d) {\n int t;\n cin >> t;\n remaining_t.erase(t);\n\n int rank_t = 0;\n for (int val : remaining_t) {\n if (val < t) rank_t++;\n }\n double t_ratio = remaining_t.empty() ? 0.0 : (double)rank_t / remaining_t.size();\n\n queue> q;\n vector> dist(D, vector(D, -1));\n \n q.push({0, 4});\n dist[0][4] = 0;\n\n vector> reachable_empty;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] == -1 && (r != 0 || c != 4)) {\n reachable_empty.push_back({r, c});\n }\n\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n \n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && dist[nr][nc] == -1) {\n if (grid[r][c] == -1 || (r == 0 && c == 4)) {\n dist[nr][nc] = dist[r][c] + 1;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int remaining_empty = total_containers - d - 1;\n vector> valid_cells;\n \n for (auto [r, c] : reachable_empty) {\n grid[r][c] = t;\n if (check_connectivity(remaining_empty)) {\n valid_cells.push_back({r, c});\n }\n grid[r][c] = -1;\n }\n\n sort(valid_cells.begin(), valid_cells.end(), [&](pair a, pair b) {\n return static_dist[a.first][a.second] < static_dist[b.first][b.second];\n });\n\n int best_r = -1, best_c = -1;\n double min_cost = 1e18;\n\n for (size_t i = 0; i < valid_cells.size(); ++i) {\n int r = valid_cells[i].first;\n int c = valid_cells[i].second;\n \n double cell_ratio = valid_cells.size() <= 1 ? 0.0 : (double)i / (valid_cells.size() - 1);\n \n // Primary rank matching cost\n double cost = abs(t_ratio - cell_ratio) * 100.0;\n \n // Proportional Monotonicity Penalties using the optimal 1.5x multiplier\n for (int k = 0; k < 4; ++k) {\n int nr = r + dx[k];\n int nc = c + dy[k];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && grid[nr][nc] != -1) {\n if (static_dist[nr][nc] < static_dist[r][c] && grid[nr][nc] > t) {\n cost += 20.0 + 1.5 * (grid[nr][nc] - t);\n } else if (static_dist[nr][nc] > static_dist[r][c] && grid[nr][nc] < t) {\n cost += 20.0 + 1.5 * (t - grid[nr][nc]);\n }\n }\n }\n \n // Slightly enhanced tie breaking\n cost -= dist[r][c] * 0.15;\n\n if (cost < min_cost) {\n min_cost = cost;\n best_r = r;\n best_c = c;\n }\n }\n\n if (best_r == -1) {\n best_r = reachable_empty.back().first;\n best_c = reachable_empty.back().second;\n }\n\n grid[best_r][best_c] = t;\n cout << best_r << \" \" << best_c << \"\\n\";\n cout << flush;\n }\n\n for (int d = 0; d < total_containers; ++d) {\n queue> q;\n vector> visited(D, vector(D, false));\n \n q.push({0, 4});\n visited[0][4] = true;\n\n vector> reachable_containers;\n\n while (!q.empty()) {\n auto [r, c] = q.front();\n q.pop();\n\n if (grid[r][c] != -1 && (r != 0 || c != 4)) {\n reachable_containers.push_back({r, c});\n } else {\n for (int i = 0; i < 4; ++i) {\n int nr = r + dx[i];\n int nc = c + dy[i];\n if (nr >= 0 && nr < D && nc >= 0 && nc < D && !obstacle[nr][nc] && !visited[nr][nc]) {\n visited[nr][nc] = true;\n q.push({nr, nc});\n }\n }\n }\n }\n\n int best_r = -1, best_c = -1;\n int min_val = 1e9;\n \n for (auto [r, c] : reachable_containers) {\n if (grid[r][c] < min_val) {\n min_val = grid[r][c];\n best_r = r;\n best_c = c;\n }\n }\n\n grid[best_r][best_c] = -1;\n cout << best_r << \" \" << best_c << \"\\n\";\n }\n \n cout << flush;\n\n return 0;\n}","ahc024":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 50;\nconst int N2 = 2500;\nint M;\n\nuint8_t grid[N2];\nuint16_t adj_count[105][105];\nbool target_adj[105][105];\nuint16_t color_count[105];\n\nint dx[] = {-1, 1, 0, 0};\nint dy[] = {0, 0, -1, 1};\n\nuint16_t visited[N2];\nuint16_t visit_id = 0;\n\nint q[3000];\n\nbool is_boundary[N2];\nint boundary_idx[N2];\nint boundary_pos[N2];\nint num_boundary = 0;\n\nuint32_t xor_state = 1337;\ninline uint32_t xor_shift() {\n xor_state ^= xor_state << 13;\n xor_state ^= xor_state >> 17;\n xor_state ^= xor_state << 5;\n return xor_state;\n}\ninline double rand_double() {\n return (xor_shift() & 0xFFFFFF) / (double)0x1000000;\n}\n\ninline bool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\ninline int get_color(int r, int c) {\n if (is_valid(r, c)) return grid[r * N + c];\n return 0; \n}\n\nvoid add_boundary(int idx) {\n if (!is_boundary[idx]) {\n is_boundary[idx] = true;\n boundary_idx[num_boundary] = idx;\n boundary_pos[idx] = num_boundary;\n num_boundary++;\n }\n}\n\nvoid remove_boundary(int idx) {\n if (is_boundary[idx]) {\n int pos = boundary_pos[idx];\n num_boundary--;\n int last_idx = boundary_idx[num_boundary];\n boundary_idx[pos] = last_idx;\n boundary_pos[last_idx] = pos;\n is_boundary[idx] = false;\n }\n}\n\nvoid check_and_update_boundary(int r, int c) {\n if (!is_valid(r, c)) return;\n bool bound = false;\n int idx = r * N + c;\n int col = grid[idx];\n for (int k = 0; k < 4; ++k) {\n int nr = r + dx[k];\n int nc = c + dy[k];\n if (get_color(nr, nc) != col) {\n bound = true;\n break;\n }\n }\n if (bound) add_boundary(idx);\n else remove_boundary(idx);\n}\n\nint d8r[] = {-1, -1, 0, 1, 1, 1, 0, -1};\nint d8c[] = {0, 1, 1, 1, 0, -1, -1, -1};\n\nbool check_connectivity(int r, int c, int color) {\n if (color != 0 && color_count[color] <= 1) return true;\n \n int n8[8];\n for(int i = 0; i < 8; ++i) {\n n8[i] = (get_color(r + d8r[i], c + d8c[i]) == color);\n }\n \n int c4_count = n8[0] + n8[2] + n8[4] + n8[6];\n if (c4_count <= 1) return true; \n \n int components = 0;\n bool in_component = false;\n for(int i = 0; i < 9; ++i) { \n int idx = i % 8;\n if (n8[idx]) {\n if (!in_component) {\n components++;\n in_component = true;\n }\n } else {\n in_component = false;\n }\n }\n if (components > 1 && n8[0] && n8[7]) components--;\n if (components == 1) return true;\n \n visit_id++;\n int count = 0;\n int head = 0, tail = 0;\n \n if (color == 0) {\n q[tail++] = -1;\n } else {\n int start_idx = -1;\n for (int k = 0; k < 4; ++k) {\n if (n8[k * 2]) { \n start_idx = (r + d8r[k * 2]) * N + (c + d8c[k * 2]);\n break;\n }\n }\n q[tail++] = start_idx;\n visited[start_idx] = visit_id;\n count = 1;\n }\n \n while (head < tail) {\n int curr = q[head++];\n \n if (curr == -1) {\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == 0 || i == N - 1 || j == 0 || j == N - 1) { \n int idx = i * N + j;\n if ((i != r || j != c) && grid[idx] == 0 && visited[idx] != visit_id) {\n visited[idx] = visit_id;\n count++;\n q[tail++] = idx;\n }\n }\n }\n }\n } else {\n int curr_r = curr / N;\n int curr_c = curr % N;\n for (int i = 0; i < 4; ++i) {\n int nr = curr_r + dx[i];\n int nc = curr_c + dy[i];\n if (is_valid(nr, nc)) {\n int nidx = nr * N + nc;\n if ((nr != r || nc != c) && grid[nidx] == color && visited[nidx] != visit_id) {\n visited[nidx] = visit_id;\n count++;\n q[tail++] = nidx;\n }\n }\n }\n }\n }\n \n return count == color_count[color] - 1;\n}\n\nint local_adj_loss[105];\nint local_adj_gain[105];\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> M >> M)) return 0;\n int n = 50;\n M = 100;\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int color;\n cin >> color;\n grid[i * N + j] = color;\n color_count[color]++;\n }\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n int c1 = grid[i * N + j];\n int right_c = get_color(i, j + 1);\n if (c1 != right_c) {\n adj_count[c1][right_c]++; adj_count[right_c][c1]++;\n target_adj[c1][right_c] = target_adj[right_c][c1] = true;\n }\n int down_c = get_color(i + 1, j);\n if (c1 != down_c) {\n adj_count[c1][down_c]++; adj_count[down_c][c1]++;\n target_adj[c1][down_c] = target_adj[down_c][c1] = true;\n }\n if (i == 0 && c1 != 0) {\n adj_count[c1][0]++; adj_count[0][c1]++;\n target_adj[c1][0] = target_adj[0][c1] = true;\n }\n if (j == 0 && c1 != 0) {\n adj_count[c1][0]++; adj_count[0][c1]++;\n target_adj[c1][0] = target_adj[0][c1] = true;\n }\n }\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) check_and_update_boundary(i, j);\n }\n \n int iter = 0;\n double T0 = 4.0; \n double T1 = 0.005; \n double time_limit = 1.95;\n double elapsed = 0.0;\n \n while (true) {\n if ((iter++ & 511) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > time_limit) break;\n }\n \n if (num_boundary == 0) continue;\n \n int b_idx = xor_shift() % num_boundary;\n int idx = boundary_idx[b_idx];\n int r = idx / N;\n int c = idx % N;\n int old_color = grid[idx];\n \n int possible_colors[4];\n int possible_count = 0;\n bool has_zero = false;\n \n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n if (nc != old_color) possible_colors[possible_count++] = nc;\n if (nc == 0) has_zero = true;\n }\n \n if (possible_count == 0) continue;\n \n int new_color;\n // Increased bias to 98% to aggressively squeeze boundaries\n if (has_zero && old_color != 0 && rand_double() < 0.98) new_color = 0;\n else new_color = possible_colors[xor_shift() % possible_count];\n \n int delta_score = 0;\n if (new_color == 0 && old_color != 0) delta_score = 1;\n else if (new_color != 0 && old_color == 0) delta_score = -1;\n \n double temp = T0 * pow(T1 / T0, elapsed / time_limit);\n if (delta_score < 0) {\n if (delta_score / temp < -10.0 || rand_double() > exp(delta_score / temp)) continue;\n }\n \n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n if (nc != old_color) local_adj_loss[nc]++;\n if (nc != new_color) local_adj_gain[nc]++;\n }\n \n bool possible = true;\n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n if (local_adj_loss[nc] > 0 && adj_count[old_color][nc] - local_adj_loss[nc] == 0) { possible = false; break; }\n if (local_adj_gain[nc] > 0 && !target_adj[new_color][nc]) { possible = false; break; }\n }\n \n if (!possible || !check_connectivity(r, c, old_color)) {\n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n local_adj_loss[nc] = local_adj_gain[nc] = 0;\n }\n continue;\n }\n \n for (int k = 0; k < 4; ++k) {\n int nc = get_color(r + dx[k], c + dy[k]);\n if (local_adj_loss[nc] > 0) {\n adj_count[old_color][nc] -= local_adj_loss[nc];\n adj_count[nc][old_color] -= local_adj_loss[nc];\n local_adj_loss[nc] = 0;\n }\n if (local_adj_gain[nc] > 0) {\n adj_count[new_color][nc] += local_adj_gain[nc];\n adj_count[nc][new_color] += local_adj_gain[nc];\n local_adj_gain[nc] = 0;\n }\n }\n \n grid[idx] = new_color;\n color_count[old_color]--;\n color_count[new_color]++;\n \n check_and_update_boundary(r, c);\n for (int k = 0; k < 4; ++k) check_and_update_boundary(r + dx[k], c + dy[k]);\n }\n \n for (int i = 0; i < n; ++i) {\n for (int j = 0; j < n; ++j) {\n cout << (int)grid[i * N + j] << (j == n - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n \n return 0;\n}","ahc025":"#pragma GCC optimize(\"O3\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N, D, Q;\nint queries_used = 0;\n\nchar query(const vector& L, const vector& R) {\n if (queries_used >= Q) return '=';\n if (L.empty() || R.empty()) {\n if (L.empty() && R.empty()) return '=';\n return L.empty() ? '<' : '>';\n }\n \n cout << L.size() << \" \" << R.size();\n for (int x : L) cout << \" \" << x;\n for (int x : R) cout << \" \" << x;\n cout << \"\\n\";\n cout.flush();\n \n char res;\n cin >> res;\n queries_used++;\n return res;\n}\n\nchar compare_items(int u, int v) {\n return query({u}, {v});\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> D >> Q)) return 0;\n\n vector items(N);\n iota(items.begin(), items.end(), 0);\n\n // Phase 1: Sort items accurately (Lightest to Heaviest)\n int max_sort_queries = min(Q - 10, Q * 3 / 4);\n stable_sort(items.begin(), items.end(), [&](int a, int b) {\n if (queries_used >= max_sort_queries) return a < b;\n return compare_items(a, b) == '<'; // Lightest comes first\n });\n\n // Phase 2: Expected Weights for Exponential Distribution\n vector est_weight(N);\n vector order_expected(N, 0.0);\n double current_sum = 0.0;\n \n // items[0] is lightest, items[N-1] is heaviest\n for (int i = 0; i < N; ++i) {\n current_sum += 1.0 / (N - i);\n order_expected[i] = current_sum; \n }\n\n for (int i = 0; i < N; ++i) {\n est_weight[items[i]] = order_expected[i];\n }\n\n // Phase 3: Greedy Initial Partition (Longest Processing Time)\n vector> groups(D);\n vector group_weights(D, 0.0);\n vector ans(N);\n\n // Process from heaviest (N-1) down to lightest (0)\n for (int i = N - 1; i >= 0; --i) {\n int item = items[i];\n int best_group = 0;\n for (int d = 1; d < D; ++d) {\n if (group_weights[d] < group_weights[best_group]) {\n best_group = d;\n }\n }\n groups[best_group].push_back(item);\n group_weights[best_group] += est_weight[item];\n ans[item] = best_group;\n }\n\n mt19937 rng(42);\n\n // Phase 4: Targeted Interactive Hill Climbing\n while (queries_used < Q) {\n int g1 = 0, g2 = 0;\n \n // Target the estimated heaviest and lightest groups frequently\n if (rng() % 4 != 0) { // 75% of the time target extremes\n for (int d = 1; d < D; ++d) {\n if (group_weights[d] > group_weights[g1]) g1 = d;\n if (group_weights[d] < group_weights[g2]) g2 = d;\n }\n if (g1 == g2) {\n g1 = rng() % D;\n g2 = rng() % D;\n while (g1 == g2) g2 = rng() % D;\n }\n } else {\n g1 = rng() % D;\n g2 = rng() % D;\n while (g1 == g2) g2 = rng() % D;\n }\n\n if (groups[g1].empty() || groups[g2].empty()) {\n query({0}, {1}); // burn query if needed\n continue;\n }\n\n char res = query(groups[g1], groups[g2]);\n if (queries_used >= Q) break;\n\n int heavy = (res == '>') ? g1 : ((res == '<') ? g2 : -1);\n int light = (res == '>') ? g2 : ((res == '<') ? g1 : -1);\n\n if (heavy != -1 && light != -1) {\n int best_u_idx = -1, best_v_idx = -1;\n double best_gap = 1e9;\n double diff = group_weights[heavy] - group_weights[light];\n double target_swap = diff / 2.0;\n\n for (size_t i = 0; i < groups[heavy].size(); ++i) {\n for (size_t j = 0; j < groups[light].size(); ++j) {\n int u = groups[heavy][i];\n int v = groups[light][j];\n \n // u is in heavy group, v is in light group. We want weight(u) > weight(v)\n if (est_weight[u] > est_weight[v]) {\n double swap_diff = est_weight[u] - est_weight[v];\n double gap = abs(swap_diff - target_swap);\n if (gap < best_gap) {\n best_gap = gap;\n best_u_idx = i;\n best_v_idx = j;\n }\n }\n }\n }\n\n if (best_u_idx != -1 && best_v_idx != -1) {\n int u = groups[heavy][best_u_idx];\n int v = groups[light][best_v_idx];\n\n // Execute swap\n swap(groups[heavy][best_u_idx], groups[light][best_v_idx]);\n \n char new_res = query(groups[heavy], groups[light]);\n bool keep_swap = false;\n\n if (new_res == '>' || new_res == '=') {\n // heavy is still heavier or perfectly balanced -> guaranteed absolute improvement\n keep_swap = true;\n } else if (queries_used <= Q) {\n // Overshot. Fallback to expected weights to verify if the new gap is smaller\n double old_diff = diff;\n double new_diff = abs(old_diff - 2.0 * (est_weight[u] - est_weight[v]));\n if (new_diff < old_diff) {\n keep_swap = true;\n }\n }\n\n if (keep_swap) {\n ans[u] = light;\n ans[v] = heavy;\n group_weights[heavy] = group_weights[heavy] - est_weight[u] + est_weight[v];\n group_weights[light] = group_weights[light] - est_weight[v] + est_weight[u];\n } else {\n // Revert swap\n swap(groups[heavy][best_u_idx], groups[light][best_v_idx]);\n }\n } else {\n // If no valid swap is found based on estimates, perturb estimates to avoid getting stuck\n group_weights[heavy] *= 0.999;\n group_weights[light] *= 1.001;\n }\n }\n }\n\n // Burn remaining unused queries safely\n while (queries_used < Q) {\n query({0}, {1});\n }\n\n // Output results\n for (int i = 0; i < N; ++i) {\n cout << ans[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n cout.flush();\n\n return 0;\n}","ahc026":"#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nconst int INF = 1e9;\n\n// Fast xorshift RNG\ninline uint32_t xorshift32(uint32_t& state) {\n state ^= state << 13;\n state ^= state >> 17;\n state ^= state << 5;\n return state;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = steady_clock::now();\n\n int n, m;\n if (!(cin >> n >> m)) return 0;\n\n vector> initial_stacks(m);\n for (int i = 0; i < m; ++i) {\n int count = n / m;\n initial_stacks[i].resize(count);\n for (int j = 0; j < count; ++j) {\n cin >> initial_stacks[i][j];\n }\n }\n\n int best_energy = INF;\n vector> best_ops;\n\n uint32_t rng_state = 1337;\n int iter = 0;\n\n int stacks[10][205];\n int stack_sizes[10];\n pair ops[5005];\n\n while (true) {\n if ((iter & 1023) == 0) {\n auto current_time = steady_clock::now();\n double elapsed = duration_cast>(current_time - start_time).count();\n if (elapsed > 1.96) break;\n }\n iter++;\n\n for (int i = 0; i < m; ++i) {\n stack_sizes[i] = initial_stacks[i].size();\n for (int j = 0; j < stack_sizes[i]; ++j) {\n stacks[i][j] = initial_stacks[i][j];\n }\n }\n\n int ops_count = 0;\n int energy = 0;\n bool possible = true;\n\n for (int v = 1; v <= n; ++v) {\n int s = -1;\n int v_idx = -1;\n for (int i = 0; i < m; ++i) {\n for (int j = 0; j < stack_sizes[i]; ++j) {\n if (stacks[i][j] == v) {\n s = i;\n v_idx = j;\n break;\n }\n }\n if (s != -1) break;\n }\n\n while (stack_sizes[s] > v_idx + 1) {\n int max_chunk = stack_sizes[s] - (v_idx + 1);\n int chunk_size = 1;\n \n if (max_chunk > 1) {\n uint32_t r_chunk = xorshift32(rng_state) % 100;\n if (r_chunk < 8) {\n chunk_size = max_chunk;\n } else if (r_chunk < 22) {\n chunk_size = 1 + (xorshift32(rng_state) % max_chunk);\n }\n }\n\n int chunk_bottom_idx = stack_sizes[s] - chunk_size;\n int u = stacks[s][chunk_bottom_idx];\n\n int best_j = -1;\n int min_diff = INF;\n int max_top = -1;\n int fallback_j = -1;\n \n int valids[10];\n int valids_count = 0;\n\n for (int i = 0; i < m; ++i) {\n if (i == s) continue;\n \n int top_val = (stack_sizes[i] == 0) ? INF : stacks[i][stack_sizes[i] - 1];\n \n if (top_val > u) {\n valids[valids_count++] = i;\n int diff = top_val - u;\n if (diff < min_diff) {\n min_diff = diff;\n best_j = i;\n }\n }\n \n if (top_val > max_top) {\n max_top = top_val;\n fallback_j = i;\n }\n }\n\n int target_stack = -1;\n if (valids_count > 0) {\n uint32_t r = xorshift32(rng_state) % 100;\n // Increase bias towards tightest fit to 94%\n if (r < 94 || valids_count == 1) {\n target_stack = best_j;\n } else {\n target_stack = valids[xorshift32(rng_state) % valids_count];\n }\n } else {\n target_stack = fallback_j;\n }\n\n for (int j = chunk_bottom_idx; j < stack_sizes[s]; ++j) {\n stacks[target_stack][stack_sizes[target_stack]++] = stacks[s][j];\n }\n stack_sizes[s] -= chunk_size;\n \n ops[ops_count++] = {u, target_stack + 1};\n energy += (chunk_size + 1);\n }\n\n stack_sizes[s]--;\n ops[ops_count++] = {v, 0};\n \n if (ops_count > 5000) {\n possible = false;\n break;\n }\n }\n\n if (possible && energy < best_energy) {\n best_energy = energy;\n best_ops.assign(ops, ops + ops_count);\n }\n }\n\n for (auto& op : best_ops) {\n cout << op.first << \" \" << op.second << \"\\n\";\n }\n\n return 0;\n}","ahc027":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\nvector h;\nvector v;\nvector> d;\nvector DIJ_R = {0, 1, 0, -1};\nvector DIJ_C = {1, 0, -1, 0};\nstring DIR = \"RDLU\";\nstring INV_DIR = \"LURD\"; \n\nint last_visit_arr[1605];\nlong long sum_w2_arr[1605];\nint first_visit_arr[1605];\n\ndouble evaluate(const string& path) {\n int L = path.length();\n if (L == 0) return 1e18;\n int r = 0, c = 0;\n \n fill(last_visit_arr, last_visit_arr + N * N, -1);\n fill(sum_w2_arr, sum_w2_arr + N * N, 0);\n fill(first_visit_arr, first_visit_arr + N * N, -1);\n\n for (int t = 0; t < L; ++t) {\n int idx = r * N + c;\n if (last_visit_arr[idx] == -1) {\n first_visit_arr[idx] = t;\n } else {\n long long w = t - last_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n }\n last_visit_arr[idx] = t;\n\n char move = path[t];\n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n double total_avg = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (last_visit_arr[idx] != -1) {\n long long w = L - last_visit_arr[idx] + first_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n total_avg += (double)d[i][j] * sum_w2_arr[idx] / L;\n } else {\n return 1e18; \n }\n }\n }\n return total_avg;\n}\n\ndouble evaluate_with_detour_fast(const vector& path_idx, int insert_idx, int idx1, int idx2) {\n int old_L = path_idx.size();\n int L = old_L + 2;\n \n fill(last_visit_arr, last_visit_arr + N * N, -1);\n fill(sum_w2_arr, sum_w2_arr + N * N, 0);\n fill(first_visit_arr, first_visit_arr + N * N, -1);\n\n for (int t = 0; t < L; ++t) {\n int idx;\n if (t < insert_idx) {\n idx = path_idx[t];\n } else if (t == insert_idx) {\n idx = idx1;\n } else if (t == insert_idx + 1) {\n idx = idx2;\n } else {\n idx = path_idx[t - 2];\n }\n\n if (last_visit_arr[idx] == -1) {\n first_visit_arr[idx] = t;\n } else {\n long long w = t - last_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n }\n last_visit_arr[idx] = t;\n }\n \n double total_avg = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n int idx = i * N + j;\n if (last_visit_arr[idx] != -1) {\n long long w = L - last_visit_arr[idx] + first_visit_arr[idx];\n sum_w2_arr[idx] += w * (w - 1) / 2;\n total_avg += (double)d[i][j] * sum_w2_arr[idx] / L;\n } else {\n return 1e18;\n }\n }\n }\n return total_avg;\n}\n\nvoid dfs(int r, int c, vector>& visited, string& current_path, mt19937& rng) {\n visited[r][c] = true;\n \n vector> valid_dirs;\n for (int dir = 0; dir < 4; ++dir) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = r + dr;\n int c2 = c + dc;\n \n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N && !visited[r2][c2]) {\n bool can_move = false;\n if (dr == 0) {\n if (v[r][min(c, c2)] == '0') can_move = true;\n } else {\n if (h[min(r, r2)][c] == '0') can_move = true;\n }\n \n if (can_move) {\n int weight = d[r2][c2] * (rng() % 100) + (rng() % 500);\n valid_dirs.push_back({weight, dir});\n }\n }\n }\n \n sort(valid_dirs.rbegin(), valid_dirs.rend());\n \n for (auto& p : valid_dirs) {\n int dir = p.second;\n int r2 = r + DIJ_R[dir];\n int c2 = c + DIJ_C[dir];\n if (!visited[r2][c2]) {\n current_path += DIR[dir];\n dfs(r2, c2, visited, current_path, rng);\n current_path += DIR[(dir + 2) % 4];\n }\n }\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N)) return 0;\n\n h.resize(N - 1);\n for (int i = 0; i < N - 1; ++i) {\n cin >> h[i];\n }\n\n v.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> v[i];\n }\n\n d.assign(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 mt19937 rng(1337);\n string best_path = \"\";\n double best_score = 1e18;\n\n while (true) {\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 0.5) break; \n\n vector> visited(N, vector(N, false));\n string current_path = \"\";\n dfs(0, 0, visited, current_path, rng);\n \n double score = evaluate(current_path);\n if (score < best_score) {\n best_score = score;\n best_path = current_path;\n }\n }\n\n bool improved = true;\n while (improved) {\n improved = false;\n auto current_time = chrono::steady_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95 || best_path.length() >= 99990) break;\n\n int L = best_path.length();\n vector path_idx(L);\n int r = 0, c = 0;\n vector> positions(L);\n vector> candidates; \n \n for (int i = 0; i < L; ++i) {\n positions[i] = {r, c};\n path_idx[i] = r * N + c;\n \n char move = best_path[i];\n int max_d_around = 0;\n for (int dir = 0; dir < 4; ++dir) {\n int r2 = r + DIJ_R[dir];\n int c2 = c + DIJ_C[dir];\n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N) {\n max_d_around = max(max_d_around, d[r2][c2]);\n }\n }\n candidates.push_back({max_d_around + (rng() % 100), i});\n \n if (move == 'R') c++;\n else if (move == 'D') r++;\n else if (move == 'L') c--;\n else if (move == 'U') r--;\n }\n \n sort(candidates.rbegin(), candidates.rend());\n \n for (size_t i = 0; i < candidates.size(); ++i) {\n int idx = candidates[i].second;\n int cr = positions[idx].first;\n int cc = positions[idx].second;\n\n for (int dir = 0; dir < 4; ++dir) {\n int dr = DIJ_R[dir];\n int dc = DIJ_C[dir];\n int r2 = cr + dr;\n int c2 = cc + dc;\n\n if (r2 >= 0 && r2 < N && c2 >= 0 && c2 < N) {\n bool can_move = false;\n if (dr == 0) {\n if (v[cr][min(cc, c2)] == '0') can_move = true;\n } else {\n if (h[min(cr, r2)][cc] == '0') can_move = true;\n }\n\n if (can_move) {\n int idx1 = r2 * N + c2;\n int idx2 = cr * N + cc;\n \n double s = evaluate_with_detour_fast(path_idx, idx, idx1, idx2);\n if (s < best_score) {\n best_score = s;\n string detour = \"\";\n detour += DIR[dir];\n detour += INV_DIR[dir];\n best_path = best_path.substr(0, idx) + detour + best_path.substr(idx);\n improved = true;\n break; // First-Choice Hill Climbing: Apply immediately!\n }\n }\n }\n }\n if (improved) break; // Restart iteration with updated path\n }\n }\n\n cout << best_path << \"\\n\";\n\n return 0;\n}","ahc028":"#pragma GCC optimize(\"O3,unroll-loops\")\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int INF = 1e9;\nint N, M;\nint start_i, start_j;\nvector grid;\nvector words;\nvector> pos[26];\nint min_dist[26][26];\nint min_start_dist[26];\n\nint overlap_precalc[205][205];\nint append_cost_precalc[205][205];\nint word_id[11881376];\n\nint dp[5005][225];\nint parent_arr[5005][225];\n\nint manhattan(pair a, pair b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint calc_overlap(const string& a, const string& b) {\n for (int k = 4; k >= 1; --k) {\n if (a.substr(5 - k) == b.substr(0, k)) {\n return k;\n }\n }\n return 0;\n}\n\nint approx_cost(char last_char, const string& add) {\n int cost = 0;\n char c = last_char;\n for (char nxt : add) {\n cost += min_dist[c - 'A'][nxt - 'A'] + 1;\n c = nxt;\n }\n return cost;\n}\n\nuint32_t xor_shift() {\n static uint32_t y = 2463534242;\n y = y ^ (y << 13);\n y = y ^ (y >> 17);\n return y = y ^ (y << 5);\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n auto start_time = chrono::high_resolution_clock::now();\n\n if (!(cin >> N >> M)) return 0;\n cin >> start_i >> start_j;\n\n grid.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> grid[i];\n for (int j = 0; j < N; ++j) {\n pos[grid[i][j] - 'A'].push_back({i, j});\n }\n }\n\n words.resize(M);\n for (int i = 0; i < 11881376; ++i) {\n word_id[i] = -1;\n }\n for (int i = 0; i < M; ++i) {\n cin >> words[i];\n int h = 0;\n for (char c : words[i]) {\n h = h * 26 + (c - 'A');\n }\n word_id[h] = i;\n }\n\n for (int i = 0; i < 26; ++i) {\n min_start_dist[i] = INF;\n for (auto p : pos[i]) {\n min_start_dist[i] = min(min_start_dist[i], manhattan({start_i, start_j}, p));\n }\n for (int j = 0; j < 26; ++j) {\n min_dist[i][j] = INF;\n if (pos[i].empty() || pos[j].empty()) continue;\n for (auto p1 : pos[i]) {\n for (auto p2 : pos[j]) {\n min_dist[i][j] = min(min_dist[i][j], manhattan(p1, p2));\n }\n }\n }\n }\n\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < M; ++j) {\n if (i == j) continue;\n overlap_precalc[i][j] = calc_overlap(words[i], words[j]);\n string add = words[j].substr(overlap_precalc[i][j]);\n append_cost_precalc[i][j] = approx_cost(words[i].back(), add);\n }\n }\n\n int best_total_cost = INF;\n vector> best_path;\n\n while (true) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break; // Extended limit slightly\n\n vector remaining(M);\n for (int i = 0; i < M; ++i) remaining[i] = i;\n\n string S = \"\";\n S.reserve(1500);\n int last_w_idx = -1;\n vector covered(M, false);\n \n int overlap_weight = 8 + (xor_shift() % 10); // Tweaked distribution\n\n while (!remaining.empty()) {\n pair cand1 = {INF, -1};\n pair cand2 = {INF, -1};\n\n for (int i = 0; i < remaining.size(); ++i) {\n int w_idx = remaining[i];\n if (covered[w_idx]) {\n cand1 = {-100000, i};\n break;\n }\n \n int cost, k;\n if (last_w_idx == -1) {\n k = 0;\n cost = 0;\n } else {\n k = overlap_precalc[last_w_idx][w_idx];\n cost = append_cost_precalc[last_w_idx][w_idx];\n }\n \n int score = cost - k * overlap_weight;\n if (score < cand1.first) {\n cand2 = cand1;\n cand1 = {score, i};\n } else if (score < cand2.first) {\n cand2 = {score, i};\n }\n }\n \n int chosen_idx = cand1.second;\n // Slightly reduced randomness \n if (cand2.second != -1 && cand1.first != -100000 && (xor_shift() % 100) < 12) {\n chosen_idx = cand2.second;\n }\n\n int w_idx = remaining[chosen_idx];\n \n if (!covered[w_idx]) {\n int k = (last_w_idx == -1) ? 0 : overlap_precalc[last_w_idx][w_idx];\n string add = words[w_idx].substr(k);\n int old_len = S.length();\n S += add;\n int new_len = S.length();\n \n int current_hash = 0;\n int start_pos = max(0, old_len - 4);\n for (int i = start_pos; i < new_len; ++i) {\n current_hash = (current_hash * 26 + (S[i] - 'A')) % 11881376;\n if (i - start_pos >= 4 || old_len >= 4) {\n int idx = word_id[current_hash];\n if (idx != -1) {\n covered[idx] = true;\n }\n }\n }\n last_w_idx = w_idx;\n }\n \n remaining[chosen_idx] = remaining.back();\n remaining.pop_back();\n }\n\n int len = S.length();\n if (len > 5000) continue;\n\n int lower_bound = min_start_dist[S[0] - 'A'] + 1;\n for (int i = 1; i < len; ++i) {\n lower_bound += min_dist[S[i - 1] - 'A'][S[i] - 'A'] + 1;\n }\n if (lower_bound >= best_total_cost) continue;\n\n for (int i = 0; i < len; ++i) {\n for (int j = 0; j < 225; ++j) {\n dp[i][j] = INF;\n }\n }\n\n for (int k = 0; k < pos[S[0] - 'A'].size(); ++k) {\n auto p = pos[S[0] - 'A'][k];\n int idx = p.first * N + p.second;\n dp[0][idx] = manhattan({start_i, start_j}, p) + 1;\n }\n\n for (int i = 1; i < len; ++i) {\n char prev_c = S[i - 1];\n char curr_c = S[i];\n for (int p_k = 0; p_k < pos[prev_c - 'A'].size(); ++p_k) {\n auto p_prev = pos[prev_c - 'A'][p_k];\n int p_idx = p_prev.first * N + p_prev.second;\n if (dp[i - 1][p_idx] == INF) continue;\n\n for (int c_k = 0; c_k < pos[curr_c - 'A'].size(); ++c_k) {\n auto p_curr = pos[curr_c - 'A'][c_k];\n int c_idx = p_curr.first * N + p_curr.second;\n int cost = dp[i - 1][p_idx] + manhattan(p_prev, p_curr) + 1;\n if (cost < dp[i][c_idx]) {\n dp[i][c_idx] = cost;\n parent_arr[i][c_idx] = p_idx;\n }\n }\n }\n }\n\n int min_cost = INF;\n int last_idx = -1;\n for (int k = 0; k < pos[S.back() - 'A'].size(); ++k) {\n auto p = pos[S.back() - 'A'][k];\n int idx = p.first * N + p.second;\n if (dp[len - 1][idx] < min_cost) {\n min_cost = dp[len - 1][idx];\n last_idx = idx;\n }\n }\n\n if (min_cost < best_total_cost) {\n best_total_cost = min_cost;\n best_path.clear();\n int curr_idx = last_idx;\n for (int i = len - 1; i >= 0; --i) {\n best_path.push_back({curr_idx / N, curr_idx % N});\n curr_idx = parent_arr[i][curr_idx];\n }\n reverse(best_path.begin(), best_path.end());\n }\n }\n\n for (auto p : best_path) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}","ahc030":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\ndouble get_time() {\n static auto start = chrono::high_resolution_clock::now();\n auto now = chrono::high_resolution_clock::now();\n return chrono::duration(now - start).count();\n}\n\nstruct Point {\n int i, j;\n};\n\nstruct Polyomino {\n int d;\n vector pts;\n int max_i, max_j;\n};\n\nint N, M;\ndouble eps;\nvector fields;\n\nint obs[25][25];\nbool is_queried[25][25];\nstruct Pt { int r, c; };\nvector placements[25][405];\nint num_placements[25];\n\nint current_p[25];\nint pred[25][25];\n\nint query_single(int i, int j) {\n cout << \"q 1 \" << i << \" \" << j << endl;\n int res;\n cin >> res;\n return res;\n}\n\nvoid answer(const vector& ans) {\n cout << \"a \" << ans.size();\n for (auto p : ans) {\n cout << \" \" << p.r << \" \" << p.c;\n }\n cout << endl;\n int res;\n cin >> res;\n if (res == 1) {\n exit(0);\n }\n}\n\nvoid init_placements() {\n for (int m = 0; m < M; ++m) {\n num_placements[m] = 0;\n for (int r = 0; r <= N - fields[m].max_i; ++r) {\n for (int c = 0; c <= N - fields[m].max_j; ++c) {\n for (auto& pt : fields[m].pts) {\n placements[m][num_placements[m]].push_back({r + pt.i, c + pt.j});\n }\n num_placements[m]++;\n }\n }\n }\n}\n\nmt19937 rng(42);\n\nbool run_SA() {\n for (int attempt = 0; attempt < 12; ++attempt) {\n if (get_time() > 2.85) return false;\n\n memset(pred, 0, sizeof(pred));\n for (int m = 0; m < M; ++m) {\n current_p[m] = rng() % num_placements[m];\n for (auto& pt : placements[m][current_p[m]]) {\n pred[pt.r][pt.c]++;\n }\n }\n \n int E = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (obs[r][c] != -1) {\n E += abs(pred[r][c] - obs[r][c]);\n }\n }\n }\n if (E == 0) return true;\n \n double T = 15.0;\n for (int step = 0; step < 15000; ++step) {\n int m = rng() % M;\n int old_p = current_p[m];\n int new_p = rng() % num_placements[m];\n if (old_p == new_p) continue;\n \n int delta = 0;\n for (auto& pt : placements[m][old_p]) {\n if (obs[pt.r][pt.c] != -1) {\n delta -= abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n pred[pt.r][pt.c]--;\n delta += abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n } else {\n pred[pt.r][pt.c]--;\n }\n }\n for (auto& pt : placements[m][new_p]) {\n if (obs[pt.r][pt.c] != -1) {\n delta -= abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n pred[pt.r][pt.c]++;\n delta += abs(pred[pt.r][pt.c] - obs[pt.r][pt.c]);\n } else {\n pred[pt.r][pt.c]++;\n }\n }\n \n if (delta <= 0 || (exp(-delta / T) > (rng() % 10000) / 10000.0)) {\n E += delta;\n current_p[m] = new_p;\n if (E == 0) return true;\n } else {\n for (auto& pt : placements[m][new_p]) pred[pt.r][pt.c]--;\n for (auto& pt : placements[m][old_p]) pred[pt.r][pt.c]++;\n }\n T *= 0.999;\n }\n }\n return false;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n get_time();\n\n if (!(cin >> N >> M >> eps)) return 0;\n\n fields.resize(M);\n for (int k = 0; k < M; ++k) {\n cin >> fields[k].d;\n fields[k].pts.resize(fields[k].d);\n fields[k].max_i = 0;\n fields[k].max_j = 0;\n for (int p = 0; p < fields[k].d; ++p) {\n cin >> fields[k].pts[p].i >> fields[k].pts[p].j;\n fields[k].max_i = max(fields[k].max_i, fields[k].pts[p].i);\n fields[k].max_j = max(fields[k].max_j, fields[k].pts[p].j);\n }\n }\n\n init_placements();\n memset(obs, -1, sizeof(obs));\n memset(is_queried, 0, sizeof(is_queried));\n\n vector unqueried;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n unqueried.push_back({r, c});\n }\n }\n \n // Sort so that cells closer to the center are at the end of the vector\n // (since we pop_back to get the next element)\n double center = (N - 1) / 2.0;\n sort(unqueried.begin(), unqueried.end(), [center](const Pt& a, const Pt& b) {\n double da = (a.r - center) * (a.r - center) + (a.c - center) * (a.c - center);\n double db = (b.r - center) * (b.r - center) + (b.c - center) * (b.c - center);\n return da > db;\n });\n\n int queried_count = 0;\n\n while (queried_count < N * N) {\n bool sa_success = false;\n if (get_time() < 2.85) {\n sa_success = run_SA();\n }\n bool queried_pred = false;\n\n if (sa_success) {\n int best_r = -1, best_c = -1, max_p = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (pred[r][c] > max_p && obs[r][c] == -1) {\n max_p = pred[r][c];\n best_r = r;\n best_c = c;\n }\n }\n }\n\n if (best_r != -1) {\n obs[best_r][best_c] = query_single(best_r, best_c);\n is_queried[best_r][best_c] = true;\n queried_count++;\n queried_pred = true;\n } else {\n vector guess_set;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (pred[r][c] > 0) {\n guess_set.push_back({r, c});\n }\n }\n }\n answer(guess_set);\n }\n } \n \n if (!queried_pred && queried_count < N * N) {\n while (!unqueried.empty()) {\n Pt next_q = unqueried.back();\n unqueried.pop_back();\n if (!is_queried[next_q.r][next_q.c]) {\n obs[next_q.r][next_q.c] = query_single(next_q.r, next_q.c);\n is_queried[next_q.r][next_q.c] = true;\n queried_count++;\n break;\n }\n }\n }\n }\n\n vector final_ans;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (obs[r][c] > 0) {\n final_ans.push_back({r, c});\n }\n }\n }\n answer(final_ans);\n\n return 0;\n}","ahc031":"#include \n#include \n#include \n\nusing namespace std;\n\nconst int W = 1000;\nconst long long INF = 1e18;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int w_input, d_days, n_res;\n if (!(cin >> w_input >> d_days >> n_res)) return 0;\n\n vector> a(d_days, vector(n_res));\n for (int d = 0; d < d_days; ++d) {\n for (int k = 0; k < n_res; ++k) {\n cin >> a[d][k];\n }\n }\n\n vector prev_B(n_res + 1, 0);\n\n for (int d = 0; d < d_days; ++d) {\n vector dp(W + 1, INF);\n dp[0] = 0;\n \n vector> parent(n_res, vector(W + 1, -1));\n\n for (int k = 0; k < n_res; ++k) {\n vector next_dp(W + 1, INF);\n \n for (int x = k + 1; x <= W - (n_res - 1 - k); ++x) {\n long long change_cost = 0;\n // If the boundary changes, we pay to remove the old W segments and add W new segments.\n if (k + 1 < n_res && d > 0) {\n if (x != prev_B[k + 1]) {\n change_cost = 2 * W; \n }\n }\n\n long long min_cost = INF;\n int best_y = -1;\n \n for (int y = k; y < x; ++y) {\n if (dp[y] == INF) continue;\n \n long long area = (long long)W * (x - y);\n long long penalty = 0;\n if (area < a[d][k]) {\n penalty = 100LL * (a[d][k] - area);\n }\n \n long long cost = dp[y] + penalty;\n if (cost < min_cost) {\n min_cost = cost;\n best_y = y;\n }\n }\n \n if (min_cost != INF) {\n next_dp[x] = min_cost + change_cost;\n parent[k][x] = best_y;\n }\n }\n dp = move(next_dp);\n }\n\n vector curr_B(n_res + 1, 0);\n curr_B[n_res] = W;\n int curr_x = W;\n \n for (int k = n_res - 1; k >= 0; --k) {\n curr_x = parent[k][curr_x];\n curr_B[k] = curr_x;\n }\n\n for (int k = 0; k < n_res; ++k) {\n cout << 0 << \" \" << curr_B[k] << \" \" << W << \" \" << curr_B[k + 1] << \"\\n\";\n }\n prev_B = curr_B;\n }\n\n return 0;\n}","ahc032":"#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst long long MOD = 998244353;\n\nstruct Op {\n int m, p, q;\n};\n\nlong long A[81];\nlong long S[20][9];\nlong long rem_val[81];\nOp ops[81];\n\n// Fast PRNG\nuint32_t xor128() {\n static uint32_t x = 123456789;\n static uint32_t y = 362436069;\n static uint32_t z = 521288629;\n static uint32_t w = 88675123;\n uint32_t t = x ^ (x << 11);\n x = y; y = z; z = w;\n return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));\n}\n\ninline double next_double() {\n return (xor128() & 0xFFFFFF) / (double)(0x1000000);\n}\n\ninline int next_int(int max_val) {\n return xor128() % max_val;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::high_resolution_clock::now();\n\n int N, M, K;\n if (!(cin >> N >> M >> K)) return 0;\n\n for (int i = 0; i < 81; ++i) {\n cin >> A[i];\n rem_val[i] = A[i] % MOD;\n }\n\n for (int m = 0; m < M; ++m) {\n for (int i = 0; i < 9; ++i) {\n cin >> S[m][i];\n }\n }\n\n for (int i = 0; i < K; ++i) {\n ops[i] = {-1, -1, -1};\n }\n\n double T0 = 2e9;\n double T1 = 1e6;\n double time_limit = 1.95;\n double T = T0;\n\n long long current_score = 0;\n for (int i = 0; i < 81; ++i) {\n current_score += rem_val[i];\n }\n\n long long best_score = current_score;\n Op best_ops[81];\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n\n int iter = 0;\n int offsets[9] = {0, 1, 2, N, N + 1, N + 2, 2 * N, 2 * N + 1, 2 * N + 2};\n\n while (true) {\n if ((iter & 2047) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > time_limit) break;\n \n double progress = elapsed / time_limit;\n T = T0 * pow(T1 / T0, progress);\n }\n\n int idx = next_int(K);\n Op old_op = ops[idx];\n Op new_op;\n int m_val = (xor128() % (M + 1)) - 1; // -1 to M-1\n new_op.m = m_val;\n if (new_op.m == -1) {\n new_op.p = -1;\n new_op.q = -1;\n } else {\n new_op.p = next_int(N - 2);\n new_op.q = next_int(N - 2);\n }\n\n long long delta = 0;\n \n if (old_op.m != -1) {\n int base_idx = old_op.p * N + old_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long old_v = rem_val[cell];\n long long new_v = old_v - S[old_op.m][i];\n if (new_v < 0) new_v += MOD;\n delta += new_v - old_v;\n rem_val[cell] = new_v;\n }\n }\n \n if (new_op.m != -1) {\n int base_idx = new_op.p * N + new_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long old_v = rem_val[cell];\n long long new_v = old_v + S[new_op.m][i];\n if (new_v >= MOD) new_v -= MOD;\n delta += new_v - old_v;\n rem_val[cell] = new_v;\n }\n }\n\n if (delta >= 0 || next_double() < exp(delta / T)) {\n current_score += delta;\n ops[idx] = new_op;\n if (current_score > best_score) {\n best_score = current_score;\n for (int i = 0; i < K; ++i) best_ops[i] = ops[i];\n }\n } else {\n // Rollback\n if (new_op.m != -1) {\n int base_idx = new_op.p * N + new_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long val = rem_val[cell] - S[new_op.m][i];\n if (val < 0) val += MOD;\n rem_val[cell] = val;\n }\n }\n if (old_op.m != -1) {\n int base_idx = old_op.p * N + old_op.q;\n for (int i = 0; i < 9; ++i) {\n int cell = base_idx + offsets[i];\n long long val = rem_val[cell] + S[old_op.m][i];\n if (val >= MOD) val -= MOD;\n rem_val[cell] = val;\n }\n }\n }\n iter++;\n }\n\n vector final_ops;\n for (int i = 0; i < K; ++i) {\n if (best_ops[i].m != -1) {\n final_ops.push_back(best_ops[i]);\n }\n }\n\n cout << final_ops.size() << \"\\n\";\n for (const auto& op : final_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\nusing namespace std;\n\nconst int N = 5;\n\nstruct Container {\n int val, r, c;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input;\n if (!(cin >> n_input)) return 0;\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 string ans0 = \".\";\n int cr = 0, cc = 0;\n \n int ptr[N] = {0};\n int grid[N][N];\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) grid[r][c] = -1;\n }\n \n bool is_delivered[25] = {false};\n int next_needed[N];\n for (int i = 0; i < N; ++i) next_needed[i] = i * N;\n\n auto move_crane = [&](int tr, int tc) {\n while (cr > tr) { ans0 += 'U'; cr--; }\n while (cr < tr) { ans0 += 'D'; cr++; }\n while (cc > tc) { ans0 += 'L'; cc--; }\n while (cc < tc) { ans0 += 'R'; cc++; }\n };\n\n int delivered = 0;\n while (delivered < 25) {\n for (int i = 0; i < N; ++i) {\n while (next_needed[i] < i * N + N && is_delivered[next_needed[i]]) {\n next_needed[i]++;\n }\n }\n\n vector accessible;\n for (int r = 0; r < N; ++r) {\n if (ptr[r] < N) accessible.push_back({A[r][ptr[r]], r, 0});\n for (int c = 1; c < N - 1; ++c) {\n if (grid[r][c] != -1) accessible.push_back({grid[r][c], r, c});\n }\n }\n\n bool found_exact = false;\n Container best_c = {-1, -1, -1};\n int min_cost = 10000;\n\n // 1. Pick the exact needed container that is CLOSEST to the crane's current position\n for (auto& cont : accessible) {\n int gate = cont.val / N;\n if (cont.val == next_needed[gate]) {\n found_exact = true;\n int cost = abs(cr - cont.r) + abs(cc - cont.c);\n if (cost < min_cost) {\n min_cost = cost;\n best_c = cont;\n }\n }\n }\n\n if (found_exact) {\n move_crane(best_c.r, best_c.c);\n ans0 += 'P';\n \n if (best_c.c == 0) ptr[best_c.r]++;\n else grid[best_c.r][best_c.c] = -1;\n\n int gate = best_c.val / N;\n move_crane(gate, N - 1);\n ans0 += 'Q';\n \n is_delivered[best_c.val] = true;\n delivered++;\n } else {\n // 2. Dig for the needed container with the lowest depth penalty + travel cost\n int best_dig_r = -1;\n int min_dig_cost = 10000;\n \n for (int i = 0; i < N; ++i) {\n int target = next_needed[i];\n if (target >= i * N + N) continue; \n \n for (int r = 0; r < N; ++r) {\n for (int j = ptr[r]; j < N; ++j) {\n if (A[r][j] == target) {\n int depth = j - ptr[r]; // Number of blocking containers\n int cost = depth * 15 + abs(cr - r); // Heavily penalize depth, break ties by distance\n if (cost < min_dig_cost) {\n min_dig_cost = cost;\n best_dig_r = r;\n }\n }\n }\n }\n }\n\n int move_r = -1;\n if (best_dig_r != -1) {\n move_r = best_dig_r;\n } else {\n for (int r = 0; r < N; ++r) {\n if (ptr[r] < N) {\n move_r = r;\n break;\n }\n }\n }\n\n int val = A[move_r][ptr[move_r]];\n int dest_gate = val / N;\n\n // 3. Find the optimal empty temp cell: minimize the vertical detour\n // Ideal 'r' is exactly between 'move_r' and 'dest_gate'\n int best_dist = 10000;\n int temp_r = -1, temp_c = -1;\n for (int c = 1; c < N - 1; ++c) {\n for (int r = 0; r < N; ++r) {\n if (grid[r][c] == -1) {\n int vertical_travel = abs(move_r - r) + abs(r - dest_gate);\n int distance_from_crane = abs(cr - move_r) + abs(0 - c); // secondary tie-breaker\n int cost = vertical_travel * 10 + c; \n \n if (cost < best_dist) {\n best_dist = cost;\n temp_r = r;\n temp_c = c;\n }\n }\n }\n }\n\n if (temp_r != -1) {\n move_crane(move_r, 0);\n ans0 += 'P';\n ptr[move_r]++;\n\n move_crane(temp_r, temp_c);\n ans0 += 'Q';\n grid[temp_r][temp_c] = val;\n } else {\n // Fallback Force deliver\n Container force_c = {-1, -1, -1};\n int min_diff = 1000;\n for (auto& cont : accessible) {\n int diff = cont.val - next_needed[cont.val / N];\n if (diff >= 0 && diff < min_diff) {\n min_diff = diff;\n force_c = cont;\n }\n }\n\n move_crane(force_c.r, force_c.c);\n ans0 += 'P';\n \n if (force_c.c == 0) ptr[force_c.r]++;\n else grid[force_c.r][force_c.c] = -1;\n\n int gate = force_c.val / N;\n move_crane(gate, N - 1);\n ans0 += 'Q';\n \n is_delivered[force_c.val] = true;\n delivered++;\n }\n }\n }\n \n cout << ans0 << \"\\n\";\n for (int i = 1; i < N; ++i) {\n cout << \"B\\n\";\n }\n \n return 0;\n}","ahc034":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int N;\n if (!(cin >> N)) return 0;\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 int x = 0, y = 0;\n long long load = 0;\n\n while (true) {\n bool action_taken = false;\n\n // Opportunistic pickup\n if (h[x][y] > 0) {\n int amt = h[x][y];\n cout << \"+\" << amt << \"\\n\";\n load += amt;\n h[x][y] -= amt;\n action_taken = true;\n } \n // Opportunistic dropoff\n else if (load > 0 && h[x][y] < 0) {\n long long amt = min(load, (long long)-h[x][y]);\n cout << \"-\" << amt << \"\\n\";\n load -= amt;\n h[x][y] += amt;\n action_taken = true;\n }\n\n if (action_taken) continue;\n\n // Check completion condition\n bool done = true;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (h[i][j] != 0) {\n done = false;\n break;\n }\n }\n if (!done) break;\n }\n if (done) break;\n\n // Target selection\n // Tuned score-based selection: distance - 0.10 * amount\n double best_score = 1e9;\n pair target = {-1, -1};\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (load == 0 && h[i][j] > 0) {\n int d = abs(i - x) + abs(j - y);\n double score = d - 0.1 * h[i][j];\n if (score < best_score) {\n best_score = score;\n target = {i, j};\n }\n } else if (load > 0 && h[i][j] < 0) {\n int d = abs(i - x) + abs(j - y);\n int needed = -h[i][j];\n double score = d - 0.1 * needed;\n if (score < best_score) {\n best_score = score;\n target = {i, j};\n }\n }\n }\n }\n\n if (target.first == -1) break;\n\n // Smart Pathfinding with 1-step Lookahead\n int nx1 = x, ny1 = y; char move1 = ' ';\n int nx2 = x, ny2 = y; char move2 = ' ';\n\n if (x < target.first) { nx1 = x + 1; move1 = 'D'; }\n else if (x > target.first) { nx1 = x - 1; move1 = 'U'; }\n\n if (y < target.second) { ny2 = y + 1; move2 = 'R'; }\n else if (y > target.second) { ny2 = y - 1; move2 = 'L'; }\n\n if (move1 != ' ' && move2 != ' ') {\n int score1 = 0;\n if (h[nx1][ny1] > 0) score1 = 1;\n if (load > 0 && h[nx1][ny1] < 0) score1 = 2; \n\n int score2 = 0;\n if (h[nx2][ny2] > 0) score2 = 1;\n if (load > 0 && h[nx2][ny2] < 0) score2 = 2; \n\n if (score2 > score1) {\n y = ny2;\n cout << move2 << \"\\n\";\n } else {\n x = nx1;\n cout << move1 << \"\\n\";\n }\n } else if (move1 != ' ') {\n x = nx1;\n cout << move1 << \"\\n\";\n } else if (move2 != ' ') {\n y = ny2;\n cout << move2 << \"\\n\";\n }\n }\n\n return 0;\n}","ahc035":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace std::chrono;\n\nstruct Seed {\n int id;\n vector x;\n int sum;\n};\n\nint N, M, T;\nint seed_count;\nvector seeds;\n\n// Calculate the score of a pair of seeds\ninline int pair_score(const Seed& a, const Seed& b) {\n int score = 0;\n for (int l = 0; l < M; ++l) {\n score += max(a.x[l], b.x[l]);\n }\n return score;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> T)) return 0;\n seed_count = 2 * N * (N - 1);\n seeds.resize(seed_count);\n\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].x.resize(M);\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n\n mt19937 rng(42);\n auto start_time = steady_clock::now();\n\n for (int t = 0; t < T; t++) {\n vector selected_ids;\n vector used(seed_count, false);\n\n // Select the top 1 seed for each criterion to maintain diversity\n for (int l = 0; l < M; ++l) {\n int best_id = -1;\n int best_val = -1;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i] && seeds[i].x[l] > best_val) {\n best_val = seeds[i].x[l];\n best_id = i;\n }\n }\n if (best_id != -1) {\n selected_ids.push_back(best_id);\n used[best_id] = true;\n }\n }\n\n // Fill the rest with the highest sum seeds\n vector remaining;\n for (int i = 0; i < seed_count; ++i) {\n if (!used[i]) remaining.push_back(i);\n }\n sort(remaining.begin(), remaining.end(), [&](int a, int b) {\n return seeds[a].sum > seeds[b].sum;\n });\n\n for (int i = 0; selected_ids.size() < N * N; ++i) {\n selected_ids.push_back(remaining[i]);\n }\n\n // Initialize grid randomly\n shuffle(selected_ids.begin(), selected_ids.end(), rng);\n vector> grid(N, vector(N));\n int idx = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n grid[r][c] = selected_ids[idx++];\n }\n }\n\n // Calculate initial score\n int current_score = 0;\n for (int r = 0; r < N; ++r) {\n for (int c = 0; c < N; ++c) {\n if (r + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r+1][c]]);\n if (c + 1 < N) current_score += pair_score(seeds[grid[r][c]], seeds[grid[r][c+1]]);\n }\n }\n\n // Simulated Annealing\n double time_limit_per_turn = 1.9 / T; \n auto turn_start = steady_clock::now();\n double start_temp = 20.0;\n double end_temp = 0.1;\n int iter = 0;\n\n while (true) {\n if ((iter & 255) == 0) {\n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n if (elapsed >= time_limit_per_turn) break;\n }\n iter++;\n\n int r1 = uniform_int_distribution(0, N - 1)(rng);\n int c1 = uniform_int_distribution(0, N - 1)(rng);\n int r2 = uniform_int_distribution(0, N - 1)(rng);\n int c2 = uniform_int_distribution(0, N - 1)(rng);\n if (r1 == r2 && c1 == c2) continue;\n\n int old_contrib = 0;\n int new_contrib = 0;\n \n int s1 = grid[r1][c1];\n int s2 = grid[r2][c2];\n\n const int dr[] = {-1, 1, 0, 0};\n const int dc[] = {0, 0, -1, 1};\n\n for (int d = 0; d < 4; ++d) {\n int nr1 = r1 + dr[d], nc1 = c1 + dc[d];\n if (nr1 >= 0 && nr1 < N && nc1 >= 0 && nc1 < N) {\n if (nr1 != r2 || nc1 != c2) {\n old_contrib += pair_score(seeds[s1], seeds[grid[nr1][nc1]]);\n new_contrib += pair_score(seeds[s2], seeds[grid[nr1][nc1]]);\n }\n }\n int nr2 = r2 + dr[d], nc2 = c2 + dc[d];\n if (nr2 >= 0 && nr2 < N && nc2 >= 0 && nc2 < N) {\n if (nr2 != r1 || nc2 != c1) {\n old_contrib += pair_score(seeds[s2], seeds[grid[nr2][nc2]]);\n new_contrib += pair_score(seeds[s1], seeds[grid[nr2][nc2]]);\n }\n }\n }\n\n int diff = new_contrib - old_contrib;\n \n auto now = steady_clock::now();\n double elapsed = duration_cast>(now - turn_start).count();\n double temp = start_temp * pow(end_temp / start_temp, elapsed / time_limit_per_turn);\n\n if (diff >= 0 || uniform_real_distribution(0.0, 1.0)(rng) < exp(diff / temp)) {\n current_score += diff;\n swap(grid[r1][c1], grid[r2][c2]);\n }\n }\n\n for (int r = 0; r < N; r++) {\n for (int c = 0; c < N; c++) {\n cout << grid[r][c] << (c == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n }\n cout.flush();\n\n if (t < T - 1) {\n for (int i = 0; i < seed_count; i++) {\n seeds[i].id = i;\n seeds[i].sum = 0;\n for (int j = 0; j < M; j++) {\n cin >> seeds[i].x[j];\n seeds[i].sum += seeds[i].x[j];\n }\n }\n }\n }\n\n return 0;\n}","ahc038":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int dx[4] = {0, 1, 0, -1};\nconst int dy[4] = {1, 0, -1, 0};\nconst char move_char[4] = {'R', 'D', 'L', 'U'};\n\nstruct State {\n int rx, ry, dir;\n};\n\nint N, M, V;\nvector s_grid, t_grid;\n\nbool is_valid_root(int x, int y) {\n return x >= 0 && x < N && y >= 0 && y < N;\n}\n\nstring navigate(int& rx, int& ry, int& dir, int target_x, int target_y) {\n int dist[35][35][4];\n pair parent_action[35][35][4];\n tuple parent_state[35][35][4];\n \n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n for (int d = 0; d < 4; ++d)\n dist[i][j][d] = 1e9;\n \n queue q;\n q.push({rx, ry, dir});\n dist[rx][ry][dir] = 0;\n \n int end_rx = -1, end_ry = -1, end_dir = -1;\n \n while (!q.empty()) {\n auto [cx, cy, cd] = q.front();\n q.pop();\n \n int lx = cx + dx[cd];\n int ly = cy + dy[cd];\n if (lx == target_x && ly == target_y) {\n end_rx = cx; end_ry = cy; end_dir = cd;\n break;\n }\n \n for (int i = 0; i < 4; ++i) {\n int nx = cx + dx[i];\n int ny = cy + dy[i];\n if (is_valid_root(nx, ny) && dist[nx][ny][cd] > dist[cx][cy][cd] + 1) {\n dist[nx][ny][cd] = dist[cx][cy][cd] + 1;\n parent_action[nx][ny][cd] = {0, i};\n parent_state[nx][ny][cd] = {cx, cy, cd};\n q.push({nx, ny, cd});\n }\n }\n \n int nd_r = (cd + 1) % 4;\n if (dist[cx][cy][nd_r] > dist[cx][cy][cd] + 1) {\n dist[cx][cy][nd_r] = dist[cx][cy][cd] + 1;\n parent_action[cx][cy][nd_r] = {1, 1};\n parent_state[cx][cy][nd_r] = {cx, cy, cd};\n q.push({cx, cy, nd_r});\n }\n \n int nd_l = (cd + 3) % 4;\n if (dist[cx][cy][nd_l] > dist[cx][cy][cd] + 1) {\n dist[cx][cy][nd_l] = dist[cx][cy][cd] + 1;\n parent_action[cx][cy][nd_l] = {1, -1};\n parent_state[cx][cy][nd_l] = {cx, cy, cd};\n q.push({cx, cy, nd_l});\n }\n }\n \n if (end_rx == -1) return \"\"; \n \n vector commands;\n int cx = end_rx, cy = end_ry, cd = end_dir;\n while (cx != rx || cy != ry || cd != dir) {\n auto [atype, aval] = parent_action[cx][cy][cd];\n auto [px, py, pd] = parent_state[cx][cy][cd];\n \n string cmd = \"....\";\n if (atype == 0) {\n cmd[0] = move_char[aval];\n } else {\n cmd[1] = (aval == 1) ? 'R' : 'L';\n }\n commands.push_back(cmd);\n cx = px; cy = py; cd = pd;\n }\n \n string final_commands = \"\";\n for (int i = (int)commands.size() - 1; i >= 0; --i) {\n final_commands += commands[i] + \"\\n\";\n }\n \n rx = end_rx; ry = end_ry; dir = end_dir;\n return final_commands;\n}\n\ninline int dist_manhattan(const pair& a, const pair& b) {\n return abs(a.first - b.first) + abs(a.second - b.second);\n}\n\nint get_cost(const vector& order, const vector& target_of, const vector>& sources, const vector>& targets) {\n int cost = 0;\n pair cur = {0, 1}; \n for (int i = 0; i < (int)order.size(); ++i) {\n int s_idx = order[i];\n int t_idx = target_of[s_idx];\n cost += dist_manhattan(cur, sources[s_idx]);\n cost += dist_manhattan(sources[s_idx], targets[t_idx]);\n cur = targets[t_idx];\n }\n return cost;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n \n if (!(cin >> N >> M >> V)) return 0;\n \n s_grid.resize(N);\n t_grid.resize(N);\n for (int i = 0; i < N; ++i) cin >> s_grid[i];\n for (int i = 0; i < N; ++i) cin >> t_grid[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_grid[i][j] == '1' && t_grid[i][j] == '0') sources.push_back({i, j});\n if (s_grid[i][j] == '0' && t_grid[i][j] == '1') targets.push_back({i, j});\n }\n }\n \n int num_t = sources.size();\n vector target_of(num_t);\n vector order(num_t);\n \n vector used_s(num_t, false);\n vector used_t(num_t, false);\n pair cur = {0, 1}; \n for (int i = 0; i < num_t; ++i) {\n int best_s = -1, min_ds = 1e9;\n for (int j = 0; j < num_t; ++j) {\n if (!used_s[j]) {\n int d = dist_manhattan(cur, sources[j]);\n if (d < min_ds) {\n min_ds = d;\n best_s = j;\n }\n }\n }\n order[i] = best_s;\n used_s[best_s] = true;\n \n int best_t = -1, min_dt = 1e9;\n for (int j = 0; j < num_t; ++j) {\n if (!used_t[j]) {\n int d = dist_manhattan(sources[best_s], targets[j]);\n if (d < min_dt) {\n min_dt = d;\n best_t = j;\n }\n }\n }\n target_of[best_s] = best_t;\n used_t[best_t] = true;\n cur = targets[best_t];\n }\n \n mt19937 rng(4242);\n int current_cost = get_cost(order, target_of, sources, targets);\n \n double temp_start = 60.0;\n double temp_end = 0.05;\n double max_time = 2.95; \n \n int iterations = 0;\n while (true) {\n if ((iterations & 1023) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n }\n iterations++;\n \n double elapsed = chrono::duration(chrono::high_resolution_clock::now() - start_time).count();\n double temp = temp_start * pow(temp_end / temp_start, elapsed / max_time);\n \n int type = uniform_int_distribution<>(0, 1)(rng);\n \n if (type == 0 && num_t >= 2) {\n int i = uniform_int_distribution<>(0, num_t - 1)(rng);\n int j = uniform_int_distribution<>(0, num_t - 1)(rng);\n if (i == j) continue;\n if (i > j) swap(i, j);\n \n int delta = 0;\n auto get_pos_before = [&](int idx) { return (idx == 0) ? make_pair(0, 1) : targets[target_of[order[idx-1]]]; };\n \n if (j == i + 1) {\n delta -= dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta -= dist_manhattan(targets[target_of[order[i]]], sources[order[j]]);\n if (j + 1 < num_t) delta -= dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n \n swap(order[i], order[j]);\n \n delta += dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta += dist_manhattan(targets[target_of[order[i]]], sources[order[j]]);\n if (j + 1 < num_t) delta += dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n } else {\n delta -= dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta -= dist_manhattan(targets[target_of[order[i]]], sources[order[i+1]]);\n delta -= dist_manhattan(get_pos_before(j), sources[order[j]]);\n if (j + 1 < num_t) delta -= dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n \n swap(order[i], order[j]);\n \n delta += dist_manhattan(get_pos_before(i), sources[order[i]]);\n delta += dist_manhattan(targets[target_of[order[i]]], sources[order[i+1]]);\n delta += dist_manhattan(get_pos_before(j), sources[order[j]]);\n if (j + 1 < num_t) delta += dist_manhattan(targets[target_of[order[j]]], sources[order[j+1]]);\n }\n \n if (delta <= 0 || uniform_real_distribution<>(0.0, 1.0)(rng) < exp(-delta / temp)) {\n current_cost += delta;\n } else {\n swap(order[i], order[j]); \n }\n \n } else if (type == 1 && num_t >= 2) {\n int i = uniform_int_distribution<>(0, num_t - 1)(rng);\n int j = uniform_int_distribution<>(0, num_t - 1)(rng);\n if (i == j) continue;\n \n int s1 = order[i], s2 = order[j];\n int t1 = target_of[s1], t2 = target_of[s2];\n \n int delta = 0;\n delta -= dist_manhattan(sources[s1], targets[t1]);\n if (i + 1 < num_t) delta -= dist_manhattan(targets[t1], sources[order[i+1]]);\n delta -= dist_manhattan(sources[s2], targets[t2]);\n if (j + 1 < num_t) delta -= dist_manhattan(targets[t2], sources[order[j+1]]);\n \n swap(target_of[s1], target_of[s2]);\n \n delta += dist_manhattan(sources[s1], targets[t2]);\n if (i + 1 < num_t) delta += dist_manhattan(targets[t2], sources[order[i+1]]);\n delta += dist_manhattan(sources[s2], targets[t1]);\n if (j + 1 < num_t) delta += dist_manhattan(targets[t1], sources[order[j+1]]);\n \n if (delta <= 0 || uniform_real_distribution<>(0.0, 1.0)(rng) < exp(-delta / temp)) {\n current_cost += delta;\n } else {\n swap(target_of[s1], target_of[s2]); \n }\n }\n }\n \n cout << 2 << \"\\n\";\n cout << 0 << \" \" << 1 << \"\\n\";\n \n int rx = 0, ry = 0;\n cout << rx << \" \" << ry << \"\\n\";\n \n int dir = 0; \n \n for (int i = 0; i < num_t; ++i) {\n int s_idx = order[i];\n int t_idx = target_of[s_idx];\n \n cout << navigate(rx, ry, dir, sources[s_idx].first, sources[s_idx].second);\n cout << \"...P\\n\"; \n \n cout << navigate(rx, ry, dir, targets[t_idx].first, targets[t_idx].second);\n cout << \"...P\\n\"; \n }\n \n return 0;\n}","ahc039":"#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int MAX_COORD = 100000;\nconst int B_COARSE = 200; \nconst int CELL = MAX_COORD / B_COARSE;\nconst int STRIPS = 245; \n\nstruct Point {\n int x, y;\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n auto start_time = chrono::high_resolution_clock::now();\n\n int N;\n if (!(cin >> N)) return 0;\n\n vector mackerels(N);\n vector sardines(N);\n vector> grid(B_COARSE, vector(B_COARSE, 0));\n\n for (int i = 0; i < N; i++) {\n cin >> mackerels[i].x >> mackerels[i].y;\n int gx = min(mackerels[i].x / CELL, B_COARSE - 1);\n int gy = min(mackerels[i].y / CELL, B_COARSE - 1);\n grid[gx][gy]++;\n }\n\n for (int i = 0; i < N; i++) {\n cin >> sardines[i].x >> sardines[i].y;\n int gx = min(sardines[i].x / CELL, B_COARSE - 1);\n int gy = min(sardines[i].y / CELL, B_COARSE - 1);\n grid[gx][gy]--;\n }\n\n int max_sum = -1e9;\n int best_r1 = 0, best_r2 = 0, best_c1 = 0, best_c2 = 0;\n\n for (int r1 = 0; r1 < B_COARSE; r1++) {\n vector temp(B_COARSE, 0);\n for (int r2 = r1; r2 < B_COARSE; r2++) {\n for (int c = 0; c < B_COARSE; c++) temp[c] += grid[r2][c];\n int current_sum = 0, c1 = 0;\n for (int c = 0; c < B_COARSE; c++) {\n current_sum += temp[c];\n if (current_sum > max_sum) {\n max_sum = current_sum;\n best_r1 = r1; best_r2 = r2;\n best_c1 = c1; best_c2 = c;\n }\n if (current_sum < 0) { current_sum = 0; c1 = c + 1; }\n }\n }\n }\n\n int init_x1 = best_r1 * CELL;\n int init_x2 = min((best_r2 + 1) * CELL, MAX_COORD);\n int init_y1 = best_c1 * CELL;\n int init_y2 = min((best_c2 + 1) * CELL, MAX_COORD);\n\n int strip_height = (MAX_COORD + STRIPS - 1) / STRIPS;\n \n int start_strip = init_y1 / strip_height;\n int end_strip = init_y2 / strip_height;\n if (end_strip >= STRIPS) end_strip = STRIPS - 1;\n if (start_strip > end_strip) start_strip = end_strip;\n\n vector L(STRIPS, init_x1);\n vector R(STRIPS, init_x2);\n\n vector> mack_x(STRIPS);\n vector> sard_x(STRIPS);\n\n for (const auto& p : mackerels) {\n int s = min(p.y / strip_height, STRIPS - 1);\n mack_x[s].push_back(p.x);\n }\n for (const auto& p : sardines) {\n int s = min(p.y / strip_height, STRIPS - 1);\n sard_x[s].push_back(p.x);\n }\n\n auto get_strip_score = [&](int strip, int l, int r) {\n int s = 0;\n for (int x : mack_x[strip]) if (x >= l && x <= r) s++;\n for (int x : sard_x[strip]) if (x >= l && x <= r) s--;\n return s;\n };\n\n int current_score = 0;\n vector strip_scores(STRIPS, 0);\n for (int i = start_strip; i <= end_strip; i++) {\n strip_scores[i] = get_strip_score(i, L[i], R[i]);\n current_score += strip_scores[i];\n }\n\n auto compute_perimeter = [&]() {\n long long perim = (R[start_strip] - L[start_strip]) + (R[end_strip] - L[end_strip]);\n perim += 2LL * (end_strip - start_strip + 1) * strip_height;\n for (int i = start_strip; i < end_strip; i++) {\n perim += abs(L[i+1] - L[i]) + abs(R[i+1] - R[i]);\n }\n return perim;\n };\n\n long long current_perim = compute_perimeter();\n\n mt19937 rng(1337);\n int iterations = 0;\n double T0 = 20.0; \n double T1 = 0.001; \n double max_time = 1.95;\n double elapsed = 0.0;\n\n while (true) {\n if ((iterations & 2047) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > max_time) break;\n }\n iterations++;\n\n double progress = min(1.0, elapsed / max_time);\n int move_type = uniform_int_distribution(0, 19)(rng);\n\n if (move_type < 18) { \n int strip = uniform_int_distribution(start_strip, end_strip)(rng);\n bool is_L = uniform_int_distribution(0, 1)(rng);\n \n int max_delta = max(100, (int)(6000 * (1.0 - progress)));\n int delta = uniform_int_distribution(-max_delta, max_delta)(rng);\n\n int old_val = is_L ? L[strip] : R[strip];\n int new_val = clamp(old_val + delta, 0, MAX_COORD);\n\n // Strictly prevent boundaries from touching or crossing\n if (is_L) {\n if (new_val >= R[strip]) continue;\n if (strip > start_strip && new_val >= R[strip - 1]) continue;\n if (strip < end_strip && new_val >= R[strip + 1]) continue;\n } else {\n if (new_val <= L[strip]) continue;\n if (strip > start_strip && new_val <= L[strip - 1]) continue;\n if (strip < end_strip && new_val <= L[strip + 1]) continue;\n }\n\n long long diff_perim = 0;\n if (is_L) {\n if (strip == start_strip) diff_perim += (old_val - new_val);\n if (strip == end_strip) diff_perim += (old_val - new_val);\n if (strip > start_strip) diff_perim += abs(new_val - L[strip - 1]) - abs(old_val - L[strip - 1]);\n if (strip < end_strip) diff_perim += abs(L[strip + 1] - new_val) - abs(L[strip + 1] - old_val);\n } else {\n if (strip == start_strip) diff_perim += (new_val - old_val);\n if (strip == end_strip) diff_perim += (new_val - old_val);\n if (strip > start_strip) diff_perim += abs(new_val - R[strip - 1]) - abs(old_val - R[strip - 1]);\n if (strip < end_strip) diff_perim += abs(R[strip + 1] - new_val) - abs(R[strip + 1] - old_val);\n }\n\n if (current_perim + diff_perim > 400000LL) continue;\n\n int new_strip_score = get_strip_score(strip, is_L ? new_val : L[strip], is_L ? R[strip] : new_val);\n int diff = new_strip_score - strip_scores[strip];\n double temp = T0 * pow(T1 / T0, progress);\n\n if (diff >= 0 || uniform_real_distribution(0, 1)(rng) < exp(diff / temp)) {\n current_score += diff;\n strip_scores[strip] = new_strip_score;\n current_perim += diff_perim;\n if (is_L) L[strip] = new_val;\n else R[strip] = new_val;\n }\n } else { \n int vert_move = uniform_int_distribution(0, 3)(rng);\n int old_start = start_strip;\n int old_end = end_strip;\n \n if (vert_move == 0 && start_strip > 0) { \n start_strip--;\n L[start_strip] = L[start_strip + 1];\n R[start_strip] = R[start_strip + 1];\n strip_scores[start_strip] = get_strip_score(start_strip, L[start_strip], R[start_strip]);\n current_score += strip_scores[start_strip];\n } else if (vert_move == 1 && start_strip < end_strip - 2) { \n current_score -= strip_scores[start_strip];\n start_strip++;\n } else if (vert_move == 2 && end_strip < STRIPS - 1) { \n end_strip++;\n L[end_strip] = L[end_strip - 1];\n R[end_strip] = R[end_strip - 1];\n strip_scores[end_strip] = get_strip_score(end_strip, L[end_strip], R[end_strip]);\n current_score += strip_scores[end_strip];\n } else if (vert_move == 3 && end_strip > start_strip + 2) { \n current_score -= strip_scores[end_strip];\n end_strip--;\n } else {\n continue;\n }\n\n long long new_perim = compute_perimeter();\n int diff = (start_strip < old_start) ? strip_scores[start_strip] : \n (end_strip > old_end) ? strip_scores[end_strip] : \n (start_strip > old_start) ? -strip_scores[old_start] : -strip_scores[old_end];\n\n double temp = T0 * pow(T1 / T0, progress);\n\n if (new_perim <= 400000LL && (diff >= 0 || uniform_real_distribution(0, 1)(rng) < exp(diff / temp))) {\n current_perim = new_perim;\n } else { \n if (start_strip < old_start) current_score -= strip_scores[start_strip];\n if (end_strip > old_end) current_score -= strip_scores[end_strip];\n if (start_strip > old_start) current_score += strip_scores[old_start];\n if (end_strip < old_end) current_score += strip_scores[old_end];\n start_strip = old_start;\n end_strip = old_end;\n }\n }\n }\n\n vector vertices;\n vertices.push_back({L[start_strip], start_strip * strip_height});\n for (int i = start_strip; i <= end_strip; i++) {\n if (i > start_strip) {\n vertices.push_back({L[i-1], i * strip_height});\n vertices.push_back({L[i], i * strip_height});\n }\n }\n vertices.push_back({L[end_strip], min((end_strip + 1) * strip_height, MAX_COORD)});\n\n vertices.push_back({R[end_strip], min((end_strip + 1) * strip_height, MAX_COORD)});\n for (int i = end_strip; i >= start_strip; i--) {\n if (i < end_strip) {\n vertices.push_back({R[i+1], (i + 1) * strip_height});\n vertices.push_back({R[i], (i + 1) * strip_height});\n }\n }\n vertices.push_back({R[start_strip], start_strip * strip_height});\n\n vector simplified;\n for (size_t i = 0; i < vertices.size(); i++) {\n Point prev = vertices[(i + vertices.size() - 1) % vertices.size()];\n Point curr = vertices[i];\n Point next = vertices[(i + 1) % vertices.size()];\n if ((prev.x == curr.x && curr.x == next.x) || (prev.y == curr.y && curr.y == next.y)) continue; \n simplified.push_back(curr);\n }\n\n if (simplified.size() < 4 || simplified.size() > 1000) {\n simplified = {{init_x1, init_y1}, {init_x2, init_y1}, {init_x2, init_y2}, {init_x1, init_y2}};\n }\n\n cout << simplified.size() << \"\\n\";\n for (const auto& v : simplified) cout << v.x << \" \" << v.y << \"\\n\";\n\n return 0;\n}","ahc040":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct Rect {\n long long w, h;\n};\n\nstruct Placement {\n int r;\n char d;\n int b;\n};\n\nint N, T;\nlong long sigma;\nvector rects;\n\nmt19937 rng(1337);\n\nlong long X_pos[105];\nlong long Y_pos[105];\nlong long W_arr[105];\nlong long H_arr[105];\n\ninline long long simulate(const vector& p, long long& out_W, long long& out_H) {\n long long max_X = 0, max_Y = 0;\n\n for (int i = 0; i < N; ++i) {\n if (p[i].r == 1) {\n W_arr[i] = rects[i].h;\n H_arr[i] = rects[i].w;\n } else {\n W_arr[i] = rects[i].w;\n H_arr[i] = rects[i].h;\n }\n\n if (p[i].d == 'U') {\n long long cur_x = (p[i].b == -1) ? 0 : (X_pos[p[i].b] + W_arr[p[i].b]);\n X_pos[i] = cur_x;\n \n long long cur_y = 0;\n long long right_x = cur_x + W_arr[i];\n \n for (int j = 0; j < i; ++j) {\n if (cur_x < X_pos[j] + W_arr[j] && X_pos[j] < right_x) {\n long long top_y = Y_pos[j] + H_arr[j];\n if (top_y > cur_y) cur_y = top_y;\n }\n }\n Y_pos[i] = cur_y;\n } else {\n long long cur_y = (p[i].b == -1) ? 0 : (Y_pos[p[i].b] + H_arr[p[i].b]);\n Y_pos[i] = cur_y;\n \n long long cur_x = 0;\n long long bottom_y = cur_y + H_arr[i];\n \n for (int j = 0; j < i; ++j) {\n if (cur_y < Y_pos[j] + H_arr[j] && Y_pos[j] < bottom_y) {\n long long right_x = X_pos[j] + W_arr[j];\n if (right_x > cur_x) cur_x = right_x;\n }\n }\n X_pos[i] = cur_x;\n }\n \n long long end_x = X_pos[i] + W_arr[i];\n long long end_y = Y_pos[i] + H_arr[i];\n \n if (end_x > max_X) max_X = end_x;\n if (end_y > max_Y) max_Y = end_y;\n }\n \n out_W = max_X;\n out_H = max_Y;\n return max_X + max_Y;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> T >> sigma)) return 0;\n\n rects.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> rects[i].w >> rects[i].h;\n }\n\n auto start_time = chrono::steady_clock::now();\n auto max_time = start_time + chrono::milliseconds(2850);\n\n double temp_start = 30000.0;\n double temp_end = 0.5;\n\n for (int t = 0; t < T; ++t) {\n auto now = chrono::steady_clock::now();\n double remaining_time = chrono::duration(max_time - now).count();\n double time_for_this_turn = remaining_time / (T - t);\n auto turn_end_time = now + chrono::duration(time_for_this_turn);\n\n // 100% independent random start each turn to maximize layout variance\n vector current_p(N);\n for (int i = 0; i < N; ++i) {\n current_p[i].r = rng() % 2;\n current_p[i].d = (rng() % 2 == 0) ? 'U' : 'L';\n current_p[i].b = (i == 0) ? -1 : ((int)(rng() % (i + 1)) - 1);\n }\n \n long long dummy_W, dummy_H;\n long long current_score = simulate(current_p, dummy_W, dummy_H);\n\n vector best_turn_p = current_p;\n long long best_turn_score = current_score;\n\n int iters_per_check = 250; \n \n while (true) {\n auto current_time = chrono::steady_clock::now();\n if (current_time >= turn_end_time) break;\n \n double elapsed_ratio = chrono::duration(current_time - now).count() / time_for_this_turn;\n double temp = temp_start * pow(temp_end / temp_start, elapsed_ratio);\n\n for (int it = 0; it < iters_per_check; ++it) {\n int i = rng() % N;\n Placement old_pl = current_p[i];\n \n int r_type = rng() % 3;\n if (r_type == 0) {\n current_p[i].r ^= 1;\n } else if (r_type == 1) {\n current_p[i].d = (current_p[i].d == 'U') ? 'L' : 'U';\n } else {\n current_p[i].b = (i == 0) ? -1 : ((int)(rng() % (i + 1)) - 1);\n }\n\n long long W, H;\n long long new_score = simulate(current_p, W, H);\n \n bool accept = false;\n if (new_score <= current_score) {\n accept = true;\n } else {\n double prob = exp((current_score - new_score) / temp);\n if (generate_canonical(rng) < prob) {\n accept = true;\n }\n }\n\n if (accept) {\n current_score = new_score;\n if (current_score < best_turn_score) {\n best_turn_score = current_score;\n best_turn_p = current_p;\n }\n } else {\n current_p[i] = old_pl;\n }\n }\n }\n\n cout << N << \"\\n\";\n for (int i = 0; i < N; ++i) {\n cout << i << \" \" << best_turn_p[i].r << \" \" << best_turn_p[i].d << \" \" << best_turn_p[i].b << \"\\n\";\n }\n cout << flush;\n\n long long W_prime, H_prime;\n cin >> W_prime >> H_prime;\n }\n\n return 0;\n}","ahc041":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nuint64_t xorshift64() {\n static uint64_t x = 88172645463325252ULL;\n x ^= x << 13;\n x ^= x >> 7;\n x ^= x << 17;\n return x;\n}\n\ndouble next_double() {\n return (xorshift64() >> 11) * (1.0 / 9007199254740992.0);\n}\n\ninline uint32_t fast_rand(uint32_t range) {\n return (uint32_t)((xorshift64() & 0xFFFFFFFFull) * range >> 32);\n}\n\nconst int MAX_H = 10;\nint N, M, H;\nvector A;\n\n// CSR Graph representation\nvector adj_head;\nvector adj_edges;\n\nstruct FastTreeState {\n vector p;\n vector first_child;\n vector next_sibling;\n vector prev_sibling;\n vector depth;\n vector max_rel_height;\n vector subtree_A;\n long long score;\n\n FastTreeState() {\n p.assign(N, -1);\n first_child.assign(N, -1);\n next_sibling.assign(N, -1);\n prev_sibling.assign(N, -1);\n depth.assign(N, 0);\n max_rel_height.assign(N, 0);\n subtree_A.assign(N, 0);\n score = 0;\n for (int i = 0; i < N; ++i) {\n subtree_A[i] = A[i];\n score += A[i];\n }\n }\n\n inline void add_child(int parent, int child) {\n if (parent == -1) return;\n int head = first_child[parent];\n next_sibling[child] = head;\n if (head != -1) prev_sibling[head] = child;\n prev_sibling[child] = -1;\n first_child[parent] = child;\n }\n\n inline void remove_child(int parent, int child) {\n if (parent == -1) return;\n int prev = prev_sibling[child];\n int next = next_sibling[child];\n if (prev != -1) next_sibling[prev] = next;\n else first_child[parent] = next;\n if (next != -1) prev_sibling[next] = prev;\n prev_sibling[child] = -1;\n next_sibling[child] = -1;\n }\n\n void update_up(int node) {\n while (node != -1) {\n long long sum_A = A[node];\n int max_h = 0;\n int c = first_child[node];\n while (c != -1) {\n sum_A += subtree_A[c];\n if (max_rel_height[c] + 1 > max_h) {\n max_h = max_rel_height[c] + 1;\n }\n c = next_sibling[c];\n }\n subtree_A[node] = sum_A;\n max_rel_height[node] = max_h;\n node = p[node];\n }\n }\n\n void update_depth(int u) {\n int c = first_child[u];\n while (c != -1) {\n depth[c] = depth[u] + 1;\n update_depth(c);\n c = next_sibling[c];\n }\n }\n};\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n auto start_time = chrono::steady_clock::now();\n\n if (!(cin >> N >> M >> H)) return 0;\n\n A.resize(N);\n for (int i = 0; i < N; ++i) cin >> A[i];\n\n vector U(M), V(M);\n vector deg(N, 0);\n for (int i = 0; i < M; ++i) {\n cin >> U[i] >> V[i];\n deg[U[i]]++;\n deg[V[i]]++;\n }\n\n adj_head.assign(N + 1, 0);\n for (int i = 0; i < N; ++i) {\n adj_head[i + 1] = adj_head[i] + deg[i];\n }\n\n adj_edges.resize(2 * M);\n vector cur_head = adj_head;\n for (int i = 0; i < M; ++i) {\n adj_edges[cur_head[U[i]]++] = V[i];\n adj_edges[cur_head[V[i]]++] = U[i];\n }\n\n // Skip coordinates\n for (int i = 0; i < N; ++i) {\n int x, y;\n cin >> x >> y;\n }\n\n FastTreeState state;\n \n // BFS initialization\n vector visited(N, false);\n for (int i = 0; i < N; ++i) {\n if (!visited[i]) {\n visited[i] = true;\n vector q;\n q.push_back(i);\n int head_q = 0;\n while (head_q < (int)q.size()) {\n int u = q[head_q++];\n if (state.depth[u] >= H) continue;\n for (int e = adj_head[u]; e < adj_head[u + 1]; ++e) {\n int v = adj_edges[e];\n if (!visited[v]) {\n visited[v] = true;\n state.add_child(u, v);\n state.p[v] = u;\n state.depth[v] = state.depth[u] + 1;\n q.push_back(v);\n }\n }\n }\n for (int j = (int)q.size() - 1; j >= 0; --j) {\n int u = q[j];\n long long sum_A = A[u];\n int max_h = 0;\n int c = state.first_child[u];\n while (c != -1) {\n sum_A += state.subtree_A[c];\n if (state.max_rel_height[c] + 1 > max_h) {\n max_h = state.max_rel_height[c] + 1;\n }\n c = state.next_sibling[c];\n }\n state.subtree_A[u] = sum_A;\n state.max_rel_height[u] = max_h;\n }\n }\n }\n\n long long best_score = state.score;\n vector best_p = state.p;\n\n double T0 = 250.0;\n double T1 = 0.01; // Restored the optimal sweet spot final temperature\n long long iter = 0;\n double temp = T0;\n \n const double TIME_LIMIT = 1.99; // Aggressive time bound\n\n while (true) {\n if ((iter & 4095) == 0) { // Finer granularity time check\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n double progress = elapsed / TIME_LIMIT;\n if (progress > 1.0) progress = 1.0;\n temp = T0 * pow(T1 / T0, progress);\n }\n iter++;\n \n int v = fast_rand(N);\n int deg_v = adj_head[v + 1] - adj_head[v];\n int num_options = deg_v + 1;\n int opt = fast_rand(num_options);\n int u = (opt == deg_v) ? -1 : adj_edges[adj_head[v] + opt];\n\n if (state.p[v] == u) continue;\n\n bool cycle = false;\n if (u != -1 && state.depth[u] >= state.depth[v]) {\n int curr = u;\n while (curr != -1) {\n if (curr == v) {\n cycle = true;\n break;\n }\n curr = state.p[curr];\n }\n }\n if (cycle) continue;\n\n int new_v_depth = (u == -1) ? 0 : state.depth[u] + 1;\n if (new_v_depth + state.max_rel_height[v] > H) continue;\n\n long long delta_score = (long long)(new_v_depth - state.depth[v]) * state.subtree_A[v];\n\n if (delta_score >= 0 || next_double() < std::exp(delta_score / temp)) {\n int old_p = state.p[v];\n state.remove_child(old_p, v);\n state.add_child(u, v);\n state.p[v] = u;\n state.depth[v] = new_v_depth;\n \n state.update_depth(v);\n state.update_up(old_p);\n state.update_up(u);\n state.score += delta_score;\n\n if (state.score > best_score) {\n best_score = state.score;\n best_p = state.p;\n }\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_p[i] << (i == N - 1 ? \"\" : \" \");\n }\n cout << \"\\n\";\n\n return 0;\n}","ahc042":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nint N;\n\nstruct Macro {\n char dir;\n int idx;\n int k;\n int cost;\n uint64_t mask;\n};\n\nint main() {\n auto start_time = chrono::high_resolution_clock::now();\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N)) return 0;\n \n vector board(N);\n for (int i = 0; i < N; ++i) {\n cin >> board[i];\n }\n \n int oni_id[20][20];\n int oni_count = 0;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n oni_id[i][j] = -1;\n if (board[i][j] == 'x') {\n oni_id[i][j] = oni_count++;\n }\n }\n }\n \n vector macros;\n \n for (int r = 0; r < N; ++r) {\n uint64_t mask = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[r][k - 1] == 'o') break;\n if (board[r][k - 1] == 'x') mask |= (1ULL << oni_id[r][k - 1]);\n if (mask > 0) macros.push_back({'L', r, k, 2 * k, mask});\n }\n mask = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[r][N - k] == 'o') break;\n if (board[r][N - k] == 'x') mask |= (1ULL << oni_id[r][N - k]);\n if (mask > 0) macros.push_back({'R', r, k, 2 * k, mask});\n }\n }\n \n for (int c = 0; c < N; ++c) {\n uint64_t mask = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[k - 1][c] == 'o') break;\n if (board[k - 1][c] == 'x') mask |= (1ULL << oni_id[k - 1][c]);\n if (mask > 0) macros.push_back({'U', c, k, 2 * k, mask});\n }\n mask = 0;\n for (int k = 1; k <= N; ++k) {\n if (board[N - k][c] == 'o') break;\n if (board[N - k][c] == 'x') mask |= (1ULL << oni_id[N - k][c]);\n if (mask > 0) macros.push_back({'D', c, k, 2 * k, mask});\n }\n }\n \n uint64_t target_mask = (1ULL << oni_count) - 1;\n vector best_sequence_idx;\n int best_cost = 1e9;\n \n vector sa_sequence_idx;\n int sa_cost = 1e9;\n \n mt19937 rng(42);\n uniform_real_distribution alpha_dist(0.5, 3.5);\n uniform_real_distribution temp_dist(1e-4, 0.05);\n uniform_int_distribution drop_dist(1, 4);\n uniform_real_distribution prob_dist(0.0, 1.0);\n \n int num_macros = macros.size();\n vector macro_weight(num_macros);\n \n int iterations = 0;\n while (true) {\n iterations++;\n if ((iterations & 255) == 0) {\n auto current_time = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(current_time - start_time).count();\n if (elapsed > 1.95) break; \n }\n\n double time_ratio = min(1.0, (iterations * 256.0) / 100000.0); // Rough estimate\n double sa_temperature = 5.0 * (1.0 - time_ratio); // Simulated Annealing temp\n\n double alpha = alpha_dist(rng);\n double temp = temp_dist(rng);\n exponential_distribution exp_dist(1.0 / temp);\n \n for (int i = 0; i < num_macros; ++i) {\n macro_weight[i] = 1.0 / pow((double)macros[i].cost, alpha);\n }\n \n uint64_t current_mask = 0;\n int current_cost = 0;\n vector current_sequence_idx;\n\n // 70% chance to mutate the SA tracking sequence, 30% complete restart\n if (!sa_sequence_idx.empty() && prob_dist(rng) < 0.7) {\n current_sequence_idx = sa_sequence_idx;\n int drops = min((int)current_sequence_idx.size(), drop_dist(rng));\n for (int d = 0; d < drops; ++d) {\n int r_idx = uniform_int_distribution(0, current_sequence_idx.size() - 1)(rng);\n current_sequence_idx.erase(current_sequence_idx.begin() + r_idx);\n }\n for (int idx : current_sequence_idx) {\n current_mask |= macros[idx].mask;\n current_cost += macros[idx].cost;\n }\n }\n \n // Greedy Repair / Construction\n while (current_mask != target_mask) {\n double best_score = -1.0;\n int best_m = -1;\n \n for (int i = 0; i < num_macros; ++i) {\n uint64_t new_bits = macros[i].mask & ~current_mask;\n int dropped = __builtin_popcountll(new_bits);\n if (dropped > 0) {\n double score = (double)dropped * macro_weight[i] + exp_dist(rng);\n if (score > best_score) {\n best_score = score;\n best_m = i;\n }\n }\n }\n \n if (best_m != -1) {\n current_mask |= macros[best_m].mask;\n current_cost += macros[best_m].cost;\n current_sequence_idx.push_back(best_m);\n } else {\n break;\n }\n }\n \n if (current_mask == target_mask) {\n // Pruning step\n bool changed = true;\n while (changed) {\n changed = false;\n for (int i = 0; i < current_sequence_idx.size(); ++i) {\n uint64_t check_mask = 0;\n for (int j = 0; j < current_sequence_idx.size(); ++j) {\n if (i != j) check_mask |= macros[current_sequence_idx[j]].mask;\n }\n if (check_mask == target_mask) {\n current_cost -= macros[current_sequence_idx[i]].cost;\n current_sequence_idx.erase(current_sequence_idx.begin() + i);\n changed = true;\n break;\n }\n }\n }\n \n // SA Acceptance\n if (current_cost < sa_cost || prob_dist(rng) < exp((sa_cost - current_cost) / max(0.1, sa_temperature))) {\n sa_cost = current_cost;\n sa_sequence_idx = current_sequence_idx;\n }\n \n // Global Best Tracking\n if (current_cost < best_cost) {\n best_cost = current_cost;\n best_sequence_idx = current_sequence_idx;\n }\n }\n }\n \n vector> moves;\n for (int idx : best_sequence_idx) {\n const auto& m = macros[idx];\n if (m.dir == 'U') {\n for (int i = 0; i < m.k; ++i) moves.push_back({'U', m.idx});\n for (int i = 0; i < m.k; ++i) moves.push_back({'D', m.idx});\n } else if (m.dir == 'D') {\n for (int i = 0; i < m.k; ++i) moves.push_back({'D', m.idx});\n for (int i = 0; i < m.k; ++i) moves.push_back({'U', m.idx});\n } else if (m.dir == 'L') {\n for (int i = 0; i < m.k; ++i) moves.push_back({'L', m.idx});\n for (int i = 0; i < m.k; ++i) moves.push_back({'R', m.idx});\n } else if (m.dir == 'R') {\n for (int i = 0; i < m.k; ++i) moves.push_back({'R', m.idx});\n for (int i = 0; i < m.k; ++i) moves.push_back({'L', m.idx});\n }\n }\n \n for (auto p : moves) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n \n return 0;\n}","ahc044":"#pragma GCC optimize(\"O3,unroll-loops\")\n#pragma GCC target(\"avx2,bmi,bmi2,lzcnt,popcnt\")\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 100;\nconst int L = 500000;\nint T[N];\n\n// Ultra-fast PRNG to replace mt19937\nuint32_t xor32() {\n static uint32_t x = 123456789;\n x ^= x << 13;\n x ^= x >> 17;\n x ^= x << 5;\n return x;\n}\n\ninline double fast_rand01() {\n return (xor32() & 0xFFFFFF) * (1.0 / 16777216.0);\n}\n\ninline int simulate(const int* sa, const int* sb) {\n int t[N] = {0};\n int curr = 0;\n \n int next_node[N][2];\n for (int i = 0; i < N; ++i) {\n next_node[i][0] = sb[i]; // even t gets b\n next_node[i][1] = sa[i]; // odd t gets a\n }\n \n int parity[N] = {0};\n \n // Loop unrolling for maximum throughput\n for (int step = 0; step < L / 4; ++step) {\n int p0 = parity[curr];\n t[curr]++;\n parity[curr] = p0 ^ 1;\n curr = next_node[curr][p0];\n\n int p1 = parity[curr];\n t[curr]++;\n parity[curr] = p1 ^ 1;\n curr = next_node[curr][p1];\n\n int p2 = parity[curr];\n t[curr]++;\n parity[curr] = p2 ^ 1;\n curr = next_node[curr][p2];\n\n int p3 = parity[curr];\n t[curr]++;\n parity[curr] = p3 ^ 1;\n curr = next_node[curr][p3];\n }\n \n int diff = 0;\n for (int i = 0; i < N; ++i) {\n int d = t[i] - T[i];\n diff += (d > 0 ? d : -d);\n }\n return diff;\n}\n\ninline int count_reachable(const int* sa, const int* sb) {\n bool visited[N] = {false};\n int q[N];\n int head = 0, tail = 0;\n \n visited[0] = true;\n q[tail++] = 0;\n \n int count = 0;\n while (head < tail) {\n int u = q[head++];\n count++;\n \n int v1 = sa[u];\n if (!visited[v1]) {\n visited[v1] = true;\n q[tail++] = v1;\n }\n int v2 = sb[u];\n if (!visited[v2]) {\n visited[v2] = true;\n q[tail++] = v2;\n }\n }\n return count;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, l_input;\n if (!(cin >> n_input >> l_input)) return 0;\n for (int i = 0; i < N; ++i) {\n cin >> T[i];\n }\n\n int a[N], b[N];\n int W0[N], W1[N];\n int I[N] = {0};\n\n for (int i = 0; i < N; ++i) {\n a[i] = (i + 1) % N;\n b[i] = (i + 1) % N;\n W0[i] = T[i] / 2; \n W1[i] = (T[i] + 1) / 2; \n }\n\n int current_cost_I = 0;\n for (int i = 0; i < N; ++i) {\n I[a[i]] += W0[i];\n I[b[i]] += W1[i];\n }\n for (int i = 0; i < N; ++i) {\n current_cost_I += abs(I[i] - T[i]);\n }\n \n int current_reach = count_reachable(a, b);\n int current_cost = current_cost_I + (N - current_reach) * 15000;\n \n int best_cost = current_cost;\n int best_a[N], best_b[N];\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n\n auto start_time = chrono::steady_clock::now();\n\n // Phase 1: Fast SA\n double t0 = 5000.0;\n double t1 = 5.0; \n int iter = 0;\n double temp = t0;\n \n while (true) {\n if ((iter & 1023) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.20) break;\n temp = t0 * pow(t1 / t0, elapsed / 1.20);\n }\n iter++;\n\n int u = xor32() % N;\n bool is_a = xor32() & 1;\n int old_v = is_a ? a[u] : b[u];\n int new_v = xor32() % N;\n \n if (old_v == new_v) continue;\n\n int weight = is_a ? W0[u] : W1[u];\n \n int old_I_cost = abs(I[old_v] - T[old_v]) + abs(I[new_v] - T[new_v]);\n I[old_v] -= weight;\n I[new_v] += weight;\n int new_I_cost = abs(I[old_v] - T[old_v]) + abs(I[new_v] - T[new_v]);\n \n int delta_I = new_I_cost - old_I_cost;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_reach = count_reachable(a, b);\n int delta_reach = (N - new_reach) * 15000 - (N - current_reach) * 15000;\n \n int delta = delta_I + delta_reach;\n\n if (delta <= 0 || fast_rand01() < exp(-delta / temp)) {\n current_cost += delta;\n current_cost_I += delta_I;\n current_reach = new_reach;\n \n if (current_cost < best_cost) {\n best_cost = current_cost;\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n I[old_v] += weight;\n I[new_v] -= weight;\n }\n }\n\n // Phase 2: Full Simulation Fine-Tuning\n for (int i = 0; i < N; ++i) {\n a[i] = best_a[i];\n b[i] = best_b[i];\n }\n \n current_cost = simulate(a, b);\n best_cost = current_cost;\n \n t0 = 50.0;\n t1 = 0.5;\n iter = 0;\n temp = t0;\n \n while (true) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > 1.98) break;\n\n if ((iter & 63) == 0) {\n temp = t0 * pow(t1 / t0, (elapsed - 1.20) / 0.78);\n }\n iter++;\n\n int u = xor32() % N;\n bool is_a = xor32() & 1;\n int old_v = is_a ? a[u] : b[u];\n int new_v = xor32() % N;\n \n if (old_v == new_v) continue;\n\n if (is_a) a[u] = new_v;\n else b[u] = new_v;\n\n int new_cost = simulate(a, b);\n int delta = new_cost - current_cost;\n\n if (delta <= 0 || fast_rand01() < exp(-delta / temp)) {\n current_cost = new_cost;\n if (current_cost < best_cost) {\n best_cost = current_cost;\n for (int i = 0; i < N; ++i) {\n best_a[i] = a[i];\n best_b[i] = b[i];\n }\n }\n } else {\n if (is_a) a[u] = old_v;\n else b[u] = old_v;\n }\n }\n\n for (int i = 0; i < N; ++i) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n\n return 0;\n}","ahc045":"#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nstruct City {\n int lx, rx, ly, ry;\n long long cx, cy;\n};\n\nint N, M, Q, L, W;\nvector G;\nvector cities;\nlong long D[805][805];\n\nstruct DSU {\n vector parent;\n DSU(int n) {\n parent.resize(n);\n iota(parent.begin(), parent.end(), 0);\n }\n int find(int i) {\n if (parent[i] == i)\n return i;\n return parent[i] = find(parent[i]);\n }\n bool unite(int i, int j) {\n int root_i = find(i);\n int root_j = find(j);\n if (root_i != root_j) {\n parent[root_i] = root_j;\n return true;\n }\n return false;\n }\n};\n\nlong long calc_mst(const vector& nodes) {\n int k = nodes.size();\n if (k <= 1) return 0;\n vector min_e(k, 1e18);\n vector vis(k, false);\n min_e[0] = 0;\n long long total = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n long long best_min = 1e18;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && min_e[j] < best_min) {\n best_min = min_e[j];\n v = j;\n }\n }\n if (best_min >= 1e18) break;\n vis[v] = true;\n total += best_min;\n int u_node = nodes[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = D[u_node][nodes[j]];\n if (d < min_e[j]) min_e[j] = d;\n }\n }\n }\n return total;\n}\n\nvector> get_mst_edges(const vector& nodes) {\n int k = nodes.size();\n vector> edges;\n if (k <= 1) return edges;\n vector min_e(k, 1e18);\n vector parent(k, -1);\n vector vis(k, false);\n min_e[0] = 0;\n for (int i = 0; i < k; ++i) {\n int v = -1;\n long long best_min = 1e18;\n for (int j = 0; j < k; ++j) {\n if (!vis[j] && min_e[j] < best_min) {\n best_min = min_e[j];\n v = j;\n }\n }\n vis[v] = true;\n if (parent[v] != -1) {\n edges.push_back({nodes[parent[v]], nodes[v]});\n }\n int u_node = nodes[v];\n for (int j = 0; j < k; ++j) {\n if (!vis[j]) {\n long long d = D[u_node][nodes[j]];\n if (d < min_e[j]) {\n min_e[j] = d;\n parent[j] = v;\n }\n }\n }\n }\n return edges;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n if (!(cin >> N >> M >> Q >> L >> W)) return 0;\n \n G.resize(M);\n for (int i = 0; i < M; ++i) cin >> G[i];\n\n cities.resize(N);\n for (int i = 0; i < N; ++i) {\n cin >> cities[i].lx >> cities[i].rx >> cities[i].ly >> cities[i].ry;\n cities[i].cx = (cities[i].lx + cities[i].rx) / 2;\n cities[i].cy = (cities[i].ly + cities[i].ry) / 2;\n }\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (i == j) D[i][j] = 0;\n else {\n long long dx = cities[i].cx - cities[j].cx;\n long long dy = cities[i].cy - cities[j].cy;\n D[i][j] = std::floor(std::sqrt(dx * dx + dy * dy));\n }\n }\n }\n\n vector assign(N, -1);\n vector> grps(M);\n vector used(N, false);\n vector g_idx(M);\n iota(g_idx.begin(), g_idx.end(), 0);\n sort(g_idx.begin(), g_idx.end(), [&](int a, int b) { return G[a] > G[b]; });\n\n for (int k : g_idx) {\n int start = -1;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) { start = i; break; }\n }\n used[start] = true;\n grps[k].push_back(start);\n assign[start] = k;\n \n while ((int)grps[k].size() < G[k]) {\n int best_c = -1;\n long long best_d = 2e18;\n for (int i = 0; i < N; ++i) {\n if (!used[i]) {\n long long d = 0;\n for (int u : grps[k]) {\n long long dx = cities[u].cx - cities[i].cx;\n long long dy = cities[u].cy - cities[i].cy;\n d += dx * dx + dy * dy;\n }\n if (d < best_d) {\n best_d = d;\n best_c = i;\n }\n }\n }\n used[best_c] = true;\n grps[k].push_back(best_c);\n assign[best_c] = k;\n }\n }\n\n vector mst_cost(M);\n for (int i = 0; i < M; ++i) mst_cost[i] = calc_mst(grps[i]);\n\n auto start_time = chrono::steady_clock::now();\n double max_time = 0.40; \n int iter = 0;\n mt19937 rng(42);\n uniform_int_distribution dist_N(0, N - 1);\n uniform_real_distribution dist_01(0.0, 1.0);\n \n double t0 = 1000.0, t1 = 10.0;\n double temp = t0;\n\n vector> nn(N);\n for(int i = 0; i < N; ++i){\n vector> dists;\n for(int j = 0; j < N; ++j) if(i != j) dists.push_back({D[i][j], j});\n sort(dists.begin(), dists.end());\n for(int j = 0; j < min(N - 1, 50); ++j) nn[i].push_back(dists[j].second);\n }\n\n while (true) {\n if ((iter & 127) == 0) {\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > max_time) break;\n temp = t0 * pow(t1 / t0, elapsed / max_time);\n }\n iter++;\n\n int u = dist_N(rng);\n int v;\n if (dist_01(rng) < 0.7 && !nn[u].empty()) {\n v = nn[u][rng() % nn[u].size()];\n } else {\n v = dist_N(rng);\n }\n\n if (assign[u] == assign[v]) continue;\n\n int gu = assign[u];\n int gv = assign[v];\n long long old_cost = mst_cost[gu] + mst_cost[gv];\n\n for (int& x : grps[gu]) if (x == u) x = v;\n for (int& x : grps[gv]) if (x == v) x = u;\n\n long long new_u_cost = calc_mst(grps[gu]);\n long long new_v_cost = calc_mst(grps[gv]);\n long long new_cost = new_u_cost + new_v_cost;\n\n if (new_cost <= old_cost || exp((old_cost - new_cost) / temp) > dist_01(rng)) {\n mst_cost[gu] = new_u_cost;\n mst_cost[gv] = new_v_cost;\n assign[u] = gv;\n assign[v] = gu;\n } else {\n for (int& x : grps[gu]) if (x == v) x = u;\n for (int& x : grps[gv]) if (x == u) x = v;\n }\n }\n\n vector>> final_group_edges(M);\n \n for (int k = 0; k < M; ++k) {\n auto approx_edges = get_mst_edges(grps[k]);\n \n vector best_seq;\n long long min_seq_dist = 2e18;\n \n if (!grps[k].empty()) {\n for (int start_node : grps[k]) {\n vector current_seq;\n vector vis2(N, false);\n int cur = start_node;\n current_seq.push_back(cur);\n vis2[cur] = true;\n long long current_dist = 0;\n \n for (int step = 1; step < (int)grps[k].size(); ++step) {\n int nxt = -1;\n long long best_d = 2e18;\n for (int v : grps[k]) {\n if (!vis2[v] && D[cur][v] < best_d) {\n best_d = D[cur][v];\n nxt = v;\n }\n }\n current_seq.push_back(nxt);\n vis2[nxt] = true;\n current_dist += best_d;\n cur = nxt;\n }\n \n if (current_dist < min_seq_dist) {\n min_seq_dist = current_dist;\n best_seq = current_seq;\n }\n }\n }\n \n vector seq = best_seq;\n \n if (seq.size() >= 4) {\n bool improved = true;\n while (improved) {\n improved = false;\n for (int i = 1; i < (int)seq.size() - 2; ++i) {\n for (int j = i + 1; j < (int)seq.size() - 1; ++j) {\n long long d1 = D[seq[i - 1]][seq[i]] + D[seq[j]][seq[j + 1]];\n long long d2 = D[seq[i - 1]][seq[j]] + D[seq[i]][seq[j + 1]];\n if (d2 < d1) {\n reverse(seq.begin() + i, seq.begin() + j + 1);\n improved = true;\n }\n }\n }\n }\n }\n\n DSU dsu(N);\n int idx = 0;\n \n while (idx + 1 < (int)seq.size() && Q > 0) {\n int take = min((int)seq.size() - idx, L);\n cout << \"? \" << take;\n for(int i = 0; i < take; ++i) cout << \" \" << seq[idx + i];\n cout << endl;\n Q--;\n \n for(int i = 0; i < take - 1; ++i) {\n int u, v; \n cin >> u >> v;\n if (dsu.unite(u, v)) {\n final_group_edges[k].push_back({u, v});\n }\n }\n idx += take - 1;\n }\n \n for (auto& e : approx_edges) {\n if (dsu.unite(e.first, e.second)) {\n final_group_edges[k].push_back(e);\n }\n }\n }\n\n cout << \"!\" << endl;\n for (int i = 0; i < M; ++i) {\n for (int j = 0; j < G[i]; ++j) {\n cout << grps[i][j] << (j + 1 == G[i] ? \"\" : \" \");\n }\n cout << endl;\n for (auto& e : final_group_edges[i]) {\n cout << e.first << \" \" << e.second << endl;\n }\n }\n\n return 0;\n}","ahc046":"#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst int N = 20;\n\nstruct Point {\n int r, c;\n bool operator==(const Point& o) const {\n return r == o.r && c == o.c;\n }\n bool operator!=(const Point& o) const {\n return r != o.r || c != o.c;\n }\n};\n\nstruct StateInfo {\n int prev_r, prev_c;\n char action_type;\n char dir;\n};\n\nint dr[] = {-1, 1, 0, 0};\nint dc[] = {0, 0, -1, 1};\nchar dir_chars[] = {'U', 'D', 'L', 'R'};\n\nbool is_valid(int r, int c) {\n return r >= 0 && r < N && c >= 0 && c < N;\n}\n\nint main() {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n\n int n_input, m_input;\n if (!(cin >> n_input >> m_input)) return 0;\n\n vector targets(m_input);\n for (int i = 0; i < m_input; ++i) {\n cin >> targets[i].r >> targets[i].c;\n }\n\n Point curr = targets[0];\n vector> total_actions;\n\n for (int i = 1; i < m_input; ++i) {\n Point target = targets[i];\n \n vector> dist(N, vector(N, 1e9));\n vector> parent(N, vector(N));\n \n queue q;\n q.push(curr);\n dist[curr.r][curr.c] = 0;\n \n while (!q.empty()) {\n Point u = q.front();\n q.pop();\n \n if (u == target) break;\n \n for (int d = 0; d < 4; ++d) {\n // Try Move\n int nr = u.r + dr[d];\n int nc = u.c + dc[d];\n if (is_valid(nr, nc)) {\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'M', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n \n // Try Slide\n nr = u.r;\n nc = u.c;\n while (is_valid(nr + dr[d], nc + dc[d])) {\n nr += dr[d];\n nc += dc[d];\n }\n if (nr != u.r || nc != u.c) { // actually moved\n if (dist[nr][nc] > dist[u.r][u.c] + 1) {\n dist[nr][nc] = dist[u.r][u.c] + 1;\n parent[nr][nc] = {u.r, u.c, 'S', dir_chars[d]};\n q.push({nr, nc});\n }\n }\n }\n }\n \n // Reconstruct path\n vector> path;\n Point step = target;\n while (step != curr) {\n StateInfo info = parent[step.r][step.c];\n path.push_back({info.action_type, info.dir});\n step = {info.prev_r, info.prev_c};\n }\n \n reverse(path.begin(), path.end());\n for (auto p : path) {\n total_actions.push_back(p);\n }\n \n curr = target;\n }\n\n for (auto p : total_actions) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n\n return 0;\n}"}}}