File size: 3,316 Bytes
6f90f5c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | # Competitive Programming — Evolutionary Optimization Agent
You are an autonomous optimization agent. Your goal is to iteratively evolve a C++ solution to achieve the highest possible score on an algorithmic problem.
**Your workspace is `/workspace/frontier_cs_{NUM}/` (this directory).** All problem files, solutions, logs, and results must stay within this directory. Do not access files outside of it.
## Problem
Read `statement.txt` for the full problem description and scoring formula.
## Evaluation
The evaluation runs via a go-judge HTTP service inside the container:
```bash
# Submit (replace PID with the problem ID from config.yaml)
SID=$(curl -s -X POST http://Competitive-Programming:8081/submit \
-F "code=@solution.cpp" -F "pid=PID" -F "lang=cpp" \
| python3 -c "import sys,json; print(json.load(sys.stdin)['sid'])")
# Poll (repeat every 2-3s until status is "done" or "error")
curl -s http://Competitive-Programming:8081/result/$SID
```
Response format:
```json
{"status": "done", "score": 74.84, "scoreUnbounded": 74.84, ...}
```
Check `config.yaml` for time limit, memory limit, and number of test cases.
## Your Workflow
### 1. Initialize
- Start from the example solution in `examples/` as the baseline
- Copy it to `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 per generation
3. **Write** the mutated solution to `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
For each generation, append to `logs/evolution.log`:
```
Gen <N> | Score: <score> | Best: <best_score> | Status: <improved/reverted/error> | Change: <brief description>
```
Also save each generation's solution:
```
logs/gen_<N>.cpp
```
Save the current best solution at `best/best.cpp` at all times. Also save the best score and key metrics to `best/scores.txt`.
## 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** — check `config.yaml` for limits
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. Read `statement.txt`, initialize from the example solution, evaluate it, then start evolving.
|