{"model_name":"grok-4.3","codes":{"1":{"ahc001":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Rect {\n int x1, y1, x2, y2;\n};\n\nint N;\nvector X, Y, R;\n\ndouble compute_score(const vector& recs) {\n double tot = 0.0;\n for (int i = 0; i < N; i++) {\n ll a = recs[i].x1, b = recs[i].y1, c = recs[i].x2, d = recs[i].y2;\n ll s = (c - a) * 1LL * (d - b);\n ll rr = R[i];\n if (s == 0 || rr == 0) continue;\n double ratio = min(s, rr) * 1.0 / max(s, rr);\n tot += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return tot;\n}\n\nvoid solve_rects(int lx, int ly, int rx, int ry, vector ps, vector& recs) {\n if (ps.size() == 0) return;\n if (ps.size() == 1) {\n recs[ps[0]] = {lx, ly, rx, ry};\n return;\n }\n ll area = (rx - lx) * 1LL * (ry - ly);\n double best_mis = 1e30;\n int best_d = -1, best_kk = -1, best_ct = -1;\n for (int dir = 0; dir < 2; dir++) {\n vector idx = ps;\n if (dir == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int m = idx.size();\n vector pref(m + 1, 0);\n for (int j = 1; j <= m; j++) {\n pref[j] = pref[j - 1] + R[idx[j - 1]];\n }\n ll tot = pref[m];\n if (tot == 0) continue;\n for (int k = 1; k < m; k++) {\n ll sleft = pref[k];\n int idl = idx[k - 1], idr = idx[k];\n ll min_c, max_c;\n if (dir == 0) {\n min_c = X[idl] + 1;\n max_c = X[idr];\n } else {\n min_c = Y[idl] + 1;\n max_c = Y[idr];\n }\n ll low = dir == 0 ? lx + 1 : ly + 1;\n ll high = dir == 0 ? rx - 1 : ry - 1;\n min_c = max(min_c, low);\n max_c = min(max_c, high);\n if (min_c > max_c) continue;\n double target_a = sleft * 1.0 / tot * area;\n ll target_cut;\n if (dir == 0) {\n ll hgt = ry - ly;\n if (hgt <= 0) continue;\n ll dw = (ll)round(target_a / hgt);\n target_cut = lx + dw;\n } else {\n ll wid = rx - lx;\n if (wid <= 0) continue;\n ll dh = (ll)round(target_a / wid);\n target_cut = ly + dh;\n }\n ll cutt = max(min_c, min(max_c, target_cut));\n ll act_area = 0;\n if (dir == 0) {\n act_area = (cutt - lx) * 1LL * (ry - ly);\n } else {\n act_area = (rx - lx) * 1LL * (cutt - ly);\n }\n double mis = fabs(act_area - target_a);\n if (mis < best_mis) {\n best_mis = mis;\n best_d = dir;\n best_kk = k;\n best_ct = (int)cutt;\n }\n }\n }\n if (best_d == -1) {\n bool found = false;\n int dir_try = (rx - lx > 1 ? 0 : 1);\n for (int tries = 0; tries < 2 && !found; tries++) {\n int dirr = dir_try;\n vector idxx = ps;\n if (dirr == 0) {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int mm = idxx.size();\n for (int kk = 1; kk < mm; kk++) {\n int idl = idxx[kk - 1], idr = idxx[kk];\n ll minc_ = dirr == 0 ? X[idl] + 1 : Y[idl] + 1;\n ll maxc_ = dirr == 0 ? X[idr] : Y[idr];\n ll loww = dirr == 0 ? lx + 1 : ly + 1;\n ll highh = dirr == 0 ? rx - 1 : ry - 1;\n if (minc_ <= maxc_ && minc_ <= highh && maxc_ >= loww) {\n best_d = dirr;\n best_kk = kk;\n ll midv = (max(minc_, loww) + min(maxc_, highh)) / 2;\n best_ct = (int)midv;\n found = true;\n break;\n }\n }\n dir_try = 1 - dir_try;\n }\n if (!found) {\n // ultimate fallback\n best_d = 0;\n best_kk = ps.size() / 2;\n best_ct = lx + (rx - lx) / 2;\n if (best_ct < lx + 1) best_ct = lx + 1;\n if (best_ct > rx - 1) best_ct = rx - 1;\n }\n }\n vector idx = ps;\n if (best_d == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n vector left_ps(idx.begin(), idx.begin() + best_kk);\n vector right_ps(idx.begin() + best_kk, idx.end());\n if (best_d == 0) {\n solve_rects(lx, ly, best_ct, ry, left_ps, recs);\n solve_rects(best_ct, ly, rx, ry, right_ps, recs);\n } else {\n solve_rects(lx, ly, rx, best_ct, left_ps, recs);\n solve_rects(lx, best_ct, rx, ry, right_ps, recs);\n }\n}\n\nint main() {\n cin >> N;\n X.resize(N);\n Y.resize(N);\n R.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n vector recs(N);\n vector ps(N);\n iota(ps.begin(), ps.end(), 0);\n solve_rects(0, 0, 10000, 10000, ps, recs);\n for (int i = 0; i < N; i++) {\n cout << recs[i].x1 << \" \" << recs[i].y1 << \" \" << recs[i].x2 << \" \" << recs[i].y2 << endl;\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int si, sj;\n cin >> si >> sj;\n int T[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> T[i][j];\n int P[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> P[i][j];\n pair sib[50][50];\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) sib[i][j] = {-1,-1};\n int maxt = 0;\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) maxt = max(maxt, T[i][j]);\n vector>> tilec(maxt+1);\n for(int i=0;i<50;i++)for(int j=0;j<50;j++){\n tilec[T[i][j]].emplace_back(i,j);\n }\n for(auto& v: tilec){\n if(v.size()==2){\n auto [x1,y1]=v[0]; auto [x2,y2]=v[1];\n sib[x1][y1]={x2,y2};\n sib[x2][y2]={x1,y1};\n }\n }\n int di[4]={-1,0,1,0};\n int dj[4]={0,1,0,-1};\n char dc[4]={'U','R','D','L'};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n ll best_score = P[si][sj];\n string best_path = \"\";\n auto simulate = [&](bool det) -> pair {\n bool vis[50][50] = {};\n vis[si][sj] = true;\n ll score = P[si][sj];\n string path = \"\";\n int ci=si, cj = sj;\n while(true) {\n vector cands;\n for(int d=0;d<4;d++) {\n int ni = ci + di[d], nj = cj + dj[d];\n if(ni<0 || ni >=50 || nj<0 || nj>=50 || vis[ni][nj]) continue;\n auto [bx,by] = sib[ni][nj];\n if(bx!=-1 && vis[bx][by] && (bx != ci || by != cj)) continue;\n cands.push_back(d);\n }\n if(cands.empty()) break;\n vector ws(cands.size(), 0);\n for(size_t k=0; k=50||nnj<0||nnj>=50 || vis[nni][nnj]) continue;\n auto [bx,by] = sib[nni][nnj];\n if(bx !=-1 && vis[bx][by] && (bx != ni || by != nj)) continue;\n maxnp = max(maxnp, (ll)P[nni][nnj]);\n }\n ws[k] = val + maxnp + 1;\n }\n size_t idx;\n if(det) {\n ll mw = -1;\n idx = 0;\n for(size_t k=0; k mw) {\n mw = ws[k];\n idx = k;\n }\n } else {\n ll sumw = 0;\n for(auto w : ws) sumw += w;\n size_t sz = cands.size();\n if(sumw == 0 || sz == 0) {\n idx = 0;\n } else {\n uniform_int_distribution dist(0, sumw-1);\n ll target = dist(rng);\n idx = sz -1;\n ll cum = 0;\n for(size_t k=0; k best_score){ best_score=sc; best_path=pa; }\n const int TRIALS = 20000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n cout << best_path << endl;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n double horiz[30][29];\n double vert[29][30];\n for(int i = 0; i < 30; i++) {\n for(int j = 0; j < 29; j++) {\n horiz[i][j] = 5000.0;\n }\n }\n for(int i = 0; i < 29; i++) {\n for(int j = 0; j < 30; j++) {\n vert[i][j] = 5000.0;\n }\n }\n double alpha = 0.25;\n for(int q = 0; q < 1000; q++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n vector> dist(30, vector(30, 1e18));\n vector>> prev(30, vector>(30, {-1, -1}));\n dist[si][sj] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0.0, si, sj);\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n while (!pq.empty()) {\n auto [cost, r, c] = pq.top(); pq.pop();\n if (cost > dist[r][c]) continue;\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 30 || nc < 0 || nc >= 30) continue;\n double edgew = 1e18;\n if (d == 0) { // U\n edgew = vert[nr][c];\n } else if (d == 1) { // D\n edgew = vert[r][c];\n } else if (d == 2) { // L\n edgew = horiz[r][nc];\n } else if (d == 3) { // R\n edgew = horiz[r][c];\n }\n if (dist[nr][nc] > dist[r][c] + edgew) {\n dist[nr][nc] = dist[r][c] + edgew;\n prev[nr][nc] = {r, c};\n pq.emplace(dist[nr][nc], nr, nc);\n }\n }\n }\n double S = dist[ti][tj];\n // build path string\n vector pathv;\n int cr = ti, cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (cr > pr) pathv.push_back('D');\n else if (cr < pr) pathv.push_back('U');\n else if (cc > pc) pathv.push_back('R');\n else if (cc < pc) pathv.push_back('L');\n cr = pr;\n cc = pc;\n }\n reverse(pathv.begin(), pathv.end());\n string path;\n for (char ch : pathv) path += ch;\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n if (S >= 1e17) {\n // invalid, skip update\n continue;\n }\n double factor = (double)meas / S;\n double mult = 1.0 - alpha + alpha * factor;\n cr = ti;\n cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (pr == cr) { // horizontal\n int minc = min(pc, cc);\n horiz[cr][minc] *= mult;\n } else { // vertical\n int minr = min(pr, cr);\n vert[minr][cc] *= mult;\n }\n cr = pr;\n cc = pc;\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct AhoCorasick {\n vector> trie;\n vector fail;\n vector> outs;\n int nodes;\n\n AhoCorasick() : nodes(1) {\n trie.emplace_back();\n trie[0].fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n\n void insert(const string& s, int idx) {\n int node = 0;\n for (char cc : s) {\n int c = (cc == '.' ? 8 : cc - 'A');\n if (trie[node][c] == -1) {\n trie[node][c] = nodes++;\n trie.emplace_back();\n trie.back().fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n node = trie[node][c];\n }\n outs[node].push_back(idx);\n }\n\n void build() {\n queue q;\n for (int c = 0; c < 9; c++) {\n if (trie[0][c] != -1) {\n int child = trie[0][c];\n fail[child] = 0;\n q.push(child);\n }\n }\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int c = 0; c < 9; c++) {\n if (trie[cur][c] != -1) {\n int child = trie[cur][c];\n int f = fail[cur];\n while (f != 0 && trie[f][c] == -1) f = fail[f];\n if (trie[f][c] != -1) f = trie[f][c];\n fail[child] = f;\n outs[child].insert(outs[child].end(), outs[f].begin(), outs[f].end());\n q.push(child);\n }\n }\n }\n }\n\n void run_on_arr(const int* seq, int len, vector& matched) {\n int node = 0;\n for (int i = 0; i < len; i++) {\n int c = seq[i];\n while (node && trie[node][c] < 0) node = fail[node];\n if (trie[node][c] >= 0) node = trie[node][c];\n else node = 0;\n for (int id : outs[node]) {\n matched[id] = 1;\n }\n }\n }\n};\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector strs(M);\n for (int i = 0; i < M; i++) {\n cin >> strs[i];\n }\n AhoCorasick ac;\n for (int i = 0; i < M; i++) {\n ac.insert(strs[i], i);\n }\n ac.build();\n\n vector> grid(N, vector(N));\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, 7);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n grid[i][j] = 'A' + dist(rng);\n }\n }\n\n const int MAXD = 32;\n int seq_arr[MAXD];\n int double_len = N + 11;\n if (double_len > MAXD) double_len = N + N; // safety\n\n vector cover_cnt(M, 0);\n vector temp_matched(M, 0);\n int current_covered = 0;\n\n auto fill_seq_row = [&](int r, int* seq, int len) {\n for (int k = 0; k < len; k++) {\n int pos = k % N;\n char ch = grid[r][pos];\n seq[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n auto fill_seq_col = [&](int c, int* seq, int len) {\n for (int k = 0; k < len; k++) {\n int pos = k % N;\n char ch = grid[pos][c];\n seq[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n // initial cover_cnt\n for (int r = 0; r < N; r++) {\n fill_seq_row(r, seq_arr, double_len);\n fill(temp_matched.begin(), temp_matched.end(), 0);\n ac.run_on_arr(seq_arr, double_len, temp_matched);\n for (int i = 0; i < M; i++) {\n if (temp_matched[i]) cover_cnt[i]++;\n }\n }\n for (int c = 0; c < N; c++) {\n fill_seq_col(c, seq_arr, double_len);\n fill(temp_matched.begin(), temp_matched.end(), 0);\n ac.run_on_arr(seq_arr, double_len, temp_matched);\n for (int i = 0; i < M; i++) {\n if (temp_matched[i]) cover_cnt[i]++;\n }\n }\n for (int i = 0; i < M; i++) {\n if (cover_cnt[i] > 0) current_covered++;\n }\n\n // SA parameters\n const int MAX_ITER = 200000;\n double temp = 4.0;\n const double COOL = 0.9999;\n\n vector old_row(M), old_col(M), new_row(M), new_col(M);\n\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int r = dist(rng) % N;\n int c_pos = dist(rng) % N;\n char old_ch = grid[r][c_pos];\n char new_ch = 'A' + dist(rng);\n\n fill(old_row.begin(), old_row.end(), 0);\n fill(old_col.begin(), old_col.end(), 0);\n fill(new_row.begin(), new_row.end(), 0);\n fill(new_col.begin(), new_col.end(), 0);\n\n // old row\n fill_seq_row(r, seq_arr, double_len);\n ac.run_on_arr(seq_arr, double_len, old_row);\n\n // old col\n fill_seq_col(c_pos, seq_arr, double_len);\n ac.run_on_arr(seq_arr, double_len, old_col);\n\n // set new\n grid[r][c_pos] = new_ch;\n\n // new row\n fill_seq_row(r, seq_arr, double_len);\n ac.run_on_arr(seq_arr, double_len, new_row);\n\n // new col\n fill_seq_col(c_pos, seq_arr, double_len);\n ac.run_on_arr(seq_arr, double_len, new_col);\n\n // compute proposed\n int new_c = current_covered;\n for (int i = 0; i < M; i++) {\n int d = 0;\n if (old_row[i]) d--;\n if (old_col[i]) d--;\n if (new_row[i]) d++;\n if (new_col[i]) d++;\n int newcnt = cover_cnt[i] + d;\n bool was = cover_cnt[i] > 0;\n bool will = newcnt > 0;\n if (was && !will) new_c--;\n else if (!was && will) new_c++;\n }\n\n bool accept = false;\n int delta = new_c - current_covered;\n if (delta > 0) {\n accept = true;\n } else if (delta == 0) {\n accept = (dist(rng) % 100 < 10); // sometimes accept flat\n } else {\n double prob = exp(delta / temp);\n if (uniform_real_distribution(0,1)(rng) < prob) accept = true;\n }\n\n if (accept) {\n // update cnt\n for (int i = 0; i < M; i++) {\n int d = 0;\n if (old_row[i]) d--;\n if (old_col[i]) d--;\n if (new_row[i]) d++;\n if (new_col[i]) d++;\n cover_cnt[i] += d;\n }\n current_covered = new_c;\n } else {\n grid[r][c_pos] = old_ch;\n }\n\n temp *= COOL;\n if (temp < 0.001) temp = 0.001;\n }\n\n // output\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << grid[i][j];\n }\n cout << endl;\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\nusing ll = long long;\nconst ll INF = 1LL << 60;\n\nint main() {\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n int cost[69][69];\n memset(cost, 0, sizeof(cost));\n vector> all_roads;\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n all_roads.emplace_back(i, j);\n }\n int hofs[69][69];\n int vofs[69][69];\n memset(hofs, -1, sizeof(hofs));\n memset(vofs, -1, sizeof(vofs));\n vector>> hsegs, vsegs;\n int nh = 0, nv = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N;) {\n if (grid[i][j] == '#') {\n j++;\n continue;\n }\n auto& seg = hsegs.emplace_back();\n while (j < N && grid[i][j] != '#') {\n hofs[i][j] = nh;\n seg.emplace_back(i, j);\n j++;\n }\n nh++;\n }\n }\n for (int j = 0; j < N; j++) {\n for (int i = 0; i < N;) {\n if (grid[i][j] == '#') {\n i++;\n continue;\n }\n auto& seg = vsegs.emplace_back();\n while (i < N && grid[i][j] != '#') {\n vofs[i][j] = nv;\n seg.emplace_back(i, j);\n i++;\n }\n nv++;\n }\n }\n bool cellcov[69][69] = {};\n if (hofs[si][sj] != -1) {\n int h = hofs[si][sj];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[si][sj];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n }\n vector> targets;\n auto count_remain = [&]() {\n int cnt = 0;\n for (auto [x, y] : all_roads)\n if (!cellcov[x][y]) cnt++;\n return cnt;\n };\n int remain = count_remain();\n while (remain > 0) {\n int maxg = 0;\n pair bp = {-1, -1};\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g > maxg) {\n maxg = g;\n bp = p;\n }\n }\n if (maxg == 0) break;\n targets.push_back(bp);\n int h = hofs[bp.first][bp.second];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[bp.first][bp.second];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n remain -= maxg;\n }\n vector> points;\n points.emplace_back(si, sj);\n for (auto tp : targets) {\n if (tp.first != si || tp.second != sj) points.push_back(tp);\n }\n int mm = points.size();\n vector> dmat(mm, vector(mm, INF));\n vector>>> par_store(\n mm, vector>>(N, vector>(N, {-1, -1})));\n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n for (int s = 0; s < mm; s++) {\n auto [sx, sy] = points[s];\n vector> dd(N, vector(N, INF));\n vector>> pr(N, vector>(N, {-1, -1}));\n dd[sx][sy] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0LL, sx, sy);\n while (!pq.empty()) {\n auto [cst, x, y] = pq.top();\n pq.pop();\n if (cst > dd[x][y]) continue;\n for (int d = 0; d < 4; d++) {\n int nx = x + di[d], ny = y + dj[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && grid[nx][ny] != '#') {\n ll nc = cst + cost[nx][ny];\n if (nc < dd[nx][ny]) {\n dd[nx][ny] = nc;\n pr[nx][ny] = {x, y};\n pq.emplace(nc, nx, ny);\n }\n }\n }\n }\n for (int p = 0; p < mm; p++) {\n auto [px, py] = points[p];\n dmat[s][p] = dd[px][py];\n }\n for (int x = 0; x < N; x++)\n for (int y = 0; y < N; y++) par_store[s][x][y] = pr[x][y];\n }\n struct Edge {\n ll c;\n int u, v;\n bool operator<(const Edge& o) const { return c < o.c; }\n };\n vector edges;\n for (int i = 0; i < mm; i++)\n for (int j = i + 1; j < mm; j++) {\n if (dmat[i][j] < INF) edges.push_back({dmat[i][j], i, j});\n }\n sort(edges.begin(), edges.end());\n vector paruf(mm);\n iota(paruf.begin(), paruf.end(), 0);\n auto findf = [&](auto&& self, int x) -> int {\n return paruf[x] == x ? x : paruf[x] = self(self, paruf[x]);\n };\n auto unionf = [&](int x, int y) {\n x = findf(findf, x);\n y = findf(findf, y);\n if (x != y) paruf[x] = y;\n };\n vector> adj(mm);\n for (auto& e : edges) {\n if (findf(findf, e.u) != findf(findf, e.v)) {\n unionf(e.u, e.v);\n adj[e.u].push_back(e.v);\n adj[e.v].push_back(e.u);\n }\n }\n vector euler_t;\n function dfs_e = [&](int u, int p) {\n euler_t.push_back(u);\n for (int v : adj[u])\n if (v != p) {\n dfs_e(v, u);\n euler_t.push_back(u);\n }\n };\n dfs_e(0, -1);\n vector path(mm);\n vector viss(mm, false);\n int cntv = 0;\n for (int nd : euler_t) {\n if (!viss[nd]) {\n viss[nd] = true;\n path[cntv++] = nd;\n }\n }\n for (int iter = 0; iter < 5; iter++) {\n bool imp = false;\n for (int i = 1; i < mm; i++) {\n for (int j = i + 1; j < mm; j++) {\n if (min(abs(i - j), mm - abs(i - j)) <= 1) continue;\n int pa = (i - 1 + mm) % mm;\n int na = (i + 1) % mm;\n int pb = (j - 1 + mm) % mm;\n int nb = (j + 1) % mm;\n ll oldd = dmat[path[pa]][path[i]] + dmat[path[i]][path[na]] +\n dmat[path[pb]][path[j]] + dmat[path[j]][path[nb]];\n ll newd = dmat[path[pa]][path[j]] + dmat[path[j]][path[na]] +\n dmat[path[pb]][path[i]] + dmat[path[i]][path[nb]];\n if (newd < oldd) {\n swap(path[i], path[j]);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n string route = \"\";\n for (int k = 0; k < mm; k++) {\n int fid = path[k];\n int tid = path[(k + 1) % mm];\n if (fid == tid) continue;\n auto [sx, sy] = points[fid];\n auto [tx, ty] = points[tid];\n vector subm;\n int cx = tx, cy = ty;\n while (cx != sx || cy != sy) {\n auto [px, py] = par_store[fid][cx][cy];\n if (px == -1) break;\n int dx = cx - px;\n int dy = cy - py;\n char mv;\n if (dx == -1) mv = 'U';\n else if (dx == 1) mv = 'D';\n else if (dy == -1) mv = 'L';\n else if (dy == 1) mv = 'R';\n else break;\n subm.push_back(mv);\n cx = px;\n cy = py;\n }\n reverse(subm.begin(), subm.end());\n for (char c : subm) route += c;\n }\n cout << route << endl;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n vector> difficulty(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> difficulty[i][k];\n }\n }\n vector> adj(N);\n vector prereq_count(N, 0);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--;\n v--;\n adj[u].push_back(v);\n prereq_count[v]++;\n }\n vector longest_chain(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n longest_chain[i] = 1;\n for (int v : adj[i]) {\n longest_chain[i] = max(longest_chain[i], 1 + longest_chain[v]);\n }\n }\n vector> est_s(M, vector(K, 0));\n vector status(N, 0); // 0 not, 1 prog, 2 done\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector workload(M, 0);\n int day = 0;\n auto estimate = [&](int task, int mem) -> int {\n int w = 0;\n for (int k = 0; k < K; k++) {\n w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n return w == 0 ? 1 : w;\n };\n while (true) {\n day++;\n vector free_m;\n for (int j = 0; j < M; j++)\n if (current_task[j] == -1) free_m.push_back(j);\n vector ready;\n for (int i = 0; i < N; i++) {\n if (status[i] == 0 && prereq_count[i] == 0) ready.push_back(i);\n }\n vector> assigns; // mem, task\n set avail_free(free_m.begin(), free_m.end());\n sort(ready.begin(), ready.end(), [&](int a, int b) {\n return longest_chain[a] > longest_chain[b] ||\n (longest_chain[a] == longest_chain[b] && a < b);\n });\n for (int rid = 0; rid < ready.size(); rid++) {\n if (avail_free.empty()) break;\n int ta = ready[rid];\n int best_mem = -1;\n int best_et = INT_MAX;\n int best_wl = INT_MAX;\n for (int jm : avail_free) {\n int et = estimate(ta, jm);\n int wl = workload[jm];\n if (et < best_et ||\n (et == best_et &&\n (wl < best_wl || (wl == best_wl && jm < best_mem)))) {\n best_et = et;\n best_wl = wl;\n best_mem = jm;\n }\n }\n if (best_mem != -1) {\n assigns.emplace_back(best_mem, ta);\n avail_free.erase(best_mem);\n workload[best_mem] += best_et;\n }\n }\n // output\n cout << assigns.size();\n for (auto [jm, ta] : assigns) {\n cout << \" \" << (jm + 1) << \" \" << (ta + 1);\n }\n cout << endl << flush;\n // set assignments\n for (auto [jm, ta] : assigns) {\n current_task[jm] = ta;\n start_day[jm] = day;\n status[ta] = 1;\n }\n // read\n int ncomp;\n cin >> ncomp;\n if (ncomp == -1) {\n break;\n }\n vector comps(ncomp);\n for (int i = 0; i < ncomp; i++) {\n cin >> comps[i];\n }\n for (int cf : comps) {\n int mem = cf - 1;\n if (current_task[mem] == -1) continue;\n int task = current_task[mem];\n int t = day - start_day[mem] + 1;\n if (t == 1) {\n for (int k = 0; k < K; k++) {\n est_s[mem][k] = max(est_s[mem][k], difficulty[task][k]);\n }\n }\n status[task] = 2;\n current_task[mem] = -1;\n for (int v : adj[task]) {\n prereq_count[v]--;\n }\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\nint manh(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\nbool is_valid(const vector& perm, int n) {\n int m = 2 * n;\n vector pos(m);\n for (int i = 0; i < m; i++) pos[perm[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) return false;\n }\n return true;\n}\n\nint calc_cost(const vector& perm, const vector& pts, Point C, int n) {\n int m = 2 * n;\n if (perm.size() != m) return INT_MAX;\n int cost = manh(C, pts[perm[0]]);\n for (int i = 0; i < m - 1; i++) {\n cost += manh(pts[perm[i]], pts[perm[i + 1]]);\n }\n cost += manh(pts[perm.back()], C);\n return cost;\n}\n\npair> greedy_cost_and_path(const vector& S, Point C, const vector& allP, const vector& allD, int n) {\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n vector mate(2 * n);\n for (int i = 0; i < n; i++) {\n mate[i] = n + i;\n mate[n + i] = i;\n }\n vector visited(2 * n, false);\n vector feasible(2 * n, false);\n for (int i = 0; i < n; i++) feasible[i] = true;\n vector perm;\n perm.reserve(2 * n);\n Point curr = C;\n int total = 0;\n for (int step = 0; step < 2 * n; step++) {\n int best_d = INT_MAX;\n int best_idx = -1;\n for (int i = 0; i < 2 * n; i++) {\n if (!visited[i] && feasible[i]) {\n int dd = manh(curr, pts[i]);\n if (dd < best_d) {\n best_d = dd;\n best_idx = i;\n }\n }\n }\n if (best_idx == -1) break;\n total += best_d;\n perm.push_back(best_idx);\n visited[best_idx] = true;\n curr = pts[best_idx];\n int m = mate[best_idx];\n if (!visited[m]) feasible[m] = true;\n }\n total += manh(curr, C);\n return {total, perm};\n}\n\nvoid optimize_perm(vector& best_perm, int& best_cost, const vector& S, Point C, const vector& allP, const vector& allD, mt19937& rng) {\n int n = S.size();\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n auto [gcost, gperm] = greedy_cost_and_path(S, C, allP, allD, n);\n vector current_perm = gperm;\n int curr_cost = gcost;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n double T = 20000.0;\n uniform_int_distribution dpos(0, 2 * n - 1);\n uniform_real_distribution dprob(0.0, 1.0);\n for (int it = 0; it < 300000; it++) {\n vector new_perm = current_perm;\n int typ = rng() % 4;\n bool can_change = false;\n if (typ == 0) { // swap two positions\n int i = dpos(rng);\n int j = dpos(rng);\n if (i != j) {\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n } else if (typ == 1) { // move / insert\n int i = dpos(rng);\n int j = dpos(rng);\n if (i != j) {\n int val = new_perm[i];\n new_perm.erase(new_perm.begin() + i);\n if (j > i) j--;\n new_perm.insert(new_perm.begin() + j, val);\n can_change = true;\n }\n } else if (typ == 2) { // reverse segment\n int i = dpos(rng);\n int j = dpos(rng);\n if (i > j) swap(i, j);\n if (i != j) {\n reverse(new_perm.begin() + i, new_perm.begin() + j + 1);\n can_change = true;\n }\n } else { // adjacent swap\n int i = dpos(rng);\n int j = (i + 1) % (2 * n);\n if (i != j) {\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n }\n if (can_change && is_valid(new_perm, n)) {\n int new_cost = calc_cost(new_perm, pts, C, n);\n double delta = new_cost - curr_cost;\n if (delta < 0 || (T > 0 && exp(-delta / T) > dprob(rng))) {\n current_perm = new_perm;\n curr_cost = new_cost;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n }\n }\n T *= 0.99995;\n }\n}\n\nint main() {\n vector allP(1000), allD(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> allP[i].x >> allP[i].y >> allD[i].x >> allD[i].y;\n }\n Point C = {400, 400};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n vector centers;\n centers.push_back(C);\n int step = 80;\n for (int cx = 80; cx < 720; cx += step) {\n for (int cy = 80; cy < 720; cy += step) {\n centers.push_back({cx, cy});\n }\n }\n centers.push_back({200,200});\n centers.push_back({200,600});\n centers.push_back({600,200});\n centers.push_back({600,600});\n centers.push_back({400,200});\n centers.push_back({400,600});\n centers.push_back({200,400});\n centers.push_back({600,400});\n int n = 50;\n int best_T = INT_MAX;\n vector best_S;\n for (auto& cen : centers) {\n vector> dists;\n for (int i = 0; i < 1000; i++) {\n Point mid = {(allP[i].x + allD[i].x) / 2, (allP[i].y + allD[i].y) / 2};\n int dd = manh(mid, cen);\n dists.emplace_back(dd, i);\n }\n sort(dists.begin(), dists.end());\n vector S;\n for (int i = 0; i < n; i++) S.push_back(dists[i].second);\n auto [gcost, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gcost < best_T) {\n best_T = gcost;\n best_S = S;\n }\n }\n // small individual\n vector> ind_cost;\n for (int i = 0; i < 1000; i++) {\n int cc = manh(C, allP[i]) + manh(allP[i], allD[i]) + manh(allD[i], C);\n ind_cost.emplace_back(cc, i);\n }\n sort(ind_cost.begin(), ind_cost.end());\n vector S_small;\n for (int i = 0; i < n; i++) S_small.push_back(ind_cost[i].second);\n auto [gcost2, gp2] = greedy_cost_and_path(S_small, C, allP, allD, n);\n if (gcost2 < best_T) {\n best_T = gcost2;\n best_S = S_small;\n }\n // random samples\n for (int tri = 0; tri < 20; tri++) {\n vector all(1000);\n iota(all.begin(), all.end(), 0);\n shuffle(all.begin(), all.end(), rng);\n vector S(all.begin(), all.begin() + n);\n auto [gc, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gc < best_T) {\n best_T = gc;\n best_S = S;\n }\n }\n // now optimize the best_S\n vector opt_perm;\n int opt_cost = INT_MAX;\n optimize_perm(opt_perm, opt_cost, best_S, C, allP, allD, rng);\n // try some replacements\n for (int trial = 0; trial < 100; trial++) {\n uniform_int_distribution dis_in(0, n - 1);\n uniform_int_distribution dis_out(0, 999);\n vector newS = best_S;\n int in = dis_in(rng);\n int out = dis_out(rng);\n bool has = false;\n for (int s : newS) if (s == out) { has = true; break; }\n if (has) continue;\n newS[in] = out;\n auto [gc, gp] = greedy_cost_and_path(newS, C, allP, allD, n);\n if (gc < opt_cost) {\n vector new_opt_perm;\n int new_opt_cost = INT_MAX;\n optimize_perm(new_opt_perm, new_opt_cost, newS, C, allP, allD, rng);\n if (new_opt_cost < opt_cost) {\n opt_cost = new_opt_cost;\n opt_perm = new_opt_perm;\n best_S = newS;\n best_T = gc;\n }\n }\n }\n // prepare output\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[best_S[i]];\n pts[n + i] = allD[best_S[i]];\n }\n vector route;\n route.push_back(C);\n for (int t : opt_perm) {\n route.push_back(pts[t]);\n }\n route.push_back(C);\n vector chosen = best_S;\n cout << 50;\n for (int r : chosen) cout << \" \" << (r + 1);\n cout << endl;\n cout << route.size();\n for (auto p : route) cout << \" \" << p.x << \" \" << p.y;\n cout << endl;\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v, idx, d, l;\n bool backup;\n};\n\nvector edges;\nvector par;\n\nint find(int x) {\n return par[x] == x ? x : par[x] = find(par[x]);\n}\n\nbool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n par[x] = y;\n return true;\n}\n\nint main() {\n vector x(400), y(400);\n for (int i = 0; i < 400; i++) {\n cin >> x[i] >> y[i];\n }\n int M = 1995;\n edges.resize(M);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i].u = u;\n edges[i].v = v;\n edges[i].idx = i;\n edges[i].l = -1;\n edges[i].backup = false;\n double dx = x[u] - x[v];\n double dy = y[u] - y[v];\n double dist = hypot(dx, dy);\n edges[i].d = (int)round(dist);\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].d < edges[b].d;\n });\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n int cnt = 0;\n for (int i : ord) {\n if (unite(edges[i].u, edges[i].v)) {\n edges[i].backup = true;\n cnt++;\n if (cnt == 399) break;\n }\n }\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n for (int i = 0; i < M; i++) {\n int l;\n cin >> l;\n edges[i].l = l;\n int u = edges[i].u, v = edges[i].v;\n int pu = find(u), pv = find(v);\n int ans = 0;\n if (pu != pv) {\n if (edges[i].backup) {\n ans = 1;\n } else {\n if (l <= 2 * edges[i].d) {\n ans = 1;\n }\n }\n if (ans == 1) {\n unite(u, v);\n }\n }\n cout << ans << endl;\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n cin >> 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 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 const int W = 30;\n vector> is_blocked(W + 2, vector(W + 2, false));\n vector> human_pos(M);\n for (int i = 0; i < M; i++) human_pos[i] = {hx[i], hy[i]};\n vector> pet_pos(N);\n for (int i = 0; i < N; i++) pet_pos[i] = {px[i], py[i]};\n vector dx = {-1, 1, 0, 0};\n vector dy = {0, 0, -1, 1};\n char move_char[4] = {'U', 'D', 'L', 'R'};\n char block_char[4] = {'u', 'd', 'l', 'r'};\n auto valid = [&](int x, int y) {\n return x >= 1 && x <= W && y >= 1 && y <= W && !is_blocked[x][y];\n };\n auto is_occupied_func = nullptr; // defined per turn\n vector> stand_pos, wall_pos;\n int wall_size = 20;\n int right_c = wall_size + 1;\n int bottom_r = wall_size + 1;\n for (int r = 1; r <= wall_size; r++) {\n stand_pos.emplace_back(r, wall_size);\n wall_pos.emplace_back(r, right_c);\n }\n for (int c = 1; c <= wall_size; c++) {\n stand_pos.emplace_back(wall_size, c);\n wall_pos.emplace_back(bottom_r, c);\n }\n set> wall_set(wall_pos.begin(), wall_pos.end());\n mt19937 rng(42);\n for (int turn = 0; turn < 300; turn++) {\n vector> next_hpos(M);\n string actions_str(M, '.');\n set> targeted_moves;\n set> this_turn_blocked;\n vector> is_occupied(W + 2, vector(W + 2, false));\n for (int i = 0; i < N; i++) {\n auto [x, y] = pet_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n for (int i = 0; i < M; i++) {\n auto [x, y] = human_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n auto can_block = [&](int tx, int ty) {\n if (!valid(tx, ty) || is_occupied[tx][ty]) return false;\n for (int d = 0; d < 4; d++) {\n int px = tx + dx[d];\n int py = ty + dy[d];\n if (valid(px, py) && is_occupied[px][py]) return false;\n }\n return true;\n };\n vector assigned_idx(M, -1);\n vector used_stand(stand_pos.size(), false);\n if (turn >= 150) {\n for (int i = 0; i < M; i++) {\n int best_j = -1;\n int best_d = INT_MAX;\n for (int j = 0; j < (int)stand_pos.size(); j++) {\n auto [wx, wy] = wall_pos[j];\n if (is_blocked[wx][wy]) continue;\n if (used_stand[j]) continue;\n auto [sx, sy] = stand_pos[j];\n int dist = abs(human_pos[i].first - sx) + abs(human_pos[i].second - sy);\n if (dist < best_d) {\n best_d = dist;\n best_j = j;\n }\n }\n if (best_j != -1) {\n assigned_idx[i] = best_j;\n used_stand[best_j] = true;\n }\n }\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for (int k = 0; k < M; k++) {\n int i = ord[k];\n auto [x, y] = human_pos[i];\n bool did = false;\n int t_idx = assigned_idx[i];\n if (turn < 150 || t_idx == -1) {\n // gather to center\n int cx = 15, cy = 15;\n vector> candidates;\n if (x < cx && valid(x + 1, y)) candidates.emplace_back(1, 'D');\n if (x > cx && valid(x - 1, y)) candidates.emplace_back(0, 'U');\n if (y < cy && valid(x, y + 1)) candidates.emplace_back(3, 'R');\n if (y > cy && valid(x, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n } else {\n auto [tx, ty] = stand_pos[t_idx];\n if (x == tx && y == ty) {\n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int bx = x + dx[d];\n int by = y + dy[d];\n if (wall_set.count({bx, by}) && can_block(bx, by)) {\n actions_str[i] = block_char[d];\n this_turn_blocked.insert({bx, by});\n is_blocked[bx][by] = true;\n next_hpos[i] = {x, y};\n did = true;\n break;\n }\n }\n } else {\n vector> candidates;\n if (x < tx && valid(x + 1, ty)) candidates.emplace_back(1, 'D');\n if (x > tx && valid(x - 1, ty)) candidates.emplace_back(0, 'U');\n if (y < ty && valid(tx, y + 1)) candidates.emplace_back(3, 'R');\n if (y > ty && valid(tx, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n }\n }\n if (!did) {\n actions_str[i] = '.';\n next_hpos[i] = {x, y};\n }\n }\n // output\n cout << actions_str << endl;\n cout.flush();\n // read pet moves\n vector pet_moves(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n // update human_pos\n for (int i = 0; i < M; i++) {\n human_pos[i] = next_hpos[i];\n }\n // update pet_pos\n for (int i = 0; i < N; i++) {\n int x = pet_pos[i].first, y = pet_pos[i].second;\n string mv = pet_moves[i];\n for (char c : mv) {\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n if (d != -1) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (valid(nx, ny)) {\n x = nx;\n y = ny;\n }\n }\n }\n pet_pos[i] = {x, y};\n }\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\ndouble compute_ES(const vector& sseq, double pp, int ssr, int ssc, int ttr, int ttc, int HH[20][19], int VV[19][20]) {\n double prb[20][20] = {};\n prb[ssr][ssc] = 1.0;\n double ES = 0.0;\n int LL = sseq.size();\n for (int tt = 0; tt < LL; tt++) {\n double rch = 0.0;\n double np[20][20] = {};\n char dr = sseq[tt];\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double prr = prb[i][j];\n if (prr < 1e-20 || (i == ttr && j == ttc)) continue;\n np[i][j] += prr * pp;\n int nii = i, njj = j;\n bool cm = false;\n if (dr == 'D' && i < 19 && VV[i][j] == 0) { nii++; cm = true; }\n else if (dr == 'U' && i > 0 && VV[i - 1][j] == 0) { nii--; cm = true; }\n else if (dr == 'R' && j < 19 && HH[i][j] == 0) { njj++; cm = true; }\n else if (dr == 'L' && j > 0 && HH[i][j - 1] == 0) { njj--; cm = true; }\n if (cm) {\n if (nii == ttr && njj == ttc) {\n rch += prr * (1 - pp);\n } else {\n np[nii][njj] += prr * (1 - pp);\n }\n } else {\n np[i][j] += prr * (1 - pp);\n }\n }\n }\n ES += rch * (401.0 - (tt + 1));\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prb[i][j] = np[i][j];\n }\n return ES;\n}\n\nint main() {\n int sr, sc, tr, tc;\n double p;\n cin >> sr >> sc >> tr >> tc >> p;\n int h[20][19];\n for (int i = 0; i < 20; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 19; j++) h[i][j] = s[j] - '0';\n }\n int v[19][20];\n for (int i = 0; i < 19; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 20; j++) v[i][j] = s[j] - '0';\n }\n const int INF = 10000;\n int dist[20][20];\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) dist[i][j] = INF;\n dist[tr][tc] = 0;\n queue> q;\n q.push({tr, tc});\n while (!q.empty()) {\n auto cur = q.front();\n q.pop();\n int x = cur.first, y = cur.second;\n int d = dist[x][y];\n if (y < 19 && h[x][y] == 0) {\n int nx = x, ny = y + 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (y > 0 && h[x][y - 1] == 0) {\n int nx = x, ny = y - 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x < 19 && v[x][y] == 0) {\n int nx = x + 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x > 0 && v[x - 1][y] == 0) {\n int nx = x - 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) if (dist[i][j] == INF) dist[i][j] = 50;\n double prob[20][20];\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = 0.0;\n prob[sr][sc] = 1.0;\n vector seq;\n char dirs[4] = {'D', 'R', 'L', 'U'};\n for (int stp = 0; stp < 200; stp++) {\n double cur_r = 0.0;\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n cur_r += prob[i][j];\n }\n if (cur_r < 1e-12) break;\n char bestc = ' ';\n double besteds = 1e100;\n double bestreach = -1;\n for (int di = 0; di < 4; di++) {\n char dir = dirs[di];\n double reach = 0.0;\n double newp[20][20] = {};\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (dir == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (dir == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (dir == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (dir == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n double eds = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n eds += newp[i][j] * dist[i][j];\n }\n }\n bool better = false;\n if (eds < besteds - 1e-9) better = true;\n else if (fabs(eds - besteds) < 1e-9 && reach > bestreach + 1e-9) better = true;\n if (better) {\n besteds = eds;\n bestreach = reach;\n bestc = dir;\n }\n }\n if (bestc == ' ') break;\n double newp[20][20] = {};\n double reach = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (bestc == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (bestc == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (bestc == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (bestc == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = newp[i][j];\n seq.push_back(bestc);\n }\n double greedy_E = compute_ES(seq, p, sr, sc, tr, tc, h, v);\n vector best_seq = seq;\n double best_E = greedy_E;\n srand(time(NULL));\n int L = best_seq.size();\n if (L > 0) {\n for (int trial = 0; trial < 500; trial++) {\n int pos = rand() % L;\n char original = best_seq[pos];\n for (int d = 0; d < 4; d++) {\n char new_dir = dirs[d];\n if (new_dir == original) continue;\n best_seq[pos] = new_dir;\n double newE = compute_ES(best_seq, p, sr, sc, tr, tc, h, v);\n if (newE > best_E + 1e-9) {\n best_E = newE;\n } else {\n best_seq[pos] = original;\n }\n }\n }\n }\n string ans = \"\";\n for (char c : best_seq) ans += c;\n cout << ans << endl;\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30;\nconst int W = 30;\nconst int D = 4;\nconst int SZ = H * W * D;\n\nint TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\nint DI[4] = {0, -1, 0, 1};\nint DJ[4] = {-1, 0, 1, 0};\n\nstatic int current_time = 0;\nstatic int timestamp[SZ];\nstatic int pstep[SZ];\nstatic bool vis[SZ];\n\nint get_eff(int o, int r) {\n if (o < 4) return (o + r) % 4;\n if (o == 4) return (r % 2 ? 5 : 4);\n if (o == 5) return (r % 2 ? 4 : 5);\n if (o == 6) return (r % 2 ? 7 : 6);\n return (r % 2 ? 6 : 7);\n}\n\nlong long compute_cycles(int t[H][W], int r[H][W], int& len1, int& len2) {\n if (current_time > 2000000000) {\n current_time = 0;\n memset(timestamp, 0, sizeof(timestamp));\n }\n int eff[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n eff[i][j] = get_eff(t[i][j], r[i][j]);\n }\n }\n static int next_state[SZ];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n for (int d = 0; d < D; d++) {\n int idx = ((i * W + j) * D + d);\n int d2 = TO[eff[i][j]][d];\n if (d2 == -1) {\n next_state[idx] = -1;\n continue;\n }\n int ni = i + DI[d2];\n int nj = j + DJ[d2];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) {\n next_state[idx] = -1;\n continue;\n }\n int nd = (d2 + 2) % 4;\n next_state[idx] = ((ni * W + nj) * D + nd);\n }\n }\n }\n memset(vis, 0, sizeof(vis));\n len1 = 0;\n len2 = 0;\n for (int s = 0; s < SZ; s++) {\n if (!vis[s]) {\n if (next_state[s] == -1) {\n vis[s] = true;\n continue;\n }\n vector path;\n int cur = s;\n int this_t = ++current_time;\n timestamp[cur] = this_t;\n pstep[cur] = 0;\n path.push_back(cur);\n bool foundc = false;\n int cst = 0;\n int nxt;\n while (true) {\n nxt = next_state[cur];\n if (nxt == -1) break;\n if (vis[nxt]) break;\n if (timestamp[nxt] == this_t) {\n foundc = true;\n cst = pstep[nxt];\n break;\n }\n if (path.size() > 4000) break;\n path.push_back(nxt);\n timestamp[nxt] = this_t;\n pstep[nxt] = path.size() - 1;\n cur = nxt;\n }\n if (foundc) {\n int cl = path.size() - cst;\n if (cl > len1) {\n len2 = len1;\n len1 = cl;\n } else if (cl > len2) {\n len2 = cl;\n }\n }\n for (int p : path) {\n vis[p] = true;\n }\n }\n }\n if (len1 > 0 && len2 > 0) return 1LL * len1 * len2;\n return 0;\n}\n\nint main() {\n int orig[H][W];\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n orig[i][j] = s[j] - '0';\n }\n }\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution randr(0, 3);\n int cur_r[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n cur_r[i][j] = randr(rng);\n }\n }\n int cl1, cl2;\n long long cur_sc = compute_cycles(orig, cur_r, cl1, cl2);\n long long best_sc = cur_sc;\n int best_r[H][W];\n memcpy(best_r, cur_r, sizeof(best_r));\n const int MAX_ITER = 30000;\n double temp = 50000.0;\n double cooling = 0.9998;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int new_r[H][W];\n memcpy(new_r, cur_r, sizeof(cur_r));\n int nmut = randr(rng) % 5 + 1;\n for (int k = 0; k < nmut; k++) {\n int pos = rng() % (H * W);\n int i = pos / W;\n int j = pos % W;\n int delta = (randr(rng) % 3) + 1;\n new_r[i][j] = (new_r[i][j] + delta) % 4;\n }\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n long long delta = new_sc - cur_sc;\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if ((double)rng() / rng.max() < prob) accept = true;\n }\n if (accept) {\n memcpy(cur_r, new_r, sizeof(cur_r));\n cur_sc = new_sc;\n if (cur_sc > best_sc) {\n best_sc = cur_sc;\n memcpy(best_r, cur_r, sizeof(best_r));\n }\n }\n temp *= cooling;\n }\n // local hill climbing\n int temp_r[H][W];\n memcpy(temp_r, best_r, sizeof(best_r));\n long long temp_sc = best_sc;\n bool improved = true;\n int passes = 0;\n while (improved && passes < 5) {\n improved = false;\n passes++;\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n int oldr = temp_r[i][j];\n long long best_this_sc = temp_sc;\n int best_this_r = oldr;\n for (int nr = 0; nr < 4; nr++) {\n temp_r[i][j] = nr;\n int tl1, tl2;\n long long sc = compute_cycles(orig, temp_r, tl1, tl2);\n if (sc > best_this_sc) {\n best_this_sc = sc;\n best_this_r = nr;\n }\n }\n temp_r[i][j] = best_this_r;\n if (best_this_sc > temp_sc) {\n temp_sc = best_this_sc;\n improved = true;\n }\n }\n }\n }\n if (temp_sc > best_sc) {\n best_sc = temp_sc;\n memcpy(best_r, temp_r, sizeof(best_r));\n }\n string ans = \"\";\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n ans += '0' + best_r[i][j];\n }\n }\n cout << ans << endl;\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint main() {\n srand(time(0));\n int N, Tmax;\n cin >> N >> Tmax;\n vector> init_board(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 char c = s[j];\n if(c >= '0' && c <= '9') init_board[i][j] = c - '0';\n else init_board[i][j] = 10 + (c - 'a');\n }\n }\n pair init_blank = {-1, -1};\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(init_board[i][j] == 0) init_blank = {i, j};\n int fullS = N * N - 1;\n int ddx[4] = {-1, 1, 0, 0};\n int ddy[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n auto compute_S = [&](const vector>& b) -> int {\n int M = N * N;\n vector parent(M), sz(M, 1), has_cyc(M, 0);\n for(int i = 0; i < M; i++) parent[i] = i;\n auto find = [&](auto&& self, int x) -> int {\n if(parent[x] != x) parent[x] = self(self, parent[x]);\n return parent[x];\n };\n auto unite = [&](int x, int y) {\n int px = find(find, x), py = find(find, y);\n if(px == py) {\n has_cyc[px] = 1;\n return;\n }\n if(sz[px] < sz[py]) swap(px, py);\n parent[py] = px;\n sz[px] += sz[py];\n if(has_cyc[py]) has_cyc[px] = 1;\n };\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n int t1 = b[i][j], t2 = b[i+1][j];\n if(t1 != 0 && t2 != 0 && (t1 & 8) && (t2 & 2)) {\n unite(i*N + j, (i+1)*N + j);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n int t1 = b[i][j], t2 = b[i][j+1];\n if(t1 != 0 && t2 != 0 && (t1 & 4) && (t2 & 1)) {\n unite(i*N + j, i*N + j + 1);\n }\n }\n int maxs = 0;\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(b[i][j] != 0) {\n int rp = find(find, i*N + j);\n if(!has_cyc[rp]) maxs = max(maxs, sz[rp]);\n }\n return maxs;\n };\n auto compute_M = [&](const vector>& b) -> int {\n int cnt = 0;\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n if(b[i][j] && b[i+1][j] && (b[i][j] & 8) && (b[i+1][j] & 2)) cnt++;\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n if(b[i][j] && b[i][j+1] && (b[i][j] & 4) && (b[i][j+1] & 1)) cnt++;\n }\n return cnt;\n };\n vector> board = init_board;\n pair blankp = init_blank;\n int bx = blankp.first, by = blankp.second;\n string moves = \"\";\n int max_achieved_S = compute_S(board);\n string best_sequence = \"\";\n int best_k = 0;\n for(int step = 0; step < Tmax; step++) {\n if(moves.length() >= Tmax) break;\n if(max_achieved_S == fullS) break;\n bool perturb = (rand() % 100 < 5);\n int chosen_d = -1;\n if(perturb) {\n vector cands;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx >= 0 && nx < N && ny >= 0 && ny < N) cands.push_back(d);\n }\n if(!cands.empty()) chosen_d = cands[rand() % cands.size()];\n } else {\n int best_future = -1, bm = -1, bd = -1;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n // sim first\n swap(board[bx][by], board[nx][ny]);\n int inter_S = compute_S(board);\n int this_future = inter_S;\n int thisM = compute_M(board);\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n int s2 = compute_S(board);\n int m2 = compute_M(board);\n if(s2 > this_future || (s2 == this_future && m2 > thisM)) {\n this_future = s2;\n thisM = m2;\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n if(this_future > best_future || (this_future == best_future && thisM > bm)) {\n best_future = this_future;\n bm = thisM;\n bd = d;\n }\n swap(board[bx][by], board[nx][ny]);\n }\n chosen_d = bd;\n }\n if(chosen_d == -1) break;\n int nx = bx + ddx[chosen_d], ny = by + ddy[chosen_d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n bx = nx; by = ny;\n moves += dchar[chosen_d];\n int ns = compute_S(board);\n int nk = moves.length();\n if(ns > max_achieved_S || (ns == max_achieved_S && nk < best_k)) {\n max_achieved_S = ns;\n best_sequence = moves;\n best_k = nk;\n }\n }\n if(max_achieved_S < fullS && best_sequence.empty()) {\n // use initial if better but already set\n }\n cout << best_sequence << endl;\n}","ahc012":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Line {\n ll px, py, qx, qy;\n};\n\nint main() {\n int N, K;\n cin >> N >> K;\n vector A(11, 0);\n for (int d = 1; d <= 10; d++) {\n cin >> A[d];\n }\n vector> pts(N);\n for (auto& p : pts) {\n cin >> p.first >> p.second;\n }\n vector all_idx(N);\n iota(all_idx.begin(), all_idx.end(), 0);\n vector> parts = {all_idx};\n vector chosen;\n auto compute_cross = [&](const Line& l, int id) -> ll {\n auto [x, y] = pts[id];\n ll a = x - l.px;\n ll b = y - l.py;\n ll c = l.qx - l.px;\n ll d = l.qy - l.py;\n return a * d - b * c;\n };\n auto calc_sat = [&](const vector>& prts) -> int {\n vector fr(5501, 0);\n for (auto& p : prts) {\n size_t s = p.size();\n if (s < 5501) fr[s]++;\n }\n int s = 0;\n for (int d = 1; d <= 10; d++) {\n s += min(A[d], fr[d]);\n }\n return s;\n };\n int cur_sat = calc_sat(parts);\n mt19937 rng(42);\n uniform_real_distribution theta_dist(0.0, 2 * 3.141592653589793);\n for (int iter = 0; iter < 100 && (int)chosen.size() < K; iter++) {\n vector large_g_idx;\n for (int i = 0; i < (int)parts.size(); i++) {\n if ((int)parts[i].size() > 10) large_g_idx.push_back(i);\n }\n if (large_g_idx.empty()) break;\n sort(large_g_idx.begin(), large_g_idx.end(), [&](int aa, int bb) {\n return parts[aa].size() > parts[bb].size();\n });\n int num_target = min(1, (int)large_g_idx.size());\n int best_new = cur_sat;\n Line best_l;\n bool improved = false;\n for (int tg = 0; tg < num_target; tg++) {\n int gidx = large_g_idx[tg];\n auto& group = parts[gidx];\n int gs = group.size();\n for (int th = 0; th < 15; th++) {\n double theta = theta_dist(rng);\n double nx = cos(theta);\n double ny = sin(theta);\n vector> projs;\n projs.reserve(gs);\n for (int id : group) {\n double pr = pts[id].first * nx + pts[id].second * ny;\n projs.emplace_back(pr, id);\n }\n sort(projs.begin(), projs.end());\n for (int m = 1; m <= min(10, gs - 1); m++) {\n double r1 = projs[m - 1].first;\n double r2 = projs[m].first;\n if (r1 == r2) continue;\n double r = (r1 + r2) / 2.0;\n double dx = -ny;\n double dy = nx;\n double D = 1000000.0;\n double bx = r * nx;\n double by = r * ny;\n double pxd = bx + D * dx;\n double pyd = by + D * dy;\n double qxd = bx - D * dx;\n double qyd = by - D * dy;\n ll px = (ll)round(pxd);\n ll py = (ll)round(pyd);\n ll qx = (ll)round(qxd);\n ll qy = (ll)round(qyd);\n if (px == qx && py == qy) continue;\n if (abs(px) > 1000000000LL || abs(py) > 1000000000LL || abs(qx) > 1000000000LL || abs(qy) > 1000000000LL) continue;\n Line llne{px, py, qx, qy};\n vector temp_fr(5501, 0);\n bool valid = true;\n for (size_t j = 0; j < parts.size() && valid; j++) {\n ll lcnt = 0, rcnt = 0;\n auto& grp = parts[j];\n for (int id : grp) {\n ll cr = compute_cross(llne, id);\n if (cr == 0) {\n valid = false;\n break;\n }\n if (cr > 0) lcnt++;\n else rcnt++;\n }\n if (valid) {\n if (lcnt > 0) temp_fr[lcnt]++;\n if (rcnt > 0) temp_fr[rcnt]++;\n }\n }\n if (!valid) continue;\n int newsat = 0;\n for (int d = 1; d <= 10; d++) {\n newsat += min(A[d], temp_fr[d]);\n }\n if (newsat > best_new) {\n best_new = newsat;\n best_l = llne;\n improved = true;\n }\n }\n }\n }\n if (improved) {\n chosen.push_back(best_l);\n vector> new_prts;\n for (auto& grp : parts) {\n vector leftv, rightv;\n for (int id : grp) {\n ll cr = compute_cross(best_l, id);\n if (cr > 0) leftv.push_back(id);\n else rightv.push_back(id);\n }\n if (!leftv.empty()) new_prts.push_back(leftv);\n if (!rightv.empty()) new_prts.push_back(rightv);\n }\n parts = std::move(new_prts);\n cur_sat = best_new;\n } else {\n break;\n }\n }\n cout << chosen.size() << endl;\n for (auto& l : chosen) {\n cout << l.px << \" \" << l.py << \" \" << l.qx << \" \" << l.qy << endl;\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\nusing pii = pair;\n\nconst int MAXN = 65;\nbool has[MAXN][MAXN];\nbool uh[MAXN][MAXN];\nbool uv[MAXN][MAXN];\nbool udp[MAXN][MAXN];\nbool udm[MAXN][MAXN];\nint N;\n\nbool inb(int x) { return 0 <= x && x < N; }\n\nint get_w(int x, int y, int c) {\n int dx = x - c, dy = y - c;\n return dx * dx + dy * dy + 1;\n}\n\nbool is_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n return uh[y1][xx];\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n return uv[x1][yy];\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int xhigh = xlow + 1;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n return udp[xlow][y_at_low];\n } else if (dyh == -1) {\n return udm[xlow][y_at_low];\n }\n return true;\n }\n return true;\n}\n\nvoid set_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n uh[y1][xx] = true;\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n uv[x1][yy] = true;\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n udp[xlow][y_at_low] = true;\n } else if (dyh == -1) {\n udm[xlow][y_at_low] = true;\n }\n }\n}\n\nbool clean_perim(const array& corn) {\n double cx = 0, cy = 0;\n for (auto& p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs.emplace_back(ang, i);\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0 && dy != 0) {\n steps = ady;\n uy = (dy > 0 ? 1 : -1);\n } else if (dy == 0 && dx != 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n uy = (dy > 0 ? 1 : -1);\n } else return false;\n for (int k = 1; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n if (has[xx][yy]) return false;\n }\n }\n return true;\n}\n\nbool edges_free(const array& corn) {\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs(4);\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs[i] = {ang, i};\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n } else return false;\n for (int k = 0; k < steps; k++) {\n int xx1 = x1 + k * ux;\n int yy1 = y1 + k * uy;\n int xx2 = xx1 + ux;\n int yy2 = yy1 + uy;\n if (is_used_unit(xx1, yy1, xx2, yy2)) return false;\n }\n }\n return true;\n}\n\nvector> cands;\nset> seen_set;\n\nvoid add_candidate(const array& corn) {\n array sorted_c = corn;\n sort(sorted_c.begin(), sorted_c.end());\n array key;\n for (int i = 0; i < 4; i++) {\n key[2 * i] = sorted_c[i].first;\n key[2 * i + 1] = sorted_c[i].second;\n }\n if (seen_set.count(key)) return;\n seen_set.insert(key);\n cands.push_back(corn);\n}\n\nbool get_three_missing(const array& corn, pii& newp) {\n int cnt_miss = 0;\n for (auto& pt : corn) {\n if (!has[pt.first][pt.second]) {\n newp = pt;\n cnt_miss++;\n if (cnt_miss > 1) return false;\n }\n }\n return cnt_miss == 1;\n}\n\nvoid try_from_pair(pii P, pii Q) {\n int px = P.first, py = P.second, qx = Q.first, qy = Q.second;\n if (!has[px][py] || !has[qx][qy]) return;\n if (px != qx && py != qy) {\n pii R = {px, qy};\n pii S = {qx, py};\n if (!inb(R.first) || !inb(R.second) || !inb(S.first) || !inb(S.second)) return;\n int hasR = has[R.first][R.second] ? 1 : 0;\n int hasS = has[S.first][S.second] ? 1 : 0;\n if (hasR + hasS == 1) {\n array corn = {P, Q, R, S};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n int dx = qx - px;\n int dy = qy - py;\n if ((dx + dy) % 2 == 0 && (dx - dy) % 2 == 0) {\n int p = (dx + dy) / 2;\n int q = (dx - dy) / 2;\n if (p != 0 && q != 0) {\n int bx = px + p;\n int by = py + p;\n int dx_ = px + q;\n int dy_ = py - q;\n if (inb(bx) && inb(by) && inb(dx_) && inb(dy_)) {\n int qcx = px + p + q;\n int qcy = py + p - q;\n if (qcx == qx && qcy == qy) {\n array corn = {{{px, py}, {bx, by}, {qx, qy}, {dx_, dy_}}};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n }\n }\n}\n\nint main() {\n int M;\n cin >> N >> M;\n vector init_dots(M);\n for (int i = 0; i < M; i++) {\n cin >> init_dots[i].first >> init_dots[i].second;\n }\n memset(has, 0, sizeof(has));\n memset(uh, 0, sizeof(uh));\n memset(uv, 0, sizeof(uv));\n memset(udp, 0, sizeof(udp));\n memset(udm, 0, sizeof(udm));\n for (auto& pt : init_dots) {\n has[pt.first][pt.second] = true;\n }\n int C = (N - 1) / 2;\n vector dots_list = init_dots;\n cands.clear();\n seen_set.clear();\n for (size_t i = 0; i < dots_list.size(); i++) {\n for (size_t j = i + 1; j < dots_list.size(); j++) {\n try_from_pair(dots_list[i], dots_list[j]);\n try_from_pair(dots_list[j], dots_list[i]);\n }\n }\n vector> answer_ops;\n for (int iter = 0; iter < 20000; iter++) {\n int best_w = -1;\n int best_idx = -1;\n pii best_new = {-1, -1};\n for (int ci = 0; ci < (int)cands.size(); ci++) {\n auto& corn = cands[ci];\n pii np;\n if (!get_three_missing(corn, np)) continue;\n if (has[np.first][np.second]) continue;\n if (!clean_perim(corn) || !edges_free(corn)) continue;\n int ww = get_w(np.first, np.second, C);\n if (ww > best_w) {\n best_w = ww;\n best_new = np;\n best_idx = ci;\n }\n }\n if (best_idx == -1) break;\n auto corn = cands[best_idx];\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n angs.emplace_back(atan2(corn[i].second - cy, corn[i].first - cx), i);\n }\n sort(angs.begin(), angs.end());\n vector ord;\n for (auto& a : angs) ord.push_back(corn[a.second]);\n int new_idx = -1;\n for (int i = 0; i < 4; i++)\n if (ord[i] == best_new) {\n new_idx = i;\n break;\n }\n if (new_idx == -1) continue;\n array op;\n op[0] = best_new.first;\n op[1] = best_new.second;\n for (int k = 0; k < 3; k++) {\n pii nxt = ord[(new_idx + 1 + k) % 4];\n op[2 + k * 2] = nxt.first;\n op[2 + k * 2 + 1] = nxt.second;\n }\n answer_ops.push_back(op);\n has[best_new.first][best_new.second] = true;\n dots_list.push_back(best_new);\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n }\n for (int k = 0; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n set_used_unit(xx, yy, xx + ux, yy + uy);\n }\n }\n for (auto& Q : dots_list) {\n if (Q == best_new) continue;\n try_from_pair(best_new, Q);\n try_from_pair(Q, best_new);\n }\n }\n cout << answer_ops.size() << endl;\n for (auto& arr : answer_ops) {\n for (int i = 0; i < 8; i++) {\n cout << arr[i];\n if (i < 7) cout << \" \";\n else cout << endl;\n }\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nlong long calc_score(const vector>& grid) {\n bool visited[10][10] = {};\n long long total = 0;\n auto dfs = [&](auto&& self, int r, int c, int flavor, int& cnt) -> void {\n visited[r][c] = true;\n cnt++;\n int dr[4] = {-1, 0, 1, 0};\n int dc[4] = {0, 1, 0, -1};\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !visited[nr][nc] && grid[nr][nc] == flavor) {\n self(self, nr, nc, flavor, cnt);\n }\n }\n };\n for (int flavor = 1; flavor <= 3; flavor++) {\n for (int r = 0; r < 10; r++) {\n for (int c = 0; c < 10; c++) {\n if (!visited[r][c] && grid[r][c] == flavor) {\n int cnt = 0;\n dfs(dfs, r, c, flavor, cnt);\n total += 1LL * cnt * cnt;\n }\n }\n }\n }\n return total;\n}\n\nvoid apply(vector>& grid, char d) {\n if (d == 'F') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int r = 0; r < 10; r++) grid[r][c] = (r < (int)line.size() ? line[r] : 0);\n }\n } else if (d == 'B') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int r = 0; r < 10; r++) grid[r][c] = (r < 10 - ls ? 0 : line[r - (10 - ls)]);\n }\n } else if (d == 'L') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int c = 0; c < 10; c++) grid[r][c] = (c < (int)line.size() ? line[c] : 0);\n }\n } else if (d == 'R') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int c = 0; c < 10; c++) grid[r][c] = (c < 10 - ls ? 0 : line[c - (10 - ls)]);\n }\n }\n}\n\nint main() {\n vector> g(10, vector(10, 0));\n vector f(100);\n for (int &x : f) cin >> x;\n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n vector> empt;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (g[r][c] == 0) empt.emplace_back(r, c);\n auto [rr, cc] = empt[p - 1];\n g[rr][cc] = f[t];\n long long best_sc = -1;\n char best_d = 'F';\n for (char d : {'F', 'B', 'L', 'R'}) {\n vector> ng = g;\n apply(ng, d);\n long long sc = calc_score(ng);\n if (sc > best_sc) {\n best_sc = sc;\n best_d = d;\n }\n }\n apply(g, best_d);\n cout << best_d << endl;\n cout.flush();\n }\n return 0;\n}","ahc016":"#include \n#include \n\nusing namespace std;\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\nusing Eigen::SelfAdjointEigenSolver;\n\nint main() {\n int M;\n double eps;\n cin >> M >> eps;\n int N = 20;\n if (eps < 0.1) N = 12;\n else if (eps < 0.2) N = 18;\n else if (eps < 0.3) N = 25;\n else N = 35;\n N = max(N, (int)ceil(sqrt(2.0 * M)));\n N = min(N, 100);\n N = max(N, 4);\n vector G(M);\n for(int k = 0; k < M; k++) {\n double p = (double)(k + 1) / (M + 1);\n string s = \"\";\n for(int i = 0; i < N; i++) {\n for(int j = i + 1; j < N; j++) {\n long long seed = (long long)k * 123457 + (long long)i * 10007 + j;\n if ((seed % 100000LL) < (long long)(p * 100000)) {\n s += '1';\n } else {\n s += '0';\n }\n }\n }\n G[k] = s;\n }\n vector> pre_degs(M);\n vector> pre_eigs(M);\n for(int k = 0; k < M; k++) {\n auto& str = G[k];\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(str[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector d(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) d[i]++;\n sort(d.begin(), d.end());\n pre_degs[k] = d;\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector ev(N);\n for(int i = 0; i < N; i++) ev[i] = e(i);\n pre_eigs[k] = ev;\n }\n cout << N << endl;\n for(auto& g : G) {\n cout << g << endl;\n }\n cout.flush();\n double scale = 1 - 2 * eps;\n double bias = eps * (N - 1.0);\n for(int q = 0; q < 100; q++) {\n string H;\n cin >> H;\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(H[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector deg(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) deg[i]++;\n sort(deg.begin(), deg.end());\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector eig(N);\n for(int i = 0; i < N; i++) eig[i] = e(i);\n int best = 0;\n double min_dist = 1e100;\n for(int k = 0; k < M; k++) {\n double ddeg = 0;\n for(int i = 0; i < N; i++) {\n double exp_d = bias + scale * pre_degs[k][i];\n ddeg += (deg[i] - exp_d) * (deg[i] - exp_d);\n }\n ddeg = sqrt(ddeg);\n double deig = 0;\n vector eexp = pre_eigs[k];\n for(int i=0; i\nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n vector U(M), V(M);\n vector W(M);\n for(int i = 0; i < M; i++) {\n cin >> U[i] >> V[i] >> W[i];\n --U[i]; --V[i];\n }\n for(int i = 0; i < N; i++) {\n int x, y;\n cin >> x >> y;\n }\n auto gen = [&](unsigned seed) -> vector {\n vector ass(M, -1);\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n mt19937 rng(seed);\n shuffle(ord.begin(), ord.end(), rng);\n for(int ei : ord) {\n int best = -1, minc = INT_MAX;\n for(int d = 0; d < D; d++) if(ld[d] < K) {\n int conf = vcnt[U[ei]][d] + vcnt[V[ei]][d];\n if(conf < minc) {\n minc = conf;\n best = d;\n }\n }\n if(best == -1) {\n exit(1);\n }\n ass[ei] = best;\n ld[best]++;\n vcnt[U[ei]][best]++;\n vcnt[V[ei]][best]++;\n }\n return ass;\n };\n auto compute_bad = [&](const vector& ass) -> ll {\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = ass[i];\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n ll bad = 0;\n for(int v = 0; v <= N; v++) {\n for(int d = 0; d < D; d++) {\n int c = vcnt[v][d];\n bad += (ll)c * (c - 1);\n }\n }\n return bad;\n };\n vector best_ass;\n ll min_bad = LLONG_MAX;\n int trials = 2000;\n for(int t = 0; t < trials; t++) {\n vector ass = gen(t * 10007 + 12345);\n ll bd = compute_bad(ass);\n if(bd < min_bad) {\n min_bad = bd;\n best_ass = ass;\n }\n }\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = best_ass[i];\n ld[d]++;\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n bool improved = true;\n int max_passes = 200;\n mt19937 rng_rand(42);\n for(int pass = 0; pass < max_passes && improved; pass++) {\n improved = false;\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng_rand);\n for(int ei : ord) {\n int cur = best_ass[ei];\n int uu = U[ei], vv = V[ei];\n ll best_delta = 0;\n int best_newd = -1;\n for(int d = 0; d < D; d++) if(d != cur && ld[d] < K) {\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta) {\n best_delta = delta;\n best_newd = d;\n }\n }\n if(best_newd != -1 && best_delta < 0) {\n int newd = best_newd;\n vcnt[uu][cur]--;\n vcnt[vv][cur]--;\n vcnt[uu][newd]++;\n vcnt[vv][newd]++;\n ld[cur]--;\n ld[newd]++;\n best_ass[ei] = newd;\n improved = true;\n }\n }\n }\n for(int i = 0; i < M; i++) {\n if(i > 0) cout << \" \";\n cout << (best_ass[i] + 1);\n }\n cout << endl;\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Rod {\n int st, f1, f2, len;\n};\n\nint main() {\n int D;\n cin >> D;\n vector F[2], R[2];\n for (int i = 0; i < 2; i++) {\n F[i].resize(D);\n for (auto &s : F[i]) cin >> s;\n R[i].resize(D);\n for (auto &s : R[i]) cin >> s;\n }\n double best_eval = 1LL << 60;\n int best_n = 0;\n int best_block[2][15][15][15];\n for (int mode = 0; mode < 2; mode++) {\n bool voxels[2][15][15][15] = {};\n for (int i = 0; i < 2; i++) {\n for (int z = 0; z < D; z++) {\n vector Xs, Ys;\n for (int x = 0; x < D; x++) if (F[i][z][x] == '1') Xs.push_back(x);\n for (int y = 0; y < D; y++) if (R[i][z][y] == '1') Ys.push_back(y);\n int a = Xs.size(), b = Ys.size();\n if (a == 0 || b == 0) continue;\n vector Xsort = Xs; sort(Xsort.begin(), Xsort.end());\n vector Ysort = Ys; sort(Ysort.begin(), Ysort.end());\n vector> assigns;\n if (mode == 0) {\n if (a >= b) {\n int base = a / b; int rem = a % b;\n int pos = 0;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[pos++], Ysort[iy]);\n }\n }\n } else {\n int base = b / a; int rem = b % a;\n int pos = 0;\n for (int ix = 0; ix < a; ix++) {\n int cnt = base + (ix < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[ix], Ysort[pos++]);\n }\n }\n }\n } else {\n if (b >= a) {\n int base = b / a; int rem = b % a;\n int pos = 0;\n for (int ix = 0; ix < a; ix++) {\n int cnt = base + (ix < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[ix], Ysort[pos++]);\n }\n }\n } else {\n int base = a / b; int rem = a % b;\n int pos = 0;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[pos++], Ysort[iy]);\n }\n }\n }\n }\n for (auto [x, y] : assigns) {\n voxels[i][x][y][z] = true;\n }\n }\n }\n vector rlist[2][16];\n for (int i = 0; i < 2; i++) {\n if (mode == 0) {\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n for (int x = 0; x < D; ) {\n if (!voxels[i][x][y][z]) { x++; continue; }\n int st = x;\n while (x < D && voxels[i][x][y][z]) x++;\n int l = x - st;\n rlist[i][l].push_back({st, y, z, l});\n }\n }\n } else {\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) {\n for (int y = 0; y < D; ) {\n if (!voxels[i][x][y][z]) { y++; continue; }\n int st = y;\n while (y < D && voxels[i][x][y][z]) y++;\n int l = y - st;\n rlist[i][l].push_back({st, x, z, l});\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n for (int l = 1; l <= D; l++) {\n int c[2] = {(int)rlist[0][l].size(), (int)rlist[1][l].size()};\n int sh = min(c[0], c[1]);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c[1] - sh) * l;\n rrs[1] += (c[0] - sh) * l;\n sinv += sh * 1.0 / l;\n for (int k = 0; k < c[0]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod &rd = rlist[0][l][k];\n if (mode == 0) {\n for (int d = 0; d < l; d++) {\n blockid[0][rd.st + d][rd.f1][rd.f2] = bid;\n }\n } else {\n for (int d = 0; d < l; d++) {\n blockid[0][rd.f1][rd.st + d][rd.f2] = bid;\n }\n }\n }\n for (int k = 0; k < c[1]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod &rd = rlist[1][l][k];\n if (mode == 0) {\n for (int d = 0; d < l; d++) {\n blockid[1][rd.st + d][rd.f1][rd.f2] = bid;\n }\n } else {\n for (int d = 0; d < l; d++) {\n blockid[1][rd.f1][rd.st + d][rd.f2] = bid;\n }\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int i = 0; i < 2; i++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n best_block[i][x][y][z] = blockid[i][x][y][z];\n }\n }\n }\n cout << best_n << endl;\n for (int i = 0; i < 2; i++) {\n for (int pos = 0; pos < D * D * D; pos++) {\n int x = pos / (D * D);\n int rem = pos % (D * D);\n int y = rem / D;\n int z = rem % D;\n cout << best_block[i][x][y][z];\n if (pos < D * D * D - 1) cout << \" \";\n }\n cout << endl;\n }\n return 0;\n}","ahc020":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct UF {\n vector p, r;\n UF(int n) : p(n+1), r(n+1, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }\n bool unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return false;\n if (r[x] < r[y]) swap(x, y);\n p[y] = x;\n if (r[x] == r[y]) r[x]++;\n return true;\n }\n};\n\nstruct Edge {\n int u, v, idx;\n ll w;\n};\n\nstruct TEdge {\n int to, eidx;\n ll w;\n};\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector X(N+1), Y(N+1);\n for (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n vector alledges(M);\n for (int j = 0; j < M; j++) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n alledges[j] = {u, v, j, w};\n }\n vector A(K+1), B(K+1);\n for (int k = 1; k <= K; k++) cin >> A[k] >> B[k];\n vector> dist2(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll dx = X[i] - A[k];\n ll dy = Y[i] - B[k];\n dist2[i][k] = dx * dx + dy * dy;\n }\n }\n vector> minP(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll d2 = dist2[i][k];\n if (d2 == 0) {\n minP[i][k] = 0;\n continue;\n }\n ll low = 0, high = 100000;\n while (low < high) {\n ll mid = (low + high) / 2;\n if (mid * mid >= d2) high = mid;\n else low = mid + 1;\n }\n minP[i][k] = low;\n }\n }\n UF uf(N);\n vector mst_edges = alledges;\n sort(mst_edges.begin(), mst_edges.end(), [](const Edge& e1, const Edge& e2) { return e1.w < e2.w; });\n vector> tree(N+1);\n for (auto& e : mst_edges) {\n if (uf.unite(e.u, e.v)) {\n tree[e.u].push_back({e.v, e.idx, e.w});\n tree[e.v].push_back({e.u, e.idx, e.w});\n }\n }\n vector> children(N+1);\n function build = [&](int u, int par) {\n for (auto& e : tree[u]) {\n if (e.to != par) {\n children[u].push_back(e);\n build(e.to, u);\n }\n }\n };\n build(1, -1);\n using pbb = pair;\n function&, const vector&)> dfs_conn = [&](int u, set& usedids, const vector& term) -> pbb {\n bool has = term[u];\n ll cst = 0;\n for (auto& e : children[u]) {\n auto [sc, sh] = dfs_conn(e.to, usedids, term);\n if (sh) {\n cst += e.w + sc;\n has = true;\n usedids.insert(e.eidx);\n } else {\n cst += sc;\n }\n }\n return {cst, has};\n };\n auto get_connect = [&](const vector& t) -> ll {\n set dum;\n auto [c, h] = dfs_conn(1, dum, t);\n return c;\n };\n vector> res_list(N+1);\n vector assignment(K+1, 0);\n vector> reqs(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n assignment[k] = best;\n res_list[best].push_back(k);\n reqs[best].insert(bp);\n }\n vector curP(N+1, 0);\n ll sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n }\n }\n vector is_open(N+1, false);\n for (int i = 1; i <= N; i++) if (curP[i] > 0) is_open[i] = true;\n auto compute_term = [&](const vector& pvals) -> vector {\n vector t(N+1, false);\n for (int i = 1; i <= N; i++) t[i] = (pvals[i] > 0) || (i == 1);\n return t;\n };\n vector curr_term(N+1, false);\n for (int i = 1; i <= N; i++) curr_term[i] = (curP[i] > 0) || (i == 1);\n ll cur_conn = get_connect(curr_term);\n ll current_total = sum_sq + cur_conn;\n const int MAX_ITER = 50;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool improved = false;\n for (int k = 1; k <= K; k++) {\n int curr = assignment[k];\n if (curr == 0) continue;\n int reqc = minP[curr][k];\n for (int j = 1; j <= N; j++) if (is_open[j] && j != curr) {\n int reqn = minP[j][k];\n reqs[curr].erase(reqs[curr].find(reqc));\n ll tpc = reqs[curr].empty() ? 0 : *reqs[curr].rbegin();\n reqs[j].insert(reqn);\n ll tpj = *reqs[j].rbegin();\n ll dsq = tpc * tpc + tpj * tpj - (ll)curP[curr] * curP[curr] - (ll)curP[j] * curP[j];\n bool will_close = (curP[curr] > 0 && tpc == 0);\n ll dcon = 0;\n if (will_close) {\n vector np(N+1);\n for (int ii = 1; ii <= N; ii++) np[ii] = curP[ii];\n np[curr] = tpc;\n np[j] = tpj;\n auto tterm = compute_term(np);\n ll newc = get_connect(tterm);\n dcon = newc - cur_conn;\n }\n reqs[j].erase(reqs[j].find(reqn));\n reqs[curr].insert(reqc);\n if (dsq + dcon < 0) {\n reqs[curr].erase(reqs[curr].find(reqc));\n reqs[j].insert(reqn);\n auto& lst = res_list[curr];\n for (size_t pos = 0; pos < lst.size(); pos++) if (lst[pos] == k) {\n swap(lst[pos], lst.back());\n lst.pop_back();\n break;\n }\n res_list[j].push_back(k);\n assignment[k] = j;\n curP[curr] = tpc;\n curP[j] = tpj;\n sum_sq += dsq;\n if (will_close) {\n is_open[curr] = false;\n cur_conn += dcon;\n curr_term[curr] = (tpc > 0) || (curr == 1);\n curr_term[j] = (tpj > 0) || (j == 1);\n } else {\n curr_term[curr] = (tpc > 0) || (curr == 1);\n curr_term[j] = (tpj > 0) || (j == 1);\n }\n current_total += dsq + dcon;\n improved = true;\n break;\n }\n }\n if (improved) break;\n }\n if (!improved) {\n for (int i = 1; i <= N && !improved; i++) if (is_open[i]) {\n vector new_add(N+1, 0);\n bool can = true;\n vector> move_info;\n for (auto kk : res_list[i]) {\n int altj = -1, altp = INT_MAX / 2;\n for (int jj = 1; jj <= N; jj++) if (is_open[jj] && jj != i) {\n if (minP[jj][kk] < altp) {\n altp = minP[jj][kk];\n altj = jj;\n }\n }\n if (altp > 5000) {\n can = false;\n break;\n }\n new_add[altj] = max(new_add[altj], altp);\n move_info.emplace_back(kk, altj);\n }\n if (!can) continue;\n ll dsq = -(ll)curP[i] * curP[i];\n vector new_p(N+1);\n for (int ii = 1; ii <= N; ii++) new_p[ii] = curP[ii];\n new_p[i] = 0;\n for (int jj = 1; jj <= N; jj++) if (new_add[jj] > 0) {\n int oldpj = curP[jj];\n new_p[jj] = max(oldpj, new_add[jj]);\n dsq += (ll)new_p[jj] * new_p[jj] - (ll)oldpj * oldpj;\n }\n auto tterm = compute_term(new_p);\n ll new_conn_val = get_connect(tterm);\n ll dcon = new_conn_val - cur_conn;\n if (dsq + dcon < 0) {\n for (auto [kk, altj] : move_info) {\n reqs[i].erase(reqs[i].find(minP[i][kk]));\n reqs[altj].insert(minP[altj][kk]);\n auto& l = res_list[i];\n for (size_t p = 0; p < l.size(); p++) if (l[p] == kk) {\n swap(l[p], l.back());\n l.pop_back();\n break;\n }\n res_list[altj].push_back(kk);\n assignment[kk] = altj;\n }\n reqs[i].clear();\n res_list[i].clear();\n for (int jj = 1; jj <= N; jj++) {\n ll np = reqs[jj].empty() ? 0 : *reqs[jj].rbegin();\n if (new_p[jj] != np) new_p[jj] = (int)np;\n }\n for (int jj = 1; jj <= N; jj++) curP[jj] = new_p[jj];\n sum_sq += dsq;\n is_open[i] = false;\n cur_conn = new_conn_val;\n for (int ii = 1; ii <= N; ii++) curr_term[ii] = (curP[ii] > 0) || (ii == 1);\n current_total += dsq + dcon;\n improved = true;\n }\n }\n }\n if (!improved) break;\n }\n vector final_term(N+1, false);\n for (int i = 1; i <= N; i++) final_term[i] = (curP[i] > 0) || (i == 1);\n set final_used;\n auto [final_c, _] = dfs_conn(1, final_used, final_term);\n vector Bs(M, 0);\n for (int ei : final_used) {\n if (ei >= 0 && ei < M) Bs[ei] = 1;\n }\n for (int i = 1; i <= N; i++) cout << curP[i] << (i < N ? \" \" : \"\\n\");\n for (int j = 0; j < M; j++) cout << Bs[j] << (j < M - 1 ? \" \" : \"\\n\");\n}","ahc021":"#include \nusing namespace std;\nusing P = pair;\n\nstruct Sw {\n int x1, y1, x2, y2;\n};\n\nint main() {\n int N = 30;\n vector> grid(N);\n for (int x = 0; x < N; x++) {\n grid[x].resize(x + 1);\n for (int y = 0; y <= x; y++) {\n cin >> grid[x][y];\n }\n }\n int total = N * (N + 1) / 2;\n vector

curr_pos(total);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int val = grid[x][y];\n curr_pos[val] = {x, y};\n }\n }\n vector> is_fixed(N, vector(N, false));\n vector ops;\n\n auto get_parents = [&](P p) -> vector

{\n auto [x, y] = p;\n vector

res;\n if (x > 0) {\n if (y <= x - 1) res.emplace_back(x - 1, y);\n if (y - 1 >= 0) {\n int py = y - 1;\n if (py <= x - 1) res.emplace_back(x - 1, py);\n }\n }\n return res;\n };\n\n auto get_neighbors = [&](P p) -> vector

{\n int x = p.first, y = p.second;\n vector

res;\n vector> deltas = {{-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}};\n for (auto [dx, dy] : deltas) {\n int nx = x + dx, ny = y + dy;\n if (nx >= 0 && nx < N && ny >= 0 && ny <= nx) {\n res.emplace_back(nx, ny);\n }\n }\n return res;\n };\n\n for (int k = 0; k < total; k++) {\n vector

avail;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n if (is_fixed[x][y]) continue;\n auto pars = get_parents({x, y});\n bool ok = true;\n for (auto pp : pars) {\n if (!is_fixed[pp.first][pp.second]) {\n ok = false;\n break;\n }\n }\n if (ok) avail.emplace_back(x, y);\n }\n }\n P start = curr_pos[k];\n vector> dist(N, vector(N, -1));\n vector> par(N, vector

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

q;\n if (!is_fixed[start.first][start.second]) {\n dist[start.first][start.second] = 0;\n q.push(start);\n }\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (is_fixed[nx.first][nx.second]) continue;\n if (dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n P target = {-1, -1};\n int min_d = INT_MAX;\n for (auto cand : avail) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1 && dx < min_d) {\n min_d = dx;\n target = cand;\n }\n }\n if (target.first == -1) {\n // Fallback: pick any avail reachable? If none, pick first and try avoid issue\n // For safety, pick first avail and use full BFS without fixed? But to prevent break, if happen, abort attempt\n // Assume won't happen\n if (!avail.empty()) {\n target = avail[0];\n min_d = 100000; // marker\n } else {\n // impossible\n assert(false);\n return 1;\n }\n }\n vector

path;\n if (min_d == 100000) {\n // special case fallback: perhaps place without path? but to handle, let's implement simple move if rare\n // but assume not reach, to make sure, I will run full grid even fixed but then may break, skip for now\n // To make robust, I will do a second BFS without fixed check for fallback\n // but then fix after careful\n // For this, since likely not trigger, and to just output\n dist.assign(N, vector(N, -1));\n par.assign(N, vector

(N, {-1, -1}));\n q = queue

();\n dist[start.first][start.second] = 0;\n q.push(start);\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n P best = avail[0];\n int bestd = dist[best.first][best.second];\n for (auto cand : avail) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1 && dx < bestd) {\n bestd = dx;\n best = cand;\n }\n }\n target = best;\n min_d = bestd;\n }\n P cur = target;\n path = {};\n while (true) {\n path.push_back(cur);\n if (dist[cur.first][cur.second] == 0) break;\n cur = par[cur.first][cur.second];\n if (cur.first == -1) break;\n }\n reverse(path.begin(), path.end());\n for (size_t i = 0; i + 1 < path.size(); i++) {\n P p1 = path[i];\n P p2 = path[i + 1];\n int v1 = grid[p1.first][p1.second];\n int v2 = grid[p2.first][p2.second];\n grid[p1.first][p1.second] = v2;\n grid[p2.first][p2.second] = v1;\n curr_pos[v1] = p2;\n curr_pos[v2] = p1;\n ops.push_back({p1.first, p1.second, p2.first, p2.second});\n }\n is_fixed[target.first][target.second] = true;\n }\n cout << ops.size() << endl;\n for (auto& s : ops) {\n cout << s.x1 << \" \" << s.y1 << \" \" << s.x2 << \" \" << s.y2 << endl;\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n int D, N;\n cin >> D >> N;\n bool is_obst[9][9] = {};\n int cont[9][9];\n memset(cont, -1, sizeof(cont));\n for (int k = 0; k < N; k++) {\n int ri, rj;\n cin >> ri >> rj;\n is_obst[ri][rj] = true;\n cont[ri][rj] = -2;\n }\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n auto is_valid = [&](int x, int y) { return x >= 0 && x < 9 && y >= 0 && y < 9; };\n int dist[9][9];\n int visit_ord[9][9];\n memset(dist, -1, sizeof(dist));\n memset(visit_ord, -1, sizeof(visit_ord));\n {\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n dist[0][4] = 0;\n visit_ord[0][4] = 0;\n int ord = 1;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n vis[nx][ny] = true;\n dist[nx][ny] = dist[x][y] + 1;\n visit_ord[nx][ny] = ord++;\n q.push({nx, ny});\n }\n }\n }\n int M = 0;\n for (int i = 0; i < 9; i++)\n for (int j = 0; j < 9; j++)\n if (!is_obst[i][j] && !(i == 0 && j == 4)) M++;\n int placed_count = 0;\n set remain;\n for (int i = 0; i < M; i++) remain.insert(i);\n auto get_reach = [&]() -> vector> {\n vector> res;\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n if (cont[nx][ny] >= 0) continue;\n vis[nx][ny] = true;\n q.push({nx, ny});\n if ((nx || ny != 4) && cont[nx][ny] == -1) res.push_back({nx, ny});\n }\n }\n return res;\n };\n auto is_safe_pos = [&](int px, int py, int curr_rem) -> bool {\n cont[px][py] = 100000;\n auto nr = get_reach();\n cont[px][py] = -1;\n return nr.size() == (size_t)(curr_rem - 1);\n };\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n vector> reach = get_reach();\n int curr_rem = M - placed_count;\n vector> cands;\n for (auto p : reach) {\n if (is_safe_pos(p.first, p.second, curr_rem)) {\n cands.push_back(p);\n }\n }\n if (cands.empty()) {\n cands = reach;\n }\n auto cmp = [&](const pair& a, const pair& b) {\n if (dist[a.first][a.second] != dist[b.first][b.second])\n return dist[a.first][a.second] < dist[b.first][b.second];\n return visit_ord[a.first][a.second] < visit_ord[b.first][b.second];\n };\n sort(cands.begin(), cands.end(), cmp);\n int j = 0;\n for (int rid : remain) {\n if (rid == t) break;\n j++;\n }\n pair place_pos;\n if (!cands.empty() && j < (int)cands.size()) {\n place_pos = cands[j];\n } else if (!cands.empty()) {\n place_pos = cands.back();\n } else {\n place_pos = {0, 0}; // fallback error\n }\n cout << place_pos.first << \" \" << place_pos.second << endl;\n cont[place_pos.first][place_pos.second] = t;\n placed_count++;\n remain.erase(t);\n }\n vector> rem_order;\n bool cleared[9][9] = {};\n cleared[0][4] = true;\n for (int step = 0; step < M; step++) {\n vector> acc;\n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (cont[i][j] < 0) continue;\n if (cleared[i][j]) continue;\n bool can = false;\n for (int d = 0; d < 4; d++) {\n int nx = i + dx[d], ny = j + dy[d];\n if (is_valid(nx, ny) && !is_obst[nx][ny] && cleared[nx][ny]) {\n can = true;\n break;\n }\n }\n if (can) acc.emplace_back(i, j);\n }\n }\n if (acc.empty()) break;\n int minid = INT_MAX;\n pair chosen = {-1, -1};\n for (auto p : acc) {\n int id = cont[p.first][p.second];\n if (id < minid) {\n minid = id;\n chosen = p;\n }\n }\n rem_order.push_back(chosen);\n cleared[chosen.first][chosen.second] = true;\n cont[chosen.first][chosen.second] = -1;\n }\n for (auto p : rem_order) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n vector>>> witnesses(\n m + 1, vector>>(m + 1));\n bitset<101> has_adj[101];\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n bool is_bound = (i == 0 || i == n - 1 || j == 0 || j == n - 1);\n if (is_bound) {\n witnesses[c][0].push_back({i, j});\n has_adj[c][0] = 1;\n has_adj[0][c] = 1;\n }\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int nc = grid[ni][nj];\n if (c != nc) {\n witnesses[c][nc].push_back({i, j});\n has_adj[c][nc] = 1;\n has_adj[nc][c] = 1;\n }\n }\n }\n }\n }\n vector>> terminals(m + 1);\n for (int c = 1; c <= m; c++) {\n set> s;\n for (int dd = 0; dd <= m; dd++) {\n if (has_adj[c][dd]) {\n if (!witnesses[c][dd].empty()) {\n s.insert(witnesses[c][dd][0]);\n }\n }\n }\n for (auto p : s) terminals[c].push_back(p);\n }\n vector> iskept(n, vector(n, false));\n for (int c = 1; c <= m; c++) {\n if (terminals[c].empty()) continue;\n auto root = terminals[c][0];\n int sx = root.first, sy = root.second;\n vector> dist(n, vector(n, -1));\n vector>> parent(n, vector>(n, {-1, -1}));\n queue> qq;\n qq.push({sx, sy});\n dist[sx][sy] = 0;\n while (!qq.empty()) {\n auto [x, y] = qq.front();\n qq.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || dist[nx][ny] != -1 || grid[nx][ny] != c) continue;\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n qq.push({nx, ny});\n }\n }\n set> sk;\n for (auto &t : terminals[c]) {\n int cx = t.first, cy = t.second;\n while (true) {\n if (cx == -1 || dist[cx][cy] == -1) break;\n sk.insert({cx, cy});\n if (cx == sx && cy == sy) break;\n auto [px, py] = parent[cx][cy];\n cx = px;\n cy = py;\n }\n }\n for (auto p : sk) {\n iskept[p.first][p.second] = true;\n }\n }\n const int maxiter = 20;\n for (int iter = 0; iter < maxiter; iter++) {\n vector> current(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) current[i][j] = grid[i][j];\n }\n }\n vector> to_add;\n bool do_change = false;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = current[i][j];\n if (c == 0) continue;\n if (has_adj[c][0]) continue;\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && current[ni][nj] == 0) {\n to_add.push_back({ni, nj});\n do_change = true;\n }\n }\n }\n }\n vector> vis(n, vector(n, false));\n queue> q0;\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) && current[i][j] == 0) {\n q0.push({i, j});\n vis[i][j] = true;\n }\n }\n }\n while (!q0.empty()) {\n auto [x, y] = q0.front();\n q0.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || vis[nx][ny] || current[nx][ny] != 0) continue;\n vis[nx][ny] = true;\n q0.push({nx, ny});\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (current[i][j] == 0 && !vis[i][j]) {\n to_add.push_back({i, j});\n do_change = true;\n }\n }\n }\n for (auto [i, j] : to_add) {\n iskept[i][j] = true;\n }\n if (!do_change) break;\n }\n vector> final(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) final[i][j] = grid[i][j];\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j > 0) cout << \" \";\n cout << final[i][j];\n }\n cout << endl;\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n srand(time(NULL));\n int N, D, Q;\n cin >> N >> D >> Q;\n vector> adj(N);\n vector outdeg(N, 0);\n bitset<128> dcomp[100];\n auto compute_ranks = [&]( ) -> vector {\n vector memo(N, -1);\n function dfs = [&](int u) -> int {\n if (memo[u] != -1) return memo[u];\n int mx = 0;\n for (int v : adj[u]) {\n mx = max(mx, dfs(v) + 1);\n }\n return memo[u] = mx;\n };\n for (int i = 0; i < N; i++) {\n dfs(i);\n }\n return memo;\n };\n for (int q = 0; q < Q; q++) {\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n bool found = false;\n pair to_comp = {-1, -1};\n for (int dist = 1; dist < N && !found; dist++) {\n for (int p = 0; p + dist < N && !found; p++) {\n int x = items[p];\n int y = items[p + dist];\n if (!dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n }\n }\n }\n if (!found) {\n for (int tries = 0; tries < 10000; tries++) {\n int x = rand() % N;\n int y = rand() % N;\n if (x != y && !dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n break;\n }\n }\n if (!found) {\n to_comp = {0, 1};\n }\n }\n int a = to_comp.first;\n int b = to_comp.second;\n cout << 1 << \" \" << 1 << \" \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n dcomp[a].set(b);\n dcomp[b].set(a);\n if (res == '>') {\n adj[a].push_back(b);\n outdeg[a]++;\n } else if (res == '<') {\n adj[b].push_back(a);\n outdeg[b]++;\n }\n }\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n vector group(N);\n for (int i = 0; i < N; i++) {\n group[items[i]] = i % D;\n }\n for (int i = 0; i < N; i++) {\n cout << group[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n int h = n / m;\n vector> st(m);\n vector stack_of(n + 1, -1);\n vector pos_in_st(n + 1, -1);\n for (int i = 0; i < m; i++) {\n st[i].resize(h);\n for (int j = 0; j < h; j++) {\n cin >> st[i][j];\n stack_of[st[i][j]] = i;\n pos_in_st[st[i][j]] = j;\n }\n }\n vector> ops;\n for (int v = 1; v <= n; v++) {\n while (true) {\n int s = stack_of[v];\n if (s == -1) {\n break;\n }\n int p = pos_in_st[v];\n if (p == (int)st[s].size() - 1) break;\n vector stack_min(m, n + 1);\n for (int i = 0; i < m; i++) {\n for (int b : st[i]) {\n if (b < stack_min[i]) stack_min[i] = b;\n }\n }\n int best_minv = -1;\n int best_sz = INT_MAX;\n int dest = -1;\n for (int i = 0; i < m; i++)\n if (i != s) {\n int cmin = stack_min[i];\n int csz = st[i].size();\n bool up = false;\n if (cmin > best_minv) up = true;\n else if (cmin == best_minv) {\n if (csz < best_sz) up = true;\n else if (csz == best_sz && (dest == -1 || i < dest)) up = true;\n }\n if (up) {\n best_minv = cmin;\n best_sz = csz;\n dest = i;\n }\n }\n if (dest == -1) {\n // fallback: any stack except s\n for (int i = 0; i < m; i++)\n if (i != s) {\n dest = i;\n break;\n }\n }\n int lift_v = st[s][p + 1];\n ops.emplace_back(lift_v, dest);\n vector to_move;\n for (size_t j = p + 1; j < st[s].size(); ++j) {\n to_move.push_back(st[s][j]);\n }\n st[s].resize(p + 1);\n size_t old_dest_sz = st[dest].size();\n st[dest].insert(st[dest].end(), to_move.begin(), to_move.end());\n for (size_t j = 0; j < to_move.size(); ++j) {\n int b = to_move[j];\n stack_of[b] = dest;\n pos_in_st[b] = old_dest_sz + j;\n }\n }\n int s = stack_of[v];\n ops.emplace_back(v, 0);\n st[s].pop_back();\n stack_of[v] = -1;\n pos_in_st[v] = -1;\n }\n for (auto [vv, ii] : ops) {\n cout << vv << \" \" << ii << endl;\n }\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector h(N-1);\n for(int i=0; i> h[i];\n vector v(N);\n for(int i=0; i> v[i];\n vector> d(N, vector(N));\n for(int i=0; i> d[i][j];\n \n vector> sd(N, vector(N));\n double sum_s = 0.0;\n for(int i=0; i bool {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n int ddi = ni - i;\n int ddj = nj - j;\n if (ddi == -1 && ddj == 0) return h[ni][j] == '0'; // up from ni to i\n if (ddi == 1 && ddj == 0) return h[i][j] == '0';\n if (ddi == 0 && ddj == 1) return v[i][j] == '0';\n if (ddi == 0 && ddj == -1) return v[i][nj] == '0';\n return false;\n };\n \n // First, base covering using DFS\n vector> visited(N, vector(N, false));\n string route = \"\";\n \n function dfs = [&](int i, int j) {\n visited[i][j] = true;\n for(int dir=0; dir<4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni>=0 && ni=0 && nj> visits(N, vector(N, 0));\n vector> positions;\n positions.emplace_back(0, 0);\n int ci = 0, cj = 0;\n for(char c : route) {\n int dir = -1;\n if(c=='U') dir=0;\n else if(c=='R') dir=1;\n else if(c=='D') dir=2;\n else if(c=='L') dir=3;\n int ni = ci + di[dir], nj = cj + dj[dir];\n // assume valid since from sample\n positions.emplace_back(ni, nj);\n visits[ni][nj]++;\n ci = ni;\n cj = nj;\n }\n int Lbase = positions.size() - 1LL;\n int cur_i = ci, cur_j = cj;\n \n // Now add more visits\n int L_target = 90000;\n while((int)positions.size() - 1 < L_target) {\n // find best targets based on priority\n double max_p = -1.0;\n pair best1 = {-1,-1};\n pair best2 = {-1,-1};\n for(int i=0; i max_p + 1e-9) {\n max_p = p;\n best2 = best1;\n best1 = {i, j};\n } else if (p > sd[best2.first][best2.second] / (visits[best2.first][best2.second] + 1.0) + 1e-9 || best2.first == -1) {\n // if similar or update\n if (abs(p - max_p) > 1e-9 && (best2.first == -1 || p > sd[best2.first][best2.second] / (visits[best2.first][best2.second] + 1.0) + 1e-9)) {\n best2 = {i,j};\n }\n }\n }\n }\n if (best1.first == -1 || max_p < 0) break;\n \n pair chosen = best1;\n int ti = best1.first, tj = best1.second;\n if (ti == cur_i && tj == cur_j) {\n if (best2.first != -1) {\n chosen = best2;\n } else {\n // excursion to neighbor\n bool found = false;\n for(int dir=0; dir<4; dir++) {\n int ni = cur_i + di[dir], nj = cur_j + dj[dir];\n if (can_move(cur_i, cur_j, ni, nj)) {\n chosen = {ni, nj};\n found = true;\n break;\n }\n }\n if (!found) break;\n }\n }\n ti = chosen.first; tj = chosen.second;\n \n // BFS to get path\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1,-1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = false;\n if (cur_i == ti && cur_j == tj) {\n found = true;\n }\n while (!q.empty() && !found) {\n auto [i,j] = q.front(); q.pop();\n for(int dir=0; dir<4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni<0 || ni>=N || nj<0 || nj>=N || vis[ni][nj]) continue;\n if (!can_move(i,j,ni,nj)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i,j};\n q.emplace(ni,nj);\n if (ni == ti && nj == tj) {\n found = true;\n break;\n }\n }\n }\n if (!found) break;\n \n // reconstruct path positions\n vector> path_to;\n pair curp = {ti, tj};\n while (curp != make_pair(cur_i, cur_j)) {\n path_to.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_to.begin(), path_to.end());\n \n if ((int)positions.size() + path_to.size() > 100001) break;\n \n for(auto p : path_to) {\n positions.push_back(p);\n visits[p.first][p.second]++;\n cur_i = p.first;\n cur_j = p.second;\n }\n }\n \n // final return to (0,0)\n {\n int ti=0, tj=0;\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1,-1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool foundd = (cur_i==0 && cur_j==0);\n while(!q.empty() && !foundd) {\n auto [i,j] = q.front(); q.pop();\n for(int dir=0;dir<4;dir++) {\n int ni=i+di[dir], nj=j+dj[dir];\n if(ni<0||ni>=N||nj<0||nj>=N || vis[ni][nj]) continue;\n if(!can_move(i,j,ni,nj)) continue;\n vis[ni][nj]=true;\n parent[ni][nj]={i,j};\n q.emplace(ni,nj);\n if(ni==0 && nj==0) {foundd=true; break;}\n }\n }\n if(foundd) {\n vector> path_back;\n pair curp = {0,0};\n while(curp != make_pair(cur_i,cur_j)) {\n path_back.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_back.begin(), path_back.end());\n for(auto p : path_back) {\n positions.push_back(p);\n visits[p.first][p.second]++;\n cur_i = p.first;\n cur_j = p.second;\n }\n }\n }\n \n // Build move string\n string ans = \"\";\n for(size_t t=1; t 100000) {\n // truncate? but shouldn't\n ans = ans.substr(0,100000);\n }\n cout << ans << endl;\n return 0;\n}","ahc028":"#include \nusing namespace std;\ntypedef long long ll;\nconst ll INF = 1LL << 60;\n\nint main() {\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for(int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for(int i = 0; i < M; i++) cin >> t[i];\n vector>> positions(26);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].emplace_back(i, j);\n }\n string best_S = \"\";\n int min_len = INT_MAX;\n for(int start = 0; start < M; start++) {\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n for(int iter = 0; iter < M; iter++) {\n bool new_covered = false;\n for(int j = 0; j < M; j++) if(!used[j] && curr.find(t[j]) != string::npos) {\n used[j] = true;\n new_covered = true;\n }\n int remaining = 0;\n for(int j = 0; j < M; j++) if(!used[j]) remaining++;\n if(remaining == 0) break;\n int best = -1;\n int maxo = -1;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = 0;\n int mp = min(4, (int)curr.size());\n bool matched = false;\n for(int o = mp; o >= 1; o--) {\n if((int)curr.size() >= o && (int)t[j].size() >= o && curr.substr(curr.size() - o, o) == t[j].substr(0, o)) {\n oo = o;\n matched = true;\n break;\n }\n }\n if(!matched) oo = 0;\n if(oo > maxo) {\n maxo = oo;\n best = j;\n }\n }\n if(best == -1) break;\n curr += t[best].substr(maxo);\n used[best] = true;\n }\n int rem = 0;\n for(bool b : used) if(!b) rem++;\n if(rem == 0 && (int)curr.size() < min_len) {\n min_len = curr.size();\n best_S = curr;\n }\n }\n string S = best_S;\n int L = S.size();\n if(L == 0) {\n // fallback unlikely\n if(M > 0) S = t[0];\n L = S.size();\n }\n vector>> cands(L);\n for(int k = 0; k < L; k++) {\n cands[k] = positions[S[k] - 'A'];\n }\n if(L == 0) {\n cout << si << \" \" << sj << endl;\n return 0;\n }\n vector> dp(L);\n vector> prevv(L);\n int nc0 = cands[0].size();\n dp[0].resize(nc0);\n prevv[0].resize(nc0, -1);\n for(int j = 0; j < nc0; j++) {\n int x = cands[0][j].first, y = cands[0][j].second;\n dp[0][j] = abs(x - si) + abs(y - sj) + 1LL;\n }\n for(int k = 1; k < L; k++) {\n int nprev = cands[k - 1].size();\n int ncur = cands[k].size();\n dp[k].assign(ncur, INF);\n prevv[k].assign(ncur, -1);\n for(int j = 0; j < ncur; j++) {\n int x = cands[k][j].first, y = cands[k][j].second;\n for(int p = 0; p < nprev; p++) {\n int px = cands[k - 1][p].first, py = cands[k - 1][p].second;\n ll c = dp[k - 1][p] + abs(x - px) + abs(y - py) + 1;\n if(c < dp[k][j]) {\n dp[k][j] = c;\n prevv[k][j] = p;\n }\n }\n }\n }\n ll min_cost = INF;\n int bestj = -1;\n int nl = cands[L - 1].size();\n for(int j = 0; j < nl; j++) {\n if(dp[L - 1][j] < min_cost) {\n min_cost = dp[L - 1][j];\n bestj = j;\n }\n }\n vector> seq(L);\n if(L > 0 && bestj != -1) {\n int curj = bestj;\n seq[L - 1] = cands[L - 1][curj];\n for(int k = L - 1; k >= 1; k--) {\n int pj = prevv[k][curj];\n seq[k - 1] = cands[k - 1][pj];\n curj = pj;\n }\n } else if(L > 0) {\n // fallback to some position\n int x = cands[L-1][0].first, y = cands[L-1][0].second;\n seq[L-1] = {x,y};\n for(int k = L-2; k>=0; k--) {\n seq[k] = cands[k][0];\n }\n }\n for(auto& p : seq) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n vector>> fields(M);\n for (int i = 0; i < M; i++) {\n int d;\n cin >> d;\n fields[i].resize(d);\n for (int j = 0; j < d; j++) {\n cin >> fields[i][j].first >> fields[i][j].second;\n }\n }\n int D = N * N;\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution dist(0.0, 1.0);\n vector> queries;\n vector measured;\n int ops = 0;\n const int MAX_OPS = 2 * N * N;\n vector est(D, 0.0);\n vector true_v(D, -1);\n vector is_drilled(D, false);\n int INIT_Q = 300;\n for (int q = 0; q < INIT_Q && ops < MAX_OPS - 100; q++) {\n vector S;\n for (int c = 0; c < D; c++) {\n if (dist(rng) < 0.2) S.push_back(c);\n }\n if (S.size() < 2) {\n q--;\n continue;\n }\n cout << \"q \" << S.size();\n for (int c : S) {\n int i = c / N;\n int j = c % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int y;\n cin >> y;\n queries.push_back(S);\n measured.push_back(y);\n ops++;\n }\n int drill_batch = 30;\n double est_thresh = 0.25;\n for (int r = 0; r < 30 && ops < MAX_OPS - 1; r++) {\n vector unknown;\n for (int c = 0; c < D; c++) if (!is_drilled[c]) unknown.push_back(c);\n int U = unknown.size();\n if (U == 0) break;\n int Qs = queries.size();\n MatrixXd A(Qs, U);\n VectorXd bb(Qs);\n for (int qi = 0; qi < Qs; qi++) {\n int k = queries[qi].size();\n double target = (measured[qi] - eps * (double)k) / (1 - eps);\n double known_s = 0.0;\n for (int c : queries[qi]) if (is_drilled[c]) known_s += true_v[c];\n bb(qi) = target - known_s;\n A.row(qi).setZero();\n vector is_in(D, false);\n for (int c : queries[qi]) is_in[c] = true;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (is_in[c]) A(qi, uj) = 1.0;\n }\n }\n VectorXd x(U);\n if (U > 0 && Qs > 0) {\n x = A.bdcSvd(ComputeThinU | ComputeThinV).solve(bb);\n } else {\n x = VectorXd::Zero(U);\n }\n for (int uj = 0; uj < U; uj++) {\n est[unknown[uj]] = max(0.0, x(uj));\n }\n vector> high;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (est[c] > est_thresh) high.emplace_back(est[c], c);\n }\n if (high.empty()) break;\n sort(high.rbegin(), high.rend());\n int num_dr = min((int)high.size(), drill_batch);\n for (int ii = 0; ii < num_dr; ii++) {\n int c = high[ii].second;\n if (is_drilled[c]) continue;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n }\n vector> final_sus;\n for (int c = 0; c < D; c++) if (!is_drilled[c] && est[c] > 0.1) final_sus.emplace_back(est[c], c);\n sort(final_sus.rbegin(), final_sus.rend());\n for (auto& pr : final_sus) {\n if (ops >= MAX_OPS - 1) break;\n int c = pr.second;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n vector> ans;\n for (int c = 0; c < D; c++) if (is_drilled[c] && true_v[c] > 0) {\n ans.emplace_back(c / N, c % N);\n }\n vector>> possible_pos(M);\n for (int m = 0; m < M; m++) {\n int maxx = 0, maxy = 0;\n for (auto& p : fields[m]) {\n maxx = max(maxx, p.first);\n maxy = max(maxy, p.second);\n }\n for (int di = 0; di + maxx < N; di++) {\n for (int dj = 0; dj + maxy < N; dj++) {\n possible_pos[m].emplace_back(di, dj);\n }\n }\n }\n vector> best_place(M);\n vector best_v(D, 0.0);\n double best_err = 1e18;\n for (int start = 0; start < 5; start++) {\n vector> place(M);\n for (int m = 0; m < M; m++) {\n auto& ps = possible_pos[m];\n if (!ps.empty()) place[m] = ps[rng() % ps.size()];\n }\n auto compute_v = [&](const vector>& pl) -> vector {\n vector vv(D, 0.0);\n for (int m = 0; m < M; m++) {\n auto [di, dj] = pl[m];\n for (auto [x, y] : fields[m]) {\n int ii = di + x, jj = dj + y;\n vv[ii * N + jj] += 1;\n }\n }\n return vv;\n };\n vector vv = compute_v(place);\n vector target_v = est;\n for (int c = 0; c < D; c++) if (is_drilled[c]) target_v[c] = true_v[c];\n auto calc_err = [&](const vector& vvv) {\n double e = 0;\n for (int c = 0; c < D; c++) e += abs(vvv[c] - target_v[c]);\n return e;\n };\n double curr_err = calc_err(vv);\n for (int tries = 0; tries < 10000; tries++) {\n int m = rng() % M;\n auto& ps = possible_pos[m];\n if (ps.empty()) continue;\n int idx = rng() % ps.size();\n auto newp = ps[idx];\n if (newp == place[m]) continue;\n vector new_vv(D);\n // delta\n double delta = 0.0;\n double delta_adjust = 0;\n // old subtract\n auto oldp = place[m];\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n int c = ii * N + jj;\n double oldv = vv[c];\n double newvv = oldv - 1;\n delta += abs(newvv - target_v[c]) - abs(oldv - target_v[c]);\n }\n // new add\n for (auto [x, y] : fields[m]) {\n int ii = newp.first + x, jj = newp.second + y;\n int c = ii * N + jj;\n double oldv_for = vv[c];\n double newvv = oldv_for + 1;\n delta += abs(newvv - target_v[c]) - abs(oldv_for - target_v[c]);\n }\n if (delta < -0.001) {\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n vv[ii * N + jj] -= 1;\n int ii2 = newp.first + x, jj2 = newp.second + y;\n vv[ii2 * N + jj2] += 1;\n }\n place[m] = newp;\n curr_err += delta;\n }\n }\n if (curr_err < best_err) {\n best_err = curr_err;\n best_place = place;\n best_v = vv;\n }\n }\n set> union_set;\n for (int m = 0; m < M; m++) {\n auto [di, dj] = best_place[m];\n for (auto [x, y] : fields[m]) {\n union_set.emplace(di + x, dj + y);\n }\n }\n vector> final_ans;\n for (auto p : union_set) final_ans.push_back(p);\n for (auto p : ans) final_ans.push_back(p); // add drilled if any missed\n sort(final_ans.begin(), final_ans.end());\n auto last = unique(final_ans.begin(), final_ans.end());\n final_ans.erase(last, final_ans.end());\n cout << \"a \" << final_ans.size();\n for (auto [i, j] : final_ans) {\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int resp;\n cin >> resp;\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n vector> A(D, vector(N));\n for(int d = 0; d < D; d++) {\n for(int k = 0; k < N; k++) {\n cin >> A[d][k];\n }\n }\n vector prev_div(N + 1, 0);\n int base = W / N;\n for(int i = 1; i < N; i++) {\n prev_div[i] = prev_div[i - 1] + base;\n }\n prev_div[N] = W;\n for(int d = 0; d < D; d++) {\n auto a = A[d];\n vector cur_w(N);\n for(int k = 0; k < N; k++) cur_w[k] = prev_div[k + 1] - prev_div[k];\n vector slot_idx(N);\n iota(slot_idx.begin(), slot_idx.end(), 0);\n sort(slot_idx.begin(), slot_idx.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n vector a_idx(N);\n iota(a_idx.begin(), a_idx.end(), 0);\n sort(a_idx.begin(), a_idx.end(), [&](int x, int y) {\n if(a[x] != a[y]) return a[x] > a[y];\n return x < y;\n });\n vector assigned(N);\n for(int i = 0; i < N; i++) {\n int s = slot_idx[i];\n int ak = a_idx[i];\n assigned[s] = a[ak];\n }\n vector targ_w(N, 0);\n long long sum_need = 0;\n for(int s = 0; s < N; s++) {\n if(assigned[s] == 0) {\n targ_w[s] = 1;\n } else {\n targ_w[s] = ((assigned[s] + 999) / 1000);\n }\n if(targ_w[s] < 1) targ_w[s] = 1;\n sum_need += targ_w[s];\n }\n if(sum_need > W) {\n vector sidx(N);\n iota(sidx.begin(), sidx.end(), 0);\n sort(sidx.begin(), sidx.end(), [&](int x, int y) {\n return assigned[x] < assigned[y] || (assigned[x] == assigned[y] && x < y);\n });\n long long deficit = sum_need - W;\n for(int i : sidx) {\n if(deficit <= 0) break;\n int can = targ_w[i] - 1;\n long long red = min((long long)can, deficit);\n targ_w[i] -= red;\n deficit -= red;\n }\n int ii = 0;\n while(deficit > 0 && ii < N * 100) {\n int idx = sidx[ii % N];\n int can = targ_w[idx] - 1;\n long long red = min((long long)can, deficit);\n targ_w[idx] -= red;\n deficit -= red;\n ii++;\n }\n } else if(sum_need < W) {\n long long extra = W - sum_need;\n int maxs = 0;\n for(int s = 1; s < N; s++) if(assigned[s] > assigned[maxs]) maxs = s;\n targ_w[maxs] += extra;\n }\n vector new_div(N + 1, 0);\n for(int s = 0; s < N; s++) {\n new_div[s + 1] = new_div[s] + targ_w[s];\n }\n new_div[N] = W;\n vector sorted_slot(N);\n iota(sorted_slot.begin(), sorted_slot.end(), 0);\n sort(sorted_slot.begin(), sorted_slot.end(), [&](int x, int y) {\n if(targ_w[x] != targ_w[y]) return targ_w[x] > targ_w[y];\n return x < y;\n });\n vector> day_rects(N);\n for(int i = 0; i < N; i++) {\n int s = sorted_slot[i];\n int k = a_idx[i];\n int j0 = new_div[s];\n int j1 = new_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n for(int k = 0; k < N; k++) {\n auto &r = day_rects[k];\n cout << r[0] << \" \" << r[1] << \" \" << r[2] << \" \" << r[3] << endl;\n }\n prev_div = new_div;\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n vector>> S(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cin >> S[m][i][j];\n const ll MOD = 998244353;\n vector> cur_mod(N, vector(N));\n vector>> op_cnt(M, vector>(N - 2, vector(N - 2, 0)));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_mod[i][j] = A[i][j];\n ll cur_score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_score += cur_mod[i][j];\n int cur_total = 0;\n vector>> best_cnt = op_cnt;\n ll best_score = cur_score;\n auto get_add_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) {\n for (int dj = 0; dj < 3; dj++) {\n int i = p + di;\n int j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr + S[m][di][dj] % MOD) % MOD;\n ds += newr - oldr;\n }\n }\n return ds;\n };\n auto get_remove_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr - (S[m][di][dj] % MOD) + MOD) % MOD;\n ds += newr - oldr;\n }\n return ds;\n };\n while (cur_total < K) {\n ll max_ds = -1000000000000000000LL;\n int bm = -1, bp = -1, bq = -1;\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds;\n bm = m; bp = p; bq = q;\n }\n }\n }\n }\n if (max_ds <= 0) break;\n int m = bm, p = bp, q = bq;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m][di][dj] % MOD)) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n if (cur_score > best_score) {\n best_score = cur_score;\n best_cnt = op_cnt;\n }\n }\n int MAX_ITER = 1000000;\n double T0 = 10000000000.0;\n srand(42);\n auto rand01 = []() { return rand() * 1.0 / RAND_MAX; };\n for (int iter = 0; iter < MAX_ITER; iter++) {\n double temp = T0 * pow(0.9995, iter);\n bool did = false;\n int rtyp = rand() % 4;\n if (rtyp == 0 && cur_total < K) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n ll dsc = get_add_dsc(m, p, q);\n bool acc = (dsc >= 0) || (temp > 0 && exp(dsc / temp) > rand01());\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m][di][dj] % MOD)) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += dsc;\n if (cur_score > best_score) {\n best_score = cur_score;\n best_cnt = op_cnt;\n }\n did = true;\n }\n } else if (rtyp == 1 && cur_total > 0) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n if (op_cnt[m][p][q] > 0) {\n ll dsc = get_remove_dsc(m, p, q);\n bool acc = (dsc >= 0) || (temp > 0 && exp(dsc / temp) > rand01());\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - (S[m][di][dj] % MOD) + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += dsc;\n if (cur_score > best_score) {\n best_score = cur_score;\n best_cnt = op_cnt;\n }\n did = true;\n }\n }\n }\n if (!did) {\n int m1 = rand() % M; int p1 = rand() % (N - 2); int q1 = rand() % (N - 2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N - 2); int q2 = rand() % (N - 2);\n ll dsc = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n ll net = 0;\n int di = i - p1, dj = j - q1;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net -= S[m1][di][dj];\n di = i - p2; dj = j - q2;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net += S[m2][di][dj];\n if (net == 0) continue;\n ll oldr = cur_mod[i][j];\n ll addm = (net % MOD + MOD) % MOD;\n ll newr = (oldr + addm) % MOD;\n dsc += newr - oldr;\n }\n bool acc = (dsc >= 0) || (temp > 0 && exp(dsc / temp) > rand01());\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - (S[m1][di][dj] % MOD) + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m2][di][dj] % MOD)) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += dsc;\n if (cur_score > best_score) {\n best_score = cur_score;\n best_cnt = op_cnt;\n }\n }\n }\n }\n }\n int L = 0;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) L += best_cnt[m][p][q];\n cout << L << endl;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) {\n for (int t = 0; t < best_cnt[m][p][q]; t++) {\n cout << m << \" \" << p << \" \" << q << endl;\n }\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> 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 int max_turn = 10000;\n vector> grid(N, vector(N, -1));\n vector next_in(N, 0);\n vector pos_r(N), pos_c(N);\n for (int i = 0; i < N; i++) {\n pos_r[i] = i;\n pos_c[i] = 0;\n }\n vector hold(N, -1);\n vector active(N, true);\n vector acts(N, \"\");\n vector next_needed(N);\n for (int i = 0; i < N; i++) next_needed[i] = i * N;\n auto find_loc = [&](int b) -> pair {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == b) return {i, j};\n }\n }\n for (int k = 0; k < N; k++) {\n if (hold[k] == b) return {pos_r[k], pos_c[k]};\n }\n return {-1, -1};\n };\n for (int turn = 0; turn < max_turn; turn++) {\n bool done = true;\n for (int i = 0; i < N; i++) {\n if (next_needed[i] < (i + 1) * N) done = false;\n }\n if (done) break;\n // incoming\n for (int i = 0; i < N; i++) {\n if (next_in[i] < N && grid[i][0] == -1) {\n bool has_hold = false;\n for (int k = 0; k < N; k++) {\n if (active[k] && pos_r[k] == i && pos_c[k] == 0 && hold[k] != -1) {\n has_hold = true;\n break;\n }\n }\n if (!has_hold) {\n grid[i][0] = A[i][next_in[i]];\n next_in[i]++;\n }\n }\n }\n // decide actions conservatively\n vector act(N, '.');\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n int r = pos_r[c];\n int co = pos_c[c];\n bool is_large = (c == 0);\n bool carrying = (hold[c] != -1);\n if (carrying) {\n int b = hold[c];\n int tr = b / N;\n int tc = N - 1;\n int expect = next_needed[tr];\n bool is_next = (b == expect);\n bool can_q = (grid[r][co] == -1);\n if (r == tr && co == tc && is_next) {\n if (can_q) act[c] = 'Q';\n else act[c] = '.';\n } else if (r == tr) {\n if (is_next && co < tc && grid[r][co + 1] == -1) {\n act[c] = 'R';\n } else if (!is_next && can_q) {\n act[c] = 'Q'; // park\n } else {\n act[c] = '.';\n }\n } else {\n // vertical\n char dir = (r < tr ? 'D' : 'U');\n int dr = (r < tr ? 1 : -1);\n int nr = r + dr;\n if (nr < 0 || nr >= N) {\n act[c] = '.';\n } else {\n bool dest_ok = (grid[nr][co] == -1 || is_large);\n if (dest_ok) {\n act[c] = dir;\n } else {\n act[c] = '.';\n }\n }\n }\n } else {\n if (grid[r][co] != -1) {\n int b = grid[r][co];\n int tr = b / N;\n bool can_pick = is_large || (tr == r);\n if (can_pick && grid[r][co] != -1) {\n act[c] = 'P';\n }\n } else {\n // move to fetch next if in same row\n pair loc = {-1, -1};\n int expect = next_needed[r];\n if (expect < (r + 1) * N) {\n loc = find_loc(expect);\n } else {\n loc = {-1, -1};\n }\n if (loc.first == r && loc.second != -1) {\n int bc = loc.second;\n if (bc < co) {\n if (co > 0) act[c] = 'L';\n } else if (bc > co) {\n if (co < N - 1) act[c] = 'R';\n } else {\n act[c] = '.';\n }\n } else {\n // go left\n if (co > 0) act[c] = 'L';\n else act[c] = '.';\n }\n }\n }\n }\n // validate and apply P/Q\n vector> new_grid = grid;\n vector new_hold = hold;\n bool inval = false;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n int pr = pos_r[c], pc = pos_c[c];\n if (ac == 'P') {\n if (hold[c] != -1 || new_grid[pr][pc] == -1) {\n act[c] = '.';\n inval = true;\n } else {\n new_hold[c] = new_grid[pr][pc];\n new_grid[pr][pc] = -1;\n }\n } else if (ac == 'Q') {\n if (hold[c] == -1 || new_grid[pr][pc] != -1) {\n act[c] = '.';\n inval = true;\n } else {\n new_grid[pr][pc] = hold[c];\n new_hold[c] = -1;\n }\n } else if (ac == 'B') {\n if (hold[c] != -1) {\n act[c] = '.';\n inval = true;\n } else {\n active[c] = false;\n }\n }\n }\n if (inval) {\n // revert to safe, but since we set ., ok\n }\n vector nr_pos = pos_r, nc_pos = pos_c;\n vector final_hold = new_hold;\n vector> final_grid = new_grid;\n // apply moves with checks\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n if (ac == 'U' || ac == 'D' || ac == 'L' || ac == 'R') {\n int pr = pos_r[c];\n int pc = pos_c[c];\n int nrr = pr, ncc = pc;\n if (ac == 'U') nrr--;\n else if (ac == 'D') nrr++;\n else if (ac == 'L') ncc--;\n else if (ac == 'R') ncc++;\n if (nrr < 0 || nrr >= N || ncc < 0 || ncc >= N) {\n act[c] = '.';\n continue;\n }\n bool car = (new_hold[c] != -1);\n bool is_l = (c == 0);\n bool dest_has = (new_grid[nrr][ncc] != -1);\n if (car && !is_l && dest_has) {\n act[c] = '.';\n continue;\n }\n nr_pos[c] = nrr;\n nc_pos[c] = ncc;\n }\n }\n // check overlap and swaps\n map, int> pos_cnt;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n pair p = {nr_pos[c], nc_pos[c]};\n pos_cnt[p]++;\n }\n bool coll = false;\n for (auto& pr : pos_cnt) {\n if (pr.second > 1) coll = true;\n }\n if (coll) {\n // revert moves to .\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c];\n nc_pos[c] = pos_c[c];\n }\n }\n }\n // check pairwise swaps\n coll = false;\n for (int c1 = 0; c1 < N; c1++) {\n for (int c2 = c1 + 1; c2 < N; c2++) {\n if (!active[c1] || !active[c2]) continue;\n if (nr_pos[c1] == pos_r[c2] && nc_pos[c1] == pos_c[c2] && nr_pos[c2] == pos_r[c1] && nc_pos[c2] == pos_c[c1]) {\n coll = true;\n }\n }\n }\n if (coll) {\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c];\n nc_pos[c] = pos_c[c];\n }\n }\n }\n // update state\n pos_r = nr_pos;\n pos_c = nc_pos;\n grid = final_grid;\n hold = final_hold;\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n int pr = pos_r[c], pc = pos_c[c]; // after update\n if (hold[c] != -1 && ! (c==0) && grid[pr][pc] != -1 ) {\n // shouldn't happen but\n act[c] = '.';\n }\n }\n }\n // apply to acts\n for (int c = 0; c < N; c++) {\n acts[c] += act[c];\n }\n // dispatch\n for (int rr = 0; rr < N; rr++) {\n if (grid[rr][N - 1] != -1) {\n int b = grid[rr][N - 1];\n grid[rr][N - 1] = -1;\n if (b == next_needed[rr]) {\n next_needed[rr]++;\n }\n }\n }\n }\n // pad to same length\n int max_len = 0;\n for (int i = 0; i < N; i++) max_len = max(max_len, (int)acts[i].size());\n for (int i = 0; i < N; i++) {\n while (acts[i].size() < max_len) acts[i] += '.';\n if (acts[i].size() > max_turn) acts[i] = acts[i].substr(0, max_turn);\n }\n for (int i = 0; i < N; i++) {\n cout << acts[i] << endl;\n }\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n int r = 0, c = 0;\n long long load = 0;\n vector ops;\n const int MAXT = 100000;\n auto is_done = [&]() -> bool {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) return false;\n }\n }\n return true;\n };\n auto find_best = [&](bool is_source) -> pair {\n double best_ratio = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n long long val = h[i][j];\n if ((is_source ? val > 0 : val < 0)) {\n int dist = abs(i - r) + abs(j - c);\n long long amnt = is_source ? val : -val;\n double ratio = (double)amnt / (dist + 1.0);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n ti = i;\n tj = j;\n }\n }\n }\n }\n return {ti, tj};\n };\n auto move_path = [&](int tr, int tc) {\n while (r < tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"L\");\n c--;\n }\n };\n while (!is_done() && (int)ops.size() < MAXT - 50) {\n bool did_something = false;\n if (load == 0 && h[r][c] > 0) {\n long long d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[r][c] -= d;\n did_something = true;\n } else if (load > 0 && h[r][c] < 0) {\n long long d = min(load, -h[r][c]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[r][c] += d;\n did_something = true;\n }\n if (did_something) continue;\n bool going_source = (load == 0);\n auto [tr, tc] = find_best(going_source);\n if (tr == -1) {\n break;\n }\n move_path(tr, tc);\n }\n for (auto& s : ops) {\n cout << s << endl;\n }\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(NULL);\n int N, M, T;\n cin >> N >> M >> T;\n int seed_count = 2 * N * (N - 1);\n vector> X(seed_count, vector(M, 0));\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n mt19937 rng(42);\n for (int t = 0; t < T; t++) {\n // compute vals\n vector vals(seed_count, 0);\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n vals[i] += X[i][j];\n }\n }\n // must_include\n set must_include;\n for (int l = 0; l < M; l++) {\n int maxl = 0;\n for (int i = 0; i < seed_count; i++) {\n maxl = max(maxl, X[i][l]);\n }\n int best_v = -1, best_i = -1;\n for (int i = 0; i < seed_count; i++) {\n if (X[i][l] == maxl) {\n if (vals[i] > best_v || best_i == -1) {\n best_v = vals[i];\n best_i = i;\n }\n }\n }\n if (best_i != -1) must_include.insert(best_i);\n }\n vector to_plant;\n for (int i : must_include) to_plant.push_back(i);\n vector> others;\n for (int i = 0; i < seed_count; i++) {\n if (must_include.find(i) == must_include.end()) {\n others.emplace_back(vals[i], i);\n }\n }\n sort(others.rbegin(), others.rend());\n int need = N * N - (int)to_plant.size();\n for (int k = 0; k < need && k < (int)others.size(); k++) {\n to_plant.push_back(others[k].second);\n }\n // sort to_plant by val desc\n sort(to_plant.begin(), to_plant.end(), [&](int a, int b) {\n return vals[a] > vals[b] || (vals[a] == vals[b] && a < b);\n });\n if ((int)to_plant.size() > N * N) {\n to_plant.resize(N * N);\n }\n while ((int)to_plant.size() < N * N) {\n // shouldn't happen\n to_plant.push_back(0);\n }\n // now initial curr\n vector curr(N * N);\n for (int i = 0; i < N * N; i++) curr[i] = to_plant[i];\n auto compute_obj = [&](const vector& arr) -> long long {\n long long obj = 0;\n // horiz\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N - 1; j++) {\n int p = arr[i * N + j];\n int q = arr[i * N + j + 1];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n }\n }\n // vert\n for (int i = 0; i < N - 1; i++) {\n for (int j = 0; j < N; j++) {\n int p = arr[i * N + j];\n int q = arr[(i + 1) * N + j];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n }\n }\n return obj;\n };\n long long curr_obj = compute_obj(curr);\n vector best_arr = curr;\n long long best_obj = curr_obj;\n vector curr_arr = curr;\n double temp = 5000.0;\n for (int iter = 0; iter < 50000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr[p1], curr_arr[p2]);\n long long new_obj = compute_obj(curr_arr);\n long long delta = new_obj - curr_obj;\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double prob = exp(delta / temp);\n double r = (rng() % 1000000000) / 1000000000.0;\n if (r < prob) accept = true;\n }\n if (accept) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr;\n }\n } else {\n swap(curr_arr[p1], curr_arr[p2]);\n }\n if (iter % 100 == 0) {\n temp *= 0.999;\n if (temp < 0.1) temp = 0.1;\n }\n }\n // now output best_arr\n vector> A(N, vector(N, 0));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n A[i][j] = best_arr[i * N + j];\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << A[i][j];\n if (j < N - 1) cout << \" \";\n else cout << \"\\n\";\n }\n }\n cout.flush();\n // read new\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n int N, M, V;\n cin >> N >> M >> V;\n vector S(N), T(N);\n for (auto& str : S) cin >> str;\n for (auto& str : T) cin >> str;\n vector> grid(N, vector(N));\n vector> target(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n grid[i][j] = S[i][j] - '0';\n target[i][j] = T[i][j] - '0';\n }\n }\n vector> supplies, demands;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] && target[i][j] == 0) supplies.emplace_back(i, j);\n if (!grid[i][j] && target[i][j]) demands.emplace_back(i, j);\n }\n }\n sort(supplies.begin(), supplies.end());\n sort(demands.begin(), demands.end());\n int Vp = 2;\n int L = 1;\n cout << Vp << endl;\n for (int u = 1; u < Vp; u++) {\n cout << 0 << \" \" << L << endl;\n }\n int rx = N / 2, ry = N / 2;\n cout << rx << \" \" << ry << endl;\n int cur_dir = 0;\n bool holding = false;\n vector commands;\n int DX[4] = {0, 1, 0, -1};\n int DY[4] = {1, 0, -1, 0};\n int delx[5] = {0, 0, 1, 0, -1};\n int dely[5] = {0, 1, 0, -1, 0};\n char mchar[5] = {'.', 'R', 'D', 'L', 'U'};\n char rchar[3] = {'.', 'L', 'R'};\n auto do_bfs = [&](int sx, int sy) -> vector> {\n vector> targets;\n for (int dd = 0; dd < 4; dd++) {\n int needx = sx - DX[dd] * L;\n int needy = sy - DY[dd] * L;\n if (needx >= 0 && needx < N && needy >= 0 && needy < N) {\n targets.emplace_back(needx, needy, dd);\n }\n }\n if (targets.empty()) return {};\n vector>> dist(N, vector>(N, vector(4, -1)));\n vector>> prev_x(N, vector>(N, vector(4, -1)));\n vector>> prev_y(N, vector>(N, vector(4, -1)));\n vector>> prev_d(N, vector>(N, vector(4, -1)));\n vector>> prev_move(N, vector>(N, vector(4, -1)));\n vector>> prev_rot(N, vector>(N, vector(4, -1)));\n dist[rx][ry][cur_dir] = 0;\n queue> q;\n q.emplace(rx, ry, cur_dir);\n while (!q.empty()) {\n auto [x, y, d] = q.front(); q.pop();\n for (int mid = 0; mid < 5; mid++) {\n int nx = x + delx[mid];\n int ny = y + dely[mid];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n for (int rid = 0; rid < 3; rid++) {\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n int nd = (d + dch) % 4;\n if (dist[nx][ny][nd] == -1) {\n dist[nx][ny][nd] = dist[x][y][d] + 1;\n prev_x[nx][ny][nd] = x;\n prev_y[nx][ny][nd] = y;\n prev_d[nx][ny][nd] = d;\n prev_move[nx][ny][nd] = mid;\n prev_rot[nx][ny][nd] = rid;\n q.emplace(nx, ny, nd);\n }\n }\n }\n }\n int min_d = 1000000000;\n int bx = -1, by = -1, bd = -1;\n for (auto [px, py, pd] : targets) {\n if (dist[px][py][pd] != -1 && dist[px][py][pd] < min_d) {\n min_d = dist[px][py][pd];\n bx = px; by = py; bd = pd;\n }\n }\n if (min_d == 1000000000) return {};\n vector> rev_path;\n int cx = bx, cy = by, cd = bd;\n while (dist[cx][cy][cd] > 0) {\n int mid = prev_move[cx][cy][cd];\n int rid = prev_rot[cx][cy][cd];\n rev_path.emplace_back(mid, rid);\n int px = prev_x[cx][cy][cd];\n int py = prev_y[cx][cy][cd];\n int pd = prev_d[cx][cy][cd];\n cx = px; cy = py; cd = pd;\n }\n reverse(rev_path.begin(), rev_path.end());\n return rev_path;\n };\n for (int k = 0; k < (int)supplies.size(); k++) {\n auto [sx, sy] = supplies[k];\n int cur_fx = rx + DX[cur_dir] * L;\n int cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != sx || cur_fy != sy) {\n auto pth = do_bfs(sx, sy);\n if (pth.empty()) {\n // error, but shouldn't\n continue;\n }\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n } else {\n if (!holding) {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n }\n if (!holding) {\n grid[sx][sy] = 0;\n holding = true;\n }\n auto [tx, ty] = demands[k];\n cur_fx = rx + DX[cur_dir] * L;\n cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != tx || cur_fy != ty) {\n auto pth = do_bfs(tx, ty);\n if (pth.empty()) continue;\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n } else {\n if (holding) {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n }\n if (holding) {\n grid[tx][ty] = 1;\n holding = false;\n }\n }\n for (auto& cmd : commands) {\n cout << cmd << endl;\n }\n return 0;\n}","ahc039":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Info {\n ll tot, pre, suf, sub;\n};\n\nInfo comb(const Info& l, const Info& r) {\n Info res;\n res.tot = l.tot + r.tot;\n res.pre = max(l.pre, l.tot + r.pre);\n res.suf = max(r.suf, r.tot + l.suf);\n res.sub = max({l.sub, r.sub, l.suf + r.pre});\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n int N;\n cin >> N;\n vector X(2 * N), Y(2 * N);\n vector ism(2 * N, false);\n for (int i = 0; i < 2 * N; i++) {\n cin >> X[i] >> Y[i];\n if (i < N) ism[i] = true;\n }\n set sx, sy;\n for (int i = 0; i < 2 * N; i++) {\n sx.insert(X[i]);\n sy.insert(Y[i]);\n }\n vector allx(sx.begin(), sx.end());\n vector ally(sy.begin(), sy.end());\n int CX = allx.size();\n int CY = ally.size();\n map xr, yr;\n for (int i = 0; i < CX; i++) xr[allx[i]] = i + 1;\n for (int i = 0; i < CY; i++) yr[ally[i]] = i + 1;\n vector>> col(CX + 1);\n for (int i = 0; i < 2 * N; i++) {\n int rrx = xr[X[i]];\n int rry = yr[Y[i]];\n ll v = ism[i] ? 1LL : -1LL;\n col[rrx].emplace_back(rry, v);\n }\n vector>> coly(CY + 1);\n for (int i = 0; i < 2 * N; i++) {\n int rry = yr[Y[i]];\n int rrx = xr[X[i]];\n ll v = ism[i] ? 1LL : -1LL;\n coly[rry].emplace_back(rrx, v);\n }\n int SX = 4 * CY + 10;\n vector tree(SX);\n auto build_func = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n tree[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n if (CY >= 1) build_func(build_func, 1, 1, CY);\n vector cur_ysum(CY + 2, 0);\n auto upd = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n tree[node].tot += delta;\n tree[node].pre += delta;\n tree[node].suf += delta;\n tree[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n ll best_val = 0;\n int blx = -1, brx = -1, bly = -1, bry = -1, dim = 0; // dim 0 for x, 1 for y\n auto get_kad_extend = [&](int& starty, int& endy) -> ll {\n if (CY < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_ysum[1];\n max_so = meh;\n for (int j = 2; j <= CY; j++) {\n if (cur_ysum[j] > meh + cur_ysum[j]) {\n meh = cur_ysum[j];\n cl = j;\n } else {\n meh += cur_ysum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n starty = bl;\n endy = br;\n return max_so;\n };\n auto process_x = [&](vector& ttree, vector& cysum, auto upd_f, int step) {\n vector lsamps;\n for (int i = 1; i <= CX; i += step) lsamps.push_back(i);\n if (CY < 1) return;\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CX; R++) {\n for (auto [yy, vv] : col[R]) {\n upd_f(upd_f, 1, 1, CY, yy, vv);\n cysum[yy] += vv;\n hist.emplace_back(yy, vv);\n }\n if ((R - L) % 20 == 0 || R == CX || R - L < 20) {\n Info infoo = tree[1];\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int yy1, yy2;\n ll act = get_kad_extend(yy1, yy2);\n if (act > best_val && yy2 > yy1 && L < R) {\n int lx_x = allx[L - 1], rx_x = allx[R - 1];\n int ly_y = ally[yy1 - 1], ry_y = ally[yy2 - 1];\n ll lengthp = 2LL * abs(lx_x - rx_x) + 2LL * abs(ly_y - ry_y);\n if (lengthp <= 400000LL) {\n best_val = act;\n blx = L; brx = R; bly = yy1; bry = yy2; dim = 0;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [yy, vv] = hist[i];\n upd_f(upd_f, 1, 1, CY, yy, -vv);\n cysum[yy] -= vv;\n }\n }\n };\n int SXy = 4 * CX + 10;\n vector treey(SXy);\n vector cur_xsum(CX + 2, 0);\n auto upd_y = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n treey[node].tot += delta;\n treey[node].pre += delta;\n treey[node].suf += delta;\n treey[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n treey[node] = comb(treey[2 * node], treey[2 * node + 1]);\n };\n auto build_y = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n treey[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n treey[node] = comb(treey[2 * node], treey[2 * node + 1]);\n };\n if (CX >= 1) build_y(build_y, 1, 1, CX);\n auto get_kad_x = [&](int& startx, int& endx) -> ll {\n if (CX < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_xsum[1];\n max_so = meh;\n for (int j = 2; j <= CX; j++) {\n if (cur_xsum[j] > meh + cur_xsum[j]) {\n meh = cur_xsum[j];\n cl = j;\n } else {\n meh += cur_xsum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n startx = bl;\n endx = br;\n return max_so;\n };\n auto process_y = [&](int step) {\n if (CX < 1) return;\n vector lsamps;\n for (int i = 1; i <= CY; i += step) lsamps.push_back(i);\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CY; R++) {\n for (auto [xx, vv] : coly[R]) {\n upd_y(upd_y, 1, 1, CX, xx, vv);\n cur_xsum[xx] += vv;\n hist.emplace_back(xx, vv);\n }\n if ((R - L) % 20 == 0 || R == CY || R - L < 20) {\n Info infoo = treey[1];\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int xx1, xx2;\n ll act = get_kad_x(xx1, xx2);\n if (act > best_val && xx2 > xx1 && L < R) {\n int ly_y = ally[L - 1], ry_y = ally[R - 1];\n int lx_x = allx[xx1 - 1], rx_x = allx[xx2 - 1];\n ll lengthp = 2LL * abs(lx_x - rx_x) + 2LL * abs(ly_y - ry_y);\n if (lengthp <= 400000LL) {\n best_val = act;\n blx = xx1; brx = xx2; bly = L; bry = R; dim = 1;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [xx, vv] = hist[i];\n upd_y(upd_y, 1, 1, CX, xx, -vv);\n cur_xsum[xx] -= vv;\n }\n }\n };\n process_x(tree, cur_ysum, upd, 10);\n process_y(10);\n if (best_val <= 0 || blx == -1) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n return 0;\n }\n int x1, x2, y1, y2;\n if (dim == 0) {\n x1 = allx[blx - 1]; x2 = allx[brx - 1];\n y1 = ally[bly - 1]; y2 = ally[bry - 1];\n } else {\n x1 = allx[blx - 1]; x2 = allx[brx - 1];\n y1 = ally[bly - 1]; y2 = ally[bry - 1];\n }\n if (x1 == x2 || y1 == y2) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n return 0;\n }\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y2 << \"\\n\";\n cout << x1 << \" \" << y2 << \"\\n\";\n}","ahc040":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Strat {\n double wa, wb;\n bool use_area;\n};\n\nint main() {\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector W(N), H(N);\n for (int i = 0; i < N; i++) {\n cin >> W[i] >> H[i];\n }\n vector strats = {\n {1.0, 1.0, false},\n {2.0, 1.0, false},\n {1.0, 2.0, false},\n {3.0, 1.0, false},\n {1.0, 3.0, false},\n {5.0, 1.0, false},\n {1.0, 5.0, false},\n {10.0, 1.0, false},\n {1.0, 10.0, false},\n {0.0, 0.0, true}\n };\n mt19937 rng(12345);\n int ns = strats.size();\n for (int t = 0; t < T; t++) {\n vector rotv(N), dirv(N), bref(N);\n if ((t % (ns + 1)) == ns) {\n for (int i = 0; i < N; i++) {\n rotv[i] = rng() % 2;\n dirv[i] = rng() % 2;\n bref[i] = (i > 0 ? (rng() % i) : -1);\n }\n } else {\n Strat st = strats[t % ns];\n vector px(N, 0), py(N, 0), pww(N, 0), phh(N, 0);\n ll cmaxw = 0, cmaxh = 0;\n for (int i = 0; i < N; i++) {\n double bestc = 1e30;\n int br = -1, bd = -1, bb = -1;\n ll bx = 0, by = 0, bww = 0, bhh = 0;\n set bset = {-1};\n if (i > 0) {\n bset.insert(i - 1);\n bset.insert(0);\n if (i >= 2) bset.insert(i / 2);\n int nsamp = 40;\n for (int k = 0; k < nsamp; k++) {\n bset.insert(rng() % i);\n }\n }\n vector bs_vec(bset.begin(), bset.end());\n for (int r = 0; r < 2; r++) {\n ll ww = r ? H[i] : W[i];\n ll hh = r ? W[i] : H[i];\n for (int dd = 0; dd < 2; dd++) {\n for (int b : bs_vec) {\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n ll y1 = yy, y2 = yy + hh;\n ll yj1 = py[j], yj2 = py[j] + phh[j];\n if (max(y1, yj1) < min(y2, yj2)) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n ll x1 = xx, x2 = xx + ww;\n ll xj1 = px[j], xj2 = px[j] + pww[j];\n if (max(x1, xj1) < min(x2, xj2)) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n ll nw = max(cmaxw, xx + ww);\n ll nh = max(cmaxh, yy + hh);\n double cost;\n if (st.use_area) {\n cost = 1.0 * nw * nh;\n } else {\n cost = st.wa * nw + st.wb * nh;\n }\n if (cost < bestc) {\n bestc = cost;\n br = r;\n bd = dd;\n bb = b;\n bx = xx;\n by = yy;\n bww = ww;\n bhh = hh;\n }\n }\n }\n }\n rotv[i] = br;\n dirv[i] = bd;\n bref[i] = bb;\n px[i] = bx;\n py[i] = by;\n pww[i] = bww;\n phh[i] = bhh;\n cmaxw = max(cmaxw, bx + bww);\n cmaxh = max(cmaxh, by + bhh);\n }\n }\n cout << N << endl;\n for (int i = 0; i < N; i++) {\n cout << i << \" \" << rotv[i] << \" \" << (dirv[i] ? \"U\" : \"L\") << \" \" << bref[i] << endl;\n }\n cout.flush();\n ll wp, hp;\n cin >> wp >> hp;\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n vector X(N), Y(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i];\n }\n vector level(N, 0);\n bool changed = true;\n int max_iter = N * H + 100;\n int iter = 0;\n while (changed && iter++ < max_iter) {\n changed = false;\n long long best_a = -1;\n int best_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] < H) {\n bool can = false;\n for (int u : adj[v]) {\n if (level[u] == level[v]) {\n can = true;\n break;\n }\n }\n if (can && A[v] > best_a) {\n best_a = A[v];\n best_v = v;\n }\n }\n }\n if (best_v != -1) {\n level[best_v]++;\n changed = true;\n }\n }\n // cleanup decrease lowest A invalid first\n iter = 0;\n while (iter++ < max_iter) {\n long long worst_a = LLONG_MAX;\n int worst_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] > 0) {\n bool has = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n has = true;\n break;\n }\n }\n if (!has && A[v] < worst_a) {\n worst_a = A[v];\n worst_v = v;\n }\n }\n }\n if (worst_v != -1) {\n level[worst_v]--;\n } else {\n break;\n }\n }\n vector p(N, -1);\n for (int v = 0; v < N; v++) {\n if (level[v] == 0) {\n p[v] = -1;\n continue;\n }\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n p[v] = u;\n break;\n }\n }\n }\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << p[i];\n }\n cout << endl;\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint NN;\nvector board;\nvector> moves;\n\nvoid do_shift(char d, int p) {\n if (d == 'L') {\n for (int j = 0; j < NN - 1; j++) board[p][j] = board[p][j + 1];\n board[p][NN - 1] = '.';\n } else if (d == 'R') {\n for (int j = NN - 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 < NN - 1; i++) board[i][p] = board[i + 1][p];\n board[NN - 1][p] = '.';\n } else if (d == 'D') {\n for (int i = NN - 1; i > 0; i--) board[i][p] = board[i - 1][p];\n board[0][p] = '.';\n }\n}\n\nint main() {\n int N;\n cin >> N;\n NN = N;\n board.resize(N);\n for (int i = 0; i < N; i++) cin >> board[i];\n int iter = 0;\n while (true) {\n int numx = 0;\n for (auto& s : board) for (char c : s) if (c == 'x') numx++;\n if (numx == 0) break;\n if (++iter > 10000) break;\n double best_r = -1;\n char best_d = ' ';\n int best_p = -1;\n int best_k = 0;\n int best_n = 0;\n int best_c = 100000;\n auto update = [&](double rt, char dd, int pp, int kk, int nm, int cc) {\n bool better = false;\n if (rt > best_r + 1e-9) better = true;\n else if (abs(rt - best_r) < 1e-9) {\n if (cc < best_c) better = true;\n else if (cc == best_c && nm > best_n) better = true;\n }\n if (better) {\n best_r = rt;\n best_d = dd;\n best_p = pp;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n };\n // rows left\n for (int i = 0; i < N; i++) {\n int maxj = -1, nm = 0;\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxj = j; nm++; }\n }\n if (nm > 0) {\n int kk = maxj + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'L', i, kk, nm, cc);\n }\n }\n // rows right\n for (int i = 0; i < N; i++) {\n int lmost = N;\n for (int j = N - 1; j >= 0; j--) {\n if (board[i][j] == 'o') { lmost = j + 1; break; }\n }\n int minj = N, nm = 0;\n for (int j = lmost; j < N; j++) {\n if (board[i][j] == 'x') { minj = min(minj, j); nm++; }\n }\n if (nm > 0) {\n int kk = N - minj;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'R', i, kk, nm, cc);\n }\n }\n // cols up\n for (int j = 0; j < N; j++) {\n int maxi = -1, nm = 0;\n for (int i = 0; i < N; i++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxi = i; nm++; }\n }\n if (nm > 0) {\n int kk = maxi + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'U', j, kk, nm, cc);\n }\n }\n // cols down\n for (int j = 0; j < N; j++) {\n int lmost = N;\n for (int i = N - 1; i >= 0; i--) {\n if (board[i][j] == 'o') { lmost = i + 1; break; }\n }\n int mini = N, nm = 0;\n for (int i = lmost; i < N; i++) {\n if (board[i][j] == 'x') { mini = min(mini, i); nm++; }\n }\n if (nm > 0) {\n int kk = N - mini;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'D', j, kk, nm, cc);\n }\n }\n if (best_p == -1) break;\n char dd = best_d;\n int p = best_p;\n int kk = best_k;\n char op = (dd == 'L' ? 'R' : (dd == 'R' ? 'L' : (dd == 'U' ? 'D' : 'U')));\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(dd, p);\n do_shift(dd, p);\n }\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(op, p);\n do_shift(op, p);\n }\n }\n for (auto [d, pp] : moves) {\n cout << d << \" \" << pp << endl;\n }\n}","ahc044":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, L;\n cin >> N >> L;\n vector T(N);\n for(int i = 0; i < N; i++) cin >> T[i];\n vector pref(N + 1, 0);\n for(int j = 0; j < N; j++) {\n pref[j + 1] = pref[j] + T[j] + 1;\n }\n ll total = pref[N];\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n auto sample = [&](const vector& p, ll tot) -> int {\n ll r = uniform_int_distribution(0, tot - 1)(rng);\n auto it = upper_bound(p.begin(), p.end(), r);\n return (it - p.begin()) - 1;\n };\n auto get_err = [&](const vector& A, const vector& B) -> int {\n vector cnt(N, 0);\n int cur = 0;\n for(int w = 1; w <= L; w++) {\n cnt[cur]++;\n if(w < L) {\n if(cnt[cur] % 2 == 1) cur = A[cur];\n else cur = B[cur];\n }\n }\n int err = 0;\n for(int i = 0; i < N; i++) {\n err += abs(cnt[i] - T[i]);\n }\n return err;\n };\n const int NUM_RANDOM = 150;\n int best_err = INT_MAX;\n vector best_a, best_b;\n vector pref_t = pref;\n for(int tr = 0; tr < NUM_RANDOM; tr++) {\n vector A(N), B(N);\n for(int i = 0; i < N; i++) {\n A[i] = sample(pref_t, total);\n B[i] = sample(pref_t, total);\n }\n int err = get_err(A, B);\n if(err < best_err) {\n best_err = err;\n best_a = A;\n best_b = B;\n }\n }\n const int NUM_MUT = 400;\n for(int m = 0; m < NUM_MUT; m++) {\n vector A = best_a;\n vector B = best_b;\n int i = uniform_int_distribution(0, N - 1)(rng);\n int choice = uniform_int_distribution(0, 1)(rng);\n int news = sample(pref_t, total);\n if(choice == 0) A[i] = news;\n else B[i] = news;\n int new_err = get_err(A, B);\n if(new_err < best_err) {\n best_err = new_err;\n best_a = A;\n best_b = B;\n }\n }\n for(int i = 0; i < N; i++) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int &g : G) cin >> g;\n vector cx(N), cy(N);\n vector Lx(N), Rx(N), Ly(N), Ry(N);\n for (int i = 0; i < N; i++) {\n cin >> Lx[i] >> Rx[i] >> Ly[i] >> Ry[i];\n cx[i] = (Lx[i] + Rx[i]) / 2.0;\n cy[i] = (Ly[i] + Ry[i]) / 2.0;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int i, int j) {\n if (cx[i] != cx[j]) return cx[i] < cx[j];\n return cy[i] < cy[j];\n });\n vector> groups(M);\n int idx = 0;\n for (int k = 0; k < M; k++) {\n groups[k].resize(G[k]);\n for (int j = 0; j < G[k]; j++) {\n groups[k][j] = order[idx++];\n }\n }\n int queries_used = 0;\n vector>> collected_edges(M);\n int adv_base = max(1, min(L - 1, N / Q));\n for (int k = 0; k < M && queries_used < Q; k++) {\n vector &grp = groups[k];\n int gs = grp.size();\n if (gs <= 1) continue;\n set> kn;\n vector> &coll = collected_edges[k];\n int i = 0;\n int adv = adv_base;\n while (i < gs - 1 && queries_used < Q) {\n int len = min(L, gs - i);\n if (len < 2) break;\n cout << \"? \" << len;\n for (int p = i; p < i + len; p++) cout << \" \" << grp[p];\n cout << endl;\n vector> resp(len - 1);\n for (int r = 0; r < len - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (kn.find(p) == kn.end()) {\n kn.insert(p);\n coll.push_back(p);\n }\n }\n queries_used++;\n if (i + len >= gs) break;\n int this_adv = max(1, adv);\n i += this_adv;\n }\n if (queries_used < Q && gs > L) {\n int start = max(0, gs - L);\n int len2 = min(L, gs - start);\n if (len2 >= 2) {\n cout << \"? \" << len2;\n for (int p = start; p < start + len2; p++) cout << \" \" << grp[p];\n cout << endl;\n vector> resp(len2 - 1);\n for (int r = 0; r < len2 - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (kn.find(p) == kn.end()) {\n kn.insert(p);\n coll.push_back(p);\n }\n }\n queries_used++;\n }\n }\n }\n cout << \"!\" << endl;\n for (int k = 0; k < M; k++) {\n vector grp = groups[k];\n int gs = grp.size();\n for (int j = 0; j < gs; j++) {\n cout << grp[j];\n if (j < gs - 1) cout << \" \";\n else cout << endl;\n }\n if (gs <= 1) continue;\n set> knownp;\n vector> &coll = collected_edges[k];\n for (auto p : coll) {\n int a = p.first, b = p.second;\n if (a > b) swap(a, b);\n knownp.insert({a, b});\n }\n vector> known_list;\n vector local_id(N, -1);\n for (int j = 0; j < gs; j++) local_id[grp[j]] = j;\n for (auto &pr : knownp) {\n int a = pr.first, b = pr.second;\n int ia = local_id[a], ib = local_id[b];\n if (ia == -1 || ib == -1) continue;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n known_list.emplace_back(d, ia, ib);\n }\n sort(known_list.begin(), known_list.end());\n vector parent(gs);\n iota(parent.begin(), parent.end(), 0);\n auto find = [&](auto &self, int x) -> int {\n return parent[x] == x ? x : parent[x] = self(self, parent[x]);\n };\n auto unite = [&](int x, int y) {\n x = find(find, x);\n y = find(find, y);\n if (x != y) {\n parent[x] = y;\n return true;\n }\n return false;\n };\n vector> mst_roads;\n int edges_added = 0;\n for (auto &[d, ia, ib] : known_list) {\n if (unite(ia, ib)) {\n mst_roads.emplace_back(grp[ia], grp[ib]);\n edges_added++;\n }\n if (edges_added == gs - 1) break;\n }\n if (edges_added < gs - 1) {\n vector> unk;\n for (int ii = 0; ii < gs; ii++) {\n for (int jj = ii + 1; jj < gs; jj++) {\n int a = grp[ii], b = grp[jj];\n pair p = {min(a, b), max(a, b)};\n if (knownp.find(p) != knownp.end()) continue;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n unk.emplace_back(d, ii, jj);\n }\n }\n sort(unk.begin(), unk.end());\n for (auto &[d, ia, ib] : unk) {\n if (unite(ia, ib)) {\n mst_roads.emplace_back(grp[ia], grp[ib]);\n edges_added++;\n }\n if (edges_added == gs - 1) break;\n }\n }\n for (auto &rd : mst_roads) {\n cout << rd.first << \" \" << rd.second << endl;\n }\n }\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> points(M);\n for (int m = 0; m < M; m++) {\n cin >> points[m].first >> points[m].second;\n }\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n pair current = points[0];\n vector> seq;\n for (int k = 1; k < M; k++) {\n pair goal = points[k];\n set> forbidden;\n for (int t = k + 1; t < M; t++) {\n forbidden.insert(points[t]);\n }\n vector> dist(N, vector(N, -1));\n vector>> prevpos(N, vector>(N, {-1, -1}));\n vector>> prevact(N, vector>(N, {' ', ' '}));\n queue> q;\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n // M actions\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n // S actions\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Fallback: no forbidden, allow all\n forbidden.clear();\n dist.assign(N, vector(N, -1));\n prevpos.assign(N, vector>(N, {-1, -1}));\n prevact.assign(N, vector>(N, {' ', ' '}));\n q = queue>();\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Still unreachable, fallback to pure M manhattan path, allowing everything\n // Compute simple horiz then vert M path\n vector> path;\n int ci = current.first, cj = current.second;\n int gi = goal.first, gj = goal.second;\n int stepi, stepj;\n stepi = (gi > ci ? 1 : (gi < ci ? -1 : 0));\n for (int s = 0; s < abs(gi - ci); s++) {\n path.push_back({'M', (stepi > 0 ? 'D' : 'U')});\n }\n stepj = (gj > cj ? 1 : (gj < cj ? -1 : 0));\n for (int s = 0; s < abs(gj - cj); s++) {\n path.push_back({'M', (stepj > 0 ? 'R' : 'L')});\n }\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n continue;\n }\n // Reconstruct path\n vector> path;\n pair pos = goal;\n while (pos != current) {\n pair act = prevact[pos.first][pos.second];\n path.push_back(act);\n pos = prevpos[pos.first][pos.second];\n }\n reverse(path.begin(), path.end());\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n }\n for (auto& p : seq) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}"},"2":{"ahc001":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Rect {\n int x1, y1, x2, y2;\n};\n\nint N;\nvector X, Y, R;\n\ndouble compute_score(const vector& recs) {\n double tot = 0.0;\n for (int i = 0; i < N; i++) {\n ll a = recs[i].x1, b = recs[i].y1, c = recs[i].x2, d = recs[i].y2;\n ll s = (c - a) * 1LL * (d - b);\n ll rr = R[i];\n if (s == 0 || rr == 0) continue;\n double ratio = min(s, rr) * 1.0 / max(s, rr);\n tot += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return tot;\n}\n\nvoid solve_rects(int lx, int ly, int rx, int ry, vector ps, vector& recs) {\n if (ps.size() == 0) return;\n if (ps.size() == 1) {\n recs[ps[0]] = {lx, ly, rx, ry};\n return;\n }\n ll area = (rx - lx) * 1LL * (ry - ly);\n double best_mis = 1e30;\n int best_d = -1, best_kk = -1, best_ct = -1;\n for (int dir = 0; dir < 2; dir++) {\n vector idx = ps;\n if (dir == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int m = idx.size();\n vector pref(m + 1, 0);\n for (int j = 1; j <= m; j++) {\n pref[j] = pref[j - 1] + R[idx[j - 1]];\n }\n ll tot = pref[m];\n if (tot == 0) continue;\n for (int k = 1; k < m; k++) {\n ll sleft = pref[k];\n int idl = idx[k - 1], idr = idx[k];\n ll min_c, max_c;\n if (dir == 0) {\n min_c = X[idl] + 1;\n max_c = X[idr];\n } else {\n min_c = Y[idl] + 1;\n max_c = Y[idr];\n }\n ll low = dir == 0 ? lx + 1 : ly + 1;\n ll high = dir == 0 ? rx - 1 : ry - 1;\n min_c = max(min_c, low);\n max_c = min(max_c, high);\n if (min_c > max_c) continue;\n double target_a = sleft * 1.0 / tot * area;\n ll target_cut;\n if (dir == 0) {\n ll hgt = ry - ly;\n if (hgt <= 0) continue;\n ll dw = (ll)round(target_a / hgt);\n target_cut = lx + dw;\n } else {\n ll wid = rx - lx;\n if (wid <= 0) continue;\n ll dh = (ll)round(target_a / wid);\n target_cut = ly + dh;\n }\n ll cutt = max(min_c, min(max_c, target_cut));\n ll act_area = 0;\n if (dir == 0) {\n act_area = (cutt - lx) * 1LL * (ry - ly);\n } else {\n act_area = (rx - lx) * 1LL * (cutt - ly);\n }\n double mis = fabs(act_area - target_a);\n if (mis < best_mis) {\n best_mis = mis;\n best_d = dir;\n best_kk = k;\n best_ct = (int)cutt;\n }\n }\n }\n if (best_d == -1) {\n bool found = false;\n int dir_try = (rx - lx > 1 ? 0 : 1);\n for (int tries = 0; tries < 2 && !found; tries++) {\n int dirr = dir_try;\n vector idxx = ps;\n if (dirr == 0) {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int mm = idxx.size();\n for (int kk = 1; kk < mm; kk++) {\n int idl = idxx[kk - 1], idr = idxx[kk];\n ll minc_ = dirr == 0 ? X[idl] + 1 : Y[idl] + 1;\n ll maxc_ = dirr == 0 ? X[idr] : Y[idr];\n ll loww = dirr == 0 ? lx + 1 : ly + 1;\n ll highh = dirr == 0 ? rx - 1 : ry - 1;\n if (minc_ <= maxc_ && minc_ <= highh && maxc_ >= loww) {\n best_d = dirr;\n best_kk = kk;\n ll midv = (max(minc_, loww) + min(maxc_, highh)) / 2;\n best_ct = (int)midv;\n found = true;\n break;\n }\n }\n dir_try = 1 - dir_try;\n }\n if (!found) {\n // ultimate fallback\n best_d = 0;\n best_kk = ps.size() / 2;\n best_ct = lx + (rx - lx) / 2;\n if (best_ct < lx + 1) best_ct = lx + 1;\n if (best_ct > rx - 1) best_ct = rx - 1;\n }\n }\n vector idx = ps;\n if (best_d == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n vector left_ps(idx.begin(), idx.begin() + best_kk);\n vector right_ps(idx.begin() + best_kk, idx.end());\n if (best_d == 0) {\n solve_rects(lx, ly, best_ct, ry, left_ps, recs);\n solve_rects(best_ct, ly, rx, ry, right_ps, recs);\n } else {\n solve_rects(lx, ly, rx, best_ct, left_ps, recs);\n solve_rects(lx, best_ct, rx, ry, right_ps, recs);\n }\n}\n\nint main() {\n cin >> N;\n X.resize(N);\n Y.resize(N);\n R.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n vector recs(N);\n vector ps(N);\n iota(ps.begin(), ps.end(), 0);\n solve_rects(0, 0, 10000, 10000, ps, recs);\n for (int i = 0; i < N; i++) {\n cout << recs[i].x1 << \" \" << recs[i].y1 << \" \" << recs[i].x2 << \" \" << recs[i].y2 << endl;\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int si, sj;\n cin >> si >> sj;\n int T[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> T[i][j];\n int P[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> P[i][j];\n pair sib[50][50];\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) sib[i][j] = {-1,-1};\n int maxt = 0;\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) maxt = max(maxt, T[i][j]);\n vector>> tilec(maxt+1);\n for(int i=0;i<50;i++)for(int j=0;j<50;j++){\n tilec[T[i][j]].emplace_back(i,j);\n }\n for(auto& v: tilec){\n if(v.size()==2){\n auto [x1,y1]=v[0]; auto [x2,y2]=v[1];\n sib[x1][y1]={x2,y2};\n sib[x2][y2]={x1,y1};\n }\n }\n int di[4]={-1,0,1,0};\n int dj[4]={0,1,0,-1};\n char dc[4]={'U','R','D','L'};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n ll best_score = P[si][sj];\n string best_path = \"\";\n auto simulate = [&](bool det) -> pair {\n bool vis[50][50] = {};\n vis[si][sj] = true;\n ll score = P[si][sj];\n string path = \"\";\n int ci=si, cj = sj;\n while(true) {\n vector cands;\n for(int d=0;d<4;d++) {\n int ni = ci + di[d], nj = cj + dj[d];\n if(ni<0 || ni >=50 || nj<0 || nj>=50 || vis[ni][nj]) continue;\n auto [bx,by] = sib[ni][nj];\n if(bx!=-1 && vis[bx][by]) continue;\n cands.push_back(d);\n }\n if(cands.empty()) break;\n vector ws(cands.size(), 0);\n for(size_t k=0; k=50||nnj<0||nnj>=50 || vis[nni][nnj]) continue;\n auto [bx,by] = sib[nni][nnj];\n if(bx !=-1 && vis[bx][by]) continue;\n maxnp = max(maxnp, (ll)P[nni][nnj]);\n }\n ws[k] = val + maxnp + 1;\n }\n size_t idx;\n if(det) {\n ll mw = -1;\n idx = 0;\n for(size_t k=0; k mw) {\n mw = ws[k];\n idx = k;\n }\n } else {\n ll sumw = 0;\n for(auto w : ws) sumw += w;\n size_t sz = cands.size();\n if(sumw == 0 || sz == 0) {\n idx = 0;\n } else {\n uniform_int_distribution dist(0, sumw-1);\n ll target = dist(rng);\n idx = sz -1;\n ll cum = 0;\n for(size_t k=0; k best_score){ best_score=sc; best_path=pa; }\n const int TRIALS = 20000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n cout << best_path << endl;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n double horiz[30][29];\n double vert[29][30];\n int hcnt[30][29];\n int vcnt[29][30];\n for(int i = 0; i < 30; i++) {\n for(int j = 0; j < 29; j++) {\n horiz[i][j] = 5000.0;\n hcnt[i][j] = 0;\n }\n }\n for(int i = 0; i < 29; i++) {\n for(int j = 0; j < 30; j++) {\n vert[i][j] = 5000.0;\n vcnt[i][j] = 0;\n }\n }\n for(int q = 0; q < 1000; q++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n vector> dist(30, vector(30, 1e18));\n vector>> prev(30, vector>(30, {-1, -1}));\n dist[si][sj] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0.0, si, sj);\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n while (!pq.empty()) {\n auto [cost, r, c] = pq.top(); pq.pop();\n if (cost > dist[r][c]) continue;\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 30 || nc < 0 || nc >= 30) continue;\n double edgew = 1e18;\n if (d == 0) { // U\n edgew = vert[nr][c];\n } else if (d == 1) { // D\n edgew = vert[r][c];\n } else if (d == 2) { // L\n edgew = horiz[r][nc];\n } else if (d == 3) { // R\n edgew = horiz[r][c];\n }\n if (dist[nr][nc] > dist[r][c] + edgew) {\n dist[nr][nc] = dist[r][c] + edgew;\n prev[nr][nc] = {r, c};\n pq.emplace(dist[nr][nc], nr, nc);\n }\n }\n }\n double S = dist[ti][tj];\n vector pathv;\n int cr = ti, cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (cr > pr) pathv.push_back('D');\n else if (cr < pr) pathv.push_back('U');\n else if (cc > pc) pathv.push_back('R');\n else if (cc < pc) pathv.push_back('L');\n cr = pr;\n cc = pc;\n }\n reverse(pathv.begin(), pathv.end());\n string path;\n for (char ch : pathv) path += ch;\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n if (S >= 1e17) {\n continue;\n }\n double factor = (double)meas / S;\n cr = ti;\n cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (pr == cr) { // horizontal\n int minc = min(pc, cc);\n int cnt = hcnt[cr][minc];\n double alpha = min(0.7, 1.0 / (cnt + 2.0));\n double mult = 1.0 - alpha + alpha * factor;\n horiz[cr][minc] *= mult;\n hcnt[cr][minc]++;\n } else { // vertical\n int minr = min(pr, cr);\n int cnt = vcnt[minr][cc];\n double alpha = min(0.7, 1.0 / (cnt + 2.0));\n double mult = 1.0 - alpha + alpha * factor;\n vert[minr][cc] *= mult;\n vcnt[minr][cc]++;\n }\n cr = pr;\n cc = pc;\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct AhoCorasick {\n vector> trie;\n vector fail;\n vector> outs;\n int nodes;\n\n AhoCorasick() : nodes(1) {\n trie.emplace_back();\n trie[0].fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n\n void insert(const string& s, int idx) {\n int node = 0;\n for (char cc : s) {\n int c = (cc == '.' ? 8 : cc - 'A');\n if (trie[node][c] == -1) {\n trie[node][c] = nodes++;\n trie.emplace_back();\n trie.back().fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n node = trie[node][c];\n }\n outs[node].push_back(idx);\n }\n\n void build() {\n queue q;\n for (int c = 0; c < 9; c++) {\n if (trie[0][c] != -1) {\n int child = trie[0][c];\n fail[child] = 0;\n q.push(child);\n }\n }\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int c = 0; c < 9; c++) {\n if (trie[cur][c] != -1) {\n int child = trie[cur][c];\n int f = fail[cur];\n while (f != 0 && trie[f][c] == -1) f = fail[f];\n if (trie[f][c] != -1) f = trie[f][c];\n fail[child] = f;\n outs[child].insert(outs[child].end(), outs[f].begin(), outs[f].end());\n q.push(child);\n }\n }\n }\n }\n\n void run_on_arr(const int* seq, int len, vector& matched) {\n int node = 0;\n for (int i = 0; i < len; i++) {\n int c = seq[i];\n while (node && trie[node][c] < 0) node = fail[node];\n if (trie[node][c] >= 0) node = trie[node][c];\n else node = 0;\n for (int id : outs[node]) {\n matched[id] = 1;\n }\n }\n }\n};\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector strs(M);\n for (int i = 0; i < M; i++) {\n cin >> strs[i];\n }\n AhoCorasick ac;\n for (int i = 0; i < M; i++) {\n ac.insert(strs[i], i);\n }\n ac.build();\n\n const int MAXD = 32;\n int seq_arr[MAXD];\n int double_len = 31;\n\n auto fill_seq_row = [&](const vector>& g, int r, int* seq) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[r][pos];\n seq[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n auto fill_seq_col = [&](const vector>& g, int c, int* seq) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[pos][c];\n seq[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, 7);\n uniform_real_distribution prob_dist(0.0, 1.0);\n\n vector> grid(N, vector(N, '.'));\n vector idx(M);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int a, int b) {\n return strs[a].size() > strs[b].size();\n });\n\n for (int ii : idx) {\n const string& s = strs[ii];\n int len = s.size();\n bool placed = false;\n // horiz\n for (int row = 0; !placed && row < N; row++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nc = (st + p) % N;\n char exp = s[p];\n if (grid[row][nc] != '.' && grid[row][nc] != exp) {\n can = false;\n break;\n }\n }\n if (can) {\n for (int p = 0; p < len; p++) {\n int nc = (st + p) % N;\n grid[row][nc] = s[p];\n }\n placed = true;\n }\n }\n }\n // vert\n for (int col = 0; !placed && col < N; col++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nr = (st + p) % N;\n char exp = s[p];\n if (grid[nr][col] != '.' && grid[nr][col] != exp) {\n can = false;\n break;\n }\n }\n if (can) {\n for (int p = 0; p < len; p++) {\n grid[(st + p) % N][col] = s[p];\n }\n placed = true;\n }\n }\n }\n }\n\n const int TRIALS = 2;\n const int MAX_ITER = 150000;\n double cooling_rate = 0.99995;\n\n vector> best_grid = grid;\n int best_covered = 0;\n\n for (int trial = 0; trial < TRIALS; trial++) {\n vector> cur_grid = grid;\n // random fill dots for diversity\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (cur_grid[i][j] == '.') {\n cur_grid[i][j] = 'A' + dist(rng);\n }\n }\n }\n\n vector cover_cnt(M, 0);\n vector temp_matched(M, 0);\n int current_covered = 0;\n\n for (int r = 0; r < N; r++) {\n fill_seq_row(cur_grid, r, seq_arr);\n fill(temp_matched.begin(), temp_matched.end(), 0);\n ac.run_on_arr(seq_arr, double_len, temp_matched);\n for (int i = 0; i < M; i++) {\n if (temp_matched[i]) cover_cnt[i]++;\n }\n }\n for (int c = 0; c < N; c++) {\n fill_seq_col(cur_grid, c, seq_arr);\n fill(temp_matched.begin(), temp_matched.end(), 0);\n ac.run_on_arr(seq_arr, double_len, temp_matched);\n for (int i = 0; i < M; i++) {\n if (temp_matched[i]) cover_cnt[i]++;\n }\n }\n for (int i = 0; i < M; i++) {\n if (cover_cnt[i] > 0) current_covered++;\n }\n\n double temp = 5.0;\n vector old_row(M), old_col(M), new_row(M), new_col(M);\n\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int r = dist(rng) % N;\n int c_pos = dist(rng) % N;\n char old_ch = cur_grid[r][c_pos];\n char new_ch = 'A' + dist(rng);\n\n fill(old_row.begin(), old_row.end(), 0);\n fill(old_col.begin(), old_col.end(), 0);\n fill(new_row.begin(), new_row.end(), 0);\n fill(new_col.begin(), new_col.end(), 0);\n\n fill_seq_row(cur_grid, r, seq_arr);\n ac.run_on_arr(seq_arr, double_len, old_row);\n\n fill_seq_col(cur_grid, c_pos, seq_arr);\n ac.run_on_arr(seq_arr, double_len, old_col);\n\n cur_grid[r][c_pos] = new_ch;\n\n fill_seq_row(cur_grid, r, seq_arr);\n ac.run_on_arr(seq_arr, double_len, new_row);\n\n fill_seq_col(cur_grid, c_pos, seq_arr);\n ac.run_on_arr(seq_arr, double_len, new_col);\n\n int new_c = current_covered;\n for (int i = 0; i < M; i++) {\n if (old_row[i] || old_col[i] || new_row[i] || new_col[i]) {\n int d = 0;\n if (old_row[i]) d--;\n if (old_col[i]) d--;\n if (new_row[i]) d++;\n if (new_col[i]) d++;\n int newcnt = cover_cnt[i] + d;\n bool was = cover_cnt[i] > 0;\n bool will = newcnt > 0;\n if (was && !will) new_c--;\n else if (!was && will) new_c++;\n }\n }\n\n bool accept = false;\n int delta = new_c - current_covered;\n if (delta > 0) {\n accept = true;\n } else if (delta == 0) {\n if (prob_dist(rng) < 0.05) accept = true;\n } else {\n double prob = exp((double)delta / temp);\n if (prob_dist(rng) < prob) accept = true;\n }\n\n if (accept) {\n for (int i = 0; i < M; i++) {\n if (old_row[i] || old_col[i] || new_row[i] || new_col[i]) {\n int d = 0;\n if (old_row[i]) d--;\n if (old_col[i]) d--;\n if (new_row[i]) d++;\n if (new_col[i]) d++;\n cover_cnt[i] += d;\n }\n }\n current_covered = new_c;\n } else {\n cur_grid[r][c_pos] = old_ch;\n }\n\n temp *= cooling_rate;\n if (temp < 0.001) temp = 0.001;\n }\n\n if (current_covered > best_covered) {\n best_covered = current_covered;\n best_grid = cur_grid;\n }\n }\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << best_grid[i][j];\n }\n cout << endl;\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\nusing ll = long long;\nconst ll INF = 1LL << 60;\n\nint main() {\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n int cost[69][69];\n memset(cost, 0, sizeof(cost));\n vector> all_roads;\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n all_roads.emplace_back(i, j);\n }\n int hofs[69][69];\n int vofs[69][69];\n memset(hofs, -1, sizeof(hofs));\n memset(vofs, -1, sizeof(vofs));\n vector>> hsegs, vsegs;\n int nh = 0, nv = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N;) {\n if (grid[i][j] == '#') {\n j++;\n continue;\n }\n auto& seg = hsegs.emplace_back();\n while (j < N && grid[i][j] != '#') {\n hofs[i][j] = nh;\n seg.emplace_back(i, j);\n j++;\n }\n nh++;\n }\n }\n for (int j = 0; j < N; j++) {\n for (int i = 0; i < N;) {\n if (grid[i][j] == '#') {\n i++;\n continue;\n }\n auto& seg = vsegs.emplace_back();\n while (i < N && grid[i][j] != '#') {\n vofs[i][j] = nv;\n seg.emplace_back(i, j);\n i++;\n }\n nv++;\n }\n }\n bool cellcov[69][69] = {};\n if (hofs[si][sj] != -1) {\n int h = hofs[si][sj];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[si][sj];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n }\n vector> targets;\n auto count_remain = [&]() {\n int cnt = 0;\n for (auto [x, y] : all_roads)\n if (!cellcov[x][y]) cnt++;\n return cnt;\n };\n int remain = count_remain();\n while (remain > 0) {\n int maxg = 0;\n pair bp = {-1, -1};\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g > maxg) {\n maxg = g;\n bp = p;\n }\n }\n if (maxg == 0) break;\n targets.push_back(bp);\n int h = hofs[bp.first][bp.second];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[bp.first][bp.second];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n remain -= maxg;\n }\n vector> points;\n points.emplace_back(si, sj);\n for (auto tp : targets) {\n if (tp.first != si || tp.second != sj) points.push_back(tp);\n }\n int mm = points.size();\n vector> dmat(mm, vector(mm, INF));\n vector>>> par_store(\n mm, vector>>(N, vector>(N, {-1, -1})));\n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n for (int s = 0; s < mm; s++) {\n auto [sx, sy] = points[s];\n vector> dd(N, vector(N, INF));\n vector>> pr(N, vector>(N, {-1, -1}));\n dd[sx][sy] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0LL, sx, sy);\n while (!pq.empty()) {\n auto [cst, x, y] = pq.top();\n pq.pop();\n if (cst > dd[x][y]) continue;\n for (int d = 0; d < 4; d++) {\n int nx = x + di[d], ny = y + dj[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && grid[nx][ny] != '#') {\n ll nc = cst + cost[nx][ny];\n if (nc < dd[nx][ny]) {\n dd[nx][ny] = nc;\n pr[nx][ny] = {x, y};\n pq.emplace(nc, nx, ny);\n }\n }\n }\n }\n for (int p = 0; p < mm; p++) {\n auto [px, py] = points[p];\n dmat[s][p] = dd[px][py];\n }\n for (int x = 0; x < N; x++)\n for (int y = 0; y < N; y++) par_store[s][x][y] = pr[x][y];\n }\n struct Edge {\n ll c;\n int u, v;\n bool operator<(const Edge& o) const { return c < o.c; }\n };\n vector edges;\n for (int i = 0; i < mm; i++)\n for (int j = i + 1; j < mm; j++) {\n if (dmat[i][j] < INF) edges.push_back({dmat[i][j], i, j});\n }\n sort(edges.begin(), edges.end());\n vector paruf(mm);\n iota(paruf.begin(), paruf.end(), 0);\n auto findf = [&](auto&& self, int x) -> int {\n return paruf[x] == x ? x : paruf[x] = self(self, paruf[x]);\n };\n auto unionf = [&](int x, int y) {\n x = findf(findf, x);\n y = findf(findf, y);\n if (x != y) paruf[x] = y;\n };\n vector> adj(mm);\n for (auto& e : edges) {\n if (findf(findf, e.u) != findf(findf, e.v)) {\n unionf(e.u, e.v);\n adj[e.u].push_back(e.v);\n adj[e.v].push_back(e.u);\n }\n }\n vector euler_t;\n function dfs_e = [&](int u, int p) {\n euler_t.push_back(u);\n for (int v : adj[u])\n if (v != p) {\n dfs_e(v, u);\n euler_t.push_back(u);\n }\n };\n dfs_e(0, -1);\n vector path(mm);\n vector viss(mm, false);\n int cntv = 0;\n for (int nd : euler_t) {\n if (!viss[nd]) {\n viss[nd] = true;\n path[cntv++] = nd;\n }\n }\n // build nn\n vector nn_path;\n {\n vector vis_nn(mm, false);\n int cur = 0;\n nn_path.push_back(0);\n vis_nn[0] = true;\n while (nn_path.size() < (size_t)mm) {\n ll md = INF;\n int nx = -1;\n for (int j = 0; j < mm; j++) {\n if (!vis_nn[j] && dmat[cur][j] < md) {\n md = dmat[cur][j];\n nx = j;\n }\n }\n if (nx == -1) break;\n nn_path.push_back(nx);\n vis_nn[nx] = true;\n cur = nx;\n }\n }\n ll mst_tot = 0;\n if (path.size() == (size_t)mm) {\n for (int ii = 0; ii < mm; ii++) {\n mst_tot += dmat[path[ii]][path[(ii + 1) % mm]];\n }\n } else {\n mst_tot = INF;\n }\n ll nn_tot = 0;\n if (nn_path.size() == (size_t)mm) {\n for (size_t ii = 0; ii < nn_path.size(); ii++) {\n int aa = nn_path[ii];\n int bb = nn_path[(ii + 1) % mm];\n nn_tot += dmat[aa][bb];\n }\n } else {\n nn_tot = INF;\n }\n if (nn_path.size() == (size_t)mm && nn_tot < mst_tot) {\n path = nn_path;\n }\n // swaps improve\n for (int iter = 0; iter < 10; iter++) {\n bool imp = false;\n for (int i = 1; i < mm; i++) {\n for (int j = i + 1; j < mm; j++) {\n if (min(abs(i - j), mm - abs(i - j)) <= 1) continue;\n int pa = (i - 1 + mm) % mm;\n int na = (i + 1) % mm;\n int pb = (j - 1 + mm) % mm;\n int nb = (j + 1) % mm;\n ll oldd = dmat[path[pa]][path[i]] + dmat[path[i]][path[na]] +\n dmat[path[pb]][path[j]] + dmat[path[j]][path[nb]];\n ll newd = dmat[path[pa]][path[j]] + dmat[path[j]][path[na]] +\n dmat[path[pb]][path[i]] + dmat[path[i]][path[nb]];\n if (newd < oldd) {\n swap(path[i], path[j]);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n string route = \"\";\n for (int k = 0; k < mm; k++) {\n int fid = path[k];\n int tid = path[(k + 1) % mm];\n if (fid == tid) continue;\n auto [sx, sy] = points[fid];\n auto [tx, ty] = points[tid];\n vector subm;\n int cx = tx, cy = ty;\n while (cx != sx || cy != sy) {\n auto [px, py] = par_store[fid][cx][cy];\n if (px == -1) break;\n int dx = cx - px;\n int dy = cy - py;\n char mv;\n if (dx == -1) mv = 'U';\n else if (dx == 1) mv = 'D';\n else if (dy == -1) mv = 'L';\n else if (dy == 1) mv = 'R';\n else break;\n subm.push_back(mv);\n cx = px;\n cy = py;\n }\n reverse(subm.begin(), subm.end());\n for (char c : subm) route += c;\n }\n cout << route << endl;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n vector> difficulty(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> difficulty[i][k];\n }\n }\n vector> adj(N);\n vector prereq_count(N, 0);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--;\n v--;\n adj[u].push_back(v);\n prereq_count[v]++;\n }\n vector longest_chain(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n longest_chain[i] = 1;\n for (int v : adj[i]) {\n longest_chain[i] = max(longest_chain[i], 1 + longest_chain[v]);\n }\n }\n vector> est_s(M, vector(K, 0));\n vector status(N, 0); // 0 not, 1 prog, 2 done\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector workload(M, 0);\n int day = 0;\n auto estimate = [&](int task, int mem) -> int {\n int w = 0;\n for (int k = 0; k < K; k++) {\n w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (w == 0) return 1;\n // optional scaling if needed but s update handles\n return w;\n };\n while (true) {\n day++;\n vector free_m;\n for (int j = 0; j < M; j++)\n if (current_task[j] == -1) free_m.push_back(j);\n vector ready;\n for (int i = 0; i < N; i++) {\n if (status[i] == 0 && prereq_count[i] == 0) ready.push_back(i);\n }\n vector> assigns; // mem, task\n set avail_free(free_m.begin(), free_m.end());\n sort(ready.begin(), ready.end(), [&](int a, int b) {\n return longest_chain[a] > longest_chain[b] ||\n (longest_chain[a] == longest_chain[b] && a < b);\n });\n for (int rid = 0; rid < ready.size(); rid++) {\n if (avail_free.empty()) break;\n int ta = ready[rid];\n int best_mem = -1;\n int best_et = INT_MAX;\n int best_wl = INT_MAX;\n for (int jm : avail_free) {\n int et = estimate(ta, jm);\n int wl = workload[jm];\n if (et < best_et ||\n (et == best_et &&\n (wl < best_wl || (wl == best_wl && jm < best_mem)))) {\n best_et = et;\n best_wl = wl;\n best_mem = jm;\n }\n }\n if (best_mem != -1) {\n assigns.emplace_back(best_mem, ta);\n avail_free.erase(best_mem);\n workload[best_mem] += best_et;\n }\n }\n // output\n cout << assigns.size();\n for (auto [jm, ta] : assigns) {\n cout << \" \" << (jm + 1) << \" \" << (ta + 1);\n }\n cout << endl << flush;\n // set assignments\n for (auto [jm, ta] : assigns) {\n current_task[jm] = ta;\n start_day[jm] = day;\n status[ta] = 1;\n }\n // read\n int ncomp;\n cin >> ncomp;\n if (ncomp == -1) {\n break;\n }\n vector comps(ncomp);\n for (int i = 0; i < ncomp; i++) {\n cin >> comps[i];\n }\n for (int cf : comps) {\n int mem = cf - 1;\n if (current_task[mem] == -1) continue;\n int task = current_task[mem];\n int t = day - start_day[mem] + 1;\n if (t == 1) {\n for (int k = 0; k < K; k++) {\n est_s[mem][k] = max(est_s[mem][k], difficulty[task][k]);\n }\n }\n int curr_w = 0;\n for (int k = 0; k < K; k++) {\n curr_w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n int obs_w = (t <= 1 ? 0 : t);\n int num_def = 0;\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) num_def++;\n }\n if (curr_w > obs_w && num_def > 0) {\n int gap = curr_w - obs_w;\n int incr = max(1, gap / (3 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] += incr;\n }\n }\n } else if (curr_w < obs_w && num_def > 0) {\n int gap = obs_w - curr_w;\n int decr = max(1, gap / (3 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] = max(0, est_s[mem][k] - decr);\n }\n }\n }\n status[task] = 2;\n current_task[mem] = -1;\n for (int v : adj[task]) {\n prereq_count[v]--;\n }\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\nint manh(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\nbool is_valid(const vector& perm, int n) {\n int m = 2 * n;\n vector pos(m);\n for (int i = 0; i < m; i++) pos[perm[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) return false;\n }\n return true;\n}\n\nint calc_cost(const vector& perm, const vector& pts, Point C, int n) {\n int m = 2 * n;\n if (perm.size() != m) return INT_MAX;\n int cost = manh(C, pts[perm[0]]);\n for (int i = 0; i < m - 1; i++) {\n cost += manh(pts[perm[i]], pts[perm[i + 1]]);\n }\n cost += manh(pts[perm.back()], C);\n return cost;\n}\n\npair> greedy_cost_and_path(const vector& S, Point C, const vector& allP, const vector& allD, int n) {\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n vector mate(2 * n);\n for (int i = 0; i < n; i++) {\n mate[i] = n + i;\n mate[n + i] = i;\n }\n vector visited(2 * n, false);\n vector feasible(2 * n, false);\n for (int i = 0; i < n; i++) feasible[i] = true;\n vector perm;\n perm.reserve(2 * n);\n Point curr = C;\n int total = 0;\n bool possible = true;\n for (int step = 0; step < 2 * n && possible; step++) {\n int best_d = INT_MAX;\n int best_idx = -1;\n for (int i = 0; i < 2 * n; i++) {\n if (!visited[i] && feasible[i]) {\n int dd = manh(curr, pts[i]);\n if (dd < best_d) {\n best_d = dd;\n best_idx = i;\n }\n }\n }\n if (best_idx == -1) {\n possible = false;\n break;\n }\n total += best_d;\n perm.push_back(best_idx);\n visited[best_idx] = true;\n curr = pts[best_idx];\n int m = mate[best_idx];\n if (!visited[m]) feasible[m] = true;\n }\n if (possible) total += manh(curr, C);\n else total = INT_MAX;\n return {total, perm};\n}\n\nvoid optimize_perm(vector& best_perm_out, int& best_cost_out, const vector& S, Point C, const vector& allP, const vector& allD, mt19937& rng) {\n int n = S.size();\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n auto [gcost, gperm] = greedy_cost_and_path(S, C, allP, allD, n);\n vector current_perm;\n int curr_cost;\n if (gperm.size() == 2 * n) {\n current_perm = gperm;\n curr_cost = gcost;\n } else {\n current_perm.resize(2*n);\n iota(current_perm.begin(), current_perm.end(), 0);\n curr_cost = INT_MAX;\n }\n vector best_perm = current_perm;\n int best_cost = curr_cost;\n double T = 20000.0;\n int m = 2 * n;\n uniform_int_distribution dpos(0, m - 1);\n uniform_real_distribution dprob(0.0, 1.0);\n for (int it = 0; it < 400000; it++) {\n vector new_perm = current_perm;\n int typ = rng() % 4;\n bool can_change = false;\n int i = dpos(rng);\n int j = dpos(rng);\n if (typ == 0) { // swap\n if (i != j) {\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n } else if (typ == 1) { // insert\n if (i != j) {\n int val = new_perm[i];\n new_perm.erase(new_perm.begin() + i);\n int jj = (j > i ? j - 1 : j);\n new_perm.insert(new_perm.begin() + jj, val);\n can_change = true;\n }\n } else if (typ == 2) { // reverse\n if (i > j) swap(i, j);\n if (i != j) {\n reverse(new_perm.begin() + i, new_perm.begin() + j + 1);\n can_change = true;\n }\n } else { // adjacent swap\n j = (i + 1) % m;\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n if (can_change && is_valid(new_perm, n)) {\n int new_cost = calc_cost(new_perm, pts, C, n);\n if (new_cost < INT_MAX) {\n double delta = new_cost - curr_cost;\n if (delta < 0 || (T > 0 && exp(-delta / T) > dprob(rng))) {\n current_perm = new_perm;\n curr_cost = new_cost;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n }\n }\n }\n T *= 0.99993;\n }\n // final exhaustive hill-climbing polish using swaps and inserts\n current_perm = best_perm;\n curr_cost = best_cost;\n int phases = 0;\n const int max_phases = 30;\n bool improved_global = true;\n while (improved_global && phases < max_phases) {\n improved_global = false;\n phases++;\n // best improving swap\n int min_newc = curr_cost;\n vector best_np;\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n swap(np[ii], np[jj]);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n improved_global = true;\n }\n // best improving insert\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = 0; jj < m; jj++) {\n if (ii == jj) continue;\n vector np = current_perm;\n int val = np[ii];\n np.erase(np.begin() + ii);\n int jj_adj = (jj > ii ? jj - 1 : jj);\n np.insert(np.begin() + jj_adj, val);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n improved_global = true;\n }\n }\n if (best_cost < best_cost_out) {\n best_cost_out = best_cost;\n best_perm_out = best_perm;\n }\n}\n\nint main() {\n vector allP(1000), allD(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> allP[i].x >> allP[i].y >> allD[i].x >> allD[i].y;\n }\n Point C = {400, 400};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n vector centers;\n centers.push_back(C);\n int step = 55;\n for (int cx = 40; cx < 760; cx += step) {\n for (int cy = 40; cy < 760; cy += step) {\n centers.push_back({cx, cy});\n }\n }\n for (int i = 0; i < 80; i++) {\n centers.push_back({rng() % 801, rng() % 801});\n }\n int n = 50;\n int best_T = INT_MAX;\n vector best_S;\n for (auto& cen : centers) {\n vector> dists;\n for (int i = 0; i < 1000; i++) {\n Point mid = {(allP[i].x + allD[i].x) / 2, (allP[i].y + allD[i].y) / 2};\n int dd = manh(mid, cen);\n dists.emplace_back(dd, i);\n }\n sort(dists.begin(), dists.end());\n vector S;\n for (int i = 0; i < n; i++) S.push_back(dists[i].second);\n auto [gcost, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gcost < best_T) {\n best_T = gcost;\n best_S = S;\n }\n }\n vector> ind_cost;\n for (int i = 0; i < 1000; i++) {\n int cc = manh(C, allP[i]) + manh(allP[i], allD[i]) + manh(allD[i], C);\n ind_cost.emplace_back(cc, i);\n }\n sort(ind_cost.begin(), ind_cost.end());\n vector S_small;\n for (int i = 0; i < n; i++) S_small.push_back(ind_cost[i].second);\n auto [gcost2, gp2] = greedy_cost_and_path(S_small, C, allP, allD, n);\n if (gcost2 < best_T) {\n best_T = gcost2;\n best_S = S_small;\n }\n for (int tri = 0; tri < 30; tri++) {\n vector all(1000);\n iota(all.begin(), all.end(), 0);\n shuffle(all.begin(), all.end(), rng);\n vector S(all.begin(), all.begin() + n);\n auto [gc, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gc < best_T) {\n best_T = gc;\n best_S = S;\n }\n }\n int opt_cost = INT_MAX;\n vector opt_perm;\n optimize_perm(opt_perm, opt_cost, best_S, C, allP, allD, rng);\n for (int trial = 0; trial < 60; trial++) {\n uniform_int_distribution dis_in(0, n - 1);\n uniform_int_distribution dis_out(0, 999);\n vector newS = best_S;\n int in_idx = dis_in(rng);\n int out = dis_out(rng);\n bool has = false;\n for (int s : newS) if (s == out) { has = true; break; }\n if (has) continue;\n newS[in_idx] = out;\n auto [gc, gp] = greedy_cost_and_path(newS, C, allP, allD, n);\n if (gc < opt_cost * 1.05 && gc < INT_MAX) {\n int new_opt_cost = INT_MAX;\n vector new_opt_perm;\n optimize_perm(new_opt_perm, new_opt_cost, newS, C, allP, allD, rng);\n if (new_opt_cost < opt_cost) {\n opt_cost = new_opt_cost;\n opt_perm = new_opt_perm;\n best_S = newS;\n best_T = gc;\n }\n }\n }\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[best_S[i]];\n pts[n + i] = allD[best_S[i]];\n }\n vector route;\n route.push_back(C);\n for (int t : opt_perm) {\n route.push_back(pts[t]);\n }\n route.push_back(C);\n cout << 50;\n for (int r : best_S) cout << \" \" << (r + 1);\n cout << endl;\n cout << route.size();\n for (auto p : route) cout << \" \" << p.x << \" \" << p.y;\n cout << endl;\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v, idx, d, l;\n bool backup;\n};\n\nvector edges;\nvector par;\n\nint find(int x) {\n return par[x] == x ? x : par[x] = find(par[x]);\n}\n\nbool unite(int x, int y) {\n x = find(x);\n y = find(y);\n if (x == y) return false;\n par[x] = y;\n return true;\n}\n\nint main() {\n vector x(400), y(400);\n for (int i = 0; i < 400; i++) {\n cin >> x[i] >> y[i];\n }\n int M = 1995;\n edges.resize(M);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i].u = u;\n edges[i].v = v;\n edges[i].idx = i;\n edges[i].l = -1;\n edges[i].backup = false;\n double dx = x[u] - x[v];\n double dy = y[u] - y[v];\n double dist = hypot(dx, dy);\n edges[i].d = (int)round(dist);\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].d < edges[b].d;\n });\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n int cnt = 0;\n for (int i : ord) {\n if (unite(edges[i].u, edges[i].v)) {\n edges[i].backup = true;\n cnt++;\n if (cnt == 399) break;\n }\n }\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n for (int i = 0; i < M; i++) {\n int l;\n cin >> l;\n edges[i].l = l;\n int u = edges[i].u, v = edges[i].v;\n int pu = find(u);\n int pv = find(v);\n int ans = 0;\n if (pu != pv) {\n if (edges[i].backup) {\n ans = 1;\n } else {\n int md = edges[i].d;\n int min_fut = INT_MAX / 2;\n for (int j = i + 1; j < M; j++) {\n int uj = edges[j].u;\n int vj = edges[j].v;\n int pj1 = find(uj);\n int pj2 = find(vj);\n if ((pj1 == pu && pj2 == pv) || (pj1 == pv && pj2 == pu)) {\n min_fut = min(min_fut, edges[j].d);\n }\n }\n if (min_fut < INT_MAX / 2) {\n md = min(md, min_fut);\n }\n if (l <= 2 * md) {\n ans = 1;\n }\n }\n if (ans == 1) {\n unite(u, v);\n }\n }\n cout << ans << endl;\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n cin >> 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 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 const int W = 30;\n vector> is_blocked(W + 2, vector(W + 2, false));\n vector> human_pos(M);\n for (int i = 0; i < M; i++) human_pos[i] = {hx[i], hy[i]};\n vector> pet_pos(N);\n for (int i = 0; i < N; i++) pet_pos[i] = {px[i], py[i]};\n vector dx = {-1, 1, 0, 0};\n vector dy = {0, 0, -1, 1};\n char move_char[4] = {'U', 'D', 'L', 'R'};\n char block_char[4] = {'u', 'd', 'l', 'r'};\n auto valid = [&](int x, int y) {\n return x >= 1 && x <= W && y >= 1 && y <= W && !is_blocked[x][y];\n };\n auto is_occupied_func = nullptr; // defined per turn\n vector> stand_pos, wall_pos;\n int wall_size = 20;\n int right_c = wall_size + 1;\n int bottom_r = wall_size + 1;\n for (int r = 1; r <= wall_size; r++) {\n stand_pos.emplace_back(r, wall_size);\n wall_pos.emplace_back(r, right_c);\n }\n for (int c = 1; c <= wall_size; c++) {\n stand_pos.emplace_back(wall_size, c);\n wall_pos.emplace_back(bottom_r, c);\n }\n set> wall_set(wall_pos.begin(), wall_pos.end());\n mt19937 rng(42);\n for (int turn = 0; turn < 300; turn++) {\n vector> next_hpos(M);\n string actions_str(M, '.');\n set> targeted_moves;\n set> this_turn_blocked;\n vector> is_occupied(W + 2, vector(W + 2, false));\n for (int i = 0; i < N; i++) {\n auto [x, y] = pet_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n for (int i = 0; i < M; i++) {\n auto [x, y] = human_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n auto can_block = [&](int tx, int ty) {\n if (!valid(tx, ty) || is_occupied[tx][ty]) return false;\n for (int d = 0; d < 4; d++) {\n int px = tx + dx[d];\n int py = ty + dy[d];\n if (valid(px, py) && is_occupied[px][py]) return false;\n }\n return true;\n };\n vector assigned_idx(M, -1);\n vector used_stand(stand_pos.size(), false);\n if (turn >= 150) {\n for (int i = 0; i < M; i++) {\n int best_j = -1;\n int best_d = INT_MAX;\n for (int j = 0; j < (int)stand_pos.size(); j++) {\n auto [wx, wy] = wall_pos[j];\n if (is_blocked[wx][wy]) continue;\n if (used_stand[j]) continue;\n auto [sx, sy] = stand_pos[j];\n int dist = abs(human_pos[i].first - sx) + abs(human_pos[i].second - sy);\n if (dist < best_d) {\n best_d = dist;\n best_j = j;\n }\n }\n if (best_j != -1) {\n assigned_idx[i] = best_j;\n used_stand[best_j] = true;\n }\n }\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for (int k = 0; k < M; k++) {\n int i = ord[k];\n auto [x, y] = human_pos[i];\n bool did = false;\n int t_idx = assigned_idx[i];\n if (turn < 150 || t_idx == -1) {\n // gather to center\n int cx = 15, cy = 15;\n vector> candidates;\n if (x < cx && valid(x + 1, y)) candidates.emplace_back(1, 'D');\n if (x > cx && valid(x - 1, y)) candidates.emplace_back(0, 'U');\n if (y < cy && valid(x, y + 1)) candidates.emplace_back(3, 'R');\n if (y > cy && valid(x, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n } else {\n auto [tx, ty] = stand_pos[t_idx];\n if (x == tx && y == ty) {\n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int bx = x + dx[d];\n int by = y + dy[d];\n if (wall_set.count({bx, by}) && can_block(bx, by)) {\n actions_str[i] = block_char[d];\n this_turn_blocked.insert({bx, by});\n is_blocked[bx][by] = true;\n next_hpos[i] = {x, y};\n did = true;\n break;\n }\n }\n } else {\n vector> candidates;\n if (x < tx && valid(x + 1, ty)) candidates.emplace_back(1, 'D');\n if (x > tx && valid(x - 1, ty)) candidates.emplace_back(0, 'U');\n if (y < ty && valid(tx, y + 1)) candidates.emplace_back(3, 'R');\n if (y > ty && valid(tx, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n }\n }\n if (!did) {\n actions_str[i] = '.';\n next_hpos[i] = {x, y};\n }\n }\n // output\n cout << actions_str << endl;\n cout.flush();\n // read pet moves\n vector pet_moves(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n // update human_pos\n for (int i = 0; i < M; i++) {\n human_pos[i] = next_hpos[i];\n }\n // update pet_pos\n for (int i = 0; i < N; i++) {\n int x = pet_pos[i].first, y = pet_pos[i].second;\n string mv = pet_moves[i];\n for (char c : mv) {\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n if (d != -1) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (valid(nx, ny)) {\n x = nx;\n y = ny;\n }\n }\n }\n pet_pos[i] = {x, y};\n }\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\ndouble compute_ES(const vector& sseq, double pp, int ssr, int ssc, int ttr, int ttc, int HH[20][19], int VV[19][20]) {\n double prb[20][20] = {};\n prb[ssr][ssc] = 1.0;\n double ES = 0.0;\n int LL = sseq.size();\n for (int tt = 0; tt < LL; tt++) {\n double rch = 0.0;\n double np[20][20] = {};\n char dr = sseq[tt];\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double prr = prb[i][j];\n if (prr < 1e-20 || (i == ttr && j == ttc)) continue;\n np[i][j] += prr * pp;\n int nii = i, njj = j;\n bool cm = false;\n if (dr == 'D' && i < 19 && VV[i][j] == 0) { nii++; cm = true; }\n else if (dr == 'U' && i > 0 && VV[i - 1][j] == 0) { nii--; cm = true; }\n else if (dr == 'R' && j < 19 && HH[i][j] == 0) { njj++; cm = true; }\n else if (dr == 'L' && j > 0 && HH[i][j - 1] == 0) { njj--; cm = true; }\n if (cm) {\n if (nii == ttr && njj == ttc) {\n rch += prr * (1 - pp);\n } else {\n np[nii][njj] += prr * (1 - pp);\n }\n } else {\n np[i][j] += prr * (1 - pp);\n }\n }\n }\n ES += rch * (401.0 - (tt + 1));\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prb[i][j] = np[i][j];\n }\n return ES;\n}\n\nint main() {\n int sr, sc, tr, tc;\n double p;\n cin >> sr >> sc >> tr >> tc >> p;\n int h[20][19];\n for (int i = 0; i < 20; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 19; j++) h[i][j] = s[j] - '0';\n }\n int v[19][20];\n for (int i = 0; i < 19; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 20; j++) v[i][j] = s[j] - '0';\n }\n const int INF = 10000;\n int dist[20][20];\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) dist[i][j] = INF;\n dist[tr][tc] = 0;\n queue> q;\n q.push({tr, tc});\n while (!q.empty()) {\n auto cur = q.front();\n q.pop();\n int x = cur.first, y = cur.second;\n int d = dist[x][y];\n if (y < 19 && h[x][y] == 0) {\n int nx = x, ny = y + 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (y > 0 && h[x][y - 1] == 0) {\n int nx = x, ny = y - 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x < 19 && v[x][y] == 0) {\n int nx = x + 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x > 0 && v[x - 1][y] == 0) {\n int nx = x - 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) if (dist[i][j] == INF) dist[i][j] = 50;\n vector dirs_list = {'D', 'R', 'L', 'U'};\n double best_init_E = -1e9;\n vector best_init_seq;\n srand(time(NULL));\n for (int rep = 0; rep < 20; rep++) {\n vector dir_order = {'D', 'R', 'L', 'U'};\n random_shuffle(dir_order.begin(), dir_order.end());\n double prob[20][20] = {};\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = 0.0;\n prob[sr][sc] = 1.0;\n vector seq;\n for (int stp = 0; stp < 200; stp++) {\n double cur_r = 0.0;\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n cur_r += prob[i][j];\n }\n double best_score = -1e100;\n char bestc = ' ';\n for (int di = 0; di < 4; di++) {\n char dir = dir_order[di];\n double reach = 0.0;\n double newp[20][20] = {};\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (dir == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (dir == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (dir == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (dir == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n double eds = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n eds += newp[i][j] * dist[i][j];\n }\n }\n double score = -eds + 20.0 * reach;\n if (score > best_score + 1e-9) {\n best_score = score;\n bestc = dir;\n }\n }\n if (bestc == ' ') break;\n double newp[20][20] = {};\n double reach = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (bestc == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (bestc == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (bestc == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (bestc == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = newp[i][j];\n seq.push_back(bestc);\n }\n double this_E = compute_ES(seq, p, sr, sc, tr, tc, h, v);\n if (this_E > best_init_E + 1e-9) {\n best_init_E = this_E;\n best_init_seq = seq;\n }\n }\n vector best_seq = best_init_seq;\n double best_E = best_init_E;\n int L = best_seq.size();\n if (L > 0 && L <= 200) {\n char dir_options[4] = {'U', 'D', 'L', 'R'};\n for (int trial = 0; trial < 2000; trial++) {\n int pos = rand() % L;\n char original = best_seq[pos];\n for (int d = 0; d < 4; d++) {\n char new_dir = dir_options[d];\n if (new_dir == original) continue;\n best_seq[pos] = new_dir;\n double newE = compute_ES(best_seq, p, sr, sc, tr, tc, h, v);\n if (newE > best_E + 1e-9) {\n best_E = newE;\n } else {\n best_seq[pos] = original;\n }\n }\n }\n }\n string ans = \"\";\n for (char c : best_seq) ans += c;\n if (ans.size() > 200) ans = ans.substr(0, 200);\n cout << ans << endl;\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30;\nconst int W = 30;\nconst int D = 4;\nconst int SZ = H * W * D;\n\nint TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\nint DI[4] = {0, -1, 0, 1};\nint DJ[4] = {-1, 0, 1, 0};\n\nstatic int current_time = 0;\nstatic int timestamp[SZ];\nstatic int pstep[SZ];\nstatic bool vis[SZ];\n\nint get_eff(int o, int r) {\n if (o < 4) return (o + r) % 4;\n if (o == 4) return (r % 2 ? 5 : 4);\n if (o == 5) return (r % 2 ? 4 : 5);\n if (o == 6) return (r % 2 ? 7 : 6);\n return (r % 2 ? 6 : 7);\n}\n\nlong long compute_cycles(int t[H][W], int r[H][W], int& len1, int& len2) {\n if (current_time > 2000000000) {\n current_time = 0;\n memset(timestamp, 0, sizeof(timestamp));\n }\n int eff[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n eff[i][j] = get_eff(t[i][j], r[i][j]);\n }\n }\n static int next_state[SZ];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n for (int d = 0; d < D; d++) {\n int idx = ((i * W + j) * D + d);\n int d2 = TO[eff[i][j]][d];\n if (d2 == -1) {\n next_state[idx] = -1;\n continue;\n }\n int ni = i + DI[d2];\n int nj = j + DJ[d2];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) {\n next_state[idx] = -1;\n continue;\n }\n int nd = (d2 + 2) % 4;\n next_state[idx] = ((ni * W + nj) * D + nd);\n }\n }\n }\n memset(vis, 0, sizeof(vis));\n len1 = 0;\n len2 = 0;\n int path_arr[4010];\n for (int s = 0; s < SZ; s++) {\n if (!vis[s]) {\n if (next_state[s] == -1) {\n vis[s] = true;\n continue;\n }\n int path_len = 0;\n int cur = s;\n int this_t = ++current_time;\n timestamp[cur] = this_t;\n pstep[cur] = 0;\n path_arr[path_len++] = cur;\n bool foundc = false;\n int cst = 0;\n int nxt;\n bool hit_limit = false;\n while (true) {\n nxt = next_state[cur];\n if (nxt == -1) break;\n if (vis[nxt]) break;\n if (timestamp[nxt] == this_t) {\n foundc = true;\n cst = pstep[nxt];\n break;\n }\n if (path_len >= 4005) {\n hit_limit = true;\n break;\n }\n path_arr[path_len] = nxt;\n timestamp[nxt] = this_t;\n pstep[nxt] = path_len;\n path_len++;\n cur = nxt;\n }\n if (foundc) {\n int cl = path_len - cst;\n if (cl > len1) {\n len2 = len1;\n len1 = cl;\n } else if (cl > len2) {\n len2 = cl;\n }\n }\n for (int p = 0; p < path_len; p++) {\n vis[path_arr[p]] = true;\n }\n }\n }\n if (len1 > 0 && len2 > 0) return 1LL * len1 * len2;\n return 0;\n}\n\nint main() {\n int orig[H][W];\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n orig[i][j] = s[j] - '0';\n }\n }\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution randr(0, 3);\n int cur_r[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n cur_r[i][j] = randr(rng);\n }\n }\n int cl1, cl2;\n long long cur_sc = compute_cycles(orig, cur_r, cl1, cl2);\n long long best_sc = cur_sc;\n int best_r[H][W];\n memcpy(best_r, cur_r, sizeof(best_r));\n const int MAX_ITER = 15000;\n double temp = 50000.0;\n double cooling = 0.9998;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int new_r[H][W];\n memcpy(new_r, cur_r, sizeof(cur_r));\n int nmut = 2;\n for (int k = 0; k < nmut; k++) {\n int pos = rng() % (H * W);\n int i = pos / W;\n int j = pos % W;\n int delta = (randr(rng) % 3) + 1;\n new_r[i][j] = (new_r[i][j] + delta) % 4;\n }\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n long long delta = new_sc - cur_sc;\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if ((double)rng() / rng.max() < prob) accept = true;\n }\n if (accept) {\n memcpy(cur_r, new_r, sizeof(cur_r));\n cur_sc = new_sc;\n if (cur_sc > best_sc) {\n best_sc = cur_sc;\n memcpy(best_r, cur_r, sizeof(best_r));\n }\n }\n temp *= cooling;\n }\n // local hill climbing, limited passes and optimize\n int temp_r[H][W];\n memcpy(temp_r, best_r, sizeof(best_r));\n long long temp_sc = best_sc;\n bool improved = true;\n int passes = 0;\n int local_iters = 0;\n const int MAX_LOCAL_EVAL = 5000;\n while (improved && passes < 3 && local_iters < MAX_LOCAL_EVAL) {\n improved = false;\n passes++;\n for (int pos = 0; pos < H*W; pos++) {\n if (local_iters >= MAX_LOCAL_EVAL) break;\n int i = pos / W;\n int j = pos % W;\n int oldr = temp_r[i][j];\n long long best_this_sc = temp_sc;\n int best_this_r = oldr;\n for (int nr = 0; nr < 4; nr++) {\n temp_r[i][j] = nr;\n int tl1, tl2;\n long long sc = compute_cycles(orig, temp_r, tl1, tl2);\n local_iters++;\n if (sc > best_this_sc) {\n best_this_sc = sc;\n best_this_r = nr;\n }\n }\n temp_r[i][j] = best_this_r;\n if (best_this_sc > temp_sc) {\n temp_sc = best_this_sc;\n improved = true;\n }\n }\n }\n if (temp_sc > best_sc) {\n best_sc = temp_sc;\n memcpy(best_r, temp_r, sizeof(best_r));\n }\n string ans = \"\";\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n ans += '0' + best_r[i][j];\n }\n }\n cout << ans << endl;\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint main() {\n srand(time(0));\n int N, Tmax;\n cin >> N >> Tmax;\n vector> init_board(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 char c = s[j];\n if(c >= '0' && c <= '9') init_board[i][j] = c - '0';\n else init_board[i][j] = 10 + (c - 'a');\n }\n }\n pair init_blank = {-1, -1};\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(init_board[i][j] == 0) init_blank = {i, j};\n int fullS = N * N - 1;\n int ddx[4] = {-1, 1, 0, 0};\n int ddy[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n auto compute_S = [&](const vector>& b) -> int {\n int M = N * N;\n vector parent(M), sz(M, 1), has_cyc(M, 0);\n for(int i = 0; i < M; i++) parent[i] = i;\n auto find = [&](auto&& self, int x) -> int {\n if(parent[x] != x) parent[x] = self(self, parent[x]);\n return parent[x];\n };\n auto unite = [&](int x, int y) {\n int px = find(find, x), py = find(find, y);\n if(px == py) {\n has_cyc[px] = 1;\n return;\n }\n if(sz[px] < sz[py]) swap(px, py);\n parent[py] = px;\n sz[px] += sz[py];\n if(has_cyc[py]) has_cyc[px] = 1;\n };\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n int t1 = b[i][j], t2 = b[i+1][j];\n if(t1 != 0 && t2 != 0 && (t1 & 8) && (t2 & 2)) {\n unite(i*N + j, (i+1)*N + j);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n int t1 = b[i][j], t2 = b[i][j+1];\n if(t1 != 0 && t2 != 0 && (t1 & 4) && (t2 & 1)) {\n unite(i*N + j, i*N + j + 1);\n }\n }\n int maxs = 0;\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(b[i][j] != 0) {\n int rp = find(find, i*N + j);\n if(!has_cyc[rp]) maxs = max(maxs, sz[rp]);\n }\n return maxs;\n };\n auto compute_M = [&](const vector>& b) -> int {\n int cnt = 0;\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n if(b[i][j] && b[i+1][j] && (b[i][j] & 8) && (b[i+1][j] & 2)) cnt++;\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n if(b[i][j] && b[i][j+1] && (b[i][j] & 4) && (b[i][j+1] & 1)) cnt++;\n }\n return cnt;\n };\n vector> board = init_board;\n pair blankp = init_blank;\n int bx = blankp.first, by = blankp.second;\n string moves = \"\";\n int max_achieved_S = compute_S(board);\n string best_sequence = \"\";\n int best_k = 0;\n for(int step = 0; step < Tmax; step++) {\n if(moves.length() >= Tmax) break;\n if(max_achieved_S == fullS) break;\n bool perturb = (rand() % 100 < 5);\n int chosen_d = -1;\n if(perturb) {\n vector cands;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx >= 0 && nx < N && ny >= 0 && ny < N) cands.push_back(d);\n }\n if(!cands.empty()) chosen_d = cands[rand() % cands.size()];\n } else {\n int best_future = -1, bm = -1, bd = -1;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n // sim first\n swap(board[bx][by], board[nx][ny]);\n int inter_S = compute_S(board);\n int this_future = inter_S;\n int thisM = compute_M(board);\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n int s2 = compute_S(board);\n int m2 = compute_M(board);\n if(s2 > this_future || (s2 == this_future && m2 > thisM)) {\n this_future = s2;\n thisM = m2;\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n if(this_future > best_future || (this_future == best_future && thisM > bm)) {\n best_future = this_future;\n bm = thisM;\n bd = d;\n }\n swap(board[bx][by], board[nx][ny]);\n }\n chosen_d = bd;\n }\n if(chosen_d == -1) break;\n int nx = bx + ddx[chosen_d], ny = by + ddy[chosen_d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n bx = nx; by = ny;\n moves += dchar[chosen_d];\n int ns = compute_S(board);\n int nk = moves.length();\n if(ns > max_achieved_S || (ns == max_achieved_S && nk < best_k)) {\n max_achieved_S = ns;\n best_sequence = moves;\n best_k = nk;\n }\n }\n if(max_achieved_S < fullS && best_sequence.empty()) {\n // use initial if better but already set\n }\n cout << best_sequence << endl;\n}","ahc012":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Line {\n ll px, py, qx, qy;\n};\n\nint main() {\n int N, K;\n cin >> N >> K;\n vector A(11, 0);\n for (int d = 1; d <= 10; d++) {\n cin >> A[d];\n }\n vector> pts(N);\n for (auto& p : pts) {\n cin >> p.first >> p.second;\n }\n auto compute_cross = [&](const Line& l, int id, const vector>& pts_ref) -> ll {\n auto [x, y] = pts_ref[id];\n ll a = x - l.px;\n ll b = y - l.py;\n ll c = l.qx - l.px;\n ll d = l.qy - l.py;\n return a * d - b * c;\n };\n auto calc_sat = [&](const vector>& prts, const vector& A) -> int {\n vector fr(5501, 0);\n for (auto& p : prts) {\n size_t s = p.size();\n if (s < 5501) fr[s]++;\n }\n int s = 0;\n for (int d = 1; d <= 10; d++) {\n s += min(A[d], fr[d]);\n }\n return s;\n };\n vector best_chosen;\n int best_sat = -1;\n mt19937 rng_base(42);\n for (int trial = 0; trial < 3; trial++) {\n mt19937 rng(rng_base() + trial * 12345); // different seeds\n vector all_idx(N);\n iota(all_idx.begin(), all_idx.end(), 0);\n vector> parts = {all_idx};\n vector chosen;\n auto calc_cross_local = [&](const Line& l, int id) -> ll {\n return compute_cross(l, id, pts);\n };\n int cur_sat = calc_sat(parts, A);\n uniform_real_distribution theta_dist(0.0, 2 * 3.141592653589793);\n for (int iter = 0; iter < 100 && (int)chosen.size() < K; iter++) {\n vector large_g_idx;\n for (int i = 0; i < (int)parts.size(); i++) {\n if ((int)parts[i].size() > 10) large_g_idx.push_back(i);\n }\n if (large_g_idx.empty()) break;\n sort(large_g_idx.begin(), large_g_idx.end(), [&](int aa, int bb) {\n return parts[aa].size() > parts[bb].size();\n });\n int num_target = min(2, (int)large_g_idx.size());\n int best_new = cur_sat;\n Line best_l;\n bool improved = false;\n for (int tg = 0; tg < num_target; tg++) {\n int gidx = large_g_idx[tg];\n auto& group = parts[gidx];\n int gs = group.size();\n for (int th = 0; th < 30; th++) {\n double theta = theta_dist(rng);\n double nx = cos(theta);\n double ny = sin(theta);\n vector> projs;\n projs.reserve(gs);\n for (int id : group) {\n double pr = pts[id].first * nx + pts[id].second * ny;\n projs.emplace_back(pr, id);\n }\n sort(projs.begin(), projs.end());\n for (int m = 1; m <= min(10, gs - 1); m++) {\n double r1 = projs[m - 1].first;\n double r2 = projs[m].first;\n if (abs(r1 - r2) < 1e-9) continue;\n double r = (r1 + r2) / 2.0;\n double dx = -ny;\n double dy = nx;\n double D = 1000000.0;\n double bx = r * nx;\n double by = r * ny;\n double pxd = bx + D * dx;\n double pyd = by + D * dy;\n double qxd = bx - D * dx;\n double qyd = by - D * dy;\n ll px = (ll)round(pxd);\n ll py = (ll)round(pyd);\n ll qx = (ll)round(qxd);\n ll qy = (ll)round(qyd);\n if (px == qx && py == qy) continue;\n if (abs(px) > 1000000000LL || abs(py) > 1000000000LL || abs(qx) > 1000000000LL || abs(qy) > 1000000000LL) continue;\n Line llne{px, py, qx, qy};\n vector temp_fr(5501, 0);\n bool valid = true;\n for (size_t j = 0; j < parts.size() && valid; j++) {\n ll lcnt = 0, rcnt = 0;\n auto& grp = parts[j];\n for (int id : grp) {\n ll cr = compute_cross(llne, id, pts);\n if (cr == 0) {\n valid = false;\n break;\n }\n if (cr > 0) lcnt++;\n else rcnt++;\n }\n if (valid) {\n if (lcnt > 0) temp_fr[lcnt]++;\n if (rcnt > 0) temp_fr[rcnt]++;\n }\n }\n if (!valid) continue;\n int newsat = 0;\n for (int d = 1; d <= 10; d++) {\n newsat += min(A[d], temp_fr[d]);\n }\n if (newsat > best_new) {\n best_new = newsat;\n best_l = llne;\n improved = true;\n }\n }\n }\n }\n if (improved) {\n chosen.push_back(best_l);\n vector> new_prts;\n for (auto& grp : parts) {\n vector leftv, rightv;\n for (int id : grp) {\n ll cr = compute_cross(best_l, id, pts);\n if (cr > 0) leftv.push_back(id);\n else rightv.push_back(id);\n }\n if (!leftv.empty()) new_prts.push_back(leftv);\n if (!rightv.empty()) new_prts.push_back(rightv);\n }\n parts = std::move(new_prts);\n cur_sat = best_new;\n } else {\n break;\n }\n }\n if (cur_sat > best_sat) {\n best_sat = cur_sat;\n best_chosen = chosen;\n }\n }\n cout << best_chosen.size() << endl;\n for (auto& l : best_chosen) {\n cout << l.px << \" \" << l.py << \" \" << l.qx << \" \" << l.qy << endl;\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\nusing pii = pair;\n\nconst int MAXN = 65;\nbool has[MAXN][MAXN];\nbool uh[MAXN][MAXN];\nbool uv[MAXN][MAXN];\nbool udp[MAXN][MAXN];\nbool udm[MAXN][MAXN];\nint N;\n\nbool inb(int x) { return 0 <= x && x < N; }\n\nint get_w(int x, int y, int c) {\n int dx = x - c, dy = y - c;\n return dx * dx + dy * dy + 1;\n}\n\nbool is_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n return uh[y1][xx];\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n return uv[x1][yy];\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int xhigh = xlow + 1;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n return udp[xlow][y_at_low];\n } else if (dyh == -1) {\n return udm[xlow][y_at_low];\n }\n return true;\n }\n return true;\n}\n\nvoid set_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n uh[y1][xx] = true;\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n uv[x1][yy] = true;\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n udp[xlow][y_at_low] = true;\n } else if (dyh == -1) {\n udm[xlow][y_at_low] = true;\n }\n }\n}\n\nbool clean_perim(const array& corn) {\n double cx = 0, cy = 0;\n for (auto& p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs.emplace_back(ang, i);\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0 && dy != 0) {\n steps = ady;\n uy = (dy > 0 ? 1 : -1);\n } else if (dy == 0 && dx != 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n uy = (dy > 0 ? 1 : -1);\n } else return false;\n for (int k = 1; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n if (has[xx][yy]) return false;\n }\n }\n return true;\n}\n\nbool edges_free(const array& corn) {\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs(4);\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs[i] = {ang, i};\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n } else return false;\n for (int k = 0; k < steps; k++) {\n int xx1 = x1 + k * ux;\n int yy1 = y1 + k * uy;\n int xx2 = xx1 + ux;\n int yy2 = yy1 + uy;\n if (is_used_unit(xx1, yy1, xx2, yy2)) return false;\n }\n }\n return true;\n}\n\nvector> cands;\nset> seen_set;\n\nvoid add_candidate(const array& corn) {\n array sorted_c = corn;\n sort(sorted_c.begin(), sorted_c.end());\n array key;\n for (int i = 0; i < 4; i++) {\n key[2 * i] = sorted_c[i].first;\n key[2 * i + 1] = sorted_c[i].second;\n }\n if (seen_set.count(key)) return;\n seen_set.insert(key);\n cands.push_back(corn);\n}\n\nbool get_three_missing(const array& corn, pii& newp) {\n int cnt_miss = 0;\n for (auto& pt : corn) {\n if (!has[pt.first][pt.second]) {\n newp = pt;\n cnt_miss++;\n if (cnt_miss > 1) return false;\n }\n }\n return cnt_miss == 1;\n}\n\nvoid try_from_pair(pii P, pii Q) {\n int px = P.first, py = P.second, qx = Q.first, qy = Q.second;\n if (!has[px][py] || !has[qx][qy]) return;\n if (px != qx && py != qy) {\n pii R = {px, qy};\n pii S = {qx, py};\n if (!inb(R.first) || !inb(R.second) || !inb(S.first) || !inb(S.second)) return;\n int hasR = has[R.first][R.second] ? 1 : 0;\n int hasS = has[S.first][S.second] ? 1 : 0;\n if (hasR + hasS == 1) {\n array corn = {P, Q, R, S};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n int dx = qx - px;\n int dy = qy - py;\n if ((dx + dy) % 2 == 0 && (dx - dy) % 2 == 0) {\n int p = (dx + dy) / 2;\n int q = (dx - dy) / 2;\n if (p != 0 && q != 0) {\n int bx = px + p;\n int by = py + p;\n int dx_ = px + q;\n int dy_ = py - q;\n if (inb(bx) && inb(by) && inb(dx_) && inb(dy_)) {\n int qcx = px + p + q;\n int qcy = py + p - q;\n if (qcx == qx && qcy == qy) {\n array corn = {{{px, py}, {bx, by}, {qx, qy}, {dx_, dy_}}};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n }\n }\n}\n\nint main() {\n int M;\n cin >> N >> M;\n vector init_dots(M);\n for (int i = 0; i < M; i++) {\n cin >> init_dots[i].first >> init_dots[i].second;\n }\n memset(has, 0, sizeof(has));\n memset(uh, 0, sizeof(uh));\n memset(uv, 0, sizeof(uv));\n memset(udp, 0, sizeof(udp));\n memset(udm, 0, sizeof(udm));\n for (auto& pt : init_dots) {\n has[pt.first][pt.second] = true;\n }\n int C = (N - 1) / 2;\n vector dots_list = init_dots;\n cands.clear();\n seen_set.clear();\n for (size_t i = 0; i < dots_list.size(); i++) {\n for (size_t j = i + 1; j < dots_list.size(); j++) {\n try_from_pair(dots_list[i], dots_list[j]);\n try_from_pair(dots_list[j], dots_list[i]);\n }\n }\n vector> answer_ops;\n for (int iter = 0; iter < 20000; iter++) {\n int best_w = -1;\n int best_idx = -1;\n pii best_new = {-1, -1};\n for (int ci = 0; ci < (int)cands.size(); ci++) {\n auto& corn = cands[ci];\n pii np;\n if (!get_three_missing(corn, np)) continue;\n if (has[np.first][np.second]) continue;\n if (!clean_perim(corn) || !edges_free(corn)) continue;\n int ww = get_w(np.first, np.second, C);\n if (ww > best_w) {\n best_w = ww;\n best_new = np;\n best_idx = ci;\n }\n }\n if (best_idx == -1) break;\n auto corn = cands[best_idx];\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n angs.emplace_back(atan2(corn[i].second - cy, corn[i].first - cx), i);\n }\n sort(angs.begin(), angs.end());\n vector ord;\n for (auto& a : angs) ord.push_back(corn[a.second]);\n int new_idx = -1;\n for (int i = 0; i < 4; i++)\n if (ord[i] == best_new) {\n new_idx = i;\n break;\n }\n if (new_idx == -1) continue;\n array op;\n op[0] = best_new.first;\n op[1] = best_new.second;\n for (int k = 0; k < 3; k++) {\n pii nxt = ord[(new_idx + 1 + k) % 4];\n op[2 + k * 2] = nxt.first;\n op[2 + k * 2 + 1] = nxt.second;\n }\n answer_ops.push_back(op);\n has[best_new.first][best_new.second] = true;\n dots_list.push_back(best_new);\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n }\n for (int k = 0; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n set_used_unit(xx, yy, xx + ux, yy + uy);\n }\n }\n for (auto& Q : dots_list) {\n if (Q == best_new) continue;\n try_from_pair(best_new, Q);\n try_from_pair(Q, best_new);\n }\n }\n cout << answer_ops.size() << endl;\n for (auto& arr : answer_ops) {\n for (int i = 0; i < 8; i++) {\n cout << arr[i];\n if (i < 7) cout << \" \";\n else cout << endl;\n }\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nlong long calc_score(const vector>& grid) {\n bool visited[10][10] = {};\n long long total = 0;\n auto dfs = [&](auto&& self, int r, int c, int flavor, int& cnt) -> void {\n visited[r][c] = true;\n cnt++;\n int dr[4] = {-1, 0, 1, 0};\n int dc[4] = {0, 1, 0, -1};\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !visited[nr][nc] && grid[nr][nc] == flavor) {\n self(self, nr, nc, flavor, cnt);\n }\n }\n };\n for (int flavor = 1; flavor <= 3; flavor++) {\n for (int r = 0; r < 10; r++) {\n for (int c = 0; c < 10; c++) {\n if (!visited[r][c] && grid[r][c] == flavor) {\n int cnt = 0;\n dfs(dfs, r, c, flavor, cnt);\n total += 1LL * cnt * cnt;\n }\n }\n }\n }\n return total;\n}\n\nvoid apply(vector>& grid, char d) {\n if (d == 'F') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int r = 0; r < 10; r++) grid[r][c] = (r < (int)line.size() ? line[r] : 0);\n }\n } else if (d == 'B') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int r = 0; r < 10; r++) grid[r][c] = (r < 10 - ls ? 0 : line[r - (10 - ls)]);\n }\n } else if (d == 'L') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int c = 0; c < 10; c++) grid[r][c] = (c < (int)line.size() ? line[c] : 0);\n }\n } else if (d == 'R') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int c = 0; c < 10; c++) grid[r][c] = (c < 10 - ls ? 0 : line[c - (10 - ls)]);\n }\n }\n}\n\nint main() {\n vector> g(10, vector(10, 0));\n vector f(100);\n for (int &x : f) cin >> x;\n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n vector> empt;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (g[r][c] == 0) empt.emplace_back(r, c);\n auto [rr, cc] = empt[p - 1];\n g[rr][cc] = f[t];\n long double best_eval = -1;\n char best_d = 'F';\n bool has_next = (t < 99);\n int next_f = has_next ? f[t + 1] : -1;\n for (char d : {'F', 'B', 'L', 'R'}) {\n vector> ng = g;\n apply(ng, d);\n long long csc = calc_score(ng);\n long double fut = 0;\n if (has_next) {\n vector> ne;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (ng[r][c] == 0) ne.emplace_back(r, c);\n if (!ne.empty()) {\n long double sumf = 0;\n for (auto& pr : ne) {\n vector> ngp = ng;\n ngp[pr.first][pr.second] = next_f;\n long long bns = 0;\n for (char nd : {'F', 'B', 'L', 'R'}) {\n vector> ng2 = ngp;\n apply(ng2, nd);\n long long sc2 = calc_score(ng2);\n if (sc2 > bns) bns = sc2;\n }\n sumf += bns;\n }\n fut = sumf / ne.size();\n }\n }\n long double evalv = csc + fut;\n if (evalv > best_eval) {\n best_eval = evalv;\n best_d = d;\n }\n }\n apply(g, best_d);\n cout << best_d << endl;\n cout.flush();\n }\n return 0;\n}","ahc016":"#include \n#include \n\nusing namespace std;\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\nusing Eigen::SelfAdjointEigenSolver;\n\nint main() {\n int M;\n double eps;\n cin >> M >> eps;\n int N = 20;\n if (eps < 0.1) N = 12;\n else if (eps < 0.2) N = 18;\n else if (eps < 0.3) N = 25;\n else N = 35;\n N = max(N, (int)ceil(sqrt(2.0 * M)));\n N = min(N, 100);\n N = max(N, 4);\n vector G(M);\n for(int k = 0; k < M; k++) {\n double p = (double)(k + 1) / (M + 1);\n string s = \"\";\n for(int i = 0; i < N; i++) {\n for(int j = i + 1; j < N; j++) {\n long long seed = (long long)k * 123457 + (long long)i * 10007 + j;\n if ((seed % 100000LL) < (long long)(p * 100000)) {\n s += '1';\n } else {\n s += '0';\n }\n }\n }\n G[k] = s;\n }\n vector> pre_degs(M);\n vector> pre_eigs(M);\n for(int k = 0; k < M; k++) {\n auto& str = G[k];\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(str[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector d(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) d[i]++;\n sort(d.begin(), d.end());\n pre_degs[k] = d;\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector ev(N);\n for(int i = 0; i < N; i++) ev[i] = e(i);\n pre_eigs[k] = ev;\n }\n cout << N << endl;\n for(auto& g : G) {\n cout << g << endl;\n }\n cout.flush();\n double scale = 1 - 2 * eps;\n double bias = eps * (N - 1.0);\n for(int q = 0; q < 100; q++) {\n string H;\n cin >> H;\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(H[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector deg(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) deg[i]++;\n sort(deg.begin(), deg.end());\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector eig(N);\n for(int i = 0; i < N; i++) eig[i] = e(i);\n int best = 0;\n double min_dist = 1e100;\n for(int k = 0; k < M; k++) {\n double ddeg = 0;\n for(int i = 0; i < N; i++) {\n double exp_d = bias + scale * pre_degs[k][i];\n ddeg += (deg[i] - exp_d) * (deg[i] - exp_d);\n }\n ddeg = sqrt(ddeg);\n double deig = 0;\n vector eexp = pre_eigs[k];\n for(int i=0; i\nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n vector U(M), V(M);\n vector W(M);\n for(int i = 0; i < M; i++) {\n cin >> U[i] >> V[i] >> W[i];\n --U[i]; --V[i];\n }\n vector> pos(N);\n for(int i = 0; i < N; i++) {\n cin >> pos[i].first >> pos[i].second;\n }\n auto gen = [&](unsigned seed) -> vector {\n vector ass(M, -1);\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n mt19937 rng(seed);\n shuffle(ord.begin(), ord.end(), rng);\n for(int ei : ord) {\n int best = -1;\n int minc = INT_MAX;\n int minld = INT_MAX;\n for(int d = 0; d < D; d++) if(ld[d] < K) {\n int conf = vcnt[U[ei]][d] + vcnt[V[ei]][d];\n if(conf < minc || (conf == minc && ld[d] < minld)) {\n minc = conf;\n minld = ld[d];\n best = d;\n }\n }\n if(best == -1) {\n // fallback\n for(int d=0;d& ass) -> ll {\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = ass[i];\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n ll bad = 0;\n for(int v = 0; v <= N; v++) {\n for(int d = 0; d < D; d++) {\n int c = vcnt[v][d];\n bad += (ll)c * (c - 1);\n }\n }\n return bad;\n };\n vector best_ass;\n ll min_bad = LLONG_MAX;\n int trials = 5000;\n for(int t = 0; t < trials; t++) {\n vector ass = gen(t * 10007ULL + 123456789ULL);\n ll bd = compute_bad(ass);\n if(bd < min_bad) {\n min_bad = bd;\n best_ass = ass;\n }\n }\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = best_ass[i];\n ld[d]++;\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n bool improved = true;\n int max_passes = 300;\n mt19937 rng_rand(424242);\n for(int pass = 0; pass < max_passes && improved; pass++) {\n improved = false;\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng_rand);\n for(int ei : ord) {\n int cur = best_ass[ei];\n int uu = U[ei], vv = V[ei];\n ll best_delta = 0;\n int best_newd = -1;\n for(int d = 0; d < D; d++) if(d != cur && ld[d] < K) {\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta) {\n best_delta = delta;\n best_newd = d;\n }\n }\n if(best_newd != -1 && best_delta < 0) {\n int newd = best_newd;\n vcnt[uu][cur]--;\n vcnt[vv][cur]--;\n vcnt[uu][newd]++;\n vcnt[vv][newd]++;\n ld[cur]--;\n ld[newd]++;\n best_ass[ei] = newd;\n improved = true;\n }\n }\n }\n // Additional load balancing opt pass, move if not increase bad much and balances\n for(int iter=0; iter<50; iter++) {\n int maxl = 0, minl = INT_MAX;\n for(int d=0;d ord(M); iota(ord.begin(),ord.end(),0);\n shuffle(ord.begin(),ord.end(),rng_rand);\n for(int ei:ord) {\n int cur = best_ass[ei];\n if(ld[cur] <= minl +1) continue;\n int uu=U[ei],vv=V[ei];\n ll best_delta = LLONG_MAX/2;\n int bestd = -1;\n for(int d=0;d= maxl) continue;\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta){\n best_delta=delta;\n bestd =d;\n }\n }\n if(bestd !=-1 && best_delta < 1000LL){ // allow slight increase sometimes for balance\n int newd=bestd;\n vcnt[uu][cur]--; vcnt[vv][cur]--;\n vcnt[uu][newd]++; vcnt[vv][newd]++;\n ld[cur]--; ld[newd]++;\n best_ass[ei]=newd;\n moved=true;\n break;\n }\n }\n if(!moved) break;\n }\n for(int i = 0; i < M; i++) {\n if(i > 0) cout << \" \";\n cout << (best_ass[i] + 1);\n }\n cout << endl;\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Rod {\n int st, f1, f2, len;\n};\n\nint main() {\n int D;\n cin >> D;\n vector F[2], R[2];\n for (int i = 0; i < 2; i++) {\n F[i].resize(D);\n for (auto &s : F[i]) cin >> s;\n R[i].resize(D);\n for (auto &s : R[i]) cin >> s;\n }\n double best_eval = 1LL << 60;\n int best_n = 0;\n int best_block[2][15][15][15];\n for (int mode = 0; mode < 3; mode++) {\n bool voxels[2][15][15][15] = {};\n for (int i = 0; i < 2; i++) {\n for (int z = 0; z < D; z++) {\n vector Xs, Ys;\n for (int x = 0; x < D; x++) if (F[i][z][x] == '1') Xs.push_back(x);\n for (int y = 0; y < D; y++) if (R[i][z][y] == '1') Ys.push_back(y);\n int a = Xs.size(), b = Ys.size();\n if (a == 0 || b == 0) continue;\n vector Xsort = Xs; sort(Xsort.begin(), Xsort.end());\n vector Ysort = Ys; sort(Ysort.begin(), Ysort.end());\n vector> assigns;\n if (mode < 2) {\n if (mode == 0) {\n if (a >= b) {\n int base = a / b; int rem = a % b;\n int pos = 0;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[pos++], Ysort[iy]);\n }\n }\n } else {\n int base = b / a; int rem = b % a;\n int pos = 0;\n for (int ix = 0; ix < a; ix++) {\n int cnt = base + (ix < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[ix], Ysort[pos++]);\n }\n }\n }\n } else {\n if (b >= a) {\n int base = b / a; int rem = b % a;\n int pos = 0;\n for (int ix = 0; ix < a; ix++) {\n int cnt = base + (ix < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[ix], Ysort[pos++]);\n }\n }\n } else {\n int base = a / b; int rem = a % b;\n int pos = 0;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[pos++], Ysort[iy]);\n }\n }\n }\n }\n } else {\n // for z bias, use one of the ways, mode0 style\n if (a >= b) {\n int base = a / b; int rem = a % b;\n int pos = 0;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[pos++], Ysort[iy]);\n }\n }\n } else {\n int base = b / a; int rem = b % a;\n int pos = 0;\n for (int ix = 0; ix < a; ix++) {\n int cnt = base + (ix < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[ix], Ysort[pos++]);\n }\n }\n }\n }\n for (auto [x, y] : assigns) {\n voxels[i][x][y][z] = true;\n }\n }\n }\n vector rlist[2][16];\n for (int i = 0; i < 2; i++) {\n if (mode == 0) {\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n for (int x = 0; x < D; ) {\n if (!voxels[i][x][y][z]) { x++; continue; }\n int st = x;\n while (x < D && voxels[i][x][y][z]) x++;\n int l = x - st;\n rlist[i][l].push_back({st, y, z, l});\n }\n }\n } else if (mode == 1) {\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) {\n for (int y = 0; y < D; ) {\n if (!voxels[i][x][y][z]) { y++; continue; }\n int st = y;\n while (y < D && voxels[i][x][y][z]) y++;\n int l = y - st;\n rlist[i][l].push_back({st, x, z, l});\n }\n }\n } else {\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; ) {\n if (!voxels[i][x][y][z]) { z++; continue; }\n int st = z;\n while (z < D && voxels[i][x][y][z]) z++;\n int l = z - st;\n rlist[i][l].push_back({st, x, y, l});\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n for (int l = 1; l <= D; l++) {\n int c[2] = {(int)rlist[0][l].size(), (int)rlist[1][l].size()};\n int sh = min(c[0], c[1]);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c[1] - sh) * l;\n rrs[1] += (c[0] - sh) * l;\n sinv += sh * 1.0 / l;\n for (int k = 0; k < c[0]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod &rd = rlist[0][l][k];\n if (mode == 0) {\n for (int d = 0; d < l; d++) {\n blockid[0][rd.st + d][rd.f1][rd.f2] = bid;\n }\n } else if (mode == 1) {\n for (int d = 0; d < l; d++) {\n blockid[0][rd.f1][rd.st + d][rd.f2] = bid;\n }\n } else {\n for (int d = 0; d < l; d++) {\n blockid[0][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n }\n for (int k = 0; k < c[1]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod &rd = rlist[1][l][k];\n if (mode == 0) {\n for (int d = 0; d < l; d++) {\n blockid[1][rd.st + d][rd.f1][rd.f2] = bid;\n }\n } else if (mode == 1) {\n for (int d = 0; d < l; d++) {\n blockid[1][rd.f1][rd.st + d][rd.f2] = bid;\n }\n } else {\n for (int d = 0; d < l; d++) {\n blockid[1][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int i = 0; i < 2; i++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n best_block[i][x][y][z] = blockid[i][x][y][z];\n }\n }\n }\n cout << best_n << endl;\n for (int i = 0; i < 2; i++) {\n for (int pos = 0; pos < D * D * D; pos++) {\n int x = pos / (D * D);\n int rem = pos % (D * D);\n int y = rem / D;\n int z = rem % D;\n cout << best_block[i][x][y][z];\n if (pos < D * D * D - 1) cout << \" \";\n }\n cout << endl;\n }\n return 0;\n}","ahc020":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct UF {\n vector p, r;\n UF(int n) : p(n+1), r(n+1, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }\n bool unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return false;\n if (r[x] < r[y]) swap(x, y);\n p[y] = x;\n if (r[x] == r[y]) r[x]++;\n return true;\n }\n};\n\nstruct Edge {\n int u, v, idx;\n ll w;\n};\n\nstruct TEdge {\n int to, eidx;\n ll w;\n};\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector X(N+1), Y(N+1);\n for (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n vector alledges(M);\n for (int j = 0; j < M; j++) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n alledges[j] = {u, v, j, w};\n }\n vector A(K+1), B(K+1);\n for (int k = 1; k <= K; k++) cin >> A[k] >> B[k];\n vector> dist2(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll dx = X[i] - A[k];\n ll dy = Y[i] - B[k];\n dist2[i][k] = dx * dx + dy * dy;\n }\n }\n vector> minP(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll d2 = dist2[i][k];\n if (d2 == 0) {\n minP[i][k] = 0;\n continue;\n }\n ll low = 0, high = 100000;\n while (low < high) {\n ll mid = (low + high) / 2;\n if (mid * mid >= d2) high = mid;\n else low = mid + 1;\n }\n minP[i][k] = low;\n }\n }\n UF uf(N);\n vector mst_edges = alledges;\n sort(mst_edges.begin(), mst_edges.end(), [](const Edge& e1, const Edge& e2) { return e1.w < e2.w; });\n vector> tree(N+1);\n for (auto& e : mst_edges) {\n if (uf.unite(e.u, e.v)) {\n tree[e.u].push_back({e.v, e.idx, e.w});\n tree[e.v].push_back({e.u, e.idx, e.w});\n }\n }\n vector> children(N+1);\n function build = [&](int u, int par) {\n for (auto& e : tree[u]) {\n if (e.to != par) {\n children[u].push_back(e);\n build(e.to, u);\n }\n }\n };\n build(1, -1);\n using pbb = pair;\n function&, const vector&)> dfs_conn = [&](int u, set& usedids, const vector& term) -> pbb {\n bool has = term[u];\n ll cst = 0;\n for (auto& e : children[u]) {\n auto [sc, sh] = dfs_conn(e.to, usedids, term);\n if (sh) {\n cst += e.w + sc;\n has = true;\n usedids.insert(e.eidx);\n } else {\n cst += sc;\n }\n }\n return {cst, has};\n };\n auto get_connect = [&](const vector& t) -> ll {\n set dum;\n auto [c, h] = dfs_conn(1, dum, t);\n return c;\n };\n vector> res_list(N+1);\n vector assignment(K+1, 0);\n vector> reqs(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n assignment[k] = best;\n res_list[best].push_back(k);\n reqs[best].insert(bp);\n }\n vector curP(N+1, 0);\n ll sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n }\n }\n vector is_open(N+1, false);\n for (int i = 1; i <= N; i++) if (curP[i] > 0) is_open[i] = true;\n auto compute_term = [&](const vector& pvals) -> vector {\n vector t(N+1, false);\n for (int i = 1; i <= N; i++) t[i] = (pvals[i] > 0) || (i == 1);\n return t;\n };\n vector curr_term(N+1, false);\n for (int i = 1; i <= N; i++) curr_term[i] = (curP[i] > 0) || (i == 1);\n ll cur_conn = get_connect(curr_term);\n ll current_total = sum_sq + cur_conn;\n const int MAX_ITER = 50;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool improved = false;\n for (int k = 1; k <= K; k++) {\n int curr = assignment[k];\n if (curr == 0) continue;\n int reqc = minP[curr][k];\n for (int j = 1; j <= N; j++) if (is_open[j] && j != curr) {\n int reqn = minP[j][k];\n reqs[curr].erase(reqs[curr].find(reqc));\n ll tpc = reqs[curr].empty() ? 0 : *reqs[curr].rbegin();\n reqs[j].insert(reqn);\n ll tpj = *reqs[j].rbegin();\n ll dsq = tpc * tpc + tpj * tpj - (ll)curP[curr] * curP[curr] - (ll)curP[j] * curP[j];\n bool will_close = (curP[curr] > 0 && tpc == 0);\n ll dcon = 0;\n if (will_close) {\n vector np(N+1);\n for (int ii = 1; ii <= N; ii++) np[ii] = curP[ii];\n np[curr] = tpc;\n np[j] = tpj;\n auto tterm = compute_term(np);\n ll newc = get_connect(tterm);\n dcon = newc - cur_conn;\n }\n reqs[j].erase(reqs[j].find(reqn));\n reqs[curr].insert(reqc);\n if (dsq + dcon < 0) {\n reqs[curr].erase(reqs[curr].find(reqc));\n reqs[j].insert(reqn);\n auto& lst = res_list[curr];\n for (size_t pos = 0; pos < lst.size(); pos++) if (lst[pos] == k) {\n swap(lst[pos], lst.back());\n lst.pop_back();\n break;\n }\n res_list[j].push_back(k);\n assignment[k] = j;\n curP[curr] = tpc;\n curP[j] = tpj;\n sum_sq += dsq;\n if (will_close) {\n is_open[curr] = false;\n cur_conn += dcon;\n curr_term[curr] = (tpc > 0) || (curr == 1);\n curr_term[j] = (tpj > 0) || (j == 1);\n } else {\n curr_term[curr] = (tpc > 0) || (curr == 1);\n curr_term[j] = (tpj > 0) || (j == 1);\n }\n current_total += dsq + dcon;\n improved = true;\n break;\n }\n }\n if (improved) break;\n }\n if (!improved) {\n for (int i = 1; i <= N && !improved; i++) if (is_open[i]) {\n vector new_add(N+1, 0);\n bool can = true;\n vector> move_info;\n for (auto kk : res_list[i]) {\n int altj = -1, altp = INT_MAX / 2;\n for (int jj = 1; jj <= N; jj++) if (is_open[jj] && jj != i) {\n if (minP[jj][kk] < altp) {\n altp = minP[jj][kk];\n altj = jj;\n }\n }\n if (altp > 5000) {\n can = false;\n break;\n }\n new_add[altj] = max(new_add[altj], altp);\n move_info.emplace_back(kk, altj);\n }\n if (!can) continue;\n ll dsq = -(ll)curP[i] * curP[i];\n vector new_p(N+1);\n for (int ii = 1; ii <= N; ii++) new_p[ii] = curP[ii];\n new_p[i] = 0;\n for (int jj = 1; jj <= N; jj++) if (new_add[jj] > 0) {\n int oldpj = curP[jj];\n new_p[jj] = max(oldpj, new_add[jj]);\n dsq += (ll)new_p[jj] * new_p[jj] - (ll)oldpj * oldpj;\n }\n auto tterm = compute_term(new_p);\n ll new_conn_val = get_connect(tterm);\n ll dcon = new_conn_val - cur_conn;\n if (dsq + dcon < 0) {\n for (auto [kk, altj] : move_info) {\n reqs[i].erase(reqs[i].find(minP[i][kk]));\n reqs[altj].insert(minP[altj][kk]);\n auto& l = res_list[i];\n for (size_t p = 0; p < l.size(); p++) if (l[p] == kk) {\n swap(l[p], l.back());\n l.pop_back();\n break;\n }\n res_list[altj].push_back(kk);\n assignment[kk] = altj;\n }\n reqs[i].clear();\n res_list[i].clear();\n for (int jj = 1; jj <= N; jj++) {\n ll np = reqs[jj].empty() ? 0 : *reqs[jj].rbegin();\n if (new_p[jj] != np) new_p[jj] = (int)np;\n }\n for (int jj = 1; jj <= N; jj++) curP[jj] = new_p[jj];\n sum_sq += dsq;\n is_open[i] = false;\n cur_conn = new_conn_val;\n for (int ii = 1; ii <= N; ii++) curr_term[ii] = (curP[ii] > 0) || (ii == 1);\n current_total += dsq + dcon;\n improved = true;\n }\n }\n }\n if (!improved) break;\n }\n vector final_term(N+1, false);\n for (int i = 1; i <= N; i++) final_term[i] = (curP[i] > 0) || (i == 1);\n set final_used;\n auto [final_c, _] = dfs_conn(1, final_used, final_term);\n vector Bs(M, 0);\n for (int ei : final_used) {\n if (ei >= 0 && ei < M) Bs[ei] = 1;\n }\n for (int i = 1; i <= N; i++) cout << curP[i] << (i < N ? \" \" : \"\\n\");\n for (int j = 0; j < M; j++) cout << Bs[j] << (j < M - 1 ? \" \" : \"\\n\");\n}","ahc021":"#include \nusing namespace std;\nusing P = pair;\n\nstruct Sw {\n int x1, y1, x2, y2;\n};\n\nint main() {\n int N = 30;\n vector> grid(N);\n for (int x = 0; x < N; x++) {\n grid[x].resize(x + 1);\n for (int y = 0; y <= x; y++) {\n cin >> grid[x][y];\n }\n }\n int total = N * (N + 1) / 2;\n vector

curr_pos(total);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int val = grid[x][y];\n curr_pos[val] = {x, y};\n }\n }\n vector> is_fixed(N, vector(N, false));\n vector ops;\n\n auto get_parents = [&](P p) -> vector

{\n auto [x, y] = p;\n vector

res;\n if (x > 0) {\n if (y <= x - 1) res.emplace_back(x - 1, y);\n if (y - 1 >= 0) {\n int py = y - 1;\n if (py <= x - 1) res.emplace_back(x - 1, py);\n }\n }\n return res;\n };\n\n auto get_neighbors = [&](P p) -> vector

{\n int x = p.first, y = p.second;\n vector

res;\n vector> deltas = {{-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}};\n for (auto [dx, dy] : deltas) {\n int nx = x + dx, ny = y + dy;\n if (nx >= 0 && nx < N && ny >= 0 && ny <= nx) {\n res.emplace_back(nx, ny);\n }\n }\n return res;\n };\n\n for (int k = 0; k < total; k++) {\n vector

avail;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n if (is_fixed[x][y]) continue;\n auto pars = get_parents({x, y});\n bool ok = true;\n for (auto pp : pars) {\n if (!is_fixed[pp.first][pp.second]) {\n ok = false;\n break;\n }\n }\n if (ok) avail.emplace_back(x, y);\n }\n }\n P start = curr_pos[k];\n vector> dist(N, vector(N, -1));\n vector> par(N, vector

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

q;\n if (!is_fixed[start.first][start.second]) {\n dist[start.first][start.second] = 0;\n q.push(start);\n }\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (is_fixed[nx.first][nx.second]) continue;\n if (dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n P target = {-1, -1};\n int min_d = INT_MAX;\n for (auto cand : avail) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1 && dx < min_d) {\n min_d = dx;\n target = cand;\n }\n }\n if (target.first == -1) {\n // Fallback: pick any avail reachable? If none, pick first and try avoid issue\n // For safety, pick first avail and use full BFS without fixed? But to prevent break, if happen, abort attempt\n // Assume won't happen\n if (!avail.empty()) {\n target = avail[0];\n min_d = 100000; // marker\n } else {\n // impossible\n assert(false);\n return 1;\n }\n }\n vector

path;\n if (min_d == 100000) {\n // special case fallback: perhaps place without path? but to handle, let's implement simple move if rare\n // but assume not reach, to make sure, I will run full grid even fixed but then may break, skip for now\n // To make robust, I will do a second BFS without fixed check for fallback\n // but then fix after careful\n // For this, since likely not trigger, and to just output\n dist.assign(N, vector(N, -1));\n par.assign(N, vector

(N, {-1, -1}));\n q = queue

();\n dist[start.first][start.second] = 0;\n q.push(start);\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n P best = avail[0];\n int bestd = dist[best.first][best.second];\n for (auto cand : avail) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1 && dx < bestd) {\n bestd = dx;\n best = cand;\n }\n }\n target = best;\n min_d = bestd;\n }\n P cur = target;\n path = {};\n while (true) {\n path.push_back(cur);\n if (dist[cur.first][cur.second] == 0) break;\n cur = par[cur.first][cur.second];\n if (cur.first == -1) break;\n }\n reverse(path.begin(), path.end());\n for (size_t i = 0; i + 1 < path.size(); i++) {\n P p1 = path[i];\n P p2 = path[i + 1];\n int v1 = grid[p1.first][p1.second];\n int v2 = grid[p2.first][p2.second];\n grid[p1.first][p1.second] = v2;\n grid[p2.first][p2.second] = v1;\n curr_pos[v1] = p2;\n curr_pos[v2] = p1;\n ops.push_back({p1.first, p1.second, p2.first, p2.second});\n }\n is_fixed[target.first][target.second] = true;\n }\n cout << ops.size() << endl;\n for (auto& s : ops) {\n cout << s.x1 << \" \" << s.y1 << \" \" << s.x2 << \" \" << s.y2 << endl;\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n int D, N;\n cin >> D >> N;\n bool is_obst[9][9] = {};\n int cont[9][9];\n memset(cont, -1, sizeof(cont));\n for (int k = 0; k < N; k++) {\n int ri, rj;\n cin >> ri >> rj;\n is_obst[ri][rj] = true;\n cont[ri][rj] = -2;\n }\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n auto is_valid = [&](int x, int y) { return x >= 0 && x < 9 && y >= 0 && y < 9; };\n int dist[9][9];\n int visit_ord[9][9];\n memset(dist, -1, sizeof(dist));\n memset(visit_ord, -1, sizeof(visit_ord));\n {\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n dist[0][4] = 0;\n visit_ord[0][4] = 0;\n int ord = 1;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n vis[nx][ny] = true;\n dist[nx][ny] = dist[x][y] + 1;\n visit_ord[nx][ny] = ord++;\n q.push({nx, ny});\n }\n }\n }\n int M = 0;\n for (int i = 0; i < 9; i++)\n for (int j = 0; j < 9; j++)\n if (!is_obst[i][j] && !(i == 0 && j == 4)) M++;\n int placed_count = 0;\n set remain;\n for (int i = 0; i < M; i++) remain.insert(i);\n auto get_reach = [&]() -> vector> {\n vector> res;\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n if (cont[nx][ny] >= 0) continue;\n vis[nx][ny] = true;\n q.push({nx, ny});\n if ((nx || ny != 4) && cont[nx][ny] == -1) res.push_back({nx, ny});\n }\n }\n return res;\n };\n auto is_safe_pos = [&](int px, int py, int curr_rem) -> bool {\n cont[px][py] = 100000;\n auto nr = get_reach();\n cont[px][py] = -1;\n return nr.size() == (size_t)(curr_rem - 1);\n };\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n vector> reach = get_reach();\n int curr_rem = M - placed_count;\n vector> cands;\n for (auto p : reach) {\n if (is_safe_pos(p.first, p.second, curr_rem)) {\n cands.push_back(p);\n }\n }\n if (cands.empty()) {\n cands = reach;\n }\n auto cmp = [&](const pair& a, const pair& b) {\n if (dist[a.first][a.second] != dist[b.first][b.second])\n return dist[a.first][a.second] < dist[b.first][b.second];\n return visit_ord[a.first][a.second] < visit_ord[b.first][b.second];\n };\n sort(cands.begin(), cands.end(), cmp);\n int j = 0;\n for (int rid : remain) {\n if (rid == t) break;\n j++;\n }\n pair place_pos;\n if (!cands.empty() && j < (int)cands.size()) {\n place_pos = cands[j];\n } else if (!cands.empty()) {\n place_pos = cands.back();\n } else {\n place_pos = {0, 0}; // fallback error\n }\n cout << place_pos.first << \" \" << place_pos.second << endl;\n cont[place_pos.first][place_pos.second] = t;\n placed_count++;\n remain.erase(t);\n }\n vector> rem_order;\n bool cleared[9][9] = {};\n cleared[0][4] = true;\n for (int step = 0; step < M; step++) {\n vector> acc;\n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (cont[i][j] < 0) continue;\n if (cleared[i][j]) continue;\n bool can = false;\n for (int d = 0; d < 4; d++) {\n int nx = i + dx[d], ny = j + dy[d];\n if (is_valid(nx, ny) && !is_obst[nx][ny] && cleared[nx][ny]) {\n can = true;\n break;\n }\n }\n if (can) acc.emplace_back(i, j);\n }\n }\n if (acc.empty()) break;\n int minid = INT_MAX;\n pair chosen = {-1, -1};\n for (auto p : acc) {\n int id = cont[p.first][p.second];\n if (id < minid) {\n minid = id;\n chosen = p;\n }\n }\n rem_order.push_back(chosen);\n cleared[chosen.first][chosen.second] = true;\n cont[chosen.first][chosen.second] = -1;\n }\n for (auto p : rem_order) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n vector>>> witnesses(\n m + 1, vector>>(m + 1));\n bitset<101> has_adj[101];\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n bool is_bound = (i == 0 || i == n - 1 || j == 0 || j == n - 1);\n if (is_bound) {\n witnesses[c][0].push_back({i, j});\n has_adj[c][0] = 1;\n has_adj[0][c] = 1;\n }\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int nc = grid[ni][nj];\n if (c != nc) {\n witnesses[c][nc].push_back({i, j});\n has_adj[c][nc] = 1;\n has_adj[nc][c] = 1;\n }\n }\n }\n }\n }\n vector>> terminals(m + 1);\n for (int c = 1; c <= m; c++) {\n set> s;\n for (int dd = 0; dd <= m; dd++) {\n if (has_adj[c][dd]) {\n if (!witnesses[c][dd].empty()) {\n s.insert(witnesses[c][dd][0]);\n }\n }\n }\n for (auto p : s) terminals[c].push_back(p);\n }\n vector> iskept(n, vector(n, false));\n for (int c = 1; c <= m; c++) {\n if (terminals[c].empty()) continue;\n auto root = terminals[c][0];\n int sx = root.first, sy = root.second;\n vector> dist(n, vector(n, -1));\n vector>> parent(n, vector>(n, {-1, -1}));\n queue> qq;\n qq.push({sx, sy});\n dist[sx][sy] = 0;\n while (!qq.empty()) {\n auto [x, y] = qq.front();\n qq.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || dist[nx][ny] != -1 || grid[nx][ny] != c) continue;\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n qq.push({nx, ny});\n }\n }\n set> sk;\n for (auto &t : terminals[c]) {\n int cx = t.first, cy = t.second;\n while (true) {\n if (cx == -1 || dist[cx][cy] == -1) break;\n sk.insert({cx, cy});\n if (cx == sx && cy == sy) break;\n auto [px, py] = parent[cx][cy];\n cx = px;\n cy = py;\n }\n }\n for (auto p : sk) {\n iskept[p.first][p.second] = true;\n }\n }\n const int maxiter = 20;\n for (int iter = 0; iter < maxiter; iter++) {\n vector> current(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) current[i][j] = grid[i][j];\n }\n }\n vector> to_add;\n bool do_change = false;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = current[i][j];\n if (c == 0) continue;\n if (has_adj[c][0]) continue;\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && current[ni][nj] == 0) {\n to_add.push_back({ni, nj});\n do_change = true;\n }\n }\n }\n }\n vector> vis(n, vector(n, false));\n queue> q0;\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) && current[i][j] == 0) {\n q0.push({i, j});\n vis[i][j] = true;\n }\n }\n }\n while (!q0.empty()) {\n auto [x, y] = q0.front();\n q0.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || vis[nx][ny] || current[nx][ny] != 0) continue;\n vis[nx][ny] = true;\n q0.push({nx, ny});\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (current[i][j] == 0 && !vis[i][j]) {\n to_add.push_back({i, j});\n do_change = true;\n }\n }\n }\n for (auto [i, j] : to_add) {\n iskept[i][j] = true;\n }\n if (!do_change) break;\n }\n vector> final(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) final[i][j] = grid[i][j];\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j > 0) cout << \" \";\n cout << final[i][j];\n }\n cout << endl;\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n srand(time(NULL));\n int N, D, Q;\n cin >> N >> D >> Q;\n vector> adj(N);\n vector outdeg(N, 0);\n bitset<128> dcomp[100];\n auto compute_ranks = [&]( ) -> vector {\n vector memo(N, -1);\n function dfs = [&](int u) -> int {\n if (memo[u] != -1) return memo[u];\n int mx = 0;\n for (int v : adj[u]) {\n mx = max(mx, dfs(v) + 1);\n }\n return memo[u] = mx;\n };\n for (int i = 0; i < N; i++) {\n dfs(i);\n }\n return memo;\n };\n for (int q = 0; q < Q; q++) {\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n bool found = false;\n pair to_comp = {-1, -1};\n for (int dist = 1; dist < N && !found; dist++) {\n for (int p = 0; p + dist < N && !found; p++) {\n int x = items[p];\n int y = items[p + dist];\n if (!dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n }\n }\n }\n if (!found) {\n for (int tries = 0; tries < 10000; tries++) {\n int x = rand() % N;\n int y = rand() % N;\n if (x != y && !dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n break;\n }\n }\n if (!found) {\n to_comp = {0, 1};\n }\n }\n int a = to_comp.first;\n int b = to_comp.second;\n cout << 1 << \" \" << 1 << \" \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n dcomp[a].set(b);\n dcomp[b].set(a);\n if (res == '>') {\n adj[a].push_back(b);\n outdeg[a]++;\n } else if (res == '<') {\n adj[b].push_back(a);\n outdeg[b]++;\n }\n }\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n vector group(N);\n for (int i = 0; i < N; i++) {\n group[items[i]] = i % D;\n }\n for (int i = 0; i < N; i++) {\n cout << group[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n int h = n / m;\n vector> st(m);\n vector stack_of(n + 1, -1);\n vector pos_in_st(n + 1, -1);\n for (int i = 0; i < m; i++) {\n st[i].resize(h);\n for (int j = 0; j < h; j++) {\n cin >> st[i][j];\n stack_of[st[i][j]] = i;\n pos_in_st[st[i][j]] = j;\n }\n }\n vector> ops;\n for (int v = 1; v <= n; v++) {\n while (true) {\n int s = stack_of[v];\n if (s == -1) {\n break;\n }\n int p = pos_in_st[v];\n if (p == (int)st[s].size() - 1) break;\n vector stack_min(m, n + 1);\n for (int i = 0; i < m; i++) {\n for (int b : st[i]) {\n if (b < stack_min[i]) stack_min[i] = b;\n }\n }\n int best_minv = -1;\n int best_sz = INT_MAX;\n int dest = -1;\n for (int i = 0; i < m; i++)\n if (i != s) {\n int cmin = stack_min[i];\n int csz = st[i].size();\n bool up = false;\n if (cmin > best_minv) up = true;\n else if (cmin == best_minv) {\n if (csz < best_sz) up = true;\n else if (csz == best_sz && (dest == -1 || i < dest)) up = true;\n }\n if (up) {\n best_minv = cmin;\n best_sz = csz;\n dest = i;\n }\n }\n if (dest == -1) {\n // fallback: any stack except s\n for (int i = 0; i < m; i++)\n if (i != s) {\n dest = i;\n break;\n }\n }\n int lift_v = st[s][p + 1];\n ops.emplace_back(lift_v, dest);\n vector to_move;\n for (size_t j = p + 1; j < st[s].size(); ++j) {\n to_move.push_back(st[s][j]);\n }\n st[s].resize(p + 1);\n size_t old_dest_sz = st[dest].size();\n st[dest].insert(st[dest].end(), to_move.begin(), to_move.end());\n for (size_t j = 0; j < to_move.size(); ++j) {\n int b = to_move[j];\n stack_of[b] = dest;\n pos_in_st[b] = old_dest_sz + j;\n }\n }\n int s = stack_of[v];\n ops.emplace_back(v, 0);\n st[s].pop_back();\n stack_of[v] = -1;\n pos_in_st[v] = -1;\n }\n for (auto [vv, ii] : ops) {\n cout << vv << \" \" << ii << endl;\n }\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector h(N-1);\n for(int i = 0; i < N-1; i++) cin >> h[i];\n vector v(N);\n for(int i = 0; i < N; i++) cin >> v[i];\n vector> d(N, vector(N));\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n vector> sd(N, vector(N));\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n sd[i][j] = sqrt(d[i][j]);\n }\n \n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n string DIR = \"URDL\";\n \n auto can_move = [&](int i, int j, int ni, int nj, const auto& hh, const auto& vv) -> bool {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n int ddi = ni - i;\n int ddj = nj - j;\n if (ddi == -1 && ddj == 0) return hh[ni][j] == '0';\n if (ddi == 1 && ddj == 0) return hh[i][j] == '0';\n if (ddi == 0 && ddj == 1) return vv[i][j] == '0';\n if (ddi == 0 && ddj == -1) return vv[i][nj] == '0';\n return false;\n };\n \n // Base covering DFS\n vector> vis_mark(N, vector(N, false));\n string route = \"\";\n function dfs = [&](int i, int j) {\n vis_mark[i][j] = true;\n for(int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !vis_mark[ni][nj] && can_move(i, j, ni, nj, h, v)) {\n route += DIR[dir];\n dfs(ni, nj);\n route += DIR[(dir + 2) % 4];\n }\n }\n };\n dfs(0, 0);\n \n // Simulate base\n vector> visits(N, vector(N, 0));\n vector> positions;\n positions.emplace_back(0, 0);\n int ci = 0, cj = 0;\n for (char c : route) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'R') dir = 1;\n else if (c == 'D') dir = 2;\n else if (c == 'L') dir = 3;\n if (dir == -1) continue;\n int ni = ci + di[dir], nj = cj + dj[dir];\n positions.emplace_back(ni, nj);\n visits[ni][nj]++;\n ci = ni;\n cj = nj;\n }\n int Ltotal = positions.size() - 1;\n int cur_i = ci, cur_j = cj;\n \n // Add more visits\n int L_target = 85000;\n while (Ltotal < L_target) {\n // Find best target != current\n double max_p = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == cur_i && j == cur_j) continue;\n double p = sd[i][j] / (visits[i][j] + 1.0);\n if (p > max_p) {\n max_p = p;\n ti = i;\n tj = j;\n }\n }\n }\n if (ti == -1) {\n // only current, do excursion\n bool ex = false;\n for (int dir = 0; dir < 4; dir++) {\n int ni = cur_i + di[dir], nj = cur_j + dj[dir];\n if (can_move(cur_i, cur_j, ni, nj, h, v)) {\n ti = ni;\n tj = nj;\n ex = true;\n break;\n }\n }\n if (!ex) break;\n }\n \n // BFS from cur to ti,tj\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == ti && cur_j == tj);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == ti && nj == tj) {\n found = true;\n break;\n }\n }\n }\n if (!found) break;\n \n // reconstruct\n vector> path_to;\n pair curp = {ti, tj};\n while (curp != make_pair(cur_i, cur_j)) {\n path_to.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_to.begin(), path_to.end());\n \n if (Ltotal + (int)path_to.size() > 100000) break;\n \n for (auto [x, y] : path_to) {\n positions.emplace_back(x, y);\n visits[x][y]++;\n cur_i = x;\n cur_j = y;\n Ltotal++;\n }\n }\n \n // Final return to (0,0)\n {\n int ti = 0, tj = 0;\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == 0 && cur_j == 0);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == 0 && nj == 0) {\n found = true;\n break;\n }\n }\n }\n if (found) {\n vector> path_back;\n pair curp = {0, 0};\n while (curp != make_pair(cur_i, cur_j)) {\n path_back.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_back.begin(), path_back.end());\n for (auto p : path_back) {\n positions.push_back(p);\n visits[p.first][p.second]++;\n cur_i = p.first;\n cur_j = p.second;\n }\n }\n }\n \n // Build ans\n string ans = \"\";\n for (size_t t = 1; t < positions.size(); t++) {\n int i1 = positions[t - 1].first, j1 = positions[t - 1].second;\n int i2 = positions[t].first, j2 = positions[t].second;\n if (i2 == i1 - 1) ans += 'U';\n else if (i2 == i1 + 1) ans += 'D';\n else if (j2 == j1 + 1) ans += 'R';\n else if (j2 == j1 - 1) ans += 'L';\n }\n \n if (ans.size() > 100000) ans = ans.substr(0, 100000);\n cout << ans << endl;\n return 0;\n}","ahc028":"#include \nusing namespace std;\ntypedef long long ll;\nconst ll INF = 1LL << 60;\n\npair>> solve_for_S(const string& S, int si, int sj, const vector>>& posis, int N) {\n int LL = S.length();\n if(LL == 0) return {INF, {}};\n vector>> cnd(LL);\n for(int k = 0; k < LL; k++) {\n cnd[k] = posis[S[k] - 'A'];\n if(cnd[k].empty()) return {INF, {}};\n }\n vector> dpp(LL);\n vector> prvv(LL);\n int n0 = cnd[0].size();\n dpp[0].resize(n0);\n prvv[0].assign(n0, -1);\n for(int j = 0; j < n0; j++) {\n int x = cnd[0][j].first, y = cnd[0][j].second;\n dpp[0][j] = abs(x - si) + abs(y - sj) + 1LL;\n }\n for(int k = 1; k < LL; k++) {\n int np = cnd[k-1].size();\n int nc = cnd[k].size();\n dpp[k].assign(nc, INF);\n prvv[k].assign(nc, -1);\n for(int j = 0; j < nc; j++) {\n int x = cnd[k][j].first, y = cnd[k][j].second;\n for(int p = 0; p < np; p++) {\n int px = cnd[k-1][p].first, py = cnd[k-1][p].second;\n ll cc = dpp[k-1][p] + abs(x - px) + abs(y - py) + 1;\n if(cc < dpp[k][j]) {\n dpp[k][j] = cc;\n prvv[k][j] = p;\n }\n }\n }\n }\n ll minc = INF;\n int bj = -1;\n int nlast = cnd[LL-1].size();\n for(int j = 0; j < nlast; j++) {\n if(dpp[LL-1][j] < minc) {\n minc = dpp[LL-1][j];\n bj = j;\n }\n }\n if(bj == -1) return {INF, {}};\n vector> sq(LL);\n int cj = bj;\n sq[LL-1] = cnd[LL-1][cj];\n for(int k = LL-1; k >= 1; k--) {\n int pj = prvv[k][cj];\n sq[k-1] = cnd[k-1][pj];\n cj = pj;\n }\n return {minc, sq};\n}\n\nint main() {\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for(int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for(int i = 0; i < M; i++) cin >> t[i];\n vector>> positions(26);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].emplace_back(i, j);\n }\n ll best_T = INF;\n string best_S = \"\";\n vector> best_seq;\n for(int start = 0; start < M; start++) {\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n for(int iter = 0; iter < M; iter++) {\n bool new_covered = false;\n for(int j = 0; j < M; j++) if(!used[j] && curr.find(t[j]) != string::npos) {\n used[j] = true;\n new_covered = true;\n }\n int remaining = 0;\n for(int j = 0; j < M; j++) if(!used[j]) remaining++;\n if(remaining == 0) break;\n int best = -1;\n int maxo = -1;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = 0;\n int mp = min(4, (int)curr.size());\n bool matched = false;\n for(int o = mp; o >= 1; o--) {\n if((int)curr.size() >= o && (int)t[j].size() >= o && curr.substr(curr.size() - o, o) == t[j].substr(0, o)) {\n oo = o;\n matched = true;\n break;\n }\n }\n if(!matched) oo = 0;\n if(oo > maxo) {\n maxo = oo;\n best = j;\n }\n }\n if(best == -1) break;\n curr += t[best].substr(maxo);\n used[best] = true;\n }\n int rem = 0;\n for(bool b : used) if(!b) rem++;\n if(rem == 0) {\n auto [this_cost, this_seq] = solve_for_S(curr, si, sj, positions, N);\n if(this_cost < best_T) {\n best_T = this_cost;\n best_S = curr;\n best_seq = this_seq;\n }\n }\n }\n if(best_T == INF) {\n // fallback to start 0\n int start = 0;\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n for(int iter = 0; iter < M; iter++) {\n for(int j = 0; j < M; j++) if(!used[j] && curr.find(t[j]) != string::npos) used[j] = true;\n int remaining = 0;\n for(int j = 0; j < M; j++) if(!used[j]) remaining++;\n if(remaining == 0) break;\n int best = -1;\n int maxo = -1;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = 0;\n int mp = min(4, (int)curr.size());\n bool matched = false;\n for(int o = mp; o >= 1; o--) {\n if((int)curr.size() >= o && (int)t[j].size() >= o && curr.substr(curr.size() - o, o) == t[j].substr(0, o)) {\n oo = o;\n matched = true;\n break;\n }\n }\n if(!matched) oo = 0;\n if(oo > maxo) {\n maxo = oo;\n best = j;\n }\n }\n if(best == -1) break;\n curr += t[best].substr(maxo);\n used[best] = true;\n }\n auto [fcost, fseq] = solve_for_S(curr, si, sj, positions, N);\n best_T = fcost;\n best_seq = fseq;\n }\n for(auto& p : best_seq) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n vector>> fields(M);\n for (int i = 0; i < M; i++) {\n int d;\n cin >> d;\n fields[i].resize(d);\n for (int j = 0; j < d; j++) {\n cin >> fields[i][j].first >> fields[i][j].second;\n }\n }\n int D = N * N;\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution dist(0.0, 1.0);\n vector> queries;\n vector measured;\n int ops = 0;\n const int MAX_OPS = 2 * N * N;\n vector est(D, 0.0);\n vector true_v(D, -1);\n vector is_drilled(D, false);\n int INIT_Q = 300;\n for (int q = 0; q < INIT_Q && ops < MAX_OPS - 100; q++) {\n vector S;\n for (int c = 0; c < D; c++) {\n if (dist(rng) < 0.2) S.push_back(c);\n }\n if (S.size() < 2) {\n q--;\n continue;\n }\n cout << \"q \" << S.size();\n for (int c : S) {\n int i = c / N;\n int j = c % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int y;\n cin >> y;\n queries.push_back(S);\n measured.push_back(y);\n ops++;\n }\n int drill_batch = 30;\n double est_thresh = 0.25;\n for (int r = 0; r < 30 && ops < MAX_OPS - 1; r++) {\n vector unknown;\n for (int c = 0; c < D; c++) if (!is_drilled[c]) unknown.push_back(c);\n int U = unknown.size();\n if (U == 0) break;\n int Qs = queries.size();\n MatrixXd A(Qs, U);\n VectorXd bb(Qs);\n for (int qi = 0; qi < Qs; qi++) {\n int k = queries[qi].size();\n double target = (measured[qi] - eps * (double)k) / (1 - eps);\n double known_s = 0.0;\n for (int c : queries[qi]) if (is_drilled[c]) known_s += true_v[c];\n bb(qi) = target - known_s;\n A.row(qi).setZero();\n vector is_in(D, false);\n for (int c : queries[qi]) is_in[c] = true;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (is_in[c]) A(qi, uj) = 1.0;\n }\n }\n VectorXd x(U);\n if (U > 0 && Qs > 0) {\n x = A.bdcSvd(ComputeThinU | ComputeThinV).solve(bb);\n } else {\n x = VectorXd::Zero(U);\n }\n for (int uj = 0; uj < U; uj++) {\n est[unknown[uj]] = max(0.0, x(uj));\n }\n vector> high;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (est[c] > est_thresh) high.emplace_back(est[c], c);\n }\n if (high.empty()) break;\n sort(high.rbegin(), high.rend());\n int num_dr = min((int)high.size(), drill_batch);\n for (int ii = 0; ii < num_dr; ii++) {\n int c = high[ii].second;\n if (is_drilled[c]) continue;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n }\n vector> final_sus;\n for (int c = 0; c < D; c++) if (!is_drilled[c] && est[c] > 0.1) final_sus.emplace_back(est[c], c);\n sort(final_sus.rbegin(), final_sus.rend());\n for (auto& pr : final_sus) {\n if (ops >= MAX_OPS - 1) break;\n int c = pr.second;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n vector> ans;\n for (int c = 0; c < D; c++) if (is_drilled[c] && true_v[c] > 0) {\n ans.emplace_back(c / N, c % N);\n }\n vector>> possible_pos(M);\n for (int m = 0; m < M; m++) {\n int maxx = 0, maxy = 0;\n for (auto& p : fields[m]) {\n maxx = max(maxx, p.first);\n maxy = max(maxy, p.second);\n }\n for (int di = 0; di + maxx < N; di++) {\n for (int dj = 0; dj + maxy < N; dj++) {\n possible_pos[m].emplace_back(di, dj);\n }\n }\n }\n vector> best_place(M);\n vector best_v(D, 0.0);\n double best_err = 1e18;\n for (int start = 0; start < 5; start++) {\n vector> place(M);\n for (int m = 0; m < M; m++) {\n auto& ps = possible_pos[m];\n if (!ps.empty()) place[m] = ps[rng() % ps.size()];\n }\n auto compute_v = [&](const vector>& pl) -> vector {\n vector vv(D, 0.0);\n for (int m = 0; m < M; m++) {\n auto [di, dj] = pl[m];\n for (auto [x, y] : fields[m]) {\n int ii = di + x, jj = dj + y;\n vv[ii * N + jj] += 1;\n }\n }\n return vv;\n };\n vector vv = compute_v(place);\n vector target_v = est;\n for (int c = 0; c < D; c++) if (is_drilled[c]) target_v[c] = true_v[c];\n auto calc_err = [&](const vector& vvv) {\n double e = 0;\n for (int c = 0; c < D; c++) e += abs(vvv[c] - target_v[c]);\n return e;\n };\n double curr_err = calc_err(vv);\n for (int tries = 0; tries < 10000; tries++) {\n int m = rng() % M;\n auto& ps = possible_pos[m];\n if (ps.empty()) continue;\n int idx = rng() % ps.size();\n auto newp = ps[idx];\n if (newp == place[m]) continue;\n vector new_vv(D);\n // delta\n double delta = 0.0;\n double delta_adjust = 0;\n // old subtract\n auto oldp = place[m];\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n int c = ii * N + jj;\n double oldv = vv[c];\n double newvv = oldv - 1;\n delta += abs(newvv - target_v[c]) - abs(oldv - target_v[c]);\n }\n // new add\n for (auto [x, y] : fields[m]) {\n int ii = newp.first + x, jj = newp.second + y;\n int c = ii * N + jj;\n double oldv_for = vv[c];\n double newvv = oldv_for + 1;\n delta += abs(newvv - target_v[c]) - abs(oldv_for - target_v[c]);\n }\n if (delta < -0.001) {\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n vv[ii * N + jj] -= 1;\n int ii2 = newp.first + x, jj2 = newp.second + y;\n vv[ii2 * N + jj2] += 1;\n }\n place[m] = newp;\n curr_err += delta;\n }\n }\n if (curr_err < best_err) {\n best_err = curr_err;\n best_place = place;\n best_v = vv;\n }\n }\n set> union_set;\n for (int m = 0; m < M; m++) {\n auto [di, dj] = best_place[m];\n for (auto [x, y] : fields[m]) {\n union_set.emplace(di + x, dj + y);\n }\n }\n vector> final_ans;\n for (auto p : union_set) final_ans.push_back(p);\n for (auto p : ans) final_ans.push_back(p); // add drilled if any missed\n sort(final_ans.begin(), final_ans.end());\n auto last = unique(final_ans.begin(), final_ans.end());\n final_ans.erase(last, final_ans.end());\n cout << \"a \" << final_ans.size();\n for (auto [i, j] : final_ans) {\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int resp;\n cin >> resp;\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n vector> A(D, vector(N));\n for(int d = 0; d < D; d++) {\n for(int k = 0; k < N; k++) {\n cin >> A[d][k];\n }\n }\n vector prev_div(N + 1, 0);\n int base = W / N;\n for(int i = 1; i < N; i++) {\n prev_div[i] = prev_div[i - 1] + base;\n }\n prev_div[N] = W;\n for(int d = 0; d < D; d++) {\n auto a = A[d];\n vector cur_w(N);\n for(int k = 0; k < N; k++) cur_w[k] = prev_div[k + 1] - prev_div[k];\n vector slot_idx(N);\n iota(slot_idx.begin(), slot_idx.end(), 0);\n sort(slot_idx.begin(), slot_idx.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n vector a_idx(N);\n iota(a_idx.begin(), a_idx.end(), 0);\n sort(a_idx.begin(), a_idx.end(), [&](int x, int y) {\n if(a[x] != a[y]) return a[x] > a[y];\n return x < y;\n });\n vector assigned(N);\n for(int i = 0; i < N; i++) {\n int s = slot_idx[i];\n int ak = a_idx[i];\n assigned[s] = a[ak];\n }\n long long current_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * cur_w[s];\n current_def += max(0LL, assigned[s] - b);\n }\n vector targ_w(N, 0);\n long long sum_need = 0;\n for(int s = 0; s < N; s++) {\n if(assigned[s] == 0) {\n targ_w[s] = 1;\n } else {\n targ_w[s] = ((assigned[s] + 999) / 1000);\n }\n if(targ_w[s] < 1) targ_w[s] = 1;\n sum_need += targ_w[s];\n }\n if(sum_need > W) {\n vector sidx(N);\n iota(sidx.begin(), sidx.end(), 0);\n sort(sidx.begin(), sidx.end(), [&](int x, int y) {\n return assigned[x] < assigned[y] || (assigned[x] == assigned[y] && x < y);\n });\n long long deficit = sum_need - W;\n for(int i : sidx) {\n if(deficit <= 0) break;\n int can = targ_w[i] - 1;\n long long red = min((long long)can, deficit);\n targ_w[i] -= red;\n deficit -= red;\n }\n int ii = 0;\n while(deficit > 0 && ii < N * 100) {\n int idx = sidx[ii % N];\n int can = targ_w[idx] - 1;\n long long red = min((long long)can, deficit);\n targ_w[idx] -= red;\n deficit -= red;\n ii++;\n }\n } else if(sum_need < W) {\n long long extra = W - sum_need;\n int maxs = 0;\n for(int s = 1; s < N; s++) if(assigned[s] > assigned[maxs]) maxs = s;\n targ_w[maxs] += extra;\n }\n vector new_div(N + 1, 0);\n for(int s = 0; s < N; s++) {\n new_div[s + 1] = new_div[s] + targ_w[s];\n }\n new_div[N] = W;\n long long new_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * targ_w[s];\n new_def += max(0LL, assigned[s] - b);\n }\n vector old_has(W + 1, false);\n vector neww_has(W + 1, false);\n for(int k = 1; k < N; k++) {\n if(prev_div[k] > 0 && prev_div[k] < W) old_has[prev_div[k]] = true;\n if(new_div[k] > 0 && new_div[k] < W) neww_has[new_div[k]] = true;\n }\n int sym = 0;\n for(int j = 0; j <= W; j++) {\n if(old_has[j] != neww_has[j]) sym++;\n }\n long long L = (long long)sym * W;\n bool move = (L < 100LL * (current_def - new_def));\n vector> day_rects(N);\n vector used_div = prev_div;\n if(move || d == 0) { // always move for day 0 or if worth\n vector sorted_slot(N);\n iota(sorted_slot.begin(), sorted_slot.end(), 0);\n sort(sorted_slot.begin(), sorted_slot.end(), [&](int x, int y) {\n if(targ_w[x] != targ_w[y]) return targ_w[x] > targ_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_slot[i];\n int k = a_idx[i];\n int j0 = new_div[s];\n int j1 = new_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n used_div = new_div;\n prev_div = new_div;\n } else {\n vector sorted_cur(N);\n iota(sorted_cur.begin(), sorted_cur.end(), 0);\n sort(sorted_cur.begin(), sorted_cur.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_cur[i];\n int k = a_idx[i];\n int j0 = prev_div[s];\n int j1 = prev_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n }\n for(int k = 0; k < N; k++) {\n auto &r = day_rects[k];\n cout << r[0] << \" \" << r[1] << \" \" << r[2] << \" \" << r[3] << endl;\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n vector>> S(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cin >> S[m][i][j];\n const ll MOD = 998244353;\n vector> cur_mod(N, vector(N));\n vector>> op_cnt(M, vector>(N - 2, vector(N - 2, 0)));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_mod[i][j] = A[i][j];\n ll cur_score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_score += cur_mod[i][j];\n int cur_total = 0;\n auto get_add_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) {\n for (int dj = 0; dj < 3; dj++) {\n int i = p + di;\n int j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr + S[m][di][dj] % MOD) % MOD;\n ds += newr - oldr;\n }\n }\n return ds;\n };\n auto get_remove_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr - (S[m][di][dj] % MOD) + MOD) % MOD;\n ds += newr - oldr;\n }\n return ds;\n };\n while (cur_total < K) {\n ll max_ds = -1000000000000000000LL;\n int bm = -1, bp = -1, bq = -1;\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds;\n bm = m; bp = p; bq = q;\n }\n }\n }\n }\n if (max_ds <= 0) break;\n int m = bm, p = bp, q = bq;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m][di][dj] % MOD)) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n }\n vector> greedy_mod = cur_mod;\n vector>> greedy_cnt = op_cnt;\n ll greedy_score = cur_score;\n int greedy_total = cur_total;\n ll overall_best_score = cur_score;\n vector>> overall_best_cnt = op_cnt;\n int MAX_ITER = 500000;\n double T0 = 5000000000.0;\n srand(42);\n auto rand01 = []() { return rand() * 1.0 / RAND_MAX; };\n for (int trial = 0; trial < 3; trial++) {\n cur_mod = greedy_mod;\n op_cnt = greedy_cnt;\n cur_score = greedy_score;\n cur_total = greedy_total;\n if (trial > 0) {\n int npert = 15 + (rand() % 25);\n for (int p = 0; p < npert; p++) {\n if (rand() % 2 && cur_total < K) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n ll dsc = get_add_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][pp][qq]++;\n cur_total++;\n cur_score += dsc;\n } else if (cur_total > 0) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n if (op_cnt[m][pp][qq] > 0) {\n ll dsc = get_remove_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][pp][qq]--;\n cur_total--;\n cur_score += dsc;\n }\n }\n }\n }\n for (int iter = 0; iter < MAX_ITER; iter++) {\n double temp = T0 * pow(0.999955, iter);\n bool did = false;\n int rtyp = rand() % 4;\n if (rtyp == 0 && cur_total < K) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n ll dsc = get_add_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n } else if (rtyp == 1 && cur_total > 0) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n if (op_cnt[m][p][q] > 0) {\n ll dsc = get_remove_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n }\n }\n if (!did) {\n int m1 = rand() % M; int p1 = rand() % (N - 2); int q1 = rand() % (N - 2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N - 2); int q2 = rand() % (N - 2);\n ll dsc = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n ll net = 0;\n int di = i - p1, dj = j - q1;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net -= S[m1][di][dj];\n di = i - p2; dj = j - q2;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net += S[m2][di][dj];\n if (net == 0) continue;\n ll oldr = cur_mod[i][j];\n ll addm = (net % MOD + MOD) % MOD;\n ll newr = (oldr + addm) % MOD;\n dsc += newr - oldr;\n }\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m1][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m2][di][dj] % MOD) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n }\n }\n }\n }\n int L = 0;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) L += overall_best_cnt[m][p][q];\n cout << L << endl;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) {\n for (int t = 0; t < overall_best_cnt[m][p][q]; t++) {\n cout << m << \" \" << p << \" \" << q << endl;\n }\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> 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 int max_turn = 10000;\n vector> grid(N, vector(N, -1));\n vector next_in(N, 0);\n vector pos_r(N), pos_c(N);\n for (int i = 0; i < N; i++) {\n pos_r[i] = i;\n pos_c[i] = 0;\n }\n vector hold(N, -1);\n vector active(N, true);\n vector acts(N, \"\");\n vector next_needed(N);\n for (int i = 0; i < N; i++) next_needed[i] = i * N;\n auto find_loc = [&](int b) -> pair {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == b) return {i, j};\n }\n }\n for (int k = 0; k < N; k++) {\n if (hold[k] == b) return {pos_r[k], pos_c[k]};\n }\n return {-1, -1};\n };\n for (int turn = 0; turn < max_turn; turn++) {\n bool done = true;\n for (int i = 0; i < N; i++) {\n if (next_needed[i] < (i + 1) * N) done = false;\n }\n if (done) break;\n // incoming\n for (int i = 0; i < N; i++) {\n if (next_in[i] < N && grid[i][0] == -1) {\n bool has_hold = false;\n for (int k = 0; k < N; k++) {\n if (active[k] && pos_r[k] == i && pos_c[k] == 0 && hold[k] != -1) {\n has_hold = true;\n break;\n }\n }\n if (!has_hold) {\n grid[i][0] = A[i][next_in[i]];\n next_in[i]++;\n }\n }\n }\n // decide actions conservatively\n vector act(N, '.');\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n int r = pos_r[c];\n int co = pos_c[c];\n bool is_large = (c == 0);\n bool carrying = (hold[c] != -1);\n if (carrying) {\n int b = hold[c];\n int tr = b / N;\n int tc = N - 1;\n int expect = next_needed[tr];\n bool is_next = (b == expect);\n bool can_q = (grid[r][co] == -1);\n if (r == tr && co == tc && is_next) {\n if (can_q) act[c] = 'Q';\n else act[c] = '.';\n } else if (r == tr) {\n if (is_next && co < tc && grid[r][co + 1] == -1) {\n act[c] = 'R';\n } else if (!is_next && can_q) {\n act[c] = 'Q'; // park\n } else {\n act[c] = '.';\n }\n } else {\n // vertical\n char dir = (r < tr ? 'D' : 'U');\n int dr = (r < tr ? 1 : -1);\n int nr = r + dr;\n if (nr < 0 || nr >= N) {\n act[c] = '.';\n } else {\n bool dest_ok = (grid[nr][co] == -1 || is_large);\n if (dest_ok) {\n act[c] = dir;\n } else {\n act[c] = '.';\n }\n }\n }\n } else {\n if (grid[r][co] != -1) {\n int b = grid[r][co];\n int tr = b / N;\n bool can_pick = is_large || (tr == r);\n if (can_pick && grid[r][co] != -1) {\n act[c] = 'P';\n }\n } else {\n // move to fetch next if in same row\n pair loc = {-1, -1};\n int expect = next_needed[r];\n if (expect < (r + 1) * N) {\n loc = find_loc(expect);\n } else {\n loc = {-1, -1};\n }\n if (loc.first == r && loc.second != -1) {\n int bc = loc.second;\n if (bc < co) {\n if (co > 0) act[c] = 'L';\n } else if (bc > co) {\n if (co < N - 1) act[c] = 'R';\n } else {\n act[c] = '.';\n }\n } else {\n // go left\n if (co > 0) act[c] = 'L';\n else act[c] = '.';\n }\n }\n }\n }\n // validate and apply P/Q\n vector> new_grid = grid;\n vector new_hold = hold;\n bool inval = false;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n int pr = pos_r[c], pc = pos_c[c];\n if (ac == 'P') {\n if (hold[c] != -1 || new_grid[pr][pc] == -1) {\n act[c] = '.';\n inval = true;\n } else {\n new_hold[c] = new_grid[pr][pc];\n new_grid[pr][pc] = -1;\n }\n } else if (ac == 'Q') {\n if (hold[c] == -1 || new_grid[pr][pc] != -1) {\n act[c] = '.';\n inval = true;\n } else {\n new_grid[pr][pc] = hold[c];\n new_hold[c] = -1;\n }\n } else if (ac == 'B') {\n if (hold[c] != -1) {\n act[c] = '.';\n inval = true;\n } else {\n active[c] = false;\n }\n }\n }\n if (inval) {\n // revert to safe, but since we set ., ok\n }\n vector nr_pos = pos_r, nc_pos = pos_c;\n vector final_hold = new_hold;\n vector> final_grid = new_grid;\n // apply moves with checks\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n if (ac == 'U' || ac == 'D' || ac == 'L' || ac == 'R') {\n int pr = pos_r[c];\n int pc = pos_c[c];\n int nrr = pr, ncc = pc;\n if (ac == 'U') nrr--;\n else if (ac == 'D') nrr++;\n else if (ac == 'L') ncc--;\n else if (ac == 'R') ncc++;\n if (nrr < 0 || nrr >= N || ncc < 0 || ncc >= N) {\n act[c] = '.';\n continue;\n }\n bool car = (new_hold[c] != -1);\n bool is_l = (c == 0);\n bool dest_has = (new_grid[nrr][ncc] != -1);\n if (car && !is_l && dest_has) {\n act[c] = '.';\n continue;\n }\n nr_pos[c] = nrr;\n nc_pos[c] = ncc;\n }\n }\n // check overlap and swaps\n map, int> pos_cnt;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n pair p = {nr_pos[c], nc_pos[c]};\n pos_cnt[p]++;\n }\n bool coll = false;\n for (auto& pr : pos_cnt) {\n if (pr.second > 1) coll = true;\n }\n if (coll) {\n // revert moves to .\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c];\n nc_pos[c] = pos_c[c];\n }\n }\n }\n // check pairwise swaps\n coll = false;\n for (int c1 = 0; c1 < N; c1++) {\n for (int c2 = c1 + 1; c2 < N; c2++) {\n if (!active[c1] || !active[c2]) continue;\n if (nr_pos[c1] == pos_r[c2] && nc_pos[c1] == pos_c[c2] && nr_pos[c2] == pos_r[c1] && nc_pos[c2] == pos_c[c1]) {\n coll = true;\n }\n }\n }\n if (coll) {\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c];\n nc_pos[c] = pos_c[c];\n }\n }\n }\n // update state\n pos_r = nr_pos;\n pos_c = nc_pos;\n grid = final_grid;\n hold = final_hold;\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n int pr = pos_r[c], pc = pos_c[c]; // after update\n if (hold[c] != -1 && ! (c==0) && grid[pr][pc] != -1 ) {\n // shouldn't happen but\n act[c] = '.';\n }\n }\n }\n // apply to acts\n for (int c = 0; c < N; c++) {\n acts[c] += act[c];\n }\n // dispatch\n for (int rr = 0; rr < N; rr++) {\n if (grid[rr][N - 1] != -1) {\n int b = grid[rr][N - 1];\n grid[rr][N - 1] = -1;\n if (b == next_needed[rr]) {\n next_needed[rr]++;\n }\n }\n }\n }\n // pad to same length\n int max_len = 0;\n for (int i = 0; i < N; i++) max_len = max(max_len, (int)acts[i].size());\n for (int i = 0; i < N; i++) {\n while (acts[i].size() < max_len) acts[i] += '.';\n if (acts[i].size() > max_turn) acts[i] = acts[i].substr(0, max_turn);\n }\n for (int i = 0; i < N; i++) {\n cout << acts[i] << endl;\n }\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n int r = 0, c = 0;\n long long load = 0;\n vector ops;\n const int MAXT = 100000;\n auto is_done = [&]() -> bool {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) return false;\n }\n }\n return true;\n };\n auto find_best = [&](bool is_source) -> pair {\n double best_ratio = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n long long val = h[i][j];\n if ((is_source ? val > 0 : val < 0)) {\n int dist = abs(i - r) + abs(j - c);\n long long amnt = is_source ? val : -val;\n double ratio = (double)amnt / (dist + 1.0);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n ti = i;\n tj = j;\n }\n }\n }\n }\n return {ti, tj};\n };\n auto move_path = [&](int tr, int tc) {\n while (r < tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"L\");\n c--;\n }\n };\n while (!is_done() && (int)ops.size() < MAXT - 50) {\n bool did_something = false;\n if (load == 0 && h[r][c] > 0) {\n long long d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[r][c] -= d;\n did_something = true;\n } else if (load > 0 && h[r][c] < 0) {\n long long d = min(load, -h[r][c]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[r][c] += d;\n did_something = true;\n }\n if (did_something) continue;\n bool going_source = (load == 0);\n auto [tr, tc] = find_best(going_source);\n if (tr == -1) {\n break;\n }\n move_path(tr, tc);\n }\n for (auto& s : ops) {\n cout << s << endl;\n }\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(NULL);\n int N, M, T;\n cin >> N >> M >> T;\n int seed_count = 2 * N * (N - 1);\n vector> X(seed_count, vector(M, 0));\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n mt19937 rng(42);\n for (int t = 0; t < T; t++) {\n // compute vals\n vector vals(seed_count, 0);\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n vals[i] += X[i][j];\n }\n }\n // must_include\n set must_include;\n for (int l = 0; l < M; l++) {\n int maxl = 0;\n for (int i = 0; i < seed_count; i++) {\n maxl = max(maxl, X[i][l]);\n }\n int best_v = -1, best_i = -1;\n for (int i = 0; i < seed_count; i++) {\n if (X[i][l] == maxl) {\n if (vals[i] > best_v || best_i == -1) {\n best_v = vals[i];\n best_i = i;\n }\n }\n }\n if (best_i != -1) must_include.insert(best_i);\n }\n vector to_plant;\n for (int i : must_include) to_plant.push_back(i);\n vector> others;\n for (int i = 0; i < seed_count; i++) {\n if (must_include.find(i) == must_include.end()) {\n others.emplace_back(vals[i], i);\n }\n }\n sort(others.rbegin(), others.rend());\n int need = N * N - (int)to_plant.size();\n for (int k = 0; k < need && k < (int)others.size(); k++) {\n to_plant.push_back(others[k].second);\n }\n // sort to_plant by val desc\n sort(to_plant.begin(), to_plant.end(), [&](int a, int b) {\n return vals[a] > vals[b] || (vals[a] == vals[b] && a < b);\n });\n if ((int)to_plant.size() > N * N) {\n to_plant.resize(N * N);\n }\n while ((int)to_plant.size() < N * N) {\n // shouldn't happen\n to_plant.push_back(0);\n }\n // now initial curr\n vector curr(N * N);\n for (int i = 0; i < N * N; i++) curr[i] = to_plant[i];\n auto compute_obj = [&](const vector& arr) -> long long {\n long long obj = 0;\n // horiz\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N - 1; j++) {\n int p = arr[i * N + j];\n int q = arr[i * N + j + 1];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n }\n }\n // vert\n for (int i = 0; i < N - 1; i++) {\n for (int j = 0; j < N; j++) {\n int p = arr[i * N + j];\n int q = arr[(i + 1) * N + j];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n }\n }\n return obj;\n };\n long long curr_obj = compute_obj(curr);\n vector best_arr = curr;\n long long best_obj = curr_obj;\n vector curr_arr = curr;\n double temp = 5000.0;\n for (int iter = 0; iter < 50000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr[p1], curr_arr[p2]);\n long long new_obj = compute_obj(curr_arr);\n long long delta = new_obj - curr_obj;\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double prob = exp(delta / temp);\n double r = (rng() % 1000000000) / 1000000000.0;\n if (r < prob) accept = true;\n }\n if (accept) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr;\n }\n } else {\n swap(curr_arr[p1], curr_arr[p2]);\n }\n if (iter % 100 == 0) {\n temp *= 0.999;\n if (temp < 0.1) temp = 0.1;\n }\n }\n // now output best_arr\n vector> A(N, vector(N, 0));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n A[i][j] = best_arr[i * N + j];\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << A[i][j];\n if (j < N - 1) cout << \" \";\n else cout << \"\\n\";\n }\n }\n cout.flush();\n // read new\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n int N, M, V;\n cin >> N >> M >> V;\n vector S(N), T(N);\n for (auto& str : S) cin >> str;\n for (auto& str : T) cin >> str;\n vector> grid(N, vector(N));\n vector> target(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n grid[i][j] = S[i][j] - '0';\n target[i][j] = T[i][j] - '0';\n }\n }\n vector> supplies, demands;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] && target[i][j] == 0) supplies.emplace_back(i, j);\n if (!grid[i][j] && target[i][j]) demands.emplace_back(i, j);\n }\n }\n if (supplies.size() != demands.size()) {\n // Should be equal, but handle by taking min or something, but assume equal\n }\n int Vp = 2;\n int L = 1;\n cout << Vp << endl;\n for (int u = 1; u < Vp; u++) {\n cout << 0 << \" \" << L << endl;\n }\n int rx = N / 2, ry = N / 2;\n cout << rx << \" \" << ry << endl;\n int cur_dir = 0;\n bool holding = false;\n vector commands;\n int DX[4] = {0, 1, 0, -1};\n int DY[4] = {1, 0, -1, 0};\n int delx[5] = {0, 0, 1, 0, -1};\n int dely[5] = {0, 1, 0, -1, 0};\n char mchar[5] = {'.', 'R', 'D', 'L', 'U'};\n char rchar[3] = {'.', 'L', 'R'};\n auto get_min_approx = [&](int px, int py) -> int {\n int md = 1000000000;\n for (int d = 0; d < 4; d++) {\n int tx = px - DX[d] * L;\n int ty = py - DY[d] * L;\n if (tx >= 0 && tx < N && ty >= 0 && ty < N) {\n md = min(md, abs(rx - tx) + abs(ry - ty));\n }\n }\n return md;\n };\n vector sup_used(supplies.size(), false);\n vector dem_used(demands.size(), false);\n int sup_rem = supplies.size();\n int dem_rem = demands.size();\n auto do_bfs = [&](int sx, int sy) -> vector> {\n vector> targets;\n for (int dd = 0; dd < 4; dd++) {\n int needx = sx - DX[dd] * L;\n int needy = sy - DY[dd] * L;\n if (needx >= 0 && needx < N && needy >= 0 && needy < N) {\n targets.emplace_back(needx, needy, dd);\n }\n }\n if (targets.empty()) return {};\n vector>> dist(N, vector>(N, vector(4, -1)));\n vector>> prev_x(N, vector>(N, vector(4, -1)));\n vector>> prev_y(N, vector>(N, vector(4, -1)));\n vector>> prev_d(N, vector>(N, vector(4, -1)));\n vector>> prev_move(N, vector>(N, vector(4, -1)));\n vector>> prev_rot(N, vector>(N, vector(4, -1)));\n dist[rx][ry][cur_dir] = 0;\n queue> q;\n q.emplace(rx, ry, cur_dir);\n while (!q.empty()) {\n auto [x, y, d] = q.front(); q.pop();\n for (int mid = 0; mid < 5; mid++) {\n int nx = x + delx[mid];\n int ny = y + dely[mid];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n for (int rid = 0; rid < 3; rid++) {\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n int nd = (d + dch) % 4;\n if (dist[nx][ny][nd] == -1) {\n dist[nx][ny][nd] = dist[x][y][d] + 1;\n prev_x[nx][ny][nd] = x;\n prev_y[nx][ny][nd] = y;\n prev_d[nx][ny][nd] = d;\n prev_move[nx][ny][nd] = mid;\n prev_rot[nx][ny][nd] = rid;\n q.emplace(nx, ny, nd);\n }\n }\n }\n }\n int min_d = 1000000000;\n int bx = -1, by = -1, bd = -1;\n for (auto [px, py, pd] : targets) {\n if (dist[px][py][pd] != -1 && dist[px][py][pd] < min_d) {\n min_d = dist[px][py][pd];\n bx = px; by = py; bd = pd;\n }\n }\n if (min_d == 1000000000) return {};\n vector> rev_path;\n int cx = bx, cy = by, cd = bd;\n while (dist[cx][cy][cd] > 0) {\n int mid = prev_move[cx][cy][cd];\n int rid = prev_rot[cx][cy][cd];\n rev_path.emplace_back(mid, rid);\n int px = prev_x[cx][cy][cd];\n int py = prev_y[cx][cy][cd];\n int pd = prev_d[cx][cy][cd];\n cx = px; cy = py; cd = pd;\n }\n reverse(rev_path.begin(), rev_path.end());\n return rev_path;\n };\n while (sup_rem > 0) {\n // Choose best supply if not holding\n int best_sup = -1;\n int minc = 1000000000;\n for (int i = 0; i < (int)supplies.size(); i++) {\n if (!sup_used[i]) {\n auto [px, py] = supplies[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_sup = i;\n }\n }\n }\n if (best_sup == -1) break;\n auto [sx, sy] = supplies[best_sup];\n int cur_fx = rx + DX[cur_dir] * L;\n int cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != sx || cur_fy != sy) {\n auto pth = do_bfs(sx, sy);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[sx][sy] = 0;\n holding = true;\n sup_used[best_sup] = true;\n sup_rem--;\n // Now choose best demand\n int best_dem = -1;\n minc = 1000000000;\n for (int i = 0; i < (int)demands.size(); i++) {\n if (!dem_used[i]) {\n auto [px, py] = demands[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_dem = i;\n }\n }\n }\n if (best_dem == -1) break;\n auto [tx, ty] = demands[best_dem];\n cur_fx = rx + DX[cur_dir] * L;\n cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != tx || cur_fy != ty) {\n auto pth = do_bfs(tx, ty);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[tx][ty] = 1;\n holding = false;\n dem_used[best_dem] = true;\n dem_rem--;\n }\n for (auto& cmd : commands) {\n cout << cmd << endl;\n }\n return 0;\n}","ahc039":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Info {\n ll tot, pre, suf, sub;\n};\n\nInfo comb(const Info& l, const Info& r) {\n Info res;\n res.tot = l.tot + r.tot;\n res.pre = max(l.pre, l.tot + r.pre);\n res.suf = max(r.suf, r.tot + l.suf);\n res.sub = max({l.sub, r.sub, l.suf + r.pre});\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n int N;\n cin >> N;\n vector X(2 * N), Y(2 * N);\n vector ism(2 * N, false);\n for (int i = 0; i < 2 * N; i++) {\n cin >> X[i] >> Y[i];\n if (i < N) ism[i] = true;\n }\n set sx, sy;\n for (int i = 0; i < 2 * N; i++) {\n sx.insert(X[i]);\n sy.insert(Y[i]);\n }\n vector allx(sx.begin(), sx.end());\n vector ally(sy.begin(), sy.end());\n int CX = allx.size();\n int CY = ally.size();\n map xr, yr;\n for (int i = 0; i < CX; i++) xr[allx[i]] = i + 1;\n for (int i = 0; i < CY; i++) yr[ally[i]] = i + 1;\n vector>> col(CX + 1);\n for (int i = 0; i < 2 * N; i++) {\n int rrx = xr[X[i]];\n int rry = yr[Y[i]];\n ll v = ism[i] ? 1LL : -1LL;\n col[rrx].emplace_back(rry, v);\n }\n vector tree(4 * 10005);\n auto build_func = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n tree[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n vector cur_ysum(10005, 0);\n if (CY >= 1) build_func(build_func, 1, 1, CY);\n auto upd = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n tree[node].tot += delta;\n tree[node].pre += delta;\n tree[node].suf += delta;\n tree[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n ll best_val = 0;\n int blx = -1, brx = -1, bly = -1, bry = -1;\n auto get_kad = [&](int& syy, int& eyy) -> ll {\n if (CY < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_ysum[1];\n max_so = meh;\n for (int j = 2; j <= CY; j++) {\n if (cur_ysum[j] > meh + cur_ysum[j]) {\n meh = cur_ysum[j];\n cl = j;\n } else {\n meh += cur_ysum[j];\n }\n if (meh >= max_so) {\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else {\n br = j;\n }\n }\n }\n syy = bl;\n eyy = br;\n return max_so;\n };\n int step = 50;\n vector lsamps;\n for (int i = 1; i <= CX; i += step) lsamps.push_back(i);\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CX; R++) {\n for (auto [yy, vv] : col[R]) {\n upd(upd, 1, 1, CY, yy, vv);\n cur_ysum[yy] += vv;\n hist.emplace_back(yy, vv);\n }\n if ((R - L) % 25 == 0 || R == CX || R == L) {\n Info infoo;\n if (CY >= 1) infoo = tree[1];\n else infoo = {0,0,0,0};\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int syy, eyy;\n ll act = get_kad(syy, eyy);\n if (act > best_val && eyy > syy && L < R) {\n int lx_x = allx[L - 1];\n int rx_x = allx[R - 1];\n int ly_y = ally[syy - 1];\n int ry_y = ally[eyy - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = L;\n brx = R;\n bly = syy;\n bry = eyy;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [yy, vv] = hist[i];\n upd(upd, 1, 1, CY, yy, -vv);\n cur_ysum[yy] -= vv;\n }\n }\n if (best_val <= 0 || blx == -1) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n int x1 = allx[blx - 1], x2 = allx[brx - 1];\n int y1 = ally[bly - 1], y2 = ally[bry - 1];\n if (x1 == x2 || y1 == y2) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y2 << \"\\n\";\n cout << x1 << \" \" << y2 << \"\\n\";\n }\n }\n}","ahc040":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Strat {\n double wa, wb;\n bool use_area;\n};\n\nint main() {\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector W(N), H(N);\n for (int i = 0; i < N; i++) {\n cin >> W[i] >> H[i];\n }\n vector strats = {\n {1.0, 1.0, false},\n {2.0, 1.0, false},\n {1.0, 2.0, false},\n {3.0, 1.0, false},\n {1.0, 3.0, false},\n {5.0, 1.0, false},\n {1.0, 5.0, false},\n {10.0, 1.0, false},\n {1.0, 10.0, false},\n {0.0, 0.0, true}\n };\n mt19937 rng(12345);\n int ns = strats.size();\n vector best_rot(N, 0), best_dir(N, 0), best_bref(N, -1);\n ll best_meas = 4e18;\n for (int t = 0; t < T; t++) {\n vector rotv(N), dirv(N), bref(N);\n bool do_random = (t % 7 == 0);\n bool do_perturb = (!do_random && t % 5 == 1 && best_meas < 4e18 && t > 10);\n if (do_random) {\n for (int i = 0; i < N; i++) {\n rotv[i] = rng() % 2;\n dirv[i] = rng() % 2;\n bref[i] = (i > 0 ? (rng() % i) : -1);\n }\n } else if (do_perturb) {\n rotv = best_rot;\n dirv = best_dir;\n bref = best_bref;\n int num_perturb = max(1, N / 5);\n for (int k = 0; k < num_perturb; k++) {\n int pos = rng() % N;\n if (rng() % 2 == 0) rotv[pos] = 1 - rotv[pos];\n if (rng() % 2 == 0) dirv[pos] = 1 - dirv[pos];\n if (pos > 0) {\n if (rng() % 3 == 0) {\n int delta = (rng() % 5 - 2);\n bref[pos] = max(-1, min(pos - 1, bref[pos] + delta));\n } else if (rng() % 3 == 1) {\n bref[pos] = rng() % pos;\n }\n }\n }\n } else {\n Strat st = strats[t % ns];\n vector px(N, 0), py(N, 0), pww(N, 0), phh(N, 0);\n ll cmaxw = 0, cmaxh = 0;\n for (int i = 0; i < N; i++) {\n double bestc = 1e30;\n int br = -1, bd = -1, bb = -1;\n ll bx = 0, by = 0, bww = 0, bhh = 0;\n vector bs_vec;\n for (int b = -1; b < i; b++) bs_vec.push_back(b);\n for (int r = 0; r < 2; r++) {\n ll ww = r ? H[i] : W[i];\n ll hh = r ? W[i] : H[i];\n for (int dd = 0; dd < 2; dd++) {\n for (int b : bs_vec) {\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n ll y1 = yy, y2 = yy + hh;\n ll yj1 = py[j], yj2 = py[j] + phh[j];\n if (max(y1, yj1) < min(y2, yj2)) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n ll x1 = xx, x2 = xx + ww;\n ll xj1 = px[j], xj2 = px[j] + pww[j];\n if (max(x1, xj1) < min(x2, xj2)) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n ll nw = max(cmaxw, xx + ww);\n ll nh = max(cmaxh, yy + hh);\n double cost;\n if (st.use_area) {\n cost = 1.0 * nw * nh;\n } else {\n cost = st.wa * nw + st.wb * nh;\n }\n // add small noise for variety\n cost += (rng() % 1001 - 500) * 1e-5;\n if (cost < bestc) {\n bestc = cost;\n br = r;\n bd = dd;\n bb = b;\n bx = xx;\n by = yy;\n bww = ww;\n bhh = hh;\n }\n }\n }\n }\n rotv[i] = br;\n dirv[i] = bd;\n bref[i] = bb;\n px[i] = bx;\n py[i] = by;\n pww[i] = bww;\n phh[i] = bhh;\n cmaxw = max(cmaxw, bx + bww);\n cmaxh = max(cmaxh, by + bhh);\n }\n }\n cout << N << endl;\n for (int i = 0; i < N; i++) {\n cout << i << \" \" << rotv[i] << \" \" << (dirv[i] ? \"U\" : \"L\") << \" \" << bref[i] << endl;\n }\n cout.flush();\n ll wp, hp;\n cin >> wp >> hp;\n ll meas = wp + hp;\n if (meas + 3LL * sigma < best_meas) {\n best_meas = meas;\n best_rot = rotv;\n best_dir = dirv;\n best_bref = bref;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n vector X(N), Y(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i];\n }\n vector level(N, 0);\n bool changed = true;\n int max_iter = N * H + 100;\n int iter = 0;\n while (changed && iter++ < max_iter) {\n changed = false;\n long long best_a = -1;\n int best_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] < H) {\n bool can = false;\n for (int u : adj[v]) {\n if (level[u] == level[v]) {\n can = true;\n break;\n }\n }\n if (can && A[v] > best_a) {\n best_a = A[v];\n best_v = v;\n }\n }\n }\n if (best_v != -1) {\n level[best_v]++;\n changed = true;\n }\n }\n // cleanup decrease lowest A invalid first\n iter = 0;\n while (iter++ < max_iter) {\n long long worst_a = LLONG_MAX;\n int worst_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] > 0) {\n bool has = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n has = true;\n break;\n }\n }\n if (!has && A[v] < worst_a) {\n worst_a = A[v];\n worst_v = v;\n }\n }\n }\n if (worst_v != -1) {\n level[worst_v]--;\n } else {\n break;\n }\n }\n vector p(N, -1);\n for (int v = 0; v < N; v++) {\n if (level[v] == 0) {\n p[v] = -1;\n continue;\n }\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n p[v] = u;\n break;\n }\n }\n }\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << p[i];\n }\n cout << endl;\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint NN;\nvector board;\nvector> moves;\n\nvoid do_shift(char d, int p) {\n if (d == 'L') {\n for (int j = 0; j < NN - 1; j++) board[p][j] = board[p][j + 1];\n board[p][NN - 1] = '.';\n } else if (d == 'R') {\n for (int j = NN - 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 < NN - 1; i++) board[i][p] = board[i + 1][p];\n board[NN - 1][p] = '.';\n } else if (d == 'D') {\n for (int i = NN - 1; i > 0; i--) board[i][p] = board[i - 1][p];\n board[0][p] = '.';\n }\n}\n\nint main() {\n int N;\n cin >> N;\n NN = N;\n board.resize(N);\n for (int i = 0; i < N; i++) cin >> board[i];\n int iter = 0;\n while (true) {\n int numx = 0;\n for (auto& s : board) for (char c : s) if (c == 'x') numx++;\n if (numx == 0) break;\n if (++iter > 10000) break;\n double best_r = -1;\n char best_d = ' ';\n int best_p = -1;\n int best_k = 0;\n int best_n = 0;\n int best_c = 100000;\n auto update = [&](double rt, char dd, int pp, int kk, int nm, int cc) {\n bool better = false;\n if (rt > best_r + 1e-9) better = true;\n else if (abs(rt - best_r) < 1e-9) {\n if (cc < best_c) better = true;\n else if (cc == best_c && nm > best_n) better = true;\n }\n if (better) {\n best_r = rt;\n best_d = dd;\n best_p = pp;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n };\n // rows left\n for (int i = 0; i < N; i++) {\n int maxj = -1, nm = 0;\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxj = j; nm++; }\n }\n if (nm > 0) {\n int kk = maxj + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'L', i, kk, nm, cc);\n }\n }\n // rows right\n for (int i = 0; i < N; i++) {\n int lmost = N;\n for (int j = N - 1; j >= 0; j--) {\n if (board[i][j] == 'o') { lmost = j + 1; break; }\n }\n int minj = N, nm = 0;\n for (int j = lmost; j < N; j++) {\n if (board[i][j] == 'x') { minj = min(minj, j); nm++; }\n }\n if (nm > 0) {\n int kk = N - minj;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'R', i, kk, nm, cc);\n }\n }\n // cols up\n for (int j = 0; j < N; j++) {\n int maxi = -1, nm = 0;\n for (int i = 0; i < N; i++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxi = i; nm++; }\n }\n if (nm > 0) {\n int kk = maxi + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'U', j, kk, nm, cc);\n }\n }\n // cols down\n for (int j = 0; j < N; j++) {\n int lmost = N;\n for (int i = N - 1; i >= 0; i--) {\n if (board[i][j] == 'o') { lmost = i + 1; break; }\n }\n int mini = N, nm = 0;\n for (int i = lmost; i < N; i++) {\n if (board[i][j] == 'x') { mini = min(mini, i); nm++; }\n }\n if (nm > 0) {\n int kk = N - mini;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'D', j, kk, nm, cc);\n }\n }\n if (best_p == -1) break;\n char dd = best_d;\n int p = best_p;\n int kk = best_k;\n char op = (dd == 'L' ? 'R' : (dd == 'R' ? 'L' : (dd == 'U' ? 'D' : 'U')));\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(dd, p);\n do_shift(dd, p);\n }\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(op, p);\n do_shift(op, p);\n }\n }\n for (auto [d, pp] : moves) {\n cout << d << \" \" << pp << endl;\n }\n}","ahc044":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, L;\n cin >> N >> L;\n vector T(N);\n for(int i = 0; i < N; i++) cin >> T[i];\n vector pref(N + 1, 0);\n for(int j = 0; j < N; j++) {\n pref[j + 1] = pref[j] + T[j] + 1;\n }\n ll total = pref[N];\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n auto sample = [&](const vector& p, ll tot) -> int {\n ll r = uniform_int_distribution(0, tot - 1)(rng);\n auto it = upper_bound(p.begin(), p.end(), r);\n return (it - p.begin()) - 1;\n };\n auto get_err = [&](const vector& A, const vector& B) -> int {\n vector cnt(N, 0);\n int cur = 0;\n for(int w = 1; w <= L; w++) {\n cnt[cur]++;\n if(w < L) {\n if(cnt[cur] % 2 == 1) cur = A[cur];\n else cur = B[cur];\n }\n }\n int err = 0;\n for(int i = 0; i < N; i++) {\n err += abs(cnt[i] - T[i]);\n }\n return err;\n };\n const int NUM_RANDOM = 150;\n int best_err = INT_MAX;\n vector best_a, best_b;\n vector pref_t = pref;\n for(int tr = 0; tr < NUM_RANDOM; tr++) {\n vector A(N), B(N);\n for(int i = 0; i < N; i++) {\n A[i] = sample(pref_t, total);\n B[i] = sample(pref_t, total);\n }\n int err = get_err(A, B);\n if(err < best_err) {\n best_err = err;\n best_a = A;\n best_b = B;\n }\n }\n const int NUM_MUT = 400;\n for(int m = 0; m < NUM_MUT; m++) {\n vector A = best_a;\n vector B = best_b;\n int i = uniform_int_distribution(0, N - 1)(rng);\n int choice = uniform_int_distribution(0, 1)(rng);\n int news = sample(pref_t, total);\n if(choice == 0) A[i] = news;\n else B[i] = news;\n int new_err = get_err(A, B);\n if(new_err < best_err) {\n best_err = new_err;\n best_a = A;\n best_b = B;\n }\n }\n for(int i = 0; i < N; i++) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nint main() {\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int &g : G) cin >> g;\n vector cx(N), cy(N);\n vector Lx(N), Rx(N), Ly(N), Ry(N);\n for (int i = 0; i < N; i++) {\n cin >> Lx[i] >> Rx[i] >> Ly[i] >> Ry[i];\n cx[i] = (Lx[i] + Rx[i]) / 2.0;\n cy[i] = (Ly[i] + Ry[i]) / 2.0;\n }\n vector order(N);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int i, int j) {\n if (cx[i] != cx[j]) return cx[i] < cx[j];\n return cy[i] < cy[j];\n });\n vector> groups(M);\n int idx = 0;\n for (int k = 0; k < M; k++) {\n groups[k].resize(G[k]);\n for (int j = 0; j < G[k]; j++) {\n groups[k][j] = order[idx++];\n }\n }\n int queries_used = 0;\n vector>> collected_edges(M);\n int adv_base = max(1, min(L - 1, N / Q));\n for (int k = 0; k < M && queries_used < Q; k++) {\n vector &grp = groups[k];\n int gs = grp.size();\n if (gs <= 1) continue;\n set> kn;\n vector> &coll = collected_edges[k];\n int i = 0;\n int adv = adv_base;\n while (i < gs - 1 && queries_used < Q) {\n int len = min(L, gs - i);\n if (len < 2) break;\n cout << \"? \" << len;\n for (int p = i; p < i + len; p++) cout << \" \" << grp[p];\n cout << endl;\n vector> resp(len - 1);\n for (int r = 0; r < len - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (kn.find(p) == kn.end()) {\n kn.insert(p);\n coll.push_back(p);\n }\n }\n queries_used++;\n if (i + len >= gs) break;\n int this_adv = max(1, adv);\n i += this_adv;\n }\n if (queries_used < Q && gs > L) {\n int start = max(0, gs - L);\n int len2 = min(L, gs - start);\n if (len2 >= 2) {\n cout << \"? \" << len2;\n for (int p = start; p < start + len2; p++) cout << \" \" << grp[p];\n cout << endl;\n vector> resp(len2 - 1);\n for (int r = 0; r < len2 - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (kn.find(p) == kn.end()) {\n kn.insert(p);\n coll.push_back(p);\n }\n }\n queries_used++;\n }\n }\n }\n cout << \"!\" << endl;\n for (int k = 0; k < M; k++) {\n vector grp = groups[k];\n int gs = grp.size();\n for (int j = 0; j < gs; j++) {\n cout << grp[j];\n if (j < gs - 1) cout << \" \";\n else cout << endl;\n }\n if (gs <= 1) continue;\n set> knownp;\n vector> &coll = collected_edges[k];\n for (auto p : coll) {\n int a = p.first, b = p.second;\n if (a > b) swap(a, b);\n knownp.insert({a, b});\n }\n vector> known_list;\n vector local_id(N, -1);\n for (int j = 0; j < gs; j++) local_id[grp[j]] = j;\n for (auto &pr : knownp) {\n int a = pr.first, b = pr.second;\n int ia = local_id[a], ib = local_id[b];\n if (ia == -1 || ib == -1) continue;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n known_list.emplace_back(d, ia, ib);\n }\n sort(known_list.begin(), known_list.end());\n vector parent(gs);\n iota(parent.begin(), parent.end(), 0);\n auto find = [&](auto &self, int x) -> int {\n return parent[x] == x ? x : parent[x] = self(self, parent[x]);\n };\n auto unite = [&](int x, int y) {\n x = find(find, x);\n y = find(find, y);\n if (x != y) {\n parent[x] = y;\n return true;\n }\n return false;\n };\n vector> mst_roads;\n int edges_added = 0;\n for (auto &[d, ia, ib] : known_list) {\n if (unite(ia, ib)) {\n mst_roads.emplace_back(grp[ia], grp[ib]);\n edges_added++;\n }\n if (edges_added == gs - 1) break;\n }\n if (edges_added < gs - 1) {\n vector> unk;\n for (int ii = 0; ii < gs; ii++) {\n for (int jj = ii + 1; jj < gs; jj++) {\n int a = grp[ii], b = grp[jj];\n pair p = {min(a, b), max(a, b)};\n if (knownp.find(p) != knownp.end()) continue;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n unk.emplace_back(d, ii, jj);\n }\n }\n sort(unk.begin(), unk.end());\n for (auto &[d, ia, ib] : unk) {\n if (unite(ia, ib)) {\n mst_roads.emplace_back(grp[ia], grp[ib]);\n edges_added++;\n }\n if (edges_added == gs - 1) break;\n }\n }\n for (auto &rd : mst_roads) {\n cout << rd.first << \" \" << rd.second << endl;\n }\n }\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> points(M);\n for (int m = 0; m < M; m++) {\n cin >> points[m].first >> points[m].second;\n }\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n pair current = points[0];\n vector> seq;\n for (int k = 1; k < M; k++) {\n pair goal = points[k];\n set> forbidden;\n for (int t = k + 1; t < M; t++) {\n forbidden.insert(points[t]);\n }\n vector> dist(N, vector(N, -1));\n vector>> prevpos(N, vector>(N, {-1, -1}));\n vector>> prevact(N, vector>(N, {' ', ' '}));\n queue> q;\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n // M actions\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n // S actions\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Fallback: no forbidden, allow all\n forbidden.clear();\n dist.assign(N, vector(N, -1));\n prevpos.assign(N, vector>(N, {-1, -1}));\n prevact.assign(N, vector>(N, {' ', ' '}));\n q = queue>();\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Still unreachable, fallback to pure M manhattan path, allowing everything\n // Compute simple horiz then vert M path\n vector> path;\n int ci = current.first, cj = current.second;\n int gi = goal.first, gj = goal.second;\n int stepi, stepj;\n stepi = (gi > ci ? 1 : (gi < ci ? -1 : 0));\n for (int s = 0; s < abs(gi - ci); s++) {\n path.push_back({'M', (stepi > 0 ? 'D' : 'U')});\n }\n stepj = (gj > cj ? 1 : (gj < cj ? -1 : 0));\n for (int s = 0; s < abs(gj - cj); s++) {\n path.push_back({'M', (stepj > 0 ? 'R' : 'L')});\n }\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n continue;\n }\n // Reconstruct path\n vector> path;\n pair pos = goal;\n while (pos != current) {\n pair act = prevact[pos.first][pos.second];\n path.push_back(act);\n pos = prevpos[pos.first][pos.second];\n }\n reverse(path.begin(), path.end());\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n }\n for (auto& p : seq) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}"},"4":{"ahc001":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Rect {\n int x1, y1, x2, y2;\n};\n\nint N;\nvector X, Y, R;\nvector best_rects;\ndouble best_score = -1.0;\n\ndouble compute_score(const vector& recs) {\n double tot = 0.0;\n for (int i = 0; i < N; i++) {\n ll a = recs[i].x1, b = recs[i].y1, c = recs[i].x2, d = recs[i].y2;\n ll s = (c - a) * 1LL * (d - b);\n ll rr = R[i];\n if (s == 0 || rr == 0) continue;\n double ratio = min(s, rr) * 1.0 / max(s, rr);\n tot += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return tot;\n}\n\nvoid solve_rects(int lx, int ly, int rx, int ry, vector ps, vector& recs) {\n if (ps.size() == 0) return;\n if (ps.size() == 1) {\n recs[ps[0]] = {lx, ly, rx, ry};\n return;\n }\n ll area = (rx - lx) * 1LL * (ry - ly);\n double best_mis = 1e30;\n int best_d = -1, best_kk = -1, best_ct = -1;\n for (int dir = 0; dir < 2; dir++) {\n vector idx = ps;\n if (dir == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int m = idx.size();\n vector pref(m + 1, 0);\n for (int j = 1; j <= m; j++) {\n pref[j] = pref[j - 1] + R[idx[j - 1]];\n }\n ll tot = pref[m];\n if (tot == 0) continue;\n for (int k = 1; k < m; k++) {\n ll sleft = pref[k];\n int idl = idx[k - 1], idr = idx[k];\n ll min_c, max_c;\n if (dir == 0) {\n min_c = X[idl] + 1;\n max_c = X[idr];\n } else {\n min_c = Y[idl] + 1;\n max_c = Y[idr];\n }\n ll low = dir == 0 ? lx + 1 : ly + 1;\n ll high = dir == 0 ? rx - 1 : ry - 1;\n min_c = max(min_c, low);\n max_c = min(max_c, high);\n if (min_c > max_c) continue;\n double target_a = sleft * 1.0 / tot * area;\n ll target_cut;\n if (dir == 0) {\n ll hgt = ry - ly;\n if (hgt <= 0) continue;\n ll dw = (ll)round(target_a / hgt);\n target_cut = lx + dw;\n } else {\n ll wid = rx - lx;\n if (wid <= 0) continue;\n ll dh = (ll)round(target_a / wid);\n target_cut = ly + dh;\n }\n ll cutt = max(min_c, min(max_c, target_cut));\n ll act_area = 0;\n if (dir == 0) {\n act_area = (cutt - lx) * 1LL * (ry - ly);\n } else {\n act_area = (rx - lx) * 1LL * (cutt - ly);\n }\n double mis = fabs(act_area - target_a);\n double pert = (rand() % 1000000) * 1e-9;\n double perturbed = mis + pert;\n if (perturbed < best_mis) {\n best_mis = perturbed;\n best_d = dir;\n best_kk = k;\n best_ct = (int)cutt;\n }\n }\n }\n if (best_d == -1) {\n bool found = false;\n int dir_try = (rx - lx > 1 ? 0 : 1);\n for (int tries = 0; tries < 2 && !found; tries++) {\n int dirr = dir_try;\n vector idxx = ps;\n if (dirr == 0) {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int mm = idxx.size();\n for (int kk = 1; kk < mm; kk++) {\n int idl = idxx[kk - 1], idr = idxx[kk];\n ll minc_ = dirr == 0 ? X[idl] + 1 : Y[idl] + 1;\n ll maxc_ = dirr == 0 ? X[idr] : Y[idr];\n ll loww = dirr == 0 ? lx + 1 : ly + 1;\n ll highh = dirr == 0 ? rx - 1 : ry - 1;\n if (minc_ <= maxc_ && minc_ <= highh && maxc_ >= loww) {\n best_d = dirr;\n best_kk = kk;\n ll midv = (max(minc_, loww) + min(maxc_, highh)) / 2;\n best_ct = (int)midv;\n found = true;\n break;\n }\n }\n dir_try = 1 - dir_try;\n }\n if (!found) {\n best_d = 0;\n best_kk = ps.size() / 2;\n best_ct = lx + (rx - lx) / 2;\n if (best_ct < lx + 1) best_ct = lx + 1;\n if (best_ct > rx - 1) best_ct = rx - 1;\n }\n }\n vector idx = ps;\n if (best_d == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n vector left_ps(idx.begin(), idx.begin() + best_kk);\n vector right_ps(idx.begin() + best_kk, idx.end());\n if (best_d == 0) {\n solve_rects(lx, ly, best_ct, ry, left_ps, recs);\n solve_rects(best_ct, ly, rx, ry, right_ps, recs);\n } else {\n solve_rects(lx, ly, rx, best_ct, left_ps, recs);\n solve_rects(lx, best_ct, rx, ry, right_ps, recs);\n }\n}\n\nvoid optimize(vector& recs) {\n int max_passes = 20;\n for (int pass = 0; pass < max_passes; pass++) {\n for (int ii = 0; ii < N; ii++) {\n int i = ii;\n ll rr = R[i];\n Rect &rct = recs[i];\n ll cur_a = rct.x1;\n ll cur_b = rct.y1;\n ll cur_c = rct.x2;\n ll cur_d = rct.y2;\n ll s = (cur_c - cur_a) * 1LL * (cur_d - cur_b);\n if (s == rr) continue;\n bool is_expand = s < rr;\n ll target_s = rr;\n vector ddirs = {0,1,2,3};\n random_shuffle(ddirs.begin(), ddirs.end());\n bool moved = false;\n for (int dd : ddirs) {\n if (moved) break;\n ll dim = 0;\n ll max_delta = 0;\n ll delta_need = 0;\n if (dd == 0) { // c: 0 right\n dim = cur_d - cur_b;\n if (dim <= 0) continue;\n if (is_expand) {\n ll max_pos = 10000;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_b, (ll)oj.y1), ov2 = min(cur_d, (ll)oj.y2);\n if (ov1 < ov2) {\n max_pos = min(max_pos, (ll)oj.x1);\n }\n }\n max_delta = max_pos - cur_c;\n } else {\n ll min_pos = max(cur_a + 1, X[i] + 1);\n max_delta = cur_c - min_pos;\n }\n if (max_delta <= 0) continue;\n ll need = abs(target_s - s);\n delta_need = (need + dim - 1) / dim;\n } else if (dd == 1) { // a left\n dim = cur_d - cur_b;\n if (dim <= 0) continue;\n if (is_expand) {\n ll min_pos = 0;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_b, (ll)oj.y1), ov2 = min(cur_d, (ll)oj.y2);\n if (ov1 < ov2) {\n min_pos = max(min_pos, (ll)oj.x2);\n }\n }\n max_delta = cur_a - min_pos;\n } else {\n ll max_pos = min(cur_c - 1, X[i]);\n max_delta = max_pos - cur_a;\n }\n if (max_delta <= 0) continue;\n ll need = abs(target_s - s);\n delta_need = (need + dim - 1) / dim;\n } else if (dd == 2) { // d up\n dim = cur_c - cur_a;\n if (dim <= 0) continue;\n if (is_expand) {\n ll max_pos = 10000;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_a, (ll)oj.x1), ov2 = min(cur_c, (ll)oj.x2);\n if (ov1 < ov2) {\n max_pos = min(max_pos, (ll)oj.y1);\n }\n }\n max_delta = max_pos - cur_d;\n } else {\n ll min_pos = max(cur_b + 1, Y[i] + 1);\n max_delta = cur_d - min_pos;\n }\n if (max_delta <= 0) continue;\n ll need = abs(target_s - s);\n delta_need = (need + dim - 1) / dim;\n } else if (dd == 3) { // b down\n dim = cur_c - cur_a;\n if (dim <= 0) continue;\n if (is_expand) {\n ll min_pos = 0;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_a, (ll)oj.x1), ov2 = min(cur_c, (ll)oj.x2);\n if (ov1 < ov2) {\n min_pos = max(min_pos, (ll)oj.y2);\n }\n }\n max_delta = cur_b - min_pos;\n } else {\n ll max_pos = min(cur_d - 1, Y[i]);\n max_delta = max_pos - cur_b;\n }\n if (max_delta <= 0) continue;\n ll need = abs(target_s - s);\n delta_need = (need + dim - 1) / dim;\n }\n ll actual_d = min(max_delta, delta_need);\n if (actual_d <= 0) continue;\n if (is_expand) {\n if (dd == 0) rct.x2 += actual_d;\n else if (dd == 1) rct.x1 -= actual_d;\n else if (dd == 2) rct.y2 += actual_d;\n else if (dd == 3) rct.y1 -= actual_d;\n } else {\n if (dd == 0) rct.x2 -= actual_d;\n else if (dd == 1) rct.x1 += actual_d;\n else if (dd == 2) rct.y2 -= actual_d;\n else if (dd == 3) rct.y1 += actual_d;\n }\n moved = true;\n }\n }\n }\n}\n\nint main() {\n srand((unsigned)time(NULL));\n cin >> N;\n X.resize(N);\n Y.resize(N);\n R.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n best_score = -1.0;\n const int trials = 30;\n for (int t = 0; t < trials; t++) {\n vector recs(N);\n vector ps(N);\n iota(ps.begin(), ps.end(), 0);\n solve_rects(0, 0, 10000, 10000, ps, recs);\n optimize(recs);\n double sc = compute_score(recs);\n if (sc > best_score) {\n best_score = sc;\n best_rects = recs;\n }\n }\n for (int i = 0; i < N; i++) {\n cout << best_rects[i].x1 << \" \" << best_rects[i].y1 << \" \" << best_rects[i].x2 << \" \" << best_rects[i].y2 << endl;\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int si, sj;\n cin >> si >> sj;\n int T[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> T[i][j];\n int P[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> P[i][j];\n pair sib[50][50];\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) sib[i][j] = {-1,-1};\n int maxt = 0;\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) maxt = max(maxt, T[i][j]);\n vector>> tilec(maxt+1);\n for(int i=0;i<50;i++)for(int j=0;j<50;j++){\n tilec[T[i][j]].emplace_back(i,j);\n }\n for(auto& v: tilec){\n if(v.size()==2){\n auto [x1,y1]=v[0]; auto [x2,y2]=v[1];\n sib[x1][y1]={x2,y2};\n sib[x2][y2]={x1,y1};\n }\n }\n int di[4]={-1,0,1,0};\n int dj[4]={0,1,0,-1};\n char dc[4]={'U','R','D','L'};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n ll best_score = P[si][sj];\n string best_path = \"\";\n auto simulate = [&](int mode) -> pair {\n bool vis[50][50] = {};\n vis[si][sj] = true;\n ll score = P[si][sj];\n string path = \"\";\n int ci=si, cj = sj;\n while(true) {\n vector cands;\n for(int d=0;d<4;d++) {\n int ni = ci + di[d], nj = cj + dj[d];\n if(ni<0 || ni >=50 || nj<0 || nj>=50 || vis[ni][nj]) continue;\n auto [bx,by] = sib[ni][nj];\n if(bx!=-1 && vis[bx][by]) continue;\n cands.push_back(d);\n }\n if(cands.empty()) break;\n vector ws;\n if(mode ==0 || mode ==1) {\n ws.assign(cands.size(), 0);\n for(size_t k=0; k=50||nnj<0||nnj>=50 || vis[nni][nnj]) continue;\n auto [bx,by] = sib[nni][nnj];\n if(bx !=-1 && vis[bx][by]) continue;\n maxnp = max(maxnp, (ll)P[nni][nnj]);\n }\n ws[k] = val + maxnp + 1;\n }\n }\n size_t idx;\n if(mode ==0) {\n ll mw = -1;\n idx = 0;\n for(size_t k=0; k mw) {\n mw = ws[k];\n idx = k;\n }\n } else if(mode ==1) {\n ll sumw = 0;\n for(auto w : ws) sumw += w;\n size_t sz = cands.size();\n if(sumw == 0 || sz == 0) {\n idx = 0;\n } else {\n uniform_int_distribution dist(0, sumw-1);\n ll target = dist(rng);\n idx = sz -1;\n ll cum = 0;\n for(size_t k=0; k dist(0, sz-1);\n idx = dist(rng);\n }\n int d = cands[idx];\n int ni=ci + di[d], nj = cj + dj[d];\n vis[ni][nj] = true;\n score += P[ni][nj];\n path += dc[d];\n ci=ni; cj=nj;\n }\n return {score, path};\n };\n auto [sc, pa] = simulate(0);\n if(sc > best_score){ best_score=sc; best_path=pa; }\n const int TRIALS_WEIGHT = 200000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n const int TRIALS_UNIFORM = 500000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n cout << best_path << endl;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n double horiz[30][29];\n double vert[29][30];\n int hcnt[30][29];\n int vcnt[29][30];\n for(int i = 0; i < 30; i++) {\n for(int j = 0; j < 29; j++) {\n horiz[i][j] = 5000.0;\n hcnt[i][j] = 0;\n }\n }\n for(int i = 0; i < 29; i++) {\n for(int j = 0; j < 30; j++) {\n vert[i][j] = 5000.0;\n vcnt[i][j] = 0;\n }\n }\n const double bias = 80.0;\n for(int q = 0; q < 1000; q++) {\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n vector> dist(30, vector(30, 1e18));\n vector>> prev(30, vector>(30, {-1, -1}));\n dist[si][sj] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0.0, si, sj);\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n while (!pq.empty()) {\n auto [cost, r, c] = pq.top(); pq.pop();\n if (cost > dist[r][c]) continue;\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 30 || nc < 0 || nc >= 30) continue;\n double est_edgew = 1e18;\n int ecnt = 0;\n if (d == 0) { // U\n est_edgew = vert[nr][c];\n ecnt = vcnt[nr][c];\n } else if (d == 1) { // D\n est_edgew = vert[r][c];\n ecnt = vcnt[r][c];\n } else if (d == 2) { // L\n est_edgew = horiz[r][nc];\n ecnt = hcnt[r][nc];\n } else if (d == 3) { // R\n est_edgew = horiz[r][c];\n ecnt = hcnt[r][c];\n }\n double unc = 1.0 / (ecnt + 1.0);\n double modified = est_edgew - bias * unc;\n modified = max(50.0, modified);\n if (dist[nr][nc] > dist[r][c] + modified) {\n dist[nr][nc] = dist[r][c] + modified;\n prev[nr][nc] = {r, c};\n pq.emplace(dist[nr][nc], nr, nc);\n }\n }\n }\n // compute actual S\n double S = 0.0;\n int cr = ti, cc = tj;\n bool valid = true;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n if (p.first == -1) {\n valid = false;\n break;\n }\n int pr = p.first, pc = p.second;\n if (pr == cr && abs(pc - cc) == 1) { // horiz\n int minc = min(pc, cc);\n S += horiz[cr][minc];\n } else if (pc == cc && abs(pr - cr) == 1) { // vert\n int minr = min(pr, cr);\n S += vert[minr][cc];\n } else {\n valid = false;\n break;\n }\n cr = pr;\n cc = pc;\n }\n if (!valid || S >= 1e17) {\n // fallback pure manhattan? but rare\n // build any path\n string path = \"\";\n int r = si, c = sj;\n int dr_move = (ti > si ? 1 : (ti < si ? -1 : 0));\n int dc_move = (tj > sj ? 1 : (tj < sj ? -1 : 0));\n // rough, may wrong but to pass\n while (r != ti) {\n if (dr_move > 0) path += 'D';\n else path += 'U';\n r += dr_move;\n }\n while (c != tj) {\n if (dc_move > 0) path += 'R';\n else path += 'L';\n c += dc_move;\n }\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n continue;\n }\n // build path string using prev\n vector pathv;\n cr = ti; cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (cr > pr) pathv.push_back('D');\n else if (cr < pr) pathv.push_back('U');\n else if (cc > pc) pathv.push_back('R');\n else if (cc < pc) pathv.push_back('L');\n cr = pr;\n cc = pc;\n }\n reverse(pathv.begin(), pathv.end());\n string path;\n for (char ch : pathv) path += ch;\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n if (S == 0) continue;\n double factor = (double)meas / S;\n cr = ti;\n cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (pr == cr) { // horizontal\n int minc = min(pc, cc);\n int cnt = hcnt[cr][minc];\n double alpha = min(0.9, 2.0 / (cnt + 1.0));\n double mult = 1.0 - alpha + alpha * factor;\n horiz[cr][minc] *= mult;\n horiz[cr][minc] = max(100.0, min(10000.0, horiz[cr][minc]));\n hcnt[cr][minc]++;\n } else { // vertical\n int minr = min(pr, cr);\n int cnt = vcnt[minr][cc];\n double alpha = min(0.9, 2.0 / (cnt + 1.0));\n double mult = 1.0 - alpha + alpha * factor;\n vert[minr][cc] *= mult;\n vert[minr][cc] = max(100.0, min(10000.0, vert[minr][cc]));\n vcnt[minr][cc]++;\n }\n cr = pr;\n cc = pc;\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct AhoCorasick {\n vector> trie;\n vector fail;\n vector> outs;\n int nodes;\n\n AhoCorasick() : nodes(1) {\n trie.emplace_back();\n trie[0].fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n\n void insert(const string& s, int idx) {\n int node = 0;\n for (char cc : s) {\n int c = (cc == '.' ? 8 : cc - 'A');\n if (trie[node][c] == -1) {\n trie[node][c] = nodes++;\n trie.emplace_back();\n trie.back().fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n node = trie[node][c];\n }\n outs[node].push_back(idx);\n }\n\n void build() {\n queue q;\n for (int c = 0; c < 9; c++) {\n if (trie[0][c] != -1) {\n int child = trie[0][c];\n fail[child] = 0;\n q.push(child);\n }\n }\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int c = 0; c < 9; c++) {\n if (trie[cur][c] != -1) {\n int child = trie[cur][c];\n int f = fail[cur];\n while (f != 0 && trie[f][c] == -1) f = fail[f];\n if (trie[f][c] != -1) f = trie[f][c];\n fail[child] = f;\n outs[child].insert(outs[child].end(), outs[f].begin(), outs[f].end());\n q.push(child);\n }\n }\n }\n }\n\n void run_on_arr(const int* seq, int len, vector& matched) {\n int node = 0;\n for (int i = 0; i < len; i++) {\n int c = seq[i];\n while (node && trie[node][c] < 0) node = fail[node];\n if (trie[node][c] >= 0) node = trie[node][c];\n else node = 0;\n for (int id : outs[node]) {\n matched[id] = 1;\n }\n }\n }\n};\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector strs(M);\n for (int i = 0; i < M; i++) {\n cin >> strs[i];\n }\n AhoCorasick ac;\n for (int i = 0; i < M; i++) {\n ac.insert(strs[i], i);\n }\n ac.build();\n\n const int MAXD = 32;\n int seq_arr[MAXD];\n int double_len = 31;\n\n auto fill_seq_row = [&](const vector>& g, int r, int* seq) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[r][pos];\n seq[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n auto fill_seq_col = [&](const vector>& g, int c, int* seq) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[pos][c];\n seq[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, 7);\n uniform_real_distribution prob_dist(0.0, 1.0);\n\n vector> grid(N, vector(N, '.'));\n vector idx(M);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int a, int b) {\n return strs[a].size() > strs[b].size();\n });\n\n for (int ii : idx) {\n const string& s = strs[ii];\n int len = s.size();\n bool placed = false;\n // horiz\n for (int row = 0; !placed && row < N; row++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nc = (st + p) % N;\n char exp = s[p];\n if (grid[row][nc] != '.' && grid[row][nc] != exp) {\n can = false;\n break;\n }\n }\n if (can) {\n for (int p = 0; p < len; p++) {\n int nc = (st + p) % N;\n grid[row][nc] = s[p];\n }\n placed = true;\n }\n }\n }\n // vert\n for (int col = 0; !placed && col < N; col++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nr = (st + p) % N;\n char exp = s[p];\n if (grid[nr][col] != '.' && grid[nr][col] != exp) {\n can = false;\n break;\n }\n }\n if (can) {\n for (int p = 0; p < len; p++) {\n grid[(st + p) % N][col] = s[p];\n }\n placed = true;\n }\n }\n }\n }\n\n const int TRIALS = 2;\n const int MAX_ITER = 150000;\n double cooling_rate = 0.99995;\n\n vector> best_grid = grid;\n int best_covered = 0;\n\n for (int trial = 0; trial < TRIALS; trial++) {\n vector> cur_grid = grid;\n // random fill dots for diversity\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (cur_grid[i][j] == '.') {\n cur_grid[i][j] = 'A' + dist(rng);\n }\n }\n }\n\n vector cover_cnt(M, 0);\n vector temp_matched(M, 0);\n int current_covered = 0;\n\n for (int r = 0; r < N; r++) {\n fill_seq_row(cur_grid, r, seq_arr);\n fill(temp_matched.begin(), temp_matched.end(), 0);\n ac.run_on_arr(seq_arr, double_len, temp_matched);\n for (int i = 0; i < M; i++) {\n if (temp_matched[i]) cover_cnt[i]++;\n }\n }\n for (int c = 0; c < N; c++) {\n fill_seq_col(cur_grid, c, seq_arr);\n fill(temp_matched.begin(), temp_matched.end(), 0);\n ac.run_on_arr(seq_arr, double_len, temp_matched);\n for (int i = 0; i < M; i++) {\n if (temp_matched[i]) cover_cnt[i]++;\n }\n }\n for (int i = 0; i < M; i++) {\n if (cover_cnt[i] > 0) current_covered++;\n }\n\n double temp = 5.0;\n vector old_row(M), old_col(M), new_row(M), new_col(M);\n\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int r = dist(rng) % N;\n int c_pos = dist(rng) % N;\n char old_ch = cur_grid[r][c_pos];\n char new_ch = 'A' + dist(rng);\n\n fill(old_row.begin(), old_row.end(), 0);\n fill(old_col.begin(), old_col.end(), 0);\n fill(new_row.begin(), new_row.end(), 0);\n fill(new_col.begin(), new_col.end(), 0);\n\n fill_seq_row(cur_grid, r, seq_arr);\n ac.run_on_arr(seq_arr, double_len, old_row);\n\n fill_seq_col(cur_grid, c_pos, seq_arr);\n ac.run_on_arr(seq_arr, double_len, old_col);\n\n cur_grid[r][c_pos] = new_ch;\n\n fill_seq_row(cur_grid, r, seq_arr);\n ac.run_on_arr(seq_arr, double_len, new_row);\n\n fill_seq_col(cur_grid, c_pos, seq_arr);\n ac.run_on_arr(seq_arr, double_len, new_col);\n\n int new_c = current_covered;\n for (int i = 0; i < M; i++) {\n if (old_row[i] || old_col[i] || new_row[i] || new_col[i]) {\n int d = 0;\n if (old_row[i]) d--;\n if (old_col[i]) d--;\n if (new_row[i]) d++;\n if (new_col[i]) d++;\n int newcnt = cover_cnt[i] + d;\n bool was = cover_cnt[i] > 0;\n bool will = newcnt > 0;\n if (was && !will) new_c--;\n else if (!was && will) new_c++;\n }\n }\n\n bool accept = false;\n int delta = new_c - current_covered;\n if (delta > 0) {\n accept = true;\n } else if (delta == 0) {\n if (prob_dist(rng) < 0.05) accept = true;\n } else {\n double prob = exp((double)delta / temp);\n if (prob_dist(rng) < prob) accept = true;\n }\n\n if (accept) {\n for (int i = 0; i < M; i++) {\n if (old_row[i] || old_col[i] || new_row[i] || new_col[i]) {\n int d = 0;\n if (old_row[i]) d--;\n if (old_col[i]) d--;\n if (new_row[i]) d++;\n if (new_col[i]) d++;\n cover_cnt[i] += d;\n }\n }\n current_covered = new_c;\n } else {\n cur_grid[r][c_pos] = old_ch;\n }\n\n temp *= cooling_rate;\n if (temp < 0.001) temp = 0.001;\n }\n\n if (current_covered > best_covered) {\n best_covered = current_covered;\n best_grid = cur_grid;\n }\n }\n\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << best_grid[i][j];\n }\n cout << endl;\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\nusing ll = long long;\nconst ll INF = 1LL << 60;\n\nint main() {\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n int cost[69][69];\n memset(cost, 0, sizeof(cost));\n vector> all_roads;\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n all_roads.emplace_back(i, j);\n }\n int hofs[69][69];\n int vofs[69][69];\n memset(hofs, -1, sizeof(hofs));\n memset(vofs, -1, sizeof(vofs));\n vector>> hsegs, vsegs;\n int nh = 0, nv = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N;) {\n if (grid[i][j] == '#') {\n j++;\n continue;\n }\n auto& seg = hsegs.emplace_back();\n while (j < N && grid[i][j] != '#') {\n hofs[i][j] = nh;\n seg.emplace_back(i, j);\n j++;\n }\n nh++;\n }\n }\n for (int j = 0; j < N; j++) {\n for (int i = 0; i < N;) {\n if (grid[i][j] == '#') {\n i++;\n continue;\n }\n auto& seg = vsegs.emplace_back();\n while (i < N && grid[i][j] != '#') {\n vofs[i][j] = nv;\n seg.emplace_back(i, j);\n i++;\n }\n nv++;\n }\n }\n bool cellcov[69][69] = {};\n if (hofs[si][sj] != -1) {\n int h = hofs[si][sj];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[si][sj];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n }\n vector> targets;\n auto count_remain = [&]() {\n int cnt = 0;\n for (auto [x, y] : all_roads)\n if (!cellcov[x][y]) cnt++;\n return cnt;\n };\n int remain = count_remain();\n while (remain > 0) {\n int maxg = 0;\n pair bp = {-1, -1};\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g > maxg) {\n maxg = g;\n bp = p;\n }\n }\n if (maxg == 0) break;\n targets.push_back(bp);\n int h = hofs[bp.first][bp.second];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[bp.first][bp.second];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n remain -= maxg;\n }\n vector> points;\n points.emplace_back(si, sj);\n for (auto tp : targets) {\n if (tp.first != si || tp.second != sj) points.push_back(tp);\n }\n // prune redundant\n vector> fullp = points;\n vector> finalp = fullp;\n auto is_full_cover = [&](const vector>& vis_set) -> bool {\n bool temp[69][69] = {};\n for (auto [x, y] : vis_set) {\n if (hofs[x][y] == -1) continue;\n int h = hofs[x][y];\n for (auto p : hsegs[h]) temp[p.first][p.second] = true;\n int vv = vofs[x][y];\n for (auto p : vsegs[vv]) temp[p.first][p.second] = true;\n }\n int rem = 0;\n for (auto [x, y] : all_roads)\n if (!temp[x][y]) rem++;\n return rem == 0;\n };\n for (int i = finalp.size() - 1; i >= 1; i--) {\n vector> temp;\n for (int j = 0; j < finalp.size(); j++) if (j != i) temp.push_back(finalp[j]);\n if (is_full_cover(temp)) {\n finalp = temp;\n }\n }\n points = finalp;\n int mm = points.size();\n vector> dmat(mm, vector(mm, INF));\n vector>>> par_store(\n mm, vector>>(N, vector>(N, {-1, -1})));\n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n for (int s = 0; s < mm; s++) {\n auto [sx, sy] = points[s];\n vector> dd(N, vector(N, INF));\n vector>> pr(N, vector>(N, {-1, -1}));\n dd[sx][sy] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0LL, sx, sy);\n while (!pq.empty()) {\n auto [cst, x, y] = pq.top();\n pq.pop();\n if (cst > dd[x][y]) continue;\n for (int d = 0; d < 4; d++) {\n int nx = x + di[d], ny = y + dj[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && grid[nx][ny] != '#') {\n ll nc = cst + cost[nx][ny];\n if (nc < dd[nx][ny]) {\n dd[nx][ny] = nc;\n pr[nx][ny] = {x, y};\n pq.emplace(nc, nx, ny);\n }\n }\n }\n }\n for (int p = 0; p < mm; p++) {\n auto [px, py] = points[p];\n dmat[s][p] = dd[px][py];\n }\n for (int x = 0; x < N; x++)\n for (int y = 0; y < N; y++) par_store[s][x][y] = pr[x][y];\n }\n struct Edge {\n ll c;\n int u, v;\n bool operator<(const Edge& o) const { return c < o.c; }\n };\n vector edges;\n for (int i = 0; i < mm; i++)\n for (int j = i + 1; j < mm; j++) {\n if (dmat[i][j] < INF) edges.push_back({dmat[i][j], i, j});\n }\n sort(edges.begin(), edges.end());\n vector paruf(mm);\n iota(paruf.begin(), paruf.end(), 0);\n auto findf = [&](auto&& self, int x) -> int {\n return paruf[x] == x ? x : paruf[x] = self(self, paruf[x]);\n };\n auto unionf = [&](int x, int y) {\n x = findf(findf, x);\n y = findf(findf, y);\n if (x != y) paruf[x] = y;\n };\n vector> adj(mm);\n for (auto& e : edges) {\n if (findf(findf, e.u) != findf(findf, e.v)) {\n unionf(e.u, e.v);\n adj[e.u].push_back(e.v);\n adj[e.v].push_back(e.u);\n }\n }\n vector euler_t;\n function dfs_e = [&](int u, int p) {\n euler_t.push_back(u);\n for (int v : adj[u])\n if (v != p) {\n dfs_e(v, u);\n euler_t.push_back(u);\n }\n };\n dfs_e(0, -1);\n vector path(mm);\n vector viss(mm, false);\n int cntv = 0;\n for (int nd : euler_t) {\n if (!viss[nd]) {\n viss[nd] = true;\n path[cntv++] = nd;\n }\n }\n // build nn\n vector nn_path;\n {\n vector vis_nn(mm, false);\n int cur = 0;\n nn_path.push_back(0);\n vis_nn[0] = true;\n while (nn_path.size() < (size_t)mm) {\n ll md = INF;\n int nx = -1;\n for (int j = 0; j < mm; j++) {\n if (!vis_nn[j] && dmat[cur][j] < md) {\n md = dmat[cur][j];\n nx = j;\n }\n }\n if (nx == -1) break;\n nn_path.push_back(nx);\n vis_nn[nx] = true;\n cur = nx;\n }\n }\n ll mst_tot = 0;\n if ((int)path.size() == mm) {\n for (int ii = 0; ii < mm; ii++) {\n mst_tot += dmat[path[ii]][path[(ii + 1) % mm]];\n }\n } else {\n mst_tot = INF;\n }\n ll nn_tot = 0;\n if ((int)nn_path.size() == mm) {\n for (size_t ii = 0; ii < nn_path.size(); ii++) {\n int aa = nn_path[ii];\n int bb = nn_path[(ii + 1) % mm];\n nn_tot += dmat[aa][bb];\n }\n } else {\n nn_tot = INF;\n }\n if ((int)nn_path.size() == mm && nn_tot < mst_tot) {\n path = nn_path;\n }\n // swaps improve\n for (int iter = 0; iter < 10; iter++) {\n bool imp = false;\n for (int i = 1; i < mm; i++) {\n for (int j = i + 1; j < mm; j++) {\n if (min(abs(i - j), mm - abs(i - j)) <= 1) continue;\n int pa = (i - 1 + mm) % mm;\n int na = (i + 1) % mm;\n int pb = (j - 1 + mm) % mm;\n int nb = (j + 1) % mm;\n ll oldd = dmat[path[pa]][path[i]] + dmat[path[i]][path[na]] +\n dmat[path[pb]][path[j]] + dmat[path[j]][path[nb]];\n ll newd = dmat[path[pa]][path[j]] + dmat[path[j]][path[na]] +\n dmat[path[pb]][path[i]] + dmat[path[i]][path[nb]];\n if (newd < oldd) {\n swap(path[i], path[j]);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n string route = \"\";\n for (int k = 0; k < mm; k++) {\n int fid = path[k];\n int tid = path[(k + 1) % mm];\n if (fid == tid) continue;\n auto [sx, sy] = points[fid];\n auto [tx, ty] = points[tid];\n vector subm;\n int cx = tx, cy = ty;\n while (cx != sx || cy != sy) {\n auto [px, py] = par_store[fid][cx][cy];\n if (px == -1) break;\n int dx = cx - px;\n int dy = cy - py;\n char mv;\n if (dx == -1) mv = 'U';\n else if (dx == 1) mv = 'D';\n else if (dy == -1) mv = 'L';\n else if (dy == 1) mv = 'R';\n else break;\n subm.push_back(mv);\n cx = px;\n cy = py;\n }\n reverse(subm.begin(), subm.end());\n for (char c : subm) route += c;\n }\n cout << route << endl;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n vector> difficulty(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> difficulty[i][k];\n }\n }\n vector> adj(N);\n vector prereq_count(N, 0);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--;\n v--;\n adj[u].push_back(v);\n prereq_count[v]++;\n }\n vector longest_chain(N, 0);\n vector num_desc(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n longest_chain[i] = 1;\n num_desc[i] = 1;\n for (int v : adj[i]) {\n longest_chain[i] = max(longest_chain[i], 1 + longest_chain[v]);\n num_desc[i] += num_desc[v];\n }\n }\n vector> est_s(M, vector(K, 0));\n vector status(N, 0); // 0 not, 1 prog, 2 done\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector workload(M, 0);\n int day = 0;\n auto estimate = [&](int task, int mem) -> int {\n int w = 0;\n for (int k = 0; k < K; k++) {\n w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (w == 0) return 1;\n return w;\n };\n while (true) {\n day++;\n vector free_m;\n for (int j = 0; j < M; j++)\n if (current_task[j] == -1) free_m.push_back(j);\n vector ready;\n for (int i = 0; i < N; i++) {\n if (status[i] == 0 && prereq_count[i] == 0) ready.push_back(i);\n }\n vector> assigns; // mem, task\n set avail_free(free_m.begin(), free_m.end());\n sort(ready.begin(), ready.end(), [&](int a, int b) {\n if (longest_chain[a] != longest_chain[b]) return longest_chain[a] > longest_chain[b];\n if (num_desc[a] != num_desc[b]) return num_desc[a] > num_desc[b];\n return a < b;\n });\n for (int rid = 0; rid < ready.size(); rid++) {\n if (avail_free.empty()) break;\n int ta = ready[rid];\n int best_mem = -1;\n int best_et = INT_MAX;\n int best_wl = INT_MAX;\n for (int jm : avail_free) {\n int et = estimate(ta, jm);\n int wl = workload[jm];\n if (et < best_et ||\n (et == best_et &&\n (wl < best_wl || (wl == best_wl && jm < best_mem)))) {\n best_et = et;\n best_wl = wl;\n best_mem = jm;\n }\n }\n if (best_mem != -1) {\n assigns.emplace_back(best_mem, ta);\n avail_free.erase(best_mem);\n workload[best_mem] += best_et;\n }\n }\n // output\n cout << assigns.size();\n for (auto [jm, ta] : assigns) {\n cout << \" \" << (jm + 1) << \" \" << (ta + 1);\n }\n cout << endl << flush;\n // set assignments\n for (auto [jm, ta] : assigns) {\n current_task[jm] = ta;\n start_day[jm] = day;\n status[ta] = 1;\n }\n // read\n int ncomp;\n cin >> ncomp;\n if (ncomp == -1) {\n break;\n }\n vector comps(ncomp);\n for (int i = 0; i < ncomp; i++) {\n cin >> comps[i];\n }\n for (int cf : comps) {\n int mem = cf - 1;\n if (current_task[mem] == -1) continue;\n int task = current_task[mem];\n int t = day - start_day[mem] + 1;\n if (t == 1) {\n for (int k = 0; k < K; k++) {\n est_s[mem][k] = max(est_s[mem][k], difficulty[task][k]);\n }\n }\n int obs_w = (t <= 1 ? 0 : t);\n int iters = 0;\n while (iters < 5) {\n iters++;\n int curr_w = 0;\n for (int k = 0; k < K; k++) {\n curr_w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (curr_w == obs_w) break;\n int num_def = 0;\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) num_def++;\n }\n if (num_def == 0) break;\n if (curr_w > obs_w) {\n int gap = curr_w - obs_w;\n int incr = max(1, gap / (2 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] += incr;\n }\n }\n } else if (curr_w < obs_w) {\n int gap = obs_w - curr_w;\n int decr = max(1, gap / (2 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] = max(0, est_s[mem][k] - decr);\n }\n }\n } else {\n break;\n }\n }\n status[task] = 2;\n current_task[mem] = -1;\n for (int v : adj[task]) {\n prereq_count[v]--;\n }\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\nint manh(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\nbool is_valid(const vector& perm, int n) {\n int m = 2 * n;\n vector pos(m);\n for (int i = 0; i < m; i++) pos[perm[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) return false;\n }\n return true;\n}\n\nint calc_cost(const vector& perm, const vector& pts, Point C, int n) {\n int m = 2 * n;\n if (perm.size() != m) return INT_MAX;\n int cost = manh(C, pts[perm[0]]);\n for (int i = 0; i < m - 1; i++) {\n cost += manh(pts[perm[i]], pts[perm[i + 1]]);\n }\n cost += manh(pts[perm.back()], C);\n return cost;\n}\n\npair> greedy_cost_and_path(const vector& S, Point C, const vector& allP, const vector& allD, int n) {\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n vector mate(2 * n);\n for (int i = 0; i < n; i++) {\n mate[i] = n + i;\n mate[n + i] = i;\n }\n vector visited(2 * n, false);\n vector feasible(2 * n, false);\n for (int i = 0; i < n; i++) feasible[i] = true;\n vector perm;\n perm.reserve(2 * n);\n Point curr = C;\n int total = 0;\n bool possible = true;\n for (int step = 0; step < 2 * n && possible; step++) {\n int best_d = INT_MAX;\n int best_idx = -1;\n for (int i = 0; i < 2 * n; i++) {\n if (!visited[i] && feasible[i]) {\n int dd = manh(curr, pts[i]);\n if (dd < best_d) {\n best_d = dd;\n best_idx = i;\n }\n }\n }\n if (best_idx == -1) {\n possible = false;\n break;\n }\n total += best_d;\n perm.push_back(best_idx);\n visited[best_idx] = true;\n curr = pts[best_idx];\n int m = mate[best_idx];\n if (!visited[m]) feasible[m] = true;\n }\n if (possible && perm.size() == 2*n) total += manh(curr, C);\n else total = INT_MAX;\n return {total, perm};\n}\n\nvoid optimize_perm(vector& best_perm_out, int& best_cost_out, const vector& S, Point C, const vector& allP, const vector& allD, mt19937& rng) {\n int n = S.size();\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n // greedy start\n auto [gcost, gperm] = greedy_cost_and_path(S, C, allP, allD, n);\n vector current_perm(2 * n);\n int curr_cost = INT_MAX;\n if (gperm.size() == 2 * n) {\n current_perm = gperm;\n curr_cost = gcost;\n } else {\n iota(current_perm.begin(), current_perm.end(), 0);\n }\n // random valid start for diversity\n {\n vector tasks(2 * n);\n iota(tasks.begin(), tasks.end(), 0);\n shuffle(tasks.begin(), tasks.end(), rng);\n vector pos(2 * n);\n for (int i = 0; i < 2 * n; i++) pos[tasks[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) {\n swap(tasks[pos[i]], tasks[pos[n + i]]);\n swap(pos[i], pos[n + i]);\n }\n }\n if (is_valid(tasks, n)) {\n int rc = calc_cost(tasks, pts, C, n);\n if (rc < curr_cost) {\n current_perm = tasks;\n curr_cost = rc;\n }\n }\n }\n vector best_perm = current_perm;\n int best_cost = curr_cost;\n double T = 20000.0;\n int m = 2 * n;\n uniform_int_distribution dpos(0, m - 1);\n uniform_real_distribution dprob(0.0, 1.0);\n for (int it = 0; it < 350000; it++) {\n vector new_perm = current_perm;\n int typ = rng() % 4;\n bool can_change = false;\n int i = dpos(rng);\n int j = dpos(rng);\n if (typ == 0) { \n if (i != j) {\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n } else if (typ == 1) { \n if (i != j) {\n int val = new_perm[i];\n new_perm.erase(new_perm.begin() + i);\n int jj = (j > i ? j - 1 : j);\n new_perm.insert(new_perm.begin() + jj, val);\n can_change = true;\n }\n } else if (typ == 2) { \n if (i > j) swap(i, j);\n if (i != j) {\n reverse(new_perm.begin() + i, new_perm.begin() + j + 1);\n can_change = true;\n }\n } else { \n j = (i + 1) % m;\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n if (can_change && is_valid(new_perm, n)) {\n int new_cost = calc_cost(new_perm, pts, C, n);\n if (new_cost < INT_MAX) {\n double delta = new_cost - curr_cost;\n if (delta < 0 || (T > 0 && exp(-delta / T) > dprob(rng))) {\n current_perm = new_perm;\n curr_cost = new_cost;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n }\n }\n }\n T *= 0.99994;\n }\n current_perm = best_perm;\n curr_cost = best_cost;\n int phases = 0;\n const int max_phases = 25;\n bool improved_global = true;\n while (improved_global && phases < max_phases) {\n improved_global = false;\n phases++;\n // improving swap\n int min_newc = curr_cost;\n vector best_np;\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n swap(np[ii], np[jj]);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n }\n // improving insert\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = 0; jj < m; jj++) {\n if (ii == jj) continue;\n vector np = current_perm;\n int val = np[ii];\n np.erase(np.begin() + ii);\n int jj_adj = (jj > ii ? jj - 1 : jj);\n np.insert(np.begin() + jj_adj, val);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n }\n // improving reverse segment\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n reverse(np.begin() + ii, np.begin() + jj + 1);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < best_cost) {\n best_cost = curr_cost;\n best_perm = current_perm;\n }\n }\n }\n if (best_cost < best_cost_out) {\n best_cost_out = best_cost;\n best_perm_out = best_perm;\n }\n}\n\nint main() {\n vector allP(1000), allD(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> allP[i].x >> allP[i].y >> allD[i].x >> allD[i].y;\n }\n Point C = {400, 400};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n vector centers;\n centers.push_back(C);\n int step = 50;\n for (int cx = 25; cx < 775; cx += step) {\n for (int cy = 25; cy < 775; cy += step) {\n centers.push_back({cx, cy});\n }\n }\n for (int i = 0; i < 100; i++) {\n centers.push_back({rng() % 801, rng() % 801});\n }\n int n = 50;\n int best_T = INT_MAX;\n vector best_S;\n for (auto& cen : centers) {\n vector> dists;\n for (int i = 0; i < 1000; i++) {\n int dd = manh(allP[i], cen) + manh(allD[i], cen);\n dists.emplace_back(dd, i);\n }\n sort(dists.begin(), dists.end());\n vector S;\n for (int i = 0; i < n; i++) S.push_back(dists[i].second);\n auto [gcost, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gcost < best_T) {\n best_T = gcost;\n best_S = S;\n }\n }\n vector> ind_cost;\n for (int i = 0; i < 1000; i++) {\n int cc = manh(C, allP[i]) + manh(allP[i], allD[i]) + manh(allD[i], C);\n ind_cost.emplace_back(cc, i);\n }\n sort(ind_cost.begin(), ind_cost.end());\n vector S_small;\n for (int i = 0; i < n; i++) S_small.push_back(ind_cost[i].second);\n auto [gcost2, gp2] = greedy_cost_and_path(S_small, C, allP, allD, n);\n if (gcost2 < best_T) {\n best_T = gcost2;\n best_S = S_small;\n }\n for (int tri = 0; tri < 40; tri++) {\n vector all(1000);\n iota(all.begin(), all.end(), 0);\n shuffle(all.begin(), all.end(), rng);\n vector S(all.begin(), all.begin() + n);\n auto [gc, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gc < best_T) {\n best_T = gc;\n best_S = S;\n }\n }\n int opt_cost = INT_MAX;\n vector opt_perm;\n optimize_perm(opt_perm, opt_cost, best_S, C, allP, allD, rng);\n for (int trial = 0; trial < 80; trial++) {\n uniform_int_distribution dis_in(0, n - 1);\n uniform_int_distribution dis_out(0, 999);\n vector newS = best_S;\n int in_idx = dis_in(rng);\n int out = dis_out(rng);\n bool has = false;\n for (int s : newS) if (s == out) { has = true; break; }\n if (has) continue;\n newS[in_idx] = out;\n auto [gc, gp] = greedy_cost_and_path(newS, C, allP, allD, n);\n if (gc < opt_cost * 1.1 && gc < INT_MAX) {\n int new_opt_cost = INT_MAX;\n vector new_opt_perm;\n optimize_perm(new_opt_perm, new_opt_cost, newS, C, allP, allD, rng);\n if (new_opt_cost < opt_cost) {\n opt_cost = new_opt_cost;\n opt_perm = new_opt_perm;\n best_S = newS;\n }\n }\n }\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[best_S[i]];\n pts[n + i] = allD[best_S[i]];\n }\n vector route;\n route.push_back(C);\n for (int t : opt_perm) {\n route.push_back(pts[t]);\n }\n route.push_back(C);\n cout << 50;\n for (int r : best_S) cout << \" \" << (r + 1);\n cout << endl;\n cout << route.size();\n for (auto p : route) cout << \" \" << p.x << \" \" << p.y;\n cout << endl;\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v, idx, d, l;\n bool backup;\n};\n\nvector edges;\nvector par;\n\nint find(vector& p, int x) {\n return p[x] == x ? x : p[x] = find(p, p[x]);\n}\n\nbool unite(vector& p, int x, int y) {\n x = find(p, x);\n y = find(p, y);\n if (x == y) return false;\n p[x] = y;\n return true;\n}\n\nint main() {\n vector x(400), y(400);\n for (int i = 0; i < 400; i++) {\n cin >> x[i] >> y[i];\n }\n int M = 1995;\n edges.resize(M);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i].u = u;\n edges[i].v = v;\n edges[i].idx = i;\n edges[i].l = -1;\n edges[i].backup = false;\n double dx = x[u] - x[v];\n double dy = y[u] - y[v];\n double dist = hypot(dx, dy);\n edges[i].d = (int)round(dist);\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].d < edges[b].d;\n });\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n int cnt = 0;\n for (int i : ord) {\n if (unite(par, edges[i].u, edges[i].v)) {\n edges[i].backup = true;\n cnt++;\n if (cnt == 399) break;\n }\n }\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n const double MULT = 2.0;\n for (int i = 0; i < M; i++) {\n int l;\n cin >> l;\n edges[i].l = l;\n int u = edges[i].u, v = edges[i].v;\n int pu = find(par, u);\n int pv = find(par, v);\n int ans = 0;\n if (pu != pv) {\n if (edges[i].backup) {\n ans = 1;\n } else {\n int md = edges[i].d;\n int min_fut = INT_MAX / 2;\n for (int j = i + 1; j < M; j++) {\n int uj = edges[j].u;\n int vj = edges[j].v;\n int pj1 = find(par, uj);\n int pj2 = find(par, vj);\n if ((pj1 == pu && pj2 == pv) || (pj1 == pv && pj2 == pu)) {\n min_fut = min(min_fut, edges[j].d);\n }\n }\n if (min_fut < INT_MAX / 2) {\n md = min(md, min_fut);\n } else {\n // indirect bottleneck estimate\n vector tmp_par = par;\n int bott = INT_MAX / 2;\n vector pord(M);\n iota(pord.begin(), pord.end(), 0);\n sort(pord.begin(), pord.end(), [&](int a, int b) {\n return edges[a].d < edges[b].d;\n });\n for (int j : pord) {\n if (j <= i) continue;\n int uj = edges[j].u, vj = edges[j].v;\n int pj1 = find(tmp_par, uj), pj2 = find(tmp_par, vj);\n if (pj1 != pj2) {\n if ((pj1 == pu && pj2 == pv) || (pj1 == pv && pj2 == pu) ||\n (find(tmp_par, pu) != find(tmp_par, pv))) {\n bott = min(bott, edges[j].d);\n if (unite(tmp_par, pj1, pj2) && find(tmp_par, pu) == find(tmp_par, pv)) break;\n }\n }\n }\n if (bott < INT_MAX / 2) {\n md = min(md, bott);\n }\n }\n if (l <= MULT * md) {\n ans = 1;\n }\n }\n if (ans == 1) {\n unite(par, u, v);\n }\n }\n cout << ans << endl;\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n cin >> 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 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 const int W = 30;\n vector> is_blocked(W + 2, vector(W + 2, false));\n vector> human_pos(M);\n for (int i = 0; i < M; i++) human_pos[i] = {hx[i], hy[i]};\n vector> pet_pos(N);\n for (int i = 0; i < N; i++) pet_pos[i] = {px[i], py[i]};\n vector dx = {-1, 1, 0, 0};\n vector dy = {0, 0, -1, 1};\n char move_char[4] = {'U', 'D', 'L', 'R'};\n char block_char[4] = {'u', 'd', 'l', 'r'};\n auto valid = [&](int x, int y) {\n return x >= 1 && x <= W && y >= 1 && y <= W && !is_blocked[x][y];\n };\n auto is_occupied_func = nullptr; // defined per turn\n vector> stand_pos, wall_pos;\n int wall_size = 20;\n int right_c = wall_size + 1;\n int bottom_r = wall_size + 1;\n for (int r = 1; r <= wall_size; r++) {\n stand_pos.emplace_back(r, wall_size);\n wall_pos.emplace_back(r, right_c);\n }\n for (int c = 1; c <= wall_size; c++) {\n stand_pos.emplace_back(wall_size, c);\n wall_pos.emplace_back(bottom_r, c);\n }\n set> wall_set(wall_pos.begin(), wall_pos.end());\n mt19937 rng(42);\n for (int turn = 0; turn < 300; turn++) {\n vector> next_hpos(M);\n string actions_str(M, '.');\n set> targeted_moves;\n set> this_turn_blocked;\n vector> is_occupied(W + 2, vector(W + 2, false));\n for (int i = 0; i < N; i++) {\n auto [x, y] = pet_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n for (int i = 0; i < M; i++) {\n auto [x, y] = human_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n auto can_block = [&](int tx, int ty) {\n if (!valid(tx, ty) || is_occupied[tx][ty]) return false;\n for (int d = 0; d < 4; d++) {\n int px = tx + dx[d];\n int py = ty + dy[d];\n if (valid(px, py) && is_occupied[px][py]) return false;\n }\n return true;\n };\n vector assigned_idx(M, -1);\n vector used_stand(stand_pos.size(), false);\n if (turn >= 150) {\n for (int i = 0; i < M; i++) {\n int best_j = -1;\n int best_d = INT_MAX;\n for (int j = 0; j < (int)stand_pos.size(); j++) {\n auto [wx, wy] = wall_pos[j];\n if (is_blocked[wx][wy]) continue;\n if (used_stand[j]) continue;\n auto [sx, sy] = stand_pos[j];\n int dist = abs(human_pos[i].first - sx) + abs(human_pos[i].second - sy);\n if (dist < best_d) {\n best_d = dist;\n best_j = j;\n }\n }\n if (best_j != -1) {\n assigned_idx[i] = best_j;\n used_stand[best_j] = true;\n }\n }\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for (int k = 0; k < M; k++) {\n int i = ord[k];\n auto [x, y] = human_pos[i];\n bool did = false;\n int t_idx = assigned_idx[i];\n if (turn < 150 || t_idx == -1) {\n // gather to center\n int cx = 15, cy = 15;\n vector> candidates;\n if (x < cx && valid(x + 1, y)) candidates.emplace_back(1, 'D');\n if (x > cx && valid(x - 1, y)) candidates.emplace_back(0, 'U');\n if (y < cy && valid(x, y + 1)) candidates.emplace_back(3, 'R');\n if (y > cy && valid(x, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n } else {\n auto [tx, ty] = stand_pos[t_idx];\n if (x == tx && y == ty) {\n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int bx = x + dx[d];\n int by = y + dy[d];\n if (wall_set.count({bx, by}) && can_block(bx, by)) {\n actions_str[i] = block_char[d];\n this_turn_blocked.insert({bx, by});\n is_blocked[bx][by] = true;\n next_hpos[i] = {x, y};\n did = true;\n break;\n }\n }\n } else {\n vector> candidates;\n if (x < tx && valid(x + 1, ty)) candidates.emplace_back(1, 'D');\n if (x > tx && valid(x - 1, ty)) candidates.emplace_back(0, 'U');\n if (y < ty && valid(tx, y + 1)) candidates.emplace_back(3, 'R');\n if (y > ty && valid(tx, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n }\n }\n if (!did) {\n actions_str[i] = '.';\n next_hpos[i] = {x, y};\n }\n }\n // output\n cout << actions_str << endl;\n cout.flush();\n // read pet moves\n vector pet_moves(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n // update human_pos\n for (int i = 0; i < M; i++) {\n human_pos[i] = next_hpos[i];\n }\n // update pet_pos\n for (int i = 0; i < N; i++) {\n int x = pet_pos[i].first, y = pet_pos[i].second;\n string mv = pet_moves[i];\n for (char c : mv) {\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n if (d != -1) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (valid(nx, ny)) {\n x = nx;\n y = ny;\n }\n }\n }\n pet_pos[i] = {x, y};\n }\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\ndouble compute_ES(const vector& sseq, double pp, int ssr, int ssc, int ttr, int ttc, int HH[20][19], int VV[19][20]) {\n double prb[20][20] = {};\n prb[ssr][ssc] = 1.0;\n double ES = 0.0;\n int LL = sseq.size();\n for (int tt = 0; tt < LL; tt++) {\n double rch = 0.0;\n double np[20][20] = {};\n char dr = sseq[tt];\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double prr = prb[i][j];\n if (prr < 1e-20 || (i == ttr && j == ttc)) continue;\n np[i][j] += prr * pp;\n int nii = i, njj = j;\n bool cm = false;\n if (dr == 'D' && i < 19 && VV[i][j] == 0) { nii++; cm = true; }\n else if (dr == 'U' && i > 0 && VV[i - 1][j] == 0) { nii--; cm = true; }\n else if (dr == 'R' && j < 19 && HH[i][j] == 0) { njj++; cm = true; }\n else if (dr == 'L' && j > 0 && HH[i][j - 1] == 0) { njj--; cm = true; }\n if (cm) {\n if (nii == ttr && njj == ttc) {\n rch += prr * (1 - pp);\n } else {\n np[nii][njj] += prr * (1 - pp);\n }\n } else {\n np[i][j] += prr * (1 - pp);\n }\n }\n }\n ES += rch * (401.0 - (tt + 1));\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prb[i][j] = np[i][j];\n }\n return ES;\n}\n\nint main() {\n int sr, sc, tr, tc;\n double p;\n cin >> sr >> sc >> tr >> tc >> p;\n int h[20][19];\n for (int i = 0; i < 20; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 19; j++) h[i][j] = s[j] - '0';\n }\n int v[19][20];\n for (int i = 0; i < 19; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 20; j++) v[i][j] = s[j] - '0';\n }\n const int INF = 10000;\n int dist[20][20];\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) dist[i][j] = INF;\n dist[tr][tc] = 0;\n queue> q;\n q.push({tr, tc});\n while (!q.empty()) {\n auto cur = q.front();\n q.pop();\n int x = cur.first, y = cur.second;\n int d = dist[x][y];\n if (y < 19 && h[x][y] == 0) {\n int nx = x, ny = y + 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (y > 0 && h[x][y - 1] == 0) {\n int nx = x, ny = y - 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x < 19 && v[x][y] == 0) {\n int nx = x + 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x > 0 && v[x - 1][y] == 0) {\n int nx = x - 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) if (dist[i][j] == INF) dist[i][j] = 50;\n double best_init_E = -1e9;\n vector best_init_seq;\n srand(time(NULL));\n for (int rep = 0; rep < 20; rep++) {\n vector dir_order = {'D', 'R', 'L', 'U'};\n random_shuffle(dir_order.begin(), dir_order.end());\n double prob[20][20] = {};\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = 0.0;\n prob[sr][sc] = 1.0;\n vector seq;\n for (int stp = 0; stp < 200; stp++) {\n double best_score = -1e100;\n char bestc = ' ';\n for (int di = 0; di < 4; di++) {\n char dir = dir_order[di];\n double reach = 0.0;\n double newp[20][20] = {};\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (dir == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (dir == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (dir == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (dir == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n double eds = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n eds += newp[i][j] * dist[i][j];\n }\n }\n double score = -eds + 25.0 * reach;\n if (score > best_score + 1e-9) {\n best_score = score;\n bestc = dir;\n }\n }\n if (bestc == ' ') break;\n double newp[20][20] = {};\n double reach = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (bestc == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (bestc == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (bestc == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (bestc == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = newp[i][j];\n seq.push_back(bestc);\n }\n double this_E = compute_ES(seq, p, sr, sc, tr, tc, h, v);\n if (this_E > best_init_E + 1e-9) {\n best_init_E = this_E;\n best_init_seq = seq;\n }\n }\n vector best_seq = best_init_seq;\n double best_E = best_init_E;\n int L = best_seq.size();\n if (L > 0) {\n char dir_options[4] = {'U', 'D', 'L', 'R'};\n for (int trial = 0; trial < 1500; trial++) {\n int pos = rand() % L;\n char original = best_seq[pos];\n for (int d = 0; d < 4; d++) {\n char new_dir = dir_options[d];\n if (new_dir == original) continue;\n best_seq[pos] = new_dir;\n double newE = compute_ES(best_seq, p, sr, sc, tr, tc, h, v);\n if (newE > best_E + 1e-9) {\n best_E = newE;\n } else {\n best_seq[pos] = original;\n }\n }\n }\n }\n string ans = \"\";\n for (char c : best_seq) ans += c;\n if (ans.size() > 200) ans = ans.substr(0, 200);\n cout << ans << endl;\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30;\nconst int W = 30;\nconst int D = 4;\nconst int SZ = H * W * D;\n\nint TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\nint DI[4] = {0, -1, 0, 1};\nint DJ[4] = {-1, 0, 1, 0};\n\nstatic int current_time = 0;\nstatic int timestamp[SZ];\nstatic int pstep[SZ];\nstatic bool vis[SZ];\n\nint get_eff(int o, int r) {\n if (o < 4) return (o + r) % 4;\n if (o == 4) return (r % 2 ? 5 : 4);\n if (o == 5) return (r % 2 ? 4 : 5);\n if (o == 6) return (r % 2 ? 7 : 6);\n return (r % 2 ? 6 : 7);\n}\n\nlong long compute_cycles(int t[H][W], int r[H][W], int& len1, int& len2) {\n if (current_time > 2000000000) {\n current_time = 0;\n memset(timestamp, 0, sizeof(timestamp));\n }\n int eff[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n eff[i][j] = get_eff(t[i][j], r[i][j]);\n }\n }\n static int next_state[SZ];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n for (int d = 0; d < D; d++) {\n int idx = ((i * W + j) * D + d);\n int d2 = TO[eff[i][j]][d];\n if (d2 == -1) {\n next_state[idx] = -1;\n continue;\n }\n int ni = i + DI[d2];\n int nj = j + DJ[d2];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) {\n next_state[idx] = -1;\n continue;\n }\n int nd = (d2 + 2) % 4;\n next_state[idx] = ((ni * W + nj) * D + nd);\n }\n }\n }\n memset(vis, 0, sizeof(vis));\n len1 = 0;\n len2 = 0;\n int path_arr[4010];\n for (int s = 0; s < SZ; s++) {\n if (!vis[s]) {\n if (next_state[s] == -1) {\n vis[s] = true;\n continue;\n }\n int path_len = 0;\n int cur = s;\n int this_t = ++current_time;\n timestamp[cur] = this_t;\n pstep[cur] = 0;\n path_arr[path_len++] = cur;\n bool foundc = false;\n int cst = 0;\n int nxt;\n while (true) {\n nxt = next_state[cur];\n if (nxt == -1) break;\n if (vis[nxt]) break;\n if (timestamp[nxt] == this_t) {\n foundc = true;\n cst = pstep[nxt];\n break;\n }\n if (path_len >= 4005) break;\n path_arr[path_len] = nxt;\n timestamp[nxt] = this_t;\n pstep[nxt] = path_len;\n path_len++;\n cur = nxt;\n }\n if (foundc) {\n int cl = path_len - cst;\n if (cl > len1) {\n len2 = len1;\n len1 = cl;\n } else if (cl > len2) {\n len2 = cl;\n }\n }\n for (int p = 0; p < path_len; p++) {\n vis[path_arr[p]] = true;\n }\n }\n }\n if (len1 > 0 && len2 > 0) return 1LL * len1 * len2;\n return 0;\n}\n\nint main() {\n int orig[H][W];\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n orig[i][j] = s[j] - '0';\n }\n }\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution randr(0, 3);\n // Try several initial configs\n long long global_best_sc = 0;\n int global_best_r[H][W];\n // Init 1: uniform r=0\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = 0;\n int cl1, cl2;\n long long init_sc = compute_cycles(orig, init_r, cl1, cl2);\n if (init_sc > global_best_sc) {\n global_best_sc = init_sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n // Init 2: uniform r=1\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = 1;\n init_sc = compute_cycles(orig, init_r, cl1, cl2);\n if (init_sc > global_best_sc) {\n global_best_sc = init_sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n // Init 3: random , best of 3 tries\n for (int tries = 0; tries < 3; tries++) {\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = randr(rng);\n init_sc = compute_cycles(orig, init_r, cl1, cl2);\n if (init_sc > global_best_sc) {\n global_best_sc = init_sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // Now start SA from the global_best\n int cur_r[H][W];\n memcpy(cur_r, global_best_r, sizeof(global_best_r));\n long long cur_sc = global_best_sc;\n long long best_sc = cur_sc;\n int best_r[H][W];\n memcpy(best_r, cur_r, sizeof(cur_r));\n const int MAX_ITER = 25000;\n double temp = 100000.0;\n double cooling = 0.9999;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int new_r[H][W];\n memcpy(new_r, cur_r, sizeof(cur_r));\n int nmut = randr(rng) % 3 + 1;\n for (int k = 0; k < nmut; k++) {\n int pos = rng() % (H * W);\n int i = pos / W;\n int j = pos % W;\n int delta = (randr(rng) % 3) + 1;\n new_r[i][j] = (new_r[i][j] + delta) % 4;\n }\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n long long delta = new_sc - cur_sc;\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if ((double)rng() / rng.max() < prob) accept = true;\n }\n if (accept) {\n memcpy(cur_r, new_r, sizeof(cur_r));\n cur_sc = new_sc;\n if (cur_sc > best_sc) {\n best_sc = cur_sc;\n memcpy(best_r, cur_r, sizeof(best_r));\n }\n }\n temp *= cooling;\n if (temp < 0.1) temp = 0.1; // avoid too small\n }\n // local hill climbing with random order and limit\n int temp_r[H][W];\n memcpy(temp_r, best_r, sizeof(best_r));\n long long temp_sc = best_sc;\n bool improved = true;\n int passes = 0;\n int local_iters = 0;\n const int MAX_LOCAL_EVAL = 8000;\n while (improved && passes < 3 && local_iters < MAX_LOCAL_EVAL) {\n improved = false;\n passes++;\n // random order for tiles this pass\n vector order(H*W);\n for (int i=0; i best_this_sc) {\n best_this_sc = sc;\n best_this_r = nr;\n }\n }\n temp_r[i][j] = best_this_r;\n if (best_this_sc > temp_sc) {\n temp_sc = best_this_sc;\n improved = true;\n }\n }\n }\n if (temp_sc > best_sc) {\n best_sc = temp_sc;\n memcpy(best_r, temp_r, sizeof(best_r));\n }\n string ans = \"\";\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n ans += '0' + best_r[i][j];\n }\n }\n cout << ans << endl;\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint main() {\n srand(time(0));\n int N, Tmax;\n cin >> N >> Tmax;\n vector> init_board(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 char c = s[j];\n if(c >= '0' && c <= '9') init_board[i][j] = c - '0';\n else init_board[i][j] = 10 + (c - 'a');\n }\n }\n pair init_blank = {-1, -1};\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(init_board[i][j] == 0) init_blank = {i, j};\n int fullS = N * N - 1;\n int ddx[4] = {-1, 1, 0, 0};\n int ddy[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n auto compute_S_and_M = [&](const vector>& b) -> pair {\n int S = 0, M = 0;\n int MM = N * N;\n vector parent(MM), sz(MM, 1), has_cyc(MM, 0);\n for(int i = 0; i < MM; i++) parent[i] = i;\n auto find = [&](auto&& self, int x) -> int {\n if(parent[x] != x) parent[x] = self(self, parent[x]);\n return parent[x];\n };\n auto unite = [&](int x, int y) {\n int px = find(find, x), py = find(find, y);\n if(px == py) {\n has_cyc[px] = 1;\n return;\n }\n if(sz[px] < sz[py]) swap(px, py);\n parent[py] = px;\n sz[px] += sz[py];\n if(has_cyc[py]) has_cyc[px] = 1;\n };\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n int t1 = b[i][j], t2 = b[i+1][j];\n if(t1 != 0 && t2 != 0 && (t1 & 8) && (t2 & 2)) {\n M++;\n unite(i*N + j, (i+1)*N + j);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n int t1 = b[i][j], t2 = b[i][j+1];\n if(t1 != 0 && t2 != 0 && (t1 & 4) && (t2 & 1)) {\n M++;\n unite(i*N + j, i*N + j + 1);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(b[i][j] != 0) {\n int rp = find(find, i*N + j);\n if(!has_cyc[rp]) S = max(S, sz[rp]);\n }\n return {S, M};\n };\n vector> board = init_board;\n int bx = init_blank.first, by = init_blank.second;\n string moves = \"\";\n auto initial_pm = compute_S_and_M(board);\n int max_achieved_S = initial_pm.first;\n int max_achieved_M = initial_pm.second;\n string best_sequence = \"\";\n int best_k = 0;\n for(int step = 0; step < Tmax; step++) {\n if(moves.length() >= Tmax) break;\n if(max_achieved_S == fullS) break;\n bool perturb = (rand() % 100 < 15);\n int chosen_d = -1;\n if(perturb) {\n vector cands;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx >= 0 && nx < N && ny >= 0 && ny < N) cands.push_back(d);\n }\n if(!cands.empty()) chosen_d = cands[rand() % cands.size()];\n } else {\n int best_future = -1, best_m = -1;\n vector best_ds;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n int bx1 = nx, by1 = ny;\n auto pm1 = compute_S_and_M(board);\n int this_future = pm1.first;\n int thisM = pm1.second;\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n int bx2 = nx2, by2 = ny2;\n auto pm2 = compute_S_and_M(board);\n int s2 = pm2.first, m2 = pm2.second;\n if(s2 > this_future || (s2 == this_future && m2 > thisM)) {\n this_future = s2;\n thisM = m2;\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n // depth 3\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n for(int d3 = 0; d3 < 4; d3++) {\n int nx3 = nx2 + ddx[d3], ny3 = ny2 + ddy[d3];\n if(nx3 < 0 || nx3 >= N || ny3 < 0 || ny3 >= N) continue;\n swap(board[nx2][ny2], board[nx3][ny3]);\n auto pm3 = compute_S_and_M(board);\n int s3 = pm3.first, m3 = pm3.second;\n if(s3 > this_future || (s3 == this_future && m3 > thisM)) {\n this_future = s3;\n thisM = m3;\n }\n swap(board[nx2][ny2], board[nx3][ny3]);\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n if(this_future > best_future || (this_future == best_future && thisM > best_m)) {\n best_future = this_future;\n best_m = thisM;\n best_ds.clear();\n best_ds.push_back(d);\n } else if(this_future == best_future && thisM == best_m) {\n best_ds.push_back(d);\n }\n swap(board[bx][by], board[nx][ny]);\n }\n if(!best_ds.empty()) {\n int idx = rand() % best_ds.size();\n chosen_d = best_ds[idx];\n }\n }\n if(chosen_d == -1) break;\n int nx = bx + ddx[chosen_d], ny = by + ddy[chosen_d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n bx = nx; by = ny;\n moves += dchar[chosen_d];\n auto [ns, nm] = compute_S_and_M(board);\n int nk = moves.length();\n if(ns > max_achieved_S || (ns == max_achieved_S && nk < best_k)) {\n max_achieved_S = ns;\n max_achieved_M = nm;\n best_sequence = moves;\n best_k = nk;\n } else if(ns == max_achieved_S && nm > max_achieved_M ) {\n max_achieved_M = nm;\n best_sequence = moves;\n best_k = nk;\n }\n }\n cout << best_sequence << endl;\n}","ahc012":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Line {\n ll px, py, qx, qy;\n};\n\nint main() {\n int N, K;\n cin >> N >> K;\n vector A(11, 0);\n for (int d = 1; d <= 10; d++) {\n cin >> A[d];\n }\n vector> pts(N);\n for (auto& p : pts) {\n cin >> p.first >> p.second;\n }\n auto compute_cross = [&](const Line& l, int id) -> ll {\n auto [x, y] = pts[id];\n ll a = x - l.px;\n ll b = y - l.py;\n ll c = l.qx - l.px;\n ll d = l.qy - l.py;\n return a * d - b * c;\n };\n auto calc_sat = [&](const vector>& prts) -> int {\n vector fr(5501, 0);\n for (auto& p : prts) {\n size_t s = p.size();\n if (s < 5501) fr[s]++;\n }\n int s = 0;\n for (int d = 1; d <= 10; d++) {\n s += min(A[d], fr[d]);\n }\n return s;\n };\n vector best_chosen;\n int best_sat = -1;\n for (int trial = 0; trial < 2; trial++) {\n double shift = trial * (2 * 3.141592653589793 / 40.0);\n vector all_idx(N);\n iota(all_idx.begin(), all_idx.end(), 0);\n vector> parts = {all_idx};\n vector chosen;\n int cur_sat = calc_sat(parts);\n for (int iter = 0; iter < 100 && (int)chosen.size() < K; iter++) {\n vector large_g_idx;\n for (int i = 0; i < (int)parts.size(); i++) {\n if ((int)parts[i].size() > 10) large_g_idx.push_back(i);\n }\n if (large_g_idx.empty()) break;\n sort(large_g_idx.begin(), large_g_idx.end(), [&](int aa, int bb) {\n return parts[aa].size() > parts[bb].size();\n });\n int num_target = min(1, (int)large_g_idx.size());\n int best_new = cur_sat;\n Line best_l;\n bool improved = false;\n for (int tg = 0; tg < num_target; tg++) {\n int gidx = large_g_idx[tg];\n auto& group = parts[gidx];\n int gs = group.size();\n for (int th = 0; th < 40; th++) {\n double theta = shift + (2 * 3.141592653589793 * th / 40.0);\n double nx = cos(theta);\n double ny = sin(theta);\n vector> projs;\n projs.reserve(gs);\n for (int id : group) {\n double pr = pts[id].first * nx + pts[id].second * ny;\n projs.emplace_back(pr, id);\n }\n sort(projs.begin(), projs.end());\n for (int m = 1; m <= min(10, gs - 1); m++) {\n double r1 = projs[m - 1].first;\n double r2 = projs[m].first;\n if (abs(r1 - r2) < 1e-9) continue;\n double r = (r1 + r2) / 2.0;\n double dx = -ny;\n double dy = nx;\n double D = 1000000.0;\n double bx = r * nx;\n double by = r * ny;\n double pxd = bx + D * dx;\n double pyd = by + D * dy;\n double qxd = bx - D * dx;\n double qyd = by - D * dy;\n ll px = (ll)round(pxd);\n ll py = (ll)round(pyd);\n ll qx = (ll)round(qxd);\n ll qy = (ll)round(qyd);\n if (px == qx && py == qy) continue;\n if (llabs(px) > 1000000000LL || llabs(py) > 1000000000LL || llabs(qx) > 1000000000LL || llabs(qy) > 1000000000LL) continue;\n Line llne{px, py, qx, qy};\n vector temp_fr(5501, 0);\n bool valid = true;\n for (size_t j = 0; j < parts.size() && valid; j++) {\n ll lcnt = 0, rcnt = 0;\n auto& grp = parts[j];\n for (int id : grp) {\n ll cr = compute_cross(llne, id);\n if (cr == 0) {\n valid = false;\n break;\n }\n if (cr > 0) lcnt++;\n else rcnt++;\n }\n if (valid) {\n if (lcnt > 0) temp_fr[lcnt]++;\n if (rcnt > 0) temp_fr[rcnt]++;\n }\n }\n if (!valid) continue;\n int newsat = 0;\n for (int d = 1; d <= 10; d++) {\n newsat += min(A[d], temp_fr[d]);\n }\n if (newsat > best_new) {\n best_new = newsat;\n best_l = llne;\n improved = true;\n }\n }\n }\n }\n if (improved) {\n chosen.push_back(best_l);\n vector> new_prts;\n for (auto& grp : parts) {\n vector leftv, rightv;\n for (int id : grp) {\n ll cr = compute_cross(best_l, id);\n if (cr > 0) leftv.push_back(id);\n else rightv.push_back(id);\n }\n if (!leftv.empty()) new_prts.push_back(leftv);\n if (!rightv.empty()) new_prts.push_back(rightv);\n }\n parts = std::move(new_prts);\n cur_sat = best_new;\n } else {\n break;\n }\n }\n if (cur_sat > best_sat) {\n best_sat = cur_sat;\n best_chosen = chosen;\n }\n }\n cout << best_chosen.size() << endl;\n for (auto& l : best_chosen) {\n cout << l.px << \" \" << l.py << \" \" << l.qx << \" \" << l.qy << endl;\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\nusing pii = pair;\n\nconst int MAXN = 65;\nbool has[MAXN][MAXN];\nbool uh[MAXN][MAXN];\nbool uv[MAXN][MAXN];\nbool udp[MAXN][MAXN];\nbool udm[MAXN][MAXN];\nint N;\n\nbool inb(int x) { return 0 <= x && x < N; }\n\nint get_w(int x, int y, int c) {\n int dx = x - c, dy = y - c;\n return dx * dx + dy * dy + 1;\n}\n\nbool is_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n return uh[y1][xx];\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n return uv[x1][yy];\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int xhigh = xlow + 1;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n return udp[xlow][y_at_low];\n } else if (dyh == -1) {\n return udm[xlow][y_at_low];\n }\n return true;\n }\n return true;\n}\n\nvoid set_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n uh[y1][xx] = true;\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n uv[x1][yy] = true;\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n udp[xlow][y_at_low] = true;\n } else if (dyh == -1) {\n udm[xlow][y_at_low] = true;\n }\n }\n}\n\nbool clean_perim(const array& corn) {\n double cx = 0, cy = 0;\n for (auto& p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs.emplace_back(ang, i);\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0 && dy != 0) {\n steps = ady;\n uy = (dy > 0 ? 1 : -1);\n } else if (dy == 0 && dx != 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n uy = (dy > 0 ? 1 : -1);\n } else return false;\n for (int k = 1; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n if (has[xx][yy]) return false;\n }\n }\n return true;\n}\n\nbool edges_free(const array& corn) {\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs(4);\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs[i] = {ang, i};\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n } else return false;\n for (int k = 0; k < steps; k++) {\n int xx1 = x1 + k * ux;\n int yy1 = y1 + k * uy;\n int xx2 = xx1 + ux;\n int yy2 = yy1 + uy;\n if (is_used_unit(xx1, yy1, xx2, yy2)) return false;\n }\n }\n return true;\n}\n\nvector> cands;\nset> seen_set;\n\nvoid add_candidate(const array& corn) {\n array sorted_c = corn;\n sort(sorted_c.begin(), sorted_c.end());\n array key;\n for (int i = 0; i < 4; i++) {\n key[2 * i] = sorted_c[i].first;\n key[2 * i + 1] = sorted_c[i].second;\n }\n if (seen_set.count(key)) return;\n seen_set.insert(key);\n cands.push_back(corn);\n}\n\nbool get_three_missing(const array& corn, pii& newp) {\n int cnt_miss = 0;\n for (auto& pt : corn) {\n if (!has[pt.first][pt.second]) {\n newp = pt;\n cnt_miss++;\n if (cnt_miss > 1) return false;\n }\n }\n return cnt_miss == 1;\n}\n\nvoid try_from_pair(pii P, pii Q) {\n int px = P.first, py = P.second, qx = Q.first, qy = Q.second;\n if (!has[px][py] || !has[qx][qy]) return;\n if (px != qx && py != qy) {\n pii R = {px, qy};\n pii S = {qx, py};\n if (!inb(R.first) || !inb(R.second) || !inb(S.first) || !inb(S.second)) return;\n int hasR = has[R.first][R.second] ? 1 : 0;\n int hasS = has[S.first][S.second] ? 1 : 0;\n if (hasR + hasS == 1) {\n array corn = {P, Q, R, S};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n int dx = qx - px;\n int dy = qy - py;\n if ((dx + dy) % 2 == 0 && (dx - dy) % 2 == 0) {\n int p = (dx + dy) / 2;\n int q = (dx - dy) / 2;\n if (p != 0 && q != 0) {\n int bx = px + p;\n int by = py + p;\n int dx_ = px + q;\n int dy_ = py - q;\n if (inb(bx) && inb(by) && inb(dx_) && inb(dy_)) {\n int qcx = px + p + q;\n int qcy = py + p - q;\n if (qcx == qx && qcy == qy) {\n array corn = {{{px, py}, {bx, by}, {qx, qy}, {dx_, dy_}}};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n }\n }\n}\n\nint main() {\n int M;\n cin >> N >> M;\n vector init_dots(M);\n for (int i = 0; i < M; i++) {\n cin >> init_dots[i].first >> init_dots[i].second;\n }\n memset(has, 0, sizeof(has));\n memset(uh, 0, sizeof(uh));\n memset(uv, 0, sizeof(uv));\n memset(udp, 0, sizeof(udp));\n memset(udm, 0, sizeof(udm));\n for (auto& pt : init_dots) {\n has[pt.first][pt.second] = true;\n }\n int C = (N - 1) / 2;\n vector dots_list = init_dots;\n cands.clear();\n seen_set.clear();\n for (size_t i = 0; i < dots_list.size(); i++) {\n for (size_t j = i + 1; j < dots_list.size(); j++) {\n try_from_pair(dots_list[i], dots_list[j]);\n try_from_pair(dots_list[j], dots_list[i]);\n }\n }\n vector> answer_ops;\n for (int iter = 0; iter < 20000; iter++) {\n int best_w = -1;\n int best_idx = -1;\n pii best_new = {-1, -1};\n for (int ci = 0; ci < (int)cands.size(); ci++) {\n auto& corn = cands[ci];\n pii np;\n if (!get_three_missing(corn, np)) continue;\n if (has[np.first][np.second]) continue;\n if (!clean_perim(corn) || !edges_free(corn)) continue;\n int ww = get_w(np.first, np.second, C);\n if (ww > best_w) {\n best_w = ww;\n best_new = np;\n best_idx = ci;\n }\n }\n if (best_idx == -1) break;\n auto corn = cands[best_idx];\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n angs.emplace_back(atan2(corn[i].second - cy, corn[i].first - cx), i);\n }\n sort(angs.begin(), angs.end());\n vector ord;\n for (auto& a : angs) ord.push_back(corn[a.second]);\n int new_idx = -1;\n for (int i = 0; i < 4; i++)\n if (ord[i] == best_new) {\n new_idx = i;\n break;\n }\n if (new_idx == -1) continue;\n array op;\n op[0] = best_new.first;\n op[1] = best_new.second;\n for (int k = 0; k < 3; k++) {\n pii nxt = ord[(new_idx + 1 + k) % 4];\n op[2 + k * 2] = nxt.first;\n op[2 + k * 2 + 1] = nxt.second;\n }\n answer_ops.push_back(op);\n has[best_new.first][best_new.second] = true;\n dots_list.push_back(best_new);\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n }\n for (int k = 0; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n set_used_unit(xx, yy, xx + ux, yy + uy);\n }\n }\n for (auto& Q : dots_list) {\n if (Q == best_new) continue;\n try_from_pair(best_new, Q);\n try_from_pair(Q, best_new);\n }\n }\n cout << answer_ops.size() << endl;\n for (auto& arr : answer_ops) {\n for (int i = 0; i < 8; i++) {\n cout << arr[i];\n if (i < 7) cout << \" \";\n else cout << endl;\n }\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nlong long calc_score(const vector>& grid) {\n bool visited[10][10] = {};\n long long total = 0;\n auto dfs = [&](auto&& self, int r, int c, int flavor, int& cnt) -> void {\n visited[r][c] = true;\n cnt++;\n int dr[4] = {-1, 0, 1, 0};\n int dc[4] = {0, 1, 0, -1};\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !visited[nr][nc] && grid[nr][nc] == flavor) {\n self(self, nr, nc, flavor, cnt);\n }\n }\n };\n for (int flavor = 1; flavor <= 3; flavor++) {\n for (int r = 0; r < 10; r++) {\n for (int c = 0; c < 10; c++) {\n if (!visited[r][c] && grid[r][c] == flavor) {\n int cnt = 0;\n dfs(dfs, r, c, flavor, cnt);\n total += 1LL * cnt * cnt;\n }\n }\n }\n }\n return total;\n}\n\nlong long potential(const vector>& grid) {\n long long res = calc_score(grid);\n for (int fl = 1; fl <= 3; fl++) {\n for (int r = 0; r < 10; r++) {\n int cnt = 0;\n for (int c = 0; c < 10; c++) if (grid[r][c] == fl) cnt++;\n res += 1LL * cnt * cnt;\n }\n for (int c = 0; c < 10; c++) {\n int cnt = 0;\n for (int r = 0; r < 10; r++) if (grid[r][c] == fl) cnt++;\n res += 1LL * cnt * cnt;\n }\n }\n return res;\n}\n\nvoid apply(vector>& grid, char d) {\n if (d == 'F') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int r = 0; r < 10; r++) grid[r][c] = (r < (int)line.size() ? line[r] : 0);\n }\n } else if (d == 'B') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int r = 0; r < 10; r++) grid[r][c] = (r < 10 - ls ? 0 : line[r - (10 - ls)]);\n }\n } else if (d == 'L') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int c = 0; c < 10; c++) grid[r][c] = (c < (int)line.size() ? line[c] : 0);\n }\n } else if (d == 'R') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int c = 0; c < 10; c++) grid[r][c] = (c < 10 - ls ? 0 : line[c - (10 - ls)]);\n }\n }\n}\n\nint main() {\n vector> g(10, vector(10, 0));\n vector f(100);\n for (int &x : f) cin >> x;\n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n vector> empt;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (g[r][c] == 0) empt.emplace_back(r, c);\n auto [rr, cc] = empt[p - 1];\n g[rr][cc] = f[t];\n long double best_eval = -1;\n char best_d = 'F';\n bool has_next = (t < 99);\n int next_f = has_next ? f[t + 1] : -1;\n for (char d : {'F', 'B', 'L', 'R'}) {\n vector> ng = g;\n apply(ng, d);\n long long csc = potential(ng);\n long double fut = 0;\n if (has_next) {\n vector> ne;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (ng[r][c] == 0) ne.emplace_back(r, c);\n if (!ne.empty()) {\n long double sumf = 0;\n for (auto& pr : ne) {\n vector> ngp = ng;\n ngp[pr.first][pr.second] = next_f;\n long long bns = 0;\n for (char nd : {'F', 'B', 'L', 'R'}) {\n vector> ng2 = ngp;\n apply(ng2, nd);\n long long sc2 = potential(ng2);\n if (sc2 > bns) bns = sc2;\n }\n sumf += bns;\n }\n fut = sumf / ne.size();\n }\n }\n long double evalv = csc + fut;\n if (evalv > best_eval) {\n best_eval = evalv;\n best_d = d;\n }\n }\n apply(g, best_d);\n cout << best_d << endl;\n cout.flush();\n }\n return 0;\n}","ahc016":"#include \n#include \n\nusing namespace std;\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\nusing Eigen::SelfAdjointEigenSolver;\n\nint main() {\n int M;\n double eps;\n cin >> M >> eps;\n int N = 20;\n if (eps < 0.1) N = 12;\n else if (eps < 0.2) N = 18;\n else if (eps < 0.3) N = 25;\n else N = 35;\n N = max(N, (int)ceil(sqrt(2.0 * M)));\n N = min(N, 100);\n N = max(N, 4);\n vector G(M);\n for(int k = 0; k < M; k++) {\n double p = (double)(k + 1) / (M + 1);\n string s = \"\";\n for(int i = 0; i < N; i++) {\n for(int j = i + 1; j < N; j++) {\n long long seed = (long long)k * 123457 + (long long)i * 10007 + j;\n if ((seed % 100000LL) < (long long)(p * 100000)) {\n s += '1';\n } else {\n s += '0';\n }\n }\n }\n G[k] = s;\n }\n vector> pre_degs(M);\n vector> pre_eigs(M);\n for(int k = 0; k < M; k++) {\n auto& str = G[k];\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(str[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector d(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) d[i]++;\n sort(d.begin(), d.end());\n pre_degs[k] = d;\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector ev(N);\n for(int i = 0; i < N; i++) ev[i] = e(i);\n pre_eigs[k] = ev;\n }\n cout << N << endl;\n for(auto& g : G) {\n cout << g << endl;\n }\n cout.flush();\n double scale = 1 - 2 * eps;\n double bias = eps * (N - 1.0);\n for(int q = 0; q < 100; q++) {\n string H;\n cin >> H;\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(H[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector deg(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) deg[i]++;\n sort(deg.begin(), deg.end());\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector eig(N);\n for(int i = 0; i < N; i++) eig[i] = e(i);\n int best = 0;\n double min_dist = 1e100;\n for(int k = 0; k < M; k++) {\n double ddeg = 0;\n for(int i = 0; i < N; i++) {\n double exp_d = bias + scale * pre_degs[k][i];\n ddeg += (deg[i] - exp_d) * (deg[i] - exp_d);\n }\n ddeg = sqrt(ddeg);\n double deig = 0;\n vector eexp = pre_eigs[k];\n for(int i=0; i\nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n vector U(M), V(M);\n vector W(M);\n for(int i = 0; i < M; i++) {\n cin >> U[i] >> V[i] >> W[i];\n --U[i]; --V[i];\n }\n vector> pos(N);\n for(int i = 0; i < N; i++) {\n cin >> pos[i].first >> pos[i].second;\n }\n auto gen = [&](unsigned seed) -> vector {\n vector ass(M, -1);\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n mt19937 rng(seed);\n shuffle(ord.begin(), ord.end(), rng);\n for(int ei : ord) {\n int best = -1;\n int minc = INT_MAX;\n int minld = INT_MAX;\n for(int d = 0; d < D; d++) if(ld[d] < K) {\n int conf = vcnt[U[ei]][d] + vcnt[V[ei]][d];\n if(conf < minc || (conf == minc && ld[d] < minld)) {\n minc = conf;\n minld = ld[d];\n best = d;\n }\n }\n if(best == -1) {\n // fallback\n for(int d=0;d& ass) -> ll {\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = ass[i];\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n ll bad = 0;\n for(int v = 0; v <= N; v++) {\n for(int d = 0; d < D; d++) {\n int c = vcnt[v][d];\n bad += (ll)c * (c - 1);\n }\n }\n return bad;\n };\n vector best_ass;\n ll min_bad = LLONG_MAX;\n int trials = 5000;\n for(int t = 0; t < trials; t++) {\n vector ass = gen(t * 10007ULL + 123456789ULL);\n ll bd = compute_bad(ass);\n if(bd < min_bad) {\n min_bad = bd;\n best_ass = ass;\n }\n }\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = best_ass[i];\n ld[d]++;\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n bool improved = true;\n int max_passes = 300;\n mt19937 rng_rand(424242);\n for(int pass = 0; pass < max_passes && improved; pass++) {\n improved = false;\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng_rand);\n for(int ei : ord) {\n int cur = best_ass[ei];\n int uu = U[ei], vv = V[ei];\n ll best_delta = 0;\n int best_newd = -1;\n for(int d = 0; d < D; d++) if(d != cur && ld[d] < K) {\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta) {\n best_delta = delta;\n best_newd = d;\n }\n }\n if(best_newd != -1 && best_delta < 0) {\n int newd = best_newd;\n vcnt[uu][cur]--;\n vcnt[vv][cur]--;\n vcnt[uu][newd]++;\n vcnt[vv][newd]++;\n ld[cur]--;\n ld[newd]++;\n best_ass[ei] = newd;\n improved = true;\n }\n }\n }\n // Additional load balancing opt pass, move if not increase bad much and balances\n for(int iter=0; iter<50; iter++) {\n int maxl = 0, minl = INT_MAX;\n for(int d=0;d ord(M); iota(ord.begin(),ord.end(),0);\n shuffle(ord.begin(),ord.end(),rng_rand);\n for(int ei:ord) {\n int cur = best_ass[ei];\n if(ld[cur] <= minl +1) continue;\n int uu=U[ei],vv=V[ei];\n ll best_delta = LLONG_MAX/2;\n int bestd = -1;\n for(int d=0;d= maxl) continue;\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta){\n best_delta=delta;\n bestd =d;\n }\n }\n if(bestd !=-1 && best_delta < 1000LL){ // allow slight increase sometimes for balance\n int newd=bestd;\n vcnt[uu][cur]--; vcnt[vv][cur]--;\n vcnt[uu][newd]++; vcnt[vv][newd]++;\n ld[cur]--; ld[newd]++;\n best_ass[ei]=newd;\n moved=true;\n break;\n }\n }\n if(!moved) break;\n }\n for(int i = 0; i < M; i++) {\n if(i > 0) cout << \" \";\n cout << (best_ass[i] + 1);\n }\n cout << endl;\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Rod {\n int st, f1, f2, len;\n};\n\nstruct Rect {\n int sx, sy, sz, wx, wy;\n};\n\nint main() {\n int D;\n cin >> D;\n vector F[2], R[2];\n for (int i = 0; i < 2; i++) {\n F[i].resize(D);\n for (auto &s : F[i]) cin >> s;\n R[i].resize(D);\n for (auto &s : R[i]) cin >> s;\n }\n double best_eval = 1LL << 60;\n int best_n = 0;\n int best_block[2][15][15][15];\n bool voxels[2][15][15][15] = {};\n for (int i = 0; i < 2; i++) {\n for (int z = 0; z < D; z++) {\n vector Xs, Ys;\n for (int x = 0; x < D; x++) if (F[i][z][x] == '1') Xs.push_back(x);\n for (int y = 0; y < D; y++) if (R[i][z][y] == '1') Ys.push_back(y);\n int a = Xs.size(), b = Ys.size();\n if (a == 0 || b == 0) continue;\n vector Xsort = Xs; sort(Xsort.begin(), Xsort.end());\n vector Ysort = Ys; sort(Ysort.begin(), Ysort.end());\n vector> assigns;\n if (a >= b) {\n int base = a / b; int rem = a % b;\n int pos = 0;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[pos++], Ysort[iy]);\n }\n }\n } else {\n int base = b / a; int rem = b % a;\n int pos = 0;\n for (int ix = 0; ix < a; ix++) {\n int cnt = base + (ix < rem);\n for (int j = 0; j < cnt; j++) {\n assigns.emplace_back(Xsort[ix], Ysort[pos++]);\n }\n }\n }\n for (auto [x, y] : assigns) {\n voxels[i][x][y][z] = true;\n }\n }\n }\n auto process_rod = [&](int di) {\n vector rlist[2][16];\n for (int i = 0; i < 2; i++) {\n if (di == 0) {\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n for (int x = 0; x < D; ) {\n if (!voxels[i][x][y][z]) { x++; continue; }\n int st = x;\n while (x < D && voxels[i][x][y][z]) x++;\n int l = x - st;\n rlist[i][l].push_back({st, y, z, l});\n }\n }\n } else if (di == 1) {\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) {\n for (int y = 0; y < D; ) {\n if (!voxels[i][x][y][z]) { y++; continue; }\n int st = y;\n while (y < D && voxels[i][x][y][z]) y++;\n int l = y - st;\n rlist[i][l].push_back({st, x, z, l});\n }\n }\n } else {\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; ) {\n if (!voxels[i][x][y][z]) { z++; continue; }\n int st = z;\n while (z < D && voxels[i][x][y][z]) z++;\n int l = z - st;\n rlist[i][l].push_back({st, x, y, l});\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n for (int l = 1; l <= D; l++) {\n int c[2] = {(int)rlist[0][l].size(), (int)rlist[1][l].size()};\n int sh = min(c[0], c[1]);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c[1] - sh) * l;\n rrs[1] += (c[0] - sh) * l;\n sinv += sh * 1.0 / l;\n for (int k = 0; k < c[0]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod& rd = rlist[0][l][k];\n if (di == 0) {\n for (int d = 0; d < l; d++) blockid[0][rd.st + d][rd.f1][rd.f2] = bid;\n } else if (di == 1) {\n for (int d = 0; d < l; d++) blockid[0][rd.f1][rd.st + d][rd.f2] = bid;\n } else {\n for (int d = 0; d < l; d++) blockid[0][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n for (int k = 0; k < c[1]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod& rd = rlist[1][l][k];\n if (di == 0) {\n for (int d = 0; d < l; d++) blockid[1][rd.st + d][rd.f1][rd.f2] = bid;\n } else if (di == 1) {\n for (int d = 0; d < l; d++) blockid[1][rd.f1][rd.st + d][rd.f2] = bid;\n } else {\n for (int d = 0; d < l; d++) blockid[1][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int p = 0; p < 2; p++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) best_block[p][x][y][z] = blockid[p][x][y][z];\n }\n };\n process_rod(0);\n process_rod(1);\n process_rod(2);\n // rect\n map, vector> rects_key[2];\n for (int i = 0; i < 2; i++) {\n for (int z = 0; z < D; z++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) {\n layer[x][y] = voxels[i][x][y][z];\n }\n while (true) {\n for (int x = 0; x < D; x++) {\n prefix[x][0] = 0;\n for (int y = 1; y <= D; y++) {\n prefix[x][y] = prefix[x][y - 1] + (layer[x][y - 1] ? 1 : 0);\n }\n }\n int max_area = 0;\n int bx = -1, by = -1, bwx = 0, bwy = 0;\n for (int t = 0; t < D; t++) {\n for (int b = t; b < D; b++) {\n for (int l = 0; l < D; l++) {\n for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int x = t; x <= b && ok; x++) {\n if (prefix[x][r + 1] - prefix[x][l] != (r - l + 1)) ok = false;\n }\n if (ok) {\n max_area = area;\n bx = t;\n by = l;\n bwx = b - t + 1;\n bwy = r - l + 1;\n }\n }\n }\n }\n }\n if (max_area == 0) break;\n int mn = min(bwx, bwy);\n int mx = max(bwx, bwy);\n rects_key[i][{mn, mx}].push_back({bx, by, z, bwx, bwy});\n for (int x = bx; x < bx + bwx; x++) for (int y = by; y < by + bwy; y++) {\n layer[x][y] = false;\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n vector> all_keys;\n for (auto& p : rects_key[0]) all_keys.push_back(p.first);\n for (auto& p : rects_key[1]) all_keys.push_back(p.first);\n sort(all_keys.begin(), all_keys.end());\n auto last = unique(all_keys.begin(), all_keys.end());\n all_keys.erase(last, all_keys.end());\n for (auto& key : all_keys) {\n int v = key.first * key.second;\n int c0 = rects_key[0].count(key) ? rects_key[0][key].size() : 0;\n int c1 = rects_key[1].count(key) ? rects_key[1][key].size() : 0;\n int sh = min(c0, c1);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c1 - sh) * v;\n rrs[1] += (c0 - sh) * v;\n sinv += sh * (1.0 / v);\n for (int k = 0; k < c0; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rect& rd = rects_key[0][key][k];\n for (int dx = 0; dx < rd.wx; dx++) for (int dy = 0; dy < rd.wy; dy++) {\n blockid[0][rd.sx + dx][rd.sy + dy][rd.sz] = bid;\n }\n }\n for (int k = 0; k < c1; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rect& rd = rects_key[1][key][k];\n for (int dx = 0; dx < rd.wx; dx++) for (int dy = 0; dy < rd.wy; dy++) {\n blockid[1][rd.sx + dx][rd.sy + dy][rd.sz] = bid;\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int p = 0; p < 2; p++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) best_block[p][x][y][z] = blockid[p][x][y][z];\n }\n cout << best_n << endl;\n for (int i = 0; i < 2; i++) {\n for (int pos = 0; pos < D * D * D; pos++) {\n int x = pos / (D * D);\n int rem = pos % (D * D);\n int y = rem / D;\n int z = rem % D;\n cout << best_block[i][x][y][z];\n if (pos < D * D * D - 1) cout << \" \";\n }\n cout << endl;\n }\n return 0;\n}","ahc020":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct UF {\n vector p, r;\n UF(int n) : p(n+1), r(n+1, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }\n bool unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return false;\n if (r[x] < r[y]) swap(x, y);\n p[y] = x;\n if (r[x] == r[y]) r[x]++;\n return true;\n }\n};\n\nstruct Edge {\n int u, v, idx;\n ll w;\n};\n\nstruct TEdge {\n int to, eidx;\n ll w;\n};\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector X(N+1), Y(N+1);\n for (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n vector alledges(M);\n for (int j = 0; j < M; j++) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n alledges[j] = {u, v, j, w};\n }\n vector A(K+1), B(K+1);\n for (int k = 1; k <= K; k++) cin >> A[k] >> B[k];\n vector> dist2(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll dx = X[i] - A[k];\n ll dy = Y[i] - B[k];\n dist2[i][k] = dx * dx + dy * dy;\n }\n }\n vector> minP(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll d2 = dist2[i][k];\n if (d2 == 0) {\n minP[i][k] = 0;\n continue;\n }\n ll low = 0, high = 100000;\n while (low < high) {\n ll mid = (low + high) / 2;\n if (mid * mid >= d2) high = mid;\n else low = mid + 1;\n }\n minP[i][k] = low;\n }\n }\n UF uf(N);\n vector mst_edges = alledges;\n sort(mst_edges.begin(), mst_edges.end(), [](const Edge& e1, const Edge& e2) { return e1.w < e2.w; });\n vector> tree(N+1);\n for (auto& e : mst_edges) {\n if (uf.unite(e.u, e.v)) {\n tree[e.u].push_back({e.v, e.idx, e.w});\n tree[e.v].push_back({e.u, e.idx, e.w});\n }\n }\n vector> children(N+1);\n function build = [&](int u, int par) {\n for (auto& e : tree[u]) {\n if (e.to != par) {\n children[u].push_back(e);\n build(e.to, u);\n }\n }\n };\n build(1, -1);\n using pbb = pair;\n function&, const vector&)> dfs_conn = [&](int u, set& usedids, const vector& term) -> pbb {\n bool has = term[u];\n ll cst = 0;\n for (auto& e : children[u]) {\n auto [sc, sh] = dfs_conn(e.to, usedids, term);\n if (sh) {\n cst += e.w + sc;\n has = true;\n usedids.insert(e.eidx);\n } else {\n cst += sc;\n }\n }\n return {cst, has};\n };\n auto get_connect = [&](const vector& t) -> ll {\n set dum;\n auto [c, h] = dfs_conn(1, dum, t);\n return c;\n };\n vector> res_list(N+1);\n vector assignment(K+1, 0);\n vector> reqs(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n assignment[k] = best;\n res_list[best].push_back(k);\n reqs[best].insert(bp);\n }\n vector curP(N+1, 0);\n ll sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n }\n }\n vector is_open(N+1, false);\n for (int i = 1; i <= N; i++) if (curP[i] > 0) is_open[i] = true;\n auto compute_term = [&](const vector& pvals) -> vector {\n vector t(N+1, false);\n for (int i = 1; i <= N; i++) t[i] = (pvals[i] > 0) || (i == 1);\n return t;\n };\n vector curr_term(N+1, false);\n for (int i = 1; i <= N; i++) curr_term[i] = (curP[i] > 0) || (i == 1);\n ll cur_conn = get_connect(curr_term);\n ll current_total = sum_sq + cur_conn;\n const int MAX_ITER = 50;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool improved = false;\n for (int k = 1; k <= K; k++) {\n int curr = assignment[k];\n if (curr == 0) continue;\n int reqc = minP[curr][k];\n for (int j = 1; j <= N; j++) if (is_open[j] && j != curr) {\n int reqn = minP[j][k];\n reqs[curr].erase(reqs[curr].find(reqc));\n ll tpc = reqs[curr].empty() ? 0 : *reqs[curr].rbegin();\n reqs[j].insert(reqn);\n ll tpj = *reqs[j].rbegin();\n ll dsq = tpc * tpc + tpj * tpj - (ll)curP[curr] * curP[curr] - (ll)curP[j] * curP[j];\n bool will_close = (curP[curr] > 0 && tpc == 0);\n ll dcon = 0;\n if (will_close) {\n vector np(N+1);\n for (int ii = 1; ii <= N; ii++) np[ii] = curP[ii];\n np[curr] = tpc;\n np[j] = tpj;\n auto tterm = compute_term(np);\n ll newc = get_connect(tterm);\n dcon = newc - cur_conn;\n }\n reqs[j].erase(reqs[j].find(reqn));\n reqs[curr].insert(reqc);\n if (dsq + dcon < 0) {\n reqs[curr].erase(reqs[curr].find(reqc));\n reqs[j].insert(reqn);\n auto& lst = res_list[curr];\n for (size_t pos = 0; pos < lst.size(); pos++) if (lst[pos] == k) {\n swap(lst[pos], lst.back());\n lst.pop_back();\n break;\n }\n res_list[j].push_back(k);\n assignment[k] = j;\n curP[curr] = tpc;\n curP[j] = tpj;\n sum_sq += dsq;\n if (will_close) {\n is_open[curr] = false;\n cur_conn += dcon;\n curr_term[curr] = (tpc > 0) || (curr == 1);\n curr_term[j] = (tpj > 0) || (j == 1);\n } else {\n curr_term[curr] = (tpc > 0) || (curr == 1);\n curr_term[j] = (tpj > 0) || (j == 1);\n }\n current_total += dsq + dcon;\n improved = true;\n break;\n }\n }\n if (improved) break;\n }\n if (!improved) {\n for (int i = 1; i <= N && !improved; i++) if (is_open[i]) {\n vector new_add(N+1, 0);\n bool can = true;\n vector> move_info;\n for (auto kk : res_list[i]) {\n int altj = -1, altp = INT_MAX / 2;\n for (int jj = 1; jj <= N; jj++) if (is_open[jj] && jj != i) {\n if (minP[jj][kk] < altp) {\n altp = minP[jj][kk];\n altj = jj;\n }\n }\n if (altp > 5000) {\n can = false;\n break;\n }\n new_add[altj] = max(new_add[altj], altp);\n move_info.emplace_back(kk, altj);\n }\n if (!can) continue;\n ll dsq = -(ll)curP[i] * curP[i];\n vector new_p(N+1);\n for (int ii = 1; ii <= N; ii++) new_p[ii] = curP[ii];\n new_p[i] = 0;\n for (int jj = 1; jj <= N; jj++) if (new_add[jj] > 0) {\n int oldpj = curP[jj];\n new_p[jj] = max(oldpj, new_add[jj]);\n dsq += (ll)new_p[jj] * new_p[jj] - (ll)oldpj * oldpj;\n }\n auto tterm = compute_term(new_p);\n ll new_conn_val = get_connect(tterm);\n ll dcon = new_conn_val - cur_conn;\n if (dsq + dcon < 0) {\n for (auto [kk, altj] : move_info) {\n reqs[i].erase(reqs[i].find(minP[i][kk]));\n reqs[altj].insert(minP[altj][kk]);\n auto& l = res_list[i];\n for (size_t p = 0; p < l.size(); p++) if (l[p] == kk) {\n swap(l[p], l.back());\n l.pop_back();\n break;\n }\n res_list[altj].push_back(kk);\n assignment[kk] = altj;\n }\n reqs[i].clear();\n res_list[i].clear();\n for (int jj = 1; jj <= N; jj++) {\n ll np = reqs[jj].empty() ? 0 : *reqs[jj].rbegin();\n if (new_p[jj] != np) new_p[jj] = (int)np;\n }\n for (int jj = 1; jj <= N; jj++) curP[jj] = new_p[jj];\n sum_sq += dsq;\n is_open[i] = false;\n cur_conn = new_conn_val;\n for (int ii = 1; ii <= N; ii++) curr_term[ii] = (curP[ii] > 0) || (ii == 1);\n current_total += dsq + dcon;\n improved = true;\n }\n }\n }\n if (!improved) break;\n }\n vector final_term(N+1, false);\n for (int i = 1; i <= N; i++) final_term[i] = (curP[i] > 0) || (i == 1);\n set final_used;\n auto [final_c, _] = dfs_conn(1, final_used, final_term);\n vector Bs(M, 0);\n for (int ei : final_used) {\n if (ei >= 0 && ei < M) Bs[ei] = 1;\n }\n for (int i = 1; i <= N; i++) cout << curP[i] << (i < N ? \" \" : \"\\n\");\n for (int j = 0; j < M; j++) cout << Bs[j] << (j < M - 1 ? \" \" : \"\\n\");\n}","ahc021":"#include \nusing namespace std;\nusing P = pair;\n\nstruct Sw {\n int x1, y1, x2, y2;\n};\n\nint main() {\n int N = 30;\n vector> grid(N);\n for (int x = 0; x < N; x++) {\n grid[x].resize(x + 1);\n for (int y = 0; y <= x; y++) {\n cin >> grid[x][y];\n }\n }\n int total = N * (N + 1) / 2;\n vector

curr_pos(total);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int val = grid[x][y];\n curr_pos[val] = {x, y};\n }\n }\n vector> is_fixed(N, vector(N, false));\n vector ops;\n\n auto get_parents = [&](P p) -> vector

{\n auto [x, y] = p;\n vector

res;\n if (x > 0) {\n if (y <= x - 1) res.emplace_back(x - 1, y);\n if (y - 1 >= 0) {\n int py = y - 1;\n if (py <= x - 1) res.emplace_back(x - 1, py);\n }\n }\n return res;\n };\n\n auto get_neighbors = [&](P p) -> vector

{\n int x = p.first, y = p.second;\n vector

res;\n vector> deltas = {{-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}};\n for (auto [dx, dy] : deltas) {\n int nx = x + dx, ny = y + dy;\n if (nx >= 0 && nx < N && ny >= 0 && ny <= nx) {\n res.emplace_back(nx, ny);\n }\n }\n return res;\n };\n\n for (int k = 0; k < total; k++) {\n vector

avail;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n if (is_fixed[x][y]) continue;\n auto pars = get_parents({x, y});\n bool ok = true;\n for (auto pp : pars) {\n if (!is_fixed[pp.first][pp.second]) {\n ok = false;\n break;\n }\n }\n if (ok) avail.emplace_back(x, y);\n }\n }\n P start = curr_pos[k];\n vector> dist(N, vector(N, -1));\n vector> par(N, vector

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

q;\n if (!is_fixed[start.first][start.second]) {\n dist[start.first][start.second] = 0;\n q.push(start);\n }\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (is_fixed[nx.first][nx.second]) continue;\n if (dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n P target = {-1, -1};\n int min_d = INT_MAX;\n for (auto cand : avail) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1 && dx < min_d) {\n min_d = dx;\n target = cand;\n }\n }\n if (target.first == -1) {\n // Fallback: pick any avail reachable? If none, pick first and try avoid issue\n // For safety, pick first avail and use full BFS without fixed? But to prevent break, if happen, abort attempt\n // Assume won't happen\n if (!avail.empty()) {\n target = avail[0];\n min_d = 100000; // marker\n } else {\n // impossible\n assert(false);\n return 1;\n }\n }\n vector

path;\n if (min_d == 100000) {\n // special case fallback: perhaps place without path? but to handle, let's implement simple move if rare\n // but assume not reach, to make sure, I will run full grid even fixed but then may break, skip for now\n // To make robust, I will do a second BFS without fixed check for fallback\n // but then fix after careful\n // For this, since likely not trigger, and to just output\n dist.assign(N, vector(N, -1));\n par.assign(N, vector

(N, {-1, -1}));\n q = queue

();\n dist[start.first][start.second] = 0;\n q.push(start);\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n P best = avail[0];\n int bestd = dist[best.first][best.second];\n for (auto cand : avail) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1 && dx < bestd) {\n bestd = dx;\n best = cand;\n }\n }\n target = best;\n min_d = bestd;\n }\n P cur = target;\n path = {};\n while (true) {\n path.push_back(cur);\n if (dist[cur.first][cur.second] == 0) break;\n cur = par[cur.first][cur.second];\n if (cur.first == -1) break;\n }\n reverse(path.begin(), path.end());\n for (size_t i = 0; i + 1 < path.size(); i++) {\n P p1 = path[i];\n P p2 = path[i + 1];\n int v1 = grid[p1.first][p1.second];\n int v2 = grid[p2.first][p2.second];\n grid[p1.first][p1.second] = v2;\n grid[p2.first][p2.second] = v1;\n curr_pos[v1] = p2;\n curr_pos[v2] = p1;\n ops.push_back({p1.first, p1.second, p2.first, p2.second});\n }\n is_fixed[target.first][target.second] = true;\n }\n cout << ops.size() << endl;\n for (auto& s : ops) {\n cout << s.x1 << \" \" << s.y1 << \" \" << s.x2 << \" \" << s.y2 << endl;\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n int D, N;\n cin >> D >> N;\n bool is_obst[9][9] = {};\n int cont[9][9];\n memset(cont, -1, sizeof(cont));\n for (int k = 0; k < N; k++) {\n int ri, rj;\n cin >> ri >> rj;\n is_obst[ri][rj] = true;\n cont[ri][rj] = -2;\n }\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n auto is_valid = [&](int x, int y) { return x >= 0 && x < 9 && y >= 0 && y < 9; };\n int dist[9][9];\n int visit_ord[9][9];\n memset(dist, -1, sizeof(dist));\n memset(visit_ord, -1, sizeof(visit_ord));\n {\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n dist[0][4] = 0;\n visit_ord[0][4] = 0;\n int ord = 1;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n vis[nx][ny] = true;\n dist[nx][ny] = dist[x][y] + 1;\n visit_ord[nx][ny] = ord++;\n q.push({nx, ny});\n }\n }\n }\n int M = 0;\n for (int i = 0; i < 9; i++)\n for (int j = 0; j < 9; j++)\n if (!is_obst[i][j] && !(i == 0 && j == 4)) M++;\n int placed_count = 0;\n set remain;\n for (int i = 0; i < M; i++) remain.insert(i);\n auto get_reach = [&]() -> vector> {\n vector> res;\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n if (cont[nx][ny] >= 0) continue;\n vis[nx][ny] = true;\n q.push({nx, ny});\n if ((nx || ny != 4) && cont[nx][ny] == -1) res.push_back({nx, ny});\n }\n }\n return res;\n };\n auto is_safe_pos = [&](int px, int py, int curr_rem) -> bool {\n cont[px][py] = 100000;\n auto nr = get_reach();\n cont[px][py] = -1;\n return nr.size() == (size_t)(curr_rem - 1);\n };\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n vector> reach = get_reach();\n int curr_rem = M - placed_count;\n vector> cands;\n for (auto p : reach) {\n if (is_safe_pos(p.first, p.second, curr_rem)) {\n cands.push_back(p);\n }\n }\n if (cands.empty()) {\n cands = reach;\n }\n auto cmp = [&](const pair& a, const pair& b) {\n if (dist[a.first][a.second] != dist[b.first][b.second])\n return dist[a.first][a.second] < dist[b.first][b.second];\n return visit_ord[a.first][a.second] < visit_ord[b.first][b.second];\n };\n sort(cands.begin(), cands.end(), cmp);\n int j = 0;\n for (int rid : remain) {\n if (rid == t) break;\n j++;\n }\n pair place_pos;\n if (!cands.empty() && j < (int)cands.size()) {\n place_pos = cands[j];\n } else if (!cands.empty()) {\n place_pos = cands.back();\n } else {\n place_pos = {0, 0}; // fallback error\n }\n cout << place_pos.first << \" \" << place_pos.second << endl;\n cont[place_pos.first][place_pos.second] = t;\n placed_count++;\n remain.erase(t);\n }\n vector> rem_order;\n bool cleared[9][9] = {};\n cleared[0][4] = true;\n for (int step = 0; step < M; step++) {\n vector> acc;\n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (cont[i][j] < 0) continue;\n if (cleared[i][j]) continue;\n bool can = false;\n for (int d = 0; d < 4; d++) {\n int nx = i + dx[d], ny = j + dy[d];\n if (is_valid(nx, ny) && !is_obst[nx][ny] && cleared[nx][ny]) {\n can = true;\n break;\n }\n }\n if (can) acc.emplace_back(i, j);\n }\n }\n if (acc.empty()) break;\n int minid = INT_MAX;\n pair chosen = {-1, -1};\n for (auto p : acc) {\n int id = cont[p.first][p.second];\n if (id < minid) {\n minid = id;\n chosen = p;\n }\n }\n rem_order.push_back(chosen);\n cleared[chosen.first][chosen.second] = true;\n cont[chosen.first][chosen.second] = -1;\n }\n for (auto p : rem_order) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n vector>>> witnesses(\n m + 1, vector>>(m + 1));\n bitset<101> has_adj[101];\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n bool is_bound = (i == 0 || i == n - 1 || j == 0 || j == n - 1);\n if (is_bound) {\n witnesses[c][0].push_back({i, j});\n has_adj[c][0] = 1;\n has_adj[0][c] = 1;\n }\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int nc = grid[ni][nj];\n if (c != nc) {\n witnesses[c][nc].push_back({i, j});\n has_adj[c][nc] = 1;\n has_adj[nc][c] = 1;\n }\n }\n }\n }\n }\n vector>> term_set(m + 1);\n for (int c = 1; c <= m; c++) {\n if (has_adj[c][0] && !witnesses[c][0].empty()) {\n term_set[c].insert(witnesses[c][0][0]);\n }\n }\n for (int c = 1; c <= m; c++) {\n for (int d = c + 1; d <= m; d++) {\n if (has_adj[c][d]) {\n bool picked = false;\n if (!witnesses[c][d].empty()) {\n auto cp = witnesses[c][d][0];\n int ci = cp.first, cj = cp.second;\n for (int dir = 0; dir < 4; dir++) {\n int ni = ci + dx[dir], nj = cj + dy[dir];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == d) {\n term_set[c].insert(cp);\n term_set[d].insert({ni, nj});\n picked = true;\n break;\n }\n }\n }\n if (!picked && !witnesses[d][c].empty()) {\n auto dp = witnesses[d][c][0];\n int di = dp.first, dj = dp.second;\n for (int dir = 0; dir < 4; dir++) {\n int ni = di + dx[dir], nj = dj + dy[dir];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == c) {\n term_set[d].insert(dp);\n term_set[c].insert({ni, nj});\n picked = true;\n break;\n }\n }\n }\n }\n }\n }\n for (int c = 1; c <= m; c++) {\n if (term_set[c].empty()) {\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n term_set[c].insert({i, j});\n break;\n }\n }\n if (!term_set[c].empty()) break;\n }\n }\n }\n vector>> terminals(m + 1);\n for (int c = 1; c <= m; c++) {\n for (auto p : term_set[c]) terminals[c].push_back(p);\n }\n vector> iskept(n, vector(n, false));\n for (int c = 1; c <= m; c++) {\n if (terminals[c].empty()) continue;\n auto root = terminals[c][0];\n int sx = root.first, sy = root.second;\n vector> dist(n, vector(n, -1));\n vector>> parent(n, vector>(n, {-1, -1}));\n queue> qq;\n qq.push({sx, sy});\n dist[sx][sy] = 0;\n while (!qq.empty()) {\n auto [x, y] = qq.front();\n qq.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || dist[nx][ny] != -1 || grid[nx][ny] != c) continue;\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n qq.push({nx, ny});\n }\n }\n set> sk;\n for (auto &t : terminals[c]) {\n int cx = t.first, cy = t.second;\n while (true) {\n if (cx == -1 || dist[cx][cy] == -1) break;\n sk.insert({cx, cy});\n if (cx == sx && cy == sy) break;\n auto [px, py] = parent[cx][cy];\n cx = px;\n cy = py;\n }\n }\n for (auto p : sk) {\n iskept[p.first][p.second] = true;\n }\n }\n auto do_fix = [&]( ) -> bool {\n vector> current(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) current[i][j] = grid[i][j];\n }\n }\n vector> to_add;\n bool changed = false;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = current[i][j];\n if (c == 0) continue;\n if (has_adj[c][0]) continue;\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && current[ni][nj] == 0) {\n to_add.push_back({ni, nj});\n changed = true;\n }\n }\n }\n }\n vector> vis(n, vector(n, false));\n queue> q0;\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) && current[i][j] == 0) {\n q0.push({i, j});\n vis[i][j] = true;\n }\n }\n }\n while (!q0.empty()) {\n auto [x, y] = q0.front();\n q0.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || vis[nx][ny] || current[nx][ny] != 0) continue;\n vis[nx][ny] = true;\n q0.push({nx, ny});\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (current[i][j] == 0 && !vis[i][j]) {\n to_add.push_back({i, j});\n changed = true;\n }\n }\n }\n for (auto [i, j] : to_add) {\n if (!iskept[i][j]) {\n iskept[i][j] = true;\n }\n }\n return changed;\n };\n auto reconnect = [&]( ) {\n for (int c = 1; c <= m; c++) {\n vector> kept_c;\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (iskept[i][j] && grid[i][j] == c) kept_c.push_back({i, j});\n if (kept_c.empty()) continue;\n vector> comp(n, vector(n, -1));\n int numcom = 0;\n for (auto [x, y] : kept_c) {\n if (comp[x][y] != -1) continue;\n numcom++;\n queue> q;\n q.push({x, y});\n comp[x][y] = numcom;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d], ny = cy + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || comp[nx][ny] != -1 || !iskept[nx][ny] || grid[nx][ny] != c) continue;\n comp[nx][ny] = numcom;\n q.push({nx, ny});\n }\n }\n }\n if (numcom <= 1) continue;\n vector> reps(numcom + 1, {-1, -1});\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (comp[i][j] != -1 && reps[comp[i][j]].first == -1) reps[comp[i][j]] = {i, j};\n pair rootp = reps[1];\n int sx = rootp.first, sy = rootp.second;\n vector> dist(n, vector(n, -1));\n vector>> par(n, vector>(n, {-1, -1}));\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx >= 0 && nx < n && ny >= 0 && ny < n && grid[nx][ny] == c && dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n par[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n set> addsk;\n for (int com = 2; com <= numcom; com++) {\n auto [cx, cy] = reps[com];\n int curx = cx, cury = cy;\n while (curx != -1) {\n if (dist[curx][cury] == -1) break;\n addsk.insert({curx, cury});\n if (curx == sx && cury == sy) break;\n auto p = par[curx][cury];\n curx = p.first;\n cury = p.second;\n }\n }\n for (auto p : addsk) {\n iskept[p.first][p.second] = true;\n }\n }\n };\n bool changed = true;\n int maxb = 30;\n for (int bigl = 0; bigl < maxb && changed; bigl++) {\n reconnect();\n changed = do_fix();\n }\n vector> final(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) final[i][j] = grid[i][j];\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j > 0) cout << \" \";\n cout << final[i][j];\n }\n cout << endl;\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n srand(time(NULL));\n int N, D, Q;\n cin >> N >> D >> Q;\n vector> adj(N);\n vector outdeg(N, 0);\n bitset<128> dcomp[100];\n auto compute_ranks = [&]( ) -> vector {\n vector memo(N, -1);\n function dfs = [&](int u) -> int {\n if (memo[u] != -1) return memo[u];\n int mx = 0;\n for (int v : adj[u]) {\n mx = max(mx, dfs(v) + 1);\n }\n return memo[u] = mx;\n };\n for (int i = 0; i < N; i++) {\n dfs(i);\n }\n return memo;\n };\n for (int q = 0; q < Q; q++) {\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n bool found = false;\n pair to_comp = {-1, -1};\n for (int dist = 1; dist < N && !found; dist++) {\n for (int p = 0; p + dist < N && !found; p++) {\n int x = items[p];\n int y = items[p + dist];\n if (!dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n }\n }\n }\n if (!found) {\n for (int tries = 0; tries < 10000; tries++) {\n int x = rand() % N;\n int y = rand() % N;\n if (x != y && !dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n break;\n }\n }\n if (!found) {\n to_comp = {0, 1};\n }\n }\n int a = to_comp.first;\n int b = to_comp.second;\n cout << 1 << \" \" << 1 << \" \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n dcomp[a].set(b);\n dcomp[b].set(a);\n if (res == '>') {\n adj[a].push_back(b);\n outdeg[a]++;\n } else if (res == '<') {\n adj[b].push_back(a);\n outdeg[b]++;\n }\n }\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n vector group(N);\n for (int i = 0; i < N; i++) {\n group[items[i]] = i % D;\n }\n for (int i = 0; i < N; i++) {\n cout << group[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n int h = n / m;\n vector> st(m);\n vector stack_of(n + 1, -1);\n vector pos_in_st(n + 1, -1);\n for (int i = 0; i < m; i++) {\n st[i].resize(h);\n for (int j = 0; j < h; j++) {\n cin >> st[i][j];\n stack_of[st[i][j]] = i;\n pos_in_st[st[i][j]] = j;\n }\n }\n vector> ops;\n for (int v = 1; v <= n; v++) {\n while (true) {\n int s = stack_of[v];\n if (s == -1) {\n break;\n }\n int p = pos_in_st[v];\n if (p == (int)st[s].size() - 1) break;\n vector stack_min(m, n + 1);\n for (int i = 0; i < m; i++) {\n for (int b : st[i]) {\n if (b < stack_min[i]) stack_min[i] = b;\n }\n }\n int best_minv = -1;\n int best_sz = INT_MAX;\n int dest = -1;\n for (int i = 0; i < m; i++)\n if (i != s) {\n int cmin = stack_min[i];\n int csz = st[i].size();\n bool up = false;\n if (cmin > best_minv) up = true;\n else if (cmin == best_minv) {\n if (csz < best_sz) up = true;\n else if (csz == best_sz && (dest == -1 || i < dest)) up = true;\n }\n if (up) {\n best_minv = cmin;\n best_sz = csz;\n dest = i;\n }\n }\n if (dest == -1) {\n // fallback: any stack except s\n for (int i = 0; i < m; i++)\n if (i != s) {\n dest = i;\n break;\n }\n }\n int lift_v = st[s][p + 1];\n ops.emplace_back(lift_v, dest);\n vector to_move;\n for (size_t j = p + 1; j < st[s].size(); ++j) {\n to_move.push_back(st[s][j]);\n }\n st[s].resize(p + 1);\n size_t old_dest_sz = st[dest].size();\n st[dest].insert(st[dest].end(), to_move.begin(), to_move.end());\n for (size_t j = 0; j < to_move.size(); ++j) {\n int b = to_move[j];\n stack_of[b] = dest;\n pos_in_st[b] = old_dest_sz + j;\n }\n }\n int s = stack_of[v];\n ops.emplace_back(v, 0);\n st[s].pop_back();\n stack_of[v] = -1;\n pos_in_st[v] = -1;\n }\n for (auto [vv, ii] : ops) {\n cout << vv << \" \" << ii << endl;\n }\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector h(N-1);\n for(int i = 0; i < N-1; i++) cin >> h[i];\n vector v(N);\n for(int i = 0; i < N; i++) cin >> v[i];\n vector> d(N, vector(N));\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n vector> sd(N, vector(N));\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n sd[i][j] = sqrt(d[i][j]);\n }\n \n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n string DIR = \"URDL\";\n \n auto can_move = [&](int i, int j, int ni, int nj, const auto& hh, const auto& vv) -> bool {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n int ddi = ni - i;\n int ddj = nj - j;\n if (ddi == -1 && ddj == 0) return hh[ni][j] == '0';\n if (ddi == 1 && ddj == 0) return hh[i][j] == '0';\n if (ddi == 0 && ddj == 1) return vv[i][j] == '0';\n if (ddi == 0 && ddj == -1) return vv[i][nj] == '0';\n return false;\n };\n \n // Base covering DFS\n vector> vis_mark(N, vector(N, false));\n string route = \"\";\n function dfs = [&](int i, int j) {\n vis_mark[i][j] = true;\n for(int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !vis_mark[ni][nj] && can_move(i, j, ni, nj, h, v)) {\n route += DIR[dir];\n dfs(ni, nj);\n route += DIR[(dir + 2) % 4];\n }\n }\n };\n dfs(0, 0);\n \n // Simulate base\n vector> visits(N, vector(N, 0));\n vector> positions;\n positions.emplace_back(0, 0);\n int ci = 0, cj = 0;\n for (char c : route) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'R') dir = 1;\n else if (c == 'D') dir = 2;\n else if (c == 'L') dir = 3;\n if (dir == -1) continue;\n int ni = ci + di[dir], nj = cj + dj[dir];\n positions.emplace_back(ni, nj);\n visits[ni][nj]++;\n ci = ni;\n cj = nj;\n }\n int Ltotal = positions.size() - 1;\n int cur_i = ci, cur_j = cj;\n \n // Add more visits\n int L_target = 99500;\n while (Ltotal < L_target) {\n // Find best target != current\n double max_p = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == cur_i && j == cur_j) continue;\n double p = sd[i][j] / (visits[i][j] + 1.0);\n if (p > max_p) {\n max_p = p;\n ti = i;\n tj = j;\n }\n }\n }\n if (ti == -1) {\n // only current, do excursion\n bool ex = false;\n for (int dir = 0; dir < 4; dir++) {\n int ni = cur_i + di[dir], nj = cur_j + dj[dir];\n if (can_move(cur_i, cur_j, ni, nj, h, v)) {\n ti = ni;\n tj = nj;\n ex = true;\n break;\n }\n }\n if (!ex) break;\n }\n \n // BFS from cur to ti,tj\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == ti && cur_j == tj);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == ti && nj == tj) {\n found = true;\n break;\n }\n }\n }\n if (!found) break;\n \n // reconstruct\n vector> path_to;\n pair curp = {ti, tj};\n while (curp != make_pair(cur_i, cur_j)) {\n path_to.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_to.begin(), path_to.end());\n \n if (Ltotal + (int)path_to.size() > 100000) break;\n \n for (auto [x, y] : path_to) {\n positions.emplace_back(x, y);\n visits[x][y]++;\n cur_i = x;\n cur_j = y;\n Ltotal++;\n }\n }\n \n // Final return to (0,0)\n {\n int ti = 0, tj = 0;\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == 0 && cur_j == 0);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == 0 && nj == 0) {\n found = true;\n break;\n }\n }\n }\n if (found) {\n vector> path_back;\n pair curp = {0, 0};\n while (curp != make_pair(cur_i, cur_j)) {\n path_back.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_back.begin(), path_back.end());\n for (auto p : path_back) {\n positions.push_back(p);\n visits[p.first][p.second]++;\n cur_i = p.first;\n cur_j = p.second;\n }\n }\n }\n \n // Build ans\n string ans = \"\";\n for (size_t t = 1; t < positions.size(); t++) {\n int i1 = positions[t - 1].first, j1 = positions[t - 1].second;\n int i2 = positions[t].first, j2 = positions[t].second;\n if (i2 == i1 - 1) ans += 'U';\n else if (i2 == i1 + 1) ans += 'D';\n else if (j2 == j1 + 1) ans += 'R';\n else if (j2 == j1 - 1) ans += 'L';\n }\n \n if (ans.size() > 100000) ans = ans.substr(0, 100000);\n cout << ans << endl;\n return 0;\n}","ahc028":"#include \nusing namespace std;\ntypedef long long ll;\nconst ll INF = 1LL << 60;\n\npair>> solve_for_S(const string& S, int si, int sj, const vector>>& posis) {\n int LL = S.length();\n if(LL == 0) return {INF, {}};\n vector>> cnd(LL);\n for(int k = 0; k < LL; k++) {\n cnd[k] = posis[S[k] - 'A'];\n if(cnd[k].empty()) return {INF, {}};\n }\n vector> dpp(LL);\n vector> prvv(LL);\n int n0 = cnd[0].size();\n dpp[0].resize(n0);\n prvv[0].assign(n0, -1);\n for(int j = 0; j < n0; j++) {\n int x = cnd[0][j].first, y = cnd[0][j].second;\n dpp[0][j] = abs(x - si) + abs(y - sj) + 1LL;\n }\n for(int k = 1; k < LL; k++) {\n int np = cnd[k-1].size();\n int nc = cnd[k].size();\n dpp[k].assign(nc, INF);\n prvv[k].assign(nc, -1);\n for(int j = 0; j < nc; j++) {\n int x = cnd[k][j].first, y = cnd[k][j].second;\n for(int p = 0; p < np; p++) {\n int px = cnd[k-1][p].first, py = cnd[k-1][p].second;\n ll cc = dpp[k-1][p] + abs(x - px) + abs(y - py) + 1;\n if(cc < dpp[k][j]) {\n dpp[k][j] = cc;\n prvv[k][j] = p;\n }\n }\n }\n }\n ll minc = INF;\n int bj = -1;\n int nlast = cnd[LL-1].size();\n for(int j = 0; j < nlast; j++) {\n if(dpp[LL-1][j] < minc) {\n minc = dpp[LL-1][j];\n bj = j;\n }\n }\n if(bj == -1) return {INF, {}};\n vector> sq(LL);\n int cj = bj;\n sq[LL-1] = cnd[LL-1][cj];\n for(int k = LL-1; k >= 1; k--) {\n int pj = prvv[k][cj];\n sq[k-1] = cnd[k-1][pj];\n cj = pj;\n }\n return {minc, sq};\n}\n\nint main() {\n srand(time(NULL));\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for(int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for(int i = 0; i < M; i++) cin >> t[i];\n vector>> positions(26);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].emplace_back(i, j);\n }\n ll best_T = INF;\n vector> best_seq;\n for(int start = 0; start < M; start++) {\n for(int tr = 0; tr < 3; tr++) {\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n for(int iter = 0; iter < M; iter++) {\n for(int j = 0; j < M; j++) if(!used[j] && curr.find(t[j]) != string::npos) {\n used[j] = true;\n }\n int remaining = 0;\n for(int j = 0; j < M; j++) if(!used[j]) remaining++;\n if(remaining == 0) break;\n int cur_maxo = -1;\n vector cands_max;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = 0;\n int mp = min(4, (int)curr.size());\n bool matched = false;\n for(int o = mp; o >= 1; o--) {\n if((int)curr.size() >= o && (int)t[j].size() >= o && curr.substr(curr.size() - o, o) == t[j].substr(0, o)) {\n oo = o;\n matched = true;\n break;\n }\n }\n if(!matched) oo = 0;\n if(oo > cur_maxo) {\n cur_maxo = oo;\n cands_max = {j};\n } else if(oo == cur_maxo) {\n cands_max.push_back(j);\n }\n }\n if(cands_max.empty()) break;\n int idx = rand() % cands_max.size();\n int best = cands_max[idx];\n int maxo_val = cur_maxo;\n if(maxo_val >= 0) {\n curr += t[best].substr(maxo_val);\n used[best] = true;\n }\n }\n int rem = 0;\n for(bool b : used) if(!b) rem++;\n if(rem == 0) {\n auto [this_cost, this_seq] = solve_for_S(curr, si, sj, positions);\n if(this_cost < best_T) {\n best_T = this_cost;\n best_seq = this_seq;\n }\n }\n }\n }\n if(best_T == INF) {\n // fallback\n int start = 0;\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n for(int iter = 0; iter < M; iter++) {\n for(int j = 0; j < M; j++) if(!used[j] && curr.find(t[j]) != string::npos) used[j] = true;\n int remaining = 0;\n for(int j = 0; j < M; j++) if(!used[j]) remaining++;\n if(remaining == 0) break;\n int best = -1;\n int maxo = -1;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = 0;\n int mp = min(4, (int)curr.size());\n bool matched = false;\n for(int o = mp; o >= 1; o--) {\n if((int)curr.size() >= o && (int)t[j].size() >= o && curr.substr(curr.size() - o, o) == t[j].substr(0, o)) {\n oo = o;\n matched = true;\n break;\n }\n }\n if(!matched) oo = 0;\n if(oo > maxo) {\n maxo = oo;\n best = j;\n }\n }\n if(best == -1) break;\n curr += t[best].substr(maxo);\n used[best] = true;\n }\n auto [fcost, fseq] = solve_for_S(curr, si, sj, positions);\n if(fcost < INF) {\n best_T = fcost;\n best_seq = fseq;\n } else {\n // worst fallback\n vector> fallback;\n for(int k=0; k<5; k++) {\n fallback.push_back(positions[0][0]);\n }\n best_seq = fallback;\n }\n }\n for(auto& p : best_seq) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n vector>> fields(M);\n for (int i = 0; i < M; i++) {\n int d;\n cin >> d;\n fields[i].resize(d);\n for (int j = 0; j < d; j++) {\n cin >> fields[i][j].first >> fields[i][j].second;\n }\n }\n int D = N * N;\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution dist(0.0, 1.0);\n vector> queries;\n vector measured;\n int ops = 0;\n const int MAX_OPS = 2 * N * N;\n vector est(D, 0.0);\n vector true_v(D, -1);\n vector is_drilled(D, false);\n int INIT_Q = 300;\n for (int q = 0; q < INIT_Q && ops < MAX_OPS - 100; q++) {\n vector S;\n for (int c = 0; c < D; c++) {\n if (dist(rng) < 0.2) S.push_back(c);\n }\n if (S.size() < 2) {\n q--;\n continue;\n }\n cout << \"q \" << S.size();\n for (int c : S) {\n int i = c / N;\n int j = c % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int y;\n cin >> y;\n queries.push_back(S);\n measured.push_back(y);\n ops++;\n }\n int drill_batch = 30;\n double est_thresh = 0.25;\n for (int r = 0; r < 30 && ops < MAX_OPS - 1; r++) {\n vector unknown;\n for (int c = 0; c < D; c++) if (!is_drilled[c]) unknown.push_back(c);\n int U = unknown.size();\n if (U == 0) break;\n int Qs = queries.size();\n MatrixXd A(Qs, U);\n VectorXd bb(Qs);\n for (int qi = 0; qi < Qs; qi++) {\n int k = queries[qi].size();\n double target = (measured[qi] - eps * (double)k) / (1 - eps);\n double known_s = 0.0;\n for (int c : queries[qi]) if (is_drilled[c]) known_s += true_v[c];\n bb(qi) = target - known_s;\n A.row(qi).setZero();\n vector is_in(D, false);\n for (int c : queries[qi]) is_in[c] = true;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (is_in[c]) A(qi, uj) = 1.0;\n }\n }\n VectorXd x(U);\n if (U > 0 && Qs > 0) {\n x = A.bdcSvd(ComputeThinU | ComputeThinV).solve(bb);\n } else {\n x = VectorXd::Zero(U);\n }\n for (int uj = 0; uj < U; uj++) {\n est[unknown[uj]] = max(0.0, x(uj));\n }\n vector> high;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (est[c] > est_thresh) high.emplace_back(est[c], c);\n }\n if (high.empty()) break;\n sort(high.rbegin(), high.rend());\n int num_dr = min((int)high.size(), drill_batch);\n for (int ii = 0; ii < num_dr; ii++) {\n int c = high[ii].second;\n if (is_drilled[c]) continue;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n }\n vector> final_sus;\n for (int c = 0; c < D; c++) if (!is_drilled[c] && est[c] > 0.1) final_sus.emplace_back(est[c], c);\n sort(final_sus.rbegin(), final_sus.rend());\n for (auto& pr : final_sus) {\n if (ops >= MAX_OPS - 1) break;\n int c = pr.second;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n vector> ans;\n for (int c = 0; c < D; c++) if (is_drilled[c] && true_v[c] > 0) {\n ans.emplace_back(c / N, c % N);\n }\n vector>> possible_pos(M);\n for (int m = 0; m < M; m++) {\n int maxx = 0, maxy = 0;\n for (auto& p : fields[m]) {\n maxx = max(maxx, p.first);\n maxy = max(maxy, p.second);\n }\n for (int di = 0; di + maxx < N; di++) {\n for (int dj = 0; dj + maxy < N; dj++) {\n possible_pos[m].emplace_back(di, dj);\n }\n }\n }\n vector> best_place(M);\n vector best_v(D, 0.0);\n double best_err = 1e18;\n for (int start = 0; start < 5; start++) {\n vector> place(M);\n for (int m = 0; m < M; m++) {\n auto& ps = possible_pos[m];\n if (!ps.empty()) place[m] = ps[rng() % ps.size()];\n }\n auto compute_v = [&](const vector>& pl) -> vector {\n vector vv(D, 0.0);\n for (int m = 0; m < M; m++) {\n auto [di, dj] = pl[m];\n for (auto [x, y] : fields[m]) {\n int ii = di + x, jj = dj + y;\n vv[ii * N + jj] += 1;\n }\n }\n return vv;\n };\n vector vv = compute_v(place);\n vector target_v = est;\n for (int c = 0; c < D; c++) if (is_drilled[c]) target_v[c] = true_v[c];\n auto calc_err = [&](const vector& vvv) {\n double e = 0;\n for (int c = 0; c < D; c++) e += abs(vvv[c] - target_v[c]);\n return e;\n };\n double curr_err = calc_err(vv);\n for (int tries = 0; tries < 10000; tries++) {\n int m = rng() % M;\n auto& ps = possible_pos[m];\n if (ps.empty()) continue;\n int idx = rng() % ps.size();\n auto newp = ps[idx];\n if (newp == place[m]) continue;\n vector new_vv(D);\n // delta\n double delta = 0.0;\n double delta_adjust = 0;\n // old subtract\n auto oldp = place[m];\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n int c = ii * N + jj;\n double oldv = vv[c];\n double newvv = oldv - 1;\n delta += abs(newvv - target_v[c]) - abs(oldv - target_v[c]);\n }\n // new add\n for (auto [x, y] : fields[m]) {\n int ii = newp.first + x, jj = newp.second + y;\n int c = ii * N + jj;\n double oldv_for = vv[c];\n double newvv = oldv_for + 1;\n delta += abs(newvv - target_v[c]) - abs(oldv_for - target_v[c]);\n }\n if (delta < -0.001) {\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n vv[ii * N + jj] -= 1;\n int ii2 = newp.first + x, jj2 = newp.second + y;\n vv[ii2 * N + jj2] += 1;\n }\n place[m] = newp;\n curr_err += delta;\n }\n }\n if (curr_err < best_err) {\n best_err = curr_err;\n best_place = place;\n best_v = vv;\n }\n }\n set> union_set;\n for (int m = 0; m < M; m++) {\n auto [di, dj] = best_place[m];\n for (auto [x, y] : fields[m]) {\n union_set.emplace(di + x, dj + y);\n }\n }\n vector> final_ans;\n for (auto p : union_set) final_ans.push_back(p);\n for (auto p : ans) final_ans.push_back(p); // add drilled if any missed\n sort(final_ans.begin(), final_ans.end());\n auto last = unique(final_ans.begin(), final_ans.end());\n final_ans.erase(last, final_ans.end());\n cout << \"a \" << final_ans.size();\n for (auto [i, j] : final_ans) {\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int resp;\n cin >> resp;\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n vector> A(D, vector(N));\n for(int d = 0; d < D; d++) {\n for(int k = 0; k < N; k++) {\n cin >> A[d][k];\n }\n }\n vector prev_div(N + 1, 0);\n int base = W / N;\n for(int i = 1; i < N; i++) {\n prev_div[i] = prev_div[i - 1] + base;\n }\n prev_div[N] = W;\n for(int d = 0; d < D; d++) {\n auto a = A[d];\n vector cur_w(N);\n for(int k = 0; k < N; k++) cur_w[k] = prev_div[k + 1] - prev_div[k];\n vector slot_idx(N);\n iota(slot_idx.begin(), slot_idx.end(), 0);\n sort(slot_idx.begin(), slot_idx.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n vector a_idx(N);\n iota(a_idx.begin(), a_idx.end(), 0);\n sort(a_idx.begin(), a_idx.end(), [&](int x, int y) {\n if(a[x] != a[y]) return a[x] > a[y];\n return x < y;\n });\n vector assigned(N);\n for(int i = 0; i < N; i++) {\n int s = slot_idx[i];\n int ak = a_idx[i];\n assigned[s] = a[ak];\n }\n long long current_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * cur_w[s];\n current_def += max(0LL, assigned[s] - b);\n }\n vector targ_w(N, 0);\n long long sum_need = 0;\n for(int s = 0; s < N; s++) {\n if(assigned[s] == 0) {\n targ_w[s] = 1;\n } else {\n targ_w[s] = ((assigned[s] + 999) / 1000);\n }\n if(targ_w[s] < 1) targ_w[s] = 1;\n sum_need += targ_w[s];\n }\n if(sum_need > W) {\n vector sidx(N);\n iota(sidx.begin(), sidx.end(), 0);\n sort(sidx.begin(), sidx.end(), [&](int x, int y) {\n return assigned[x] < assigned[y] || (assigned[x] == assigned[y] && x < y);\n });\n long long deficit = sum_need - W;\n for(int i : sidx) {\n if(deficit <= 0) break;\n int can = targ_w[i] - 1;\n long long red = min((long long)can, deficit);\n targ_w[i] -= red;\n deficit -= red;\n }\n int ii = 0;\n while(deficit > 0 && ii < N * 100) {\n int idx = sidx[ii % N];\n int can = targ_w[idx] - 1;\n long long red = min((long long)can, deficit);\n targ_w[idx] -= red;\n deficit -= red;\n ii++;\n }\n } else if(sum_need < W) {\n long long extra = W - sum_need;\n int maxs = 0;\n for(int s = 1; s < N; s++) if(assigned[s] > assigned[maxs]) maxs = s;\n targ_w[maxs] += extra;\n }\n vector new_div(N + 1, 0);\n for(int s = 0; s < N; s++) {\n new_div[s + 1] = new_div[s] + targ_w[s];\n }\n new_div[N] = W;\n long long new_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * targ_w[s];\n new_def += max(0LL, assigned[s] - b);\n }\n vector old_has(W + 1, false);\n vector neww_has(W + 1, false);\n for(int k = 1; k < N; k++) {\n if(prev_div[k] > 0 && prev_div[k] < W) old_has[prev_div[k]] = true;\n if(new_div[k] > 0 && new_div[k] < W) neww_has[new_div[k]] = true;\n }\n int sym = 0;\n for(int j = 0; j <= W; j++) {\n if(old_has[j] != neww_has[j]) sym++;\n }\n long long L = (long long)sym * W;\n bool move = (L < 100LL * (current_def - new_def));\n vector> day_rects(N);\n vector used_div = prev_div;\n if(move || d == 0) { // always move for day 0 or if worth\n vector sorted_slot(N);\n iota(sorted_slot.begin(), sorted_slot.end(), 0);\n sort(sorted_slot.begin(), sorted_slot.end(), [&](int x, int y) {\n if(targ_w[x] != targ_w[y]) return targ_w[x] > targ_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_slot[i];\n int k = a_idx[i];\n int j0 = new_div[s];\n int j1 = new_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n used_div = new_div;\n prev_div = new_div;\n } else {\n vector sorted_cur(N);\n iota(sorted_cur.begin(), sorted_cur.end(), 0);\n sort(sorted_cur.begin(), sorted_cur.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_cur[i];\n int k = a_idx[i];\n int j0 = prev_div[s];\n int j1 = prev_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n }\n for(int k = 0; k < N; k++) {\n auto &r = day_rects[k];\n cout << r[0] << \" \" << r[1] << \" \" << r[2] << \" \" << r[3] << endl;\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n vector>> S(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cin >> S[m][i][j];\n const ll MOD = 998244353;\n vector> cur_mod(N, vector(N));\n vector>> op_cnt(M, vector>(N - 2, vector(N - 2, 0)));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_mod[i][j] = A[i][j];\n ll cur_score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_score += cur_mod[i][j];\n int cur_total = 0;\n auto get_add_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) {\n for (int dj = 0; dj < 3; dj++) {\n int i = p + di;\n int j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr + S[m][di][dj] % MOD) % MOD;\n ds += newr - oldr;\n }\n }\n return ds;\n };\n auto get_remove_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr - (S[m][di][dj] % MOD) + MOD) % MOD;\n ds += newr - oldr;\n }\n return ds;\n };\n while (cur_total < K) {\n ll max_ds = -1000000000000000000LL;\n int bm = -1, bp = -1, bq = -1;\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds;\n bm = m; bp = p; bq = q;\n }\n }\n }\n }\n if (max_ds <= 0) break;\n int m = bm, p = bp, q = bq;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m][di][dj] % MOD)) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n }\n vector> greedy_mod = cur_mod;\n vector>> greedy_cnt = op_cnt;\n ll greedy_score = cur_score;\n int greedy_total = cur_total;\n ll overall_best_score = cur_score;\n vector>> overall_best_cnt = op_cnt;\n int MAX_ITER = 500000;\n double T0 = 5000000000.0;\n srand(42);\n auto rand01 = []() { return rand() * 1.0 / RAND_MAX; };\n for (int trial = 0; trial < 3; trial++) {\n cur_mod = greedy_mod;\n op_cnt = greedy_cnt;\n cur_score = greedy_score;\n cur_total = greedy_total;\n if (trial > 0) {\n int npert = 15 + (rand() % 25);\n for (int p = 0; p < npert; p++) {\n if (rand() % 2 && cur_total < K) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n ll dsc = get_add_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][pp][qq]++;\n cur_total++;\n cur_score += dsc;\n } else if (cur_total > 0) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n if (op_cnt[m][pp][qq] > 0) {\n ll dsc = get_remove_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][pp][qq]--;\n cur_total--;\n cur_score += dsc;\n }\n }\n }\n }\n for (int iter = 0; iter < MAX_ITER; iter++) {\n double temp = T0 * pow(0.999955, iter);\n bool did = false;\n int rtyp = rand() % 4;\n if (rtyp == 0 && cur_total < K) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n ll dsc = get_add_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n } else if (rtyp == 1 && cur_total > 0) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n if (op_cnt[m][p][q] > 0) {\n ll dsc = get_remove_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n }\n }\n if (!did) {\n int m1 = rand() % M; int p1 = rand() % (N - 2); int q1 = rand() % (N - 2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N - 2); int q2 = rand() % (N - 2);\n ll dsc = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n ll net = 0;\n int di = i - p1, dj = j - q1;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net -= S[m1][di][dj];\n di = i - p2; dj = j - q2;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net += S[m2][di][dj];\n if (net == 0) continue;\n ll oldr = cur_mod[i][j];\n ll addm = (net % MOD + MOD) % MOD;\n ll newr = (oldr + addm) % MOD;\n dsc += newr - oldr;\n }\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m1][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m2][di][dj] % MOD) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n }\n }\n }\n }\n int L = 0;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) L += overall_best_cnt[m][p][q];\n cout << L << endl;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) {\n for (int t = 0; t < overall_best_cnt[m][p][q]; t++) {\n cout << m << \" \" << p << \" \" << q << endl;\n }\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> 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 int max_turn = 10000;\n vector> grid(N, vector(N, -1));\n vector next_in(N, 0);\n vector pos_r(N), pos_c(N);\n for (int i = 0; i < N; i++) {\n pos_r[i] = i;\n pos_c[i] = 0;\n }\n vector hold(N, -1);\n vector active(N, true);\n vector acts(N, \"\");\n auto find_loc = [&](int b) -> pair {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] == b) return {i, j};\n }\n }\n for (int k = 0; k < N; k++) {\n if (hold[k] == b) return {pos_r[k], pos_c[k]};\n }\n return {-1, -1};\n };\n int total_disp = 0;\n for (int turn = 0; turn < max_turn; turn++) {\n if (total_disp >= N * N) break;\n // incoming\n for (int i = 0; i < N; i++) {\n if (next_in[i] < N && grid[i][0] == -1) {\n bool has_hold = false;\n for (int k = 0; k < N; k++) {\n if (active[k] && pos_r[k] == i && pos_c[k] == 0 && hold[k] != -1) {\n has_hold = true; break;\n }\n }\n if (!has_hold) {\n grid[i][0] = A[i][next_in[i]];\n next_in[i]++;\n }\n }\n }\n // decide actions\n vector act(N, '.');\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n int r = pos_r[c];\n int co = pos_c[c];\n bool is_large = (c == 0);\n bool carrying = (hold[c] != -1);\n if (carrying) {\n int b = hold[c];\n int tr = b / N;\n if (r == tr && co == N - 1) {\n act[c] = 'Q';\n } else if (r == tr && co < N - 1) {\n act[c] = 'R';\n } else if (r != tr) {\n char dir = (r < tr ? 'D' : 'U');\n int nr = r + (r < tr ? 1 : -1);\n if (nr >= 0 && nr < N) {\n bool dest_ok = (grid[nr][co] == -1 || is_large);\n if (dest_ok) act[c] = dir;\n }\n }\n } else {\n if (grid[r][co] != -1) {\n int b = grid[r][co];\n int tr = b / N;\n bool can_pick = is_large || (tr == r);\n if (can_pick) act[c] = 'P';\n } else {\n if (c == 0) {\n // large nearest any container\n int min_d = INT_MAX;\n pair tloc = {-1, -1};\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) if (grid[i][j] != -1) {\n int dist = abs(i - r) + abs(j - co);\n if (dist < min_d) {\n min_d = dist;\n tloc = {i, j};\n }\n }\n for (int k = 0; k < N; k++) if (hold[k] != -1) {\n int dist = abs(pos_r[k] - r) + abs(pos_c[k] - co);\n if (dist < min_d) {\n min_d = dist;\n tloc = {pos_r[k], pos_c[k]};\n }\n }\n if (tloc.first != -1) {\n int br = tloc.first, bc = tloc.second;\n if (br != r) act[c] = (br > r ? 'D' : 'U');\n else if (bc != co) act[c] = (bc > co ? 'R' : 'L');\n } else if (co > 0) act[c] = 'L';\n } else {\n // small : containers in same row\n int min_d = INT_MAX;\n pair tloc = {-1, -1};\n for (int j = 0; j < N; j++) if (grid[r][j] != -1) {\n int dist = abs(j - co);\n if (dist < min_d) {\n min_d = dist;\n tloc = {r, j};\n }\n }\n if (tloc.first != -1) {\n int bc = tloc.second;\n if (bc < co) act[c] = 'L';\n else if (bc > co) act[c] = 'R';\n } else if (co > 0) act[c] = 'L';\n }\n }\n }\n }\n // P/Q tentative\n vector> new_grid = grid;\n vector new_hold = hold;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n int pr = pos_r[c], pc = pos_c[c];\n if (ac == 'P') {\n if (hold[c] != -1 || new_grid[pr][pc] == -1) act[c] = '.';\n else {\n new_hold[c] = new_grid[pr][pc];\n new_grid[pr][pc] = -1;\n }\n } else if (ac == 'Q') {\n if (hold[c] == -1 || new_grid[pr][pc] != -1) act[c] = '.';\n else {\n new_grid[pr][pc] = hold[c];\n new_hold[c] = -1;\n }\n }\n }\n // moves\n vector nr_pos = pos_r, nc_pos = pos_c;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n if (ac != 'U' && ac != 'D' && ac != 'L' && ac != 'R') continue;\n int pr = pos_r[c], pc = pos_c[c];\n int nrr = pr, ncc = pc;\n if (ac == 'U') nrr--;\n if (ac == 'D') nrr++;\n if (ac == 'L') ncc--;\n if (ac == 'R') ncc++;\n if (nrr < 0 || nrr >= N || ncc < 0 || ncc >= N) {\n act[c] = '.'; continue;\n }\n bool car = (new_hold[c] != -1);\n bool is_l = (c == 0);\n bool dhas = (new_grid[nrr][ncc] != -1);\n if (car && !is_l && dhas) {\n act[c] = '.'; continue;\n }\n nr_pos[c] = nrr;\n nc_pos[c] = ncc;\n }\n // coll check\n map, int> cnt;\n for (int c = 0; c < N; c++) {\n if (active[c]) cnt[{nr_pos[c], nc_pos[c]}]++;\n }\n bool cl = false;\n for (auto& p : cnt) if (p.second > 1) cl = true;\n if (cl) {\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c]; nc_pos[c] = pos_c[c];\n }\n }\n }\n // swap check\n cl = false;\n for (int c1 = 0; c1 < N && !cl; c1++) for (int c2 = c1 + 1; c2 < N; c2++) {\n if (active[c1] && active[c2]) {\n if (nr_pos[c1] == pos_r[c2] && nc_pos[c1] == pos_c[c2] && nr_pos[c2] == pos_r[c1] && nc_pos[c2] == pos_c[c1]) cl = true;\n }\n }\n if (cl) {\n for (int c = 0; c < N; c++) {\n if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c]; nc_pos[c] = pos_c[c];\n }\n }\n }\n // update\n pos_r = nr_pos;\n pos_c = nc_pos;\n grid = new_grid;\n hold = new_hold;\n // dispatch\n for (int rr = 0; rr < N; rr++) {\n if (grid[rr][N-1] != -1) {\n grid[rr][N-1] = -1;\n total_disp++;\n }\n }\n // append\n for (int c = 0; c < N; c++) acts[c] += act[c];\n }\n // pad\n int ml = 0;\n for (auto& s : acts) ml = max(ml, (int)s.size());\n for (int i = 0; i < N; i++) {\n while ((int)acts[i].size() < ml) acts[i] += '.';\n if ((int)acts[i].size() > max_turn) acts[i].resize(max_turn);\n }\n for (int i = 0; i < N; i++) cout << acts[i] << endl;\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n int r = 0, c = 0;\n long long load = 0;\n vector ops;\n const int MAXT = 100000;\n auto is_done = [&]() -> bool {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) return false;\n }\n }\n return true;\n };\n auto find_best = [&](bool is_source) -> pair {\n double best_ratio = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n long long val = h[i][j];\n if ((is_source ? val > 0 : val < 0)) {\n int dist = abs(i - r) + abs(j - c);\n long long amnt = is_source ? val : -val;\n double ratio = (double)amnt / (dist + 1.0);\n if (ratio > best_ratio) {\n best_ratio = ratio;\n ti = i;\n tj = j;\n }\n }\n }\n }\n return {ti, tj};\n };\n auto move_path = [&](int tr, int tc) {\n while (r < tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"L\");\n c--;\n }\n };\n while (!is_done() && (int)ops.size() < MAXT - 50) {\n bool did_something = false;\n if (load == 0 && h[r][c] > 0) {\n long long d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[r][c] -= d;\n did_something = true;\n } else if (load > 0 && h[r][c] < 0) {\n long long d = min(load, -h[r][c]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[r][c] += d;\n did_something = true;\n }\n if (did_something) continue;\n bool going_source = (load == 0);\n auto [tr, tc] = find_best(going_source);\n if (tr == -1) {\n break;\n }\n move_path(tr, tc);\n }\n for (auto& s : ops) {\n cout << s << endl;\n }\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(NULL);\n int N, M, T;\n cin >> N >> M >> T;\n int seed_count = 2 * N * (N - 1);\n vector> X(seed_count, vector(M, 0));\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n mt19937 rng(42);\n for (int t = 0; t < T; t++) {\n vector vals(seed_count, 0);\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n vals[i] += X[i][j];\n }\n }\n vector> trait_carriers(M);\n set all_carrier_set;\n vector maxl_per_trait(M, 0);\n vector num_max_traits_per_seed(seed_count, 0);\n for (int l = 0; l < M; l++) {\n int ml = 0;\n for (int i = 0; i < seed_count; i++) ml = max(ml, X[i][l]);\n maxl_per_trait[l] = ml;\n for (int i = 0; i < seed_count; i++) {\n if (X[i][l] == ml) {\n trait_carriers[l].push_back(i);\n all_carrier_set.insert(i);\n num_max_traits_per_seed[i]++;\n }\n }\n }\n vector all_carriers(all_carrier_set.begin(), all_carrier_set.end());\n vector to_plant;\n set selected;\n vector covered(M, false);\n int num_covered = 0;\n while ((int)to_plant.size() < N * N && num_covered < M) {\n int best_score = -1;\n int best_i = -1;\n for (int cand : all_carriers) {\n if (selected.count(cand)) continue;\n int new_cov = 0;\n for (int l = 0; l < M; l++) {\n if (!covered[l] && X[cand][l] == maxl_per_trait[l]) new_cov++;\n }\n int score = new_cov * 100000 + vals[cand] + num_max_traits_per_seed[cand] * 1000;\n if (score > best_score) {\n best_score = score;\n best_i = cand;\n }\n }\n if (best_i == -1) break;\n selected.insert(best_i);\n to_plant.push_back(best_i);\n for (int l = 0; l < M; l++) {\n if (!covered[l] && X[best_i][l] == maxl_per_trait[l]) {\n covered[l] = true;\n num_covered++;\n }\n }\n }\n vector> remain_car;\n for (int i : all_carriers) {\n if (!selected.count(i)) {\n remain_car.emplace_back(vals[i] + num_max_traits_per_seed[i] * 10000, i);\n }\n }\n sort(remain_car.rbegin(), remain_car.rend());\n for (auto& p : remain_car) {\n if ((int)to_plant.size() >= N * N) break;\n to_plant.push_back(p.second);\n selected.insert(p.second);\n }\n vector> non_car;\n for (int i = 0; i < seed_count; i++) {\n if (!selected.count(i)) {\n non_car.emplace_back(vals[i], i);\n }\n }\n sort(non_car.rbegin(), non_car.rend());\n for (auto& p : non_car) {\n if ((int)to_plant.size() >= N * N) break;\n to_plant.push_back(p.second);\n }\n sort(to_plant.begin(), to_plant.end(), [&](int a, int b) {\n return vals[a] + num_max_traits_per_seed[a] * 10000 > vals[b] + num_max_traits_per_seed[b] * 10000 || (vals[a] + num_max_traits_per_seed[a] * 10000 == vals[b] + num_max_traits_per_seed[b] * 10000 && a < b);\n });\n if ((int)to_plant.size() > N * N) to_plant.resize(N * N);\n while ((int)to_plant.size() < N * N) to_plant.push_back(0);\n vector curr_arr(N * N);\n for (int i = 0; i < N * N; i++) curr_arr[i] = to_plant[i];\n auto compute_obj = [&](const vector& arr) -> long long {\n long long obj = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N - 1; j++) {\n int p = arr[i * N + j];\n int q = arr[i * N + j + 1];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n }\n }\n for (int i = 0; i < N - 1; i++) {\n for (int j = 0; j < N; j++) {\n int p = arr[i * N + j];\n int q = arr[(i + 1) * N + j];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n }\n }\n return obj;\n };\n long long curr_obj = compute_obj(curr_arr);\n long long best_obj = curr_obj;\n vector best_arr = curr_arr;\n vector curr_arr_swap = curr_arr;\n double temp = 20000.0;\n for (int iter = 0; iter < 200000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n long long new_obj = compute_obj(curr_arr_swap);\n long long delta = new_obj - curr_obj;\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / temp);\n double r = (rng() % 1000000000LL) / 1000000000.0;\n if (r < prob) accept = true;\n }\n if (accept) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr_swap;\n }\n } else {\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n }\n if (iter % 500 == 0) {\n temp *= 0.9975;\n if (temp < 0.5) temp = 0.5;\n }\n }\n // post SA hill climb greedy swaps\n curr_arr_swap = best_arr;\n curr_obj = best_obj;\n for (int iter = 0; iter < 50000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n long long new_obj = compute_obj(curr_arr_swap);\n if (new_obj > curr_obj) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr_swap;\n }\n } else {\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n }\n }\n vector> A(N, vector(N, 0));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n A[i][j] = best_arr[i * N + j];\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << A[i][j];\n if (j < N - 1) cout << \" \";\n else cout << \"\\n\";\n }\n }\n cout.flush();\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n int N, M, V;\n cin >> N >> M >> V;\n vector S(N), T(N);\n for (auto& str : S) cin >> str;\n for (auto& str : T) cin >> str;\n vector> grid(N, vector(N));\n vector> target(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n grid[i][j] = S[i][j] - '0';\n target[i][j] = T[i][j] - '0';\n }\n }\n vector> supplies, demands;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] && target[i][j] == 0) supplies.emplace_back(i, j);\n if (!grid[i][j] && target[i][j]) demands.emplace_back(i, j);\n }\n }\n if (supplies.size() != demands.size()) {\n // Should be equal, but handle by taking min or something, but assume equal\n }\n int Vp = 2;\n int L = 1;\n cout << Vp << endl;\n for (int u = 1; u < Vp; u++) {\n cout << 0 << \" \" << L << endl;\n }\n int rx = N / 2, ry = N / 2;\n cout << rx << \" \" << ry << endl;\n int cur_dir = 0;\n bool holding = false;\n vector commands;\n int DX[4] = {0, 1, 0, -1};\n int DY[4] = {1, 0, -1, 0};\n int delx[5] = {0, 0, 1, 0, -1};\n int dely[5] = {0, 1, 0, -1, 0};\n char mchar[5] = {'.', 'R', 'D', 'L', 'U'};\n char rchar[3] = {'.', 'L', 'R'};\n auto get_min_approx = [&](int px, int py) -> int {\n int md = 1000000000;\n for (int d = 0; d < 4; d++) {\n int tx = px - DX[d] * L;\n int ty = py - DY[d] * L;\n if (tx >= 0 && tx < N && ty >= 0 && ty < N) {\n md = min(md, abs(rx - tx) + abs(ry - ty));\n }\n }\n return md;\n };\n vector sup_used(supplies.size(), false);\n vector dem_used(demands.size(), false);\n int sup_rem = supplies.size();\n int dem_rem = demands.size();\n auto do_bfs = [&](int sx, int sy) -> vector> {\n vector> targets;\n for (int dd = 0; dd < 4; dd++) {\n int needx = sx - DX[dd] * L;\n int needy = sy - DY[dd] * L;\n if (needx >= 0 && needx < N && needy >= 0 && needy < N) {\n targets.emplace_back(needx, needy, dd);\n }\n }\n if (targets.empty()) return {};\n vector>> dist(N, vector>(N, vector(4, -1)));\n vector>> prev_x(N, vector>(N, vector(4, -1)));\n vector>> prev_y(N, vector>(N, vector(4, -1)));\n vector>> prev_d(N, vector>(N, vector(4, -1)));\n vector>> prev_move(N, vector>(N, vector(4, -1)));\n vector>> prev_rot(N, vector>(N, vector(4, -1)));\n dist[rx][ry][cur_dir] = 0;\n queue> q;\n q.emplace(rx, ry, cur_dir);\n while (!q.empty()) {\n auto [x, y, d] = q.front(); q.pop();\n for (int mid = 0; mid < 5; mid++) {\n int nx = x + delx[mid];\n int ny = y + dely[mid];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n for (int rid = 0; rid < 3; rid++) {\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n int nd = (d + dch) % 4;\n if (dist[nx][ny][nd] == -1) {\n dist[nx][ny][nd] = dist[x][y][d] + 1;\n prev_x[nx][ny][nd] = x;\n prev_y[nx][ny][nd] = y;\n prev_d[nx][ny][nd] = d;\n prev_move[nx][ny][nd] = mid;\n prev_rot[nx][ny][nd] = rid;\n q.emplace(nx, ny, nd);\n }\n }\n }\n }\n int min_d = 1000000000;\n int bx = -1, by = -1, bd = -1;\n for (auto [px, py, pd] : targets) {\n if (dist[px][py][pd] != -1 && dist[px][py][pd] < min_d) {\n min_d = dist[px][py][pd];\n bx = px; by = py; bd = pd;\n }\n }\n if (min_d == 1000000000) return {};\n vector> rev_path;\n int cx = bx, cy = by, cd = bd;\n while (dist[cx][cy][cd] > 0) {\n int mid = prev_move[cx][cy][cd];\n int rid = prev_rot[cx][cy][cd];\n rev_path.emplace_back(mid, rid);\n int px = prev_x[cx][cy][cd];\n int py = prev_y[cx][cy][cd];\n int pd = prev_d[cx][cy][cd];\n cx = px; cy = py; cd = pd;\n }\n reverse(rev_path.begin(), rev_path.end());\n return rev_path;\n };\n while (sup_rem > 0) {\n // Choose best supply if not holding\n int best_sup = -1;\n int minc = 1000000000;\n for (int i = 0; i < (int)supplies.size(); i++) {\n if (!sup_used[i]) {\n auto [px, py] = supplies[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_sup = i;\n }\n }\n }\n if (best_sup == -1) break;\n auto [sx, sy] = supplies[best_sup];\n int cur_fx = rx + DX[cur_dir] * L;\n int cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != sx || cur_fy != sy) {\n auto pth = do_bfs(sx, sy);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[sx][sy] = 0;\n holding = true;\n sup_used[best_sup] = true;\n sup_rem--;\n // Now choose best demand\n int best_dem = -1;\n minc = 1000000000;\n for (int i = 0; i < (int)demands.size(); i++) {\n if (!dem_used[i]) {\n auto [px, py] = demands[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_dem = i;\n }\n }\n }\n if (best_dem == -1) break;\n auto [tx, ty] = demands[best_dem];\n cur_fx = rx + DX[cur_dir] * L;\n cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != tx || cur_fy != ty) {\n auto pth = do_bfs(tx, ty);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[tx][ty] = 1;\n holding = false;\n dem_used[best_dem] = true;\n dem_rem--;\n }\n for (auto& cmd : commands) {\n cout << cmd << endl;\n }\n return 0;\n}","ahc039":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Info {\n ll tot, pre, suf, sub;\n};\n\nInfo comb(const Info& l, const Info& r) {\n Info res;\n res.tot = l.tot + r.tot;\n res.pre = max(l.pre, l.tot + r.pre);\n res.suf = max(r.suf, r.tot + l.suf);\n res.sub = max({l.sub, r.sub, l.suf + r.pre});\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n int N;\n cin >> N;\n vector X(2 * N), Y(2 * N);\n vector ism(2 * N, false);\n for (int i = 0; i < 2 * N; i++) {\n cin >> X[i] >> Y[i];\n if (i < N) ism[i] = true;\n }\n set sx, sy;\n for (int i = 0; i < 2 * N; i++) {\n sx.insert(X[i]);\n sy.insert(Y[i]);\n }\n vector allx(sx.begin(), sx.end());\n vector ally(sy.begin(), sy.end());\n int CX = allx.size();\n int CY = ally.size();\n map xr, yr;\n for (int i = 0; i < CX; i++) xr[allx[i]] = i + 1;\n for (int i = 0; i < CY; i++) yr[ally[i]] = i + 1;\n vector>> col(CX + 1);\n vector>> coly(CY + 1);\n for (int i = 0; i < 2 * N; i++) {\n int rrx = xr[X[i]];\n int rry = yr[Y[i]];\n ll v = ism[i] ? 1LL : -1LL;\n col[rrx].emplace_back(rry, v);\n coly[rry].emplace_back(rrx, v);\n }\n // for x-fixed sweeps (y intervals)\n vector tree(4 * 10005);\n vector cur_ysum(10005, 0);\n auto build_func = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n tree[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n auto upd = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n tree[node].tot += delta;\n tree[node].pre += delta;\n tree[node].suf += delta;\n tree[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n if (CY >= 1) build_func(build_func, 1, 1, CY);\n auto get_kad_y = [&](int& syy, int& eyy) -> ll {\n if (CY < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_ysum[1];\n max_so = meh;\n for (int j = 2; j <= CY; j++) {\n if (cur_ysum[j] > meh + cur_ysum[j]) {\n meh = cur_ysum[j];\n cl = j;\n } else {\n meh += cur_ysum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n syy = bl;\n eyy = br;\n return max_so;\n };\n ll best_val = 0;\n int blx = -1, brx = -1, bly = -1, bry = -1;\n bool best_is_x_sweep = true; // for recording\n int step = 20;\n // sweep x fixed\n {\n vector lsamps;\n for (int i = 1; i <= CX; i += step) lsamps.push_back(i);\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CX; R++) {\n for (auto [yy, vv] : col[R]) {\n upd(upd, 1, 1, CY, yy, vv);\n cur_ysum[yy] += vv;\n hist.emplace_back(yy, vv);\n }\n if ((R - L) % 20 == 0 || R == CX || R == L) {\n Info infoo = (CY >= 1 ? tree[1] : Info{0,0,0,0});\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int syy, eyy;\n ll act = get_kad_y(syy, eyy);\n if (act > best_val && eyy > syy && L < R) {\n int lx_x = allx[L - 1];\n int rx_x = allx[R - 1];\n int ly_y = ally[syy - 1];\n int ry_y = ally[eyy - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = L;\n brx = R;\n bly = syy;\n bry = eyy;\n best_is_x_sweep = true;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [yy, vv] = hist[i];\n upd(upd, 1, 1, CY, yy, -vv);\n cur_ysum[yy] -= vv;\n }\n }\n }\n // reset for y sweep\n for (auto &v : cur_ysum) v = 0;\n fill(tree.begin(), tree.end(), Info{0,0,0,0});\n if (CY >= 1) build_func(build_func, 1, 1, CY);\n // y-fixed sweep (x intervals) \n vector treex(4 * 10005);\n vector cur_xsum(10005, 0);\n auto build_x = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n treex[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n treex[node] = comb(treex[2 * node], treex[2 * node + 1]);\n };\n auto upd_x = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n treex[node].tot += delta;\n treex[node].pre += delta;\n treex[node].suf += delta;\n treex[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n treex[node] = comb(treex[2 * node], treex[2 * node + 1]);\n };\n if (CX >= 1) build_x(build_x, 1, 1, CX);\n auto get_kad_x = [&](int& sxx, int& exx) -> ll {\n if (CX < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_xsum[1];\n max_so = meh;\n for (int j = 2; j <= CX; j++) {\n if (cur_xsum[j] > meh + cur_xsum[j]) {\n meh = cur_xsum[j];\n cl = j;\n } else {\n meh += cur_xsum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n sxx = bl;\n exx = br;\n return max_so;\n };\n // sweep y fixed\n {\n vector lsamps;\n for (int i = 1; i <= CY; i += step) lsamps.push_back(i);\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CY; R++) {\n for (auto [xx, vv] : coly[R]) {\n upd_x(upd_x, 1, 1, CX, xx, vv);\n cur_xsum[xx] += vv;\n hist.emplace_back(xx, vv);\n }\n if ((R - L) % 20 == 0 || R == CY || R == L) {\n Info infoo = (CX >= 1 ? treex[1] : Info{0,0,0,0});\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int sxx, exx;\n ll act = get_kad_x(sxx, exx);\n if (act > best_val && exx > sxx && L < R) {\n int ly_y = ally[L - 1];\n int ry_y = ally[R - 1];\n int lx_x = allx[sxx - 1];\n int rx_x = allx[exx - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = sxx;\n brx = exx;\n bly = L;\n bry = R;\n best_is_x_sweep = false;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [xx, vv] = hist[i];\n upd_x(upd_x, 1, 1, CX, xx, -vv);\n cur_xsum[xx] -= vv;\n }\n }\n }\n if (best_val <= 0 || blx == -1) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n int x1, x2, y1, y2;\n if (best_is_x_sweep) {\n x1 = allx[blx - 1]; x2 = allx[brx - 1];\n y1 = ally[bly - 1]; y2 = ally[bry - 1];\n } else {\n x1 = allx[blx - 1]; x2 = allx[brx - 1];\n y1 = ally[bly - 1]; y2 = ally[bry - 1];\n }\n if (x1 == x2 || y1 == y2) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y2 << \"\\n\";\n cout << x1 << \" \" << y2 << \"\\n\";\n }\n }\n}","ahc040":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Strat {\n double wa, wb;\n bool use_area;\n};\n\nint main() {\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector W(N), H(N);\n for (int i = 0; i < N; i++) {\n cin >> W[i] >> H[i];\n }\n vector strats = {\n {1.0, 1.0, false},\n {2.0, 1.0, false},\n {1.0, 2.0, false},\n {3.0, 1.0, false},\n {1.0, 3.0, false},\n {5.0, 1.0, false},\n {1.0, 5.0, false},\n {10.0, 1.0, false},\n {1.0, 10.0, false},\n {0.0, 0.0, true}\n };\n mt19937 rng(12345);\n int ns = strats.size();\n vector best_rot(N, 0), best_dir(N, 0), best_bref(N, -1);\n ll best_meas = 4e18;\n for (int t = 0; t < T; t++) {\n vector rotv(N), dirv(N), bref(N);\n bool do_random = (t % 7 == 0);\n bool do_perturb = (!do_random && t % 5 == 1 && best_meas < 4e18 && t > 10);\n if (do_random) {\n for (int i = 0; i < N; i++) {\n rotv[i] = rng() % 2;\n dirv[i] = rng() % 2;\n bref[i] = (i > 0 ? (rng() % i) : -1);\n }\n } else if (do_perturb) {\n rotv = best_rot;\n dirv = best_dir;\n bref = best_bref;\n int num_perturb = max(1, N / 5);\n for (int k = 0; k < num_perturb; k++) {\n int pos = rng() % N;\n if (rng() % 2 == 0) rotv[pos] = 1 - rotv[pos];\n if (rng() % 2 == 0) dirv[pos] = 1 - dirv[pos];\n if (pos > 0) {\n if (rng() % 3 == 0) {\n int delta = (rng() % 5 - 2);\n bref[pos] = max(-1, min(pos - 1, bref[pos] + delta));\n } else if (rng() % 3 == 1) {\n bref[pos] = rng() % pos;\n }\n }\n }\n } else {\n Strat st = strats[t % ns];\n vector px(N, 0), py(N, 0), pww(N, 0), phh(N, 0);\n ll cmaxw = 0, cmaxh = 0;\n for (int i = 0; i < N; i++) {\n double bestc = 1e30;\n int br = -1, bd = -1, bb = -1;\n ll bx = 0, by = 0, bww = 0, bhh = 0;\n vector bs_vec;\n for (int b = -1; b < i; b++) bs_vec.push_back(b);\n for (int r = 0; r < 2; r++) {\n ll ww = r ? H[i] : W[i];\n ll hh = r ? W[i] : H[i];\n for (int dd = 0; dd < 2; dd++) {\n for (int b : bs_vec) {\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n ll y1 = yy, y2 = yy + hh;\n ll yj1 = py[j], yj2 = py[j] + phh[j];\n if (max(y1, yj1) < min(y2, yj2)) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n ll x1 = xx, x2 = xx + ww;\n ll xj1 = px[j], xj2 = px[j] + pww[j];\n if (max(x1, xj1) < min(x2, xj2)) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n ll nw = max(cmaxw, xx + ww);\n ll nh = max(cmaxh, yy + hh);\n double cost;\n if (st.use_area) {\n cost = 1.0 * nw * nh;\n } else {\n cost = st.wa * nw + st.wb * nh;\n }\n // add small noise for variety\n cost += (rng() % 1001 - 500) * 1e-5;\n if (cost < bestc) {\n bestc = cost;\n br = r;\n bd = dd;\n bb = b;\n bx = xx;\n by = yy;\n bww = ww;\n bhh = hh;\n }\n }\n }\n }\n rotv[i] = br;\n dirv[i] = bd;\n bref[i] = bb;\n px[i] = bx;\n py[i] = by;\n pww[i] = bww;\n phh[i] = bhh;\n cmaxw = max(cmaxw, bx + bww);\n cmaxh = max(cmaxh, by + bhh);\n }\n }\n cout << N << endl;\n for (int i = 0; i < N; i++) {\n cout << i << \" \" << rotv[i] << \" \" << (dirv[i] ? \"U\" : \"L\") << \" \" << bref[i] << endl;\n }\n cout.flush();\n ll wp, hp;\n cin >> wp >> hp;\n ll meas = wp + hp;\n if (meas + 3LL * sigma < best_meas) {\n best_meas = meas;\n best_rot = rotv;\n best_dir = dirv;\n best_bref = bref;\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n vector X(N), Y(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i];\n }\n long long best_score = -1;\n vector best_p(N, -1);\n // Mode 0: prefer high promotion\n for (int mode = 0; mode < 3; mode++) {\n vector level(N, 0);\n vector p(N, -1);\n long long score = 0;\n if (mode < 2) {\n bool prefer_high = (mode == 0);\n bool changed = true;\n int max_iter = N * H + 100;\n int iter = 0;\n while (changed && iter++ < max_iter) {\n changed = false;\n long long best_a = prefer_high ? -1 : LLONG_MAX;\n int best_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] < H) {\n bool can = false;\n for (int u : adj[v]) {\n if (level[u] == level[v]) {\n can = true;\n break;\n }\n }\n if (can) {\n if (prefer_high) {\n if (A[v] > best_a) {\n best_a = A[v];\n best_v = v;\n }\n } else {\n if (A[v] < best_a) {\n best_a = A[v];\n best_v = v;\n }\n }\n }\n }\n }\n if (best_v != -1) {\n level[best_v]++;\n changed = true;\n }\n }\n iter = 0;\n while (iter++ < max_iter) {\n long long worst_a = LLONG_MAX;\n int worst_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] > 0) {\n bool has = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n has = true;\n break;\n }\n }\n if (!has && A[v] < worst_a) {\n worst_a = A[v];\n worst_v = v;\n }\n }\n }\n if (worst_v != -1) {\n level[worst_v]--;\n } else {\n break;\n }\n }\n bool valid = true;\n for (int v = 0; v < N; v++) {\n if (level[v] == 0) {\n p[v] = -1;\n } else {\n bool found = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n p[v] = u;\n found = true;\n break;\n }\n }\n if (!found) valid = false;\n }\n }\n if (!valid) continue;\n score = 0;\n for (int v = 0; v < N; v++) {\n score += level[v] * A[v];\n }\n } else {\n // Mode 2: greedy attach low A first max depth\n vector depth(N, -1);\n p.assign(N, -1);\n vector> order(N);\n for (int i = 0; i < N; i++) order[i] = {A[i], i};\n sort(order.begin(), order.end());\n for (auto& pr : order) {\n int v = pr.second;\n int max_par_d = -1;\n int best_par = -1;\n for (int u : adj[v]) {\n if (depth[u] != -1 && depth[u] < H) {\n if (depth[u] > max_par_d) {\n max_par_d = depth[u];\n best_par = u;\n }\n }\n }\n if (max_par_d != -1) {\n depth[v] = max_par_d + 1;\n p[v] = best_par;\n } else {\n depth[v] = 0;\n p[v] = -1;\n }\n }\n score = 0;\n bool valid = true;\n for (int v = 0; v < N; v++) {\n if (depth[v] == -1) valid = false;\n else score += depth[v] * A[v];\n }\n if (!valid) continue;\n level = depth; // for consistency, but not needed\n }\n if (score > best_score) {\n best_score = score;\n best_p = p;\n }\n }\n if (best_score == -1) {\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << -1;\n }\n cout << endl;\n } else {\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << best_p[i];\n }\n cout << endl;\n }\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint NN;\nvector board;\nvector> moves;\n\nvoid do_shift(char d, int p) {\n if (d == 'L') {\n for (int j = 0; j < NN - 1; j++) board[p][j] = board[p][j + 1];\n board[p][NN - 1] = '.';\n } else if (d == 'R') {\n for (int j = NN - 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 < NN - 1; i++) board[i][p] = board[i + 1][p];\n board[NN - 1][p] = '.';\n } else if (d == 'D') {\n for (int i = NN - 1; i > 0; i--) board[i][p] = board[i - 1][p];\n board[0][p] = '.';\n }\n}\n\nint main() {\n int N;\n cin >> N;\n NN = N;\n board.resize(N);\n for (int i = 0; i < N; i++) cin >> board[i];\n int iter = 0;\n while (true) {\n int numx = 0;\n for (auto& s : board) for (char c : s) if (c == 'x') numx++;\n if (numx == 0) break;\n if (++iter > 10000) break;\n double best_r = -1;\n char best_d = ' ';\n int best_p = -1;\n int best_k = 0;\n int best_n = 0;\n int best_c = 100000;\n auto update = [&](double rt, char dd, int pp, int kk, int nm, int cc) {\n bool better = false;\n if (rt > best_r + 1e-9) better = true;\n else if (abs(rt - best_r) < 1e-9) {\n if (cc < best_c) better = true;\n else if (cc == best_c && nm > best_n) better = true;\n }\n if (better) {\n best_r = rt;\n best_d = dd;\n best_p = pp;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n };\n // rows left\n for (int i = 0; i < N; i++) {\n int maxj = -1, nm = 0;\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxj = j; nm++; }\n }\n if (nm > 0) {\n int kk = maxj + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'L', i, kk, nm, cc);\n }\n }\n // rows right\n for (int i = 0; i < N; i++) {\n int lmost = N;\n for (int j = N - 1; j >= 0; j--) {\n if (board[i][j] == 'o') { lmost = j + 1; break; }\n }\n int minj = N, nm = 0;\n for (int j = lmost; j < N; j++) {\n if (board[i][j] == 'x') { minj = min(minj, j); nm++; }\n }\n if (nm > 0) {\n int kk = N - minj;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'R', i, kk, nm, cc);\n }\n }\n // cols up\n for (int j = 0; j < N; j++) {\n int maxi = -1, nm = 0;\n for (int i = 0; i < N; i++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxi = i; nm++; }\n }\n if (nm > 0) {\n int kk = maxi + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'U', j, kk, nm, cc);\n }\n }\n // cols down\n for (int j = 0; j < N; j++) {\n int lmost = N;\n for (int i = N - 1; i >= 0; i--) {\n if (board[i][j] == 'o') { lmost = i + 1; break; }\n }\n int mini = N, nm = 0;\n for (int i = lmost; i < N; i++) {\n if (board[i][j] == 'x') { mini = min(mini, i); nm++; }\n }\n if (nm > 0) {\n int kk = N - mini;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n update(rt, 'D', j, kk, nm, cc);\n }\n }\n if (best_p == -1) break;\n char dd = best_d;\n int p = best_p;\n int kk = best_k;\n char op = (dd == 'L' ? 'R' : (dd == 'R' ? 'L' : (dd == 'U' ? 'D' : 'U')));\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(dd, p);\n do_shift(dd, p);\n }\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(op, p);\n do_shift(op, p);\n }\n }\n for (auto [d, pp] : moves) {\n cout << d << \" \" << pp << endl;\n }\n}","ahc044":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, L;\n cin >> N >> L;\n static int T[100];\n for(int i = 0; i < N; i++) cin >> T[i];\n static ll pref[101];\n pref[0] = 0;\n for(int j = 0; j < N; j++) {\n pref[j + 1] = pref[j] + T[j] + 1;\n }\n ll total = pref[N];\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n auto get_sample = [&](ll p[], ll tot) -> int {\n ll r = uniform_int_distribution(0, tot - 1)(rng);\n int low = 0, high = N;\n while(low < high) {\n int mid = (low + high) / 2;\n if(p[mid] > r) high = mid;\n else low = mid + 1;\n }\n return low - 1;\n };\n static int best_a[100], best_b[100], best_cnt[100];\n static int tmp_a[100], tmp_b[100], tmp_cnt[100];\n static ll def_pref[101];\n auto do_sim = [&](int A[], int B[], int* cnt) -> int {\n memset(cnt, 0, sizeof(int) * N);\n int cur = 0;\n for(int w = 1; w <= L; w++) {\n cnt[cur]++;\n if(w < L) {\n if(cnt[cur] % 2 == 1) cur = A[cur];\n else cur = B[cur];\n }\n }\n int err = 0;\n for(int i = 0; i < N; i++) {\n err += abs(cnt[i] - T[i]);\n }\n return err;\n };\n const int NUM_RANDOM = 50;\n int best_err = INT_MAX;\n for(int tr = 0; tr < NUM_RANDOM; tr++) {\n for(int i = 0; i < N; i++) {\n tmp_a[i] = get_sample(pref, total);\n tmp_b[i] = get_sample(pref, total);\n }\n int err = do_sim(tmp_a, tmp_b, tmp_cnt);\n if(err < best_err) {\n best_err = err;\n memcpy(best_a, tmp_a, sizeof(int)*N);\n memcpy(best_b, tmp_b, sizeof(int)*N);\n memcpy(best_cnt, tmp_cnt, sizeof(int)*N);\n }\n }\n const int NUM_MUT = 350;\n for(int m = 0; m < NUM_MUT; m++) {\n memcpy(tmp_a, best_a, sizeof(int)*N);\n memcpy(tmp_b, best_b, sizeof(int)*N);\n def_pref[0] = 0;\n for(int j = 0; j < N; j++) {\n int def = max(0, T[j] - best_cnt[j]);\n def_pref[j + 1] = def_pref[j] + (def + 1LL);\n }\n ll def_tot = def_pref[N];\n int i = uniform_int_distribution(0, N - 1)(rng);\n int choice = uniform_int_distribution(0, 1)(rng);\n int news = get_sample(def_pref, def_tot);\n if(choice == 0) tmp_a[i] = news;\n else tmp_b[i] = news;\n int new_err = do_sim(tmp_a, tmp_b, tmp_cnt);\n if(new_err < best_err) {\n best_err = new_err;\n memcpy(best_a, tmp_a, sizeof(int)*N);\n memcpy(best_b, tmp_b, sizeof(int)*N);\n memcpy(best_cnt, tmp_cnt, sizeof(int)*N);\n }\n }\n for(int i = 0; i < N; i++) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n double d;\n};\n\nint main() {\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int &g : G) cin >> g;\n vector cx(N), cy(N);\n vector Lx(N), Rx(N), Ly(N), Ry(N);\n for (int i = 0; i < N; i++) {\n cin >> Lx[i] >> Rx[i] >> Ly[i] >> Ry[i];\n cx[i] = (Lx[i] + Rx[i]) / 2.0;\n cy[i] = (Ly[i] + Ry[i]) / 2.0;\n }\n vector alledges;\n for (int i = 0; i < N; i++) {\n for (int j = i + 1; j < N; j++) {\n double d = hypot(cx[i] - cx[j], cy[i] - cy[j]);\n alledges.push_back({i, j, d});\n }\n }\n sort(alledges.begin(), alledges.end(), [](const Edge &a, const Edge &b) {\n return a.d < b.d;\n });\n vector par_mst(N);\n iota(par_mst.begin(), par_mst.end(), 0);\n function find_mst = [&](int x) -> int {\n return par_mst[x] == x ? x : par_mst[x] = find_mst(par_mst[x]);\n };\n vector> adj(N);\n for (auto &e : alledges) {\n int pu = find_mst(e.u), pv = find_mst(e.v);\n if (pu != pv) {\n par_mst[pu] = pv;\n adj[e.u].push_back(e.v);\n adj[e.v].push_back(e.u);\n }\n }\n vector order;\n vector vis(N, false);\n function dfs = [&](int u, int p) {\n vis[u] = true;\n order.push_back(u);\n for (int v : adj[u]) {\n if (!vis[v] && v != p) {\n dfs(v, u);\n }\n }\n };\n dfs(0, -1);\n if (order.size() < (size_t)N) {\n for (int i = 0; i < N; i++) if (!vis[i]) dfs(i, -1);\n }\n vector> groups(M);\n int idx = 0;\n for (int k = 0; k < M; k++) {\n groups[k].resize(G[k]);\n for (int j = 0; j < G[k]; j++) {\n groups[k][j] = order[idx++];\n }\n }\n int queries_used = 0;\n vector>> collected_edges(M);\n int adv_base = max(1, min(L - 1, N / max(1, Q)));\n // First, query all small groups\n for (int k = 0; k < M && queries_used < Q; k++) {\n vector &grp = groups[k];\n int gs = grp.size();\n if (gs >= 2 && gs <= L) {\n set> kn;\n vector> &coll = collected_edges[k];\n cout << \"? \" << gs;\n for (int p : grp) cout << \" \" << p;\n cout << endl;\n vector> resp(gs - 1);\n for (int r = 0; r < gs - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (kn.find(p) == kn.end()) {\n kn.insert(p);\n coll.push_back(p);\n }\n }\n queries_used++;\n }\n }\n // Now handle groups not yet fully queried\n for (int k = 0; k < M && queries_used < Q; k++) {\n vector &grp = groups[k];\n int gs = grp.size();\n if (gs <= 1) continue;\n if (gs <= L && !collected_edges[k].empty()) continue;\n set> kn;\n vector> &coll = collected_edges[k];\n for (auto pp : coll) kn.insert(pp);\n int i = 0;\n int adv = max(1, adv_base);\n if (gs <= L) {\n adv = gs;\n }\n while (i < gs - 1 && queries_used < Q) {\n int len = min(L, gs - i);\n if (len < 2) break;\n cout << \"? \" << len;\n for (int p = i; p < i + len; p++) cout << \" \" << grp[p];\n cout << endl;\n vector> resp(len - 1);\n for (int r = 0; r < len - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (kn.find(p) == kn.end()) {\n kn.insert(p);\n coll.push_back(p);\n }\n }\n queries_used++;\n if (i + len >= gs) break;\n int this_adv = (gs > L ? max(1, adv) : gs);\n i += this_adv;\n }\n }\n cout << \"!\" << endl;\n for (int k = 0; k < M; k++) {\n vector grp = groups[k];\n int gs = grp.size();\n for (int j = 0; j < gs; j++) {\n cout << grp[j];\n if (j < gs - 1) cout << \" \";\n else cout << endl;\n }\n if (gs <= 1) continue;\n set> knownp;\n vector> &coll = collected_edges[k];\n for (auto p : coll) {\n int a = p.first, b = p.second;\n if (a > b) swap(a, b);\n knownp.insert({a, b});\n }\n vector> known_list;\n vector local_id(N, -1);\n for (int j = 0; j < gs; j++) local_id[grp[j]] = j;\n for (auto &pr : knownp) {\n int a = pr.first, b = pr.second;\n int ia = local_id[a], ib = local_id[b];\n if (ia == -1 || ib == -1) continue;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n known_list.emplace_back(d, ia, ib);\n }\n sort(known_list.begin(), known_list.end());\n vector parent(gs);\n iota(parent.begin(), parent.end(), 0);\n auto find = [&](auto &self, int x) -> int {\n return parent[x] == x ? x : parent[x] = self(self, parent[x]);\n };\n auto unite = [&](int x, int y) -> bool {\n x = find(find, x); y = find(find, y);\n if (x != y) { parent[x] = y; return true; }\n return false;\n };\n vector> mst_roads;\n int edges_added = 0;\n for (auto &[d, ia, ib] : known_list) {\n if (unite(ia, ib)) {\n mst_roads.emplace_back(grp[ia], grp[ib]);\n edges_added++;\n }\n if (edges_added == gs - 1) break;\n }\n if (edges_added < gs - 1) {\n vector> unk;\n for (int ii = 0; ii < gs; ii++) {\n for (int jj = ii + 1; jj < gs; jj++) {\n int a = grp[ii], b = grp[jj];\n pair p = {min(a, b), max(a, b)};\n if (knownp.find(p) != knownp.end()) continue;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n unk.emplace_back(d, ii, jj);\n }\n }\n sort(unk.begin(), unk.end());\n for (auto &[d, ia, ib] : unk) {\n if (unite(ia, ib)) {\n mst_roads.emplace_back(grp[ia], grp[ib]);\n edges_added++;\n }\n if (edges_added == gs - 1) break;\n }\n }\n for (auto &rd : mst_roads) {\n cout << rd.first << \" \" << rd.second << endl;\n }\n }\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> points(M);\n for (int m = 0; m < M; m++) {\n cin >> points[m].first >> points[m].second;\n }\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n pair current = points[0];\n vector> seq;\n for (int k = 1; k < M; k++) {\n pair goal = points[k];\n set> forbidden;\n for (int t = k + 1; t < M; t++) {\n forbidden.insert(points[t]);\n }\n vector> dist(N, vector(N, -1));\n vector>> prevpos(N, vector>(N, {-1, -1}));\n vector>> prevact(N, vector>(N, {' ', ' '}));\n queue> q;\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n // M actions\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n // S actions\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Fallback: no forbidden, allow all\n forbidden.clear();\n dist.assign(N, vector(N, -1));\n prevpos.assign(N, vector>(N, {-1, -1}));\n prevact.assign(N, vector>(N, {' ', ' '}));\n q = queue>();\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Still unreachable, fallback to pure M manhattan path, allowing everything\n // Compute simple horiz then vert M path\n vector> path;\n int ci = current.first, cj = current.second;\n int gi = goal.first, gj = goal.second;\n int stepi, stepj;\n stepi = (gi > ci ? 1 : (gi < ci ? -1 : 0));\n for (int s = 0; s < abs(gi - ci); s++) {\n path.push_back({'M', (stepi > 0 ? 'D' : 'U')});\n }\n stepj = (gj > cj ? 1 : (gj < cj ? -1 : 0));\n for (int s = 0; s < abs(gj - cj); s++) {\n path.push_back({'M', (stepj > 0 ? 'R' : 'L')});\n }\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n continue;\n }\n // Reconstruct path\n vector> path;\n pair pos = goal;\n while (pos != current) {\n pair act = prevact[pos.first][pos.second];\n path.push_back(act);\n pos = prevpos[pos.first][pos.second];\n }\n reverse(path.begin(), path.end());\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n }\n for (auto& p : seq) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}"},"8":{"ahc001":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Rect {\n int x1, y1, x2, y2;\n};\n\nint N;\nvector X, Y, R;\nvector best_rects;\ndouble best_score = -1.0;\n\ndouble compute_score(const vector& recs) {\n double tot = 0.0;\n for (int i = 0; i < N; i++) {\n ll a = recs[i].x1, b = recs[i].y1, c = recs[i].x2, d = recs[i].y2;\n ll s = (c - a) * 1LL * (d - b);\n ll rr = R[i];\n if (s == 0 || rr == 0) continue;\n double ratio = min(s, rr) * 1.0 / max(s, rr);\n tot += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return tot;\n}\n\nvoid solve_rects(int lx, int ly, int rx, int ry, vector ps, vector& recs) {\n if (ps.size() == 0) return;\n if (ps.size() == 1) {\n recs[ps[0]] = {lx, ly, rx, ry};\n return;\n }\n ll area = (rx - lx) * 1LL * (ry - ly);\n double best_mis = 1e30;\n int best_d = -1, best_kk = -1, best_ct = -1;\n for (int dir = 0; dir < 2; dir++) {\n vector idx = ps;\n if (dir == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int m = idx.size();\n vector pref(m + 1, 0);\n for (int j = 1; j <= m; j++) {\n pref[j] = pref[j - 1] + R[idx[j - 1]];\n }\n ll tot = pref[m];\n if (tot == 0) continue;\n for (int k = 1; k < m; k++) {\n ll sleft = pref[k];\n int idl = idx[k - 1], idr = idx[k];\n ll min_c, max_c;\n if (dir == 0) {\n min_c = X[idl] + 1;\n max_c = X[idr];\n } else {\n min_c = Y[idl] + 1;\n max_c = Y[idr];\n }\n ll low = dir == 0 ? lx + 1 : ly + 1;\n ll high = dir == 0 ? rx - 1 : ry - 1;\n min_c = max(min_c, low);\n max_c = min(max_c, high);\n if (min_c > max_c) continue;\n double target_a = sleft * 1.0 / tot * area;\n ll target_cut;\n if (dir == 0) {\n ll hgt = ry - ly;\n if (hgt <= 0) continue;\n ll dw = (ll)round(target_a / hgt);\n target_cut = lx + dw;\n } else {\n ll wid = rx - lx;\n if (wid <= 0) continue;\n ll dh = (ll)round(target_a / wid);\n target_cut = ly + dh;\n }\n ll cutt = max(min_c, min(max_c, target_cut));\n ll act_area = 0;\n if (dir == 0) {\n act_area = (cutt - lx) * 1LL * (ry - ly);\n } else {\n act_area = (rx - lx) * 1LL * (cutt - ly);\n }\n double mis = fabs(act_area - target_a);\n double pert = (rand() % 1000000) * 1e-9;\n double perturbed = mis + pert;\n if (perturbed < best_mis) {\n best_mis = perturbed;\n best_d = dir;\n best_kk = k;\n best_ct = (int)cutt;\n }\n }\n }\n if (best_d == -1) {\n bool found = false;\n int dir_try = (rx - lx > 1 ? 0 : 1);\n for (int tries = 0; tries < 2 && !found; tries++) {\n int dirr = dir_try;\n vector idxx = ps;\n if (dirr == 0) {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int mm = idxx.size();\n for (int kk = 1; kk < mm; kk++) {\n int idl = idxx[kk - 1], idr = idxx[kk];\n ll minc_ = dirr == 0 ? X[idl] + 1 : Y[idl] + 1;\n ll maxc_ = dirr == 0 ? X[idr] : Y[idr];\n ll loww = dirr == 0 ? lx + 1 : ly + 1;\n ll highh = dirr == 0 ? rx - 1 : ry - 1;\n if (minc_ <= maxc_ && minc_ <= highh && maxc_ >= loww) {\n best_d = dirr;\n best_kk = kk;\n ll midv = (max(minc_, loww) + min(maxc_, highh)) / 2;\n best_ct = (int)midv;\n found = true;\n break;\n }\n }\n dir_try = 1 - dir_try;\n }\n if (!found) {\n best_d = 0;\n best_kk = ps.size() / 2;\n best_ct = lx + (rx - lx) / 2;\n if (best_ct < lx + 1) best_ct = lx + 1;\n if (best_ct > rx - 1) best_ct = rx - 1;\n }\n }\n vector idx = ps;\n if (best_d == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n vector left_ps(idx.begin(), idx.begin() + best_kk);\n vector right_ps(idx.begin() + best_kk, idx.end());\n if (best_d == 0) {\n solve_rects(lx, ly, best_ct, ry, left_ps, recs);\n solve_rects(best_ct, ly, rx, ry, right_ps, recs);\n } else {\n solve_rects(lx, ly, rx, best_ct, left_ps, recs);\n solve_rects(lx, best_ct, rx, ry, right_ps, recs);\n }\n}\n\nvoid optimize(vector& recs) {\n int max_passes = 100;\n for (int pass = 0; pass < max_passes; pass++) {\n vector> candidates;\n for (int i = 0; i < N; i++) {\n Rect &rct = recs[i];\n ll s = (rct.x2 - rct.x1) * 1LL * (rct.y2 - rct.y1);\n ll rr = R[i];\n ll diff = abs(s - rr);\n if (diff > 0) candidates.emplace_back(diff, i);\n }\n if (candidates.empty()) break;\n sort(candidates.rbegin(), candidates.rend());\n bool changed = false;\n for (auto& p : candidates) {\n int i = p.second;\n ll rr = R[i];\n Rect &rct = recs[i];\n ll cur_a = rct.x1;\n ll cur_b = rct.y1;\n ll cur_c = rct.x2;\n ll cur_d = rct.y2;\n ll s = (cur_c - cur_a) * 1LL * (cur_d - cur_b);\n if (s == rr) continue;\n bool is_expand = s < rr;\n ll target_s = rr;\n vector ddirs = {0,1,2,3};\n random_shuffle(ddirs.begin(), ddirs.end());\n bool moved = false;\n for (int dd : ddirs) {\n ll dim = 0;\n ll max_delta = 0;\n if (dd == 0) {\n dim = cur_d - cur_b;\n if (dim <= 0) continue;\n if (is_expand) {\n ll max_pos = 10000;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_b, (ll)oj.y1), ov2 = min(cur_d, (ll)oj.y2);\n if (ov1 < ov2) max_pos = min(max_pos, (ll)oj.x1);\n }\n max_delta = max_pos - cur_c;\n } else {\n ll min_pos = max(cur_a + 1, X[i] + 1);\n max_delta = cur_c - min_pos;\n }\n } else if (dd == 1) {\n dim = cur_d - cur_b;\n if (dim <= 0) continue;\n if (is_expand) {\n ll min_pos = 0;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_b, (ll)oj.y1), ov2 = min(cur_d, (ll)oj.y2);\n if (ov1 < ov2) min_pos = max(min_pos, (ll)oj.x2);\n }\n max_delta = cur_a - min_pos;\n } else {\n ll max_pos = min(cur_c - 1, X[i]);\n max_delta = max_pos - cur_a;\n }\n } else if (dd == 2) {\n dim = cur_c - cur_a;\n if (dim <= 0) continue;\n if (is_expand) {\n ll max_pos = 10000;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_a, (ll)oj.x1), ov2 = min(cur_c, (ll)oj.x2);\n if (ov1 < ov2) max_pos = min(max_pos, (ll)oj.y1);\n }\n max_delta = max_pos - cur_d;\n } else {\n ll min_pos = max(cur_b + 1, Y[i] + 1);\n max_delta = cur_d - min_pos;\n }\n } else if (dd == 3) {\n dim = cur_c - cur_a;\n if (dim <= 0) continue;\n if (is_expand) {\n ll min_pos = 0;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_a, (ll)oj.x1), ov2 = min(cur_c, (ll)oj.x2);\n if (ov1 < ov2) min_pos = max(min_pos, (ll)oj.y2);\n }\n max_delta = cur_b - min_pos;\n } else {\n ll max_pos = min(cur_d - 1, Y[i]);\n max_delta = max_pos - cur_b;\n }\n }\n if (max_delta <= 0) continue;\n ll need = abs(target_s - s);\n ll delta_need = (need + dim - 1LL) / dim;\n ll actual = min(max_delta, delta_need);\n if (actual > 0) {\n if (is_expand) {\n if (dd == 0) rct.x2 += actual;\n else if (dd == 1) rct.x1 -= actual;\n else if (dd == 2) rct.y2 += actual;\n else if (dd == 3) rct.y1 -= actual;\n } else {\n if (dd == 0) rct.x2 -= actual;\n else if (dd == 1) rct.x1 += actual;\n else if (dd == 2) rct.y2 -= actual;\n else if (dd == 3) rct.y1 += actual;\n }\n moved = true;\n changed = true;\n break;\n }\n }\n }\n if (!changed) break;\n }\n}\n\nint main() {\n srand((unsigned)time(NULL));\n cin >> N;\n X.resize(N);\n Y.resize(N);\n R.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n best_score = -1.0;\n const int trials = 50;\n for (int t = 0; t < trials; t++) {\n vector recs(N);\n vector ps(N);\n iota(ps.begin(), ps.end(), 0);\n solve_rects(0, 0, 10000, 10000, ps, recs);\n optimize(recs);\n double sc = compute_score(recs);\n if (sc > best_score) {\n best_score = sc;\n best_rects = recs;\n }\n }\n for (int i = 0; i < N; i++) {\n cout << best_rects[i].x1 << \" \" << best_rects[i].y1 << \" \" << best_rects[i].x2 << \" \" << best_rects[i].y2 << endl;\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct State {\n int ci, cj;\n ll score;\n string pth;\n bitset<2500> vis;\n};\n\nint main() {\n int si, sj;\n cin >> si >> sj;\n int T[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> T[i][j];\n int P[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> P[i][j];\n pair sib[50][50];\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) sib[i][j] = {-1,-1};\n int maxt = 0;\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) maxt = max(maxt, T[i][j]);\n vector>> tilec(maxt+1);\n for(int i=0;i<50;i++)for(int j=0;j<50;j++){\n tilec[T[i][j]].emplace_back(i,j);\n }\n for(auto& v: tilec){\n if(v.size()==2){\n auto [x1,y1]=v[0]; auto [x2,y2]=v[1];\n sib[x1][y1]={x2,y2};\n sib[x2][y2]={x1,y1};\n }\n }\n int di[4]={-1,0,1,0};\n int dj[4]={0,1,0,-1};\n char dc[4]={'U','R','D','L'};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n ll best_score = P[si][sj];\n string best_path = \"\";\n auto simulate = [&](int mode) -> pair {\n bool vis[50][50] = {};\n vis[si][sj] = true;\n ll score = P[si][sj];\n string path = \"\";\n int ci=si, cj = sj;\n while(true) {\n vector cands;\n for(int d=0;d<4;d++) {\n int ni = ci + di[d], nj = cj + dj[d];\n if(ni<0 || ni >=50 || nj<0 || nj>=50 || vis[ni][nj]) continue;\n auto [bx,by] = sib[ni][nj];\n if(bx!=-1 && vis[bx][by]) continue;\n cands.push_back(d);\n }\n if(cands.empty()) break;\n vector ws;\n if(mode ==0 || mode ==1) {\n ws.assign(cands.size(), 0);\n for(size_t k=0; k=50||nnj<0||nnj>=50 || vis[nni][nnj]) continue;\n auto [bx,by] = sib[nni][nnj];\n if(bx !=-1 && vis[bx][by]) continue;\n maxnp = max(maxnp, (ll)P[nni][nnj]);\n }\n ws[k] = val + maxnp + 1;\n }\n }\n size_t idx;\n if(mode ==0) {\n ll mw = -1;\n idx = 0;\n for(size_t k=0; k mw) {\n mw = ws[k];\n idx = k;\n }\n } else if(mode ==1) {\n ll sumw = 0;\n for(auto w : ws) sumw += w;\n size_t sz = cands.size();\n if(sumw == 0 || sz == 0) {\n idx = 0;\n } else {\n uniform_int_distribution dist(0, sumw-1);\n ll target = dist(rng);\n idx = sz -1;\n ll cum = 0;\n for(size_t k=0; k dist(0, sz-1);\n idx = dist(rng);\n }\n int d = cands[idx];\n int ni=ci + di[d], nj = cj + dj[d];\n vis[ni][nj] = true;\n score += P[ni][nj];\n path += dc[d];\n ci=ni; cj=nj;\n }\n return {score, path};\n };\n auto [sc, pa] = simulate(0);\n if(sc > best_score){ best_score=sc; best_path=pa; }\n const int TRIALS_WEIGHT = 200000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n const int TRIALS_UNIFORM = 500000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n // Beam search\n {\n vector beam;\n State inits;\n inits.ci = si; inits.cj = sj;\n inits.score = P[si][sj];\n inits.pth = \"\";\n inits.vis.reset();\n inits.vis[si * 50 + sj] = 1;\n beam.push_back(inits);\n const int BEAM_WIDTH = 256;\n int max_steps = 0;\n while (!beam.empty() && max_steps < 3500) {\n ++max_steps;\n vector candidates;\n for (const auto& st : beam) {\n for (int d = 0; d < 4; d++) {\n int ni = st.ci + di[d];\n int nj = st.cj + dj[d];\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n int idn = ni * 50 + nj;\n if (st.vis[idn]) continue;\n auto [bx, by] = sib[ni][nj];\n if (bx != -1 && st.vis[bx * 50 + by]) continue;\n State news = st;\n news.ci = ni;\n news.cj = nj;\n news.pth += dc[d];\n news.score += P[ni][nj];\n news.vis[idn] = 1;\n candidates.push_back(news);\n }\n }\n if (candidates.empty()) break;\n for (auto& c : candidates) {\n if (c.score > best_score) {\n best_score = c.score;\n best_path = c.pth;\n }\n }\n sort(candidates.begin(), candidates.end(), [](const State& a, const State& b) {\n return a.score > b.score;\n });\n if (candidates.size() > BEAM_WIDTH) candidates.resize(BEAM_WIDTH);\n beam = std::move(candidates);\n }\n }\n cout << best_path << endl;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n double horiz[30][29];\n double vert[29][30];\n int hcnt[30][29];\n int vcnt[29][30];\n for(int i = 0; i < 30; i++) {\n for(int j = 0; j < 29; j++) {\n horiz[i][j] = 5000.0;\n hcnt[i][j] = 0;\n }\n }\n for(int i = 0; i < 29; i++) {\n for(int j = 0; j < 30; j++) {\n vert[i][j] = 5000.0;\n vcnt[i][j] = 0;\n }\n }\n for(int q = 0; q < 1000; q++) {\n double bias = (q < 300 ? 180.0 : 30.0);\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n vector> dist(30, vector(30, 1e18));\n vector>> prev(30, vector>(30, {-1, -1}));\n dist[si][sj] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0.0, si, sj);\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n while (!pq.empty()) {\n auto [cost, r, c] = pq.top(); pq.pop();\n if (cost > dist[r][c]) continue;\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 30 || nc < 0 || nc >= 30) continue;\n double est_edgew = 1e18;\n int ecnt = 0;\n if (d == 0) {\n est_edgew = vert[nr][c];\n ecnt = vcnt[nr][c];\n } else if (d == 1) {\n est_edgew = vert[r][c];\n ecnt = vcnt[r][c];\n } else if (d == 2) {\n est_edgew = horiz[r][nc];\n ecnt = hcnt[r][nc];\n } else if (d == 3) {\n est_edgew = horiz[r][c];\n ecnt = hcnt[r][c];\n }\n double unc = 1.0 / (ecnt + 1.0);\n double modified = est_edgew - bias * unc;\n modified = max(50.0, modified);\n if (dist[nr][nc] > dist[r][c] + modified) {\n dist[nr][nc] = dist[r][c] + modified;\n prev[nr][nc] = {r, c};\n pq.emplace(dist[nr][nc], nr, nc);\n }\n }\n }\n double S = 0.0;\n int cr = ti, cc = tj;\n bool valid = true;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n if (p.first == -1) {\n valid = false;\n break;\n }\n int pr = p.first, pc = p.second;\n if (pr == cr && abs(pc - cc) == 1) {\n int minc = min(pc, cc);\n S += horiz[cr][minc];\n } else if (pc == cc && abs(pr - cr) == 1) {\n int minr = min(pr, cr);\n S += vert[minr][cc];\n } else {\n valid = false;\n break;\n }\n cr = pr;\n cc = pc;\n }\n if (!valid || S <= 0 || S >= 1e17) {\n string path = \"\";\n int r = si, c = sj;\n while (r != ti) {\n path += (ti > r ? 'D' : 'U');\n r += (ti > r ? 1 : -1);\n }\n while (c != tj) {\n path += (tj > c ? 'R' : 'L');\n c += (tj > c ? 1 : -1);\n }\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n continue;\n }\n vector pathv;\n cr = ti; cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (cr > pr) pathv.push_back('D');\n else if (cr < pr) pathv.push_back('U');\n else if (cc > pc) pathv.push_back('R');\n else if (cc < pc) pathv.push_back('L');\n cr = pr;\n cc = pc;\n }\n reverse(pathv.begin(), pathv.end());\n string path = \"\";\n for (char ch : pathv) path += ch;\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n double factor = (double)meas / S;\n cr = ti;\n cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (pr == cr) {\n int minc = min(pc, cc);\n int cnt = hcnt[cr][minc];\n double alpha = min(0.9, 3.0 / (cnt + 2.0));\n double mult = 1.0 - alpha + alpha * factor;\n horiz[cr][minc] *= mult;\n horiz[cr][minc] = max(100.0, min(10000.0, horiz[cr][minc]));\n hcnt[cr][minc]++;\n } else {\n int minr = min(pr, cr);\n int cnt = vcnt[minr][cc];\n double alpha = min(0.9, 3.0 / (cnt + 2.0));\n double mult = 1.0 - alpha + alpha * factor;\n vert[minr][cc] *= mult;\n vert[minr][cc] = max(100.0, min(10000.0, vert[minr][cc]));\n vcnt[minr][cc]++;\n }\n cr = pr;\n cc = pc;\n }\n // mild smoothing every 5 queries to propagate estimates\n if (q % 5 == 0) {\n double eps = 0.025;\n // smooth horiz\n for(int i = 0; i < 30; i++) {\n double temp[29];\n for(int j = 0; j < 29; j++) {\n if (j == 0) {\n temp[j] = (1 - eps) * horiz[i][0] + eps * horiz[i][1];\n } else if (j == 28) {\n temp[j] = (1 - eps) * horiz[i][28] + eps * horiz[i][27];\n } else {\n temp[j] = (1 - 2*eps) * horiz[i][j] + eps * (horiz[i][j-1] + horiz[i][j+1]);\n }\n }\n for(int j=0; j<29; j++) horiz[i][j] = temp[j];\n }\n // smooth vert\n for(int j = 0; j < 30; j++) {\n double temp[29];\n for(int i = 0; i < 29; i++) {\n if (i == 0) {\n temp[i] = (1 - eps) * vert[0][j] + eps * vert[1][j];\n } else if (i == 28) {\n temp[i] = (1 - eps) * vert[28][j] + eps * vert[27][j];\n } else {\n temp[i] = (1 - 2*eps) * vert[i][j] + eps * (vert[i-1][j] + vert[i+1][j]);\n }\n }\n for(int i=0; i<29; i++) vert[i][j] = temp[i];\n }\n // also smooth counts? no, only est\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct AhoCorasick {\n vector> trie;\n vector fail;\n vector> outs;\n int nodes;\n\n AhoCorasick() : nodes(1) {\n trie.emplace_back();\n trie[0].fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n\n void insert(const string& s, int idx) {\n int node = 0;\n for (char cc : s) {\n int c = (cc == '.' ? 8 : cc - 'A');\n if (trie[node][c] == -1) {\n trie[node][c] = nodes++;\n trie.emplace_back();\n trie.back().fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n node = trie[node][c];\n }\n outs[node].push_back(idx);\n }\n\n void build() {\n queue q;\n for (int c = 0; c < 9; c++) {\n if (trie[0][c] != -1) {\n int child = trie[0][c];\n fail[child] = 0;\n q.push(child);\n }\n }\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int c = 0; c < 9; c++) {\n if (trie[cur][c] != -1) {\n int child = trie[cur][c];\n int f = fail[cur];\n while (f != 0 && trie[f][c] == -1) f = fail[f];\n if (trie[f][c] != -1) f = trie[f][c];\n fail[child] = f;\n outs[child].insert(outs[child].end(), outs[f].begin(), outs[f].end());\n q.push(child);\n }\n }\n }\n }\n};\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector strs(M);\n for (int i = 0; i < M; i++) {\n cin >> strs[i];\n }\n AhoCorasick ac;\n for (int i = 0; i < M; i++) {\n ac.insert(strs[i], i);\n }\n ac.build();\n\n const int MAXD = 32;\n int seq_arr[MAXD];\n int double_len = 31;\n\n auto fill_seq_row = [&](const vector>& g, int r) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[r][pos];\n seq_arr[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n auto fill_seq_col = [&](const vector>& g, int c) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[pos][c];\n seq_arr[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, 7);\n uniform_real_distribution prob_dist(0.0, 1.0);\n\n vector> grid(N, vector(N, '.'));\n vector idx(M);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int a, int b){ return strs[a].size() > strs[b].size(); });\n\n for (int ii : idx) {\n const string& s = strs[ii];\n int len = s.size();\n bool placed = false;\n for (int row = 0; !placed && row < N; row++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nc = (st + p) % N;\n char exp = s[p];\n if (grid[row][nc] != '.' && grid[row][nc] != exp) { can = false; break; }\n }\n if (can) {\n for (int p = 0; p < len; p++) grid[row][(st + p) % N] = s[p];\n placed = true;\n }\n }\n }\n for (int col = 0; !placed && col < N; col++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nr = (st + p) % N;\n char exp = s[p];\n if (grid[nr][col] != '.' && grid[nr][col] != exp) { can = false; break; }\n }\n if (can) {\n for (int p = 0; p < len; p++) grid[(st + p) % N][col] = s[p];\n placed = true;\n }\n }\n }\n }\n\n const int TRIALS = 1;\n const int MAX_ITER = 120000;\n double cooling = 0.99995;\n\n vector> best_grid = grid;\n int best_covered = 0;\n\n vector vis(M, 0);\n int stamp = 0;\n\n for (int trial = 0; trial < TRIALS; trial++) {\n vector> cur_grid = grid;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) if(cur_grid[i][j]=='.') cur_grid[i][j] = 'A' + dist(rng);\n\n vector cover_cnt(M, 0);\n int curr_cov = 0;\n vector tmp_list;\n\n auto collect = [&](auto fillf, vector& mlist) {\n mlist.clear();\n stamp++;\n if(stamp==0) {\n fill(vis.begin(),vis.end(),0);\n stamp=1;\n }\n fillf(cur_grid);\n int node = 0;\n for(int k=0; k=0) node=ac.trie[node][c];\n else node=0;\n for(int id : ac.outs[node]){\n if(vis[id] != stamp){\n vis[id]=stamp;\n mlist.push_back(id);\n }\n }\n }\n };\n\n for(int r=0;r0) curr_cov++;\n\n double ttemp = 5.0;\n\n for(int it=0; it orow, ocol, nrow, ncol;\n auto fr = [&](auto& g){fill_seq_row(g,r);};\n collect(fr , orow);\n auto fc = [&](auto& g){fill_seq_col(g,cp);};\n collect(fc , ocol);\n\n cur_grid[r][cp] = nch;\n\n collect(fr , nrow);\n collect(fc , ncol);\n\n int newcov = curr_cov;\n map dmap;\n for(int id:orow) dmap[id]--;\n for(int id:ocol) dmap[id]--;\n for(int id:nrow) dmap[id]++;\n for(int id:ncol) dmap[id]++;\n for(auto& p : dmap){\n int id = p.first; int d = p.second;\n int newc = cover_cnt[id] + d;\n bool w = cover_cnt[id]>0;\n bool nw = newc >0;\n if(w && !nw) newcov--;\n else if(!w && nw) newcov++;\n }\n\n bool acc = false;\n int del = newcov - curr_cov;\n if(del>0) acc = true;\n else if(del==0 && prob_dist(rng)<0.05) acc=true;\n else {\n double pr = exp(del / max(ttemp ,0.001));\n if(prob_dist(rng) < pr) acc = true;\n }\n\n if(acc){\n for(auto& p : dmap){\n cover_cnt[p.first] += p.second;\n }\n curr_cov = newcov;\n } else {\n cur_grid[r][cp] = och;\n }\n ttemp *= cooling;\n if(ttemp < 0.001) ttemp = 0.001;\n }\n\n int maxref = 3;\n bool changed = true;\n int rp = 0;\n while(changed && rp < maxref){\n changed = false;\n rp ++;\n for(int r=0;r orow, ocol, nrow, ncol;\n auto fr = [&](auto& gg){fill_seq_row(gg,r);};\n collect(fr, orow);\n auto fc = [&](auto& gg){fill_seq_col(gg,cp);};\n collect(fc, ocol);\n cur_grid[r][cp] = nch;\n collect(fr, nrow);\n collect(fc, ncol);\n\n int ncov = curr_cov;\n map dm;\n for(int id:orow) dm[id]--;\n for(int id:ocol) dm[id]--;\n for(int id:nrow) dm[id]++;\n for(int id:ncol) dm[id]++;\n for(auto& pp:dm){\n int id=pp.first; int dd=pp.second;\n int nc= cover_cnt[id]+dd;\n bool ww = cover_cnt[id]>0;\n bool nww = nc>0;\n if(ww&&!nww) ncov--;\n else if(!ww&&nww) ncov++;\n }\n int ddelt = ncov - curr_cov;\n cur_grid[r][cp]=och;\n if(ddelt > bestd){\n bestd=ddelt;\n bn = nch;\n }\n }\n if(bestd >0){\n cur_grid[r][cp] = bn;\n vector orow, ocol, nrow, ncol;\n auto frr = [&](auto& gg){fill_seq_row(gg,r);};\n collect(frr, orow);\n auto fcc = [&](auto& gg){fill_seq_col(gg,cp);};\n collect(fcc, ocol);\n cur_grid[r][cp] = bn;\n collect(frr, nrow);\n collect(fcc, ncol);\n map dmm;\n for(int id:orow) dmm[id]--;\n for(int id:ocol) dmm[id]--;\n for(int id:nrow) dmm[id]++;\n for(int id:ncol) dmm[id]++;\n for(auto& p:dmm) cover_cnt[p.first] += p.second;\n curr_cov += bestd;\n changed = true;\n }\n }\n }\n\n if(curr_cov > best_covered){\n best_covered = curr_cov;\n best_grid = cur_grid;\n }\n }\n\n for(int i=0;i\nusing namespace std;\nusing ll = long long;\nconst ll INF = 1LL << 60;\n\nint main() {\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n int cost[69][69];\n memset(cost, 0, sizeof(cost));\n vector> all_roads;\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n all_roads.emplace_back(i, j);\n }\n int hofs[69][69];\n int vofs[69][69];\n memset(hofs, -1, sizeof(hofs));\n memset(vofs, -1, sizeof(vofs));\n vector>> hsegs, vsegs;\n int nh = 0, nv = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N;) {\n if (grid[i][j] == '#') {\n j++;\n continue;\n }\n auto& seg = hsegs.emplace_back();\n while (j < N && grid[i][j] != '#') {\n hofs[i][j] = nh;\n seg.emplace_back(i, j);\n j++;\n }\n nh++;\n }\n }\n for (int j = 0; j < N; j++) {\n for (int i = 0; i < N;) {\n if (grid[i][j] == '#') {\n i++;\n continue;\n }\n auto& seg = vsegs.emplace_back();\n while (i < N && grid[i][j] != '#') {\n vofs[i][j] = nv;\n seg.emplace_back(i, j);\n i++;\n }\n nv++;\n }\n }\n vector> best_points;\n int best_m = 100000;\n srand(42);\n for (int trial = 0; trial < 5; trial++) {\n bool cellcov[69][69] = {};\n if (hofs[si][sj] != -1) {\n int h = hofs[si][sj];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[si][sj];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n }\n vector> targets;\n auto count_remain = [&]() {\n int cnt = 0;\n for (auto [x, y] : all_roads)\n if (!cellcov[x][y]) cnt++;\n return cnt;\n };\n int remain = count_remain();\n while (remain > 0) {\n int maxg = 0;\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g > maxg) maxg = g;\n }\n if (maxg == 0) break;\n vector> cands;\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g == maxg) cands.push_back(p);\n }\n if (cands.empty()) break;\n int idx = rand() % cands.size();\n auto bp = cands[idx];\n targets.push_back(bp);\n int h = hofs[bp.first][bp.second];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[bp.first][bp.second];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n remain = count_remain();\n }\n vector> points;\n points.emplace_back(si, sj);\n for (auto tp : targets) {\n if (tp.first != si || tp.second != sj) points.push_back(tp);\n }\n vector> fullp = points;\n vector> finalp = fullp;\n auto is_full_cover = [&](const vector>& vis_set) -> bool {\n bool temp[69][69] = {};\n for (auto [x, y] : vis_set) {\n if (hofs[x][y] == -1) continue;\n int h = hofs[x][y];\n for (auto p : hsegs[h]) temp[p.first][p.second] = true;\n int vv = vofs[x][y];\n for (auto p : vsegs[vv]) temp[p.first][p.second] = true;\n }\n int rem = 0;\n for (auto [x, y] : all_roads)\n if (!temp[x][y]) rem++;\n return rem == 0;\n };\n for (int i = finalp.size() - 1; i >= 1; i--) {\n vector> temp;\n for (int j = 0; j < finalp.size(); j++) if (j != i) temp.push_back(finalp[j]);\n if (is_full_cover(temp)) {\n finalp = temp;\n }\n }\n points = finalp;\n if ((int)points.size() < best_m) {\n best_m = points.size();\n best_points = points;\n }\n }\n vector> points = best_points;\n int mm = points.size();\n vector> dmat(mm, vector(mm, INF));\n vector>>> par_store(\n mm, vector>>(N, vector>(N, {-1, -1})));\n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n for (int s = 0; s < mm; s++) {\n auto [sx, sy] = points[s];\n vector> dd(N, vector(N, INF));\n vector>> pr(N, vector>(N, {-1, -1}));\n dd[sx][sy] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0LL, sx, sy);\n while (!pq.empty()) {\n auto [cst, x, y] = pq.top();\n pq.pop();\n if (cst > dd[x][y]) continue;\n for (int d = 0; d < 4; d++) {\n int nx = x + di[d], ny = y + dj[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && grid[nx][ny] != '#') {\n ll nc = cst + cost[nx][ny];\n if (nc < dd[nx][ny]) {\n dd[nx][ny] = nc;\n pr[nx][ny] = {x, y};\n pq.emplace(nc, nx, ny);\n }\n }\n }\n }\n for (int p = 0; p < mm; p++) {\n auto [px, py] = points[p];\n dmat[s][p] = dd[px][py];\n }\n for (int x = 0; x < N; x++)\n for (int y = 0; y < N; y++) par_store[s][x][y] = pr[x][y];\n }\n struct Edge {\n ll c;\n int u, v;\n bool operator<(const Edge& o) const { return c < o.c; }\n };\n vector edges;\n for (int i = 0; i < mm; i++)\n for (int j = i + 1; j < mm; j++) {\n if (dmat[i][j] < INF) edges.push_back({dmat[i][j], i, j});\n }\n sort(edges.begin(), edges.end());\n vector paruf(mm);\n iota(paruf.begin(), paruf.end(), 0);\n auto findf = [&](auto&& self, int x) -> int {\n return paruf[x] == x ? x : paruf[x] = self(self, paruf[x]);\n };\n auto unionf = [&](int x, int y) {\n x = findf(findf, x);\n y = findf(findf, y);\n if (x != y) paruf[x] = y;\n };\n vector> adj(mm);\n for (auto& e : edges) {\n if (findf(findf, e.u) != findf(findf, e.v)) {\n unionf(e.u, e.v);\n adj[e.u].push_back(e.v);\n adj[e.v].push_back(e.u);\n }\n }\n vector euler_t;\n function dfs_e = [&](int u, int p) {\n euler_t.push_back(u);\n for (int v : adj[u])\n if (v != p) {\n dfs_e(v, u);\n euler_t.push_back(u);\n }\n };\n dfs_e(0, -1);\n vector path(mm);\n vector viss(mm, false);\n int cntv = 0;\n for (int nd : euler_t) {\n if (!viss[nd]) {\n viss[nd] = true;\n path[cntv++] = nd;\n }\n }\n // build nn\n vector nn_path;\n {\n vector vis_nn(mm, false);\n int cur = 0;\n nn_path.push_back(0);\n vis_nn[0] = true;\n while (nn_path.size() < (size_t)mm) {\n ll md = INF;\n int nx = -1;\n for (int j = 0; j < mm; j++) {\n if (!vis_nn[j] && dmat[cur][j] < md) {\n md = dmat[cur][j];\n nx = j;\n }\n }\n if (nx == -1) break;\n nn_path.push_back(nx);\n vis_nn[nx] = true;\n cur = nx;\n }\n }\n ll mst_tot = 0;\n if ((int)path.size() == mm) {\n for (int ii = 0; ii < mm; ii++) {\n mst_tot += dmat[path[ii]][path[(ii + 1) % mm]];\n }\n } else {\n mst_tot = INF;\n }\n ll nn_tot = 0;\n if ((int)nn_path.size() == mm) {\n for (size_t ii = 0; ii < nn_path.size(); ii++) {\n int aa = nn_path[ii];\n int bb = nn_path[(ii + 1) % mm];\n nn_tot += dmat[aa][bb];\n }\n } else {\n nn_tot = INF;\n }\n if ((int)nn_path.size() == mm && nn_tot < mst_tot) {\n path = nn_path;\n }\n // swaps improve\n for (int iter = 0; iter < 10; iter++) {\n bool imp = false;\n for (int i = 1; i < mm; i++) {\n for (int j = i + 1; j < mm; j++) {\n if (min(abs(i - j), mm - abs(i - j)) <= 1) continue;\n int pa = (i - 1 + mm) % mm;\n int na = (i + 1) % mm;\n int pb = (j - 1 + mm) % mm;\n int nb = (j + 1) % mm;\n ll oldd = dmat[path[pa]][path[i]] + dmat[path[i]][path[na]] +\n dmat[path[pb]][path[j]] + dmat[path[j]][path[nb]];\n ll newd = dmat[path[pa]][path[j]] + dmat[path[j]][path[na]] +\n dmat[path[pb]][path[i]] + dmat[path[i]][path[nb]];\n if (newd < oldd) {\n swap(path[i], path[j]);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n // partial 2-opt\n for (int it = 0; it < 5; it++) {\n bool imp = false;\n for (int i = 0; i < mm - 3; i++) {\n for (int j = i + 2; j < mm - 1; j++) {\n ll oldd = dmat[path[i]][path[i + 1]] + dmat[path[j]][path[j + 1]];\n ll newd = dmat[path[i]][path[j]] + dmat[path[i + 1]][path[j + 1]];\n if (newd < oldd) {\n reverse(path.begin() + i + 1, path.begin() + j + 1);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n string route = \"\";\n for (int k = 0; k < mm; k++) {\n int fid = path[k];\n int tid = path[(k + 1) % mm];\n if (fid == tid) continue;\n auto [sx, sy] = points[fid];\n auto [tx, ty] = points[tid];\n vector subm;\n int cx = tx, cy = ty;\n while (cx != sx || cy != sy) {\n auto [px, py] = par_store[fid][cx][cy];\n if (px == -1) break;\n int dx = cx - px;\n int dy = cy - py;\n char mv;\n if (dx == -1) mv = 'U';\n else if (dx == 1) mv = 'D';\n else if (dy == -1) mv = 'L';\n else if (dy == 1) mv = 'R';\n else break;\n subm.push_back(mv);\n cx = px;\n cy = py;\n }\n reverse(subm.begin(), subm.end());\n for (char c : subm) route += c;\n }\n cout << route << endl;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n vector> difficulty(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> difficulty[i][k];\n }\n }\n vector> adj(N);\n vector prereq_count(N, 0);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--;\n v--;\n adj[u].push_back(v);\n prereq_count[v]++;\n }\n vector longest_chain(N, 0);\n vector num_desc(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n longest_chain[i] = 1;\n num_desc[i] = 1;\n for (int v : adj[i]) {\n longest_chain[i] = max(longest_chain[i], 1 + longest_chain[v]);\n num_desc[i] += num_desc[v];\n }\n }\n vector> est_s(M, vector(K, 0));\n vector status(N, 0); // 0 not, 1 prog, 2 done\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector workload(M, 0);\n int day = 0;\n auto estimate = [&](int task, int mem) -> int {\n int w = 0;\n for (int k = 0; k < K; k++) {\n w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (w == 0) return 1;\n return w;\n };\n while (true) {\n day++;\n vector min_task_time(N, 0);\n for (int i = 0; i < N; i++) {\n if (status[i] == 0) {\n int mt = INT_MAX;\n for (int j = 0; j < M; j++) {\n mt = min(mt, estimate(i, j));\n }\n min_task_time[i] = max(1, mt);\n }\n }\n vector crit_path(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n if (status[i] != 0) continue;\n crit_path[i] = min_task_time[i];\n for (int v : adj[i]) {\n if (status[v] == 0) {\n crit_path[i] = max(crit_path[i], min_task_time[i] + crit_path[v]);\n }\n }\n }\n vector free_m;\n for (int j = 0; j < M; j++)\n if (current_task[j] == -1) free_m.push_back(j);\n vector ready;\n for (int i = 0; i < N; i++) {\n if (status[i] == 0 && prereq_count[i] == 0) ready.push_back(i);\n }\n vector> assigns; // mem, task\n set avail_free(free_m.begin(), free_m.end());\n sort(ready.begin(), ready.end(), [&](int a, int b) {\n if (crit_path[a] != crit_path[b]) return crit_path[a] > crit_path[b];\n if (longest_chain[a] != longest_chain[b]) return longest_chain[a] > longest_chain[b];\n if (num_desc[a] != num_desc[b]) return num_desc[a] > num_desc[b];\n return a < b;\n });\n for (int rid = 0; rid < ready.size(); rid++) {\n if (avail_free.empty()) break;\n int ta = ready[rid];\n int best_mem = -1;\n int best_et = INT_MAX;\n int best_wl = INT_MAX;\n for (int jm : avail_free) {\n int et = estimate(ta, jm);\n int wl = workload[jm];\n if (et < best_et ||\n (et == best_et &&\n (wl < best_wl || (wl == best_wl && jm < best_mem)))) {\n best_et = et;\n best_wl = wl;\n best_mem = jm;\n }\n }\n if (best_mem != -1) {\n assigns.emplace_back(best_mem, ta);\n avail_free.erase(best_mem);\n workload[best_mem] += best_et;\n }\n }\n // output\n cout << assigns.size();\n for (auto [jm, ta] : assigns) {\n cout << \" \" << (jm + 1) << \" \" << (ta + 1);\n }\n cout << endl << flush;\n // set assignments\n for (auto [jm, ta] : assigns) {\n current_task[jm] = ta;\n start_day[jm] = day;\n status[ta] = 1;\n }\n // read\n int ncomp;\n cin >> ncomp;\n if (ncomp == -1) {\n break;\n }\n vector comps(ncomp);\n for (int i = 0; i < ncomp; i++) {\n cin >> comps[i];\n }\n for (int cf : comps) {\n int mem = cf - 1;\n if (current_task[mem] == -1) continue;\n int task = current_task[mem];\n int t = day - start_day[mem] + 1;\n if (t == 1) {\n for (int k = 0; k < K; k++) {\n est_s[mem][k] = max(est_s[mem][k], difficulty[task][k]);\n }\n }\n int obs_w = (t <= 1 ? 0 : t - 1);\n int iters = 0;\n while (iters < 5) {\n iters++;\n int curr_w = 0;\n for (int k = 0; k < K; k++) {\n curr_w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (curr_w == obs_w) break;\n int num_def = 0;\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) num_def++;\n }\n if (num_def == 0) break;\n if (curr_w > obs_w) {\n int gap = curr_w - obs_w;\n int incr = max(1, gap / (2 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] += incr;\n }\n }\n } else if (curr_w < obs_w) {\n int gap = obs_w - curr_w;\n int decr = max(1, gap / (2 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] = max(0, est_s[mem][k] - decr);\n }\n }\n } else {\n break;\n }\n }\n status[task] = 2;\n current_task[mem] = -1;\n for (int v : adj[task]) {\n prereq_count[v]--;\n }\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\nint manh(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\nbool is_valid(const vector& perm, int n) {\n int m = 2 * n;\n vector pos(m);\n for (int i = 0; i < m; i++) pos[perm[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) return false;\n }\n return true;\n}\n\nint calc_cost(const vector& perm, const vector& pts, Point C, int n) {\n int m = 2 * n;\n if ((int)perm.size() != m) return INT_MAX;\n int cost = manh(C, pts[perm[0]]);\n for (int i = 0; i < m - 1; i++) {\n cost += manh(pts[perm[i]], pts[perm[i + 1]]);\n }\n cost += manh(pts[perm.back()], C);\n return cost;\n}\n\nvector generate_valid_random(int n, mt19937& rng) {\n int m = 2 * n;\n vector tasks(m);\n iota(tasks.begin(), tasks.end(), 0);\n shuffle(tasks.begin(), tasks.end(), rng);\n vector pos(m);\n for (int i = 0; i < m; i++) pos[tasks[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) {\n swap(tasks[pos[i]], tasks[pos[n + i]]);\n swap(pos[i], pos[n + i]);\n }\n }\n if (is_valid(tasks, n)) return tasks;\n return vector();\n}\n\npair> greedy_cost_and_path(const vector& S, Point C, const vector& allP, const vector& allD, int n) {\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n vector mate(2 * n);\n for (int i = 0; i < n; i++) {\n mate[i] = n + i;\n mate[n + i] = i;\n }\n vector visited(2 * n, false);\n vector feasible(2 * n, false);\n for (int i = 0; i < n; i++) feasible[i] = true;\n vector perm;\n perm.reserve(2 * n);\n Point curr = C;\n int total = 0;\n bool possible = true;\n for (int step = 0; step < 2 * n && possible; step++) {\n int best_d = INT_MAX;\n int best_idx = -1;\n for (int i = 0; i < 2 * n; i++) {\n if (!visited[i] && feasible[i]) {\n int dd = manh(curr, pts[i]);\n if (dd < best_d) {\n best_d = dd;\n best_idx = i;\n }\n }\n }\n if (best_idx == -1) {\n possible = false;\n break;\n }\n total += best_d;\n perm.push_back(best_idx);\n visited[best_idx] = true;\n curr = pts[best_idx];\n int m = mate[best_idx];\n if (!visited[m]) feasible[m] = true;\n }\n if (possible && (int)perm.size() == 2 * n) total += manh(curr, C);\n else total = INT_MAX;\n return {total, perm};\n}\n\nvoid optimize_perm_inner(vector& best_perm, int& best_cost, const vector& S, Point C, const vector& allP, const vector& allD, mt19937& rng) {\n int n = S.size();\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n auto [gcost, gperm] = greedy_cost_and_path(S, C, allP, allD, n);\n int m = 2 * n;\n int curr_cost = INT_MAX;\n vector current_perm(m);\n if ((int)gperm.size() == 2 * n) {\n current_perm = gperm;\n curr_cost = gcost;\n }\n vector best_init = current_perm;\n int best_init_cost = curr_cost;\n for (int rtry = 0; rtry < 5; rtry++) {\n vector rand_tasks = generate_valid_random(n, rng);\n if (!rand_tasks.empty()) {\n int rc = calc_cost(rand_tasks, pts, C, n);\n if (rc < best_init_cost) {\n best_init_cost = rc;\n best_init = rand_tasks;\n }\n }\n }\n if (best_init_cost < curr_cost) {\n current_perm = best_init;\n curr_cost = best_init_cost;\n }\n vector local_best_perm = current_perm;\n int local_best_cost = curr_cost;\n double T = 22000.0;\n uniform_int_distribution dpos(0, m - 1);\n uniform_real_distribution dprob(0.0, 1.0);\n for (int it = 0; it < 380000; it++) {\n vector new_perm = current_perm;\n int typ = rng() % 4;\n bool can_change = false;\n int i = dpos(rng);\n int j = dpos(rng);\n if (typ == 0) {\n if (i != j) {\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n } else if (typ == 1) {\n if (i != j) {\n int val = new_perm[i];\n new_perm.erase(new_perm.begin() + i);\n int jj = (j > i ? j - 1 : j);\n new_perm.insert(new_perm.begin() + jj, val);\n can_change = true;\n }\n } else if (typ == 2) {\n if (i > j) swap(i, j);\n if (i != j) {\n reverse(new_perm.begin() + i, new_perm.begin() + j + 1);\n can_change = true;\n }\n } else {\n j = (i + 1) % m;\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n if (can_change && is_valid(new_perm, n)) {\n int new_cost = calc_cost(new_perm, pts, C, n);\n if (new_cost < INT_MAX) {\n double delta = new_cost - curr_cost;\n if (delta < 0 || (T > 0 && exp(-delta / T) > dprob(rng))) {\n current_perm = new_perm;\n curr_cost = new_cost;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n }\n }\n T *= 0.99993;\n }\n current_perm = local_best_perm;\n curr_cost = local_best_cost;\n int phases = 0;\n const int max_phases = 28;\n bool improved_global = true;\n while (improved_global && phases < max_phases) {\n improved_global = false;\n phases++;\n int min_newc = curr_cost;\n vector best_np;\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n swap(np[ii], np[jj]);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = 0; jj < m; jj++) {\n if (ii == jj) continue;\n vector np = current_perm;\n int val = np[ii];\n np.erase(np.begin() + ii);\n int jj_adj = (jj > ii ? jj - 1 : jj);\n np.insert(np.begin() + jj_adj, val);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n reverse(np.begin() + ii, np.begin() + jj + 1);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n }\n best_perm = local_best_perm;\n best_cost = local_best_cost;\n}\n\ntuple, vector> run_optimization(const vector& allP, const vector& allD, Point C, mt19937& rng, int trials = 2) {\n int best_cost = INT_MAX;\n vector best_perm(2 * 50);\n vector best_S(50);\n for (int tr = 0; tr < trials; tr++) {\n vector centers;\n centers.push_back(C);\n int step = 42;\n for (int cx = 20; cx < 780; cx += step) {\n for (int cy = 20; cy < 780; cy += step) {\n centers.push_back({cx, cy});\n }\n }\n for (int i = 0; i < 120; i++) {\n centers.push_back({static_cast(rng() % 801), static_cast(rng() % 801)});\n }\n int n = 50;\n int local_best_T = INT_MAX;\n vector local_best_S;\n for (auto& cen : centers) {\n vector> dists;\n for (int i = 0; i < 1000; i++) {\n int dd = manh(allP[i], cen) + manh(allD[i], cen);\n dists.emplace_back(dd, i);\n }\n sort(dists.begin(), dists.end());\n vector S;\n for (int i = 0; i < n; i++) S.push_back(dists[i].second);\n auto [gcost, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gcost < local_best_T) {\n local_best_T = gcost;\n local_best_S = S;\n }\n }\n vector> ind_cost;\n for (int i = 0; i < 1000; i++) {\n int cc = manh(C, allP[i]) + manh(allP[i], allD[i]) + manh(allD[i], C);\n ind_cost.emplace_back(cc, i);\n }\n sort(ind_cost.begin(), ind_cost.end());\n vector S_small;\n for (int i = 0; i < n; i++) S_small.push_back(ind_cost[i].second);\n auto [gcost2, gp2] = greedy_cost_and_path(S_small, C, allP, allD, n);\n if (gcost2 < local_best_T) {\n local_best_T = gcost2;\n local_best_S = S_small;\n }\n for (int tri = 0; tri < 50; tri++) {\n vector all(1000);\n iota(all.begin(), all.end(), 0);\n shuffle(all.begin(), all.end(), rng);\n vector S(all.begin(), all.begin() + n);\n auto [gc, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gc < local_best_T) {\n local_best_T = gc;\n local_best_S = S;\n }\n }\n int opt_cost = INT_MAX;\n vector opt_perm(100);\n int tmp_c = INT_MAX;\n vector tmp_perm;\n optimize_perm_inner(tmp_perm, tmp_c, local_best_S, C, allP, allD, rng);\n if (tmp_c < opt_cost) {\n opt_cost = tmp_c;\n opt_perm = tmp_perm;\n }\n int repl_cnt = 0;\n for (int trial = 0; trial < 80; trial++) {\n if (repl_cnt >= 25) break;\n uniform_int_distribution dis_in(0, n - 1);\n uniform_int_distribution dis_out(0, 999);\n vector newS = local_best_S;\n int in_idx = dis_in(rng);\n int out = dis_out(rng);\n bool has = false;\n for (int s : newS) if (s == out) { has = true; break; }\n if (has) continue;\n newS[in_idx] = out;\n auto [gc, gp] = greedy_cost_and_path(newS, C, allP, allD, n);\n if (gc < opt_cost * 1.05 && gc < INT_MAX) {\n tmp_c = INT_MAX;\n tmp_perm.clear();\n optimize_perm_inner(tmp_perm, tmp_c, newS, C, allP, allD, rng);\n if (tmp_c < opt_cost) {\n opt_cost = tmp_c;\n opt_perm = tmp_perm;\n local_best_S = newS;\n }\n repl_cnt++;\n }\n }\n if (opt_cost < best_cost) {\n best_cost = opt_cost;\n best_perm = opt_perm;\n best_S = local_best_S;\n }\n }\n return make_tuple(best_cost, best_perm, best_S);\n}\n\nint main() {\n vector allP(1000), allD(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> allP[i].x >> allP[i].y >> allD[i].x >> allD[i].y;\n }\n Point C = {400, 400};\n mt19937 rng(987654321);\n auto res = run_optimization(allP, allD, C, rng, 2);\n int n = get<2>(res).size();\n vector best_S = get<2>(res);\n vector opt_perm = get<1>(res);\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[best_S[i]];\n pts[n + i] = allD[best_S[i]];\n }\n vector route;\n route.push_back(C);\n for (int t : opt_perm) {\n route.push_back(pts[t]);\n }\n route.push_back(C);\n cout << 50;\n for (int r : best_S) cout << \" \" << (r + 1);\n cout << endl;\n cout << route.size();\n for (auto p : route) cout << \" \" << p.x << \" \" << p.y;\n cout << endl;\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v, idx, d, l;\n bool backup;\n};\n\nvector edges;\nvector par;\n\nint find(vector& p, int x) {\n return p[x] == x ? x : p[x] = find(p, p[x]);\n}\n\nbool unite(vector& p, int x, int y) {\n x = find(p, x);\n y = find(p, y);\n if (x == y) return false;\n p[x] = y;\n return true;\n}\n\nint main() {\n vector x(400), y(400);\n for (int i = 0; i < 400; i++) {\n cin >> x[i] >> y[i];\n }\n int M = 1995;\n edges.resize(M);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i].u = u;\n edges[i].v = v;\n edges[i].idx = i;\n edges[i].l = -1;\n edges[i].backup = false;\n double dx = x[u] - x[v];\n double dy = y[u] - y[v];\n double dist = hypot(dx, dy);\n edges[i].d = (int)round(dist);\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].d < edges[b].d;\n });\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n int cnt = 0;\n for (int i : ord) {\n if (unite(par, edges[i].u, edges[i].v)) {\n edges[i].backup = true;\n cnt++;\n if (cnt == 399) break;\n }\n }\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n const double MULT = 2.0;\n for (int i = 0; i < M; i++) {\n int l;\n cin >> l;\n edges[i].l = l;\n int u = edges[i].u, v = edges[i].v;\n int pu = find(par, u);\n int pv = find(par, v);\n int ans = 0;\n if (pu != pv) {\n if (edges[i].backup) {\n ans = 1;\n } else {\n int md = edges[i].d;\n // direct future cross min-d\n int min_fut = INT_MAX / 2;\n for (int j = i + 1; j < M; j++) {\n int uj = edges[j].u, vj = edges[j].v;\n int pj1 = find(par, uj), pj2 = find(par, vj);\n if ((pj1 == pu && pj2 == pv) || (pj1 == pv && pj2 == pu)) {\n min_fut = min(min_fut, edges[j].d);\n }\n }\n if (min_fut < INT_MAX / 2) md = min(md, min_fut);\n // always compute correct MST-bottleneck for indirect routes\n vector tmp_par = par;\n int bott = INT_MAX / 2;\n for (int jj : ord) {\n if (jj <= i) continue;\n int j = jj;\n int uj = edges[j].u, vj = edges[j].v;\n int pj1 = find(tmp_par, uj), pj2 = find(tmp_par, vj);\n if (pj1 != pj2 && unite(tmp_par, pj1, pj2)) {\n if (find(tmp_par, pu) == find(tmp_par, pv)) {\n bott = edges[j].d;\n break;\n }\n }\n }\n if (bott < INT_MAX / 2) md = min(md, bott);\n if (l <= MULT * md) ans = 1;\n }\n if (ans == 1) {\n unite(par, u, v);\n }\n }\n cout << ans << endl;\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n cin >> 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 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 const int W = 30;\n vector> is_blocked(W + 2, vector(W + 2, false));\n vector> human_pos(M);\n for (int i = 0; i < M; i++) human_pos[i] = {hx[i], hy[i]};\n vector> pet_pos(N);\n for (int i = 0; i < N; i++) pet_pos[i] = {px[i], py[i]};\n vector dx = {-1, 1, 0, 0};\n vector dy = {0, 0, -1, 1};\n char move_char[4] = {'U', 'D', 'L', 'R'};\n char block_char[4] = {'u', 'd', 'l', 'r'};\n auto valid = [&](int x, int y) {\n return x >= 1 && x <= W && y >= 1 && y <= W && !is_blocked[x][y];\n };\n auto is_occupied_func = nullptr; // defined per turn\n vector> stand_pos, wall_pos;\n int wall_size = 20;\n int right_c = wall_size + 1;\n int bottom_r = wall_size + 1;\n for (int r = 1; r <= wall_size; r++) {\n stand_pos.emplace_back(r, wall_size);\n wall_pos.emplace_back(r, right_c);\n }\n for (int c = 1; c <= wall_size; c++) {\n stand_pos.emplace_back(wall_size, c);\n wall_pos.emplace_back(bottom_r, c);\n }\n set> wall_set(wall_pos.begin(), wall_pos.end());\n mt19937 rng(42);\n for (int turn = 0; turn < 300; turn++) {\n vector> next_hpos(M);\n string actions_str(M, '.');\n set> targeted_moves;\n set> this_turn_blocked;\n vector> is_occupied(W + 2, vector(W + 2, false));\n for (int i = 0; i < N; i++) {\n auto [x, y] = pet_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n for (int i = 0; i < M; i++) {\n auto [x, y] = human_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n auto can_block = [&](int tx, int ty) {\n if (!valid(tx, ty) || is_occupied[tx][ty]) return false;\n for (int d = 0; d < 4; d++) {\n int px = tx + dx[d];\n int py = ty + dy[d];\n if (valid(px, py) && is_occupied[px][py]) return false;\n }\n return true;\n };\n vector assigned_idx(M, -1);\n vector used_stand(stand_pos.size(), false);\n if (turn >= 150) {\n for (int i = 0; i < M; i++) {\n int best_j = -1;\n int best_d = INT_MAX;\n for (int j = 0; j < (int)stand_pos.size(); j++) {\n auto [wx, wy] = wall_pos[j];\n if (is_blocked[wx][wy]) continue;\n if (used_stand[j]) continue;\n auto [sx, sy] = stand_pos[j];\n int dist = abs(human_pos[i].first - sx) + abs(human_pos[i].second - sy);\n if (dist < best_d) {\n best_d = dist;\n best_j = j;\n }\n }\n if (best_j != -1) {\n assigned_idx[i] = best_j;\n used_stand[best_j] = true;\n }\n }\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for (int k = 0; k < M; k++) {\n int i = ord[k];\n auto [x, y] = human_pos[i];\n bool did = false;\n int t_idx = assigned_idx[i];\n if (turn < 150 || t_idx == -1) {\n // gather to center\n int cx = 15, cy = 15;\n vector> candidates;\n if (x < cx && valid(x + 1, y)) candidates.emplace_back(1, 'D');\n if (x > cx && valid(x - 1, y)) candidates.emplace_back(0, 'U');\n if (y < cy && valid(x, y + 1)) candidates.emplace_back(3, 'R');\n if (y > cy && valid(x, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n } else {\n auto [tx, ty] = stand_pos[t_idx];\n if (x == tx && y == ty) {\n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int bx = x + dx[d];\n int by = y + dy[d];\n if (wall_set.count({bx, by}) && can_block(bx, by)) {\n actions_str[i] = block_char[d];\n this_turn_blocked.insert({bx, by});\n is_blocked[bx][by] = true;\n next_hpos[i] = {x, y};\n did = true;\n break;\n }\n }\n } else {\n vector> candidates;\n if (x < tx && valid(x + 1, ty)) candidates.emplace_back(1, 'D');\n if (x > tx && valid(x - 1, ty)) candidates.emplace_back(0, 'U');\n if (y < ty && valid(tx, y + 1)) candidates.emplace_back(3, 'R');\n if (y > ty && valid(tx, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n }\n }\n if (!did) {\n actions_str[i] = '.';\n next_hpos[i] = {x, y};\n }\n }\n // output\n cout << actions_str << endl;\n cout.flush();\n // read pet moves\n vector pet_moves(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n // update human_pos\n for (int i = 0; i < M; i++) {\n human_pos[i] = next_hpos[i];\n }\n // update pet_pos\n for (int i = 0; i < N; i++) {\n int x = pet_pos[i].first, y = pet_pos[i].second;\n string mv = pet_moves[i];\n for (char c : mv) {\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n if (d != -1) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (valid(nx, ny)) {\n x = nx;\n y = ny;\n }\n }\n }\n pet_pos[i] = {x, y};\n }\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\ndouble compute_ES(const vector& sseq, double pp, int ssr, int ssc, int ttr, int ttc, int HH[20][19], int VV[19][20]) {\n double prb[20][20] = {};\n prb[ssr][ssc] = 1.0;\n double ES = 0.0;\n int LL = sseq.size();\n for (int tt = 0; tt < LL; tt++) {\n double rch = 0.0;\n double np[20][20] = {};\n char dr = sseq[tt];\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double prr = prb[i][j];\n if (prr < 1e-20 || (i == ttr && j == ttc)) continue;\n np[i][j] += prr * pp;\n int nii = i, njj = j;\n bool cm = false;\n if (dr == 'D' && i < 19 && VV[i][j] == 0) { nii++; cm = true; }\n else if (dr == 'U' && i > 0 && VV[i - 1][j] == 0) { nii--; cm = true; }\n else if (dr == 'R' && j < 19 && HH[i][j] == 0) { njj++; cm = true; }\n else if (dr == 'L' && j > 0 && HH[i][j - 1] == 0) { njj--; cm = true; }\n if (cm) {\n if (nii == ttr && njj == ttc) {\n rch += prr * (1 - pp);\n } else {\n np[nii][njj] += prr * (1 - pp);\n }\n } else {\n np[i][j] += prr * (1 - pp);\n }\n }\n }\n ES += rch * (401.0 - (tt + 1));\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prb[i][j] = np[i][j];\n double remain = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i != ttr || j != ttc) remain += prb[i][j];\n }\n }\n if (remain < 1e-9) break;\n }\n return ES;\n}\n\nint main() {\n int sr, sc, tr, tc;\n double p;\n cin >> sr >> sc >> tr >> tc >> p;\n int h[20][19];\n for (int i = 0; i < 20; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 19; j++) h[i][j] = s[j] - '0';\n }\n int v[19][20];\n for (int i = 0; i < 19; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 20; j++) v[i][j] = s[j] - '0';\n }\n const int INF = 10000;\n int dist[20][20];\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) dist[i][j] = INF;\n dist[tr][tc] = 0;\n queue> q;\n q.push({tr, tc});\n while (!q.empty()) {\n auto cur = q.front();\n q.pop();\n int x = cur.first, y = cur.second;\n int d = dist[x][y];\n if (y < 19 && h[x][y] == 0) {\n int nx = x, ny = y + 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (y > 0 && h[x][y - 1] == 0) {\n int nx = x, ny = y - 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x < 19 && v[x][y] == 0) {\n int nx = x + 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x > 0 && v[x - 1][y] == 0) {\n int nx = x - 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) if (dist[i][j] == INF) dist[i][j] = 50;\n double best_init_E = -1e9;\n vector best_init_seq;\n srand(time(NULL));\n vector> fixed_orders = {\n {'D', 'R', 'L', 'U'},\n {'R', 'D', 'L', 'U'},\n {'D', 'L', 'R', 'U'},\n {'D', 'R', 'U', 'L'},\n {'R', 'L', 'D', 'U'}\n };\n for (auto& dir_order_base : fixed_orders) {\n vector dir_order = dir_order_base;\n double prob[20][20] = {};\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = 0.0;\n prob[sr][sc] = 1.0;\n vector seq;\n for (int stp = 0; stp < 200; stp++) {\n double best_score = -1e100;\n char bestc = ' ';\n for (int di = 0; di < 4; di++) {\n char dir = dir_order[di];\n double reach = 0.0;\n double newp[20][20] = {};\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (dir == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (dir == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (dir == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (dir == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n double eds = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n eds += newp[i][j] * dist[i][j];\n }\n }\n double score = -eds + 25.0 * reach;\n if (score > best_score + 1e-9) {\n best_score = score;\n bestc = dir;\n }\n }\n if (bestc == ' ') break;\n double newp[20][20] = {};\n double reach = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (bestc == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (bestc == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (bestc == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (bestc == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = newp[i][j];\n seq.push_back(bestc);\n }\n double this_E = compute_ES(seq, p, sr, sc, tr, tc, h, v);\n if (this_E > best_init_E + 1e-9) {\n best_init_E = this_E;\n best_init_seq = seq;\n }\n }\n for (int rep = 0; rep < 20; rep++) {\n vector dir_order = {'D', 'R', 'L', 'U'};\n random_shuffle(dir_order.begin(), dir_order.end());\n double prob[20][20] = {};\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = 0.0;\n prob[sr][sc] = 1.0;\n vector seq;\n for (int stp = 0; stp < 200; stp++) {\n double best_score = -1e100;\n char bestc = ' ';\n for (int di = 0; di < 4; di++) {\n char dir = dir_order[di];\n double reach = 0.0;\n double newp[20][20] = {};\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (dir == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (dir == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (dir == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (dir == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n double eds = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n eds += newp[i][j] * dist[i][j];\n }\n }\n double score = -eds + 25.0 * reach;\n if (score > best_score + 1e-9) {\n best_score = score;\n bestc = dir;\n }\n }\n if (bestc == ' ') break;\n double newp[20][20] = {};\n double reach = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (bestc == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (bestc == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (bestc == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (bestc == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = newp[i][j];\n seq.push_back(bestc);\n }\n double this_E = compute_ES(seq, p, sr, sc, tr, tc, h, v);\n if (this_E > best_init_E + 1e-9) {\n best_init_E = this_E;\n best_init_seq = seq;\n }\n }\n vector best_seq = best_init_seq;\n double best_E = best_init_E;\n int L = best_seq.size();\n if (L > 0) {\n char dir_options[4] = {'U', 'D', 'L', 'R'};\n for (int trial = 0; trial < 1800; trial++) {\n int pos = rand() % L;\n char original = best_seq[pos];\n for (int d = 0; d < 4; d++) {\n char new_dir = dir_options[d];\n if (new_dir == original) continue;\n best_seq[pos] = new_dir;\n double newE = compute_ES(best_seq, p, sr, sc, tr, tc, h, v);\n if (newE > best_E + 1e-9) {\n best_E = newE;\n } else {\n best_seq[pos] = original;\n }\n }\n }\n }\n string ans = \"\";\n for (char c : best_seq) ans += c;\n if (ans.size() > 200) ans = ans.substr(0, 200);\n cout << ans << endl;\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30;\nconst int W = 30;\nconst int D = 4;\nconst int SZ = H * W * D;\n\nint TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\nint DI[4] = {0, -1, 0, 1};\nint DJ[4] = {-1, 0, 1, 0};\n\nstatic int current_time = 0;\nstatic int timestamp[SZ];\nstatic int pstep[SZ];\nstatic bool vis[SZ];\n\nint get_eff(int o, int r) {\n if (o < 4) return (o + r) % 4;\n if (o == 4) return (r % 2 ? 5 : 4);\n if (o == 5) return (r % 2 ? 4 : 5);\n if (o == 6) return (r % 2 ? 7 : 6);\n return (r % 2 ? 6 : 7);\n}\n\nlong long compute_cycles(int t[H][W], int r[H][W], int& len1, int& len2) {\n if (current_time > 2000000000) {\n current_time = 0;\n memset(timestamp, 0, sizeof(timestamp));\n }\n int eff[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n eff[i][j] = get_eff(t[i][j], r[i][j]);\n }\n }\n static int next_state[SZ];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n for (int d = 0; d < D; d++) {\n int idx = ((i * W + j) * D + d);\n int d2 = TO[eff[i][j]][d];\n if (d2 == -1) {\n next_state[idx] = -1;\n continue;\n }\n int ni = i + DI[d2];\n int nj = j + DJ[d2];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) {\n next_state[idx] = -1;\n continue;\n }\n int nd = (d2 + 2) % 4;\n next_state[idx] = ((ni * W + nj) * D + nd);\n }\n }\n }\n memset(vis, 0, sizeof(vis));\n len1 = 0;\n len2 = 0;\n int path_arr[4010];\n for (int s = 0; s < SZ; s++) {\n if (!vis[s]) {\n if (next_state[s] == -1) {\n vis[s] = true;\n continue;\n }\n int path_len = 0;\n int cur = s;\n int this_t = ++current_time;\n timestamp[cur] = this_t;\n pstep[cur] = 0;\n path_arr[path_len++] = cur;\n bool foundc = false;\n int cst = 0;\n int nxt;\n while (true) {\n nxt = next_state[cur];\n if (nxt == -1) break;\n if (vis[nxt]) break;\n if (timestamp[nxt] == this_t) {\n foundc = true;\n cst = pstep[nxt];\n break;\n }\n if (path_len >= 4005) break;\n path_arr[path_len] = nxt;\n timestamp[nxt] = this_t;\n pstep[nxt] = path_len;\n path_len++;\n cur = nxt;\n }\n if (foundc) {\n int cl = path_len - cst;\n if (cl > len1) {\n len2 = len1;\n len1 = cl;\n } else if (cl > len2) {\n len2 = cl;\n }\n }\n for (int p = 0; p < path_len; p++) {\n vis[path_arr[p]] = true;\n }\n }\n }\n if (len1 > 0 && len2 > 0) return 1LL * len1 * len2;\n return 0;\n}\n\nint main() {\n int orig[H][W];\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n orig[i][j] = s[j] - '0';\n }\n }\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution randr(0, 3);\n long long global_best_sc = 0;\n int global_best_r[H][W];\n // Uniform\n for (int val = 0; val < 4; val++) {\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = val;\n int cl1, cl2;\n long long sc = compute_cycles(orig, init_r, cl1, cl2);\n if (sc > global_best_sc) {\n global_best_sc = sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // position based patterns\n int patterns[5][2] = {{1, 0}, {0, 1}, {2, 1}, {1, 3}, {3, 1}};\n for (int p = 0; p < 5; p++) {\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = (i * patterns[p][0] + j * patterns[p][1]) % 4;\n int cl1, cl2;\n long long sc = compute_cycles(orig, init_r, cl1, cl2);\n if (sc > global_best_sc) {\n global_best_sc = sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // random tries\n for (int tries = 0; tries < 6; tries++) {\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = randr(rng);\n int cl1, cl2;\n long long sc = compute_cycles(orig, init_r, cl1, cl2);\n if (sc > global_best_sc) {\n global_best_sc = sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // Start SA\n int cur_r[H][W];\n memcpy(cur_r, global_best_r, sizeof(global_best_r));\n long long cur_sc = global_best_sc;\n long long best_sc = cur_sc;\n int best_r[H][W];\n memcpy(best_r, cur_r, sizeof(cur_r));\n const int MAX_ITER = 30000;\n double temp = 120000.0;\n double cooling = 0.9999;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int new_r[H][W];\n memcpy(new_r, cur_r, sizeof(cur_r));\n int nmut = randr(rng) % 3 + 1;\n for (int k = 0; k < nmut; k++) {\n int pos = rng() % (H * W);\n int i = pos / W;\n int j = pos % W;\n int delta = (randr(rng) % 3) + 1;\n new_r[i][j] = (new_r[i][j] + delta) % 4;\n }\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n long long delta = new_sc - cur_sc;\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if ((double)rng() / rng.max() < prob) accept = true;\n }\n if (accept) {\n memcpy(cur_r, new_r, sizeof(cur_r));\n cur_sc = new_sc;\n if (cur_sc > best_sc) {\n best_sc = cur_sc;\n memcpy(best_r, cur_r, sizeof(best_r));\n }\n }\n temp *= cooling;\n if (temp < 0.5) temp = 0.5;\n }\n // Fine tune phase: small mutations only rotations +1 mod, prefer improvement\n for (int fiter = 0; fiter < 8000; fiter++) {\n int new_r[H][W];\n memcpy(new_r, best_r, sizeof(best_r));\n int i = rng() % H;\n int j = rng() % W;\n int delta = (randr(rng) % 2 + 1) * ((randr(rng) % 2 == 0) ? 1 : -1);\n new_r[i][j] = (best_r[i][j] + delta + 4) % 4;\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n if (new_sc > best_sc) {\n best_sc = new_sc;\n memcpy(best_r, new_r, sizeof(new_r));\n }\n }\n // local\n int temp_r[H][W];\n memcpy(temp_r, best_r, sizeof(best_r));\n long long temp_sc = best_sc;\n bool improved = true;\n int passes = 0;\n int local_iters = 0;\n const int MAX_LOCAL_EVAL = 10000;\n while (improved && passes < 4 && local_iters < MAX_LOCAL_EVAL) {\n improved = false;\n passes++;\n vector order(H*W);\n for (int i = 0; i < H*W; i++) order[i] = i;\n shuffle(order.begin(), order.end(), rng);\n for (int pidx = 0; pidx < H*W && local_iters < MAX_LOCAL_EVAL; pidx++) {\n int pos = order[pidx];\n int i = pos / W;\n int j = pos % W;\n int oldr = temp_r[i][j];\n long long best_this_sc = temp_sc;\n int best_this_r = oldr;\n for (int nr = 0; nr < 4; nr++) {\n temp_r[i][j] = nr;\n int tl1, tl2;\n long long sc = compute_cycles(orig, temp_r, tl1, tl2);\n local_iters++;\n if (sc > best_this_sc) {\n best_this_sc = sc;\n best_this_r = nr;\n }\n }\n temp_r[i][j] = best_this_r;\n if (best_this_sc > temp_sc) {\n temp_sc = best_this_sc;\n improved = true;\n }\n }\n }\n if (temp_sc > best_sc) {\n best_sc = temp_sc;\n memcpy(best_r, temp_r, sizeof(best_r));\n }\n string ans = \"\";\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n ans += '0' + best_r[i][j];\n }\n }\n cout << ans << endl;\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint main() {\n srand(time(0));\n int N, Tmax;\n cin >> N >> Tmax;\n vector> init_board(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 char c = s[j];\n if(c >= '0' && c <= '9') init_board[i][j] = c - '0';\n else init_board[i][j] = 10 + (c - 'a');\n }\n }\n pair init_blank = {-1, -1};\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(init_board[i][j] == 0) init_blank = {i, j};\n int fullS = N * N - 1;\n int ddx[4] = {-1, 1, 0, 0};\n int ddy[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n auto compute_S_and_M = [&](const vector>& b) -> pair {\n int S = 0, M = 0;\n int MM = N * N;\n vector parent(MM), sz(MM, 1), has_cyc(MM, 0);\n for(int i = 0; i < MM; i++) parent[i] = i;\n auto find = [&](auto&& self, int x) -> int {\n if(parent[x] != x) parent[x] = self(self, parent[x]);\n return parent[x];\n };\n auto unite = [&](int x, int y) {\n int px = find(find, x), py = find(find, y);\n if(px == py) {\n has_cyc[px] = 1;\n return;\n }\n if(sz[px] < sz[py]) swap(px, py);\n parent[py] = px;\n sz[px] += sz[py];\n if(has_cyc[py]) has_cyc[px] = 1;\n };\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n int t1 = b[i][j], t2 = b[i+1][j];\n if(t1 != 0 && t2 != 0 && (t1 & 8) && (t2 & 2)) {\n M++;\n unite(i*N + j, (i+1)*N + j);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n int t1 = b[i][j], t2 = b[i][j+1];\n if(t1 != 0 && t2 != 0 && (t1 & 4) && (t2 & 1)) {\n M++;\n unite(i*N + j, i*N + j + 1);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(b[i][j] != 0) {\n int rp = find(find, i*N + j);\n if(!has_cyc[rp]) S = max(S, sz[rp]);\n }\n return {S, M};\n };\n vector> board = init_board;\n int bx = init_blank.first, by = init_blank.second;\n string moves = \"\";\n auto initial_pm = compute_S_and_M(board);\n int max_achieved_S = initial_pm.first;\n int max_achieved_M = initial_pm.second;\n string best_sequence = \"\";\n int best_k = 0;\n for(int step = 0; step < Tmax; step++) {\n if(moves.length() >= Tmax) break;\n if(max_achieved_S == fullS) break;\n bool perturb = (rand() % 100 < 18);\n int chosen_d = -1;\n if(perturb) {\n vector cands;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx >= 0 && nx < N && ny >= 0 && ny < N) cands.push_back(d);\n }\n if(!cands.empty()) chosen_d = cands[rand() % cands.size()];\n } else {\n int best_future = -1, best_m = -1;\n vector best_ds;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n auto pm1 = compute_S_and_M(board);\n int this_future = pm1.first;\n int thisM = pm1.second;\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n auto pm2 = compute_S_and_M(board);\n int s2 = pm2.first, m2 = pm2.second;\n if(s2 > this_future || (s2 == this_future && m2 > thisM)) {\n this_future = s2;\n thisM = m2;\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n for(int d3 = 0; d3 < 4; d3++) {\n int nx3 = nx2 + ddx[d3], ny3 = ny2 + ddy[d3];\n if(nx3 < 0 || nx3 >= N || ny3 < 0 || ny3 >= N) continue;\n swap(board[nx2][ny2], board[nx3][ny3]);\n auto pm3 = compute_S_and_M(board);\n int s3 = pm3.first, m3 = pm3.second;\n if(s3 > this_future || (s3 == this_future && m3 > thisM)) {\n this_future = s3;\n thisM = m3;\n }\n for(int d4 = 0; d4 < 4; d4++) {\n int nx4 = nx3 + ddx[d4], ny4 = ny3 + ddy[d4];\n if(nx4 < 0 || nx4 >= N || ny4 < 0 || ny4 >= N) continue;\n swap(board[nx3][ny3], board[nx4][ny4]);\n auto pm4 = compute_S_and_M(board);\n int s4 = pm4.first, m4 = pm4.second;\n if(s4 > this_future || (s4 == this_future && m4 > thisM)) {\n this_future = s4;\n thisM = m4;\n }\n swap(board[nx3][ny3], board[nx4][ny4]);\n }\n swap(board[nx2][ny2], board[nx3][ny3]);\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n if(this_future > best_future || (this_future == best_future && thisM > best_m)) {\n best_future = this_future;\n best_m = thisM;\n best_ds.clear();\n best_ds.push_back(d);\n } else if(this_future == best_future && thisM == best_m) {\n best_ds.push_back(d);\n }\n swap(board[bx][by], board[nx][ny]);\n }\n if(!best_ds.empty()) {\n int idx = rand() % best_ds.size();\n chosen_d = best_ds[idx];\n }\n }\n if(chosen_d == -1) break;\n int nx = bx + ddx[chosen_d], ny = by + ddy[chosen_d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n bx = nx; by = ny;\n moves += dchar[chosen_d];\n auto [ns, nm] = compute_S_and_M(board);\n int nk = moves.length();\n if(ns > max_achieved_S || (ns == max_achieved_S && nk < best_k)) {\n max_achieved_S = ns;\n max_achieved_M = nm;\n best_sequence = moves;\n best_k = nk;\n } else if(ns == max_achieved_S && nm > max_achieved_M) {\n max_achieved_M = nm;\n best_sequence = moves;\n best_k = nk;\n }\n }\n cout << best_sequence << endl;\n}","ahc012":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Line {\n ll px, py, qx, qy;\n};\n\nint main() {\n int N, K;\n cin >> N >> K;\n vector A(11, 0);\n for (int d = 1; d <= 10; d++) {\n cin >> A[d];\n }\n vector> pts(N);\n for (auto& p : pts) {\n cin >> p.first >> p.second;\n }\n auto compute_cross = [&](const Line& l, int id) -> ll {\n auto [x, y] = pts[id];\n ll a = x - l.px;\n ll b = y - l.py;\n ll c = l.qx - l.px;\n ll d = l.qy - l.py;\n return a * d - b * c;\n };\n auto get_fr_sat = [&](const vector>& prts) -> pair, int> {\n vector fr(5501, 0);\n for (auto& p : prts) {\n size_t s = p.size();\n if (s < 5501) fr[s]++;\n }\n int s = 0;\n for (int d = 1; d <= 10; d++) {\n s += min(A[d], fr[d]);\n }\n return {fr, s};\n };\n vector best_chosen;\n int best_sat = -1;\n for (int trial = 0; trial < 3; trial++) {\n double shift = trial * (2 * 3.141592653589793 / 36.0);\n vector all_idx(N);\n iota(all_idx.begin(), all_idx.end(), 0);\n vector> parts = {all_idx};\n vector chosen;\n auto [_, init_sat] = get_fr_sat(parts);\n int cur_sat = init_sat;\n for (int iter = 0; iter < 100 && (int)chosen.size() < K; iter++) {\n auto [fr, tmp_sat] = get_fr_sat(parts);\n vector needed;\n for (int d = 1; d <= 10; d++) {\n if (fr[d] < A[d]) needed.push_back(d);\n }\n vector large_g_idx;\n for (int i = 0; i < (int)parts.size(); i++) {\n if ((int)parts[i].size() > 10) large_g_idx.push_back(i);\n }\n if (large_g_idx.empty()) break;\n sort(large_g_idx.begin(), large_g_idx.end(), [&](int aa, int bb) {\n return parts[aa].size() > parts[bb].size();\n });\n int num_target = min(1, (int)large_g_idx.size());\n int best_new = cur_sat;\n Line best_l;\n bool improved = false;\n for (int tg = 0; tg < num_target; tg++) {\n int gidx = large_g_idx[tg];\n auto& group = parts[gidx];\n int gs = group.size();\n for (int th = 0; th < 36; th++) {\n double theta = shift + (2 * 3.141592653589793 * th / 36.0);\n double nx = cos(theta);\n double ny = sin(theta);\n vector> projs;\n projs.reserve(gs);\n for (int id : group) {\n double pr = pts[id].first * nx + pts[id].second * ny;\n projs.emplace_back(pr, id);\n }\n sort(projs.begin(), projs.end());\n for (int mm : needed) {\n int m = mm;\n if (m < 1 || m > min(10, gs - 1)) continue;\n double r1 = projs[m - 1].first;\n double r2 = projs[m].first;\n if (abs(r1 - r2) < 1e-9) continue;\n double r = (r1 + r2) / 2.0;\n double dx = -ny;\n double dy = nx;\n double D = 1000000.0;\n double bx = r * nx;\n double by = r * ny;\n double pxd = bx + D * dx;\n double pyd = by + D * dy;\n double qxd = bx - D * dx;\n double qyd = by - D * dy;\n ll px = (ll)round(pxd);\n ll py = (ll)round(pyd);\n ll qx = (ll)round(qxd);\n ll qy = (ll)round(qyd);\n if (px == qx && py == qy) continue;\n if (llabs(px) > 1000000000LL || llabs(py) > 1000000000LL || llabs(qx) > 1000000000LL || llabs(qy) > 1000000000LL) continue;\n Line llne{px, py, qx, qy};\n vector temp_fr(5501, 0);\n bool valid = true;\n for (size_t j = 0; j < parts.size() && valid; j++) {\n ll lcnt = 0, rcnt = 0;\n auto& grp = parts[j];\n for (int id : grp) {\n ll cr = compute_cross(llne, id);\n if (cr == 0) {\n valid = false;\n break;\n }\n if (cr > 0) lcnt++;\n else rcnt++;\n }\n if (valid) {\n if (lcnt > 0) temp_fr[lcnt]++;\n if (rcnt > 0) temp_fr[rcnt]++;\n }\n }\n if (!valid) continue;\n int newsat = 0;\n for (int d = 1; d <= 10; d++) {\n newsat += min(A[d], temp_fr[d]);\n }\n if (newsat > best_new) {\n best_new = newsat;\n best_l = llne;\n improved = true;\n }\n }\n }\n }\n if (improved) {\n chosen.push_back(best_l);\n vector> new_prts;\n for (auto& grp : parts) {\n vector leftv, rightv;\n for (int id : grp) {\n ll cr = compute_cross(best_l, id);\n if (cr > 0) leftv.push_back(id);\n else rightv.push_back(id);\n }\n if (!leftv.empty()) new_prts.push_back(leftv);\n if (!rightv.empty()) new_prts.push_back(rightv);\n }\n parts = std::move(new_prts);\n cur_sat = best_new;\n } else {\n break;\n }\n }\n if (cur_sat > best_sat) {\n best_sat = cur_sat;\n best_chosen = chosen;\n }\n }\n cout << best_chosen.size() << endl;\n for (auto& l : best_chosen) {\n cout << l.px << \" \" << l.py << \" \" << l.qx << \" \" << l.qy << endl;\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\nusing pii = pair;\n\nconst int MAXN = 65;\nbool has[MAXN][MAXN];\nbool uh[MAXN][MAXN];\nbool uv[MAXN][MAXN];\nbool udp[MAXN][MAXN];\nbool udm[MAXN][MAXN];\nint N;\n\nbool inb(int x) { return 0 <= x && x < N; }\n\nint get_w(int x, int y, int c) {\n int dx = x - c, dy = y - c;\n return dx * dx + dy * dy + 1;\n}\n\nbool is_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n return uh[y1][xx];\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n return uv[x1][yy];\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int xhigh = xlow + 1;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n return udp[xlow][y_at_low];\n } else if (dyh == -1) {\n return udm[xlow][y_at_low];\n }\n return true;\n }\n return true;\n}\n\nvoid set_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n uh[y1][xx] = true;\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n uv[x1][yy] = true;\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low;\n int y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n udp[xlow][y_at_low] = true;\n } else if (dyh == -1) {\n udm[xlow][y_at_low] = true;\n }\n }\n}\n\nbool clean_perim(const array& corn) {\n double cx = 0, cy = 0;\n for (auto& p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs.emplace_back(ang, i);\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0 && dy != 0) {\n steps = ady;\n uy = (dy > 0 ? 1 : -1);\n } else if (dy == 0 && dx != 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n uy = (dy > 0 ? 1 : -1);\n } else return false;\n for (int k = 1; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n if (has[xx][yy]) return false;\n }\n }\n return true;\n}\n\nbool edges_free(const array& corn) {\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs(4);\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs[i] = {ang, i};\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n } else return false;\n for (int k = 0; k < steps; k++) {\n int xx1 = x1 + k * ux;\n int yy1 = y1 + k * uy;\n int xx2 = xx1 + ux;\n int yy2 = yy1 + uy;\n if (is_used_unit(xx1, yy1, xx2, yy2)) return false;\n }\n }\n return true;\n}\n\nvector> cands;\nset> seen_set;\n\nvoid add_candidate(const array& corn) {\n array sorted_c = corn;\n sort(sorted_c.begin(), sorted_c.end());\n array key;\n for (int i = 0; i < 4; i++) {\n key[2 * i] = sorted_c[i].first;\n key[2 * i + 1] = sorted_c[i].second;\n }\n if (seen_set.count(key)) return;\n seen_set.insert(key);\n cands.push_back(corn);\n}\n\nbool get_three_missing(const array& corn, pii& newp) {\n int cnt_miss = 0;\n for (auto& pt : corn) {\n if (!has[pt.first][pt.second]) {\n newp = pt;\n cnt_miss++;\n if (cnt_miss > 1) return false;\n }\n }\n return cnt_miss == 1;\n}\n\nvoid try_from_pair(pii P, pii Q) {\n int px = P.first, py = P.second, qx = Q.first, qy = Q.second;\n if (!has[px][py] || !has[qx][qy]) return;\n if (px != qx && py != qy) {\n pii R = {px, qy};\n pii S = {qx, py};\n if (!inb(R.first) || !inb(R.second) || !inb(S.first) || !inb(S.second)) return;\n int hasR = has[R.first][R.second] ? 1 : 0;\n int hasS = has[S.first][S.second] ? 1 : 0;\n if (hasR + hasS == 1) {\n array corn = {P, Q, R, S};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n int dx = qx - px;\n int dy = qy - py;\n if ((dx + dy) % 2 == 0 && (dx - dy) % 2 == 0) {\n int p = (dx + dy) / 2;\n int q = (dx - dy) / 2;\n if (p != 0 && q != 0) {\n int bx = px + p;\n int by = py + p;\n int dx_ = px + q;\n int dy_ = py - q;\n if (inb(bx) && inb(by) && inb(dx_) && inb(dy_)) {\n int qcx = px + p + q;\n int qcy = py + p - q;\n if (qcx == qx && qcy == qy) {\n array corn = {{{px, py}, {bx, by}, {qx, qy}, {dx_, dy_}}};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n }\n }\n}\n\nint main() {\n int M;\n cin >> N >> M;\n vector init_dots(M);\n for (int i = 0; i < M; i++) {\n cin >> init_dots[i].first >> init_dots[i].second;\n }\n memset(has, 0, sizeof(has));\n memset(uh, 0, sizeof(uh));\n memset(uv, 0, sizeof(uv));\n memset(udp, 0, sizeof(udp));\n memset(udm, 0, sizeof(udm));\n for (auto& pt : init_dots) {\n has[pt.first][pt.second] = true;\n }\n int C = (N - 1) / 2;\n vector dots_list = init_dots;\n cands.clear();\n seen_set.clear();\n for (size_t i = 0; i < dots_list.size(); i++) {\n for (size_t j = i + 1; j < dots_list.size(); j++) {\n try_from_pair(dots_list[i], dots_list[j]);\n try_from_pair(dots_list[j], dots_list[i]);\n }\n }\n vector> answer_ops;\n for (int iter = 0; iter < 20000; iter++) {\n int best_w = -1;\n int best_idx = -1;\n pii best_new = {-1, -1};\n for (int ci = 0; ci < (int)cands.size(); ci++) {\n auto& corn = cands[ci];\n pii np;\n if (!get_three_missing(corn, np)) continue;\n if (has[np.first][np.second]) continue;\n if (!clean_perim(corn) || !edges_free(corn)) continue;\n int ww = get_w(np.first, np.second, C);\n if (ww > best_w) {\n best_w = ww;\n best_new = np;\n best_idx = ci;\n }\n }\n if (best_idx == -1) break;\n auto corn = cands[best_idx];\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n angs.emplace_back(atan2(corn[i].second - cy, corn[i].first - cx), i);\n }\n sort(angs.begin(), angs.end());\n vector ord;\n for (auto& a : angs) ord.push_back(corn[a.second]);\n int new_idx = -1;\n for (int i = 0; i < 4; i++)\n if (ord[i] == best_new) {\n new_idx = i;\n break;\n }\n if (new_idx == -1) continue;\n array op;\n op[0] = best_new.first;\n op[1] = best_new.second;\n for (int k = 0; k < 3; k++) {\n pii nxt = ord[(new_idx + 1 + k) % 4];\n op[2 + k * 2] = nxt.first;\n op[2 + k * 2 + 1] = nxt.second;\n }\n answer_ops.push_back(op);\n has[best_new.first][best_new.second] = true;\n dots_list.push_back(best_new);\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n }\n for (int k = 0; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n set_used_unit(xx, yy, xx + ux, yy + uy);\n }\n }\n for (auto& Q : dots_list) {\n if (Q == best_new) continue;\n try_from_pair(best_new, Q);\n try_from_pair(Q, best_new);\n }\n }\n cout << answer_ops.size() << endl;\n for (auto& arr : answer_ops) {\n for (int i = 0; i < 8; i++) {\n cout << arr[i];\n if (i < 7) cout << \" \";\n else cout << endl;\n }\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nlong long calc_score(const vector>& grid) {\n bool visited[10][10] = {};\n long long total = 0;\n auto dfs = [&](auto&& self, int r, int c, int flavor, int& cnt) -> void {\n visited[r][c] = true;\n cnt++;\n int dr[4] = {-1, 0, 1, 0};\n int dc[4] = {0, 1, 0, -1};\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !visited[nr][nc] && grid[nr][nc] == flavor) {\n self(self, nr, nc, flavor, cnt);\n }\n }\n };\n for (int flavor = 1; flavor <= 3; flavor++) {\n for (int r = 0; r < 10; r++) {\n for (int c = 0; c < 10; c++) {\n if (!visited[r][c] && grid[r][c] == flavor) {\n int cnt = 0;\n dfs(dfs, r, c, flavor, cnt);\n total += 1LL * cnt * cnt;\n }\n }\n }\n }\n return total;\n}\n\nlong long potential(const vector>& grid) {\n long long res = calc_score(grid);\n for (int fl = 1; fl <= 3; fl++) {\n for (int r = 0; r < 10; r++) {\n int cnt = 0;\n for (int c = 0; c < 10; c++) if (grid[r][c] == fl) cnt++;\n res += (1LL * cnt * cnt) / 4;\n }\n for (int c = 0; c < 10; c++) {\n int cnt = 0;\n for (int r = 0; r < 10; r++) if (grid[r][c] == fl) cnt++;\n res += (1LL * cnt * cnt) / 4;\n }\n }\n return res;\n}\n\nvoid apply(vector>& grid, char d) {\n if (d == 'F') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int r = 0; r < 10; r++) grid[r][c] = (r < (int)line.size() ? line[r] : 0);\n }\n } else if (d == 'B') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int r = 0; r < 10; r++) grid[r][c] = (r < 10 - ls ? 0 : line[r - (10 - ls)]);\n }\n } else if (d == 'L') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int c = 0; c < 10; c++) grid[r][c] = (c < (int)line.size() ? line[c] : 0);\n }\n } else if (d == 'R') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int c = 0; c < 10; c++) grid[r][c] = (c < 10 - ls ? 0 : line[c - (10 - ls)]);\n }\n }\n}\n\nint main() {\n vector> g(10, vector(10, 0));\n vector f(100);\n for (int &x : f) cin >> x;\n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n vector> empt;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (g[r][c] == 0) empt.emplace_back(r, c);\n auto [rr, cc] = empt[p - 1];\n g[rr][cc] = f[t];\n long double best_eval = -1;\n char best_d = 'F';\n bool has_next = (t < 99);\n int next_f = has_next ? f[t + 1] : -1;\n for (char d : {'F', 'B', 'L', 'R'}) {\n vector> ng = g;\n apply(ng, d);\n long long csc = potential(ng);\n long double fut = 0;\n if (has_next) {\n vector> ne;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (ng[r][c] == 0) ne.emplace_back(r, c);\n if (!ne.empty()) {\n long double sumf = 0;\n for (auto& pr : ne) {\n vector> ngp = ng;\n ngp[pr.first][pr.second] = next_f;\n long long bns = 0;\n for (char nd : {'F', 'B', 'L', 'R'}) {\n vector> ng2 = ngp;\n apply(ng2, nd);\n long long sc2 = potential(ng2);\n if (sc2 > bns) bns = sc2;\n }\n sumf += bns;\n }\n fut = sumf / ne.size();\n }\n }\n long double evalv = csc + fut;\n if (evalv > best_eval) {\n best_eval = evalv;\n best_d = d;\n }\n }\n apply(g, best_d);\n cout << best_d << endl;\n cout.flush();\n }\n return 0;\n}","ahc016":"#include \n#include \n\nusing namespace std;\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\nusing Eigen::SelfAdjointEigenSolver;\n\nint main() {\n int M;\n double eps;\n cin >> M >> eps;\n int N = 20;\n if (eps < 0.1) N = 12;\n else if (eps < 0.2) N = 18;\n else if (eps < 0.3) N = 25;\n else N = 35;\n N = max(N, (int)ceil(sqrt(2.0 * M)));\n N = min(N, 100);\n N = max(N, 4);\n vector G(M);\n for(int k = 0; k < M; k++) {\n double p = (double)(k + 1) / (M + 1);\n string s = \"\";\n for(int i = 0; i < N; i++) {\n for(int j = i + 1; j < N; j++) {\n long long seed = (long long)k * 123457 + (long long)i * 10007 + j;\n if ((seed % 100000LL) < (long long)(p * 100000)) {\n s += '1';\n } else {\n s += '0';\n }\n }\n }\n G[k] = s;\n }\n vector> pre_degs(M);\n vector> pre_eigs(M);\n for(int k = 0; k < M; k++) {\n auto& str = G[k];\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(str[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector d(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) d[i]++;\n sort(d.begin(), d.end());\n pre_degs[k] = d;\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector ev(N);\n for(int i = 0; i < N; i++) ev[i] = e(i);\n pre_eigs[k] = ev;\n }\n cout << N << endl;\n for(auto& g : G) {\n cout << g << endl;\n }\n cout.flush();\n double scale = 1 - 2 * eps;\n double bias = eps * (N - 1.0);\n for(int q = 0; q < 100; q++) {\n string H;\n cin >> H;\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(H[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector deg(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) deg[i]++;\n sort(deg.begin(), deg.end());\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector eig(N);\n for(int i = 0; i < N; i++) eig[i] = e(i);\n int best = 0;\n double min_dist = 1e100;\n for(int k = 0; k < M; k++) {\n double ddeg = 0;\n for(int i = 0; i < N; i++) {\n double exp_d = bias + scale * pre_degs[k][i];\n ddeg += (deg[i] - exp_d) * (deg[i] - exp_d);\n }\n ddeg = sqrt(ddeg);\n double deig = 0;\n vector eexp = pre_eigs[k];\n for(int i=0; i\nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n vector U(M), V(M);\n vector W(M);\n for(int i = 0; i < M; i++) {\n cin >> U[i] >> V[i] >> W[i];\n --U[i]; --V[i];\n }\n vector> pos(N);\n for(int i = 0; i < N; i++) {\n cin >> pos[i].first >> pos[i].second;\n }\n auto gen = [&](unsigned seed) -> vector {\n vector ass(M, -1);\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n mt19937 rng(seed);\n shuffle(ord.begin(), ord.end(), rng);\n for(int ei : ord) {\n int best = -1;\n int minc = INT_MAX;\n int minld = INT_MAX;\n for(int d = 0; d < D; d++) if(ld[d] < K) {\n int conf = vcnt[U[ei]][d] + vcnt[V[ei]][d];\n if(conf < minc || (conf == minc && ld[d] < minld)) {\n minc = conf;\n minld = ld[d];\n best = d;\n }\n }\n if(best == -1) {\n // fallback\n for(int d=0;d& ass) -> ll {\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = ass[i];\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n ll bad = 0;\n for(int v = 0; v <= N; v++) {\n for(int d = 0; d < D; d++) {\n int c = vcnt[v][d];\n bad += (ll)c * (c - 1);\n }\n }\n return bad;\n };\n vector best_ass;\n ll min_bad = LLONG_MAX;\n int trials = 5000;\n for(int t = 0; t < trials; t++) {\n vector ass = gen(t * 10007ULL + 123456789ULL);\n ll bd = compute_bad(ass);\n if(bd < min_bad) {\n min_bad = bd;\n best_ass = ass;\n }\n }\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = best_ass[i];\n ld[d]++;\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n bool improved = true;\n int max_passes = 300;\n mt19937 rng_rand(424242);\n for(int pass = 0; pass < max_passes && improved; pass++) {\n improved = false;\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng_rand);\n for(int ei : ord) {\n int cur = best_ass[ei];\n int uu = U[ei], vv = V[ei];\n ll best_delta = 0;\n int best_newd = -1;\n for(int d = 0; d < D; d++) if(d != cur && ld[d] < K) {\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta) {\n best_delta = delta;\n best_newd = d;\n }\n }\n if(best_newd != -1 && best_delta < 0) {\n int newd = best_newd;\n vcnt[uu][cur]--;\n vcnt[vv][cur]--;\n vcnt[uu][newd]++;\n vcnt[vv][newd]++;\n ld[cur]--;\n ld[newd]++;\n best_ass[ei] = newd;\n improved = true;\n }\n }\n }\n // Additional load balancing opt pass, move if not increase bad much and balances\n for(int iter=0; iter<50; iter++) {\n int maxl = 0, minl = INT_MAX;\n for(int d=0;d ord(M); iota(ord.begin(),ord.end(),0);\n shuffle(ord.begin(),ord.end(),rng_rand);\n for(int ei:ord) {\n int cur = best_ass[ei];\n if(ld[cur] <= minl +1) continue;\n int uu=U[ei],vv=V[ei];\n ll best_delta = LLONG_MAX/2;\n int bestd = -1;\n for(int d=0;d= maxl) continue;\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta){\n best_delta=delta;\n bestd =d;\n }\n }\n if(bestd !=-1 && best_delta < 1000LL){ // allow slight increase sometimes for balance\n int newd=bestd;\n vcnt[uu][cur]--; vcnt[vv][cur]--;\n vcnt[uu][newd]++; vcnt[vv][newd]++;\n ld[cur]--; ld[newd]++;\n best_ass[ei]=newd;\n moved=true;\n break;\n }\n }\n if(!moved) break;\n }\n for(int i = 0; i < M; i++) {\n if(i > 0) cout << \" \";\n cout << (best_ass[i] + 1);\n }\n cout << endl;\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Rod {\n int st, f1, f2, len;\n};\n\nstruct Rect {\n int sx, sy, sz, wx, wy;\n};\n\nint main() {\n int D;\n cin >> D;\n vector F[2], R[2];\n for (int i = 0; i < 2; i++) {\n F[i].resize(D);\n for (auto &s : F[i]) cin >> s;\n R[i].resize(D);\n for (auto &s : R[i]) cin >> s;\n }\n double best_eval = 1LL << 60;\n int best_n = 0;\n int best_block[2][15][15][15];\n for (int trial = 0; trial < 20; trial++) {\n bool voxels[2][15][15][15] = {};\n srand(trial * 12345 + 1);\n for (int ii = 0; ii < 2; ii++) {\n for (int z = 0; z < D; z++) {\n vector Xs, Ys;\n for (int x = 0; x < D; x++) if (F[ii][z][x] == '1') Xs.push_back(x);\n for (int y = 0; y < D; y++) if (R[ii][z][y] == '1') Ys.push_back(y);\n int a = Xs.size(), b = Ys.size();\n if (a == 0 || b == 0) continue;\n vector Xsort = Xs; sort(Xsort.begin(), Xsort.end());\n vector Ysort = Ys; sort(Ysort.begin(), Ysort.end());\n vector> assigns;\n vector target_b;\n if (a >= b) {\n int base = a / b; int rem = a % b;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem ? 1 : 0);\n for (int j = 0; j < cnt; j++) target_b.push_back(Ysort[iy]);\n }\n } else {\n for (int iy = 0; iy < b; iy++) {\n target_b.push_back(Ysort[iy]);\n }\n }\n random_shuffle(target_b.begin(), target_b.end());\n if (a >= b) {\n for (int k = 0; k < a; k++) {\n assigns.emplace_back(Xsort[k], target_b[k]);\n }\n } else {\n for (int k = 0; k < b; k++) {\n assigns.emplace_back(Xsort[k % a], target_b[k]);\n }\n }\n for (auto p : assigns) {\n voxels[ii][p.first][p.second][z] = true;\n }\n }\n }\n auto process_rod = [&](int di) {\n vector rlist[2][16];\n for (int i = 0; i < 2; i++) {\n if (di == 0) {\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n for (int x = 0; x < D; ) {\n if (!voxels[i][x][y][z]) { x++; continue; }\n int st = x;\n while (x < D && voxels[i][x][y][z]) x++;\n int l = x - st;\n rlist[i][l].push_back({st, y, z, l});\n }\n }\n } else if (di == 1) {\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) {\n for (int y = 0; y < D; ) {\n if (!voxels[i][x][y][z]) { y++; continue; }\n int st = y;\n while (y < D && voxels[i][x][y][z]) y++;\n int l = y - st;\n rlist[i][l].push_back({st, x, z, l});\n }\n }\n } else {\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; ) {\n if (!voxels[i][x][y][z]) { z++; continue; }\n int st = z;\n while (z < D && voxels[i][x][y][z]) z++;\n int l = z - st;\n rlist[i][l].push_back({st, x, y, l});\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n for (int l = 1; l <= D; l++) {\n int c[2] = {(int)rlist[0][l].size(), (int)rlist[1][l].size()};\n int sh = min(c[0], c[1]);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c[1] - sh) * l;\n rrs[1] += (c[0] - sh) * l;\n sinv += sh * 1.0 / l;\n for (int k = 0; k < c[0]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod& rd = rlist[0][l][k];\n if (di == 0) {\n for (int d = 0; d < l; d++) blockid[0][rd.st + d][rd.f1][rd.f2] = bid;\n } else if (di == 1) {\n for (int d = 0; d < l; d++) blockid[0][rd.f1][rd.st + d][rd.f2] = bid;\n } else {\n for (int d = 0; d < l; d++) blockid[0][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n for (int k = 0; k < c[1]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod& rd = rlist[1][l][k];\n if (di == 0) {\n for (int d = 0; d < l; d++) blockid[1][rd.st + d][rd.f1][rd.f2] = bid;\n } else if (di == 1) {\n for (int d = 0; d < l; d++) blockid[1][rd.f1][rd.st + d][rd.f2] = bid;\n } else {\n for (int d = 0; d < l; d++) blockid[1][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int p = 0; p < 2; p++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) best_block[p][x][y][z] = blockid[p][x][y][z];\n }\n };\n process_rod(0);\n process_rod(1);\n process_rod(2);\n auto try_rect_plane = [&](int plane) {\n map, vector> rects_key[2];\n for (int i = 0; i < 2; i++) {\n if (plane == 0) {\n for (int z = 0; z < D; z++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) layer[x][y] = voxels[i][x][y][z];\n while (true) {\n for (int x = 0; x < D; x++) {\n prefix[x][0] = 0;\n for (int y = 1; y <= D; y++) prefix[x][y] = prefix[x][y - 1] + (layer[x][y - 1] ? 1 : 0);\n }\n int max_area = 0, bx = -1, by = -1, bwx = 0, bwy = 0;\n for (int t = 0; t < D; t++) for (int b = t; b < D; b++) for (int l = 0; l < D; l++) for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int x = t; x <= b && ok; x++) if (prefix[x][r + 1] - prefix[x][l] != (r - l + 1)) ok = false;\n if (ok) {\n max_area = area; bx = t; by = l; bwx = b - t + 1; bwy = r - l + 1;\n }\n }\n if (max_area == 0) break;\n int mn = min(bwx, bwy), mx = max(bwx, bwy);\n rects_key[i][{mn, mx}].push_back({bx, by, z, bwx, bwy});\n for (int dx = 0; dx < bwx; dx++) for (int dy = 0; dy < bwy; dy++) layer[bx + dx][by + dy] = false;\n }\n }\n } else if (plane == 1) {\n for (int y = 0; y < D; y++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) layer[x][z] = voxels[i][x][y][z];\n while (true) {\n for (int x = 0; x < D; x++) {\n prefix[x][0] = 0;\n for (int z = 1; z <= D; z++) prefix[x][z] = prefix[x][z - 1] + (layer[x][z - 1] ? 1 : 0);\n }\n int max_area = 0, bx = -1, bz = -1, bwx = 0, bwz = 0;\n for (int t = 0; t < D; t++) for (int b = t; b < D; b++) for (int l = 0; l < D; l++) for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int x = t; x <= b && ok; x++) if (prefix[x][r + 1] - prefix[x][l] != (r - l + 1)) ok = false;\n if (ok) {\n max_area = area; bx = t; bz = l; bwx = b - t + 1; bwz = r - l + 1;\n }\n }\n if (max_area == 0) break;\n int mn = min(bwx, bwz), mx = max(bwx, bwz);\n rects_key[i][{mn, mx}].push_back({bx, y, bz, bwx, bwz});\n for (int dx = 0; dx < bwx; dx++) for (int dz = 0; dz < bwz; dz++) layer[bx + dx][bz + dz] = false;\n }\n }\n } else {\n for (int x = 0; x < D; x++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) layer[y][z] = voxels[i][x][y][z];\n while (true) {\n for (int y = 0; y < D; y++) {\n prefix[y][0] = 0;\n for (int z = 1; z <= D; z++) prefix[y][z] = prefix[y][z - 1] + (layer[y][z - 1] ? 1 : 0);\n }\n int max_area = 0, by = -1, bz = -1, bwy = 0, bwz = 0;\n for (int t = 0; t < D; t++) for (int b = t; b < D; b++) for (int l = 0; l < D; l++) for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int y = t; y <= b && ok; y++) if (prefix[y][r + 1] - prefix[y][l] != (r - l + 1)) ok = false;\n if (ok) {\n max_area = area; by = t; bz = l; bwy = b - t + 1; bwz = r - l + 1;\n }\n }\n if (max_area == 0) break;\n int mn = min(bwy, bwz), mx = max(bwy, bwz);\n rects_key[i][{mn, mx}].push_back({x, by, bz, bwy, bwz});\n for (int dy = 0; dy < bwy; dy++) for (int dz = 0; dz < bwz; dz++) layer[by + dy][bz + dz] = false;\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n vector> all_keys;\n for (auto& p : rects_key[0]) all_keys.push_back(p.first);\n for (auto& p : rects_key[1]) all_keys.push_back(p.first);\n sort(all_keys.begin(), all_keys.end());\n auto last = unique(all_keys.begin(), all_keys.end());\n all_keys.erase(last, all_keys.end());\n for (auto& key : all_keys) {\n int v = key.first * key.second;\n int c0 = rects_key[0].count(key) ? rects_key[0][key].size() : 0;\n int c1 = rects_key[1].count(key) ? rects_key[1][key].size() : 0;\n int sh = min(c0, c1);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c1 - sh) * v;\n rrs[1] += (c0 - sh) * v;\n sinv += sh * (1.0 / v);\n for (int k = 0; k < c0; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rect& rd = rects_key[0][key][k];\n if (plane == 0) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dy = 0; dy < rd.wy; dy++) blockid[0][rd.sx + dx][rd.sy + dy][rd.sz] = bid;\n } else if (plane == 1) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dz = 0; dz < rd.wy; dz++) blockid[0][rd.sx + dx][rd.sy][rd.sz + dz] = bid;\n } else {\n for (int dy = 0; dy < rd.wx; dy++) for (int dz = 0; dz < rd.wy; dz++) blockid[0][rd.sx][rd.sy + dy][rd.sz + dz] = bid;\n }\n }\n for (int k = 0; k < c1; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rect& rd = rects_key[1][key][k];\n if (plane == 0) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dy = 0; dy < rd.wy; dy++) blockid[1][rd.sx + dx][rd.sy + dy][rd.sz] = bid;\n } else if (plane == 1) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dz = 0; dz < rd.wy; dz++) blockid[1][rd.sx + dx][rd.sy][rd.sz + dz] = bid;\n } else {\n for (int dy = 0; dy < rd.wx; dy++) for (int dz = 0; dz < rd.wy; dz++) blockid[1][rd.sx][rd.sy + dy][rd.sz + dz] = bid;\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int p = 0; p < 2; p++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) best_block[p][x][y][z] = blockid[p][x][y][z];\n }\n };\n try_rect_plane(0);\n try_rect_plane(1);\n try_rect_plane(2);\n }\n cout << best_n << endl;\n for (int i = 0; i < 2; i++) {\n for (int pos = 0; pos < D * D * D; pos++) {\n int x = pos / (D * D);\n int rem = pos % (D * D);\n int y = rem / D;\n int z = rem % D;\n cout << best_block[i][x][y][z];\n if (pos < D * D * D - 1) cout << \" \";\n }\n cout << endl;\n }\n return 0;\n}","ahc020":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct UF {\n vector p, r;\n UF(int n) : p(n+1), r(n+1, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }\n bool unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return false;\n if (r[x] < r[y]) swap(x, y);\n p[y] = x;\n if (r[x] == r[y]) r[x]++;\n return true;\n }\n};\n\nstruct Edge {\n int u, v, idx;\n ll w;\n};\n\nstruct TEdge {\n int to, eidx;\n ll w;\n};\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector X(N+1), Y(N+1);\n for (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n vector alledges(M);\n for (int j = 0; j < M; j++) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n alledges[j] = {u, v, j, w};\n }\n vector A(K+1), B(K+1);\n for (int k = 1; k <= K; k++) cin >> A[k] >> B[k];\n vector> dist2(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll dx = X[i] - A[k];\n ll dy = Y[i] - B[k];\n dist2[i][k] = dx * dx + dy * dy;\n }\n }\n vector> minP(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll d2 = dist2[i][k];\n if (d2 == 0) {\n minP[i][k] = 0;\n continue;\n }\n ll low = 0, high = 100000;\n while (low < high) {\n ll mid = (low + high) / 2;\n if (mid * mid >= d2) high = mid;\n else low = mid + 1;\n }\n minP[i][k] = low;\n }\n }\n UF uf(N);\n vector mst_edges = alledges;\n sort(mst_edges.begin(), mst_edges.end(), [](const Edge& e1, const Edge& e2) { return e1.w < e2.w; });\n vector> tree(N+1);\n for (auto& e : mst_edges) {\n if (uf.unite(e.u, e.v)) {\n tree[e.u].push_back({e.v, e.idx, e.w});\n tree[e.v].push_back({e.u, e.idx, e.w});\n }\n }\n vector> children(N+1);\n function build = [&](int u, int par) {\n for (auto& e : tree[u]) {\n if (e.to != par) {\n children[u].push_back(e);\n build(e.to, u);\n }\n }\n };\n build(1, -1);\n using pbb = pair;\n function&, const vector&)> dfs_conn = [&](int u, set& usedids, const vector& term) -> pbb {\n bool has = term[u];\n ll cst = 0;\n for (auto& e : children[u]) {\n auto [sc, sh] = dfs_conn(e.to, usedids, term);\n if (sh) {\n cst += e.w + sc;\n has = true;\n usedids.insert(e.eidx);\n } else {\n cst += sc;\n }\n }\n return {cst, has};\n };\n auto get_conn = [&](const vector& t, set& used) -> ll {\n auto [c, h] = dfs_conn(1, used, t);\n return c;\n };\n mt19937 rng(42);\n int best_R = 35;\n ll best_init_score = LLONG_MAX / 2;\n vector best_is_selected(N+1, false);\n for (int rr = 25; rr <= 45; rr += 5) {\n int R = rr;\n vector cx(R), cy(R);\n for (int c = 0; c < R; c++) {\n int randk = 1 + rng() % K;\n cx[c] = A[randk];\n cy[c] = B[randk];\n }\n vector cluster_assign(K+1, 0);\n for (int it = 0; it < 20; it++) {\n vector sx(R, 0), sy(R, 0);\n vector cnt(R, 0);\n for (int k = 1; k <= K; k++) {\n ll bd = LLONG_MAX;\n int bc = 0;\n for (int c = 0; c < R; c++) {\n ll dx = A[k] - cx[c];\n ll dy = B[k] - cy[c];\n ll d = dx * dx + dy * dy;\n if (d < bd) {\n bd = d;\n bc = c;\n }\n }\n cluster_assign[k] = bc;\n sx[bc] += A[k];\n sy[bc] += B[k];\n cnt[bc]++;\n }\n for (int c = 0; c < R; c++) {\n if (cnt[c] > 0) {\n cx[c] = sx[c] / cnt[c];\n cy[c] = sy[c] / cnt[c];\n }\n }\n }\n vector is_selected(N+1, false);\n for (int c = 0; c < R; c++) {\n ll bd = LLONG_MAX;\n int bi = 1;\n for (int i = 1; i <= N; i++) {\n ll dx = X[i] - cx[c];\n ll dy = Y[i] - cy[c];\n ll d = dx * dx + dy * dy;\n if (d < bd) {\n bd = d;\n bi = i;\n }\n }\n is_selected[bi] = true;\n }\n is_selected[1] = true;\n vector> temp_res(N+1);\n vector temp_assign(K+1, 0);\n vector> temp_req(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 1; i <= N; i++) if (is_selected[i]) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n if (bp > 5000) {\n best = 1; bp = minP[1][k];\n for (int i = 2; i <= N; i++) if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n temp_assign[k] = best;\n temp_res[best].push_back(k);\n temp_req[best].insert(bp);\n }\n vector temp_P(N+1, 0);\n ll temp_sq = 0;\n for (int i = 1; i <= N; i++) if (!temp_req[i].empty()) {\n temp_P[i] = *temp_req[i].rbegin();\n temp_sq += (ll)temp_P[i]*temp_P[i];\n }\n vector temp_open(N+1, false);\n for(int i=1;i<=N;i++) if(!temp_req[i].empty()) temp_open[i]=true;\n vector temp_term(N+1,false);\n for(int i=1;i<=N;i++) temp_term[i] = (temp_P[i]>0) || i==1;\n set dum;\n ll temp_conn = get_conn(temp_term, dum);\n ll this_score = temp_sq + temp_conn;\n if (this_score < best_init_score) {\n best_init_score = this_score;\n best_R = rr;\n best_is_selected = is_selected;\n }\n }\n vector is_selected = best_is_selected;\n vector> res_list(N+1);\n vector assignment(K+1, 0);\n vector> reqs(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 1; i <= N; i++) if (is_selected[i]) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n if (bp > 5000) {\n best = 1; bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n }\n assignment[k] = best;\n res_list[best].push_back(k);\n reqs[best].insert(bp);\n }\n vector curP(N+1, 0);\n ll sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n }\n }\n vector is_open(N+1, false);\n for (int i = 1; i <= N; i++) if (curP[i] > 0) is_open[i] = true;\n auto compute_curr_term = [&]() -> vector {\n vector t(N+1, false);\n for (int i = 1; i <= N; i++) t[i] = (curP[i] > 0) || (i == 1);\n return t;\n };\n vector curr_term = compute_curr_term();\n set dummy_used;\n ll cur_conn = get_conn(curr_term, dummy_used);\n ll current_total = sum_sq + cur_conn;\n auto re_voronoi = [&]() {\n vector opens;\n for (int i = 1; i <= N; i++) if (is_open[i]) opens.push_back(i);\n if (opens.empty()) {\n is_open[1] = true;\n opens.push_back(1);\n }\n bool changed = false;\n vector> new_reqs(N+1);\n vector> new_res_list(N+1);\n vector new_assign(K+1, 0);\n for (int k = 1; k <= K; k++) {\n int best = opens[0], bp = minP[opens[0]][k];\n for (int j : opens) {\n if (minP[j][k] < bp) {\n bp = minP[j][k];\n best = j;\n }\n }\n if (bp > 5000) {\n best = 1; bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n }\n new_assign[k] = best;\n new_res_list[best].push_back(k);\n new_reqs[best].insert(bp);\n if (assignment[k] != best) changed = true;\n }\n if (!changed) return;\n reqs = new_reqs;\n res_list = new_res_list;\n assignment = new_assign;\n sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n } else curP[i] = 0;\n }\n for (int i = 1; i <= N; i++) is_open[i] = !reqs[i].empty();\n curr_term = compute_curr_term();\n set dum;\n cur_conn = get_conn(curr_term, dum);\n current_total = sum_sq + cur_conn;\n };\n const int MAX_ITER = 40;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool improved = false;\n for (int k = 1; k <= K; k++) {\n int curr = assignment[k];\n if (!is_open[curr]) continue;\n int reqc = minP[curr][k];\n for (int j = 1; j <= N; j++) if (is_open[j] && j != curr && minP[j][k] <= 5000) {\n int reqn = minP[j][k];\n auto it = reqs[curr].find(reqc);\n if (it != reqs[curr].end()) reqs[curr].erase(it);\n ll tpc = reqs[curr].empty() ? 0LL : *reqs[curr].rbegin();\n reqs[j].insert(reqn);\n ll tpj = *reqs[j].rbegin();\n ll dsq = tpc * tpc + tpj * tpj - (ll)curP[curr] * curP[curr] - (ll)curP[j] * curP[j];\n bool will_close = (curP[curr] > 0 && (int)tpc == 0);\n ll dcon = 0;\n if (will_close) {\n vector np = curP;\n np[curr] = tpc;\n np[j] = tpj;\n vector tterm(N+1, false);\n for (int ii = 1; ii <= N; ii++) tterm[ii] = (np[ii] > 0) || (ii == 1);\n set dum;\n ll newc = get_conn(tterm, dum);\n dcon = newc - cur_conn;\n }\n reqs[j].erase(reqs[j].find(reqn));\n reqs[curr].insert(reqc);\n if (dsq + dcon < 0) {\n reqs[curr].erase(reqs[curr].find(reqc));\n reqs[j].insert(reqn);\n auto& lst = res_list[curr];\n for (size_t pos = 0; pos < lst.size(); pos++) if (lst[pos] == k) {\n swap(lst[pos], lst.back());\n lst.pop_back();\n break;\n }\n res_list[j].push_back(k);\n assignment[k] = j;\n curP[curr] = (int)tpc;\n curP[j] = (int)tpj;\n sum_sq += dsq;\n if (will_close) {\n is_open[curr] = false;\n curr_term[curr] = (tpc > 0) || curr == 1;\n curr_term[j] = true;\n cur_conn += dcon;\n }\n current_total += dsq + dcon;\n improved = true;\n break;\n }\n }\n if (improved) break;\n }\n if (!improved) {\n for (int i = 1; i <= N && !improved; i++) if (is_open[i]) {\n vector new_add(N+1, 0);\n bool can = true;\n vector> move_info;\n for (auto kk : res_list[i]) {\n int altj = -1, altp = INT_MAX / 2;\n for (int jj = 1; jj <= N; jj++) if (is_open[jj] && jj != i) {\n if (minP[jj][kk] < altp && minP[jj][kk] <= 5000) {\n altp = minP[jj][kk];\n altj = jj;\n }\n }\n if (altp > 5000) {\n can = false;\n break;\n }\n if (altj != -1) {\n new_add[altj] = max(new_add[altj], altp);\n move_info.emplace_back(kk, altj);\n }\n }\n if (!can) continue;\n ll dsq = -(ll)curP[i] * curP[i];\n vector new_p(N+1);\n for (int ii = 1; ii <= N; ii++) new_p[ii] = curP[ii];\n new_p[i] = 0;\n for (int jj = 1; jj <= N; jj++) if (new_add[jj] > 0) {\n int oldpj = curP[jj];\n new_p[jj] = max(oldpj, new_add[jj]);\n dsq += (ll)new_p[jj] * new_p[jj] - (ll)oldpj * oldpj;\n }\n vector tterm(N+1, false);\n for (int ii = 1; ii <= N; ii++) tterm[ii] = (new_p[ii] > 0) || (ii == 1);\n set dum;\n ll new_conn_val = get_conn(tterm, dum);\n ll dcon = new_conn_val - cur_conn;\n if (dsq + dcon < 0) {\n for (auto [kk, altj] : move_info) {\n if (altj == -1) continue;\n reqs[i].erase(reqs[i].find(minP[i][kk]));\n reqs[altj].insert(minP[altj][kk]);\n auto& l = res_list[i];\n for (size_t p = 0; p < l.size(); p++) if (l[p] == kk) {\n swap(l[p], l.back());\n l.pop_back();\n break;\n }\n res_list[altj].push_back(kk);\n assignment[kk] = altj;\n }\n reqs[i].clear();\n res_list[i].clear();\n for (int jj = 1; jj <= N; jj++) {\n int np = reqs[jj].empty() ? 0 : *reqs[jj].rbegin();\n curP[jj] = np;\n }\n sum_sq += dsq;\n is_open[i] = false;\n cur_conn = new_conn_val;\n curr_term = compute_curr_term();\n current_total += dsq + dcon;\n improved = true;\n }\n }\n }\n if (iter % 5 == 0) re_voronoi();\n if (!improved) break;\n }\n re_voronoi();\n vector final_term = curr_term;\n set final_used;\n auto fc = get_conn(final_term, final_used);\n vector Bs(M, 0);\n for (int ei : final_used) if (ei >= 0 && ei < M) Bs[ei] = 1;\n for (int i = 1; i <= N; i++) {\n if (curP[i] > 5000) curP[i] = 5000;\n cout << curP[i];\n if (i < N) cout << \" \";\n else cout << \"\\n\";\n }\n for (int j = 0; j < M; j++) {\n cout << Bs[j];\n if (j < M - 1) cout << \" \";\n else cout << \"\\n\";\n }\n return 0;\n}","ahc021":"#include \nusing namespace std;\nusing P = pair;\n\nstruct Sw {\n int x1, y1, x2, y2;\n};\n\nvector run_simulation(const vector>& init_grid, const vector

& init_pos, mt19937& rng, bool use_random) {\n int N = 30;\n int total = 465;\n vector> grid = init_grid;\n vector

curr_pos = init_pos;\n vector> is_fixed(N, vector(N, false));\n vector ops;\n auto get_parents = [&](P p) -> vector

{\n auto [x, y] = p;\n vector

res;\n if (x > 0) {\n if (y <= x - 1) res.emplace_back(x - 1, y);\n if (y - 1 >= 0) {\n int py = y - 1;\n if (py <= x - 1) res.emplace_back(x - 1, py);\n }\n }\n return res;\n };\n auto get_neighbors = [&](P p) -> vector

{\n int x = p.first, y = p.second;\n vector

res;\n vector> deltas = {{-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}};\n for (auto [dx, dy] : deltas) {\n int nx = x + dx, ny = y + dy;\n if (nx >= 0 && nx < N && ny >= 0 && ny <= nx) res.emplace_back(nx, ny);\n }\n return res;\n };\n for (int k = 0; k < total; k++) {\n vector

avail;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n if (is_fixed[x][y]) continue;\n auto pars = get_parents({x, y});\n bool can = true;\n for (auto pp : pars) {\n if (!is_fixed[pp.first][pp.second]) {\n can = false;\n break;\n }\n }\n if (can) avail.emplace_back(x, y);\n }\n }\n P start = curr_pos[k];\n vector> dist(N, vector(N, -1));\n vector> par(N, vector

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

q;\n if (start.first >= 0 && start.first < N && start.second >= 0 && start.second <= start.first && !is_fixed[start.first][start.second]) {\n dist[start.first][start.second] = 0;\n q.push(start);\n }\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (nx.first < N && nx.second >= 0 && nx.second <= nx.first && !is_fixed[nx.first][nx.second] && dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n vector> cands;\n for (auto cand : avail) {\n if (cand.first < N && cand.second <= cand.first) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1) {\n cands.emplace_back(dx, cand);\n }\n }\n }\n if (cands.empty()) {\n return {};\n }\n sort(cands.begin(), cands.end());\n int min_d_val = cands[0].first;\n vector

min_targets;\n for (auto& pr : cands) {\n if (pr.first == min_d_val) min_targets.push_back(pr.second);\n }\n P target = min_targets[0];\n if (use_random && min_targets.size() > 1) {\n uniform_int_distribution d(0, (int)min_targets.size() - 1);\n target = min_targets[d(rng)];\n }\n vector

path;\n P curp = target;\n while (true) {\n path.push_back(curp);\n if (dist[curp.first][curp.second] == 0) break;\n curp = par[curp.first][curp.second];\n if (curp.first == -1) break;\n }\n reverse(path.begin(), path.end());\n for (size_t i = 0; i + 1 < path.size(); ++i) {\n P p1 = path[i];\n P p2 = path[i + 1];\n int v1 = grid[p1.first][p1.second];\n int v2 = grid[p2.first][p2.second];\n swap(grid[p1.first][p1.second], grid[p2.first][p2.second]);\n curr_pos[v1] = p2;\n curr_pos[v2] = p1;\n ops.push_back({p1.first, p1.second, p2.first, p2.second});\n }\n is_fixed[target.first][target.second] = true;\n }\n return ops;\n}\n\nint main() {\n int N = 30;\n vector> init_grid(N);\n for (int x = 0; x < N; x++) {\n init_grid[x].resize(x + 1);\n for (int y = 0; y <= x; y++) {\n cin >> init_grid[x][y];\n }\n }\n int total = N * (N + 1) / 2;\n vector

init_pos(total);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int val = init_grid[x][y];\n init_pos[val] = {x, y};\n }\n }\n mt19937 rng(42);\n long long best_K = LLONG_MAX;\n vector best_ops;\n int num_trials = 80;\n for (int t = 0; t < num_trials; t++) {\n vector ops = run_simulation(init_grid, init_pos, rng, true);\n if (!ops.empty() && (long long)ops.size() < best_K) {\n best_K = ops.size();\n best_ops = ops;\n }\n }\n if (best_K == LLONG_MAX) {\n vector ops = run_simulation(init_grid, init_pos, rng, false);\n if (!ops.empty()) {\n best_K = ops.size();\n best_ops = ops;\n } else {\n cout << 0 << endl;\n return 0;\n }\n }\n cout << best_K << endl;\n for (auto& s : best_ops) {\n cout << s.x1 << \" \" << s.y1 << \" \" << s.x2 << \" \" << s.y2 << endl;\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n int D, N;\n cin >> D >> N;\n bool is_obst[9][9] = {};\n int cont[9][9];\n memset(cont, -1, sizeof(cont));\n for (int k = 0; k < N; k++) {\n int ri, rj;\n cin >> ri >> rj;\n is_obst[ri][rj] = true;\n cont[ri][rj] = -2;\n }\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n auto is_valid = [&](int x, int y) { return x >= 0 && x < 9 && y >= 0 && y < 9; };\n int dist[9][9];\n int visit_ord[9][9];\n memset(dist, -1, sizeof(dist));\n memset(visit_ord, -1, sizeof(visit_ord));\n {\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n dist[0][4] = 0;\n visit_ord[0][4] = 0;\n int ord = 1;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n vis[nx][ny] = true;\n dist[nx][ny] = dist[x][y] + 1;\n visit_ord[nx][ny] = ord++;\n q.push({nx, ny});\n }\n }\n }\n int M = 0;\n for (int i = 0; i < 9; i++)\n for (int j = 0; j < 9; j++)\n if (!is_obst[i][j] && !(i == 0 && j == 4)) M++;\n int placed_count = 0;\n set remain;\n for (int i = 0; i < M; i++) remain.insert(i);\n auto get_reach = [&]() -> vector> {\n vector> res;\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n if (cont[nx][ny] >= 0) continue;\n vis[nx][ny] = true;\n q.push({nx, ny});\n if ((nx || ny != 4) && cont[nx][ny] == -1) res.push_back({nx, ny});\n }\n }\n return res;\n };\n auto is_safe_pos = [&](int px, int py, int curr_rem) -> bool {\n cont[px][py] = 100000;\n auto nr = get_reach();\n cont[px][py] = -1;\n return nr.size() == (size_t)(curr_rem - 1);\n };\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n vector> reach = get_reach();\n int curr_rem = M - placed_count;\n vector> cands;\n for (auto p : reach) {\n if (is_safe_pos(p.first, p.second, curr_rem)) {\n cands.push_back(p);\n }\n }\n if (cands.empty()) {\n cands = reach;\n }\n auto cmp = [&](const pair& a, const pair& b) {\n if (dist[a.first][a.second] != dist[b.first][b.second])\n return dist[a.first][a.second] < dist[b.first][b.second];\n return visit_ord[a.first][a.second] < visit_ord[b.first][b.second];\n };\n sort(cands.begin(), cands.end(), cmp);\n int j = 0;\n for (int rid : remain) {\n if (rid == t) break;\n j++;\n }\n pair place_pos;\n if (!cands.empty() && j < (int)cands.size()) {\n place_pos = cands[j];\n } else if (!cands.empty()) {\n place_pos = cands.back();\n } else {\n place_pos = {0, 0}; // fallback error\n }\n cout << place_pos.first << \" \" << place_pos.second << endl;\n cont[place_pos.first][place_pos.second] = t;\n placed_count++;\n remain.erase(t);\n }\n vector> rem_order;\n bool cleared[9][9] = {};\n cleared[0][4] = true;\n for (int step = 0; step < M; step++) {\n vector> acc;\n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (cont[i][j] < 0) continue;\n if (cleared[i][j]) continue;\n bool can = false;\n for (int d = 0; d < 4; d++) {\n int nx = i + dx[d], ny = j + dy[d];\n if (is_valid(nx, ny) && !is_obst[nx][ny] && cleared[nx][ny]) {\n can = true;\n break;\n }\n }\n if (can) acc.emplace_back(i, j);\n }\n }\n if (acc.empty()) break;\n int minid = INT_MAX;\n pair chosen = {-1, -1};\n for (auto p : acc) {\n int id = cont[p.first][p.second];\n if (id < minid) {\n minid = id;\n chosen = p;\n }\n }\n rem_order.push_back(chosen);\n cleared[chosen.first][chosen.second] = true;\n cont[chosen.first][chosen.second] = -1;\n }\n for (auto p : rem_order) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n vector>>> witnesses(\n m + 1, vector>>(m + 1));\n bitset<101> has_adj[101];\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n bool is_bound = (i == 0 || i == n - 1 || j == 0 || j == n - 1);\n if (is_bound) {\n witnesses[c][0].push_back({i, j});\n has_adj[c][0] = 1;\n has_adj[0][c] = 1;\n }\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int nc = grid[ni][nj];\n if (c != nc) {\n witnesses[c][nc].push_back({i, j});\n has_adj[c][nc] = 1;\n has_adj[nc][c] = 1;\n }\n }\n }\n }\n }\n vector> cent(m + 1, vector(2, 0.0));\n for (int c = 1; c <= m; c++) {\n long long si = 0, sj = 0, cnt = 0;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n si += i;\n sj += j;\n cnt++;\n }\n }\n }\n if (cnt > 0) {\n cent[c][0] = si * 1.0 / cnt;\n cent[c][1] = sj * 1.0 / cnt;\n }\n }\n vector>> term_set(m + 1);\n for (int c = 1; c <= m; c++) {\n if (has_adj[c][0] && !witnesses[c][0].empty()) {\n double mind = 1e9;\n pair best = witnesses[c][0][0];\n for (auto p : witnesses[c][0]) {\n double dd = abs(p.first - cent[c][0]) + abs(p.second - cent[c][1]);\n if (dd < mind) {\n mind = dd;\n best = p;\n }\n }\n term_set[c].insert(best);\n }\n }\n for (int c = 1; c <= m; c++) {\n for (int d = c + 1; d <= m; d++) {\n if (has_adj[c][d]) {\n bool picked = false;\n if (!witnesses[c][d].empty()) {\n double mind = 1e9;\n pair best = witnesses[c][d][0];\n for (auto p : witnesses[c][d]) {\n double dd = abs(p.first - cent[c][0]) + abs(p.second - cent[c][1]);\n if (dd < mind) {\n mind = dd;\n best = p;\n }\n }\n int ci = best.first, cj = best.second;\n for (int dir = 0; dir < 4; dir++) {\n int ni = ci + dx[dir], nj = cj + dy[dir];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == d) {\n term_set[c].insert(best);\n term_set[d].insert({ni, nj});\n picked = true;\n break;\n }\n }\n }\n if (!picked && !witnesses[d][c].empty()) {\n double mind = 1e9;\n pair best = witnesses[d][c][0];\n for (auto p : witnesses[d][c]) {\n double dd = abs(p.first - cent[d][0]) + abs(p.second - cent[d][1]);\n if (dd < mind) {\n mind = dd;\n best = p;\n }\n }\n int di = best.first, dj = best.second;\n for (int dir = 0; dir < 4; dir++) {\n int ni = di + dx[dir], nj = dj + dy[dir];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == c) {\n term_set[d].insert(best);\n term_set[c].insert({ni, nj});\n picked = true;\n break;\n }\n }\n }\n }\n }\n }\n for (int c = 1; c <= m; c++) {\n if (term_set[c].empty()) {\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n term_set[c].insert({i, j});\n break;\n }\n }\n if (!term_set[c].empty()) break;\n }\n }\n }\n vector>> terminals(m + 1);\n for (int c = 1; c <= m; c++) {\n for (auto p : term_set[c]) terminals[c].push_back(p);\n }\n vector> iskept(n, vector(n, false));\n for (int c = 1; c <= m; c++) {\n if (terminals[c].empty()) continue;\n auto root = terminals[c][0];\n int sx = root.first, sy = root.second;\n vector> dist(n, vector(n, -1));\n vector>> parent(n, vector>(n, {-1, -1}));\n queue> qq;\n qq.push({sx, sy});\n dist[sx][sy] = 0;\n while (!qq.empty()) {\n auto [x, y] = qq.front();\n qq.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || dist[nx][ny] != -1 || grid[nx][ny] != c) continue;\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n qq.push({nx, ny});\n }\n }\n set> sk;\n for (auto &t : terminals[c]) {\n int cx = t.first, cy = t.second;\n while (true) {\n if (cx == -1 || dist[cx][cy] == -1) break;\n sk.insert({cx, cy});\n if (cx == sx && cy == sy) break;\n auto [px, py] = parent[cx][cy];\n cx = px;\n cy = py;\n }\n }\n for (auto p : sk) {\n iskept[p.first][p.second] = true;\n }\n }\n auto do_fix = [&]( ) -> bool {\n vector> current(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) current[i][j] = grid[i][j];\n }\n }\n vector> to_add;\n bool changed = false;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = current[i][j];\n if (c == 0) continue;\n if (has_adj[c][0]) continue;\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && current[ni][nj] == 0) {\n to_add.push_back({ni, nj});\n changed = true;\n }\n }\n }\n }\n vector> vis(n, vector(n, false));\n queue> q0;\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) && current[i][j] == 0) {\n q0.push({i, j});\n vis[i][j] = true;\n }\n }\n }\n while (!q0.empty()) {\n auto [x, y] = q0.front();\n q0.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || vis[nx][ny] || current[nx][ny] != 0) continue;\n vis[nx][ny] = true;\n q0.push({nx, ny});\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (current[i][j] == 0 && !vis[i][j]) {\n to_add.push_back({i, j});\n changed = true;\n }\n }\n }\n for (auto [i, j] : to_add) {\n if (!iskept[i][j]) {\n iskept[i][j] = true;\n }\n }\n return changed;\n };\n auto reconnect = [&]( ) {\n for (int c = 1; c <= m; c++) {\n vector> kept_c;\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (iskept[i][j] && grid[i][j] == c) kept_c.push_back({i, j});\n if (kept_c.empty()) continue;\n vector> comp(n, vector(n, -1));\n int numcom = 0;\n for (auto [x, y] : kept_c) {\n if (comp[x][y] != -1) continue;\n numcom++;\n queue> q;\n q.push({x, y});\n comp[x][y] = numcom;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d], ny = cy + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || comp[nx][ny] != -1 || !iskept[nx][ny] || grid[nx][ny] != c) continue;\n comp[nx][ny] = numcom;\n q.push({nx, ny});\n }\n }\n }\n if (numcom <= 1) continue;\n vector> reps(numcom + 1, {-1, -1});\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (comp[i][j] != -1 && reps[comp[i][j]].first == -1) reps[comp[i][j]] = {i, j};\n pair rootp = reps[1];\n int sx = rootp.first, sy = rootp.second;\n vector> dist(n, vector(n, -1));\n vector>> par(n, vector>(n, {-1, -1}));\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx >= 0 && nx < n && ny >= 0 && ny < n && grid[nx][ny] == c && dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n par[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n set> addsk;\n for (int com = 2; com <= numcom; com++) {\n auto [cx, cy] = reps[com];\n int curx = cx, cury = cy;\n while (curx != -1) {\n if (dist[curx][cury] == -1) break;\n addsk.insert({curx, cury});\n if (curx == sx && cury == sy) break;\n auto p = par[curx][cury];\n curx = p.first;\n cury = p.second;\n }\n }\n for (auto p : addsk) {\n iskept[p.first][p.second] = true;\n }\n }\n };\n bool changed = true;\n int maxb = 30;\n for (int bigl = 0; bigl < maxb && changed; bigl++) {\n reconnect();\n changed = do_fix();\n }\n vector> final(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) final[i][j] = grid[i][j];\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j > 0) cout << \" \";\n cout << final[i][j];\n }\n cout << endl;\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n srand(time(NULL));\n int N, D, Q;\n cin >> N >> D >> Q;\n vector> adj(N);\n vector outdeg(N, 0);\n bitset<128> dcomp[100];\n auto compute_ranks = [&]( ) -> vector {\n vector memo(N, -1);\n function dfs = [&](int u) -> int {\n if (memo[u] != -1) return memo[u];\n int mx = 0;\n for (int v : adj[u]) {\n mx = max(mx, dfs(v) + 1);\n }\n return memo[u] = mx;\n };\n for (int i = 0; i < N; i++) {\n dfs(i);\n }\n return memo;\n };\n for (int q = 0; q < Q; q++) {\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n bool found = false;\n pair to_comp = {-1, -1};\n for (int dist = 1; dist < N && !found; dist++) {\n for (int p = 0; p + dist < N && !found; p++) {\n int x = items[p];\n int y = items[p + dist];\n if (!dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n }\n }\n }\n if (!found) {\n for (int tries = 0; tries < 10000; tries++) {\n int x = rand() % N;\n int y = rand() % N;\n if (x != y && !dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n break;\n }\n }\n if (!found) {\n to_comp = {0, 1};\n }\n }\n int a = to_comp.first;\n int b = to_comp.second;\n cout << 1 << \" \" << 1 << \" \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n dcomp[a].set(b);\n dcomp[b].set(a);\n if (res == '>') {\n adj[a].push_back(b);\n outdeg[a]++;\n } else if (res == '<') {\n adj[b].push_back(a);\n outdeg[b]++;\n }\n }\n vector ranks = compute_ranks();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n vector group(N);\n for (int i = 0; i < N; i++) {\n group[items[i]] = i % D;\n }\n for (int i = 0; i < N; i++) {\n cout << group[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n int h = n / m;\n vector> st(m);\n vector stack_of(n + 1, -1);\n vector pos_in_st(n + 1, -1);\n for (int i = 0; i < m; i++) {\n st[i].resize(h);\n for (int j = 0; j < h; j++) {\n cin >> st[i][j];\n stack_of[st[i][j]] = i;\n pos_in_st[st[i][j]] = j;\n }\n }\n vector> ops;\n for (int v = 1; v <= n; v++) {\n while (true) {\n int s = stack_of[v];\n if (s == -1) {\n break;\n }\n int p = pos_in_st[v];\n if (p == (int)st[s].size() - 1) break;\n vector stack_min(m, n + 1);\n for (int i = 0; i < m; i++) {\n for (int b : st[i]) {\n if (b < stack_min[i]) stack_min[i] = b;\n }\n }\n int best_minv = -1;\n int best_sz = INT_MAX;\n int dest = -1;\n for (int i = 0; i < m; i++)\n if (i != s) {\n int cmin = stack_min[i];\n int csz = st[i].size();\n bool up = false;\n if (cmin > best_minv) up = true;\n else if (cmin == best_minv) {\n if (csz < best_sz) up = true;\n else if (csz == best_sz && (dest == -1 || i < dest)) up = true;\n }\n if (up) {\n best_minv = cmin;\n best_sz = csz;\n dest = i;\n }\n }\n if (dest == -1) {\n // fallback: any stack except s\n for (int i = 0; i < m; i++)\n if (i != s) {\n dest = i;\n break;\n }\n }\n int lift_v = st[s][p + 1];\n ops.emplace_back(lift_v, dest);\n vector to_move;\n for (size_t j = p + 1; j < st[s].size(); ++j) {\n to_move.push_back(st[s][j]);\n }\n st[s].resize(p + 1);\n size_t old_dest_sz = st[dest].size();\n st[dest].insert(st[dest].end(), to_move.begin(), to_move.end());\n for (size_t j = 0; j < to_move.size(); ++j) {\n int b = to_move[j];\n stack_of[b] = dest;\n pos_in_st[b] = old_dest_sz + j;\n }\n }\n int s = stack_of[v];\n ops.emplace_back(v, 0);\n st[s].pop_back();\n stack_of[v] = -1;\n pos_in_st[v] = -1;\n }\n for (auto [vv, ii] : ops) {\n cout << vv << \" \" << ii << endl;\n }\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector h(N-1);\n for(int i = 0; i < N-1; i++) cin >> h[i];\n vector v(N);\n for(int i = 0; i < N; i++) cin >> v[i];\n vector> d(N, vector(N));\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n vector> sd(N, vector(N));\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n sd[i][j] = sqrt(d[i][j]);\n }\n \n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n string DIR = \"URDL\";\n \n auto can_move = [&](int i, int j, int ni, int nj, const auto& hh, const auto& vv) -> bool {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n int ddi = ni - i;\n int ddj = nj - j;\n if (ddi == -1 && ddj == 0) return hh[ni][j] == '0';\n if (ddi == 1 && ddj == 0) return hh[i][j] == '0';\n if (ddi == 0 && ddj == 1) return vv[i][j] == '0';\n if (ddi == 0 && ddj == -1) return vv[i][nj] == '0';\n return false;\n };\n \n // Base covering DFS\n vector> vis_mark(N, vector(N, false));\n string route = \"\";\n function dfs = [&](int i, int j) {\n vis_mark[i][j] = true;\n for(int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !vis_mark[ni][nj] && can_move(i, j, ni, nj, h, v)) {\n route += DIR[dir];\n dfs(ni, nj);\n route += DIR[(dir + 2) % 4];\n }\n }\n };\n dfs(0, 0);\n \n // Simulate base\n vector> visits(N, vector(N, 0));\n vector> positions;\n positions.emplace_back(0, 0);\n int ci = 0, cj = 0;\n for (char c : route) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'R') dir = 1;\n else if (c == 'D') dir = 2;\n else if (c == 'L') dir = 3;\n if (dir == -1) continue;\n int ni = ci + di[dir], nj = cj + dj[dir];\n positions.emplace_back(ni, nj);\n visits[ni][nj]++;\n ci = ni;\n cj = nj;\n }\n int Ltotal = positions.size() - 1;\n int cur_i = ci, cur_j = cj;\n \n // Add more visits\n int L_target = 99920;\n const int MAX_L = 100000;\n const int RESERVE = 100;\n while (Ltotal < L_target) {\n // Find best target != current\n double max_p = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == cur_i && j == cur_j) continue;\n double p = sd[i][j] / (visits[i][j] + 1.0);\n if (p > max_p) {\n max_p = p;\n ti = i;\n tj = j;\n }\n }\n }\n if (ti == -1) {\n // only current, do excursion\n bool ex = false;\n for (int dir = 0; dir < 4; dir++) {\n int ni = cur_i + di[dir], nj = cur_j + dj[dir];\n if (can_move(cur_i, cur_j, ni, nj, h, v)) {\n ti = ni;\n tj = nj;\n ex = true;\n break;\n }\n }\n if (!ex) break;\n }\n \n // BFS from cur to ti,tj\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == ti && cur_j == tj);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == ti && nj == tj) {\n found = true;\n break;\n }\n }\n }\n if (!found) break;\n \n // reconstruct\n vector> path_to;\n pair curp = {ti, tj};\n while (curp != make_pair(cur_i, cur_j)) {\n path_to.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_to.begin(), path_to.end());\n \n if (Ltotal + (int)path_to.size() + RESERVE > MAX_L) break;\n \n for (auto [x, y] : path_to) {\n positions.emplace_back(x, y);\n visits[x][y]++;\n cur_i = x;\n cur_j = y;\n Ltotal++;\n }\n }\n \n // Final return to (0,0)\n {\n int ti = 0, tj = 0;\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == 0 && cur_j == 0);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == 0 && nj == 0) {\n found = true;\n break;\n }\n }\n }\n if (found) {\n vector> path_back;\n pair curp = {0, 0};\n while (curp != make_pair(cur_i, cur_j)) {\n path_back.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_back.begin(), path_back.end());\n if (Ltotal + (int)path_back.size() <= MAX_L) {\n for (auto p : path_back) {\n positions.push_back(p);\n visits[p.first][p.second]++;\n cur_i = p.first;\n cur_j = p.second;\n }\n }\n }\n }\n \n // Build ans\n string ans = \"\";\n for (size_t t = 1; t < positions.size(); t++) {\n int i1 = positions[t - 1].first, j1 = positions[t - 1].second;\n int i2 = positions[t].first, j2 = positions[t].second;\n if (i2 == i1 - 1) ans += 'U';\n else if (i2 == i1 + 1) ans += 'D';\n else if (j2 == j1 + 1) ans += 'R';\n else if (j2 == j1 - 1) ans += 'L';\n }\n \n if (ans.size() > MAX_L) ans = ans.substr(0, MAX_L);\n cout << ans << endl;\n return 0;\n}","ahc028":"#include \nusing namespace std;\ntypedef long long ll;\nconst ll INF = 1LL << 60;\n\npair>> solve_for_S(const string& S, int si, int sj, const vector>>& posis) {\n int LL = S.length();\n if(LL == 0) return {INF, {}};\n vector>> cnd(LL);\n for(int k = 0; k < LL; k++) {\n cnd[k] = posis[S[k] - 'A'];\n if(cnd[k].empty()) return {INF, {}};\n }\n vector> dpp(LL);\n vector> prvv(LL);\n int n0 = cnd[0].size();\n dpp[0].resize(n0);\n prvv[0].assign(n0, -1);\n for(int j = 0; j < n0; j++) {\n int x = cnd[0][j].first, y = cnd[0][j].second;\n dpp[0][j] = abs(x - si) + abs(y - sj) + 1LL;\n }\n for(int k = 1; k < LL; k++) {\n int np = cnd[k-1].size();\n int nc = cnd[k].size();\n dpp[k].assign(nc, INF);\n prvv[k].assign(nc, -1);\n for(int j = 0; j < nc; j++) {\n int x = cnd[k][j].first, y = cnd[k][j].second;\n for(int p = 0; p < np; p++) {\n int px = cnd[k-1][p].first, py = cnd[k-1][p].second;\n ll cc = dpp[k-1][p] + abs(x - px) + abs(y - py) + 1;\n if(cc < dpp[k][j]) {\n dpp[k][j] = cc;\n prvv[k][j] = p;\n }\n }\n }\n }\n ll minc = INF;\n int bj = -1;\n int nlast = cnd[LL-1].size();\n for(int j = 0; j < nlast; j++) {\n if(dpp[LL-1][j] < minc) {\n minc = dpp[LL-1][j];\n bj = j;\n }\n }\n if(bj == -1) return {INF, {}};\n vector> sq(LL);\n int cj = bj;\n sq[LL-1] = cnd[LL-1][cj];\n for(int k = LL-1; k >= 1; k--) {\n int pj = prvv[k][cj];\n sq[k-1] = cnd[k-1][pj];\n cj = pj;\n }\n return {minc, sq};\n}\n\nint main() {\n srand(time(NULL));\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for(int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for(int i = 0; i < M; i++) cin >> t[i];\n vector>> positions(26);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].emplace_back(i, j);\n }\n vector> overlap(M, vector(M, 0));\n for(int i = 0; i < M; i++) {\n for(int j = 0; j < M; j++) if(i != j) {\n int best = 0;\n for(int o = 4; o >= 0; o--) {\n if(t[i].substr(5 - o) == t[j].substr(0, o)) {\n best = o;\n break;\n }\n }\n overlap[i][j] = best;\n }\n }\n const int TRIALS = 40;\n const int MAX_CAND = 600;\n vector> candidates;\n for(int start = 0; start < M; start++) {\n for(int tr = 0; tr < TRIALS; tr++) {\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n int last = start;\n for(int iter = 1; iter < M; iter++) {\n int cur_maxo = -1;\n vector cands_max;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = overlap[last][j];\n if(oo > cur_maxo) {\n cur_maxo = oo;\n cands_max = {j};\n } else if(oo == cur_maxo) {\n cands_max.push_back(j);\n }\n }\n if(cands_max.empty()) break;\n int idx = rand() % cands_max.size();\n int best = cands_max[idx];\n int maxo_val = cur_maxo;\n used[best] = true;\n curr += t[best].substr(maxo_val);\n last = best;\n }\n candidates.emplace_back((int)curr.size(), curr);\n }\n }\n sort(candidates.begin(), candidates.end());\n if((int)candidates.size() > MAX_CAND) candidates.resize(MAX_CAND);\n ll best_T = INF;\n vector> best_seq;\n for(auto& pr : candidates) {\n const string& curr = pr.second;\n auto [this_cost, this_seq] = solve_for_S(curr, si, sj, positions);\n if(this_cost < best_T) {\n best_T = this_cost;\n best_seq = this_seq;\n }\n }\n if(best_T == INF || best_seq.empty()) {\n string curr = t[0];\n auto [fcost, fseq] = solve_for_S(curr, si, sj, positions);\n if(fcost < INF) {\n best_seq = fseq;\n } else {\n vector> fb;\n if(!positions[0].empty()){\n auto p0 = positions[0][0];\n fb.push_back(p0);\n for(int k = 0; k < 4; k++) fb.push_back(p0);\n } else {\n fb.push_back({0,0});\n for(int k = 0; k < 4; k++) fb.push_back({0,0});\n }\n best_seq = fb;\n }\n }\n for(auto& p : best_seq) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n return 0;\n}","ahc030":"#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n vector>> fields(M);\n for (int i = 0; i < M; i++) {\n int d;\n cin >> d;\n fields[i].resize(d);\n for (int j = 0; j < d; j++) {\n cin >> fields[i][j].first >> fields[i][j].second;\n }\n }\n int D = N * N;\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_real_distribution dist(0.0, 1.0);\n vector> queries;\n vector measured;\n int ops = 0;\n const int MAX_OPS = 2 * N * N;\n vector est(D, 0.0);\n vector true_v(D, -1);\n vector is_drilled(D, false);\n int INIT_Q = 300;\n for (int q = 0; q < INIT_Q && ops < MAX_OPS - 100; q++) {\n vector S;\n for (int c = 0; c < D; c++) {\n if (dist(rng) < 0.2) S.push_back(c);\n }\n if (S.size() < 2) {\n q--;\n continue;\n }\n cout << \"q \" << S.size();\n for (int c : S) {\n int i = c / N;\n int j = c % N;\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int y;\n cin >> y;\n queries.push_back(S);\n measured.push_back(y);\n ops++;\n }\n int drill_batch = 30;\n double est_thresh = 0.25;\n for (int r = 0; r < 30 && ops < MAX_OPS - 1; r++) {\n vector unknown;\n for (int c = 0; c < D; c++) if (!is_drilled[c]) unknown.push_back(c);\n int U = unknown.size();\n if (U == 0) break;\n int Qs = queries.size();\n MatrixXd A(Qs, U);\n VectorXd bb(Qs);\n for (int qi = 0; qi < Qs; qi++) {\n int k = queries[qi].size();\n double target = (measured[qi] - eps * (double)k) / (1 - eps);\n double known_s = 0.0;\n for (int c : queries[qi]) if (is_drilled[c]) known_s += true_v[c];\n bb(qi) = target - known_s;\n A.row(qi).setZero();\n vector is_in(D, false);\n for (int c : queries[qi]) is_in[c] = true;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (is_in[c]) A(qi, uj) = 1.0;\n }\n }\n VectorXd x(U);\n if (U > 0 && Qs > 0) {\n x = A.bdcSvd(ComputeThinU | ComputeThinV).solve(bb);\n } else {\n x = VectorXd::Zero(U);\n }\n for (int uj = 0; uj < U; uj++) {\n est[unknown[uj]] = max(0.0, x(uj));\n }\n vector> high;\n for (int uj = 0; uj < U; uj++) {\n int c = unknown[uj];\n if (est[c] > est_thresh) high.emplace_back(est[c], c);\n }\n if (high.empty()) break;\n sort(high.rbegin(), high.rend());\n int num_dr = min((int)high.size(), drill_batch);\n for (int ii = 0; ii < num_dr; ii++) {\n int c = high[ii].second;\n if (is_drilled[c]) continue;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n }\n vector> final_sus;\n for (int c = 0; c < D; c++) if (!is_drilled[c] && est[c] > 0.1) final_sus.emplace_back(est[c], c);\n sort(final_sus.rbegin(), final_sus.rend());\n for (auto& pr : final_sus) {\n if (ops >= MAX_OPS - 1) break;\n int c = pr.second;\n int i = c / N, j = c % N;\n cout << \"q 1 \" << i << \" \" << j << \"\\n\";\n cout.flush();\n int v;\n cin >> v;\n true_v[c] = v;\n is_drilled[c] = true;\n ops++;\n }\n vector> ans;\n for (int c = 0; c < D; c++) if (is_drilled[c] && true_v[c] > 0) {\n ans.emplace_back(c / N, c % N);\n }\n vector>> possible_pos(M);\n for (int m = 0; m < M; m++) {\n int maxx = 0, maxy = 0;\n for (auto& p : fields[m]) {\n maxx = max(maxx, p.first);\n maxy = max(maxy, p.second);\n }\n for (int di = 0; di + maxx < N; di++) {\n for (int dj = 0; dj + maxy < N; dj++) {\n possible_pos[m].emplace_back(di, dj);\n }\n }\n }\n vector> best_place(M);\n vector best_v(D, 0.0);\n double best_err = 1e18;\n for (int start = 0; start < 5; start++) {\n vector> place(M);\n for (int m = 0; m < M; m++) {\n auto& ps = possible_pos[m];\n if (!ps.empty()) place[m] = ps[rng() % ps.size()];\n }\n auto compute_v = [&](const vector>& pl) -> vector {\n vector vv(D, 0.0);\n for (int m = 0; m < M; m++) {\n auto [di, dj] = pl[m];\n for (auto [x, y] : fields[m]) {\n int ii = di + x, jj = dj + y;\n vv[ii * N + jj] += 1;\n }\n }\n return vv;\n };\n vector vv = compute_v(place);\n vector target_v = est;\n for (int c = 0; c < D; c++) if (is_drilled[c]) target_v[c] = true_v[c];\n auto calc_err = [&](const vector& vvv) {\n double e = 0;\n for (int c = 0; c < D; c++) e += abs(vvv[c] - target_v[c]);\n return e;\n };\n double curr_err = calc_err(vv);\n for (int tries = 0; tries < 10000; tries++) {\n int m = rng() % M;\n auto& ps = possible_pos[m];\n if (ps.empty()) continue;\n int idx = rng() % ps.size();\n auto newp = ps[idx];\n if (newp == place[m]) continue;\n vector new_vv(D);\n // delta\n double delta = 0.0;\n double delta_adjust = 0;\n // old subtract\n auto oldp = place[m];\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n int c = ii * N + jj;\n double oldv = vv[c];\n double newvv = oldv - 1;\n delta += abs(newvv - target_v[c]) - abs(oldv - target_v[c]);\n }\n // new add\n for (auto [x, y] : fields[m]) {\n int ii = newp.first + x, jj = newp.second + y;\n int c = ii * N + jj;\n double oldv_for = vv[c];\n double newvv = oldv_for + 1;\n delta += abs(newvv - target_v[c]) - abs(oldv_for - target_v[c]);\n }\n if (delta < -0.001) {\n for (auto [x, y] : fields[m]) {\n int ii = oldp.first + x, jj = oldp.second + y;\n vv[ii * N + jj] -= 1;\n int ii2 = newp.first + x, jj2 = newp.second + y;\n vv[ii2 * N + jj2] += 1;\n }\n place[m] = newp;\n curr_err += delta;\n }\n }\n if (curr_err < best_err) {\n best_err = curr_err;\n best_place = place;\n best_v = vv;\n }\n }\n set> union_set;\n for (int m = 0; m < M; m++) {\n auto [di, dj] = best_place[m];\n for (auto [x, y] : fields[m]) {\n union_set.emplace(di + x, dj + y);\n }\n }\n vector> final_ans;\n for (auto p : union_set) final_ans.push_back(p);\n for (auto p : ans) final_ans.push_back(p); // add drilled if any missed\n sort(final_ans.begin(), final_ans.end());\n auto last = unique(final_ans.begin(), final_ans.end());\n final_ans.erase(last, final_ans.end());\n cout << \"a \" << final_ans.size();\n for (auto [i, j] : final_ans) {\n cout << \" \" << i << \" \" << j;\n }\n cout << \"\\n\";\n cout.flush();\n int resp;\n cin >> resp;\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n vector> A(D, vector(N));\n for(int d = 0; d < D; d++) {\n for(int k = 0; k < N; k++) {\n cin >> A[d][k];\n }\n }\n vector prev_div(N + 1, 0);\n int base = W / N;\n for(int i = 1; i < N; i++) {\n prev_div[i] = prev_div[i - 1] + base;\n }\n prev_div[N] = W;\n for(int d = 0; d < D; d++) {\n auto a = A[d];\n vector cur_w(N);\n for(int k = 0; k < N; k++) cur_w[k] = prev_div[k + 1] - prev_div[k];\n vector slot_idx(N);\n iota(slot_idx.begin(), slot_idx.end(), 0);\n sort(slot_idx.begin(), slot_idx.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n vector a_idx(N);\n iota(a_idx.begin(), a_idx.end(), 0);\n sort(a_idx.begin(), a_idx.end(), [&](int x, int y) {\n if(a[x] != a[y]) return a[x] > a[y];\n return x < y;\n });\n vector assigned(N);\n for(int i = 0; i < N; i++) {\n int s = slot_idx[i];\n int ak = a_idx[i];\n assigned[s] = a[ak];\n }\n long long current_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * cur_w[s];\n current_def += max(0LL, assigned[s] - b);\n }\n vector targ_w(N, 0);\n long long sum_need = 0;\n for(int s = 0; s < N; s++) {\n if(assigned[s] == 0) {\n targ_w[s] = 1;\n } else {\n targ_w[s] = ((assigned[s] + 999) / 1000);\n }\n if(targ_w[s] < 1) targ_w[s] = 1;\n sum_need += targ_w[s];\n }\n if(sum_need > W) {\n vector sidx(N);\n iota(sidx.begin(), sidx.end(), 0);\n sort(sidx.begin(), sidx.end(), [&](int x, int y) {\n return assigned[x] < assigned[y] || (assigned[x] == assigned[y] && x < y);\n });\n long long deficit = sum_need - W;\n for(int i : sidx) {\n if(deficit <= 0) break;\n int can = targ_w[i] - 1;\n long long red = min((long long)can, deficit);\n targ_w[i] -= red;\n deficit -= red;\n }\n int ii = 0;\n while(deficit > 0 && ii < N * 100) {\n int idx = sidx[ii % N];\n int can = targ_w[idx] - 1;\n long long red = min((long long)can, deficit);\n targ_w[idx] -= red;\n deficit -= red;\n ii++;\n }\n } else if(sum_need < W) {\n long long extra = W - sum_need;\n int maxs = 0;\n for(int s = 1; s < N; s++) if(assigned[s] > assigned[maxs]) maxs = s;\n targ_w[maxs] += extra;\n }\n vector new_div(N + 1, 0);\n for(int s = 0; s < N; s++) {\n new_div[s + 1] = new_div[s] + targ_w[s];\n }\n new_div[N] = W;\n long long new_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * targ_w[s];\n new_def += max(0LL, assigned[s] - b);\n }\n vector old_has(W + 1, false);\n vector neww_has(W + 1, false);\n for(int k = 1; k < N; k++) {\n if(prev_div[k] > 0 && prev_div[k] < W) old_has[prev_div[k]] = true;\n if(new_div[k] > 0 && new_div[k] < W) neww_has[new_div[k]] = true;\n }\n int sym = 0;\n for(int j = 0; j <= W; j++) {\n if(old_has[j] != neww_has[j]) sym++;\n }\n long long L = (long long)sym * W;\n bool move = (L < 100LL * (current_def - new_def));\n vector> day_rects(N);\n vector used_div = prev_div;\n if(move || d == 0) { // always move for day 0 or if worth\n vector sorted_slot(N);\n iota(sorted_slot.begin(), sorted_slot.end(), 0);\n sort(sorted_slot.begin(), sorted_slot.end(), [&](int x, int y) {\n if(targ_w[x] != targ_w[y]) return targ_w[x] > targ_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_slot[i];\n int k = a_idx[i];\n int j0 = new_div[s];\n int j1 = new_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n used_div = new_div;\n prev_div = new_div;\n } else {\n vector sorted_cur(N);\n iota(sorted_cur.begin(), sorted_cur.end(), 0);\n sort(sorted_cur.begin(), sorted_cur.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_cur[i];\n int k = a_idx[i];\n int j0 = prev_div[s];\n int j1 = prev_div[s + 1];\n day_rects[k] = {0, j0, W, j1};\n }\n }\n for(int k = 0; k < N; k++) {\n auto &r = day_rects[k];\n cout << r[0] << \" \" << r[1] << \" \" << r[2] << \" \" << r[3] << endl;\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n vector>> S(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cin >> S[m][i][j];\n const ll MOD = 998244353;\n vector> cur_mod(N, vector(N));\n vector>> op_cnt(M, vector>(N - 2, vector(N - 2, 0)));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_mod[i][j] = A[i][j];\n ll cur_score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_score += cur_mod[i][j];\n int cur_total = 0;\n auto get_add_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) {\n for (int dj = 0; dj < 3; dj++) {\n int i = p + di;\n int j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr + S[m][di][dj] % MOD) % MOD;\n ds += newr - oldr;\n }\n }\n return ds;\n };\n auto get_remove_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr - (S[m][di][dj] % MOD) + MOD) % MOD;\n ds += newr - oldr;\n }\n return ds;\n };\n while (cur_total < K) {\n ll max_ds = -1000000000000000000LL;\n int bm = -1, bp = -1, bq = -1;\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds;\n bm = m; bp = p; bq = q;\n }\n }\n }\n }\n if (max_ds <= 0) break;\n int m = bm, p = bp, q = bq;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m][di][dj] % MOD)) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n }\n vector> greedy_mod = cur_mod;\n vector>> greedy_cnt = op_cnt;\n ll greedy_score = cur_score;\n int greedy_total = cur_total;\n ll overall_best_score = cur_score;\n vector>> overall_best_cnt = op_cnt;\n int MAX_ITER = 800000;\n double T0 = 10000000000.0;\n srand(42);\n auto rand01 = []() { return rand() * 1.0 / RAND_MAX; };\n for (int trial = 0; trial < 3; trial++) {\n cur_mod = greedy_mod;\n op_cnt = greedy_cnt;\n cur_score = greedy_score;\n cur_total = greedy_total;\n if (trial > 0) {\n int npert = 12 + (rand() % 12);\n for (int p = 0; p < npert; p++) {\n if (rand() % 2 && cur_total < K) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n ll dsc = get_add_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][pp][qq]++;\n cur_total++;\n cur_score += dsc;\n } else if (cur_total > 0) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n if (op_cnt[m][pp][qq] > 0) {\n ll dsc = get_remove_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][pp][qq]--;\n cur_total--;\n cur_score += dsc;\n }\n }\n }\n }\n for (int iter = 0; iter < MAX_ITER; iter++) {\n double temp = T0 * pow(0.99996, iter);\n bool did = false;\n int rtyp = rand() % 4;\n if (rtyp == 0 && cur_total < K) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n ll dsc = get_add_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n } else if (rtyp == 1 && cur_total > 0) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n if (op_cnt[m][p][q] > 0) {\n ll dsc = get_remove_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n }\n }\n if (!did) {\n int m1 = rand() % M; int p1 = rand() % (N - 2); int q1 = rand() % (N - 2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N - 2); int q2 = rand() % (N - 2);\n ll dsc = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n ll net = 0;\n int di = i - p1, dj = j - q1;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net -= S[m1][di][dj];\n di = i - p2; dj = j - q2;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net += S[m2][di][dj];\n if (net == 0) continue;\n ll oldr = cur_mod[i][j];\n ll addm = (net % MOD + MOD) % MOD;\n ll newr = (oldr + addm) % MOD;\n dsc += newr - oldr;\n }\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m1][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m2][di][dj] % MOD) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n }\n }\n }\n // deterministic local hill climb\n const int MAX_HILL = 800;\n for (int h = 0; h < MAX_HILL; h++) {\n ll max_ds = 0;\n int best_type = -1;\n int ba_m = -1, ba_p = -1, ba_q = -1;\n int br_m = -1, br_p = -1, br_q = -1;\n if (cur_total < K) {\n for (int m = 0; m < M; m++) for (int p = 0; p < N-2; p++) for (int q = 0; q < N-2; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds; best_type = 0; ba_m = m; ba_p = p; ba_q = q;\n }\n }\n }\n for (int m = 0; m < M; m++) for (int p = 0; p < N-2; p++) for (int q = 0; q < N-2; q++) if (op_cnt[m][p][q] > 0) {\n ll ds = get_remove_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds; best_type = 1; br_m = m; br_p = p; br_q = q;\n }\n }\n if (max_ds <= 0) break;\n if (best_type == 0) {\n int m = ba_m, p = ba_p, q = ba_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n } else if (best_type == 1) {\n int m = br_m, p = br_p, q = br_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += max_ds;\n }\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n }\n // rebuild cur from overall_best for final hill\n for(int i=0;i max_ds) {\n max_ds = ds; best_type = 0; ba_m = m; ba_p = p; ba_q = q;\n }\n }\n }\n for (int m = 0; m < M; m++) for (int p = 0; p < N-2; p++) for (int q = 0; q < N-2; q++) if (op_cnt[m][p][q] > 0) {\n ll ds = get_remove_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds; best_type = 1; br_m = m; br_p = p; br_q = q;\n }\n }\n if (max_ds <= 0) break;\n if (best_type == 0) {\n int m = ba_m, p = ba_p, q = ba_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n } else if (best_type == 1) {\n int m = br_m, p = br_p, q = br_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += max_ds;\n }\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n int L = 0;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) L += overall_best_cnt[m][p][q];\n cout << L << endl;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) {\n for (int t = 0; t < overall_best_cnt[m][p][q]; t++) {\n cout << m << \" \" << p << \" \" << q << endl;\n }\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> 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 int max_turn = 10000;\n vector> grid(N, vector(N, -1));\n vector next_in(N, 0);\n vector pos_r(N), pos_c(N);\n for (int i = 0; i < N; i++) {\n pos_r[i] = i;\n pos_c[i] = 0;\n }\n vector hold(N, -1);\n vector active(N, true);\n vector acts(N, \"\");\n int total_disp = 0;\n for (int turn = 0; turn < max_turn; turn++) {\n if (total_disp >= N * N) break;\n for (int i = 0; i < N; i++) {\n if (next_in[i] < N && grid[i][0] == -1) {\n bool has_hold = false;\n for (int k = 0; k < N; k++) if (active[k] && pos_r[k] == i && pos_c[k] == 0 && hold[k] != -1) {\n has_hold = true; break;\n }\n if (!has_hold) {\n grid[i][0] = A[i][next_in[i]];\n next_in[i]++;\n }\n }\n }\n vector act(N, '.');\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n int r = pos_r[c];\n int co = pos_c[c];\n bool is_large = (c == 0);\n bool carrying = (hold[c] != -1);\n if (carrying) {\n int b = hold[c];\n int tr = b / N;\n if (co == N-1) {\n if (r == tr) {\n act[c] = 'Q';\n } else {\n char dir = (r < tr ? 'D' : 'U');\n int nr = r + (r < tr ? 1 : -1);\n if (nr >= 0 && nr < N && (grid[nr][co] == -1 || is_large)) {\n act[c] = dir;\n } else {\n act[c] = '.';\n }\n }\n } else {\n act[c] = 'R';\n }\n } else {\n if (grid[r][co] != -1) {\n int b = grid[r][co];\n int tr = b / N;\n bool can_pick = is_large || (tr == r);\n if (can_pick) act[c] = 'P';\n } else {\n act[c] = (co > 0 ? 'L' : '.');\n }\n }\n }\n vector> new_grid = grid;\n vector new_hold = hold;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n int pr = pos_r[c], pc = pos_c[c];\n if (ac == 'P') {\n if (hold[c] != -1 || new_grid[pr][pc] == -1) {\n act[c] = '.';\n } else {\n new_hold[c] = new_grid[pr][pc];\n new_grid[pr][pc] = -1;\n }\n } else if (ac == 'Q') {\n if (hold[c] == -1 || new_grid[pr][pc] != -1) {\n act[c] = '.';\n } else {\n new_grid[pr][pc] = hold[c];\n new_hold[c] = -1;\n }\n }\n }\n vector nr_pos = pos_r, nc_pos = pos_c;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n if (ac != 'U' && ac != 'D' && ac != 'L' && ac != 'R') continue;\n int pr = pos_r[c], pc = pos_c[c];\n int nrr = pr, ncc = pc;\n if (ac == 'U') nrr--;\n if (ac == 'D') nrr++;\n if (ac == 'L') ncc--;\n if (ac == 'R') ncc++;\n if (nrr < 0 || nrr >= N || ncc < 0 || ncc >= N) {\n act[c] = '.'; continue;\n }\n bool car = (new_hold[c] != -1);\n bool isl = (c == 0);\n bool dh = (new_grid[nrr][ncc] != -1);\n if (car && !isl && dh) {\n act[c] = '.'; continue;\n }\n nr_pos[c] = nrr;\n nc_pos[c] = ncc;\n }\n map,int> cnt;\n for(int c=0;c1) cl=true;\n if(cl){\n for(int c=0;cmax_turn)acts[i].resize(max_turn);\n }\n for(int i=0;i\nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n int r = 0, c = 0;\n long long load = 0;\n vector ops;\n const int MAXT = 100000;\n auto is_done = [&]() -> bool {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) return false;\n }\n }\n return true;\n };\n auto find_best = [&](bool is_source) -> pair {\n double best_ratio = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n long long val = h[i][j];\n if ((is_source ? val > 0 : val < 0)) {\n int dist = abs(i - r) + abs(j - c);\n long long amnt = is_source ? val : -val;\n double ratio;\n if (dist == 0) ratio = 1e18;\n else ratio = (double)amnt / dist;\n if (ratio > best_ratio) {\n best_ratio = ratio;\n ti = i;\n tj = j;\n }\n }\n }\n }\n return {ti, tj};\n };\n auto move_path = [&](int tr, int tc) {\n while (r < tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"L\");\n c--;\n }\n };\n while (!is_done() && (int)ops.size() < MAXT - 50) {\n bool did_something = false;\n if (load == 0 && h[r][c] > 0) {\n long long d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[r][c] -= d;\n did_something = true;\n } else if (load > 0 && h[r][c] < 0) {\n long long d = min(load, -h[r][c]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[r][c] += d;\n did_something = true;\n }\n if (did_something) continue;\n bool going_source = (load == 0);\n auto target = find_best(going_source);\n if (target.first == -1) {\n break;\n }\n move_path(target.first, target.second);\n }\n // post-sweep passes \n auto do_sweep = [&]() {\n for (int i = 0; i < N && (int)ops.size() < MAXT - 10; i++) {\n for (int j = 0; j < N && (int)ops.size() < MAXT - 10; j++) {\n move_path(i, j);\n if (load == 0 && h[i][j] > 0) {\n long long d = h[i][j];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[i][j] -= d;\n } else if (load > 0 && h[i][j] < 0) {\n long long d = min(load, -h[i][j]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[i][j] += d;\n }\n }\n }\n };\n if (!is_done()) {\n for (int p = 0; p < 30 && !is_done() && (int)ops.size() < MAXT - 50; p++) {\n do_sweep();\n }\n }\n for (auto& s : ops) {\n cout << s << endl;\n }\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(NULL);\n int N, M, T;\n cin >> N >> M >> T;\n int seed_count = 2 * N * (N - 1);\n vector> X(seed_count, vector(M, 0));\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n mt19937 rng(42);\n for (int t = 0; t < T; t++) {\n vector vals(seed_count, 0);\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n vals[i] += X[i][j];\n }\n }\n vector> trait_carriers(M);\n set all_carrier_set;\n vector maxl_per_trait(M, 0);\n vector num_max_traits_per_seed(seed_count, 0);\n vector carrier_count_per_trait(M, 0);\n vector rare_prio(seed_count, 0.0);\n for (int l = 0; l < M; l++) {\n int ml = 0;\n for (int i = 0; i < seed_count; i++) ml = max(ml, X[i][l]);\n maxl_per_trait[l] = ml;\n for (int i = 0; i < seed_count; i++) {\n if (X[i][l] == ml) {\n trait_carriers[l].push_back(i);\n all_carrier_set.insert(i);\n num_max_traits_per_seed[i]++;\n rare_prio[i] += 5.0 / max(1, (int)trait_carriers[l].size());\n }\n }\n carrier_count_per_trait[l] = trait_carriers[l].size();\n }\n vector all_carriers(all_carrier_set.begin(), all_carrier_set.end());\n for (int i = 0; i < seed_count; i++) rare_prio[i] *= 2.0;\n vector to_plant;\n set selected;\n vector covered(M, false);\n int num_covered = 0;\n while ((int)to_plant.size() < N * N && num_covered < M) {\n int best_score = -1;\n int best_i = -1;\n for (int cand : all_carriers) {\n if (selected.count(cand)) continue;\n int new_cov = 0;\n for (int l = 0; l < M; l++) {\n if (!covered[l] && X[cand][l] == maxl_per_trait[l]) new_cov++;\n }\n int score = new_cov * 100000 + vals[cand] + num_max_traits_per_seed[cand] * 1000;\n if (score > best_score) {\n best_score = score;\n best_i = cand;\n }\n }\n if (best_i == -1) break;\n selected.insert(best_i);\n to_plant.push_back(best_i);\n for (int l = 0; l < M; l++) {\n if (!covered[l] && X[best_i][l] == maxl_per_trait[l]) {\n covered[l] = true;\n num_covered++;\n }\n }\n }\n vector> remain_car;\n for (int i : all_carriers) {\n if (!selected.count(i)) {\n remain_car.emplace_back(vals[i] + num_max_traits_per_seed[i] * 1000.0 + rare_prio[i] * 50, i);\n }\n }\n sort(remain_car.rbegin(), remain_car.rend());\n for (auto& p : remain_car) {\n if ((int)to_plant.size() >= N * N) break;\n to_plant.push_back(p.second);\n selected.insert(p.second);\n }\n vector> non_car;\n for (int i = 0; i < seed_count; i++) {\n if (!selected.count(i)) {\n non_car.emplace_back(vals[i], i);\n }\n }\n sort(non_car.rbegin(), non_car.rend());\n for (auto& p : non_car) {\n if ((int)to_plant.size() >= N * N) break;\n to_plant.push_back(p.second);\n }\n sort(to_plant.begin(), to_plant.end(), [&](int a, int b) {\n return vals[a] + num_max_traits_per_seed[a] * 10000 > vals[b] + num_max_traits_per_seed[b] * 10000 || (vals[a] + num_max_traits_per_seed[a] * 10000 == vals[b] + num_max_traits_per_seed[b] * 10000 && a < b);\n });\n if ((int)to_plant.size() > N * N) to_plant.resize(N * N);\n while ((int)to_plant.size() < N * N) to_plant.push_back(0);\n vector curr_arr(N * N);\n for (int i = 0; i < N * N; i++) curr_arr[i] = to_plant[i];\n auto compute_obj = [&](const vector& arr) -> long long {\n long long obj = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N - 1; j++) {\n int p = arr[i * N + j];\n int q = arr[i * N + j + 1];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n obj += (long long)(rare_prio[p] + rare_prio[q]) * 20;\n }\n }\n for (int i = 0; i < N - 1; i++) {\n for (int j = 0; j < N; j++) {\n int p = arr[i * N + j];\n int q = arr[(i + 1) * N + j];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n obj += (long long)(rare_prio[p] + rare_prio[q]) * 20;\n }\n }\n return obj;\n };\n long long curr_obj = compute_obj(curr_arr);\n long long best_obj = curr_obj;\n vector best_arr = curr_arr;\n vector curr_arr_swap = curr_arr;\n double temp = 20000.0;\n for (int iter = 0; iter < 120000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n long long new_obj = compute_obj(curr_arr_swap);\n long long delta = new_obj - curr_obj;\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / temp);\n double r = (rng() % 1000000000LL) / 1000000000.0;\n if (r < prob) accept = true;\n }\n if (accept) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr_swap;\n }\n } else {\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n }\n if (iter % 400 == 0) {\n temp *= 0.9975;\n if (temp < 0.5) temp = 0.5;\n }\n }\n curr_arr_swap = best_arr;\n curr_obj = best_obj;\n for (int iter = 0; iter < 40000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n long long new_obj = compute_obj(curr_arr_swap);\n if (new_obj > curr_obj) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr_swap;\n }\n } else {\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n }\n }\n // restart SA with perturbed initial\n vector restart_arr = best_arr;\n for (int s = 0; s < 30; s++) {\n int pp1 = rng() % (N * N);\n int pp2 = rng() % (N * N);\n swap(restart_arr[pp1], restart_arr[pp2]);\n }\n vector curr_restart = restart_arr;\n long long restart_obj = compute_obj(curr_restart);\n double temp2 = 15000.0;\n vector best_restart = curr_restart;\n long long best_restart_obj = restart_obj;\n for (int iter = 0; iter < 100000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_restart[p1], curr_restart[p2]);\n long long new_obj = compute_obj(curr_restart);\n long long delta = new_obj - restart_obj;\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / temp2);\n double r = (rng() % 1000000000LL) / 1000000000.0;\n if (r < prob) accept = true;\n }\n if (accept) {\n restart_obj = new_obj;\n if (new_obj > best_restart_obj) {\n best_restart_obj = new_obj;\n best_restart = curr_restart;\n }\n } else {\n swap(curr_restart[p1], curr_restart[p2]);\n }\n if (iter % 400 == 0) {\n temp2 *= 0.9975;\n if (temp2 < 0.5) temp2 = 0.5;\n }\n }\n curr_restart = best_restart;\n for (int iter = 0; iter < 30000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_restart[p1], curr_restart[p2]);\n long long new_obj = compute_obj(curr_restart);\n if (new_obj > best_restart_obj) {\n best_restart_obj = new_obj;\n best_restart = curr_restart;\n }\n }\n if (best_restart_obj > best_obj) {\n best_obj = best_restart_obj;\n best_arr = best_restart;\n }\n vector> A(N, vector(N, 0));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n A[i][j] = best_arr[i * N + j];\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << A[i][j];\n if (j < N - 1) cout << \" \";\n else cout << \"\\n\";\n }\n }\n cout.flush();\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n int N, M, V;\n cin >> N >> M >> V;\n vector S(N), T(N);\n for (auto& str : S) cin >> str;\n for (auto& str : T) cin >> str;\n vector> grid(N, vector(N));\n vector> target(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n grid[i][j] = S[i][j] - '0';\n target[i][j] = T[i][j] - '0';\n }\n }\n vector> supplies, demands;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] && target[i][j] == 0) supplies.emplace_back(i, j);\n if (!grid[i][j] && target[i][j]) demands.emplace_back(i, j);\n }\n }\n if (supplies.size() != demands.size()) {\n // Should be equal, but handle by taking min or something, but assume equal\n }\n int Vp = 2;\n int L = 1;\n cout << Vp << endl;\n for (int u = 1; u < Vp; u++) {\n cout << 0 << \" \" << L << endl;\n }\n int rx = N / 2, ry = N / 2;\n cout << rx << \" \" << ry << endl;\n int cur_dir = 0;\n bool holding = false;\n vector commands;\n int DX[4] = {0, 1, 0, -1};\n int DY[4] = {1, 0, -1, 0};\n int delx[5] = {0, 0, 1, 0, -1};\n int dely[5] = {0, 1, 0, -1, 0};\n char mchar[5] = {'.', 'R', 'D', 'L', 'U'};\n char rchar[3] = {'.', 'L', 'R'};\n auto get_min_approx = [&](int px, int py) -> int {\n int md = 1000000000;\n for (int d = 0; d < 4; d++) {\n int tx = px - DX[d] * L;\n int ty = py - DY[d] * L;\n if (tx >= 0 && tx < N && ty >= 0 && ty < N) {\n md = min(md, abs(rx - tx) + abs(ry - ty));\n }\n }\n return md;\n };\n vector sup_used(supplies.size(), false);\n vector dem_used(demands.size(), false);\n int sup_rem = supplies.size();\n int dem_rem = demands.size();\n auto do_bfs = [&](int sx, int sy) -> vector> {\n vector> targets;\n for (int dd = 0; dd < 4; dd++) {\n int needx = sx - DX[dd] * L;\n int needy = sy - DY[dd] * L;\n if (needx >= 0 && needx < N && needy >= 0 && needy < N) {\n targets.emplace_back(needx, needy, dd);\n }\n }\n if (targets.empty()) return {};\n vector>> dist(N, vector>(N, vector(4, -1)));\n vector>> prev_x(N, vector>(N, vector(4, -1)));\n vector>> prev_y(N, vector>(N, vector(4, -1)));\n vector>> prev_d(N, vector>(N, vector(4, -1)));\n vector>> prev_move(N, vector>(N, vector(4, -1)));\n vector>> prev_rot(N, vector>(N, vector(4, -1)));\n dist[rx][ry][cur_dir] = 0;\n queue> q;\n q.emplace(rx, ry, cur_dir);\n while (!q.empty()) {\n auto [x, y, d] = q.front(); q.pop();\n for (int mid = 0; mid < 5; mid++) {\n int nx = x + delx[mid];\n int ny = y + dely[mid];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n for (int rid = 0; rid < 3; rid++) {\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n int nd = (d + dch) % 4;\n if (dist[nx][ny][nd] == -1) {\n dist[nx][ny][nd] = dist[x][y][d] + 1;\n prev_x[nx][ny][nd] = x;\n prev_y[nx][ny][nd] = y;\n prev_d[nx][ny][nd] = d;\n prev_move[nx][ny][nd] = mid;\n prev_rot[nx][ny][nd] = rid;\n q.emplace(nx, ny, nd);\n }\n }\n }\n }\n int min_d = 1000000000;\n int bx = -1, by = -1, bd = -1;\n for (auto [px, py, pd] : targets) {\n if (dist[px][py][pd] != -1 && dist[px][py][pd] < min_d) {\n min_d = dist[px][py][pd];\n bx = px; by = py; bd = pd;\n }\n }\n if (min_d == 1000000000) return {};\n vector> rev_path;\n int cx = bx, cy = by, cd = bd;\n while (dist[cx][cy][cd] > 0) {\n int mid = prev_move[cx][cy][cd];\n int rid = prev_rot[cx][cy][cd];\n rev_path.emplace_back(mid, rid);\n int px = prev_x[cx][cy][cd];\n int py = prev_y[cx][cy][cd];\n int pd = prev_d[cx][cy][cd];\n cx = px; cy = py; cd = pd;\n }\n reverse(rev_path.begin(), rev_path.end());\n return rev_path;\n };\n while (sup_rem > 0) {\n // Choose best supply if not holding\n int best_sup = -1;\n int minc = 1000000000;\n for (int i = 0; i < (int)supplies.size(); i++) {\n if (!sup_used[i]) {\n auto [px, py] = supplies[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_sup = i;\n }\n }\n }\n if (best_sup == -1) break;\n auto [sx, sy] = supplies[best_sup];\n int cur_fx = rx + DX[cur_dir] * L;\n int cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != sx || cur_fy != sy) {\n auto pth = do_bfs(sx, sy);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[sx][sy] = 0;\n holding = true;\n sup_used[best_sup] = true;\n sup_rem--;\n // Now choose best demand\n int best_dem = -1;\n minc = 1000000000;\n for (int i = 0; i < (int)demands.size(); i++) {\n if (!dem_used[i]) {\n auto [px, py] = demands[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_dem = i;\n }\n }\n }\n if (best_dem == -1) break;\n auto [tx, ty] = demands[best_dem];\n cur_fx = rx + DX[cur_dir] * L;\n cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != tx || cur_fy != ty) {\n auto pth = do_bfs(tx, ty);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[tx][ty] = 1;\n holding = false;\n dem_used[best_dem] = true;\n dem_rem--;\n }\n for (auto& cmd : commands) {\n cout << cmd << endl;\n }\n return 0;\n}","ahc039":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Info {\n ll tot, pre, suf, sub;\n};\n\nInfo comb(const Info& l, const Info& r) {\n Info res;\n res.tot = l.tot + r.tot;\n res.pre = max(l.pre, l.tot + r.pre);\n res.suf = max(r.suf, r.tot + l.suf);\n res.sub = max({l.sub, r.sub, l.suf + r.pre});\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n int N;\n cin >> N;\n vector X(2 * N), Y(2 * N);\n vector ism(2 * N, false);\n for (int i = 0; i < 2 * N; i++) {\n cin >> X[i] >> Y[i];\n if (i < N) ism[i] = true;\n }\n set sx, sy;\n for (int i = 0; i < 2 * N; i++) {\n sx.insert(X[i]);\n sy.insert(Y[i]);\n }\n vector allx(sx.begin(), sx.end());\n vector ally(sy.begin(), sy.end());\n int CX = allx.size();\n int CY = ally.size();\n map xr, yr;\n for (int i = 0; i < CX; i++) xr[allx[i]] = i + 1;\n for (int i = 0; i < CY; i++) yr[ally[i]] = i + 1;\n vector>> col(CX + 1);\n vector>> coly(CY + 1);\n for (int i = 0; i < 2 * N; i++) {\n int rrx = xr[X[i]];\n int rry = yr[Y[i]];\n ll v = ism[i] ? 1LL : -1LL;\n col[rrx].emplace_back(rry, v);\n coly[rry].emplace_back(rrx, v);\n }\n vector tree(4 * 10005);\n vector cur_ysum(10005, 0);\n auto build_func = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n tree[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n auto upd = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n tree[node].tot += delta;\n tree[node].pre += delta;\n tree[node].suf += delta;\n tree[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n if (CY >= 1) build_func(build_func, 1, 1, CY);\n auto get_kad_y = [&](int& syy, int& eyy) -> ll {\n if (CY < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_ysum[1];\n max_so = meh;\n for (int j = 2; j <= CY; j++) {\n if (cur_ysum[j] > meh + cur_ysum[j]) {\n meh = cur_ysum[j];\n cl = j;\n } else {\n meh += cur_ysum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n syy = bl;\n eyy = br;\n return max_so;\n };\n ll best_val = 0;\n int blx = -1, brx = -1, bly = -1, bry = -1;\n bool best_is_x_sweep = true;\n int step = 20;\n // x sweep\n {\n vector lsamps;\n for (int i = 1; i <= CX; i += step) lsamps.push_back(i);\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CX; R++) {\n for (auto [yy, vv] : col[R]) {\n upd(upd, 1, 1, CY, yy, vv);\n cur_ysum[yy] += vv;\n hist.emplace_back(yy, vv);\n }\n if ((R - L) % 25 == 0 || R == CX || R == L) {\n Info infoo = (CY >= 1 ? tree[1] : Info{0,0,0,0});\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int syy, eyy;\n ll act = get_kad_y(syy, eyy);\n if (act > best_val && eyy > syy && L < R) {\n int lx_x = allx[L - 1];\n int rx_x = allx[R - 1];\n int ly_y = ally[syy - 1];\n int ry_y = ally[eyy - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = L;\n brx = R;\n bly = syy;\n bry = eyy;\n best_is_x_sweep = true;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [yy, vv] = hist[i];\n upd(upd, 1, 1, CY, yy, -vv);\n cur_ysum[yy] -= vv;\n }\n }\n }\n // y sweep\n {\n vector treex(4 * 10005);\n vector cur_xsum(10005, 0);\n auto build_x = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n treex[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n treex[node] = comb(treex[2 * node], treex[2 * node + 1]);\n };\n auto upd_x = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n treex[node].tot += delta;\n treex[node].pre += delta;\n treex[node].suf += delta;\n treex[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n treex[node] = comb(treex[2 * node], treex[2 * node + 1]);\n };\n if (CX >= 1) build_x(build_x, 1, 1, CX);\n auto get_kad_x = [&](int& sxx, int& exx) -> ll {\n if (CX < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_xsum[1];\n max_so = meh;\n for (int j = 2; j <= CX; j++) {\n if (cur_xsum[j] > meh + cur_xsum[j]) {\n meh = cur_xsum[j];\n cl = j;\n } else {\n meh += cur_xsum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n sxx = bl;\n exx = br;\n return max_so;\n };\n vector lsamps;\n for (int i = 1; i <= CY; i += step) lsamps.push_back(i);\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CY; R++) {\n for (auto [xx, vv] : coly[R]) {\n upd_x(upd_x, 1, 1, CX, xx, vv);\n cur_xsum[xx] += vv;\n hist.emplace_back(xx, vv);\n }\n if ((R - L) % 25 == 0 || R == CY || R == L) {\n Info infoo = (CX >= 1 ? treex[1] : Info{0,0,0,0});\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int sxx, exx;\n ll act = get_kad_x(sxx, exx);\n if (act > best_val && exx > sxx && L < R) {\n int ly_y = ally[L - 1];\n int ry_y = ally[R - 1];\n int lx_x = allx[sxx - 1];\n int rx_x = allx[exx - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = sxx;\n brx = exx;\n bly = L;\n bry = R;\n best_is_x_sweep = false;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [xx, vv] = hist[i];\n upd_x(upd_x, 1, 1, CX, xx, -vv);\n cur_xsum[xx] -= vv;\n }\n }\n }\n if (best_val <= 0 || blx == -1) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n int x1, x2, y1, y2;\n x1 = allx[blx - 1]; x2 = allx[brx - 1];\n y1 = ally[bly - 1]; y2 = ally[bry - 1];\n if (x1 == x2 || y1 == y2) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y2 << \"\\n\";\n cout << x1 << \" \" << y2 << \"\\n\";\n }\n }\n}","ahc040":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Strat {\n double wa, wb;\n bool use_area;\n int force_d;\n};\n\nll calc_bbox(const vector& WW, const vector& HH, const vector& rots, const vector& dirs, const vector& brefs) {\n int n = WW.size();\n vector px(n, 0), py(n, 0), pww(n, 0), phh(n, 0);\n ll cmw = 0, cmh = 0;\n for (int i = 0; i < n; i++) {\n int r = rots[i];\n ll ww = r ? HH[i] : WW[i];\n ll hh = r ? WW[i] : HH[i];\n int dd = dirs[i];\n int b = brefs[i];\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n if (max(yy, py[j]) < min(yy + hh, py[j] + phh[j])) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n if (max(xx, px[j]) < min(xx + ww, px[j] + pww[j])) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n px[i] = xx; py[i] = yy; pww[i] = ww; phh[i] = hh;\n cmw = max(cmw, xx + ww);\n cmh = max(cmh, yy + hh);\n }\n return cmw + cmh;\n}\n\nint main() {\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector W(N), H(N);\n for (int i = 0; i < N; i++) {\n cin >> W[i] >> H[i];\n }\n vector strats = {\n {1.0, 1.0, false, -1},\n {2.0, 1.0, false, -1},\n {1.0, 2.0, false, -1},\n {3.0, 1.0, false, -1},\n {1.0, 3.0, false, -1},\n {5.0, 1.0, false, -1},\n {1.0, 5.0, false, -1},\n {10.0, 1.0, false, -1},\n {1.0, 10.0, false, -1},\n {0.0, 0.0, true, -1},\n {1.0, 1.0, false, 0},\n {1.0, 1.0, false, 1}\n };\n mt19937 rng(12345);\n int ns = strats.size();\n vector, vector, vector>> top_configs;\n const int max_top = 5;\n for (int t = 0; t < T; t++) {\n vector rotv(N), dirv(N), bref(N);\n bool do_random = (t % 7 == 0);\n bool do_perturb = (!do_random && t % 4 == 1 && !top_configs.empty() && t > 3);\n if (do_random) {\n for (int i = 0; i < N; i++) {\n rotv[i] = rng() % 2;\n dirv[i] = rng() % 2;\n bref[i] = (i > 0 ? (rng() % i) : -1);\n }\n } else if (do_perturb) {\n int idx = rng() % top_configs.size();\n auto& tp = top_configs[idx];\n rotv = get<1>(tp);\n dirv = get<2>(tp);\n bref = get<3>(tp);\n vector bestv_rot = rotv, bestv_dir = dirv, bestv_bref = bref;\n ll best_bbox = calc_bbox(W, H, bestv_rot, bestv_dir, bestv_bref);\n for (int iter = 0; iter < 80; iter++) {\n vector temp_rot = bestv_rot;\n vector temp_dir = bestv_dir;\n vector temp_bref = bestv_bref;\n int pos = rng() % N;\n if (rng() % 2 == 0) temp_rot[pos] = 1 - temp_rot[pos];\n if (rng() % 2 == 0) temp_dir[pos] = 1 - temp_dir[pos];\n if (pos > 0) {\n int rch = rng() % 4;\n if (rch == 0) {\n int del = (rng() % 5 - 2);\n temp_bref[pos] = max(-1, min(pos - 1, temp_bref[pos] + del));\n } else if (rch == 1) {\n temp_bref[pos] = rng() % pos;\n }\n if (rch == 2) {\n int del = (rng() % 5 - 2);\n temp_bref[pos] = max(-1, min(pos - 1, temp_bref[pos] + del));\n }\n }\n ll sc = calc_bbox(W, H, temp_rot, temp_dir, temp_bref);\n if (sc < best_bbox) {\n best_bbox = sc;\n bestv_rot = temp_rot;\n bestv_dir = temp_dir;\n bestv_bref = temp_bref;\n }\n }\n rotv = bestv_rot;\n dirv = bestv_dir;\n bref = bestv_bref;\n } else {\n Strat st = strats[t % ns];\n vector px(N, 0), py(N, 0), pww(N, 0), phh(N, 0);\n ll cmaxw = 0, cmaxh = 0;\n for (int i = 0; i < N; i++) {\n double bestc = 1e30;\n int br = -1, bd = -1, bb = -1;\n ll bx = 0, by = 0, bww = 0, bhh = 0;\n vector bs_vec;\n for (int b = -1; b < i; b++) bs_vec.push_back(b);\n for (int r = 0; r < 2; r++) {\n ll ww = r ? H[i] : W[i];\n ll hh = r ? W[i] : H[i];\n for (int dd = 0; dd < 2; dd++) {\n if (st.force_d >= 0 && dd != st.force_d) continue;\n for (int b : bs_vec) {\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n if (max(yy, py[j]) < min(yy + hh, py[j] + phh[j])) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n if (max(xx, px[j]) < min(xx + ww, px[j] + pww[j])) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n ll nw = max(cmaxw, xx + ww);\n ll nh = max(cmaxh, yy + hh);\n double cost;\n if (st.use_area) {\n cost = 1.0 * nw * nh;\n } else {\n cost = st.wa * nw + st.wb * nh;\n }\n cost += (rng() % 1001 - 500) * 1e-5;\n if (cost < bestc) {\n bestc = cost;\n br = r;\n bd = dd;\n bb = b;\n bx = xx;\n by = yy;\n bww = ww;\n bhh = hh;\n }\n }\n }\n }\n rotv[i] = br;\n dirv[i] = bd;\n bref[i] = bb;\n px[i] = bx;\n py[i] = by;\n pww[i] = bww;\n phh[i] = bhh;\n cmaxw = max(cmaxw, bx + bww);\n cmaxh = max(cmaxh, by + bhh);\n }\n }\n cout << N << endl;\n for (int i = 0; i < N; i++) {\n cout << i << \" \" << rotv[i] << \" \" << (dirv[i] ? \"U\" : \"L\") << \" \" << bref[i] << endl;\n }\n cout.flush();\n ll wp, hp;\n cin >> wp >> hp;\n ll meas = wp + hp;\n bool added_top = false;\n if (top_configs.size() < max_top) {\n added_top = true;\n } else if (!top_configs.empty() && meas + 3LL * sigma < get<0>(top_configs.back())) {\n added_top = true;\n }\n if (added_top) {\n auto tup = make_tuple(meas, rotv, dirv, bref);\n top_configs.push_back(tup);\n sort(top_configs.begin(), top_configs.end());\n if (top_configs.size() > max_top) {\n top_configs.resize(max_top);\n }\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n vector X(N), Y(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i];\n }\n long long best_score = -1;\n vector best_p(N, -1);\n // Mode 0: prefer high promotion\n for (int mode = 0; mode < 3; mode++) {\n vector level(N, 0);\n vector p(N, -1);\n long long score = 0;\n if (mode < 2) {\n bool prefer_high = (mode == 0);\n bool changed = true;\n int max_iter = N * H + 100;\n int iter = 0;\n while (changed && iter++ < max_iter) {\n changed = false;\n long long best_a = prefer_high ? -1 : LLONG_MAX;\n int best_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] < H) {\n bool can = false;\n for (int u : adj[v]) {\n if (level[u] == level[v]) {\n can = true;\n break;\n }\n }\n if (can) {\n if (prefer_high) {\n if (A[v] > best_a) {\n best_a = A[v];\n best_v = v;\n }\n } else {\n if (A[v] < best_a) {\n best_a = A[v];\n best_v = v;\n }\n }\n }\n }\n }\n if (best_v != -1) {\n level[best_v]++;\n changed = true;\n }\n }\n iter = 0;\n while (iter++ < max_iter) {\n long long worst_a = LLONG_MAX;\n int worst_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] > 0) {\n bool has = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n has = true;\n break;\n }\n }\n if (!has && A[v] < worst_a) {\n worst_a = A[v];\n worst_v = v;\n }\n }\n }\n if (worst_v != -1) {\n level[worst_v]--;\n } else {\n break;\n }\n }\n bool valid = true;\n for (int v = 0; v < N; v++) {\n if (level[v] == 0) {\n p[v] = -1;\n } else {\n bool found = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n p[v] = u;\n found = true;\n break;\n }\n }\n if (!found) valid = false;\n }\n }\n if (!valid) continue;\n score = 0;\n for (int v = 0; v < N; v++) {\n score += level[v] * A[v];\n }\n } else {\n // Mode 2: greedy attach low A first max depth\n vector depth(N, -1);\n p.assign(N, -1);\n vector> order(N);\n for (int i = 0; i < N; i++) order[i] = {A[i], i};\n sort(order.begin(), order.end());\n for (auto& pr : order) {\n int v = pr.second;\n int max_par_d = -1;\n int best_par = -1;\n for (int u : adj[v]) {\n if (depth[u] != -1 && depth[u] < H) {\n if (depth[u] > max_par_d) {\n max_par_d = depth[u];\n best_par = u;\n }\n }\n }\n if (max_par_d != -1) {\n depth[v] = max_par_d + 1;\n p[v] = best_par;\n } else {\n depth[v] = 0;\n p[v] = -1;\n }\n }\n score = 0;\n bool valid = true;\n for (int v = 0; v < N; v++) {\n if (depth[v] == -1) valid = false;\n else score += depth[v] * A[v];\n }\n if (!valid) continue;\n level = depth; // for consistency, but not needed\n }\n if (score > best_score) {\n best_score = score;\n best_p = p;\n }\n }\n if (best_score == -1) {\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << -1;\n }\n cout << endl;\n } else {\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << best_p[i];\n }\n cout << endl;\n }\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint NN;\nvector board;\nvector> moves;\n\nvoid do_shift(char d, int p) {\n if (d == 'L') {\n for (int j = 0; j < NN - 1; j++) board[p][j] = board[p][j + 1];\n board[p][NN - 1] = '.';\n } else if (d == 'R') {\n for (int j = NN - 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 < NN - 1; i++) board[i][p] = board[i + 1][p];\n board[NN - 1][p] = '.';\n } else if (d == 'D') {\n for (int i = NN - 1; i > 0; i--) board[i][p] = board[i - 1][p];\n board[0][p] = '.';\n }\n}\n\nint main() {\n srand(time(NULL));\n int N;\n cin >> N;\n NN = N;\n board.resize(N);\n for (int i = 0; i < N; i++) cin >> board[i];\n vector orig_board = board;\n vector> best_moves;\n int minT = INT_MAX;\n for (int trial = 0; trial < 200; trial++) {\n board = orig_board;\n moves.clear();\n int iter = 0;\n while (true) {\n int numx = 0;\n for (auto& s : board) for (char c : s) if (c == 'x') numx++;\n if (numx == 0) break;\n if (++iter > 10000) break;\n double best_r = -1;\n char best_d = ' ';\n int best_p = -1;\n int best_k = 0;\n int best_n = 0;\n int best_c = 1000000000;\n bool use_pert = (trial % 5 != 0);\n // rows left\n for (int i = 0; i < N; i++) {\n int maxj = -1, nm = 0;\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxj = j; nm++; }\n }\n if (nm > 0) {\n int kk = maxj + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'L';\n best_p = i;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n // rows right\n for (int i = 0; i < N; i++) {\n int lmost = N;\n for (int j = N - 1; j >= 0; j--) {\n if (board[i][j] == 'o') { lmost = j + 1; break; }\n }\n int minj = N, nm = 0;\n for (int j = lmost; j < N; j++) {\n if (board[i][j] == 'x') { minj = min(minj, j); nm++; }\n }\n if (nm > 0) {\n int kk = N - minj;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'R';\n best_p = i;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n // cols up\n for (int j = 0; j < N; j++) {\n int maxi = -1, nm = 0;\n for (int i = 0; i < N; i++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxi = i; nm++; }\n }\n if (nm > 0) {\n int kk = maxi + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'U';\n best_p = j;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n // cols down\n for (int j = 0; j < N; j++) {\n int lmost = N;\n for (int i = N - 1; i >= 0; i--) {\n if (board[i][j] == 'o') { lmost = i + 1; break; }\n }\n int mini = N, nm = 0;\n for (int i = lmost; i < N; i++) {\n if (board[i][j] == 'x') { mini = min(mini, i); nm++; }\n }\n if (nm > 0) {\n int kk = N - mini;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'D';\n best_p = j;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n if (best_p == -1) break;\n char dd = best_d;\n int p = best_p;\n int kk = best_k;\n char op = (dd == 'L' ? 'R' : (dd == 'R' ? 'L' : (dd == 'U' ? 'D' : 'U')));\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(dd, p);\n do_shift(dd, p);\n }\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(op, p);\n do_shift(op, p);\n }\n }\n int curT = moves.size();\n if (curT < minT) {\n minT = curT;\n best_moves = moves;\n }\n }\n for (auto [d, pp] : best_moves) {\n cout << d << \" \" << pp << endl;\n }\n}","ahc044":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, L;\n cin >> N >> L;\n static int T[100];\n for(int i = 0; i < N; i++) cin >> T[i];\n static ll pref[101];\n pref[0] = 0;\n for(int j = 0; j < N; j++) {\n pref[j + 1] = pref[j] + T[j] + 1;\n }\n ll total = pref[N];\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n auto get_sample = [&](ll p[], ll tot) -> int {\n ll r = uniform_int_distribution(0, tot - 1)(rng);\n int low = 0, high = N;\n while(low < high) {\n int mid = (low + high) / 2;\n if(p[mid] > r) high = mid;\n else low = mid + 1;\n }\n return low - 1;\n };\n static int best_a[100], best_b[100], best_cnt[100];\n static int tmp_a[100], tmp_b[100], tmp_cnt[100];\n static ll def_pref[101];\n auto do_sim = [&](int A[], int B[], int* cnt) -> int {\n memset(cnt, 0, sizeof(int) * N);\n int cur = 0;\n for(int w = 1; w <= L; w++) {\n cnt[cur]++;\n if(w < L) {\n if(cnt[cur] % 2 == 1) cur = A[cur];\n else cur = B[cur];\n }\n }\n int err = 0;\n for(int i = 0; i < N; i++) {\n err += abs(cnt[i] - T[i]);\n }\n return err;\n };\n // greedy construction start\n int greedy_trials = 40;\n int best_err = INT_MAX;\n static int greedy_idx[100];\n for(int gt=0; gt d1) {\n d2 = d1; b2 = b1;\n d1 = d; b1 = j;\n } else if(d > d2) {\n d2 = d; b2 = j;\n }\n }\n if(b2 == -1) b2 = b1;\n AA[i] = b1;\n BB[i] = b2;\n inflow[b1] += T[i] * 0.5 + 0.25;\n inflow[b2] += T[i] * 0.5 - 0.25;\n if(b1 == b2) inflow[b1] += 0.5; // adjust if same\n }\n int err = do_sim(AA, BB, tmp_cnt);\n if(err < best_err) {\n best_err = err;\n memcpy(best_a, AA, sizeof(int)*N);\n memcpy(best_b, BB, sizeof(int)*N);\n memcpy(best_cnt, tmp_cnt, sizeof(int)*N);\n }\n }\n const int NUM_MUT = 420;\n for(int m = 0; m < NUM_MUT; m++) {\n memcpy(tmp_a, best_a, sizeof(int)*N);\n memcpy(tmp_b, best_b, sizeof(int)*N);\n def_pref[0] = 0;\n for(int j = 0; j < N; j++) {\n int def = max(0, T[j] - best_cnt[j]);\n def_pref[j + 1] = def_pref[j] + (def + 1LL);\n }\n ll def_tot = def_pref[N];\n int num_changes = (uniform_int_distribution(0, 9)(rng) < 1 ? 2 : 1);\n for(int ch = 0; ch < num_changes; ch++) {\n int i = uniform_int_distribution(0, N - 1)(rng);\n int choice = uniform_int_distribution(0, 1)(rng);\n int news = get_sample(def_pref, def_tot);\n if(choice == 0) tmp_a[i] = news;\n else tmp_b[i] = news;\n }\n int new_err = do_sim(tmp_a, tmp_b, tmp_cnt);\n if(new_err < best_err) {\n best_err = new_err;\n memcpy(best_a, tmp_a, sizeof(int)*N);\n memcpy(best_b, tmp_b, sizeof(int)*N);\n memcpy(best_cnt, tmp_cnt, sizeof(int)*N);\n }\n }\n for(int i = 0; i < N; i++) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n double d;\n};\n\nint main() {\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int &g : G) cin >> g;\n vector cx(N), cy(N);\n vector Lx(N), Rx(N), Ly(N), Ry(N);\n for (int i = 0; i < N; i++) {\n cin >> Lx[i] >> Rx[i] >> Ly[i] >> Ry[i];\n cx[i] = (Lx[i] + Rx[i]) / 2.0;\n cy[i] = (Ly[i] + Ry[i]) / 2.0;\n }\n vector>> near(N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i != j) {\n double d = hypot(cx[i] - cx[j], cy[i] - cy[j]);\n near[i].emplace_back(d, j);\n }\n }\n sort(near[i].begin(), near[i].end());\n if (near[i].size() > 20) near[i].resize(20);\n }\n vector> known_global;\n set> known_set;\n int q_disc = Q / 2;\n int queries_done = 0;\n for (int q = 0; q < q_disc && queries_done < q_disc; q++) {\n int base = (q * 3) % N;\n vector cset = {base};\n set in_set = {base};\n for (auto &pr : near[base]) {\n if ((int)cset.size() >= L) break;\n if (in_set.find(pr.second) == in_set.end()) {\n cset.push_back(pr.second);\n in_set.insert(pr.second);\n }\n }\n if (cset.size() < 2) continue;\n cout << \"? \" << cset.size();\n for (int p : cset) cout << \" \" << p;\n cout << endl;\n int lsize = cset.size();\n vector> resp(lsize - 1);\n for (int r = 0; r < lsize - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (known_set.find(p) == known_set.end()) {\n known_set.insert(p);\n known_global.push_back(p);\n }\n }\n queries_done++;\n }\n // build priority MST\n vector prio_known;\n for (auto &pr : known_global) {\n int a = pr.first, b = pr.second;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n prio_known.push_back({a, b, d});\n }\n sort(prio_known.begin(), prio_known.end(), [](const Edge &a, const Edge &b){ return a.d < b.d; });\n vector par(N); iota(par.begin(), par.end(), 0);\n auto findp = [&](auto self, int x) -> int { return par[x] == x ? x : par[x] = self(self, par[x]); };\n vector> adj_prio(N);\n for (auto &e : prio_known) {\n int pu = findp(findp, e.u), pv = findp(findp, e.v);\n if (pu != pv) {\n par[pu] = pv;\n adj_prio[e.u].push_back(e.v);\n adj_prio[e.v].push_back(e.u);\n }\n }\n vector est_rem;\n for (int i=0;i order;\n vector vis(N, false);\n function dfs_p = [&](int u, int p){\n vis[u]=true;\n order.push_back(u);\n for(int v:adj_prio[u]) if(!vis[v]&&v!=p) dfs_p(v,u);\n };\n dfs_p(0,-1);\n if(order.size() < (size_t)N){\n vis.assign(N,false);\n for(int i=0;i> groups(M);\n int idxx = 0;\n for(int k=0;k &grp = groups[k];\n int gs = grp.size();\n if(gs <= 1) continue;\n int i = 0;\n while(i < gs-1 && queries_done < Q){\n int len = min(L, gs-i);\n if(len < 2) break;\n cout << \"? \" << len;\n for(int p=i; p> resp(len-1);\n for(int r=0;r>a>>b; if(a>b)swap(a,b); resp[r]={a,b};\n }\n for(auto p:resp){\n if(known_set.find(p)==known_set.end()){\n known_set.insert(p);\n known_global.push_back(p);\n }\n }\n queries_done++;\n if(i + len >= gs) break;\n i += max(1, adv_base);\n }\n }\n // additional offset pass for remaining\n for(int k=0; k &grp = groups[k];\n int gs = grp.size();\n if(gs <=1) continue;\n int off = 1;\n int step = max(1, adv_base / 2);\n int i = step;\n while(i < gs-2 && queries_done < Q && off < 3){\n int len = min(L, gs - i);\n if(len < 2) break;\n cout << \"? \" << len;\n for(int p=i; p> resp(len-1);\n for(int r=0;r>a>>b; if(a>b)swap(a,b); resp[r]={a,b};\n }\n for(auto p:resp){\n if(known_set.find(p)==known_set.end()){\n known_set.insert(p);\n known_global.push_back(p);\n }\n }\n queries_done++;\n if(queries_done >=Q) break;\n i += step;\n off++;\n }\n }\n cout << \"!\" << endl;\n for(int k=0;k grp = groups[k];\n int gs = grp.size();\n for(int j=0;j> knownp(known_global.begin(), known_global.end());\n vector> known_list;\n vector local_id(N,-1);\n for(int j=0;j parent(gs); iota(parent.begin(),parent.end(),0);\n auto find = [&](auto &self,int x)->int{return parent[x]==x?x:parent[x]=self(self,parent[x]);};\n auto unite=[&](int x,int y)->bool{ x=find(find,x);y=find(find,y); if(x!=y){parent[x]=y;return true;} return false;};\n vector> mst_roads;\n int added=0;\n for(auto &[d,ia,ib]:known_list){\n if(unite(ia,ib)){ mst_roads.emplace_back(grp[ia],grp[ib]); added++;}\n if(added==gs-1) break;\n }\n if(added < gs-1){\n vector> unk;\n for(int ii=0;ii pp={min(a,b),max(a,b)};\n if(knownp.find(pp)!=knownp.end()) continue;\n double d = hypot(cx[a]-cx[b],cy[a]-cy[b]);\n unk.emplace_back(d,ii,jj);\n }\n sort(unk.begin(),unk.end());\n for(auto &[d,ia,ib]:unk){\n if(unite(ia,ib)){mst_roads.emplace_back(grp[ia],grp[ib]); added++;}\n if(added==gs-1) break;\n }\n }\n for(auto &rd:mst_roads){\n cout << rd.first << \" \" << rd.second << endl;\n }\n }\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> points(M);\n for (int m = 0; m < M; m++) {\n cin >> points[m].first >> points[m].second;\n }\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n pair current = points[0];\n vector> seq;\n for (int k = 1; k < M; k++) {\n pair goal = points[k];\n set> forbidden;\n for (int t = k + 1; t < M; t++) {\n forbidden.insert(points[t]);\n }\n vector> dist(N, vector(N, -1));\n vector>> prevpos(N, vector>(N, {-1, -1}));\n vector>> prevact(N, vector>(N, {' ', ' '}));\n queue> q;\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n // M actions\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n // S actions\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Fallback: no forbidden, allow all\n forbidden.clear();\n dist.assign(N, vector(N, -1));\n prevpos.assign(N, vector>(N, {-1, -1}));\n prevact.assign(N, vector>(N, {' ', ' '}));\n q = queue>();\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Still unreachable, fallback to pure M manhattan path, allowing everything\n // Compute simple horiz then vert M path\n vector> path;\n int ci = current.first, cj = current.second;\n int gi = goal.first, gj = goal.second;\n int stepi, stepj;\n stepi = (gi > ci ? 1 : (gi < ci ? -1 : 0));\n for (int s = 0; s < abs(gi - ci); s++) {\n path.push_back({'M', (stepi > 0 ? 'D' : 'U')});\n }\n stepj = (gj > cj ? 1 : (gj < cj ? -1 : 0));\n for (int s = 0; s < abs(gj - cj); s++) {\n path.push_back({'M', (stepj > 0 ? 'R' : 'L')});\n }\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n continue;\n }\n // Reconstruct path\n vector> path;\n pair pos = goal;\n while (pos != current) {\n pair act = prevact[pos.first][pos.second];\n path.push_back(act);\n pos = prevpos[pos.first][pos.second];\n }\n reverse(path.begin(), path.end());\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n }\n for (auto& p : seq) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}"},"16":{"ahc001":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Rect {\n int x1, y1, x2, y2;\n};\n\nint N;\nvector X, Y, R;\nvector best_rects;\ndouble best_score = -1.0;\n\ndouble compute_score(const vector& recs) {\n double tot = 0.0;\n for (int i = 0; i < N; i++) {\n ll a = recs[i].x1, b = recs[i].y1, c = recs[i].x2, d = recs[i].y2;\n ll s = (c - a) * 1LL * (d - b);\n ll rr = R[i];\n if (s == 0 || rr == 0) continue;\n double ratio = min(s, rr) * 1.0 / max(s, rr);\n tot += 1.0 - (1.0 - ratio) * (1.0 - ratio);\n }\n return tot;\n}\n\nvoid solve_rects(int lx, int ly, int rx, int ry, vector ps, vector& recs) {\n if (ps.size() == 0) return;\n if (ps.size() == 1) {\n recs[ps[0]] = {lx, ly, rx, ry};\n return;\n }\n ll area = (rx - lx) * 1LL * (ry - ly);\n double best_mis = 1e30;\n int best_d = -1, best_kk = -1, best_ct = -1;\n for (int dir = 0; dir < 2; dir++) {\n vector idx = ps;\n if (dir == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int m = idx.size();\n vector pref(m + 1, 0);\n for (int j = 1; j <= m; j++) {\n pref[j] = pref[j - 1] + R[idx[j - 1]];\n }\n ll tot = pref[m];\n if (tot == 0) continue;\n for (int k = 1; k < m; k++) {\n ll sleft = pref[k];\n int idl = idx[k - 1], idr = idx[k];\n ll min_c, max_c;\n if (dir == 0) {\n min_c = X[idl] + 1;\n max_c = X[idr];\n } else {\n min_c = Y[idl] + 1;\n max_c = Y[idr];\n }\n ll low = dir == 0 ? lx + 1 : ly + 1;\n ll high = dir == 0 ? rx - 1 : ry - 1;\n min_c = max(min_c, low);\n max_c = min(max_c, high);\n if (min_c > max_c) continue;\n double target_a = sleft * 1.0 / tot * area;\n ll target_cut;\n if (dir == 0) {\n ll hgt = ry - ly;\n if (hgt <= 0) continue;\n ll dw = (ll)round(target_a / hgt);\n target_cut = lx + dw;\n } else {\n ll wid = rx - lx;\n if (wid <= 0) continue;\n ll dh = (ll)round(target_a / wid);\n target_cut = ly + dh;\n }\n ll cutt = max(min_c, min(max_c, target_cut));\n ll act_area = 0;\n if (dir == 0) {\n act_area = (cutt - lx) * 1LL * (ry - ly);\n } else {\n act_area = (rx - lx) * 1LL * (cutt - ly);\n }\n double mis = fabs(act_area - target_a);\n double pert = (rand() % 1000000) * 1e-9;\n double perturbed = mis + pert;\n if (perturbed < best_mis) {\n best_mis = perturbed;\n best_d = dir;\n best_kk = k;\n best_ct = (int)cutt;\n }\n }\n }\n if (best_d == -1) {\n bool found = false;\n int dir_try = (rx - lx > 1 ? 0 : 1);\n for (int tries = 0; tries < 2 && !found; tries++) {\n int dirr = dir_try;\n vector idxx = ps;\n if (dirr == 0) {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idxx.begin(), idxx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n int mm = idxx.size();\n for (int kk = 1; kk < mm; kk++) {\n int idl = idxx[kk - 1], idr = idxx[kk];\n ll minc_ = dirr == 0 ? X[idl] + 1 : Y[idl] + 1;\n ll maxc_ = dirr == 0 ? X[idr] : Y[idr];\n ll loww = dirr == 0 ? lx + 1 : ly + 1;\n ll highh = dirr == 0 ? rx - 1 : ry - 1;\n if (minc_ <= maxc_ && minc_ <= highh && maxc_ >= loww) {\n best_d = dirr;\n best_kk = kk;\n ll midv = (max(minc_, loww) + min(maxc_, highh)) / 2;\n best_ct = (int)midv;\n found = true;\n break;\n }\n }\n dir_try = 1 - dir_try;\n }\n if (!found) {\n best_d = 0;\n best_kk = ps.size() / 2;\n best_ct = lx + (rx - lx) / 2;\n if (best_ct < lx + 1) best_ct = lx + 1;\n if (best_ct > rx - 1) best_ct = rx - 1;\n }\n }\n vector idx = ps;\n if (best_d == 0) {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (X[p] != X[q]) return X[p] < X[q];\n return Y[p] < Y[q];\n });\n } else {\n sort(idx.begin(), idx.end(), [&](int p, int q) {\n if (Y[p] != Y[q]) return Y[p] < Y[q];\n return X[p] < X[q];\n });\n }\n vector left_ps(idx.begin(), idx.begin() + best_kk);\n vector right_ps(idx.begin() + best_kk, idx.end());\n if (best_d == 0) {\n solve_rects(lx, ly, best_ct, ry, left_ps, recs);\n solve_rects(best_ct, ly, rx, ry, right_ps, recs);\n } else {\n solve_rects(lx, ly, rx, best_ct, left_ps, recs);\n solve_rects(lx, best_ct, rx, ry, right_ps, recs);\n }\n}\n\nvoid optimize(vector& recs) {\n int max_passes = 100;\n for (int pass = 0; pass < max_passes; pass++) {\n vector> candidates;\n for (int i = 0; i < N; i++) {\n Rect &rct = recs[i];\n ll s = (rct.x2 - rct.x1) * 1LL * (rct.y2 - rct.y1);\n ll rr = R[i];\n ll diff = abs(s - rr);\n if (diff > 0) candidates.emplace_back(diff, i);\n }\n if (candidates.empty()) break;\n sort(candidates.rbegin(), candidates.rend());\n bool changed = false;\n for (auto& p : candidates) {\n int i = p.second;\n ll rr = R[i];\n Rect &rct = recs[i];\n ll cur_a = rct.x1;\n ll cur_b = rct.y1;\n ll cur_c = rct.x2;\n ll cur_d = rct.y2;\n ll s = (cur_c - cur_a) * 1LL * (cur_d - cur_b);\n if (s == rr) continue;\n bool is_expand = s < rr;\n ll target_s = rr;\n vector ddirs = {0,1,2,3};\n random_shuffle(ddirs.begin(), ddirs.end());\n bool moved = false;\n for (int dd : ddirs) {\n ll dim = 0;\n ll max_delta = 0;\n if (dd == 0) {\n dim = cur_d - cur_b;\n if (dim <= 0) continue;\n if (is_expand) {\n ll max_pos = 10000;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_b, (ll)oj.y1), ov2 = min(cur_d, (ll)oj.y2);\n if (ov1 < ov2) max_pos = min(max_pos, (ll)oj.x1);\n }\n max_delta = max_pos - cur_c;\n } else {\n ll min_pos = max(cur_a + 1, X[i] + 1);\n max_delta = cur_c - min_pos;\n }\n } else if (dd == 1) {\n dim = cur_d - cur_b;\n if (dim <= 0) continue;\n if (is_expand) {\n ll min_pos = 0;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_b, (ll)oj.y1), ov2 = min(cur_d, (ll)oj.y2);\n if (ov1 < ov2) min_pos = max(min_pos, (ll)oj.x2);\n }\n max_delta = cur_a - min_pos;\n } else {\n ll max_pos = min(cur_c - 1, X[i]);\n max_delta = max_pos - cur_a;\n }\n } else if (dd == 2) {\n dim = cur_c - cur_a;\n if (dim <= 0) continue;\n if (is_expand) {\n ll max_pos = 10000;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_a, (ll)oj.x1), ov2 = min(cur_c, (ll)oj.x2);\n if (ov1 < ov2) max_pos = min(max_pos, (ll)oj.y1);\n }\n max_delta = max_pos - cur_d;\n } else {\n ll min_pos = max(cur_b + 1, Y[i] + 1);\n max_delta = cur_d - min_pos;\n }\n } else if (dd == 3) {\n dim = cur_c - cur_a;\n if (dim <= 0) continue;\n if (is_expand) {\n ll min_pos = 0;\n for (int j = 0; j < N; j++) if (j != i) {\n Rect oj = recs[j];\n ll ov1 = max(cur_a, (ll)oj.x1), ov2 = min(cur_c, (ll)oj.x2);\n if (ov1 < ov2) min_pos = max(min_pos, (ll)oj.y2);\n }\n max_delta = cur_b - min_pos;\n } else {\n ll max_pos = min(cur_d - 1, Y[i]);\n max_delta = max_pos - cur_b;\n }\n }\n if (max_delta <= 0) continue;\n ll need = abs(target_s - s);\n ll delta_need = (need + dim - 1LL) / dim;\n ll actual = min(max_delta, delta_need);\n if (actual > 0) {\n if (is_expand) {\n if (dd == 0) rct.x2 += actual;\n else if (dd == 1) rct.x1 -= actual;\n else if (dd == 2) rct.y2 += actual;\n else if (dd == 3) rct.y1 -= actual;\n } else {\n if (dd == 0) rct.x2 -= actual;\n else if (dd == 1) rct.x1 += actual;\n else if (dd == 2) rct.y2 -= actual;\n else if (dd == 3) rct.y1 += actual;\n }\n moved = true;\n changed = true;\n break;\n }\n }\n }\n if (!changed) break;\n }\n}\n\nint main() {\n srand((unsigned)time(NULL));\n cin >> N;\n X.resize(N);\n Y.resize(N);\n R.resize(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i] >> R[i];\n }\n best_score = -1.0;\n const int trials = 50;\n for (int t = 0; t < trials; t++) {\n vector recs(N);\n vector ps(N);\n iota(ps.begin(), ps.end(), 0);\n solve_rects(0, 0, 10000, 10000, ps, recs);\n optimize(recs);\n double sc = compute_score(recs);\n if (sc > best_score) {\n best_score = sc;\n best_rects = recs;\n }\n }\n for (int i = 0; i < N; i++) {\n cout << best_rects[i].x1 << \" \" << best_rects[i].y1 << \" \" << best_rects[i].x2 << \" \" << best_rects[i].y2 << endl;\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct State {\n int ci, cj;\n ll score;\n string pth;\n bitset<2500> vis;\n};\n\nint main() {\n int si, sj;\n cin >> si >> sj;\n int T[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> T[i][j];\n int P[50][50];\n for(int i=0; i<50; i++) for(int j=0; j<50; j++) cin >> P[i][j];\n pair sib[50][50];\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) sib[i][j] = {-1,-1};\n int maxt = 0;\n for(int i=0;i<50;i++)for(int j=0;j<50;j++) maxt = max(maxt, T[i][j]);\n vector>> tilec(maxt+1);\n for(int i=0;i<50;i++)for(int j=0;j<50;j++){\n tilec[T[i][j]].emplace_back(i,j);\n }\n for(auto& v: tilec){\n if(v.size()==2){\n auto [x1,y1]=v[0]; auto [x2,y2]=v[1];\n sib[x1][y1]={x2,y2};\n sib[x2][y2]={x1,y1};\n }\n }\n int di[4]={-1,0,1,0};\n int dj[4]={0,1,0,-1};\n char dc[4]={'U','R','D','L'};\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n ll best_score = P[si][sj];\n string best_path = \"\";\n auto simulate = [&](int mode) -> pair {\n bool vis[50][50] = {};\n vis[si][sj] = true;\n ll score = P[si][sj];\n string path = \"\";\n int ci=si, cj = sj;\n while(true) {\n vector cands;\n for(int d=0;d<4;d++) {\n int ni = ci + di[d], nj = cj + dj[d];\n if(ni<0 || ni >=50 || nj<0 || nj>=50 || vis[ni][nj]) continue;\n auto [bx,by] = sib[ni][nj];\n if(bx!=-1 && vis[bx][by]) continue;\n cands.push_back(d);\n }\n if(cands.empty()) break;\n vector ws;\n if(mode ==0 || mode ==1) {\n ws.assign(cands.size(), 0);\n for(size_t k=0; k=50||nnj<0||nnj>=50 || vis[nni][nnj]) continue;\n auto [bx,by] = sib[nni][nnj];\n if(bx !=-1 && vis[bx][by]) continue;\n maxnp = max(maxnp, (ll)P[nni][nnj]);\n }\n ws[k] = val + maxnp + 1;\n }\n }\n size_t idx;\n if(mode ==0) {\n ll mw = -1;\n idx = 0;\n for(size_t k=0; k mw) {\n mw = ws[k];\n idx = k;\n }\n } else if(mode ==1) {\n ll sumw = 0;\n for(auto w : ws) sumw += w;\n size_t sz = cands.size();\n if(sumw == 0 || sz == 0) {\n idx = 0;\n } else {\n uniform_int_distribution dist(0, sumw-1);\n ll target = dist(rng);\n idx = sz -1;\n ll cum = 0;\n for(size_t k=0; k dist(0, sz-1);\n idx = dist(rng);\n }\n int d = cands[idx];\n int ni=ci + di[d], nj = cj + dj[d];\n vis[ni][nj] = true;\n score += P[ni][nj];\n path += dc[d];\n ci=ni; cj=nj;\n }\n return {score, path};\n };\n auto [sc, pa] = simulate(0);\n if(sc > best_score){ best_score=sc; best_path=pa; }\n const int TRIALS_WEIGHT = 50000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n const int TRIALS_UNIFORM = 100000;\n for(int trial=0; trial best_score){ best_score=sc; best_path = pa;}\n }\n // Beam search\n {\n vector beam;\n State inits;\n inits.ci = si; inits.cj = sj;\n inits.score = P[si][sj];\n inits.pth = \"\";\n inits.vis.reset();\n inits.vis[si * 50 + sj] = 1;\n beam.push_back(inits);\n const int BEAM_WIDTH = 512;\n int max_steps = 0;\n while (!beam.empty() && max_steps < 3500) {\n ++max_steps;\n vector candidates;\n for (const auto& st : beam) {\n for (int d = 0; d < 4; d++) {\n int ni = st.ci + di[d];\n int nj = st.cj + dj[d];\n if (ni < 0 || ni >= 50 || nj < 0 || nj >= 50) continue;\n int idn = ni * 50 + nj;\n if (st.vis[idn]) continue;\n auto [bx, by] = sib[ni][nj];\n if (bx != -1 && st.vis[bx * 50 + by]) continue;\n State news = st;\n news.ci = ni;\n news.cj = nj;\n news.pth += dc[d];\n news.score += P[ni][nj];\n news.vis[idn] = 1;\n candidates.push_back(news);\n }\n }\n if (candidates.empty()) break;\n for (auto& c : candidates) {\n if (c.score > best_score) {\n best_score = c.score;\n best_path = c.pth;\n }\n }\n sort(candidates.begin(), candidates.end(), [](const State& a, const State& b) {\n return a.score > b.score;\n });\n if (candidates.size() > BEAM_WIDTH) candidates.resize(BEAM_WIDTH);\n beam = std::move(candidates);\n }\n }\n cout << best_path << endl;\n}","ahc003":"#include \nusing namespace std;\n\nint main() {\n double horiz[30][29];\n double vert[29][30];\n int hcnt[30][29];\n int vcnt[29][30];\n for(int i = 0; i < 30; i++) {\n for(int j = 0; j < 29; j++) {\n horiz[i][j] = 5000.0;\n hcnt[i][j] = 0;\n }\n }\n for(int i = 0; i < 29; i++) {\n for(int j = 0; j < 30; j++) {\n vert[i][j] = 5000.0;\n vcnt[i][j] = 0;\n }\n }\n for(int q = 0; q < 1000; q++) {\n double bias = (q < 300 ? 180.0 : 30.0);\n int si, sj, ti, tj;\n cin >> si >> sj >> ti >> tj;\n vector> dist(30, vector(30, 1e18));\n vector>> prev(30, vector>(30, {-1, -1}));\n dist[si][sj] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0.0, si, sj);\n int dr[4] = {-1, 1, 0, 0};\n int dc[4] = {0, 0, -1, 1};\n while (!pq.empty()) {\n auto [cost, r, c] = pq.top(); pq.pop();\n if (cost > dist[r][c]) continue;\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d];\n int nc = c + dc[d];\n if (nr < 0 || nr >= 30 || nc < 0 || nc >= 30) continue;\n double est_edgew = 1e18;\n int ecnt = 0;\n if (d == 0) {\n est_edgew = vert[nr][c];\n ecnt = vcnt[nr][c];\n } else if (d == 1) {\n est_edgew = vert[r][c];\n ecnt = vcnt[r][c];\n } else if (d == 2) {\n est_edgew = horiz[r][nc];\n ecnt = hcnt[r][nc];\n } else if (d == 3) {\n est_edgew = horiz[r][c];\n ecnt = hcnt[r][c];\n }\n double unc = 1.0 / (ecnt + 1.0);\n double modified = est_edgew - bias * unc;\n modified = max(50.0, modified);\n if (dist[nr][nc] > dist[r][c] + modified) {\n dist[nr][nc] = dist[r][c] + modified;\n prev[nr][nc] = {r, c};\n pq.emplace(dist[nr][nc], nr, nc);\n }\n }\n }\n double S = 0.0;\n int cr = ti, cc = tj;\n bool valid = true;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n if (p.first == -1) {\n valid = false;\n break;\n }\n int pr = p.first, pc = p.second;\n if (pr == cr && abs(pc - cc) == 1) {\n int minc = min(pc, cc);\n S += horiz[cr][minc];\n } else if (pc == cc && abs(pr - cr) == 1) {\n int minr = min(pr, cr);\n S += vert[minr][cc];\n } else {\n valid = false;\n break;\n }\n cr = pr;\n cc = pc;\n }\n if (!valid || S <= 0 || S >= 1e17) {\n string path = \"\";\n int r = si, c = sj;\n while (r != ti) {\n path += (ti > r ? 'D' : 'U');\n r += (ti > r ? 1 : -1);\n }\n while (c != tj) {\n path += (tj > c ? 'R' : 'L');\n c += (tj > c ? 1 : -1);\n }\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n continue;\n }\n vector pathv;\n cr = ti; cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (cr > pr) pathv.push_back('D');\n else if (cr < pr) pathv.push_back('U');\n else if (cc > pc) pathv.push_back('R');\n else if (cc < pc) pathv.push_back('L');\n cr = pr;\n cc = pc;\n }\n reverse(pathv.begin(), pathv.end());\n string path = \"\";\n for (char ch : pathv) path += ch;\n cout << path << '\\n';\n cout.flush();\n long long meas;\n cin >> meas;\n double factor = (double)meas / S;\n cr = ti;\n cc = tj;\n while (cr != si || cc != sj) {\n auto p = prev[cr][cc];\n int pr = p.first, pc = p.second;\n if (pr == cr) {\n int minc = min(pc, cc);\n int cnt = hcnt[cr][minc];\n double alpha = min(0.9, 3.0 / (cnt + 2.0));\n double mult = 1.0 - alpha + alpha * factor;\n horiz[cr][minc] *= mult;\n horiz[cr][minc] = max(100.0, min(10000.0, horiz[cr][minc]));\n hcnt[cr][minc]++;\n } else {\n int minr = min(pr, cr);\n int cnt = vcnt[minr][cc];\n double alpha = min(0.9, 3.0 / (cnt + 2.0));\n double mult = 1.0 - alpha + alpha * factor;\n vert[minr][cc] *= mult;\n vert[minr][cc] = max(100.0, min(10000.0, vert[minr][cc]));\n vcnt[minr][cc]++;\n }\n cr = pr;\n cc = pc;\n }\n // enhanced mild smoothing every 3 queries \n if (q % 3 == 0) {\n double eps = 0.035;\n for(int pp=0; pp<2; pp++) {\n // smooth horiz\n for(int i = 0; i < 30; i++) {\n double temp[29];\n for(int j = 0; j < 29; j++) {\n if (j == 0) {\n temp[j] = (1 - eps) * horiz[i][0] + eps * horiz[i][1];\n } else if (j == 28) {\n temp[j] = (1 - eps) * horiz[i][28] + eps * horiz[i][27];\n } else {\n temp[j] = (1 - 2*eps) * horiz[i][j] + eps * (horiz[i][j-1] + horiz[i][j+1]);\n }\n }\n for(int j=0; j<29; j++) horiz[i][j] = temp[j];\n }\n // smooth vert\n for(int j = 0; j < 30; j++) {\n double temp[29];\n for(int i = 0; i < 29; i++) {\n if (i == 0) {\n temp[i] = (1 - eps) * vert[0][j] + eps * vert[1][j];\n } else if (i == 28) {\n temp[i] = (1 - eps) * vert[28][j] + eps * vert[27][j];\n } else {\n temp[i] = (1 - 2*eps) * vert[i][j] + eps * (vert[i-1][j] + vert[i+1][j]);\n }\n }\n for(int i=0; i<29; i++) vert[i][j] = temp[i];\n }\n }\n }\n }\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nusing ll = long long;\n\nstruct AhoCorasick {\n vector> trie;\n vector fail;\n vector> outs;\n int nodes;\n\n AhoCorasick() : nodes(1) {\n trie.emplace_back();\n trie[0].fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n\n void insert(const string& s, int idx) {\n int node = 0;\n for (char cc : s) {\n int c = (cc == '.' ? 8 : cc - 'A');\n if (trie[node][c] == -1) {\n trie[node][c] = nodes++;\n trie.emplace_back();\n trie.back().fill(-1);\n fail.push_back(0);\n outs.emplace_back();\n }\n node = trie[node][c];\n }\n outs[node].push_back(idx);\n }\n\n void build() {\n queue q;\n for (int c = 0; c < 9; c++) {\n if (trie[0][c] != -1) {\n int child = trie[0][c];\n fail[child] = 0;\n q.push(child);\n }\n }\n while (!q.empty()) {\n int cur = q.front(); q.pop();\n for (int c = 0; c < 9; c++) {\n if (trie[cur][c] != -1) {\n int child = trie[cur][c];\n int f = fail[cur];\n while (f != 0 && trie[f][c] == -1) f = fail[f];\n if (trie[f][c] != -1) f = trie[f][c];\n fail[child] = f;\n outs[child].insert(outs[child].end(), outs[f].begin(), outs[f].end());\n q.push(child);\n }\n }\n }\n }\n};\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector strs(M);\n for (int i = 0; i < M; i++) {\n cin >> strs[i];\n }\n AhoCorasick ac;\n for (int i = 0; i < M; i++) {\n ac.insert(strs[i], i);\n }\n ac.build();\n\n const int MAXD = 32;\n int seq_arr[MAXD];\n int double_len = 31;\n\n auto fill_seq_row = [&](const vector>& g, int r) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[r][pos];\n seq_arr[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n auto fill_seq_col = [&](const vector>& g, int c) {\n for (int k = 0; k < double_len; k++) {\n int pos = k % N;\n char ch = g[pos][c];\n seq_arr[k] = (ch == '.' ? 8 : ch - 'A');\n }\n };\n\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution dist(0, 7);\n uniform_real_distribution prob_dist(0.0, 1.0);\n\n vector> grid(N, vector(N, '.'));\n vector idx(M);\n iota(idx.begin(), idx.end(), 0);\n sort(idx.begin(), idx.end(), [&](int a, int b){ return strs[a].size() > strs[b].size(); });\n\n for (int ii : idx) {\n const string& s = strs[ii];\n int len = s.size();\n bool placed = false;\n for (int row = 0; !placed && row < N; row++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nc = (st + p) % N;\n char exp = s[p];\n if (grid[row][nc] != '.' && grid[row][nc] != exp) { can = false; break; }\n }\n if (can) {\n for (int p = 0; p < len; p++) grid[row][(st + p) % N] = s[p];\n placed = true;\n }\n }\n }\n for (int col = 0; !placed && col < N; col++) {\n for (int st = 0; !placed && st < N; st++) {\n bool can = true;\n for (int p = 0; p < len; p++) {\n int nr = (st + p) % N;\n char exp = s[p];\n if (grid[nr][col] != '.' && grid[nr][col] != exp) { can = false; break; }\n }\n if (can) {\n for (int p = 0; p < len; p++) grid[(st + p) % N][col] = s[p];\n placed = true;\n }\n }\n }\n }\n\n const int TRIALS = 1;\n const int MAX_ITER = 100000;\n double cooling = 0.99995;\n\n vector> best_grid = grid;\n int best_covered = 0;\n\n vector vis(M, 0);\n int stamp = 0;\n\n for (int trial = 0; trial < TRIALS; trial++) {\n vector> cur_grid = grid;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) if(cur_grid[i][j]=='.') cur_grid[i][j] = 'A' + dist(rng);\n\n vector cover_cnt(M, 0);\n int curr_cov = 0;\n vector tmp_list;\n\n auto collect = [&](auto fillf, vector& mlist) {\n mlist.clear();\n stamp++;\n if(stamp==0) {\n fill(vis.begin(),vis.end(),0);\n stamp=1;\n }\n fillf(cur_grid);\n int node = 0;\n for(int k=0; k=0) node=ac.trie[node][c];\n else node=0;\n for(int id : ac.outs[node]){\n if(vis[id] != stamp){\n vis[id]=stamp;\n mlist.push_back(id);\n }\n }\n }\n };\n\n for(int r=0;r0) curr_cov++;\n\n double ttemp = 5.0;\n\n for(int it=0; it orow, ocol, nrow, ncol;\n auto fr = [&](auto& g){fill_seq_row(g,r);};\n collect(fr , orow);\n auto fc = [&](auto& g){fill_seq_col(g,cp);};\n collect(fc , ocol);\n\n cur_grid[r][cp] = nch;\n\n collect(fr , nrow);\n collect(fc , ncol);\n\n int newcov = curr_cov;\n map dmap;\n for(int id:orow) dmap[id]--;\n for(int id:ocol) dmap[id]--;\n for(int id:nrow) dmap[id]++;\n for(int id:ncol) dmap[id]++;\n for(auto& p : dmap){\n int id = p.first; int d = p.second;\n int newc = cover_cnt[id] + d;\n bool w = cover_cnt[id]>0;\n bool nw = newc >0;\n if(w && !nw) newcov--;\n else if(!w && nw) newcov++;\n }\n\n bool acc = false;\n int del = newcov - curr_cov;\n if(del>0) acc = true;\n else if(del==0 && prob_dist(rng)<0.05) acc=true;\n else {\n double pr = exp(del / max(ttemp ,0.001));\n if(prob_dist(rng) < pr) acc = true;\n }\n\n if(acc){\n for(auto& p : dmap){\n cover_cnt[p.first] += p.second;\n }\n curr_cov = newcov;\n } else {\n cur_grid[r][cp] = och;\n }\n ttemp *= cooling;\n if(ttemp < 0.001) ttemp = 0.001;\n }\n\n int maxref = 3;\n bool changed = true;\n int rp = 0;\n while(changed && rp < maxref){\n changed = false;\n rp ++;\n for(int r=0;r orow, ocol, nrow, ncol;\n auto fr = [&](auto& gg){fill_seq_row(gg,r);};\n collect(fr, orow);\n auto fc = [&](auto& gg){fill_seq_col(gg,cp);};\n collect(fc, ocol);\n cur_grid[r][cp] = nch;\n collect(fr, nrow);\n collect(fc, ncol);\n\n int ncov = curr_cov;\n map dm;\n for(int id:orow) dm[id]--;\n for(int id:ocol) dm[id]--;\n for(int id:nrow) dm[id]++;\n for(int id:ncol) dm[id]++;\n for(auto& pp:dm){\n int id=pp.first; int dd=pp.second;\n int nc= cover_cnt[id]+dd;\n bool ww = cover_cnt[id]>0;\n bool nww = nc>0;\n if(ww&&!nww) ncov--;\n else if(!ww&&nww) ncov++;\n }\n int ddelt = ncov - curr_cov;\n cur_grid[r][cp]=och;\n if(ddelt > bestd){\n bestd=ddelt;\n bn = nch;\n }\n }\n if(bestd >0){\n cur_grid[r][cp] = bn;\n vector orow, ocol, nrow, ncol;\n auto frr = [&](auto& gg){fill_seq_row(gg,r);};\n collect(frr, orow);\n auto fcc = [&](auto& gg){fill_seq_col(gg,cp);};\n collect(fcc, ocol);\n cur_grid[r][cp] = bn;\n collect(frr, nrow);\n collect(fcc, ncol);\n map dmm;\n for(int id:orow) dmm[id]--;\n for(int id:ocol) dmm[id]--;\n for(int id:nrow) dmm[id]++;\n for(int id:ncol) dmm[id]++;\n for(auto& p:dmm) cover_cnt[p.first] += p.second;\n curr_cov += bestd;\n changed = true;\n }\n }\n }\n\n if(curr_cov > best_covered){\n best_covered = curr_cov;\n best_grid = cur_grid;\n }\n }\n\n for(int i=0;i\nusing namespace std;\nusing ll = long long;\nconst ll INF = 1LL << 60;\n\nint main() {\n int N, si, sj;\n cin >> N >> si >> sj;\n vector grid(N);\n for (int i = 0; i < N; i++) cin >> grid[i];\n int cost[69][69];\n memset(cost, 0, sizeof(cost));\n vector> all_roads;\n for (int i = 0; i < N; i++)\n for (int j = 0; j < N; j++)\n if (grid[i][j] != '#') {\n cost[i][j] = grid[i][j] - '0';\n all_roads.emplace_back(i, j);\n }\n int hofs[69][69];\n int vofs[69][69];\n memset(hofs, -1, sizeof(hofs));\n memset(vofs, -1, sizeof(vofs));\n vector>> hsegs, vsegs;\n int nh = 0, nv = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N;) {\n if (grid[i][j] == '#') {\n j++;\n continue;\n }\n auto& seg = hsegs.emplace_back();\n while (j < N && grid[i][j] != '#') {\n hofs[i][j] = nh;\n seg.emplace_back(i, j);\n j++;\n }\n nh++;\n }\n }\n for (int j = 0; j < N; j++) {\n for (int i = 0; i < N;) {\n if (grid[i][j] == '#') {\n i++;\n continue;\n }\n auto& seg = vsegs.emplace_back();\n while (i < N && grid[i][j] != '#') {\n vofs[i][j] = nv;\n seg.emplace_back(i, j);\n i++;\n }\n nv++;\n }\n }\n vector> best_points;\n int best_m = 100000;\n srand(42);\n for (int trial = 0; trial < 50; trial++) {\n bool cellcov[69][69] = {};\n if (hofs[si][sj] != -1) {\n int h = hofs[si][sj];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[si][sj];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n }\n vector> targets;\n vector> sel_pos;\n sel_pos.emplace_back(si, sj);\n auto count_remain = [&]() {\n int cnt = 0;\n for (auto [x, y] : all_roads)\n if (!cellcov[x][y]) cnt++;\n return cnt;\n };\n int remain = count_remain();\n while (remain > 0) {\n int maxg = 0;\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g > maxg) maxg = g;\n }\n if (maxg == 0) break;\n vector> cands;\n for (auto p : all_roads) {\n auto [px, py] = p;\n if (hofs[px][py] == -1) continue;\n int h = hofs[px][py];\n int v = vofs[px][py];\n int g = 0;\n for (auto [x, y] : hsegs[h])\n if (!cellcov[x][y]) g++;\n for (auto [x, y] : vsegs[v])\n if (!cellcov[x][y]) g++;\n if (!cellcov[px][py]) g--;\n if (g == maxg) cands.push_back(p);\n }\n if (cands.empty()) break;\n // bias to close to sel\n int min_cls = INT_MAX;\n vector> best_c;\n for (auto p : cands) {\n int md = INT_MAX;\n for (auto sp : sel_pos) {\n md = min(md, abs(sp.first - p.first) + abs(sp.second - p.second));\n }\n if (md < min_cls) {\n min_cls = md;\n best_c.clear();\n best_c.push_back(p);\n } else if (md == min_cls) {\n best_c.push_back(p);\n }\n }\n if (best_c.empty()) break;\n int id = rand() % best_c.size();\n auto bp = best_c[id];\n targets.push_back(bp);\n sel_pos.push_back(bp);\n int h = hofs[bp.first][bp.second];\n for (auto [x, y] : hsegs[h]) cellcov[x][y] = true;\n int v = vofs[bp.first][bp.second];\n for (auto [x, y] : vsegs[v]) cellcov[x][y] = true;\n remain = count_remain();\n }\n vector> points;\n points.emplace_back(si, sj);\n for (auto tp : targets) {\n if (tp.first != si || tp.second != sj) points.push_back(tp);\n }\n vector> fullp = points;\n vector> finalp = fullp;\n auto is_full_cover = [&](const vector>& vis_set) -> bool {\n bool temp[69][69] = {};\n for (auto [x, y] : vis_set) {\n if (hofs[x][y] == -1) continue;\n int h = hofs[x][y];\n for (auto p : hsegs[h]) temp[p.first][p.second] = true;\n int vv = vofs[x][y];\n for (auto p : vsegs[vv]) temp[p.first][p.second] = true;\n }\n int rem = 0;\n for (auto [x, y] : all_roads)\n if (!temp[x][y]) rem++;\n return rem == 0;\n };\n for (int i = finalp.size() - 1; i >= 1; i--) {\n vector> temp;\n for (int j = 0; j < finalp.size(); j++) if (j != i) temp.push_back(finalp[j]);\n if (is_full_cover(temp)) {\n finalp = temp;\n }\n }\n points = finalp;\n if ((int)points.size() < best_m) {\n best_m = points.size();\n best_points = points;\n }\n }\n vector> points = best_points;\n int mm = points.size();\n vector> dmat(mm, vector(mm, INF));\n vector>>> par_store(\n mm, vector>>(N, vector>(N, {-1, -1})));\n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n for (int s = 0; s < mm; s++) {\n auto [sx, sy] = points[s];\n vector> dd(N, vector(N, INF));\n vector>> pr(N, vector>(N, {-1, -1}));\n dd[sx][sy] = 0;\n priority_queue, vector>, greater>> pq;\n pq.emplace(0LL, sx, sy);\n while (!pq.empty()) {\n auto [cst, x, y] = pq.top();\n pq.pop();\n if (cst > dd[x][y]) continue;\n for (int d = 0; d < 4; d++) {\n int nx = x + di[d], ny = y + dj[d];\n if (nx >= 0 && nx < N && ny >= 0 && ny < N && grid[nx][ny] != '#') {\n ll nc = cst + cost[nx][ny];\n if (nc < dd[nx][ny]) {\n dd[nx][ny] = nc;\n pr[nx][ny] = {x, y};\n pq.emplace(nc, nx, ny);\n }\n }\n }\n }\n for (int p = 0; p < mm; p++) {\n auto [px, py] = points[p];\n dmat[s][p] = dd[px][py];\n }\n for (int x = 0; x < N; x++)\n for (int y = 0; y < N; y++) par_store[s][x][y] = pr[x][y];\n }\n struct Edge {\n ll c;\n int u, v;\n bool operator<(const Edge& o) const { return c < o.c; }\n };\n vector edges;\n for (int i = 0; i < mm; i++)\n for (int j = i + 1; j < mm; j++) {\n if (dmat[i][j] < INF) edges.push_back({dmat[i][j], i, j});\n }\n sort(edges.begin(), edges.end());\n vector paruf(mm);\n iota(paruf.begin(), paruf.end(), 0);\n auto findf = [&](auto&& self, int x) -> int {\n return paruf[x] == x ? x : paruf[x] = self(self, paruf[x]);\n };\n auto unionf = [&](int x, int y) {\n x = findf(findf, x);\n y = findf(findf, y);\n if (x != y) paruf[x] = y;\n };\n vector> adj(mm);\n for (auto& e : edges) {\n if (findf(findf, e.u) != findf(findf, e.v)) {\n unionf(e.u, e.v);\n adj[e.u].push_back(e.v);\n adj[e.v].push_back(e.u);\n }\n }\n vector euler_t;\n function dfs_e = [&](int u, int p) {\n euler_t.push_back(u);\n for (int v : adj[u])\n if (v != p) {\n dfs_e(v, u);\n euler_t.push_back(u);\n }\n };\n dfs_e(0, -1);\n vector path(mm);\n vector viss(mm, false);\n int cntv = 0;\n for (int nd : euler_t) {\n if (!viss[nd]) {\n viss[nd] = true;\n path[cntv++] = nd;\n }\n }\n // build nn\n vector nn_path;\n {\n vector vis_nn(mm, false);\n int cur = 0;\n nn_path.push_back(0);\n vis_nn[0] = true;\n while (nn_path.size() < (size_t)mm) {\n ll md = INF;\n int nx = -1;\n for (int j = 0; j < mm; j++) {\n if (!vis_nn[j] && dmat[cur][j] < md) {\n md = dmat[cur][j];\n nx = j;\n }\n }\n if (nx == -1) break;\n nn_path.push_back(nx);\n vis_nn[nx] = true;\n cur = nx;\n }\n }\n ll mst_tot = 0;\n if ((int)path.size() == mm) {\n for (int ii = 0; ii < mm; ii++) {\n mst_tot += dmat[path[ii]][path[(ii + 1) % mm]];\n }\n } else {\n mst_tot = INF;\n }\n ll nn_tot = 0;\n if ((int)nn_path.size() == mm) {\n for (size_t ii = 0; ii < nn_path.size(); ii++) {\n int aa = nn_path[ii];\n int bb = nn_path[(ii + 1) % mm];\n nn_tot += dmat[aa][bb];\n }\n } else {\n nn_tot = INF;\n }\n if ((int)nn_path.size() == mm && nn_tot < mst_tot) {\n path = nn_path;\n }\n // swaps improve\n for (int iter = 0; iter < 40; iter++) {\n bool imp = false;\n for (int i = 1; i < mm; i++) {\n for (int j = i + 1; j < mm; j++) {\n if (min(abs(i - j), mm - abs(i - j)) <= 1) continue;\n int pa = (i - 1 + mm) % mm;\n int na = (i + 1) % mm;\n int pb = (j - 1 + mm) % mm;\n int nb = (j + 1) % mm;\n ll oldd = dmat[path[pa]][path[i]] + dmat[path[i]][path[na]] +\n dmat[path[pb]][path[j]] + dmat[path[j]][path[nb]];\n ll newd = dmat[path[pa]][path[j]] + dmat[path[j]][path[na]] +\n dmat[path[pb]][path[i]] + dmat[path[i]][path[nb]];\n if (newd < oldd) {\n swap(path[i], path[j]);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n // partial 2-opt\n for (int it = 0; it < 30; it++) {\n bool imp = false;\n for (int i = 0; i < mm - 3; i++) {\n for (int j = i + 2; j < mm - 1; j++) {\n ll oldd = dmat[path[i]][path[i + 1]] + dmat[path[j]][path[j + 1]];\n ll newd = dmat[path[i]][path[j]] + dmat[path[i + 1]][path[j + 1]];\n if (newd < oldd) {\n reverse(path.begin() + i + 1, path.begin() + j + 1);\n imp = true;\n }\n }\n }\n if (!imp) break;\n }\n string route = \"\";\n for (int k = 0; k < mm; k++) {\n int fid = path[k];\n int tid = path[(k + 1) % mm];\n if (fid == tid) continue;\n auto [sx, sy] = points[fid];\n auto [tx, ty] = points[tid];\n vector subm;\n int cx = tx, cy = ty;\n while (cx != sx || cy != sy) {\n auto [px, py] = par_store[fid][cx][cy];\n if (px == -1) break;\n int dx = cx - px;\n int dy = cy - py;\n char mv;\n if (dx == -1) mv = 'U';\n else if (dx == 1) mv = 'D';\n else if (dy == -1) mv = 'L';\n else if (dy == 1) mv = 'R';\n else break;\n subm.push_back(mv);\n cx = px;\n cy = py;\n }\n reverse(subm.begin(), subm.end());\n for (char c : subm) route += c;\n }\n cout << route << endl;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n int N, M, K, R;\n cin >> N >> M >> K >> R;\n vector> difficulty(N, vector(K));\n for (int i = 0; i < N; i++) {\n for (int k = 0; k < K; k++) {\n cin >> difficulty[i][k];\n }\n }\n vector> adj(N);\n vector prereq_count(N, 0);\n for (int i = 0; i < R; i++) {\n int u, v;\n cin >> u >> v;\n u--;\n v--;\n adj[u].push_back(v);\n prereq_count[v]++;\n }\n vector longest_chain(N, 0);\n vector num_desc(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n longest_chain[i] = 1;\n num_desc[i] = 1;\n for (int v : adj[i]) {\n longest_chain[i] = max(longest_chain[i], 1 + longest_chain[v]);\n num_desc[i] += num_desc[v];\n }\n }\n vector> est_s(M, vector(K, 0));\n vector status(N, 0); // 0 not, 1 prog, 2 done\n vector current_task(M, -1);\n vector start_day(M, 0);\n vector workload(M, 0);\n int day = 0;\n auto estimate = [&](int task, int mem) -> int {\n int w = 0;\n for (int k = 0; k < K; k++) {\n w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (w == 0) return 1;\n return w;\n };\n while (true) {\n day++;\n vector min_task_time(N, 0);\n for (int i = 0; i < N; i++) {\n if (status[i] == 0) {\n int mt = INT_MAX;\n for (int j = 0; j < M; j++) {\n mt = min(mt, estimate(i, j));\n }\n min_task_time[i] = max(1, mt);\n }\n }\n vector crit_path(N, 0);\n for (int i = N - 1; i >= 0; i--) {\n if (status[i] != 0) continue;\n crit_path[i] = min_task_time[i];\n for (int v : adj[i]) {\n if (status[v] == 0) {\n crit_path[i] = max(crit_path[i], min_task_time[i] + crit_path[v]);\n }\n }\n }\n vector free_m;\n for (int j = 0; j < M; j++)\n if (current_task[j] == -1) free_m.push_back(j);\n vector ready;\n for (int i = 0; i < N; i++) {\n if (status[i] == 0 && prereq_count[i] == 0) ready.push_back(i);\n }\n vector> assigns; // mem, task\n set avail_free(free_m.begin(), free_m.end());\n sort(ready.begin(), ready.end(), [&](int a, int b) {\n if (crit_path[a] != crit_path[b]) return crit_path[a] > crit_path[b];\n if (longest_chain[a] != longest_chain[b]) return longest_chain[a] > longest_chain[b];\n if (num_desc[a] != num_desc[b]) return num_desc[a] > num_desc[b];\n return a < b;\n });\n for (int rid = 0; rid < ready.size(); rid++) {\n if (avail_free.empty()) break;\n int ta = ready[rid];\n int best_mem = -1;\n int best_et = INT_MAX;\n int best_wl = INT_MAX;\n for (int jm : avail_free) {\n int et = estimate(ta, jm);\n int wl = workload[jm];\n if (et < best_et ||\n (et == best_et &&\n (wl < best_wl || (wl == best_wl && jm < best_mem)))) {\n best_et = et;\n best_wl = wl;\n best_mem = jm;\n }\n }\n if (best_mem != -1) {\n assigns.emplace_back(best_mem, ta);\n avail_free.erase(best_mem);\n workload[best_mem] += best_et;\n }\n }\n // output\n cout << assigns.size();\n for (auto [jm, ta] : assigns) {\n cout << \" \" << (jm + 1) << \" \" << (ta + 1);\n }\n cout << endl << flush;\n // set assignments\n for (auto [jm, ta] : assigns) {\n current_task[jm] = ta;\n start_day[jm] = day;\n status[ta] = 1;\n }\n // read\n int ncomp;\n cin >> ncomp;\n if (ncomp == -1) {\n break;\n }\n vector comps(ncomp);\n for (int i = 0; i < ncomp; i++) {\n cin >> comps[i];\n }\n for (int cf : comps) {\n int mem = cf - 1;\n if (current_task[mem] == -1) continue;\n int task = current_task[mem];\n int t = day - start_day[mem] + 1;\n if (t == 1) {\n for (int k = 0; k < K; k++) {\n est_s[mem][k] = max(est_s[mem][k], difficulty[task][k]);\n }\n }\n int obs_w = (t <= 1 ? 0 : t - 1);\n int iters = 0;\n while (iters < 5) {\n iters++;\n int curr_w = 0;\n for (int k = 0; k < K; k++) {\n curr_w += max(0, difficulty[task][k] - est_s[mem][k]);\n }\n if (curr_w == obs_w) break;\n int num_def = 0;\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) num_def++;\n }\n if (num_def == 0) break;\n if (curr_w > obs_w) {\n int gap = curr_w - obs_w;\n int incr = max(1, gap / (2 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] += incr;\n }\n }\n } else if (curr_w < obs_w) {\n int gap = obs_w - curr_w;\n int decr = max(1, gap / (2 * num_def));\n for (int k = 0; k < K; k++) {\n if (difficulty[task][k] > est_s[mem][k]) {\n est_s[mem][k] = max(0, est_s[mem][k] - decr);\n }\n }\n } else {\n break;\n }\n }\n status[task] = 2;\n current_task[mem] = -1;\n for (int v : adj[task]) {\n prereq_count[v]--;\n }\n }\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Point {\n int x, y;\n};\n\nint manh(const Point& a, const Point& b) {\n return abs(a.x - b.x) + abs(a.y - b.y);\n}\n\nbool is_valid(const vector& perm, int n) {\n int m = 2 * n;\n vector pos(m);\n for (int i = 0; i < m; i++) pos[perm[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) return false;\n }\n return true;\n}\n\nint calc_cost(const vector& perm, const vector& pts, Point C, int n) {\n int m = 2 * n;\n if ((int)perm.size() != m) return INT_MAX;\n int cost = manh(C, pts[perm[0]]);\n for (int i = 0; i < m - 1; i++) {\n cost += manh(pts[perm[i]], pts[perm[i + 1]]);\n }\n cost += manh(pts[perm.back()], C);\n return cost;\n}\n\nvector generate_valid_random(int n, mt19937& rng) {\n int m = 2 * n;\n vector tasks(m);\n iota(tasks.begin(), tasks.end(), 0);\n shuffle(tasks.begin(), tasks.end(), rng);\n vector pos(m);\n for (int i = 0; i < m; i++) pos[tasks[i]] = i;\n for (int i = 0; i < n; i++) {\n if (pos[i] > pos[n + i]) {\n swap(tasks[pos[i]], tasks[pos[n + i]]);\n swap(pos[i], pos[n + i]);\n }\n }\n if (is_valid(tasks, n)) return tasks;\n return vector();\n}\n\npair> greedy_cost_and_path(const vector& S, Point C, const vector& allP, const vector& allD, int n) {\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n vector mate(2 * n);\n for (int i = 0; i < n; i++) {\n mate[i] = n + i;\n mate[n + i] = i;\n }\n vector visited(2 * n, false);\n vector feasible(2 * n, false);\n for (int i = 0; i < n; i++) feasible[i] = true;\n vector perm;\n perm.reserve(2 * n);\n Point curr = C;\n int total = 0;\n bool possible = true;\n for (int step = 0; step < 2 * n && possible; step++) {\n int best_d = INT_MAX;\n int best_idx = -1;\n for (int i = 0; i < 2 * n; i++) {\n if (!visited[i] && feasible[i]) {\n int dd = manh(curr, pts[i]);\n if (dd < best_d) {\n best_d = dd;\n best_idx = i;\n }\n }\n }\n if (best_idx == -1) {\n possible = false;\n break;\n }\n total += best_d;\n perm.push_back(best_idx);\n visited[best_idx] = true;\n curr = pts[best_idx];\n int m = mate[best_idx];\n if (!visited[m]) feasible[m] = true;\n }\n if (possible && (int)perm.size() == 2 * n) total += manh(curr, C);\n else total = INT_MAX;\n return {total, perm};\n}\n\nvoid optimize_perm_inner(vector& best_perm, int& best_cost, const vector& S, Point C, const vector& allP, const vector& allD, mt19937& rng) {\n int n = S.size();\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[S[i]];\n pts[n + i] = allD[S[i]];\n }\n auto [gcost, gperm] = greedy_cost_and_path(S, C, allP, allD, n);\n int m = 2 * n;\n int curr_cost = INT_MAX;\n vector current_perm(m);\n if ((int)gperm.size() == 2 * n) {\n current_perm = gperm;\n curr_cost = gcost;\n }\n vector best_init = current_perm;\n int best_init_cost = curr_cost;\n for (int rtry = 0; rtry < 6; rtry++) {\n vector rand_tasks = generate_valid_random(n, rng);\n if (!rand_tasks.empty()) {\n int rc = calc_cost(rand_tasks, pts, C, n);\n if (rc < best_init_cost) {\n best_init_cost = rc;\n best_init = rand_tasks;\n }\n }\n }\n if (best_init_cost < curr_cost) {\n current_perm = best_init;\n curr_cost = best_init_cost;\n }\n vector local_best_perm = current_perm;\n int local_best_cost = curr_cost;\n double T = 20000.0;\n uniform_int_distribution dpos(0, m - 1);\n uniform_real_distribution dprob(0.0, 1.0);\n for (int it = 0; it < 300000; it++) {\n vector new_perm = current_perm;\n int typ = rng() % 4;\n bool can_change = false;\n int i = dpos(rng);\n int j = dpos(rng);\n if (typ == 0) {\n if (i != j) {\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n } else if (typ == 1) {\n if (i != j) {\n int val = new_perm[i];\n new_perm.erase(new_perm.begin() + i);\n int jj = (j > i ? j - 1 : j);\n new_perm.insert(new_perm.begin() + jj, val);\n can_change = true;\n }\n } else if (typ == 2) {\n if (i > j) swap(i, j);\n if (i != j) {\n reverse(new_perm.begin() + i, new_perm.begin() + j + 1);\n can_change = true;\n }\n } else {\n j = (i + 1) % m;\n swap(new_perm[i], new_perm[j]);\n can_change = true;\n }\n if (can_change && is_valid(new_perm, n)) {\n int new_cost = calc_cost(new_perm, pts, C, n);\n if (new_cost < INT_MAX) {\n double delta = new_cost - curr_cost;\n if (delta < 0 || (T > 0 && exp(-delta / T) > dprob(rng))) {\n current_perm = new_perm;\n curr_cost = new_cost;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n }\n }\n T *= 0.99994;\n }\n current_perm = local_best_perm;\n curr_cost = local_best_cost;\n int phases = 0;\n const int max_phases = 25;\n bool improved_global = true;\n while (improved_global && phases < max_phases) {\n improved_global = false;\n phases++;\n int min_newc = curr_cost;\n vector best_np;\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n swap(np[ii], np[jj]);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = 0; jj < m; jj++) {\n if (ii == jj) continue;\n vector np = current_perm;\n int val = np[ii];\n np.erase(np.begin() + ii);\n int jj_adj = (jj > ii ? jj - 1 : jj);\n np.insert(np.begin() + jj_adj, val);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n min_newc = curr_cost;\n best_np.clear();\n for (int ii = 0; ii < m; ii++) {\n for (int jj = ii + 1; jj < m; jj++) {\n vector np = current_perm;\n reverse(np.begin() + ii, np.begin() + jj + 1);\n if (is_valid(np, n)) {\n int nc = calc_cost(np, pts, C, n);\n if (nc < min_newc) {\n min_newc = nc;\n best_np = np;\n }\n }\n }\n }\n if (min_newc < curr_cost) {\n current_perm = best_np;\n curr_cost = min_newc;\n improved_global = true;\n if (curr_cost < local_best_cost) {\n local_best_cost = curr_cost;\n local_best_perm = current_perm;\n }\n }\n }\n best_perm = local_best_perm;\n best_cost = local_best_cost;\n}\n\ntuple, vector> run_optimization(const vector& allP, const vector& allD, Point C, mt19937& rng, int trials = 3) {\n int best_cost = INT_MAX;\n vector best_perm(2 * 50);\n vector best_S(50);\n for (int tr = 0; tr < trials; tr++) {\n vector centers;\n centers.push_back(C);\n int step = 40;\n for (int cx = 20; cx < 780; cx += step) {\n for (int cy = 20; cy < 780; cy += step) {\n centers.push_back({cx, cy});\n }\n }\n for (int i = 0; i < 130; i++) {\n centers.push_back({static_cast(rng() % 801), static_cast(rng() % 801)});\n }\n int n = 50;\n int local_best_T = INT_MAX;\n vector local_best_S;\n for (auto& cen : centers) {\n vector> dists;\n for (int i = 0; i < 1000; i++) {\n int dd = manh(allP[i], cen) + manh(allD[i], cen);\n dists.emplace_back(dd, i);\n }\n sort(dists.begin(), dists.end());\n vector S;\n for (int i = 0; i < n; i++) S.push_back(dists[i].second);\n auto [gcost, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gcost < local_best_T) {\n local_best_T = gcost;\n local_best_S = S;\n }\n }\n vector> ind_cost;\n for (int i = 0; i < 1000; i++) {\n int cc = manh(C, allP[i]) + manh(allP[i], allD[i]) + manh(allD[i], C);\n ind_cost.emplace_back(cc, i);\n }\n sort(ind_cost.begin(), ind_cost.end());\n vector S_small;\n for (int i = 0; i < n; i++) S_small.push_back(ind_cost[i].second);\n auto [gcost2, gp2] = greedy_cost_and_path(S_small, C, allP, allD, n);\n if (gcost2 < local_best_T) {\n local_best_T = gcost2;\n local_best_S = S_small;\n }\n for (int tri = 0; tri < 55; tri++) {\n vector all(1000);\n iota(all.begin(), all.end(), 0);\n shuffle(all.begin(), all.end(), rng);\n vector S(all.begin(), all.begin() + n);\n auto [gc, gp] = greedy_cost_and_path(S, C, allP, allD, n);\n if (gc < local_best_T) {\n local_best_T = gc;\n local_best_S = S;\n }\n }\n int opt_cost = INT_MAX;\n vector opt_perm;\n int tmp_c = INT_MAX;\n vector tmp_perm;\n optimize_perm_inner(tmp_perm, tmp_c, local_best_S, C, allP, allD, rng);\n if (tmp_c < opt_cost) {\n opt_cost = tmp_c;\n opt_perm = tmp_perm;\n }\n int repl_cnt = 0;\n for (int trial = 0; trial < 80; trial++) {\n if (repl_cnt >= 22) break;\n uniform_int_distribution dis_in(0, n - 1);\n uniform_int_distribution dis_out(0, 999);\n vector newS = local_best_S;\n int in_idx = dis_in(rng);\n int out = dis_out(rng);\n bool has = false;\n for (int s : newS) if (s == out) { has = true; break; }\n if (has) continue;\n newS[in_idx] = out;\n auto [gc, gp] = greedy_cost_and_path(newS, C, allP, allD, n);\n if (gc < opt_cost * 1.05 && gc < INT_MAX) {\n tmp_c = INT_MAX;\n tmp_perm.clear();\n optimize_perm_inner(tmp_perm, tmp_c, newS, C, allP, allD, rng);\n if (tmp_c < opt_cost) {\n opt_cost = tmp_c;\n opt_perm = tmp_perm;\n local_best_S = newS;\n }\n repl_cnt++;\n }\n }\n if (opt_cost < best_cost) {\n best_cost = opt_cost;\n best_perm = opt_perm;\n best_S = local_best_S;\n }\n }\n return make_tuple(best_cost, best_perm, best_S);\n}\n\nint main() {\n vector allP(1000), allD(1000);\n for (int i = 0; i < 1000; i++) {\n cin >> allP[i].x >> allP[i].y >> allD[i].x >> allD[i].y;\n }\n Point C = {400, 400};\n mt19937 rng(987654321);\n auto res = run_optimization(allP, allD, C, rng, 3);\n int n = get<2>(res).size();\n vector best_S = get<2>(res);\n vector opt_perm = get<1>(res);\n vector pts(2 * n);\n for (int i = 0; i < n; i++) {\n pts[i] = allP[best_S[i]];\n pts[n + i] = allD[best_S[i]];\n }\n vector route;\n route.push_back(C);\n for (int t : opt_perm) {\n route.push_back(pts[t]);\n }\n route.push_back(C);\n cout << 50;\n for (int r : best_S) cout << \" \" << (r + 1);\n cout << endl;\n cout << route.size();\n for (auto p : route) cout << \" \" << p.x << \" \" << p.y;\n cout << endl;\n return 0;\n}","ahc007":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v, idx, d, l;\n bool backup;\n};\n\nvector edges;\nvector par;\n\nint find(vector& p, int x) {\n return p[x] == x ? x : p[x] = find(p, p[x]);\n}\n\nbool unite(vector& p, int x, int y) {\n x = find(p, x);\n y = find(p, y);\n if (x == y) return false;\n p[x] = y;\n return true;\n}\n\nint main() {\n vector x(400), y(400);\n for (int i = 0; i < 400; i++) {\n cin >> x[i] >> y[i];\n }\n int M = 1995;\n edges.resize(M);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n edges[i].u = u;\n edges[i].v = v;\n edges[i].idx = i;\n edges[i].l = -1;\n edges[i].backup = false;\n double dx = x[u] - x[v];\n double dy = y[u] - y[v];\n double dist = hypot(dx, dy);\n edges[i].d = (int)round(dist);\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n sort(ord.begin(), ord.end(), [&](int a, int b) {\n return edges[a].d < edges[b].d;\n });\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n int cnt = 0;\n for (int i : ord) {\n if (unite(par, edges[i].u, edges[i].v)) {\n edges[i].backup = true;\n cnt++;\n if (cnt == 399) break;\n }\n }\n par.assign(400, 0);\n iota(par.begin(), par.end(), 0);\n const double MULT = 2.0;\n for (int i = 0; i < M; i++) {\n int l;\n cin >> l;\n edges[i].l = l;\n int u = edges[i].u, v = edges[i].v;\n int pu = find(par, u);\n int pv = find(par, v);\n int ans = 0;\n if (pu != pv) {\n if (edges[i].backup) {\n ans = 1;\n } else {\n int md = edges[i].d;\n // direct future cross min-d\n int min_fut = INT_MAX / 2;\n for (int j = i + 1; j < M; j++) {\n int uj = edges[j].u, vj = edges[j].v;\n int pj1 = find(par, uj), pj2 = find(par, vj);\n if ((pj1 == pu && pj2 == pv) || (pj1 == pv && pj2 == pu)) {\n min_fut = min(min_fut, edges[j].d);\n }\n }\n if (min_fut < INT_MAX / 2) md = min(md, min_fut);\n // always compute correct MST-bottleneck for indirect routes\n vector tmp_par = par;\n int bott = INT_MAX / 2;\n for (int jj : ord) {\n if (jj <= i) continue;\n int j = jj;\n int uj = edges[j].u, vj = edges[j].v;\n int pj1 = find(tmp_par, uj), pj2 = find(tmp_par, vj);\n if (pj1 != pj2 && unite(tmp_par, pj1, pj2)) {\n if (find(tmp_par, pu) == find(tmp_par, pv)) {\n bott = edges[j].d;\n break;\n }\n }\n }\n if (bott < INT_MAX / 2) md = min(md, bott);\n if (l <= MULT * md) ans = 1;\n }\n if (ans == 1) {\n unite(par, u, v);\n }\n }\n cout << ans << endl;\n cout.flush();\n }\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N;\n cin >> 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 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 const int W = 30;\n vector> is_blocked(W + 2, vector(W + 2, false));\n vector> human_pos(M);\n for (int i = 0; i < M; i++) human_pos[i] = {hx[i], hy[i]};\n vector> pet_pos(N);\n for (int i = 0; i < N; i++) pet_pos[i] = {px[i], py[i]};\n vector dx = {-1, 1, 0, 0};\n vector dy = {0, 0, -1, 1};\n char move_char[4] = {'U', 'D', 'L', 'R'};\n char block_char[4] = {'u', 'd', 'l', 'r'};\n auto valid = [&](int x, int y) {\n return x >= 1 && x <= W && y >= 1 && y <= W && !is_blocked[x][y];\n };\n auto is_occupied_func = nullptr; // defined per turn\n vector> stand_pos, wall_pos;\n int wall_size = 20;\n int right_c = wall_size + 1;\n int bottom_r = wall_size + 1;\n for (int r = 1; r <= wall_size; r++) {\n stand_pos.emplace_back(r, wall_size);\n wall_pos.emplace_back(r, right_c);\n }\n for (int c = 1; c <= wall_size; c++) {\n stand_pos.emplace_back(wall_size, c);\n wall_pos.emplace_back(bottom_r, c);\n }\n set> wall_set(wall_pos.begin(), wall_pos.end());\n mt19937 rng(42);\n for (int turn = 0; turn < 300; turn++) {\n vector> next_hpos(M);\n string actions_str(M, '.');\n set> targeted_moves;\n set> this_turn_blocked;\n vector> is_occupied(W + 2, vector(W + 2, false));\n for (int i = 0; i < N; i++) {\n auto [x, y] = pet_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n for (int i = 0; i < M; i++) {\n auto [x, y] = human_pos[i];\n if (valid(x, y)) is_occupied[x][y] = true;\n }\n auto can_block = [&](int tx, int ty) {\n if (!valid(tx, ty) || is_occupied[tx][ty]) return false;\n for (int d = 0; d < 4; d++) {\n int px = tx + dx[d];\n int py = ty + dy[d];\n if (valid(px, py) && is_occupied[px][py]) return false;\n }\n return true;\n };\n vector assigned_idx(M, -1);\n vector used_stand(stand_pos.size(), false);\n if (turn >= 150) {\n for (int i = 0; i < M; i++) {\n int best_j = -1;\n int best_d = INT_MAX;\n for (int j = 0; j < (int)stand_pos.size(); j++) {\n auto [wx, wy] = wall_pos[j];\n if (is_blocked[wx][wy]) continue;\n if (used_stand[j]) continue;\n auto [sx, sy] = stand_pos[j];\n int dist = abs(human_pos[i].first - sx) + abs(human_pos[i].second - sy);\n if (dist < best_d) {\n best_d = dist;\n best_j = j;\n }\n }\n if (best_j != -1) {\n assigned_idx[i] = best_j;\n used_stand[best_j] = true;\n }\n }\n }\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng);\n for (int k = 0; k < M; k++) {\n int i = ord[k];\n auto [x, y] = human_pos[i];\n bool did = false;\n int t_idx = assigned_idx[i];\n if (turn < 150 || t_idx == -1) {\n // gather to center\n int cx = 15, cy = 15;\n vector> candidates;\n if (x < cx && valid(x + 1, y)) candidates.emplace_back(1, 'D');\n if (x > cx && valid(x - 1, y)) candidates.emplace_back(0, 'U');\n if (y < cy && valid(x, y + 1)) candidates.emplace_back(3, 'R');\n if (y > cy && valid(x, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n } else {\n auto [tx, ty] = stand_pos[t_idx];\n if (x == tx && y == ty) {\n vector dirs = {0, 1, 2, 3};\n shuffle(dirs.begin(), dirs.end(), rng);\n for (int d : dirs) {\n int bx = x + dx[d];\n int by = y + dy[d];\n if (wall_set.count({bx, by}) && can_block(bx, by)) {\n actions_str[i] = block_char[d];\n this_turn_blocked.insert({bx, by});\n is_blocked[bx][by] = true;\n next_hpos[i] = {x, y};\n did = true;\n break;\n }\n }\n } else {\n vector> candidates;\n if (x < tx && valid(x + 1, ty)) candidates.emplace_back(1, 'D');\n if (x > tx && valid(x - 1, ty)) candidates.emplace_back(0, 'U');\n if (y < ty && valid(tx, y + 1)) candidates.emplace_back(3, 'R');\n if (y > ty && valid(tx, y - 1)) candidates.emplace_back(2, 'L');\n for (auto [d, c] : candidates) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (this_turn_blocked.count({nx, ny})) continue;\n if (targeted_moves.count({nx, ny})) continue;\n actions_str[i] = c;\n next_hpos[i] = {nx, ny};\n targeted_moves.insert({nx, ny});\n did = true;\n break;\n }\n }\n }\n if (!did) {\n actions_str[i] = '.';\n next_hpos[i] = {x, y};\n }\n }\n // output\n cout << actions_str << endl;\n cout.flush();\n // read pet moves\n vector pet_moves(N);\n for (int i = 0; i < N; i++) {\n cin >> pet_moves[i];\n }\n // update human_pos\n for (int i = 0; i < M; i++) {\n human_pos[i] = next_hpos[i];\n }\n // update pet_pos\n for (int i = 0; i < N; i++) {\n int x = pet_pos[i].first, y = pet_pos[i].second;\n string mv = pet_moves[i];\n for (char c : mv) {\n int d = -1;\n if (c == 'U') d = 0;\n else if (c == 'D') d = 1;\n else if (c == 'L') d = 2;\n else if (c == 'R') d = 3;\n if (d != -1) {\n int nx = x + dx[d];\n int ny = y + dy[d];\n if (valid(nx, ny)) {\n x = nx;\n y = ny;\n }\n }\n }\n pet_pos[i] = {x, y};\n }\n }\n return 0;\n}","ahc009":"#include \nusing namespace std;\n\ndouble compute_ES(const vector& sseq, double pp, int ssr, int ssc, int ttr, int ttc, int HH[20][19], int VV[19][20]) {\n double prb[20][20] = {};\n prb[ssr][ssc] = 1.0;\n double ES = 0.0;\n int LL = sseq.size();\n for (int tt = 0; tt < LL; tt++) {\n double rch = 0.0;\n double np[20][20] = {};\n char dr = sseq[tt];\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double prr = prb[i][j];\n if (prr < 1e-20 || (i == ttr && j == ttc)) continue;\n np[i][j] += prr * pp;\n int nii = i, njj = j;\n bool cm = false;\n if (dr == 'D' && i < 19 && VV[i][j] == 0) { nii++; cm = true; }\n else if (dr == 'U' && i > 0 && VV[i - 1][j] == 0) { nii--; cm = true; }\n else if (dr == 'R' && j < 19 && HH[i][j] == 0) { njj++; cm = true; }\n else if (dr == 'L' && j > 0 && HH[i][j - 1] == 0) { njj--; cm = true; }\n if (cm) {\n if (nii == ttr && njj == ttc) {\n rch += prr * (1 - pp);\n } else {\n np[nii][njj] += prr * (1 - pp);\n }\n } else {\n np[i][j] += prr * (1 - pp);\n }\n }\n }\n ES += rch * (401.0 - (tt + 1));\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prb[i][j] = np[i][j];\n double remain = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i != ttr || j != ttc) remain += prb[i][j];\n }\n }\n if (remain < 1e-9) break;\n }\n return ES;\n}\n\nint main() {\n int sr, sc, tr, tc;\n double p;\n cin >> sr >> sc >> tr >> tc >> p;\n int h[20][19];\n for (int i = 0; i < 20; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 19; j++) h[i][j] = s[j] - '0';\n }\n int v[19][20];\n for (int i = 0; i < 19; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 20; j++) v[i][j] = s[j] - '0';\n }\n const int INF = 10000;\n int dist[20][20];\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) dist[i][j] = INF;\n dist[tr][tc] = 0;\n queue> q;\n q.push({tr, tc});\n while (!q.empty()) {\n auto cur = q.front();\n q.pop();\n int x = cur.first, y = cur.second;\n int d = dist[x][y];\n if (y < 19 && h[x][y] == 0) {\n int nx = x, ny = y + 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (y > 0 && h[x][y - 1] == 0) {\n int nx = x, ny = y - 1;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x < 19 && v[x][y] == 0) {\n int nx = x + 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n if (x > 0 && v[x - 1][y] == 0) {\n int nx = x - 1, ny = y;\n if (dist[nx][ny] == INF) {\n dist[nx][ny] = d + 1;\n q.push({nx, ny});\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) if (dist[i][j] == INF) dist[i][j] = 50;\n double best_init_E = -1e9;\n vector best_init_seq;\n // shortest path repeat\n {\n vector path;\n int cx = sr, cy = sc;\n while ((cx != tr || cy != tc) && path.size() < 50) {\n bool found = false;\n for (char ddir : string(\"DRUL\")) {\n int ni = cx, nj = cy;\n bool can = false;\n if (ddir == 'D' && cx < 19 && v[cx][cy] == 0) { ni++; can = true; }\n else if (ddir == 'U' && cx > 0 && v[cx - 1][cy] == 0) { ni--; can = true; }\n else if (ddir == 'R' && cy < 19 && h[cx][cy] == 0) { nj++; can = true; }\n else if (ddir == 'L' && cy > 0 && h[cx][cy - 1] == 0) { nj--; can = true; }\n if (can && dist[ni][nj] == dist[cx][cy] - 1) {\n path.push_back(ddir);\n cx = ni;\n cy = nj;\n found = true;\n break;\n }\n }\n if (!found) break;\n }\n if (path.size() > 0) {\n vector fullp;\n int need = (200 / max(1,(int)path.size())) + 2;\n for (int r = 0; r < need; r++) {\n for (auto c : path) {\n if (fullp.size() < 200) fullp.push_back(c);\n }\n }\n double pE = compute_ES(fullp, p, sr, sc, tr, tc, h, v);\n if (pE > best_init_E + 1e-9) {\n best_init_E = pE;\n best_init_seq = fullp;\n }\n }\n }\n vector> fixed_orders = {\n {'D','R','L','U'}, {'R','D','L','U'}, {'D','L','R','U'}, {'D','R','U','L'}, {'R','L','D','U'},\n {'R','D','U','L'}, {'D','U','R','L'}, {'L','U','R','D'}, {'D','R','L','U'}, {'U','D','R','L'},\n {'D','L','U','R'}, {'R','U','D','L'}, {'L','D','R','U'}\n };\n for (auto& dir_order_base : fixed_orders) {\n vector dir_order = dir_order_base;\n double prob[20][20] = {};\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = 0.0;\n prob[sr][sc] = 1.0;\n vector seq;\n for (int stp = 0; stp < 200; stp++) {\n double best_score = -1e100;\n char bestc = ' ';\n for (int di = 0; di < 4; di++) {\n char dir = dir_order[di];\n double reach = 0.0;\n double newp[20][20] = {};\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (dir == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (dir == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (dir == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (dir == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n double eds = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n if (i == tr && j == tc) continue;\n eds += newp[i][j] * dist[i][j];\n }\n }\n double score = -eds + 30.0 * reach;\n if (score > best_score + 1e-9) {\n best_score = score;\n bestc = dir;\n }\n }\n if (bestc == ' ') break;\n double newp[20][20] = {};\n double reach = 0.0;\n for (int i = 0; i < 20; i++) {\n for (int j = 0; j < 20; j++) {\n double pr = prob[i][j];\n if (pr <= 0 || (i == tr && j == tc)) continue;\n newp[i][j] += pr * p;\n int ni = i, nj = j;\n bool can_move = false;\n if (bestc == 'D' && i < 19 && v[i][j] == 0) { ni++; can_move = true; }\n else if (bestc == 'U' && i > 0 && v[i - 1][j] == 0) { ni--; can_move = true; }\n else if (bestc == 'R' && j < 19 && h[i][j] == 0) { nj++; can_move = true; }\n else if (bestc == 'L' && j > 0 && h[i][j - 1] == 0) { nj--; can_move = true; }\n if (can_move) {\n if (ni == tr && nj == tc) {\n reach += pr * (1 - p);\n } else {\n newp[ni][nj] += pr * (1 - p);\n }\n } else {\n newp[i][j] += pr * (1 - p);\n }\n }\n }\n for (int i = 0; i < 20; i++) for (int j = 0; j < 20; j++) prob[i][j] = newp[i][j];\n seq.push_back(bestc);\n }\n double this_E = compute_ES(seq, p, sr, sc, tr, tc, h, v);\n if (this_E > best_init_E + 1e-9) {\n best_init_E = this_E;\n best_init_seq = seq;\n }\n }\n vector best_seq = best_init_seq;\n double best_E = best_init_E;\n int L = best_seq.size();\n if (L > 0) {\n for (int sweep = 0; sweep < 2; sweep++) {\n bool improved = false;\n for (int pos = 0; pos < L; pos++) {\n char orig = best_seq[pos];\n for (char nd : string(\"UDLR\")) {\n if (nd == orig) continue;\n best_seq[pos] = nd;\n double ne = compute_ES(best_seq, p, sr, sc, tr, tc, h, v);\n if (ne > best_E + 1e-9) {\n best_E = ne;\n improved = true;\n } else {\n best_seq[pos] = orig;\n }\n }\n }\n if (!improved) break;\n }\n }\n string ans = \"\";\n for (char c : best_seq) ans += c;\n if (ans.size() > 200) ans = ans.substr(0, 200);\n cout << ans << endl;\n return 0;\n}","ahc010":"#include \nusing namespace std;\n\nconst int H = 30;\nconst int W = 30;\nconst int D = 4;\nconst int SZ = H * W * D;\n\nint TO[8][4] = {\n {1, 0, -1, -1},\n {3, -1, -1, 0},\n {-1, -1, 3, 2},\n {-1, 2, 1, -1},\n {1, 0, 3, 2},\n {3, 2, 1, 0},\n {2, -1, 0, -1},\n {-1, 3, -1, 1}\n};\nint DI[4] = {0, -1, 0, 1};\nint DJ[4] = {-1, 0, 1, 0};\n\nstatic int current_time = 0;\nstatic int timestamp[SZ];\nstatic int pstep[SZ];\nstatic bool vis[SZ];\n\nint get_eff(int o, int r) {\n if (o < 4) return (o + r) % 4;\n if (o == 4) return (r % 2 ? 5 : 4);\n if (o == 5) return (r % 2 ? 4 : 5);\n if (o == 6) return (r % 2 ? 7 : 6);\n return (r % 2 ? 6 : 7);\n}\n\nlong long compute_cycles(int t[H][W], int r[H][W], int& len1, int& len2) {\n if (current_time > 2000000000) {\n current_time = 0;\n memset(timestamp, 0, sizeof(timestamp));\n }\n int eff[H][W];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n eff[i][j] = get_eff(t[i][j], r[i][j]);\n }\n }\n static int next_state[SZ];\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n for (int d = 0; d < D; d++) {\n int idx = ((i * W + j) * D + d);\n int d2 = TO[eff[i][j]][d];\n if (d2 == -1) {\n next_state[idx] = -1;\n continue;\n }\n int ni = i + DI[d2];\n int nj = j + DJ[d2];\n if (ni < 0 || ni >= H || nj < 0 || nj >= W) {\n next_state[idx] = -1;\n continue;\n }\n int nd = (d2 + 2) % 4;\n next_state[idx] = ((ni * W + nj) * D + nd);\n }\n }\n }\n memset(vis, 0, sizeof(vis));\n len1 = 0;\n len2 = 0;\n int path_arr[4010];\n for (int s = 0; s < SZ; s++) {\n if (!vis[s]) {\n if (next_state[s] == -1) {\n vis[s] = true;\n continue;\n }\n int path_len = 0;\n int cur = s;\n int this_t = ++current_time;\n timestamp[cur] = this_t;\n pstep[cur] = 0;\n path_arr[path_len++] = cur;\n bool foundc = false;\n int cst = 0;\n int nxt;\n while (true) {\n nxt = next_state[cur];\n if (nxt == -1) break;\n if (vis[nxt]) break;\n if (timestamp[nxt] == this_t) {\n foundc = true;\n cst = pstep[nxt];\n break;\n }\n if (path_len >= 4005) break;\n path_arr[path_len] = nxt;\n timestamp[nxt] = this_t;\n pstep[nxt] = path_len;\n path_len++;\n cur = nxt;\n }\n if (foundc) {\n int cl = path_len - cst;\n if (cl > len1) {\n len2 = len1;\n len1 = cl;\n } else if (cl > len2) {\n len2 = cl;\n }\n }\n for (int p = 0; p < path_len; p++) {\n vis[path_arr[p]] = true;\n }\n }\n }\n if (len1 > 0 && len2 > 0) return 1LL * len1 * len2;\n return 0;\n}\n\nint main() {\n int orig[H][W];\n for (int i = 0; i < 30; i++) {\n string s;\n cin >> s;\n for (int j = 0; j < 30; j++) {\n orig[i][j] = s[j] - '0';\n }\n }\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n uniform_int_distribution randr(0, 3);\n long long global_best_sc = 0;\n int global_best_r[H][W];\n // Uniform\n for (int val = 0; val < 4; val++) {\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = val;\n int cl1, cl2;\n long long sc = compute_cycles(orig, init_r, cl1, cl2);\n if (sc > global_best_sc) {\n global_best_sc = sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // position based patterns\n int patterns[5][2] = {{1, 0}, {0, 1}, {2, 1}, {1, 3}, {3, 1}};\n for (int p = 0; p < 5; p++) {\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = (i * patterns[p][0] + j * patterns[p][1]) % 4;\n int cl1, cl2;\n long long sc = compute_cycles(orig, init_r, cl1, cl2);\n if (sc > global_best_sc) {\n global_best_sc = sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // random tries\n for (int tries = 0; tries < 6; tries++) {\n int init_r[H][W];\n for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) init_r[i][j] = randr(rng);\n int cl1, cl2;\n long long sc = compute_cycles(orig, init_r, cl1, cl2);\n if (sc > global_best_sc) {\n global_best_sc = sc;\n memcpy(global_best_r, init_r, sizeof(init_r));\n }\n }\n // Start SA\n int cur_r[H][W];\n memcpy(cur_r, global_best_r, sizeof(global_best_r));\n long long cur_sc = global_best_sc;\n long long best_sc = cur_sc;\n int best_r[H][W];\n memcpy(best_r, cur_r, sizeof(cur_r));\n const int MAX_ITER = 30000;\n double temp = 120000.0;\n double cooling = 0.9999;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n int new_r[H][W];\n memcpy(new_r, cur_r, sizeof(cur_r));\n int nmut = randr(rng) % 3 + 1;\n for (int k = 0; k < nmut; k++) {\n int pos = rng() % (H * W);\n int i = pos / W;\n int j = pos % W;\n int delta = (randr(rng) % 3) + 1;\n new_r[i][j] = (new_r[i][j] + delta) % 4;\n }\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n long long delta = new_sc - cur_sc;\n bool accept = false;\n if (delta >= 0) accept = true;\n else {\n double prob = exp((double)delta / temp);\n if ((double)rng() / rng.max() < prob) accept = true;\n }\n if (accept) {\n memcpy(cur_r, new_r, sizeof(cur_r));\n cur_sc = new_sc;\n if (cur_sc > best_sc) {\n best_sc = cur_sc;\n memcpy(best_r, cur_r, sizeof(best_r));\n }\n }\n temp *= cooling;\n if (temp < 0.5) temp = 0.5;\n }\n // Fine tune phase: small mutations only rotations +1 mod, prefer improvement\n for (int fiter = 0; fiter < 8000; fiter++) {\n int new_r[H][W];\n memcpy(new_r, best_r, sizeof(best_r));\n int i = rng() % H;\n int j = rng() % W;\n int delta = (randr(rng) % 2 + 1) * ((randr(rng) % 2 == 0) ? 1 : -1);\n new_r[i][j] = (best_r[i][j] + delta + 4) % 4;\n int nl1, nl2;\n long long new_sc = compute_cycles(orig, new_r, nl1, nl2);\n if (new_sc > best_sc) {\n best_sc = new_sc;\n memcpy(best_r, new_r, sizeof(new_r));\n }\n }\n // local\n int temp_r[H][W];\n memcpy(temp_r, best_r, sizeof(best_r));\n long long temp_sc = best_sc;\n bool improved = true;\n int passes = 0;\n int local_iters = 0;\n const int MAX_LOCAL_EVAL = 10000;\n while (improved && passes < 4 && local_iters < MAX_LOCAL_EVAL) {\n improved = false;\n passes++;\n vector order(H*W);\n for (int i = 0; i < H*W; i++) order[i] = i;\n shuffle(order.begin(), order.end(), rng);\n for (int pidx = 0; pidx < H*W && local_iters < MAX_LOCAL_EVAL; pidx++) {\n int pos = order[pidx];\n int i = pos / W;\n int j = pos % W;\n int oldr = temp_r[i][j];\n long long best_this_sc = temp_sc;\n int best_this_r = oldr;\n for (int nr = 0; nr < 4; nr++) {\n temp_r[i][j] = nr;\n int tl1, tl2;\n long long sc = compute_cycles(orig, temp_r, tl1, tl2);\n local_iters++;\n if (sc > best_this_sc) {\n best_this_sc = sc;\n best_this_r = nr;\n }\n }\n temp_r[i][j] = best_this_r;\n if (best_this_sc > temp_sc) {\n temp_sc = best_this_sc;\n improved = true;\n }\n }\n }\n if (temp_sc > best_sc) {\n best_sc = temp_sc;\n memcpy(best_r, temp_r, sizeof(best_r));\n }\n string ans = \"\";\n for (int i = 0; i < H; i++) {\n for (int j = 0; j < W; j++) {\n ans += '0' + best_r[i][j];\n }\n }\n cout << ans << endl;\n return 0;\n}","ahc011":"#include \nusing namespace std;\n\nint main() {\n srand(time(0));\n int N, Tmax;\n cin >> N >> Tmax;\n vector> init_board(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 char c = s[j];\n if(c >= '0' && c <= '9') init_board[i][j] = c - '0';\n else init_board[i][j] = 10 + (c - 'a');\n }\n }\n pair init_blank = {-1, -1};\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(init_board[i][j] == 0) init_blank = {i, j};\n int fullS = N * N - 1;\n int ddx[4] = {-1, 1, 0, 0};\n int ddy[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n auto compute_S_and_M = [&](const vector>& b) -> pair {\n int S = 0, M = 0;\n int MM = N * N;\n vector parent(MM), sz(MM, 1), has_cyc(MM, 0);\n for(int i = 0; i < MM; i++) parent[i] = i;\n auto find = [&](auto&& self, int x) -> int {\n if(parent[x] != x) parent[x] = self(self, parent[x]);\n return parent[x];\n };\n auto unite = [&](int x, int y) {\n int px = find(find, x), py = find(find, y);\n if(px == py) {\n has_cyc[px] = 1;\n return;\n }\n if(sz[px] < sz[py]) swap(px, py);\n parent[py] = px;\n sz[px] += sz[py];\n if(has_cyc[py]) has_cyc[px] = 1;\n };\n for(int i = 0; i < N-1; i++) for(int j = 0; j < N; j++) {\n int t1 = b[i][j], t2 = b[i+1][j];\n if(t1 != 0 && t2 != 0 && (t1 & 8) && (t2 & 2)) {\n M++;\n unite(i*N + j, (i+1)*N + j);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N-1; j++) {\n int t1 = b[i][j], t2 = b[i][j+1];\n if(t1 != 0 && t2 != 0 && (t1 & 4) && (t2 & 1)) {\n M++;\n unite(i*N + j, i*N + j + 1);\n }\n }\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(b[i][j] != 0) {\n int rp = find(find, i*N + j);\n if(!has_cyc[rp]) S = max(S, sz[rp]);\n }\n return {S, M};\n };\n vector> board = init_board;\n int bx = init_blank.first, by = init_blank.second;\n string moves = \"\";\n auto initial_pm = compute_S_and_M(board);\n int max_achieved_S = initial_pm.first;\n int max_achieved_M = initial_pm.second;\n string best_sequence = \"\";\n int best_k = 0;\n for(int step = 0; step < Tmax; step++) {\n if(moves.length() >= Tmax) break;\n if(max_achieved_S == fullS) break;\n bool perturb = (rand() % 100 < 20);\n int chosen_d = -1;\n if(perturb) {\n vector cands;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx >= 0 && nx < N && ny >= 0 && ny < N) cands.push_back(d);\n }\n if(!cands.empty()) chosen_d = cands[rand() % cands.size()];\n } else {\n int best_future = -1, best_m = -1;\n vector best_ds;\n for(int d = 0; d < 4; d++) {\n int nx = bx + ddx[d], ny = by + ddy[d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n auto pm1 = compute_S_and_M(board);\n int this_future = pm1.first;\n int thisM = pm1.second;\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n auto pm2 = compute_S_and_M(board);\n int s2 = pm2.first, m2 = pm2.second;\n if(s2 > this_future || (s2 == this_future && m2 > thisM)) {\n this_future = s2;\n thisM = m2;\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n for(int d2 = 0; d2 < 4; d2++) {\n int nx2 = nx + ddx[d2], ny2 = ny + ddy[d2];\n if(nx2 < 0 || nx2 >= N || ny2 < 0 || ny2 >= N) continue;\n swap(board[nx][ny], board[nx2][ny2]);\n for(int d3 = 0; d3 < 4; d3++) {\n int nx3 = nx2 + ddx[d3], ny3 = ny2 + ddy[d3];\n if(nx3 < 0 || nx3 >= N || ny3 < 0 || ny3 >= N) continue;\n swap(board[nx2][ny2], board[nx3][ny3]);\n auto pm3 = compute_S_and_M(board);\n int s3 = pm3.first, m3 = pm3.second;\n if(s3 > this_future || (s3 == this_future && m3 > thisM)) {\n this_future = s3;\n thisM = m3;\n }\n for(int d4 = 0; d4 < 4; d4++) {\n int nx4 = nx3 + ddx[d4], ny4 = ny3 + ddy[d4];\n if(nx4 < 0 || nx4 >= N || ny4 < 0 || ny4 >= N) continue;\n swap(board[nx3][ny3], board[nx4][ny4]);\n auto pm4 = compute_S_and_M(board);\n int s4 = pm4.first, m4 = pm4.second;\n if(s4 > this_future || (s4 == this_future && m4 > thisM)) {\n this_future = s4;\n thisM = m4;\n }\n for(int d5 = 0; d5 < 4; d5++) {\n int nx5 = nx4 + ddx[d5], ny5 = ny4 + ddy[d5];\n if(nx5 < 0 || nx5 >= N || ny5 < 0 || ny5 >= N) continue;\n swap(board[nx4][ny4], board[nx5][ny5]);\n auto pm5 = compute_S_and_M(board);\n int s5 = pm5.first, m5 = pm5.second;\n if(s5 > this_future || (s5 == this_future && m5 > thisM)) {\n this_future = s5;\n thisM = m5;\n }\n swap(board[nx4][ny4], board[nx5][ny5]);\n }\n swap(board[nx3][ny3], board[nx4][ny4]);\n }\n swap(board[nx2][ny2], board[nx3][ny3]);\n }\n swap(board[nx][ny], board[nx2][ny2]);\n }\n if(this_future > best_future || (this_future == best_future && thisM > best_m)) {\n best_future = this_future;\n best_m = thisM;\n best_ds.clear();\n best_ds.push_back(d);\n } else if(this_future == best_future && thisM == best_m) {\n best_ds.push_back(d);\n }\n swap(board[bx][by], board[nx][ny]);\n }\n if(!best_ds.empty()) {\n int idx = rand() % best_ds.size();\n chosen_d = best_ds[idx];\n }\n }\n if(chosen_d == -1) break;\n int nx = bx + ddx[chosen_d], ny = by + ddy[chosen_d];\n if(nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n swap(board[bx][by], board[nx][ny]);\n bx = nx; by = ny;\n moves += dchar[chosen_d];\n auto [ns, nm] = compute_S_and_M(board);\n int nk = moves.length();\n if(ns > max_achieved_S || (ns == max_achieved_S && nk < best_k)) {\n max_achieved_S = ns;\n max_achieved_M = nm;\n best_sequence = moves;\n best_k = nk;\n } else if(ns == max_achieved_S && nm > max_achieved_M) {\n max_achieved_M = nm;\n best_sequence = moves;\n best_k = nk;\n }\n }\n cout << best_sequence << endl;\n}","ahc012":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Line {\n ll px, py, qx, qy;\n};\n\nint main() {\n int N, K;\n cin >> N >> K;\n vector A(11, 0);\n for (int d = 1; d <= 10; d++) {\n cin >> A[d];\n }\n vector> pts(N);\n for (auto& p : pts) {\n cin >> p.first >> p.second;\n }\n auto compute_cross = [&](const Line& l, int id) -> ll {\n auto [x, y] = pts[id];\n ll a = x - l.px;\n ll b = y - l.py;\n ll c = l.qx - l.px;\n ll d = l.qy - l.py;\n return a * d - b * c;\n };\n auto get_fr_sat = [&](const vector>& prts) -> pair, int> {\n vector fr(5501, 0);\n for (auto& p : prts) {\n size_t s = p.size();\n if (s < 5501) fr[s]++;\n }\n int s = 0;\n for (int d = 1; d <= 10; d++) {\n s += min(A[d], fr[d]);\n }\n return {fr, s};\n };\n vector best_chosen;\n int best_sat = -1;\n for (int trial = 0; trial < 3; trial++) {\n double shift = trial * (2 * 3.141592653589793 / 36.0);\n vector all_idx(N);\n iota(all_idx.begin(), all_idx.end(), 0);\n vector> parts = {all_idx};\n vector chosen;\n auto [_, init_sat] = get_fr_sat(parts);\n int cur_sat = init_sat;\n for (int iter = 0; iter < 100 && (int)chosen.size() < K; iter++) {\n auto [fr, tmp_sat] = get_fr_sat(parts);\n vector needed;\n for (int d = 1; d <= 10; d++) {\n if (fr[d] < A[d]) needed.push_back(d);\n }\n vector large_g_idx;\n for (int i = 0; i < (int)parts.size(); i++) {\n if ((int)parts[i].size() > 10) large_g_idx.push_back(i);\n }\n if (large_g_idx.empty()) break;\n sort(large_g_idx.begin(), large_g_idx.end(), [&](int aa, int bb) {\n return parts[aa].size() > parts[bb].size();\n });\n int num_target = min(1, (int)large_g_idx.size());\n int best_new = cur_sat;\n Line best_l;\n bool improved = false;\n for (int tg = 0; tg < num_target; tg++) {\n int gidx = large_g_idx[tg];\n auto& group = parts[gidx];\n int gs = group.size();\n for (int th = 0; th < 36; th++) {\n double theta = shift + (2 * 3.141592653589793 * th / 36.0);\n double nx = cos(theta);\n double ny = sin(theta);\n vector> projs;\n projs.reserve(gs);\n for (int id : group) {\n double pr = pts[id].first * nx + pts[id].second * ny;\n projs.emplace_back(pr, id);\n }\n sort(projs.begin(), projs.end());\n for (int mm : needed) {\n int m = mm;\n if (m < 1 || m > min(10, gs - 1)) continue;\n double r1 = projs[m - 1].first;\n double r2 = projs[m].first;\n if (abs(r1 - r2) < 1e-9) continue;\n double r = (r1 + r2) / 2.0;\n double dx = -ny;\n double dy = nx;\n double D = 1000000.0;\n double bx = r * nx;\n double by = r * ny;\n double pxd = bx + D * dx;\n double pyd = by + D * dy;\n double qxd = bx - D * dx;\n double qyd = by - D * dy;\n ll px = (ll)round(pxd);\n ll py = (ll)round(pyd);\n ll qx = (ll)round(qxd);\n ll qy = (ll)round(qyd);\n if (px == qx && py == qy) continue;\n if (llabs(px) > 1000000000LL || llabs(py) > 1000000000LL || llabs(qx) > 1000000000LL || llabs(qy) > 1000000000LL) continue;\n Line llne{px, py, qx, qy};\n vector temp_fr(5501, 0);\n bool valid = true;\n for (size_t j = 0; j < parts.size() && valid; j++) {\n ll lcnt = 0, rcnt = 0;\n auto& grp = parts[j];\n for (int id : grp) {\n ll cr = compute_cross(llne, id);\n if (cr == 0) {\n valid = false;\n break;\n }\n if (cr > 0) lcnt++;\n else rcnt++;\n }\n if (valid) {\n if (lcnt > 0) temp_fr[lcnt]++;\n if (rcnt > 0) temp_fr[rcnt]++;\n }\n }\n if (!valid) continue;\n int newsat = 0;\n for (int d = 1; d <= 10; d++) {\n newsat += min(A[d], temp_fr[d]);\n }\n if (newsat > best_new) {\n best_new = newsat;\n best_l = llne;\n improved = true;\n }\n }\n }\n }\n if (improved) {\n chosen.push_back(best_l);\n vector> new_prts;\n for (auto& grp : parts) {\n vector leftv, rightv;\n for (int id : grp) {\n ll cr = compute_cross(best_l, id);\n if (cr > 0) leftv.push_back(id);\n else rightv.push_back(id);\n }\n if (!leftv.empty()) new_prts.push_back(leftv);\n if (!rightv.empty()) new_prts.push_back(rightv);\n }\n parts = std::move(new_prts);\n cur_sat = best_new;\n } else {\n break;\n }\n }\n if (cur_sat > best_sat) {\n best_sat = cur_sat;\n best_chosen = chosen;\n }\n }\n cout << best_chosen.size() << endl;\n for (auto& l : best_chosen) {\n cout << l.px << \" \" << l.py << \" \" << l.qx << \" \" << l.qy << endl;\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\nusing pii = pair;\n\nconst int MAXN = 65;\nbool has[MAXN][MAXN];\nbool uh[MAXN][MAXN];\nbool uv[MAXN][MAXN];\nbool udp[MAXN][MAXN];\nbool udm[MAXN][MAXN];\nint N;\nvector init_dots;\nint M;\nint C;\n\nbool inb(int x) { return 0 <= x && x < N; }\n\nint get_w(int x, int y) {\n int dx = x - C, dy = y - C;\n return dx * dx + dy * dy + 1;\n}\n\nbool is_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n return uh[y1][xx];\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n return uv[x1][yy];\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low, y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n return udp[xlow][y_at_low];\n } else if (dyh == -1) {\n return udm[xlow][y_at_low];\n }\n return true;\n }\n return true;\n}\n\nvoid set_used_unit(int x1, int y1, int x2, int y2) {\n if (y1 == y2 && abs(x1 - x2) == 1) {\n int xx = min(x1, x2);\n uh[y1][xx] = true;\n } else if (x1 == x2 && abs(y1 - y2) == 1) {\n int yy = min(y1, y2);\n uv[x1][yy] = true;\n } else if (abs(x1 - x2) == 1 && abs(y1 - y2) == 1) {\n int xlow = min(x1, x2);\n int y_at_low, y_at_high;\n if (x1 == xlow) {\n y_at_low = y1;\n y_at_high = y2;\n } else {\n y_at_low = y2;\n y_at_high = y1;\n }\n int dyh = y_at_high - y_at_low;\n if (dyh == 1) {\n udp[xlow][y_at_low] = true;\n } else if (dyh == -1) {\n udm[xlow][y_at_low] = true;\n }\n }\n}\n\nbool clean_perim(const array& corn) {\n double cx = 0, cy = 0;\n for (auto& p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs.emplace_back(ang, i);\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0 && dy != 0) {\n steps = ady;\n uy = (dy > 0 ? 1 : -1);\n } else if (dy == 0 && dx != 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = (dx > 0 ? 1 : -1);\n uy = (dy > 0 ? 1 : -1);\n } else return false;\n for (int k = 1; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n if (has[xx][yy]) return false;\n }\n }\n return true;\n}\n\nbool edges_free(const array& corn) {\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs(4);\n for (int i = 0; i < 4; i++) {\n double ang = atan2(corn[i].second - cy, corn[i].first - cx);\n angs[i] = {ang, i};\n }\n sort(angs.begin(), angs.end());\n vector ord(4);\n for (int i = 0; i < 4; i++) ord[i] = corn[angs[i].second];\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n } else return false;\n for (int k = 0; k < steps; k++) {\n int xx1 = x1 + k * ux;\n int yy1 = y1 + k * uy;\n int xx2 = xx1 + ux;\n int yy2 = yy1 + uy;\n if (is_used_unit(xx1, yy1, xx2, yy2)) return false;\n }\n }\n return true;\n}\n\nvector> cands;\nset> seen_set;\n\nvoid add_candidate(const array& corn) {\n array sorted_c = corn;\n sort(sorted_c.begin(), sorted_c.end());\n array key;\n for (int i = 0; i < 4; i++) {\n key[2 * i] = sorted_c[i].first;\n key[2 * i + 1] = sorted_c[i].second;\n }\n if (seen_set.count(key)) return;\n seen_set.insert(key);\n cands.push_back(corn);\n}\n\nbool get_three_missing(const array& corn, pii& newp) {\n int cnt_miss = 0;\n for (auto& pt : corn) {\n if (!has[pt.first][pt.second]) {\n newp = pt;\n cnt_miss++;\n if (cnt_miss > 1) return false;\n }\n }\n return cnt_miss == 1;\n}\n\nvoid try_from_pair(pii P, pii Q) {\n int px = P.first, py = P.second, qx = Q.first, qy = Q.second;\n if (!has[px][py] || !has[qx][qy]) return;\n if (px != qx && py != qy) {\n pii R = {px, qy};\n pii S = {qx, py};\n if (!inb(R.first) || !inb(R.second) || !inb(S.first) || !inb(S.second)) return;\n int hasR = has[R.first][R.second] ? 1 : 0;\n int hasS = has[S.first][S.second] ? 1 : 0;\n if (hasR + hasS == 1) {\n array corn = {P, Q, R, S};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n int dx = qx - px;\n int dy = qy - py;\n if ((dx + dy) % 2 == 0 && (dx - dy) % 2 == 0) {\n int p = (dx + dy) / 2;\n int q = (dx - dy) / 2;\n if (p != 0 && q != 0) {\n int bx = px + p;\n int by = py + p;\n int dx_ = px + q;\n int dy_ = py - q;\n if (inb(bx) && inb(by) && inb(dx_) && inb(dy_)) {\n int qcx = px + p + q;\n int qcy = py + p - q;\n if (qcx == qx && qcy == qy) {\n array corn = {{{px, py}, {bx, by}, {qx, qy}, {dx_, dy_}}};\n int num_has = 0;\n for (auto pr : corn) if (has[pr.first][pr.second]) num_has++;\n if (num_has == 3 && clean_perim(corn) && edges_free(corn)) {\n add_candidate(corn);\n }\n }\n }\n }\n }\n}\n\nint main() {\n srand(time(nullptr));\n cin >> N >> M;\n init_dots.resize(M);\n for (int i = 0; i < M; i++) {\n cin >> init_dots[i].first >> init_dots[i].second;\n }\n C = (N - 1) / 2;\n vector> best_ops;\n long long best_sumw = 0;\n int trials = 50;\n for (int trial = 0; trial < trials; trial++) {\n memset(has, 0, sizeof(has));\n memset(uh, 0, sizeof(uh));\n memset(uv, 0, sizeof(uv));\n memset(udp, 0, sizeof(udp));\n memset(udm, 0, sizeof(udm));\n for (auto& pt : init_dots) {\n has[pt.first][pt.second] = true;\n }\n vector dots_list = init_dots;\n cands.clear();\n seen_set.clear();\n for (size_t i = 0; i < dots_list.size(); i++) {\n for (size_t j = i + 1; j < dots_list.size(); j++) {\n try_from_pair(dots_list[i], dots_list[j]);\n try_from_pair(dots_list[j], dots_list[i]);\n }\n }\n vector> this_ops;\n while (true) {\n vector> valid_w;\n for (int ci = 0; ci < (int)cands.size(); ci++) {\n auto& corn = cands[ci];\n pii np;\n if (!get_three_missing(corn, np)) continue;\n if (has[np.first][np.second]) continue;\n if (!clean_perim(corn) || !edges_free(corn)) continue;\n int ww = get_w(np.first, np.second);\n valid_w.emplace_back(-ww, ci);\n }\n if (valid_w.empty()) break;\n sort(valid_w.begin(), valid_w.end());\n int num_top = min(10, (int)valid_w.size());\n int sel = rand() % num_top;\n int best_idx = valid_w[sel].second;\n auto corn = cands[best_idx];\n double cx = 0, cy = 0;\n for (auto p : corn) {\n cx += p.first;\n cy += p.second;\n }\n cx /= 4;\n cy /= 4;\n vector> angs;\n for (int i = 0; i < 4; i++) {\n angs.emplace_back(atan2(corn[i].second - cy, corn[i].first - cx), i);\n }\n sort(angs.begin(), angs.end());\n vector ord;\n for (auto& a : angs) ord.push_back(corn[a.second]);\n int new_idx = -1;\n pii best_new;\n for (int i = 0; i < 4; i++) {\n if (!has[ord[i].first][ord[i].second]) {\n new_idx = i;\n best_new = ord[i];\n break;\n }\n }\n if (new_idx == -1) continue;\n array op;\n op[0] = best_new.first;\n op[1] = best_new.second;\n for (int k = 0; k < 3; k++) {\n pii nxt = ord[(new_idx + 1 + k) % 4];\n op[2 + k * 2] = nxt.first;\n op[2 + k * 2 + 1] = nxt.second;\n }\n this_ops.push_back(op);\n has[best_new.first][best_new.second] = true;\n dots_list.push_back(best_new);\n for (int i = 0; i < 4; i++) {\n pii p1 = ord[i];\n pii p2 = ord[(i + 1) % 4];\n int x1 = p1.first, y1 = p1.second, x2 = p2.first, y2 = p2.second;\n int dx = x2 - x1, dy = y2 - y1;\n int adx = abs(dx), ady = abs(dy);\n int steps = 0, ux = 0, uy = 0;\n if (dx == 0) {\n steps = ady;\n uy = dy > 0 ? 1 : -1;\n } else if (dy == 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n } else if (adx == ady && adx > 0) {\n steps = adx;\n ux = dx > 0 ? 1 : -1;\n uy = dy > 0 ? 1 : -1;\n }\n for (int k = 0; k < steps; k++) {\n int xx = x1 + k * ux;\n int yy = y1 + k * uy;\n set_used_unit(xx, yy, xx + ux, yy + uy);\n }\n }\n for (auto& Q : dots_list) {\n if (Q == best_new) continue;\n try_from_pair(best_new, Q);\n try_from_pair(Q, best_new);\n }\n }\n long long cur_sumw = 0;\n for (auto& pt : dots_list) {\n cur_sumw += get_w(pt.first, pt.second);\n }\n if (cur_sumw > best_sumw) {\n best_sumw = cur_sumw;\n best_ops = this_ops;\n }\n }\n cout << best_ops.size() << endl;\n for (auto& arr : best_ops) {\n for (int i = 0; i < 8; i++) {\n cout << arr[i];\n if (i < 7) cout << \" \";\n else cout << endl;\n }\n }\n return 0;\n}","ahc015":"#include \nusing namespace std;\n\nlong long calc_score(const vector>& grid) {\n bool visited[10][10] = {};\n long long total = 0;\n auto dfs = [&](auto&& self, int r, int c, int flavor, int& cnt) -> void {\n visited[r][c] = true;\n cnt++;\n int dr[4] = {-1, 0, 1, 0};\n int dc[4] = {0, 1, 0, -1};\n for (int d = 0; d < 4; d++) {\n int nr = r + dr[d], nc = c + dc[d];\n if (nr >= 0 && nr < 10 && nc >= 0 && nc < 10 && !visited[nr][nc] && grid[nr][nc] == flavor) {\n self(self, nr, nc, flavor, cnt);\n }\n }\n };\n for (int flavor = 1; flavor <= 3; flavor++) {\n for (int r = 0; r < 10; r++) {\n for (int c = 0; c < 10; c++) {\n if (!visited[r][c] && grid[r][c] == flavor) {\n int cnt = 0;\n dfs(dfs, r, c, flavor, cnt);\n total += 1LL * cnt * cnt;\n }\n }\n }\n }\n return total;\n}\n\nlong long potential(const vector>& grid) {\n long long res = calc_score(grid);\n for (int fl = 1; fl <= 3; fl++) {\n for (int r = 0; r < 10; r++) {\n int cnt = 0;\n for (int c = 0; c < 10; c++) if (grid[r][c] == fl) cnt++;\n res += (1LL * cnt * cnt) / 4;\n }\n for (int c = 0; c < 10; c++) {\n int cnt = 0;\n for (int r = 0; r < 10; r++) if (grid[r][c] == fl) cnt++;\n res += (1LL * cnt * cnt) / 4;\n }\n }\n return res;\n}\n\nvoid apply(vector>& grid, char d) {\n if (d == 'F') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int r = 0; r < 10; r++) grid[r][c] = (r < (int)line.size() ? line[r] : 0);\n }\n } else if (d == 'B') {\n for (int c = 0; c < 10; c++) {\n vector line;\n for (int r = 0; r < 10; r++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int r = 0; r < 10; r++) grid[r][c] = (r < 10 - ls ? 0 : line[r - (10 - ls)]);\n }\n } else if (d == 'L') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n for (int c = 0; c < 10; c++) grid[r][c] = (c < (int)line.size() ? line[c] : 0);\n }\n } else if (d == 'R') {\n for (int r = 0; r < 10; r++) {\n vector line;\n for (int c = 0; c < 10; c++) if (grid[r][c]) line.push_back(grid[r][c]);\n int ls = line.size();\n for (int c = 0; c < 10; c++) grid[r][c] = (c < 10 - ls ? 0 : line[c - (10 - ls)]);\n }\n }\n}\n\nint main() {\n vector> g(10, vector(10, 0));\n vector f(100);\n for (int &x : f) cin >> x;\n for (int t = 0; t < 100; t++) {\n int p;\n cin >> p;\n vector> empt;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (g[r][c] == 0) empt.emplace_back(r, c);\n auto [rr, cc] = empt[p - 1];\n g[rr][cc] = f[t];\n long double best_eval = -1;\n char best_d = 'F';\n bool has_next = (t < 99);\n int next_f = has_next ? f[t + 1] : -1;\n for (char d : {'F', 'B', 'L', 'R'}) {\n vector> ng = g;\n apply(ng, d);\n long long csc = potential(ng);\n long double fut = 0;\n if (has_next) {\n vector> ne;\n for (int r = 0; r < 10; r++) for (int c = 0; c < 10; c++) if (ng[r][c] == 0) ne.emplace_back(r, c);\n if (!ne.empty()) {\n long double sumf = 0;\n for (auto& pr : ne) {\n vector> ngp = ng;\n ngp[pr.first][pr.second] = next_f;\n long long bns = 0;\n for (char nd : {'F', 'B', 'L', 'R'}) {\n vector> ng2 = ngp;\n apply(ng2, nd);\n long long sc2 = potential(ng2);\n if (sc2 > bns) bns = sc2;\n }\n sumf += bns;\n }\n fut = sumf / ne.size();\n }\n }\n long double evalv = csc + fut;\n if (evalv > best_eval) {\n best_eval = evalv;\n best_d = d;\n }\n }\n apply(g, best_d);\n cout << best_d << endl;\n cout.flush();\n }\n return 0;\n}","ahc016":"#include \n#include \n\nusing namespace std;\nusing Eigen::MatrixXd;\nusing Eigen::VectorXd;\nusing Eigen::SelfAdjointEigenSolver;\n\nint main() {\n int M;\n double eps;\n cin >> M >> eps;\n int N = 20;\n if (eps < 0.1) N = 12;\n else if (eps < 0.2) N = 18;\n else if (eps < 0.3) N = 25;\n else N = 35;\n N = max(N, (int)ceil(sqrt(2.0 * M)));\n N = min(N, 100);\n N = max(N, 4);\n vector G(M);\n for(int k = 0; k < M; k++) {\n double p = (double)(k + 1) / (M + 1);\n string s = \"\";\n for(int i = 0; i < N; i++) {\n for(int j = i + 1; j < N; j++) {\n long long seed = (long long)k * 123457 + (long long)i * 10007 + j;\n if ((seed % 100000LL) < (long long)(p * 100000)) {\n s += '1';\n } else {\n s += '0';\n }\n }\n }\n G[k] = s;\n }\n vector> pre_degs(M);\n vector> pre_eigs(M);\n for(int k = 0; k < M; k++) {\n auto& str = G[k];\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(str[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector d(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) d[i]++;\n sort(d.begin(), d.end());\n pre_degs[k] = d;\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector ev(N);\n for(int i = 0; i < N; i++) ev[i] = e(i);\n pre_eigs[k] = ev;\n }\n cout << N << endl;\n for(auto& g : G) {\n cout << g << endl;\n }\n cout.flush();\n double scale = 1 - 2 * eps;\n double bias = eps * (N - 1.0);\n for(int q = 0; q < 100; q++) {\n string H;\n cin >> H;\n vector> a(N, vector(N, 0));\n int pos = 0;\n for(int i = 0; i < N; i++) for(int j = i + 1; j < N; j++) {\n if(H[pos++] == '1') a[i][j] = a[j][i] = 1;\n }\n vector deg(N, 0);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) if(a[i][j]) deg[i]++;\n sort(deg.begin(), deg.end());\n MatrixXd A(N, N);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) A(i,j) = a[i][j];\n SelfAdjointEigenSolver es(A);\n VectorXd e = es.eigenvalues();\n vector eig(N);\n for(int i = 0; i < N; i++) eig[i] = e(i);\n int best = 0;\n double min_dist = 1e100;\n for(int k = 0; k < M; k++) {\n double ddeg = 0;\n for(int i = 0; i < N; i++) {\n double exp_d = bias + scale * pre_degs[k][i];\n ddeg += (deg[i] - exp_d) * (deg[i] - exp_d);\n }\n ddeg = sqrt(ddeg);\n double deig = 0;\n vector eexp = pre_eigs[k];\n for(int i=0; i\nusing namespace std;\nusing ll = long long;\n\nmt19937 rng(42);\n\nint main() {\n int N, M, D, K;\n cin >> N >> M >> D >> K;\n vector U(M), V(M);\n vector W(M);\n for(int i = 0; i < M; i++) {\n cin >> U[i] >> V[i] >> W[i];\n --U[i]; --V[i];\n }\n vector> pos(N);\n for(int i = 0; i < N; i++) {\n cin >> pos[i].first >> pos[i].second;\n }\n vector> edge_ang(M);\n for(int i=0;i vector {\n vector ass(M, -1);\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n mt19937 rng(seed);\n sort(ord.begin(), ord.end(), [&](int a,int b){return edge_ang[a].first < edge_ang[b].first;});\n shuffle(ord.begin(), ord.end(), rng);\n for(int ei : ord) {\n int best = -1;\n int minc = INT_MAX;\n int minld = INT_MAX;\n for(int d = 0; d < D; d++) if(ld[d] < K) {\n int conf = vcnt[U[ei]][d] + vcnt[V[ei]][d];\n if(conf < minc || (conf == minc && ld[d] < minld)) {\n minc = conf;\n minld = ld[d];\n best = d;\n }\n }\n if(best == -1) {\n for(int d=0;d& ass) -> ll {\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = ass[i];\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n ll bad = 0;\n for(int v = 0; v <= N; v++) {\n for(int d = 0; d < D; d++) {\n int c = vcnt[v][d];\n bad += (ll)c * (c - 1);\n }\n }\n return bad;\n };\n vector best_ass;\n ll min_bad = LLONG_MAX;\n int trials = 8000;\n for(int t = 0; t < trials; t++) {\n vector ass = gen(t * 10007ULL + 123456789ULL);\n ll bd = compute_bad(ass);\n if(bd < min_bad) {\n min_bad = bd;\n best_ass = ass;\n }\n }\n vector ld(D, 0);\n vector> vcnt(N + 1, vector(D, 0));\n for(int i = 0; i < M; i++) {\n int d = best_ass[i];\n ld[d]++;\n vcnt[U[i]][d]++;\n vcnt[V[i]][d]++;\n }\n bool improved = true;\n int max_passes = 350;\n mt19937 rng_rand(424242);\n for(int pass = 0; pass < max_passes && improved; pass++) {\n improved = false;\n vector ord(M);\n iota(ord.begin(), ord.end(), 0);\n shuffle(ord.begin(), ord.end(), rng_rand);\n for(int ei : ord) {\n int cur = best_ass[ei];\n int uu = U[ei], vv = V[ei];\n ll best_delta = 0;\n int best_newd = -1;\n for(int d = 0; d < D; d++) if(d != cur && ld[d] < K) {\n int c1a = vcnt[uu][cur];\n int c2a = vcnt[vv][cur];\n ll delta_cur = -2LL * (c1a + c2a - 2);\n int c1b = vcnt[uu][d];\n int c2b = vcnt[vv][d];\n ll delta_newd = 2LL * (c1b + c2b);\n ll delta = delta_cur + delta_newd;\n if(delta < best_delta) {\n best_delta = delta;\n best_newd = d;\n }\n }\n if(best_newd != -1 && best_delta < 0) {\n int newd = best_newd;\n vcnt[uu][cur]--;\n vcnt[vv][cur]--;\n vcnt[uu][newd]++;\n vcnt[vv][newd]++;\n ld[cur]--;\n ld[newd]++;\n best_ass[ei] = newd;\n improved = true;\n }\n }\n }\n for(int i = 0; i < M; i++) {\n if(i > 0) cout << \" \";\n cout << (best_ass[i] + 1);\n }\n cout << endl;\n return 0;\n}","ahc019":"#include \nusing namespace std;\n\nstruct Rod {\n int st, f1, f2, len;\n};\n\nstruct Rect {\n int sx, sy, sz, wx, wy;\n};\n\nint main() {\n int D;\n cin >> D;\n vector F[2], R[2];\n for (int i = 0; i < 2; i++) {\n F[i].resize(D);\n for (auto &s : F[i]) cin >> s;\n R[i].resize(D);\n for (auto &s : R[i]) cin >> s;\n }\n double best_eval = 1LL << 60;\n int best_n = 0;\n int best_block[2][15][15][15];\n for (int trial = 0; trial < 500; trial++) {\n bool voxels[2][15][15][15] = {};\n srand(trial * 12345 + 1);\n for (int ii = 0; ii < 2; ii++) {\n for (int z = 0; z < D; z++) {\n vector Xs, Ys;\n for (int x = 0; x < D; x++) if (F[ii][z][x] == '1') Xs.push_back(x);\n for (int y = 0; y < D; y++) if (R[ii][z][y] == '1') Ys.push_back(y);\n int a = Xs.size(), b = Ys.size();\n if (a == 0 || b == 0) continue;\n vector Xsort = Xs; sort(Xsort.begin(), Xsort.end());\n vector Ysort = Ys; sort(Ysort.begin(), Ysort.end());\n vector> assigns;\n vector target_b;\n if (a >= b) {\n int base = a / b; int rem = a % b;\n for (int iy = 0; iy < b; iy++) {\n int cnt = base + (iy < rem ? 1 : 0);\n for (int j = 0; j < cnt; j++) target_b.push_back(Ysort[iy]);\n }\n } else {\n for (int iy = 0; iy < b; iy++) {\n target_b.push_back(Ysort[iy]);\n }\n }\n random_shuffle(target_b.begin(), target_b.end());\n if (a >= b) {\n for (int k = 0; k < a; k++) {\n assigns.emplace_back(Xsort[k], target_b[k]);\n }\n } else {\n for (int k = 0; k < b; k++) {\n assigns.emplace_back(Xsort[k % a], target_b[k]);\n }\n }\n for (auto p : assigns) {\n voxels[ii][p.first][p.second][z] = true;\n }\n }\n }\n auto process_rod = [&](int di) {\n vector rlist[2][16];\n for (int i = 0; i < 2; i++) {\n if (di == 0) {\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) {\n for (int x = 0; x < D; ) {\n if (!voxels[i][x][y][z]) { x++; continue; }\n int st = x;\n while (x < D && voxels[i][x][y][z]) x++;\n int l = x - st;\n rlist[i][l].push_back({st, y, z, l});\n }\n }\n } else if (di == 1) {\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) {\n for (int y = 0; y < D; ) {\n if (!voxels[i][x][y][z]) { y++; continue; }\n int st = y;\n while (y < D && voxels[i][x][y][z]) y++;\n int l = y - st;\n rlist[i][l].push_back({st, x, z, l});\n }\n }\n } else {\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) {\n for (int z = 0; z < D; ) {\n if (!voxels[i][x][y][z]) { z++; continue; }\n int st = z;\n while (z < D && voxels[i][x][y][z]) z++;\n int l = z - st;\n rlist[i][l].push_back({st, x, y, l});\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n for (int l = 1; l <= D; l++) {\n int c[2] = {(int)rlist[0][l].size(), (int)rlist[1][l].size()};\n int sh = min(c[0], c[1]);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c[1] - sh) * l;\n rrs[1] += (c[0] - sh) * l;\n sinv += sh * 1.0 / l;\n for (int k = 0; k < c[0]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod& rd = rlist[0][l][k];\n if (di == 0) {\n for (int d = 0; d < l; d++) blockid[0][rd.st + d][rd.f1][rd.f2] = bid;\n } else if (di == 1) {\n for (int d = 0; d < l; d++) blockid[0][rd.f1][rd.st + d][rd.f2] = bid;\n } else {\n for (int d = 0; d < l; d++) blockid[0][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n for (int k = 0; k < c[1]; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rod& rd = rlist[1][l][k];\n if (di == 0) {\n for (int d = 0; d < l; d++) blockid[1][rd.st + d][rd.f1][rd.f2] = bid;\n } else if (di == 1) {\n for (int d = 0; d < l; d++) blockid[1][rd.f1][rd.st + d][rd.f2] = bid;\n } else {\n for (int d = 0; d < l; d++) blockid[1][rd.f1][rd.f2][rd.st + d] = bid;\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int p = 0; p < 2; p++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) best_block[p][x][y][z] = blockid[p][x][y][z];\n }\n };\n process_rod(0);\n process_rod(1);\n process_rod(2);\n auto try_rect_plane = [&](int plane) {\n map, vector> rects_key[2];\n for (int i = 0; i < 2; i++) {\n if (plane == 0) {\n for (int z = 0; z < D; z++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) layer[x][y] = voxels[i][x][y][z];\n while (true) {\n for (int x = 0; x < D; x++) {\n prefix[x][0] = 0;\n for (int y = 1; y <= D; y++) prefix[x][y] = prefix[x][y - 1] + (layer[x][y - 1] ? 1 : 0);\n }\n int max_area = 0, bx = -1, by = -1, bwx = 0, bwy = 0;\n for (int t = 0; t < D; t++) for (int b = t; b < D; b++) for (int l = 0; l < D; l++) for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int x = t; x <= b && ok; x++) if (prefix[x][r + 1] - prefix[x][l] != (r - l + 1)) ok = false;\n if (ok) {\n max_area = area; bx = t; by = l; bwx = b - t + 1; bwy = r - l + 1;\n }\n }\n if (max_area == 0) break;\n int mn = min(bwx, bwy), mx = max(bwx, bwy);\n rects_key[i][{mn, mx}].push_back({bx, by, z, bwx, bwy});\n for (int dx = 0; dx < bwx; dx++) for (int dy = 0; dy < bwy; dy++) layer[bx + dx][by + dy] = false;\n }\n }\n } else if (plane == 1) {\n for (int y = 0; y < D; y++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int x = 0; x < D; x++) for (int z = 0; z < D; z++) layer[x][z] = voxels[i][x][y][z];\n while (true) {\n for (int x = 0; x < D; x++) {\n prefix[x][0] = 0;\n for (int z = 1; z <= D; z++) prefix[x][z] = prefix[x][z - 1] + (layer[x][z - 1] ? 1 : 0);\n }\n int max_area = 0, bx = -1, bz = -1, bwx = 0, bwz = 0;\n for (int t = 0; t < D; t++) for (int b = t; b < D; b++) for (int l = 0; l < D; l++) for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int x = t; x <= b && ok; x++) if (prefix[x][r + 1] - prefix[x][l] != (r - l + 1)) ok = false;\n if (ok) {\n max_area = area; bx = t; bz = l; bwx = b - t + 1; bwz = r - l + 1;\n }\n }\n if (max_area == 0) break;\n int mn = min(bwx, bwz), mx = max(bwx, bwz);\n rects_key[i][{mn, mx}].push_back({bx, y, bz, bwx, bwz});\n for (int dx = 0; dx < bwx; dx++) for (int dz = 0; dz < bwz; dz++) layer[bx + dx][bz + dz] = false;\n }\n }\n } else {\n for (int x = 0; x < D; x++) {\n bool layer[15][15] = {};\n vector> prefix(D, vector(D + 1, 0));\n for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) layer[y][z] = voxels[i][x][y][z];\n while (true) {\n for (int y = 0; y < D; y++) {\n prefix[y][0] = 0;\n for (int z = 1; z <= D; z++) prefix[y][z] = prefix[y][z - 1] + (layer[y][z - 1] ? 1 : 0);\n }\n int max_area = 0, by = -1, bz = -1, bwy = 0, bwz = 0;\n for (int t = 0; t < D; t++) for (int b = t; b < D; b++) for (int l = 0; l < D; l++) for (int r = l; r < D; r++) {\n int area = (b - t + 1) * (r - l + 1);\n if (area <= max_area) continue;\n bool ok = true;\n for (int y = t; y <= b && ok; y++) if (prefix[y][r + 1] - prefix[y][l] != (r - l + 1)) ok = false;\n if (ok) {\n max_area = area; by = t; bz = l; bwy = b - t + 1; bwz = r - l + 1;\n }\n }\n if (max_area == 0) break;\n int mn = min(bwy, bwz), mx = max(bwy, bwz);\n rects_key[i][{mn, mx}].push_back({x, by, bz, bwy, bwz});\n for (int dy = 0; dy < bwy; dy++) for (int dz = 0; dz < bwz; dz++) layer[by + dy][bz + dz] = false;\n }\n }\n }\n }\n int blockid[2][15][15][15] = {};\n int nid = 1;\n int rrs[2] = {0};\n double sinv = 0;\n vector> all_keys;\n for (auto& p : rects_key[0]) all_keys.push_back(p.first);\n for (auto& p : rects_key[1]) all_keys.push_back(p.first);\n sort(all_keys.begin(), all_keys.end());\n auto last = unique(all_keys.begin(), all_keys.end());\n all_keys.erase(last, all_keys.end());\n for (auto& key : all_keys) {\n int v = key.first * key.second;\n int c0 = rects_key[0].count(key) ? rects_key[0][key].size() : 0;\n int c1 = rects_key[1].count(key) ? rects_key[1][key].size() : 0;\n int sh = min(c0, c1);\n vector shid(sh);\n for (int k = 0; k < sh; k++) shid[k] = nid++;\n rrs[0] += (c1 - sh) * v;\n rrs[1] += (c0 - sh) * v;\n sinv += sh * (1.0 / v);\n for (int k = 0; k < c0; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rect& rd = rects_key[0][key][k];\n if (plane == 0) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dy = 0; dy < rd.wy; dy++) blockid[0][rd.sx + dx][rd.sy + dy][rd.sz] = bid;\n } else if (plane == 1) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dz = 0; dz < rd.wy; dz++) blockid[0][rd.sx + dx][rd.sy][rd.sz + dz] = bid;\n } else {\n for (int dy = 0; dy < rd.wx; dy++) for (int dz = 0; dz < rd.wy; dz++) blockid[0][rd.sx][rd.sy + dy][rd.sz + dz] = bid;\n }\n }\n for (int k = 0; k < c1; k++) {\n int bid = k < sh ? shid[k] : nid++;\n Rect& rd = rects_key[1][key][k];\n if (plane == 0) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dy = 0; dy < rd.wy; dy++) blockid[1][rd.sx + dx][rd.sy + dy][rd.sz] = bid;\n } else if (plane == 1) {\n for (int dx = 0; dx < rd.wx; dx++) for (int dz = 0; dz < rd.wy; dz++) blockid[1][rd.sx + dx][rd.sy][rd.sz + dz] = bid;\n } else {\n for (int dy = 0; dy < rd.wx; dy++) for (int dz = 0; dz < rd.wy; dz++) blockid[1][rd.sx][rd.sy + dy][rd.sz + dz] = bid;\n }\n }\n }\n double ev = rrs[0] + rrs[1] + sinv;\n if (ev < best_eval) {\n best_eval = ev;\n best_n = nid - 1;\n for (int p = 0; p < 2; p++) for (int x = 0; x < D; x++) for (int y = 0; y < D; y++) for (int z = 0; z < D; z++) best_block[p][x][y][z] = blockid[p][x][y][z];\n }\n };\n try_rect_plane(0);\n try_rect_plane(1);\n try_rect_plane(2);\n }\n cout << best_n << endl;\n for (int i = 0; i < 2; i++) {\n for (int pos = 0; pos < D * D * D; pos++) {\n int x = pos / (D * D);\n int rem = pos % (D * D);\n int y = rem / D;\n int z = rem % D;\n cout << best_block[i][x][y][z];\n if (pos < D * D * D - 1) cout << \" \";\n }\n cout << endl;\n }\n return 0;\n}","ahc020":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct UF {\n vector p, r;\n UF(int n) : p(n+1), r(n+1, 0) { iota(p.begin(), p.end(), 0); }\n int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }\n bool unite(int x, int y) {\n x = find(x); y = find(y);\n if (x == y) return false;\n if (r[x] < r[y]) swap(x, y);\n p[y] = x;\n if (r[x] == r[y]) r[x]++;\n return true;\n }\n};\n\nstruct Edge {\n int u, v, idx;\n ll w;\n};\n\nstruct TEdge {\n int to, eidx;\n ll w;\n};\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector X(N+1), Y(N+1);\n for (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n vector alledges(M);\n for (int j = 0; j < M; j++) {\n int u, v;\n ll w;\n cin >> u >> v >> w;\n alledges[j] = {u, v, j, w};\n }\n vector A(K+1), B(K+1);\n for (int k = 1; k <= K; k++) cin >> A[k] >> B[k];\n vector> dist2(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll dx = X[i] - A[k];\n ll dy = Y[i] - B[k];\n dist2[i][k] = dx * dx + dy * dy;\n }\n }\n vector> minP(N+1, vector(K+1, 0));\n for (int i = 1; i <= N; i++) {\n for (int k = 1; k <= K; k++) {\n ll d2 = dist2[i][k];\n if (d2 == 0) {\n minP[i][k] = 0;\n continue;\n }\n ll low = 0, high = 100000;\n while (low < high) {\n ll mid = (low + high) / 2;\n if (mid * mid >= d2) high = mid;\n else low = mid + 1;\n }\n minP[i][k] = low;\n }\n }\n UF uf(N);\n vector mst_edges = alledges;\n sort(mst_edges.begin(), mst_edges.end(), [](const Edge& e1, const Edge& e2) { return e1.w < e2.w; });\n vector> tree(N+1);\n for (auto& e : mst_edges) {\n if (uf.unite(e.u, e.v)) {\n tree[e.u].push_back({e.v, e.idx, e.w});\n tree[e.v].push_back({e.u, e.idx, e.w});\n }\n }\n vector> children(N+1);\n function build = [&](int u, int par) {\n for (auto& e : tree[u]) {\n if (e.to != par) {\n children[u].push_back(e);\n build(e.to, u);\n }\n }\n };\n build(1, -1);\n using pbb = pair;\n function&, const vector&)> dfs_conn = [&](int u, set& usedids, const vector& term) -> pbb {\n bool has = term[u];\n ll cst = 0;\n for (auto& e : children[u]) {\n auto [sc, sh] = dfs_conn(e.to, usedids, term);\n if (sh) {\n cst += e.w + sc;\n has = true;\n usedids.insert(e.eidx);\n } else {\n cst += sc;\n }\n }\n return {cst, has};\n };\n auto get_conn = [&](const vector& t, set& used) -> ll {\n auto [c, h] = dfs_conn(1, used, t);\n return c;\n };\n mt19937 rng(42);\n ll best_init_score = LLONG_MAX / 2;\n vector best_is_selected(N+1, false);\n for (int rr = 15; rr <= 55; rr += 2) {\n int R = rr;\n for (int trial = 0; trial < 7; trial++) {\n vector cx(R), cy(R);\n for (int c = 0; c < R; c++) {\n int randk = 1 + (rng() % K);\n cx[c] = A[randk];\n cy[c] = B[randk];\n }\n vector cluster_assign(K+1, 0);\n for (int it = 0; it < 40; it++) {\n vector sx(R, 0), sy(R, 0);\n vector cnt(R, 0);\n for (int k = 1; k <= K; k++) {\n ll bd = LLONG_MAX;\n int bc = 0;\n for (int c = 0; c < R; c++) {\n ll dx = A[k] - cx[c];\n ll dy = B[k] - cy[c];\n ll d = dx * dx + dy * dy;\n if (d < bd) {\n bd = d;\n bc = c;\n }\n }\n cluster_assign[k] = bc;\n sx[bc] += A[k];\n sy[bc] += B[k];\n cnt[bc]++;\n }\n for (int c = 0; c < R; c++) {\n if (cnt[c] > 0) {\n cx[c] = sx[c] / cnt[c];\n cy[c] = sy[c] / cnt[c];\n }\n }\n }\n vector is_selected(N+1, false);\n for (int c = 0; c < R; c++) {\n ll bd = LLONG_MAX;\n int bi = 1;\n for (int i = 1; i <= N; i++) {\n ll dx = X[i] - cx[c];\n ll dy = Y[i] - cy[c];\n ll d = dx * dx + dy * dy;\n if (d < bd) {\n bd = d;\n bi = i;\n }\n }\n is_selected[bi] = true;\n }\n is_selected[1] = true;\n vector> temp_res(N+1);\n vector temp_assign(K+1, 0);\n vector> temp_req(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 1; i <= N; i++) if (is_selected[i]) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n if (bp > 5000) {\n best = 1; bp = minP[1][k];\n for (int i = 2; i <= N; i++) if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n temp_assign[k] = best;\n temp_res[best].push_back(k);\n temp_req[best].insert(bp);\n }\n vector temp_P(N+1, 0);\n ll temp_sq = 0;\n for (int i = 1; i <= N; i++) if (!temp_req[i].empty()) {\n temp_P[i] = *temp_req[i].rbegin();\n temp_sq += (ll)temp_P[i]*temp_P[i];\n }\n vector temp_term(N+1,false);\n for(int i=1;i<=N;i++) temp_term[i] = (temp_P[i]>0) || i==1;\n set dum;\n ll temp_conn = get_conn(temp_term, dum);\n ll this_score = temp_sq + temp_conn;\n if (this_score < best_init_score) {\n best_init_score = this_score;\n best_is_selected = is_selected;\n }\n }\n }\n vector is_selected = best_is_selected;\n vector> res_list(N+1);\n vector assignment(K+1, 0);\n vector> reqs(N+1);\n for (int k = 1; k <= K; k++) {\n int best = 1, bp = minP[1][k];\n for (int i = 1; i <= N; i++) if (is_selected[i]) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n if (bp > 5000) {\n best = 1; bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n }\n assignment[k] = best;\n res_list[best].push_back(k);\n reqs[best].insert(bp);\n }\n vector curP(N+1, 0);\n ll sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n }\n }\n vector is_open(N+1, false);\n for (int i = 1; i <= N; i++) if (curP[i] > 0) is_open[i] = true;\n auto compute_curr_term = [&]() -> vector {\n vector t(N+1, false);\n for (int i = 1; i <= N; i++) t[i] = (curP[i] > 0) || (i == 1);\n return t;\n };\n vector curr_term = compute_curr_term();\n set dummy_used;\n ll cur_conn = get_conn(curr_term, dummy_used);\n ll current_total = sum_sq + cur_conn;\n auto re_voronoi = [&]() {\n vector opens;\n for (int i = 1; i <= N; i++) if (is_open[i]) opens.push_back(i);\n if (opens.empty()) {\n is_open[1] = true;\n opens.push_back(1);\n }\n bool changed = false;\n vector> new_reqs(N+1);\n vector> new_res_list(N+1);\n vector new_assign(K+1, 0);\n for (int k = 1; k <= K; k++) {\n int best = opens[0], bp = minP[opens[0]][k];\n for (int j : opens) {\n if (minP[j][k] < bp) {\n bp = minP[j][k];\n best = j;\n }\n }\n if (bp > 5000) {\n best = 1; bp = minP[1][k];\n for (int i = 2; i <= N; i++) {\n if (minP[i][k] < bp) {\n bp = minP[i][k];\n best = i;\n }\n }\n }\n new_assign[k] = best;\n new_res_list[best].push_back(k);\n new_reqs[best].insert(bp);\n if (assignment[k] != best) changed = true;\n }\n if (!changed) return;\n reqs = new_reqs;\n res_list = new_res_list;\n assignment = new_assign;\n sum_sq = 0;\n for (int i = 1; i <= N; i++) {\n if (!reqs[i].empty()) {\n curP[i] = *reqs[i].rbegin();\n sum_sq += (ll)curP[i] * curP[i];\n } else curP[i] = 0;\n }\n for (int i = 1; i <= N; i++) is_open[i] = !reqs[i].empty();\n curr_term = compute_curr_term();\n set dum;\n cur_conn = get_conn(curr_term, dum);\n current_total = sum_sq + cur_conn;\n };\n const int MAX_ITER = 70;\n for (int iter = 0; iter < MAX_ITER; iter++) {\n bool improved = false;\n for (int k = 1; k <= K; k++) {\n int curr = assignment[k];\n if (!is_open[curr]) continue;\n int reqc = minP[curr][k];\n for (int j = 1; j <= N; j++) if (is_open[j] && j != curr && minP[j][k] <= 5000) {\n int reqn = minP[j][k];\n auto it = reqs[curr].find(reqc);\n if (it != reqs[curr].end()) reqs[curr].erase(it);\n ll tpc = reqs[curr].empty() ? 0LL : *reqs[curr].rbegin();\n reqs[j].insert(reqn);\n ll tpj = *reqs[j].rbegin();\n ll dsq = tpc * tpc + tpj * tpj - (ll)curP[curr] * curP[curr] - (ll)curP[j] * curP[j];\n bool will_close = (curP[curr] > 0 && (int)tpc == 0);\n ll dcon = 0;\n if (will_close) {\n vector np = curP;\n np[curr] = tpc;\n np[j] = tpj;\n vector tterm(N+1, false);\n for (int ii = 1; ii <= N; ii++) tterm[ii] = (np[ii] > 0) || (ii == 1);\n set dum;\n ll newc = get_conn(tterm, dum);\n dcon = newc - cur_conn;\n }\n reqs[j].erase(reqs[j].find(reqn));\n reqs[curr].insert(reqc);\n if (dsq + dcon < 0) {\n reqs[curr].erase(reqs[curr].find(reqc));\n reqs[j].insert(reqn);\n auto& lst = res_list[curr];\n for (size_t pos = 0; pos < lst.size(); pos++) if (lst[pos] == k) {\n swap(lst[pos], lst.back());\n lst.pop_back();\n break;\n }\n res_list[j].push_back(k);\n assignment[k] = j;\n curP[curr] = (int)tpc;\n curP[j] = (int)tpj;\n sum_sq += dsq;\n if (will_close) {\n is_open[curr] = false;\n curr_term[curr] = (tpc > 0) || curr == 1;\n curr_term[j] = true;\n cur_conn += dcon;\n }\n current_total += dsq + dcon;\n improved = true;\n break;\n }\n }\n if (improved) break;\n }\n if (!improved) {\n for (int i = 1; i <= N && !improved; i++) if (is_open[i]) {\n vector new_add(N+1, 0);\n bool can = true;\n vector> move_info;\n for (auto kk : res_list[i]) {\n int altj = -1, altp = INT_MAX / 2;\n for (int jj = 1; jj <= N; jj++) if (is_open[jj] && jj != i) {\n if (minP[jj][kk] < altp && minP[jj][kk] <= 5000) {\n altp = minP[jj][kk];\n altj = jj;\n }\n }\n if (altp > 5000) {\n can = false;\n break;\n }\n if (altj != -1) {\n new_add[altj] = max(new_add[altj], altp);\n move_info.emplace_back(kk, altj);\n }\n }\n if (!can) continue;\n ll dsq = -(ll)curP[i] * curP[i];\n vector new_p(N+1);\n for (int ii = 1; ii <= N; ii++) new_p[ii] = curP[ii];\n new_p[i] = 0;\n for (int jj = 1; jj <= N; jj++) if (new_add[jj] > 0) {\n int oldpj = curP[jj];\n new_p[jj] = max(oldpj, new_add[jj]);\n dsq += (ll)new_p[jj] * new_p[jj] - (ll)oldpj * oldpj;\n }\n vector tterm(N+1, false);\n for (int ii = 1; ii <= N; ii++) tterm[ii] = (new_p[ii] > 0) || (ii == 1);\n set dum;\n ll new_conn_val = get_conn(tterm, dum);\n ll dcon = new_conn_val - cur_conn;\n if (dsq + dcon < 0) {\n for (auto [kk, altj] : move_info) {\n if (altj == -1) continue;\n reqs[i].erase(reqs[i].find(minP[i][kk]));\n reqs[altj].insert(minP[altj][kk]);\n auto& l = res_list[i];\n for (size_t p = 0; p < l.size(); p++) if (l[p] == kk) {\n swap(l[p], l.back());\n l.pop_back();\n break;\n }\n res_list[altj].push_back(kk);\n assignment[kk] = altj;\n }\n reqs[i].clear();\n res_list[i].clear();\n for (int jj = 1; jj <= N; jj++) {\n int np = reqs[jj].empty() ? 0 : *reqs[jj].rbegin();\n curP[jj] = np;\n }\n sum_sq += dsq;\n is_open[i] = false;\n cur_conn = new_conn_val;\n curr_term = compute_curr_term();\n current_total += dsq + dcon;\n improved = true;\n }\n }\n }\n if (iter % 5 == 0) re_voronoi();\n if (!improved) break;\n }\n re_voronoi();\n vector final_term = curr_term;\n set final_used;\n auto fc = get_conn(final_term, final_used);\n vector Bs(M, 0);\n for (int ei : final_used) if (ei >= 0 && ei < M) Bs[ei] = 1;\n for (int i = 1; i <= N; i++) {\n if (curP[i] > 5000) curP[i] = 5000;\n cout << curP[i];\n if (i < N) cout << \" \";\n else cout << \"\\n\";\n }\n for (int j = 0; j < M; j++) {\n cout << Bs[j];\n if (j < M - 1) cout << \" \";\n else cout << \"\\n\";\n }\n return 0;\n}","ahc021":"#include \nusing namespace std;\nusing P = pair;\n\nstruct Sw {\n int x1, y1, x2, y2;\n};\n\nvector run_simulation(const vector>& init_grid, const vector

& init_pos, mt19937& rng, bool use_random, int variant = 0) {\n int N = 30;\n int total = 465;\n vector> grid = init_grid;\n vector

curr_pos = init_pos;\n vector> is_fixed(N, vector(N, false));\n vector ops;\n auto get_parents = [&](P p) -> vector

{\n auto [x, y] = p;\n vector

res;\n if (x > 0) {\n if (y <= x - 1) res.emplace_back(x - 1, y);\n if (y - 1 >= 0) {\n int py = y - 1;\n if (py <= x - 1) res.emplace_back(x - 1, py);\n }\n }\n return res;\n };\n auto get_neighbors = [&](P p) -> vector

{\n int x = p.first, y = p.second;\n vector

res;\n vector> deltas = {{-1, -1}, {-1, 0}, {0, -1}, {0, 1}, {1, 0}, {1, 1}};\n for (auto [dx, dy] : deltas) {\n int nx = x + dx, ny = y + dy;\n if (nx >= 0 && nx < N && ny >= 0 && ny <= nx) res.emplace_back(nx, ny);\n }\n return res;\n };\n bool success = true;\n for (int k = 0; k < total && success; k++) {\n vector

avail;\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n if (is_fixed[x][y]) continue;\n auto pars = get_parents({x, y});\n bool can = true;\n for (auto pp : pars) {\n if (!is_fixed[pp.first][pp.second]) {\n can = false;\n break;\n }\n }\n if (can) avail.emplace_back(x, y);\n }\n }\n P start = curr_pos[k];\n vector> dist(N, vector(N, -1));\n vector> par(N, vector

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

q;\n if (start.first >= 0 && start.first < N && start.second >= 0 && start.second <= start.first && !is_fixed[start.first][start.second]) {\n dist[start.first][start.second] = 0;\n q.push(start);\n }\n while (!q.empty()) {\n P cur = q.front(); q.pop();\n int cd = dist[cur.first][cur.second];\n auto neighs = get_neighbors(cur);\n for (auto nx : neighs) {\n if (nx.first < N && nx.second >= 0 && nx.second <= nx.first && !is_fixed[nx.first][nx.second] && dist[nx.first][nx.second] == -1) {\n dist[nx.first][nx.second] = cd + 1;\n par[nx.first][nx.second] = cur;\n q.push(nx);\n }\n }\n }\n vector> cands;\n for (auto cand : avail) {\n if (cand.first < N && cand.second <= cand.first) {\n int dx = dist[cand.first][cand.second];\n if (dx != -1) {\n int tie1 = 0;\n if (variant == 1) tie1 = - (cand.first * 31 + cand.second); // prefer large row lex\n else if (variant == 2) tie1 = grid[cand.first][cand.second]; // prefer small grid\n else if (variant == 3) tie1 = -grid[cand.first][cand.second]; // prefer large grid\n else tie1 = (cand.first * 31 + cand.second); // prefer small lex\n cands.emplace_back(dx, tie1, cand);\n }\n }\n }\n if (cands.empty()) {\n success = false;\n break;\n }\n sort(cands.begin(), cands.end());\n int min_d_val = get<0>(cands[0]);\n vector

min_targets;\n for (auto& tp : cands) {\n if (get<0>(tp) == min_d_val) min_targets.push_back(get<2>(tp));\n }\n P target = min_targets[0];\n if (use_random && min_targets.size() > 1) {\n uniform_int_distribution d(0, (int)min_targets.size() - 1);\n target = min_targets[d(rng)];\n }\n vector

path;\n P curp = target;\n while (true) {\n path.push_back(curp);\n if (dist[curp.first][curp.second] == 0) break;\n curp = par[curp.first][curp.second];\n if (curp.first == -1) break;\n }\n reverse(path.begin(), path.end());\n for (size_t i = 0; i + 1 < path.size(); ++i) {\n P p1 = path[i];\n P p2 = path[i + 1];\n int v1 = grid[p1.first][p1.second];\n int v2 = grid[p2.first][p2.second];\n swap(grid[p1.first][p1.second], grid[p2.first][p2.second]);\n curr_pos[v1] = p2;\n curr_pos[v2] = p1;\n ops.push_back({p1.first, p1.second, p2.first, p2.second});\n }\n is_fixed[target.first][target.second] = true;\n }\n if (!success) return {};\n return ops;\n}\n\nint main() {\n int N = 30;\n vector> init_grid(N);\n for (int x = 0; x < N; x++) {\n init_grid[x].resize(x + 1);\n for (int y = 0; y <= x; y++) {\n cin >> init_grid[x][y];\n }\n }\n int total = N * (N + 1) / 2;\n vector

init_pos(total);\n for (int x = 0; x < N; x++) {\n for (int y = 0; y <= x; y++) {\n int val = init_grid[x][y];\n init_pos[val] = {x, y};\n }\n }\n mt19937 rng(42);\n long long best_K = LLONG_MAX;\n vector best_ops;\n int num_trials = 100;\n // rand trials\n for (int t = 0; t < num_trials; t++) {\n vector ops = run_simulation(init_grid, init_pos, rng, true, 0);\n if (!ops.empty() && (long long)ops.size() < best_K) {\n best_K = ops.size();\n best_ops = ops;\n }\n }\n // deterministic variants\n for (int v = 0; v < 4; v++) {\n vector ops = run_simulation(init_grid, init_pos, rng, false, v);\n if (!ops.empty() && (long long)ops.size() < best_K) {\n best_K = ops.size();\n best_ops = ops;\n }\n }\n if (best_K == LLONG_MAX) {\n vector ops = run_simulation(init_grid, init_pos, rng, false, 0);\n if (!ops.empty()) {\n best_K = ops.size();\n best_ops = ops;\n } else {\n cout << 0 << endl;\n return 0;\n }\n }\n cout << best_K << endl;\n for (auto& s : best_ops) {\n cout << s.x1 << \" \" << s.y1 << \" \" << s.x2 << \" \" << s.y2 << endl;\n }\n return 0;\n}","toyota2023summer-final":"#include \nusing namespace std;\n\nint main() {\n int D, N;\n cin >> D >> N;\n bool is_obst[9][9] = {};\n int cont[9][9];\n memset(cont, -1, sizeof(cont));\n for (int k = 0; k < N; k++) {\n int ri, rj;\n cin >> ri >> rj;\n is_obst[ri][rj] = true;\n cont[ri][rj] = -2;\n }\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n auto is_valid = [&](int x, int y) { return x >= 0 && x < 9 && y >= 0 && y < 9; };\n int dist[9][9];\n int visit_ord[9][9];\n memset(dist, -1, sizeof(dist));\n memset(visit_ord, -1, sizeof(visit_ord));\n {\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n dist[0][4] = 0;\n visit_ord[0][4] = 0;\n int ord = 1;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n vis[nx][ny] = true;\n dist[nx][ny] = dist[x][y] + 1;\n visit_ord[nx][ny] = ord++;\n q.push({nx, ny});\n }\n }\n }\n int M = 0;\n for (int i = 0; i < 9; i++)\n for (int j = 0; j < 9; j++)\n if (!is_obst[i][j] && !(i == 0 && j == 4)) M++;\n int placed_count = 0;\n set remain;\n for (int i = 0; i < M; i++) remain.insert(i);\n auto get_reach = [&]() -> vector> {\n vector> res;\n bool vis[9][9] = {};\n queue> q;\n q.push({0, 4});\n vis[0][4] = true;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (!is_valid(nx, ny) || is_obst[nx][ny] || vis[nx][ny]) continue;\n if (cont[nx][ny] >= 0) continue;\n vis[nx][ny] = true;\n q.push({nx, ny});\n if ((nx || ny != 4) && cont[nx][ny] == -1) res.push_back({nx, ny});\n }\n }\n return res;\n };\n auto is_safe_pos = [&](int px, int py, int curr_rem) -> bool {\n cont[px][py] = 100000;\n auto nr = get_reach();\n cont[px][py] = -1;\n return nr.size() == (size_t)(curr_rem - 1);\n };\n for (int step = 0; step < M; step++) {\n int t;\n cin >> t;\n vector> reach = get_reach();\n int curr_rem = M - placed_count;\n vector> cands;\n for (auto p : reach) {\n if (is_safe_pos(p.first, p.second, curr_rem)) {\n cands.push_back(p);\n }\n }\n if (cands.empty()) {\n cands = reach;\n }\n auto cmp = [&](const pair& a, const pair& b) {\n if (dist[a.first][a.second] != dist[b.first][b.second])\n return dist[a.first][a.second] < dist[b.first][b.second];\n return visit_ord[a.first][a.second] < visit_ord[b.first][b.second];\n };\n sort(cands.begin(), cands.end(), cmp);\n int j = 0;\n for (int rid : remain) {\n if (rid == t) break;\n j++;\n }\n pair place_pos;\n if (!cands.empty() && j < (int)cands.size()) {\n place_pos = cands[j];\n } else if (!cands.empty()) {\n place_pos = cands.back();\n } else {\n place_pos = {0, 0}; // fallback error\n }\n cout << place_pos.first << \" \" << place_pos.second << endl;\n cont[place_pos.first][place_pos.second] = t;\n placed_count++;\n remain.erase(t);\n }\n vector> rem_order;\n bool cleared[9][9] = {};\n cleared[0][4] = true;\n for (int step = 0; step < M; step++) {\n vector> acc;\n for (int i = 0; i < 9; i++) {\n for (int j = 0; j < 9; j++) {\n if (cont[i][j] < 0) continue;\n if (cleared[i][j]) continue;\n bool can = false;\n for (int d = 0; d < 4; d++) {\n int nx = i + dx[d], ny = j + dy[d];\n if (is_valid(nx, ny) && !is_obst[nx][ny] && cleared[nx][ny]) {\n can = true;\n break;\n }\n }\n if (can) acc.emplace_back(i, j);\n }\n }\n if (acc.empty()) break;\n int minid = INT_MAX;\n pair chosen = {-1, -1};\n for (auto p : acc) {\n int id = cont[p.first][p.second];\n if (id < minid) {\n minid = id;\n chosen = p;\n }\n }\n rem_order.push_back(chosen);\n cleared[chosen.first][chosen.second] = true;\n cont[chosen.first][chosen.second] = -1;\n }\n for (auto p : rem_order) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}","ahc024":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n vector> grid(n, vector(n));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n cin >> grid[i][j];\n }\n }\n vector>>> witnesses(\n m + 1, vector>>(m + 1));\n bitset<101> has_adj[101];\n int dx[4] = {-1, 0, 1, 0};\n int dy[4] = {0, 1, 0, -1};\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = grid[i][j];\n bool is_bound = (i == 0 || i == n - 1 || j == 0 || j == n - 1);\n if (is_bound) {\n witnesses[c][0].push_back({i, j});\n has_adj[c][0] = 1;\n has_adj[0][c] = 1;\n }\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n) {\n int nc = grid[ni][nj];\n if (c != nc) {\n witnesses[c][nc].push_back({i, j});\n has_adj[c][nc] = 1;\n has_adj[nc][c] = 1;\n }\n }\n }\n }\n }\n vector> cent(m + 1, vector(2, 0.0));\n for (int c = 1; c <= m; c++) {\n long long si = 0, sj = 0, cnt = 0;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n si += i;\n sj += j;\n cnt++;\n }\n }\n }\n if (cnt > 0) {\n cent[c][0] = si * 1.0 / cnt;\n cent[c][1] = sj * 1.0 / cnt;\n }\n }\n vector>> term_set(m + 1);\n for (int c = 1; c <= m; c++) {\n if (has_adj[c][0] && !witnesses[c][0].empty()) {\n double mind = 1e9;\n pair best = witnesses[c][0][0];\n for (auto p : witnesses[c][0]) {\n double dd = abs(p.first - cent[c][0]) + abs(p.second - cent[c][1]);\n if (dd < mind) {\n mind = dd;\n best = p;\n }\n }\n term_set[c].insert(best);\n }\n }\n for (int c = 1; c <= m; c++) {\n for (int d = c + 1; d <= m; d++) {\n if (has_adj[c][d]) {\n bool picked = false;\n if (!witnesses[c][d].empty()) {\n double mind = 1e9;\n pair best = witnesses[c][d][0];\n for (auto p : witnesses[c][d]) {\n double dd = abs(p.first - cent[c][0]) + abs(p.second - cent[c][1]);\n if (dd < mind) {\n mind = dd;\n best = p;\n }\n }\n int ci = best.first, cj = best.second;\n for (int dir = 0; dir < 4; dir++) {\n int ni = ci + dx[dir], nj = cj + dy[dir];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == d) {\n term_set[c].insert(best);\n term_set[d].insert({ni, nj});\n picked = true;\n break;\n }\n }\n }\n if (!picked && !witnesses[d][c].empty()) {\n double mind = 1e9;\n pair best = witnesses[d][c][0];\n for (auto p : witnesses[d][c]) {\n double dd = abs(p.first - cent[d][0]) + abs(p.second - cent[d][1]);\n if (dd < mind) {\n mind = dd;\n best = p;\n }\n }\n int di = best.first, dj = best.second;\n for (int dir = 0; dir < 4; dir++) {\n int ni = di + dx[dir], nj = dj + dy[dir];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == c) {\n term_set[d].insert(best);\n term_set[c].insert({ni, nj});\n picked = true;\n break;\n }\n }\n }\n }\n }\n }\n for (int c = 1; c <= m; c++) {\n if (term_set[c].empty()) {\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (grid[i][j] == c) {\n term_set[c].insert({i, j});\n break;\n }\n }\n if (!term_set[c].empty()) break;\n }\n }\n }\n vector>> terminals(m + 1);\n for (int c = 1; c <= m; c++) {\n for (auto p : term_set[c]) terminals[c].push_back(p);\n }\n vector> iskept(n, vector(n, false));\n for (int c = 1; c <= m; c++) {\n if (terminals[c].empty()) continue;\n auto root = terminals[c][0];\n int sx = root.first, sy = root.second;\n vector> dist(n, vector(n, -1));\n vector>> parent(n, vector>(n, {-1, -1}));\n queue> qq;\n qq.push({sx, sy});\n dist[sx][sy] = 0;\n while (!qq.empty()) {\n auto [x, y] = qq.front();\n qq.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || dist[nx][ny] != -1 || grid[nx][ny] != c) continue;\n dist[nx][ny] = dist[x][y] + 1;\n parent[nx][ny] = {x, y};\n qq.push({nx, ny});\n }\n }\n set> sk;\n for (auto &t : terminals[c]) {\n int cx = t.first, cy = t.second;\n while (true) {\n if (cx == -1 || dist[cx][cy] == -1) break;\n sk.insert({cx, cy});\n if (cx == sx && cy == sy) break;\n auto [px, py] = parent[cx][cy];\n cx = px;\n cy = py;\n }\n }\n for (auto p : sk) {\n iskept[p.first][p.second] = true;\n }\n }\n auto do_fix = [&]( ) -> bool {\n vector> current(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) current[i][j] = grid[i][j];\n }\n }\n vector> to_add;\n bool changed = false;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n int c = current[i][j];\n if (c == 0) continue;\n if (has_adj[c][0]) continue;\n for (int d = 0; d < 4; d++) {\n int ni = i + dx[d], nj = j + dy[d];\n if (ni >= 0 && ni < n && nj >= 0 && nj < n && current[ni][nj] == 0) {\n to_add.push_back({ni, nj});\n changed = true;\n }\n }\n }\n }\n vector> vis(n, vector(n, false));\n queue> q0;\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) && current[i][j] == 0) {\n q0.push({i, j});\n vis[i][j] = true;\n }\n }\n }\n while (!q0.empty()) {\n auto [x, y] = q0.front();\n q0.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || vis[nx][ny] || current[nx][ny] != 0) continue;\n vis[nx][ny] = true;\n q0.push({nx, ny});\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (current[i][j] == 0 && !vis[i][j]) {\n to_add.push_back({i, j});\n changed = true;\n }\n }\n }\n for (auto [i, j] : to_add) {\n if (!iskept[i][j]) {\n iskept[i][j] = true;\n }\n }\n return changed;\n };\n auto reconnect = [&]( ) {\n for (int c = 1; c <= m; c++) {\n vector> kept_c;\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (iskept[i][j] && grid[i][j] == c) kept_c.push_back({i, j});\n if (kept_c.empty()) continue;\n vector> comp(n, vector(n, -1));\n int numcom = 0;\n for (auto [x, y] : kept_c) {\n if (comp[x][y] != -1) continue;\n numcom++;\n queue> q;\n q.push({x, y});\n comp[x][y] = numcom;\n while (!q.empty()) {\n auto [cx, cy] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = cx + dx[d], ny = cy + dy[d];\n if (nx < 0 || nx >= n || ny < 0 || ny >= n || comp[nx][ny] != -1 || !iskept[nx][ny] || grid[nx][ny] != c) continue;\n comp[nx][ny] = numcom;\n q.push({nx, ny});\n }\n }\n }\n if (numcom <= 1) continue;\n vector> reps(numcom + 1, {-1, -1});\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++)\n if (comp[i][j] != -1 && reps[comp[i][j]].first == -1) reps[comp[i][j]] = {i, j};\n pair rootp = reps[1];\n int sx = rootp.first, sy = rootp.second;\n vector> dist(n, vector(n, -1));\n vector>> par(n, vector>(n, {-1, -1}));\n queue> q;\n q.push({sx, sy});\n dist[sx][sy] = 0;\n while (!q.empty()) {\n auto [x, y] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int nx = x + dx[d], ny = y + dy[d];\n if (nx >= 0 && nx < n && ny >= 0 && ny < n && grid[nx][ny] == c && dist[nx][ny] == -1) {\n dist[nx][ny] = dist[x][y] + 1;\n par[nx][ny] = {x, y};\n q.push({nx, ny});\n }\n }\n }\n set> addsk;\n for (int com = 2; com <= numcom; com++) {\n auto [cx, cy] = reps[com];\n int curx = cx, cury = cy;\n while (curx != -1) {\n if (dist[curx][cury] == -1) break;\n addsk.insert({curx, cury});\n if (curx == sx && cury == sy) break;\n auto p = par[curx][cury];\n curx = p.first;\n cury = p.second;\n }\n }\n for (auto p : addsk) {\n iskept[p.first][p.second] = true;\n }\n }\n };\n bool changed = true;\n int maxb = 30;\n for (int bigl = 0; bigl < maxb && changed; bigl++) {\n reconnect();\n changed = do_fix();\n }\n vector> final(n, vector(n, 0));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (iskept[i][j]) final[i][j] = grid[i][j];\n }\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j > 0) cout << \" \";\n cout << final[i][j];\n }\n cout << endl;\n }\n return 0;\n}","ahc025":"#include \nusing namespace std;\n\nint main() {\n srand(time(NULL));\n int N, D, Q;\n cin >> N >> D >> Q;\n vector> adj(N);\n vector outdeg(N, 0);\n bitset<128> dcomp[100];\n auto compute_ranks = [&]( ) -> vector {\n vector memo(N, -1);\n function dfs = [&](int u) -> int {\n if (memo[u] != -1) return memo[u];\n int mx = 0;\n for (int v : adj[u]) {\n mx = max(mx, dfs(v) + 1);\n }\n return memo[u] = mx;\n };\n for (int i = 0; i < N; i++) {\n dfs(i);\n }\n return memo;\n };\n auto compute_dom = [&]( ) -> vector {\n vector> rch(N);\n vector compd(N, false);\n auto getr = [&](auto&& self, int u) -> const bitset<128>& {\n if (compd[u]) return rch[u];\n compd[u] = true;\n rch[u].reset();\n for (int v : adj[u]) {\n rch[u].set(v);\n rch[u] |= self(self, v);\n }\n return rch[u];\n };\n for (int i = 0; i < N; i++) {\n getr(getr, i);\n }\n vector dc(N);\n for (int i = 0; i < N; i++) dc[i] = rch[i].count();\n return dc;\n };\n for (int q = 0; q < Q; q++) {\n vector ranks = compute_ranks();\n vector dom = compute_dom();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (dom[x] != dom[y]) return dom[x] > dom[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n bool found = false;\n pair to_comp = {-1, -1};\n for (int dist = 1; dist < N && !found; dist++) {\n for (int p = 0; p + dist < N && !found; p++) {\n int x = items[p];\n int y = items[p + dist];\n if (!dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n }\n }\n }\n if (!found) {\n for (int tries = 0; tries < 10000; tries++) {\n int x = rand() % N;\n int y = rand() % N;\n if (x != y && !dcomp[x][y]) {\n to_comp = {x, y};\n found = true;\n break;\n }\n }\n if (!found) to_comp = {0, 1};\n }\n int a = to_comp.first;\n int b = to_comp.second;\n cout << 1 << \" \" << 1 << \" \" << a << \" \" << b << endl;\n cout.flush();\n char res;\n cin >> res;\n dcomp[a].set(b);\n dcomp[b].set(a);\n if (res == '>') {\n adj[a].push_back(b);\n outdeg[a]++;\n } else if (res == '<') {\n adj[b].push_back(a);\n outdeg[b]++;\n }\n }\n vector ranks = compute_ranks();\n vector dom = compute_dom();\n vector items(N);\n iota(items.begin(), items.end(), 0);\n sort(items.begin(), items.end(), [&](int x, int y) {\n if (ranks[x] != ranks[y]) return ranks[x] > ranks[y];\n if (dom[x] != dom[y]) return dom[x] > dom[y];\n if (outdeg[x] != outdeg[y]) return outdeg[x] > outdeg[y];\n return x < y;\n });\n vector group(N);\n for (int i = 0; i < N; i++) {\n int row = i / D;\n int col = i % D;\n if (row % 2 == 0) {\n group[items[i]] = col;\n } else {\n group[items[i]] = D - 1 - col;\n }\n }\n for (int i = 0; i < N; i++) {\n cout << group[i];\n if (i < N - 1) cout << \" \";\n }\n cout << endl;\n cout.flush();\n return 0;\n}","ahc026":"#include \nusing namespace std;\n\nint main() {\n int n, m;\n cin >> n >> m;\n int h = n / m;\n vector> st(m);\n vector stack_of(n + 1, -1);\n vector pos_in_st(n + 1, -1);\n for (int i = 0; i < m; i++) {\n st[i].resize(h);\n for (int j = 0; j < h; j++) {\n cin >> st[i][j];\n stack_of[st[i][j]] = i;\n pos_in_st[st[i][j]] = j;\n }\n }\n vector> ops;\n for (int v = 1; v <= n; v++) {\n while (true) {\n int s = stack_of[v];\n if (s == -1) {\n break;\n }\n int p = pos_in_st[v];\n if (p == (int)st[s].size() - 1) break;\n vector stack_min(m, n + 1);\n for (int i = 0; i < m; i++) {\n for (int b : st[i]) {\n if (b < stack_min[i]) stack_min[i] = b;\n }\n }\n int best_minv = -1;\n int best_sz = INT_MAX;\n int dest = -1;\n for (int i = 0; i < m; i++)\n if (i != s) {\n int cmin = stack_min[i];\n int csz = st[i].size();\n bool up = false;\n if (cmin > best_minv) up = true;\n else if (cmin == best_minv) {\n if (csz < best_sz) up = true;\n else if (csz == best_sz && (dest == -1 || i < dest)) up = true;\n }\n if (up) {\n best_minv = cmin;\n best_sz = csz;\n dest = i;\n }\n }\n if (dest == -1) {\n // fallback: any stack except s\n for (int i = 0; i < m; i++)\n if (i != s) {\n dest = i;\n break;\n }\n }\n int lift_v = st[s][p + 1];\n ops.emplace_back(lift_v, dest);\n vector to_move;\n for (size_t j = p + 1; j < st[s].size(); ++j) {\n to_move.push_back(st[s][j]);\n }\n st[s].resize(p + 1);\n size_t old_dest_sz = st[dest].size();\n st[dest].insert(st[dest].end(), to_move.begin(), to_move.end());\n for (size_t j = 0; j < to_move.size(); ++j) {\n int b = to_move[j];\n stack_of[b] = dest;\n pos_in_st[b] = old_dest_sz + j;\n }\n }\n int s = stack_of[v];\n ops.emplace_back(v, 0);\n st[s].pop_back();\n stack_of[v] = -1;\n pos_in_st[v] = -1;\n }\n for (auto [vv, ii] : ops) {\n cout << vv << \" \" << ii << endl;\n }\n}","ahc027":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector h(N-1);\n for(int i = 0; i < N-1; i++) cin >> h[i];\n vector v(N);\n for(int i = 0; i < N; i++) cin >> v[i];\n vector> d(N, vector(N));\n for(int i = 0; i < N; i++) {\n for(int j = 0; j < N; j++) {\n cin >> d[i][j];\n }\n }\n \n vector> sd(N, vector(N));\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n sd[i][j] = sqrt(d[i][j]);\n }\n \n int di[4] = {-1, 0, 1, 0};\n int dj[4] = {0, 1, 0, -1};\n string DIR = \"URDL\";\n \n auto can_move = [&](int i, int j, int ni, int nj, const auto& hh, const auto& vv) -> bool {\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) return false;\n int ddi = ni - i;\n int ddj = nj - j;\n if (ddi == -1 && ddj == 0) return hh[ni][j] == '0';\n if (ddi == 1 && ddj == 0) return hh[i][j] == '0';\n if (ddi == 0 && ddj == 1) return vv[i][j] == '0';\n if (ddi == 0 && ddj == -1) return vv[i][nj] == '0';\n return false;\n };\n \n // Base covering DFS\n vector> vis_mark(N, vector(N, false));\n string route = \"\";\n function dfs = [&](int i, int j) {\n vis_mark[i][j] = true;\n for(int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir];\n int nj = j + dj[dir];\n if (ni >= 0 && ni < N && nj >= 0 && nj < N && !vis_mark[ni][nj] && can_move(i, j, ni, nj, h, v)) {\n route += DIR[dir];\n dfs(ni, nj);\n route += DIR[(dir + 2) % 4];\n }\n }\n };\n dfs(0, 0);\n \n // Simulate base\n vector> visits(N, vector(N, 0));\n vector> positions;\n positions.emplace_back(0, 0);\n int ci = 0, cj = 0;\n for (char c : route) {\n int dir = -1;\n if (c == 'U') dir = 0;\n else if (c == 'R') dir = 1;\n else if (c == 'D') dir = 2;\n else if (c == 'L') dir = 3;\n if (dir == -1) continue;\n int ni = ci + di[dir], nj = cj + dj[dir];\n positions.emplace_back(ni, nj);\n visits[ni][nj]++;\n ci = ni;\n cj = nj;\n }\n int Ltotal = positions.size() - 1;\n int cur_i = ci, cur_j = cj;\n \n // Add more visits\n int L_target = 99920;\n const int MAX_L = 100000;\n const int RESERVE = 100;\n while (Ltotal < L_target) {\n // Find best target != current\n double max_p = -1.0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i == cur_i && j == cur_j) continue;\n double p = sd[i][j] / (visits[i][j] + 1.0);\n if (p > max_p) {\n max_p = p;\n ti = i;\n tj = j;\n }\n }\n }\n if (ti == -1) {\n // only current, do excursion\n bool ex = false;\n for (int dir = 0; dir < 4; dir++) {\n int ni = cur_i + di[dir], nj = cur_j + dj[dir];\n if (can_move(cur_i, cur_j, ni, nj, h, v)) {\n ti = ni;\n tj = nj;\n ex = true;\n break;\n }\n }\n if (!ex) break;\n }\n \n // BFS from cur to ti,tj\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == ti && cur_j == tj);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == ti && nj == tj) {\n found = true;\n break;\n }\n }\n }\n if (!found) break;\n \n // reconstruct\n vector> path_to;\n pair curp = {ti, tj};\n while (curp != make_pair(cur_i, cur_j)) {\n path_to.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_to.begin(), path_to.end());\n \n if (Ltotal + (int)path_to.size() + RESERVE > MAX_L) break;\n \n for (auto [x, y] : path_to) {\n positions.emplace_back(x, y);\n visits[x][y]++;\n cur_i = x;\n cur_j = y;\n Ltotal++;\n }\n }\n \n // Final return to (0,0)\n {\n int ti = 0, tj = 0;\n vector> vis(N, vector(N, false));\n vector>> parent(N, vector>(N, {-1, -1}));\n queue> q;\n q.emplace(cur_i, cur_j);\n vis[cur_i][cur_j] = true;\n bool found = (cur_i == 0 && cur_j == 0);\n while (!q.empty() && !found) {\n auto [i, j] = q.front(); q.pop();\n for (int dir = 0; dir < 4; dir++) {\n int ni = i + di[dir], nj = j + dj[dir];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N || vis[ni][nj]) continue;\n if (!can_move(i, j, ni, nj, h, v)) continue;\n vis[ni][nj] = true;\n parent[ni][nj] = {i, j};\n q.emplace(ni, nj);\n if (ni == 0 && nj == 0) {\n found = true;\n break;\n }\n }\n }\n if (found) {\n vector> path_back;\n pair curp = {0, 0};\n while (curp != make_pair(cur_i, cur_j)) {\n path_back.push_back(curp);\n curp = parent[curp.first][curp.second];\n }\n reverse(path_back.begin(), path_back.end());\n if (Ltotal + (int)path_back.size() <= MAX_L) {\n for (auto p : path_back) {\n positions.push_back(p);\n visits[p.first][p.second]++;\n cur_i = p.first;\n cur_j = p.second;\n }\n }\n }\n }\n \n // Build ans\n string ans = \"\";\n for (size_t t = 1; t < positions.size(); t++) {\n int i1 = positions[t - 1].first, j1 = positions[t - 1].second;\n int i2 = positions[t].first, j2 = positions[t].second;\n if (i2 == i1 - 1) ans += 'U';\n else if (i2 == i1 + 1) ans += 'D';\n else if (j2 == j1 + 1) ans += 'R';\n else if (j2 == j1 - 1) ans += 'L';\n }\n \n if (ans.size() > MAX_L) ans = ans.substr(0, MAX_L);\n cout << ans << endl;\n return 0;\n}","ahc028":"#include \nusing namespace std;\ntypedef long long ll;\nconst ll INF = 1LL << 60;\n\npair>> solve_for_S(const string& S, int si, int sj, const vector>>& posis) {\n int LL = S.length();\n if(LL == 0) return {INF, {}};\n vector>> cnd(LL);\n for(int k = 0; k < LL; k++) {\n cnd[k] = posis[S[k] - 'A'];\n if(cnd[k].empty()) return {INF, {}};\n }\n vector> dpp(LL);\n vector> prvv(LL);\n int n0 = cnd[0].size();\n dpp[0].resize(n0);\n prvv[0].assign(n0, -1);\n for(int j = 0; j < n0; j++) {\n int x = cnd[0][j].first, y = cnd[0][j].second;\n dpp[0][j] = abs(x - si) + abs(y - sj) + 1LL;\n }\n for(int k = 1; k < LL; k++) {\n int np = cnd[k-1].size();\n int nc = cnd[k].size();\n dpp[k].assign(nc, INF);\n prvv[k].assign(nc, -1);\n for(int j = 0; j < nc; j++) {\n int x = cnd[k][j].first, y = cnd[k][j].second;\n for(int p = 0; p < np; p++) {\n int px = cnd[k-1][p].first, py = cnd[k-1][p].second;\n ll cc = dpp[k-1][p] + abs(x - px) + abs(y - py) + 1;\n if(cc < dpp[k][j]) {\n dpp[k][j] = cc;\n prvv[k][j] = p;\n }\n }\n }\n }\n ll minc = INF;\n int bj = -1;\n int nlast = cnd[LL-1].size();\n for(int j = 0; j < nlast; j++) {\n if(dpp[LL-1][j] < minc) {\n minc = dpp[LL-1][j];\n bj = j;\n }\n }\n if(bj == -1) return {INF, {}};\n vector> sq(LL);\n int cj = bj;\n sq[LL-1] = cnd[LL-1][cj];\n for(int k = LL-1; k >= 1; k--) {\n int pj = prvv[k][cj];\n sq[k-1] = cnd[k-1][pj];\n cj = pj;\n }\n return {minc, sq};\n}\n\nint main() {\n srand(time(NULL));\n int N, M;\n cin >> N >> M;\n int si, sj;\n cin >> si >> sj;\n vector A(N);\n for(int i = 0; i < N; i++) cin >> A[i];\n vector t(M);\n for(int i = 0; i < M; i++) cin >> t[i];\n vector>> positions(26);\n for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) {\n positions[A[i][j] - 'A'].emplace_back(i, j);\n }\n vector> overlap(M, vector(M, 0));\n for(int i = 0; i < M; i++) {\n for(int j = 0; j < M; j++) if(i != j) {\n int best = 0;\n for(int o = 4; o >= 0; o--) {\n if(t[i].substr(5 - o) == t[j].substr(0, o)) {\n best = o;\n break;\n }\n }\n overlap[i][j] = best;\n }\n }\n const int TRIALS = 60;\n const int MAX_CAND = 800;\n vector> candidates;\n for(int start = 0; start < M; start++) {\n for(int tr = 0; tr < TRIALS; tr++) {\n vector used(M, false);\n used[start] = true;\n string curr = t[start];\n int last = start;\n for(int iter = 1; iter < M; iter++) {\n int cur_maxo = -1;\n vector cands_max;\n for(int j = 0; j < M; j++) if(!used[j]) {\n int oo = overlap[last][j];\n if(oo > cur_maxo) {\n cur_maxo = oo;\n cands_max = {j};\n } else if(oo == cur_maxo) {\n cands_max.push_back(j);\n }\n }\n if(cands_max.empty()) break;\n int idx = rand() % cands_max.size();\n int best = cands_max[idx];\n int maxo_val = cur_maxo;\n used[best] = true;\n curr += t[best].substr(maxo_val);\n last = best;\n }\n candidates.emplace_back((int)curr.size(), curr);\n }\n }\n sort(candidates.begin(), candidates.end());\n if((int)candidates.size() > MAX_CAND) candidates.resize(MAX_CAND);\n ll best_T = INF;\n vector> best_seq;\n for(auto& pr : candidates) {\n const string& curr = pr.second;\n auto [this_cost, this_seq] = solve_for_S(curr, si, sj, positions);\n if(this_cost < best_T) {\n best_T = this_cost;\n best_seq = this_seq;\n }\n }\n if(best_T == INF || best_seq.empty()) {\n string curr = t[0];\n auto [fcost, fseq] = solve_for_S(curr, si, sj, positions);\n if(fcost < INF) {\n best_seq = fseq;\n } else {\n vector> fb;\n if(!positions[0].empty()){\n auto p0 = positions[0][0];\n fb.push_back(p0);\n for(int k = 0; k < 4; k++) fb.push_back(p0);\n } else {\n fb.push_back({0,0});\n for(int k = 0; k < 4; k++) fb.push_back({0,0});\n }\n best_seq = fb;\n }\n }\n for(auto& p : best_seq) {\n cout << p.first << \" \" << p.second << \"\\n\";\n }\n return 0;\n}","ahc030":"#include \n\nusing namespace std;\n\nint main() {\n int N, M;\n double eps;\n cin >> N >> M >> eps;\n vector>> fields(M);\n for(int i=0; i> d;\n fields[i].resize(d);\n for(int j=0; j> fields[i][j].first >> fields[i][j].second;\n }\n }\n int D = N*N;\n vector> has_oil;\n for(int i=0; i> v;\n if(v != 0){\n has_oil.emplace_back(i, j);\n }\n }\n }\n cout << \"a \" << has_oil.size();\n for(auto p : has_oil){\n cout << \" \" << p.first << \" \" << p.second;\n }\n cout << \"\\n\";\n cout.flush();\n int resp;\n cin >> resp;\n if(resp != 1){\n // additional attempt\n has_oil.clear();\n for(int i=0; i> v;\n if(v >0 ) has_oil.emplace_back(i,j);\n }\n cout << \"a \" << has_oil.size();\n for(auto p : has_oil) cout << \" \" << p.first << \" \" << p.second;\n cout << \"\\n\";\n cout.flush();\n cin >> resp;\n }\n return 0;\n}","ahc031":"#include \nusing namespace std;\n\ntypedef array Rect;\n\nlong long simulate(int mode, int W, int D, int N, const vector>& A, vector>& outputs, bool collect, double thresh_factor) {\n vector prev_div(N + 1, 0);\n int base = W / N;\n for(int i = 1; i < N; i++) {\n prev_div[i] = prev_div[i - 1] + base;\n }\n prev_div[N] = W;\n long long total_cost = 0;\n if (collect) outputs.assign(D, vector(N));\n for(int d = 0; d < D; d++) {\n auto a = A[d];\n vector cur_w(N);\n for(int k = 0; k < N; k++) cur_w[k] = prev_div[k + 1] - prev_div[k];\n vector slot_idx(N);\n iota(slot_idx.begin(), slot_idx.end(), 0);\n sort(slot_idx.begin(), slot_idx.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n vector a_idx(N);\n iota(a_idx.begin(), a_idx.end(), 0);\n sort(a_idx.begin(), a_idx.end(), [&](int x, int y) {\n if(a[x] != a[y]) return a[x] > a[y];\n return x < y;\n });\n vector assigned(N);\n for(int i = 0; i < N; i++) {\n int s = slot_idx[i];\n int ak = a_idx[i];\n assigned[s] = a[ak];\n }\n long long current_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * cur_w[s];\n current_def += max(0LL, assigned[s] - b);\n }\n vector targ_w(N, 0);\n long long sum_need = 0;\n for(int s = 0; s < N; s++) {\n if(assigned[s] == 0) {\n targ_w[s] = 1;\n } else {\n targ_w[s] = ((assigned[s] + 999) / 1000);\n }\n if(targ_w[s] < 1) targ_w[s] = 1;\n sum_need += targ_w[s];\n }\n if(sum_need > W) {\n vector sidx(N);\n iota(sidx.begin(), sidx.end(), 0);\n sort(sidx.begin(), sidx.end(), [&](int x, int y) {\n return assigned[x] < assigned[y] || (assigned[x] == assigned[y] && x < y);\n });\n long long deficit = sum_need - W;\n for(int i : sidx) {\n if(deficit <= 0) break;\n int can = targ_w[i] - 1;\n long long red = min((long long)can, deficit);\n targ_w[i] -= red;\n deficit -= red;\n }\n int ii = 0;\n while(deficit > 0 && ii < N * 100) {\n int idx = sidx[ii % N];\n int can = targ_w[idx] - 1;\n long long red = min((long long)can, deficit);\n targ_w[idx] -= red;\n deficit -= red;\n ii++;\n }\n } else if(sum_need < W) {\n long long extra = W - sum_need;\n vector> large_ass;\n for(int s=0;s 0) {\n int s = large_ass[idx % min(4, (int)large_ass.size())].second;\n targ_w[s]++;\n extra--;\n idx++;\n }\n }\n vector new_div(N + 1, 0);\n for(int s = 0; s < N; s++) {\n new_div[s + 1] = new_div[s] + targ_w[s];\n }\n new_div[N] = W;\n long long new_def = 0;\n for(int s = 0; s < N; s++) {\n long long b = 1000LL * targ_w[s];\n new_def += max(0LL, assigned[s] - b);\n }\n vector old_has(W + 1, false);\n vector neww_has(W + 1, false);\n for(int k = 1; k < N; k++) {\n if(prev_div[k] > 0 && prev_div[k] < W) old_has[prev_div[k]] = true;\n if(new_div[k] > 0 && new_div[k] < W) neww_has[new_div[k]] = true;\n }\n int sym = 0;\n for(int j = 0; j <= W; j++) {\n if(old_has[j] != neww_has[j]) sym++;\n }\n long long L = (long long)sym * W;\n long long delta = current_def - new_def;\n bool domove = (d == 0) || (L < static_cast(100 * thresh_factor) * delta);\n long long day_short = domove ? new_def : current_def;\n vector dayr(N);\n if (domove) {\n vector sorted_slot(N);\n iota(sorted_slot.begin(), sorted_slot.end(), 0);\n sort(sorted_slot.begin(), sorted_slot.end(), [&](int x, int y) {\n if(targ_w[x] != targ_w[y]) return targ_w[x] > targ_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_slot[i];\n int k = a_idx[i];\n int j0 = new_div[s];\n int j1 = new_div[s + 1];\n if (mode == 0) {\n dayr[k] = {0, j0, W, j1};\n } else {\n dayr[k] = {j0, 0, j1, W};\n }\n }\n prev_div = new_div;\n } else {\n vector sorted_cur(N);\n iota(sorted_cur.begin(), sorted_cur.end(), 0);\n sort(sorted_cur.begin(), sorted_cur.end(), [&](int x, int y) {\n if(cur_w[x] != cur_w[y]) return cur_w[x] > cur_w[y];\n return x < y;\n });\n for(int i = 0; i < N; i++) {\n int s = sorted_cur[i];\n int k = a_idx[i];\n int j0 = prev_div[s];\n int j1 = prev_div[s + 1];\n if (mode == 0) {\n dayr[k] = {0, j0, W, j1};\n } else {\n dayr[k] = {j0, 0, j1, W};\n }\n }\n }\n total_cost += (domove ? L : 0) + 100 * day_short;\n if (collect) outputs[d] = dayr;\n }\n return total_cost;\n}\n\nint main() {\n int W, D, N;\n cin >> W >> D >> N;\n vector> A(D, vector(N));\n for(int d = 0; d < D; d++) {\n for(int k = 0; k < N; k++) {\n cin >> A[d][k];\n }\n }\n vector> out_best;\n long long best_cost = LLONG_MAX;\n vector factors = {0.8, 1.0, 1.2};\n vector modes = {0, 1};\n for(double f : factors) {\n for(int m : modes) {\n vector> cur_out;\n long long c = simulate(m, W, D, N, A, cur_out, true, f);\n if(c < best_cost) {\n best_cost = c;\n out_best = cur_out;\n }\n }\n }\n for(int d = 0; d < D; d++) {\n for(int k = 0; k < N; k++) {\n auto& r = out_best[d][k];\n cout << r[0] << \" \" << r[1] << \" \" << r[2] << \" \" << r[3] << endl;\n }\n }\n return 0;\n}","ahc032":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n int N, M, K;\n cin >> N >> M >> K;\n vector> A(N, vector(N));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> A[i][j];\n vector>> S(M, vector>(3, vector(3)));\n for (int m = 0; m < M; m++) for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cin >> S[m][i][j];\n const ll MOD = 998244353;\n vector> cur_mod(N, vector(N));\n vector>> op_cnt(M, vector>(N - 2, vector(N - 2, 0)));\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_mod[i][j] = A[i][j];\n ll cur_score = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cur_score += cur_mod[i][j];\n int cur_total = 0;\n auto get_add_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) {\n for (int dj = 0; dj < 3; dj++) {\n int i = p + di;\n int j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr + S[m][di][dj] % MOD) % MOD;\n ds += newr - oldr;\n }\n }\n return ds;\n };\n auto get_remove_dsc = [&](int m, int p, int q) -> ll {\n ll ds = 0;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i >= N || j >= N) continue;\n ll oldr = cur_mod[i][j];\n ll newr = (oldr - (S[m][di][dj] % MOD) + MOD) % MOD;\n ds += newr - oldr;\n }\n return ds;\n };\n auto get_reconfig_dsc = [&](int m1, int p1, int q1, int m2, int p2, int q2) -> ll {\n ll ds = 0;\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {\n ll net = 0;\n int di = i - p1, dj = j - q1;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net -= S[m1][di][dj];\n di = i - p2; dj = j - q2;\n if (di >= 0 && di < 3 && dj >= 0 && dj < 3) net += S[m2][di][dj];\n if (net == 0) continue;\n ll oldr = cur_mod[i][j];\n ll addm = (net % MOD + MOD) % MOD;\n ll newr = (oldr + addm) % MOD;\n ds += newr - oldr;\n }\n return ds;\n };\n while (cur_total < K) {\n ll max_ds = -1000000000000000000LL;\n int bm = -1, bp = -1, bq = -1;\n for (int m = 0; m < M; m++) {\n for (int p = 0; p <= N - 3; p++) {\n for (int q = 0; q <= N - 3; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds;\n bm = m; bp = p; bq = q;\n }\n }\n }\n }\n if (max_ds <= 0) break;\n int m = bm, p = bp, q = bq;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + (S[m][di][dj] % MOD)) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n }\n vector> greedy_mod = cur_mod;\n vector>> greedy_cnt = op_cnt;\n ll greedy_score = cur_score;\n int greedy_total = cur_total;\n ll overall_best_score = cur_score;\n vector>> overall_best_cnt = op_cnt;\n int MAX_ITER = 850000;\n double T0 = 10000000000.0;\n srand(42);\n auto rand01 = []() { return rand() * 1.0 / RAND_MAX; };\n for (int trial = 0; trial < 3; trial++) {\n cur_mod = greedy_mod;\n op_cnt = greedy_cnt;\n cur_score = greedy_score;\n cur_total = greedy_total;\n if (trial > 0) {\n int npert = 15 + (rand() % 15);\n for (int p = 0; p < npert; p++) {\n if (rand() % 2 && cur_total < K) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n ll dsc = get_add_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][pp][qq]++;\n cur_total++;\n cur_score += dsc;\n } else if (cur_total > 0) {\n int m = rand() % M;\n int pp = rand() % (N - 2);\n int qq = rand() % (N - 2);\n if (op_cnt[m][pp][qq] > 0) {\n ll dsc = get_remove_dsc(m, pp, qq);\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = pp + di, j = qq + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][pp][qq]--;\n cur_total--;\n cur_score += dsc;\n }\n }\n }\n }\n for (int iter = 0; iter < MAX_ITER; iter++) {\n double temp = T0 * pow(0.99995, iter);\n bool did = false;\n int rtyp = rand() % 4;\n if (rtyp == 0 && cur_total < K) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n ll dsc = get_add_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n } else if (rtyp == 1 && cur_total > 0) {\n int m = rand() % M;\n int p = rand() % (N - 2);\n int q = rand() % (N - 2);\n if (op_cnt[m][p][q] > 0) {\n ll dsc = get_remove_dsc(m, p, q);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n did = true;\n }\n }\n }\n if (!did) {\n int m1 = rand() % M; int p1 = rand() % (N - 2); int q1 = rand() % (N - 2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N - 2); int q2 = rand() % (N - 2);\n ll dsc = get_reconfig_dsc(m1, p1, q1, m2, p2, q2);\n bool acc = (dsc >= 0);\n if (!acc && temp > 0) {\n double pr = exp(dsc / temp);\n if (pr > 1.0) pr = 1.0;\n acc = (pr > rand01());\n }\n if (acc) {\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m1][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m2][di][dj] % MOD) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += dsc;\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n }\n }\n }\n // deterministic local hill climb with reconfig sample\n const int MAX_HILL = 800;\n for (int h = 0; h < MAX_HILL; h++) {\n ll max_ds = 0;\n int best_type = -1;\n int ba_m = -1, ba_p = -1, ba_q = -1;\n int br_m = -1, br_p = -1, br_q = -1;\n int b1_m = -1, b1_p = -1, b1_q = -1, b2_m = -1, b2_p = -1, b2_q = -1;\n if (cur_total < K) {\n for (int m = 0; m < M; m++) for (int p = 0; p < N-2; p++) for (int q = 0; q < N-2; q++) {\n ll ds = get_add_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds; best_type = 0; ba_m = m; ba_p = p; ba_q = q;\n }\n }\n }\n for (int m = 0; m < M; m++) for (int p = 0; p < N-2; p++) for (int q = 0; q < N-2; q++) if (op_cnt[m][p][q] > 0) {\n ll ds = get_remove_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds; best_type = 1; br_m = m; br_p = p; br_q = q;\n }\n }\n for (int samp = 0; samp < 300; samp++) {\n int m1 = rand() % M; int p1 = rand() % (N-2); int q1 = rand() % (N-2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N-2); int q2 = rand() % (N-2);\n ll ds = get_reconfig_dsc(m1, p1, q1, m2, p2, q2);\n if (ds > max_ds) {\n max_ds = ds; best_type = 2; b1_m = m1; b1_p = p1; b1_q = q1; b2_m = m2; b2_p = p2; b2_q = q2;\n }\n }\n }\n if (max_ds <= 0) break;\n if (best_type == 0) {\n int m = ba_m, p = ba_p, q = ba_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n } else if (best_type == 1) {\n int m = br_m, p = br_p, q = br_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += max_ds;\n } else if (best_type == 2) {\n int m1 = b1_m, p1 = b1_p, q1 = b1_q;\n int m2 = b2_m, p2 = b2_p, q2 = b2_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m1][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m2][di][dj] % MOD) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += max_ds;\n }\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n }\n // rebuild cur from overall_best for final hill\n for(int i=0;i max_ds) {\n max_ds = ds; best_type = 0; ba_m = m; ba_p = p; ba_q = q;\n }\n }\n }\n for (int m = 0; m < M; m++) for (int p = 0; p < N-2; p++) for (int q = 0; q < N-2; q++) if (op_cnt[m][p][q] > 0) {\n ll ds = get_remove_dsc(m, p, q);\n if (ds > max_ds) {\n max_ds = ds; best_type = 1; br_m = m; br_p = p; br_q = q;\n }\n }\n for (int samp = 0; samp < 300; samp++) {\n int m1 = rand() % M; int p1 = rand() % (N-2); int q1 = rand() % (N-2);\n if (op_cnt[m1][p1][q1] > 0) {\n int m2 = rand() % M; int p2 = rand() % (N-2); int q2 = rand() % (N-2);\n ll ds = get_reconfig_dsc(m1, p1, q1, m2, p2, q2);\n if (ds > max_ds) {\n max_ds = ds; best_type = 2; b1_m = m1; b1_p = p1; b1_q = q1; b2_m = m2; b2_p = p2; b2_q = q2;\n }\n }\n }\n if (max_ds <= 0) break;\n if (best_type == 0) {\n int m = ba_m, p = ba_p, q = ba_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m][di][dj] % MOD) % MOD;\n }\n op_cnt[m][p][q]++;\n cur_total++;\n cur_score += max_ds;\n } else if (best_type == 1) {\n int m = br_m, p = br_p, q = br_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p + di, j = q + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m][p][q]--;\n cur_total--;\n cur_score += max_ds;\n } else if (best_type == 2) {\n int m1 = b1_m, p1 = b1_p, q1 = b1_q;\n int m2 = b2_m, p2 = b2_p, q2 = b2_q;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p1 + di, j = q1 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] - S[m1][di][dj] % MOD + MOD) % MOD;\n }\n op_cnt[m1][p1][q1]--;\n for (int di = 0; di < 3; di++) for (int dj = 0; dj < 3; dj++) {\n int i = p2 + di, j = q2 + dj;\n if (i < N && j < N) cur_mod[i][j] = (cur_mod[i][j] + S[m2][di][dj] % MOD) % MOD;\n }\n op_cnt[m2][p2][q2]++;\n cur_score += max_ds;\n }\n if (cur_score > overall_best_score) {\n overall_best_score = cur_score;\n overall_best_cnt = op_cnt;\n }\n }\n int L = 0;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) L += overall_best_cnt[m][p][q];\n cout << L << endl;\n for (int m = 0; m < M; m++) for (int p = 0; p <= N - 3; p++) for (int q = 0; q <= N - 3; q++) {\n for (int t = 0; t < overall_best_cnt[m][p][q]; t++) {\n cout << m << \" \" << p << \" \" << q << endl;\n }\n }\n return 0;\n}","ahc033":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> 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 int max_turn = 10000;\n vector> grid(N, vector(N, -1));\n vector next_in(N, 0);\n vector pos_r(N), pos_c(N);\n for (int i = 0; i < N; i++) {\n pos_r[i] = i;\n pos_c[i] = 0;\n }\n vector hold(N, -1);\n vector active(N, true);\n vector acts(N, \"\");\n int total_disp = 0;\n for (int turn = 0; turn < max_turn; turn++) {\n if (total_disp >= N * N) break;\n for (int i = 0; i < N; i++) {\n if (next_in[i] < N && grid[i][0] == -1) {\n bool has_hold = false;\n for (int k = 0; k < N; k++) if (active[k] && pos_r[k] == i && pos_c[k] == 0 && hold[k] != -1) {\n has_hold = true; break;\n }\n if (!has_hold) {\n grid[i][0] = A[i][next_in[i]];\n next_in[i]++;\n }\n }\n }\n vector act(N, '.');\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n int r = pos_r[c];\n int co = pos_c[c];\n bool carrying = (hold[c] != -1);\n if (carrying) {\n if (co == N - 1) {\n act[c] = 'Q';\n } else {\n act[c] = 'R';\n }\n } else {\n if (grid[r][co] != -1) {\n int b = grid[r][co];\n int tr = b / N;\n bool can_pick = (c == 0) || (tr == r);\n if (can_pick) act[c] = 'P';\n } else {\n act[c] = (co > 0 ? 'L' : '.');\n }\n }\n }\n vector> new_grid = grid;\n vector new_hold = hold;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n int pr = pos_r[c], pc = pos_c[c];\n if (ac == 'P') {\n if (hold[c] != -1 || new_grid[pr][pc] == -1) act[c] = '.';\n else {\n new_hold[c] = new_grid[pr][pc];\n new_grid[pr][pc] = -1;\n }\n } else if (ac == 'Q') {\n if (hold[c] == -1 || new_grid[pr][pc] != -1) act[c] = '.';\n else {\n new_grid[pr][pc] = hold[c];\n new_hold[c] = -1;\n }\n }\n }\n vector nr_pos = pos_r, nc_pos = pos_c;\n for (int c = 0; c < N; c++) {\n if (!active[c]) continue;\n char ac = act[c];\n if (ac != 'U' && ac != 'D' && ac != 'L' && ac != 'R') continue;\n int pr = pos_r[c], pc = pos_c[c];\n int nrr = pr, ncc = pc;\n if (ac == 'U') nrr--;\n else if (ac == 'D') nrr++;\n else if (ac == 'L') ncc--;\n else if (ac == 'R') ncc++;\n if (nrr < 0 || nrr >= N || ncc < 0 || ncc >= N) {\n act[c] = '.'; continue;\n }\n bool car = (new_hold[c] != -1);\n bool isl = (c == 0);\n bool dh = (new_grid[nrr][ncc] != -1);\n if (car && !isl && dh) {\n act[c] = '.'; continue;\n }\n nr_pos[c] = nrr;\n nc_pos[c] = ncc;\n }\n map, int> cnt;\n for (int c = 0; c < N; c++) if (active[c]) cnt[{nr_pos[c], nc_pos[c]}]++;\n bool cl = false;\n for (auto& p : cnt) if (p.second > 1) cl = true;\n if (cl) {\n for (int c = 0; c < N; c++) if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c];\n nc_pos[c] = pos_c[c];\n }\n }\n bool swapc = false;\n for (int c1 = 0; c1 < N && !swapc; c1++) for (int c2 = c1 + 1; c2 < N; c2++) if (active[c1] && active[c2]) {\n if (nr_pos[c1] == pos_r[c2] && nc_pos[c1] == pos_c[c2] && nr_pos[c2] == pos_r[c1] && nc_pos[c2] == pos_c[c1]) swapc = true;\n }\n if (swapc) {\n for (int c = 0; c < N; c++) if (act[c] == 'U' || act[c] == 'D' || act[c] == 'L' || act[c] == 'R') {\n act[c] = '.';\n nr_pos[c] = pos_r[c];\n nc_pos[c] = pos_c[c];\n }\n }\n pos_r = nr_pos;\n pos_c = nc_pos;\n grid = new_grid;\n hold = new_hold;\n for (int rr = 0; rr < N; rr++) {\n if (grid[rr][N - 1] != -1) {\n grid[rr][N - 1] = -1;\n total_disp++;\n }\n }\n for (int c = 0; c < N; c++) acts[c] += act[c];\n }\n size_t ml = 0;\n for (auto& s : acts) ml = max(ml, s.size());\n for (int i = 0; i < N; i++) {\n while (acts[i].size() < ml) acts[i] += '.';\n if (acts[i].size() > max_turn) acts[i].resize(max_turn);\n }\n for (int i = 0; i < N; i++) cout << acts[i] << endl;\n return 0;\n}","ahc034":"#include \nusing namespace std;\n\nint main() {\n int N;\n cin >> N;\n vector> h(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cin >> h[i][j];\n }\n }\n int r = 0, c = 0;\n long long load = 0;\n vector ops;\n const int MAXT = 100000;\n auto is_done = [&]() -> bool {\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (h[i][j] != 0) return false;\n }\n }\n return true;\n };\n auto find_best = [&](bool is_source) -> pair {\n int best_dist = INT_MAX / 2;\n long long best_am = 0;\n int ti = -1, tj = -1;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n long long val = h[i][j];\n if ((is_source ? val > 0 : val < 0)) {\n int dist = abs(i - r) + abs(j - c);\n long long amnt = is_source ? val : -val;\n if (dist < best_dist || (dist == best_dist && amnt > best_am)) {\n best_dist = dist;\n best_am = amnt;\n ti = i;\n tj = j;\n }\n }\n }\n }\n return {ti, tj};\n };\n auto move_path = [&](int tr, int tc) {\n while (r < tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"D\");\n r++;\n }\n while (r > tr && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"U\");\n r--;\n }\n while (c < tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"R\");\n c++;\n }\n while (c > tc && (int)ops.size() < MAXT - 5) {\n ops.push_back(\"L\");\n c--;\n }\n };\n while (!is_done() && (int)ops.size() < MAXT - 50) {\n bool did_something = false;\n if (load == 0 && h[r][c] > 0) {\n long long d = h[r][c];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[r][c] -= d;\n did_something = true;\n } else if (load > 0 && h[r][c] < 0) {\n long long d = min(load, -h[r][c]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[r][c] += d;\n did_something = true;\n }\n if (did_something) continue;\n bool going_source = (load == 0);\n auto target = find_best(going_source);\n if (target.first == -1) {\n break;\n }\n move_path(target.first, target.second);\n }\n auto do_sweep = [&]() {\n for (int i = 0; i < N && (int)ops.size() < MAXT - 10; i++) {\n for (int j = 0; j < N && (int)ops.size() < MAXT - 10; j++) {\n move_path(i, j);\n if (load == 0 && h[i][j] > 0) {\n long long d = h[i][j];\n ops.push_back(\"+\" + to_string(d));\n load += d;\n h[i][j] -= d;\n } else if (load > 0 && h[i][j] < 0) {\n long long d = min(load, -h[i][j]);\n ops.push_back(\"-\" + to_string(d));\n load -= d;\n h[i][j] += d;\n }\n }\n }\n };\n if (!is_done()) {\n for (int p = 0; p < 30 && !is_done() && (int)ops.size() < MAXT - 50; p++) {\n do_sweep();\n }\n }\n for (auto& s : ops) {\n cout << s << endl;\n }\n return 0;\n}","ahc035":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(NULL);\n int N, M, T;\n cin >> N >> M >> T;\n int seed_count = 2 * N * (N - 1);\n vector> X(seed_count, vector(M, 0));\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n mt19937 rng(42);\n for (int t = 0; t < T; t++) {\n vector vals(seed_count, 0);\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n vals[i] += X[i][j];\n }\n }\n vector> trait_carriers(M);\n set all_carrier_set;\n vector maxl_per_trait(M, 0);\n vector num_max_traits_per_seed(seed_count, 0);\n vector carrier_count_per_trait(M, 0);\n vector rare_prio(seed_count, 0.0);\n for (int l = 0; l < M; l++) {\n int ml = 0;\n for (int i = 0; i < seed_count; i++) ml = max(ml, X[i][l]);\n maxl_per_trait[l] = ml;\n for (int i = 0; i < seed_count; i++) {\n if (X[i][l] == ml) {\n trait_carriers[l].push_back(i);\n all_carrier_set.insert(i);\n num_max_traits_per_seed[i]++;\n rare_prio[i] += 5.0 / max(1, (int)trait_carriers[l].size());\n }\n }\n carrier_count_per_trait[l] = trait_carriers[l].size();\n }\n vector all_carriers(all_carrier_set.begin(), all_carrier_set.end());\n for (int i = 0; i < seed_count; i++) rare_prio[i] *= 2.0;\n vector to_plant;\n set selected;\n // top 2 carriers per trait\n for (int l = 0; l < M; l++) {\n sort(trait_carriers[l].begin(), trait_carriers[l].end(), [&](int a, int b){\n return vals[a] > vals[b] || (vals[a] == vals[b] && a < b);\n });\n for (int k = 0; k < 2 && k < (int)trait_carriers[l].size(); k++) {\n int cand = trait_carriers[l][k];\n if (!selected.count(cand)) {\n selected.insert(cand);\n to_plant.push_back(cand);\n }\n }\n }\n vector> add_car;\n for (int i : all_carriers) {\n if (!selected.count(i)) {\n add_car.emplace_back(rare_prio[i] * 20 + vals[i] + num_max_traits_per_seed[i] * 100, i);\n }\n }\n sort(add_car.rbegin(), add_car.rend());\n for (auto& p : add_car) {\n if ((int)to_plant.size() >= N * N) break;\n to_plant.push_back(p.second);\n selected.insert(p.second);\n }\n vector> non_car;\n for (int i = 0; i < seed_count; i++) {\n if (!selected.count(i)) {\n non_car.emplace_back(vals[i], i);\n }\n }\n sort(non_car.rbegin(), non_car.rend());\n for (auto& p : non_car) {\n if ((int)to_plant.size() >= N * N) break;\n to_plant.push_back(p.second);\n }\n sort(to_plant.begin(), to_plant.end(), [&](int a, int b) {\n return vals[a] + num_max_traits_per_seed[a] * 10000 > vals[b] + num_max_traits_per_seed[b] * 10000 || (vals[a] + num_max_traits_per_seed[a] * 10000 == vals[b] + num_max_traits_per_seed[b] * 10000 && a < b);\n });\n if ((int)to_plant.size() > N * N) to_plant.resize(N * N);\n while ((int)to_plant.size() < N * N) to_plant.push_back(0);\n vector curr_arr(N * N);\n for (int i = 0; i < N * N; i++) curr_arr[i] = to_plant[i];\n auto compute_obj = [&](const vector& arr) -> long long {\n long long obj = 0;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N - 1; j++) {\n int p = arr[i * N + j];\n int q = arr[i * N + j + 1];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n obj += (long long)(rare_prio[p] + rare_prio[q]) * 25;\n }\n }\n for (int i = 0; i < N - 1; i++) {\n for (int j = 0; j < N; j++) {\n int p = arr[i * N + j];\n int q = arr[(i + 1) * N + j];\n for (int l = 0; l < M; l++) {\n obj += max(X[p][l], X[q][l]);\n }\n obj += (long long)(rare_prio[p] + rare_prio[q]) * 25;\n }\n }\n return obj;\n };\n long long curr_obj = compute_obj(curr_arr);\n long long best_obj = curr_obj;\n vector best_arr = curr_arr;\n vector curr_arr_swap = curr_arr;\n double temp = 20000.0;\n for (int iter = 0; iter < 130000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n long long new_obj = compute_obj(curr_arr_swap);\n long long delta = new_obj - curr_obj;\n bool accept = false;\n if (delta > 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / temp);\n double r = (rng() % 1000000000LL) / 1000000000.0;\n if (r < prob) accept = true;\n }\n if (accept) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr_swap;\n }\n } else {\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n }\n if (iter % 400 == 0) {\n temp *= 0.9975;\n if (temp < 0.5) temp = 0.5;\n }\n }\n curr_arr_swap = best_arr;\n curr_obj = best_obj;\n for (int iter = 0; iter < 40000; iter++) {\n int p1 = rng() % (N * N);\n int p2 = rng() % (N * N);\n if (p1 == p2) continue;\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n long long new_obj = compute_obj(curr_arr_swap);\n if (new_obj > curr_obj) {\n curr_obj = new_obj;\n if (new_obj > best_obj) {\n best_obj = new_obj;\n best_arr = curr_arr_swap;\n }\n } else {\n swap(curr_arr_swap[p1], curr_arr_swap[p2]);\n }\n }\n vector> A(N, vector(N, 0));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n A[i][j] = best_arr[i * N + j];\n }\n }\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n cout << A[i][j];\n if (j < N - 1) cout << \" \";\n else cout << \"\\n\";\n }\n }\n cout.flush();\n for (int i = 0; i < seed_count; i++) {\n for (int j = 0; j < M; j++) {\n cin >> X[i][j];\n }\n }\n }\n return 0;\n}","ahc038":"#include \nusing namespace std;\n\nint main() {\n int N, M, V;\n cin >> N >> M >> V;\n vector S(N), T(N);\n for (auto& str : S) cin >> str;\n for (auto& str : T) cin >> str;\n vector> grid(N, vector(N));\n vector> target(N, vector(N));\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n grid[i][j] = S[i][j] - '0';\n target[i][j] = T[i][j] - '0';\n }\n }\n vector> supplies, demands;\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (grid[i][j] && target[i][j] == 0) supplies.emplace_back(i, j);\n if (!grid[i][j] && target[i][j]) demands.emplace_back(i, j);\n }\n }\n if (supplies.size() != demands.size()) {\n // Should be equal, but handle by taking min or something, but assume equal\n }\n int Vp = 2;\n int L = 1;\n cout << Vp << endl;\n for (int u = 1; u < Vp; u++) {\n cout << 0 << \" \" << L << endl;\n }\n int rx = N / 2, ry = N / 2;\n cout << rx << \" \" << ry << endl;\n int cur_dir = 0;\n bool holding = false;\n vector commands;\n int DX[4] = {0, 1, 0, -1};\n int DY[4] = {1, 0, -1, 0};\n int delx[5] = {0, 0, 1, 0, -1};\n int dely[5] = {0, 1, 0, -1, 0};\n char mchar[5] = {'.', 'R', 'D', 'L', 'U'};\n char rchar[3] = {'.', 'L', 'R'};\n auto get_min_approx = [&](int px, int py) -> int {\n int md = 1000000000;\n for (int d = 0; d < 4; d++) {\n int tx = px - DX[d] * L;\n int ty = py - DY[d] * L;\n if (tx >= 0 && tx < N && ty >= 0 && ty < N) {\n md = min(md, abs(rx - tx) + abs(ry - ty));\n }\n }\n return md;\n };\n vector sup_used(supplies.size(), false);\n vector dem_used(demands.size(), false);\n int sup_rem = supplies.size();\n int dem_rem = demands.size();\n auto do_bfs = [&](int sx, int sy) -> vector> {\n vector> targets;\n for (int dd = 0; dd < 4; dd++) {\n int needx = sx - DX[dd] * L;\n int needy = sy - DY[dd] * L;\n if (needx >= 0 && needx < N && needy >= 0 && needy < N) {\n targets.emplace_back(needx, needy, dd);\n }\n }\n if (targets.empty()) return {};\n vector>> dist(N, vector>(N, vector(4, -1)));\n vector>> prev_x(N, vector>(N, vector(4, -1)));\n vector>> prev_y(N, vector>(N, vector(4, -1)));\n vector>> prev_d(N, vector>(N, vector(4, -1)));\n vector>> prev_move(N, vector>(N, vector(4, -1)));\n vector>> prev_rot(N, vector>(N, vector(4, -1)));\n dist[rx][ry][cur_dir] = 0;\n queue> q;\n q.emplace(rx, ry, cur_dir);\n while (!q.empty()) {\n auto [x, y, d] = q.front(); q.pop();\n for (int mid = 0; mid < 5; mid++) {\n int nx = x + delx[mid];\n int ny = y + dely[mid];\n if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue;\n for (int rid = 0; rid < 3; rid++) {\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n int nd = (d + dch) % 4;\n if (dist[nx][ny][nd] == -1) {\n dist[nx][ny][nd] = dist[x][y][d] + 1;\n prev_x[nx][ny][nd] = x;\n prev_y[nx][ny][nd] = y;\n prev_d[nx][ny][nd] = d;\n prev_move[nx][ny][nd] = mid;\n prev_rot[nx][ny][nd] = rid;\n q.emplace(nx, ny, nd);\n }\n }\n }\n }\n int min_d = 1000000000;\n int bx = -1, by = -1, bd = -1;\n for (auto [px, py, pd] : targets) {\n if (dist[px][py][pd] != -1 && dist[px][py][pd] < min_d) {\n min_d = dist[px][py][pd];\n bx = px; by = py; bd = pd;\n }\n }\n if (min_d == 1000000000) return {};\n vector> rev_path;\n int cx = bx, cy = by, cd = bd;\n while (dist[cx][cy][cd] > 0) {\n int mid = prev_move[cx][cy][cd];\n int rid = prev_rot[cx][cy][cd];\n rev_path.emplace_back(mid, rid);\n int px = prev_x[cx][cy][cd];\n int py = prev_y[cx][cy][cd];\n int pd = prev_d[cx][cy][cd];\n cx = px; cy = py; cd = pd;\n }\n reverse(rev_path.begin(), rev_path.end());\n return rev_path;\n };\n while (sup_rem > 0) {\n // Choose best supply if not holding\n int best_sup = -1;\n int minc = 1000000000;\n for (int i = 0; i < (int)supplies.size(); i++) {\n if (!sup_used[i]) {\n auto [px, py] = supplies[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_sup = i;\n }\n }\n }\n if (best_sup == -1) break;\n auto [sx, sy] = supplies[best_sup];\n int cur_fx = rx + DX[cur_dir] * L;\n int cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != sx || cur_fy != sy) {\n auto pth = do_bfs(sx, sy);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[sx][sy] = 0;\n holding = true;\n sup_used[best_sup] = true;\n sup_rem--;\n // Now choose best demand\n int best_dem = -1;\n minc = 1000000000;\n for (int i = 0; i < (int)demands.size(); i++) {\n if (!dem_used[i]) {\n auto [px, py] = demands[i];\n int cd = get_min_approx(px, py);\n if (cd < minc) {\n minc = cd;\n best_dem = i;\n }\n }\n }\n if (best_dem == -1) break;\n auto [tx, ty] = demands[best_dem];\n cur_fx = rx + DX[cur_dir] * L;\n cur_fy = ry + DY[cur_dir] * L;\n if (cur_fx != tx || cur_fy != ty) {\n auto pth = do_bfs(tx, ty);\n if (!pth.empty()) {\n for (size_t i = 0; i < pth.size(); i++) {\n auto [mid, rid] = pth[i];\n string cmd(4, '.');\n cmd[0] = mchar[mid];\n cmd[1] = rchar[rid];\n if (i == pth.size() - 1) cmd[3] = 'P';\n commands.push_back(cmd);\n int dch = (rid == 0 ? 0 : rid == 1 ? 3 : 1);\n cur_dir = (cur_dir + dch) % 4;\n rx += delx[mid];\n ry += dely[mid];\n }\n }\n } else {\n string cmd(4, '.');\n cmd[3] = 'P';\n commands.push_back(cmd);\n }\n grid[tx][ty] = 1;\n holding = false;\n dem_used[best_dem] = true;\n dem_rem--;\n }\n for (auto& cmd : commands) {\n cout << cmd << endl;\n }\n return 0;\n}","ahc039":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Info {\n ll tot, pre, suf, sub;\n};\n\nInfo comb(const Info& l, const Info& r) {\n Info res;\n res.tot = l.tot + r.tot;\n res.pre = max(l.pre, l.tot + r.pre);\n res.suf = max(r.suf, r.tot + l.suf);\n res.sub = max({l.sub, r.sub, l.suf + r.pre});\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(0);\n int N;\n cin >> N;\n vector X(2 * N), Y(2 * N);\n vector ism(2 * N, false);\n for (int i = 0; i < 2 * N; i++) {\n cin >> X[i] >> Y[i];\n if (i < N) ism[i] = true;\n }\n set sx, sy;\n for (int i = 0; i < 2 * N; i++) {\n sx.insert(X[i]);\n sy.insert(Y[i]);\n }\n vector allx(sx.begin(), sx.end());\n vector ally(sy.begin(), sy.end());\n int CX = allx.size();\n int CY = ally.size();\n map xr, yr;\n for (int i = 0; i < CX; i++) xr[allx[i]] = i + 1;\n for (int i = 0; i < CY; i++) yr[ally[i]] = i + 1;\n vector>> col(CX + 1);\n vector>> coly(CY + 1);\n for (int i = 0; i < 2 * N; i++) {\n int rrx = xr[X[i]];\n int rry = yr[Y[i]];\n ll v = ism[i] ? 1LL : -1LL;\n col[rrx].emplace_back(rry, v);\n coly[rry].emplace_back(rrx, v);\n }\n vector tree(4 * 10005);\n vector cur_ysum(10005, 0);\n auto build_func = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n tree[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n auto upd = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n tree[node].tot += delta;\n tree[node].pre += delta;\n tree[node].suf += delta;\n tree[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n tree[node] = comb(tree[2 * node], tree[2 * node + 1]);\n };\n if (CY >= 1) build_func(build_func, 1, 1, CY);\n auto get_kad_y = [&](int& syy, int& eyy) -> ll {\n if (CY < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_ysum[1];\n max_so = meh;\n for (int j = 2; j <= CY; j++) {\n if (cur_ysum[j] > meh + cur_ysum[j]) {\n meh = cur_ysum[j];\n cl = j;\n } else {\n meh += cur_ysum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n syy = bl;\n eyy = br;\n return max_so;\n };\n ll best_val = 0;\n int blx = -1, brx = -1, bly = -1, bry = -1;\n bool best_is_x_sweep = true;\n int step = 20;\n // x sweep\n {\n vector lsamps;\n for (int i = 1; i <= CX; i += step) lsamps.push_back(i);\n mt19937 rng(42);\n for (int ii = 0; ii < 100; ii++) lsamps.push_back(rng() % CX + 1);\n sort(lsamps.begin(), lsamps.end());\n lsamps.erase(unique(lsamps.begin(), lsamps.end()), lsamps.end());\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CX; R++) {\n for (auto [yy, vv] : col[R]) {\n upd(upd, 1, 1, CY, yy, vv);\n cur_ysum[yy] += vv;\n hist.emplace_back(yy, vv);\n }\n if ((R - L) % 25 == 0 || R == CX || R == L) {\n Info infoo = (CY >= 1 ? tree[1] : Info{0,0,0,0});\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int syy, eyy;\n ll act = get_kad_y(syy, eyy);\n if (act > best_val && eyy > syy && L < R) {\n int lx_x = allx[L - 1];\n int rx_x = allx[R - 1];\n int ly_y = ally[syy - 1];\n int ry_y = ally[eyy - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = L;\n brx = R;\n bly = syy;\n bry = eyy;\n best_is_x_sweep = true;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [yy, vv] = hist[i];\n upd(upd, 1, 1, CY, yy, -vv);\n cur_ysum[yy] -= vv;\n }\n }\n }\n // y sweep\n {\n vector treex(4 * 10005);\n vector cur_xsum(10005, 0);\n auto build_x = [&](auto self, int node, int st, int en) -> void {\n if (st == en) {\n treex[node] = {0, 0, 0, 0};\n return;\n }\n int m = (st + en) / 2;\n self(self, 2 * node, st, m);\n self(self, 2 * node + 1, m + 1, en);\n treex[node] = comb(treex[2 * node], treex[2 * node + 1]);\n };\n auto upd_x = [&](auto self, int node, int st, int en, int idx, ll delta) -> void {\n if (st == en) {\n treex[node].tot += delta;\n treex[node].pre += delta;\n treex[node].suf += delta;\n treex[node].sub += delta;\n return;\n }\n int m = (st + en) / 2;\n if (idx <= m) self(self, 2 * node, st, m, idx, delta);\n else self(self, 2 * node + 1, m + 1, en, idx, delta);\n treex[node] = comb(treex[2 * node], treex[2 * node + 1]);\n };\n if (CX >= 1) build_x(build_x, 1, 1, CX);\n auto get_kad_x = [&](int& sxx, int& exx) -> ll {\n if (CX < 1) return 0;\n ll max_so = LLONG_MIN / 2;\n int bl = 1, br = 1, cl = 1;\n ll meh = cur_xsum[1];\n max_so = meh;\n for (int j = 2; j <= CX; j++) {\n if (cur_xsum[j] > meh + cur_xsum[j]) {\n meh = cur_xsum[j];\n cl = j;\n } else {\n meh += cur_xsum[j];\n }\n if (meh > max_so) {\n max_so = meh;\n bl = cl;\n br = j;\n } else if (meh == max_so) {\n br = j;\n }\n }\n sxx = bl;\n exx = br;\n return max_so;\n };\n vector lsamps;\n for (int i = 1; i <= CY; i += step) lsamps.push_back(i);\n mt19937 rng2(43);\n for (int ii = 0; ii < 100; ii++) lsamps.push_back(rng2() % CY + 1);\n sort(lsamps.begin(), lsamps.end());\n lsamps.erase(unique(lsamps.begin(), lsamps.end()), lsamps.end());\n for (int L : lsamps) {\n vector> hist;\n for (int R = L; R <= CY; R++) {\n for (auto [xx, vv] : coly[R]) {\n upd_x(upd_x, 1, 1, CX, xx, vv);\n cur_xsum[xx] += vv;\n hist.emplace_back(xx, vv);\n }\n if ((R - L) % 25 == 0 || R == CY || R == L) {\n Info infoo = (CX >= 1 ? treex[1] : Info{0,0,0,0});\n ll mss = max(0LL, infoo.sub);\n if (mss > best_val) {\n int sxx, exx;\n ll act = get_kad_x(sxx, exx);\n if (act > best_val && exx > sxx && L < R) {\n int ly_y = ally[L - 1];\n int ry_y = ally[R - 1];\n int lx_x = allx[sxx - 1];\n int rx_x = allx[exx - 1];\n ll plen = 2LL * (abs(lx_x - rx_x) + abs(ly_y - ry_y));\n if (plen <= 400000LL) {\n best_val = act;\n blx = sxx;\n brx = exx;\n bly = L;\n bry = R;\n best_is_x_sweep = false;\n }\n }\n }\n }\n }\n for (int i = (int)hist.size() - 1; i >= 0; i--) {\n auto [xx, vv] = hist[i];\n upd_x(upd_x, 1, 1, CX, xx, -vv);\n cur_xsum[xx] -= vv;\n }\n }\n }\n if (best_val <= 0 || blx == -1) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n int x1 = allx[blx - 1], x2 = allx[brx - 1];\n int y1 = ally[bly - 1], y2 = ally[bry - 1];\n // simple shrink heuristic on each side if possible\n auto try_shrink = [&](int dx1, int dx2, int dy1, int dy2) {\n // only try very localized shrink inside the fish grid\n ll plen = 2LL * (abs(x2 - x1) + abs(y2 - y1));\n if (plen > 400000LL) return false;\n return false; // safe no-op\n };\n if (x1 == x2 || y1 == y2) {\n cout << 4 << \"\\n\";\n cout << 0 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 0 << \"\\n\";\n cout << 100 << \" \" << 100 << \"\\n\";\n cout << 0 << \" \" << 100 << \"\\n\";\n } else {\n cout << 4 << \"\\n\";\n cout << x1 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y1 << \"\\n\";\n cout << x2 << \" \" << y2 << \"\\n\";\n cout << x1 << \" \" << y2 << \"\\n\";\n }\n }\n}","ahc040":"#include \nusing namespace std;\nusing ll = long long;\n\nstruct Strat {\n double wa, wb;\n bool use_area;\n int force_d;\n};\n\nll calc_bbox(const vector& WW, const vector& HH, const vector& rots, const vector& dirs, const vector& brefs) {\n int n = WW.size();\n vector px(n, 0), py(n, 0), pww(n, 0), phh(n, 0);\n ll cmw = 0, cmh = 0;\n for (int i = 0; i < n; i++) {\n int r = rots[i];\n ll ww = r ? HH[i] : WW[i];\n ll hh = r ? WW[i] : HH[i];\n int dd = dirs[i];\n int b = brefs[i];\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n if (max(yy, py[j]) < min(yy + hh, py[j] + phh[j])) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n if (max(xx, px[j]) < min(xx + ww, px[j] + pww[j])) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n px[i] = xx; py[i] = yy; pww[i] = ww; phh[i] = hh;\n cmw = max(cmw, xx + ww);\n cmh = max(cmh, yy + hh);\n }\n return cmw + cmh;\n}\n\nint main() {\n int N, T, sigma;\n cin >> N >> T >> sigma;\n vector W(N), H(N);\n for (int i = 0; i < N; i++) {\n cin >> W[i] >> H[i];\n }\n vector strats = {\n {1.0, 1.0, false, -1},\n {2.0, 1.0, false, -1},\n {1.0, 2.0, false, -1},\n {3.0, 1.0, false, -1},\n {1.0, 3.0, false, -1},\n {5.0, 1.0, false, -1},\n {1.0, 5.0, false, -1},\n {10.0, 1.0, false, -1},\n {1.0, 10.0, false, -1},\n {0.0, 0.0, true, -1},\n {1.0, 1.0, false, 0},\n {1.0, 1.0, false, 1}\n };\n mt19937 rng(12345);\n int ns = strats.size();\n vector, vector, vector>> top_configs;\n const int max_top = 10;\n for (int t = 0; t < T; t++) {\n vector rotv(N), dirv(N), bref(N);\n bool do_random = (t % 7 == 0);\n bool do_perturb = (!do_random && t % 3 == 1 && !top_configs.empty() && t > 3);\n if (do_random) {\n for (int i = 0; i < N; i++) {\n rotv[i] = rng() % 2;\n dirv[i] = rng() % 2;\n bref[i] = (i > 0 ? (rng() % i) : -1);\n }\n } else if (do_perturb) {\n int idx = rng() % top_configs.size();\n auto& tp = top_configs[idx];\n rotv = get<1>(tp);\n dirv = get<2>(tp);\n bref = get<3>(tp);\n vector bestv_rot = rotv, bestv_dir = dirv, bestv_bref = bref;\n ll best_bbox = calc_bbox(W, H, bestv_rot, bestv_dir, bestv_bref);\n for (int iter = 0; iter < 200; iter++) {\n vector temp_rot = bestv_rot;\n vector temp_dir = bestv_dir;\n vector temp_bref = bestv_bref;\n int pos = rng() % N;\n if (rng() % 2 == 0) temp_rot[pos] = 1 - temp_rot[pos];\n if (rng() % 2 == 0) temp_dir[pos] = 1 - temp_dir[pos];\n if (pos > 0) {\n int rch = rng() % 7;\n if (rch <= 2) {\n int del = (rng() % 5 - 2);\n temp_bref[pos] = max(-1, min(pos - 1, temp_bref[pos] + del));\n } else if (rch == 3) {\n temp_bref[pos] = rng() % pos;\n } else if (rch == 4) {\n int del = (rng() % 11 - 5);\n temp_bref[pos] = max(-1, min(pos - 1, temp_bref[pos] + del));\n } else if (rch == 5) {\n int del = (rng() % 5 - 2);\n temp_bref[pos] = max(-1, min(pos - 1, temp_bref[pos] + del));\n }\n }\n ll sc = calc_bbox(W, H, temp_rot, temp_dir, temp_bref);\n if (sc < best_bbox) {\n best_bbox = sc;\n bestv_rot = temp_rot;\n bestv_dir = temp_dir;\n bestv_bref = temp_bref;\n }\n }\n rotv = bestv_rot;\n dirv = bestv_dir;\n bref = bestv_bref;\n } else {\n Strat st = strats[t % ns];\n vector px(N, 0), py(N, 0), pww(N, 0), phh(N, 0);\n ll cmaxw = 0, cmaxh = 0;\n for (int i = 0; i < N; i++) {\n double bestc = 1e30;\n int br = -1, bd = -1, bb = -1;\n ll bx = 0, by = 0, bww = 0, bhh = 0;\n vector bs_vec;\n for (int b = -1; b < i; b++) bs_vec.push_back(b);\n for (int r = 0; r < 2; r++) {\n ll ww = r ? H[i] : W[i];\n ll hh = r ? W[i] : H[i];\n for (int dd = 0; dd < 2; dd++) {\n if (st.force_d >= 0 && dd != st.force_d) continue;\n for (int b : bs_vec) {\n ll xx = 0, yy = 0;\n if (dd == 0) { // L\n if (b >= 0) yy = py[b] + phh[b];\n else yy = 0;\n xx = 0;\n for (int j = 0; j < i; j++) {\n if (max(yy, py[j]) < min(yy + hh, py[j] + phh[j])) {\n xx = max(xx, px[j] + pww[j]);\n }\n }\n } else { // U\n if (b >= 0) xx = px[b] + pww[b];\n else xx = 0;\n yy = 0;\n for (int j = 0; j < i; j++) {\n if (max(xx, px[j]) < min(xx + ww, px[j] + pww[j])) {\n yy = max(yy, py[j] + phh[j]);\n }\n }\n }\n ll nw = max(cmaxw, xx + ww);\n ll nh = max(cmaxh, yy + hh);\n double cost;\n if (st.use_area) {\n cost = 1.0 * nw * nh;\n } else {\n cost = st.wa * nw + st.wb * nh;\n }\n cost += (rng() % 1001 - 500) * 1e-5;\n if (cost < bestc) {\n bestc = cost;\n br = r;\n bd = dd;\n bb = b;\n bx = xx;\n by = yy;\n bww = ww;\n bhh = hh;\n }\n }\n }\n }\n rotv[i] = br;\n dirv[i] = bd;\n bref[i] = bb;\n px[i] = bx;\n py[i] = by;\n pww[i] = bww;\n phh[i] = bhh;\n cmaxw = max(cmaxw, bx + bww);\n cmaxh = max(cmaxh, by + bhh);\n }\n }\n cout << N << endl;\n for (int i = 0; i < N; i++) {\n cout << i << \" \" << rotv[i] << \" \" << (dirv[i] ? \"U\" : \"L\") << \" \" << bref[i] << endl;\n }\n cout.flush();\n ll wp, hp;\n cin >> wp >> hp;\n ll meas = wp + hp;\n bool added_top = false;\n if (top_configs.size() < max_top) {\n added_top = true;\n } else if (!top_configs.empty() && meas + 3LL * sigma < get<0>(top_configs.back())) {\n added_top = true;\n }\n if (added_top) {\n auto tup = make_tuple(meas, rotv, dirv, bref);\n top_configs.push_back(tup);\n sort(top_configs.begin(), top_configs.end());\n if (top_configs.size() > max_top) {\n top_configs.resize(max_top);\n }\n }\n }\n return 0;\n}","ahc041":"#include \nusing namespace std;\n\nint main() {\n int N, M, H;\n cin >> N >> M >> H;\n vector A(N);\n for (int i = 0; i < N; i++) cin >> A[i];\n vector> adj(N);\n for (int i = 0; i < M; i++) {\n int u, v;\n cin >> u >> v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n vector X(N), Y(N);\n for (int i = 0; i < N; i++) {\n cin >> X[i] >> Y[i];\n }\n long long best_score = -1;\n vector best_p(N, -1);\n // Mode 0: prefer high promotion\n for (int mode = 0; mode < 3; mode++) {\n vector level(N, 0);\n vector p(N, -1);\n long long score = 0;\n if (mode < 2) {\n bool prefer_high = (mode == 0);\n bool changed = true;\n int max_iter = N * H + 100;\n int iter = 0;\n while (changed && iter++ < max_iter) {\n changed = false;\n long long best_a = prefer_high ? -1 : LLONG_MAX;\n int best_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] < H) {\n bool can = false;\n for (int u : adj[v]) {\n if (level[u] == level[v]) {\n can = true;\n break;\n }\n }\n if (can) {\n if (prefer_high) {\n if (A[v] > best_a) {\n best_a = A[v];\n best_v = v;\n }\n } else {\n if (A[v] < best_a) {\n best_a = A[v];\n best_v = v;\n }\n }\n }\n }\n }\n if (best_v != -1) {\n level[best_v]++;\n changed = true;\n }\n }\n iter = 0;\n while (iter++ < max_iter) {\n long long worst_a = LLONG_MAX;\n int worst_v = -1;\n for (int v = 0; v < N; v++) {\n if (level[v] > 0) {\n bool has = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n has = true;\n break;\n }\n }\n if (!has && A[v] < worst_a) {\n worst_a = A[v];\n worst_v = v;\n }\n }\n }\n if (worst_v != -1) {\n level[worst_v]--;\n } else {\n break;\n }\n }\n bool valid = true;\n for (int v = 0; v < N; v++) {\n if (level[v] == 0) {\n p[v] = -1;\n } else {\n bool found = false;\n for (int u : adj[v]) {\n if (level[u] == level[v] - 1) {\n p[v] = u;\n found = true;\n break;\n }\n }\n if (!found) valid = false;\n }\n }\n if (!valid) continue;\n score = 0;\n for (int v = 0; v < N; v++) {\n score += level[v] * A[v];\n }\n } else {\n // Mode 2: greedy attach low A first max depth\n vector depth(N, -1);\n p.assign(N, -1);\n vector> order(N);\n for (int i = 0; i < N; i++) order[i] = {A[i], i};\n sort(order.begin(), order.end());\n for (auto& pr : order) {\n int v = pr.second;\n int max_par_d = -1;\n int best_par = -1;\n for (int u : adj[v]) {\n if (depth[u] != -1 && depth[u] < H) {\n if (depth[u] > max_par_d) {\n max_par_d = depth[u];\n best_par = u;\n }\n }\n }\n if (max_par_d != -1) {\n depth[v] = max_par_d + 1;\n p[v] = best_par;\n } else {\n depth[v] = 0;\n p[v] = -1;\n }\n }\n score = 0;\n bool valid = true;\n for (int v = 0; v < N; v++) {\n if (depth[v] == -1) valid = false;\n else score += depth[v] * A[v];\n }\n if (!valid) continue;\n level = depth; // for consistency, but not needed\n }\n if (score > best_score) {\n best_score = score;\n best_p = p;\n }\n }\n if (best_score == -1) {\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << -1;\n }\n cout << endl;\n } else {\n for (int i = 0; i < N; i++) {\n if (i > 0) cout << \" \";\n cout << best_p[i];\n }\n cout << endl;\n }\n return 0;\n}","ahc042":"#include \nusing namespace std;\n\nint NN;\nvector board;\nvector> moves;\n\nvoid do_shift(char d, int p) {\n if (d == 'L') {\n for (int j = 0; j < NN - 1; j++) board[p][j] = board[p][j + 1];\n board[p][NN - 1] = '.';\n } else if (d == 'R') {\n for (int j = NN - 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 < NN - 1; i++) board[i][p] = board[i + 1][p];\n board[NN - 1][p] = '.';\n } else if (d == 'D') {\n for (int i = NN - 1; i > 0; i--) board[i][p] = board[i - 1][p];\n board[0][p] = '.';\n }\n}\n\nint main() {\n srand(time(NULL));\n int N;\n cin >> N;\n NN = N;\n board.resize(N);\n for (int i = 0; i < N; i++) cin >> board[i];\n vector orig_board = board;\n vector> best_moves;\n int minT = INT_MAX;\n for (int trial = 0; trial < 200; trial++) {\n board = orig_board;\n moves.clear();\n int iter = 0;\n while (true) {\n int numx = 0;\n for (auto& s : board) for (char c : s) if (c == 'x') numx++;\n if (numx == 0) break;\n if (++iter > 10000) break;\n double best_r = -1;\n char best_d = ' ';\n int best_p = -1;\n int best_k = 0;\n int best_n = 0;\n int best_c = 1000000000;\n bool use_pert = (trial % 5 != 0);\n // rows left\n for (int i = 0; i < N; i++) {\n int maxj = -1, nm = 0;\n for (int j = 0; j < N; j++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxj = j; nm++; }\n }\n if (nm > 0) {\n int kk = maxj + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'L';\n best_p = i;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n // rows right\n for (int i = 0; i < N; i++) {\n int lmost = N;\n for (int j = N - 1; j >= 0; j--) {\n if (board[i][j] == 'o') { lmost = j + 1; break; }\n }\n int minj = N, nm = 0;\n for (int j = lmost; j < N; j++) {\n if (board[i][j] == 'x') { minj = min(minj, j); nm++; }\n }\n if (nm > 0) {\n int kk = N - minj;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'R';\n best_p = i;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n // cols up\n for (int j = 0; j < N; j++) {\n int maxi = -1, nm = 0;\n for (int i = 0; i < N; i++) {\n if (board[i][j] == 'o') break;\n if (board[i][j] == 'x') { maxi = i; nm++; }\n }\n if (nm > 0) {\n int kk = maxi + 1;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'U';\n best_p = j;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n // cols down\n for (int j = 0; j < N; j++) {\n int lmost = N;\n for (int i = N - 1; i >= 0; i--) {\n if (board[i][j] == 'o') { lmost = i + 1; break; }\n }\n int mini = N, nm = 0;\n for (int i = lmost; i < N; i++) {\n if (board[i][j] == 'x') { mini = min(mini, i); nm++; }\n }\n if (nm > 0) {\n int kk = N - mini;\n int cc = 2 * kk;\n double rt = nm * 1.0 / cc;\n if (use_pert) rt += (rand() % 1001 - 500) * 0.00005;\n bool better = false;\n if (rt > best_r + 1e-9 || (fabs(rt - best_r) < 1e-9 && (cc < best_c || (cc == best_c && nm > best_n)))) better = true;\n if (better) {\n best_r = rt;\n best_d = 'D';\n best_p = j;\n best_k = kk;\n best_n = nm;\n best_c = cc;\n }\n }\n }\n if (best_p == -1) break;\n char dd = best_d;\n int p = best_p;\n int kk = best_k;\n char op = (dd == 'L' ? 'R' : (dd == 'R' ? 'L' : (dd == 'U' ? 'D' : 'U')));\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(dd, p);\n do_shift(dd, p);\n }\n for (int t = 0; t < kk; t++) {\n moves.emplace_back(op, p);\n do_shift(op, p);\n }\n }\n int curT = moves.size();\n if (curT < minT) {\n minT = curT;\n best_moves = moves;\n }\n }\n for (auto [d, pp] : best_moves) {\n cout << d << \" \" << pp << endl;\n }\n}","ahc044":"#include \nusing namespace std;\nusing ll = long long;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, L;\n cin >> N >> L;\n static int T[100];\n for(int i = 0; i < N; i++) cin >> T[i];\n static ll pref[101];\n pref[0] = 0;\n for(int j = 0; j < N; j++) {\n pref[j + 1] = pref[j] + T[j] + 1;\n }\n ll total = pref[N];\n mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());\n auto get_sample = [&](ll p[], ll tot) -> int {\n ll r = uniform_int_distribution(0, tot - 1)(rng);\n int low = 0, high = N;\n while(low < high) {\n int mid = (low + high) / 2;\n if(p[mid] > r) high = mid;\n else low = mid + 1;\n }\n return low - 1;\n };\n static int best_a[100], best_b[100], best_cnt[100];\n static int tmp_a[100], tmp_b[100], tmp_cnt[100];\n static ll def_pref[101];\n auto do_sim = [&](int A[], int B[], int* cnt) -> int {\n memset(cnt, 0, sizeof(int) * N);\n int cur = 0;\n for(int w = 1; w <= L; w++) {\n cnt[cur]++;\n if(w < L) {\n if(cnt[cur] % 2 == 1) cur = A[cur];\n else cur = B[cur];\n }\n }\n int err = 0;\n for(int i = 0; i < N; i++) {\n err += abs(cnt[i] - T[i]);\n }\n return err;\n };\n // mix greedy and random inits\n int num_inits = 80;\n int best_err = INT_MAX;\n static int greedy_idx[100];\n for(int init = 0; init < num_inits; init++) {\n int AA[100], BB[100];\n if (init % 3 == 0) {\n // random biased\n for(int i = 0; i < N; i++) {\n AA[i] = get_sample(pref, total);\n BB[i] = get_sample(pref, total);\n }\n } else {\n // greedy shuffle\n for(int i = 0; i < N; i++) greedy_idx[i] = i;\n shuffle(greedy_idx, greedy_idx + N, rng);\n double inflow[100] = {0};\n for(int k = 0; k < N; k++) {\n int i = greedy_idx[k];\n int b1 = -1, b2 = -1;\n double d1 = -1e18, d2 = -1e18;\n for(int j = 0; j < N; j++) {\n double d = T[j] - inflow[j];\n if(d > d1) {\n d2 = d1; b2 = b1;\n d1 = d; b1 = j;\n } else if(d > d2) {\n d2 = d; b2 = j;\n }\n }\n if(b2 == -1) b2 = b1;\n if(b1 == b2) {\n inflow[b1] += T[i];\n } else {\n inflow[b1] += T[i] * 0.5 + 0.25;\n inflow[b2] += T[i] * 0.5 - 0.25;\n }\n AA[i] = b1;\n BB[i] = b2;\n }\n }\n int err = do_sim(AA, BB, tmp_cnt);\n if(err < best_err) {\n best_err = err;\n memcpy(best_a, AA, sizeof(int)*N);\n memcpy(best_b, BB, sizeof(int)*N);\n memcpy(best_cnt, tmp_cnt, sizeof(int)*N);\n }\n }\n const int NUM_MUT = 520;\n for(int m = 0; m < NUM_MUT; m++) {\n memcpy(tmp_a, best_a, sizeof(int)*N);\n memcpy(tmp_b, best_b, sizeof(int)*N);\n def_pref[0] = 0;\n for(int j = 0; j < N; j++) {\n int def = max(0, T[j] - best_cnt[j]);\n def_pref[j + 1] = def_pref[j] + (def + 1LL);\n }\n ll def_tot = def_pref[N];\n // smart choice of i: prefer changing those pointing to over-visited\n vector candidates;\n for(int i = 0; i < N; i++) {\n if (best_cnt[best_a[i]] > T[best_a[i]] + 50) candidates.push_back(i);\n if (best_cnt[best_b[i]] > T[best_b[i]] + 50) candidates.push_back(i);\n }\n int i;\n if (!candidates.empty()) {\n i = candidates[uniform_int_distribution(0, (int)candidates.size()-1)(rng)];\n } else {\n i = uniform_int_distribution(0, N - 1)(rng);\n }\n int choice = uniform_int_distribution(0, 1)(rng);\n if (uniform_int_distribution(0, 1)(rng) == 0) {\n // prefer over branch\n if (best_cnt[best_a[i]] > T[best_a[i]] + 50) choice = 0;\n else if (best_cnt[best_b[i]] > T[best_b[i]] + 50) choice = 1;\n }\n int news = get_sample(def_pref, def_tot);\n if(choice == 0) tmp_a[i] = news;\n else tmp_b[i] = news;\n int new_err = do_sim(tmp_a, tmp_b, tmp_cnt);\n if (new_err < best_err) {\n best_err = new_err;\n memcpy(best_a, tmp_a, sizeof(int)*N);\n memcpy(best_b, tmp_b, sizeof(int)*N);\n memcpy(best_cnt, tmp_cnt, sizeof(int)*N);\n }\n }\n for(int i = 0; i < N; i++) {\n cout << best_a[i] << \" \" << best_b[i] << \"\\n\";\n }\n return 0;\n}","ahc045":"#include \nusing namespace std;\n\nstruct Edge {\n int u, v;\n double d;\n};\n\nint main() {\n int N, M, Q, L, W;\n cin >> N >> M >> Q >> L >> W;\n vector G(M);\n for (int &g : G) cin >> g;\n vector cx(N), cy(N);\n vector Lx(N), Rx(N), Ly(N), Ry(N);\n for (int i = 0; i < N; i++) {\n cin >> Lx[i] >> Rx[i] >> Ly[i] >> Ry[i];\n cx[i] = (Lx[i] + Rx[i]) / 2.0;\n cy[i] = (Ly[i] + Ry[i]) / 2.0;\n }\n vector>> near(N);\n for (int i = 0; i < N; i++) {\n for (int j = 0; j < N; j++) {\n if (i != j) {\n double d = hypot(cx[i] - cx[j], cy[i] - cy[j]);\n near[i].emplace_back(d, j);\n }\n }\n sort(near[i].begin(), near[i].end());\n if (near[i].size() > 20) near[i].resize(20);\n }\n vector> known_global;\n set> known_set;\n int q_disc = Q / 2;\n int queries_done = 0;\n for (int q = 0; q < q_disc && queries_done < q_disc; q++) {\n int base = (q * 3) % N;\n vector cset = {base};\n set in_set = {base};\n for (auto &pr : near[base]) {\n if ((int)cset.size() >= L) break;\n if (in_set.find(pr.second) == in_set.end()) {\n cset.push_back(pr.second);\n in_set.insert(pr.second);\n }\n }\n if (cset.size() < 2) continue;\n cout << \"? \" << cset.size();\n for (int p : cset) cout << \" \" << p;\n cout << endl;\n int lsize = cset.size();\n vector> resp(lsize - 1);\n for (int r = 0; r < lsize - 1; r++) {\n int a, b;\n cin >> a >> b;\n if (a > b) swap(a, b);\n resp[r] = {a, b};\n }\n for (auto p : resp) {\n if (known_set.find(p) == known_set.end()) {\n known_set.insert(p);\n known_global.push_back(p);\n }\n }\n queries_done++;\n }\n // build priority MST\n vector prio_known;\n for (auto &pr : known_global) {\n int a = pr.first, b = pr.second;\n double d = hypot(cx[a] - cx[b], cy[a] - cy[b]);\n prio_known.push_back({a, b, d});\n }\n sort(prio_known.begin(), prio_known.end(), [](const Edge &a, const Edge &b){ return a.d < b.d; });\n vector par(N); iota(par.begin(), par.end(), 0);\n auto findp = [&](auto self, int x) -> int { return par[x] == x ? x : par[x] = self(self, par[x]); };\n vector> adj_prio(N);\n for (auto &e : prio_known) {\n int pu = findp(findp, e.u), pv = findp(findp, e.v);\n if (pu != pv) {\n par[pu] = pv;\n adj_prio[e.u].push_back(e.v);\n adj_prio[e.v].push_back(e.u);\n }\n }\n vector est_rem;\n for (int i=0;i order;\n vector vis(N, false);\n function dfs_p = [&](int u, int p){\n vis[u]=true;\n order.push_back(u);\n for(int v:adj_prio[u]) if(!vis[v]&&v!=p) dfs_p(v,u);\n };\n dfs_p(0,-1);\n if(order.size() < (size_t)N){\n vis.assign(N,false);\n for(int i=0;i> groups(M);\n int idxx = 0;\n for(int k=0;k &grp = groups[k];\n int gs = grp.size();\n if(gs <= 1) continue;\n int i = 0;\n while(i < gs-1 && queries_done < Q){\n int len = min(L, gs-i);\n if(len < 2) break;\n cout << \"? \" << len;\n for(int p=i; p> resp(len-1);\n for(int r=0;r>a>>b; if(a>b)swap(a,b); resp[r]={a,b};\n }\n for(auto p:resp){\n if(known_set.find(p)==known_set.end()){\n known_set.insert(p);\n known_global.push_back(p);\n }\n }\n queries_done++;\n if(i + len >= gs) break;\n i += max(1, adv_base);\n }\n }\n // additional offset pass for remaining\n for(int k=0; k &grp = groups[k];\n int gs = grp.size();\n if(gs <=1) continue;\n int off = 1;\n int step = max(1, adv_base / 2);\n int i = step;\n while(i < gs-2 && queries_done < Q && off < 3){\n int len = min(L, gs - i);\n if(len < 2) break;\n cout << \"? \" << len;\n for(int p=i; p> resp(len-1);\n for(int r=0;r>a>>b; if(a>b)swap(a,b); resp[r]={a,b};\n }\n for(auto p:resp){\n if(known_set.find(p)==known_set.end()){\n known_set.insert(p);\n known_global.push_back(p);\n }\n }\n queries_done++;\n if(queries_done >=Q) break;\n i += step;\n off++;\n }\n }\n cout << \"!\" << endl;\n for(int k=0;k grp = groups[k];\n int gs = grp.size();\n for(int j=0;j> knownp(known_global.begin(), known_global.end());\n vector> known_list;\n vector local_id(N,-1);\n for(int j=0;j parent(gs); iota(parent.begin(),parent.end(),0);\n auto find = [&](auto &self,int x)->int{return parent[x]==x?x:parent[x]=self(self,parent[x]);};\n auto unite=[&](int x,int y)->bool{ x=find(find,x);y=find(find,y); if(x!=y){parent[x]=y;return true;} return false;};\n vector> mst_roads;\n int added=0;\n for(auto &[d,ia,ib]:known_list){\n if(unite(ia,ib)){ mst_roads.emplace_back(grp[ia],grp[ib]); added++;}\n if(added==gs-1) break;\n }\n if(added < gs-1){\n vector> unk;\n for(int ii=0;ii pp={min(a,b),max(a,b)};\n if(knownp.find(pp)!=knownp.end()) continue;\n double d = hypot(cx[a]-cx[b],cy[a]-cy[b]);\n unk.emplace_back(d,ii,jj);\n }\n sort(unk.begin(),unk.end());\n for(auto &[d,ia,ib]:unk){\n if(unite(ia,ib)){mst_roads.emplace_back(grp[ia],grp[ib]); added++;}\n if(added==gs-1) break;\n }\n }\n for(auto &rd:mst_roads){\n cout << rd.first << \" \" << rd.second << endl;\n }\n }\n return 0;\n}","ahc046":"#include \nusing namespace std;\n\nint main() {\n int N, M;\n cin >> N >> M;\n vector> points(M);\n for (int m = 0; m < M; m++) {\n cin >> points[m].first >> points[m].second;\n }\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n char dchar[4] = {'U', 'D', 'L', 'R'};\n pair current = points[0];\n vector> seq;\n for (int k = 1; k < M; k++) {\n pair goal = points[k];\n set> forbidden;\n for (int t = k + 1; t < M; t++) {\n forbidden.insert(points[t]);\n }\n vector> dist(N, vector(N, -1));\n vector>> prevpos(N, vector>(N, {-1, -1}));\n vector>> prevact(N, vector>(N, {' ', ' '}));\n queue> q;\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n // M actions\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n // S actions\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (forbidden.count({ni, nj})) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Fallback: no forbidden, allow all\n forbidden.clear();\n dist.assign(N, vector(N, -1));\n prevpos.assign(N, vector>(N, {-1, -1}));\n prevact.assign(N, vector>(N, {' ', ' '}));\n q = queue>();\n dist[current.first][current.second] = 0;\n q.push(current);\n while (!q.empty()) {\n auto [ci, cj] = q.front();\n q.pop();\n for (int d = 0; d < 4; d++) {\n int ni = ci + di[d];\n int nj = cj + dj[d];\n if (ni < 0 || ni >= N || nj < 0 || nj >= N) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'M', dchar[d]};\n q.push({ni, nj});\n }\n }\n for (int d = 0; d < 4; d++) {\n int ni = ci;\n int nj = cj;\n while (true) {\n int ti = ni + di[d];\n int tj = nj + dj[d];\n if (ti < 0 || ti >= N || tj < 0 || tj >= N) break;\n ni = ti;\n nj = tj;\n }\n if (ni == ci && nj == cj) continue;\n if (dist[ni][nj] == -1) {\n dist[ni][nj] = dist[ci][cj] + 1;\n prevpos[ni][nj] = {ci, cj};\n prevact[ni][nj] = {'S', dchar[d]};\n q.push({ni, nj});\n }\n }\n }\n }\n if (dist[goal.first][goal.second] == -1) {\n // Still unreachable, fallback to pure M manhattan path, allowing everything\n // Compute simple horiz then vert M path\n vector> path;\n int ci = current.first, cj = current.second;\n int gi = goal.first, gj = goal.second;\n int stepi, stepj;\n stepi = (gi > ci ? 1 : (gi < ci ? -1 : 0));\n for (int s = 0; s < abs(gi - ci); s++) {\n path.push_back({'M', (stepi > 0 ? 'D' : 'U')});\n }\n stepj = (gj > cj ? 1 : (gj < cj ? -1 : 0));\n for (int s = 0; s < abs(gj - cj); s++) {\n path.push_back({'M', (stepj > 0 ? 'R' : 'L')});\n }\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n continue;\n }\n // Reconstruct path\n vector> path;\n pair pos = goal;\n while (pos != current) {\n pair act = prevact[pos.first][pos.second];\n path.push_back(act);\n pos = prevpos[pos.first][pos.second];\n }\n reverse(path.begin(), path.end());\n seq.insert(seq.end(), path.begin(), path.end());\n current = goal;\n }\n for (auto& p : seq) {\n cout << p.first << \" \" << p.second << endl;\n }\n return 0;\n}"}}}