Add files using upload-large-folder tool

.claude/skills/dataclaw/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: dataclaw
+description: >
+  Export Claude Code, Codex, Gemini CLI, OpenCode, and OpenClaw conversation history to Hugging Face.
+  Use when the user asks about exporting conversations, uploading to Hugging Face,
+  configuring DataClaw, reviewing PII/secrets in exports, or managing their dataset.
+allowed-tools: Bash(dataclaw *), Bash(huggingface-cli login *), Bash(pip install dataclaw*), Bash(grep *)
+---
+
+<!-- dataclaw-begin -->
+
+# DataClaw Skill
+
+## THE RULE
+
+**Every `dataclaw` command outputs `next_steps`. FOLLOW THEM.**
+
+Do not memorize the flow. Do not skip steps. Do not improvise.
+Run the command → read the output → follow `next_steps`. That's it.
+
+The CLI tracks your stage (1-4: auth → configure → review → done).
+`dataclaw export` (push) is **gated** — you must run `dataclaw confirm` first or it will refuse.
+
+## Getting Started
+
+Run `dataclaw status` (or `dataclaw prep` for full details) and follow the `next_steps`.
+
+## Output Format
+
+- `dataclaw prep`, `dataclaw config`, `dataclaw status`, and `dataclaw confirm` output pure JSON
+- `dataclaw export` outputs human-readable text followed by `---DATACLAW_JSON---` and a JSON block
+- Always parse the JSON and act on `next_steps`
+
+Key fields:
+- `stage` / `stage_number` / `total_stages` — where you are
+- `next_steps` — follow these in order
+- `next_command` — the single most important command to run next (null if user input needed first)
+
+## PII Audit (Stage 3)
+
+After `dataclaw export --no-push`, follow the `next_steps` in the JSON output. The flow is:
+
+1. **Ask the user their full name** — then grep the export for it
+2. **Run the pii_commands** from the JSON output and review results with the user
+3. **Ask the user what else to look for** — company names, client names, private URLs, other people's names, custom domains
+4. **Deep manual scan** — sample ~20 sessions (beginning, middle, end) and look for anything sensitive the regex missed
+5. **Fix and re-export** if anything found: `dataclaw config --redact "string"` then `dataclaw export --no-push`
+6. **Run `dataclaw confirm` with text attestations** — pass `--full-name`, `--attest-full-name`, `--attest-sensitive`, and `--attest-manual-scan`. It runs PII scan, verifies attestations, shows project breakdown, and unlocks pushing.
+7. **Push only after explicit user confirmation**: `dataclaw export --publish-attestation "User explicitly approved publishing to Hugging Face."`
+
+## Commands Reference
+
+```bash
+dataclaw status                            # Show current stage and next steps (JSON)
+dataclaw prep                              # Discover projects, check HF auth (JSON)
+dataclaw prep --source all                 # All sources (Claude + Codex + Gemini + OpenCode + OpenClaw)
+dataclaw prep --source claude              # Only Claude Code sessions
+dataclaw prep --source codex               # Only Codex sessions
+dataclaw prep --source gemini              # Only Gemini CLI sessions
+dataclaw prep --source opencode            # Only OpenCode sessions
+dataclaw prep --source openclaw            # Only OpenClaw sessions
+dataclaw confirm --full-name "NAME" --attest-full-name "..." --attest-sensitive "..." --attest-manual-scan "..." # Scan PII, verify attestations, unlock pushing (JSON)
+dataclaw confirm --file /path/to/file.jsonl --full-name "NAME" --attest-full-name "..." --attest-sensitive "..." --attest-manual-scan "..." # Confirm a specific export file
+dataclaw list                              # List all projects with exclusion status
+dataclaw list --source all                 # List all sources
+dataclaw list --source codex               # List only Codex projects
+dataclaw config                            # Show current config
+dataclaw config --repo user/my-dataset     # Set HF repo
+dataclaw config --source all               # REQUIRED source scope: claude|codex|gemini|opencode|openclaw|all
+dataclaw config --exclude "a,b"            # Add excluded projects (appends)
+dataclaw config --redact "str1,str2"       # Add strings to redact (appends)
+dataclaw config --redact-usernames "u1,u2" # Add usernames to anonymize (appends)
+dataclaw config --confirm-projects         # Mark project selection as confirmed
+dataclaw export --publish-attestation "..." # Export and push (requires dataclaw confirm first)
+dataclaw export --no-push                  # Export locally only
+dataclaw export --source all --no-push     # Export all sources locally
+dataclaw export --source codex --no-push   # Export only Codex sessions
+dataclaw export --source claude --no-push  # Export only Claude Code sessions
+dataclaw export --source gemini --no-push  # Export only Gemini CLI sessions
+dataclaw export --source opencode --no-push # Export only OpenCode sessions
+dataclaw export --source openclaw --no-push # Export only OpenClaw sessions
+dataclaw export --all-projects             # Include everything (ignore exclusions)
+dataclaw export --no-thinking              # Exclude extended thinking blocks
+dataclaw export -o /path/to/file.jsonl     # Custom output path
+dataclaw update-skill claude               # Install/update the dataclaw skill for Claude Code
+```
+
+## Gotchas
+
+- **Never run bare `huggingface-cli login`** — it's interactive and will hang. Always use `--token`.
+- **`--exclude`, `--redact`, `--redact-usernames` APPEND** — they never overwrite. Safe to call repeatedly.
+- **Source selection is REQUIRED before export** — explicitly set `dataclaw config --source claude|codex|gemini|opencode|openclaw|all` (or pass `--source ...` on export).
+- **`dataclaw prep` outputs pure JSON** — parse it directly.
+- **Always export with `--no-push` first** — review before publishing.
+- **`dataclaw export` (push) requires `dataclaw confirm` first** — it will refuse otherwise. Re-exporting with `--no-push` resets this.
+- **PII audit is critical** — automated redaction is not foolproof.
+- **Large exports take time** — 500+ sessions may take 1-3 minutes. Use a generous timeout.
+
+## Prerequisite
+
+`command -v dataclaw >/dev/null 2>&1 && echo "dataclaw: installed" || echo "NOT INSTALLED — run: pip install dataclaw"`
+
+<!-- dataclaw-end -->

docker_space/frontier_cs_0_polyomino/0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "deny": [
+      "WebFetch",
+      "WebSearch"
+    ]
+  }
+}

docker_space/frontier_cs_0_polyomino/0/INSTRUCTION.md

