First scheduled session: Saturday, November 21, 2026.
Location: second-floor computer cluster in CSB.
Joining and materials: Any access changes, online links, calendar details, and weekly problem sets will be posted in the team communication channel and calendar invite.
Post-contest teaching block: Within the existing 7:00-8:00 PM ET block, the focused lecture will run from 7:00-7:40 PM. The remaining 20 minutes are optional questions and office hours. Slides, notes, or a recording may be shared for asynchronous review when appropriate.
Team contest performance: record the five-hour solve count and acceptance timeline after every simulation.
Upsolving: track assigned problems completed within seven days.
Topic preparation: track completion of the weekly topic-specific problem set by the next scheduled practice.
Recurring weaknesses: maintain a shared log of missed techniques, implementation errors, and unresolved problems.
Coaching review: set numerical targets after the initial baseline sessions and adjust training from the weekly evidence.
This training plan prepares Columbia’s ICPC team for the ICPC North America Championship (NAC), March 16-21, 2027. The objective is to become a team that consistently solves more difficult problems within five hours through weekly contest simulations, upsolving, and targeted algorithm training.
Saturdays
November 21, 2026 - Optimization and Search. Techniques: binary search on the answer, monotone predicates, parametric and ternary search, backtracking with pruning, and meet-in-the-middle. Goal: prove the search condition and complexity before coding.
December 5, 2026 - Graph Algorithms. Techniques: BFS/DFS, connected components, topological sorting, Dijkstra, all-pairs shortest paths, minimum spanning trees, and disjoint-set union. Goal: choose the right graph model and connectivity or path tool.
December 12, 2026 - Computational Geometry. Techniques: vectors, cross products, orientation, segment intersection, convex hulls, point-in-polygon tests, sweep lines, and robust precision. Goal: express geometry as reliable predicates and avoid floating-point errors.
January 16, 2027 - Dynamic Programming. Techniques: state and transition design, memoization, tabulation, bitmask DP, interval DP, tree DP, reconstruction, and memory optimization. Goal: define complete states, justify transitions, and reduce unnecessary dimensions.
January 23, 2027 - Data Structures. Techniques: stacks, queues, deques, priority queues, disjoint sets, ordered sets/maps, hashing, coordinate compression, and amortized analysis. Goal: match required operations and constraints to the simplest effective structure.
January 30, 2027 - String Algorithms. Techniques: prefix functions and KMP, Z-algorithm, rolling hashes, tries, parsing, prefix/suffix reasoning, and palindrome methods. Goal: expose repeated structure and choose deterministic or hashing-based matching safely.
February 6, 2027 - Greedy Algorithms. Techniques: sorting-based choices, exchange arguments, invariants, interval scheduling, priority-driven selection, constructive methods, and counterexample testing. Goal: prove the local choice instead of relying on intuition.
February 13, 2027 - Range and Offline Queries. Techniques: prefix/difference arrays, Fenwick trees, segment trees with lazy propagation, coordinate compression, sweep lines, and offline query ordering. Goal: turn updates into events and choose the lightest sufficient structure.
February 20, 2027 - Trees. Techniques: rooted traversal, subtree aggregation, diameters, Euler tours, rerooting, binary lifting, lowest common ancestors, and tree DP. Goal: exploit unique paths and move cleanly between tree and array representations.
February 27, 2027 - Number Theory. Techniques: Euclid's algorithm, modular arithmetic, fast exponentiation, modular inverses, sieves, prime factorization, Chinese remainder theorem, and Euler's totient. Goal: identify the algebraic structure and control overflow and normalization.
March 6, 2027 - Probability and Expected Value. Techniques: conditional probability, indicator variables, linearity of expectation, expectation recurrences, DP over random states, and Markov-style transitions. Goal: model the random process precisely and replace enumeration with compact recurrences.
1:30-6:30 PM ET: Five-hour team contest simulation.
6:30-7:00 PM ET: Contest review focused on approaches, mistakes, and missed opportunities.
7:00-8:00 PM ET: Coach-led lecture on one priority topic, followed by a new assigned problem set. Problem sets will be shared separately.
Primary: All available past ICPC NAC contests, attempted under timed conditions before reviewing solutions.
Comparable championship contests: ICPC Europe Championship (EUC), Eastern Europe regional finals (EC Finals), Northern Eurasia contests (NERC), and ICPC World Finals.
Supplementary: Codeforces, AtCoder, MIT Informatics Tournament (MITIT), and other contests with problems of comparable difficulty.
Coaches will select specific contests and problem sets based on the team’s current level, weaknesses, and remaining preparation time. Actual weekly problem sets will be shared separately.
Training will target the algorithms and techniques most important for NAC-level competition. Priority areas include dynamic programming; graph algorithms; greedy algorithms; trees; data structures; combinatorics and number theory; string algorithms; computational geometry; network flow and matching; advanced dynamic programming; range and offline queries; polynomial algorithms; probability and expected value; linear algebra; advanced graph, tree, and string techniques; optimization and search; and game theory and interactive problems.
Topics will not necessarily be taught in this order. Coaches will prioritize weaknesses identified through contest performance.
Upsolve Saturday’s problems, beginning with those the team was closest to solving.
Complete the assigned topic-specific problem set.
Discuss approaches with teammates and coaches, and be prepared to explain the key ideas behind solutions.
Review recurring mistakes so the following week’s topics and problem sets can be adjusted.
Team: Complete the Saturday simulation and review every unsolved problem.
Each member: Upsolve assigned problems, complete the weekly problem set, and explain at least one previously unsolved problem each week.
Coaches: Track performance, review recurring mistakes, and adjust the following week’s training.
Progress tracking: Record problems solved during contests, problems solved through upsolving, and unresolved weaknesses.
Alongside algorithm knowledge, we will practice problem selection, team communication, implementation speed, debugging, and time management. The goal is to consistently solve more difficult problems as a team within five hours.