Sefism Competitive Programming Roadmap

What it is

Sefism's competitive programming roadmap treats contests as what they are: a sport. It takes you from setting up a compiler and a C++ template to playing a five-hour ICPC-style round with two teammates, in ten stages and about 184 hours of work. Each stage lists its topics in learning order, a short explanation of each, a check question to answer without notes, a milestone, a practical checklist and hand-picked resources such as the CSES Problem Set, the USACO Guide, cp-algorithms and Codeforces.

By the end you can:

• Write contest C++ with the STL from a template you know by heart, and read the constraints to pick a complexity before writing any code.
• Recognise and implement the core techniques for your rating band: maths basics, greedy with proofs, binary search, prefix sums, graphs, DP and range structures.
• Take part in rated contests regularly and upsolve the problem just above your level after each one.
• Find your own bugs with edge cases, sanitizers and stress tests instead of guessing.
• Play an ICPC-style team contest with clear roles, problem triage, penalty awareness and a tested team notebook.

Three starting levels

When you open the roadmap you pick where you are starting from, and the page adjusts:

• Beginner: new to contests, rating under 1200. You get 60 topics; harder ones such as anti-hash tests, coordinate compression and lazy propagation are left out until you are ready.
• Intermediate: rating around 1200 to 1600. 67 topics, adding modular inverses, two-dimensional prefix sums, topological order, LIS and real-valued search.
• Advanced: rating 1600 and above, aiming for ICPC. All 73 topics, including bitmask DP, DP on trees, lowest common ancestors with binary lifting, sparse tables, lazy propagation and ordered sets.

Each level has its own page: /roadmaps/competitive-programming/ for beginners, with intermediate and advanced versions linked from it. The stage list is the same ten stages for everyone; what changes is the depth inside them and the practice advice in the contest strategy stage.

Who it suits, and who should start elsewhere

It suits university students who can already write a loop, a function and an array in some language and want to compete: on Codeforces or AtCoder for rating, or with a university team in the ICPC. It also suits anyone who enjoys puzzles and wants a structured way to get faster and more accurate.

It is not the right first step if you are still learning to program. Start with the Programming foundations roadmap and come back. If your goal is the coding rounds of a job search rather than contests, the DSA and problem solving roadmap covers the same ideas at a calmer pace and in the language you already use. And if you have tried contests and dislike them, that is fine too: enjoying technology but not competitive programming is a common and perfectly good place to be.

Time and a weekly plan

The ten stages add up to about 184 hours. The first two, C++ for contests and Maths basics (28 hours together), are marked as foundations: if you already compete in C++ you can skim them. The page turns hours into weeks using the pace you choose: about 40 weeks at 5 hours a week, 26 weeks at 8 hours, or 19 weeks at 12 hours.

A student with 10 to 12 hours a week: two weekday evenings on the current stage's topics and checklist, one rated or virtual contest at the weekend, and one session after it to upsolve. That rhythm finishes the roadmap in roughly five months, in time for a regional season.

Someone working full time with 5 hours a week: one evening on topics, one contest at the weekend (AtCoder Beginner Contests are short and well suited to this), and an hour of upsolving. It takes closer to ten months, and that is fine: rating comes from showing up every week, not from rushing stages.

Stage by stage

1. C++ for contests (14 hours, foundation)

Set up a compiler and a template, learn the STL containers and algorithms contests use every day, and learn to read constraints so you know what complexity you can afford. Topics include reading constraints and time limits, compiler flags and sanitizers, your template and fast input and output, vectors, pairs and sorting, sets, maps and priority queues, the STL algorithms you will use weekly, and integer overflow. Intermediate and advanced levels add hash maps and anti-hash tests. Milestone: a compiler and editor set up with warnings and sanitizers, a template you can type from memory, and the first two CSES sections or 20 easy Codeforces problems solved in C++.

2. Maths basics (14 hours, foundation)

The small number theory toolkit contests use constantly: modular arithmetic, GCD, LCM and Euclid's algorithm, primes and the sieve, factorisation and divisors, fast exponentiation, and parity and invariants, with modular inverses and counting for higher levels. Milestone: fast power, sieve and trial division written from memory, and 10 maths problems solved across CSES Mathematics and Codeforces number theory problems at your level.

3. Greedy and sorting (16 hours)

Make the locally best choice, prove it is safe with an exchange argument, and use sorting to turn messy problems into one pass. Topics cover greedy thinking, exchange arguments, interval scheduling, sort then scan, constructive problems and checking ideas with a brute force. Milestone: fifteen greedy and sorting problems solved, an exchange argument written for three of them, and a brute force that caught at least one wrong idea.

4. Binary search (12 hours)