@@ -0,0 +1,89 @@
+# Polyomino Packing — Evolutionary Optimization Agent
+
+You are an autonomous optimization agent. Your goal is to iteratively evolve a C++ solution for the Polyomino Packing problem to achieve the highest possible score.
+
+## Problem
+
+Read `statement.txt` for the full problem description. In short: pack n polyominoes (each 1-10 cells) into a W×H rectangle with no overlaps, minimizing area. Score = 1e5 * Σk_i / (W*H), higher is better. There are 70 test cases with n ranging from 100 to 10000.
+
+## Evaluation
+
+See `evaluate.md` for the full API reference. Quick summary:
+
+```bash
+# Submit
+SID=$(curl -s -X POST http://Competitive-Programming:8081/submit \
+  -F "code=@/workspace/solution.cpp" -F "pid=0" -F "lang=cpp" \
+  | python3 -c "import sys,json; print(json.load(sys.stdin)['sid'])")
+
+# Poll (repeat until status is "done" or "error")
+curl -s http://Competitive-Programming:8081/result/$SID
+```
+
+- Time limit: 2s per test case, Memory limit: 256MB
+- Solution must be a single self-contained C++ file
+
+## Your Workflow
+
+Follow this evolutionary loop:
+
+### 1. Initialize
+- Start from `examples/reference.cpp` as the baseline solution
+- Copy it to `/workspace/solution.cpp`
+- Evaluate it to get the baseline score
+- Record it in the log
+
+### 2. Evolve (repeat for many generations)
+
+For each generation:
+
+1. **Analyze** the current best solution — understand its algorithm, identify bottlenecks and weaknesses
+2. **Mutate** — apply ONE meaningful improvement. Ideas include:
+   - Better packing heuristics (bottom-left, skyline, shelf, guillotine)
+   - Smarter piece ordering (sort by area, by shape complexity, by bounding box)
+   - Better rotation/reflection selection per piece
+   - Local search / simulated annealing to improve placement
+   - Tighter bounding box estimation
+   - Better data structures for collision detection
+   - Time-aware optimization (use remaining time budget for local search)
+3. **Write** the mutated solution to `/workspace/solution.cpp`
+4. **Evaluate** — submit to judge and get the score
+5. **Select**:
+   - If score improved → keep the new solution as the current best
+   - If score decreased or errored → revert to the previous best
+6. **Log** the result (see below)
+
+### 3. Exploration vs Exploitation
+- Don't just make small tweaks. Periodically try bold algorithmic changes
+- If stuck at a plateau for 3+ generations, try a fundamentally different approach
+- Consider maintaining 2-3 alternative solution strategies and switching between them
+- Learn from failed attempts — record what didn't work and why
+
+## Logging
+
+Create `/workspace/logs/` directory. For each generation, append to `/workspace/logs/evolution.log`:
+
+```
+Gen <N> | Score: <score> | Best: <best_score> | Status: <improved/reverted/error> | Change: <brief description>
+```
+
+Also save each generation's solution:
+```
+/workspace/logs/gen_<N>.cpp
+```
+
+Save the current best solution at `/workspace/best.cpp` at all times.
+
+## Important Rules
+
+1. **Never read testdata/** — solve the problem algorithmically, do not hardcode answers
+2. **Always keep a backup** of the current best before mutating
+3. **The solution must compile and run correctly** — syntax errors waste a generation
+4. **Stay within time/memory limits** — 2s per test, 256MB memory
+5. **Each solution must be a single .cpp file** — no external dependencies beyond standard library
+6. **Aim for at least 50 generations** — keep going as long as you're making progress
+7. **Be systematic** — don't repeat failed approaches, learn from each generation
+
+## Getting Started
+
+Begin now. Initialize from the reference solution, evaluate it, then start evolving.

docker_space/frontier_cs_0_polyomino/0/best/evolution.log

@@ -0,0 +1,24 @@
+Gen 0 | Score: 86.46 | Best: 86.46 | Status: baseline | Change: reference.cpp (rectangular, all WA due to W!=H)
+Gen 1 | Score: 60.92 | Best: 86.46 | Status: reverted | Change: square packing attempt, too slow (TLE)
+Gen 2 | Score: 77.77 | Best: 77.77 | Status: improved | Change: x-step optimization, 4 TLE
+Gen 3 | Score: 71.83 | Best: 77.77 | Status: reverted | Change: binary search approach, worse quality
+Gen 4 | Score: 81.90 | Best: 81.90 | Status: improved | Change: better time mgmt, xMaxPos by size
+Gen 5 | Score: 83.72 | Best: 83.72 | Status: improved | Change: xMaxPos=200, strict per-call budget, 0 TLE
+Gen 6 | Score: 82.31 | Best: 83.72 | Status: reverted | Change: multi-ordering+sqMode, 1 TLE
+Gen 7 | Score: 81.86 | Best: 83.72 | Status: reverted | Change: xMaxPos=50 for more dynLIM, worse quality
+Gen 8 | Score: 83.10 | Best: 83.72 | Status: reverted | Change: adaptive W2, 1 TLE (case 3)
+Gen 9 | Score: 83.08 | Best: 83.72 | Status: reverted | Change: tighter time mgmt, still 1 TLE
+Gen 10 | Score: 79.70 | Best: 83.72 | Status: reverted | Change: S>5000 threshold, 4 TLE
+Gen 11 | Score: 83.66 | Best: 83.72 | Status: reverted | Change: gen5+W2 post-opt, close but no gain
+Gen 12 | Score: 82.78 | Best: 83.72 | Status: reverted | Change: hybrid S>15000, 1 TLE (case 3)
+Gen 13 | Score: 83.72 | Best: 83.72 | Status: improved | Change: fix big threshold S>3000, hybrid S>15000 adaptive, 0 TLE
+Gen 14 | Score: 84.20 | Best: 84.20 | Status: improved | Change: lower large threshold to S>10000, more cases get adaptive W2
+Gen 15 | Score: 84.34 | Best: 84.34 | Status: improved | Change: lower threshold to S>7000
+Gen 16 | Score: 84.89 | Best: 84.89 | Status: improved | Change: lower threshold to S>5000, case 3 huge improvement
+Gen 21 | Score: 88.81 | Best: 88.81 | Status: improved | Change: reference solution with TL=1880, TLms=1800, big=S>3000. Rectangular packing (no W=H)
+Gen 22 | Score: 89.02 | Best: 89.02 | Status: improved | Change: wider span, adaptive W2 post-opt
+Gen 23 | Score: 88.99 | Best: 89.02 | Status: reverted | Change: W3 pass hurt 5 cases
+Gen 24 | Score: 89.10 | Best: 89.10 | Status: improved | Change: random tie-breaking trials at best width
+Gen 25 | Score: 89.21 | Best: 89.21 | Status: improved | Change: multi-width random trials
+Gen 26 | Score: 89.11 | Best: 89.21 | Status: reverted | Change: wider trial range hurt
+Gen 27 | Score: 88.84-89.12 (3 runs) | Best: ~89.0 | Status: improved stability | Change: TL=1800, TLms=1700, trial check avg*2.0. 0 TLE across 3 runs

docker_space/frontier_cs_0_polyomino/0/best/score.txt

@@ -0,0 +1,12 @@
+Best Score: 89.21 (Gen 25 peak)
+Stable Score: 88.84 - 89.12 (Gen 27, 0 TLE across 3 runs)
+
+Current best.cpp: Gen 27 (stable version)
+- TL=1800ms, TLms=1700ms, big threshold S>3000
+- Rectangular packing (W*H minimization, no W=H constraint)
+- Adaptive W2 post-optimization
+- Random tie-breaking trials at multiple widths
+
+Key metrics (Gen 27 average):
+- 70 test cases, 0 TLE
+- Min ratio: ~0.85, Max ratio: ~0.94, Avg ratio: ~0.89

docker_space/frontier_cs_0_polyomino/0/best/solution.cpp

@@ -0,0 +1,337 @@
+/*
+SOURCE: Shang Zhou
+IIMOC SUBMISSION #1443
+HUMAN BEST FOR POLYPACK (TRANSFORMATION OUTPUT FORMAT)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+    auto ord4 = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>3000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1700:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            int limCnt=max(1,dynLIM);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(bds2<bds) take=true;
+                    else if(bds2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=bds2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+    double factor;
+    if (S < 1000) {
+        factor = 0.4;
+    } else if (S < 3000) {
+        factor = 0.5;
+    } else if (S < 10000) {
+        factor = 0.27;
+    } else if (S < 30000) {
+        factor = 0.08;
+    } else {
+        factor = 0.01;
+    }
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(128,max(30,base));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1800.0;
+    double avg=250.0; int cnt=0;
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used=chrono::duration<double,milli>(now-t0).count();
+        if(used+avg*1.3>TL) break;
+        int W=Ws[wi];
+        vector<vector<int>> orders;
+        orders.push_back(ord4());
+        int oi=0;
+        while(oi<(int)orders.size()){
+            auto t1=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(t1-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            R r=pack(W,orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+            oi++;
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord4();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    // Adaptive W2: compute eff-optimal width and try if time remains
+    if(hasBestmine && bestW>0 && bestH>0){
+        auto now=chrono::steady_clock::now();
+        double used=chrono::duration<double,milli>(now-t0).count();
+        if(used+avg*1.3<TL){
+            double eff=(double)S/((double)bestW*bestH);
+            if(eff>0.3&&eff<1.0){
+                // Optimal width for eff: W*H = S/eff, with H = S/(W*eff)
+                // Want to find W that minimizes W*H given eff varies
+                // Use current eff estimate: try W2 = S/bestH (so that H2 ≈ bestW)
+                int W2=max(minW,(int)max<long long>(minW,S/bestH));
+                if(abs(W2-base)>2){
+                    auto o=ord4();
+                    R r=pack(W2,o,rng,false);
+                    if(r.A<bestA||(r.A==bestA&&(r.H<bestH||(r.H==bestH&&r.W<bestW)))){
+                        bestA=r.A;bestW=r.W;bestH=r.H;bestR=r;
+                    }
+                }
+            }
+        }
+    }
+    // Random tie-breaking trials at promising widths with remaining time
+    if(hasBestmine){
+        vector<int> trialWs;
+        trialWs.push_back(base);
+        if(bestH>0){int w2=max(minW,(int)max<long long>(minW,S/bestH));if(w2!=base)trialWs.push_back(w2);}
+        trialWs.push_back(max(minW,base-1));
+        trialWs.push_back(base+1);
+        int ti=0;
+        for(auto now=chrono::steady_clock::now();
+            chrono::duration<double,milli>(now-t0).count()+avg*2.0<TL;
+            now=chrono::steady_clock::now()){
+            int W=trialWs[ti%trialWs.size()];ti++;
+            auto o=ord4();
+            R r=pack(W,o,rng,true);
+            if(r.A<bestA||(r.A==bestA&&(r.H<bestH||(r.H==bestH&&r.W<bestW)))){
+                bestA=r.A;bestW=r.W;bestH=r.H;bestR=r;
+            }
+        }
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino/0/chk.cc

@@ -0,0 +1,152 @@
+// Polyomino Packing (Reflections Allowed) — Checker (updated to new statement)
+// Uses testlib: https://codeforces.com/blog/entry/18431
+//
+// Validates a participant's output for a single test case.
+//
+// Problem statement deltas reflected here:
+//   - n ∈ [100, 10000]
+//   - k_i ∈ [1, 10]
+//   - Σk_i ≤ 2000  (enforced)
+//   - Scoring per test: score = 1e5 * (Σk_i) / (W*H)   (higher is better)
+//
+// Input (from problem):
+//   Line 1: n
+//   For each i=1..n:
+//     Line: k_i
+//     Next k_i lines: x y   (integers; define a polyomino in local coords)
+//
+// Output (participant):
+//   Line 1: W H
+//   Then n lines (one per polyomino i):
+//     X_i Y_i R_i F_i
+//       R_i ∈ {0,1,2,3} = # of 90° clockwise rotations
+//       F_i ∈ {0,1}     = reflection flag (1 = reflect across y-axis)
+// Transform order (must): reflect → rotate → translate.
+//
+// Checks performed:
+//   - Token counts and ranges (R_i, F_i in valid sets)
+//   - After transform, every cell in [0, W) × [0, H)
+//   - No overlapping occupied grid cells between pieces
+// Scoring message: Score = Σk_i / (W*H)
+
+#include "testlib.h"
+#include <bits/stdc++.h>
+using namespace std;
+
+struct CellHash {
+    size_t operator()(const pair<long long,long long>& p) const noexcept {
+        uint64_t x = static_cast<uint64_t>(p.first);
+        uint64_t y = static_cast<uint64_t>(p.second);
+        // splitmix-style mixing
+        x ^= y + 0x9e3779b97f4a7c15ULL + (x<<6) + (x>>2);
+        x ^= x >> 30; x *= 0xbf58476d1ce4e5b9ULL;
+        x ^= x >> 27; x *= 0x94d049bb133111ebULL;
+        x ^= x >> 31;
+        return static_cast<size_t>(x);
+    }
+};
+
+static inline pair<long long,long long> rot90cw(long long x, long long y, int r) {
+    switch (r & 3) {
+        case 0:  return { x,  y};
+        case 1:  return { y, -x};
+        case 2:  return {-x, -y};
+        default: return {-y,  x};
+    }
+}
+
+int main(int argc, char* argv[]) {
+    registerTestlibCmd(argc, argv);
+
+    // ===== Read input =====
+    const int n = inf.readInt(100, 10000, "n");
+
+    vector<vector<pair<long long,long long>>> shapes(n);
+    long long totalCells = 0;
+
+    for (int i = 0; i < n; ++i) {
+        int k = inf.readInt(1, 10, "k_i");
+        shapes[i].reserve(k);
+        for (int j = 0; j < k; ++j) {
+            long long x = inf.readLong(numeric_limits<long long>::min()/4,
+                                       numeric_limits<long long>::max()/4, "x_ij");
+            long long y = inf.readLong(numeric_limits<long long>::min()/4,
+                                       numeric_limits<long long>::max()/4, "y_ij");
+            shapes[i].push_back({x, y});
+        }
+        totalCells += k;
+    }
+
+    // ===== Read participant output =====
+    // Allow large W/H to avoid artificial limits; still within signed 64-bit
+    long long W = ouf.readLong(1, (long long)4e12, "W");
+    long long H = ouf.readLong(1, (long long)4e12, "H");
+
+    struct Place { long long X, Y; int R; int F; };
+    vector<Place> place(n);
+    for (int i = 0; i < n; ++i) {
+        long long X = ouf.readLong(-(long long)4e12, (long long)4e12, "X_i");
+        long long Y = ouf.readLong(-(long long)4e12, (long long)4e12, "Y_i");
+        int R = ouf.readInt(0, 3, "R_i");
+        int F = ouf.readInt(0, 1, "F_i");
+        place[i] = {X, Y, R, F};
+    }
+
+    if (!ouf.seekEof()) {
+        quitf(_pe, "Extra data after expected %d placement lines", n);
+    }
+
+    // ===== Validate placement =====
+    unordered_set<pair<long long,long long>, CellHash> occ;
+    occ.reserve(static_cast<size_t>(max<long long>(16, totalCells * 2)));
+
+    auto inBounds = [&](long long x, long long y) -> bool {
+        return x >= 0 && y >= 0 && x < W && y < H;
+    };
+
+    for (int i = 0; i < n; ++i) {
+        const auto [X, Y, R, F] = place[i];
+        for (const auto& c : shapes[i]) {
+            long long sx = c.first, sy = c.second;
+
+            // reflect across y-axis if F=1: (x, y) -> (-x, y)
+            long long rx = (F == 1 ? -sx : sx);
+            long long ry = sy;
+
+            // rotate r times 90° CW about origin
+            auto [qx, qy] = rot90cw(rx, ry, R);
+
+            // translate by (X, Y) with overflow checks
+            long long gx, gy;
+            if (__builtin_add_overflow(qx, X, &gx) ||
+                __builtin_add_overflow(qy, Y, &gy)) {
+                quitf(_wa, "Overflow after transforming piece %d", i+1);
+            }
+
+            if (!inBounds(gx, gy)) {
+                quitf(_wa,
+                      "Out of bounds: piece %d cell -> (%lld,%lld) not in [0,%lld)×[0,%lld)",
+                      i+1, gx, gy, W, H);
+            }
+
+            auto ins = occ.insert({gx, gy});
+            if (!ins.second) {
+                quitf(_wa, "Overlap at cell (%lld,%lld)", gx, gy);
+            }
+        }
+    }
+
+    // ===== Scoring message =====
+    // Use 128-bit to avoid overflow in W*H
+    __int128 area128 = (__int128)W * (__int128)H;
+    if (area128 <= 0) quitf(_wa, "Non-positive area (W*H)");
+    long long area;
+    if (area128 > numeric_limits<long long>::max())
+        quitf(_wa, "Area overflow: W*H exceeds 64-bit");
+    area = (long long)area128;
+
+    double score = (double) totalCells / (double) area;
+    // Include "Ratio:" in message so judge system can parse the partial score
+    quitp(score, "Ratio: %.9f (cells=%lld, W=%lld, H=%lld, area=%lld)",
+          score, totalCells, W, H, area);
+}

docker_space/frontier_cs_0_polyomino/0/config.yaml

@@ -0,0 +1,12 @@
+
+type: default
+checker: chk.cc
+
+# Time and memory limits still apply to the contestant's solution
+time: 2s
+memory: 256m
+
+# The subtasks section works the same way
+subtasks:
+- score: 100
+  n_cases: 70

docker_space/frontier_cs_0_polyomino/0/evaluate.md

@@ -0,0 +1,76 @@
+# Evaluation Guide (Inside Container)
+
+## Judge Service
+
+The evaluation runs via a go-judge HTTP service accessible inside the container at:
+
+```
+http://Competitive-Programming:8081
+```
+
+## How to Evaluate a Solution
+
+### Step 1: Submit
+
+```bash
+curl -s -X POST http://Competitive-Programming:8081/submit \
+  -F "code=@solution.cpp" \
+  -F "pid=0" \
+  -F "lang=cpp"
+```
+
+Returns: `{"sid": 1}` — the submission ID.
+
+### Step 2: Poll Result
+
+```bash
+curl -s http://Competitive-Programming:8081/result/<sid>
+```
+
+Poll every 2-3 seconds until `status` is `"done"` or `"error"`.
+
+### Response Format
+
+Success:
+```json
+{
+  "status": "done",
+  "score": 74.84,
+  "scoreUnbounded": 74.84,
+  ...
+}
+```
+
+Error (compile error, runtime error, etc.):
+```json
+{
+  "status": "error",
+  "error": "...",
+  "message": "..."
+}
+```
+
+## Scoring
+
+- Per test case: `score = 1e5 * Σk_i / (W * H)` (higher is better)
+- 70 test cases total, final score is the average across all cases
+- The score is bounded to [0, 100]
+
+## One-Liner Example
+
+```bash
+# Submit and poll
+SID=$(curl -s -X POST http://Competitive-Programming:8081/submit \
+  -F "code=@solution.cpp" -F "pid=0" -F "lang=cpp" | python3 -c "import sys,json; print(json.load(sys.stdin)['sid'])")
+
+# Wait and get result
+sleep 15 && curl -s http://Competitive-Programming:8081/result/$SID | python3 -m json.tool
+```
+
+## Notes
+
+- The solution must be C++ and compile with g++
+- Time limit: 2 seconds per test case
+- Memory limit: 256 MB
+- The judge compiles the solution once, then runs it against all 70 test cases
+- Problem data is in `/workspace/problem/0/` (statement.txt, testdata/, chk.cc)

docker_space/frontier_cs_0_polyomino/0/examples/gpt5.cpp

@@ -0,0 +1,271 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Cell { int x, y; };
+struct Transform { int R, F; }; // reflect (y-axis) then rotate R*90° CW
+struct Oriented {
+    vector<Cell> pts; // normalized: minx=miny=0
+    int w, h;
+    int offx, offy;   // = -minx, -miny (to undo normalization for output)
+    Transform tf;
+};
+struct Piece {
+    int id;
+    vector<Cell> base;
+    vector<Oriented> variants;
+    int area;
+};
+
+static inline uint64_t pack_xy(int x,int y){
+    return (uint64_t(uint32_t(x))<<32) | uint32_t(y);
+}
+static inline pair<int,int> apply_transform(int x,int y,int F,int R){
+    if (F) x = -x;
+    switch (R & 3){
+        case 0: return { x,  y};
+        case 1: return { y, -x}; // 90 CW
+        case 2: return {-x, -y}; // 180
+        default:return {-y,  x}; // 270 CW
+    }
+}
+static Oriented make_oriented(const vector<Cell>& base,int F,int R){
+    vector<Cell> t; t.reserve(base.size());
+    int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+    for (auto &c: base){
+        auto [tx,ty]=apply_transform(c.x,c.y,F,R);
+        minx=min(minx,tx); miny=min(miny,ty);
+        maxx=max(maxx,tx); maxy=max(maxy,ty);
+        t.push_back({tx,ty});
+    }
+    // normalization
+    for (auto &c: t){ c.x -= minx; c.y -= miny; }
+    int W = maxx-minx+1, H = maxy-miny+1;
+    sort(t.begin(), t.end(), [](const Cell&a,const Cell&b){
+        if (a.y!=b.y) return a.y<b.y; return a.x<b.x;
+    });
+    return Oriented{t, W, H, -minx, -miny, Transform{R,F}};
+}
+static void build_variants(Piece& P){
+    vector<Oriented> cand; cand.reserve(8);
+    for (int F=0;F<=1;++F) for (int R=0;R<4;++R)
+        cand.push_back(make_oriented(P.base,F,R));
+    // dedup
+    vector<Oriented> uniq;
+    for (auto &o: cand){
+        bool dup=false;
+        for (auto &u: uniq){
+            if (u.w==o.w && u.h==o.h && u.pts.size()==o.pts.size()){
+                bool same=true;
+                for (size_t i=0;i<u.pts.size();++i)
+                    if (u.pts[i].x!=o.pts[i].x || u.pts[i].y!=o.pts[i].y){ same=false; break; }
+                if (same){ dup=true; break; }
+            }
+        }
+        if (!dup) uniq.push_back(o);
+    }
+    P.variants.swap(uniq);
+}
+
+struct Placement { int X=0,Y=0,R=0,F=0; int w=0,h=0; int vi=-1; }; // vi = variant index used
+struct PackedSolution { int W=0,H=0; vector<Placement> place; };
+
+struct World {
+    int W, Hlimit;                    // square side S; W==Hlimit==S
+    vector<int> height; 
+    unordered_set<uint64_t> occ; 
+    int maxH=0;
+
+    World(int S=1){ clear(S); }
+    void clear(int S){ W=S; Hlimit=S; height.assign(W,0); occ.clear(); maxH=0; }
+
+    inline int shelfY(int x,int w) const {
+        int y=0; for (int i=0;i<w;++i) y=max(y,height[x+i]); return y;
+    }
+    inline bool can_place(const Oriented& o,int X,int Y) const {
+        if (X<0 || Y<0) return false;
+        if (X + o.w > W) return false;
+        if (Y + o.h > Hlimit) return false;       // enforce square height cap
+        for (auto &c: o.pts){
+            int gx=X+c.x, gy=Y+c.y;
+            if (occ.find(pack_xy(gx,gy))!=occ.end()) return false;
+        }
+        return true;
+    }
+    inline void do_place(const Oriented& o,int X,int Y){
+        for (auto &c: o.pts){
+            int gx=X+c.x, gy=Y+c.y;
+            occ.insert(pack_xy(gx,gy));
+            height[gx]=max(height[gx], gy+1);
+            if (height[gx]>maxH) maxH=height[gx];
+        }
+    }
+};
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n; if(!(cin>>n)) return 0;
+    vector<Piece> P(n);
+    long long totalCells=0;
+    for (int i=0;i<n;++i){
+        P[i].id=i;
+        int k; cin>>k;
+        P[i].base.resize(k);
+        for (int j=0;j<k;++j){ int x,y; cin>>x>>y; P[i].base[j]={x,y}; }
+        P[i].area=k; totalCells+=k;
+        build_variants(P[i]);
+    }
+
+    // Place larger / less flexible first
+    vector<int> order(n); iota(order.begin(), order.end(), 0);
+    sort(order.begin(), order.end(), [&](int a,int b){
+        if (P[a].area!=P[b].area) return P[a].area>P[b].area;
+        return P[a].variants.size()<P[b].variants.size();
+    });
+
+    // Lower bound on square side:
+    // 1) area bound
+    int S_area = (int)ceil(sqrt((long double)totalCells));
+    // 2) geometry bound: each piece needs some min side to fit; use min over variants of max(w,h)
+    int S_geom = 1;
+    for (auto &p: P){
+        int need = INT_MAX;
+        for (auto &o: p.variants) need = min(need, max(o.w, o.h));
+        S_geom = max(S_geom, need);
+    }
+    int S0 = max(S_area, S_geom);
+
+    // Generate candidate square sizes; grow if needed
+    vector<int> sides = {
+        S0,
+        max(S0, (int)ceil(1.05*S0)),
+        max(S0, (int)ceil(1.15*S0)),
+        max(S0, (int)ceil(0.95*S0))
+    };
+    sort(sides.begin(), sides.end());
+    sides.erase(unique(sides.begin(), sides.end()), sides.end());
+
+    auto better = [](const PackedSolution& A, const PackedSolution& B){
+        if (B.W==0) return true;
+        long long aA=1LL*A.W*A.H, aB=1LL*B.W*B.H;
+        if (aA!=aB) return aA<aB;
+        // If equal area (same S), prefer lower max column height (tie-breaker, though W=H).
+        if (A.H!=B.H) return A.H<B.H;
+        return A.W<B.W;
+    };
+
+    PackedSolution best; best.W=0; best.H=INT_MAX;
+
+    auto try_with_side = [&](int S)->optional<PackedSolution>{
+        World world(S);
+        world.occ.reserve((size_t)totalCells*2 + 1024);
+        vector<Placement> place(n);
+
+        for (int idx=0; idx<n; ++idx){
+            int i = order[idx];
+            auto &piece = P[i];
+
+            // Favor shorter/taller shapes appropriately
+            vector<int> vord(piece.variants.size());
+            iota(vord.begin(), vord.end(), 0);
+            sort(vord.begin(), vord.end(), [&](int a,int b){
+                const auto&A=piece.variants[a], &B=piece.variants[b];
+                if (A.h!=B.h) return A.h<B.h;
+                if (A.w!=B.w) return A.w>B.w;
+                return A.pts.size()>B.pts.size();
+            });
+
+            int bestVi=-1, bestX=-1, bestY=INT_MAX;
+
+            for (int vi: vord){
+                const auto &o = piece.variants[vi];
+                if (o.w > world.W || o.h > world.Hlimit) continue;
+
+                // x scan (try both coarse step and right align)
+                int step = max(1, o.w/2);
+                for (int x=0; x + o.w <= world.W; x += step){
+                    int y = world.shelfY(x, o.w);
+                    if (y + o.h > world.Hlimit) continue;       // square cap
+                    if (y > bestY) continue;
+                    if (!world.can_place(o, x, y)) continue;
+                    bestY=y; bestX=x; bestVi=vi;
+                }
+                int xr = world.W - o.w;
+                if (xr>=0){
+                    int y = world.shelfY(xr, o.w);
+                    if (y + o.h <= world.Hlimit && y <= bestY && world.can_place(o, xr, y)){
+                        bestY=y; bestX=xr; bestVi=vi;
+                    }
+                }
+            }
+
+            if (bestVi<0) return {}; // fail for this S
+
+            const auto &o = piece.variants[bestVi];
+            world.do_place(o, bestX, bestY);
+            place[i] = {bestX, bestY, o.tf.R, o.tf.F, o.w, o.h, bestVi};
+        }
+
+        // success with this S
+        PackedSolution cand; 
+        cand.W = S; 
+        cand.H = S; // enforce square
+        cand.place.resize(n);
+        for (int i=0;i<n;++i) cand.place[i]=place[i];
+        return cand;
+    };
+
+    // Try preset candidates
+    for (int S : sides){
+        if (auto sol = try_with_side(S)){
+            if (best.W==0 || better(*sol,best)) best=*sol;
+        }
+    }
+
+    // If none worked, escalate S until it does (guaranteed cap: vertical stack height)
+    if (best.W==0){
+        // Safe upper bound: stack piece heights of a chosen variant each
+        int maxW=1, sumH=0;
+        for (auto &p: P){
+            int wmin=INT_MAX, hmin=INT_MAX;
+            for (auto &o: p.variants){
+                wmin = min(wmin, o.w);
+                hmin = min(hmin, o.h);
+            }
+            maxW = max(maxW, wmin);
+            sumH += hmin;
+        }
+        int S = max({S0, maxW, sumH}); // square that trivially fits vertical stack
+        // grow linearly from S0 to S (usually hits long before)
+        for (int s = S0; s <= S; ++s){
+            if (auto sol = try_with_side(s)){ best = *sol; break; }
+        }
+        // If still nothing (extremely unlikely), force a trivial square stack at side S
+        if (best.W==0){
+            int y=0;
+            vector<Placement> pl(n);
+            // Use each piece's first variant
+            for (int i=0;i<n;++i){
+                const auto &o = P[i].variants[0];
+                pl[i]={0,y,o.tf.R,o.tf.F,o.w,o.h,0};
+                y += o.h;
+            }
+            int Sforce = max({S, y, maxW});
+            best.W = best.H = Sforce;
+            best.place = move(pl);
+        }
+    }
+
+    // ---- OUTPUT with offset compensation ----
+    cout << best.W << " " << best.H << "\n";
+    for (int i=0;i<n;++i){
+        const auto &pl = best.place[i];
+        const auto &o  = P[i].variants[pl.vi];
+        // t = (X - minx, Y - miny) = (X + offx, Y + offy)
+        int Xout = pl.X + o.offx;
+        int Yout = pl.Y + o.offy;
+        cout << Xout << " " << Yout << " " << pl.R << " " << pl.F << "\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino/0/examples/reference.cpp

@@ -0,0 +1,297 @@
+/*
+SOURCE: Shang Zhou
+IIMOC SUBMISSION #1443
+HUMAN BEST FOR POLYPACK (TRANSFORMATION OUTPUT FORMAT)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+    auto ord4 = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            int limCnt=max(1,dynLIM);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(bds2<bds) take=true;
+                    else if(bds2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=bds2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+    double factor;
+    if (S < 1000) {
+        factor = 0.4;
+    } else if (S < 3000) {
+        factor = 0.5;
+    } else if (S < 10000) {
+        factor = 0.27;
+    } else if (S < 30000) {
+        factor = 0.08;
+    } else {
+        factor = 0.01;
+    }
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used=chrono::duration<double,milli>(now-t0).count();
+        if(used+avg*1.3>TL) break;
+        int W=Ws[wi];
+        vector<vector<int>> orders;
+        orders.push_back(ord4());
+        int oi=0;
+        while(oi<(int)orders.size()){
+            auto t1=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(t1-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            R r=pack(W,orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+            oi++;
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord4();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino/0/statement.txt

@@ -0,0 +1,107 @@
+# Pack the Polyominoes (Reflections Allowed)
+
+## Problem
+You are given a set of n polyominoes placed on a unit square grid. Each polyomino consists of between 1 and 10 unit cells, connected edge-to-edge (4-connectivity). Your task is to place all polyominoes—allowing **rotations, reflections, and translations**—into an axis-aligned rectangle of the grid with no overlaps and no cells outside the rectangle, minimizing the rectangle’s area.
+
+A placement specifies, for every polyomino, an integer translation, an optional reflection, and a rotation by a multiple of 90°, such that:
+
+- every cell lands on integer grid coordinates,
+- no two placed cells overlap,
+- all placed cells lie within a single axis-aligned rectangle of width W and height H.
+
+The objective is to minimize A = W × H. In case of ties on area, prefer smaller H, then smaller W.
+
+---
+
+## Input Format
+- Line 1: integer n (100 <= n <= 10^4) — number of polyominoes.  
+- For each polyomino i = 1 … n:
+  - One line: integer kᵢ (1 ≤ kᵢ ≤ 10) — number of cells.
+  - Next kᵢ lines: two integers xᵢⱼ, yᵢⱼ — cell coordinates in the polyomino’s local frame.  
+    These coordinates define a 4-connected polyomino.
+
+Notes:
+- Coordinates may be negative.
+- Shapes may have internal holes.
+- Shapes are defined by structure; initial placement does not matter.
+
+---
+
+## Output Format
+- Line 1: two integers W and H — width and height of the chosen rectangle.
+- Then n lines — one per polyomino i, each containing:
+$$X_i\ Y_i\ R_i\ F_i$$
+
+Where:
+- (Xᵢ, Yᵢ): integer translation  
+- Rᵢ ∈ {0,1,2,3}: number of 90° clockwise rotations  
+- Fᵢ ∈ {0,1}: reflection flag (**1 = reflect across the y-axis before rotation**, 0 = no reflection)
+
+All transformed cells must satisfy:
+0 ≤ xᵢⱼ′ < W, 0 ≤ yᵢⱼ′ < H, W=H
+
+---
+
+## Rules
+1. All cells occupy unit squares with integer coordinates.  
+2. **Allowed transforms: reflection (optional) → rotation (0°, 90°, 180°, 270°) → translation (in that order).**  
+3. Distinct polyomino cells must not overlap.  
+4. Every cell must lie inside [0, W) × [0, H).  
+5. Scoring: Minimize A = W × H.
+
+---
+
+## Constraints
+- 100 ≤ n ≤ 10000
+- 1 ≤ kᵢ ≤ 10  
+
+---
+
+## Validation
+A solution is valid if:
+- All rules are satisfied.  
+- The judge verifies non-overlap and bounding-box compliance.
+
+---
+
+## Scoring (for heuristic / leaderboard contests)
+- Per test case: score = 1e5*Σkᵢ/A
+- Any invalid test case → entire submission rejected
+
+---
+
+## Example
+
+Input
+```
+3
+1
+0 0
+3
+0 0
+1 0
+0 1
+4
+0 0
+1 0
+0 1
+1 1
+```
+
+Output
+```
+3 3
+0 0 0 0
+2 0 1 0
+1 1 0 0
+```
+
+This places the monomino at (0,0), rotates the triomino by 90° (R=1), and fits all shapes into a 3×3 rectangle. (Reflections are allowed, but not used in this example: F=0.)
+
+---
+
+## Generation
+
+Let $S$ be the set of all pieces from size 1-10. Each piece is chosen uniformly at random with replacement from $S$. 
+
+$n$ is chosen as $10^p$, where $p \sim U(2, 4)$.

docker_space/frontier_cs_0_polyomino_ev2/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "deny": [
+      "WebSearch",
+      "WebFetch"
+    ]
+  }
+}

docker_space/frontier_cs_0_polyomino_ev2/best/best.cpp

@@ -0,0 +1,535 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        bool big2=(S>7000);
+        int maxBound=max(1,n/4);
+        int expLIM2=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big2?expLIM2:maxBound;
+        bool gapEnabled=true;
+        auto gpTStart=chrono::steady_clock::now();
+        auto gpBatchStart=gpTStart;
+        long long gpTLms=big2?1800:LLONG_MAX/4;
+        int gpStepCnt=0;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/max(1,dynLIM))):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+            gpStepCnt++;
+            if(big2&&gpStepCnt==5){
+                auto gpNow=chrono::steady_clock::now();
+                auto gpElapsed=chrono::duration<double,milli>(gpNow-gpTStart).count();
+                auto gpBatch=chrono::duration<double,milli>(gpNow-gpBatchStart).count();
+                double gpRemT=max(0.0,(double)gpTLms-gpElapsed);
+                int gpRemSteps=max(1,nm-t2);
+                double gpBudget=gpRemT*5.0/gpRemSteps;
+                if(gpBatch<gpBudget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                gpBatchStart=gpNow;
+                gpStepCnt=0;
+            }
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare orderings - fewer for gap packer (slower per call)
+    bool useGapPacker = (S < 12000);
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    if(!useGapPacker){
+        base_orders.push_back(ord_desc_area());
+        base_orders.push_back(ord_desc_maxdim());
+        base_orders.push_back(ord_desc_bbox());
+        base_orders.push_back(ord_flexibility());
+    }
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        int maxRandom = useGapPacker ? 1 : 4;
+        for(int ri=0;ri<maxRandom;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/best/scores.txt

@@ -0,0 +1,14 @@
+Best confirmed score: ~90.4 (varies 90.3-90.4 due to RNG)
+Average ratio: 0.904
+Min ratio: 0.873
+Max ratio: 0.949
+
+Improvement from baseline: 85.19 -> 90.4 (+5.2 points, +6.1%)
+
+Key techniques:
+1. Multiple orderings (5 for skyline, 1 for gap packer) with perturbation restarts
+2. Waste-based between-piece scoring (dsum - k instead of dsum)
+3. Early lookahead boost (3x for first 10% of pieces)
+4. Gap-filling bitmap packer for S < 12000 (scans 3 rows below skyline)
+5. Adaptive time management with dynLIM for medium inputs
+6. 1 ordering + 1 random restart per width for gap packer (maximizes width diversity)

docker_space/frontier_cs_0_polyomino_ev2/examples/gpt5.cpp

@@ -0,0 +1,271 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Cell { int x, y; };
+struct Transform { int R, F; }; // reflect (y-axis) then rotate R*90° CW
+struct Oriented {
+    vector<Cell> pts; // normalized: minx=miny=0
+    int w, h;
+    int offx, offy;   // = -minx, -miny (to undo normalization for output)
+    Transform tf;
+};
+struct Piece {
+    int id;
+    vector<Cell> base;
+    vector<Oriented> variants;
+    int area;
+};
+
+static inline uint64_t pack_xy(int x,int y){
+    return (uint64_t(uint32_t(x))<<32) | uint32_t(y);
+}
+static inline pair<int,int> apply_transform(int x,int y,int F,int R){
+    if (F) x = -x;
+    switch (R & 3){
+        case 0: return { x,  y};
+        case 1: return { y, -x}; // 90 CW
+        case 2: return {-x, -y}; // 180
+        default:return {-y,  x}; // 270 CW
+    }
+}
+static Oriented make_oriented(const vector<Cell>& base,int F,int R){
+    vector<Cell> t; t.reserve(base.size());
+    int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+    for (auto &c: base){
+        auto [tx,ty]=apply_transform(c.x,c.y,F,R);
+        minx=min(minx,tx); miny=min(miny,ty);
+        maxx=max(maxx,tx); maxy=max(maxy,ty);
+        t.push_back({tx,ty});
+    }
+    // normalization
+    for (auto &c: t){ c.x -= minx; c.y -= miny; }
+    int W = maxx-minx+1, H = maxy-miny+1;
+    sort(t.begin(), t.end(), [](const Cell&a,const Cell&b){
+        if (a.y!=b.y) return a.y<b.y; return a.x<b.x;
+    });
+    return Oriented{t, W, H, -minx, -miny, Transform{R,F}};
+}
+static void build_variants(Piece& P){
+    vector<Oriented> cand; cand.reserve(8);
+    for (int F=0;F<=1;++F) for (int R=0;R<4;++R)
+        cand.push_back(make_oriented(P.base,F,R));
+    // dedup
+    vector<Oriented> uniq;
+    for (auto &o: cand){
+        bool dup=false;
+        for (auto &u: uniq){
+            if (u.w==o.w && u.h==o.h && u.pts.size()==o.pts.size()){
+                bool same=true;
+                for (size_t i=0;i<u.pts.size();++i)
+                    if (u.pts[i].x!=o.pts[i].x || u.pts[i].y!=o.pts[i].y){ same=false; break; }
+                if (same){ dup=true; break; }
+            }
+        }
+        if (!dup) uniq.push_back(o);
+    }
+    P.variants.swap(uniq);
+}
+
+struct Placement { int X=0,Y=0,R=0,F=0; int w=0,h=0; int vi=-1; }; // vi = variant index used
+struct PackedSolution { int W=0,H=0; vector<Placement> place; };
+
+struct World {
+    int W, Hlimit;                    // square side S; W==Hlimit==S
+    vector<int> height; 
+    unordered_set<uint64_t> occ; 
+    int maxH=0;
+
+    World(int S=1){ clear(S); }
+    void clear(int S){ W=S; Hlimit=S; height.assign(W,0); occ.clear(); maxH=0; }
+
+    inline int shelfY(int x,int w) const {
+        int y=0; for (int i=0;i<w;++i) y=max(y,height[x+i]); return y;
+    }
+    inline bool can_place(const Oriented& o,int X,int Y) const {
+        if (X<0 || Y<0) return false;
+        if (X + o.w > W) return false;
+        if (Y + o.h > Hlimit) return false;       // enforce square height cap
+        for (auto &c: o.pts){
+            int gx=X+c.x, gy=Y+c.y;
+            if (occ.find(pack_xy(gx,gy))!=occ.end()) return false;
+        }
+        return true;
+    }
+    inline void do_place(const Oriented& o,int X,int Y){
+        for (auto &c: o.pts){
+            int gx=X+c.x, gy=Y+c.y;
+            occ.insert(pack_xy(gx,gy));
+            height[gx]=max(height[gx], gy+1);
+            if (height[gx]>maxH) maxH=height[gx];
+        }
+    }
+};
+
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    int n; if(!(cin>>n)) return 0;
+    vector<Piece> P(n);
+    long long totalCells=0;
+    for (int i=0;i<n;++i){
+        P[i].id=i;
+        int k; cin>>k;
+        P[i].base.resize(k);
+        for (int j=0;j<k;++j){ int x,y; cin>>x>>y; P[i].base[j]={x,y}; }
+        P[i].area=k; totalCells+=k;
+        build_variants(P[i]);
+    }
+
+    // Place larger / less flexible first
+    vector<int> order(n); iota(order.begin(), order.end(), 0);
+    sort(order.begin(), order.end(), [&](int a,int b){
+        if (P[a].area!=P[b].area) return P[a].area>P[b].area;
+        return P[a].variants.size()<P[b].variants.size();
+    });
+
+    // Lower bound on square side:
+    // 1) area bound
+    int S_area = (int)ceil(sqrt((long double)totalCells));
+    // 2) geometry bound: each piece needs some min side to fit; use min over variants of max(w,h)
+    int S_geom = 1;
+    for (auto &p: P){
+        int need = INT_MAX;
+        for (auto &o: p.variants) need = min(need, max(o.w, o.h));
+        S_geom = max(S_geom, need);
+    }
+    int S0 = max(S_area, S_geom);
+
+    // Generate candidate square sizes; grow if needed
+    vector<int> sides = {
+        S0,
+        max(S0, (int)ceil(1.05*S0)),
+        max(S0, (int)ceil(1.15*S0)),
+        max(S0, (int)ceil(0.95*S0))
+    };
+    sort(sides.begin(), sides.end());
+    sides.erase(unique(sides.begin(), sides.end()), sides.end());
+
+    auto better = [](const PackedSolution& A, const PackedSolution& B){
+        if (B.W==0) return true;
+        long long aA=1LL*A.W*A.H, aB=1LL*B.W*B.H;
+        if (aA!=aB) return aA<aB;
+        // If equal area (same S), prefer lower max column height (tie-breaker, though W=H).
+        if (A.H!=B.H) return A.H<B.H;
+        return A.W<B.W;
+    };
+
+    PackedSolution best; best.W=0; best.H=INT_MAX;
+
+    auto try_with_side = [&](int S)->optional<PackedSolution>{
+        World world(S);
+        world.occ.reserve((size_t)totalCells*2 + 1024);
+        vector<Placement> place(n);
+
+        for (int idx=0; idx<n; ++idx){
+            int i = order[idx];
+            auto &piece = P[i];
+
+            // Favor shorter/taller shapes appropriately
+            vector<int> vord(piece.variants.size());
+            iota(vord.begin(), vord.end(), 0);
+            sort(vord.begin(), vord.end(), [&](int a,int b){
+                const auto&A=piece.variants[a], &B=piece.variants[b];
+                if (A.h!=B.h) return A.h<B.h;
+                if (A.w!=B.w) return A.w>B.w;
+                return A.pts.size()>B.pts.size();
+            });
+
+            int bestVi=-1, bestX=-1, bestY=INT_MAX;
+
+            for (int vi: vord){
+                const auto &o = piece.variants[vi];
+                if (o.w > world.W || o.h > world.Hlimit) continue;
+
+                // x scan (try both coarse step and right align)
+                int step = max(1, o.w/2);
+                for (int x=0; x + o.w <= world.W; x += step){
+                    int y = world.shelfY(x, o.w);
+                    if (y + o.h > world.Hlimit) continue;       // square cap
+                    if (y > bestY) continue;
+                    if (!world.can_place(o, x, y)) continue;
+                    bestY=y; bestX=x; bestVi=vi;
+                }
+                int xr = world.W - o.w;
+                if (xr>=0){
+                    int y = world.shelfY(xr, o.w);
+                    if (y + o.h <= world.Hlimit && y <= bestY && world.can_place(o, xr, y)){
+                        bestY=y; bestX=xr; bestVi=vi;
+                    }
+                }
+            }
+
+            if (bestVi<0) return {}; // fail for this S
+
+            const auto &o = piece.variants[bestVi];
+            world.do_place(o, bestX, bestY);
+            place[i] = {bestX, bestY, o.tf.R, o.tf.F, o.w, o.h, bestVi};
+        }
+
+        // success with this S
+        PackedSolution cand; 
+        cand.W = S; 
+        cand.H = S; // enforce square
+        cand.place.resize(n);
+        for (int i=0;i<n;++i) cand.place[i]=place[i];
+        return cand;
+    };
+
+    // Try preset candidates
+    for (int S : sides){
+        if (auto sol = try_with_side(S)){
+            if (best.W==0 || better(*sol,best)) best=*sol;
+        }
+    }
+
+    // If none worked, escalate S until it does (guaranteed cap: vertical stack height)
+    if (best.W==0){
+        // Safe upper bound: stack piece heights of a chosen variant each
+        int maxW=1, sumH=0;
+        for (auto &p: P){
+            int wmin=INT_MAX, hmin=INT_MAX;
+            for (auto &o: p.variants){
+                wmin = min(wmin, o.w);
+                hmin = min(hmin, o.h);
+            }
+            maxW = max(maxW, wmin);
+            sumH += hmin;
+        }
+        int S = max({S0, maxW, sumH}); // square that trivially fits vertical stack
+        // grow linearly from S0 to S (usually hits long before)
+        for (int s = S0; s <= S; ++s){
+            if (auto sol = try_with_side(s)){ best = *sol; break; }
+        }
+        // If still nothing (extremely unlikely), force a trivial square stack at side S
+        if (best.W==0){
+            int y=0;
+            vector<Placement> pl(n);
+            // Use each piece's first variant
+            for (int i=0;i<n;++i){
+                const auto &o = P[i].variants[0];
+                pl[i]={0,y,o.tf.R,o.tf.F,o.w,o.h,0};
+                y += o.h;
+            }
+            int Sforce = max({S, y, maxW});
+            best.W = best.H = Sforce;
+            best.place = move(pl);
+        }
+    }
+
+    // ---- OUTPUT with offset compensation ----
+    cout << best.W << " " << best.H << "\n";
+    for (int i=0;i<n;++i){
+        const auto &pl = best.place[i];
+        const auto &o  = P[i].variants[pl.vi];
+        // t = (X - minx, Y - miny) = (X + offx, Y + offy)
+        int Xout = pl.X + o.offx;
+        int Yout = pl.Y + o.offy;
+        cout << Xout << " " << Yout << " " << pl.R << " " << pl.F << "\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/examples/reference.cpp

@@ -0,0 +1,297 @@
+/*
+SOURCE: Shang Zhou
+IIMOC SUBMISSION #1443
+HUMAN BEST FOR POLYPACK (TRANSFORMATION OUTPUT FORMAT)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+    auto ord4 = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            int limCnt=max(1,dynLIM);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(bds2<bds) take=true;
+                    else if(bds2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=bds2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+    double factor;
+    if (S < 1000) {
+        factor = 0.4;
+    } else if (S < 3000) {
+        factor = 0.5;
+    } else if (S < 10000) {
+        factor = 0.27;
+    } else if (S < 30000) {
+        factor = 0.08;
+    } else {
+        factor = 0.01;
+    }
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used=chrono::duration<double,milli>(now-t0).count();
+        if(used+avg*1.3>TL) break;
+        int W=Ws[wi];
+        vector<vector<int>> orders;
+        orders.push_back(ord4());
+        int oi=0;
+        while(oi<(int)orders.size()){
+            auto t1=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(t1-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            R r=pack(W,orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+            oi++;
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord4();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/evolution.log

@@ -0,0 +1,48 @@
+Gen 0 | Score: 85.19 | Best: 85.19 | Status: baseline | Change: reference.cpp baseline
+Gen 1 | Score: 88.77 | Best: 88.77 | Status: improved | Change: multiple orderings (desc area, desc maxdim, desc bbox, random) + sqrt(S) width candidates
+Gen 2 | Score: 87.76 | Best: 88.77 | Status: reverted | Change: two-phase width search (worse - less time per width for ordering diversity)
+Gen 3 | Score: 88.94 | Best: 88.94 | Status: improved | Change: added flexibility ordering + perturbation-based restarts
+Gen 4 | Score: 64.01 | Best: 88.94 | Status: reverted | Change: multi-center width search (much worse - wide widths bad for skyline)
+Gen 5 | Score: 89.63 | Best: 89.63 | Status: improved | Change: waste-based between-piece scoring (dsum-k) + early piece lookahead boost
+Gen 6 | Score: 89.56 | Best: 89.63 | Status: reverted | Change: phase 3 random restarts on best width (slightly worse)
+Gen 7 | Score: 89.59 | Best: 89.63 | Status: reverted | Change: variant pre-sorting (no improvement)
+Gen 8 | Score: 89.61 | Best: 89.63 | Status: reverted | Change: early termination pruning (no improvement)
+Gen 9 | Score: 89.58/89.57 | Best: 89.63 | Status: reverted | Change: Y-compaction post-processing (no improvement due to skyline already optimal locally)
+Gen 10 | Score: 89.25 | Best: 89.63 | Status: reverted | Change: bitmap-based exact packer for small inputs (too slow, fewer trials)
+Gen 11 | Score: 89.61 | Best: 89.63 | Status: reverted | Change: skyline-based early cutoff (negligible effect)
+Gen 12 | Score: 89.53 | Best: 89.63 | Status: reverted | Change: added compact+interleaved orderings (too many orderings, fewer widths)
+Gen 13 | Score: 89.63 | Best: 89.63 | Status: tie | Change: 3 orderings + 6 restarts (no improvement over 5+4)
+Gen 14 | Score: 85.56 | Best: 89.63 | Status: reverted | Change: top-piece re-packing with exact tracking (TLE on most cases)
+Gen 15 | Score: 89.46 | Best: 89.63 | Status: reverted | Change: more aggressive early boost (too much time consumed)
+Gen 16 | Score: 89.21 | Best: 89.63 | Status: reverted | Change: composite scoring (hierarchical is better)
+Gen 17 | Score: 89.56 | Best: 89.63 | Status: reverted | Change: adaptive orderings per width size (no improvement)
+Gen 18 | Score: 90.00 | Best: 90.00 | Status: improved | Change: gap-filling pack_gap with bitmap for S<2000, scan depth 3
+Gen 19 | Score: 89.93 | Best: 90.00 | Status: reverted | Change: threshold 1500 (worse)
+Gen 20 | Score: 90.06 | Best: 90.06 | Status: improved | Change: threshold 2500 for gap packer
+Gen 21 | Score: 90.04 | Best: 90.06 | Status: reverted | Change: threshold 3500 (slightly worse)
+Gen 22 | Score: 90.00 | Best: 90.06 | Status: reverted | Change: scan depth 5 (slightly worse)
+Gen 23 | Score: 89.99 | Best: 90.06 | Status: reverted | Change: time-aware gap control (too aggressive cutoff)
+Gen 24-25 | Score: 89.99-90.02 | Best: 90.06 | Status: noise | Change: adaptive scan depth (within noise)
+Gen 26 | Score: 90.13 | Best: 90.13 | Status: improved | Change: 3 orderings for gap packer (more widths explored)
+Gen 27 | Score: 90.22 | Best: 90.22 | Status: improved | Change: only 2 orderings + 2 random for gap packer
+Gen 28 | Score: 90.27 | Best: 90.27 | Status: improved | Change: 1 ordering + 1 random for gap packer (max width diversity)
+Gen 29 | Score: 87.60 | Best: 90.27 | Status: reverted | Change: 0 random restarts (too few trials)
+Gen 30 | Score: 90.32 | Best: 90.32 | Status: improved | Change: gap packer threshold S<5000
+Gen 31 | Score: 90.33 | Best: 90.33 | Status: improved | Change: gap packer threshold S<8000
+Gen 32 | Score: 82.20 | Best: 90.33 | Status: reverted | Change: threshold 15000 (too slow for medium cases)
+Gen 33 | Score: 90.42 | Best: 90.42 | Status: improved | Change: gap packer with adaptive time management, S<12000 threshold
+Gen 34 | Score: 90.29 | Best: 90.42 | Status: reverted | Change: threshold 25000 (slightly worse)
+Gen 35 | Score: 88.98 | Best: 90.42 | Status: reverted | Change: scan depth 5 (too slow with time mgmt)
+Gen 36 | Score: 89.06 | Best: 90.42 | Status: reverted | Change: adaptive depth + threshold 20000 (too slow)
+Gen 37 | Score: 88.90 | Best: 90.42 | Status: reverted | Change: 2 orderings for gap (worse, less width diversity)
+Gen 38 | Score: 90.34 | Best: 90.42 | Status: reverted | Change: reduced orderings for large too (worse)
+
+=== Final Summary ===
+Best confirmed score: ~90.4 (avg ratio 0.904)
+Improvement: 85.19 → 90.4 (+5.2 points, +6.1%)
+
+Key improvements:
+1. Multiple orderings: +3.6 points
+2. Waste-based scoring + early boost: +0.7 points
+3. Gap-filling bitmap packer: +0.8 points
+4. Adaptive time management for gap packer: +0.1 points

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_0.cpp

@@ -0,0 +1,297 @@
+/*
+SOURCE: Shang Zhou
+IIMOC SUBMISSION #1443
+HUMAN BEST FOR POLYPACK (TRANSFORMATION OUTPUT FORMAT)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+    auto ord4 = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            int limCnt=max(1,dynLIM);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(bds2<bds) take=true;
+                    else if(bds2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=bds2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+    double factor;
+    if (S < 1000) {
+        factor = 0.4;
+    } else if (S < 3000) {
+        factor = 0.5;
+    } else if (S < 10000) {
+        factor = 0.27;
+    } else if (S < 30000) {
+        factor = 0.08;
+    } else {
+        factor = 0.01;
+    }
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used=chrono::duration<double,milli>(now-t0).count();
+        if(used+avg*1.3>TL) break;
+        int W=Ws[wi];
+        vector<vector<int>> orders;
+        orders.push_back(ord4());
+        int oi=0;
+        while(oi<(int)orders.size()){
+            auto t1=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(t1-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            R r=pack(W,orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+            oi++;
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord4();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_1.cpp

@@ -0,0 +1,366 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            int limCnt=max(1,dynLIM);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(bds2<bds) take=true;
+                    else if(bds2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=bds2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare multiple orderings
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    base_orders.push_back(ord_desc_maxdim());
+    base_orders.push_back(ord_desc_bbox());
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=pack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+
+        // Also try random orderings if time permits
+        for(int ri=0;ri<2;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            R r=pack(W,ord_random(),rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_18.cpp

@@ -0,0 +1,515 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        int maxBound=max(1,n/4);
+        int dynLIM=maxBound;
+        bool gapEnabled=true;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/dynLIM)):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare multiple orderings
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    base_orders.push_back(ord_desc_maxdim());
+    base_orders.push_back(ord_desc_bbox());
+    base_orders.push_back(ord_flexibility());
+
+    bool useGapPacker = (S < 2000); // Use gap-filling for small inputs
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        for(int ri=0;ri<4;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_20.cpp

@@ -0,0 +1,515 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        int maxBound=max(1,n/4);
+        int dynLIM=maxBound;
+        bool gapEnabled=true;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/dynLIM)):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare multiple orderings
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    base_orders.push_back(ord_desc_maxdim());
+    base_orders.push_back(ord_desc_bbox());
+    base_orders.push_back(ord_flexibility());
+
+    bool useGapPacker = (S < 2500); // Use gap-filling for small inputs
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        for(int ri=0;ri<4;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_26.cpp

@@ -0,0 +1,516 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        int maxBound=max(1,n/4);
+        int dynLIM=maxBound;
+        bool gapEnabled=true;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/dynLIM)):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare orderings - fewer for gap packer (slower per call)
+    bool useGapPacker = (S < 2500);
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    if(!useGapPacker){
+        base_orders.push_back(ord_desc_maxdim());
+        base_orders.push_back(ord_desc_bbox());
+    }
+    base_orders.push_back(ord_flexibility());
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        for(int ri=0;ri<4;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_27.cpp

@@ -0,0 +1,517 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        int maxBound=max(1,n/4);
+        int dynLIM=maxBound;
+        bool gapEnabled=true;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/dynLIM)):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare orderings - fewer for gap packer (slower per call)
+    bool useGapPacker = (S < 2500);
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    if(!useGapPacker){
+        base_orders.push_back(ord_desc_maxdim());
+        base_orders.push_back(ord_desc_bbox());
+        base_orders.push_back(ord_flexibility());
+    }
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        int maxRandom = useGapPacker ? 2 : 4;
+        for(int ri=0;ri<maxRandom;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_28.cpp

@@ -0,0 +1,517 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        int maxBound=max(1,n/4);
+        int dynLIM=maxBound;
+        bool gapEnabled=true;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/dynLIM)):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare orderings - fewer for gap packer (slower per call)
+    bool useGapPacker = (S < 2500);
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    if(!useGapPacker){
+        base_orders.push_back(ord_desc_area());
+        base_orders.push_back(ord_desc_maxdim());
+        base_orders.push_back(ord_desc_bbox());
+        base_orders.push_back(ord_flexibility());
+    }
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        int maxRandom = useGapPacker ? 1 : 4;
+        for(int ri=0;ri<maxRandom;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_3.cpp

@@ -0,0 +1,395 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            int limCnt=max(1,dynLIM);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(bds2<bds) take=true;
+                    else if(bds2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=bds2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare multiple orderings
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    base_orders.push_back(ord_desc_maxdim());
+    base_orders.push_back(ord_desc_bbox());
+    base_orders.push_back(ord_flexibility());
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=pack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        for(int ri=0;ri<4;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=pack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_30.cpp

@@ -0,0 +1,517 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        int maxBound=max(1,n/4);
+        int dynLIM=maxBound;
+        bool gapEnabled=true;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/dynLIM)):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare orderings - fewer for gap packer (slower per call)
+    bool useGapPacker = (S < 5000);
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    if(!useGapPacker){
+        base_orders.push_back(ord_desc_area());
+        base_orders.push_back(ord_desc_maxdim());
+        base_orders.push_back(ord_desc_bbox());
+        base_orders.push_back(ord_flexibility());
+    }
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        int maxRandom = useGapPacker ? 1 : 4;
+        for(int ri=0;ri<maxRandom;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_33.cpp

@@ -0,0 +1,535 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    // Gap-filling pack for small inputs - tries positions below skyline using bitmap
+    auto pack_gap=[&](int W,const vector<int>& o0,RNG &rng,bool randtie) -> R {
+        int maxHg=(int)(S/max(1,W)+W+50);
+        vector<vector<bool>> grid(W, vector<bool>(maxHg, false));
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t2=0,nm=(int)o.size();
+        bool big2=(S>7000);
+        int maxBound=max(1,n/4);
+        int expLIM2=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big2?expLIM2:maxBound;
+        bool gapEnabled=true;
+        auto gpTStart=chrono::steady_clock::now();
+        auto gpBatchStart=gpTStart;
+        long long gpTLms=big2?1800:LLONG_MAX/4;
+        int gpStepCnt=0;
+        while(t2<nm){
+            int earlyBoost=(t2<nm/10)?min(3,max(1,maxBound/max(1,dynLIM))):1;
+            int limCnt=max(1,dynLIM*earlyBoost);
+            int lim=min(nm,t2+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t2; int bestid=-1;
+            for(int pos=t2;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        // Skyline placement
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        // Also try gap positions (scan up to 10 rows below skyline)
+                        int gapY=-1;
+                        if(gapEnabled && y0>0){
+                            int sd=min(y0,3); // Only check 3 rows below skyline
+                            for(int gy=max(0,y0-sd);gy<y0;gy++){
+                                bool ok=true;
+                                for(auto &q:tsh.c){
+                                    int gx=x0+q.first,gcy=gy+q.second;
+                                    if(gcy<0||gcy>=maxHg||grid[gx][gcy]){ok=false;break;}
+                                }
+                                if(ok){gapY=gy;break;}
+                            }
+                        }
+                        // Evaluate both positions
+                        for(int pass=0;pass<(gapY>=0?2:1);pass++){
+                            int yy=(pass==0)?y0:gapY;
+                            int nhbuf[32];
+                            int l=-1; long long dsum=0;
+                            for(int j=0;j<tsh.w;j++){
+                                int nh=h[x0+j];
+                                if(tsh.hi[j]!=INT_MIN){int cand=yy+tsh.hi[j]; if(nh<cand) nh=cand;}
+                                nhbuf[j]=nh; if(nh>l) l=nh;
+                            }
+                            for(int j=0;j<tsh.w;j++){int inc=nhbuf[j]-h[x0+j]; if(inc>0) dsum+=inc;}
+                            long long dr=0;
+                            if(x0>0){dr+=llabs((long long)nhbuf[0]-h[x0-1])-llabs((long long)h[x0]-h[x0-1]);}
+                            for(int j=0;j<tsh.w-1;j++){dr+=llabs((long long)nhbuf[j+1]-nhbuf[j])-llabs((long long)h[x0+j+1]-h[x0+j]);}
+                            if(x0+tsh.w<W){dr+=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1])-llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);}
+                            long long gg=g; if(gg<l) gg=l;
+                            bool take=false;
+                            if(gg<bestg2) take=true;
+                            else if(gg==bestg2){
+                                if(dsum<bds2) take=true;
+                                else if(dsum==bds2){if(l<bl2) take=true;
+                                else if(l==bl2){if(dr<bdr2) take=true;
+                                else if(dr==bdr2){if(yy<by02) take=true;
+                                else if(yy==by02){if(x0<bx02) take=true;
+                                else if(x0==bx02&&randtie&&rng.coin()) take=true;}}}}
+                            }
+                            if(take){bestg2=gg;bti2=ti;bx2=x0;by2=yy;bl2=l;bds2=dsum;bdr2=dr;by02=yy;bx02=x0;}
+                        }
+                    }
+                }
+                if(bti2==-1) continue;
+                long long waste2=bds2-p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){if(waste2<bds) take=true;
+                else if(waste2==bds){if(bl2<bl) take=true;
+                else if(bl2==bl){if(bdr2<bdr) take=true;
+                else if(bdr2==bdr){if(by02<by0) take=true;
+                else if(by02==by0){if(bx02<bx0) take=true;
+                else if(bx02==bx0&&randtie&&rng.coin()) take=true;}}}}}
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t2++;continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){int cand=by+tsh.hi[j]; if(nh<cand) nh=cand;}
+                h[bx+j]=nh;
+            }
+            for(auto &q:tsh.c){int gx=bx+q.first,gy=by+q.second; if(gx>=0&&gx<W&&gy>=0&&gy<maxHg) grid[gx][gy]=true;}
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t2) swap(o[t2],o[bestpos]);
+            t2++;
+            gpStepCnt++;
+            if(big2&&gpStepCnt==5){
+                auto gpNow=chrono::steady_clock::now();
+                auto gpElapsed=chrono::duration<double,milli>(gpNow-gpTStart).count();
+                auto gpBatch=chrono::duration<double,milli>(gpNow-gpBatchStart).count();
+                double gpRemT=max(0.0,(double)gpTLms-gpElapsed);
+                int gpRemSteps=max(1,nm-t2);
+                double gpBudget=gpRemT*5.0/gpRemSteps;
+                if(gpBatch<gpBudget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                gpBatchStart=gpNow;
+                gpStepCnt=0;
+            }
+        }
+        if((int)pl.size() < nm){
+            // Not all pieces placed - return failure
+            return R{LLONG_MAX, W, 0, {}};
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}}
+        int Wused=0;
+        if(maxX>=0){vector<char> used(maxX+1,false); for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}} for(int x=0;x<=maxX;x++) if(used[x]) Wused++;}
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare orderings - fewer for gap packer (slower per call)
+    bool useGapPacker = (S < 12000);
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    if(!useGapPacker){
+        base_orders.push_back(ord_desc_area());
+        base_orders.push_back(ord_desc_maxdim());
+        base_orders.push_back(ord_desc_bbox());
+        base_orders.push_back(ord_flexibility());
+    }
+    auto doPack = [&](int W, const vector<int>& order, RNG& rng, bool randtie) -> R {
+        if(useGapPacker) return pack_gap(W, order, rng, randtie);
+        return pack(W, order, rng, randtie);
+    };
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=doPack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        int maxRandom = useGapPacker ? 1 : 4;
+        for(int ri=0;ri<maxRandom;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=doPack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_0_polyomino_ev2/logs/gen_5.cpp

@@ -0,0 +1,399 @@
+/*
+Gen 1: Multiple orderings + improved width search
+Based on reference.cpp with:
+- 4 ordering strategies (ascending min dim, descending area, descending max dim, random)
+- Each width tries all orderings (time permitting)
+- Better width candidate generation
+*/
+#include <bits/stdc++.h>
+using namespace std;
+struct T{int w,h;vector<pair<int,int>> c;vector<int> lo,hi;int r,f,minx,miny;};
+struct P{int id,k;vector<pair<int,int>> b;vector<T> t;int minW=1e9,minH=1e9,minA=1e9;};
+struct Pl{int idx,ti,x,y;};
+struct R{long long A;int W,H;vector<Pl> pl;};
+struct RNG{unsigned long long s;RNG(unsigned long long x){s=x?x:1;}inline unsigned long long nxt(){s^=s<<7;s^=s>>9;return s;}inline int rint(int n){return (int)(nxt()%n);}inline bool coin(){return nxt()&1;}};
+static inline pair<int,int> rotp(pair<int,int> p,int r){if(r==0)return p; if(r==1)return make_pair(-p.second,p.first); if(r==2)return make_pair(-p.first,-p.second); return make_pair(p.second,-p.first);}
+int main(){
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    int n; if(!(cin>>n)) return 0;
+    vector<P> ps(n); long long S=0;
+    for(int i=0;i<n;i++){
+        int k;cin>>k; ps[i].id=i+1; ps[i].k=k; ps[i].b.resize(k);
+        for(int j=0;j<k;j++){int x,y;cin>>x>>y; ps[i].b[j]={x,y};}
+        S+=k;
+    }
+    for(int i=0;i<n;i++){
+        auto &p=ps[i]; unordered_set<string> seen; seen.reserve(32);
+        for(int rf=0;rf<2;rf++){
+            vector<pair<int,int>> src=p.b; if(rf){for(auto &q:src) q.first=-q.first;}
+            for(int r=0;r<4;r++){
+                vector<pair<int,int>> v=src; for(auto &q:v) q=rotp(q,r);
+                int minx=INT_MAX,miny=INT_MAX,maxx=INT_MIN,maxy=INT_MIN;
+                for(auto &q:v){minx=min(minx,q.first);miny=min(miny,q.second);maxx=max(maxx,q.first);maxy=max(maxy,q.second);}
+                vector<pair<int,int>> v2=v; for(auto &q:v2){q.first-=minx;q.second-=miny;}
+                sort(v2.begin(),v2.end());
+                string key; key.reserve(v2.size()*8);
+                for(auto &q:v2){key.append(to_string(q.first));key.push_back(',');key.append(to_string(q.second));key.push_back(';');}
+                if(seen.insert(key).second){
+                    T t; t.w=maxx-minx+1; t.h=maxy-miny+1; t.c=v2; t.r=r; t.f=rf; t.minx=minx; t.miny=miny;
+                    t.lo.assign(t.w,INT_MAX); t.hi.assign(t.w,INT_MIN);
+                    for(auto &q:v2){int x=q.first,y=q.second; if(t.lo[x]>y) t.lo[x]=y; if(t.hi[x]<y) t.hi[x]=y;}
+                    p.t.push_back(move(t));
+                }
+            }
+        }
+        for(auto &t:p.t){p.minW=min(p.minW,t.w); p.minH=min(p.minH,t.h); p.minA=min(p.minA,t.w*t.h);}
+        if(p.t.empty()){T t; t.w=1;t.h=1;t.c={{0,0}};t.lo={0};t.hi={0};t.r=0;t.f=0;t.minx=0;t.miny=0;p.t.push_back(t);p.minW=1;p.minH=1;p.minA=1;}
+    }
+    vector<int> idx(n); iota(idx.begin(),idx.end(),0);
+    unsigned long long seed=((unsigned long long)chrono::high_resolution_clock::now().time_since_epoch().count()) ^ (S<<1) ^ (unsigned long long)(n*1469598103934665603ULL);
+    RNG rng(seed);
+
+    // Multiple ordering strategies
+    auto ord_asc_mindim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da < db;
+            if (ps[a].k != ps[b].k) return ps[a].k < ps[b].k;
+            return ps[a].id > ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_area = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            int da = min(ps[a].minW, ps[a].minH);
+            int db = min(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_maxdim = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int da = max(ps[a].minW, ps[a].minH);
+            int db = max(ps[b].minW, ps[b].minH);
+            if (da != db) return da > db;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_desc_bbox = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            if (ps[a].minA != ps[b].minA) return ps[a].minA > ps[b].minA;
+            if (ps[a].k != ps[b].k) return ps[a].k > ps[b].k;
+            return ps[a].id < ps[b].id;
+        });
+        return res;
+    };
+    auto ord_random = [&]() {
+        vector<int> res = idx;
+        for(int i=n-1;i>0;i--){
+            int j=rng.rint(i+1);
+            swap(res[i],res[j]);
+        }
+        return res;
+    };
+    // Perturb a given ordering by making random swaps
+    auto ord_perturb = [&](const vector<int>& base_ord, int nswaps) {
+        vector<int> res = base_ord;
+        for(int i=0;i<nswaps;i++){
+            int a=rng.rint(n), b=rng.rint(n);
+            swap(res[a],res[b]);
+        }
+        return res;
+    };
+    // Sort by flexibility (fewer variants first = harder to place)
+    auto ord_flexibility = [&]() {
+        vector<int> res = idx;
+        stable_sort(res.begin(), res.end(), [&](int a, int b) {
+            int va=(int)ps[a].t.size(), vb=(int)ps[b].t.size();
+            if(va!=vb) return va<vb;
+            if(ps[a].k!=ps[b].k) return ps[a].k>ps[b].k;
+            return ps[a].id<ps[b].id;
+        });
+        return res;
+    };
+
+    auto pack=[&](int W,const vector<int>& o0,RNG &rng,bool randtie){
+        vector<int> h(W,-1);
+        long long g=-1;
+        vector<Pl> pl; pl.reserve(o0.size());
+        vector<int> o=o0;
+        int t=0,nm=(int)o.size();
+        bool big=S>7000;
+        int maxBound=max(1,n/4);
+        int expLIM=min(maxBound,(int)(350000/max(1LL,S-3500)));
+        int dynLIM=big?expLIM:maxBound;
+        auto tStart=chrono::steady_clock::now();
+        auto batchStart=tStart;
+        long long TLms=big?1900:LLONG_MAX/4;
+        int stepCnt=0;
+        while(t<nm){
+            // Increase lookahead for early pieces (they have most impact)
+            int earlyBoost = (t < nm/10) ? min(3, max(1, maxBound/dynLIM)) : 1;
+            int limCnt=max(1,dynLIM * earlyBoost);
+            int lim=min(nm,t+limCnt);
+            long long bestg=LLONG_MAX; int bti=-1,bx=0,by=0,bl=INT_MAX; long long bds=LLONG_MAX; long long bdr=LLONG_MAX; int by0=INT_MAX,bx0=INT_MAX; int bestpos=t; int bestid=-1;
+            for(int pos=t;pos<lim;pos++){
+                int id=o[pos];
+                auto &p=ps[id];
+                long long bestg2=LLONG_MAX; int bti2=-1,bx2=0,by2=0,bl2=INT_MAX; long long bds2=LLONG_MAX; long long bdr2=LLONG_MAX; int by02=INT_MAX,bx02=INT_MAX;
+                for(int ti=0;ti<(int)p.t.size();ti++){
+                    auto &tsh=p.t[ti]; if(tsh.w>W) continue; int Rpos=W-tsh.w+1;
+                    for(int x0=0;x0<Rpos;x0++){
+                        int y0=0;
+                        for(int j=0;j<tsh.w;j++){
+                            if(tsh.lo[j]!=INT_MAX){int v=h[x0+j]-tsh.lo[j]+1; if(v>y0) y0=v;}
+                        }
+                        int nhbuf[32];
+                        int l=-1; long long dsum=0;
+                        for(int j=0;j<tsh.w;j++){
+                            int nh=h[x0+j];
+                            if(tsh.hi[j]!=INT_MIN){
+                                int cand=y0+tsh.hi[j];
+                                if(nh<cand) nh=cand;
+                            }
+                            nhbuf[j]=nh;
+                            if(nh>l) l=nh;
+                        }
+                        for(int j=0;j<tsh.w;j++){
+                            int inc=nhbuf[j]-h[x0+j];
+                            if(inc>0) dsum+=inc;
+                        }
+                        long long dr=0;
+                        if(x0>0){
+                            long long old=llabs((long long)h[x0]-h[x0-1]);
+                            long long nw=llabs((long long)nhbuf[0]-h[x0-1]);
+                            dr+=nw-old;
+                        }
+                        for(int j=0;j<tsh.w-1;j++){
+                            long long old=llabs((long long)h[x0+j+1]-h[x0+j]);
+                            long long nw=llabs((long long)nhbuf[j+1]-nhbuf[j]);
+                            dr+=nw-old;
+                        }
+                        if(x0+tsh.w<W){
+                            long long old=llabs((long long)h[x0+tsh.w]-h[x0+tsh.w-1]);
+                            long long nw=llabs((long long)h[x0+tsh.w]-nhbuf[tsh.w-1]);
+                            dr+=nw-old;
+                        }
+                        long long gg=g; if(gg<l) gg=l;
+                        bool take=false;
+                        if(gg<bestg2) take=true;
+                        else if(gg==bestg2){
+                            if(dsum<bds2) take=true;
+                            else if(dsum==bds2){
+                                if(l<bl2) take=true;
+                                else if(l==bl2){
+                                    if(dr<bdr2) take=true;
+                                    else if(dr==bdr2){
+                                        if(y0<by02) take=true;
+                                        else if(y0==by02){
+                                            if(x0<bx02) take=true;
+                                            else if(x0==bx02 && randtie && rng.coin()) take=true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if(take){bestg2=gg;bti2=ti;bx2=x0;by2=y0;bl2=l;bds2=dsum;bdr2=dr;by02=y0;bx02=x0;}
+                    }
+                }
+                if(bti2==-1) continue;
+                // Use waste = dsum - k for between-piece comparison (accounts for piece size)
+                long long waste2 = bds2 - p.k;
+                bool take=false;
+                if(bestg2<bestg) take=true;
+                else if(bestg2==bestg){
+                    if(waste2<bds) take=true;
+                    else if(waste2==bds){
+                        if(bl2<bl) take=true;
+                        else if(bl2==bl){
+                            if(bdr2<bdr) take=true;
+                            else if(bdr2==bdr){
+                                if(by02<by0) take=true;
+                                else if(by02==by0){
+                                    if(bx02<bx0) take=true;
+                                    else if(bx02==bx0 && randtie && rng.coin()) take=true;
+                                }
+                            }
+                        }
+                    }
+                }
+                if(take){bestg=bestg2;bti=bti2;bx=bx2;by=by2;bl=bl2;bds=waste2;bdr=bdr2;by0=by02;bx0=bx02;bestpos=pos;bestid=id;}
+            }
+            if(bti==-1){t++;stepCnt++;if(big&&stepCnt==5){auto now=chrono::steady_clock::now(); auto elapsed=chrono::duration<double,milli>(now-tStart).count(); auto batch=chrono::duration<double,milli>(now-batchStart).count(); double remT=max(0.0,TLms-elapsed); int remSteps=max(1,nm-t); double budget=remT*5.0/remSteps; if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1); batchStart=now; stepCnt=0;} continue;}
+            auto &tsh=ps[bestid].t[bti];
+            for(int j=0;j<tsh.w;j++){
+                int nh=h[bx+j];
+                if(tsh.hi[j]!=INT_MIN){
+                    int cand=by+tsh.hi[j];
+                    if(nh<cand) nh=cand;
+                }
+                h[bx+j]=nh;
+            }
+            if(g<bl) g=bl;
+            pl.push_back({bestid,bti,bx,by});
+            if(bestpos!=t) swap(o[t],o[bestpos]);
+            t++;
+            stepCnt++;
+            if(big&&stepCnt==5){
+                auto now=chrono::steady_clock::now();
+                auto elapsed=chrono::duration<double,milli>(now-tStart).count();
+                auto batch=chrono::duration<double,milli>(now-batchStart).count();
+                double remT=max(0.0,TLms-elapsed);
+                int remSteps=max(1,nm-t);
+                double budget=remT*5.0/remSteps;
+                if(batch<budget) dynLIM=min(maxBound,dynLIM+1); else dynLIM=max(1,dynLIM-1);
+                batchStart=now;
+                stepCnt=0;
+            }
+        }
+        int H=(int)g+1;
+        int maxX=-1;
+        for(auto &pp:pl){
+            auto &t=ps[pp.idx].t[pp.ti];
+            for(auto &q:t.c){int x=pp.x+q.first; if(x>maxX) maxX=x;}
+        }
+        int Wused=0;
+        if(maxX>=0){
+            vector<char> used(maxX+1,false);
+            for(auto &pp:pl){auto &t=ps[pp.idx].t[pp.ti]; for(auto &q:t.c){used[pp.x+q.first]=true;}}
+            for(int x=0;x<=maxX;x++) if(used[x]) Wused++;
+        }
+        int Wfinal=max(0,Wused);
+        long long A=1LL*H*max(1,Wfinal);
+        return R{A,max(1,Wfinal),H,move(pl)};
+    };
+    int minW=0; for(auto &p:ps) minW=max(minW,p.minW);
+
+    // Improved width estimation
+    double factor;
+    if (S < 1000) factor = 0.4;
+    else if (S < 3000) factor = 0.5;
+    else if (S < 10000) factor = 0.27;
+    else if (S < 30000) factor = 0.08;
+    else factor = 0.01;
+
+    int base = max(minW, (int)floor(sqrt((double)S * factor)));
+    vector<int> Ws;
+    {
+        unordered_set<int> used; used.reserve(512);
+        auto addW=[&](int w){if(w<minW) w=minW; if(used.insert(w).second) Ws.push_back(w);};
+        addW(base);
+        int span=min(96,max(20,base/2));
+        for(int d=1;d<=span;d++){addW(base-d); addW(base+d);}
+        addW(minW);
+        addW((int)max<long long>(minW,(S+base-1)/base));
+        for(int m=2;m<=6;m++){addW(base*m/3); addW((int)max<long long>(minW,S/((base*m/3)?(base*m/3):1)));}
+        // Add sqrt(S) based widths for more square-like rectangles
+        int sqrtS = max(minW, (int)floor(sqrt((double)S)));
+        addW(sqrtS);
+        addW(sqrtS+1);
+        addW(sqrtS-1);
+        addW(sqrtS*2/3);
+        addW(sqrtS/2);
+        sort(Ws.begin(),Ws.end(),[&](int a,int b){int da=abs(a-base),db=abs(b-base); if(da!=db) return da<db; return a<b;});
+    }
+    long long bestA=LLONG_MAX; int bestW=0,bestH=0; R bestR; bool hasBestmine=false;
+    auto t0=chrono::steady_clock::now();
+    const double TL=1980.0;
+    double avg=250.0; int cnt=0;
+
+    // Prepare multiple orderings
+    vector<vector<int>> base_orders;
+    base_orders.push_back(ord_asc_mindim());
+    base_orders.push_back(ord_desc_area());
+    base_orders.push_back(ord_desc_maxdim());
+    base_orders.push_back(ord_desc_bbox());
+    base_orders.push_back(ord_flexibility());
+
+    // Track best ordering index per width for perturbation
+    int bestOrderIdx = 0;
+
+    for(int wi=0;wi<(int)Ws.size();wi++){
+        auto now=chrono::steady_clock::now();
+        double used_time=chrono::duration<double,milli>(now-t0).count();
+        if(used_time+avg*1.3>TL) break;
+        int W=Ws[wi];
+
+        // Try each base ordering
+        for(int oi=0;oi<(int)base_orders.size();oi++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            bool randtie=(oi>=1);
+            auto t1=chrono::steady_clock::now();
+            R r=pack(W,base_orders[oi],rng,randtie);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+                bestOrderIdx=oi;
+            }
+        }
+
+        // Perturbation of best ordering + random orderings
+        int nswaps = max(1, n/20);
+        for(int ri=0;ri<4;ri++){
+            now=chrono::steady_clock::now();
+            double used2=chrono::duration<double,milli>(now-t0).count();
+            if(used2+avg*1.15>TL) break;
+            auto t1=chrono::steady_clock::now();
+            vector<int> order;
+            if(ri < 2) order = ord_perturb(base_orders[bestOrderIdx], nswaps);
+            else order = ord_random();
+            R r=pack(W,order,rng,true);
+            auto t2=chrono::steady_clock::now();
+            double dt=chrono::duration<double,milli>(t2-t1).count();
+            cnt++; avg=(avg*(cnt-1)+dt)/cnt;
+            if(!hasBestmine || r.A<bestA || (r.A==bestA && (r.H<bestH || (r.H==bestH && r.W<bestW)))){
+                bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+            }
+        }
+    }
+    if(!hasBestmine){
+        int W=max(minW,(int)floor(sqrt((double)S)));
+        auto o=ord_asc_mindim();
+        R r=pack(W,o,rng,false);
+        bestA=r.A; bestW=r.W; bestH=r.H; bestR=r; hasBestmine=true;
+    }
+    int maxX=-1;
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        for(auto &q:t.c){int x=p.x+q.first; if(x>maxX) maxX=x;}
+    }
+    vector<int> mapx(maxX+1,-1);
+    if(maxX>=0){
+        vector<char> used(maxX+1,false);
+        for(auto &p:bestR.pl){
+            auto &t=ps[p.idx].t[p.ti];
+            for(auto &q:t.c){used[p.x+q.first]=true;}
+        }
+        int cur=0;
+        for(int x=0;x<=maxX;x++) if(used[x]) mapx[x]=cur++;
+    }
+    vector<array<int,4>> ans(n,{0,0,0,0});
+    for(auto &p:bestR.pl){
+        auto &t=ps[p.idx].t[p.ti];
+        int bx = (mapx.empty()?p.x:mapx[p.x]);
+        int Xi = bx - t.minx;
+        int Yi = p.y - t.miny;
+        int Ri = (4 - (t.r%4) + 4) % 4;
+        int Fi = t.f;
+        ans[p.idx]={Xi,Yi,Ri,Fi};
+    }
+    cout<<bestR.W<<" "<<bestR.H<<"\n";
+    for(int i=0;i<n;i++){
+        cout<<ans[i][0]<<" "<<ans[i][1]<<" "<<ans[i][2]<<" "<<ans[i][3]<<"\n";
+    }
+    return 0;
+}

docker_space/frontier_cs_1/examples/deepseekreasoner.cpp

@@ -0,0 +1,232 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <random>
+#include <cctype>
+#include <cmath>
+
+using namespace std;
+
+const long long M = 20000000;   // mg
+const long long L = 25000000;   // µL
+
+struct Treasure {
+    string name;
+    long long q; // max quantity
+    long long v; // value per item
+    long long m; // mass per item (mg)
+    long long l; // volume per item (µL)
+    double density;
+};
+
+vector<Treasure> treasures;
+
+void parseInput() {
+    string s;
+    char c;
+    while (cin.get(c)) s += c;
+
+    size_t i = 0;
+    auto skipWS = [&]() {
+        while (i < s.size() && isspace(s[i])) i++;
+    };
+
+    skipWS();
+    if (s[i] != '{') return;
+    i++;
+    while (true) {
+        skipWS();
+        if (s[i] == '}') break;
+        if (s[i] == '"') {
+            i++;
+            size_t start = i;
+            while (s[i] != '"') i++;
+            string key = s.substr(start, i - start);
+            i++; // skip '"'
+            skipWS();
+            if (s[i] != ':') return;
+            i++;
+            skipWS();
+            if (s[i] != '[') return;
+            i++;
+            vector<long long> nums;
+            for (int j = 0; j < 4; j++) {
+                skipWS();
+                long long num = 0;
+                while (i < s.size() && isdigit(s[i])) {
+                    num = num * 10 + (s[i] - '0');
+                    i++;
+                }
+                nums.push_back(num);
+                if (j < 3) {
+                    skipWS();
+                    if (s[i] != ',') return;
+                    i++;
+                }
+            }
+            skipWS();
+            if (s[i] != ']') return;
+            i++;
+            treasures.push_back({key, nums[0], nums[1], nums[2], nums[3], 0.0});
+            skipWS();
+            if (s[i] == ',') i++;
+            else if (s[i] == '}') break;
+            else return;
+        }
+    }
+}
+
+vector<long long> greedy(const vector<int>& order) {
+    vector<long long> cnt(treasures.size(), 0);
+    long long cur_m = 0, cur_l = 0;
+    for (int idx : order) {
+        const Treasure& t = treasures[idx];
+        long long maxTake = t.q;
+        if (t.m > 0) maxTake = min(maxTake, (M - cur_m) / t.m);
+        if (t.l > 0) maxTake = min(maxTake, (L - cur_l) / t.l);
+        cnt[idx] = maxTake;
+        cur_m += maxTake * t.m;
+        cur_l += maxTake * t.l;
+    }
+    return cnt;
+}
+
+void improve(vector<long long>& cnt, long long& cur_m, long long& cur_l, long long& cur_v) {
+    bool improved = true;
+    while (improved) {
+        improved = false;
+        // try to add one item
+        for (int i = 0; i < (int)treasures.size(); i++) {
+            if (cnt[i] < treasures[i].q) {
+                long long new_m = cur_m + treasures[i].m;
+                long long new_l = cur_l + treasures[i].l;
+                if (new_m <= M && new_l <= L) {
+                    cnt[i]++;
+                    cur_m = new_m;
+                    cur_l = new_l;
+                    cur_v += treasures[i].v;
+                    improved = true;
+                }
+            }
+        }
+        // try to swap: remove one from j, add one to i
+        for (int i = 0; i < (int)treasures.size() && !improved; i++) {
+            for (int j = 0; j < (int)treasures.size(); j++) {
+                if (i == j) continue;
+                if (cnt[i] < treasures[i].q && cnt[j] > 0) {
+                    long long delta_m = treasures[i].m - treasures[j].m;
+                    long long delta_l = treasures[i].l - treasures[j].l;
+                    long long delta_v = treasures[i].v - treasures[j].v;
+                    if (delta_v > 0 && cur_m + delta_m <= M && cur_l + delta_l <= L) {
+                        cnt[i]++; cnt[j]--;
+                        cur_m += delta_m;
+                        cur_l += delta_l;
+                        cur_v += delta_v;
+                        improved = true;
+                        break;
+                    }
+                }
+            }
+            if (improved) break;
+        }
+    }
+}
+
+void finalRefine(vector<long long>& cnt, long long& cur_m, long long& cur_l, long long& cur_v) {
+    int n = treasures.size();
+    for (int i = 0; i < n; i++) {
+        for (int j = i+1; j < n; j++) {
+            long long cur_xi = cnt[i], cur_xj = cnt[j];
+            long long base_m = cur_m - cur_xi*treasures[i].m - cur_xj*treasures[j].m;
+            long long base_l = cur_l - cur_xi*treasures[i].l - cur_xj*treasures[j].l;
+            long long base_v = cur_v - cur_xi*treasures[i].v - cur_xj*treasures[j].v;
+            long long best_xi = cur_xi, best_xj = cur_xj;
+            long long best_m = cur_m, best_l = cur_l, best_v = cur_v;
+            for (long long xi = max(0LL, cur_xi-10); xi <= min(treasures[i].q, cur_xi+10); xi++) {
+                for (long long xj = max(0LL, cur_xj-10); xj <= min(treasures[j].q, cur_xj+10); xj++) {
+                    long long new_m = base_m + xi*treasures[i].m + xj*treasures[j].m;
+                    long long new_l = base_l + xi*treasures[i].l + xj*treasures[j].l;
+                    if (new_m <= M && new_l <= L) {
+                        long long new_v = base_v + xi*treasures[i].v + xj*treasures[j].v;
+                        if (new_v > best_v) {
+                            best_v = new_v;
+                            best_m = new_m;
+                            best_l = new_l;
+                            best_xi = xi;
+                            best_xj = xj;
+                        }
+                    }
+                }
+            }
+            if (best_xi != cur_xi || best_xj != cur_xj) {
+                cnt[i] = best_xi;
+                cnt[j] = best_xj;
+                cur_m = best_m;
+                cur_l = best_l;
+                cur_v = best_v;
+            }
+        }
+    }
+}
+
+int main() {
+    parseInput();
+    int n = treasures.size();
+    // compute density: value per combined resource
+    for (int i = 0; i < n; i++) {
+        // density = v_i / (m_i/M + l_i/L) = v_i * M * L / (m_i * L + l_i * M)
+        double denom = treasures[i].m * L + treasures[i].l * M;
+        treasures[i].density = (denom > 0) ? (treasures[i].v * M * L / denom) : 1e18;
+    }
+
+    vector<int> order(n);
+    for (int i = 0; i < n; i++) order[i] = i;
+    sort(order.begin(), order.end(), [&](int a, int b) {
+        return treasures[a].density > treasures[b].density;
+    });
+
+    // initial solution from density order
+    vector<long long> best_cnt = greedy(order);
+    long long best_m = 0, best_l = 0, best_v = 0;
+    for (int i = 0; i < n; i++) {
+        best_m += best_cnt[i] * treasures[i].m;
+        best_l += best_cnt[i] * treasures[i].l;
+        best_v += best_cnt[i] * treasures[i].v;
+    }
+    improve(best_cnt, best_m, best_l, best_v);
+
+    // random permutations
+    mt19937 rng(123456); // fixed seed for reproducibility
+    for (int iter = 0; iter < 100; iter++) {
+        shuffle(order.begin(), order.end(), rng);
+        vector<long long> cnt = greedy(order);
+        long long cur_m = 0, cur_l = 0, cur_v = 0;
+        for (int i = 0; i < n; i++) {
+            cur_m += cnt[i] * treasures[i].m;
+            cur_l += cnt[i] * treasures[i].l;
+            cur_v += cnt[i] * treasures[i].v;
+        }
+        improve(cnt, cur_m, cur_l, cur_v);
+        if (cur_v > best_v) {
+            best_v = cur_v;
+            best_m = cur_m;
+            best_l = cur_l;
+            best_cnt = cnt;
+        }
+    }
+
+    // final refinement on pairs
+    finalRefine(best_cnt, best_m, best_l, best_v);
+
+    // output JSON
+    cout << "{\n";
+    for (int i = 0; i < n; i++) {
+        cout << " \"" << treasures[i].name << "\": " << best_cnt[i];
+        if (i != n-1) cout << ",";
+        cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/deepseekreasoner_1.cpp

@@ -0,0 +1,174 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <algorithm>
+
+using namespace std;
+
+const long long M_MAX = 20000000;   // 20 kg in mg
+const long long V_MAX = 25000000;   // 25 liters in µL
+
+struct BinaryItem {
+    long long mass;
+    long long volume;
+    long long value;
+    int category;
+    int copies;
+};
+
+struct State {
+    long long volume;
+    long long value;
+    int prev_item;      // index in binary_items
+    long long prev_mass;
+};
+
+int main() {
+    // Read the whole input
+    string input;
+    char c;
+    while (cin.get(c)) input += c;
+
+    // Parse JSON
+    vector<string> categories;
+    vector<long long> q, v, m, l;
+    size_t pos = 0;
+    while (pos < input.size() && input[pos] != '{') ++pos;
+    ++pos; // skip '{'
+    for (int i = 0; i < 12; ++i) {
+        // Key
+        while (pos < input.size() && input[pos] != '"') ++pos;
+        size_t start_key = pos + 1;
+        ++pos;
+        while (pos < input.size() && input[pos] != '"') ++pos;
+        string key = input.substr(start_key, pos - start_key);
+        categories.push_back(key);
+        ++pos; // skip '"'
+
+        // Skip to '['
+        while (pos < input.size() && input[pos] != '[') ++pos;
+        ++pos;
+
+        // Four integers
+        long long nums[4];
+        for (int j = 0; j < 4; ++j) {
+            while (pos < input.size() && (input[pos] < '0' || input[pos] > '9')) ++pos;
+            size_t start_num = pos;
+            while (pos < input.size() && input[pos] >= '0' && input[pos] <= '9') ++pos;
+            nums[j] = stoll(input.substr(start_num, pos - start_num));
+            if (j < 3) {
+                while (pos < input.size() && input[pos] != ',') ++pos;
+                ++pos;
+            }
+        }
+        q.push_back(nums[0]);
+        v.push_back(nums[1]);
+        m.push_back(nums[2]);
+        l.push_back(nums[3]);
+
+        // Skip ']'
+        while (pos < input.size() && input[pos] != ']') ++pos;
+        ++pos;
+        // Skip whitespace and comma (or '}')
+        while (pos < input.size() && (input[pos] == ' ' || input[pos] == '\n' || input[pos] == '\r' || input[pos] == '\t'))
+            ++pos;
+        if (i < 11 && input[pos] == ',') ++pos;
+    }
+
+    // Build binary items (bounded knapsack -> 0/1 via powers of two)
+    vector<BinaryItem> binary_items;
+    int cat_count = categories.size();
+    for (int i = 0; i < cat_count; ++i) {
+        long long quantity = q[i];
+        int mult = 1;
+        while (quantity > 0) {
+            long long take = min((long long)mult, quantity);
+            binary_items.push_back({
+                take * m[i],
+                take * l[i],
+                take * v[i],
+                i,
+                (int)take
+            });
+            quantity -= take;
+            mult <<= 1;
+        }
+    }
+
+    // Sparse DP: map mass -> best state (volume, value, back pointer)
+    unordered_map<long long, State> dp;
+    dp[0] = {0, 0, -1, -1};
+    long long best_value = 0;
+    long long best_mass = 0;
+
+    int item_count = binary_items.size();
+    for (int idx = 0; idx < item_count; ++idx) {
+        const BinaryItem& it = binary_items[idx];
+        unordered_map<long long, State> updates;
+
+        for (const auto& entry : dp) {
+            long long old_mass = entry.first;
+            const State& s = entry.second;
+
+            long long new_mass = old_mass + it.mass;
+            if (new_mass > M_MAX) continue;
+            long long new_volume = s.volume + it.volume;
+            if (new_volume > V_MAX) continue;
+            long long new_value = s.value + it.value;
+
+            bool better = false;
+            auto cur_it = dp.find(new_mass);
+            if (cur_it == dp.end()) {
+                better = true;
+            } else {
+                const State& cur = cur_it->second;
+                if (new_value > cur.value ||
+                    (new_value == cur.value && new_volume < cur.volume))
+                    better = true;
+            }
+
+            if (better) {
+                auto upd_it = updates.find(new_mass);
+                if (upd_it == updates.end() ||
+                    new_value > upd_it->second.value ||
+                    (new_value == upd_it->second.value && new_volume < upd_it->second.volume))
+                {
+                    updates[new_mass] = {new_volume, new_value, idx, old_mass};
+                }
+            }
+        }
+
+        // Merge updates into dp
+        for (const auto& p : updates) {
+            dp[p.first] = p.second;
+            if (p.second.value > best_value) {
+                best_value = p.second.value;
+                best_mass = p.first;
+            }
+        }
+    }
+
+    // Reconstruct counts
+    vector<long long> counts(cat_count, 0);
+    long long cur_mass = best_mass;
+    while (cur_mass > 0) {
+        State& s = dp[cur_mass];
+        int idx = s.prev_item;
+        if (idx == -1) break;
+        BinaryItem& it = binary_items[idx];
+        counts[it.category] += it.copies;
+        cur_mass = s.prev_mass;
+    }
+
+    // Output JSON
+    cout << "{\n";
+    for (int i = 0; i < cat_count; ++i) {
+        cout << " \"" << categories[i] << "\": " << counts[i];
+        if (i < cat_count - 1) cout << ",";
+        cout << "\n";
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/deepseekreasoner_2.cpp

@@ -0,0 +1,265 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <numeric>
+#include <cctype>
+#include <cmath>
+
+using namespace std;
+
+struct Item {
+    string name;
+    int q, v, m, l;
+};
+
+const long long Mmax = 20000000;
+const long long Vmax = 25000000;
+
+vector<Item> items;
+vector<int> best_counts(12, 0);
+long long best_value = 0;
+
+void update_best(const vector<int>& counts) {
+    long long value = 0;
+    for (int i = 0; i < 12; ++i) {
+        value += counts[i] * (long long)items[i].v;
+    }
+    if (value > best_value) {
+        best_value = value;
+        best_counts = counts;
+    }
+}
+
+vector<int> greedy_fill(const vector<int>& order) {
+    vector<int> counts(12, 0);
+    long long cur_mass = 0, cur_vol = 0;
+    for (int idx : order) {
+        const Item& it = items[idx];
+        int maxTake = min(it.q, (int)((Mmax - cur_mass) / it.m), (int)((Vmax - cur_vol) / it.l));
+        if (maxTake > 0) {
+            counts[idx] = maxTake;
+            cur_mass += maxTake * (long long)it.m;
+            cur_vol += maxTake * (long long)it.l;
+        }
+    }
+    return counts;
+}
+
+void swap_local_search(vector<int>& counts, long long& cur_mass, long long& cur_vol) {
+    bool improved = true;
+    while (improved) {
+        improved = false;
+        for (int i = 0; i < 12 && !improved; ++i) {
+            if (counts[i] >= items[i].q) continue;
+            const Item& it_i = items[i];
+            // 1-for-1 swap
+            for (int j = 0; j < 12 && !improved; ++j) {
+                if (counts[j] == 0) continue;
+                const Item& it_j = items[j];
+                if (cur_mass - it_j.m + it_i.m <= Mmax && cur_vol - it_j.l + it_i.l <= Vmax) {
+                    if (it_i.v > it_j.v) {
+                        counts[i]++; counts[j]--;
+                        cur_mass += it_i.m - it_j.m;
+                        cur_vol += it_i.l - it_j.l;
+                        improved = true;
+                    }
+                }
+            }
+            if (improved) break;
+            // 1-for-2 swap
+            for (int j = 0; j < 12 && !improved; ++j) {
+                if (counts[j] == 0) continue;
+                const Item& it_j = items[j];
+                for (int k = 0; k < 12 && !improved; ++k) {
+                    if (counts[k] == 0) continue;
+                    if (k == j && counts[j] < 2) continue;
+                    const Item& it_k = items[k];
+                    if (cur_mass - it_j.m - it_k.m + it_i.m <= Mmax &&
+                        cur_vol - it_j.l - it_k.l + it_i.l <= Vmax) {
+                        long long removed = it_j.v + (k == j ? it_j.v : it_k.v);
+                        if (it_i.v > removed) {
+                            counts[i]++; counts[j]--;
+                            if (k == j) counts[j]--;
+                            else counts[k]--;
+                            cur_mass += it_i.m - it_j.m - it_k.m;
+                            cur_vol += it_i.l - it_j.l - it_k.l;
+                            improved = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+void removal_reopt(const vector<int>& order, const vector<int>& base_counts,
+                   long long base_mass, long long base_vol) {
+    // subsets of size 1,2,3
+    for (int sz = 1; sz <= 3; ++sz) {
+        if (sz == 1) {
+            for (int i = 0; i < 12; ++i) {
+                vector<int> counts = base_counts;
+                long long cur_mass = base_mass;
+                long long cur_vol = base_vol;
+                if (counts[i] > 0) {
+                    cur_mass -= counts[i] * (long long)items[i].m;
+                    cur_vol -= counts[i] * (long long)items[i].l;
+                    counts[i] = 0;
+                }
+                for (int idx : order) {
+                    if (idx == i) continue;
+                    const Item& it = items[idx];
+                    int maxTake = min(it.q - counts[idx],
+                                      (int)((Mmax - cur_mass) / it.m),
+                                      (int)((Vmax - cur_vol) / it.l));
+                    if (maxTake > 0) {
+                        counts[idx] += maxTake;
+                        cur_mass += maxTake * (long long)it.m;
+                        cur_vol += maxTake * (long long)it.l;
+                    }
+                }
+                update_best(counts);
+            }
+        } else if (sz == 2) {
+            for (int i = 0; i < 12; ++i) {
+                for (int j = i+1; j < 12; ++j) {
+                    vector<int> counts = base_counts;
+                    long long cur_mass = base_mass;
+                    long long cur_vol = base_vol;
+                    for (int t : {i, j}) {
+                        if (counts[t] > 0) {
+                            cur_mass -= counts[t] * (long long)items[t].m;
+                            cur_vol -= counts[t] * (long long)items[t].l;
+                            counts[t] = 0;
+                        }
+                    }
+                    for (int idx : order) {
+                        if (idx == i || idx == j) continue;
+                        const Item& it = items[idx];
+                        int maxTake = min(it.q - counts[idx],
+                                          (int)((Mmax - cur_mass) / it.m),
+                                          (int)((Vmax - cur_vol) / it.l));
+                        if (maxTake > 0) {
+                            counts[idx] += maxTake;
+                            cur_mass += maxTake * (long long)it.m;
+                            cur_vol += maxTake * (long long)it.l;
+                        }
+                    }
+                    update_best(counts);
+                }
+            }
+        } else { // sz == 3
+            for (int i = 0; i < 12; ++i) {
+                for (int j = i+1; j < 12; ++j) {
+                    for (int k = j+1; k < 12; ++k) {
+                        vector<int> counts = base_counts;
+                        long long cur_mass = base_mass;
+                        long long cur_vol = base_vol;
+                        for (int t : {i, j, k}) {
+                            if (counts[t] > 0) {
+                                cur_mass -= counts[t] * (long long)items[t].m;
+                                cur_vol -= counts[t] * (long long)items[t].l;
+                                counts[t] = 0;
+                            }
+                        }
+                        for (int idx : order) {
+                            if (idx == i || idx == j || idx == k) continue;
+                            const Item& it = items[idx];
+                            int maxTake = min(it.q - counts[idx],
+                                              (int)((Mmax - cur_mass) / it.m),
+                                              (int)((Vmax - cur_vol) / it.l));
+                            if (maxTake > 0) {
+                                counts[idx] += maxTake;
+                                cur_mass += maxTake * (long long)it.m;
+                                cur_vol += maxTake * (long long)it.l;
+                            }
+                        }
+                        update_best(counts);
+                    }
+                }
+            }
+        }
+    }
+}
+
+int main() {
+    // Read entire input
+    string s, line;
+    while (getline(cin, line)) s += line;
+    // Remove whitespace
+    s.erase(remove_if(s.begin(), s.end(), ::isspace), s.end());
+    // Parse JSON
+    // Remove outer braces
+    if (s.front() == '{') s = s.substr(1, s.size()-2);
+    size_t pos = 0;
+    while (pos < s.size()) {
+        if (s[pos] != '"') break;
+        size_t key_start = pos+1;
+        size_t key_end = s.find('"', key_start);
+        string key = s.substr(key_start, key_end - key_start);
+        pos = key_end + 1;
+        if (s[pos] != ':') break;
+        pos++;
+        if (s[pos] != '[') break;
+        pos++;
+        size_t array_end = s.find(']', pos);
+        string array_str = s.substr(pos, array_end - pos);
+        vector<int> nums;
+        size_t comma = 0;
+        while (true) {
+            size_t next_comma = array_str.find(',', comma);
+            if (next_comma == string::npos) {
+                nums.push_back(stoi(array_str.substr(comma)));
+                break;
+            }
+            nums.push_back(stoi(array_str.substr(comma, next_comma - comma)));
+            comma = next_comma + 1;
+        }
+        items.push_back({key, nums[0], nums[1], nums[2], nums[3]});
+        pos = array_end + 1;
+        if (pos < s.size() && s[pos] == ',') pos++;
+    }
+
+    // Three metrics
+    for (int metric = 1; metric <= 3; ++metric) {
+        vector<int> order(12);
+        iota(order.begin(), order.end(), 0);
+        if (metric == 1) {
+            sort(order.begin(), order.end(), [](int a, int b) {
+                double da = items[a].v / (items[a].m / (double)Mmax + items[a].l / (double)Vmax);
+                double db = items[b].v / (items[b].m / (double)Mmax + items[b].l / (double)Vmax);
+                return da > db;
+            });
+        } else if (metric == 2) {
+            sort(order.begin(), order.end(), [](int a, int b) {
+                return (long long)items[a].v * items[b].m > (long long)items[b].v * items[a].m;
+            });
+        } else {
+            sort(order.begin(), order.end(), [](int a, int b) {
+                return (long long)items[a].v * items[b].l > (long long)items[b].v * items[a].l;
+            });
+        }
+
+        vector<int> counts = greedy_fill(order);
+        long long cur_mass = 0, cur_vol = 0;
+        for (int i = 0; i < 12; ++i) {
+            cur_mass += counts[i] * (long long)items[i].m;
+            cur_vol += counts[i] * (long long)items[i].l;
+        }
+        swap_local_search(counts, cur_mass, cur_vol);
+        update_best(counts);
+        removal_reopt(order, counts, cur_mass, cur_vol);
+    }
+
+    // Output JSON
+    cout << "{\n";
+    for (int i = 0; i < 12; ++i) {
+        cout << " \"" << items[i].name << "\": " << best_counts[i];
+        if (i != 11) cout << ",";
+        cout << "\n";
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/deepseekreasoner_3.cpp

@@ -0,0 +1,179 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cmath>
+#include <cctype>
+#include <sstream>
+#include <map>
+
+using namespace std;
+
+typedef long long ll;
+
+struct Item {
+    string name;
+    ll q, v, m, l;
+    ll cnt; // number taken
+};
+
+// Simple JSON parser for this specific format
+bool parse_input(const string& json, vector<Item>& items, vector<string>& order) {
+    items.clear();
+    order.clear();
+    size_t i = 0;
+    // skip whitespace
+    while (i < json.size() && isspace(json[i])) i++;
+    if (i >= json.size() || json[i] != '{') return false;
+    i++;
+    while (i < json.size()) {
+        // skip whitespace
+        while (i < json.size() && isspace(json[i])) i++;
+        if (i >= json.size()) return false;
+        if (json[i] == '}') break;
+        // parse key
+        if (json[i] != '"') return false;
+        i++;
+        string key;
+        while (i < json.size() && json[i] != '"') key += json[i++];
+        if (i >= json.size() || json[i] != '"') return false;
+        i++; // skip closing quote
+        // skip to ':'
+        while (i < json.size() && isspace(json[i])) i++;
+        if (i >= json.size() || json[i] != ':') return false;
+        i++;
+        // skip whitespace
+        while (i < json.size() && isspace(json[i])) i++;
+        // expect '['
+        if (i >= json.size() || json[i] != '[') return false;
+        i++;
+        // parse four integers
+        vector<ll> nums;
+        while (nums.size() < 4) {
+            while (i < json.size() && isspace(json[i])) i++;
+            if (i >= json.size()) return false;
+            ll val = 0;
+            bool neg = false;
+            if (json[i] == '-') { neg = true; i++; }
+            while (i < json.size() && isdigit(json[i])) {
+                val = val * 10 + (json[i] - '0');
+                i++;
+            }
+            if (neg) val = -val;
+            nums.push_back(val);
+            while (i < json.size() && isspace(json[i])) i++;
+            if (nums.size() < 4) {
+                if (i >= json.size() || json[i] != ',') return false;
+                i++;
+            }
+        }
+        // expect ']'
+        while (i < json.size() && isspace(json[i])) i++;
+        if (i >= json.size() || json[i] != ']') return false;
+        i++;
+        // skip to ',' or '}'
+        while (i < json.size() && isspace(json[i])) i++;
+        if (i < json.size() && json[i] == ',') i++;
+        // store item
+        items.push_back({key, nums[0], nums[1], nums[2], nums[3], 0});
+        order.push_back(key);
+    }
+    return true;
+}
+
+int main() {
+    // read entire input
+    string json;
+    char ch;
+    while (cin.get(ch)) json += ch;
+
+    vector<Item> items;
+    vector<string> order;
+    if (!parse_input(json, items, order)) {
+        // should not happen with valid input
+        return 1;
+    }
+
+    const ll M_MAX = 20000000; // mg
+    const ll V_MAX = 25000000; // µL
+    ll remaining_mass = M_MAX;
+    ll remaining_volume = V_MAX;
+    int n = items.size(); // should be 12
+
+    // Greedy: one at a time, choose item with highest score based on remaining capacities
+    while (true) {
+        double best_score = -1;
+        int best_idx = -1;
+        for (int i = 0; i < n; i++) {
+            if (items[i].cnt >= items[i].q) continue;
+            if (items[i].m > remaining_mass || items[i].l > remaining_volume) continue;
+            // score = value per unit of normalized resource consumption
+            double score = items[i].v / (items[i].m / (double)remaining_mass + items[i].l / (double)remaining_volume);
+            if (score > best_score) {
+                best_score = score;
+                best_idx = i;
+            }
+        }
+        if (best_idx == -1) break;
+        // take one
+        items[best_idx].cnt++;
+        remaining_mass -= items[best_idx].m;
+        remaining_volume -= items[best_idx].l;
+    }
+
+    // Local improvement: try swaps and additions
+    bool improved = true;
+    while (improved) {
+        improved = false;
+        // Try to add an item without removing
+        for (int j = 0; j < n; j++) {
+            if (items[j].cnt >= items[j].q) continue;
+            if (items[j].m <= remaining_mass && items[j].l <= remaining_volume) {
+                items[j].cnt++;
+                remaining_mass -= items[j].m;
+                remaining_volume -= items[j].l;
+                improved = true;
+                break;
+            }
+        }
+        if (improved) continue;
+        // Try to swap one item for another (remove one i, add one j)
+        for (int i = 0; i < n; i++) {
+            if (items[i].cnt == 0) continue;
+            for (int j = 0; j < n; j++) {
+                if (i == j) continue;
+                if (items[j].cnt >= items[j].q) continue;
+                // Check if swapping increases value and is feasible
+                if (items[j].v > items[i].v &&
+                    remaining_mass + items[i].m >= items[j].m &&
+                    remaining_volume + items[i].l >= items[j].l) {
+                    // Perform swap
+                    items[i].cnt--;
+                    items[j].cnt++;
+                    remaining_mass += items[i].m - items[j].m;
+                    remaining_volume += items[i].l - items[j].l;
+                    improved = true;
+                    break;
+                }
+            }
+            if (improved) break;
+        }
+    }
+
+    // Output JSON in the original key order
+    cout << "{";
+    for (size_t idx = 0; idx < order.size(); idx++) {
+        string key = order[idx];
+        // find item with that name
+        for (const auto& it : items) {
+            if (it.name == key) {
+                cout << "\"" << key << "\": " << it.cnt;
+                break;
+            }
+        }
+        if (idx != order.size() - 1) cout << ",";
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/deepseekreasoner_4.cpp

@@ -0,0 +1,300 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cmath>
+#include <cctype>
+#include <sstream>
+#include <cstring>
+
+using namespace std;
+
+typedef long long ll;
+
+const ll M = 20000000;   // mass limit in mg
+const ll L = 25000000;   // volume limit in µl
+
+struct Group {
+    ll mass, vol, value;
+    int type;
+};
+
+int main() {
+    // Read entire input
+    string s;
+    char ch;
+    while (cin.get(ch)) s += ch;
+
+    // Parse JSON
+    vector<string> names;
+    vector<ll> q, v, m, l;
+    int pos = 0;
+    auto skip_ws = [&]() {
+        while (pos < (int)s.size() && isspace(s[pos])) pos++;
+    };
+    skip_ws();
+    if (s[pos] != '{') return 1;
+    pos++;
+    for (int i = 0; i < 12; ++i) {
+        skip_ws();
+        if (s[pos] != '"') return 1;
+        pos++;
+        string key;
+        while (pos < (int)s.size() && s[pos] != '"') key += s[pos++];
+        if (s[pos] != '"') return 1;
+        pos++;
+        skip_ws();
+        if (s[pos] != ':') return 1;
+        pos++;
+        skip_ws();
+        if (s[pos] != '[') return 1;
+        pos++;
+        vector<ll> nums;
+        for (int j = 0; j < 4; ++j) {
+            skip_ws();
+            ll num = 0;
+            bool neg = false;
+            if (s[pos] == '-') { neg = true; pos++; }
+            while (pos < (int)s.size() && isdigit(s[pos])) {
+                num = num * 10 + (s[pos] - '0');
+                pos++;
+            }
+            if (neg) num = -num;
+            nums.push_back(num);
+            skip_ws();
+            if (j < 3) {
+                if (s[pos] != ',') return 1;
+                pos++;
+            }
+        }
+        skip_ws();
+        if (s[pos] != ']') return 1;
+        pos++;
+        skip_ws();
+        if (i < 11) {
+            if (s[pos] != ',') return 1;
+            pos++;
+        }
+        names.push_back(key);
+        q.push_back(nums[0]);
+        v.push_back(nums[1]);
+        m.push_back(nums[2]);
+        l.push_back(nums[3]);
+    }
+    skip_ws();
+    if (s[pos] != '}') return 1;
+
+    int n = 12;
+
+    // Precompute mask values
+    int total_masks = 1 << n;
+    vector<ll> mass_mask(total_masks, 0), vol_mask(total_masks, 0), value_mask(total_masks, 0);
+    for (int mask = 0; mask < total_masks; ++mask) {
+        ll mass = 0, vol = 0, val = 0;
+        for (int i = 0; i < n; ++i) {
+            if (mask & (1 << i)) {
+                mass += q[i] * m[i];
+                vol += q[i] * l[i];
+                val += q[i] * v[i];
+            }
+        }
+        mass_mask[mask] = mass;
+        vol_mask[mask] = vol;
+        value_mask[mask] = val;
+    }
+
+    // Best solution found
+    ll best_value = -1;
+    vector<ll> best_counts(n, 0);
+
+    // 1. All variables at bounds (0 or q[i])
+    for (int mask = 0; mask < total_masks; ++mask) {
+        if (mass_mask[mask] <= M && vol_mask[mask] <= L) {
+            if (value_mask[mask] > best_value) {
+                best_value = value_mask[mask];
+                for (int i = 0; i < n; ++i)
+                    best_counts[i] = (mask & (1 << i)) ? q[i] : 0;
+            }
+        }
+    }
+
+    // 2. One free variable
+    for (int mask = 0; mask < total_masks; ++mask) {
+        for (int i = 0; i < n; ++i) {
+            int fixed_mask = mask & ~(1 << i);
+            ll mass_fixed = mass_mask[fixed_mask];
+            ll vol_fixed = vol_mask[fixed_mask];
+            ll value_fixed = value_mask[fixed_mask];
+            ll rm = M - mass_fixed;
+            ll rv = L - vol_fixed;
+            if (rm < 0 || rv < 0) continue;
+            ll max_xi = q[i];
+            if (m[i] > 0) max_xi = min(max_xi, rm / m[i]);
+            if (l[i] > 0) max_xi = min(max_xi, rv / l[i]);
+            if (max_xi >= 0) {
+                ll total_value = value_fixed + max_xi * v[i];
+                if (total_value > best_value) {
+                    best_value = total_value;
+                    for (int k = 0; k < n; ++k)
+                        best_counts[k] = (fixed_mask & (1 << k)) ? q[k] : 0;
+                    best_counts[i] = max_xi;
+                }
+            }
+        }
+    }
+
+    // 3. Two free variables
+    for (int mask = 0; mask < total_masks; ++mask) {
+        for (int i = 0; i < n; ++i) {
+            for (int j = i + 1; j < n; ++j) {
+                int fixed_mask = mask & ~(1 << i) & ~(1 << j);
+                ll mass_fixed = mass_mask[fixed_mask];
+                ll vol_fixed = vol_mask[fixed_mask];
+                ll value_fixed = value_mask[fixed_mask];
+                ll M_res = M - mass_fixed;
+                ll L_res = L - vol_fixed;
+                if (M_res < 0 || L_res < 0) continue;
+                double det = (double)m[i] * l[j] - (double)m[j] * l[i];
+                if (fabs(det) < 1e-9) continue;
+                double xi_cont = (M_res * l[j] - L_res * m[j]) / det;
+                double xj_cont = (m[i] * L_res - l[i] * M_res) / det;
+                for (int xi_round = 0; xi_round <= 1; ++xi_round) {
+                    ll xi = (xi_round == 0) ? (ll)floor(xi_cont) : (ll)ceil(xi_cont);
+                    if (xi < 0) xi = 0;
+                    if (xi > q[i]) xi = q[i];
+                    for (int xj_round = 0; xj_round <= 1; ++xj_round) {
+                        ll xj = (xj_round == 0) ? (ll)floor(xj_cont) : (ll)ceil(xj_cont);
+                        if (xj < 0) xj = 0;
+                        if (xj > q[j]) xj = q[j];
+                        ll mass = mass_fixed + xi * m[i] + xj * m[j];
+                        ll volume = vol_fixed + xi * l[i] + xj * l[j];
+                        if (mass <= M && volume <= L) {
+                            ll total_value = value_fixed + xi * v[i] + xj * v[j];
+                            if (total_value > best_value) {
+                                best_value = total_value;
+                                for (int k = 0; k < n; ++k)
+                                    best_counts[k] = (fixed_mask & (1 << k)) ? q[k] : 0;
+                                best_counts[i] = xi;
+                                best_counts[j] = xj;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Try to improve the solution by filling remaining capacity
+    ll total_mass = 0, total_vol = 0;
+    for (int i = 0; i < n; ++i) {
+        total_mass += best_counts[i] * m[i];
+        total_vol  += best_counts[i] * l[i];
+    }
+    ll rm = M - total_mass;
+    ll rv = L - total_vol;
+
+    if (rm > 0 && rv > 0) {
+        // If remaining capacities are small, use DP
+        if (rm <= 2000 && rv <= 2500) {
+            vector<Group> groups;
+            for (int i = 0; i < n; ++i) {
+                ll rq_i = q[i] - best_counts[i];
+                if (rq_i <= 0) continue;
+                ll k = rq_i;
+                for (ll p = 1; p <= k; p <<= 1) {
+                    ll take = min(p, k);
+                    groups.push_back({ m[i] * take, l[i] * take, v[i] * take, i });
+                    k -= take;
+                }
+            }
+            int RM = (int)rm;
+            int RV = (int)rv;
+            vector<vector<ll>> dp(RM + 1, vector<ll>(RV + 1, -1));
+            vector<vector<int>> from_group(RM + 1, vector<int>(RV + 1, -1));
+            dp[0][0] = 0;
+            for (int g = 0; g < (int)groups.size(); ++g) {
+                Group &gr = groups[g];
+                if (gr.mass > RM || gr.vol > RV) continue;
+                for (int x = RM; x >= gr.mass; --x) {
+                    for (int y = RV; y >= gr.vol; --y) {
+                        if (dp[x - gr.mass][y - gr.vol] != -1) {
+                            ll new_val = dp[x - gr.mass][y - gr.vol] + gr.value;
+                            if (new_val > dp[x][y]) {
+                                dp[x][y] = new_val;
+                                from_group[x][y] = g;
+                            }
+                        }
+                    }
+                }
+            }
+            // Find best additional value
+            ll best_add = 0;
+            int best_x = 0, best_y = 0;
+            for (int x = 0; x <= RM; ++x) {
+                for (int y = 0; y <= RV; ++y) {
+                    if (dp[x][y] > best_add) {
+                        best_add = dp[x][y];
+                        best_x = x;
+                        best_y = y;
+                    }
+                }
+            }
+            if (best_add > 0) {
+                vector<ll> add_counts(n, 0);
+                int x = best_x, y = best_y;
+                while (from_group[x][y] != -1) {
+                    int g = from_group[x][y];
+                    add_counts[groups[g].type] += groups[g].value / v[groups[g].type];
+                    int nx = x - groups[g].mass;
+                    int ny = y - groups[g].vol;
+                    x = nx; y = ny;
+                }
+                for (int i = 0; i < n; ++i) {
+                    best_counts[i] += add_counts[i];
+                    best_value += add_counts[i] * v[i];
+                }
+            }
+        } else {
+            // Greedy fill based on value density
+            vector<int> indices;
+            for (int i = 0; i < n; ++i)
+                if (best_counts[i] < q[i]) indices.push_back(i);
+            sort(indices.begin(), indices.end(), [&](int a, int b) {
+                double den_a = (double)v[a] / ( (double)m[a]/M + (double)l[a]/L );
+                double den_b = (double)v[b] / ( (double)m[b]/M + (double)l[b]/L );
+                return den_a > den_b;
+            });
+            vector<ll> temp_counts = best_counts;
+            ll temp_mass = total_mass, temp_vol = total_vol;
+            ll temp_rm = rm, temp_rv = rv;
+            for (int i : indices) {
+                ll can_add = min(q[i] - temp_counts[i],
+                                 min(temp_rm / m[i], temp_rv / l[i]));
+                if (can_add > 0) {
+                    temp_counts[i] += can_add;
+                    temp_mass += can_add * m[i];
+                    temp_vol  += can_add * l[i];
+                    temp_rm   -= can_add * m[i];
+                    temp_rv   -= can_add * l[i];
+                }
+            }
+            ll temp_value = 0;
+            for (int i = 0; i < n; ++i) temp_value += temp_counts[i] * v[i];
+            if (temp_value > best_value) {
+                best_value = temp_value;
+                best_counts = temp_counts;
+            }
+        }
+    }
+
+    // Output JSON
+    cout << "{\n";
+    for (int i = 0; i < n; ++i) {
+        cout << " \"" << names[i] << "\": " << best_counts[i];
+        if (i != n - 1) cout << ",";
+        cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini2.5pro.cpp

@@ -0,0 +1,234 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <array>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+const long long W_MASS = 20000000;
+const long long W_VOL = 25000000;
+const int N_ITEMS = 12;
+
+struct Item {
+    std::string name;
+    int q;
+    long long v, m, l;
+    int original_idx;
+};
+
+struct State {
+    long long m = 0, l = 0, v = 0;
+    std::vector<int> counts;
+
+    bool operator<(const State& other) const {
+        if (m != other.m) return m < other.m;
+        if (l != other.l) return l < other.l;
+        return v > other.v; // for sorting, higher value is better
+    }
+};
+
+std::vector<State> prune(std::vector<State>& states) {
+    if (states.size() <= 1) return states;
+    
+    std::sort(states.begin(), states.end(), [](const State& a, const State& b){
+        return a.v > b.v;
+    });
+
+    std::vector<State> final_pruned;
+    final_pruned.reserve(states.size());
+
+    for(const auto& s : states) {
+        bool dominated = false;
+        for(const auto& p : final_pruned) {
+            if (p.m <= s.m && p.l <= s.l) { // p.v >= s.v is guaranteed by sort order
+                dominated = true;
+                break;
+            }
+        }
+        if (!dominated) {
+            final_pruned.push_back(s);
+        }
+    }
+    return final_pruned;
+}
+
+std::vector<State> generate_states(const std::vector<Item>& items, int state_limit) {
+    int n = items.size();
+    if (n == 0) {
+        std::vector<State> res;
+        res.emplace_back();
+        res.back().counts.resize(0);
+        return res;
+    }
+
+    std::vector<State> states;
+    states.emplace_back();
+    states.back().counts.resize(n, 0);
+
+    for (int i = 0; i < n; ++i) {
+        std::vector<State> next_states;
+        int q_eff = items[i].q;
+        // Heuristic cap to prevent state explosion
+        if (q_eff > 30) q_eff = 30;
+
+        next_states.reserve(states.size() * (q_eff + 1));
+
+        for (const auto& s : states) {
+            for (int c = 0; c <= q_eff; ++c) {
+                long long next_m = s.m + c * items[i].m;
+                long long next_l = s.l + c * items[i].l;
+                if (next_m > W_MASS || next_l > W_VOL) {
+                    break;
+                }
+                State next_s;
+                next_s.m = next_m;
+                next_s.l = next_l;
+                next_s.v = s.v + c * items[i].v;
+                next_s.counts = s.counts;
+                next_s.counts[i] = c;
+                next_states.push_back(next_s);
+            }
+        }
+        
+        states = prune(next_states);
+        if (states.size() > state_limit) {
+            std::sort(states.begin(), states.end(), [](const State& a, const State& b){
+                return a.v > b.v;
+            });
+            states.resize(state_limit);
+        }
+    }
+    return states;
+}
+
+int main() {
+    std::ios_base::sync_with_stdio(false);
+    std::cin.tie(NULL);
+
+    json input_json;
+    std::cin >> input_json;
+
+    std::vector<Item> all_items;
+    int idx_counter = 0;
+    for (auto& [name, val] : input_json.items()) {
+        all_items.push_back({
+            name,
+            val[0].get<int>(),
+            val[1].get<long long>(),
+            val[2].get<long long>(),
+            val[3].get<long long>(),
+            idx_counter++
+        });
+    }
+
+    std::vector<Item> lumpy_items, dust_items;
+    
+    for (const auto& item : all_items) {
+        if (item.q > 50 && (item.m < 100000 || item.l < 100000)) {
+            dust_items.push_back(item);
+        } else {
+            lumpy_items.push_back(item);
+        }
+    }
+
+    std::sort(dust_items.begin(), dust_items.end(), [](const Item& a, const Item& b) {
+        double dens_a = (double)a.v / (a.m / (double)W_MASS * 0.5 + a.l / (double)W_VOL * 0.5 + 1e-9);
+        double dens_b = (double)b.v / (b.m / (double)W_MASS * 0.5 + b.l / (double)W_VOL * 0.5 + 1e-9);
+        return dens_a > dens_b;
+    });
+
+    std::vector<Item> lumpy_a, lumpy_b;
+    for (size_t i = 0; i < lumpy_items.size(); ++i) {
+        if (i < lumpy_items.size() / 2) {
+            lumpy_a.push_back(lumpy_items[i]);
+        } else {
+            lumpy_b.push_back(lumpy_items[i]);
+        }
+    }
+    
+    int state_limit = 4000;
+    auto states_a = generate_states(lumpy_a, state_limit);
+    auto states_b = generate_states(lumpy_b, state_limit);
+
+    long long max_total_value = -1;
+    std::vector<int> best_counts(N_ITEMS, 0);
+
+    for (const auto& s_a : states_a) {
+        for (const auto& s_b : states_b) {
+            long long current_m = s_a.m + s_b.m;
+            long long current_l = s_a.l + s_b.l;
+
+            if (current_m > W_MASS || current_l > W_VOL) continue;
+
+            long long current_v = s_a.v + s_b.v;
+            std::vector<int> current_counts(N_ITEMS, 0);
+
+            for (size_t i = 0; i < lumpy_a.size(); ++i) current_counts[lumpy_a[i].original_idx] = s_a.counts[i];
+            for (size_t i = 0; i < lumpy_b.size(); ++i) current_counts[lumpy_b[i].original_idx] = s_b.counts[i];
+            
+            long long m_rem = W_MASS - current_m;
+            long long l_rem = W_VOL - current_l;
+            long long dust_v = 0;
+            
+            for (const auto& item : dust_items) {
+                int num_to_take = item.q;
+                if (item.m > 0) num_to_take = std::min(num_to_take, (int)(m_rem / item.m));
+                if (item.l > 0) num_to_take = std::min(num_to_take, (int)(l_rem / item.l));
+                
+                if (num_to_take > 0) {
+                    m_rem -= (long long)num_to_take * item.m;
+                    l_rem -= (long long)num_to_take * item.l;
+                    dust_v += (long long)num_to_take * item.v;
+                    current_counts[item.original_idx] += num_to_take;
+                }
+            }
+            
+            if (current_v + dust_v > max_total_value) {
+                max_total_value = current_v + dust_v;
+                best_counts = current_counts;
+            }
+        }
+    }
+
+    // A pure greedy solution on all items as a baseline
+    {
+        long long m_rem = W_MASS;
+        long long l_rem = W_VOL;
+        long long current_v = 0;
+        std::vector<int> current_counts(N_ITEMS, 0);
+        std::vector<Item> sorted_all = all_items;
+        std::sort(sorted_all.begin(), sorted_all.end(), [](const Item& a, const Item& b) {
+            double dens_a = (double)a.v / (a.m / (double)W_MASS * 0.5 + a.l / (double)W_VOL * 0.5 + 1e-9);
+            double dens_b = (double)b.v / (b.m / (double)W_MASS * 0.5 + b.l / (double)W_VOL * 0.5 + 1e-9);
+            return dens_a > dens_b;
+        });
+
+        for (const auto& item : sorted_all) {
+             int num_to_take = item.q;
+             if (item.m > 0) num_to_take = std::min(num_to_take, (int)(m_rem / item.m));
+             if (item.l > 0) num_to_take = std::min(num_to_take, (int)(l_rem / item.l));
+             
+             if (num_to_take > 0) {
+                 m_rem -= (long long)num_to_take * item.m;
+                 l_rem -= (long long)num_to_take * item.l;
+                 current_v += (long long)num_to_take * item.v;
+                 current_counts[item.original_idx] = num_to_take;
+             }
+        }
+        if (current_v > max_total_value) {
+            best_counts = current_counts;
+        }
+    }
+
+    json output_json;
+    for (int i = 0; i < N_ITEMS; ++i) {
+        output_json[all_items[i].name] = best_counts[i];
+    }
+
+    std::cout << output_json.dump(1, '\t') << std::endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini2.5pro_2.cpp

@@ -0,0 +1,185 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <functional>
+
+// To create a single-file solution, the content of nlohmann/json.hpp is included here.
+// This is a placeholder for the actual header content.
+#ifndef NLOHMANN_JSON_HPP
+#include "json.hpp" // Assumes json.hpp is in the same directory or in include path.
+#endif
+
+
+using json = nlohmann::json;
+using ll = long long;
+
+const ll M_CAP = 20000000;
+const ll L_CAP = 25000000;
+
+struct Item {
+    std::string name;
+    int id;
+    int q;
+    ll v, m, l;
+    double density;
+};
+
+std::vector<Item> all_items;
+std::vector<Item> large_items, small_items;
+
+ll max_total_value = -1;
+std::vector<int> best_counts;
+
+ll states_visited = 0;
+const ll MAX_STATES_PER_RUN = 5000000;
+
+void solve(int large_item_idx, ll current_m, ll current_l, ll current_v, std::vector<int>& current_counts) {
+    if (states_visited++ > MAX_STATES_PER_RUN) {
+        return;
+    }
+
+    if (large_item_idx == large_items.size()) {
+        ll rem_m = M_CAP - current_m;
+        ll rem_l = L_CAP - current_l;
+        ll total_v = current_v;
+        
+        std::vector<int> final_counts = current_counts;
+
+        for (const auto& s_item : small_items) {
+            final_counts[s_item.id] = 0; // Ensure small item counts are reset for this path
+            if (s_item.m <= 0 && s_item.l <= 0) continue;
+            
+            ll can_take = s_item.q;
+            if (s_item.m > 0) can_take = std::min(can_take, rem_m / s_item.m);
+            if (s_item.l > 0) can_take = std::min(can_take, rem_l / s_item.l);
+            
+            if (can_take > 0) {
+                rem_m -= can_take * s_item.m;
+                rem_l -= can_take * s_item.l;
+                total_v += can_take * s_item.v;
+                final_counts[s_item.id] = can_take;
+            }
+        }
+
+        if (total_v > max_total_value) {
+            max_total_value = total_v;
+            best_counts = final_counts;
+        }
+        return;
+    }
+
+    const auto& l_item = large_items[large_item_idx];
+    ll max_k = l_item.q;
+    if (l_item.m > 0) max_k = std::min(max_k, (M_CAP - current_m) / l_item.m);
+    if (l_item.l > 0) max_k = std::min(max_k, (L_CAP - current_l) / l_item.l);
+
+    for (ll k = max_k; k >= 0; --k) { // Iterate downwards to prioritize fuller bags
+        current_counts[l_item.id] = k;
+        solve(large_item_idx + 1,
+              current_m + k * l_item.m,
+              current_l + k * l_item.l,
+              current_v + k * l_item.v,
+              current_counts);
+        if (states_visited > MAX_STATES_PER_RUN) return;
+    }
+    current_counts[l_item.id] = 0;
+}
+
+int main() {
+    std::ios_base::sync_with_stdio(false);
+    std::cin.tie(NULL);
+
+    json input;
+    std::cin >> input;
+
+    int current_id = 0;
+    for (auto const& [name, val] : input.items()) {
+        all_items.push_back({
+            name,
+            current_id++,
+            val[0].get<int>(),
+            val[1].get<ll>(),
+            val[2].get<ll>(),
+            val[3].get<ll>(),
+            0.0
+        });
+    }
+
+    ll m_thresh = M_CAP / 40;
+    ll l_thresh = L_CAP / 40;
+    for (const auto& item : all_items) {
+        if (item.m > m_thresh || item.l > l_thresh) {
+            large_items.push_back(item);
+        } else {
+            small_items.push_back(item);
+        }
+    }
+    
+    best_counts.resize(all_items.size(), 0);
+    std::vector<int> current_counts(all_items.size(), 0);
+
+    for (int i = 0; i <= 10; ++i) {
+        double alpha = i / 10.0;
+        
+        for (auto& item : small_items) {
+            if (alpha < 1e-9) {
+                item.density = (item.l > 0) ? (double)item.v / item.l : 1e18;
+            } else if (alpha > 1.0 - 1e-9) {
+                item.density = (item.m > 0) ? (double)item.v / item.m : 1e18;
+            } else {
+                double normalized_cost = alpha * (double)item.m / M_CAP + (1.0 - alpha) * (double)item.l / L_CAP;
+                item.density = (normalized_cost > 1e-12) ? (double)item.v / normalized_cost : 1e18;
+            }
+        }
+
+        std::sort(small_items.begin(), small_items.end(), [&](const Item& a, const Item& b) {
+            return a.density > b.density;
+        });
+        
+        states_visited = 0;
+        solve(0, 0, 0, 0, current_counts);
+    }
+    
+    auto run_greedy = [&](auto density_func) {
+        std::vector<Item> sorted_items = all_items;
+        std::sort(sorted_items.begin(), sorted_items.end(), [&](const Item& a, const Item& b) {
+            return density_func(a) > density_func(b);
+        });
+
+        std::vector<int> greedy_counts(all_items.size(), 0);
+        ll current_m = 0, current_l = 0, current_v = 0;
+        
+        for (const auto& item : sorted_items) {
+            ll rem_m = M_CAP - current_m;
+            ll rem_l = L_CAP - current_l;
+            ll can_take = item.q;
+            if (item.m > 0) can_take = std::min(can_take, rem_m / item.m);
+            if (item.l > 0) can_take = std::min(can_take, rem_l / item.l);
+
+            if(can_take > 0) {
+                current_m += can_take * item.m;
+                current_l += can_take * item.l;
+                current_v += can_take * item.v;
+                greedy_counts[item.id] = can_take;
+            }
+        }
+        if (current_v > max_total_value) {
+            max_total_value = current_v;
+            best_counts = greedy_counts;
+        }
+    };
+
+    run_greedy([](const Item& i) { return (i.m > 0) ? (double)i.v / i.m : 1e18; });
+    run_greedy([](const Item& i) { return (i.l > 0) ? (double)i.v / i.l : 1e18; });
+    run_greedy([](const Item& i) { return (i.m + i.l > 0) ? (double)i.v / (double)(i.m + i.l) : 1e18; });
+
+    json output;
+    for (const auto& item : all_items) {
+        output[item.name] = best_counts[item.id];
+    }
+    std::cout << output.dump(2) << std::endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini2.5pro_3.cpp

@@ -0,0 +1,184 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <array>
+#include <unordered_map>
+#include <algorithm>
+#include <utility>
+#include "json.hpp"
+
+using json = nlohmann::json;
+
+const long long MAX_MASS = 20000000;
+const long long MAX_VOLUME = 25000000;
+const int NUM_ITEMS = 12;
+const int HALF_NUM_ITEMS = 6;
+
+struct Item {
+    std::string name;
+    int q;
+    long long v, m, l;
+    int original_idx;
+};
+
+struct State {
+    long long m, l, v;
+    std::array<int, HALF_NUM_ITEMS> counts;
+};
+
+struct pair_hash {
+    template <class T1, class T2>
+    std::size_t operator () (const std::pair<T1, T2>& p) const {
+        auto h1 = std::hash<T1>{}(p.first);
+        auto h2 = std::hash<T2>{}(p.second);
+        // A simple way to combine hashes, found to be effective in practice.
+        return h1 ^ (h2 << 1);
+    }
+};
+
+using StatesMap = std::unordered_map<std::pair<long long, long long>, std::pair<long long, std::array<int, HALF_NUM_ITEMS>>, pair_hash>;
+
+StatesMap generate_states(const std::vector<Item>& items) {
+    StatesMap states;
+    states.reserve(100000); // Pre-allocation to reduce rehashes
+    states[{0, 0}] = {0, {}};
+
+    for (int i = 0; i < items.size(); ++i) {
+        const auto& item = items[i];
+        long long current_q = item.q;
+        
+        std::vector<long long> meta_quantities;
+        for (long long p = 1; current_q > 0; p *= 2) {
+            long long take = std::min(p, current_q);
+            meta_quantities.push_back(take);
+            current_q -= take;
+        }
+
+        for (const auto& k : meta_quantities) {
+            long long delta_m = k * item.m;
+            long long delta_l = k * item.l;
+            long long delta_v = k * item.v;
+
+            std::vector<std::pair<std::pair<long long, long long>, std::pair<long long, std::array<int, HALF_NUM_ITEMS>>>> updates;
+            updates.reserve(states.size());
+
+            for (const auto& s : states) {
+                long long new_m = s.first.first + delta_m;
+                long long new_l = s.first.second + delta_l;
+
+                if (new_m <= MAX_MASS && new_l <= MAX_VOLUME) {
+                    long long new_v = s.second.first + delta_v;
+                    auto new_counts = s.second.second;
+                    new_counts[i] += k;
+                    updates.push_back({{new_m, new_l}, {new_v, new_counts}});
+                }
+            }
+            
+            for (const auto& update : updates) {
+                const auto& key = update.first;
+                const auto& val = update.second;
+                auto it = states.find(key);
+                if (it == states.end() || it->second.first < val.first) {
+                    states[key] = val;
+                }
+            }
+        }
+    }
+    return states;
+}
+
+std::vector<State> prune_and_convert(const StatesMap& states_map) {
+    std::vector<State> states_vec;
+    states_vec.reserve(states_map.size());
+    for (const auto& pair : states_map) {
+        states_vec.push_back({pair.first.first, pair.first.second, pair.second.first, pair.second.second});
+    }
+
+    std::sort(states_vec.begin(), states_vec.end(), [](const State& a, const State& b) {
+        if (a.m != b.m) return a.m < b.m;
+        if (a.l != b.l) return a.l < b.l;
+        return a.v > b.v;
+    });
+
+    std::vector<State> pruned;
+    pruned.reserve(states_vec.size());
+    for (const auto& s : states_vec) {
+        while (!pruned.empty() && pruned.back().l >= s.l && pruned.back().v <= s.v) {
+            pruned.pop_back();
+        }
+        if (pruned.empty() || pruned.back().l < s.l || pruned.back().v < s.v) {
+            pruned.push_back(s);
+        }
+    }
+    return pruned;
+}
+
+int main() {
+    std::ios_base::sync_with_stdio(false);
+    std::cin.tie(NULL);
+
+    json input_json;
+    std::cin >> input_json;
+
+    std::vector<Item> all_items;
+    int idx = 0;
+    for (auto& [key, value] : input_json.items()) {
+        all_items.push_back({key, value[0], value[1], value[2], value[3], idx++});
+    }
+    
+    std::sort(all_items.begin(), all_items.end(), [](const Item& a, const Item& b){
+        return a.name < b.name;
+    });
+
+    std::vector<Item> groupA(all_items.begin(), all_items.begin() + HALF_NUM_ITEMS);
+    std::vector<Item> groupB(all_items.begin() + HALF_NUM_ITEMS, all_items.end());
+
+    StatesMap states_map_A = generate_states(groupA);
+    StatesMap states_map_B = generate_states(groupB);
+    
+    std::vector<State> listA = prune_and_convert(states_map_A);
+    std::vector<State> listB = prune_and_convert(states_map_B);
+    
+    std::sort(listA.begin(), listA.end(), [](const State& a, const State& b) {
+        return a.m < b.m;
+    });
+    std::sort(listB.begin(), listB.end(), [](const State& a, const State& b) {
+        return a.m < b.m;
+    });
+
+    long long max_val = 0;
+    std::array<int, NUM_ITEMS> best_counts = {};
+
+    int ptrB = listB.size() - 1;
+    for (const auto& s_a : listA) {
+        while (ptrB >= 0 && s_a.m + listB[ptrB].m > MAX_MASS) {
+            ptrB--;
+        }
+        if (ptrB < 0) {
+            break;
+        }
+
+        for (int i = 0; i <= ptrB; ++i) {
+            const auto& s_b = listB[i];
+            if (s_a.l + s_b.l <= MAX_VOLUME) {
+                if (s_a.v + s_b.v > max_val) {
+                    max_val = s_a.v + s_b.v;
+                    for (int j = 0; j < HALF_NUM_ITEMS; ++j) {
+                        best_counts[groupA[j].original_idx] = s_a.counts[j];
+                    }
+                    for (int j = 0; j < HALF_NUM_ITEMS; ++j) {
+                        best_counts[groupB[j].original_idx] = s_b.counts[j];
+                    }
+                }
+            }
+        }
+    }
+
+    json output_json;
+    for(int i = 0; i < NUM_ITEMS; ++i) {
+        output_json[all_items[i].name] = best_counts[i];
+    }
+    std::cout << output_json.dump(1, '\t') << std::endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini2.5pro_4.cpp

@@ -0,0 +1,203 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <map>
+#include <set>
+#include <random>
+#include <chrono>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+struct Item {
+    std::string name;
+    int q;
+    long long v, m, l;
+    double density;
+    int original_idx;
+};
+
+// Global constants
+const long long MAX_MASS = 20000000;
+const long long MAX_VOL = 25000000;
+
+int main() {
+    std::ios_base::sync_with_stdio(false);
+    std::cin.tie(NULL);
+
+    json input_json;
+    std::cin >> input_json;
+
+    std::vector<Item> original_items;
+    std::vector<std::string> key_order;
+    int idx_counter = 0;
+    for (auto& el : input_json.items()) {
+        key_order.push_back(el.key());
+        auto& props = el.value();
+        original_items.push_back({
+            el.key(),
+            (int)props[0],
+            (long long)props[1],
+            (long long)props[2],
+            (long long)props[3],
+            0.0,
+            idx_counter++
+        });
+    }
+
+    std::set<double> c_values_set;
+    c_values_set.insert(0.0);
+    c_values_set.insert(1.0);
+    for (size_t i = 0; i < original_items.size(); ++i) {
+        for (size_t j = i + 1; j < original_items.size(); ++j) {
+            auto& item1 = original_items[i];
+            auto& item2 = original_items[j];
+            long long v1 = item1.v, m1 = item1.m, l1 = item1.l;
+            long long v2 = item2.v, m2 = item2.m, l2 = item2.l;
+            
+            double num = (double)v2 * l1 - (double)v1 * l2;
+            double den = (double)v1 * (m2 - l2) - (double)v2 * (m1 - l1);
+
+            if (std::abs(den) > 1e-9) {
+                double c = num / den;
+                if (c > 1e-9 && c < 1.0 - 1e-9) {
+                    c_values_set.insert(c);
+                }
+            }
+        }
+    }
+    
+    std::vector<double> test_cs;
+    for (double c : c_values_set) {
+        test_cs.push_back(c);
+        if (c > 1e-9) test_cs.push_back(c - 1e-9);
+        if (c < 1.0 - 1e-9) test_cs.push_back(c + 1e-9);
+    }
+    std::sort(test_cs.begin(), test_cs.end());
+    test_cs.erase(std::unique(test_cs.begin(), test_cs.end()), test_cs.end());
+
+    long long best_total_value = -1;
+    std::vector<int> best_counts(original_items.size());
+    double best_c = -1.0;
+    
+    for (double c : test_cs) {
+        if (c < 0 || c > 1) continue;
+        std::vector<Item> current_items = original_items;
+        for (auto& item : current_items) {
+            double cost = c * item.m + (1.0 - c) * item.l;
+            if (cost < 1e-9) {
+                item.density = 1e18; // Effectively infinite
+            } else {
+                item.density = (double)item.v / cost;
+            }
+        }
+        
+        std::sort(current_items.begin(), current_items.end(), [](const Item& a, const Item& b) {
+            return a.density > b.density;
+        });
+
+        long long current_m = 0;
+        long long current_l = 0;
+        long long current_v = 0;
+        std::vector<int> current_counts(original_items.size(), 0);
+
+        for (const auto& item : current_items) {
+            long long can_take = item.q;
+            if (item.m > 0) can_take = std::min(can_take, (MAX_MASS - current_m) / item.m);
+            if (item.l > 0) can_take = std::min(can_take, (MAX_VOL - current_l) / item.l);
+            
+            if (can_take > 0) {
+                current_m += can_take * item.m;
+                current_l += can_take * item.l;
+                current_v += can_take * item.v;
+                current_counts[item.original_idx] = can_take;
+            }
+        }
+
+        if (current_v > best_total_value) {
+            best_total_value = current_v;
+            best_counts = current_counts;
+            best_c = c;
+        }
+    }
+
+    // Local Search to improve the best solution
+    if (best_c >= 0) {
+        std::vector<Item> sorted_by_best_c = original_items;
+        for (auto& item : sorted_by_best_c) {
+            double cost = best_c * item.m + (1.0 - best_c) * item.l;
+            if (cost < 1e-9) item.density = 1e18;
+            else item.density = (double)item.v / cost;
+        }
+        std::sort(sorted_by_best_c.begin(), sorted_by_best_c.end(), [](const Item& a, const Item& b) {
+            return a.density > b.density;
+        });
+
+        long long current_m = 0;
+        long long current_l = 0;
+        for (size_t i = 0; i < original_items.size(); ++i) {
+            current_m += (long long)best_counts[i] * original_items[i].m;
+            current_l += (long long)best_counts[i] * original_items[i].l;
+        }
+        
+        std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
+        
+        // Iteration limit is heuristic.
+        for (int iter = 0; iter < 100000; ++iter) {
+            std::vector<int> present_items_indices;
+            for (size_t i = 0; i < best_counts.size(); ++i) {
+                if (best_counts[i] > 0) {
+                    present_items_indices.push_back(i);
+                }
+            }
+            if (present_items_indices.empty()) break;
+
+            std::uniform_int_distribution<int> dist(0, present_items_indices.size() - 1);
+            int idx_to_remove = present_items_indices[dist(rng)];
+
+            long long temp_m = current_m - original_items[idx_to_remove].m;
+            long long temp_l = current_l - original_items[idx_to_remove].l;
+            long long temp_v = best_total_value - original_items[idx_to_remove].v;
+            std::vector<int> temp_counts = best_counts;
+            temp_counts[idx_to_remove]--;
+            
+            for (const auto& item : sorted_by_best_c) {
+                long long can_take = item.q - temp_counts[item.original_idx];
+                if (can_take <= 0) continue;
+                if (item.m > 0) can_take = std::min(can_take, (MAX_MASS - temp_m) / item.m);
+                if (item.l > 0) can_take = std::min(can_take, (MAX_VOL - temp_l) / item.l);
+                
+                if (can_take > 0) {
+                    temp_m += can_take * item.m;
+                    temp_l += can_take * item.l;
+                    temp_v += can_take * item.v;
+                    temp_counts[item.original_idx] += can_take;
+                }
+            }
+            
+            if (temp_v > best_total_value) {
+                best_total_value = temp_v;
+                best_counts = temp_counts;
+                current_m = temp_m;
+                current_l = temp_l;
+            }
+        }
+    }
+    
+    json output_json;
+    for (const auto& key : key_order) {
+        bool found = false;
+        for (size_t i=0; i < original_items.size(); ++i) {
+            if (original_items[i].name == key) {
+                output_json[key] = best_counts[i];
+                found = true;
+                break;
+            }
+        }
+    }
+    
+    std::cout << output_json.dump(2) << std::endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini3pro.cpp

@@ -0,0 +1,217 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <map>
+#include <ctime>
+#include <cstdlib>
+
+using namespace std;
+
+// Structure to represent each treasure category
+struct Item {
+    string name;
+    int id;
+    long long q; // quantity
+    long long v; // value
+    long long m; // mass
+    long long l; // volume
+};
+
+// Global capacity constraints
+const long long MAX_M = 20000000; // 20 kg in mg
+const long long MAX_L = 25000000; // 25 L in uL
+
+// Structure to represent a solution state
+struct Solution {
+    vector<int> counts;
+    long long total_v;
+    long long total_m;
+    long long total_l;
+
+    Solution(int n) : counts(n, 0), total_v(0), total_m(0), total_l(0) {}
+};
+
+vector<Item> items;
+int N;
+
+// Parse the JSON-like input
+void parseInput() {
+    string input, line;
+    // Read all stdin into a single string
+    while (getline(cin, line)) {
+        input += line + " ";
+    }
+
+    vector<string> tokens;
+    string current;
+    bool inQuotes = false;
+    for (char c : input) {
+        if (inQuotes) {
+            if (c == '"') {
+                inQuotes = false;
+                if (!current.empty()) tokens.push_back(current);
+                current = "";
+            } else {
+                current += c;
+            }
+        } else {
+            if (c == '"') {
+                inQuotes = true;
+            } else if (isdigit(c) || c == '-') {
+                current += c;
+            } else {
+                if (!current.empty()) {
+                    tokens.push_back(current);
+                    current = "";
+                }
+            }
+        }
+    }
+    if (!current.empty()) tokens.push_back(current);
+
+    // Tokens are expected in groups of 5: Key, q, v, m, l
+    for (size_t i = 0; i < tokens.size(); i += 5) {
+        if (i + 4 >= tokens.size()) break;
+        Item item;
+        item.name = tokens[i];
+        item.id = (int)items.size();
+        item.q = stoll(tokens[i+1]);
+        item.v = stoll(tokens[i+2]);
+        item.m = stoll(tokens[i+3]);
+        item.l = stoll(tokens[i+4]);
+        items.push_back(item);
+    }
+    N = (int)items.size();
+}
+
+// Greedily fill the bag based on a specific item order
+void fillGreedy(Solution& sol, const vector<int>& order) {
+    for (int idx : order) {
+        if (sol.counts[idx] >= items[idx].q) continue;
+        
+        long long rem_m = MAX_M - sol.total_m;
+        long long rem_l = MAX_L - sol.total_l;
+        
+        if (rem_m < items[idx].m || rem_l < items[idx].l) continue;
+        
+        long long take_m = rem_m / items[idx].m;
+        long long take_l = rem_l / items[idx].l;
+        long long take_q = items[idx].q - sol.counts[idx];
+        
+        long long count = min({take_m, take_l, take_q});
+        
+        if (count > 0) {
+            sol.counts[idx] += count;
+            sol.total_v += count * items[idx].v;
+            sol.total_m += count * items[idx].m;
+            sol.total_l += count * items[idx].l;
+        }
+    }
+}
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    srand((unsigned)time(NULL));
+
+    parseInput();
+    
+    if (N == 0) {
+        cout << "{}" << endl;
+        return 0;
+    }
+
+    double start_time = (double)clock() / CLOCKS_PER_SEC;
+    
+    Solution bestSol(N);
+    
+    int iterations = 0;
+    // Keep trying to improve the solution until time limit approaches
+    while (true) {
+        iterations++;
+        // Check time every 50 iterations to avoid overhead
+        if (iterations % 50 == 0) {
+            double curr_time = (double)clock() / CLOCKS_PER_SEC;
+            if (curr_time - start_time > 0.95) break;
+        }
+
+        // Generate a random tradeoff parameter alpha between mass and volume
+        double alpha = (double)rand() / RAND_MAX;
+        
+        // Ensure we test pure Mass and pure Volume heuristics occasionally
+        if (iterations == 1) alpha = 0.0;
+        else if (iterations == 2) alpha = 1.0;
+        else if (iterations == 3) alpha = 0.5;
+
+        // Calculate score for each item based on value per weighted resource usage
+        vector<pair<double, int>> density(N);
+        for (int i = 0; i < N; ++i) {
+            // Normalize costs to capacity to make alpha meaningful
+            double w_m = (double)items[i].m / MAX_M;
+            double w_l = (double)items[i].l / MAX_L;
+            double cost = alpha * w_m + (1.0 - alpha) * w_l;
+            if (cost < 1e-15) cost = 1e-15;
+            density[i] = { (double)items[i].v / cost, i };
+        }
+        
+        // Sort items by calculated density
+        sort(density.rbegin(), density.rend());
+        
+        vector<int> order;
+        for(auto p : density) order.push_back(p.second);
+        
+        // Construct initial greedy solution
+        Solution currSol(N);
+        fillGreedy(currSol, order);
+        
+        // Local Search: "Remove-1-and-Fill" Strategy
+        // Try to escape local optima by removing one item and refilling greedily
+        bool improved = true;
+        while (improved) {
+            improved = false;
+            Solution localBest = currSol;
+            
+            for (int i = 0; i < N; ++i) {
+                if (currSol.counts[i] > 0) {
+                    Solution temp = currSol;
+                    // Remove 1 unit of item i
+                    temp.counts[i]--;
+                    temp.total_v -= items[i].v;
+                    temp.total_m -= items[i].m;
+                    temp.total_l -= items[i].l;
+                    
+                    // Try to fill remaining space
+                    fillGreedy(temp, order);
+                    
+                    if (temp.total_v > localBest.total_v) {
+                        localBest = temp;
+                        improved = true;
+                    }
+                }
+            }
+            if (improved) currSol = localBest;
+        }
+
+        if (currSol.total_v > bestSol.total_v) {
+            bestSol = currSol;
+        }
+    }
+    
+    // Output result in JSON format
+    cout << "{";
+    map<string, int> outMap;
+    for(int i=0; i<N; ++i) {
+        outMap[items[i].name] = bestSol.counts[i];
+    }
+    
+    bool first = true;
+    for (auto const& [key, val] : outMap) {
+        if (!first) cout << ",";
+        cout << "\n \"" << key << "\": " << val;
+        first = false;
+    }
+    cout << "\n}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini3pro_1.cpp

@@ -0,0 +1,287 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <sstream>
+#include <random>
+#include <chrono>
+
+using namespace std;
+
+// Problem Constants
+const long long MAX_MASS_MG = 20000000;
+const long long MAX_VOL_UL = 25000000;
+
+struct Item {
+    string name;
+    int id;
+    long long q;
+    long long v;
+    long long m;
+    long long l;
+};
+
+// Solution state
+struct Solution {
+    vector<long long> counts;
+    long long current_m;
+    long long current_l;
+    long long current_v;
+    
+    Solution(int n) : counts(n, 0), current_m(0), current_l(0), current_v(0) {}
+};
+
+int main() {
+    // Optimize I/O operations
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    // Parse Input
+    // Reading all stdin into a string
+    string raw_input;
+    string line;
+    while(getline(cin, line)) {
+        raw_input += line + " ";
+    }
+    
+    // Replace JSON delimiters with spaces to simplify parsing
+    for(char &c : raw_input) {
+        if (c == '{' || c == '}' || c == '[' || c == ']' || c == ',' || c == '"' || c == ':') {
+            c = ' ';
+        }
+    }
+    
+    stringstream ss(raw_input);
+    string key;
+    vector<Item> items;
+    int id_gen = 0;
+    
+    // Parse loop
+    while(ss >> key) {
+        Item item;
+        item.name = key;
+        item.id = id_gen++;
+        if (!(ss >> item.q >> item.v >> item.m >> item.l)) break;
+        items.push_back(item);
+    }
+    
+    int N = items.size();
+    if (N == 0) {
+        cout << "{}" << endl;
+        return 0;
+    }
+    
+    // Random engine
+    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
+    
+    // Track best solution
+    long long best_v = -1;
+    vector<long long> best_counts(N, 0);
+    
+    // Time control
+    clock_t start_clock = clock();
+    double time_limit = 0.95; // Use slightly less than 1.0s to be safe
+    
+    // Auxiliary vector for item indices
+    vector<int> indices(N);
+    for(int i=0; i<N; ++i) indices[i] = i;
+
+    // Main Optimization Loop
+    while (true) {
+        // Check time limit
+        if ((double)(clock() - start_clock) / CLOCKS_PER_SEC > time_limit) break;
+        
+        // 1. Randomized Greedy Construction
+        
+        // Generate random weights for scoring metric
+        uniform_real_distribution<double> dist01(0.0, 1.0);
+        double w_mass = dist01(rng);
+        
+        // Occasionally try pure strategies
+        double rand_strat = dist01(rng);
+        if (rand_strat < 0.1) w_mass = 1.0;
+        else if (rand_strat < 0.2) w_mass = 0.0;
+        
+        double w_vol = 1.0 - w_mass;
+        
+        // Rank items
+        vector<pair<double, int>> ranked(N);
+        for(int i=0; i<N; ++i) {
+            double cost = 0;
+            // Normalized cost
+            if (MAX_MASS_MG > 0) cost += w_mass * ((double)items[i].m / MAX_MASS_MG);
+            if (MAX_VOL_UL > 0) cost += w_vol * ((double)items[i].l / MAX_VOL_UL);
+            
+            if (cost < 1e-15) cost = 1e-15;
+            
+            double score = (double)items[i].v / cost;
+            // Add multiplicative noise to score to explore local variations
+            double noise = dist01(rng) * 0.4 + 0.8; // Range [0.8, 1.2]
+            ranked[i] = {score * noise, i};
+        }
+        
+        sort(ranked.rbegin(), ranked.rend());
+        
+        // Fill greedily
+        Solution sol(N);
+        for(auto& p : ranked) {
+            int idx = p.second;
+            long long rem_m = MAX_MASS_MG - sol.current_m;
+            long long rem_l = MAX_VOL_UL - sol.current_l;
+            
+            long long count = items[idx].q;
+            if (items[idx].m > 0) count = min(count, rem_m / items[idx].m);
+            if (items[idx].l > 0) count = min(count, rem_l / items[idx].l);
+            
+            sol.counts[idx] = count;
+            sol.current_m += count * items[idx].m;
+            sol.current_l += count * items[idx].l;
+            sol.current_v += count * items[idx].v;
+        }
+        
+        // 2. Local Search
+        
+        // Phase A: Fill Gaps
+        // Try to add any item that fits
+        shuffle(indices.begin(), indices.end(), rng);
+        bool changed = true;
+        while(changed) {
+            changed = false;
+            for(int idx : indices) {
+                if (sol.counts[idx] < items[idx].q) {
+                    long long rem_m = MAX_MASS_MG - sol.current_m;
+                    long long rem_l = MAX_VOL_UL - sol.current_l;
+                    
+                    long long can_add = items[idx].q - sol.counts[idx];
+                    if (items[idx].m > 0) can_add = min(can_add, rem_m / items[idx].m);
+                    if (items[idx].l > 0) can_add = min(can_add, rem_l / items[idx].l);
+                    
+                    if (can_add > 0) {
+                        sol.counts[idx] += can_add;
+                        sol.current_m += can_add * items[idx].m;
+                        sol.current_l += can_add * items[idx].l;
+                        sol.current_v += can_add * items[idx].v;
+                        changed = true;
+                    }
+                }
+            }
+        }
+        
+        // Phase B: Pairwise Exchange
+        // Try to force add item j by removing items of type i
+        bool improved = true;
+        while(improved) {
+            improved = false;
+            // Check time inside local search to prevent timeout in edge cases
+            if ((double)(clock() - start_clock) / CLOCKS_PER_SEC > time_limit) break;
+
+            for(int i : indices) { // Candidate to remove
+                if (sol.counts[i] == 0) continue;
+                for(int j : indices) { // Candidate to add
+                    if (i == j || sol.counts[j] >= items[j].q) continue;
+                    
+                    // We want to add at least 1 item of j.
+                    long long rem_m = MAX_MASS_MG - sol.current_m;
+                    long long rem_l = MAX_VOL_UL - sol.current_l;
+                    
+                    long long need_m = (items[j].m > rem_m) ? (items[j].m - rem_m) : 0;
+                    long long need_l = (items[j].l > rem_l) ? (items[j].l - rem_l) : 0;
+                    
+                    if (need_m == 0 && need_l == 0) {
+                        // Fits without removal (should be handled by gap fill, but safe to have)
+                        long long take = 1; 
+                        sol.counts[j] += take;
+                        sol.current_m += items[j].m;
+                        sol.current_l += items[j].l;
+                        sol.current_v += items[j].v;
+                        improved = true;
+                        goto next_iter;
+                    }
+                    
+                    // Calculate minimum items of i to remove to fit 1 j
+                    long long remove_i = 0;
+                    bool possible = true;
+                    
+                    if (need_m > 0) {
+                        if (items[i].m == 0) { possible = false; }
+                        else remove_i = max(remove_i, (need_m + items[i].m - 1) / items[i].m);
+                    }
+                    if (possible && need_l > 0) {
+                        if (items[i].l == 0) { possible = false; }
+                        else remove_i = max(remove_i, (need_l + items[i].l - 1) / items[i].l);
+                    }
+                    
+                    if (!possible || remove_i > sol.counts[i]) continue;
+                    
+                    // Tentative Swap
+                    // Remove k items of i
+                    long long old_count_i = sol.counts[i];
+                    long long old_count_j = sol.counts[j];
+                    long long old_m = sol.current_m;
+                    long long old_l = sol.current_l;
+                    long long old_v = sol.current_v;
+                    
+                    sol.counts[i] -= remove_i;
+                    sol.current_m -= remove_i * items[i].m;
+                    sol.current_l -= remove_i * items[i].l;
+                    sol.current_v -= remove_i * items[i].v;
+                    
+                    // Fill with j as much as possible
+                    long long can_add_j = items[j].q - sol.counts[j];
+                    long long room_m = MAX_MASS_MG - sol.current_m;
+                    long long room_l = MAX_VOL_UL - sol.current_l;
+                    
+                    if (items[j].m > 0) can_add_j = min(can_add_j, room_m / items[j].m);
+                    if (items[j].l > 0) can_add_j = min(can_add_j, room_l / items[j].l);
+                    
+                    if (can_add_j < 1) {
+                        // Should not happen if logic is correct, but sanity check
+                        // Revert
+                        sol.counts[i] = old_count_i;
+                        sol.counts[j] = old_count_j;
+                        sol.current_m = old_m;
+                        sol.current_l = old_l;
+                        sol.current_v = old_v;
+                        continue;
+                    }
+                    
+                    sol.counts[j] += can_add_j;
+                    sol.current_m += can_add_j * items[j].m;
+                    sol.current_l += can_add_j * items[j].l;
+                    sol.current_v += can_add_j * items[j].v;
+                    
+                    // Check improvement
+                    if (sol.current_v > old_v) {
+                        improved = true;
+                        goto next_iter;
+                    } else {
+                        // Revert
+                        sol.counts[i] = old_count_i;
+                        sol.counts[j] = old_count_j;
+                        sol.current_m = old_m;
+                        sol.current_l = old_l;
+                        sol.current_v = old_v;
+                    }
+                }
+            }
+            next_iter:;
+        }
+        
+        // Update Global Best
+        if (sol.current_v > best_v) {
+            best_v = sol.current_v;
+            best_counts = sol.counts;
+        }
+    }
+    
+    // Output Result
+    cout << "{" << endl;
+    for(int i=0; i<N; ++i) {
+        cout << " \"" << items[i].name << "\": " << best_counts[i];
+        if (i < N - 1) cout << ",";
+        cout << endl;
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini3pro_2.cpp

@@ -0,0 +1,288 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <ctime>
+#include <cstdlib>
+#include <random>
+#include <chrono>
+
+using namespace std;
+
+const long long MAX_M = 20000000; // 20 kg in mg
+const long long MAX_L = 25000000; // 25 L in uL
+
+struct Item {
+    string name;
+    int id;
+    int q;
+    long long v, m, l;
+};
+
+struct Solution {
+    vector<int> counts;
+    long long total_v;
+    long long total_m;
+    long long total_l;
+
+    Solution(int n) : counts(n, 0), total_v(0), total_m(0), total_l(0) {}
+
+    // Try to add one unit of item idx
+    bool add(int idx, const vector<Item>& items) {
+        if (counts[idx] >= items[idx].q) return false;
+        if (total_m + items[idx].m > MAX_M) return false;
+        if (total_l + items[idx].l > MAX_L) return false;
+        counts[idx]++;
+        total_v += items[idx].v;
+        total_m += items[idx].m;
+        total_l += items[idx].l;
+        return true;
+    }
+
+    // Try to remove one unit of item idx
+    bool remove(int idx, const vector<Item>& items) {
+        if (counts[idx] <= 0) return false;
+        counts[idx]--;
+        total_v -= items[idx].v;
+        total_m -= items[idx].m;
+        total_l -= items[idx].l;
+        return true;
+    }
+    
+    // Fill remaining space with items in order of p
+    void fill(const vector<Item>& items, const vector<int>& p) {
+        for (int idx : p) {
+            long long rem_m = MAX_M - total_m;
+            long long rem_l = MAX_L - total_l;
+            
+            long long count_by_m = (items[idx].m == 0) ? items[idx].q : rem_m / items[idx].m;
+            long long count_by_l = (items[idx].l == 0) ? items[idx].q : rem_l / items[idx].l;
+            
+            int take = (int)min((long long)(items[idx].q - counts[idx]), min(count_by_m, count_by_l));
+            
+            if (take > 0) {
+                counts[idx] += take;
+                total_v += (long long)take * items[idx].v;
+                total_m += (long long)take * items[idx].m;
+                total_l += (long long)take * items[idx].l;
+            }
+        }
+    }
+};
+
+vector<Item> items;
+int N;
+
+void parse_input() {
+    string s, line;
+    while (getline(cin, line)) s += line;
+    
+    // Remove whitespace
+    string clean;
+    clean.reserve(s.size());
+    for (char c : s) if (!isspace(c)) clean += c;
+    s = clean;
+
+    size_t pos = 1; // skip '{'
+    while (pos < s.length() && s[pos] != '}') {
+        if (s[pos] == ',') { pos++; continue; }
+        if (s[pos] == '"') {
+            size_t end_quote = s.find('"', pos + 1);
+            string key = s.substr(pos + 1, end_quote - pos - 1);
+            pos = end_quote + 1;
+            if (s[pos] == ':') pos++;
+            if (s[pos] == '[') pos++;
+            
+            Item item;
+            item.name = key;
+            item.id = items.size();
+            
+            for (int i = 0; i < 4; ++i) {
+                size_t next_comma = s.find_first_of(",]", pos);
+                string num_str = s.substr(pos, next_comma - pos);
+                long long val = stoll(num_str);
+                if (i == 0) item.q = (int)val;
+                else if (i == 1) item.v = val;
+                else if (i == 2) item.m = val;
+                else if (i == 3) item.l = val;
+                pos = next_comma + 1;
+            }
+            items.push_back(item);
+        } else {
+            pos++;
+        }
+    }
+}
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    parse_input();
+    N = items.size();
+    
+    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
+    std::default_random_engine generator(seed);
+    std::uniform_real_distribution<double> dist(0.0, 1.0);
+    srand(seed);
+
+    Solution best_sol(N);
+    
+    clock_t start_time = clock();
+    // Use 0.9 seconds to stay safe within 1s limit
+    double time_limit = 0.9; 
+
+    auto solve_heuristic = [&](double alpha, double beta, bool rand_perturb) {
+        vector<int> p(N);
+        for(int i=0; i<N; ++i) p[i] = i;
+        
+        sort(p.begin(), p.end(), [&](int a, int b) {
+            double wa = (double)items[a].v / (alpha * items[a].m + beta * items[a].l + 1e-9);
+            double wb = (double)items[b].v / (alpha * items[b].m + beta * items[b].l + 1e-9);
+            if (rand_perturb) {
+                // Slightly randomize the density to break ties or explore neighbors
+                wa *= (0.95 + 0.1 * dist(generator));
+                wb *= (0.95 + 0.1 * dist(generator));
+            }
+            return wa > wb;
+        });
+        
+        Solution cur(N);
+        cur.fill(items, p);
+        
+        // Local Search / Hill Climbing
+        bool improved = true;
+        while (improved) {
+            improved = false;
+            
+            // 1. Try adding items that fit
+            for (int i = 0; i < N; ++i) {
+                if (cur.add(i, items)) {
+                    improved = true;
+                    while(cur.add(i, items));
+                }
+            }
+            
+            // 2. Try swapping: remove 1 item, fill with others
+            vector<int> check_order(N);
+            for(int k=0; k<N; ++k) check_order[k] = k;
+            std::shuffle(check_order.begin(), check_order.end(), generator);
+            
+            for (int i : check_order) {
+                if (cur.counts[i] > 0) {
+                    cur.remove(i, items);
+                    long long val_prev = cur.total_v + items[i].v;
+                    
+                    // Try filling with current heuristic order p
+                    Solution temp = cur;
+                    temp.fill(items, p);
+                    
+                    if (temp.total_v > val_prev) {
+                        cur = temp;
+                        improved = true;
+                        break; 
+                    } else {
+                        cur.add(i, items); // Revert
+                    }
+                }
+            }
+        }
+        
+        if (cur.total_v > best_sol.total_v) {
+            best_sol = cur;
+        }
+    };
+
+    // 1. Deterministic Sweeps
+    for (int i = 0; i <= 20; ++i) {
+        double alpha = i / 20.0;
+        solve_heuristic(alpha, 1.0 - alpha, false);
+        solve_heuristic(alpha, 1.0, false);
+        solve_heuristic(1.0, alpha, false);
+    }
+    
+    // 2. Randomized Search + Iterated Greedy
+    while ((double)(clock() - start_time) / CLOCKS_PER_SEC < time_limit) {
+        // Random Weights from scratch
+        double alpha = dist(generator);
+        double beta = dist(generator);
+        solve_heuristic(alpha, beta, true);
+        
+        // Iterated Greedy: Perturb best solution
+        if (best_sol.total_v > 0) {
+            Solution cur = best_sol;
+            
+            // Remove random parts
+            int types_to_reduce = 1 + rand() % 4;
+            for(int k=0; k<types_to_reduce; ++k) {
+                int idx = rand() % N;
+                if (cur.counts[idx] > 0) {
+                    int remove_cnt = 1 + rand() % (max(1, cur.counts[idx]/2) + 1);
+                    for(int r=0; r<remove_cnt; ++r) cur.remove(idx, items);
+                }
+            }
+            
+            // Generate random weights for refill
+            double a = dist(generator);
+            double b = dist(generator);
+            vector<int> p(N);
+            for(int i=0; i<N; ++i) p[i] = i;
+            sort(p.begin(), p.end(), [&](int x, int y) {
+                double wx = (double)items[x].v / (a * items[x].m + b * items[x].l + 1e-9);
+                double wy = (double)items[y].v / (a * items[y].m + b * items[y].l + 1e-9);
+                return wx > wy;
+            });
+            
+            cur.fill(items, p);
+            
+            // Improve
+            bool improved = true;
+            while (improved) {
+                improved = false;
+                for (int i = 0; i < N; ++i) {
+                    if (cur.add(i, items)) {
+                        improved = true;
+                        while(cur.add(i, items));
+                    }
+                }
+                vector<int> check_order(N);
+                for(int k=0; k<N; ++k) check_order[k] = k;
+                std::shuffle(check_order.begin(), check_order.end(), generator);
+                for (int i : check_order) {
+                    if (cur.counts[i] > 0) {
+                        cur.remove(i, items);
+                        long long val_prev = cur.total_v + items[i].v;
+                        Solution temp = cur;
+                        temp.fill(items, p);
+                        if (temp.total_v > val_prev) {
+                            cur = temp;
+                            improved = true;
+                            break; 
+                        } else {
+                            cur.add(i, items);
+                        }
+                    }
+                }
+            }
+            if (cur.total_v > best_sol.total_v) best_sol = cur;
+        }
+    }
+
+    // Output
+    vector<int> out_order(N);
+    for(int i=0; i<N; ++i) out_order[i] = i;
+    sort(out_order.begin(), out_order.end(), [&](int a, int b){
+        return items[a].name < items[b].name;
+    });
+
+    cout << "{";
+    for (size_t k = 0; k < out_order.size(); ++k) {
+        int idx = out_order[k];
+        cout << "\n \"" << items[idx].name << "\": " << best_sol.counts[idx];
+        if (k < out_order.size() - 1) cout << ",";
+        else cout << "\n";
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini3pro_3.cpp

@@ -0,0 +1,251 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <map>
+#include <chrono>
+#include <random>
+#include <iomanip>
+
+using namespace std;
+
+// Problem Constants
+const long long MAX_MASS = 20000000; // 20 kg in mg
+const long long MAX_VOL = 25000000;  // 25 L in uL
+
+struct Item {
+    string name;
+    int id;
+    int q;
+    long long v;
+    long long m;
+    long long l;
+};
+
+// Global variables
+vector<Item> items;
+vector<string> keys_order;
+map<string, int> name_to_id;
+int N;
+
+// Solution State
+vector<int> best_counts;
+long long best_total_value = -1;
+
+void parse_input() {
+    char c;
+    // Skip initial whitespace and opening brace if present
+    // The JSON input starts with {
+    
+    while (cin >> c) {
+        if (c == '"') {
+            string key = "";
+            // Read key until closing quote
+            while (cin.get(c) && c != '"') {
+                key += c;
+            }
+            
+            // Key found. Expect : then [
+            while (cin >> c && c != '[');
+            
+            // Read array values
+            long long q, v, m, l;
+            
+            // Read q
+            cin >> q;
+            // Skip to comma
+            while (cin >> c && c != ',');
+            
+            // Read v
+            cin >> v;
+            // Skip to comma
+            while (cin >> c && c != ',');
+            
+            // Read m
+            cin >> m;
+            // Skip to comma
+            while (cin >> c && c != ',');
+            
+            // Read l
+            cin >> l;
+            // Skip to closing bracket
+            while (cin >> c && c != ']');
+            
+            Item item;
+            item.name = key;
+            item.q = (int)q;
+            item.v = v;
+            item.m = m;
+            item.l = l;
+            item.id = items.size();
+            
+            name_to_id[key] = item.id;
+            keys_order.push_back(key);
+            items.push_back(item);
+        }
+    }
+    N = items.size();
+    best_counts.resize(N, 0);
+}
+
+// Timer
+auto start_time = chrono::high_resolution_clock::now();
+
+double get_elapsed() {
+    auto now = chrono::high_resolution_clock::now();
+    return chrono::duration<double>(now - start_time).count();
+}
+
+int main() {
+    // Fast IO
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    parse_input();
+    
+    if (N == 0) {
+        cout << "{}" << endl;
+        return 0;
+    }
+
+    // Random number generator
+    mt19937 rng(1337);
+    uniform_real_distribution<double> dist_real(0.0, 1.0);
+    uniform_int_distribution<int> dist_int(0, N - 1);
+
+    // Indices for sorting
+    vector<int> p(N);
+    for(int i=0; i<N; ++i) p[i] = i;
+
+    // Temporary solution storage
+    vector<int> current_counts(N);
+    
+    // Main optimization loop
+    // We run multiple iterations of randomized greedy heuristics
+    // Since N=12, we can run many iterations in 1 second.
+    while (get_elapsed() < 0.90) {
+        
+        // Strategy: Randomized Weights for Greedy
+        // Generate random weights for mass and volume penalties
+        // This corresponds to exploring the dual space of the relaxed LP.
+        double w_m = dist_real(rng);
+        double w_l = dist_real(rng);
+        
+        // Occasionally force extreme weights to explore boundaries
+        double r = dist_real(rng);
+        if (r < 0.05) { w_m = 1.0; w_l = 0.0; }
+        else if (r < 0.10) { w_m = 0.0; w_l = 1.0; }
+        else if (r < 0.15) { w_m = 1.0; w_l = 1.0; } // Equal weight
+        else if (r < 0.20) { w_m = 1.0; w_l = 0.0001; } // Nearly ignore volume
+        else if (r < 0.25) { w_m = 0.0001; w_l = 1.0; } // Nearly ignore mass
+
+        // Compute scores and sort
+        // Heuristic: Value / Weighted_Cost
+        // Cost is normalized by capacity to handle different units
+        sort(p.begin(), p.end(), [&](int i, int j) {
+            double cost_i = w_m * ((double)items[i].m / MAX_MASS) + w_l * ((double)items[i].l / MAX_VOL);
+            double cost_j = w_m * ((double)items[j].m / MAX_MASS) + w_l * ((double)items[j].l / MAX_VOL);
+            if (cost_i < 1e-12) cost_i = 1e-12;
+            if (cost_j < 1e-12) cost_j = 1e-12;
+            return (items[i].v / cost_i) > (items[j].v / cost_j);
+        });
+
+        // Current solution state
+        long long current_m = 0;
+        long long current_l = 0;
+        long long current_v = 0;
+        fill(current_counts.begin(), current_counts.end(), 0);
+
+        // Perturbation Strategy:
+        // Sometimes, force a random item to have a random count (Fix & Fill)
+        // This helps escape local optima where greedy dominates.
+        bool forced = false;
+        int force_idx = -1;
+        
+        if (dist_real(rng) < 0.3) {
+            force_idx = dist_int(rng);
+            uniform_int_distribution<int> q_dist(1, items[force_idx].q);
+            int force_qty = q_dist(rng);
+            
+            // Only apply if feasible alone
+            if (items[force_idx].m * (long long)force_qty <= MAX_MASS && 
+                items[force_idx].l * (long long)force_qty <= MAX_VOL) {
+                current_counts[force_idx] = force_qty;
+                current_m += items[force_idx].m * force_qty;
+                current_l += items[force_idx].l * force_qty;
+                current_v += items[force_idx].v * force_qty;
+                forced = true;
+            }
+        }
+
+        // Greedy Fill Phase
+        for (int i : p) {
+            if (forced && i == force_idx) continue;
+            
+            long long rem_m = MAX_MASS - current_m;
+            long long rem_l = MAX_VOL - current_l;
+            
+            if (rem_m < 0) rem_m = 0;
+            if (rem_l < 0) rem_l = 0;
+            
+            int can_take_m = (items[i].m == 0) ? items[i].q : (int)(rem_m / items[i].m);
+            int can_take_l = (items[i].l == 0) ? items[i].q : (int)(rem_l / items[i].l);
+            
+            int take = min(items[i].q, min(can_take_m, can_take_l));
+            
+            // Small mutation: Occasionally take slightly less than max possible
+            // to leave space for other items
+            if (take > 0 && dist_real(rng) < 0.05) {
+                take = max(0, take - 1);
+            }
+
+            current_counts[i] = take;
+            current_m += (long long)take * items[i].m;
+            current_l += (long long)take * items[i].l;
+            current_v += (long long)take * items[i].v;
+        }
+        
+        // Gap Filling Phase
+        // Iterate through all items again to fill any remaining space
+        // This is necessary because the sorted order might have skipped items 
+        // that now fit in the small remaining space.
+        for (int i = 0; i < N; ++i) {
+            if (current_counts[i] < items[i].q) {
+                 long long rem_m = MAX_MASS - current_m;
+                 long long rem_l = MAX_VOL - current_l;
+                 
+                 if (items[i].m <= rem_m && items[i].l <= rem_l) {
+                     int can_take_m = (items[i].m == 0) ? items[i].q : (int)(rem_m / items[i].m);
+                     int can_take_l = (items[i].l == 0) ? items[i].q : (int)(rem_l / items[i].l);
+                     int extra = min(items[i].q - current_counts[i], min(can_take_m, can_take_l));
+                     
+                     current_counts[i] += extra;
+                     current_m += (long long)extra * items[i].m;
+                     current_l += (long long)extra * items[i].l;
+                     current_v += (long long)extra * items[i].v;
+                 }
+            }
+        }
+
+        // Update Global Best
+        if (current_v > best_total_value) {
+            best_total_value = current_v;
+            best_counts = current_counts;
+        }
+    }
+
+    // Output JSON
+    cout << "{" << endl;
+    for (size_t i = 0; i < keys_order.size(); ++i) {
+        string key = keys_order[i];
+        int id = name_to_id[key];
+        cout << " \"" << key << "\": " << best_counts[id];
+        if (i < keys_order.size() - 1) {
+            cout << ",";
+        }
+        cout << endl;
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gemini3pro_4.cpp

@@ -0,0 +1,284 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <map>
+#include <cmath>
+#include <ctime>
+#include <random>
+#include <climits>
+
+using namespace std;
+
+// Problem constants
+const long long MAX_M = 20000000;
+const long long MAX_L = 25000000;
+
+struct Item {
+    string name;
+    int q;
+    long long v, m, l;
+    int original_index;
+};
+
+struct Solution {
+    vector<int> counts;
+    long long total_v;
+    long long total_m;
+    long long total_l;
+};
+
+vector<Item> items;
+vector<string> key_order;
+Solution best_sol;
+
+// Parse JSON from stdin
+void parse_input() {
+    string data;
+    char c;
+    while (cin.get(c)) data += c;
+
+    size_t n = data.size();
+    size_t i = 0;
+
+    while (i < n) {
+        // Find start of a key string
+        while (i < n && data[i] != '"') i++;
+        if (i >= n) break;
+        i++; // skip "
+
+        string key = "";
+        while (i < n && data[i] != '"') {
+            key += data[i];
+            i++;
+        }
+        i++; // skip closing "
+
+        // Search for colon to confirm it's a key
+        size_t temp_i = i;
+        while (temp_i < n && isspace(data[temp_i])) temp_i++;
+        if (temp_i >= n || data[temp_i] != ':') {
+            // Not a key-value pair we are interested in (or end of file)
+            i = temp_i;
+            continue;
+        }
+        i = temp_i + 1; // skip :
+
+        // Search for array start
+        while (i < n && data[i] != '[') i++;
+        if (i >= n) break;
+        i++; // skip [
+
+        // Parse 4 numbers
+        long long vals[4];
+        for (int k = 0; k < 4; ++k) {
+            while (i < n && !isdigit(data[i])) i++;
+            string num_s = "";
+            while (i < n && isdigit(data[i])) {
+                num_s += data[i];
+                i++;
+            }
+            if (!num_s.empty()) vals[k] = stoll(num_s);
+            else vals[k] = 0;
+        }
+
+        Item item;
+        item.name = key;
+        item.q = (int)vals[0];
+        item.v = vals[1];
+        item.m = vals[2];
+        item.l = vals[3];
+        item.original_index = items.size();
+        
+        items.push_back(item);
+        key_order.push_back(key);
+
+        // skip until ]
+        while (i < n && data[i] != ']') i++;
+        i++;
+    }
+}
+
+int main() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    parse_input();
+
+    int N = items.size();
+    if (N == 0) {
+        cout << "{}" << endl;
+        return 0;
+    }
+
+    // Map name to index for easy lookup later
+    map<string, int> name_to_idx;
+    for (int i = 0; i < N; ++i) {
+        name_to_idx[items[i].name] = i;
+    }
+
+    // Initialize best solution
+    best_sol.counts.assign(N, 0);
+    best_sol.total_v = 0;
+    best_sol.total_m = 0;
+    best_sol.total_l = 0;
+
+    mt19937 rng(12345);
+    clock_t start_time = clock();
+
+    // Phase 1: GRASP (Greedy Randomized Adaptive Search Procedure)
+    // Run for 40% of allowed time
+    while ((double)(clock() - start_time) / CLOCKS_PER_SEC < 0.4) {
+        // Random alpha for linear combination of constraints
+        double alpha = (double)(rng() % 1001) / 1000.0;
+        vector<int> p(N);
+        for (int k = 0; k < N; ++k) p[k] = k;
+
+        // Randomized sorting based on value density
+        shuffle(p.begin(), p.end(), rng); 
+        sort(p.begin(), p.end(), [&](int a, int b) {
+            double m_norm_a = (double)items[a].m / MAX_M;
+            double l_norm_a = (double)items[a].l / MAX_L;
+            double cost_a = alpha * m_norm_a + (1.0 - alpha) * l_norm_a;
+            
+            double m_norm_b = (double)items[b].m / MAX_M;
+            double l_norm_b = (double)items[b].l / MAX_L;
+            double cost_b = alpha * m_norm_b + (1.0 - alpha) * l_norm_b;
+            
+            if (cost_a <= 1e-12) return true;
+            if (cost_b <= 1e-12) return false;
+
+            double score_a = items[a].v / cost_a;
+            double score_b = items[b].v / cost_b;
+            return score_a > score_b;
+        });
+
+        Solution curr;
+        curr.counts.assign(N, 0);
+        curr.total_v = 0;
+        curr.total_m = 0;
+        curr.total_l = 0;
+
+        for (int idx : p) {
+            long long rem_m = MAX_M - curr.total_m;
+            long long rem_l = MAX_L - curr.total_l;
+            
+            int can_take = items[idx].q;
+            if (items[idx].m > 0) can_take = min((long long)can_take, rem_m / items[idx].m);
+            if (items[idx].l > 0) can_take = min((long long)can_take, rem_l / items[idx].l);
+            
+            if (can_take > 0) {
+                curr.counts[idx] = can_take;
+                curr.total_v += (long long)can_take * items[idx].v;
+                curr.total_m += (long long)can_take * items[idx].m;
+                curr.total_l += (long long)can_take * items[idx].l;
+            }
+        }
+
+        if (curr.total_v > best_sol.total_v) {
+            best_sol = curr;
+        }
+    }
+
+    // Phase 2: Local Search / Hill Climbing
+    // Start from best found in GRASP
+    Solution curr = best_sol;
+    vector<int> candidates; 
+    candidates.reserve(N);
+
+    int iter = 0;
+    while (true) {
+        iter++;
+        // Check time every 1024 iterations
+        if ((iter & 1023) == 0) {
+            if ((double)(clock() - start_time) / CLOCKS_PER_SEC > 0.98) break;
+        }
+
+        Solution next_sol = curr;
+        int move_type = rng() % 3;
+
+        if (move_type == 0) { 
+            // Move: Add item and Repair if needed
+            int idx = rng() % N;
+            if (next_sol.counts[idx] < items[idx].q) {
+                next_sol.counts[idx]++;
+                next_sol.total_v += items[idx].v;
+                next_sol.total_m += items[idx].m;
+                next_sol.total_l += items[idx].l;
+
+                // Repair if invalid
+                while (next_sol.total_m > MAX_M || next_sol.total_l > MAX_L) {
+                    candidates.clear();
+                    for(int k=0; k<N; ++k) if(next_sol.counts[k] > 0) candidates.push_back(k);
+                    if(candidates.empty()) break; 
+                    
+                    int victim = candidates[rng() % candidates.size()];
+                    next_sol.counts[victim]--;
+                    next_sol.total_v -= items[victim].v;
+                    next_sol.total_m -= items[victim].m;
+                    next_sol.total_l -= items[victim].l;
+                }
+                
+                // If valid and not worse, accept
+                if (next_sol.total_m <= MAX_M && next_sol.total_l <= MAX_L) {
+                    if (next_sol.total_v >= curr.total_v) {
+                        curr = next_sol;
+                        if (curr.total_v > best_sol.total_v) best_sol = curr;
+                    }
+                }
+            }
+        } else if (move_type == 1) {
+            // Move: Swap (Add i, Remove j)
+            int i = rng() % N;
+            int j = rng() % N;
+            
+            if (i != j && next_sol.counts[i] < items[i].q && next_sol.counts[j] > 0) {
+                next_sol.counts[i]++;
+                next_sol.total_v += items[i].v;
+                next_sol.total_m += items[i].m;
+                next_sol.total_l += items[i].l;
+                
+                next_sol.counts[j]--;
+                next_sol.total_v -= items[j].v;
+                next_sol.total_m -= items[j].m;
+                next_sol.total_l -= items[j].l;
+                
+                // Only accept if valid and not worse
+                if (next_sol.total_m <= MAX_M && next_sol.total_l <= MAX_L) {
+                    if (next_sol.total_v >= curr.total_v) {
+                        curr = next_sol;
+                        if (curr.total_v > best_sol.total_v) best_sol = curr;
+                    }
+                }
+            }
+        } else {
+            // Move: Fill slack (Add only, valid check immediately)
+            int idx = rng() % N;
+            if (next_sol.counts[idx] < items[idx].q) {
+                if (next_sol.total_m + items[idx].m <= MAX_M && 
+                    next_sol.total_l + items[idx].l <= MAX_L) {
+                    next_sol.counts[idx]++;
+                    next_sol.total_v += items[idx].v;
+                    next_sol.total_m += items[idx].m;
+                    next_sol.total_l += items[idx].l;
+                    
+                    curr = next_sol;
+                    if (curr.total_v > best_sol.total_v) best_sol = curr;
+                }
+            }
+        }
+    }
+
+    // Output JSON
+    cout << "{" << endl;
+    for (size_t i = 0; i < key_order.size(); ++i) {
+        string key = key_order[i];
+        int idx = name_to_idx[key];
+        cout << " \"" << key << "\": " << best_sol.counts[idx];
+        if (i < key_order.size() - 1) cout << ",";
+        cout << endl;
+    }
+    cout << "}" << endl;
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.1.cpp

@@ -0,0 +1,334 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+using ll = long long;
+
+struct Cat {
+    string name;
+    ll q, v, m, l;
+};
+
+struct Package {
+    int type;
+    int cnt;
+    ll value;
+    int sm, sl;
+};
+
+struct Solution {
+    vector<ll> cnts;
+    ll val;
+    ll mass;
+    ll vol;
+};
+
+static const ll MAX_MASS = 20LL * 1000000LL; // 20 kg in mg
+static const ll MAX_VOL  = 25LL * 1000000LL; // 25 L in uL
+
+string inputStr;
+size_t posPtr = 0;
+
+void skipWS() {
+    while (posPtr < inputStr.size() && isspace((unsigned char)inputStr[posPtr])) posPtr++;
+}
+
+ll parseLL() {
+    skipWS();
+    int sign = 1;
+    if (posPtr < inputStr.size() && (inputStr[posPtr] == '-' || inputStr[posPtr] == '+')) {
+        if (inputStr[posPtr] == '-') sign = -1;
+        posPtr++;
+    }
+    ll val = 0;
+    while (posPtr < inputStr.size() && isdigit((unsigned char)inputStr[posPtr])) {
+        val = val * 10 + (inputStr[posPtr] - '0');
+        posPtr++;
+    }
+    return sign * val;
+}
+
+vector<Cat> parseInput() {
+    vector<Cat> cats;
+    skipWS();
+    if (posPtr < inputStr.size() && inputStr[posPtr] == '{') posPtr++;
+    while (true) {
+        skipWS();
+        if (posPtr >= inputStr.size()) break;
+        if (inputStr[posPtr] == '}') {
+            posPtr++;
+            break;
+        }
+        // parse key
+        if (inputStr[posPtr] != '"') break;
+        posPtr++;
+        size_t start = posPtr;
+        while (posPtr < inputStr.size() && inputStr[posPtr] != '"') posPtr++;
+        string key = inputStr.substr(start, posPtr - start);
+        if (posPtr < inputStr.size() && inputStr[posPtr] == '"') posPtr++;
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == ':') posPtr++;
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == '[') posPtr++;
+
+        ll q = parseLL();
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == ',') posPtr++;
+        ll v = parseLL();
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == ',') posPtr++;
+        ll m = parseLL();
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == ',') posPtr++;
+        ll l = parseLL();
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == ']') posPtr++;
+        skipWS();
+        if (posPtr < inputStr.size() && inputStr[posPtr] == ',') posPtr++;
+
+        Cat c;
+        c.name = key;
+        c.q = q;
+        c.v = v;
+        c.m = m;
+        c.l = l;
+        cats.push_back(c);
+    }
+    return cats;
+}
+
+Solution solveDP(const vector<Cat>& cats) {
+    int n = (int)cats.size();
+    const int TARGET = 200;
+
+    ll M = MAX_MASS;
+    ll L = MAX_VOL;
+
+    ll fMass = max(1LL, (M + TARGET - 1) / TARGET); // ceil(M/TARGET)
+    ll fVol  = max(1LL, (L + TARGET - 1) / TARGET);
+
+    int sM = (int)(M / fMass); // <= TARGET
+    int sL = (int)(L / fVol);  // <= TARGET
+
+    int width = sL + 1;
+    int S = (sM + 1) * (sL + 1);
+
+    vector<Package> pkgs;
+    pkgs.reserve(n * 16);
+
+    for (int i = 0; i < n; ++i) {
+        ll q = cats[i].q;
+        ll remain = q;
+        ll k = 1;
+        while (remain > 0) {
+            ll cnt = min(k, remain);
+            ll mass = cats[i].m * cnt;
+            ll vol = cats[i].l * cnt;
+            if (mass <= M && vol <= L) {
+                int sm = (int)((mass + fMass - 1) / fMass);
+                int sl = (int)((vol + fVol - 1) / fVol);
+                if (sm <= sM && sl <= sL) {
+                    Package p;
+                    p.type = i;
+                    p.cnt = (int)cnt;
+                    p.value = cats[i].v * cnt;
+                    p.sm = sm;
+                    p.sl = sl;
+                    pkgs.push_back(p);
+                }
+            }
+            remain -= cnt;
+            k <<= 1;
+        }
+    }
+
+    int P = (int)pkgs.size();
+    const ll NEG_INF = (ll)-4e18;
+
+    vector<ll> dp(S, NEG_INF);
+    dp[0] = 0;
+    vector<unsigned char> choose((size_t)P * (size_t)S, 0);
+
+    for (int p = 0; p < P; ++p) {
+        int wM = pkgs[p].sm;
+        int wL = pkgs[p].sl;
+        ll val = pkgs[p].value;
+        for (int m = sM; m >= wM; --m) {
+            int baseRow = m * width;
+            int prevRow = (m - wM) * width;
+            for (int l = sL; l >= wL; --l) {
+                int idx = baseRow + l;
+                int prev = prevRow + (l - wL);
+                ll prevVal = dp[prev];
+                if (prevVal == NEG_INF) continue;
+                ll cand = prevVal + val;
+                if (cand > dp[idx]) {
+                    dp[idx] = cand;
+                    choose[(size_t)p * (size_t)S + (size_t)idx] = 1;
+                }
+            }
+        }
+    }
+
+    ll bestVal = 0;
+    int bestIdx = 0;
+    for (int idx = 0; idx < S; ++idx) {
+        if (dp[idx] > bestVal) {
+            bestVal = dp[idx];
+            bestIdx = idx;
+        }
+    }
+
+    vector<ll> cnts(n, 0);
+    int curM = bestIdx / width;
+    int curL = bestIdx % width;
+
+    for (int p = P - 1; p >= 0; --p) {
+        int idx = curM * width + curL;
+        if (choose[(size_t)p * (size_t)S + (size_t)idx]) {
+            cnts[pkgs[p].type] += pkgs[p].cnt;
+            curM -= pkgs[p].sm;
+            curL -= pkgs[p].sl;
+        }
+    }
+
+    Solution sol;
+    sol.cnts = cnts;
+    sol.mass = 0;
+    sol.vol = 0;
+    sol.val = 0;
+    for (int i = 0; i < n; ++i) {
+        sol.mass += sol.cnts[i] * cats[i].m;
+        sol.vol  += sol.cnts[i] * cats[i].l;
+        sol.val  += sol.cnts[i] * cats[i].v;
+    }
+    // Feasibility should hold by construction.
+    if (sol.mass > M || sol.vol > L) {
+        // Safety fallback: zero solution
+        sol.cnts.assign(n, 0);
+        sol.mass = sol.vol = sol.val = 0;
+    }
+    return sol;
+}
+
+Solution greedyFill(const vector<Cat>& cats,
+                    const vector<ll>& baseCnt,
+                    ll baseMass, ll baseVol, ll baseVal,
+                    int mode) {
+    int n = (int)cats.size();
+    Solution sol;
+    sol.cnts = baseCnt;
+    sol.mass = baseMass;
+    sol.vol = baseVol;
+    sol.val = baseVal;
+
+    if (sol.mass > MAX_MASS || sol.vol > MAX_VOL) {
+        // invalid base; return as is
+        return sol;
+    }
+
+    vector<ll> remaining(n);
+    for (int i = 0; i < n; ++i) {
+        ll rem = cats[i].q - baseCnt[i];
+        if (rem < 0) rem = 0;
+        remaining[i] = rem;
+    }
+
+    vector<int> idxs;
+    idxs.reserve(n);
+    for (int i = 0; i < n; ++i) {
+        if (remaining[i] > 0) idxs.push_back(i);
+    }
+    if (idxs.empty()) return sol;
+
+    vector<double> score(n, 0.0);
+    for (int i : idxs) {
+        double s = 0.0;
+        double d1 = (double)cats[i].m / (double)MAX_MASS;
+        double d2 = (double)cats[i].l / (double)MAX_VOL;
+        switch (mode) {
+            case 0: // normalized sum
+                s = (double)cats[i].v / (d1 + d2);
+                break;
+            case 1: // value per mass
+                s = (double)cats[i].v / (double)cats[i].m;
+                break;
+            case 2: // value per volume
+                s = (double)cats[i].v / (double)cats[i].l;
+                break;
+            case 3: { // value per max normalized
+                double d = max(d1, d2);
+                s = (double)cats[i].v / d;
+                break;
+            }
+            default:
+                s = (double)cats[i].v / (d1 + d2);
+                break;
+        }
+        score[i] = s;
+    }
+
+    sort(idxs.begin(), idxs.end(), [&](int a, int b) {
+        if (score[a] == score[b]) return cats[a].v > cats[b].v;
+        return score[a] > score[b];
+    });
+
+    for (int i : idxs) {
+        if (remaining[i] <= 0) continue;
+        if (sol.mass >= MAX_MASS || sol.vol >= MAX_VOL) break;
+        ll maxByMass = (cats[i].m > 0) ? ( (MAX_MASS - sol.mass) / cats[i].m ) : remaining[i];
+        ll maxByVol  = (cats[i].l > 0) ? ( (MAX_VOL  - sol.vol ) / cats[i].l ) : remaining[i];
+        ll canTake = min(remaining[i], min(maxByMass, maxByVol));
+        if (canTake <= 0) continue;
+        sol.cnts[i] += canTake;
+        sol.mass += canTake * cats[i].m;
+        sol.vol  += canTake * cats[i].l;
+        sol.val  += canTake * cats[i].v;
+    }
+
+    return sol;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    inputStr.assign((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());
+    vector<Cat> cats = parseInput();
+    int n = (int)cats.size();
+
+    vector<ll> emptyCnt(n, 0);
+
+    Solution best;
+    best.cnts = emptyCnt;
+    best.mass = 0;
+    best.vol = 0;
+    best.val = 0;
+
+    // Greedy from empty with various heuristics
+    for (int mode = 0; mode <= 3; ++mode) {
+        Solution cand = greedyFill(cats, emptyCnt, 0, 0, 0, mode);
+        if (cand.mass <= MAX_MASS && cand.vol <= MAX_VOL && cand.val > best.val) {
+            best = cand;
+        }
+    }
+
+    // DP-based solution + greedy refinements
+    Solution dpSol = solveDP(cats);
+    for (int mode = 0; mode <= 3; ++mode) {
+        Solution cand = greedyFill(cats, dpSol.cnts, dpSol.mass, dpSol.vol, dpSol.val, mode);
+        if (cand.mass <= MAX_MASS && cand.vol <= MAX_VOL && cand.val > best.val) {
+            best = cand;
+        }
+    }
+
+    // Output JSON with same key order
+    cout << "{\n";
+    for (int i = 0; i < n; ++i) {
+        cout << " \"" << cats[i].name << "\": " << best.cnts[i];
+        if (i + 1 < n) cout << ",\n";
+        else cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.1_1.cpp

@@ -0,0 +1,304 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    // Read entire input
+    string s((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());
+    size_t pos = 0;
+
+    auto skipWS = [&]() {
+        while (pos < s.size() && isspace((unsigned char)s[pos])) ++pos;
+    };
+
+    auto parseString = [&]() -> string {
+        skipWS();
+        if (pos >= s.size() || s[pos] != '"') return "";
+        ++pos;
+        size_t start = pos;
+        while (pos < s.size() && s[pos] != '"') ++pos;
+        string res = s.substr(start, pos - start);
+        if (pos < s.size() && s[pos] == '"') ++pos;
+        return res;
+    };
+
+    auto parseLongLong = [&]() -> long long {
+        skipWS();
+        int sign = 1;
+        if (pos < s.size() && s[pos] == '-') {
+            sign = -1;
+            ++pos;
+        }
+        long long val = 0;
+        while (pos < s.size() && isdigit((unsigned char)s[pos])) {
+            val = val * 10 + (s[pos] - '0');
+            ++pos;
+        }
+        return sign * val;
+    };
+
+    skipWS();
+    if (pos < s.size() && s[pos] == '{') ++pos;
+
+    vector<string> names;
+    vector<long long> q, v, m, l;
+
+    while (true) {
+        skipWS();
+        if (pos >= s.size()) break;
+        if (s[pos] == '}') {
+            ++pos;
+            break;
+        }
+
+        string name = parseString();
+        if (name.empty()) break;
+
+        // Skip until '['
+        while (pos < s.size() && s[pos] != '[') ++pos;
+        if (pos < s.size() && s[pos] == '[') ++pos;
+
+        long long nums[4];
+        for (int i = 0; i < 4; ++i) {
+            nums[i] = parseLongLong();
+            skipWS();
+            if (i < 3 && pos < s.size() && s[pos] == ',') ++pos;
+        }
+
+        // Skip until ']'
+        while (pos < s.size() && s[pos] != ']') ++pos;
+        if (pos < s.size() && s[pos] == ']') ++pos;
+
+        skipWS();
+        if (pos < s.size() && s[pos] == ',') ++pos;
+
+        names.push_back(name);
+        q.push_back(nums[0]);
+        v.push_back(nums[1]);
+        m.push_back(nums[2]);
+        l.push_back(nums[3]);
+    }
+
+    int n = (int)names.size();
+    if (n == 0) {
+        cout << "{}\n";
+        return 0;
+    }
+
+    const long long M_CAP = 20'000'000LL;
+    const long long L_CAP = 25'000'000LL;
+
+    vector<long long> bestX(n, 0);
+    long long bestVal = 0;
+
+    auto greedyFromOrder = [&](const vector<int> &order) {
+        vector<long long> x(n, 0);
+        long long usedM = 0;
+        long long usedL = 0;
+        long long totalVal = 0;
+        for (int idx : order) {
+            if (usedM >= M_CAP || usedL >= L_CAP) break;
+            long long remM = M_CAP - usedM;
+            long long remL = L_CAP - usedL;
+            long long maxByM = remM / m[idx];
+            long long maxByL = remL / l[idx];
+            long long canTake = std::min<long long>({q[idx], maxByM, maxByL});
+            if (canTake <= 0) continue;
+            x[idx] = canTake;
+            usedM += canTake * m[idx];
+            usedL += canTake * l[idx];
+            totalVal += canTake * v[idx];
+        }
+        if (totalVal > bestVal) {
+            bestVal = totalVal;
+            bestX = std::move(x);
+        }
+    };
+
+    double M_cap_d = (double)M_CAP;
+    double L_cap_d = (double)L_CAP;
+    vector<double> mNorm(n), lNorm(n);
+    for (int i = 0; i < n; ++i) {
+        mNorm[i] = (double)m[i] / M_cap_d;
+        lNorm[i] = (double)l[i] / L_cap_d;
+    }
+
+    auto runHeuristic = [&](auto getDensity) {
+        struct Pair {
+            double d;
+            int idx;
+        };
+        vector<Pair> arr;
+        arr.reserve(n);
+        for (int i = 0; i < n; ++i) {
+            double d = getDensity(i);
+            if (!std::isfinite(d)) d = -1e300;
+            arr.push_back({d, i});
+        }
+        sort(arr.begin(), arr.end(), [](const Pair &a, const Pair &b) {
+            return a.d > b.d;
+        });
+        vector<int> order;
+        order.reserve(n);
+        for (auto &p : arr) order.push_back(p.idx);
+        greedyFromOrder(order);
+    };
+
+    // Basic heuristics
+    runHeuristic([&](int i) { return (double)v[i] / (double)m[i]; });                     // value per mass
+    runHeuristic([&](int i) { return (double)v[i] / (double)l[i]; });                     // value per volume
+    runHeuristic([&](int i) { return (double)v[i]; });                                     // raw value
+    runHeuristic([&](int i) { return (double)v[i] / (mNorm[i] + lNorm[i]); });             // value per combined normalized size
+    runHeuristic([&](int i) { return (double)v[i] / std::max(mNorm[i], lNorm[i]); });      // value per max normalized
+    runHeuristic([&](int i) {
+        double s = mNorm[i] * mNorm[i] + lNorm[i] * lNorm[i];
+        return (double)v[i] / s;
+    });
+    runHeuristic([&](int i) { return 1.0 / (mNorm[i] + lNorm[i]); });                      // prioritize small items
+
+    // Directional heuristics
+    const int K_dir = 32;
+    const double PI = acos(-1.0);
+    for (int k = 0; k <= K_dir; ++k) {
+        double theta = (PI / 2.0) * k / (double)K_dir;
+        double alpha = cos(theta);
+        double beta = sin(theta);
+        runHeuristic([&](int i) {
+            double cons = alpha * mNorm[i] + beta * lNorm[i];
+            return (double)v[i] / cons;
+        });
+    }
+
+    // Local search improvement
+    long long usedM = 0, usedL = 0;
+    for (int i = 0; i < n; ++i) {
+        usedM += bestX[i] * m[i];
+        usedL += bestX[i] * l[i];
+    }
+
+    auto tryExchangeType = [&](int addIdx, vector<long long> &x, long long &curUsedM,
+                               long long &curUsedL, long long &curVal) -> bool {
+        if (x[addIdx] >= q[addIdx]) return false;
+
+        long long M_rem = M_CAP - curUsedM;
+        long long L_rem = L_CAP - curUsedL;
+
+        if (m[addIdx] <= M_rem && l[addIdx] <= L_rem) {
+            x[addIdx] += 1;
+            curUsedM += m[addIdx];
+            curUsedL += l[addIdx];
+            curVal += v[addIdx];
+            return true;
+        }
+
+        long long mass_needed = std::max(0LL, m[addIdx] - M_rem);
+        long long vol_needed = std::max(0LL, l[addIdx] - L_rem);
+        long long w_m = mass_needed;
+        long long w_l = vol_needed;
+
+        if (w_m == 0 && w_l == 0) {
+            x[addIdx] += 1;
+            curUsedM += m[addIdx];
+            curUsedL += l[addIdx];
+            curVal += v[addIdx];
+            return true;
+        }
+
+        vector<int> cand;
+        cand.reserve(n);
+        for (int i = 0; i < n; ++i) {
+            if (i == addIdx) continue;
+            if (x[i] > 0) cand.push_back(i);
+        }
+        if (cand.empty()) return false;
+
+        struct Node {
+            double score;
+            int idx;
+        };
+        vector<Node> nodes;
+        nodes.reserve(cand.size());
+        for (int i : cand) {
+            long long denom_ll = w_m * m[i] + w_l * l[i];
+            double denom = (double)denom_ll;
+            double score;
+            if (denom <= 0.0) score = 1e300;
+            else score = (double)v[i] / denom;
+            nodes.push_back({score, i});
+        }
+        sort(nodes.begin(), nodes.end(), [](const Node &a, const Node &b) {
+            return a.score < b.score;  // remove lowest score first
+        });
+
+        vector<long long> removeCnt(n, 0);
+        long long freedM = 0, freedL = 0, valueLoss = 0;
+        for (const auto &nd : nodes) {
+            if (freedM >= mass_needed && freedL >= vol_needed) break;
+            int i = nd.idx;
+            long long available = x[i] - removeCnt[i];
+            if (available <= 0) continue;
+
+            long long remMassNeed = std::max(0LL, mass_needed - freedM);
+            long long remVolNeed = std::max(0LL, vol_needed - freedL);
+            if (remMassNeed <= 0 && remVolNeed <= 0) break;
+
+            long long unitsByM = remMassNeed > 0 ? ((remMassNeed + m[i] - 1) / m[i]) : 0;
+            long long unitsByL = remVolNeed > 0 ? ((remVolNeed + l[i] - 1) / l[i]) : 0;
+            long long unitsNeed = std::max(unitsByM, unitsByL);
+            if (unitsNeed <= 0) unitsNeed = 1;
+            if (unitsNeed > available) unitsNeed = available;
+
+            freedM += unitsNeed * m[i];
+            freedL += unitsNeed * l[i];
+            valueLoss += unitsNeed * v[i];
+            removeCnt[i] += unitsNeed;
+        }
+
+        if (freedM < mass_needed || freedL < vol_needed) return false;
+
+        long long netGain = v[addIdx] - valueLoss;
+        if (netGain <= 0) return false;
+
+        // Commit changes
+        x[addIdx] += 1;
+        curUsedM += m[addIdx];
+        curUsedL += l[addIdx];
+        curVal += v[addIdx];
+        for (int i = 0; i < n; ++i) {
+            long long c = removeCnt[i];
+            if (c > 0) {
+                x[i] -= c;
+                curUsedM -= c * m[i];
+                curUsedL -= c * l[i];
+                curVal -= c * v[i];
+            }
+        }
+        return true;
+    };
+
+    const int MAX_IMPROVE_STEPS = 2000;
+    int improveCount = 0;
+    bool improved = true;
+    while (improved && improveCount < MAX_IMPROVE_STEPS) {
+        improved = false;
+        for (int j = 0; j < n && improveCount < MAX_IMPROVE_STEPS; ++j) {
+            if (tryExchangeType(j, bestX, usedM, usedL, bestVal)) {
+                improved = true;
+                ++improveCount;
+            }
+        }
+    }
+
+    // Output JSON
+    cout << "{\n";
+    for (int i = 0; i < n; ++i) {
+        cout << " \"" << names[i] << "\": " << bestX[i];
+        if (i + 1 < n) cout << ",\n";
+        else cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.1_2.cpp

@@ -0,0 +1,302 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Item {
+    string name;
+    long long q, v, m, l;
+};
+
+const long long MAX_MASS = 20000000LL;
+const long long MAX_VOL  = 25000000LL;
+const double EPS = 1e-12;
+
+vector<Item> items;
+int n;
+
+void skipWhitespace(const string &s, size_t &pos) {
+    while (pos < s.size() && isspace((unsigned char)s[pos])) pos++;
+}
+
+string parseString(const string &s, size_t &pos) {
+    skipWhitespace(s, pos);
+    if (pos >= s.size() || s[pos] != '"') return "";
+    pos++;
+    size_t start = pos;
+    while (pos < s.size() && s[pos] != '"') pos++;
+    string res = s.substr(start, pos - start);
+    if (pos < s.size() && s[pos] == '"') pos++;
+    return res;
+}
+
+long long parseInt(const string &s, size_t &pos) {
+    skipWhitespace(s, pos);
+    bool neg = false;
+    if (pos < s.size() && s[pos] == '-') {
+        neg = true;
+        pos++;
+    }
+    long long val = 0;
+    while (pos < s.size() && isdigit((unsigned char)s[pos])) {
+        val = val * 10 + (s[pos] - '0');
+        pos++;
+    }
+    return neg ? -val : val;
+}
+
+enum Mode { MASS, VOL, SUMD, MASS_HEAVY, VOL_HEAVY, MAXR, VALUE_ONLY };
+
+double computeScore(Mode mode, int idx) {
+    const Item &it = items[idx];
+    double mRel = (double)it.m / (double)MAX_MASS;
+    double lRel = (double)it.l / (double)MAX_VOL;
+    switch (mode) {
+        case MASS:
+            return (double)it.v / (double)it.m;
+        case VOL:
+            return (double)it.v / (double)it.l;
+        case SUMD: {
+            double denom = mRel + lRel + EPS;
+            return (double)it.v / denom;
+        }
+        case MASS_HEAVY: {
+            double denom = 0.7 * mRel + 0.3 * lRel + EPS;
+            return (double)it.v / denom;
+        }
+        case VOL_HEAVY: {
+            double denom = 0.3 * mRel + 0.7 * lRel + EPS;
+            return (double)it.v / denom;
+        }
+        case MAXR: {
+            double denom = max(mRel, lRel) + EPS;
+            return (double)it.v / denom;
+        }
+        case VALUE_ONLY:
+        default:
+            return (double)it.v;
+    }
+}
+
+vector<int> getOrder(Mode mode) {
+    vector<int> idx(n);
+    iota(idx.begin(), idx.end(), 0);
+    sort(idx.begin(), idx.end(), [&](int a, int b) {
+        double sa = computeScore(mode, a);
+        double sb = computeScore(mode, b);
+        if (sa != sb) return sa > sb;
+        const Item &ia = items[a];
+        const Item &ib = items[b];
+        double wa = (double)ia.m / MAX_MASS + (double)ia.l / MAX_VOL;
+        double wb = (double)ib.m / MAX_MASS + (double)ib.l / MAX_VOL;
+        if (wa != wb) return wa < wb;
+        return a < b;
+    });
+    return idx;
+}
+
+vector<long long> greedyPack(Mode mode) {
+    vector<int> order = getOrder(mode);
+    vector<long long> x(n, 0);
+    long long massUsed = 0, volUsed = 0;
+    for (int id : order) {
+        const Item &it = items[id];
+        if (it.m > MAX_MASS || it.l > MAX_VOL) continue;
+        long long remM = MAX_MASS - massUsed;
+        long long remL = MAX_VOL - volUsed;
+        if (remM <= 0 || remL <= 0) break;
+        long long maxByM = remM / it.m;
+        long long maxByL = remL / it.l;
+        long long take = min(it.q, min(maxByM, maxByL));
+        if (take > 0) {
+            x[id] += take;
+            massUsed += take * it.m;
+            volUsed += take * it.l;
+        }
+    }
+    return x;
+}
+
+long long evaluateSolution(const vector<long long> &x) {
+    long long massUsed = 0, volUsed = 0, val = 0;
+    for (int i = 0; i < n; i++) {
+        if (x[i] < 0 || x[i] > items[i].q) return -1;
+        massUsed += x[i] * items[i].m;
+        if (massUsed > MAX_MASS) return -1;
+        volUsed += x[i] * items[i].l;
+        if (volUsed > MAX_VOL) return -1;
+        val += x[i] * items[i].v;
+    }
+    return val;
+}
+
+void fillRemByMode(vector<long long> &x, Mode mode) {
+    vector<int> order = getOrder(mode);
+    long long massUsed = 0, volUsed = 0;
+    for (int i = 0; i < n; i++) {
+        massUsed += x[i] * items[i].m;
+        volUsed  += x[i] * items[i].l;
+    }
+    long long remM = MAX_MASS - massUsed;
+    long long remL = MAX_VOL - volUsed;
+    if (remM <= 0 || remL <= 0) return;
+    for (int id : order) {
+        const Item &it = items[id];
+        if (x[id] >= it.q) continue;
+        if (it.m > remM || it.l > remL) continue;
+        long long maxByM = remM / it.m;
+        long long maxByL = remL / it.l;
+        long long canAdd = min(it.q - x[id], min(maxByM, maxByL));
+        if (canAdd > 0) {
+            x[id] += canAdd;
+            remM -= canAdd * it.m;
+            remL -= canAdd * it.l;
+            if (remM <= 0 || remL <= 0) break;
+        }
+    }
+}
+
+vector<long long> localSearch(const vector<long long> &start) {
+    vector<long long> cur = start;
+    fillRemByMode(cur, SUMD);
+    const int MAX_ITER = 40;
+    const int MAX_REMOVE = 3;
+    for (int iter = 0; iter < MAX_ITER; ++iter) {
+        long long massUsed = 0, volUsed = 0, curVal = 0;
+        for (int i = 0; i < n; i++) {
+            massUsed += cur[i] * items[i].m;
+            volUsed  += cur[i] * items[i].l;
+            curVal   += cur[i] * items[i].v;
+        }
+        long long remM = MAX_MASS - massUsed;
+        long long remL = MAX_VOL  - volUsed;
+        long long bestDelta = 0;
+        int bestI = -1, bestJ = -1;
+        long long bestRemCnt = 0, bestAddCnt = 0;
+
+        for (int i = 0; i < n; i++) {
+            if (cur[i] == 0) continue;
+            const Item &itI = items[i];
+            long long maxRem = min(cur[i], (long long)MAX_REMOVE);
+            for (long long remCnt = 1; remCnt <= maxRem; ++remCnt) {
+                long long freedM = remCnt * itI.m;
+                long long freedL = remCnt * itI.l;
+                long long M2 = remM + freedM;
+                long long L2 = remL + freedL;
+                if (M2 <= 0 || L2 <= 0) continue;
+                for (int j = 0; j < n; j++) {
+                    if (j == i) continue;
+                    const Item &itJ = items[j];
+                    if (cur[j] >= itJ.q) continue;
+                    if (itJ.m > M2 || itJ.l > L2) continue;
+                    long long maxByM = M2 / itJ.m;
+                    long long maxByL = L2 / itJ.l;
+                    long long addCnt = min(itJ.q - cur[j], min(maxByM, maxByL));
+                    if (addCnt <= 0) continue;
+                    long long delta = addCnt * itJ.v - remCnt * itI.v;
+                    if (delta > bestDelta) {
+                        bestDelta = delta;
+                        bestI = i; bestJ = j;
+                        bestRemCnt = remCnt; bestAddCnt = addCnt;
+                    }
+                }
+            }
+        }
+
+        if (bestDelta <= 0) break;
+        cur[bestI] -= bestRemCnt;
+        cur[bestJ] += bestAddCnt;
+        fillRemByMode(cur, SUMD);
+    }
+    return cur;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string input((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());
+    size_t pos = 0;
+    skipWhitespace(input, pos);
+    if (pos < input.size() && input[pos] == '{') pos++;
+    skipWhitespace(input, pos);
+    items.clear();
+
+    while (pos < input.size()) {
+        skipWhitespace(input, pos);
+        if (pos < input.size() && input[pos] == '}') {
+            pos++;
+            break;
+        }
+        string key = parseString(input, pos);
+        skipWhitespace(input, pos);
+        if (pos < input.size() && input[pos] == ':') pos++;
+        skipWhitespace(input, pos);
+        if (pos < input.size() && input[pos] == '[') pos++;
+
+        vector<long long> nums;
+        for (int k = 0; k < 4; k++) {
+            long long v = parseInt(input, pos);
+            nums.push_back(v);
+            skipWhitespace(input, pos);
+            if (k < 3 && pos < input.size() && input[pos] == ',') {
+                pos++;
+                skipWhitespace(input, pos);
+            }
+        }
+        skipWhitespace(input, pos);
+        if (pos < input.size() && input[pos] == ']') pos++;
+
+        if (nums.size() == 4) {
+            Item it;
+            it.name = key;
+            it.q = nums[0];
+            it.v = nums[1];
+            it.m = nums[2];
+            it.l = nums[3];
+            items.push_back(it);
+        }
+
+        skipWhitespace(input, pos);
+        if (pos < input.size() && input[pos] == ',') {
+            pos++;
+            continue;
+        } else if (pos < input.size() && input[pos] == '}') {
+            pos++;
+            break;
+        }
+    }
+
+    n = (int)items.size();
+    if (n == 0) {
+        cout << "{\n}\n";
+        return 0;
+    }
+
+    vector<Mode> modes = { MASS, VOL, SUMD, MASS_HEAVY, VOL_HEAVY, MAXR, VALUE_ONLY };
+
+    vector<long long> bestSol(n, 0);
+    long long bestVal = evaluateSolution(bestSol); // initial 0
+
+    for (Mode m : modes) {
+        vector<long long> sol = greedyPack(m);
+        sol = localSearch(sol);
+        long long val = evaluateSolution(sol);
+        if (val > bestVal) {
+            bestVal = val;
+            bestSol = sol;
+        }
+    }
+
+    if (evaluateSolution(bestSol) < 0) {
+        bestSol.assign(n, 0);
+    }
+
+    cout << "{\n";
+    for (int i = 0; i < n; i++) {
+        cout << " \"" << items[i].name << "\": " << bestSol[i];
+        if (i + 1 < n) cout << ",\n";
+        else cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.1_3.cpp

@@ -0,0 +1,353 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+// Capacities in mg and µL
+const long long MASS_CAP = 20LL * 1000000LL;
+const long long VOL_CAP  = 25LL * 1000000LL;
+
+// Global item data
+vector<string> names;
+vector<int> qty;
+vector<long long> val, massv, volv;
+
+// JSON parsing globals
+string json_input;
+size_t pos_json = 0;
+
+void skip_ws() {
+    while (pos_json < json_input.size() &&
+           isspace((unsigned char)json_input[pos_json])) {
+        ++pos_json;
+    }
+}
+
+string parse_string() {
+    skip_ws();
+    if (pos_json >= json_input.size() || json_input[pos_json] != '"') return "";
+    ++pos_json; // skip opening quote
+    string res;
+    while (pos_json < json_input.size() && json_input[pos_json] != '"') {
+        res.push_back(json_input[pos_json++]);
+    }
+    if (pos_json < json_input.size() && json_input[pos_json] == '"') ++pos_json;
+    return res;
+}
+
+long long parse_ll() {
+    skip_ws();
+    int sign = 1;
+    if (pos_json < json_input.size() && json_input[pos_json] == '-') {
+        sign = -1;
+        ++pos_json;
+    }
+    long long v = 0;
+    while (pos_json < json_input.size() &&
+           isdigit((unsigned char)json_input[pos_json])) {
+        v = v * 10 + (json_input[pos_json] - '0');
+        ++pos_json;
+    }
+    return sign * v;
+}
+
+void build_greedy(int heurType, vector<int> &x) {
+    int n = (int)names.size();
+    x.assign(n, 0);
+    vector<double> ratio(n);
+
+    for (int i = 0; i < n; ++i) {
+        double cost = 0.0;
+        double m = (double)massv[i];
+        double l = (double)volv[i];
+        double nm = m / (double)MASS_CAP;
+        double nl = l / (double)VOL_CAP;
+        switch (heurType) {
+            case 0: // value per mass
+                cost = m;
+                break;
+            case 1: // value per volume
+                cost = l;
+                break;
+            case 2: // equal normalized
+                cost = nm + nl;
+                break;
+            case 3: // bias mass
+                cost = 0.7 * nm + 0.3 * nl;
+                break;
+            case 4: // bias volume
+                cost = 0.3 * nm + 0.7 * nl;
+                break;
+            case 5: // max normalized
+                cost = max(nm, nl);
+                break;
+            case 6: { // L2 squared
+                cost = nm * nm + nl * nl;
+                break;
+            }
+            default:
+                cost = nm + nl;
+                break;
+        }
+        if (cost <= 0.0) cost = 1e-9;
+        ratio[i] = (double)val[i] / cost;
+    }
+
+    vector<int> order(n);
+    iota(order.begin(), order.end(), 0);
+    sort(order.begin(), order.end(), [&](int a, int b) {
+        if (ratio[a] == ratio[b]) {
+            long long ca = massv[a] + volv[a];
+            long long cb = massv[b] + volv[b];
+            if (ca != cb) return ca < cb;
+            return a < b;
+        }
+        return ratio[a] > ratio[b];
+    });
+
+    long long Mrem = MASS_CAP;
+    long long Lrem = VOL_CAP;
+
+    for (int idx : order) {
+        if (Mrem <= 0 || Lrem <= 0) break;
+        if (massv[idx] <= 0 || volv[idx] <= 0) continue;
+        long long maxK1 = qty[idx];
+        long long maxK2 = Mrem / massv[idx];
+        long long maxK3 = Lrem / volv[idx];
+        long long k = min(maxK1, min(maxK2, maxK3));
+        if (k <= 0) continue;
+        x[idx] += (int)k;
+        Mrem -= k * massv[idx];
+        Lrem -= k * volv[idx];
+    }
+}
+
+long long improve(vector<int> &x) {
+    int n = (int)names.size();
+    long long Mcur = 0, Lcur = 0, Vcur = 0;
+    for (int i = 0; i < n; ++i) {
+        Mcur += (long long)x[i] * massv[i];
+        Lcur += (long long)x[i] * volv[i];
+        Vcur += (long long)x[i] * val[i];
+    }
+
+    auto fill_capacity = [&]() {
+        while (true) {
+            long long Mfree = MASS_CAP - Mcur;
+            long long Lfree = VOL_CAP - Lcur;
+            if (Mfree <= 0 || Lfree <= 0) break;
+            long long bestGain = 0;
+            int bestJ = -1;
+            long long bestK = 0;
+            for (int j = 0; j < n; ++j) {
+                if (x[j] >= qty[j]) continue;
+                if (massv[j] > Mfree || volv[j] > Lfree) continue;
+                long long maxK1 = (long long)qty[j] - x[j];
+                long long maxK2 = Mfree / massv[j];
+                long long maxK3 = Lfree / volv[j];
+                long long k = min(maxK1, min(maxK2, maxK3));
+                if (k <= 0) continue;
+                long long gain = k * val[j];
+                if (gain > bestGain) {
+                    bestGain = gain;
+                    bestJ = j;
+                    bestK = k;
+                }
+            }
+            if (bestJ == -1) break;
+            x[bestJ] += (int)bestK;
+            Mcur += bestK * massv[bestJ];
+            Lcur += bestK * volv[bestJ];
+            Vcur += bestGain;
+        }
+    };
+
+    fill_capacity();
+
+    const int MAX_ITERS = 60;
+    for (int iter = 0; iter < MAX_ITERS; ++iter) {
+        long long bestDV = 0;
+        int moveType = 0; // 0 none, 1 one-drop, 2 two-drop
+        int bi1 = -1, bi2 = -1, bj = -1;
+        long long bk = 0;
+
+        // One-drop moves: remove 1 of i, add k of j
+        for (int i = 0; i < n; ++i) {
+            if (x[i] <= 0) continue;
+            for (int j = 0; j < n; ++j) {
+                if (j == i) continue;
+                if (x[j] >= qty[j]) continue;
+                long long Mfree = MASS_CAP - (Mcur - massv[i]);
+                long long Lfree = VOL_CAP - (Lcur - volv[i]);
+                if (Mfree <= 0 || Lfree <= 0) continue;
+                if (massv[j] > Mfree || volv[j] > Lfree) continue;
+                long long maxK1 = (long long)qty[j] - x[j];
+                long long maxK2 = Mfree / massv[j];
+                long long maxK3 = Lfree / volv[j];
+                long long k = min(maxK1, min(maxK2, maxK3));
+                if (k <= 0) continue;
+                long long DV = -val[i] + k * val[j];
+                if (DV > bestDV) {
+                    bestDV = DV;
+                    moveType = 1;
+                    bi1 = i;
+                    bj = j;
+                    bk = k;
+                }
+            }
+        }
+
+        // Two-drop moves: remove 2 items (a,b), add k of j
+        for (int a = 0; a < n; ++a) {
+            if (x[a] <= 0) continue;
+            for (int b = a; b < n; ++b) {
+                if (b == a) {
+                    if (x[a] < 2) continue;
+                } else {
+                    if (x[b] <= 0) continue;
+                }
+                long long removeMass = massv[a] + (b == a ? massv[a] : massv[b]);
+                long long removeVol  = volv[a] + (b == a ? volv[a] : volv[b]);
+                long long McurP = Mcur - removeMass;
+                long long LcurP = Lcur - removeVol;
+                if (McurP < 0 || LcurP < 0) continue;
+                long long Mfree = MASS_CAP - McurP;
+                long long Lfree = VOL_CAP - LcurP;
+                if (Mfree <= 0 || Lfree <= 0) continue;
+
+                for (int j = 0; j < n; ++j) {
+                    if (j == a || j == b) continue;
+                    if (x[j] >= qty[j]) continue;
+                    if (massv[j] > Mfree || volv[j] > Lfree) continue;
+                    long long maxK1 = (long long)qty[j] - x[j];
+                    long long maxK2 = Mfree / massv[j];
+                    long long maxK3 = Lfree / volv[j];
+                    long long k = min(maxK1, min(maxK2, maxK3));
+                    if (k <= 0) continue;
+                    long long DV = -val[a] - (b == a ? val[a] : val[b]) + k * val[j];
+                    if (DV > bestDV) {
+                        bestDV = DV;
+                        moveType = 2;
+                        bi1 = a;
+                        bi2 = b;
+                        bj = j;
+                        bk = k;
+                    }
+                }
+            }
+        }
+
+        if (bestDV <= 0 || moveType == 0) break;
+
+        if (moveType == 1) {
+            x[bi1]--;
+            x[bj] += (int)bk;
+            Mcur = Mcur - massv[bi1] + bk * massv[bj];
+            Lcur = Lcur - volv[bi1] + bk * volv[bj];
+        } else { // moveType == 2
+            x[bi1]--;
+            x[bi2]--;
+            x[bj] += (int)bk;
+            long long removeMass = massv[bi1] + (bi2 == bi1 ? massv[bi1] : massv[bi2]);
+            long long removeVol  = volv[bi1] + (bi2 == bi1 ? volv[bi1] : volv[bi2]);
+            Mcur = Mcur - removeMass + bk * massv[bj];
+            Lcur = Lcur - removeVol  + bk * volv[bj];
+        }
+        Vcur += bestDV;
+
+        fill_capacity();
+    }
+
+    return Vcur;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    json_input.assign(istreambuf_iterator<char>(cin), istreambuf_iterator<char>());
+    pos_json = 0;
+
+    skip_ws();
+    if (pos_json < json_input.size() && json_input[pos_json] == '{') ++pos_json;
+
+    names.clear();
+    qty.clear();
+    val.clear();
+    massv.clear();
+    volv.clear();
+
+    while (true) {
+        skip_ws();
+        if (pos_json >= json_input.size()) break;
+        if (json_input[pos_json] == '}') {
+            ++pos_json;
+            break;
+        }
+
+        string key = parse_string();
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == ':') ++pos_json;
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == '[') ++pos_json;
+
+        long long qv = parse_ll();
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == ',') ++pos_json;
+        long long vv = parse_ll();
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == ',') ++pos_json;
+        long long mv = parse_ll();
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == ',') ++pos_json;
+        long long lv = parse_ll();
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == ']') ++pos_json;
+
+        names.push_back(key);
+        qty.push_back((int)qv);
+        val.push_back(vv);
+        massv.push_back(mv);
+        volv.push_back(lv);
+
+        skip_ws();
+        if (pos_json < json_input.size() && json_input[pos_json] == ',') {
+            ++pos_json;
+            continue;
+        }
+    }
+
+    int n = (int)names.size();
+    vector<int> bestX(n, 0);
+    long long bestValue = -1;
+
+    // Heuristic greedy starts
+    for (int ht = 0; ht < 7; ++ht) {
+        vector<int> x(n, 0);
+        build_greedy(ht, x);
+        long long vsol = improve(x);
+        if (vsol > bestValue) {
+            bestValue = vsol;
+            bestX = x;
+        }
+    }
+
+    // Start from empty as additional candidate
+    {
+        vector<int> x(n, 0);
+        long long vsol = improve(x);
+        if (vsol > bestValue) {
+            bestValue = vsol;
+            bestX = x;
+        }
+    }
+
+    // Output JSON
+    cout << "{\n";
+    for (int i = 0; i < n; ++i) {
+        cout << " \"" << names[i] << "\": " << bestX[i];
+        if (i + 1 < n) cout << ",\n";
+        else cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.1_4.cpp

@@ -0,0 +1,308 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Item {
+    string name;
+    long long q, v, m, l;
+    long long max_take;
+};
+
+const long long CAP_M = 20000000LL;
+const long long CAP_L = 25000000LL;
+
+vector<Item> items;
+int n_items = 0;
+
+void parse_input() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    string s((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());
+    int len = (int)s.size();
+    int pos = 0;
+
+    auto skip_ws = [&]() {
+        while (pos < len && isspace((unsigned char)s[pos])) pos++;
+    };
+
+    skip_ws();
+    if (pos < len && s[pos] == '{') pos++;
+
+    while (pos < len) {
+        skip_ws();
+        if (pos >= len) break;
+        if (s[pos] == '}') { pos++; break; }
+        if (s[pos] == ',') { pos++; continue; }
+
+        skip_ws();
+        if (pos >= len || s[pos] != '"') break;
+        pos++; // skip opening quote
+        string name;
+        while (pos < len && s[pos] != '"') {
+            name.push_back(s[pos]);
+            pos++;
+        }
+        if (pos < len && s[pos] == '"') pos++; // closing quote
+
+        skip_ws();
+        if (pos < len && s[pos] == ':') pos++;
+        skip_ws();
+        if (pos < len && s[pos] == '[') pos++;
+
+        vector<long long> arr;
+        arr.reserve(4);
+        for (int k = 0; k < 4; k++) {
+            skip_ws();
+            long long sign = 1;
+            if (pos < len && s[pos] == '-') {
+                sign = -1;
+                pos++;
+            }
+            long long val = 0;
+            while (pos < len && isdigit((unsigned char)s[pos])) {
+                val = val * 10 + (s[pos] - '0');
+                pos++;
+            }
+            arr.push_back(sign * val);
+            skip_ws();
+            if (k < 3 && pos < len && s[pos] == ',') pos++;
+        }
+        skip_ws();
+        if (pos < len && s[pos] == ']') pos++;
+
+        Item it;
+        it.name = name;
+        it.q = arr[0];
+        it.v = arr[1];
+        it.m = arr[2];
+        it.l = arr[3];
+        it.max_take = 0; // to be set later
+        items.push_back(it);
+
+        skip_ws();
+        if (pos < len && s[pos] == ',') { pos++; continue; }
+    }
+
+    n_items = (int)items.size();
+}
+
+long long evalSolution(const vector<long long>& x) {
+    long long val = 0;
+    for (int i = 0; i < n_items; i++) {
+        val += x[i] * items[i].v;
+    }
+    return val;
+}
+
+long long greedy_fill(const vector<int>& order, vector<long long>& x, long long& massUsed, long long& volUsed) {
+    long long rM = CAP_M - massUsed;
+    long long rL = CAP_L - volUsed;
+    for (int idx : order) {
+        int i = idx;
+        if (items[i].max_take <= x[i]) continue;
+        long long avail = items[i].max_take - x[i];
+        if (avail <= 0) continue;
+        if (items[i].m > 0) {
+            long long byM = rM / items[i].m;
+            if (byM < avail) avail = byM;
+        }
+        if (items[i].l > 0) {
+            long long byL = rL / items[i].l;
+            if (byL < avail) avail = byL;
+        }
+        if (avail <= 0) continue;
+        x[i] += avail;
+        long long addM = avail * items[i].m;
+        long long addL = avail * items[i].l;
+        massUsed += addM;
+        volUsed += addL;
+        rM -= addM;
+        rL -= addL;
+        if (rM <= 0 || rL <= 0) break;
+    }
+    return evalSolution(x);
+}
+
+void local_search(vector<long long>& x, long long& value, long long& massUsed, long long& volUsed,
+                  const vector<int>& refill_order, clock_t t0) {
+    const int MAX_ITERS = 100;
+    for (int iter = 0; iter < MAX_ITERS; iter++) {
+        double elapsed = double(clock() - t0) / CLOCKS_PER_SEC;
+        if (elapsed > 0.90) return;
+
+        bool improved = false;
+        long long bestVal = value;
+        vector<long long> bestX;
+        long long bestMass = massUsed, bestVol = volUsed;
+
+        // 1-item removal moves
+        for (int i = 0; i < n_items; i++) {
+            if (x[i] == 0) continue;
+            long long lim = min(10LL, x[i]);
+            for (long long rem = 1; rem <= lim; rem++) {
+                vector<long long> tmp_x = x;
+                tmp_x[i] -= rem;
+                long long tmpMass = massUsed - rem * items[i].m;
+                long long tmpVol = volUsed - rem * items[i].l;
+                long long newVal = greedy_fill(refill_order, tmp_x, tmpMass, tmpVol);
+                if (newVal > bestVal) {
+                    bestVal = newVal;
+                    bestX.swap(tmp_x);
+                    bestMass = tmpMass;
+                    bestVol = tmpVol;
+                    improved = true;
+                }
+            }
+        }
+
+        // 2-item removal moves
+        for (int i = 0; i < n_items; i++) {
+            if (x[i] == 0) continue;
+            long long limi = min(5LL, x[i]);
+            for (int j = i + 1; j < n_items; j++) {
+                if (x[j] == 0) continue;
+                long long limj = min(5LL, x[j]);
+                for (long long remi = 1; remi <= limi; remi++) {
+                    for (long long remj = 1; remj <= limj; remj++) {
+                        vector<long long> tmp_x = x;
+                        tmp_x[i] -= remi;
+                        tmp_x[j] -= remj;
+                        long long tmpMass = massUsed - remi * items[i].m - remj * items[j].m;
+                        long long tmpVol = volUsed - remi * items[i].l - remj * items[j].l;
+                        long long newVal = greedy_fill(refill_order, tmp_x, tmpMass, tmpVol);
+                        if (newVal > bestVal) {
+                            bestVal = newVal;
+                            bestX.swap(tmp_x);
+                            bestMass = tmpMass;
+                            bestVol = tmpVol;
+                            improved = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!improved) break;
+        x.swap(bestX);
+        value = bestVal;
+        massUsed = bestMass;
+        volUsed = bestVol;
+    }
+}
+
+vector<int> create_order_from_scores(const vector<long double>& scores, bool descending) {
+    vector<int> ord(n_items);
+    iota(ord.begin(), ord.end(), 0);
+    if (descending) {
+        sort(ord.begin(), ord.end(), [&](int a, int b) {
+            if (scores[a] == scores[b]) return a < b;
+            return scores[a] > scores[b];
+        });
+    } else {
+        sort(ord.begin(), ord.end(), [&](int a, int b) {
+            if (scores[a] == scores[b]) return a < b;
+            return scores[a] < scores[b];
+        });
+    }
+    return ord;
+}
+
+int main() {
+    parse_input();
+    n_items = (int)items.size();
+
+    // Compute per-item max_take
+    for (int i = 0; i < n_items; i++) {
+        long long max_by_q = items[i].q;
+        long long max_by_m = (items[i].m == 0) ? max_by_q : (CAP_M / items[i].m);
+        long long max_by_l = (items[i].l == 0) ? max_by_q : (CAP_L / items[i].l);
+        long long mt = max_by_q;
+        if (max_by_m < mt) mt = max_by_m;
+        if (max_by_l < mt) mt = max_by_l;
+        if (mt < 0) mt = 0;
+        items[i].max_take = mt;
+    }
+
+    // Build various heuristic orders
+    const long double NEG_INF = -1e300L;
+    const long double POS_INF = 1e300L;
+
+    vector<long double> ratioApprox(n_items), ratioMass(n_items), ratioVol(n_items), ratioMax(n_items);
+    vector<long double> massScore(n_items), volScore(n_items);
+
+    for (int i = 0; i < n_items; i++) {
+        if (items[i].max_take == 0) {
+            ratioApprox[i] = ratioMass[i] = ratioVol[i] = ratioMax[i] = NEG_INF;
+            massScore[i] = volScore[i] = POS_INF;
+        } else {
+            long double wm = (long double)items[i].m / (long double)CAP_M;
+            long double wl = (long double)items[i].l / (long double)CAP_L;
+            long double denom = wm + wl;
+            if (denom <= 0) denom = 1e-18L;
+            ratioApprox[i] = (long double)items[i].v / denom;
+            ratioMass[i] = (long double)items[i].v / (long double)items[i].m;
+            ratioVol[i]  = (long double)items[i].v / (long double)items[i].l;
+            long double maxCost = max(wm, wl);
+            if (maxCost <= 0) maxCost = 1e-18L;
+            ratioMax[i] = (long double)items[i].v / maxCost;
+            massScore[i] = (long double)items[i].m;
+            volScore[i] = (long double)items[i].l;
+        }
+    }
+
+    vector<vector<int>> orders;
+    orders.push_back(create_order_from_scores(ratioApprox, true));
+    orders.push_back(create_order_from_scores(ratioMass, true));
+    orders.push_back(create_order_from_scores(ratioVol, true));
+    orders.push_back(create_order_from_scores(ratioMax, true));
+    orders.push_back(create_order_from_scores(massScore, false)); // light items first
+    orders.push_back(create_order_from_scores(volScore, false));  // small volume first
+
+    mt19937_64 rng(123456);
+    uniform_real_distribution<long double> dist(0.8L, 1.2L);
+
+    for (int t = 0; t < 5; t++) {
+        vector<long double> noisy(n_items);
+        for (int i = 0; i < n_items; i++) {
+            if (items[i].max_take == 0) noisy[i] = NEG_INF;
+            else noisy[i] = ratioApprox[i] * dist(rng);
+        }
+        orders.push_back(create_order_from_scores(noisy, true));
+    }
+
+    vector<int> refill_order = orders.front(); // use approximate ratio as refill order
+
+    vector<long long> bestX(n_items, 0);
+    long long bestVal = 0;
+
+    clock_t t0 = clock();
+
+    for (auto &order : orders) {
+        double elapsed = double(clock() - t0) / CLOCKS_PER_SEC;
+        if (elapsed > 0.95) break;
+
+        vector<long long> x(n_items, 0);
+        long long massUsed = 0, volUsed = 0;
+        long long val = greedy_fill(order, x, massUsed, volUsed);
+        if (val > bestVal) {
+            bestVal = val;
+            bestX = x;
+        }
+
+        local_search(x, val, massUsed, volUsed, refill_order, t0);
+        if (val > bestVal) {
+            bestVal = val;
+            bestX = x;
+        }
+    }
+
+    // Output JSON with original keys
+    cout << "{\n";
+    for (int i = 0; i < n_items; i++) {
+        cout << " \"" << items[i].name << "\": " << bestX[i];
+        if (i + 1 < n_items) cout << ",\n";
+        else cout << "\n";
+    }
+    cout << "}\n";
+
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.2.cpp

@@ -0,0 +1,546 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Item {
+    string name;
+    int q;
+    long long v, m, l;
+};
+
+static inline void skip_ws(const string& s, size_t& i) {
+    while (i < s.size() && isspace((unsigned char)s[i])) i++;
+}
+
+static string parse_string(const string& s, size_t& i) {
+    skip_ws(s, i);
+    if (i >= s.size() || s[i] != '"') return "";
+    i++;
+    string out;
+    while (i < s.size()) {
+        char c = s[i++];
+        if (c == '"') break;
+        if (c == '\\') { // minimal escape support
+            if (i < s.size()) {
+                char e = s[i++];
+                out.push_back(e);
+            }
+        } else out.push_back(c);
+    }
+    return out;
+}
+
+static long long parse_int(const string& s, size_t& i) {
+    skip_ws(s, i);
+    bool neg = false;
+    if (i < s.size() && s[i] == '-') { neg = true; i++; }
+    long long x = 0;
+    while (i < s.size() && isdigit((unsigned char)s[i])) {
+        x = x * 10 + (s[i] - '0');
+        i++;
+    }
+    return neg ? -x : x;
+}
+
+struct Solution {
+    array<int,12> x{};
+    long long value = 0;
+    long long usedM = 0, usedL = 0;
+};
+
+static inline long long compute_value(const vector<Item>& items, const array<int,12>& x) {
+    long long val = 0;
+    for (int i = 0; i < 12; i++) val += (long long)x[i] * items[i].v;
+    return val;
+}
+
+static inline pair<long long,long long> compute_used(const vector<Item>& items, const array<int,12>& x) {
+    __int128 um = 0, ul = 0;
+    for (int i = 0; i < 12; i++) {
+        um += (__int128)x[i] * items[i].m;
+        ul += (__int128)x[i] * items[i].l;
+    }
+    return {(long long)um, (long long)ul};
+}
+
+static Solution greedy(const vector<Item>& items, long long M, long long L, long double alphaM, long double alphaL) {
+    vector<int> idx(12);
+    iota(idx.begin(), idx.end(), 0);
+    vector<long double> score(12, 0);
+    for (int i = 0; i < 12; i++) {
+        long double denom = alphaM * (long double)items[i].m + alphaL * (long double)items[i].l;
+        if (denom <= 0) score[i] = 0;
+        else score[i] = (long double)items[i].v / denom;
+    }
+    stable_sort(idx.begin(), idx.end(), [&](int a, int b){
+        if (score[a] != score[b]) return score[a] > score[b];
+        return items[a].v > items[b].v;
+    });
+
+    Solution sol;
+    long long remM = M, remL = L;
+    for (int id : idx) {
+        if (items[id].m > remM || items[id].l > remL) continue;
+        long long byM = remM / items[id].m;
+        long long byL = remL / items[id].l;
+        long long take = min<long long>(items[id].q, min(byM, byL));
+        sol.x[id] = (int)take;
+        remM -= take * items[id].m;
+        remL -= take * items[id].l;
+        sol.value += take * items[id].v;
+        sol.usedM += take * items[id].m;
+        sol.usedL += take * items[id].l;
+    }
+    return sol;
+}
+
+struct WeightRun {
+    long long p, q; // coefficient k = p/q
+    bool volCoeff; // if true: w = m*L*q + l*M*p; else: w = m*L*p + l*M*q
+};
+
+struct BeamState {
+    array<int,12> x{};
+    long long remM = 0, remL = 0;
+    long long val = 0;
+    long double ub = 0;
+};
+
+static long double fractional_bound(
+    const vector<Item>& items,
+    const vector<int>& order,
+    int pos,
+    long long remM, long long remL,
+    long long M, long long L,
+    long long wM1, long long wL1
+) {
+    __int128 remW128 = (__int128)remM * wM1 + (__int128)remL * wL1;
+    long long remW = (remW128 > (__int128)LLONG_MAX ? LLONG_MAX : (long long)remW128);
+    long double add = 0.0L;
+
+    for (int k = pos; k < (int)order.size(); k++) {
+        int i = order[k];
+        long long wi;
+        {
+            __int128 w128 = (__int128)items[i].m * wM1 + (__int128)items[i].l * wL1;
+            if (w128 <= 0) continue;
+            wi = (w128 > (__int128)LLONG_MAX ? LLONG_MAX : (long long)w128);
+        }
+        if (wi <= 0) continue;
+
+        long long capByM = (items[i].m == 0 ? (long long)items[i].q : remM / items[i].m);
+        long long capByL = (items[i].l == 0 ? (long long)items[i].q : remL / items[i].l);
+        long long avail = min<long long>(items[i].q, min(capByM, capByL));
+        if (avail <= 0) continue;
+        if (remW <= 0) break;
+
+        long long take = min(avail, remW / wi);
+        if (take > 0) {
+            add += (long double)take * (long double)items[i].v;
+            remW -= take * wi;
+            remM -= take * items[i].m;
+            remL -= take * items[i].l;
+        }
+        if (take < avail && remW > 0) {
+            // fractional
+            add += (long double)remW * ((long double)items[i].v / (long double)wi);
+            break;
+        }
+    }
+    return add;
+}
+
+static Solution beam_search(
+    const vector<Item>& items,
+    long long M, long long L,
+    const WeightRun& wr,
+    int BEAM_W
+) {
+    long long wM1, wL1;
+    if (wr.volCoeff) {
+        // w = m*(L*q) + l*(M*p)
+        wM1 = L * wr.q;
+        wL1 = M * wr.p;
+    } else {
+        // w = m*(L*p) + l*(M*q)
+        wM1 = L * wr.p;
+        wL1 = M * wr.q;
+    }
+
+    vector<int> order(12);
+    iota(order.begin(), order.end(), 0);
+    vector<long double> dens(12, 0.0L);
+    for (int i = 0; i < 12; i++) {
+        __int128 w128 = (__int128)items[i].m * wM1 + (__int128)items[i].l * wL1;
+        long double wi = (w128 <= 0 ? 1.0L : (long double)(long long)min<__int128>(w128, (__int128)LLONG_MAX));
+        dens[i] = (wi <= 0 ? 0.0L : (long double)items[i].v / wi);
+    }
+    stable_sort(order.begin(), order.end(), [&](int a, int b){
+        if (dens[a] != dens[b]) return dens[a] > dens[b];
+        // tie-break: prefer higher absolute value
+        if (items[a].v != items[b].v) return items[a].v > items[b].v;
+        // then smaller combined consumption
+        __int128 wa = (__int128)items[a].m * wM1 + (__int128)items[a].l * wL1;
+        __int128 wb = (__int128)items[b].m * wM1 + (__int128)items[b].l * wL1;
+        return wa < wb;
+    });
+
+    vector<BeamState> beam, nxt;
+    beam.reserve(BEAM_W);
+    nxt.reserve(BEAM_W * 8);
+
+    BeamState init;
+    init.remM = M; init.remL = L; init.val = 0;
+    init.ub = (long double)init.val + fractional_bound(items, order, 0, init.remM, init.remL, M, L, wM1, wL1);
+    beam.push_back(init);
+
+    auto push_state = [&](vector<BeamState>& vec, const BeamState& st){
+        vec.push_back(st);
+    };
+
+    for (int pos = 0; pos < 12; pos++) {
+        nxt.clear();
+        int it = order[pos];
+        for (const auto& st : beam) {
+            long long remM = st.remM, remL = st.remL;
+            long long maxTake = 0;
+            if (items[it].m <= remM && items[it].l <= remL) {
+                long long byM = remM / items[it].m;
+                long long byL = remL / items[it].l;
+                maxTake = min<long long>(items[it].q, min(byM, byL));
+            }
+
+            vector<int> cands;
+            cands.reserve(12);
+            cands.push_back(0);
+            if (maxTake > 0) {
+                cands.push_back((int)maxTake);
+                cands.push_back(1);
+                cands.push_back((int)min<long long>(2, maxTake));
+                cands.push_back((int)min<long long>(3, maxTake));
+                cands.push_back((int)(maxTake / 2));
+                cands.push_back((int)(maxTake / 3));
+                cands.push_back((int)(maxTake * 3 / 4));
+                cands.push_back((int)(maxTake * 4 / 5));
+                cands.push_back((int)(maxTake / 5));
+            }
+            sort(cands.begin(), cands.end());
+            cands.erase(unique(cands.begin(), cands.end()), cands.end());
+
+            for (int take : cands) {
+                if (take < 0) continue;
+                if ((long long)take > maxTake) continue;
+                BeamState ns = st;
+                ns.x[it] = take;
+                ns.remM = remM - (long long)take * items[it].m;
+                ns.remL = remL - (long long)take * items[it].l;
+                ns.val = st.val + (long long)take * items[it].v;
+                ns.ub = (long double)ns.val + fractional_bound(items, order, pos+1, ns.remM, ns.remL, M, L, wM1, wL1);
+                push_state(nxt, ns);
+            }
+        }
+
+        // Keep top BEAM_W by (ub, val)
+        if ((int)nxt.size() > BEAM_W) {
+            nth_element(nxt.begin(), nxt.begin() + BEAM_W, nxt.end(), [](const BeamState& a, const BeamState& b){
+                if (a.ub != b.ub) return a.ub > b.ub;
+                return a.val > b.val;
+            });
+            nxt.resize(BEAM_W);
+        }
+        sort(nxt.begin(), nxt.end(), [](const BeamState& a, const BeamState& b){
+            if (a.ub != b.ub) return a.ub > b.ub;
+            return a.val > b.val;
+        });
+
+        beam.swap(nxt);
+    }
+
+    // Choose best by value (all feasible)
+    Solution best;
+    long long bestV = -1;
+    for (const auto& st : beam) {
+        if (st.val > bestV) {
+            bestV = st.val;
+            best.x = st.x;
+        }
+    }
+    best.value = bestV;
+    auto used = compute_used(items, best.x);
+    best.usedM = used.first;
+    best.usedL = used.second;
+    return best;
+}
+
+static Solution local_improve(
+    const vector<Item>& items,
+    long long M, long long L,
+    Solution sol,
+    uint64_t seed,
+    int ITER
+) {
+    // fixed density based on normalized combined weight: w = m*L + l*M
+    vector<int> order(12);
+    iota(order.begin(), order.end(), 0);
+    vector<long double> dens(12, 0.0L);
+    for (int i = 0; i < 12; i++) {
+        __int128 w = (__int128)items[i].m * L + (__int128)items[i].l * M;
+        long double wi = (w <= 0 ? 1.0L : (long double)(long long)min<__int128>(w, (__int128)LLONG_MAX));
+        dens[i] = (wi <= 0 ? 0.0L : (long double)items[i].v / wi);
+    }
+    stable_sort(order.begin(), order.end(), [&](int a, int b){
+        if (dens[a] != dens[b]) return dens[a] > dens[b];
+        return items[a].v > items[b].v;
+    });
+
+    auto eval = [&](const array<int,12>& x, long long& usedM, long long& usedL, long long& val) {
+        __int128 um = 0, ul = 0, vv = 0;
+        for (int i = 0; i < 12; i++) {
+            um += (__int128)x[i] * items[i].m;
+            ul += (__int128)x[i] * items[i].l;
+            vv += (__int128)x[i] * items[i].v;
+        }
+        usedM = (long long)um;
+        usedL = (long long)ul;
+        val = (long long)vv;
+    };
+
+    auto refill_greedy = [&](array<int,12>& x) {
+        long long usedM, usedL, val;
+        eval(x, usedM, usedL, val);
+        long long remM = M - usedM;
+        long long remL = L - usedL;
+        if (remM < 0 || remL < 0) return;
+        for (int id : order) {
+            int have = x[id];
+            int canMore = items[id].q - have;
+            if (canMore <= 0) continue;
+            if (items[id].m > remM || items[id].l > remL) continue;
+            long long add = min<long long>(canMore, min(remM / items[id].m, remL / items[id].l));
+            if (add <= 0) continue;
+            x[id] += (int)add;
+            remM -= add * items[id].m;
+            remL -= add * items[id].l;
+        }
+    };
+
+    mt19937_64 rng(seed);
+
+    Solution best = sol;
+    if (best.usedM > M || best.usedL > L) {
+        // repair (shouldn't happen)
+        best.x.fill(0);
+        best = greedy(items, M, L, 1.0L/(long double)M, 1.0L/(long double)L);
+    }
+
+    vector<int> nonzero;
+    nonzero.reserve(12);
+
+    for (int it = 0; it < ITER; it++) {
+        array<int,12> x = best.x;
+
+        nonzero.clear();
+        for (int i = 0; i < 12; i++) if (x[i] > 0) nonzero.push_back(i);
+        if (nonzero.empty()) break;
+
+        int i = nonzero[(size_t)(rng() % nonzero.size())];
+
+        int maxRemove = min(x[i], 30);
+        if (maxRemove <= 0) continue;
+        int r = 1 + (int)(rng() % maxRemove);
+
+        x[i] -= r;
+
+        // occasional second removal to escape local maxima
+        if ((rng() % 5) == 0) {
+            nonzero.clear();
+            for (int j = 0; j < 12; j++) if (x[j] > 0) nonzero.push_back(j);
+            if (!nonzero.empty()) {
+                int j = nonzero[(size_t)(rng() % nonzero.size())];
+                int maxRemove2 = min(x[j], 20);
+                if (maxRemove2 > 0) {
+                    int r2 = 1 + (int)(rng() % maxRemove2);
+                    x[j] -= r2;
+                }
+            }
+        }
+
+        refill_greedy(x);
+
+        long long usedM, usedL, val;
+        eval(x, usedM, usedL, val);
+        if (usedM <= M && usedL <= L && val > best.value) {
+            best.x = x;
+            best.value = val;
+            best.usedM = usedM;
+            best.usedL = usedL;
+        }
+    }
+
+    return best;
+}
+
+static uint64_t hash_input(const string& s) {
+    // FNV-1a 64-bit
+    uint64_t h = 1469598103934665603ULL;
+    for (unsigned char c : s) {
+        h ^= (uint64_t)c;
+        h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string input((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());
+    size_t i = 0;
+    skip_ws(input, i);
+    if (i >= input.size() || input[i] != '{') return 0;
+    i++;
+
+    vector<Item> items;
+    items.reserve(12);
+    vector<string> keyOrder;
+
+    while (true) {
+        skip_ws(input, i);
+        if (i >= input.size()) break;
+        if (input[i] == '}') { i++; break; }
+
+        string key = parse_string(input, i);
+        skip_ws(input, i);
+        if (i < input.size() && input[i] == ':') i++;
+        skip_ws(input, i);
+        if (i < input.size() && input[i] == '[') i++;
+        long long q = parse_int(input, i);
+        skip_ws(input, i); if (i < input.size() && input[i] == ',') i++;
+        long long v = parse_int(input, i);
+        skip_ws(input, i); if (i < input.size() && input[i] == ',') i++;
+        long long m = parse_int(input, i);
+        skip_ws(input, i); if (i < input.size() && input[i] == ',') i++;
+        long long l = parse_int(input, i);
+        skip_ws(input, i);
+        if (i < input.size() && input[i] == ']') i++;
+
+        Item it;
+        it.name = key;
+        it.q = (int)q;
+        it.v = v;
+        it.m = m;
+        it.l = l;
+
+        items.push_back(it);
+        keyOrder.push_back(key);
+
+        skip_ws(input, i);
+        if (i < input.size() && input[i] == ',') { i++; continue; }
+        if (i < input.size() && input[i] == '}') { i++; break; }
+    }
+
+    // Ensure exactly 12; if not, still proceed with min size but output what's given.
+    int n = (int)items.size();
+    if (n == 0) {
+        cout << "{}\n";
+        return 0;
+    }
+    if (n < 12) {
+        // pad to 12 with dummies to keep code simple
+        while ((int)items.size() < 12) {
+            Item dummy;
+            dummy.name = "__dummy" + to_string(items.size());
+            dummy.q = 0;
+            dummy.v = dummy.m = dummy.l = 0;
+            items.push_back(dummy);
+            keyOrder.push_back(dummy.name);
+        }
+    }
+    if (n > 12) {
+        items.resize(12);
+        keyOrder.resize(12);
+        n = 12;
+    }
+
+    const long long M = 20LL * 1000000LL;
+    const long long L = 25LL * 1000000LL;
+
+    vector<Solution> candidates;
+
+    // Greedy candidates
+    {
+        long double invM = 1.0L / (long double)M;
+        long double invL = 1.0L / (long double)L;
+        vector<pair<long double,long double>> wts = {
+            {1.0L, 0.0L},
+            {0.0L, 1.0L},
+            {invM, invL},
+            {invM, 0.5L*invL},
+            {invM, 2.0L*invL},
+            {2.0L*invM, invL},
+            {0.5L*invM, invL}
+        };
+        uint64_t h = hash_input(input);
+        mt19937_64 rng(h ^ 0xA5A5A5A5A5A5A5A5ULL);
+        for (int t = 0; t < 6; t++) {
+            long double a = (long double)(rng() % 5000) / 1000.0L; // [0,5)
+            long double b = (long double)(rng() % 5000) / 1000.0L; // [0,5)
+            if (a < 0.05L && b < 0.05L) { a = invM; b = invL; }
+            wts.push_back({a*invM, b*invL});
+        }
+        for (auto [a,b] : wts) candidates.push_back(greedy(items, M, L, a, b));
+    }
+
+    // Beam search candidates
+    vector<WeightRun> runs;
+    runs.push_back({1,1,true});
+    runs.push_back({0,1,true});
+    runs.push_back({1,4,true});
+    runs.push_back({1,2,true});
+    runs.push_back({2,1,true});
+    runs.push_back({4,1,true});
+    runs.push_back({8,1,true});
+    runs.push_back({1,4,false});
+    runs.push_back({1,2,false});
+    runs.push_back({2,1,false});
+    {
+        uint64_t h = hash_input(input);
+        mt19937_64 rng(h ^ 0x1234567890ABCDEFULL);
+        for (int t = 0; t < 4; t++) {
+            long long p = 1 + (long long)(rng() % 6);
+            long long q = 1 + (long long)(rng() % 6);
+            bool vol = (rng() & 1);
+            runs.push_back({p,q,vol});
+        }
+    }
+
+    int BEAM_W = 2500;
+    for (auto &wr : runs) {
+        candidates.push_back(beam_search(items, M, L, wr, BEAM_W));
+    }
+
+    // Choose best candidate
+    Solution best;
+    best.value = -1;
+    for (auto &s : candidates) {
+        auto used = compute_used(items, s.x);
+        s.usedM = used.first;
+        s.usedL = used.second;
+        if (s.usedM <= M && s.usedL <= L && s.value > best.value) best = s;
+    }
+
+    // Local improvement on best
+    {
+        uint64_t seed = hash_input(input) ^ 0x9E3779B97F4A7C15ULL;
+        best = local_improve(items, M, L, best, seed, 6000);
+    }
+
+    // Output JSON in original key order (first n keys)
+    cout << "{\n";
+    for (int k = 0; k < n; k++) {
+        cout << " \"" << items[k].name << "\": " << best.x[k];
+        if (k + 1 < n) cout << ",\n";
+        else cout << "\n";
+    }
+    cout << "}\n";
+    return 0;
+}

docker_space/frontier_cs_1/examples/gpt5.2_1.cpp

@@ -0,0 +1,437 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Item {
+    string name;
+    int q;
+    long long v, m, l;
+};
+
+struct Solution {
+    vector<long long> x;
+    long long mass = 0, vol = 0, val = 0;
+};
+
+static const long long CAP_M = 20LL * 1000000LL;
+static const long long CAP_L = 25LL * 1000000LL;
+
+struct Parser {
+    string s;
+    size_t i = 0;
+
+    explicit Parser(string in) : s(std::move(in)), i(0) {}
+
+    void skipWs() {
+        while (i < s.size() && (s[i] == ' ' || s[i] == '\n' || s[i] == '\r' || s[i] == '\t')) i++;
+    }
+
+    void expect(char c) {
+        skipWs();
+        if (i >= s.size() || s[i] != c) {
+            // invalid input, but we assume valid per problem statement
+            return;
+        }
+        i++;
+    }
+
+    string parseString() {
+        skipWs();
+        expect('"');
+        string out;
+        while (i < s.size() && s[i] != '"') {
+            out.push_back(s[i]);
+            i++;
+        }
+        expect('"');
+        return out;
+    }
+
+    long long parseInt() {
+        skipWs();
+        long long sign = 1;
+        if (i < s.size() && s[i] == '-') { sign = -1; i++; }
+        long long x = 0;
+        while (i < s.size() && isdigit((unsigned char)s[i])) {
+            x = x * 10 + (s[i] - '0');
+            i++;
+        }
+        return x * sign;
+    }
+};
+
+static inline long long clamp_ll(long long x, long long lo, long long hi) {
+    return max(lo, min(hi, x));
+}
+
+static inline long double densityNormSum(const Item& it, long double alpha) {
+    long double dm = (long double)it.m / (long double)CAP_M;
+    long double dl = (long double)it.l / (long double)CAP_L;
+    long double denom = alpha * dm + (1.0L - alpha) * dl;
+    if (denom <= 0) return 0;
+    return (long double)it.v / denom;
+}
+
+static inline long double densityNormMax(const Item& it) {
+    long double dm = (long double)it.m / (long double)CAP_M;
+    long double dl = (long double)it.l / (long double)CAP_L;
+    long double denom = max(dm, dl);
+    if (denom <= 0) return 0;
+    return (long double)it.v / denom;
+}
+
+static inline long double densitySumRaw(const Item& it, long double lambda) {
+    long double denom = (long double)it.m + lambda * (long double)it.l;
+    if (denom <= 0) return 0;
+    return (long double)it.v / denom;
+}
+
+static Solution evalSolution(const vector<Item>& items, const vector<long long>& x) {
+    Solution sol;
+    sol.x = x;
+    sol.mass = sol.vol = sol.val = 0;
+    for (size_t k = 0; k < items.size(); k++) {
+        sol.mass += items[k].m * sol.x[k];
+        sol.vol  += items[k].l * sol.x[k];
+        sol.val  += items[k].v * sol.x[k];
+    }
+    return sol;
+}
+
+static void refillWithOrder(const vector<Item>& items, Solution& sol, const vector<int>& order) {
+    for (int idx : order) {
+        const auto& it = items[idx];
+        if (sol.x[idx] >= it.q) continue;
+        long long remM = CAP_M - sol.mass;
+        long long remL = CAP_L - sol.vol;
+        if (remM <= 0 || remL <= 0) continue;
+        long long add = it.q - sol.x[idx];
+        add = min(add, remM / it.m);
+        add = min(add, remL / it.l);
+        if (add <= 0) continue;
+        sol.x[idx] += add;
+        sol.mass += it.m * add;
+        sol.vol  += it.l * add;
+        sol.val  += it.v * add;
+    }
+}
+
+static void greedyFillFromEmpty(const vector<Item>& items, Solution& sol, const vector<int>& order) {
+    sol.x.assign(items.size(), 0);
+    sol.mass = sol.vol = sol.val = 0;
+    refillWithOrder(items, sol, order);
+}
+
+static void repairFeasible(const vector<Item>& items, Solution& sol) {
+    if (sol.mass <= CAP_M && sol.vol <= CAP_L) return;
+
+    int n = (int)items.size();
+    vector<int> idxs(n);
+    iota(idxs.begin(), idxs.end(), 0);
+
+    auto dens = [&](int i) -> long double {
+        return densityNormSum(items[i], 0.5L);
+    };
+
+    // Remove lowest density items in bulk until feasible.
+    for (int step = 0; step < 1000 && (sol.mass > CAP_M || sol.vol > CAP_L); step++) {
+        int best = -1;
+        long double bestD = 1e300L;
+        for (int i = 0; i < n; i++) {
+            if (sol.x[i] <= 0) continue;
+            long double d = dens(i);
+            if (d < bestD) { bestD = d; best = i; }
+        }
+        if (best < 0) break;
+
+        long long overM = max(0LL, sol.mass - CAP_M);
+        long long overL = max(0LL, sol.vol - CAP_L);
+        const auto& it = items[best];
+
+        long long need = 1;
+        if (overM > 0) need = max(need, (overM + it.m - 1) / it.m);
+        if (overL > 0) need = max(need, (overL + it.l - 1) / it.l);
+        need = min(need, sol.x[best]);
+        if (need <= 0) need = 1;
+
+        sol.x[best] -= need;
+        sol.mass -= it.m * need;
+        sol.vol  -= it.l * need;
+        sol.val  -= it.v * need;
+    }
+
+    // Final safety: remove one by one if still infeasible.
+    for (int step = 0; step < 100000 && (sol.mass > CAP_M || sol.vol > CAP_L); step++) {
+        int best = -1;
+        long double bestD = 1e300L;
+        for (int i = 0; i < (int)items.size(); i++) {
+            if (sol.x[i] <= 0) continue;
+            long double d = densityNormSum(items[i], 0.5L);
+            if (d < bestD) { bestD = d; best = i; }
+        }
+        if (best < 0) break;
+        sol.x[best]--;
+        sol.mass -= items[best].m;
+        sol.vol  -= items[best].l;
+        sol.val  -= items[best].v;
+    }
+
+    if (sol.mass < 0) sol.mass = 0;
+    if (sol.vol < 0) sol.vol = 0;
+    if (sol.val < 0) sol.val = 0;
+}
+
+static bool pairOptimizeExact(const vector<Item>& items, Solution& sol, int i, int j) {
+    if (i == j) return false;
+    const auto& A = items[i];
+    const auto& B = items[j];
+
+    long long xi = sol.x[i], xj = sol.x[j];
+    long long mass_others = sol.mass - A.m * xi - B.m * xj;
+    long long vol_others  = sol.vol  - A.l * xi - B.l * xj;
+    long long val_others  = sol.val  - A.v * xi - B.v * xj;
+
+    long long Mrem = CAP_M - mass_others;
+    long long Lrem = CAP_L - vol_others;
+    if (Mrem < 0 || Lrem < 0) return false;
+
+    long long aUpper = min<long long>(A.q, min(Mrem / A.m, Lrem / A.l));
+    long long bUpper = min<long long>(B.q, min(Mrem / B.m, Lrem / B.l));
+
+    long long curPairVal = A.v * xi + B.v * xj;
+    long long curPairMass = A.m * xi + B.m * xj;
+    long long curPairVol  = A.l * xi + B.l * xj;
+
+    long long bestA = xi, bestB = xj;
+    long long bestPairVal = curPairVal;
+    long long bestPairUsed = curPairMass + curPairVol;
+
+    auto consider = [&](long long a, long long b) {
+        if (a < 0 || b < 0) return;
+        if (a > A.q || b > B.q) return;
+        long long mm = A.m * a + B.m * b;
+        long long ll = A.l * a + B.l * b;
+        if (mm > Mrem || ll > Lrem) return;
+        long long vv = A.v * a + B.v * b;
+        long long used = mm + ll;
+        if (vv > bestPairVal || (vv == bestPairVal && used < bestPairUsed)) {
+            bestPairVal = vv;
+            bestPairUsed = used;
+            bestA = a;
+            bestB = b;
+        }
+    };
+
+    if (aUpper <= bUpper) {
+        for (long long a = 0; a <= aUpper; a++) {
+            long long Mleft = Mrem - A.m * a;
+            long long Lleft = Lrem - A.l * a;
+            if (Mleft < 0 || Lleft < 0) break;
+            long long b = min<long long>(B.q, min(Mleft / B.m, Lleft / B.l));
+            consider(a, b);
+        }
+    } else {
+        for (long long b = 0; b <= bUpper; b++) {
+            long long Mleft = Mrem - B.m * b;
+            long long Lleft = Lrem - B.l * b;
+            if (Mleft < 0 || Lleft < 0) break;
+            long long a = min<long long>(A.q, min(Mleft / A.m, Lleft / A.l));
+            consider(a, b);
+        }
+    }
+
+    if (bestA == xi && bestB == xj) return false;
+
+    // Apply
+    sol.x[i] = bestA;
+    sol.x[j] = bestB;
+    sol.mass = mass_others + A.m * bestA + B.m * bestB;
+    sol.vol  = vol_others  + A.l * bestA + B.l * bestB;
+    sol.val  = val_others  + A.v * bestA + B.v * bestB;
+
+    return true;
+}
+
+static void improveSolution(const vector<Item>& items, Solution& sol, const vector<int>& refillOrder, mt19937_64& rng, int maxRounds) {
+    repairFeasible(items, sol);
+    refillWithOrder(items, sol, refillOrder);
+    repairFeasible(items, sol);
+
+    int n = (int)items.size();
+    vector<pair<int,int>> pairs;
+    pairs.reserve(n*(n-1)/2);
+    for (int i = 0; i < n; i++)
+        for (int j = i+1; j < n; j++)
+            pairs.emplace_back(i,j);
+
+    for (int round = 0; round < maxRounds; round++) {
+        bool changed = false;
+        shuffle(pairs.begin(), pairs.end(), rng);
+        for (auto [i,j] : pairs) {
+            changed |= pairOptimizeExact(items, sol, i, j);
+        }
+        long long oldVal = sol.val;
+        long long oldMass = sol.mass, oldVol = sol.vol;
+        refillWithOrder(items, sol, refillOrder);
+        if (sol.val != oldVal || sol.mass != oldMass || sol.vol != oldVol) changed = true;
+        if (!changed) break;
+    }
+    repairFeasible(items, sol);
+}
+
+static vector<int> makeOrder(const vector<Item>& items, function<long double(const Item&)> scoreFn) {
+    int n = (int)items.size();
+    vector<int> order(n);
+    iota(order.begin(), order.end(), 0);
+    stable_sort(order.begin(), order.end(), [&](int a, int b){
+        long double sa = scoreFn(items[a]);
+        long double sb = scoreFn(items[b]);
+        if (sa != sb) return sa > sb;
+        return items[a].v > items[b].v;
+    });
+    return order;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+
+    string input, line;
+    while (getline(cin, line)) {
+        input += line;
+        input.push_back('\n');
+    }
+
+    Parser p(input);
+    p.skipWs();
+    p.expect('{');
+
+    vector<Item> items;
+    vector<string> keyOrder;
+
+    while (true) {
+        p.skipWs();
+        if (p.i < p.s.size() && p.s[p.i] == '}') { p.i++; break; }
+        string key = p.parseString();
+        keyOrder.push_back(key);
+        p.skipWs();
+        p.expect(':');
+        p.skipWs();
+        p.expect('[');
+        long long q = p.parseInt();
+        p.skipWs(); p.expect(',');
+        long long v = p.parseInt();
+        p.skipWs(); p.expect(',');
+        long long m = p.parseInt();
+        p.skipWs(); p.expect(',');
+        long long l = p.parseInt();
+        p.skipWs();
+        p.expect(']');
+        items.push_back(Item{key, (int)q, v, m, l});
+        p.skipWs();
+        if (p.i < p.s.size() && p.s[p.i] == ',') { p.i++; continue; }
+        if (p.i < p.s.size() && p.s[p.i] == '}') { p.i++; break; }
+    }
+
+    int n = (int)items.size();
+    // Safety if input malformed; but statement guarantees exactly 12.
+    if (n == 0) {
+        cout << "{\n}\n";
+        return 0;
+    }
+
+    mt19937_64 rng(0xC0FFEE123456789ULL);
+
+    // Precompute a few orders
+    vector<vector<int>> orders;
+    vector<long double> alphas = {0.0L, 0.2L, 0.4L, 0.5L, 0.6L, 0.8L, 1.0L};
+    for (auto a : alphas) {
+        orders.push_back(makeOrder(items, [a](const Item& it){ return densityNormSum(it, a); }));
+    }
+    orders.push_back(makeOrder(items, [](const Item& it){ return densityNormMax(it); }));
+    orders.push_back(makeOrder(items, [](const Item& it){
+        return (it.m > 0) ? (long double)it.v / (long double)it.m : 0.0L;
+    }));
+    orders.push_back(makeOrder(items, [](const Item& it){
+        return (it.l > 0) ? (long double)it.v / (long double)it.l : 0.0L;
+    }));
+    orders.push_back(makeOrder(items, [](const Item& it){ return (long double)it.v; }));
+    orders.push_back(makeOrder(items, [](const Item& it){
+        return (long double)it.v / ( (long double)it.m + (long double)it.l );
+    }));
+    vector<long double> lambdas = {0.0L, 0.01L, 0.05L, 0.1L, 0.2L, 0.5L, 1.0L, 2.0L, 5.0L, 10.0L};
+    for (auto lam : lambdas) {
+        orders.push_back(makeOrder(items, [lam](const Item& it){ return densitySumRaw(it, lam); }));
+    }
+
+    // Baseline best: try each order
+    Solution best;
+    best.x.assign(n, 0);
+    best.mass = best.vol = best.val = 0;
+
+    for (const auto& ord : orders) {
+        Solution sol;
+        greedyFillFromEmpty(items, sol, ord);
+        improveSolution(items, sol, ord, rng, 4);
+        if (sol.val > best.val) best = sol;
+    }
+
+    // Randomized multi-start / perturbation
+    int ITER = 160;
+    for (int t = 0; t < ITER; t++) {
+        Solution sol = best;
+
+        if (t % 6 == 0) {
+            // start from empty with random order
+            vector<int> ord(n);
+            iota(ord.begin(), ord.end(), 0);
+            shuffle(ord.begin(), ord.end(), rng);
+            greedyFillFromEmpty(items, sol, ord);
+            improveSolution(items, sol, ord, rng, 3);
+        } else {
+            // perturb best
+            for (int i = 0; i < n; i++) {
+                if (sol.x[i] == 0) continue;
+                uint64_t r = rng() % 100;
+                if (r < 8) sol.x[i] = 0;
+                else if (r < 24) sol.x[i] = sol.x[i] / 4;
+                else if (r < 48) sol.x[i] = sol.x[i] / 2;
+                else if (r < 64) sol.x[i] = (sol.x[i] * 3) / 4;
+            }
+            sol = evalSolution(items, sol.x);
+            repairFeasible(items, sol);
+
+            // choose a random alpha-based order to refill
+            long double a = (long double)(rng() % 1000) / 1000.0L;
+            auto ord = makeOrder(items, [a](const Item& it){ return densityNormSum(it, a); });
+            refillWithOrder(items, sol, ord);
+            improveSolution(items, sol, ord, rng, 3);
+        }
+
+        if (sol.val > best.val) best = sol;
+    }
+
+    // Final repair and slight refill using best normalized order
+    auto finalOrd = makeOrder(items, [](const Item& it){ return densityNormSum(it, 0.5L); });
+    repairFeasible(items, best);
+    refillWithOrder(items, best, finalOrd);
+    repairFeasible(items, best);
+
+    // Output JSON with same keys as input in the same order.
+    // Build mapping from name to count from items order.
+    unordered_map<string, long long> out;
+    out.reserve(n * 2);
+    for (int i = 0; i < n; i++) out[items[i].name] = best.x[i];
+
+    cout << "{\n";
+    for (int k = 0; k < (int)keyOrder.size(); k++) {
+        const string& key = keyOrder[k];
+        long long cnt = 0;
+        auto it = out.find(key);
+        if (it != out.end()) cnt = it->second;
+        cout << " \"" << key << "\": " << cnt;
+        if (k + 1 < (int)keyOrder.size()) cout << ",";
+        cout << "\n";
+    }
+    cout << "}\n";
+    return 0;
+}