18-Month Competitive Programming Roadmap
(Beginner → CF 2000)
Month 1 – Target ~1000 (Green) 1
Start by solidifying basic programming skills in C/C++: syntax, data types, input/output, conditionals (if/else),
loops, functions and simple array/string operations 2 . Aim to enter the green band (900–1199) by month’s
end 1 . Split your ~50 hours/month roughly half on learning and half on practice.
• Topics to learn: Programming fundamentals (variables, control flow, loops, functions); basic 1D
arrays and strings; simple math (modulo, gcd); elementary sorting (e.g. std::sort ) and searching.
• Problems to solve: Codeforces Div3 A/B problems (≈800–1000 rating). Focus on easy “A” problems
and the easiest “B” problems to apply basics.
• Strategy/Advice: Practice consistently and master fundamentals 3 . In contests, solve the easiest
problems first and gradually tackle harder ones 4 . Regularly review solutions and read editorials to
learn clean implementations.
Month 2 – Target ~1100
Build on Month 1 by reinforcing arrays/strings and introducing basic data structures and algorithms.
Continue practicing easy problems and extend to slightly harder ones.
• Topics to learn: 2D arrays/grids; basic recursion (e.g. factorial, simple backtracking); sorting/
binary search ; stacks and queues (for simple BFS/DFS later); modular arithmetic.
• Problems to solve: CF problems rated ~900–1100 (Div3 B and easy Div3 C, Div2 A/B). Aim to solve all
A’s and many B’s.
• Strategy/Advice: When stuck, study editorial solutions to understand patterns. Keep practicing
problem writing and debugging. Focus on algorithmic thinking more than memorizing code.
Month 3 – Target ~1200 (Blue)
By now you should be comfortable in green; push into the lower blue range (1200–1499). Start learning
graph basics and dynamic programming.
• Topics to learn: Graph fundamentals: representation (adjacency list), breadth-first search (BFS) and
depth-first search (DFS) on simple graphs/grids. 1D dynamic programming (e.g. Fibonacci, basic
knapsack). More math: primes, sieve of Eratosthenes.
• Problems to solve: CF problems ≈1000–1200 (Div3 C, Div2 A/B). Solve mixed A/B/C problems,
focusing on applying BFS/DFS and DP ideas.
• Strategy/Advice: Continue consistent practice 3 . In contests, do a quick pass: solve trivial tasks
first, then one medium challenge. Learning graphs and DP now will unlock many problems.
1
Month 4 – Target ~1300
Deepen your understanding of graphs and DP, and explore more data structures.
• Topics to learn: Simple recursion/backtracking (subset generation), introduction to trees (tree
traversal by DFS). Basic data structures: std::map , std::set (for frequency counting, ordering).
Continue 2D DP (e.g. 0/1 knapsack).
• Problems to solve: CF problems ≈1100–1300 (Div2 B/C). Tackle problems that combine earlier
topics (e.g. BFS on a grid, basic DP on arrays).
• Strategy/Advice: Aim to solve 2–3 problems per weekly contest. Focus on writing clean code (handle
multiple test cases, edge cases). Review incorrect attempts thoroughly.
Month 5 – Target ~1400
Start learning greedy algorithms and more advanced graph concepts. Aim to enter upper blue/lower yellow
territory.
• Topics to learn: Greedy strategies: sorting-based greedy, two-pointers/sliding-window techniques.
Advanced graph: Dijkstra’s shortest paths, simple cycle detection. Disjoint Set Union (DSU) basics for
connectivity.
• Problems to solve: CF problems ≈1200–1400 (Div2 B/C and easy Div1 A). Try Div2 B/C in contests
regularly.
• Strategy/Advice: Identify patterns in greedy problems (e.g. always sort or pick smallest/largest).
Practice contests in timed mode to simulate pressure.
Month 6 – Target ~1500 (Yellow)
Focus on deepening DP and complex data structures to reach mid-yellow (~1500).
• Topics to learn: Advanced DP (bitmask DP, multi-dimensional DP), tree DP basics, rolling hash or
modular inverses if time permits. Continue DSU (Union-Find). Intro to range queries (Fenwick tree/
segment tree concept).
• Problems to solve: CF problems ≈1300–1500 (Div2 C and Div1 A/B). Attempt harder Div2 Cs, and
start trying Div1 A.
• Strategy/Advice: Aim to break the 1500 barrier by Month 6. Practice reading/editorial techniques
for challenging problems. Ensure you understand time complexity to write efficient code.
Month 7 – Target ~1550
Consolidate what you’ve learned and start specialized topics.
• Topics to learn: Tree algorithms: Lowest Common Ancestor (basic binary lifting), Euler Tour. More DP
(longest increasing subsequence, knapsack variants). Elementary combinatorics (precompute
factorials for nCr).
• Problems to solve: CF problems ≈1400–1550 (Div1 A/B). Work on medium-hard problems; split time
between old unsolved problems and new ones.
2
• Strategy/Advice: Continue participating in weekly contests. Analyze which areas still cause trouble
(graph, DP, implementation) and practice those specifically.
Month 8 – Target ~1600
Enter expert territory (1600+) by focusing on range queries and optimization.
• Topics to learn: Range-query structures: Segment Tree and Fenwick Tree basics. More graph: 0-1
BFS for weighted graphs. Bitsets or bitwise optimizations. Further DP on trees (e.g. DP on subtrees).
• Problems to solve: CF problems ≈1500–1600 (Div1 A/B, Div1 C). Attempt at least one Div1 C per
contest.
• Strategy/Advice: Dedicate roughly equal time to learning a new data structure and practicing with
it. Always revisit editorials for unfamiliar problems to expand your toolkit.
Month 9 – Target ~1650
Tackle advanced algorithms and polish problem-solving speed.
• Topics to learn: Advanced graph: Minimum spanning tree (Kruskal/Prim), Bellman–Ford. Number
theory: modular exponentiation, extended GCD. Two-pointer and greedy in more contexts.
• Problems to solve: CF problems ≈1550–1650. Solve Div1 B/C, and attempt Div1 C regularly.
• Strategy/Advice: Focus on speed and accuracy. Time yourself on problems. Mistakes are valuable –
review and learn from them.
Month 10 – Target ~1700
Expand into string algorithms and complex data structures.
• Topics to learn: String algorithms: KMP or Z-algorithm basics. Advanced data structures:
std::multiset or policy-based data structures (order statistics tree). Sparse table or Mo’s
algorithm overview (for range queries offline).
• Problems to solve: CF problems ≈1600–1700. Try solving at least one Div1 C and one Div2 D per
contest.
• Strategy/Advice: Continue solving problems just above your comfort zone to force learning new
concepts 4 . Seek to solve a variety of problem types (graphs, dp, greedy, math).
Month 11 – Target ~1750
Prepare for red-coder level by learning very advanced topics.
• Topics to learn: Network flow basics (max-flow/min-cut). Trie (prefix tree) for string manipulation.
Advanced trees (Heavy-Light Decomposition intro). More DP: bitmask DP on grids or games.
• Problems to solve: CF problems ≈1650–1750 (Div1 B/C). Solve at least two Div1 problems per
contest.
• Strategy/Advice: Refine contest strategy: know when to move on from a problem. Continue steady
practice 3 . If possible, participate in some virtual old contests (used to contest in real time).
3
Month 12 – Target ~1800 (Candidate Master) 5
Reaching ~1800 will make you a Candidate Master. Review all fundamentals and tackle top-of-division
problems.
• Topics to learn: Solidify any weak areas from before. Constructive algorithms (writing your own
greedy or DP from scratch). Basic game theory (sprague-grundy). Practice common problem
patterns (prefix/suffix sums, sliding window variants).
• Problems to solve: CF problems ≈1700–1800 (Div1 B/C). Aim to reliably solve 2 of 3 problems in
most contests.
• Strategy/Advice: Keep problems balanced between practice contests and solving at leisure. Focus
on high-probability contest wins (Div1 A and B). Remain consistent and patient 3 .
Month 13 – Target ~1850
Solidify advanced knowledge and expand problem portfolio.
• Topics to learn: Advanced number theory (CRT, Euler’s totient, if needed). More graph: SCC (Tarjan/
Kosaraju), topological sort applications. DP on DAGs.
• Problems to solve: CF problems ≈1750–1850. Tackle Div1 C/D problems; try a few harder Div1 C’s
and easier Div1 D’s.
• Strategy/Advice: Analyze performance trends. If contests are stagnating, switch focus: solve
random problems from Codeforces or CSES to expose new ideas.
Month 14 – Target ~1900
Reach mid-1900s by mastering tricky topics.
• Topics to learn: Geometry basics (if applicable): cross product, line intersection. Metaprogramming:
bitmask tricks, inclusion–exclusion. Suffix arrays or advanced string techniques if needed.
• Problems to solve: CF problems ≈1800–1900. Mostly Div1 C/D, occasional Div1 E.
• Strategy/Advice: Focus on contest simulation. Use training contests or gym to replicate contest
pressure. Work on clear, bug-free code writing.
Month 15 – Target ~1930
Continue intensive practice with focus on weak points.
• Topics to learn: Balanced parenthesis problems and stack applications. More advanced DP (meet-inthe-middle). Review all data structures (Fenwick, SegTree, DSU).
• Problems to solve: CF problems ≈1850–1950. Aim for a mix of Div1 B/C/D.
• Strategy/Advice: By now, devote equal time to contests and upsolving. When you see a concept
(e.g. DFS tree, flow) apply it in a problem to reinforce learning.
4
Month 16 – Target ~1950
Nearly there – polish remaining areas.
• Topics to learn: Suffix Automaton (if needed for strings), advanced trees (centroid decomposition
overview). Miscellaneous: 2-SAT conceptual, “MEX” operations.
• Problems to solve: CF problems ≈1900–1970. Prioritize solving Div1 problems quickly and
accurately.
• Strategy/Advice: In every contest, solve at least two problems with confidence. Work on optimizing
code and thinking in advanced algorithmic ways.
Month 17 – Target ~1970
Final stretch to 2000 – fine-tune problem-solving and strategy.
• Topics to learn: Revisit all learned topics. Practice combined problems (e.g. combine graph+DP, data
structures+math).
• Problems to solve: CF problems ≈1950–1990. Focus on Div1 B/C and even try a Div1 D occasionally.
• Strategy/Advice: Maintain consistent contest practice. Analyze any recurring mistakes. Confidence
and steady improvement are key.
Month 18 – Target 2000 (Master) 5
In the last month, consolidate everything and focus on contest performance to break 2000 (red zone).
• Topics to learn: Reinforce weak or rarely used topics. Ensure you know how to approach any
problem type.
• Problems to solve: CF problems ~1900–2000+. Solve the hardest Div1 A/B/C problems you can.
• Strategy/Advice: Be relentless and keep pushing difficulty. Aim to consistently solve 2+ problems in
each contest. By this stage, strategy and persistence matter most. Celebrate reaching Master (2000+)
5 , and keep learning for higher goals.
Note: This plan assumes ~12–14 hours/week (≈50 hours/month), with roughly half spent learning new
algorithms/data structures and half on practice. Consistent effort, learning from mistakes, and gradually
tackling harder problems are the keys to steadily rising on Codeforces 4 3 .
Sources: Codeforces and competitive-programming guides provide recommended topic orders and practice
strategies 2 1 4 3 . These were used to structure this roadmap.
1
5
How to Interpret Contest Ratings - Codeforces
https://codeforces.com/blog/entry/68288
2
3
4
Competitive Programming (CP) Handbook with Complete Roadmap - GeeksforGeeks
https://www.geeksforgeeks.org/competitive-programming/competitive-programming-cp-handbook-with-complete-roadmap/
5