Search sorted data with lower_bound and upper_bound, then learn the bigger idea: binary searching over the answer whenever a yes or no check only flips once. You also learn loop invariants that stop off-by-one errors. Milestone: ten binary search problems, at least five of them on the answer, each with the invariant and the check written in a comment.

5. Prefix sums and two pointers (12 hours)

Range sums in O(1), difference arrays for range updates, two pointers, sliding windows and counting subarrays with a prefix sum and a map. Milestone: twelve problems across these techniques, including one with negative numbers solved with a prefix sum map.

6. Graphs (24 hours)

Store graphs as adjacency lists, traverse them with BFS and DFS, treat grids and trees as graphs, and find weighted shortest paths with Dijkstra. Higher levels add topological order and lowest common ancestors. Milestone: BFS, DFS and Dijkstra written from memory, and 15 graph problems solved across CSES Graph Algorithms, Tree Algorithms and Codeforces.

7. Dynamic programming (28 hours)

The longest stage. Define a state and a transition, choose between memoisation and tabulation, and learn the classic shapes: one-dimensional DP, grid DP and knapsack, then LIS, bitmask DP and DP on trees at higher levels. Milestone: ten problems of the AtCoder Educational DP Contest solved with each state written in a sentence, plus five CSES Dynamic Programming problems.

8. Data structures (24 hours)

Disjoint set union, minimum spanning trees, Fenwick trees and segment trees, and how to choose the right range structure. Advanced adds sparse tables, lazy propagation and ordered sets. Milestone: DSU, a Fenwick tree and a segment tree written, tested on CSES problems and kept in your own library of tested code, plus 8 range query or DSU problems.

9. Contest strategy and upsolving (20 hours)

How to read a problem set, what each verdict means, upsolving, virtual contests, stress testing, ratings and tilt, and the current rules on AI tools in rated rounds. Each level gets its own advice on what to practise. Milestone: eight rated or virtual contests, at least one problem upsolved after each, a working stress test script and a log of contests and upsolved problems.

10. Team play and ICPC (20 hours)

How the ICPC works, from eligibility and registration to scoring, penalty time and the frozen scoreboard, then three people on one computer: team roles, problem triage and the team notebook. Milestone: a registered team with a coach, five full five-hour practice contests on past regional sets, a first team notebook and a written team plan.

Projects that fit

The roadmap suggests final year and portfolio projects that grow out of contest work: a training tracker for university clubs and ICPC coaches built on the Codeforces API, an algorithm visualisation puzzle game, and for higher levels procedural puzzle generation with guaranteed solvability and university timetable scheduling with constraint solving.

How it works on Sefism

Everything here is free to learn from. The public page shows the full list of ten stages, with the first two stages open to read. Adding the roadmap to your dashboard uses credits: new members get starting credits and the first roadmap you add is free. Once added, every stage opens, you can tick off topics and track progress, the page paces itself to your weekly hours, and the companion cheat sheet opens with it. If you get stuck on a stage, send Tauseef a question about it, or book a 1:1 session to plan a season.

The companion cheat sheet

The Competitive programming cheat sheet follows the same ten chapters, from C++ for contests to team play and ICPC, with a complexity table, templates, STL snippets and the classic mistake for each idea. Use it to revise a technique after each stage and before a contest.

Related on Sefism

• How to start competitive programming, and what to learn at each rating
• Is ICPC worth it if you will not reach the World Finals?
• Is DSA still worth learning with AI?
• Fifteen problem shapes and the move that solves each
• Library picks used in the stages: CSES Problem Set, USACO Guide, Competitive Programmer's Handbook, cp-algorithms and KACTL
• Related roadmaps: DSA and problem solving and CS core subjects

What you can do afterwards

Compete every week with a routine that keeps improving your rating, coach newer students at your university club, and walk into a regional with a team that has practised together. The same skills (reading constraints, choosing a complexity, testing your own code) carry straight into the coding rounds of a job search and into everyday engineering.

FAQ

How long does it take to get good at competitive programming? The roadmap is about 184 hours. At 8 hours a week that is roughly six months of steady work, but rating moves with regular contests and upsolving rather than with hours alone.

Do I have to use C++? The roadmap teaches contest C++ because it is fast and has the STL most editorials use. The ideas carry over to any language, but the templates and snippets are in C++.

Can I use AI tools during a contest? Rules differ by platform and change over time. The contest strategy stage asks you to read each platform's current rules before a rated round; use AI for hints while upsolving, never during a rated contest.

Is competitive programming still worth it in 2026? If you enjoy it, yes: it builds speed, rigour and debugging habits that last. If you do not, the DSA roadmap is a better use of your time.