{"model_name":"gpt-5.1-thinking","codes":{"1":{"ahc001":"#include \nusing namespace std;\n\nstruct Rect {\n int a, b, c, d; // [a,c) x [b,d)\n};\n\nint n;\nvector xs, ys;\nvector rs;\n\n// Compute total satisfaction for a layout\nlong double compute_score(const vector &rect) {\n long double sum = 0.0L;\n for (int i = 0; i < n; ++i) {\n long long w = rect[i].c - rect[i].a;\n long long h = rect[i].d - rect[i].b;\n if (w <= 0 || h <= 0) continue; // shouldn't happen\n long long s = w * h;\n long double sd = (long double)s;\n long double rd = (long double)rs[i];\n long double ratio = sd / rd;\n if (ratio > 1.0L) ratio = rd / sd; // safety; ideally s <= r always\n long double pi = 1.0L - (1.0L - ratio) * (1.0L - ratio);\n sum += pi;\n }\n return sum;\n}\n\n// Grow rectangles in the given order, produce layout in 'rect' and return score\nlong double run_order(const vector &order, vector &rect) {\n rect.assign(n, Rect());\n vector area(n);\n\n // Initialize as 1x1 cells at seeds\n for (int i = 0; i < n; ++i) {\n rect[i].a = xs[i];\n rect[i].c = xs[i] + 1;\n rect[i].b = ys[i];\n rect[i].d = ys[i] + 1;\n area[i] = 1;\n }\n\n // For each company in the chosen order, grow its rectangle\n for (int idx_pos = 0; idx_pos < n; ++idx_pos) {\n int i = order[idx_pos];\n long long target = rs[i];\n if (target <= 1) continue; // already at desired area\n\n while (area[i] < target) {\n Rect &cur = rect[i];\n int w = cur.c - cur.a;\n int h = cur.d - cur.b;\n if (w <= 0 || h <= 0) break;\n long long remaining = target - area[i];\n\n int bestDir = -1;\n int bestL = 0;\n long long bestDelta = 0;\n\n // Direction 0: up (increase d)\n if (cur.d < 10000 && remaining >= w) {\n long long L_area = remaining / w;\n if (L_area > 0) {\n int limit = 10000 - cur.d; // board boundary\n if (limit > 0) {\n for (int j = 0; j < n; ++j) {\n if (j == i) continue;\n const Rect &s = rect[j];\n // x-overlap?\n if (s.a >= cur.c || s.c <= cur.a) continue;\n // if obstacle is completely below or touching at top\n if (cur.d >= s.d) continue;\n // now s.d > cur.d\n if (s.b <= cur.d) {\n // s.b <= d < s.d -> any extension up hits s\n limit = 0;\n break;\n } else {\n int cand = s.b - cur.d;\n if (cand < limit) {\n limit = cand;\n if (limit <= 0) {\n limit = 0;\n break;\n }\n }\n }\n }\n if (limit > 0) {\n int L = (int)min(limit, L_area);\n if (L > 0) {\n long long delta = 1LL * L * w;\n if (delta > bestDelta) {\n bestDelta = delta;\n bestDir = 0;\n bestL = L;\n }\n }\n }\n }\n }\n }\n\n // Direction 1: down (decrease b)\n if (cur.b > 0 && remaining >= w) {\n long long L_area = remaining / w;\n if (L_area > 0) {\n int limit = cur.b; // distance to 0\n if (limit > 0) {\n for (int j = 0; j < n; ++j) {\n if (j == i) continue;\n const Rect &s = rect[j];\n // x-overlap?\n if (s.a >= cur.c || s.c <= cur.a) continue;\n if (s.b >= cur.b) continue; // s is above or touching\n // s.b < cur.b\n if (s.d > cur.b) {\n // s.b < b < s.d, any extension down hits s\n limit = 0;\n break;\n } else {\n // s.d <= cur.b\n int cand = cur.b - s.d;\n if (cand < limit) {\n limit = cand;\n if (limit <= 0) {\n limit = 0;\n break;\n }\n }\n }\n }\n if (limit > 0) {\n int L = (int)min(limit, L_area);\n if (L > 0) {\n long long delta = 1LL * L * w;\n if (delta > bestDelta) {\n bestDelta = delta;\n bestDir = 1;\n bestL = L;\n }\n }\n }\n }\n }\n }\n\n // Direction 2: left (decrease a)\n if (cur.a > 0 && remaining >= h) {\n long long L_area = remaining / h;\n if (L_area > 0) {\n int limit = cur.a; // distance to 0\n if (limit > 0) {\n for (int j = 0; j < n; ++j) {\n if (j == i) continue;\n const Rect &s = rect[j];\n // y-overlap?\n if (s.d <= cur.b || cur.d <= s.b) continue;\n if (s.a >= cur.a) {\n // s entirely to the right or touching at a\n continue;\n } else {\n // s.a < cur.a\n if (s.c > cur.a) {\n // s crosses vertical line x = cur.a,\n // any extension left hits s\n limit = 0;\n break;\n } else {\n // s.c <= cur.a, s entirely left\n int cand = cur.a - s.c;\n if (cand < limit) {\n limit = cand;\n if (limit <= 0) {\n limit = 0;\n break;\n }\n }\n }\n }\n }\n if (limit > 0) {\n int L = (int)min(limit, L_area);\n if (L > 0) {\n long long delta = 1LL * L * h;\n if (delta > bestDelta) {\n bestDelta = delta;\n bestDir = 2;\n bestL = L;\n }\n }\n }\n }\n }\n }\n\n // Direction 3: right (increase c)\n if (cur.c < 10000 && remaining >= h) {\n long long L_area = remaining / h;\n if (L_area > 0) {\n int limit = 10000 - cur.c; // board boundary\n if (limit > 0) {\n for (int j = 0; j < n; ++j) {\n if (j == i) continue;\n const Rect &s = rect[j];\n // y-overlap?\n if (s.d <= cur.b || cur.d <= s.b) continue;\n if (cur.c >= s.c) {\n // s entirely to the left or touching at c\n continue;\n } else {\n // cur.c < s.c\n if (s.a <= cur.c) {\n // s crosses vertical line x = cur.c\n limit = 0;\n break;\n } else {\n // s.a > cur.c, s entirely to the right\n int cand = s.a - cur.c;\n if (cand < limit) {\n limit = cand;\n if (limit <= 0) {\n limit = 0;\n break;\n }\n }\n }\n }\n }\n if (limit > 0) {\n int L = (int)min(limit, L_area);\n if (L > 0) {\n long long delta = 1LL * L * h;\n if (delta > bestDelta) {\n bestDelta = delta;\n bestDir = 3;\n bestL = L;\n }\n }\n }\n }\n }\n }\n\n if (bestDir == -1 || bestL <= 0 || bestDelta <= 0) {\n break; // no further growth possible\n }\n\n // Apply the best extension\n switch (bestDir) {\n case 0: // up\n cur.d += bestL;\n break;\n case 1: // down\n cur.b -= bestL;\n break;\n case 2: // left\n cur.a -= bestL;\n break;\n case 3: // right\n cur.c += bestL;\n break;\n }\n area[i] += bestDelta;\n }\n }\n\n return compute_score(rect);\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> n;\n xs.resize(n);\n ys.resize(n);\n rs.resize(n);\n\n for (int i = 0; i < n; ++i) {\n cin >> xs[i] >> ys[i] >> rs[i];\n }\n\n vector base(n);\n iota(base.begin(), base.end(), 0);\n\n vector rect, bestRect;\n long double bestScore = -1.0L;\n\n // 1) order by increasing r_i\n {\n vector order = base;\n sort(order.begin(), order.end(), [&](int a, int b) {\n if (rs[a] != rs[b]) return rs[a] < rs[b];\n return a < b;\n });\n long double sc = run_order(order, rect);\n if (sc > bestScore) {\n bestScore = sc;\n bestRect = rect;\n }\n }\n\n // 2) order by decreasing r_i\n {\n vector order = base;\n sort(order.begin(), order.end(), [&](int a, int b) {\n if (rs[a] != rs[b]) return rs[a] > rs[b];\n return a < b;\n });\n long double sc = run_order(order, rect);\n if (sc > bestScore) {\n bestScore = sc;\n bestRect = rect;\n }\n }\n\n // 3) order by increasing x\n {\n vector order = base;\n sort(order.begin(), order.end(), [&](int a, int b) {\n if (xs[a] != xs[b]) return xs[a] < xs[b];\n return a < b;\n });\n long double sc = run_order(order, rect);\n if (sc > bestScore) {\n bestScore = sc;\n bestRect = rect;\n }\n }\n\n // 4) order by increasing y\n {\n vector order = base;\n sort(order.begin(), order.end(), [&](int a, int b) {\n if (ys[a] != ys[b]) return ys[a] < ys[b];\n return a < b;\n });\n long double sc = run_order(order, rect);\n if (sc > bestScore) {\n bestScore = sc;\n bestRect = rect;\n }\n }\n\n // Randomized orders\n std::mt19937_64 rng(123456789ULL);\n int randomRuns = 48; // total ~52 runs including 4 deterministic\n\n for (int t = 0; t < randomRuns; ++t) {\n vector order = base;\n shuffle(order.begin(), order.end(), rng);\n long double sc = run_order(order, rect);\n if (sc > bestScore) {\n bestScore = sc;\n bestRect = rect;\n }\n }\n\n // Output best layout\n for (int i = 0; i < n; ++i) {\n cout << bestRect[i].a << ' ' << bestRect[i].b << ' '\n << bestRect[i].c << ' ' << bestRect[i].d << '\\n';\n }\n return 0;\n}","ahc002":"#include \nusing namespace std;\n\n// Fast xorshift RNG\nstruct XorShift64 {\n uint64_t x;\n XorShift64() {\n uint64_t seed = chrono::steady_clock::now().time_since_epoch().count();\n x = seed ^ (seed << 13);\n }\n inline uint64_t next() {\n x ^= x << 7;\n x ^= x >> 9;\n return x;\n }\n inline uint32_t next_u32() {\n return static_cast(next());\n }\n};\n\nstruct Path {\n int score;\n vector seq;\n};\n\n// Globals for simplicity (grid is fixed 50x50)\nconstexpr int H = 50;\nconstexpr int W = 50;\nconstexpr int N = H * W;\nconstexpr int MAX_TILES = 2500;\n\nint tileID[N]; // tile index for each cell\nint valCell[N]; // score of each cell\nint nei[N][4]; // neighbors (cell indices)\nint neiCnt[N]; // number of neighbors for each cell\nint visitedTime[MAX_TILES]; // last iteration stamp when tile was visited\nint startCell; // starting cell index\nint maxTileId; // max tile id in input\n\nint iterStamp = 0;\nXorShift64 rng;\n\n// Check if tile t is visited in current walk\ninline bool isVisitedTile(int t) {\n return visitedTime[t] == iterStamp;\n}\n\n// Build one path using a given mode (0,1,2)\nPath build_path(int mode) {\n ++iterStamp;\n Path path;\n path.seq.reserve(N);\n path.score = 0;\n\n int cur = startCell;\n path.seq.push_back(cur);\n path.score += valCell[cur];\n visitedTime[tileID[cur]] = iterStamp;\n\n while (true) {\n int cand[4];\n int candCount = 0;\n\n // Collect candidate neighbors: adjacent cells whose tile is not yet visited\n for (int k = 0; k < neiCnt[cur]; ++k) {\n int v = nei[cur][k];\n int t = tileID[v];\n if (isVisitedTile(t)) continue; // tile already visited\n cand[candCount++] = v;\n }\n\n if (candCount == 0) break;\n\n int deg[4];\n\n // Compute \"forward degree\" for each candidate: how many moves are possible after stepping there\n for (int i = 0; i < candCount; ++i) {\n int v = cand[i];\n int tv = tileID[v];\n int d = 0;\n for (int k = 0; k < neiCnt[v]; ++k) {\n int w = nei[v][k];\n int tw = tileID[w];\n if (tw == tv) continue; // same tile, won't be allowed after step\n if (isVisitedTile(tw)) continue; // tile already used\n ++d;\n }\n deg[i] = d;\n }\n\n int chosenIdx = 0;\n\n if (mode == 0) {\n // Mode 0: balanced\n // Prefer class 0 (deg>=2), then 1 (deg==1), then 2 (deg==0)\n // Within class: smaller deg first, then higher value\n int bestClass = 3;\n int bestDeg = 1000;\n int bestVal = -1;\n for (int i = 0; i < candCount; ++i) {\n int d = deg[i];\n int cls = (d >= 2 ? 0 : (d == 1 ? 1 : 2));\n int v = cand[i];\n int pv = valCell[v];\n bool better = false;\n\n if (cls < bestClass) {\n better = true;\n } else if (cls == bestClass) {\n if (d < bestDeg) {\n better = true;\n } else if (d == bestDeg) {\n if (pv > bestVal) {\n better = true;\n } else if (pv == bestVal) {\n // random tie-break\n if (rng.next_u32() & 1u) better = true;\n }\n }\n }\n\n if (better) {\n bestClass = cls;\n bestDeg = d;\n bestVal = pv;\n chosenIdx = i;\n }\n }\n } else if (mode == 1) {\n // Mode 1: pure Warnsdorff (minimize deg), tie by high value\n int bestDeg = 1000;\n int bestVal = -1;\n for (int i = 0; i < candCount; ++i) {\n int d = deg[i];\n int v = cand[i];\n int pv = valCell[v];\n bool better = false;\n\n if (d < bestDeg) {\n better = true;\n } else if (d == bestDeg) {\n if (pv > bestVal) {\n better = true;\n } else if (pv == bestVal) {\n if (rng.next_u32() & 1u) better = true;\n }\n }\n\n if (better) {\n bestDeg = d;\n bestVal = pv;\n chosenIdx = i;\n }\n }\n } else {\n // Mode 2: value-first, tie by larger deg\n int bestVal = -1;\n int bestDeg = -1;\n for (int i = 0; i < candCount; ++i) {\n int v = cand[i];\n int pv = valCell[v];\n int d = deg[i];\n bool better = false;\n\n if (pv > bestVal) {\n better = true;\n } else if (pv == bestVal) {\n if (d > bestDeg) {\n better = true;\n } else if (d == bestDeg) {\n if (rng.next_u32() & 1u) better = true;\n }\n }\n\n if (better) {\n bestVal = pv;\n bestDeg = d;\n chosenIdx = i;\n }\n }\n }\n\n // Small random exploration: 5% chance choose totally random candidate\n if (candCount > 1 && (rng.next_u32() % 20u == 0u)) {\n chosenIdx = rng.next_u32() % candCount;\n }\n\n int nextCell = cand[chosenIdx];\n cur = nextCell;\n path.seq.push_back(cur);\n path.score += valCell[cur];\n visitedTime[tileID[cur]] = iterStamp;\n }\n\n return path;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int si, sj;\n if (!(cin >> si >> sj)) {\n return 0;\n }\n\n maxTileId = -1;\n\n // Read tiles\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n int t;\n cin >> t;\n int idx = i * W + j;\n tileID[idx] = t;\n if (t > maxTileId) maxTileId = t;\n }\n }\n\n // Read cell values\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n int p;\n cin >> p;\n int idx = i * W + j;\n valCell[idx] = p;\n }\n }\n\n // Precompute neighbors on the grid (4-neighborhood)\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W; ++j) {\n int idx = i * W + j;\n int cnt = 0;\n if (i > 0) nei[idx][cnt++] = (i - 1) * W + j;\n if (i + 1 < H) nei[idx][cnt++] = (i + 1) * W + j;\n if (j > 0) nei[idx][cnt++] = i * W + (j - 1);\n if (j + 1 < W) nei[idx][cnt++] = i * W + (j + 1);\n neiCnt[idx] = cnt;\n }\n }\n\n // Initialize visitedTime\n for (int i = 0; i <= maxTileId; ++i) visitedTime[i] = 0;\n\n startCell = si * W + sj;\n\n auto startTime = chrono::steady_clock::now();\n const double TIME_LIMIT = 1.9; // seconds\n\n Path best;\n best.score = -1;\n\n int iterations = 0;\n while (true) {\n int mode = static_cast(rng.next_u32() % 3u); // 0,1,2\n Path cur = build_path(mode);\n\n if (cur.score > best.score ||\n (cur.score == best.score && cur.seq.size() > best.seq.size())) {\n best = std::move(cur);\n }\n\n ++iterations;\n if ((iterations & 7) == 0) { // check time every 8 iterations\n auto now = chrono::steady_clock::now();\n double elapsed = chrono::duration(now - startTime).count();\n if (elapsed > TIME_LIMIT) break;\n }\n }\n\n // Convert best.seq (cells) into moves string\n string ans;\n ans.reserve(best.seq.size());\n for (size_t k = 1; k < best.seq.size(); ++k) {\n int prev = best.seq[k - 1];\n int cur = best.seq[k];\n int pi = prev / W, pj = prev % W;\n int ci = cur / W, cj = cur % W;\n if (ci == pi) {\n if (cj == pj + 1) ans.push_back('R');\n else if (cj == pj - 1) ans.push_back('L');\n } else if (cj == pj) {\n if (ci == pi + 1) ans.push_back('D');\n else if (ci == pi - 1) ans.push_back('U');\n }\n // Since we only move along neighbors, no other case should occur.\n }\n\n cout << ans << '\\n';\n return 0;\n}","ahc003":"#include \nusing namespace std;\n\nstatic const int H = 30;\nstatic const int W = 30;\nstatic const int N = H * W;\nstatic const int EH = H * (W - 1);\nstatic const int EV = (H - 1) * W;\nstatic const int E = EH + EV;\nstatic const double INF = 1e100;\n\n// Edge indices for canonical orientations\nint h_id[H][W - 1]; // horizontal: (i,j)-(i,j+1) -> h_id[i][j]\nint v_id[H - 1][W]; // vertical: (i,j)-(i+1,j) -> v_id[i][j]\n\n// Adjacency: for each vertex, (to, edge_id)\nvector> adj[N];\n\n// Edge weights (our estimates) and their randomized version per query\nvector w(E), eff_w(E);\n\n// Dijkstra buffers\ndouble dist_arr[N];\nint prev_v_arr[N];\nint prev_e_arr[N];\n\ninline int vid(int i, int j) {\n return i * W + j;\n}\n\n// RNG for jitter\nmt19937_64 rng(71236782123ULL);\n\ninline double rand01() {\n return std::generate_canonical(rng); // [0,1)\n}\n\n// Dijkstra using eff_w, returns path as \"UDLR\"\nstring dijkstra_path(int si, int sj, int ti, int tj, int query_id) {\n // Jitter decreases over time\n const double JITTER0 = 0.03;\n double jitter = JITTER0 * max(0.0, 1.0 - (double)query_id / 800.0);\n if (jitter < 0.0) jitter = 0.0;\n\n // Build jittered weights\n for (int e = 0; e < E; ++e) {\n double u = 2.0 * rand01() - 1.0; // [-1,1)\n double factor = 1.0 + jitter * u;\n if (factor < 0.5) factor = 0.5; // safety\n eff_w[e] = w[e] * factor;\n if (eff_w[e] < 1.0) eff_w[e] = 1.0; // strictly positive\n }\n\n int s = vid(si, sj);\n int t = vid(ti, tj);\n\n // Initialize Dijkstra\n for (int i = 0; i < N; ++i) {\n dist_arr[i] = INF;\n prev_v_arr[i] = -1;\n prev_e_arr[i] = -1;\n }\n dist_arr[s] = 0.0;\n\n using P = pair;\n priority_queue, greater

> pq;\n pq.emplace(0.0, s);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist_arr[u]) continue;\n if (u == t) break;\n for (auto &pe : adj[u]) {\n int v = pe.first;\n int eid = pe.second;\n double nd = d + eff_w[eid];\n if (nd < dist_arr[v]) {\n dist_arr[v] = nd;\n prev_v_arr[v] = u;\n prev_e_arr[v] = eid;\n pq.emplace(nd, v);\n }\n }\n }\n\n // Reconstruct path\n string rev;\n int v = t;\n while (v != s) {\n int u = prev_v_arr[v];\n if (u == -1) {\n // Fallback: Manhattan path if something goes wrong\n rev.clear();\n int ci = si, cj = sj;\n while (ci < ti) { rev.push_back('D'); ++ci; }\n while (ci > ti) { rev.push_back('U'); --ci; }\n while (cj < tj) { rev.push_back('R'); ++cj; }\n while (cj > tj) { rev.push_back('L'); --cj; }\n break;\n }\n int ui = u / W, uj = u % W;\n int vi = v / W, vj = v % W;\n if (vi == ui) {\n if (vj == uj + 1) rev.push_back('R');\n else if (vj == uj - 1) rev.push_back('L');\n } else if (vj == uj) {\n if (vi == ui + 1) rev.push_back('D');\n else if (vi == ui - 1) rev.push_back('U');\n }\n v = u;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n}\n\n// Convert move string into list of edge IDs\nvoid path_to_edges(int si, int sj, const string &path, vector &edges) {\n edges.clear();\n edges.reserve(path.size());\n int i = si, j = sj;\n for (char c : path) {\n int eid = -1;\n if (c == 'U') {\n int ni = i - 1;\n eid = v_id[ni][j]; // edge between (ni,j) and (ni+1,j)\n i = ni;\n } else if (c == 'D') {\n eid = v_id[i][j]; // edge between (i,j) and (i+1,j)\n i = i + 1;\n } else if (c == 'L') {\n int nj = j - 1;\n eid = h_id[i][nj]; // edge between (i,nj) and (i,nj+1)\n j = nj;\n } else if (c == 'R') {\n eid = h_id[i][j]; // edge between (i,j) and (i,j+1)\n j = j + 1;\n }\n edges.push_back(eid);\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Build graph and edge indexing\n int eid = 0;\n // Horizontal edges\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W - 1; ++j) {\n h_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i, j + 1);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n // Vertical edges\n for (int i = 0; i < H - 1; ++i) {\n for (int j = 0; j < W; ++j) {\n v_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i + 1, j);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n\n // Initialize weights\n w.assign(E, 5000.0);\n eff_w.assign(E, 5000.0);\n\n vector edges;\n const double ETA = 0.5; // learning rate multiplier\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; // EOF / error\n }\n\n // Compute path\n string path = dijkstra_path(si, sj, ti, tj, q);\n\n // Output and flush\n cout << path << '\\n';\n cout.flush();\n\n long long y_ll;\n if (!(cin >> y_ll)) {\n return 0; // EOF / error\n }\n double y = (double)y_ll;\n\n // Update weights based on feedback\n path_to_edges(si, sj, path, edges);\n int L = (int)edges.size();\n if (L == 0) continue; // shouldn't happen (distance >= 10)\n\n double pred = 0.0;\n for (int e : edges) {\n pred += w[e];\n }\n double error = y - pred;\n\n double lr = ETA / (double)L;\n for (int e : edges) {\n w[e] += lr * error;\n if (w[e] < 1000.0) w[e] = 1000.0;\n else if (w[e] > 9000.0) w[e] = 9000.0;\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int MAX_N = 20;\nstatic const int MAX_M = 800;\nstatic const int ALPHA = 8;\n\nint N, M;\nvector patterns;\n\n// Aho-Corasick automaton\nstruct Node {\n int next[ALPHA];\n int link;\n vector out;\n Node() {\n fill(next, next + ALPHA, -1);\n link = -1;\n }\n};\nvector ac;\n\n// grid\nchar grid[MAX_N][MAX_N];\n\n// pattern occurrence flags\n// store as unsigned char 0/1\nunsigned char row_has[MAX_N][MAX_M];\nunsigned char col_has[MAX_N][MAX_M];\nint pattern_cov_count[MAX_M]; // how many rows+cols contain pattern i\nint current_c = 0;\n\n// scratch for SA\nbool mark_row[MAX_M];\nbool mark_col[MAX_M];\n\n// random generator\nmt19937_64 rng;\n\n/// Map character 'A'..'H' to 0..7\ninline int ch_idx(char c) {\n return c - 'A';\n}\n\nvoid build_automaton() {\n ac.clear();\n ac.emplace_back(); // root\n\n // build trie\n for (int i = 0; i < M; ++i) {\n const string &s = patterns[i];\n int v = 0;\n for (char ch : s) {\n int c = ch_idx(ch);\n if (ac[v].next[c] == -1) {\n ac[v].next[c] = (int)ac.size();\n ac.emplace_back();\n }\n v = ac[v].next[c];\n }\n ac[v].out.push_back(i);\n }\n\n // build failure links\n queue q;\n // root link to 0\n ac[0].link = 0;\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[0].next[c];\n if (u != -1) {\n ac[u].link = 0;\n q.push(u);\n } else {\n ac[0].next[c] = 0; // missing edge loops to root\n }\n }\n\n while (!q.empty()) {\n int v = q.front(); q.pop();\n int link = ac[v].link;\n // propagate outputs\n if (!ac[link].out.empty()) {\n // append pattern indices from link to v\n ac[v].out.insert(ac[v].out.end(), ac[link].out.begin(), ac[link].out.end());\n }\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[v].next[c];\n if (u != -1) {\n ac[u].link = ac[link].next[c];\n q.push(u);\n } else {\n ac[v].next[c] = ac[link].next[c];\n }\n }\n }\n}\n\n// scan a line (length len) through AC, mark which patterns appear\ninline void scan_line(const char *s, int len, bool *mark) {\n int v = 0;\n for (int i = 0; i < len; ++i) {\n int c = ch_idx(s[i]);\n v = ac[v].next[c];\n const vector &out = ac[v].out;\n for (int id : out) {\n if (id < M) mark[id] = true;\n }\n }\n}\n\n// recompute one row r and update global counts\nvoid recalc_row(int r) {\n char line[2 * MAX_N];\n for (int j = 0; j < N; ++j) line[j] = grid[r][j];\n for (int j = 0; j < N; ++j) line[N + j] = line[j];\n\n static bool mark[MAX_M];\n fill(mark, mark + M, false);\n scan_line(line, 2 * N, mark);\n\n for (int i = 0; i < M; ++i) {\n int oldFlag = row_has[r][i];\n int newFlag = mark[i] ? 1 : 0;\n if (oldFlag == newFlag) continue;\n if (newFlag) {\n row_has[r][i] = 1;\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n row_has[r][i] = 0;\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n }\n}\n\n// recompute one column c and update global counts\nvoid recalc_col(int c) {\n char line[2 * MAX_N];\n for (int i = 0; i < N; ++i) line[i] = grid[i][c];\n for (int i = 0; i < N; ++i) line[N + i] = line[i];\n\n static bool mark[MAX_M];\n fill(mark, mark + M, false);\n scan_line(line, 2 * N, mark);\n\n for (int i = 0; i < M; ++i) {\n int oldFlag = col_has[c][i];\n int newFlag = mark[i] ? 1 : 0;\n if (oldFlag == newFlag) continue;\n if (newFlag) {\n col_has[c][i] = 1;\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n col_has[c][i] = 0;\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n }\n}\n\n// pattern \"kick\" move: force-place a random pattern somewhere\nvoid apply_pattern_kick() {\n uniform_int_distribution pat_dist(0, M - 1);\n int pid = pat_dist(rng);\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n uniform_int_distribution dir_dist(0, 1);\n int dir = dir_dist(rng); // 0: horizontal, 1: vertical\n\n bool rowChanged[MAX_N] = {false};\n bool colChanged[MAX_N] = {false};\n\n if (dir == 0) {\n // horizontal\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n int r = row_dist(rng);\n int c0 = col_dist(rng);\n\n for (int t = 0; t < len; ++t) {\n int cc = c0 + t;\n if (cc >= N) cc -= N;\n if (grid[r][cc] != s[t]) {\n grid[r][cc] = s[t];\n rowChanged[r] = true;\n colChanged[cc] = true;\n }\n }\n } else {\n // vertical\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n int r0 = row_dist(rng);\n int c = col_dist(rng);\n\n for (int t = 0; t < len; ++t) {\n int rr = r0 + t;\n if (rr >= N) rr -= N;\n if (grid[rr][c] != s[t]) {\n grid[rr][c] = s[t];\n rowChanged[rr] = true;\n colChanged[c] = true;\n }\n }\n }\n\n for (int r = 0; r < N; ++r) if (rowChanged[r]) recalc_row(r);\n for (int c = 0; c < N; ++c) if (colChanged[c]) recalc_col(c);\n}\n\ndouble my_rand_double() {\n // 53-bit mantissa random double in [0,1)\n return (rng() >> 11) * (1.0 / (1ull << 53));\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M;\n patterns.resize(M);\n for (int i = 0; i < M; ++i) {\n cin >> patterns[i];\n }\n\n // init RNG\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n build_automaton();\n\n // initial grid: random letters\n uniform_int_distribution letter_dist(0, ALPHA - 1);\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n grid[i][j] = char('A' + letter_dist(rng));\n }\n }\n\n // constructive pass: greedily place patterns to align with existing letters\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n\n for (int idx = 0; idx < M; ++idx) {\n int pid = order[idx];\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0;\n int bestR = 0;\n int bestC = 0;\n\n // horizontal candidates\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore) {\n if (my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n }\n\n // vertical candidates\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore) {\n if (my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n }\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n r++;\n if (r == N) r = 0;\n }\n }\n }\n\n // Initialize evaluation\n memset(row_has, 0, sizeof(row_has));\n memset(col_has, 0, sizeof(col_has));\n fill(pattern_cov_count, pattern_cov_count + M, 0);\n current_c = 0;\n\n for (int r = 0; r < N; ++r) recalc_row(r);\n for (int c = 0; c < N; ++c) recalc_col(c);\n\n // SA parameters\n const double TIME_LIMIT = 2.8; // seconds (stay below 3.0)\n auto start_time = chrono::high_resolution_clock::now();\n double T0 = 2.0;\n double T1 = 0.1;\n\n // keep best grid\n char best_grid[MAX_N][MAX_N];\n int best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n\n int iter = 0;\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n double progress = elapsed / TIME_LIMIT;\n double T = T0 + (T1 - T0) * progress;\n\n // occasional pattern kick in early phase\n if ((iter % 1000 == 0) && (progress < 0.5)) {\n apply_pattern_kick();\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n int r = row_dist(rng);\n int c = col_dist(rng);\n char oldCh = grid[r][c];\n\n char newCh;\n do {\n newCh = char('A' + letter_dist(rng));\n } while (newCh == oldCh);\n\n // build candidate row line\n char row_line[2 * MAX_N];\n for (int j = 0; j < N; ++j) {\n row_line[j] = (j == c) ? newCh : grid[r][j];\n }\n for (int j = 0; j < N; ++j) row_line[N + j] = row_line[j];\n\n fill(mark_row, mark_row + M, false);\n scan_line(row_line, 2 * N, mark_row);\n\n // candidate column line\n char col_line[2 * MAX_N];\n for (int i = 0; i < N; ++i) {\n col_line[i] = (i == r) ? newCh : grid[i][c];\n }\n for (int i = 0; i < N; ++i) col_line[N + i] = col_line[i];\n\n fill(mark_col, mark_col + M, false);\n scan_line(col_line, 2 * N, mark_col);\n\n int new_c = current_c;\n // compute new_c\n for (int i = 0; i < M; ++i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n int oldRow = row_has[r][i];\n int newRow = mark_row[i] ? 1 : 0;\n newCov += newRow - oldRow;\n\n int oldCol = col_has[c][i];\n int newCol = mark_col[i] ? 1 : 0;\n newCov += newCol - oldCol;\n\n if (oldCov <= 0 && newCov > 0) new_c++;\n else if (oldCov > 0 && newCov <= 0) new_c--;\n }\n\n int delta = new_c - current_c;\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (prob > my_rand_double()) accept = true;\n }\n\n if (accept) {\n // commit\n grid[r][c] = newCh;\n for (int i = 0; i < M; ++i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n int oldRow = row_has[r][i];\n int newRow = mark_row[i] ? 1 : 0;\n newCov += newRow - oldRow;\n\n int oldCol = col_has[c][i];\n int newCol = mark_col[i] ? 1 : 0;\n newCov += newCol - oldCol;\n\n pattern_cov_count[i] = newCov;\n row_has[r][i] = (unsigned char)newRow;\n col_has[c][i] = (unsigned char)newCol;\n }\n current_c = new_c;\n\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n ++iter;\n }\n\n // Output best grid\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 << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n int w;\n};\n\nconst int INF = 1e9;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector grid(N);\n for (int i = 0; i < N; ++i) cin >> grid[i];\n\n // Map each road cell to an id\n static int idOf[70][70];\n int r = 0;\n vector> pos; // id -> (i,j)\n vector cost; // id -> cell cost (5-9)\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n idOf[i][j] = r++;\n pos.emplace_back(i, j);\n cost.push_back(grid[i][j] - '0');\n } else {\n idOf[i][j] = -1;\n }\n }\n }\n\n if (r == 0) {\n // Should not happen (start is road), but just in case\n cout << \"\\n\";\n return 0;\n }\n\n int startId = idOf[si][sj];\n\n // Build graph\n vector> G(r);\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N && idOf[ni][nj] != -1) {\n int v = idOf[ni][nj];\n G[id].push_back({v, cost[v]});\n }\n }\n }\n\n // -------- Build fallback DFS route (simple traversal of all cells) --------\n auto buildDFSRoute = [&]() -> vector {\n vector route;\n route.reserve(2 * r + 5);\n vector used(r, 0);\n vector st;\n vector edgeIdx(r, 0);\n\n route.push_back(startId);\n used[startId] = 1;\n st.push_back(startId);\n\n while (!st.empty()) {\n int u = st.back();\n bool advanced = false;\n auto &ei = edgeIdx[u];\n while (ei < (int)G[u].size()) {\n int v = G[u][ei].to;\n ++ei;\n if (!used[v]) {\n used[v] = 1;\n st.push_back(v);\n route.push_back(v);\n advanced = true;\n break;\n }\n }\n if (!advanced) {\n st.pop_back();\n if (!st.empty()) {\n route.push_back(st.back());\n }\n }\n }\n return route; // starts and ends at startId\n };\n\n auto computeTravelTime = [&](const vector &route) -> long long {\n long long t = 0;\n for (int i = 1; i < (int)route.size(); ++i) {\n t += cost[route[i]];\n }\n return t;\n };\n\n vector fallbackRoute = buildDFSRoute();\n long long fallbackTime = computeTravelTime(fallbackRoute);\n\n // -------- Build horizontal and vertical segments --------\n vector> rowSegCells;\n vector rowSegIdOfCell(r, -1);\n\n for (int i = 0; i < N; ++i) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') {\n ++j;\n continue;\n }\n int segIdx = (int)rowSegCells.size();\n rowSegCells.emplace_back();\n while (j < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n rowSegIdOfCell[id] = segIdx;\n rowSegCells.back().push_back(id);\n ++j;\n }\n }\n }\n\n vector> colSegCells;\n vector colSegIdOfCell(r, -1);\n\n for (int j = 0; j < N; ++j) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') {\n ++i;\n continue;\n }\n int segIdx = (int)colSegCells.size();\n colSegCells.emplace_back();\n while (i < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n colSegIdOfCell[id] = segIdx;\n colSegCells.back().push_back(id);\n ++i;\n }\n }\n }\n\n // -------- Precompute visibility (coverage) for *all* cells --------\n vector> coverageAll(r);\n for (int id = 0; id < r; ++id) {\n auto &v = coverageAll[id];\n auto &rowV = rowSegCells[rowSegIdOfCell[id]];\n auto &colV = colSegCells[colSegIdOfCell[id]];\n v.reserve(rowV.size() + colV.size());\n for (int x : rowV) v.push_back(x);\n for (int x : colV) v.push_back(x);\n }\n\n // -------- Build candidate vantage cells --------\n vector isIntersection(r, 0);\n vector hasInterRow(rowSegCells.size(), 0);\n vector hasInterCol(colSegCells.size(), 0);\n\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n bool hor = false, ver = false;\n if (j > 0 && idOf[i][j-1] != -1) hor = true;\n if (j+1 < N && idOf[i][j+1] != -1) hor = true;\n if (i > 0 && idOf[i-1][j] != -1) ver = true;\n if (i+1 < N && idOf[i+1][j] != -1) ver = true;\n if (hor && ver) {\n isIntersection[id] = 1;\n hasInterRow[rowSegIdOfCell[id]] = 1;\n hasInterCol[colSegIdOfCell[id]] = 1;\n }\n }\n\n vector isCandidate(r, 0);\n vector candidateCells;\n candidateCells.reserve(r);\n\n // Intersection cells as candidates\n for (int id = 0; id < r; ++id) {\n if (isIntersection[id]) {\n isCandidate[id] = 1;\n candidateCells.push_back(id);\n }\n }\n\n // Segments without intersections: pick a midpoint cell as candidate\n for (int s = 0; s < (int)rowSegCells.size(); ++s) {\n if (!hasInterRow[s]) {\n int mid = rowSegCells[s][rowSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n for (int s = 0; s < (int)colSegCells.size(); ++s) {\n if (!hasInterCol[s]) {\n int mid = colSegCells[s][colSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n\n // Ensure start cell is a candidate\n if (!isCandidate[startId]) {\n isCandidate[startId] = 1;\n candidateCells.push_back(startId);\n }\n\n // Coverage of candidates\n int C = (int)candidateCells.size();\n vector> candCover;\n candCover.reserve(C);\n vector cellCovered(r, 0);\n for (int idx = 0; idx < C; ++idx) {\n int cell = candidateCells[idx];\n candCover.push_back(coverageAll[cell]);\n for (int x : candCover[idx]) cellCovered[x] = 1;\n }\n\n // Patch: if some cell is not covered by any candidate, add it as candidate\n for (int id = 0; id < r; ++id) {\n if (!cellCovered[id]) {\n isCandidate[id] = 1;\n candidateCells.push_back(id);\n candCover.push_back(coverageAll[id]);\n for (int x : coverageAll[id]) cellCovered[x] = 1;\n }\n }\n C = (int)candidateCells.size();\n\n // -------- Greedy set cover on candidates --------\n vector vantageCells; // chosen vantage cell ids\n vantageCells.reserve(C);\n\n vector coveredCells(r, 0);\n int coveredCount = 0;\n vector candSelected(C, 0);\n\n auto selectCandidate = [&](int idx) {\n if (candSelected[idx]) return;\n candSelected[idx] = 1;\n int cell = candidateCells[idx];\n vantageCells.push_back(cell);\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n };\n\n int startCandIdx = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candidateCells[idx] == startId) {\n startCandIdx = idx;\n break;\n }\n }\n if (startCandIdx == -1) {\n // Should not happen, but safeguard: add start as standalone vantage\n vantageCells.push_back(startId);\n for (int x : coverageAll[startId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(startCandIdx);\n }\n\n while (coveredCount < r) {\n int bestIdx = -1;\n int bestGain = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candSelected[idx]) continue;\n int gain = 0;\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) ++gain;\n }\n if (gain > bestGain) {\n bestGain = gain;\n bestIdx = idx;\n } else if (gain == bestGain && gain > 0 && bestIdx != -1) {\n // Tie-break: closer (Manhattan) to start\n int cellNew = candidateCells[idx];\n int cellBest = candidateCells[bestIdx];\n auto [ni, nj] = pos[cellNew];\n auto [bi, bj] = pos[cellBest];\n int manNew = abs(ni - si) + abs(nj - sj);\n int manBest = abs(bi - si) + abs(bj - sj);\n if (manNew < manBest) bestIdx = idx;\n }\n }\n\n if (bestIdx == -1 || bestGain <= 0) {\n // Safeguard: pick some uncovered cell itself as vantage\n int uncoveredId = -1;\n for (int id = 0; id < r; ++id) {\n if (!coveredCells[id]) {\n uncoveredId = id;\n break;\n }\n }\n if (uncoveredId == -1) break; // should not\n vantageCells.push_back(uncoveredId);\n for (int x : coverageAll[uncoveredId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(bestIdx);\n }\n }\n\n // Remove possible duplicates in vantageCells (shouldn't normally exist)\n sort(vantageCells.begin(), vantageCells.end());\n vantageCells.erase(unique(vantageCells.begin(), vantageCells.end()), vantageCells.end());\n\n // -------- Build main route visiting all vantages (nearest-neighbor via Dijkstra) --------\n vector isTarget(r, 0);\n for (int id : vantageCells) isTarget[id] = 1;\n\n vector visitedTarget(r, 0);\n int remainingTargets = 0;\n for (int id : vantageCells) {\n if (id == startId) {\n visitedTarget[id] = 1;\n } else {\n ++remainingTargets;\n }\n }\n\n vector routeMain;\n routeMain.reserve(2 * r + 5);\n routeMain.push_back(startId);\n\n vector dist(r), prev(r);\n\n auto dijkstraNearestTarget = [&](int src) -> int {\n fill(dist.begin(), dist.end(), INF);\n fill(prev.begin(), prev.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n int target = -1;\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (isTarget[u] && !visitedTarget[u]) {\n target = u;\n break;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.push({nd, v});\n }\n }\n }\n return target;\n };\n\n auto dijkstraToDest = [&](int src, int dest) {\n fill(dist.begin(), dist.end(), INF);\n fill(prev.begin(), prev.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (u == dest) break;\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prev[v] = u;\n pq.push({nd, v});\n }\n }\n }\n };\n\n int curr = startId;\n while (remainingTargets > 0) {\n int target = dijkstraNearestTarget(curr);\n if (target == -1) {\n break; // should not happen if graph is connected\n }\n // reconstruct path from curr to target (excluding curr)\n vector tmp;\n int x = target;\n while (x != curr && x != -1) {\n tmp.push_back(x);\n x = prev[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n int node = tmp[i];\n routeMain.push_back(node);\n if (isTarget[node] && !visitedTarget[node]) {\n visitedTarget[node] = 1;\n --remainingTargets;\n }\n }\n curr = target;\n }\n\n // Return to start\n if (curr != startId) {\n dijkstraToDest(curr, startId);\n vector tmp;\n int x = startId;\n while (x != curr && x != -1) {\n tmp.push_back(x);\n x = prev[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n routeMain.push_back(tmp[i]);\n }\n }\n\n long long mainTime = computeTravelTime(routeMain);\n\n // Choose better route (shorter travel time)\n vector bestRoute;\n long long bestTime;\n if (mainTime < fallbackTime) {\n bestRoute = std::move(routeMain);\n bestTime = mainTime;\n } else {\n bestRoute = std::move(fallbackRoute);\n bestTime = fallbackTime;\n }\n\n // If route has no movement (length 1), add a tiny loop to avoid t=0\n if ((int)bestRoute.size() == 1) {\n int u = startId;\n int v = -1;\n for (auto &e : G[u]) {\n v = e.to;\n break;\n }\n if (v != -1) {\n bestRoute.push_back(v);\n bestRoute.push_back(u);\n }\n }\n\n // Convert node sequence to direction string\n string ans;\n ans.reserve(bestRoute.size());\n for (int i = 1; i < (int)bestRoute.size(); ++i) {\n auto [i1, j1] = pos[bestRoute[i-1]];\n auto [i2, j2] = pos[bestRoute[i]];\n if (i2 == i1 - 1 && j2 == j1) ans.push_back('U');\n else if (i2 == i1 + 1 && j2 == j1) ans.push_back('D');\n else if (j2 == j1 - 1 && i2 == i1) ans.push_back('L');\n else if (j2 == j1 + 1 && i2 == i1) ans.push_back('R');\n else {\n // Should not happen; if it does, output empty (WA rather than UB)\n // but this should never occur with correct Dijkstra paths.\n }\n }\n\n cout << ans << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) {\n return 0;\n }\n\n // Task requirements d[i][k]\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) {\n cin >> d[i][k];\n }\n }\n\n // Dependencies: u -> v (v depends on u)\n vector> out(N);\n vector indeg(N, 0);\n for (int e = 0; e < R; ++e) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg[v]++;\n }\n\n // Precompute depth-from-end (longest path length to any sink)\n vector depth(N, 0);\n for (int i = N - 1; i >= 0; --i) {\n int best = 0;\n for (int v : out[i]) {\n best = max(best, depth[v] + 1);\n }\n depth[i] = best;\n }\n\n // Task states\n const int NOT_STARTED = 0;\n const int IN_PROGRESS = 1;\n const int DONE = 2;\n vector state(N, NOT_STARTED);\n vector degRem = indeg;\n int tasksDone = 0;\n\n // Worker states\n vector curTask(M, -1); // current task index or -1\n vector startDay(M, -1); // start day of current task\n\n // Per-worker linear model coefficients a[j][k]\n vector> a(M, vector(K, 0.5)); // initial slope ~0.5\n const double GAMMA = 5e-4;\n\n int day = 0;\n const int MAX_CAND = 200;\n\n while (true) {\n day++;\n\n // Compute available tasks (not started and all prerequisites done)\n vector available;\n if (tasksDone < N) {\n available.reserve(N);\n for (int i = 0; i < N; ++i) {\n if (state[i] == NOT_STARTED && degRem[i] == 0) {\n available.push_back(i);\n }\n }\n }\n\n // Collect free workers\n vector freeWorkers;\n freeWorkers.reserve(M);\n for (int j = 0; j < M; ++j) {\n if (curTask[j] == -1) {\n freeWorkers.push_back(j);\n }\n }\n\n // Decide assignments\n vector> assigns; // (worker, task)\n if (!freeWorkers.empty() && !available.empty()) {\n // Restrict to top MAX_CAND tasks by depth\n auto cmpTask = [&](int x, int y) {\n if (depth[x] != depth[y]) return depth[x] > depth[y];\n return x < y;\n };\n\n int sz = (int)available.size();\n if (sz > MAX_CAND) {\n int limit = MAX_CAND;\n // partial_sort first 'limit' elements\n partial_sort(available.begin(), available.begin() + limit,\n available.end(), cmpTask);\n available.resize(limit);\n sz = limit;\n } else {\n sort(available.begin(), available.end(), cmpTask);\n }\n\n // Build all (worker, task) options with predicted cost\n struct Option {\n double cost;\n int w;\n int task;\n };\n vector

> pq;\n pq.emplace(0.0, s);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist_arr[u]) continue;\n if (u == t) break;\n for (auto &pe : adj[u]) {\n int v = pe.first;\n int eid = pe.second;\n double nd = d + eff_w[eid];\n if (nd < dist_arr[v]) {\n dist_arr[v] = nd;\n prev_v_arr[v] = u;\n prev_e_arr[v] = eid;\n pq.emplace(nd, v);\n }\n }\n }\n\n // Reconstruct path\n string rev;\n int v = t;\n while (v != s) {\n int u = prev_v_arr[v];\n if (u == -1) {\n // Fallback: Manhattan path if something goes wrong\n rev.clear();\n int ci = si, cj = sj;\n while (ci < ti) { rev.push_back('D'); ++ci; }\n while (ci > ti) { rev.push_back('U'); --ci; }\n while (cj < tj) { rev.push_back('R'); ++cj; }\n while (cj > tj) { rev.push_back('L'); --cj; }\n break;\n }\n int ui = u / W, uj = u % W;\n int vi = v / W, vj = v % W;\n if (vi == ui) {\n if (vj == uj + 1) rev.push_back('R');\n else if (vj == uj - 1) rev.push_back('L');\n } else if (vj == uj) {\n if (vi == ui + 1) rev.push_back('D');\n else if (vi == ui - 1) rev.push_back('U');\n }\n v = u;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n}\n\n// Convert move string into list of edge IDs\nvoid path_to_edges(int si, int sj, const string &path, vector &edges) {\n edges.clear();\n edges.reserve(path.size());\n int i = si, j = sj;\n for (char c : path) {\n int eid = -1;\n if (c == 'U') {\n int ni = i - 1;\n eid = v_id[ni][j]; // edge between (ni,j) and (ni+1,j)\n i = ni;\n } else if (c == 'D') {\n eid = v_id[i][j]; // edge between (i,j) and (i+1,j)\n i = i + 1;\n } else if (c == 'L') {\n int nj = j - 1;\n eid = h_id[i][nj]; // edge between (i,nj) and (i,nj+1)\n j = nj;\n } else if (c == 'R') {\n eid = h_id[i][j]; // edge between (i,j) and (i,j+1)\n j = j + 1;\n }\n edges.push_back(eid);\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Build graph and edge indexing\n int eid = 0;\n // Horizontal edges\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W - 1; ++j) {\n h_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i, j + 1);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n // Vertical edges\n for (int i = 0; i < H - 1; ++i) {\n for (int j = 0; j < W; ++j) {\n v_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i + 1, j);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n\n // Initialize weights\n w.assign(E, 5000.0);\n eff_w.assign(E, 5000.0);\n\n vector edges;\n const double ETA = 0.5; // learning rate multiplier\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; // EOF / error\n }\n\n // Compute path\n string path = dijkstra_path(si, sj, ti, tj, q);\n\n // Output and flush\n cout << path << '\\n';\n cout.flush();\n\n long long y_ll;\n if (!(cin >> y_ll)) {\n return 0; // EOF / error\n }\n double y = (double)y_ll;\n\n // Update weights based on feedback\n path_to_edges(si, sj, path, edges);\n int L = (int)edges.size();\n if (L == 0) continue; // shouldn't happen (distance >= 10)\n\n double pred = 0.0;\n for (int e : edges) {\n pred += w[e];\n }\n double error = y - pred;\n\n double lr = ETA / (double)L;\n for (int e : edges) {\n w[e] += lr * error;\n if (w[e] < 1000.0) w[e] = 1000.0;\n else if (w[e] > 9000.0) w[e] = 9000.0;\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int MAX_N = 20;\nstatic const int MAX_M = 800;\nstatic const int ALPHA = 8;\nstatic const int MAXW = (MAX_M + 63) / 64;\n\nint N, M;\nint WORDS; // actual number of 64-bit words used\nvector patterns;\n\n// bitset over up to MAX_M bits\nstruct BS {\n uint64_t w[MAXW];\n};\n\n// bitset helpers\ninline void bs_clear(BS &b) {\n // clear all words; cost is tiny (<= 13 words)\n memset(b.w, 0, sizeof(b.w));\n}\ninline void bs_or_inplace(BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) a.w[i] |= b.w[i];\n}\ninline void bs_xor(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] ^ b.w[i];\n}\ninline void bs_or(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] | b.w[i];\n}\ninline bool bs_test(const BS &b, int idx) {\n return (b.w[idx >> 6] >> (idx & 63)) & 1ULL;\n}\ninline void bs_set(BS &b, int idx) {\n b.w[idx >> 6] |= 1ULL << (idx & 63);\n}\ninline void bs_reset(BS &b, int idx) {\n b.w[idx >> 6] &= ~(1ULL << (idx & 63));\n}\n\n// iterate over set bits of b, calling f(idx) for each\ntemplate \ninline void bs_for_each(const BS &b, F f) {\n for (int w = 0; w < WORDS; ++w) {\n uint64_t x = b.w[w];\n while (x) {\n int lsb = __builtin_ctzll(x);\n int idx = (w << 6) + lsb;\n if (idx >= M) return; // safety; bits >=M are never set\n f(idx);\n x &= x - 1; // clear lowest set bit\n }\n }\n}\n\n// Aho\u2013Corasick automaton\nstruct Node {\n int next[ALPHA];\n int link;\n BS out; // bitset of patterns that end at this state (including via failure)\n Node() {\n fill(next, next + ALPHA, -1);\n link = 0;\n bs_clear(out);\n }\n};\nvector ac;\n\n// grid\nchar grid[MAX_N][MAX_N];\n\n// row/col pattern presence\nBS row_bs[MAX_N], col_bs[MAX_N];\n\n// pattern coverage count across all rows+cols\nint pattern_cov_count[MAX_M];\nint current_c = 0;\n\n// RNG\nmt19937_64 rng;\n\ninline int ch_idx(char c) {\n return c - 'A'; // 'A'..'H' -> 0..7\n}\n\nvoid build_automaton() {\n ac.clear();\n ac.emplace_back(); // root\n\n // build trie and set pattern bits\n for (int i = 0; i < M; ++i) {\n const string &s = patterns[i];\n int v = 0;\n for (char ch : s) {\n int c = ch_idx(ch);\n if (ac[v].next[c] == -1) {\n ac[v].next[c] = (int)ac.size();\n ac.emplace_back();\n }\n v = ac[v].next[c];\n }\n bs_set(ac[v].out, i);\n }\n\n // build failure links\n queue q;\n\n // initialize root transitions\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[0].next[c];\n if (u != -1) {\n ac[u].link = 0;\n q.push(u);\n } else {\n ac[0].next[c] = 0;\n }\n }\n\n while (!q.empty()) {\n int v = q.front(); q.pop();\n int link = ac[v].link;\n\n // propagate pattern bits from failure link\n bs_or_inplace(ac[v].out, ac[link].out);\n\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[v].next[c];\n if (u != -1) {\n ac[u].link = ac[link].next[c];\n q.push(u);\n } else {\n ac[v].next[c] = ac[link].next[c];\n }\n }\n }\n}\n\n// scan a line through AC, return bitset of patterns appearing\ninline BS scan_line(const char *s, int len) {\n BS res;\n bs_clear(res);\n int v = 0;\n for (int i = 0; i < len; ++i) {\n int c = ch_idx(s[i]);\n v = ac[v].next[c];\n bs_or_inplace(res, ac[v].out);\n }\n return res;\n}\n\n// recompute one row r and update global counts\nvoid recalc_row(int r) {\n char line[2 * MAX_N];\n for (int j = 0; j < N; ++j) line[j] = grid[r][j];\n for (int j = 0; j < N; ++j) line[N + j] = line[j];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, row_bs[r], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(row_bs[r], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return; // should not happen but safe\n\n if (newFlag) {\n bs_set(row_bs[r], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(row_bs[r], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// recompute one column c and update global counts\nvoid recalc_col(int c) {\n char line[2 * MAX_N];\n for (int i = 0; i < N; ++i) line[i] = grid[i][c];\n for (int i = 0; i < N; ++i) line[N + i] = line[i];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, col_bs[c], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(col_bs[c], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return; // should not happen but safe\n\n if (newFlag) {\n bs_set(col_bs[c], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(col_bs[c], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// pattern \"kick\" move: force-place a random pattern somewhere\nvoid apply_pattern_kick() {\n uniform_int_distribution pat_dist(0, M - 1);\n int pid = pat_dist(rng);\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n uniform_int_distribution dir_dist(0, 1);\n int dir = dir_dist(rng); // 0: horizontal, 1: vertical\n\n bool rowChanged[MAX_N] = {false};\n bool colChanged[MAX_N] = {false};\n\n if (dir == 0) {\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n int r = row_dist(rng);\n int c0 = col_dist(rng);\n\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n c++;\n if (c == N) c = 0;\n }\n } else {\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n int r0 = row_dist(rng);\n int c = col_dist(rng);\n\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n r++;\n if (r == N) r = 0;\n }\n }\n\n for (int r = 0; r < N; ++r) if (rowChanged[r]) recalc_row(r);\n for (int c = 0; c < N; ++c) if (colChanged[c]) recalc_col(c);\n}\n\ndouble my_rand_double() {\n // 53-bit mantissa random double in [0,1)\n return (rng() >> 11) * (1.0 / (1ULL << 53));\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M;\n patterns.resize(M);\n for (int i = 0; i < M; ++i) cin >> patterns[i];\n\n WORDS = (M + 63) / 64;\n\n // init RNG\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n build_automaton();\n\n uniform_int_distribution letter_dist(0, ALPHA - 1);\n\n // initial grid: random letters\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n grid[i][j] = char('A' + letter_dist(rng));\n\n // constructive pass: greedily place patterns to align with existing letters\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n\n for (int idx = 0; idx < M; ++idx) {\n int pid = order[idx];\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0;\n int bestR = 0;\n int bestC = 0;\n\n // horizontal candidates\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n\n // vertical candidates\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n r++;\n if (r == N) r = 0;\n }\n }\n }\n\n // Initialize evaluation\n for (int r = 0; r < N; ++r) bs_clear(row_bs[r]);\n for (int c = 0; c < N; ++c) bs_clear(col_bs[c]);\n fill(pattern_cov_count, pattern_cov_count + M, 0);\n current_c = 0;\n\n for (int r = 0; r < N; ++r) recalc_row(r);\n for (int c = 0; c < N; ++c) recalc_col(c);\n\n // SA parameters\n const double TIME_LIMIT = 2.75; // seconds for SA part\n auto start_time = chrono::high_resolution_clock::now();\n double T0 = 1.5;\n double T1 = 0.05;\n\n // keep best grid\n char best_grid[MAX_N][MAX_N];\n int best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n\n int iter = 0;\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n double progress = elapsed / TIME_LIMIT;\n double T = T0 + (T1 - T0) * progress;\n\n // occasional pattern kick in early phase\n if ((iter % 2000 == 0) && (progress < 0.5)) {\n apply_pattern_kick();\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n int r = row_dist(rng);\n int c = col_dist(rng);\n char oldCh = grid[r][c];\n\n char newCh;\n do {\n newCh = char('A' + letter_dist(rng));\n } while (newCh == oldCh);\n\n // candidate row\n char row_line[2 * MAX_N];\n for (int j = 0; j < N; ++j)\n row_line[j] = (j == c) ? newCh : grid[r][j];\n for (int j = 0; j < N; ++j)\n row_line[N + j] = row_line[j];\n\n BS mark_row = scan_line(row_line, 2 * N);\n\n // candidate column\n char col_line[2 * MAX_N];\n for (int i = 0; i < N; ++i)\n col_line[i] = (i == r) ? newCh : grid[i][c];\n for (int i = 0; i < N; ++i)\n col_line[N + i] = col_line[i];\n\n BS mark_col = scan_line(col_line, 2 * N);\n\n // changed patterns on row and column\n BS changed_row, changed_col, changed_union;\n bs_xor(changed_row, row_bs[r], mark_row);\n bs_xor(changed_col, col_bs[c], mark_col);\n bs_or(changed_union, changed_row, changed_col);\n\n int new_c = current_c;\n\n // compute new_c considering only changed patterns\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n if (oldCov == 0 && newCov > 0) new_c++;\n else if (oldCov > 0 && newCov == 0) new_c--;\n });\n\n int delta = new_c - current_c;\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (prob > my_rand_double()) accept = true;\n }\n\n if (accept) {\n // commit the change\n grid[r][c] = newCh;\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n pattern_cov_count[i] = newCov;\n\n if (newRow) bs_set(row_bs[r], i);\n else bs_reset(row_bs[r], i);\n if (newCol) bs_set(col_bs[c], i);\n else bs_reset(col_bs[c], i);\n });\n current_c = new_c;\n\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n ++iter;\n }\n\n // Output best grid\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 << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n int w;\n};\n\nconst int INF = 1e9;\n\n// Compute travel time of a route (sequence of cell IDs).\n// Cost to move into cell v is cost[v].\nlong long computeTravelTime(const vector &route, const vector &cost) {\n long long t = 0;\n for (int i = 1; i < (int)route.size(); ++i) {\n t += cost[route[i]];\n }\n return t;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector grid(N);\n for (int i = 0; i < N; ++i) cin >> grid[i];\n\n // Map each road cell to an ID\n static int idOf[70][70];\n int r = 0;\n vector> pos; // id -> (i,j)\n vector cost; // id -> cell cost (5-9)\n pos.reserve(N * N);\n cost.reserve(N * N);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n idOf[i][j] = r++;\n pos.emplace_back(i, j);\n cost.push_back(grid[i][j] - '0');\n } else {\n idOf[i][j] = -1;\n }\n }\n }\n\n if (r == 0) {\n cout << \"\\n\";\n return 0;\n }\n\n int startId = idOf[si][sj];\n\n // Build graph of road cells\n vector> G(r);\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N && idOf[ni][nj] != -1) {\n int v = idOf[ni][nj];\n G[id].push_back({v, cost[v]});\n }\n }\n }\n\n // ---------- Fallback DFS route (visits all cells) ----------\n auto buildDFSRoute = [&]() -> vector {\n vector route;\n route.reserve(2 * r + 5);\n vector used(r, 0);\n vector st;\n vector edgeIdx(r, 0);\n\n route.push_back(startId);\n used[startId] = 1;\n st.push_back(startId);\n\n while (!st.empty()) {\n int u = st.back();\n bool advanced = false;\n int &ei = edgeIdx[u];\n while (ei < (int)G[u].size()) {\n int v = G[u][ei].to;\n ++ei;\n if (!used[v]) {\n used[v] = 1;\n st.push_back(v);\n route.push_back(v);\n advanced = true;\n break;\n }\n }\n if (!advanced) {\n st.pop_back();\n if (!st.empty()) {\n route.push_back(st.back());\n }\n }\n }\n return route; // starts and ends at startId\n };\n\n vector fallbackRoute = buildDFSRoute();\n long long fallbackTime = computeTravelTime(fallbackRoute, cost);\n\n // ---------- Build horizontal and vertical segments ----------\n vector> rowSegCells;\n vector rowSegIdOfCell(r, -1);\n for (int i = 0; i < N; ++i) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') {\n ++j;\n continue;\n }\n int segIdx = (int)rowSegCells.size();\n rowSegCells.emplace_back();\n while (j < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n rowSegIdOfCell[id] = segIdx;\n rowSegCells.back().push_back(id);\n ++j;\n }\n }\n }\n\n vector> colSegCells;\n vector colSegIdOfCell(r, -1);\n for (int j = 0; j < N; ++j) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') {\n ++i;\n continue;\n }\n int segIdx = (int)colSegCells.size();\n colSegCells.emplace_back();\n while (i < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n colSegIdOfCell[id] = segIdx;\n colSegCells.back().push_back(id);\n ++i;\n }\n }\n }\n\n // ---------- Precompute visibility (coverage) for all cells ----------\n vector> coverageAll(r);\n for (int id = 0; id < r; ++id) {\n auto &v = coverageAll[id];\n auto &rowV = rowSegCells[rowSegIdOfCell[id]];\n auto &colV = colSegCells[colSegIdOfCell[id]];\n v.reserve(rowV.size() + colV.size());\n for (int x : rowV) v.push_back(x);\n for (int x : colV) v.push_back(x);\n }\n\n // ---------- Build candidate vantage cells (mostly intersections) ----------\n vector isIntersection(r, 0);\n vector hasInterRow(rowSegCells.size(), 0);\n vector hasInterCol(colSegCells.size(), 0);\n\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n bool hor = false, ver = false;\n if (j > 0 && idOf[i][j-1] != -1) hor = true;\n if (j+1 < N && idOf[i][j+1] != -1) hor = true;\n if (i > 0 && idOf[i-1][j] != -1) ver = true;\n if (i+1 < N && idOf[i+1][j] != -1) ver = true;\n if (hor && ver) {\n isIntersection[id] = 1;\n hasInterRow[rowSegIdOfCell[id]] = 1;\n hasInterCol[colSegIdOfCell[id]] = 1;\n }\n }\n\n vector isCandidate(r, 0);\n vector candidateCells;\n candidateCells.reserve(r);\n\n // Intersections\n for (int id = 0; id < r; ++id) {\n if (isIntersection[id]) {\n isCandidate[id] = 1;\n candidateCells.push_back(id);\n }\n }\n // Midpoints of segments without intersections\n for (int s = 0; s < (int)rowSegCells.size(); ++s) {\n if (!hasInterRow[s]) {\n int mid = rowSegCells[s][rowSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n for (int s = 0; s < (int)colSegCells.size(); ++s) {\n if (!hasInterCol[s]) {\n int mid = colSegCells[s][colSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n // Ensure start cell is candidate\n if (!isCandidate[startId]) {\n isCandidate[startId] = 1;\n candidateCells.push_back(startId);\n }\n\n // Coverage of candidates, and which cells are coverable by some candidate\n int C = (int)candidateCells.size();\n vector> candCover;\n candCover.reserve(C);\n vector cellCovered(r, 0);\n for (int idx = 0; idx < C; ++idx) {\n int cell = candidateCells[idx];\n candCover.push_back(coverageAll[cell]);\n for (int x : candCover.back()) cellCovered[x] = 1;\n }\n\n // Patch: if some cell is not covered by any candidate, add it itself as candidate\n for (int id = 0; id < r; ++id) {\n if (!cellCovered[id]) {\n candidateCells.push_back(id);\n candCover.push_back(coverageAll[id]);\n for (int x : coverageAll[id]) cellCovered[x] = 1;\n }\n }\n C = (int)candidateCells.size();\n\n // ---------- Greedy set cover on candidates (cell-based) ----------\n vector vantageCells;\n vantageCells.reserve(C);\n\n vector coveredCells(r, 0);\n int coveredCount = 0;\n vector candSelected(C, 0);\n\n auto selectCandidate = [&](int idx) {\n if (candSelected[idx]) return;\n candSelected[idx] = 1;\n int cell = candidateCells[idx];\n vantageCells.push_back(cell);\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n };\n\n // Use start cell as the first vantage (it's \"free\" since we start there)\n int startCandIdx = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candidateCells[idx] == startId) {\n startCandIdx = idx;\n break;\n }\n }\n if (startCandIdx == -1) {\n // Safeguard (shouldn't happen)\n vantageCells.push_back(startId);\n for (int x : coverageAll[startId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(startCandIdx);\n }\n\n // Greedy: repeatedly add candidate with maximum marginal gain\n while (coveredCount < r) {\n int bestIdx = -1;\n int bestGain = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candSelected[idx]) continue;\n int gain = 0;\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) ++gain;\n }\n if (gain > bestGain) {\n bestGain = gain;\n bestIdx = idx;\n } else if (gain == bestGain && gain > 0 && bestIdx != -1) {\n // Tie-break: closer to start (Manhattan)\n int cellNew = candidateCells[idx];\n int cellBest = candidateCells[bestIdx];\n auto [ni, nj] = pos[cellNew];\n auto [bi, bj] = pos[cellBest];\n int manNew = abs(ni - si) + abs(nj - sj);\n int manBest = abs(bi - si) + abs(bj - sj);\n if (manNew < manBest) bestIdx = idx;\n }\n }\n\n if (bestIdx == -1 || bestGain <= 0) {\n // Safeguard: directly add some uncovered cell as vantage\n int uncoveredId = -1;\n for (int id = 0; id < r; ++id) {\n if (!coveredCells[id]) {\n uncoveredId = id;\n break;\n }\n }\n if (uncoveredId == -1) break; // should not happen\n vantageCells.push_back(uncoveredId);\n for (int x : coverageAll[uncoveredId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(bestIdx);\n }\n }\n\n // Deduplicate vantages (just in case)\n sort(vantageCells.begin(), vantageCells.end());\n vantageCells.erase(unique(vantageCells.begin(), vantageCells.end()), vantageCells.end());\n\n // ---------- Dijkstra helpers ----------\n vector dist(r), prevv(r);\n\n auto dijkstraNearestTarget = [&](int src,\n const vector &isTarget,\n const vector &visitedTarget) -> int {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n int target = -1;\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (isTarget[u] && !visitedTarget[u]) {\n target = u;\n break;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n return target;\n };\n\n auto dijkstraToDest = [&](int src, int dest) {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (u == dest) break;\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n };\n\n auto appendPath = [&](vector &route, int src, int dest) {\n if (src == dest) return;\n dijkstraToDest(src, dest);\n vector tmp;\n int x = dest;\n while (x != src && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n route.push_back(tmp[i]);\n }\n };\n\n // ---------- Route 1: Greedy nearest neighbor on vantages ----------\n auto buildRouteGreedyNN = [&](const vector &vantages) -> vector {\n vector route;\n route.reserve(2 * r + 5);\n\n vector isTarget(r, 0), visitedTarget(r, 0);\n for (int id : vantages) isTarget[id] = 1;\n\n int remainingTargets = 0;\n for (int id : vantages) {\n if (id == startId) {\n visitedTarget[id] = 1;\n } else {\n ++remainingTargets;\n }\n }\n\n route.push_back(startId);\n int curr = startId;\n\n while (remainingTargets > 0) {\n int target = dijkstraNearestTarget(curr, isTarget, visitedTarget);\n if (target == -1) break; // should not happen (connected component)\n\n // Reconstruct path curr -> target using prevv from dijkstraNearestTarget\n vector tmp;\n int x = target;\n while (x != curr && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n int node = tmp[i];\n route.push_back(node);\n if (isTarget[node] && !visitedTarget[node]) {\n visitedTarget[node] = 1;\n --remainingTargets;\n }\n }\n curr = target;\n }\n\n // Return to start\n if (curr != startId) {\n appendPath(route, curr, startId);\n }\n return route;\n };\n\n vector routeNN = buildRouteGreedyNN(vantageCells);\n long long timeNN = computeTravelTime(routeNN, cost);\n\n // ---------- Route 2: Approximate TSP (Manhattan + 2-opt) on vantages ----------\n vector routeTSP;\n long long timeTSP = (1LL << 60);\n\n if (!vantageCells.empty()) {\n // Build node list: start + all vantages (without duplicating start)\n vector nodes;\n nodes.reserve(vantageCells.size() + 1);\n nodes.push_back(startId);\n for (int v : vantageCells) {\n if (v != startId) nodes.push_back(v);\n }\n int K = (int)nodes.size();\n\n // Limit TSP heuristic to moderate size to keep cost under control\n if (K <= 250) {\n // Manhattan distances as cheap approximation\n vector> approxDist(K, vector(K, 0));\n for (int i = 0; i < K; ++i) {\n auto [xi, yi] = pos[nodes[i]];\n for (int j = i + 1; j < K; ++j) {\n auto [xj, yj] = pos[nodes[j]];\n int d = abs(xi - xj) + abs(yi - yj);\n approxDist[i][j] = approxDist[j][i] = d;\n }\n }\n\n // Initial route: nearest neighbor on approxDist\n vector order(K);\n vector used(K, 0);\n order[0] = 0;\n used[0] = 1;\n for (int t = 1; t < K; ++t) {\n int prevIdx = order[t - 1];\n int best = -1;\n int bestD = INT_MAX;\n for (int j = 0; j < K; ++j) {\n if (used[j]) continue;\n int d = approxDist[prevIdx][j];\n if (d < bestD) {\n bestD = d;\n best = j;\n }\n }\n if (best == -1) best = 0; // safety\n order[t] = best;\n used[best] = 1;\n }\n\n // 2-opt improvement (first-improvement, keep start fixed at order[0] = 0)\n bool improved = true;\n while (improved) {\n improved = false;\n for (int i = 1; i < K - 1 && !improved; ++i) {\n int a = order[i - 1];\n int b = order[i];\n for (int j = i + 1; j < K; ++j) {\n int c = order[j];\n int d = (j + 1 < K ? order[j + 1] : order[0]);\n int curCost = approxDist[a][b] + approxDist[c][d];\n int newCost = approxDist[a][c] + approxDist[b][d];\n if (newCost < curCost) {\n reverse(order.begin() + i, order.begin() + j + 1);\n improved = true;\n break;\n }\n }\n }\n }\n\n // Build actual route following this order (0..K-1), starting at startId\n routeTSP.reserve(2 * r + 5);\n routeTSP.push_back(startId);\n int curr = startId;\n for (int idxPos = 1; idxPos < K; ++idxPos) {\n int nodeIdx = order[idxPos];\n int dest = nodes[nodeIdx];\n if (dest == curr) continue;\n appendPath(routeTSP, curr, dest);\n curr = dest;\n }\n if (curr != startId) {\n appendPath(routeTSP, curr, startId);\n }\n timeTSP = computeTravelTime(routeTSP, cost);\n }\n }\n\n // ---------- Choose the best route among: DFS fallback, NN, TSP ----------\n vector bestRoute = fallbackRoute;\n long long bestTime = fallbackTime;\n\n if (!routeNN.empty() && timeNN < bestTime) {\n bestTime = timeNN;\n bestRoute = std::move(routeNN);\n }\n if (!routeTSP.empty() && timeTSP < bestTime) {\n bestTime = timeTSP;\n bestRoute = std::move(routeTSP);\n }\n\n // If route has no movement, add a tiny loop to avoid t=0\n if ((int)bestRoute.size() == 1) {\n int u = startId;\n int v = -1;\n for (auto &e : G[u]) {\n v = e.to;\n break;\n }\n if (v != -1) {\n bestRoute.push_back(v);\n bestRoute.push_back(u);\n }\n }\n\n // ---------- Convert node sequence to direction string ----------\n string ans;\n ans.reserve(bestRoute.size());\n for (int i = 1; i < (int)bestRoute.size(); ++i) {\n auto [i1, j1] = pos[bestRoute[i-1]];\n auto [i2, j2] = pos[bestRoute[i]];\n if (i2 == i1 - 1 && j2 == j1) ans.push_back('U');\n else if (i2 == i1 + 1 && j2 == j1) ans.push_back('D');\n else if (j2 == j1 - 1 && i2 == i1) ans.push_back('L');\n else if (j2 == j1 + 1 && i2 == i1) ans.push_back('R');\n else {\n // Should not happen with valid shortest paths\n }\n }\n\n cout << ans << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n // Task requirements d[i][k]\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) cin >> d[i][k];\n }\n\n // Dependencies: u -> v\n vector> out(N);\n vector indeg(N, 0);\n for (int e = 0; e < R; ++e) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg[v]++;\n }\n\n // Precompute depth-from-end (longest path length to any sink)\n vector depth(N, 0);\n for (int i = N - 1; i >= 0; --i) {\n int best = 0;\n for (int v : out[i]) {\n best = max(best, depth[v] + 1);\n }\n depth[i] = best;\n }\n\n // Precompute simple difficulty measure (L1 norm)\n vector diffL1(N, 0);\n for (int i = 0; i < N; ++i) {\n int s = 0;\n for (int k = 0; k < K; ++k) s += d[i][k];\n diffL1[i] = s;\n }\n\n // Task states\n const int NOT_STARTED = 0;\n const int IN_PROGRESS = 1;\n const int DONE = 2;\n vector state(N, NOT_STARTED);\n vector degRem = indeg;\n int tasksDone = 0;\n\n // Worker states\n vector curTask(M, -1);\n vector startDay(M, -1);\n\n // Worker skill vectors s_j[k]\n vector> skill(M, vector(K, 0.0));\n // History of (task, w_obs) per worker for fitting\n vector> histTasks(M);\n vector> histW(M);\n\n const int FIT_ITERS = 5;\n const double LR = 0.05;\n const double SKILL_MAX = 100.0;\n\n // Fitting function for one worker (small batch GD over its history)\n auto fitWorker = [&](int j) {\n auto &s = skill[j];\n auto &ht = histTasks[j];\n auto &hw = histW[j];\n int S = (int)ht.size();\n if (S == 0) return;\n for (int it = 0; it < FIT_ITERS; ++it) {\n for (int idx = 0; idx < S; ++idx) {\n int ti = ht[idx];\n double w_obs = hw[idx];\n\n // Compute w_pred = sum_k max(0, d[ti][k] - s[k])\n const auto &dv = d[ti];\n double w_pred = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = (double)dv[k] - s[k];\n if (diff > 0.0) w_pred += diff;\n }\n\n double e = w_pred - w_obs;\n if (e == 0.0) continue;\n double step = LR * e;\n\n // Gradient: for dims where d > s, s[k] += step\n for (int k = 0; k < K; ++k) {\n if ((double)dv[k] > s[k]) {\n s[k] += step;\n if (s[k] < 0.0) s[k] = 0.0;\n if (s[k] > SKILL_MAX) s[k] = SKILL_MAX;\n }\n }\n }\n }\n };\n\n int day = 0;\n const int MAX_CAND = 400; // number of candidate tasks per day to consider\n\n while (true) {\n day++;\n\n // Compute available tasks (not started and all prerequisites done)\n vector available;\n if (tasksDone < N) {\n available.reserve(N);\n for (int i = 0; i < N; ++i) {\n if (state[i] == NOT_STARTED && degRem[i] == 0) {\n available.push_back(i);\n }\n }\n }\n\n // Collect free workers\n vector freeWorkers;\n freeWorkers.reserve(M);\n for (int j = 0; j < M; ++j) {\n if (curTask[j] == -1) freeWorkers.push_back(j);\n }\n\n vector> assigns; // (worker, task)\n\n if (!freeWorkers.empty() && !available.empty()) {\n // Sort available tasks by priority: depth desc, diffL1 desc, id asc\n auto cmpTask = [&](int x, int y) {\n if (depth[x] != depth[y]) return depth[x] > depth[y];\n if (diffL1[x] != diffL1[y]) return diffL1[x] > diffL1[y];\n return x < y;\n };\n\n int sz = (int)available.size();\n if (sz > MAX_CAND) {\n int limit = MAX_CAND;\n partial_sort(available.begin(), available.begin() + limit,\n available.end(), cmpTask);\n available.resize(limit);\n sz = limit;\n } else {\n sort(available.begin(), available.end(), cmpTask);\n }\n\n // Build all (worker, task) options with predicted cost = t_pred\n struct Option {\n double cost;\n int w;\n int task;\n };\n vector

