{"model_name":"gpt-5","codes":{"1":{"ahc001":"#include \nusing namespace std;\n\n// Heuristic rectangle growth with spatial hashing.\n// Compile with -O2 -std=gnu++20\n\nstruct Rect {\n int a,b,c,d; // [a,c) x [b,d), integers, a not counted as overlap; this function returns true only if positive overlap\n return true;\n}\n\nstruct Hasher {\n size_t operator()(const pair& p) const noexcept {\n return (size_t)p.first * 1000003u ^ (size_t)p.second;\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int n;\n if (!(cin >> n)) return 0;\n vector x(n), y(n);\n vector r(n);\n for (int i=0;i> x[i] >> y[i] >> r[i];\n }\n\n // Initialize rectangles as 1x1 including (xi+0.5, yi+0.5): [xi,xi+1) x [yi,yi+1)\n vector rect(n);\n for (int i=0;i> buckets(GRID*GRID);\n auto cell_id = [&](int gx, int gy){ return gy*GRID + gx; };\n auto gx_from_x = [&](int X){ return min(GRID-1, max(0, X / G)); };\n auto gy_from_y = [&](int Y){ return min(GRID-1, max(0, Y / G)); };\n\n auto add_rect = [&](int id){\n auto &R = rect[id];\n int gx0 = gx_from_x(R.a);\n int gx1 = gx_from_x(max(0,R.c-1));\n int gy0 = gy_from_y(R.b);\n int gy1 = gy_from_y(max(0,R.d-1));\n for (int gy=gy0; gy<=gy1; ++gy)\n for (int gx=gx0; gx<=gx1; ++gx)\n buckets[cell_id(gx,gy)].push_back(id);\n };\n auto remove_rect = [&](int id){\n auto &R = rect[id];\n int gx0 = gx_from_x(R.a);\n int gx1 = gx_from_x(max(0,R.c-1));\n int gy0 = gy_from_y(R.b);\n int gy1 = gy_from_y(max(0,R.d-1));\n for (int gy=gy0; gy<=gy1; ++gy)\n for (int gx=gx0; gx<=gx1; ++gx) {\n auto &v = buckets[cell_id(gx,gy)];\n // remove id from v (v is small)\n for (size_t k=0;k(now() - start_time).count();\n };\n\n vector order(n);\n iota(order.begin(), order.end(), 0);\n\n // Helper: check if expanding rect i by one unit on side s is feasible (no overlap and within bounds)\n // s: 0=left,1=right,2=down,3=up\n auto can_expand = [&](int i, int s)->bool{\n const Rect &R = rect[i];\n if (s==0) { // left\n if (R.a <= 0) return false;\n Rect NR = R; NR.a = R.a - 1;\n // band is [R.a-1,R.a) x [R.b,R.d)\n int x0 = NR.a, x1 = R.a;\n int y0 = R.b, y1 = R.d;\n int gx0 = gx_from_x(x0);\n int gx1 = gx_from_x(max(0,x1-1));\n int gy0 = gy_from_y(y0);\n int gy1 = gy_from_y(max(0,y1-1));\n for (int gy=gy0; gy<=gy1; ++gy)\n for (int gx=gx0; gx<=gx1; ++gx){\n for (int id : buckets[cell_id(gx,gy)]) {\n if (id==i) continue;\n if (overlap_pos(NR, rect[id])) return false;\n }\n }\n return true;\n } else if (s==1) { // right\n if (R.c >= 10000) return false;\n Rect NR = R; NR.c = R.c + 1;\n int x0 = R.c, x1 = NR.c;\n int y0 = R.b, y1 = R.d;\n int gx0 = gx_from_x(x0);\n int gx1 = gx_from_x(max(0,x1-1));\n int gy0 = gy_from_y(y0);\n int gy1 = gy_from_y(max(0,y1-1));\n for (int gy=gy0; gy<=gy1; ++gy)\n for (int gx=gx0; gx<=gx1; ++gx){\n for (int id : buckets[cell_id(gx,gy)]) {\n if (id==i) continue;\n if (overlap_pos(NR, rect[id])) return false;\n }\n }\n return true;\n } else if (s==2) { // down\n if (R.b <= 0) return false;\n Rect NR = R; NR.b = R.b - 1;\n int x0 = R.a, x1 = R.c;\n int y0 = NR.b, y1 = R.b;\n int gx0 = gx_from_x(x0);\n int gx1 = gx_from_x(max(0,x1-1));\n int gy0 = gy_from_y(y0);\n int gy1 = gy_from_y(max(0,y1-1));\n for (int gy=gy0; gy<=gy1; ++gy)\n for (int gx=gx0; gx<=gx1; ++gx){\n for (int id : buckets[cell_id(gx,gy)]) {\n if (id==i) continue;\n if (overlap_pos(NR, rect[id])) return false;\n }\n }\n return true;\n } else { // up\n if (R.d >= 10000) return false;\n Rect NR = R; NR.d = R.d + 1;\n int x0 = R.a, x1 = R.c;\n int y0 = R.d, y1 = NR.d;\n int gx0 = gx_from_x(x0);\n int gx1 = gx_from_x(max(0,x1-1));\n int gy0 = gy_from_y(y0);\n int gy1 = gy_from_y(max(0,y1-1));\n for (int gy=gy0; gy<=gy1; ++gy)\n for (int gx=gx0; gx<=gx1; ++gx){\n for (int id : buckets[cell_id(gx,gy)]) {\n if (id==i) continue;\n if (overlap_pos(NR, rect[id])) return false;\n }\n }\n return true;\n }\n };\n\n auto do_expand = [&](int i, int s){\n remove_rect(i);\n if (s==0) rect[i].a--;\n else if (s==1) rect[i].c++;\n else if (s==2) rect[i].b--;\n else rect[i].d++;\n add_rect(i);\n };\n\n // Main loop\n // Prioritize deficit\n vector dirs = {0,1,2,3};\n size_t stagnation = 0;\n while (elapsed_sec() < TIME_LIMIT) {\n // Sort by deficit descending\n vector> order_def;\n order_def.reserve(n);\n for (int i=0;i= 0 ? deficit : deficit/4); // discourage overshot\n order_def.emplace_back(key, i);\n }\n sort(order_def.begin(), order_def.end(), [&](auto& L, auto& R){\n if (L.first != R.first) return L.first > R.first;\n return L.second < R.second;\n });\n\n bool any = false;\n for (auto &pr : order_def) {\n if (elapsed_sec() >= TIME_LIMIT) break;\n int i = pr.second;\n long long si = rect[i].area();\n long long ri = r[i];\n\n // Over-expansion allowance factor based on time: early more, late less\n double t = elapsed_sec() / TIME_LIMIT;\n double over_factor = 1.2 - 0.5 * t; // from 1.2 down to 0.7\n long long cap = (long long) llround(ri * over_factor);\n if (cap < (long long)ri) cap = ri; // never below ri\n\n // Try a few random directions with slight bias towards aspect balancing\n array tries;\n // shuffle dirs\n tries = {0,1,2,3};\n shuffle(tries.begin(), tries.end(), rng);\n\n // Aspect bias: if width << height and target wants larger area, prefer left/right\n int w = rect[i].c - rect[i].a;\n int h = rect[i].d - rect[i].b;\n\n int best_dir = -1;\n long double best_gain = -1e100;\n\n for (int dtry : tries) {\n if (!can_expand(i, dtry)) continue;\n long long newS = si + (dtry<=1 ? h : w);\n if (newS > cap) continue;\n // Evaluate p_i gain\n auto score = [&](long long s)->long double{\n long double mn = min(ri, s);\n long double mx = max(ri, s);\n long double ratio = mn / mx;\n long double val = 1.0L - (1.0L - ratio)*(1.0L - ratio);\n return val;\n };\n long double cur = score(si);\n long double nxt = score(newS);\n long double gain = nxt - cur;\n // bias directions to balance aspect ratio (try to get closer to square)\n int nw = w + ((dtry==0||dtry==1)?1:0);\n int nh = h + ((dtry==2||dtry==3)?1:0);\n long double aspect_pen = fabsl((long double)nw/nh - 1.0L);\n gain -= 0.00001L * aspect_pen; // small penalty\n if (gain > best_gain + 1e-18) {\n best_gain = gain;\n best_dir = dtry;\n }\n }\n if (best_dir != -1 && best_gain > -1e-18) {\n do_expand(i, best_dir);\n any = true;\n }\n }\n if (!any) {\n stagnation++;\n if (stagnation > 3) break;\n } else stagnation = 0;\n }\n\n // Output rectangles\n for (int i=0;i\nusing namespace std;\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int si, sj;\n if(!(cin>>si>>sj)) return 0;\n const int H=50, W=50;\n vector> t(H, vector(W));\n for(int i=0;i>t[i][j];\n vector> p(H, vector(W));\n for(int i=0;i>p[i][j];\n\n int M = 0;\n for(int i=0;i>> tiles(M);\n tiles.reserve(M);\n for(int i=0;i> preferred(H, vector(W, 0));\n for(int id=0; id bestv){\n bestv = p[i][j];\n bestk = k;\n }\n }\n for(int k=0;k<(int)cells.size();k++){\n auto [i,j]=cells[k];\n preferred[i][j] = (k==bestk) ? 1 : 0;\n }\n }\n\n // Serpentine index\n vector> sidx(H, vector(W, -1));\n int idx=0;\n for(int i=0;i=0;j--) sidx[i][j] = idx++;\n }\n }\n auto inb = [&](int i,int j)->bool{ return (0<=i && i ans;\n ans.reserve(H*W);\n vector visited_tile(M, 0);\n vector> visited_cell(H, vector(W, 0));\n\n int ci=si, cj=sj;\n int startTile = t[ci][cj];\n visited_tile[startTile] = 1;\n visited_cell[ci][cj] = 1;\n\n // Precompute degrees quickly function\n auto tile_not_visited = [&](int i,int j)->bool{\n return !visited_tile[t[i][j]];\n };\n auto local_deg = [&](int i,int j)->int{\n static int di[4]={-1,1,0,0};\n static int dj[4]={0,0,-1,1};\n int d=0;\n for(int k=0;k<4;k++){\n int ni=i+di[k], nj=j+dj[k];\n if(!inb(ni,nj)) continue;\n if(!visited_tile[t[ni][nj]]) d++;\n }\n return d;\n };\n\n // Movement\n static int di[4]={-1,1,0,0};\n static int dj[4]={0,0,-1,1};\n static char dc[4]={'U','D','L','R'};\n\n // We will loop until stuck or a safety iteration limit\n for(int step=0; step < H*W; step++){\n // Collect candidate neighbors\n struct Cand{\n int k, ni, nj;\n long long score;\n int pval;\n int deg;\n bool is_pref;\n int sdiff;\n };\n vector cands;\n cands.reserve(4);\n for(int k=0;k<4;k++){\n int ni=ci+di[k], nj=cj+dj[k];\n if(!inb(ni,nj)) continue;\n int tid = t[ni][nj];\n if(visited_tile[tid]) continue; // cannot revisit any tile\n int pval = p[ni][nj];\n int deg = local_deg(ni,nj);\n bool is_pref = preferred[ni][nj];\n int diff = sidx[ni][nj] - sidx[ci][cj];\n // Heuristic score\n long long sc = 0;\n // weights\n const int w_p = 100;\n const int w_pref = 30;\n const int w_flow = 10;\n const int w_deg = 3;\n sc += 1LL*w_p * pval;\n sc += 1LL*w_pref * (is_pref ? 1 : 0);\n // flow bonus: prefer increasing serp idx by small positive numbers\n int flow = 0;\n if(diff >= 1 && diff <= 3) flow = 2;\n else if(diff == 0) flow = -2;\n else if(diff < 0 && diff >= -3) flow = 1;\n else if(diff < -3) flow = -1;\n sc += 1LL*w_flow * flow;\n sc += 1LL*w_deg * deg;\n cands.push_back({k,ni,nj,sc,pval,deg,is_pref,diff});\n }\n if(cands.empty()) break;\n\n // Optional shallow lookahead: pick among top few by score, break ties by next move availability\n // Sort by score desc, then is_pref, then deg, then pval\n sort(cands.begin(), cands.end(), [&](const Cand& a, const Cand& b){\n if(a.score != b.score) return a.score > b.score;\n if(a.is_pref != b.is_pref) return a.is_pref > b.is_pref;\n if(a.deg != b.deg) return a.deg > b.deg;\n if(a.pval != b.pval) return a.pval > b.pval;\n return a.sdiff > b.sdiff;\n });\n\n // Choose best\n auto best = cands[0];\n // Move\n ans.push_back(dc[best.k]);\n ci = best.ni; cj = best.nj;\n int tid = t[ci][cj];\n visited_tile[tid] = 1;\n visited_cell[ci][cj] = 1;\n }\n\n // Output\n string s(ans.begin(), ans.end());\n cout<\nusing namespace std;\n\nstruct FastIO {\n static void flush() { cout.flush(); }\n};\n\nstruct GridRouter {\n static constexpr int HN = 30;\n static constexpr int WN = 30;\n static constexpr int HHE = HN * (WN - 1); // horizontal edges count 30*29=870\n static constexpr int HVE = (HN - 1) * WN; // vertical edges count 29*30=870\n static constexpr int E = HHE + HVE; // 1740\n\n // map edge ids\n static int idH(int i, int j) { return i * (WN - 1) + j; }\n static int idV(int i, int j) { return HHE + i * WN + j; }\n static bool inb(int i, int j) { return 0 <= i && i < HN && 0 <= j && j < WN; }\n\n vector w; // edge weights\n vector> adjIdx[HN][WN]; // (neighbor node index, edge id)\n mt19937 rng;\n\n GridRouter() : w(E, 5000.0) {\n rng.seed(std::chrono::high_resolution_clock::now().time_since_epoch().count());\n buildGraph();\n }\n\n int nodeId(int i, int j) const { return i * WN + j; }\n pair nodePos(int id) const { return {id / WN, id % WN}; }\n\n void buildGraph() {\n for (int i = 0; i < HN; ++i) for (int j = 0; j < WN; ++j) adjIdx[i][j].clear();\n for (int i = 0; i < HN; ++i) {\n for (int j = 0; j < WN - 1; ++j) {\n int e = idH(i,j);\n int u = nodeId(i,j), v = nodeId(i,j+1);\n adjIdx[i][j].push_back({v, e});\n adjIdx[i][j+1].push_back({u, e});\n }\n }\n for (int i = 0; i < HN - 1; ++i) {\n for (int j = 0; j < WN; ++j) {\n int e = idV(i,j);\n int u = nodeId(i,j), v = nodeId(i+1,j);\n adjIdx[i][j].push_back({v, e});\n adjIdx[i+1][j].push_back({u, e});\n }\n }\n }\n\n struct DRes {\n vector prevNode;\n vector prevEdge;\n vector pathEdges;\n string pathMoves;\n double pathCost;\n };\n\n // Dijkstra with optional per-query randomization factor on edges to encourage exploration\n DRes shortestPath(pair s, pair t, double randEps, uint64_t randSeed) {\n int N = HN * WN;\n vector dist(N, numeric_limits::infinity());\n vector prevN(N, -1), prevE(N, -1);\n int sId = nodeId(s.first, s.second);\n int tId = nodeId(t.first, t.second);\n\n // prepare random multipliers if needed\n vector mult;\n if (randEps > 0) {\n mult.assign(E, 1.0f);\n // Use a simple hash PRNG based on seed for determinism per query\n uint64_t x = randSeed ? randSeed : rng();\n auto nextRand = [&]() {\n x ^= x << 13; x ^= x >> 7; x ^= x << 17;\n return x;\n };\n for (int e = 0; e < E; ++e) {\n // uniform in [-1,1]\n uint64_t r = nextRand();\n double u = ((r >> 11) & 0xFFFFFFFFull) / double(0xFFFFFFFFull);\n double z = 2.0*u - 1.0;\n mult[e] = float(1.0 + randEps * z);\n }\n }\n\n using P = pair;\n priority_queue, greater

> pq;\n dist[sId] = 0.0;\n pq.emplace(0.0, sId);\n\n while (!pq.empty()) {\n auto [d,u] = pq.top(); pq.pop();\n if (d != dist[u]) continue;\n if (u == tId) break;\n auto [ui, uj] = nodePos(u);\n for (auto [v, e] : adjIdx[ui][uj]) {\n double ew = w[e];\n if (!mult.empty()) ew *= mult[e];\n // safety clamp\n if (ew < 100.0) ew = 100.0;\n if (ew > 20000.0) ew = 20000.0;\n double nd = d + ew;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevN[v] = u;\n prevE[v] = e;\n pq.emplace(nd, v);\n }\n }\n }\n\n DRes res;\n res.prevNode = move(prevN);\n res.prevEdge = move(prevE);\n res.pathCost = dist[tId];\n\n // reconstruct path edges and moves\n vector edges;\n string moves;\n int cur = tId;\n while (cur != sId && res.prevEdge[cur] != -1) {\n int e = res.prevEdge[cur];\n edges.push_back(e);\n auto [pi, pj] = nodePos(res.prevNode[cur]);\n auto [ci, cj] = nodePos(cur);\n if (ci == pi) {\n // horizontal\n if (cj == pj + 1) moves.push_back('R');\n else moves.push_back('L');\n } else {\n // vertical\n if (ci == pi + 1) moves.push_back('D');\n else moves.push_back('U');\n }\n cur = res.prevNode[cur];\n }\n reverse(edges.begin(), edges.end());\n reverse(moves.begin(), moves.end());\n res.pathEdges = move(edges);\n res.pathMoves = move(moves);\n return res;\n }\n\n void updateWeights(const vector& pathEdges, long long observed, int qIndex) {\n if (pathEdges.empty()) return;\n double pred = 0.0;\n for (int e : pathEdges) pred += w[e];\n if (pred <= 1e-6) return;\n\n double y = (double)observed;\n // Compute scaling, clipped\n double s = y / pred;\n s = max(0.9, min(1.1, s));\n\n // Learning rate schedule: start higher, decay\n double eta0 = 0.35;\n double eta1 = 0.05;\n double progress = (double)qIndex / 999.0;\n double eta = eta0 * (1.0 - progress) + eta1 * progress;\n\n // Update multiplicatively on used edges\n double factor = 1.0 + eta * (s - 1.0);\n // Clamp factor slightly to be safe\n factor = max(0.95, min(1.05, factor));\n\n for (int e : pathEdges) {\n w[e] *= factor;\n }\n\n // Mild smoothing to neighbors of same row/col to reduce variance\n double beta = 0.02;\n // Horizontal neighbors: for each horizontal edge used, nudge adjacent horizontal edges in same row\n for (int e : pathEdges) {\n if (e < HHE) {\n int i = e / (WN - 1);\n int j = e % (WN - 1);\n // left neighbor\n if (j - 1 >= 0) {\n int ne = idH(i, j - 1);\n w[ne] += beta * (w[e] - w[ne]);\n }\n // right neighbor\n if (j + 1 < WN - 1) {\n int ne = idH(i, j + 1);\n w[ne] += beta * (w[e] - w[ne]);\n }\n } else {\n int ve = e - HHE;\n int i = ve / WN;\n int j = ve % WN;\n // up neighbor\n if (i - 1 >= 0) {\n int ne = idV(i - 1, j);\n w[ne] += beta * (w[e] - w[ne]);\n }\n // down neighbor\n if (i + 1 < HN - 1) {\n int ne = idV(i + 1, j);\n w[ne] += beta * (w[e] - w[ne]);\n }\n }\n }\n\n // Global clipping\n for (int e : pathEdges) {\n if (w[e] < 500.0) w[e] = 500.0;\n if (w[e] > 15000.0) w[e] = 15000.0;\n }\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n GridRouter gr;\n\n long long prev_result = 0; // not used for first query but we will read after output\n\n for (int q = 0; q < 1000; ++q) {\n int si, sj, ti, tj;\n if (!(cin >> si >> sj >> ti >> tj)) {\n return 0;\n }\n\n // Exploration epsilon schedule: decay over first 200 queries\n double eps_start = 0.05;\n double eps = 0.0;\n if (q < 200) {\n double t = (double)q / 200.0;\n eps = eps_start * (1.0 - t);\n }\n\n uint64_t seed = ((uint64_t)si<<48) ^ ((uint64_t)sj<<32) ^ ((uint64_t)ti<<16) ^ (uint64_t)tj ^ (uint64_t)q*1469598103934665603ull;\n\n auto res = gr.shortestPath({si,sj},{ti,tj}, eps, seed);\n\n // Fallback: if something went wrong (no path), output a simple Manhattan path\n string path = res.pathMoves;\n if ((int)path.size() == 0) {\n // Construct naive Manhattan path\n int di = ti - si;\n int dj = tj - sj;\n string tmp;\n if (di > 0) tmp.append(di, 'D'); else tmp.append(-di, 'U');\n if (dj > 0) tmp.append(dj, 'R'); else tmp.append(-dj, 'L');\n path = tmp;\n // Note: our graph ensures connectivity; this fallback is just for safety\n }\n\n cout << path << \"\\n\";\n FastIO::flush();\n\n long long observed;\n if (!(cin >> observed)) {\n return 0;\n }\n\n // Update weights with observation\n gr.updateWeights(res.pathEdges, observed, q);\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic inline int ch2i(char c){ return c - 'A'; }\nstatic inline char i2ch(int x){ return char('A' + x); }\n\nstruct Placement {\n uint8_t dir; // 0=hor,1=ver\n uint8_t fixed; // row for hor, col for ver\n uint8_t start; // start index\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if(!(cin >> N >> M)) return 0;\n vector s(M);\n for(int i=0;i> s[i];\n\n // Encode strings\n vector> enc(M);\n int maxLen=0;\n array globalCnt{}; globalCnt.fill(0);\n for(int i=0;i(maxLen, s[i].size());\n }\n int fillChar = int(max_element(globalCnt.begin(), globalCnt.end()) - globalCnt.begin());\n\n // Precompute all placements per string (we can keep all: 2*N*N)\n vector> placements(M);\n placements.reserve(M);\n for(int i=0;i ps;\n ps.reserve(2*N*N);\n int k = (int)enc[i].size();\n // Horizontal\n for(int r=0;r grid(N*N, UNKNOWN);\n\n auto checkGain = [&](int si, const Placement& pl)->int{\n const auto& e = enc[si];\n int k = (int)e.size();\n int gain = 0;\n if(pl.dir==0){\n int r = pl.fixed;\n int c0 = pl.start;\n int base = r*N;\n for(int p=0;p satisfied(M, 0);\n\n // Greedy loop: repeatedly apply the single best positive-gain placement\n // until no positive-gain placement exists or time budget reached.\n // To limit time, cap total iterations.\n const int maxGlobalIters = 20000; // generous but safe\n int applied = 0;\n for(int iter=0; iter bestGain_i){\n bestGain_i = g;\n bestPl_i = pl;\n if(g == (int)enc[i].size()){\n // perfect fresh placement, good enough\n // keep but continue; we still might find equal\n }\n }\n }\n if(bestGain_i >= 0){\n if(bestGain_i == 0 && hasZeroSat){\n satisfied[i] = 1;\n newlySatisfiedZero++;\n }else if(bestGain_i > bestGain){\n bestGain = bestGain_i;\n bestSi = i;\n bestPl = bestPl_i;\n }\n }\n }\n\n if(bestSi == -1){\n // No positive-gain moves left; we only possibly marked zero-gain strings.\n break;\n }\n applyPlacement(bestSi, bestPl);\n satisfied[bestSi] = 1;\n applied++;\n }\n\n // Final pass: mark any remaining satisfied by zero-gain\n for(int i=0;i\nusing namespace std;\n\nstruct Timer {\n chrono::steady_clock::time_point st;\n Timer() { st = chrono::steady_clock::now(); }\n double elapsed() const {\n using namespace chrono;\n return duration(steady_clock::now() - st).count();\n }\n};\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector g(N);\n for (int i = 0; i < N; ++i) cin >> g[i];\n auto inb = [&](int i, int j){ return 0<=i && i id(N*N, -1);\n vector> pos; pos.reserve(N*N);\n for (int i=0;i> 6;\n vector> vis(R, vector(W, 0));\n // Helper to set bits in a run [k0,k1] of ids stored in a tmp vector\n // Build mapping from (i,j) road to compact idx\n // Row runs\n for (int i=0;i=N) break;\n int k=j;\n vector runIds;\n while (k>6] |= (1ULL << (rid & 63));\n }\n }\n j = k;\n }\n }\n // Column runs\n for (int j=0;j=N) break;\n int k=i;\n vector runIds;\n while (k>6] |= (1ULL << (rid & 63));\n }\n }\n i = k;\n }\n }\n // Precompute neighbors and weights\n vector> neigh(R); // neighbor ids or -1\n vector> moveCost(R);\n for (int r=0;r covered(W, 0);\n auto or_into = [&](vector& a, const vector& b){\n for (int k=0;k& a, const vector& cov)->int{\n int s=0;\n for (int k=0;k(W,0)); // popcount(covered)\n // Dijkstra buffers\n const int INF = 1e9;\n vector dist(R), prevId(R, -1), prevDir(R,-1);\n auto dijkstra_from = [&](int src){\n // Reset\n fill(dist.begin(), dist.end(), INF);\n fill(prevId.begin(), prevId.end(), -1);\n fill(prevDir.begin(), prevDir.end(), -1);\n using P = pair;\n priority_queue, greater

> pq;\n dist[src]=0; pq.emplace(0, src);\n while (!pq.empty()){\n auto [cd,u] = pq.top(); pq.pop();\n if (cd!=dist[u]) continue;\n for (int d=0; d<4; ++d) {\n int v = neigh[u][d];\n if (v<0) continue;\n int w = moveCost[u][d];\n int nd = cd + w;\n if (nd < dist[v]) {\n dist[v]=nd; prevId[v]=u; prevDir[v]=d;\n pq.emplace(nd, v);\n }\n }\n }\n };\n // Build moves along path given target\n auto reconstruct_moves = [&](int cur, int tgt){\n string s;\n if (cur==tgt) return s;\n vector seq;\n int x = tgt;\n while (x != -1 && x != cur) {\n seq.push_back(x);\n x = prevId[x];\n }\n if (x != cur) {\n // disconnected? shouldn't happen\n return s;\n }\n reverse(seq.begin(), seq.end());\n for (int v: seq) {\n int u = prevId[v];\n auto [ui,uj] = pos[u];\n auto [vi,vj] = pos[v];\n if (vi==ui-1 && vj==uj) s.push_back('U');\n else if (vi==ui+1 && vj==uj) s.push_back('D');\n else if (vi==ui && vj==uj-1) s.push_back('L');\n else if (vi==ui && vj==uj+1) s.push_back('R');\n else {\n // Should not happen\n }\n }\n return s;\n };\n string answer;\n Timer timer;\n int cur = startId;\n // Main greedy loop\n const double timeLimit = 2.85; // seconds\n const double beta = 1.1;\n // Precompute list of candidate ids (all roads)\n vector cand(R);\n iota(cand.begin(), cand.end(), 0);\n // Track coverage count cheaply\n auto popcount_bits = [&](const vector& a)->int{\n int s=0; for (int k=0;k timeLimit) break;\n dijkstra_from(cur);\n // Find best target by dist / gain^beta\n int bestT = -1;\n double bestScore = 1e100;\n int bestGain = 0;\n // For a small boost, skip candidates with dist very large to speed up comparison\n for (int t : cand) {\n int d = dist[t];\n if (d >= INF) continue;\n int gain = popcount_and_not(vis[t], covered);\n if (gain <= 0) continue;\n // score function\n double sc = (double)d / pow((double)gain, beta);\n if (sc < bestScore - 1e-12 || (abs(sc - bestScore) <= 1e-12 && gain > bestGain)) {\n bestScore = sc;\n bestT = t;\n bestGain = gain;\n }\n }\n if (bestT == -1) {\n // No progress from here (shouldn't happen unless covered); try move towards start and break\n break;\n }\n // Append path to bestT\n string mv = reconstruct_moves(cur, bestT);\n answer += mv;\n // Update current\n cur = bestT;\n // Update covered\n or_into(covered, vis[cur]);\n coveredCount = popcount_bits(covered);\n ++iterations;\n // Optional: early return when very close to finishing time\n if (timer.elapsed() > timeLimit) break;\n // Additional small heuristic: if bestGain is huge relative to remaining, maybe try return check later\n }\n // Ensure we return to start\n if (cur != startId) {\n dijkstra_from(cur);\n string mv = reconstruct_moves(cur, startId);\n answer += mv;\n cur = startId;\n }\n // Output\n cout << answer << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nstruct RNG {\n uint64_t x=88172645463393265ull;\n uint32_t next() { x ^= x<<7; x ^= x>>9; return uint32_t(x); }\n double drand() { return (next()>>8) * (1.0/16777216.0); }\n} rng;\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N,M,K,R;\n if(!(cin>>N>>M>>K>>R)) return 0;\n vector> d(N, vector(K));\n for(int i=0;i>d[i][k];\n vector> g(N);\n vector indeg(N,0);\n for(int i=0;i>u>>v; --u;--v;\n g[u].push_back(v);\n indeg[v]++;\n }\n // compute \"height\" (distance to sink) via reverse DP: longest path length estimate\n vector topo;\n {\n vector indeg2 = indeg;\n queue q;\n for(int i=0;i> rg(N);\n for(int u=0;u height(N,0);\n // reverse topo to compute longest path to end (in terms of edges)\n for(int idx=N-1; idx>=0; --idx){\n int u = topo[idx];\n int best=0;\n for(int v: g[u]) best = max(best, 1 + height[v]);\n height[u]=best;\n }\n // Also compute number of descendants approximate via DP (could be heavy to exact), skip.\n\n // Estimations\n vector> est(M, vector(K, 10.0));\n vector> lb(M, vector(K, 0));\n\n // Task status: 0 not started, 1 started, 2 done\n vector tstat(N,0);\n vector started_by(N, -1);\n vector start_day(N, -1);\n\n // Member status: -1 idle, else task index\n vector mtask(M, -1);\n\n // Current indegree mutable\n vector cur_indeg = indeg;\n vector in_ready(N, 0);\n deque ready;\n // initialize ready tasks (no deps)\n for(int i=0;idouble{\n double w=0.0;\n for(int k=0;k0) w += def;\n }\n // r mean ~0, but add small bias\n if(w<1.0) return 1.0;\n return max(1.0, w);\n };\n\n auto assign_task = [&](int mem, int task, int day){\n mtask[mem]=task;\n tstat[task]=1;\n started_by[task]=mem;\n start_day[task]=day;\n // remove from ready if present\n if(in_ready[task]){\n in_ready[task]=0;\n // we won't remove efficiently from deque; will skip when popping\n }\n };\n\n int day=0;\n const double alpha = 1.0;\n const double beta = 0.3;\n const double eps = 0.05;\n\n while(true){\n day++;\n // Build list of idle members\n vector idle;\n for(int j=0;j rlist;\n // Rebuild rlist from flags to avoid stale entries\n rlist.reserve(ready.size());\n for(int i=0;i> out; out.reserve(idle.size());\n // To limit cost, consider up to topL by height\n int topL = 300; // cap candidates\n if((int)rlist.size()>topL){\n // pick top by height\n nth_element(rlist.begin(), rlist.begin()+topL, rlist.end(), [&](int a,int b){\n return height[a] > height[b];\n });\n rlist.resize(topL);\n }\n // Keep a set to avoid assigning same task twice\n vector taken(N, 0);\n for(int mem: idle){\n int bestTask = -1;\n double bestScore = 1e100;\n // exploration?\n bool doExplore = (rng.drand() < eps);\n if(doExplore){\n // pick task with largest uncertainty: sum(est-lb gaps near d)\n double bestU = -1.0;\n for(int t: rlist){\n if(taken[t]) continue;\n double unc=0.0;\n for(int k=0;klb[mem][k]){\n double gap = max(0.0, est[mem][k] - (double)lb[mem][k]);\n // uncertainty where d is near est\n double closeness = max(0.0, est[mem][k] - d[t][k]);\n unc += gap - 0.5*closeness;\n }\n }\n unc += 0.1*height[t];\n if(unc>bestU){\n bestU=unc; bestTask=t;\n }\n }\n } else {\n for(int t: rlist){\n if(taken[t]) continue;\n double tp = predicted_time(t, mem);\n double score = alpha*tp - beta*height[t];\n if(score < bestScore){\n bestScore=score; bestTask=t;\n }\n }\n }\n if(bestTask!=-1){\n taken[bestTask]=1;\n out.emplace_back(mem, bestTask);\n }\n }\n\n // Output\n cout<>nfin)) return 0;\n if(nfin==-1) return 0;\n vector fins(nfin);\n for(int i=0;i>fins[i]; fins[i]--; }\n\n // Process finishes: mark tasks done, update estimates, update ready\n for(int mem: fins){\n int task = mtask[mem];\n if(task<0) continue; // safety\n int dur = day - start_day[task] + 1;\n // Update estimates\n if(dur<=1){\n // strict implication w=0 -> s >= d\n for(int k=0;k1, adjust est upwards to reduce predicted deficit towards T\n // Compute current deficit\n vector def(K,0.0);\n double W=0.0;\n for(int k=0;k0){ def[k]=df; W+=df; }\n }\n // Target T ~ dur, clamp\n double T = (double)dur;\n if(W > T){\n // reduce W by increasing on positive def dims\n double sumdef = W;\n if(sumdef>1e-9){\n double delta = min(W - T, 3.0); // cautious step\n for(int k=0;k0){\n double inc = delta * (def[k]/sumdef);\n est[mem][k] += inc;\n est[mem][k] = max(est[mem][k], (double)lb[mem][k]);\n } else {\n est[mem][k] = max(est[mem][k], (double)lb[mem][k]);\n }\n }\n }\n } else {\n // W <= T, maybe we overestimate somewhere; lightly pull down non-lb dims\n double delta = min(T - W, 1.0);\n for(int k=0;k lb[mem][k]){\n est[mem][k] = max((double)lb[mem][k], est[mem][k] - delta*0.05);\n }\n }\n }\n }\n // free member and mark task done\n mtask[mem] = -1;\n tstat[task]=2;\n // unlock successors\n for(int v: g[task]){\n cur_indeg[v]--;\n if(cur_indeg[v]==0 && tstat[v]==0){\n in_ready[v]=1;\n }\n }\n }\n\n // Compact ready deque representation not necessary; we rebuild rlist each day from flags.\n // Loop continues\n }\n return 0;\n}","ahc006":"#include \nusing namespace std;\n\nstruct Order {\n int ax, ay, cx, cy, idx;\n double score;\n double ang_pick, ang_drop;\n};\n\nstatic inline int manh(int x1,int y1,int x2,int y2){ return abs(x1-x2)+abs(y1-y2); }\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n const int DEPX=400, DEPY=400;\n vector all;\n all.reserve(1000);\n for(int i=0;i<1000;i++){\n int a,b,c,d;\n if(!(cin>>a>>b>>c>>d)) return 0;\n Order o; o.ax=a;o.ay=b;o.cx=c;o.cy=d;o.idx=i+1;\n all.push_back(o);\n }\n // Compute scores\n const double alpha=1.0, beta=1.0, gamma=0.7; // weights\n const double angle_penalty = 10.0; // mild\n for(auto &o: all){\n int da = manh(DEPX,DEPY,o.ax,o.ay);\n int ac = manh(o.ax,o.ay,o.cx,o.cy);\n int cd = manh(o.cx,o.cy,DEPX,DEPY);\n // angle from depot (for pickup and drop)\n double angp = atan2((double)o.ay - DEPY, (double)o.ax - DEPX);\n double angd = atan2((double)o.cy - DEPY, (double)o.cx - DEPX);\n o.ang_pick = angp; o.ang_drop = angd;\n double dang = fabs(angp - angd);\n while(dang > M_PI) dang = fabs(dang - 2*M_PI);\n o.score = alpha*da + beta*ac + gamma*cd + angle_penalty * dang;\n }\n // Sort by score and pick top 50\n sort(all.begin(), all.end(), [](const Order& A, const Order& B){\n if (A.score != B.score) return A.score < B.score;\n return A.idx < B.idx;\n });\n int m = 50;\n vector sel(all.begin(), all.begin()+m);\n // Greedy route construction with precedence\n struct Node { int x,y; int ordIdx; bool isPickup; };\n // Map from idx to order data\n unordered_map omap;\n omap.reserve(m*2);\n for (auto &o: sel) omap[o.idx]=o;\n\n // Sets\n vector unpicked, carrying;\n unpicked.reserve(m);\n for (auto &o: sel) unpicked.push_back(o.idx);\n vector route;\n route.push_back({DEPX,DEPY,-1,false}); // start\n\n int curx=DEPX, cury=DEPY;\n // simple structure for lookup location\n auto getPick = [&](int id)->pair{\n auto &o = omap[id]; return {o.ax,o.ay};\n };\n auto getDrop = [&](int id)->pair{\n auto &o = omap[id]; return {o.cx,o.cy};\n };\n\n for(int step=0; step<2*m; ++step){\n // find best pickup\n int bestPid=-1; int bestPdist=INT_MAX; int px=0,py=0;\n for(int id: unpicked){\n auto p = getPick(id);\n int d = manh(curx,cury,p.first,p.second);\n if(d < bestPdist){\n bestPdist = d; bestPid=id; px=p.first; py=p.second;\n }\n }\n // find best drop\n int bestDid=-1; int bestDdist=INT_MAX; int dx=0,dy=0;\n for(int id: carrying){\n auto p = getDrop(id);\n int d = manh(curx,cury,p.first,p.second);\n if(d < bestDdist){\n bestDdist = d; bestDid=id; dx=p.first; dy=p.second;\n }\n }\n // choose\n bool doPickup = false;\n if(bestPid==-1 && bestDid!=-1) doPickup=false;\n else if(bestPid!=-1 && bestDid==-1) doPickup=true;\n else {\n // bias against picking when carrying many\n double bias = 1.05 + 0.02 * (int)carrying.size();\n doPickup = (bestPdist * bias <= bestDdist + 1e-9);\n }\n if(doPickup){\n // move to pickup\n route.push_back({px,py,bestPid,true});\n curx=px; cury=py;\n // update sets\n // remove from unpicked\n auto it = find(unpicked.begin(), unpicked.end(), bestPid);\n if(it!=unpicked.end()) unpicked.erase(it);\n carrying.push_back(bestPid);\n }else{\n // move to drop\n route.push_back({dx,dy,bestDid,false});\n curx=dx; cury=dy;\n // remove from carrying\n auto it = find(carrying.begin(), carrying.end(), bestDid);\n if(it!=carrying.end()) carrying.erase(it);\n }\n }\n // return to depot\n route.push_back({DEPX,DEPY,-1,false});\n\n // Build mapping of order to first/second occurrence indices\n int n = (int)route.size();\n vector firstIdx(1001,-1), secondIdx(1001,-1);\n for(int i=0;i& R)->long long{\n long long t=0;\n for(size_t i=0;i+1& R)->bool{\n // check for each order where pickup or drop falls in [i..j], whether pickup index < drop index\n // First collect indices for orders affected\n // For simplicity, recompute full positions\n vector pidx(1001,-1), didx(1001,-1);\n for(int k=0;k<(int)R.size();++k){\n int id=R[k].ordIdx;\n if(id==-1) continue;\n if(R[k].isPickup){ if(pidx[id]==-1) pidx[id]=k; }\n else { if(didx[id]==-1) didx[id]=k; }\n }\n for (auto &o: sel){\n int pid = pidx[o.idx];\n int did = didx[o.idx];\n if(pid==-1 || did==-1) continue;\n if(pid >= did) return true;\n }\n return false;\n };\n\n auto try_two_opt = [&](vector& R){\n bool improved=true;\n int iter=0;\n while(improved && iter<200){\n improved=false; iter++;\n long long bestGain=0;\n int bi=-1,bj=-1;\n for(int i=1;i+2<(int)R.size();++i){\n for(int j=i+1;j+1<(int)R.size();++j){\n // endpoints fixed\n long long d0 = manh(R[i-1].x,R[i-1].y,R[i].x,R[i].y)\n + manh(R[j].x,R[j].y,R[j+1].x,R[j+1].y);\n long long d1 = manh(R[i-1].x,R[i-1].y,R[j].x,R[j].y)\n + manh(R[i].x,R[i].y,R[j+1].x,R[j+1].y);\n long long gain = d0 - d1;\n if(gain > bestGain){\n // simulate reversal and check precedence\n // We can avoid full recomputation by temporarily reverse and check\n reverse(R.begin()+i, R.begin()+j+1);\n if(!violates(0,0,R)){\n bestGain = gain;\n bi=i; bj=j;\n }\n reverse(R.begin()+i, R.begin()+j+1);\n }\n }\n }\n if(bestGain > 0 && bi!=-1){\n reverse(R.begin()+bi, R.begin()+bj+1);\n improved=true;\n }\n }\n };\n\n try_two_opt(route);\n\n // Simple paired relocate: move a pickup-drop pair closer together\n auto index_of = [&](const vector& R, int id, bool pickup)->int{\n for(int i=0;i<(int)R.size();++i){\n if(R[i].ordIdx==id && R[i].isPickup==pickup) return i;\n }\n return -1;\n };\n auto relocate_pair = [&](vector& R){\n bool improved=true;\n int attempts=0;\n while(improved && attempts<50){\n improved=false; attempts++;\n long long bestDelta=0;\n int bid=-1, insertPos=-1;\n // compute current length\n long long curL = routeDist(R);\n for(auto &o: sel){\n int pid = index_of(R,o.idx,true);\n int did = index_of(R,o.idx,false);\n if(pid==-1 || did==-1 || pid>=did) continue;\n // Remove both nodes; try reinsert pickup at pos p, and drop at some q>p\n // To keep it cheap, try a few candidate positions around pid and did\n vector candP;\n for(int t=max(1,pid-3); t<=min((int)R.size()-2,pid+3); ++t) candP.push_back(t);\n for(int p: candP){\n if(p==pid) continue;\n // Build list of candidate q near did adjusted for shift\n for(int q=max(p+1, did-3); q<=min((int)R.size()-1, did+3); ++q){\n // Simulate cost delta cheaply by rebuilding a temporary vector for small sizes\n vector T = R;\n // extract nodes\n Node P = T[pid];\n Node D = T[did];\n if(pid bestDelta){\n bestDelta = delta;\n bid = o.idx;\n insertPos = p;\n // Apply immediately for speed\n R.swap(T);\n improved=true;\n break;\n }\n }\n if(improved) break;\n }\n if(improved) break;\n }\n }\n };\n\n relocate_pair(route);\n try_two_opt(route);\n\n // Output\n cout<\nusing namespace std;\n\nstruct DSU {\n int n;\n vector p, r;\n int comps;\n DSU(int n=0): n(n), p(n), r(n,0), comps(n) { iota(p.begin(), p.end(), 0); }\n int find(int x){ return p[x]==x?x:p[x]=find(p[x]); }\n bool same(int a,int b){ return find(a)==find(b); }\n bool unite(int a,int b){\n a=find(a); b=find(b);\n if(a==b) return false;\n if(r[a] x(N), y(N);\n for(int i=0;i>x[i]>>y[i])) return 0;\n }\n vector U(M), V(M);\n for(int i=0;i>U[i]>>V[i];\n }\n\n auto rd = [&](int i)->int{\n long long dx = x[U[i]] - x[V[i]];\n long long dy = y[U[i]] - y[V[i]];\n double dist = sqrt((double)(dx*dx + dy*dy));\n int di = (int)llround(dist);\n return di;\n };\n\n vector edges(M);\n for(int i=0;i layer(M, -1);\n vector removed(M, 0);\n // We'll make a list of remaining edge indices\n vector order(M);\n iota(order.begin(), order.end(), 0);\n\n for(int lay=0; lay<5; lay++){\n // Prepare list of available edges\n vector avail;\n avail.reserve(M);\n for(int ei=0; ei more confident to accept at higher cost\n array alpha;\n // base values\n alpha[0]=1.60; alpha[1]=1.50; alpha[2]=1.40; alpha[3]=1.30; alpha[4]=1.20;\n\n for(int i=0;i>l_i)) return 0;\n int u = U[i], v = V[i];\n int d = edges[i].d;\n int lay = layer[i];\n if(lay<0 || lay>4) lay = 4; // fallback\n\n int R = M - i - 1;\n int C = cur.comps;\n\n bool accept = false;\n if(cur.same(u,v)){\n accept = false;\n }else{\n if(C-1 <= 1) {\n // only one connection needed, still be cautious\n }\n // safety relaxations\n double mul = alpha[lay];\n if(R <= 3*(C-1)) mul += 0.30;\n if(R <= 2*(C-1)) {\n // To guarantee connectivity, accept any connecting edge\n accept = true;\n } else {\n // Normal threshold decision\n // Also quick absolute cap: accept if l is very small compared to global scale\n // but primarily use l <= mul * d\n if((double)l_i <= mul * (double)d) accept = true;\n }\n }\n\n if(accept){\n if(!cur.same(u,v)){\n cur.unite(u,v);\n totalA += l_i;\n }\n cout << 1 << '\\n' << flush;\n }else{\n cout << 0 << '\\n' << flush;\n }\n }\n\n return 0;\n}","ahc008":"#include \nusing namespace std;\n\n// Constants\nstatic const int H = 30, W = 30;\nstruct Pet {\n int x, y;\n int t;\n};\nstruct Human {\n int x, y;\n int wallRow; // target wall row (6,12,18,24)\n int standRow; // row we stand on to place block (wallRow-1 or wallRow+1)\n int L, R; // sweep column range inclusive\n int dir; // +1 to sweep increasing y, -1 decreasing\n int targetCol; // current sweep target column\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N; \n if(!(cin>>N)) return 0;\n vector pets(N);\n for(int i=0;i>px>>py>>pt;\n pets[i]={px,py,pt};\n }\n int M; cin>>M;\n vector humans(M);\n vector> initH(M);\n for(int i=0;i>hx>>hy;\n humans[i].x=hx; humans[i].y=hy;\n initH[i]={hx,hy};\n }\n // Grid state\n vector> blocked(H+1, vector(W+1,false));\n vector> petCnt(H+1, vector(W+1,0));\n auto inb=[&](int x,int y){ return 1<=x && x<=H && 1<=y && y<=W; };\n // Initialize pet counts\n for(auto &p: pets) petCnt[p.x][p.y]++;\n\n // Assign walls rows cycling among 6,12,18,24\n vector wallRowsBase = {6,12,18,24};\n for(int i=0;i& hs)->bool{\n if(!inb(tx,ty)) return false;\n if(blocked[tx][ty]) return false;\n if(petCnt[tx][ty]>0) return false;\n // cannot choose a square that contains humans at the start of the turn\n for(const auto& h: hs){\n if(h.x==tx && h.y==ty) return false;\n }\n // cannot choose a square whose adjacent square contains a pet\n static const int dx[4]={-1,1,0,0};\n static const int dy[4]={0,0,-1,1};\n for(int k=0;k<4;k++){\n int nx=tx+dx[k], ny=ty+dy[k];\n if(inb(nx,ny) && petCnt[nx][ny]>0) return false;\n }\n return true;\n };\n\n auto human_at = [&](int x,int y,const vector& hs)->bool{\n for(auto &h: hs) if(h.x==x && h.y==y) return true;\n return false;\n };\n\n // Main 300 turns\n for(int turn=0; turn<300; turn++){\n string actions(M, '.');\n // Decide actions per human\n for(int i=0;i sr){\n // move up\n if(inb(h.x-1,h.y) && !blocked[h.x-1][h.y]){\n actions[i] = 'U';\n continue;\n }\n }else{\n if(inb(h.x+1,h.y) && !blocked[h.x+1][h.y]){\n actions[i] = 'D';\n continue;\n }\n }\n // fallback do nothing if blocked\n actions[i]='.';\n continue;\n }\n // Step 2: move to targetCol within [L,R]\n if(h.y < h.L){ \n if(inb(h.x, h.y+1) && !blocked[h.x][h.y+1]) { actions[i]='R'; continue; }\n }\n if(h.y > h.R){\n if(inb(h.x, h.y-1) && !blocked[h.x][h.y-1]) { actions[i]='L'; continue; }\n }\n // Now inside range [L,R]; aim to sweep\n // Try to place a block into the wall row at current column if possible\n int tx = wr;\n int ty = h.y;\n char place = (sr < wr ? 'd' : 'u');\n if(safe_to_block(tx,ty, humans)){\n actions[i] = place;\n continue;\n }\n // If not safe or already blocked, move horizontally to keep sweeping\n // Ensure we stay within [L,R], bouncing at ends\n if(h.dir > 0){\n if(h.y < h.R){\n if(!blocked[h.x][h.y+1]) actions[i]='R';\n else actions[i]='.';\n }else{\n h.dir = -1;\n if(h.y > h.L && !blocked[h.x][h.y-1]) actions[i]='L';\n else actions[i]='.';\n }\n }else{\n if(h.y > h.L){\n if(!blocked[h.x][h.y-1]) actions[i]='L';\n else actions[i]='.';\n }else{\n h.dir = +1;\n if(h.y < h.R && !blocked[h.x][h.y+1]) actions[i]='R';\n else actions[i]='.';\n }\n }\n }\n\n // Output actions\n cout<> newBlocks;\n for(int i=0;i pm(N);\n for(int i=0;i>pm[i];\n }\n // Clear pet counts, then update\n for(int x=1;x<=H;x++) for(int y=1;y<=W;y++) petCnt[x][y]=0;\n for(int i=0;i\nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int si,sj,ti,tj;\n double p;\n if(!(cin>>si>>sj>>ti>>tj>>p)) return 0;\n vector h(20), v(19);\n for(int i=0;i<20;i++){\n cin>>h[i];\n }\n for(int i=0;i<19;i++){\n cin>>v[i];\n }\n auto inb = [](int x,int y){ return 0<=x && x<20 && 0<=y && y<20; };\n auto can_move = [&](int x,int y,int nx,int ny)->bool{\n if(!inb(nx,ny)) return false;\n if(nx==x && ny==y+1){\n return h[x][y]=='0';\n }\n if(nx==x && ny==y-1){\n return h[x][y-1]=='0';\n }\n if(nx==x+1 && ny==y){\n return v[x][y]=='0';\n }\n if(nx==x-1 && ny==y){\n return v[x-1][y]=='0';\n }\n return false;\n };\n // BFS shortest path\n const int N=20;\n vector> dist(N, vector(N, INT_MAX));\n vector>> par(N, vector>(N, {-1,-1}));\n queue> q;\n dist[si][sj]=0;\n q.push({si,sj});\n int dx[4]={-1,1,0,0};\n int dy[4]={0,0,-1,1};\n char dc[4] = {'U','D','L','R'};\n while(!q.empty()){\n auto [x,y]=q.front(); q.pop();\n if(x==ti && y==tj) break;\n for(int d=0;d<4;d++){\n int nx=x+dx[d], ny=y+dy[d];\n if(!inb(nx,ny)) continue;\n if(!can_move(x,y,nx,ny)) continue;\n if(dist[nx][ny] > dist[x][y] + 1){\n dist[nx][ny] = dist[x][y] + 1;\n par[nx][ny] = {x,y};\n q.push({nx,ny});\n }\n }\n }\n // Reconstruct path\n vector> path;\n int cx=ti, cy=tj;\n while(!(cx==si && cy==sj) && cx!=-1){\n path.push_back({cx,cy});\n auto pr = par[cx][cy];\n cx = pr.first; cy = pr.second;\n }\n path.push_back({si,sj});\n reverse(path.begin(), path.end());\n // If BFS somehow fails (shouldn't), fallback to simple greedy without walls\n vector dirs;\n if((int)path.size()>=2){\n for(size_t k=1;kti) { dirs.push_back('U'); x--; }\n while(xtj) { dirs.push_back('L'); y--; }\n while(yint{\n int k = (int)ceil(x - 1e-12);\n return k;\n };\n int r_cap;\n if(p>=1.0-1e-12) r_cap = 8;\n else {\n double num = log(0.02);\n double den = log(p);\n int rc = safe_ceil(num/den); // since den<0, this is positive\n r_cap = max(2, min(8, rc));\n }\n int r_max = max(1, 200 / max(1, D));\n int r = min(r_max, r_cap);\n // Build output\n string out;\n out.reserve(200);\n auto append_repeats = [&](const vector& P, int rep){\n for(char c: P){\n for(int k=0;k\nusing namespace std;\n\nstatic const int H = 30, W = 30;\nstatic const int di4[4] = {0,-1,0,1};\nstatic const int dj4[4] = {-1,0,1,0};\n\n// Base to mapping for tile types 0..7 as per statement.\nint base_to_[8][4] = {\n {1,0,-1,-1},\n {3,-1,-1,0},\n {-1,-1,3,2},\n {-1,2,1,-1},\n {1,0,3,2},\n {3,2,1,0},\n {2,-1,0,-1},\n {-1,3,-1,1},\n};\n// to_rot[t][r][d]: with tile type t rotated r times CCW, entering from direction d, output direction or -1.\nint to_rot[8][4][4];\n\ninline int mod4(int x){ x%=4; if(x<0)x+=4; return x; }\n\nstruct Solver {\n array, H> t;\n array, H> r; // current rotations\n array, H> best_r;\n // desired outgoing direction for each entering direction\n array, W>, H> desired_to;\n\n int proxyScore = 0;\n\n Solver() {}\n\n void precompute_to_rot() {\n for(int tt=0; tt<8; ++tt){\n for(int rot=0; rot<4; ++rot){\n for(int d=0; d<4; ++d){\n int din = mod4(d - rot);\n int e = base_to_[tt][din];\n if(e==-1) to_rot[tt][rot][d] = -1;\n else to_rot[tt][rot][d] = mod4(e + rot);\n }\n }\n }\n }\n\n void read_input() {\n for(int i=0;i>s;\n for(int j=0;j bestdot){ bestdot=dot; bestd=d; }\n }\n for(int d=0; d<4; ++d){\n desired_to[i][j][d] = bestd;\n }\n }\n }\n }\n\n int tile_local_score(int i,int j,int rot){\n int sc = 0;\n for(int d=0; d<4; ++d){\n int e = to_rot[t[i][j]][rot][d];\n if(e==-1){ sc -= 2; continue; }\n if(e == desired_to[i][j][d]) sc += 1;\n int ni = i + di4[e], nj = j + dj4[e];\n if(ni<0||ni>=H||nj<0||nj>=W) sc -= 3;\n }\n return sc;\n }\n\n void initial_assignment() {\n for(int i=0;i bestSc){\n bestSc = sc; bestRot = rot;\n }\n }\n r[i][j] = bestRot;\n }\n }\n }\n\n // Check if the edge between (i,j) and (i+di[d], j+dj[d]) is matched (undirected) under current r\n inline int edge_match_at(int i,int j,int d) {\n int ni = i + di4[d], nj = j + dj4[d];\n if(ni<0||ni>=H||nj<0||nj>=W) return 0;\n int Ato = to_rot[t[i][j]][r[i][j]][(d+2)&3];\n if(Ato != d) return 0;\n int Bd = (d+2)&3;\n int Bto = to_rot[t[ni][nj]][r[ni][nj]][Bd];\n if(Bto != Bd) return 0;\n return 1;\n }\n\n int compute_proxy_score() {\n int total = 0;\n // horizontal edges\n for(int i=0;i0 is counted at (i,j-1, R)\n if(j>0) sum += edge_match_at(i,j-1,2);\n // right edge if j0 at (i-1,j, D)\n if(i>0) sum += edge_match_at(i-1,j,3);\n // down edge if i compute_top2_loops() {\n // visited states: -1 unvisited, >=0 timestamp or component id\n // We can simply do standard functional graph cycle detection by stepping, but we need to start from all states.\n vector>> vis(H, vector>(W, {0,0,0,0}));\n int best1=0, best2=0;\n for(int i=0;i seen; seen.reserve(32);\n while(true){\n if(vis[ci][cj][cd]){ // already processed; no new cycle counted\n // mark visited along this walk\n ci=si; cj=sj; cd=sd;\n while(true){\n if(vis[ci][cj][cd]) break;\n vis[ci][cj][cd] = 1;\n int e = to_rot[t[ci][cj]][r[ci][cj]][cd];\n if(e==-1) break;\n int ni = ci + di4[e], nj = cj + dj4[e];\n if(ni<0||ni>=H||nj<0||nj>=W) break;\n int nd = (e+2)&3;\n ci=ni; cj=nj; cd=nd;\n if(ci==si && cj==sj && cd==sd) break;\n }\n break;\n }\n // step\n long long key = (((long long)ci*W + cj)<<2) | cd;\n if(seen.find(key)!=seen.end()){\n int cyc_start = seen[key];\n int cyc_len = steps - cyc_start;\n // update best two\n if(cyc_len >= best1){ best2=best1; best1=cyc_len; }\n else if(cyc_len > best2){ best2=cyc_len; }\n // mark visited\n ci=si; cj=sj; cd=sd;\n while(true){\n if(vis[ci][cj][cd]) break;\n vis[ci][cj][cd]=1;\n int e = to_rot[t[ci][cj]][r[ci][cj]][cd];\n if(e==-1) break;\n int ni = ci + di4[e], nj = cj + dj4[e];\n if(ni<0||ni>=H||nj<0||nj>=W) break;\n int nd = (e+2)&3;\n ci=ni; cj=nj; cd=nd;\n if(ci==si && cj==sj && cd==sd) break;\n }\n break;\n }\n seen.emplace(key, steps);\n int e = to_rot[t[ci][cj]][r[ci][cj]][cd];\n if(e==-1){\n // mark visited along the walk\n ci=si; cj=sj; cd=sd;\n while(true){\n if(vis[ci][cj][cd]) break;\n vis[ci][cj][cd]=1;\n int e2 = to_rot[t[ci][cj]][r[ci][cj]][cd];\n if(e2==-1) break;\n int ni = ci + di4[e2], nj = cj + dj4[e2];\n if(ni<0||ni>=H||nj<0||nj>=W) break;\n int nd = (e2+2)&3;\n ci=ni; cj=nj; cd=nd;\n if(ci==si && cj==sj && cd==sd) break;\n }\n break;\n }\n int ni = ci + di4[e], nj = cj + dj4[e];\n if(ni<0||ni>=H||nj<0||nj>=W){\n // mark visited along the walk\n ci=si; cj=sj; cd=sd;\n while(true){\n if(vis[ci][cj][cd]) break;\n vis[ci][cj][cd]=1;\n int e2 = to_rot[t[ci][cj]][r[ci][cj]][cd];\n if(e2==-1) break;\n int nni = ci + di4[e2], nnj = cj + dj4[e2];\n if(nni<0||nni>=H||nnj<0||nnj>=W) break;\n int nd = (e2+2)&3;\n ci=nni; cj=nnj; cd=nd;\n if(ci==si && cj==sj && cd==sd) break;\n }\n break;\n }\n ci=ni; cj=nj; cd=(e+2)&3;\n steps++;\n }\n }\n }\n }\n return {best1,best2};\n }\n\n void solve() {\n precompute_to_rot();\n read_input();\n build_desired();\n initial_assignment();\n\n // compute initial proxy and best\n proxyScore = compute_proxy_score();\n best_r = r;\n auto top2 = compute_top2_loops();\n long long bestScore = 1LL*top2.first*top2.second;\n\n // Simulated annealing / hill climb\n std::mt19937 rng(712367);\n auto start = chrono::high_resolution_clock::now();\n const double TIME_LIMIT = 1.95; // seconds\n int iter=0, accepted=0;\n while(true){\n iter++;\n if((iter & 0x3FFF)==0){\n auto now = chrono::high_resolution_clock::now();\n double t = chrono::duration(now - start).count();\n if(t > TIME_LIMIT) break;\n }\n int i = rng()%H;\n int j = rng()%W;\n int cur = r[i][j];\n int before = local_proxy_contrib_cell(i,j);\n int bestRot = cur;\n int bestLocal = before;\n for(int rot=0; rot<4; ++rot){\n if(rot==cur) continue;\n int old = r[i][j];\n r[i][j] = rot;\n int after = local_proxy_contrib_cell(i,j);\n if(after > bestLocal){\n bestLocal = after; bestRot = rot;\n }\n r[i][j] = old;\n }\n int gain = bestLocal - before;\n bool take = false;\n if(gain > 0) take = true;\n else {\n // mild SA\n double temp = 0.5; // constant small temperature\n double prob = exp(gain / max(1.0, temp));\n uniform_real_distribution urd(0.0,1.0);\n if(urd(rng) < prob) take = true;\n }\n if(take){\n r[i][j] = bestRot;\n proxyScore += gain;\n accepted++;\n if((accepted % 500)==0){\n // Evaluate exact\n auto p = compute_top2_loops();\n long long sc = 1LL*p.first*p.second;\n if(sc > bestScore){\n bestScore = sc;\n best_r = r;\n }\n }\n }\n }\n // Final evaluation checkpoint\n auto p = compute_top2_loops();\n long long sc = 1LL*p.first*p.second;\n if(sc > bestScore){\n bestScore = sc;\n best_r = r;\n }\n\n // Output best rotations as a single line of 900 digits\n string out; out.reserve(H*W);\n for(int i=0;i\nusing namespace std;\n\n// Direction masks: bit 0=left(1), bit1=up(2), bit2=right(4), bit3=down(8)\nstatic inline bool matchLR(int a, int b){ // a right with b left\n return (a & 4) && (b & 1);\n}\nstatic inline bool matchUD(int a, int b){ // a down with b up\n return (a & 8) && (b & 2);\n}\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t seed=712367821) : x(seed) {}\n uint32_t next() { x ^= x<<7; x ^= x>>9; return (uint32_t)x; }\n int randint(int l, int r){ return l + (int)(next() % (uint32_t)(r-l+1)); }\n bool prob(double p){ return (next() / (double)UINT32_MAX) < p; }\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N; int Tlimit;\n if(!(cin>>N>>Tlimit)) {\n return 0;\n }\n vector rows(N);\n for(int i=0;i>rows[i];\n vector a(N*N);\n int emptyPos=-1;\n for(int i=0;i='0' && c<='9') v = c-'0';\n else v = 10 + (c-'a');\n a[i*N+j]=v;\n if(v==0) emptyPos=i*N+j;\n }\n }\n\n RNG rng(123456789 ^ (uint64_t)chrono::high_resolution_clock::now().time_since_epoch().count());\n\n auto inb = [&](int r,int c){ return r>=0 && r=0 && c horiz(N*(N-1),0), vert((N-1)*N,0);\n auto idxH = [&](int i,int j){ return i*(N-1)+j; };\n auto idxV = [&](int i,int j){ return i*N+j; };\n\n auto recompute_local_edges = [&](int r,int c){\n // Update matches around (r,c): edges to left/right/up/down if exist\n int p = r*N+c;\n if(a[p]==0){\n // empty contributes no edges, but neighbors matching is only defined on non-empty squares\n // However matched edges definition is between non-empty squares; empty breaks edges.\n }\n // Horizontal edges with (r,c-1)-(r,c) and (r,c)-(r,c+1)\n if(c-1>=0){\n int L = a[r*N+(c-1)], Rv = a[r*N+c];\n horiz[idxH(r,c-1)] = (L!=0 && Rv!=0 && matchLR(L,Rv)) ? 1:0;\n }\n if(c=0){\n int U = a[(r-1)*N+c], Dv = a[r*N+c];\n vert[idxV(r-1,c)] = (U!=0 && Dv!=0 && matchUD(U,Dv)) ? 1:0;\n }\n if(rint{\n // collect set of affected edges indices before and after; easiest is to sum contributions around the two cells\n int before=0, after=0;\n auto add_edges = [&](int r,int c,int &acc){\n if(c-1>=0) acc += horiz[idxH(r,c-1)];\n if(c=0) acc += vert[idxV(r-1,c)];\n if(rint{\n int s=0;\n // left edge (r,c-1)-(r,c)\n if(c-1>=0){\n int L = (r*N + c-1 == pe ? vn : (r*N + c-1 == pn ? 0 : a[r*N + c-1]));\n int Rv = val_at_rc;\n s += (L!=0 && Rv!=0 && matchLR(L,Rv)) ? 1:0;\n }\n // right edge (r,c)-(r,c+1)\n if(c=0){\n int U = ( (r-1)*N + c == pe ? vn : ((r-1)*N + c == pn ? 0 : a[(r-1)*N + c]) );\n int Dv = val_at_rc;\n s += (U!=0 && Dv!=0 && matchUD(U,Dv)) ? 1:0;\n }\n // down edge (r,c)-(r+1,c)\n if(r(now - t_start).count();\n if(ms > time_limit_ms) break;\n }\n // evaluate candidates\n struct Cand{ int dir; int delta; int tie; };\n vector cands;\n for(int d=0; d<4; d++){\n int nr = er + dr[d], nc = ec + dc[d];\n if(!inb(nr,nc)) continue;\n if(last_dir != -1 && revdir[d]==last_dir){\n // consider but downweight; we'll keep it but mark tie worse unless strictly good\n }\n int del = delta_for_move(er,ec,nr,nc);\n int tie = 0;\n // tie-breaker: prefer central positions for the empty after move\n int cen_bias = - (abs((N-1)/2 - nr) + abs((N-1)/2 - nc));\n tie += cen_bias;\n // small random jitter\n tie += rng.randint(-2,2);\n cands.push_back({d, del, tie});\n }\n if(cands.empty()) break;\n // choose best\n sort(cands.begin(), cands.end(), [&](const Cand& A, const Cand& B){\n if(A.delta != B.delta) return A.delta > B.delta;\n return A.tie > B.tie;\n });\n int chosen = 0;\n // If best delta <= 0, allow some randomness to escape local minima\n if(cands[0].delta <= 0){\n // with small probability pick a random candidate\n if(rng.prob(0.15)){\n chosen = rng.randint(0, (int)cands.size()-1);\n }else{\n // avoid immediate reversal if not improving\n if(last_dir != -1 && revdir[cands[0].dir]==last_dir && cands.size()>=2){\n if(cands[1].delta == cands[0].delta || rng.prob(0.5)) chosen = 1;\n }\n }\n }else{\n // improving move, but avoid immediate reversal when tie\n if(last_dir != -1 && revdir[cands[0].dir]==last_dir && cands.size()>=2 && cands[1].delta==cands[0].delta){\n if(rng.prob(0.5)) chosen = 1;\n }\n }\n apply_move(cands[chosen].dir);\n }\n\n // Output\n cout<\nusing namespace std;\n\nstruct Sig {\n uint64_t a=0, b=0;\n bool operator==(Sig const& o) const { return a==o.a && b==o.b; }\n};\nstruct SigHash {\n size_t operator()(Sig const& s) const noexcept {\n uint64_t x = s.a * 0x9E3779B97F4A7C15ULL ^ (s.b + 0x9E3779B97F4A7C15ULL + (s.a<<6) + (s.a>>2));\n return (size_t)x;\n }\n};\n\nstruct LineParam {\n // Integer normal (A,B) with gcd=1, threshold T between projections.\n int A, B;\n long long T;\n};\n\nstruct Point { int x,y; };\n\nstatic inline long long dotAB(int A,int B,int x,int y){ return (long long)A*x + (long long)B*y; }\n\nstatic long long egcd(long long a, long long b, long long &x, long long &y){\n if(b==0){ x = (a>=0?1:-1); y=0; return llabs(a); }\n long long x1,y1;\n long long g = egcd(b, a%b, x1, y1);\n x = y1;\n y = x1 - (a/b) * y1;\n return g;\n}\n\nstatic pair line_two_points(int A,int B,long long T){\n // Find integer solution to A*x + B*y = T, with gcd(A,B)=1.\n long long x0,y0;\n long long g = egcd(A,B,x0,y0);\n // g should be 1 or -1; adjust\n if(g < 0){ g = -g; x0 = -x0; y0 = -y0; }\n // Ensure T divisible by g (it is since g=1).\n long long mul = T / g;\n __int128 xi = (__int128)x0 * mul;\n __int128 yi = (__int128)y0 * mul;\n long long x = (long long)xi;\n long long y = (long long)yi;\n // Generate second point by adding k*(B, -A).\n // Choose k so both points within [-1e9,1e9].\n auto inb = [](long long v){ return v>=-1000000000LL && v<=1000000000LL; };\n long long k = 1000000; // large separation\n // Clamp k by bounds\n auto clamp_k = [&](long long x,long long y)->long long{\n // Need to keep |x + B*k| <= 1e9 and |y - A*k| <= 1e9\n long long k1 = k;\n // reduce if exceeding\n auto fit = [&](long long &kref){\n if(B!=0){\n // compute max |k| bound for x\n long double maxdx = (1000000000.0L - fabsl((long double)x)) / fabsl((long double)B);\n kref = min(kref, (long long)maxdx);\n }\n if(A!=0){\n long double maxdy = (1000000000.0L - fabsl((long double)y)) / fabsl((long double)A);\n kref = min(kref, (long long)maxdy);\n }\n if(kref<=0) kref=1;\n };\n fit(k1);\n return max(1LL, k1);\n };\n long long kk = clamp_k(x,y);\n long long x2 = x + (long long)B * kk;\n long long y2 = y - (long long)A * kk;\n // Ensure first point also in bounds; if not, adjust by shifting k to move closer to zero\n if(!inb(x) || !inb(y)){\n // adjust by shifting with k to bring closer\n long long kshift = 0;\n if(B!=0) kshift = -x / B;\n // try some kshift values\n for(long long u = kshift-5; u<=kshift+5; ++u){\n long long xt = x + (long long)B * u;\n long long yt = y - (long long)A * u;\n if(inb(xt) && inb(yt)){ x=xt; y=yt; break; }\n }\n }\n // If still out of bounds, clamp to +/-1e9 by choosing big k\n if(!inb(x) || !inb(y)){\n // Fallback to simple two points using parameter with kk\n // set base near origin by taking k bringing to origin-ish\n long long k0 = 0;\n if(B!=0) k0 = -x / B;\n x = x + (long long)B * k0;\n y = y - (long long)A * k0;\n if(!inb(x) || !inb(y)){\n // fallback set x=0 solution: if B divides T\n if(B!=0){\n if(T % B == 0){\n y = T / B; x = 0;\n }else{\n // set y=0 solution if A divides T\n if(A!=0 && T % A == 0){\n x = T / A; y = 0;\n }else{\n // leave as is; values should still be small given small A,B,T\n }\n }\n }\n }\n }\n // recompute second point after possibly changed x,y\n kk = 1;\n long long x3 = x + (long long)B * kk;\n long long y3 = y - (long long)A * kk;\n // Final ensure distinct\n if(x3==x && y3==y){\n kk = 2;\n x3 = x + (long long)B * kk;\n y3 = y - (long long)A * kk;\n }\n // Clip to bounds if needed\n auto clip = [](long long v){\n if(v < -1000000000LL) return -1000000000LL;\n if(v > 1000000000LL) return 1000000000LL;\n return v;\n };\n x = clip(x); y = clip(y);\n x3 = clip(x3); y3 = clip(y3);\n return {x, y}; // We'll output both points: (x,y) and (x3,y3)\n}\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, K;\n if(!(cin>>N>>K)) return 0;\n vector a(11);\n for(int d=1; d<=10; ++d) cin>>a[d];\n vector pts(N);\n for(int i=0;i>pts[i].x>>pts[i].y; }\n\n // Predefine normals (A,B), coprime pairs\n vector> normals = {\n {1,0},{0,1},{1,1},{1,-1},{2,1},{1,2},{2,-1},{1,-2},\n {3,1},{1,3},{3,2},{2,3},{3,-1},{1,-3},{3,-2},{2,-3}\n };\n auto reduce_gcd = [](int &A,int &B){\n if(A==0 && B==0){ A=1; B=0; return; }\n if(A==0){ B = (B>0?1:-1); return; }\n if(B==0){ A = (A>0?1:-1); return; }\n int g = std::gcd(abs(A),abs(B));\n A/=g; B/=g;\n if(A<0){ A=-A; B=-B; }\n else if(A==0 && B<0){ B=-B; }\n };\n for(auto &p : normals){ reduce_gcd(p.first, p.second); }\n // Remove duplicates\n sort(normals.begin(), normals.end());\n normals.erase(unique(normals.begin(), normals.end()), normals.end());\n\n // Signatures\n vector sig(N);\n vector lines;\n lines.reserve(K);\n\n // Helper to compute b_d from current signatures\n auto compute_bd = [&](vector& bd, unordered_map, SigHash>& cells){\n cells.clear();\n cells.reserve(N*2);\n for(int i=0;i bd(11,0);\n unordered_map, SigHash> cells;\n compute_bd(bd, cells);\n\n int cutsLeft = K;\n // Main loop\n while(cutsLeft > 0){\n // Needs\n vector need(11,0);\n bool anyNeed = false;\n for(int d=1; d<=10; ++d){ need[d] = max(0, a[d] - bd[d]); if(need[d]>0) anyNeed=true; }\n // Select candidate cells: top by size\n vector> candidates; // (size, sig)\n candidates.reserve(cells.size());\n for(auto &kv : cells){\n candidates.emplace_back((int)kv.second.size(), kv.first);\n }\n sort(candidates.begin(), candidates.end(), [](auto &l, auto &r){ return l.first>r.first; });\n if(candidates.empty()) break;\n int consider = min((int)candidates.size(), 8);\n\n long long bestDelta = LLONG_MIN;\n LineParam bestLine{0,0,0};\n bool found = false;\n\n for(int ci=0; ci 0 && ci >= 2) {\n // keep some resistance to splitting needed sizes unless not in top 2\n continue;\n }\n // Pre-collect points\n vector proj;\n proj.reserve(s);\n\n // For each normal\n for(auto [A,B] : normals){\n proj.clear();\n proj.resize(s);\n for(int i=0;i Lcand;\n // median split\n Lcand.push_back(s/2);\n // aim for most needed d\n int bestd=1, bestNeed=0;\n for(int d=1; d<=10; ++d){ if(need[d]>bestNeed){ bestNeed=need[d]; bestd=d; } }\n if(bestNeed>0) Lcand.push_back(bestd);\n // neighbors\n if(bestd+1 < s) Lcand.push_back(bestd+1);\n if(bestd>1) Lcand.push_back(bestd-1);\n // ensure within [1..s-1]\n for(int &v: Lcand){ if(v<1) v=1; if(v>s-1) v=s-1; }\n // dedup\n sort(Lcand.begin(), Lcand.end());\n Lcand.erase(unique(Lcand.begin(), Lcand.end()), Lcand.end());\n\n // For each target count l, choose the cut between positions l-1 and l (0-index)\n for(int l : Lcand){\n int i = l-1;\n if(i<0 || i+1>=s) continue;\n long long vL = proj[i];\n long long vR = proj[i+1];\n if(vL == vR){\n // if duplicates at border, we can move to nearest gap by expanding\n int il=i, ir=i+1;\n while(il>=0 && proj[il]==vL) --il;\n while(ir=0 && ir=0){\n vL = proj[il]; vR = proj[il+1];\n l = il+1;\n }else if(ir bestDelta){\n bestDelta = score;\n bestLine = {A,B,T};\n found = true;\n }\n }\n }\n }\n\n if(!found){\n // Fallback: simple median split of largest cell with A,B=(1,0)\n auto &idxs = cells[candidates[0].second];\n int s = (int)idxs.size();\n vector proj(s);\n int A=1,B=0;\n for(int i=0;i bd[d]) { allSizesSatisfied=false; break; }\n if(allSizesSatisfied) break;\n }\n\n // Output lines converted to two integer points each\n cout << (int)lines.size() << \"\\n\";\n for(auto &L : lines){\n // Get two points\n long long x0,y0;\n long long xa, ya;\n // get base solution and a second point\n long long x1,y1;\n {\n long long xx, yy;\n long long g = egcd(L.A, L.B, xx, yy);\n if(g<0){ g=-g; xx=-xx; yy=-yy; }\n long long mul = L.T / g;\n x0 = xx * mul;\n y0 = yy * mul;\n long long kk = 100000; // moderate\n x1 = x0 + (long long)L.B * kk;\n y1 = y0 - (long long)L.A * kk;\n auto clip = [](long long v){\n if(v < -1000000000LL) return -1000000000LL;\n if(v > 1000000000LL) return 1000000000LL;\n return v;\n };\n x0 = clip(x0); y0 = clip(y0);\n x1 = clip(x1); y1 = clip(y1);\n if(x1==x0 && y1==y0){\n kk = 1;\n x1 = x0 + (long long)L.B * kk;\n y1 = y0 - (long long)L.A * kk;\n x1 = clip(x1); y1 = clip(y1);\n }\n }\n cout << x0 << \" \" << y0 << \" \" << x1 << \" \" << y1 << \"\\n\";\n }\n return 0;\n}","ahc014":"#include \nusing namespace std;\n\nstruct P { int x,y; };\n\nstatic inline int64_t w_of(int x,int y,int c){\n int dx=x-c, dy=y-c;\n return int64_t(dx)*dx + int64_t(dy)*dy + 1;\n}\n\nstruct Candidate{\n // rectangle in order: p1=new point, then others around perimeter\n P p1,p2,p3,p4;\n int64_t score;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int N, M;\n if(!(cin>>N>>M)) return 0;\n vector

init(M);\n for(int i=0;i>init[i].x>>init[i].y; }\n int c=(N-1)/2;\n\n // Occupancy grid\n vector> occ(N, vector(N, 0));\n for(auto &p:init) occ[p.x][p.y]=1;\n\n // Edge usage: used horizontal edges H[y][x] for (x,y)-(x+1,y), x in [0..N-2], y in [0..N-1]\n vector> usedH(N, vector(N-1, 0));\n // Vertical edges V[x][y] for (x,y)-(x,y+1), x in [0..N-1], y in [0..N-2]\n vector> usedV(N, vector(N-1, 0));\n // We skip diagonal edges in this baseline.\n\n // Maintain list of occupied points per row/col for faster enumeration\n vector> rows(N), cols(N);\n auto rebuild_index = [&](){\n for(int y=0;ybool{\n // axis-aligned rectangle with corners a,b,c,d in order around\n // Iterate unit edges on each side and check used arrays\n auto check_edge = [&](int x1,int y1,int x2,int y2)->bool{\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; ybool{\n // iterate lattice points along sides; allow exactly the three existing corners among perimeter points; new corner a must be empty initially.\n // We assume axis-aligned rectangle with sides parallel to axes.\n auto ok_line = [&](int x1,int y1,int x2,int y2)->bool{\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; y<=yhi; y++){\n if((x==a.x && y==a.y) || (x==b.x && y==b.y) || (x==c.x && y==c.y) || (x==d.x && y==d.y)) continue;\n if(occ[x][y]) return false;\n }\n }else{\n int y=y1;\n int xlo=min(x1,x2), xhi=max(x1,x2);\n for(int x=xlo; x<=xhi; x++){\n if((x==a.x && y==a.y) || (x==b.x && y==b.y) || (x==c.x && y==c.y) || (x==d.x && y==d.y)) continue;\n if(occ[x][y]) return false;\n }\n }\n return true;\n };\n if(!ok_line(a.x,a.y,b.x,b.y)) return false;\n if(!ok_line(b.x,b.y,c.x,c.y)) return false;\n if(!ok_line(c.x,c.y,d.x,d.y)) return false;\n if(!ok_line(d.x,d.y(a.x),(a.y))) return false; // fix after writing\n return true;\n };\n\n // The previous lambda had a minor syntactic issue; we will implement perimeter_points_clean inline later.\n\n // Candidate generation full enumeration (axis-aligned):\n auto build_candidates = [&](vector& out){\n out.clear();\n // For performance, cap number of candidates\n const size_t CAP = 40000;\n // Enumerate pivot B over all occupied\n for(int xb=0; xb=N||yd<0||yd>=N) continue;\n if(occ[xd][yd]) continue;\n // define rectangle order p1=D, p2=A, p3=B, p4=C:\n P D{xd,yd}, A{xa,yb}, B{xb,yb}, C{xb,yc};\n // perimeter dot check\n // Implement perimeter_points_clean inline:\n auto ok_line = [&](int x1,int y1,int x2,int y2)->bool{\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; y<=yhi; y++){\n if((x==D.x && y==D.y) || (x==A.x && y==A.y) || (x==B.x && y==B.y) || (x==C.x && y==C.y)) continue;\n if(occ[x][y]) return false;\n }\n }else if(y1==y2){\n int y=y1;\n int xlo=min(x1,x2), xhi=max(x1,x2);\n for(int x=xlo; x<=xhi; x++){\n if((x==D.x && y==D.y) || (x==A.x && y==A.y) || (x==B.x && y==B.y) || (x==C.x && y==C.y)) continue;\n if(occ[x][y]) return false;\n }\n }else{\n return false;\n }\n return true;\n };\n if(!ok_line(D.x,D.y,A.x,A.y)) continue;\n if(!ok_line(A.x,A.y,B.x,B.y)) continue;\n if(!ok_line(B.x,B.y,C.x,C.y)) continue;\n if(!ok_line(C.x,C.y,D.x,D.y)) continue;\n // edge overlap check without marking now\n auto edges_free = [&]()->bool{\n auto check_edge = [&](int x1,int y1,int x2,int y2)->bool{\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; y= CAP) return;\n }\n }\n }\n }\n };\n\n vector> answer;\n answer.reserve(100000);\n\n auto apply_rect = [&](const Candidate& cand){\n const P &D=cand.p1, &A=cand.p2, &B=cand.p3, &C=cand.p4;\n // Mark edges\n auto mark_edge = [&](int x1,int y1,int x2,int y2){\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; y op = {D.x,D.y, A.x,A.y, B.x,B.y, C.x,C.y};\n answer.push_back(op);\n };\n\n // Main greedy loop\n auto t_start = chrono::steady_clock::now();\n const double TIME_LIMIT = 4.8; // seconds\n int iter = 0;\n while(true){\n // Time check\n if(iter % 10 == 0){\n auto t_now = chrono::steady_clock::now();\n double elapsed = chrono::duration(t_now - t_start).count();\n if(elapsed > TIME_LIMIT) break;\n }\n // Rebuild indices occasionally to keep rows/cols sane (sorted not required)\n if(iter % 50 == 0) rebuild_index();\n\n vector cands;\n build_candidates(cands);\n if(cands.empty()) break;\n // sort by score descending, minor tiebreaker by perimeter length\n stable_sort(cands.begin(), cands.end(), [&](const Candidate& a, const Candidate& b){\n if(a.score != b.score) return a.score > b.score;\n int per_a = abs(a.p1.x - a.p3.x) + abs(a.p1.y - a.p3.y) + abs(a.p2.x - a.p4.x) + abs(a.p2.y - a.p4.y);\n int per_b = abs(b.p1.x - b.p3.x) + abs(b.p1.y - b.p3.y) + abs(b.p2.x - b.p4.x) + abs(b.p2.y - b.p4.y);\n return per_a > per_b;\n });\n bool placed = false;\n for(const auto& cand : cands){\n const P &D=cand.p1, &A=cand.p2, &B=cand.p3, &C=cand.p4;\n if(D.x<0||D.x>=N||D.y<0||D.y>=N) continue;\n if(occ[D.x][D.y]) continue;\n // recheck perimeter cleanliness and edge free (state may have changed)\n auto ok_line = [&](int x1,int y1,int x2,int y2)->bool{\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; y<=yhi; y++){\n if((x==D.x && y==D.y) || (x==A.x && y==A.y) || (x==B.x && y==B.y) || (x==C.x && y==C.y)) continue;\n if(occ[x][y]) return false;\n }\n }else if(y1==y2){\n int y=y1;\n int xlo=min(x1,x2), xhi=max(x1,x2);\n for(int x=xlo; x<=xhi; x++){\n if((x==D.x && y==D.y) || (x==A.x && y==A.y) || (x==B.x && y==B.y) || (x==C.x && y==C.y)) continue;\n if(occ[x][y]) return false;\n }\n }else{\n return false;\n }\n return true;\n };\n if(!ok_line(D.x,D.y,A.x,A.y)) continue;\n if(!ok_line(A.x,A.y,B.x,B.y)) continue;\n if(!ok_line(B.x,B.y,C.x,C.y)) continue;\n if(!ok_line(C.x,C.y,D.x,D.y)) continue;\n\n auto edges_free = [&]()->bool{\n auto check_edge = [&](int x1,int y1,int x2,int y2)->bool{\n if(x1==x2){\n int x=x1;\n int ylo=min(y1,y2), yhi=max(y1,y2);\n for(int y=ylo; y\nusing namespace std;\n\nstruct RNG {\n uint64_t x;\n RNG(uint64_t s=88172645463393265ull){ seed(s); }\n void seed(uint64_t s){ x = s ? s : 88172645463393265ull; }\n uint32_t next_u32(){\n x ^= x << 7; x ^= x >> 9;\n return uint32_t(x & 0xffffffffu);\n }\n double next_double(){\n return (next_u32() + 0.5) / 4294967296.0;\n }\n};\n\nstruct Board {\n static constexpr int H=10, W=10;\n array,H> g{}; // 0 empty, 1..3 flavors\n void clear(){ for(int i=0;i place_by_index(int p, int f){\n int cnt=0;\n for(int i=0;i=0;i--){\n if(b.g[i][j]){\n int v=b.g[i][j];\n b.g[i][j]=0;\n b.g[write][j]=v;\n write--;\n }\n }\n }\n } else if(dir=='L'){ // move left to j=0\n for(int i=0;i=0;j--){\n if(b.g[i][j]){\n int v=b.g[i][j];\n b.g[i][j]=0;\n b.g[i][write]=v;\n write--;\n }\n }\n }\n }\n return b;\n }\n\n bool equals(const Board& other) const {\n for(int i=0;i,4> anchor; // 1-based index used\n int wa=5, wd=2, wdist=1;\n RNG rng;\n Heuristic(){\n // set anchors\n anchor[1] = {0,0}; // flavor 1 -> top-left\n anchor[2] = {0,9}; // flavor 2 -> top-right\n anchor[3] = {9,4}; // flavor 3 -> bottom middle\n rng.seed(123456789u);\n }\n\n int adj_score(const Board& b) const {\n int H=Board::H, W=Board::W;\n int bonus=0, penalty=0;\n for(int i=0;i f(100);\n for(int i=0;i<100;i++){\n if(!(cin>>f[i])) return 0;\n }\n Board board;\n board.clear();\n Heuristic H;\n char lastMove = 'F';\n\n const array dirs = {'F','B','L','R'};\n\n for(int t=0;t<100;t++){\n int p;\n if(!(cin>>p)) return 0;\n // place the candy\n board.place_by_index(p, f[t]);\n\n if(t==99){\n // last tilt does nothing; can skip output per statement\n // But to be safe, output a default move\n // We'll skip to avoid unnecessary I/O\n continue;\n }\n\n int bestScore = INT_MIN;\n char bestDir = 'F';\n Board bestBoard = board;\n\n for(char d: dirs){\n Board nb = board.tilt(d);\n int sc = H.score(nb);\n // prefer actual-changing moves slightly\n if(nb.equals(board)){\n sc -= 1;\n }\n // small tie-breaking inertia\n if(d == lastMove) sc += 0;\n if(sc > bestScore || (sc==bestScore && d==lastMove)){\n bestScore = sc;\n bestDir = d;\n bestBoard = nb;\n }\n }\n\n cout << bestDir << '\\n' << flush;\n lastMove = bestDir;\n board = bestBoard; // maintain internal state consistent with our output\n }\n\n return 0;\n}","ahc016":"#include \n#include \nusing namespace std;\nusing ull = unsigned long long;\nstruct XorShift64 {\n uint64_t x;\n XorShift64(uint64_t s=88172645463393265ull){ if(!s) s=1; x=s; }\n uint64_t rng(){ uint64_t y=x; y^=y<<7; y^=y>>9; return x=y; }\n double drand(){ return (rng() >> 11) * (1.0/9007199254740992.0); } // [0,1)\n int irand(int L,int R){ return L + (int)(rng() % (uint64_t)(R-L+1)); }\n};\nstruct Graph {\n int N;\n vector adj; // upper triangle packed? For building use matrix\n};\nstatic inline int idx_pair(int N,int i,int j){ // i deg_hist; // size N\n vector deg_sorted; // size N\n vector eig; // top T eigenvalues (descending by abs)\n vector nbrdeg_hist; // binned histogram\n};\nstruct Template {\n vector bits; // length N(N-1)/2\n vector deg;\n Features feat;\n};\n\nint main(){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int M;\n double eps;\n if(!(cin>>M>>eps)) return 0;\n\n // Choose N\n int N = 64;\n if (M >= 90 && eps <= 0.08) N = 48; // slightly smaller to improve 1/N when easy\n if (eps >= 0.3) N = 80; // harder noise => more vertices for robustness\n if (N > 100) N = 100;\n if (N < 4) N = 4;\n\n // RNG for constructing templates: deterministic from M, eps\n uint64_t seed = 1469598103934665603ull ^ (uint64_t)M * 1099511628211ull ^ (uint64_t)llround(eps*100.0+0.5);\n XorShift64 gen(seed);\n\n int B = 4; // blocks\n vector block(N);\n // Split N into B almost equal parts\n for(int i=0;iTemplate{\n // derive parameters from k deterministically\n XorShift64 g(seed ^ (uint64_t)(0x9e3779b97f4a7c15ull * (k+1)));\n // base block density matrix P[b][c] in [pmin, pmax]\n double pmin = 0.08 + 0.02 * (g.drand()); // slight variation\n double pmax = 0.92 - 0.02 * (g.drand());\n vector> P(B, vector(B, 0.0));\n for(int b=0;b biasB(B);\n for(int b=0;b bits(Ebits, 0);\n vector deg(N,0);\n for(int i=0;i 0.99) adjp = 0.99;\n if (g.drand() < adjp){\n bits[idx_pair(N,i,j)] = 1;\n deg[i]++; deg[j]++;\n }\n }\n }\n // ensure connectedness is not required; leave as is\n Template T;\n T.bits = move(bits);\n T.deg = move(deg);\n return T;\n };\n\n // Build templates\n vector