USACO Tutoring
I run a weekly program built around the patterns USACO commonly tests, with teaching sessions, timed problem sets, and review. Curriculum is tuned to recent contests (2024-2026) and real promotion gates.
One concept, one guided problem, one you-drive variant. I focus on the idea and then you implement it.
2-3 problems under strict time. Builds contest stamina and forces clean, fast code.
Debugging, complexity, edge cases. I fix what broke and tighten what worked.
Bronze has shifted toward clean simulation, careful casework, and counting/prefix ideas (e.g. Chip Exchange, COW Splits, Photoshoot in 2026). I build the habits that make all of Bronze #1, #2, and #3 reliably solvable.
8-10 weeks · C++ / Java / Python
Concepts: I/O speed, reading constraints, using long long. Write brute force first, then tighten. Testing discipline: small cases, random tests, boundaries.
Drills: Implement sort, count freq, prefix sum, two loops with constraints check. Debugging: off-by-one, indexing, overflow.
Concepts: Step-by-step simulation with variables/invariants. Do not be clever; implement exactly the process described. Pattern: maintain state, update in loop, assert constraints.
Practice: 2026 Contest 1 Bronze P1: Chip Exchange; 2024 Dec Bronze P2: Farmer John's Cheese Block.
Tutor focus: Students narrate state transitions out loud.
Concepts: Frequency arrays/maps. O(N²) is fine if N ≤ 2000-ish, not if N = 2e5. Build counts, then answer queries.
Practice: Bronze counting problems + custom drills: count pairs with condition, count equalities after transforming.
Concepts: Prefix sum array, range sum in O(1). Split points: count ways where left and right conditions hold. Avoid recomputing sums in loops.
Practice: 2026 Contest 1 Bronze P2: COW Splits; 2025 US Open Bronze P2: More Cow Photos.
Tutor focus: What you need to know about the prefix to answer quickly.
Concepts: Sort pairs, sort by key. Greedy that is obvious after sorting (do smallest first, group equal items).
Practice: 2024 Dec Bronze P1: Roundabout Rounding; timed set: 2 older Bronze sorting problems from USACO Guide.
Concepts: Scan once, count transitions, segments, runs. Build answer from local patterns. Pitfalls: substring indices, inclusive/exclusive.
Practice: 2025 US Open Bronze P1: Hoof Paper Scissors Minus One; 2025 US Open Bronze P3: It's Mooin' Time III.
Concepts: Parity (even/odd), modular arithmetic basics. When brute force works vs doesn't. Translating English constraints into code checks.
Practice: Mix of USACO Guide Bronze math/ad hoc buckets.
Concepts: Break into exhaustive cases without overlap. Proving you covered all cases. Edge-case checklist: N=1, all equal, strictly increasing, duplicates, large values.
Practice: 2026 Contest 1 Bronze P3: Photoshoot; review set of 3 earlier Bronze #3s.
Solve full recent Bronze contests under time, then analyze mistakes.
Suggested mocks: 2026 Contest 1 Bronze (Chip Exchange / COW Splits / Photoshoot); 2024 Dec Bronze (Roundabout Rounding / Cheese Block / It's Mooin' Time); 2026 Contest 2 Bronze (It's Mooin' Time IV / Moo Hunt / Purchasing Milk).
Modern Silver is pattern-driven: prefix sums + sliding window, binary search on answer, greedy, BFS/DFS flood fill, coordinate compression, interval logic, and implementation under pressure (e.g. 2026 Contest 1 Silver: Lineup Queries, Mooclear Reactor, Sliding Window Summation).
10-12+ weeks · C++ / Java / Python
Concepts: Big-O reality: N up to 2e5 means ~O(N log N) or O(N). Arrays vs maps; sets; sorting pairs; coordinate compression idea. Writing helper functions cleanly.
Drill: Convert brute force to prefix sum to two pointers.
Concepts: Multiple prefix arrays for categories. Difference array for range increments. Query many times: precompute.
Practice: 2026 Contest 1 Silver P1: Lineup Queries; 2024 Dec Silver P2: Deforestation.
Concepts: Maintain window invariant (sum ≤ K, distinct ≤ K). Two-pointer proofs: why left pointer only moves forward. Prefix sums + multiset/Counter for counts.
Practice: 2026 Contest 1 Silver P3: Sliding Window Summation; additional two pointers from USACO Guide Silver.
Concepts: Turn optimization into is X possible? Monotonicity as the core requirement. Write check(x) cleanly; avoid off-by-one.
Practice: Typical Silver min max / largest minimum style problems (USACO Guide).
Concepts: Sorting by the right key. Exchange argument intuition. Priority queues for take best available.
Practice: 2026 Contest 2 Silver P2: Declining Invitations; 2025 US Open Silver P2: Compatible Pairs.
Concepts: Adjacency lists, visited arrays. Components, shortest path in unweighted graphs (BFS). Grid flood fill patterns.
Practice: USACO Guide Silver graph/flood fill set; (optional) 2025 US Open Silver P3: Ski Slope.
Concepts: Sort endpoints, sweep with events. Coordinate compression for large coordinates. Difference array + prefix to rebuild counts.
Practice: 2024 Dec Silver P3: 2D Conveyor Belt.
Concepts: Handling constraints + corner cases + indexing. Building robust helpers and testing quickly. Silver traps: inclusive ranges, duplicates, 1-index vs 0-index, overflow.
Practice: 2026 Contest 2 Silver P3: Farmer John Loves Rotations; 2026 Contest 2 Silver P1: Cow-libi 2.
Mock contests: 2026 Contest 1 Silver; 2026 Contest 2 Silver; 2024 Dec Silver; 2025 US Open Silver.
Patch plan: Missing #1s: drill prefix sums and sorting. Missing #2s: two pointers and binary search. Missing #3s: implementation, graphs, intervals, compression.
I have tutored 20+ students from Bronze to Platinum. If you are serious about improving and want a structured path tied to real contests, reach out.
Email me to get started