> pq;\n pq.emplace(0.0, s);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist_arr[u]) continue;\n if (u == t) break;\n for (auto &pe : adj[u]) {\n int v = pe.first;\n int eid = pe.second;\n double nd = d + eff_w[eid];\n if (nd < dist_arr[v]) {\n dist_arr[v] = nd;\n prev_v_arr[v] = u;\n prev_e_arr[v] = eid;\n pq.emplace(nd, v);\n }\n }\n }\n\n // Reconstruct path\n string rev;\n int v = t;\n while (v != s) {\n int u = prev_v_arr[v];\n if (u == -1) {\n // Fallback: Manhattan path if something goes wrong\n rev.clear();\n int ci = si, cj = sj;\n while (ci < ti) { rev.push_back('D'); ++ci; }\n while (ci > ti) { rev.push_back('U'); --ci; }\n while (cj < tj) { rev.push_back('R'); ++cj; }\n while (cj > tj) { rev.push_back('L'); --cj; }\n break;\n }\n int ui = u / W, uj = u % W;\n int vi = v / W, vj = v % W;\n if (vi == ui) {\n if (vj == uj + 1) rev.push_back('R');\n else if (vj == uj - 1) rev.push_back('L');\n } else if (vj == uj) {\n if (vi == ui + 1) rev.push_back('D');\n else if (vi == ui - 1) rev.push_back('U');\n }\n v = u;\n }\n reverse(rev.begin(), rev.end());\n return rev;\n}\n\n// Convert move string into list of edge IDs\nvoid path_to_edges(int si, int sj, const string &path, vector &edges) {\n edges.clear();\n edges.reserve(path.size());\n int i = si, j = sj;\n for (char c : path) {\n int eid = -1;\n if (c == 'U') {\n int ni = i - 1;\n eid = v_id[ni][j]; // edge between (ni,j) and (ni+1,j)\n i = ni;\n } else if (c == 'D') {\n eid = v_id[i][j]; // edge between (i,j) and (i+1,j)\n i = i + 1;\n } else if (c == 'L') {\n int nj = j - 1;\n eid = h_id[i][nj]; // edge between (i,nj) and (i,nj+1)\n j = nj;\n } else if (c == 'R') {\n eid = h_id[i][j]; // edge between (i,j) and (i,j+1)\n j = j + 1;\n }\n edges.push_back(eid);\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Build graph and edge indexing\n int eid = 0;\n // Horizontal edges\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W - 1; ++j) {\n h_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i, j + 1);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n // Vertical edges\n for (int i = 0; i < H - 1; ++i) {\n for (int j = 0; j < W; ++j) {\n v_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i + 1, j);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n\n // Initialize weights\n w.assign(E, 5000.0);\n eff_w.assign(E, 5000.0);\n\n vector edges;\n const double ETA = 0.5; // learning rate multiplier\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; // EOF / error\n }\n\n // Compute path\n string path = dijkstra_path(si, sj, ti, tj, q);\n\n // Output and flush\n cout << path << '\\n';\n cout.flush();\n\n long long y_ll;\n if (!(cin >> y_ll)) {\n return 0; // EOF / error\n }\n double y = (double)y_ll;\n\n // Update weights based on feedback\n path_to_edges(si, sj, path, edges);\n int L = (int)edges.size();\n if (L == 0) continue; // shouldn't happen (distance >= 10)\n\n double pred = 0.0;\n for (int e : edges) {\n pred += w[e];\n }\n double error = y - pred;\n\n double lr = ETA / (double)L;\n for (int e : edges) {\n w[e] += lr * error;\n if (w[e] < 1000.0) w[e] = 1000.0;\n else if (w[e] > 9000.0) w[e] = 9000.0;\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int MAX_N = 20;\nstatic const int MAX_M = 800;\nstatic const int ALPHA = 8;\nstatic const int MAXW = (MAX_M + 63) / 64;\n\nint N, M;\nint WORDS; // actual number of 64-bit words used\nvector patterns;\n\n// bitset over up to MAX_M bits\nstruct BS {\n uint64_t w[MAXW];\n};\n\n// bitset helpers\ninline void bs_clear(BS &b) {\n // clear all words; cost is tiny (<= 13 words)\n memset(b.w, 0, sizeof(b.w));\n}\ninline void bs_or_inplace(BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) a.w[i] |= b.w[i];\n}\ninline void bs_xor(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] ^ b.w[i];\n}\ninline void bs_or(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] | b.w[i];\n}\ninline bool bs_test(const BS &b, int idx) {\n return (b.w[idx >> 6] >> (idx & 63)) & 1ULL;\n}\ninline void bs_set(BS &b, int idx) {\n b.w[idx >> 6] |= 1ULL << (idx & 63);\n}\ninline void bs_reset(BS &b, int idx) {\n b.w[idx >> 6] &= ~(1ULL << (idx & 63));\n}\n\n// iterate over set bits of b, calling f(idx) for each\ntemplate \ninline void bs_for_each(const BS &b, F f) {\n for (int w = 0; w < WORDS; ++w) {\n uint64_t x = b.w[w];\n while (x) {\n int lsb = __builtin_ctzll(x);\n int idx = (w << 6) + lsb;\n if (idx >= M) return; // safety; bits >=M are never set\n f(idx);\n x &= x - 1; // clear lowest set bit\n }\n }\n}\n\n// Aho\u2013Corasick automaton\nstruct Node {\n int next[ALPHA];\n int link;\n BS out; // bitset of patterns that end at this state (including via failure)\n Node() {\n fill(next, next + ALPHA, -1);\n link = 0;\n bs_clear(out);\n }\n};\nvector ac;\n\n// grid\nchar grid[MAX_N][MAX_N];\n\n// row/col pattern presence\nBS row_bs[MAX_N], col_bs[MAX_N];\n\n// pattern coverage count across all rows+cols\nint pattern_cov_count[MAX_M];\nint current_c = 0;\n\n// RNG\nmt19937_64 rng;\n\ninline int ch_idx(char c) {\n return c - 'A'; // 'A'..'H' -> 0..7\n}\n\nvoid build_automaton() {\n ac.clear();\n ac.emplace_back(); // root\n\n // build trie and set pattern bits\n for (int i = 0; i < M; ++i) {\n const string &s = patterns[i];\n int v = 0;\n for (char ch : s) {\n int c = ch_idx(ch);\n if (ac[v].next[c] == -1) {\n ac[v].next[c] = (int)ac.size();\n ac.emplace_back();\n }\n v = ac[v].next[c];\n }\n bs_set(ac[v].out, i);\n }\n\n // build failure links\n queue q;\n\n // initialize root transitions\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[0].next[c];\n if (u != -1) {\n ac[u].link = 0;\n q.push(u);\n } else {\n ac[0].next[c] = 0;\n }\n }\n\n while (!q.empty()) {\n int v = q.front(); q.pop();\n int link = ac[v].link;\n\n // propagate pattern bits from failure link\n bs_or_inplace(ac[v].out, ac[link].out);\n\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[v].next[c];\n if (u != -1) {\n ac[u].link = ac[link].next[c];\n q.push(u);\n } else {\n ac[v].next[c] = ac[link].next[c];\n }\n }\n }\n}\n\n// scan a line through AC, return bitset of patterns appearing\ninline BS scan_line(const char *s, int len) {\n BS res;\n bs_clear(res);\n int v = 0;\n for (int i = 0; i < len; ++i) {\n int c = ch_idx(s[i]);\n v = ac[v].next[c];\n bs_or_inplace(res, ac[v].out);\n }\n return res;\n}\n\n// recompute one row r and update global counts\nvoid recalc_row(int r) {\n char line[2 * MAX_N];\n for (int j = 0; j < N; ++j) line[j] = grid[r][j];\n for (int j = 0; j < N; ++j) line[N + j] = line[j];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, row_bs[r], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(row_bs[r], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return; // should not happen but safe\n\n if (newFlag) {\n bs_set(row_bs[r], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(row_bs[r], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// recompute one column c and update global counts\nvoid recalc_col(int c) {\n char line[2 * MAX_N];\n for (int i = 0; i < N; ++i) line[i] = grid[i][c];\n for (int i = 0; i < N; ++i) line[N + i] = line[i];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, col_bs[c], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(col_bs[c], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return; // should not happen but safe\n\n if (newFlag) {\n bs_set(col_bs[c], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(col_bs[c], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// pattern \"kick\" move: force-place a random pattern somewhere\nvoid apply_pattern_kick() {\n uniform_int_distribution pat_dist(0, M - 1);\n int pid = pat_dist(rng);\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n uniform_int_distribution dir_dist(0, 1);\n int dir = dir_dist(rng); // 0: horizontal, 1: vertical\n\n bool rowChanged[MAX_N] = {false};\n bool colChanged[MAX_N] = {false};\n\n if (dir == 0) {\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n int r = row_dist(rng);\n int c0 = col_dist(rng);\n\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n c++;\n if (c == N) c = 0;\n }\n } else {\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n int r0 = row_dist(rng);\n int c = col_dist(rng);\n\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n r++;\n if (r == N) r = 0;\n }\n }\n\n for (int r = 0; r < N; ++r) if (rowChanged[r]) recalc_row(r);\n for (int c = 0; c < N; ++c) if (colChanged[c]) recalc_col(c);\n}\n\ndouble my_rand_double() {\n // 53-bit mantissa random double in [0,1)\n return (rng() >> 11) * (1.0 / (1ULL << 53));\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M;\n patterns.resize(M);\n for (int i = 0; i < M; ++i) cin >> patterns[i];\n\n WORDS = (M + 63) / 64;\n\n // init RNG\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n build_automaton();\n\n uniform_int_distribution letter_dist(0, ALPHA - 1);\n\n // initial grid: random letters\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n grid[i][j] = char('A' + letter_dist(rng));\n\n // constructive pass: greedily place patterns to align with existing letters\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n\n for (int idx = 0; idx < M; ++idx) {\n int pid = order[idx];\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0;\n int bestR = 0;\n int bestC = 0;\n\n // horizontal candidates\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n\n // vertical candidates\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n r++;\n if (r == N) r = 0;\n }\n }\n }\n\n // Initialize evaluation\n for (int r = 0; r < N; ++r) bs_clear(row_bs[r]);\n for (int c = 0; c < N; ++c) bs_clear(col_bs[c]);\n fill(pattern_cov_count, pattern_cov_count + M, 0);\n current_c = 0;\n\n for (int r = 0; r < N; ++r) recalc_row(r);\n for (int c = 0; c < N; ++c) recalc_col(c);\n\n // SA parameters\n const double TIME_LIMIT = 2.75; // seconds for SA part\n auto start_time = chrono::high_resolution_clock::now();\n double T0 = 1.5;\n double T1 = 0.05;\n\n // keep best grid\n char best_grid[MAX_N][MAX_N];\n int best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n\n int iter = 0;\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n\n while (true) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n double progress = elapsed / TIME_LIMIT;\n double T = T0 + (T1 - T0) * progress;\n\n // occasional pattern kick in early phase\n if ((iter % 2000 == 0) && (progress < 0.5)) {\n apply_pattern_kick();\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n int r = row_dist(rng);\n int c = col_dist(rng);\n char oldCh = grid[r][c];\n\n char newCh;\n do {\n newCh = char('A' + letter_dist(rng));\n } while (newCh == oldCh);\n\n // candidate row\n char row_line[2 * MAX_N];\n for (int j = 0; j < N; ++j)\n row_line[j] = (j == c) ? newCh : grid[r][j];\n for (int j = 0; j < N; ++j)\n row_line[N + j] = row_line[j];\n\n BS mark_row = scan_line(row_line, 2 * N);\n\n // candidate column\n char col_line[2 * MAX_N];\n for (int i = 0; i < N; ++i)\n col_line[i] = (i == r) ? newCh : grid[i][c];\n for (int i = 0; i < N; ++i)\n col_line[N + i] = col_line[i];\n\n BS mark_col = scan_line(col_line, 2 * N);\n\n // changed patterns on row and column\n BS changed_row, changed_col, changed_union;\n bs_xor(changed_row, row_bs[r], mark_row);\n bs_xor(changed_col, col_bs[c], mark_col);\n bs_or(changed_union, changed_row, changed_col);\n\n int new_c = current_c;\n\n // compute new_c considering only changed patterns\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n if (oldCov == 0 && newCov > 0) new_c++;\n else if (oldCov > 0 && newCov == 0) new_c--;\n });\n\n int delta = new_c - current_c;\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (prob > my_rand_double()) accept = true;\n }\n\n if (accept) {\n // commit the change\n grid[r][c] = newCh;\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n pattern_cov_count[i] = newCov;\n\n if (newRow) bs_set(row_bs[r], i);\n else bs_reset(row_bs[r], i);\n if (newCol) bs_set(col_bs[c], i);\n else bs_reset(col_bs[c], i);\n });\n current_c = new_c;\n\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n ++iter;\n }\n\n // Output best grid\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 << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n int w;\n};\n\nconst int INF = 1e9;\n\n// Compute travel time of a route (sequence of cell IDs).\n// Cost to move into cell v is cost[v].\nlong long computeTravelTime(const vector &route, const vector &cost) {\n long long t = 0;\n for (int i = 1; i < (int)route.size(); ++i) {\n t += cost[route[i]];\n }\n return t;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector grid(N);\n for (int i = 0; i < N; ++i) cin >> grid[i];\n\n // Map each road cell to an ID\n static int idOf[70][70];\n int r = 0;\n vector> pos; // id -> (i,j)\n vector cost; // id -> cell cost (5-9)\n pos.reserve(N * N);\n cost.reserve(N * N);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n idOf[i][j] = r++;\n pos.emplace_back(i, j);\n cost.push_back(grid[i][j] - '0');\n } else {\n idOf[i][j] = -1;\n }\n }\n }\n\n if (r == 0) {\n cout << \"\\n\";\n return 0;\n }\n\n int startId = idOf[si][sj];\n\n // Build graph of road cells\n vector> G(r);\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N && idOf[ni][nj] != -1) {\n int v = idOf[ni][nj];\n G[id].push_back({v, cost[v]});\n }\n }\n }\n\n // ---------- Fallback DFS route (visit all cells) ----------\n auto buildDFSRoute = [&]() -> vector {\n vector route;\n route.reserve(2 * r + 5);\n vector used(r, 0);\n vector st;\n vector edgeIdx(r, 0);\n\n route.push_back(startId);\n used[startId] = 1;\n st.push_back(startId);\n\n while (!st.empty()) {\n int u = st.back();\n bool advanced = false;\n int &ei = edgeIdx[u];\n while (ei < (int)G[u].size()) {\n int v = G[u][ei].to;\n ++ei;\n if (!used[v]) {\n used[v] = 1;\n st.push_back(v);\n route.push_back(v);\n advanced = true;\n break;\n }\n }\n if (!advanced) {\n st.pop_back();\n if (!st.empty()) {\n route.push_back(st.back());\n }\n }\n }\n return route; // starts and ends at startId\n };\n\n vector fallbackRoute = buildDFSRoute();\n long long fallbackTime = computeTravelTime(fallbackRoute, cost);\n\n // ---------- Build horizontal and vertical segments ----------\n vector> rowSegCells;\n vector rowSegIdOfCell(r, -1);\n for (int i = 0; i < N; ++i) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') {\n ++j;\n continue;\n }\n int segIdx = (int)rowSegCells.size();\n rowSegCells.emplace_back();\n while (j < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n rowSegIdOfCell[id] = segIdx;\n rowSegCells.back().push_back(id);\n ++j;\n }\n }\n }\n\n vector> colSegCells;\n vector colSegIdOfCell(r, -1);\n for (int j = 0; j < N; ++j) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') {\n ++i;\n continue;\n }\n int segIdx = (int)colSegCells.size();\n colSegCells.emplace_back();\n while (i < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n colSegIdOfCell[id] = segIdx;\n colSegCells.back().push_back(id);\n ++i;\n }\n }\n }\n\n // ---------- Precompute visibility (coverage) for all cells ----------\n vector> coverageAll(r);\n for (int id = 0; id < r; ++id) {\n auto &v = coverageAll[id];\n auto &rowV = rowSegCells[rowSegIdOfCell[id]];\n auto &colV = colSegCells[colSegIdOfCell[id]];\n v.reserve(rowV.size() + colV.size());\n for (int x : rowV) v.push_back(x);\n for (int x : colV) v.push_back(x);\n }\n\n // ---------- Build candidate vantage cells (mostly intersections) ----------\n vector isIntersection(r, 0);\n vector hasInterRow(rowSegCells.size(), 0);\n vector hasInterCol(colSegCells.size(), 0);\n\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n bool hor = false, ver = false;\n if (j > 0 && idOf[i][j-1] != -1) hor = true;\n if (j+1 < N && idOf[i][j+1] != -1) hor = true;\n if (i > 0 && idOf[i-1][j] != -1) ver = true;\n if (i+1 < N && idOf[i+1][j] != -1) ver = true;\n if (hor && ver) {\n isIntersection[id] = 1;\n hasInterRow[rowSegIdOfCell[id]] = 1;\n hasInterCol[colSegIdOfCell[id]] = 1;\n }\n }\n\n vector isCandidate(r, 0);\n vector candidateCells;\n candidateCells.reserve(r);\n\n // Intersections\n for (int id = 0; id < r; ++id) {\n if (isIntersection[id]) {\n isCandidate[id] = 1;\n candidateCells.push_back(id);\n }\n }\n // Midpoints of segments without intersections\n for (int s = 0; s < (int)rowSegCells.size(); ++s) {\n if (!hasInterRow[s]) {\n int mid = rowSegCells[s][rowSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n for (int s = 0; s < (int)colSegCells.size(); ++s) {\n if (!hasInterCol[s]) {\n int mid = colSegCells[s][colSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n // Ensure start cell is candidate\n if (!isCandidate[startId]) {\n isCandidate[startId] = 1;\n candidateCells.push_back(startId);\n }\n\n // Coverage of candidates, and which cells are coverable by some candidate\n int C = (int)candidateCells.size();\n vector> candCover;\n candCover.reserve(C);\n vector cellCovered(r, 0);\n for (int idx = 0; idx < C; ++idx) {\n int cell = candidateCells[idx];\n candCover.push_back(coverageAll[cell]);\n for (int x : candCover.back()) cellCovered[x] = 1;\n }\n\n // Patch: if some cell is not covered by any candidate, add it itself as candidate\n for (int id = 0; id < r; ++id) {\n if (!cellCovered[id]) {\n candidateCells.push_back(id);\n candCover.push_back(coverageAll[id]);\n for (int x : coverageAll[id]) cellCovered[x] = 1;\n }\n }\n C = (int)candidateCells.size();\n\n // ---------- Greedy set cover on candidates (cell-based) ----------\n vector vantageCells; // resulting vantage cell IDs\n vantageCells.reserve(C);\n\n vector coveredCells(r, 0);\n int coveredCount = 0;\n vector candSelected(C, 0);\n\n auto selectCandidate = [&](int idx) {\n if (candSelected[idx]) return;\n candSelected[idx] = 1;\n int cell = candidateCells[idx];\n vantageCells.push_back(cell);\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n };\n\n // Use start cell as the first vantage\n int startCandIdx = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candidateCells[idx] == startId) {\n startCandIdx = idx;\n break;\n }\n }\n if (startCandIdx == -1) {\n // Safeguard (shouldn't happen)\n vantageCells.push_back(startId);\n for (int x : coverageAll[startId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(startCandIdx);\n }\n\n while (coveredCount < r) {\n int bestIdx = -1;\n int bestGain = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candSelected[idx]) continue;\n int gain = 0;\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) ++gain;\n }\n if (gain > bestGain) {\n bestGain = gain;\n bestIdx = idx;\n } else if (gain == bestGain && gain > 0 && bestIdx != -1) {\n // Tie-break: closer to start (Manhattan)\n int cellNew = candidateCells[idx];\n int cellBest = candidateCells[bestIdx];\n auto [ni, nj] = pos[cellNew];\n auto [bi, bj] = pos[cellBest];\n int manNew = abs(ni - si) + abs(nj - sj);\n int manBest = abs(bi - si) + abs(bj - sj);\n if (manNew < manBest) bestIdx = idx;\n }\n }\n\n if (bestIdx == -1 || bestGain <= 0) {\n // Safeguard: directly add some uncovered cell as vantage\n int uncoveredId = -1;\n for (int id = 0; id < r; ++id) {\n if (!coveredCells[id]) {\n uncoveredId = id;\n break;\n }\n }\n if (uncoveredId == -1) break; // should not happen\n vantageCells.push_back(uncoveredId);\n for (int x : coverageAll[uncoveredId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(bestIdx);\n }\n }\n\n // Deduplicate vantages (just in case)\n sort(vantageCells.begin(), vantageCells.end());\n vantageCells.erase(unique(vantageCells.begin(), vantageCells.end()), vantageCells.end());\n\n // ---------- Eliminate redundant vantages using coverage frequencies ----------\n {\n int V = (int)vantageCells.size();\n if (V > 0) {\n vector freq(r, 0);\n\n // Base coverage from starting cell (we always start there)\n for (int c : coverageAll[startId]) freq[c]++;\n\n // Add contributions from all vantages\n for (int v : vantageCells) {\n for (int c : coverageAll[v]) freq[c]++;\n }\n\n // Process vantages in ascending order of coverage size (remove small ones first)\n vector order(V);\n iota(order.begin(), order.end(), 0);\n sort(order.begin(), order.end(), [&](int a, int b) {\n return coverageAll[vantageCells[a]].size() < coverageAll[vantageCells[b]].size();\n });\n\n vector removed(V, 0);\n for (int idx : order) {\n int v = vantageCells[idx];\n bool canRemove = true;\n for (int c : coverageAll[v]) {\n if (freq[c] <= 1) { // would leave some cell uncovered\n canRemove = false;\n break;\n }\n }\n if (!canRemove) continue;\n // Remove this vantage\n removed[idx] = 1;\n for (int c : coverageAll[v]) {\n --freq[c];\n }\n }\n\n vector reduced;\n reduced.reserve(V);\n for (int i = 0; i < V; ++i) {\n if (!removed[i]) reduced.push_back(vantageCells[i]);\n }\n vantageCells.swap(reduced);\n }\n }\n\n // ---------- Dijkstra helpers ----------\n vector dist(r), prevv(r);\n\n auto dijkstraToDest = [&](int src, int dest) {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (u == dest) break;\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n };\n\n auto appendPath = [&](vector &route, int src, int dest) {\n if (src == dest) return;\n dijkstraToDest(src, dest);\n vector tmp;\n int x = dest;\n while (x != src && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n route.push_back(tmp[i]);\n }\n };\n\n auto dijkstraNearestTarget = [&](int src,\n const vector &isTarget,\n const vector &visitedTarget) -> int {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n int target = -1;\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (isTarget[u] && !visitedTarget[u]) {\n target = u;\n break;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n return target;\n };\n\n // ---------- Route 1: Greedy nearest neighbor on vantages ----------\n auto buildRouteGreedyNN = [&](const vector &vantages) -> vector {\n vector route;\n route.reserve(2 * r + 5);\n\n vector isTarget(r, 0), visitedTarget(r, 0);\n for (int id : vantages) isTarget[id] = 1;\n\n int remainingTargets = 0;\n for (int id : vantages) {\n if (id == startId) {\n visitedTarget[id] = 1;\n } else {\n ++remainingTargets;\n }\n }\n\n route.push_back(startId);\n int curr = startId;\n\n while (remainingTargets > 0) {\n int target = dijkstraNearestTarget(curr, isTarget, visitedTarget);\n if (target == -1) break; // should not happen (connected component)\n\n // Reconstruct path curr -> target using prevv from dijkstraNearestTarget\n vector tmp;\n int x = target;\n while (x != curr && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n int node = tmp[i];\n route.push_back(node);\n if (isTarget[node] && !visitedTarget[node]) {\n visitedTarget[node] = 1;\n --remainingTargets;\n }\n }\n curr = target;\n }\n\n // Return to start\n if (curr != startId) {\n appendPath(route, curr, startId);\n }\n return route;\n };\n\n vector routeNN = buildRouteGreedyNN(vantageCells);\n long long timeNN = computeTravelTime(routeNN, cost);\n\n // ---------- Route 2: TSP over vantages ----------\n vector routeTSP;\n long long timeTSP = (1LL << 60);\n\n if (!vantageCells.empty()) {\n // Build node list: start + all vantages (without duplicating start)\n vector nodes;\n nodes.reserve(vantageCells.size() + 1);\n nodes.push_back(startId);\n for (int v : vantageCells) {\n if (v != startId) nodes.push_back(v);\n }\n int K = (int)nodes.size();\n\n // Distance matrix between nodes (either true shortest-path or Manhattan)\n vector> distNode(K, vector(K, 0));\n const int MAX_TSP_REAL_DIST_NODES = 600;\n bool useRealDist = (K <= MAX_TSP_REAL_DIST_NODES);\n\n if (useRealDist) {\n // Map cell id -> node index\n vector nodeIndex(r, -1);\n for (int i = 0; i < K; ++i) nodeIndex[nodes[i]] = i;\n\n // Dijkstra from each node to compute distances to all others\n for (int i = 0; i < K; ++i) {\n int src = nodes[i];\n fill(dist.begin(), dist.end(), INF);\n dist[src] = 0;\n priority_queue, vector>, greater>> pq;\n pq.push({0, src});\n int remaining = K;\n while (!pq.empty() && remaining > 0) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n int idxU = nodeIndex[u];\n if (idxU != -1) {\n distNode[i][idxU] = d;\n --remaining;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n pq.push({nd, v});\n }\n }\n }\n }\n } else {\n // Approximate distances by Manhattan\n for (int i = 0; i < K; ++i) {\n auto [xi, yi] = pos[nodes[i]];\n for (int j = i + 1; j < K; ++j) {\n auto [xj, yj] = pos[nodes[j]];\n int d = abs(xi - xj) + abs(yi - yj);\n distNode[i][j] = distNode[j][i] = d;\n }\n }\n }\n\n if (K >= 2) {\n // Initial route: nearest neighbor on distNode\n vector order(K);\n vector used(K, 0);\n order[0] = 0;\n used[0] = 1;\n for (int t = 1; t < K; ++t) {\n int prevIdx = order[t - 1];\n int best = -1;\n int bestD = INT_MAX;\n for (int j = 0; j < K; ++j) {\n if (used[j]) continue;\n int d = distNode[prevIdx][j];\n if (d < bestD) {\n bestD = d;\n best = j;\n }\n }\n if (best == -1) best = 0; // safety\n order[t] = best;\n used[best] = 1;\n }\n\n // 2-opt improvement\n bool improved = true;\n while (improved) {\n improved = false;\n for (int i = 1; i < K - 1 && !improved; ++i) {\n int a = order[i - 1];\n int b = order[i];\n for (int j = i + 1; j < K; ++j) {\n int c = order[j];\n int d = (j + 1 < K ? order[j + 1] : order[0]);\n int curCost = distNode[a][b] + distNode[c][d];\n int newCost = distNode[a][c] + distNode[b][d];\n if (newCost < curCost) {\n reverse(order.begin() + i, order.begin() + j + 1);\n improved = true;\n break;\n }\n }\n }\n }\n\n // Or-opt improvement (move one vertex) for moderate sizes\n if (K <= 400) {\n int maxIter = 4;\n for (int iter = 0; iter < maxIter; ++iter) {\n bool anyImproved = false;\n for (int i = 1; i < K; ++i) {\n int prev = order[i - 1];\n int cur = order[i];\n int next = (i == K - 1 ? order[0] : order[i + 1]);\n for (int j = 0; j < K; ++j) {\n if (j == i || j == i - 1) continue;\n int a = order[j];\n int b = (j == K - 1 ? order[0] : order[j + 1]);\n if (a == cur || b == cur) continue;\n\n int delta = 0;\n // Remove cur from between prev and next\n delta -= distNode[prev][cur] + distNode[cur][next] - distNode[prev][next];\n // Insert cur between a and b\n delta += distNode[a][cur] + distNode[cur][b] - distNode[a][b];\n\n if (delta < 0) {\n int node = cur;\n if (j < i) {\n // remove at i\n for (int k = i; k < K - 1; ++k) order[k] = order[k + 1];\n // insert after j (position j+1)\n for (int k = K - 1; k > j + 1; --k) order[k] = order[k - 1];\n order[j + 1] = node;\n } else { // j > i\n // remove at i\n for (int k = i; k < K - 1; ++k) order[k] = order[k + 1];\n // after removal, original index j becomes j-1\n int newJ = j - 1;\n for (int k = K - 1; k > newJ + 1; --k) order[k] = order[k - 1];\n order[newJ + 1] = node;\n }\n anyImproved = true;\n goto NEXT_OR_ITER;\n }\n }\n }\n NEXT_OR_ITER:\n if (!anyImproved) break;\n }\n\n // Final small 2-opt pass\n improved = true;\n while (improved) {\n improved = false;\n for (int i = 1; i < K - 1 && !improved; ++i) {\n int a = order[i - 1];\n int b = order[i];\n for (int j = i + 1; j < K; ++j) {\n int c = order[j];\n int d = (j + 1 < K ? order[j + 1] : order[0]);\n int curCost = distNode[a][b] + distNode[c][d];\n int newCost = distNode[a][c] + distNode[b][d];\n if (newCost < curCost) {\n reverse(order.begin() + i, order.begin() + j + 1);\n improved = true;\n break;\n }\n }\n }\n }\n }\n\n // Build actual route following this order (0..K-1), starting at startId\n routeTSP.reserve(2 * r + 5);\n routeTSP.push_back(startId);\n int curr = startId;\n for (int idxPos = 1; idxPos < K; ++idxPos) {\n int nodeIdx = order[idxPos];\n int dest = nodes[nodeIdx];\n if (dest == curr) continue;\n appendPath(routeTSP, curr, dest);\n curr = dest;\n }\n if (curr != startId) {\n appendPath(routeTSP, curr, startId);\n }\n timeTSP = computeTravelTime(routeTSP, cost);\n }\n }\n\n // ---------- Choose the best route among: DFS fallback, NN, TSP ----------\n vector bestRoute = fallbackRoute;\n long long bestTime = fallbackTime;\n\n if (!routeNN.empty() && timeNN < bestTime) {\n bestTime = timeNN;\n bestRoute = std::move(routeNN);\n }\n if (!routeTSP.empty() && timeTSP < bestTime) {\n bestTime = timeTSP;\n bestRoute = std::move(routeTSP);\n }\n\n // If route has no movement, add a tiny loop to avoid t=0\n if ((int)bestRoute.size() == 1) {\n int u = startId;\n int v = -1;\n for (auto &e : G[u]) {\n v = e.to;\n break;\n }\n if (v != -1) {\n bestRoute.push_back(v);\n bestRoute.push_back(u);\n }\n }\n\n // ---------- Convert node sequence to direction string ----------\n string ans;\n ans.reserve(bestRoute.size());\n for (int i = 1; i < (int)bestRoute.size(); ++i) {\n auto [i1, j1] = pos[bestRoute[i-1]];\n auto [i2, j2] = pos[bestRoute[i]];\n if (i2 == i1 - 1 && j2 == j1) ans.push_back('U');\n else if (i2 == i1 + 1 && j2 == j1) ans.push_back('D');\n else if (j2 == j1 - 1 && i2 == i1) ans.push_back('L');\n else if (j2 == j1 + 1 && i2 == i1) ans.push_back('R');\n else {\n // Should not happen with valid shortest paths\n }\n }\n\n cout << ans << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n // Task requirements d[i][k]\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) cin >> d[i][k];\n }\n\n // Dependencies: u -> v\n vector> out(N);\n vector indeg(N, 0);\n for (int e = 0; e < R; ++e) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg[v]++;\n }\n\n // Precompute depth-from-end (longest path length to any sink)\n vector depth(N, 0);\n for (int i = N - 1; i >= 0; --i) {\n int best = 0;\n for (int v : out[i]) {\n best = max(best, depth[v] + 1);\n }\n depth[i] = best;\n }\n\n // Precompute simple difficulty measure (L1 norm)\n vector diffL1(N, 0);\n for (int i = 0; i < N; ++i) {\n int s = 0;\n for (int k = 0; k < K; ++k) s += d[i][k];\n diffL1[i] = s;\n }\n\n // Task states\n const int NOT_STARTED = 0;\n const int IN_PROGRESS = 1;\n const int DONE = 2;\n vector state(N, NOT_STARTED);\n vector degRem = indeg;\n int tasksDone = 0;\n\n // Worker states\n vector curTask(M, -1);\n vector startDay(M, -1);\n\n // Worker skill vectors s_j[k]\n vector> skill(M, vector(K, 0.0));\n // History of (task, w_obs) per worker for fitting\n vector> histTasks(M);\n vector> histW(M);\n\n const int FIT_ITERS = 5;\n const double LR = 0.05;\n const double SKILL_MAX = 100.0;\n\n // Fitting function for one worker (small batch GD over its history)\n auto fitWorker = [&](int j) {\n auto &s = skill[j];\n auto &ht = histTasks[j];\n auto &hw = histW[j];\n int S = (int)ht.size();\n if (S == 0) return;\n for (int it = 0; it < FIT_ITERS; ++it) {\n for (int idx = 0; idx < S; ++idx) {\n int ti = ht[idx];\n double w_obs = hw[idx];\n\n // Compute w_pred = sum_k max(0, d[ti][k] - s[k])\n const auto &dv = d[ti];\n double w_pred = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = (double)dv[k] - s[k];\n if (diff > 0.0) w_pred += diff;\n }\n\n double e = w_pred - w_obs;\n if (e == 0.0) continue;\n double step = LR * e;\n\n // Gradient: for dims where d > s, s[k] += step\n for (int k = 0; k < K; ++k) {\n if ((double)dv[k] > s[k]) {\n s[k] += step;\n if (s[k] < 0.0) s[k] = 0.0;\n if (s[k] > SKILL_MAX) s[k] = SKILL_MAX;\n }\n }\n }\n }\n };\n\n int day = 0;\n const int MAX_CAND = 400; // number of candidate tasks per day to consider\n\n while (true) {\n day++;\n\n // Compute available tasks (not started and all prerequisites done)\n vector available;\n if (tasksDone < N) {\n available.reserve(N);\n for (int i = 0; i < N; ++i) {\n if (state[i] == NOT_STARTED && degRem[i] == 0) {\n available.push_back(i);\n }\n }\n }\n\n // Collect free workers\n vector freeWorkers;\n freeWorkers.reserve(M);\n for (int j = 0; j < M; ++j) {\n if (curTask[j] == -1) freeWorkers.push_back(j);\n }\n\n vector> assigns; // (worker, task)\n\n if (!freeWorkers.empty() && !available.empty()) {\n // Sort available tasks by priority: depth desc, diffL1 desc, id asc\n auto cmpTask = [&](int x, int y) {\n if (depth[x] != depth[y]) return depth[x] > depth[y];\n if (diffL1[x] != diffL1[y]) return diffL1[x] > diffL1[y];\n return x < y;\n };\n\n int sz = (int)available.size();\n if (sz > MAX_CAND) {\n int limit = MAX_CAND;\n partial_sort(available.begin(), available.begin() + limit,\n available.end(), cmpTask);\n available.resize(limit);\n sz = limit;\n } else {\n sort(available.begin(), available.end(), cmpTask);\n }\n\n // Build all (worker, task) options with predicted cost = t_pred\n struct Option {\n double cost;\n int w;\n int task;\n };\n vector

> pq;\n pq.emplace(0.0, s);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist_arr[u]) continue;\n if (u == t) break;\n for (auto &pe : adj[u]) {\n int v = pe.first;\n int eid = pe.second;\n double nd = d + eff_w[eid];\n if (nd < dist_arr[v]) {\n dist_arr[v] = nd;\n prev_v_arr[v] = u;\n pq.emplace(nd, v);\n }\n }\n }\n\n if (prev_v_arr[t] == -1) {\n // Fallback: Manhattan path (should not happen in connected grid)\n build_manhattan(si, sj, ti, tj, path, edges, pred_cost);\n return;\n }\n\n // Reconstruct vertex sequence from s to t\n vector vs_rev;\n vs_rev.reserve(64);\n int cur = t;\n while (cur != s) {\n vs_rev.push_back(cur);\n cur = prev_v_arr[cur];\n }\n vs_rev.push_back(s); // now vs_rev: [t, ..., s]\n\n vector vs;\n vs.reserve(vs_rev.size());\n for (int idx = (int)vs_rev.size() - 1; idx >= 0; --idx) {\n vs.push_back(vs_rev[idx]);\n }\n int L = (int)vs.size() - 1; // number of edges\n\n // Build move string and edges, and compute predicted cost under w\n path.clear();\n path.reserve(L);\n edges.clear();\n edges.reserve(L);\n pred_cost = 0.0;\n\n for (int k = 0; k < L; ++k) {\n int u = vs[k];\n int v = vs[k + 1];\n int ui = u / W, uj = u % W;\n int vi = v / W, vj = v % W;\n\n char c;\n int eid = -1;\n\n if (vi == ui) {\n if (vj == uj + 1) { // right\n c = 'R';\n eid = h_id[ui][uj];\n } else { // vj == uj - 1, left\n c = 'L';\n eid = h_id[ui][vj];\n }\n } else { // vj == uj\n if (vi == ui + 1) { // down\n c = 'D';\n eid = v_id[ui][uj];\n } else { // vi == ui - 1, up\n c = 'U';\n eid = v_id[vi][uj];\n }\n }\n\n path.push_back(c);\n edges.push_back(eid);\n pred_cost += w[eid];\n }\n}\n\n// Convert move string into edge list (used only for fallback if needed elsewhere)\nvoid path_to_edges(int si, int sj, const string &path, vector &edges) {\n edges.clear();\n edges.reserve(path.size());\n int i = si, j = sj;\n for (char c : path) {\n int eid = -1;\n if (c == 'U') {\n int ni = i - 1;\n eid = v_id[ni][j];\n i = ni;\n } else if (c == 'D') {\n eid = v_id[i][j];\n i = i + 1;\n } else if (c == 'L') {\n int nj = j - 1;\n eid = h_id[i][nj];\n j = nj;\n } else if (c == 'R') {\n eid = h_id[i][j];\n j = j + 1;\n }\n edges.push_back(eid);\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Build graph and edge indexing\n int eid = 0;\n // Horizontal edges\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W - 1; ++j) {\n h_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i, j + 1);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n // Vertical edges\n for (int i = 0; i < H - 1; ++i) {\n for (int j = 0; j < W; ++j) {\n v_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i + 1, j);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n\n // Initialize weights\n w.assign(E, 5000.0);\n eff_w.assign(E, 5000.0);\n\n const double ETA = 0.5; // learning rate multiplier\n\n vector best_edges, tmp_edges;\n string best_path, tmp_path;\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; // EOF / error\n }\n\n // Jitter amplitude for this query (same as baseline)\n const double JITTER0 = 0.03;\n double jitter = JITTER0 * max(0.0, 1.0 - (double)q / 800.0);\n if (jitter < 0.0) jitter = 0.0;\n\n int num_candidates = (jitter > 1e-12 ? 4 : 1);\n\n double best_cost = INF;\n best_path.clear();\n best_edges.clear();\n\n for (int it = 0; it < num_candidates; ++it) {\n double pred_cost = 0.0;\n build_candidate(si, sj, ti, tj, jitter, tmp_path, tmp_edges, pred_cost);\n if (pred_cost < best_cost) {\n best_cost = pred_cost;\n best_path = tmp_path;\n best_edges = tmp_edges;\n }\n }\n\n // Output chosen path\n cout << best_path << '\\n';\n cout.flush();\n\n long long y_ll;\n if (!(cin >> y_ll)) {\n return 0; // EOF / error\n }\n double y = (double)y_ll;\n\n int L = (int)best_edges.size();\n if (L == 0) continue; // should not happen (Manhattan distance >= 10)\n\n double pred = best_cost; // predicted cost under w for chosen path\n double error = y - pred;\n\n double lr = ETA / (double)L;\n for (int e : best_edges) {\n w[e] += lr * error;\n if (w[e] < 1000.0) w[e] = 1000.0;\n else if (w[e] > 9000.0) w[e] = 9000.0;\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int MAX_N = 20;\nstatic const int MAX_M = 800;\nstatic const int ALPHA = 8;\nstatic const int MAXW = (MAX_M + 63) / 64;\n\nint N, M;\nint WORDS; // number of 64-bit words used for bitsets\nvector patterns;\n\n// bitset over up to MAX_M bits\nstruct BS {\n uint64_t w[MAXW];\n};\n\n// bitset helpers\ninline void bs_clear(BS &b) {\n memset(b.w, 0, sizeof(b.w));\n}\ninline void bs_or_inplace(BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) a.w[i] |= b.w[i];\n}\ninline void bs_xor(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] ^ b.w[i];\n}\ninline void bs_or(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] | b.w[i];\n}\ninline bool bs_test(const BS &b, int idx) {\n return (b.w[idx >> 6] >> (idx & 63)) & 1ULL;\n}\ninline void bs_set(BS &b, int idx) {\n b.w[idx >> 6] |= 1ULL << (idx & 63);\n}\ninline void bs_reset(BS &b, int idx) {\n b.w[idx >> 6] &= ~(1ULL << (idx & 63));\n}\n\n// iterate over set bits of b, calling f(idx) for each\ntemplate \ninline void bs_for_each(const BS &b, F f) {\n for (int w = 0; w < WORDS; ++w) {\n uint64_t x = b.w[w];\n while (x) {\n int lsb = __builtin_ctzll(x);\n int idx = (w << 6) + lsb;\n if (idx >= M) return; // safety; bits >= M are not used\n f(idx);\n x &= x - 1; // clear lowest set bit\n }\n }\n}\n\n// Aho\u2013Corasick automaton\nstruct Node {\n int next[ALPHA];\n int link;\n BS out; // bitset of patterns that end at this state (including via failure)\n Node() {\n fill(next, next + ALPHA, -1);\n link = 0;\n bs_clear(out);\n }\n};\nvector ac;\n\n// grid and evaluation structures\nchar grid[MAX_N][MAX_N];\nBS row_bs[MAX_N], col_bs[MAX_N];\nint pattern_cov_count[MAX_M];\nint current_c = 0;\n\n// RNG\nmt19937_64 rng;\n\ninline int ch_idx(char c) {\n return c - 'A'; // 'A'..'H' -> 0..7\n}\n\nvoid build_automaton() {\n ac.clear();\n ac.emplace_back(); // root\n\n // build trie and set pattern bits\n for (int i = 0; i < M; ++i) {\n const string &s = patterns[i];\n int v = 0;\n for (char ch : s) {\n int c = ch_idx(ch);\n if (ac[v].next[c] == -1) {\n ac[v].next[c] = (int)ac.size();\n ac.emplace_back();\n }\n v = ac[v].next[c];\n }\n bs_set(ac[v].out, i);\n }\n\n // build failure links\n queue q;\n\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[0].next[c];\n if (u != -1) {\n ac[u].link = 0;\n q.push(u);\n } else {\n ac[0].next[c] = 0;\n }\n }\n\n while (!q.empty()) {\n int v = q.front(); q.pop();\n int link = ac[v].link;\n\n // propagate pattern bits from failure link\n bs_or_inplace(ac[v].out, ac[link].out);\n\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[v].next[c];\n if (u != -1) {\n ac[u].link = ac[link].next[c];\n q.push(u);\n } else {\n ac[v].next[c] = ac[link].next[c];\n }\n }\n }\n}\n\n// scan a line through AC, return bitset of patterns appearing\ninline BS scan_line(const char *s, int len) {\n BS res;\n bs_clear(res);\n int v = 0;\n for (int i = 0; i < len; ++i) {\n int c = ch_idx(s[i]);\n v = ac[v].next[c];\n bs_or_inplace(res, ac[v].out);\n }\n return res;\n}\n\n// recompute one row r and update global counts\nvoid recalc_row(int r) {\n char line[2 * MAX_N];\n for (int j = 0; j < N; ++j) line[j] = grid[r][j];\n for (int j = 0; j < N; ++j) line[N + j] = line[j];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, row_bs[r], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(row_bs[r], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return;\n\n if (newFlag) {\n bs_set(row_bs[r], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(row_bs[r], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// recompute one column c and update global counts\nvoid recalc_col(int c) {\n char line[2 * MAX_N];\n for (int i = 0; i < N; ++i) line[i] = grid[i][c];\n for (int i = 0; i < N; ++i) line[N + i] = line[i];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, col_bs[c], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(col_bs[c], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return;\n\n if (newFlag) {\n bs_set(col_bs[c], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(col_bs[c], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// targeted pattern \"kick\": choose a poorly-covered pattern and place it greedily\nvoid apply_pattern_kick() {\n if (M == 0) return;\n\n uniform_int_distribution base_dist(0, M - 1);\n int base = base_dist(rng);\n int pid = -1;\n\n // coverage == 0 preferred\n for (int j = 0; j < M; ++j) {\n int id = (base + j) % M;\n if (pattern_cov_count[id] == 0) {\n pid = id;\n break;\n }\n }\n // then coverage == 1\n if (pid == -1) {\n for (int j = 0; j < M; ++j) {\n int id = (base + j) % M;\n if (pattern_cov_count[id] == 1) {\n pid = id;\n break;\n }\n }\n }\n // fallback to random\n if (pid == -1) pid = base;\n\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0; // 0: horizontal, 1: vertical\n int bestR = 0, bestC = 0;\n\n // horizontal placements\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore && (rng() & 1)) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n\n // vertical placements\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore && (rng() & 1)) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n\n bool rowChanged[MAX_N] = {false};\n bool colChanged[MAX_N] = {false};\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n r++;\n if (r == N) r = 0;\n }\n }\n\n // recompute affected rows/columns\n for (int r = 0; r < N; ++r) if (rowChanged[r]) recalc_row(r);\n for (int c = 0; c < N; ++c) if (colChanged[c]) recalc_col(c);\n}\n\ndouble my_rand_double() {\n // 53-bit mantissa random double in [0,1)\n return (rng() >> 11) * (1.0 / (1ULL << 53));\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M;\n patterns.resize(M);\n for (int i = 0; i < M; ++i) cin >> patterns[i];\n\n WORDS = (M + 63) / 64;\n\n // init RNG\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n build_automaton();\n\n uniform_int_distribution letter_dist(0, ALPHA - 1);\n\n // initial grid: random letters\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n grid[i][j] = char('A' + letter_dist(rng));\n\n // constructive pass: random order of patterns, greedily align with existing letters\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n\n for (int idx = 0; idx < M; ++idx) {\n int pid = order[idx];\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0;\n int bestR = 0, bestC = 0;\n\n // horizontal candidates\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n\n // vertical candidates\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n r++;\n if (r == N) r = 0;\n }\n }\n }\n\n // Initialize evaluation\n for (int r = 0; r < N; ++r) bs_clear(row_bs[r]);\n for (int c = 0; c < N; ++c) bs_clear(col_bs[c]);\n fill(pattern_cov_count, pattern_cov_count + M, 0);\n current_c = 0;\n\n for (int r = 0; r < N; ++r) recalc_row(r);\n for (int c = 0; c < N; ++c) recalc_col(c);\n\n // SA parameters\n const double TIME_LIMIT = 2.78; // seconds for SA part\n auto start_time = chrono::high_resolution_clock::now();\n double T0 = 1.5;\n double T1 = 0.05;\n\n // keep best grid\n char best_grid[MAX_N][MAX_N];\n int best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n\n int iter = 0;\n int stagnation = 0; // iterations since last improvement of best_c\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n\n double progress = 0.0;\n double T = T0;\n\n while (true) {\n ++iter;\n if ((iter & 511) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n progress = elapsed / TIME_LIMIT;\n if (progress > 1.0) progress = 1.0;\n T = T0 + (T1 - T0) * progress;\n }\n\n // periodic targeted kicks early\n if ((iter % 2000 == 0) && (progress < 0.5)) {\n apply_pattern_kick();\n if (current_c > best_c) {\n best_c = current_c;\n stagnation = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n // stagnation-based stronger kicks\n if (stagnation > 25000 && progress < 0.7) {\n for (int t = 0; t < 3; ++t) apply_pattern_kick();\n stagnation = 0;\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n int r = row_dist(rng);\n int c = col_dist(rng);\n char oldCh = grid[r][c];\n\n char newCh;\n do {\n newCh = char('A' + letter_dist(rng));\n } while (newCh == oldCh);\n\n // candidate row\n char row_line[2 * MAX_N];\n for (int j = 0; j < N; ++j)\n row_line[j] = (j == c) ? newCh : grid[r][j];\n for (int j = 0; j < N; ++j)\n row_line[N + j] = row_line[j];\n\n BS mark_row = scan_line(row_line, 2 * N);\n\n // candidate column\n char col_line[2 * MAX_N];\n for (int i = 0; i < N; ++i)\n col_line[i] = (i == r) ? newCh : grid[i][c];\n for (int i = 0; i < N; ++i)\n col_line[N + i] = col_line[i];\n\n BS mark_col = scan_line(col_line, 2 * N);\n\n // changed patterns on row and column\n BS changed_row, changed_col, changed_union;\n bs_xor(changed_row, row_bs[r], mark_row);\n bs_xor(changed_col, col_bs[c], mark_col);\n bs_or(changed_union, changed_row, changed_col);\n\n int new_c = current_c;\n\n // compute new_c considering only changed patterns\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n if (oldCov == 0 && newCov > 0) new_c++;\n else if (oldCov > 0 && newCov == 0) new_c--;\n });\n\n int delta = new_c - current_c;\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (prob > my_rand_double()) accept = true;\n }\n\n if (accept) {\n // commit the change\n grid[r][c] = newCh;\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n pattern_cov_count[i] = newCov;\n\n if (newRow) bs_set(row_bs[r], i);\n else bs_reset(row_bs[r], i);\n if (newCol) bs_set(col_bs[c], i);\n else bs_reset(col_bs[c], i);\n });\n current_c = new_c;\n\n if (current_c > best_c) {\n best_c = current_c;\n stagnation = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n } else {\n stagnation++;\n }\n } else {\n stagnation++;\n }\n }\n\n // Output best grid\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) cout << best_grid[i][j];\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n int w;\n};\n\nconst int INF = 1e9;\n\n// Compute travel time of a route (sequence of cell IDs).\n// Cost to move into cell v is cost[v].\nlong long computeTravelTime(const vector &route, const vector &cost) {\n long long t = 0;\n for (int i = 1; i < (int)route.size(); ++i) {\n t += cost[route[i]];\n }\n return t;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector grid(N);\n for (int i = 0; i < N; ++i) cin >> grid[i];\n\n // Map each road cell to an ID\n static int idOf[70][70];\n int r = 0;\n vector> pos; // id -> (i,j)\n vector cost; // id -> cell cost (5-9)\n pos.reserve(N * N);\n cost.reserve(N * N);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n idOf[i][j] = r++;\n pos.emplace_back(i, j);\n cost.push_back(grid[i][j] - '0');\n } else {\n idOf[i][j] = -1;\n }\n }\n }\n\n if (r == 0) {\n cout << \"\\n\";\n return 0;\n }\n\n int startId = idOf[si][sj];\n\n // Build graph of road cells\n vector> G(r);\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N && idOf[ni][nj] != -1) {\n int v = idOf[ni][nj];\n G[id].push_back({v, cost[v]});\n }\n }\n }\n\n // ---------- Fallback DFS route (visit all cells) ----------\n auto buildDFSRoute = [&]() -> vector {\n vector route;\n route.reserve(2 * r + 5);\n vector used(r, 0);\n vector st;\n vector edgeIdx(r, 0);\n\n route.push_back(startId);\n used[startId] = 1;\n st.push_back(startId);\n\n while (!st.empty()) {\n int u = st.back();\n bool advanced = false;\n int &ei = edgeIdx[u];\n while (ei < (int)G[u].size()) {\n int v = G[u][ei].to;\n ++ei;\n if (!used[v]) {\n used[v] = 1;\n st.push_back(v);\n route.push_back(v);\n advanced = true;\n break;\n }\n }\n if (!advanced) {\n st.pop_back();\n if (!st.empty()) {\n route.push_back(st.back());\n }\n }\n }\n return route; // starts and ends at startId\n };\n\n vector fallbackRoute = buildDFSRoute();\n long long fallbackTime = computeTravelTime(fallbackRoute, cost);\n\n // ---------- Build horizontal and vertical segments ----------\n vector> rowSegCells;\n vector rowSegIdOfCell(r, -1);\n for (int i = 0; i < N; ++i) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') {\n ++j;\n continue;\n }\n int segIdx = (int)rowSegCells.size();\n rowSegCells.emplace_back();\n while (j < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n rowSegIdOfCell[id] = segIdx;\n rowSegCells.back().push_back(id);\n ++j;\n }\n }\n }\n\n vector> colSegCells;\n vector colSegIdOfCell(r, -1);\n for (int j = 0; j < N; ++j) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') {\n ++i;\n continue;\n }\n int segIdx = (int)colSegCells.size();\n colSegCells.emplace_back();\n while (i < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n colSegIdOfCell[id] = segIdx;\n colSegCells.back().push_back(id);\n ++i;\n }\n }\n }\n\n // ---------- Precompute visibility (coverage) for all cells ----------\n vector> coverageAll(r);\n for (int id = 0; id < r; ++id) {\n auto &v = coverageAll[id];\n auto &rowV = rowSegCells[rowSegIdOfCell[id]];\n auto &colV = colSegCells[colSegIdOfCell[id]];\n v.reserve(rowV.size() + colV.size());\n for (int x : rowV) v.push_back(x);\n for (int x : colV) v.push_back(x);\n }\n\n // ---------- Build candidate vantage cells (mostly intersections) ----------\n vector isIntersection(r, 0);\n vector hasInterRow(rowSegCells.size(), 0);\n vector hasInterCol(colSegCells.size(), 0);\n\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n bool hor = false, ver = false;\n if (j > 0 && idOf[i][j-1] != -1) hor = true;\n if (j+1 < N && idOf[i][j+1] != -1) hor = true;\n if (i > 0 && idOf[i-1][j] != -1) ver = true;\n if (i+1 < N && idOf[i+1][j] != -1) ver = true;\n if (hor && ver) {\n isIntersection[id] = 1;\n hasInterRow[rowSegIdOfCell[id]] = 1;\n hasInterCol[colSegIdOfCell[id]] = 1;\n }\n }\n\n vector isCandidate(r, 0);\n vector candidateCells;\n candidateCells.reserve(r);\n\n // Intersections\n for (int id = 0; id < r; ++id) {\n if (isIntersection[id]) {\n isCandidate[id] = 1;\n candidateCells.push_back(id);\n }\n }\n // Midpoints of segments without intersections\n for (int s = 0; s < (int)rowSegCells.size(); ++s) {\n if (!hasInterRow[s]) {\n int mid = rowSegCells[s][rowSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n for (int s = 0; s < (int)colSegCells.size(); ++s) {\n if (!hasInterCol[s]) {\n int mid = colSegCells[s][colSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n // Ensure start cell is candidate\n if (!isCandidate[startId]) {\n isCandidate[startId] = 1;\n candidateCells.push_back(startId);\n }\n\n // Coverage of candidates, and which cells are coverable by some candidate\n int C = (int)candidateCells.size();\n vector> candCover;\n candCover.reserve(C);\n vector cellCovered(r, 0);\n for (int idx = 0; idx < C; ++idx) {\n int cell = candidateCells[idx];\n candCover.push_back(coverageAll[cell]);\n for (int x : candCover.back()) cellCovered[x] = 1;\n }\n\n // Patch: if some cell is not covered by any candidate, add it itself as candidate\n for (int id = 0; id < r; ++id) {\n if (!cellCovered[id]) {\n candidateCells.push_back(id);\n candCover.push_back(coverageAll[id]);\n for (int x : coverageAll[id]) cellCovered[x] = 1;\n }\n }\n C = (int)candidateCells.size();\n\n // ---------- Greedy set cover on candidates (cell-based) ----------\n vector vantageCells; // resulting vantage cell IDs\n vantageCells.reserve(C);\n\n vector coveredCells(r, 0);\n int coveredCount = 0;\n vector candSelected(C, 0);\n\n auto selectCandidate = [&](int idx) {\n if (candSelected[idx]) return;\n candSelected[idx] = 1;\n int cell = candidateCells[idx];\n vantageCells.push_back(cell);\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n };\n\n // Use start cell as the first vantage\n int startCandIdx = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candidateCells[idx] == startId) {\n startCandIdx = idx;\n break;\n }\n }\n if (startCandIdx == -1) {\n // Safeguard (shouldn't happen)\n vantageCells.push_back(startId);\n for (int x : coverageAll[startId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(startCandIdx);\n }\n\n while (coveredCount < r) {\n int bestIdx = -1;\n int bestGain = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candSelected[idx]) continue;\n int gain = 0;\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) ++gain;\n }\n if (gain > bestGain) {\n bestGain = gain;\n bestIdx = idx;\n } else if (gain == bestGain && gain > 0 && bestIdx != -1) {\n // Tie-break: closer to start (Manhattan)\n int cellNew = candidateCells[idx];\n int cellBest = candidateCells[bestIdx];\n auto [ni, nj] = pos[cellNew];\n auto [bi, bj] = pos[cellBest];\n int manNew = abs(ni - si) + abs(nj - sj);\n int manBest = abs(bi - si) + abs(bj - sj);\n if (manNew < manBest) bestIdx = idx;\n }\n }\n\n if (bestIdx == -1 || bestGain <= 0) {\n // Safeguard: directly add some uncovered cell as vantage\n int uncoveredId = -1;\n for (int id = 0; id < r; ++id) {\n if (!coveredCells[id]) {\n uncoveredId = id;\n break;\n }\n }\n if (uncoveredId == -1) break; // should not happen\n vantageCells.push_back(uncoveredId);\n for (int x : coverageAll[uncoveredId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(bestIdx);\n }\n }\n\n // Deduplicate vantages (just in case)\n sort(vantageCells.begin(), vantageCells.end());\n vantageCells.erase(unique(vantageCells.begin(), vantageCells.end()), vantageCells.end());\n\n // ---------- Eliminate redundant vantages using coverage frequencies ----------\n {\n int V = (int)vantageCells.size();\n if (V > 0) {\n vector freq(r, 0);\n\n // Base coverage from starting cell (we always start there)\n for (int c : coverageAll[startId]) freq[c]++;\n\n // Add contributions from all vantages\n for (int v : vantageCells) {\n for (int c : coverageAll[v]) freq[c]++;\n }\n\n // Process vantages in ascending order of coverage size (remove small ones first)\n vector orderIdx(V);\n iota(orderIdx.begin(), orderIdx.end(), 0);\n sort(orderIdx.begin(), orderIdx.end(), [&](int a, int b) {\n return coverageAll[vantageCells[a]].size() < coverageAll[vantageCells[b]].size();\n });\n\n vector removed(V, 0);\n for (int idx : orderIdx) {\n int v = vantageCells[idx];\n bool canRemove = true;\n for (int c : coverageAll[v]) {\n if (freq[c] <= 1) { // would leave some cell uncovered\n canRemove = false;\n break;\n }\n }\n if (!canRemove) continue;\n // Remove this vantage\n removed[idx] = 1;\n for (int c : coverageAll[v]) {\n --freq[c];\n }\n }\n\n vector reduced;\n reduced.reserve(V);\n for (int i = 0; i < V; ++i) {\n if (!removed[i]) reduced.push_back(vantageCells[i]);\n }\n vantageCells.swap(reduced);\n }\n }\n\n // ---------- Dijkstra helpers ----------\n vector dist(r), prevv(r);\n\n auto dijkstraToDest = [&](int src, int dest) {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (u == dest) break;\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n };\n\n auto appendPath = [&](vector &route, int src, int dest) {\n if (src == dest) return;\n dijkstraToDest(src, dest);\n vector tmp;\n int x = dest;\n while (x != src && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n route.push_back(tmp[i]);\n }\n };\n\n auto dijkstraNearestTarget = [&](int src,\n const vector &isTarget,\n const vector &visitedTarget) -> int {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n int target = -1;\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (isTarget[u] && !visitedTarget[u]) {\n target = u;\n break;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n return target;\n };\n\n // ---------- Route 1: Greedy nearest neighbor on vantages ----------\n auto buildRouteGreedyNN = [&](const vector &vantages) -> vector {\n vector route;\n route.reserve(2 * r + 5);\n\n vector isTarget(r, 0), visitedTarget(r, 0);\n for (int id : vantages) isTarget[id] = 1;\n\n int remainingTargets = 0;\n for (int id : vantages) {\n if (id == startId) {\n visitedTarget[id] = 1;\n } else {\n ++remainingTargets;\n }\n }\n\n route.push_back(startId);\n int curr = startId;\n\n while (remainingTargets > 0) {\n int target = dijkstraNearestTarget(curr, isTarget, visitedTarget);\n if (target == -1) break; // should not happen (connected component)\n\n // Reconstruct path curr -> target using prevv from dijkstraNearestTarget\n vector tmp;\n int x = target;\n while (x != curr && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n int node = tmp[i];\n route.push_back(node);\n if (isTarget[node] && !visitedTarget[node]) {\n visitedTarget[node] = 1;\n --remainingTargets;\n }\n }\n curr = target;\n }\n\n // Return to start\n if (curr != startId) {\n appendPath(route, curr, startId);\n }\n return route;\n };\n\n vector routeNN = buildRouteGreedyNN(vantageCells);\n long long timeNN = computeTravelTime(routeNN, cost);\n\n // ---------- Route 2: TSP over vantages ----------\n vector routeTSP;\n long long timeTSP = (1LL << 60);\n\n if (!vantageCells.empty()) {\n // Build node list: start + all vantages (without duplicating start)\n vector nodes;\n nodes.reserve(vantageCells.size() + 1);\n nodes.push_back(startId);\n for (int v : vantageCells) {\n if (v != startId) nodes.push_back(v);\n }\n int K = (int)nodes.size();\n\n if (K >= 2) {\n const int MAX_TSP_REAL_DIST_NODES = 320; // lowered threshold to avoid TLE\n bool useRealDist = (K <= MAX_TSP_REAL_DIST_NODES);\n\n vector> distNode(K, vector(K, 0));\n\n if (useRealDist) {\n // Map cell id -> node index\n vector nodeIndex(r, -1);\n for (int i = 0; i < K; ++i) nodeIndex[nodes[i]] = i;\n\n // Dijkstra from each node to compute distances to all others\n for (int i = 0; i < K; ++i) {\n int src = nodes[i];\n fill(dist.begin(), dist.end(), INF);\n dist[src] = 0;\n priority_queue, vector>, greater>> pq;\n pq.push({0, src});\n int remaining = K;\n while (!pq.empty() && remaining > 0) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n int idxU = nodeIndex[u];\n if (idxU != -1) {\n distNode[i][idxU] = d;\n --remaining;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n pq.push({nd, v});\n }\n }\n }\n }\n } else {\n // Approximate distances by Manhattan\n for (int i = 0; i < K; ++i) {\n auto [xi, yi] = pos[nodes[i]];\n for (int j = i + 1; j < K; ++j) {\n auto [xj, yj] = pos[nodes[j]];\n int d = abs(xi - xj) + abs(yi - yj);\n distNode[i][j] = distNode[j][i] = d;\n }\n }\n }\n\n // Initial route: nearest neighbor on distNode\n vector order(K);\n vector usedNode(K, 0);\n order[0] = 0;\n usedNode[0] = 1;\n for (int t = 1; t < K; ++t) {\n int prevIdx = order[t - 1];\n int best = -1;\n int bestD = INT_MAX;\n for (int j = 0; j < K; ++j) {\n if (usedNode[j]) continue;\n int d = distNode[prevIdx][j];\n if (d < bestD) {\n bestD = d;\n best = j;\n }\n }\n if (best == -1) best = 0; // safety\n order[t] = best;\n usedNode[best] = 1;\n }\n\n // Local search: 2-opt + Or-opt, with multi-start kicks\n auto tourLen = [&](const vector &ord) -> long long {\n long long len = 0;\n for (int i = 0; i < K; ++i) {\n int a = ord[i];\n int b = ord[(i + 1) % K];\n len += distNode[a][b];\n }\n return len;\n };\n\n auto twoOptImprove = [&](vector &ord) {\n if (K < 3) return;\n bool improved = true;\n while (improved) {\n improved = false;\n for (int i = 1; i < K - 1 && !improved; ++i) {\n int a = ord[i - 1];\n int b = ord[i];\n for (int j = i + 1; j < K; ++j) {\n int c = ord[j];\n int d = (j + 1 < K ? ord[j + 1] : ord[0]);\n int curCost = distNode[a][b] + distNode[c][d];\n int newCost = distNode[a][c] + distNode[b][d];\n if (newCost < curCost) {\n reverse(ord.begin() + i, ord.begin() + j + 1);\n improved = true;\n break;\n }\n }\n }\n }\n };\n\n auto orOptImprove = [&](vector &ord) {\n if (K < 3) return;\n int maxIter = 4;\n for (int iter = 0; iter < maxIter; ++iter) {\n bool anyImproved = false;\n for (int i = 1; i < K; ++i) {\n int prev = ord[i - 1];\n int cur = ord[i];\n int next = (i == K - 1 ? ord[0] : ord[i + 1]);\n for (int j = 0; j < K; ++j) {\n if (j == i || j == i - 1) continue;\n int a = ord[j];\n int b = (j == K - 1 ? ord[0] : ord[j + 1]);\n if (a == cur || b == cur) continue;\n\n int delta = 0;\n // Remove cur from between prev and next\n delta -= distNode[prev][cur] + distNode[cur][next] - distNode[prev][next];\n // Insert cur between a and b\n delta += distNode[a][cur] + distNode[cur][b] - distNode[a][b];\n\n if (delta < 0) {\n int node = cur;\n if (j < i) {\n // remove at i\n for (int k = i; k < K - 1; ++k) ord[k] = ord[k + 1];\n // insert after j (position j+1)\n for (int k = K - 1; k > j + 1; --k) ord[k] = ord[k - 1];\n ord[j + 1] = node;\n } else { // j > i\n // remove at i\n for (int k = i; k < K - 1; ++k) ord[k] = ord[k + 1];\n // after removal, original index j becomes j-1\n int newJ = j - 1;\n for (int k = K - 1; k > newJ + 1; --k) ord[k] = ord[k - 1];\n ord[newJ + 1] = node;\n }\n anyImproved = true;\n goto NEXT_OR_ITER;\n }\n }\n }\n NEXT_OR_ITER:\n if (!anyImproved) break;\n }\n\n // Final small 2-opt pass\n twoOptImprove(ord);\n };\n\n auto localImprove = [&](vector &ord) {\n twoOptImprove(ord);\n if (K <= 400) { // Or-opt for moderate K only\n orOptImprove(ord);\n }\n };\n\n localImprove(order);\n\n long long bestLen = tourLen(order);\n vector bestOrder = order;\n\n // Multi-start with random \"kicks\"\n static mt19937_64 rng(1234567ULL);\n if (K >= 4) {\n int kicks;\n if (K >= 320) kicks = 4;\n else if (K >= 160) kicks = 4;\n else if (K >= 80) kicks = 3;\n else if (K >= 40) kicks = 3;\n else kicks = 2;\n\n auto randomKick = [&](vector &ord) {\n if (K < 4) return;\n int a = 1 + (int)(rng() % (K - 3));\n int b = a + 1 + (int)(rng() % (K - 2 - a));\n int c = b + 1 + (int)(rng() % (K - 1 - b));\n vector newOrd;\n newOrd.reserve(K);\n for (int i = 0; i < a; ++i) newOrd.push_back(ord[i]); // S1\n for (int i = b; i < c; ++i) newOrd.push_back(ord[i]); // S3\n for (int i = a; i < b; ++i) newOrd.push_back(ord[i]); // S2\n for (int i = c; i < K; ++i) newOrd.push_back(ord[i]); // S4\n ord.swap(newOrd);\n };\n\n for (int it = 0; it < kicks; ++it) {\n vector tmp = bestOrder;\n randomKick(tmp);\n localImprove(tmp);\n long long len = tourLen(tmp);\n if (len < bestLen) {\n bestLen = len;\n bestOrder.swap(tmp);\n }\n }\n order.swap(bestOrder);\n }\n\n // Build actual route following this order (0..K-1), starting at startId\n routeTSP.reserve(2 * r + 5);\n routeTSP.push_back(startId);\n int curr = startId;\n for (int idxPos = 1; idxPos < K; ++idxPos) {\n int nodeIdx = order[idxPos];\n int dest = nodes[nodeIdx];\n if (dest == curr) continue;\n appendPath(routeTSP, curr, dest);\n curr = dest;\n }\n if (curr != startId) {\n appendPath(routeTSP, curr, startId);\n }\n timeTSP = computeTravelTime(routeTSP, cost);\n }\n }\n\n // ---------- Choose the best route among: DFS fallback, NN, TSP ----------\n vector bestRoute = fallbackRoute;\n long long bestTime = fallbackTime;\n\n if (!routeNN.empty() && timeNN < bestTime) {\n bestTime = timeNN;\n bestRoute = std::move(routeNN);\n }\n if (!routeTSP.empty() && timeTSP < bestTime) {\n bestTime = timeTSP;\n bestRoute = std::move(routeTSP);\n }\n\n // If route has no movement, add a tiny loop to avoid t=0\n if ((int)bestRoute.size() == 1) {\n int u = startId;\n int v = -1;\n for (auto &e : G[u]) {\n v = e.to;\n break;\n }\n if (v != -1) {\n bestRoute.push_back(v);\n bestRoute.push_back(u);\n }\n }\n\n // ---------- Convert node sequence to direction string ----------\n string ans;\n ans.reserve(bestRoute.size());\n for (int i = 1; i < (int)bestRoute.size(); ++i) {\n auto [i1, j1] = pos[bestRoute[i-1]];\n auto [i2, j2] = pos[bestRoute[i]];\n if (i2 == i1 - 1 && j2 == j1) ans.push_back('U');\n else if (i2 == i1 + 1 && j2 == j1) ans.push_back('D');\n else if (j2 == j1 - 1 && i2 == i1) ans.push_back('L');\n else if (j2 == j1 + 1 && i2 == i1) ans.push_back('R');\n else {\n // Should not happen with valid shortest paths\n }\n }\n\n cout << ans << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n // Task requirements d[i][k]\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) cin >> d[i][k];\n }\n\n // Dependencies: u -> v\n vector> out(N);\n vector indeg(N, 0);\n for (int e = 0; e < R; ++e) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg[v]++;\n }\n\n // Precompute depth-from-end (longest path length to any sink)\n vector depth(N, 0);\n for (int i = N - 1; i >= 0; --i) {\n int best = 0;\n for (int v : out[i]) {\n best = max(best, depth[v] + 1);\n }\n depth[i] = best;\n }\n\n // Precompute simple difficulty measure (L1 norm)\n vector diffL1(N, 0);\n for (int i = 0; i < N; ++i) {\n int s = 0;\n for (int k = 0; k < K; ++k) s += d[i][k];\n diffL1[i] = s;\n }\n\n // Task states\n const int NOT_STARTED = 0;\n const int IN_PROGRESS = 1;\n const int DONE = 2;\n vector state(N, NOT_STARTED);\n vector degRem = indeg;\n int tasksDone = 0;\n\n // Worker states\n vector curTask(M, -1);\n vector startDay(M, -1);\n\n // Worker skill vectors s_j[k]\n vector> skill(M, vector(K, 0.0));\n // History of (task, w_obs) per worker for fitting\n vector> histTasks(M);\n vector> histW(M);\n\n const int FIT_ITERS = 5;\n const double LR = 0.05;\n const double SKILL_MAX = 100.0;\n\n // Fitting function for one worker (small batch GD over its history)\n auto fitWorker = [&](int j) {\n auto &s = skill[j];\n auto &ht = histTasks[j];\n auto &hw = histW[j];\n int S = (int)ht.size();\n if (S == 0) return;\n for (int it = 0; it < FIT_ITERS; ++it) {\n for (int idx = 0; idx < S; ++idx) {\n int ti = ht[idx];\n double w_obs = hw[idx];\n\n // Compute w_pred = sum_k max(0, d[ti][k] - s[k])\n const auto &dv = d[ti];\n double w_pred = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = (double)dv[k] - s[k];\n if (diff > 0.0) w_pred += diff;\n }\n\n double e = w_pred - w_obs;\n if (e == 0.0) continue;\n double step = LR * e;\n\n // Gradient: for dims where d > s, s[k] += step\n for (int k = 0; k < K; ++k) {\n if ((double)dv[k] > s[k]) {\n s[k] += step;\n if (s[k] < 0.0) s[k] = 0.0;\n if (s[k] > SKILL_MAX) s[k] = SKILL_MAX;\n }\n }\n }\n }\n };\n\n int day = 0;\n const int MAX_CAND = 400; // number of candidate tasks per day to consider\n\n while (true) {\n day++;\n\n // Compute available tasks (not started and all prerequisites done)\n vector available;\n if (tasksDone < N) {\n available.reserve(N);\n for (int i = 0; i < N; ++i) {\n if (state[i] == NOT_STARTED && degRem[i] == 0) {\n available.push_back(i);\n }\n }\n }\n\n // Collect free workers\n vector freeWorkers;\n freeWorkers.reserve(M);\n for (int j = 0; j < M; ++j) {\n if (curTask[j] == -1) freeWorkers.push_back(j);\n }\n\n vector> assigns; // (worker, task)\n\n if (!freeWorkers.empty() && !available.empty()) {\n // Sort available tasks by priority: depth desc, diffL1 desc, id asc\n auto cmpTask = [&](int x, int y) {\n if (depth[x] != depth[y]) return depth[x] > depth[y];\n if (diffL1[x] != diffL1[y]) return diffL1[x] > diffL1[y];\n return x < y;\n };\n\n int sz = (int)available.size();\n if (sz > MAX_CAND) {\n int limit = MAX_CAND;\n partial_sort(available.begin(), available.begin() + limit,\n available.end(), cmpTask);\n available.resize(limit);\n sz = limit;\n } else {\n sort(available.begin(), available.end(), cmpTask);\n }\n\n // Build all (worker, task) options with predicted cost = t_pred\n struct Option {\n double cost;\n int w;\n int task;\n };\n vector

> pq;\n pq.emplace(0.0, s);\n\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist_arr[u]) continue;\n if (u == t) break;\n for (auto &pe : adj[u]) {\n int v = pe.first;\n int eid = pe.second;\n double nd = d + eff_w[eid];\n if (nd < dist_arr[v]) {\n dist_arr[v] = nd;\n prev_v_arr[v] = u;\n pq.emplace(nd, v);\n }\n }\n }\n\n if (prev_v_arr[t] == -1) {\n // Fallback: Manhattan path (should not happen in connected grid)\n build_manhattan(si, sj, ti, tj, path, edges, pred_cost);\n return;\n }\n\n // Reconstruct vertex sequence from s to t\n vector vs_rev;\n vs_rev.reserve(64);\n int cur = t;\n while (cur != s) {\n vs_rev.push_back(cur);\n cur = prev_v_arr[cur];\n }\n vs_rev.push_back(s); // now vs_rev: [t, ..., s]\n\n vector vs;\n vs.reserve(vs_rev.size());\n for (int idx = (int)vs_rev.size() - 1; idx >= 0; --idx) {\n vs.push_back(vs_rev[idx]);\n }\n int L = (int)vs.size() - 1; // number of edges\n\n // Build move string and edges, and compute predicted cost under w\n path.clear();\n path.reserve(L);\n edges.clear();\n edges.reserve(L);\n pred_cost = 0.0;\n\n for (int k = 0; k < L; ++k) {\n int u = vs[k];\n int v = vs[k + 1];\n int ui = u / W, uj = u % W;\n int vi = v / W, vj = v % W;\n\n char c;\n int eid = -1;\n\n if (vi == ui) {\n if (vj == uj + 1) { // right\n c = 'R';\n eid = h_id[ui][uj];\n } else { // vj == uj - 1, left\n c = 'L';\n eid = h_id[ui][vj];\n }\n } else { // vj == uj\n if (vi == ui + 1) { // down\n c = 'D';\n eid = v_id[ui][uj];\n } else { // vi == ui - 1, up\n c = 'U';\n eid = v_id[vi][uj];\n }\n }\n\n path.push_back(c);\n edges.push_back(eid);\n pred_cost += w[eid];\n }\n}\n\n// Convert move string into edge list (used only for fallback if needed elsewhere)\nvoid path_to_edges(int si, int sj, const string &path, vector &edges) {\n edges.clear();\n edges.reserve(path.size());\n int i = si, j = sj;\n for (char c : path) {\n int eid = -1;\n if (c == 'U') {\n int ni = i - 1;\n eid = v_id[ni][j];\n i = ni;\n } else if (c == 'D') {\n eid = v_id[i][j];\n i = i + 1;\n } else if (c == 'L') {\n int nj = j - 1;\n eid = h_id[i][nj];\n j = nj;\n } else if (c == 'R') {\n eid = h_id[i][j];\n j = j + 1;\n }\n edges.push_back(eid);\n }\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n // Build graph and edge indexing\n int eid = 0;\n // Horizontal edges\n for (int i = 0; i < H; ++i) {\n for (int j = 0; j < W - 1; ++j) {\n h_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i, j + 1);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n // Vertical edges\n for (int i = 0; i < H - 1; ++i) {\n for (int j = 0; j < W; ++j) {\n v_id[i][j] = eid;\n int u = vid(i, j);\n int v = vid(i + 1, j);\n adj[u].emplace_back(v, eid);\n adj[v].emplace_back(u, eid);\n ++eid;\n }\n }\n\n // Initialize weights\n w.assign(E, 5000.0);\n eff_w.assign(E, 5000.0);\n\n const double ETA = 0.5; // learning rate multiplier\n\n vector best_edges, tmp_edges;\n string best_path, tmp_path;\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; // EOF / error\n }\n\n // Jitter amplitude for this query (same as baseline)\n const double JITTER0 = 0.03;\n double jitter = JITTER0 * max(0.0, 1.0 - (double)q / 800.0);\n if (jitter < 0.0) jitter = 0.0;\n\n int num_candidates = (jitter > 1e-12 ? 4 : 1);\n\n double best_cost = INF;\n best_path.clear();\n best_edges.clear();\n\n for (int it = 0; it < num_candidates; ++it) {\n double pred_cost = 0.0;\n build_candidate(si, sj, ti, tj, jitter, tmp_path, tmp_edges, pred_cost);\n if (pred_cost < best_cost) {\n best_cost = pred_cost;\n best_path = tmp_path;\n best_edges = tmp_edges;\n }\n }\n\n // Output chosen path\n cout << best_path << '\\n';\n cout.flush();\n\n long long y_ll;\n if (!(cin >> y_ll)) {\n return 0; // EOF / error\n }\n double y = (double)y_ll;\n\n int L = (int)best_edges.size();\n if (L == 0) continue; // should not happen (Manhattan distance >= 10)\n\n double pred = best_cost; // predicted cost under w for chosen path\n double error = y - pred;\n\n double lr = ETA / (double)L;\n for (int e : best_edges) {\n w[e] += lr * error;\n if (w[e] < 1000.0) w[e] = 1000.0;\n else if (w[e] > 9000.0) w[e] = 9000.0;\n }\n }\n\n return 0;\n}","ahc004":"#include \nusing namespace std;\n\nstatic const int MAX_N = 20;\nstatic const int MAX_M = 800;\nstatic const int ALPHA = 8;\nstatic const int MAXW = (MAX_M + 63) / 64;\n\nint N, M;\nint WORDS; // number of 64-bit words used for bitsets\nvector patterns;\n\n// bitset over up to MAX_M bits\nstruct BS {\n uint64_t w[MAXW];\n};\n\n// bitset helpers\ninline void bs_clear(BS &b) {\n memset(b.w, 0, sizeof(b.w));\n}\ninline void bs_or_inplace(BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) a.w[i] |= b.w[i];\n}\ninline void bs_xor(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] ^ b.w[i];\n}\ninline void bs_or(BS &res, const BS &a, const BS &b) {\n for (int i = 0; i < WORDS; ++i) res.w[i] = a.w[i] | b.w[i];\n}\ninline bool bs_test(const BS &b, int idx) {\n return (b.w[idx >> 6] >> (idx & 63)) & 1ULL;\n}\ninline void bs_set(BS &b, int idx) {\n b.w[idx >> 6] |= 1ULL << (idx & 63);\n}\ninline void bs_reset(BS &b, int idx) {\n b.w[idx >> 6] &= ~(1ULL << (idx & 63));\n}\n\n// iterate over set bits of b, calling f(idx) for each\ntemplate \ninline void bs_for_each(const BS &b, F f) {\n for (int w = 0; w < WORDS; ++w) {\n uint64_t x = b.w[w];\n while (x) {\n int lsb = __builtin_ctzll(x);\n int idx = (w << 6) + lsb;\n if (idx >= M) return; // safety; bits >= M are not used\n f(idx);\n x &= x - 1; // clear lowest set bit\n }\n }\n}\n\n// Aho\u2013Corasick automaton\nstruct Node {\n int next[ALPHA];\n int link;\n BS out; // bitset of patterns that end at this state (including via failure)\n Node() {\n fill(next, next + ALPHA, -1);\n link = 0;\n bs_clear(out);\n }\n};\nvector ac;\n\n// grid and evaluation structures\nchar grid[MAX_N][MAX_N];\nBS row_bs[MAX_N], col_bs[MAX_N];\nint pattern_cov_count[MAX_M];\nint current_c = 0;\n\n// RNG\nmt19937_64 rng;\n\ninline int ch_idx(char c) {\n return c - 'A'; // 'A'..'H' -> 0..7\n}\n\nvoid build_automaton() {\n ac.clear();\n ac.emplace_back(); // root\n\n // build trie and set pattern bits\n for (int i = 0; i < M; ++i) {\n const string &s = patterns[i];\n int v = 0;\n for (char ch : s) {\n int c = ch_idx(ch);\n if (ac[v].next[c] == -1) {\n ac[v].next[c] = (int)ac.size();\n ac.emplace_back();\n }\n v = ac[v].next[c];\n }\n bs_set(ac[v].out, i);\n }\n\n // build failure links\n queue q;\n\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[0].next[c];\n if (u != -1) {\n ac[u].link = 0;\n q.push(u);\n } else {\n ac[0].next[c] = 0;\n }\n }\n\n while (!q.empty()) {\n int v = q.front(); q.pop();\n int link = ac[v].link;\n\n // propagate pattern bits from failure link\n bs_or_inplace(ac[v].out, ac[link].out);\n\n for (int c = 0; c < ALPHA; ++c) {\n int u = ac[v].next[c];\n if (u != -1) {\n ac[u].link = ac[link].next[c];\n q.push(u);\n } else {\n ac[v].next[c] = ac[link].next[c];\n }\n }\n }\n}\n\n// scan a line through AC, return bitset of patterns appearing\ninline BS scan_line(const char *s, int len) {\n BS res;\n bs_clear(res);\n int v = 0;\n for (int i = 0; i < len; ++i) {\n int c = ch_idx(s[i]);\n v = ac[v].next[c];\n bs_or_inplace(res, ac[v].out);\n }\n return res;\n}\n\n// recompute one row r and update global counts\nvoid recalc_row(int r) {\n char line[2 * MAX_N];\n for (int j = 0; j < N; ++j) line[j] = grid[r][j];\n for (int j = 0; j < N; ++j) line[N + j] = line[j];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, row_bs[r], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(row_bs[r], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return;\n\n if (newFlag) {\n bs_set(row_bs[r], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(row_bs[r], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// recompute one column c and update global counts\nvoid recalc_col(int c) {\n char line[2 * MAX_N];\n for (int i = 0; i < N; ++i) line[i] = grid[i][c];\n for (int i = 0; i < N; ++i) line[N + i] = line[i];\n\n BS mark = scan_line(line, 2 * N);\n BS changed;\n bs_xor(changed, col_bs[c], mark);\n\n bs_for_each(changed, [&](int i) {\n bool oldFlag = bs_test(col_bs[c], i);\n bool newFlag = bs_test(mark, i);\n if (oldFlag == newFlag) return;\n\n if (newFlag) {\n bs_set(col_bs[c], i);\n if (pattern_cov_count[i] == 0) current_c++;\n pattern_cov_count[i]++;\n } else {\n bs_reset(col_bs[c], i);\n pattern_cov_count[i]--;\n if (pattern_cov_count[i] == 0) current_c--;\n }\n });\n}\n\n// targeted pattern \"kick\": prefer patterns with low coverage and place them greedily\nvoid apply_pattern_kick() {\n if (M == 0) return;\n\n uniform_int_distribution base_dist(0, M - 1);\n int base = base_dist(rng);\n int pid = -1;\n\n // coverage == 0 preferred\n for (int j = 0; j < M; ++j) {\n int id = (base + j) % M;\n if (pattern_cov_count[id] == 0) {\n pid = id;\n break;\n }\n }\n // then coverage == 1\n if (pid == -1) {\n for (int j = 0; j < M; ++j) {\n int id = (base + j) % M;\n if (pattern_cov_count[id] == 1) {\n pid = id;\n break;\n }\n }\n }\n // fallback to base\n if (pid == -1) pid = base;\n\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0; // 0: horizontal, 1: vertical\n int bestR = 0, bestC = 0;\n\n // horizontal placements\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore && (rng() & 1)) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n\n // vertical placements\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore && (rng() & 1)) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n\n bool rowChanged[MAX_N] = {false};\n bool colChanged[MAX_N] = {false};\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] != s[t]) {\n grid[r][c] = s[t];\n rowChanged[r] = true;\n colChanged[c] = true;\n }\n r++;\n if (r == N) r = 0;\n }\n }\n\n // recompute affected rows/columns\n for (int r = 0; r < N; ++r) if (rowChanged[r]) recalc_row(r);\n for (int c = 0; c < N; ++c) if (colChanged[c]) recalc_col(c);\n}\n\ndouble my_rand_double() {\n // 53-bit mantissa random double in [0,1)\n return (rng() >> 11) * (1.0 / (1ULL << 53));\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n cin >> N >> M;\n patterns.resize(M);\n for (int i = 0; i < M; ++i) cin >> patterns[i];\n\n WORDS = (M + 63) / 64;\n\n // init RNG\n uint64_t seed = chrono::high_resolution_clock::now().time_since_epoch().count();\n rng.seed(seed);\n\n build_automaton();\n\n uniform_int_distribution letter_dist(0, ALPHA - 1);\n\n // initial grid: random letters (uniform)\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n grid[i][j] = char('A' + letter_dist(rng));\n\n // constructive pass:\n // - shuffle to randomize\n // - then sort by descending length so longer patterns are placed first\n vector order(M);\n iota(order.begin(), order.end(), 0);\n shuffle(order.begin(), order.end(), rng);\n stable_sort(order.begin(), order.end(), [&](int a, int b) {\n return patterns[a].size() > patterns[b].size();\n });\n\n for (int idx = 0; idx < M; ++idx) {\n int pid = order[idx];\n const string &s = patterns[pid];\n int len = (int)s.size();\n\n int bestScore = -1;\n int bestDir = 0;\n int bestR = 0, bestC = 0;\n\n // horizontal candidates\n for (int r = 0; r < N; ++r) {\n for (int c0 = 0; c0 < N; ++c0) {\n int score = 0;\n int c = c0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n c++;\n if (c == N) c = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 0;\n bestR = r;\n bestC = c0;\n }\n }\n }\n\n // vertical candidates\n for (int c = 0; c < N; ++c) {\n for (int r0 = 0; r0 < N; ++r0) {\n int score = 0;\n int r = r0;\n for (int t = 0; t < len; ++t) {\n if (grid[r][c] == s[t]) score++;\n r++;\n if (r == N) r = 0;\n }\n if (score > bestScore) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n } else if (score == bestScore && my_rand_double() < 0.5) {\n bestScore = score;\n bestDir = 1;\n bestR = r0;\n bestC = c;\n }\n }\n }\n\n // apply best placement\n if (bestDir == 0) {\n int r = bestR;\n int c = bestC;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n c++;\n if (c == N) c = 0;\n }\n } else {\n int c = bestC;\n int r = bestR;\n for (int t = 0; t < len; ++t) {\n grid[r][c] = s[t];\n r++;\n if (r == N) r = 0;\n }\n }\n }\n\n // Initialize evaluation\n for (int r = 0; r < N; ++r) bs_clear(row_bs[r]);\n for (int c = 0; c < N; ++c) bs_clear(col_bs[c]);\n fill(pattern_cov_count, pattern_cov_count + M, 0);\n current_c = 0;\n\n for (int r = 0; r < N; ++r) recalc_row(r);\n for (int c = 0; c < N; ++c) recalc_col(c);\n\n // SA parameters\n const double TIME_LIMIT = 2.78; // seconds for SA part\n auto start_time = chrono::high_resolution_clock::now();\n double T0 = 1.5;\n double T1 = 0.05;\n\n // keep best grid\n char best_grid[MAX_N][MAX_N];\n int best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n\n int iter = 0;\n int stagnation = 0; // iterations since last improvement of best_c\n uniform_int_distribution row_dist(0, N - 1);\n uniform_int_distribution col_dist(0, N - 1);\n\n double progress = 0.0;\n double T = T0;\n\n while (true) {\n ++iter;\n if ((iter & 511) == 0) {\n auto now = chrono::high_resolution_clock::now();\n double elapsed = chrono::duration(now - start_time).count();\n if (elapsed > TIME_LIMIT) break;\n progress = elapsed / TIME_LIMIT;\n if (progress > 1.0) progress = 1.0;\n T = T0 + (T1 - T0) * progress;\n }\n\n // periodic targeted kicks early\n if ((iter % 2000 == 0) && (progress < 0.5)) {\n apply_pattern_kick();\n if (current_c > best_c) {\n best_c = current_c;\n stagnation = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n // stagnation-based stronger kicks\n if (stagnation > 25000 && progress < 0.7) {\n for (int t = 0; t < 3; ++t) apply_pattern_kick();\n stagnation = 0;\n if (current_c > best_c) {\n best_c = current_c;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n }\n }\n\n int r = row_dist(rng);\n int c = col_dist(rng);\n char oldCh = grid[r][c];\n\n char newCh;\n do {\n newCh = char('A' + letter_dist(rng));\n } while (newCh == oldCh);\n\n // candidate row\n char row_line[2 * MAX_N];\n for (int j = 0; j < N; ++j)\n row_line[j] = (j == c) ? newCh : grid[r][j];\n for (int j = 0; j < N; ++j)\n row_line[N + j] = row_line[j];\n\n BS mark_row = scan_line(row_line, 2 * N);\n\n // candidate column\n char col_line[2 * MAX_N];\n for (int i = 0; i < N; ++i)\n col_line[i] = (i == r) ? newCh : grid[i][c];\n for (int i = 0; i < N; ++i)\n col_line[N + i] = col_line[i];\n\n BS mark_col = scan_line(col_line, 2 * N);\n\n // changed patterns on row and column\n BS changed_row, changed_col, changed_union;\n bs_xor(changed_row, row_bs[r], mark_row);\n bs_xor(changed_col, col_bs[c], mark_col);\n bs_or(changed_union, changed_row, changed_col);\n\n int new_c = current_c;\n\n // compute new_c considering only changed patterns\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n if (oldCov == 0 && newCov > 0) new_c++;\n else if (oldCov > 0 && newCov == 0) new_c--;\n });\n\n int delta = new_c - current_c;\n bool accept = false;\n if (delta >= 0) {\n accept = true;\n } else {\n double prob = exp((double)delta / T);\n if (prob > my_rand_double()) accept = true;\n }\n\n if (accept) {\n // commit the change\n grid[r][c] = newCh;\n bs_for_each(changed_union, [&](int i) {\n int oldCov = pattern_cov_count[i];\n int newCov = oldCov;\n\n bool oldRow = bs_test(row_bs[r], i);\n bool newRow = bs_test(mark_row, i);\n newCov += (int)newRow - (int)oldRow;\n\n bool oldCol = bs_test(col_bs[c], i);\n bool newCol = bs_test(mark_col, i);\n newCov += (int)newCol - (int)oldCol;\n\n pattern_cov_count[i] = newCov;\n\n if (newRow) bs_set(row_bs[r], i);\n else bs_reset(row_bs[r], i);\n if (newCol) bs_set(col_bs[c], i);\n else bs_reset(col_bs[c], i);\n });\n current_c = new_c;\n\n if (current_c > best_c) {\n best_c = current_c;\n stagnation = 0;\n for (int i = 0; i < N; ++i)\n for (int j = 0; j < N; ++j)\n best_grid[i][j] = grid[i][j];\n } else {\n stagnation++;\n }\n } else {\n stagnation++;\n }\n }\n\n // Output best grid\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) cout << best_grid[i][j];\n cout << '\\n';\n }\n\n return 0;\n}","ahc005":"#include \nusing namespace std;\n\nstruct Edge {\n int to;\n int w;\n};\n\nconst int INF = 1e9;\n\n// Compute travel time of a route (sequence of cell IDs).\n// Cost to move into cell v is cost[v].\nlong long computeTravelTime(const vector &route, const vector &cost) {\n long long t = 0;\n for (int i = 1; i < (int)route.size(); ++i) {\n t += cost[route[i]];\n }\n return t;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, si, sj;\n if (!(cin >> N >> si >> sj)) return 0;\n vector grid(N);\n for (int i = 0; i < N; ++i) cin >> grid[i];\n\n // Map each road cell to an ID\n static int idOf[70][70];\n int r = 0;\n vector> pos; // id -> (i,j)\n vector cost; // id -> cell cost (5-9)\n pos.reserve(N * N);\n cost.reserve(N * N);\n\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n if (grid[i][j] != '#') {\n idOf[i][j] = r++;\n pos.emplace_back(i, j);\n cost.push_back(grid[i][j] - '0');\n } else {\n idOf[i][j] = -1;\n }\n }\n }\n\n if (r == 0) {\n cout << \"\\n\";\n return 0;\n }\n\n int startId = idOf[si][sj];\n\n // Build graph of road cells\n vector> G(r);\n int di[4] = {-1, 1, 0, 0};\n int dj[4] = {0, 0, -1, 1};\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n for (int d = 0; d < 4; ++d) {\n int ni = i + di[d], nj = j + dj[d];\n if (0 <= ni && ni < N && 0 <= nj && nj < N && idOf[ni][nj] != -1) {\n int v = idOf[ni][nj];\n G[id].push_back({v, cost[v]});\n }\n }\n }\n\n // ---------- Build horizontal and vertical segments ----------\n vector> rowSegCells;\n vector rowSegIdOfCell(r, -1);\n for (int i = 0; i < N; ++i) {\n int j = 0;\n while (j < N) {\n if (grid[i][j] == '#') {\n ++j;\n continue;\n }\n int segIdx = (int)rowSegCells.size();\n rowSegCells.emplace_back();\n while (j < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n rowSegIdOfCell[id] = segIdx;\n rowSegCells.back().push_back(id);\n ++j;\n }\n }\n }\n\n vector> colSegCells;\n vector colSegIdOfCell(r, -1);\n for (int j = 0; j < N; ++j) {\n int i = 0;\n while (i < N) {\n if (grid[i][j] == '#') {\n ++i;\n continue;\n }\n int segIdx = (int)colSegCells.size();\n colSegCells.emplace_back();\n while (i < N && grid[i][j] != '#') {\n int id = idOf[i][j];\n colSegIdOfCell[id] = segIdx;\n colSegCells.back().push_back(id);\n ++i;\n }\n }\n }\n\n // ---------- Precompute visibility (coverage) for all cells ----------\n vector> coverageAll(r);\n for (int id = 0; id < r; ++id) {\n auto &v = coverageAll[id];\n auto &rowV = rowSegCells[rowSegIdOfCell[id]];\n auto &colV = colSegCells[colSegIdOfCell[id]];\n v.reserve(rowV.size() + colV.size());\n for (int x : rowV) v.push_back(x);\n // avoid counting the same cell twice (self) from row & col\n for (int x : colV) if (x != id) v.push_back(x);\n }\n\n // ---------- Build candidate vantage cells (mostly intersections) ----------\n vector isIntersection(r, 0);\n vector hasInterRow(rowSegCells.size(), 0);\n vector hasInterCol(colSegCells.size(), 0);\n\n for (int id = 0; id < r; ++id) {\n auto [i, j] = pos[id];\n bool hor = false, ver = false;\n if (j > 0 && idOf[i][j-1] != -1) hor = true;\n if (j+1 < N && idOf[i][j+1] != -1) hor = true;\n if (i > 0 && idOf[i-1][j] != -1) ver = true;\n if (i+1 < N && idOf[i+1][j] != -1) ver = true;\n if (hor && ver) {\n isIntersection[id] = 1;\n hasInterRow[rowSegIdOfCell[id]] = 1;\n hasInterCol[colSegIdOfCell[id]] = 1;\n }\n }\n\n vector isCandidate(r, 0);\n vector candidateCells;\n candidateCells.reserve(r);\n\n // Intersections\n for (int id = 0; id < r; ++id) {\n if (isIntersection[id]) {\n isCandidate[id] = 1;\n candidateCells.push_back(id);\n }\n }\n // Midpoints of segments without intersections\n for (int s = 0; s < (int)rowSegCells.size(); ++s) {\n if (!hasInterRow[s]) {\n int mid = rowSegCells[s][rowSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n for (int s = 0; s < (int)colSegCells.size(); ++s) {\n if (!hasInterCol[s]) {\n int mid = colSegCells[s][colSegCells[s].size() / 2];\n if (!isCandidate[mid]) {\n isCandidate[mid] = 1;\n candidateCells.push_back(mid);\n }\n }\n }\n // Ensure start cell is candidate\n if (!isCandidate[startId]) {\n isCandidate[startId] = 1;\n candidateCells.push_back(startId);\n }\n\n // Coverage of candidates, and which cells are coverable by some candidate\n int C = (int)candidateCells.size();\n vector> candCover;\n candCover.reserve(C);\n vector cellCovered(r, 0);\n for (int idx = 0; idx < C; ++idx) {\n int cell = candidateCells[idx];\n candCover.push_back(coverageAll[cell]);\n for (int x : candCover.back()) cellCovered[x] = 1;\n }\n\n // Patch: if some cell is not covered by any candidate, add it itself as candidate\n for (int id = 0; id < r; ++id) {\n if (!cellCovered[id]) {\n candidateCells.push_back(id);\n candCover.push_back(coverageAll[id]);\n for (int x : coverageAll[id]) cellCovered[x] = 1;\n }\n }\n C = (int)candidateCells.size();\n\n // ---------- Greedy set cover on candidates (cell-based) ----------\n vector vantageCells; // resulting vantage cell IDs\n vantageCells.reserve(C);\n\n vector coveredCells(r, 0);\n int coveredCount = 0;\n vector candSelected(C, 0);\n\n auto selectCandidate = [&](int idx) {\n if (candSelected[idx]) return;\n candSelected[idx] = 1;\n int cell = candidateCells[idx];\n vantageCells.push_back(cell);\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n };\n\n // Use start cell as the first vantage\n int startCandIdx = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candidateCells[idx] == startId) {\n startCandIdx = idx;\n break;\n }\n }\n if (startCandIdx == -1) {\n // Safeguard (shouldn't happen)\n vantageCells.push_back(startId);\n for (int x : coverageAll[startId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(startCandIdx);\n }\n\n while (coveredCount < r) {\n int bestIdx = -1;\n int bestGain = -1;\n for (int idx = 0; idx < C; ++idx) {\n if (candSelected[idx]) continue;\n int gain = 0;\n for (int x : candCover[idx]) {\n if (!coveredCells[x]) ++gain;\n }\n if (gain > bestGain) {\n bestGain = gain;\n bestIdx = idx;\n } else if (gain == bestGain && gain > 0 && bestIdx != -1) {\n int cellNew = candidateCells[idx];\n int cellBest = candidateCells[bestIdx];\n if (cost[cellNew] < cost[cellBest]) {\n bestIdx = idx;\n } else if (cost[cellNew] == cost[cellBest]) {\n auto [ni, nj] = pos[cellNew];\n auto [bi, bj] = pos[cellBest];\n int manNew = abs(ni - si) + abs(nj - sj);\n int manBest = abs(bi - si) + abs(bj - sj);\n if (manNew < manBest) bestIdx = idx;\n }\n }\n }\n\n if (bestIdx == -1 || bestGain <= 0) {\n // Safeguard: directly add some uncovered cell as vantage\n int uncoveredId = -1;\n for (int id = 0; id < r; ++id) {\n if (!coveredCells[id]) {\n uncoveredId = id;\n break;\n }\n }\n if (uncoveredId == -1) break; // should not happen\n vantageCells.push_back(uncoveredId);\n for (int x : coverageAll[uncoveredId]) {\n if (!coveredCells[x]) {\n coveredCells[x] = 1;\n ++coveredCount;\n }\n }\n } else {\n selectCandidate(bestIdx);\n }\n }\n\n // Deduplicate vantages (just in case)\n sort(vantageCells.begin(), vantageCells.end());\n vantageCells.erase(unique(vantageCells.begin(), vantageCells.end()), vantageCells.end());\n\n // ---------- Eliminate redundant vantages using coverage frequencies (cost-biased) ----------\n {\n int V = (int)vantageCells.size();\n if (V > 0) {\n vector freq(r, 0);\n\n // Base coverage from starting cell\n for (int c : coverageAll[startId]) freq[c]++;\n\n // Add contributions from all vantages\n for (int v : vantageCells) {\n for (int c : coverageAll[v]) freq[c]++;\n }\n\n // Try to remove expensive vantages first\n vector orderIdx(V);\n iota(orderIdx.begin(), orderIdx.end(), 0);\n sort(orderIdx.begin(), orderIdx.end(), [&](int a, int b) {\n int va = vantageCells[a], vb = vantageCells[b];\n if (cost[va] != cost[vb]) return cost[va] > cost[vb]; // remove high-cost first\n return coverageAll[va].size() < coverageAll[vb].size();\n });\n\n vector removed(V, 0);\n for (int idx : orderIdx) {\n int v = vantageCells[idx];\n bool canRemove = true;\n for (int c : coverageAll[v]) {\n if (freq[c] <= 1) { // would leave some cell uncovered\n canRemove = false;\n break;\n }\n }\n if (!canRemove) continue;\n removed[idx] = 1;\n for (int c : coverageAll[v]) {\n --freq[c];\n }\n }\n\n vector reduced;\n reduced.reserve(V);\n for (int i = 0; i < V; ++i) {\n if (!removed[i]) reduced.push_back(vantageCells[i]);\n }\n vantageCells.swap(reduced);\n }\n }\n\n // ---------- Second elimination pass (coverage-size-biased) ----------\n {\n int V = (int)vantageCells.size();\n if (V > 0) {\n vector freq(r, 0);\n for (int c : coverageAll[startId]) freq[c]++;\n for (int v : vantageCells) {\n for (int c : coverageAll[v]) freq[c]++;\n }\n\n vector orderIdx(V);\n iota(orderIdx.begin(), orderIdx.end(), 0);\n sort(orderIdx.begin(), orderIdx.end(), [&](int a, int b) {\n int va = vantageCells[a], vb = vantageCells[b];\n if (coverageAll[va].size() != coverageAll[vb].size())\n return coverageAll[va].size() < coverageAll[vb].size(); // remove small-coverage first\n return cost[va] > cost[vb]; // then remove more expensive\n });\n\n vector removed(V, 0);\n for (int idx : orderIdx) {\n int v = vantageCells[idx];\n bool canRemove = true;\n for (int c : coverageAll[v]) {\n if (freq[c] <= 1) {\n canRemove = false;\n break;\n }\n }\n if (!canRemove) continue;\n removed[idx] = 1;\n for (int c : coverageAll[v]) {\n --freq[c];\n }\n }\n\n vector reduced;\n reduced.reserve(V);\n for (int i = 0; i < V; ++i) {\n if (!removed[i]) reduced.push_back(vantageCells[i]);\n }\n vantageCells.swap(reduced);\n }\n }\n\n // ---------- Dijkstra helpers ----------\n vector dist(r), prevv(r);\n\n auto dijkstraToDest = [&](int src, int dest) {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (u == dest) break;\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n };\n\n auto appendPath = [&](vector &route, int src, int dest) {\n if (src == dest) return;\n dijkstraToDest(src, dest);\n vector tmp;\n int x = dest;\n while (x != src && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n route.push_back(tmp[i]);\n }\n };\n\n auto dijkstraNearestTarget = [&](int src,\n const vector &isTarget,\n const vector &visitedTarget) -> int {\n fill(dist.begin(), dist.end(), INF);\n fill(prevv.begin(), prevv.end(), -1);\n priority_queue, vector>, greater>> pq;\n dist[src] = 0;\n pq.push({0, src});\n int target = -1;\n while (!pq.empty()) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n if (isTarget[u] && !visitedTarget[u]) {\n target = u;\n break;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n prevv[v] = u;\n pq.push({nd, v});\n }\n }\n }\n return target;\n };\n\n // ---------- Greedy NN route builder (used only when needed) ----------\n auto buildRouteGreedyNN = [&](const vector &vantages) -> vector {\n vector route;\n route.reserve(2 * r + 5);\n\n vector isTarget(r, 0), visitedTarget(r, 0);\n for (int id : vantages) isTarget[id] = 1;\n\n int remainingTargets = 0;\n for (int id : vantages) {\n if (id == startId) {\n visitedTarget[id] = 1;\n } else {\n ++remainingTargets;\n }\n }\n\n route.push_back(startId);\n int curr = startId;\n\n while (remainingTargets > 0) {\n int target = dijkstraNearestTarget(curr, isTarget, visitedTarget);\n if (target == -1) break; // should not happen (connected)\n\n vector tmp;\n int x = target;\n while (x != curr && x != -1) {\n tmp.push_back(x);\n x = prevv[x];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n int node = tmp[i];\n route.push_back(node);\n if (isTarget[node] && !visitedTarget[node]) {\n visitedTarget[node] = 1;\n --remainingTargets;\n }\n }\n curr = target;\n }\n\n if (curr != startId) {\n appendPath(route, curr, startId);\n }\n return route;\n };\n\n // RNG seeded from input to diversify per-instance local search\n uint64_t seed = 88172645463393265ULL;\n seed ^= (uint64_t)N * 10007;\n seed ^= (uint64_t)si * 1000003;\n seed ^= (uint64_t)sj * 1000000007ULL;\n for (int i = 0; i < N; ++i) {\n for (int j = 0; j < N; ++j) {\n unsigned char c = grid[i][j];\n seed = seed * 19260817ULL + c + 1;\n }\n }\n mt19937_64 rng(seed);\n\n // ---------- Route 2: TSP over vantages ----------\n vector routeTSP;\n long long timeTSP = (1LL << 60);\n bool builtTSP = false;\n bool useRealDist = false;\n\n if (!vantageCells.empty()) {\n // Build node list: start + all vantages (without duplicating start)\n vector nodes;\n nodes.reserve(vantageCells.size() + 1);\n nodes.push_back(startId);\n for (int v : vantageCells) {\n if (v != startId) nodes.push_back(v);\n }\n int K = (int)nodes.size();\n\n if (K >= 2) {\n const int MAX_TSP_REAL_DIST_NODES = 480;\n useRealDist = (K <= MAX_TSP_REAL_DIST_NODES);\n\n vector> distNode(K, vector(K, 0));\n vector nodeIndex;\n vector> parentAll;\n\n if (useRealDist) {\n nodeIndex.assign(r, -1);\n for (int i = 0; i < K; ++i) nodeIndex[nodes[i]] = i;\n\n parentAll.assign(K, vector(r, -1));\n\n // Dijkstra from each node to compute distances to all others, storing parents\n for (int i = 0; i < K; ++i) {\n int src = nodes[i];\n auto &parent = parentAll[i];\n\n fill(dist.begin(), dist.end(), INF);\n fill(parent.begin(), parent.end(), -1);\n dist[src] = 0;\n priority_queue, vector>, greater>> pq;\n pq.push({0, src});\n int remaining = K;\n while (!pq.empty() && remaining > 0) {\n auto [d, u] = pq.top();\n pq.pop();\n if (d != dist[u]) continue;\n int idxU = nodeIndex[u];\n if (idxU != -1) {\n distNode[i][idxU] = d;\n --remaining;\n }\n for (auto &e : G[u]) {\n int v = e.to;\n int nd = d + e.w;\n if (nd < dist[v]) {\n dist[v] = nd;\n parent[v] = u;\n pq.push({nd, v});\n }\n }\n }\n }\n } else {\n // Approximate distances by Manhattan\n for (int i = 0; i < K; ++i) {\n auto [xi, yi] = pos[nodes[i]];\n for (int j = i + 1; j < K; ++j) {\n auto [xj, yj] = pos[nodes[j]];\n int d = abs(xi - xj) + abs(yi - yj);\n distNode[i][j] = distNode[j][i] = d;\n }\n }\n }\n\n // Initial route: nearest neighbor on distNode\n vector order(K);\n vector usedNode(K, 0);\n order[0] = 0;\n usedNode[0] = 1;\n for (int t = 1; t < K; ++t) {\n int prevIdx = order[t - 1];\n int best = -1;\n int bestD = INT_MAX;\n for (int j = 0; j < K; ++j) {\n if (usedNode[j]) continue;\n int d = distNode[prevIdx][j];\n if (d < bestD) {\n bestD = d;\n best = j;\n }\n }\n if (best == -1) best = 0; // safety\n order[t] = best;\n usedNode[best] = 1;\n }\n\n // Local search: 2-opt + Or-opt, with multi-start kicks\n auto tourLen = [&](const vector &ord) -> long long {\n long long len = 0;\n for (int i = 0; i < K; ++i) {\n int a = ord[i];\n int b = ord[(i + 1) % K];\n len += distNode[a][b];\n }\n return len;\n };\n\n auto twoOptImprove = [&](vector &ord) {\n if (K < 3) return;\n bool improved = true;\n while (improved) {\n improved = false;\n for (int i = 1; i < K - 1 && !improved; ++i) {\n int a = ord[i - 1];\n int b = ord[i];\n for (int j = i + 1; j < K; ++j) {\n int c = ord[j];\n int d = (j + 1 < K ? ord[j + 1] : ord[0]);\n int curCost = distNode[a][b] + distNode[c][d];\n int newCost = distNode[a][c] + distNode[b][d];\n if (newCost < curCost) {\n reverse(ord.begin() + i, ord.begin() + j + 1);\n improved = true;\n break;\n }\n }\n }\n }\n };\n\n auto orOptImprove = [&](vector &ord) {\n if (K < 3) return;\n int maxIter;\n if (K <= 60) maxIter = 8;\n else if (K <= 120) maxIter = 6;\n else if (K <= 200) maxIter = 4;\n else if (K <= 400) maxIter = 3;\n else maxIter = 2;\n\n for (int iter = 0; iter < maxIter; ++iter) {\n bool anyImproved = false;\n for (int i = 1; i < K; ++i) {\n int prev = ord[i - 1];\n int cur = ord[i];\n int next = (i == K - 1 ? ord[0] : ord[i + 1]);\n for (int j = 0; j < K; ++j) {\n if (j == i || j == i - 1) continue;\n int a = ord[j];\n int b = (j == K - 1 ? ord[0] : ord[j + 1]);\n if (a == cur || b == cur) continue;\n\n int delta = 0;\n // Remove cur from between prev and next\n delta -= distNode[prev][cur] + distNode[cur][next] - distNode[prev][next];\n // Insert cur between a and b\n delta += distNode[a][cur] + distNode[cur][b] - distNode[a][b];\n\n if (delta < 0) {\n int node = cur;\n if (j < i) {\n for (int k = i; k < K - 1; ++k) ord[k] = ord[k + 1];\n for (int k = K - 1; k > j + 1; --k) ord[k] = ord[k - 1];\n ord[j + 1] = node;\n } else { // j > i\n for (int k = i; k < K - 1; ++k) ord[k] = ord[k + 1];\n int newJ = j - 1;\n for (int k = K - 1; k > newJ + 1; --k) ord[k] = ord[k - 1];\n ord[newJ + 1] = node;\n }\n anyImproved = true;\n goto NEXT_OR_ITER;\n }\n }\n }\n NEXT_OR_ITER:\n if (!anyImproved) break;\n }\n\n twoOptImprove(ord);\n };\n\n auto localImprove = [&](vector &ord) {\n twoOptImprove(ord);\n orOptImprove(ord);\n };\n\n localImprove(order);\n\n long long bestLen = tourLen(order);\n vector bestOrder = order;\n\n // Multi-start with random \"kicks\" (more kicks for small K where it is cheap)\n if (K >= 4) {\n int kicks;\n if (K <= 40) kicks = 8;\n else if (K <= 80) kicks = 6;\n else if (K <= 160) kicks = 4;\n else if (K <= 320) kicks = 3;\n else kicks = 2;\n\n auto randomKick = [&](vector &ord) {\n if (K < 4) return;\n int a = 1 + (int)(rng() % (K - 3));\n int b = a + 1 + (int)(rng() % (K - 2 - a));\n int c = b + 1 + (int)(rng() % (K - 1 - b));\n vector newOrd;\n newOrd.reserve(K);\n for (int i = 0; i < a; ++i) newOrd.push_back(ord[i]); // S1\n for (int i = b; i < c; ++i) newOrd.push_back(ord[i]); // S3\n for (int i = a; i < b; ++i) newOrd.push_back(ord[i]); // S2\n for (int i = c; i < K; ++i) newOrd.push_back(ord[i]); // S4\n ord.swap(newOrd);\n };\n\n for (int it = 0; it < kicks; ++it) {\n vector tmp = bestOrder;\n randomKick(tmp);\n localImprove(tmp);\n long long len = tourLen(tmp);\n if (len < bestLen) {\n bestLen = len;\n bestOrder.swap(tmp);\n }\n }\n order.swap(bestOrder);\n }\n\n // Build actual route following this order (0..K-1), starting at startId\n routeTSP.reserve(2 * r + 5);\n routeTSP.push_back(startId);\n int curr = startId;\n\n if (useRealDist) {\n // Use stored parents (no extra Dijkstra)\n for (int idxPos = 1; idxPos < K; ++idxPos) {\n int dest = nodes[order[idxPos]];\n if (dest == curr) continue;\n int srcIdx = nodeIndex[curr];\n auto &parent = parentAll[srcIdx];\n vector tmp;\n int v = dest;\n while (v != curr && v != -1) {\n tmp.push_back(v);\n v = parent[v];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n routeTSP.push_back(tmp[i]);\n }\n curr = dest;\n }\n if (curr != startId) {\n int srcIdx = nodeIndex[curr];\n auto &parent = parentAll[srcIdx];\n vector tmp;\n int v = startId;\n while (v != curr && v != -1) {\n tmp.push_back(v);\n v = parent[v];\n }\n for (int i = (int)tmp.size() - 1; i >= 0; --i) {\n routeTSP.push_back(tmp[i]);\n }\n }\n } else {\n // Manhattan-based TSP: still need Dijkstra to realize actual paths\n for (int idxPos = 1; idxPos < K; ++idxPos) {\n int dest = nodes[order[idxPos]];\n if (dest == curr) continue;\n appendPath(routeTSP, curr, dest);\n curr = dest;\n }\n if (curr != startId) {\n appendPath(routeTSP, curr, startId);\n }\n }\n\n timeTSP = computeTravelTime(routeTSP, cost);\n builtTSP = true;\n }\n }\n\n // ---------- Route 1: Greedy nearest neighbor (only when needed) ----------\n vector routeNN;\n long long timeNN = (1LL << 60);\n\n bool needNN = true;\n if (builtTSP && useRealDist) needNN = false;\n\n if (needNN) {\n routeNN = buildRouteGreedyNN(vantageCells);\n if (!routeNN.empty()) timeNN = computeTravelTime(routeNN, cost);\n }\n\n // ---------- Choose the best route ----------\n vector bestRoute;\n long long bestTime = (1LL << 60);\n\n if (!routeNN.empty()) {\n bestTime = timeNN;\n bestRoute = std::move(routeNN);\n }\n if (builtTSP && !routeTSP.empty() && timeTSP < bestTime) {\n bestTime = timeTSP;\n bestRoute = std::move(routeTSP);\n }\n\n // As a last resort (should not happen), if nothing was built, stay at start\n if (bestRoute.empty()) {\n bestRoute.push_back(startId);\n }\n\n // If route has no movement, add a tiny loop to avoid t=0\n if ((int)bestRoute.size() == 1) {\n int u = startId;\n int v = -1;\n for (auto &e : G[u]) {\n v = e.to;\n break;\n }\n if (v != -1) {\n bestRoute.push_back(v);\n bestRoute.push_back(u);\n }\n }\n\n // ---------- Convert node sequence to direction string ----------\n string ans;\n ans.reserve(bestRoute.size());\n for (int i = 1; i < (int)bestRoute.size(); ++i) {\n auto [i1, j1] = pos[bestRoute[i-1]];\n auto [i2, j2] = pos[bestRoute[i]];\n if (i2 == i1 - 1 && j2 == j1) ans.push_back('U');\n else if (i2 == i1 + 1 && j2 == j1) ans.push_back('D');\n else if (j2 == j1 - 1 && i2 == i1) ans.push_back('L');\n else if (j2 == j1 + 1 && i2 == i1) ans.push_back('R');\n else {\n // Should not happen with valid shortest paths\n }\n }\n\n cout << ans << '\\n';\n return 0;\n}","future-contest-2022-qual":"#include \nusing namespace std;\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n\n int N, M, K, R;\n if (!(cin >> N >> M >> K >> R)) return 0;\n\n // Task requirements d[i][k]\n vector> d(N, vector(K));\n for (int i = 0; i < N; ++i) {\n for (int k = 0; k < K; ++k) cin >> d[i][k];\n }\n\n // Dependencies: u -> v\n vector> out(N);\n vector indeg(N, 0);\n for (int e = 0; e < R; ++e) {\n int u, v;\n cin >> u >> v;\n --u; --v;\n out[u].push_back(v);\n indeg[v]++;\n }\n\n // Precompute depth-from-end (longest path length to any sink)\n vector depth(N, 0);\n for (int i = N - 1; i >= 0; --i) {\n int best = 0;\n for (int v : out[i]) {\n best = max(best, depth[v] + 1);\n }\n depth[i] = best;\n }\n\n // Precompute simple difficulty measure (L1 norm)\n vector diffL1(N, 0);\n for (int i = 0; i < N; ++i) {\n int s = 0;\n for (int k = 0; k < K; ++k) s += d[i][k];\n diffL1[i] = s;\n }\n\n // Task states\n const int NOT_STARTED = 0;\n const int IN_PROGRESS = 1;\n const int DONE = 2;\n vector state(N, NOT_STARTED);\n vector degRem = indeg;\n int tasksDone = 0;\n\n // Worker states\n vector curTask(M, -1);\n vector startDay(M, -1);\n\n // Worker skill vectors s_j[k]\n vector> skill(M, vector(K, 0.0));\n // History of (task, w_obs) per worker for fitting\n vector> histTasks(M);\n vector> histW(M);\n\n const int FIT_ITERS = 5;\n const double LR = 0.05;\n const double SKILL_MAX = 100.0;\n\n // Fitting function for one worker (small batch GD over its history)\n auto fitWorker = [&](int j) {\n auto &s = skill[j];\n auto &ht = histTasks[j];\n auto &hw = histW[j];\n int S = (int)ht.size();\n if (S == 0) return;\n for (int it = 0; it < FIT_ITERS; ++it) {\n for (int idx = 0; idx < S; ++idx) {\n int ti = ht[idx];\n double w_obs = hw[idx];\n\n // Compute w_pred = sum_k max(0, d[ti][k] - s[k])\n const auto &dv = d[ti];\n double w_pred = 0.0;\n for (int k = 0; k < K; ++k) {\n double diff = (double)dv[k] - s[k];\n if (diff > 0.0) w_pred += diff;\n }\n\n double e = w_pred - w_obs;\n if (e == 0.0) continue;\n double step = LR * e;\n\n // Gradient: for dims where d > s, s[k] += step\n for (int k = 0; k < K; ++k) {\n if ((double)dv[k] > s[k]) {\n s[k] += step;\n if (s[k] < 0.0) s[k] = 0.0;\n if (s[k] > SKILL_MAX) s[k] = SKILL_MAX;\n }\n }\n }\n }\n };\n\n int day = 0;\n const int MAX_CAND = 400; // number of candidate tasks per day to consider\n\n while (true) {\n day++;\n\n // Compute available tasks (not started and all prerequisites done)\n vector available;\n if (tasksDone < N) {\n available.reserve(N);\n for (int i = 0; i < N; ++i) {\n if (state[i] == NOT_STARTED && degRem[i] == 0) {\n available.push_back(i);\n }\n }\n }\n\n // Collect free workers\n vector freeWorkers;\n freeWorkers.reserve(M);\n for (int j = 0; j < M; ++j) {\n if (curTask[j] == -1) freeWorkers.push_back(j);\n }\n\n vector> assigns; // (worker, task)\n\n if (!freeWorkers.empty() && !available.empty()) {\n // Sort available tasks by priority: depth desc, diffL1 desc, id asc\n auto cmpTask = [&](int x, int y) {\n if (depth[x] != depth[y]) return depth[x] > depth[y];\n if (diffL1[x] != diffL1[y]) return diffL1[x] > diffL1[y];\n return x < y;\n };\n\n int sz = (int)available.size();\n if (sz > MAX_CAND) {\n int limit = MAX_CAND;\n partial_sort(available.begin(), available.begin() + limit,\n available.end(), cmpTask);\n available.resize(limit);\n sz = limit;\n } else {\n sort(available.begin(), available.end(), cmpTask);\n }\n\n // Build all (worker, task) options with predicted cost = t_pred\n struct Option {\n double cost;\n int w;\n int task;\n };\n vector