Here’s a comprehensive 2-year roadmap to master competitive programming (CP)
from absolute beginner to advanced, covering languages (Python → C++),
algorithms, contests, and mindset. This plan assumes no prior coding experience.
Year 1: Foundation Building
Focus: Learn Python, basic algorithms, and problem-solving patterns. Participate in
contests and build consistency.
Phase 1: Python Basics (Month 1–2)
Goals:
● Master Python syntax, loops, conditionals, and functions.
● Solve 50+ beginner problems.
Resources:
1. Practice: HackerRank Python Track
2. Tutorial: Python for Everybody (Coursera)
3. Books: "Automate the Boring Stuff with Python" (free online).
Key Topics:
● Lists, dictionaries, strings, sets.
● File I/O, recursion, and basic math (GCD, primes).
Practice:
● Solve 5 problems daily on CodeChef Beginner or LeetCode Easy.
Phase 2: Data Structures (Month 3–4)
Goals:
● Implement stacks, queues, trees, and graphs in Python.
● Solve 100+ problems.
Topics:
● Linked lists, binary trees, heaps, hash tables.
● Graph representations (adjacency list/matrix).
Resources:
1. Course: Data Structures & Algorithms in Python (Udemy)
2. Guide: GeeksforGeeks DSA
Practice:
● Focus on LeetCode Explore Cards.
● Participate in AtCoder Beginner Contests (ABC).
Phase 3: Algorithms (Month 5–7)
Goals:
● Learn core algorithms and time complexity analysis.
Topics:
● Sorting (merge, quick, heap), searching (binary).
● BFS, DFS, Dijkstra’s algorithm.
● Dynamic Programming (knapsack, LCS).
● Greedy algorithms (activity selection, Huffman coding).
Resources:
1. Book: "Introduction to Algorithms" (CLRS)
2. YouTube: Abdul Bari’s Algorithm Playlist
Practice:
● Solve 10 problems/week on Codeforces Problemset (A-C).
Phase 4: Math for CP (Month 8–9)
Goals:
● Master number theory, combinatorics, and modular arithmetic.
Topics:
● Prime numbers, sieve of Eratosthenes.
● Modular exponentiation, combinatorics (nCr, permutations).
● Matrix exponentiation, probability basics.
Resources:
1. Guide: CP-Algorithms Math Section
2. Book: "Competitive Programming 4" (Halim)
Practice:
● Solve math-heavy problems on Project Euler.
Phase 5: Beginner Contests (Month 10–12)
Goals:
● Compete in 15+ contests and reach Codeforces Rating 1200+.
Platforms:
1. Codeforces Div 3/4
2. AtCoder Beginner Contests
3. LeetCode Weekly Contests
Tips:
● Analyze every contest: re-solve unsolved problems.
● Learn contest strategies (time management, problem prioritization).
Year 2: Advanced Mastery
Focus: Transition to C++, master advanced algorithms, and aim for elite contests
(ICPC, Codeforces Div1).
Phase 6: Learn C++ (Month 13–14)
Goals:
● Transition to C++ for speed and STL.
Topics:
● C++ syntax, pointers, OOP basics.
● STL containers (vector, set, map, priority_queue).
● Fast I/O, template shortcuts.
Resources:
1. Course: C++ Fundamentals (Codecademy)
2. Practice: HackerRank C++ Track
Practice:
● Rewrite Year 1 Python solutions in C++.
Phase 7: Advanced Algorithms (Month 15–17)
Goals:
● Solve 200+ problems using advanced algorithms.
Topics:
● Segment trees, Fenwick trees.
● Suffix arrays, trie, heavy-light decomposition.
● Network flow, bipartite matching.
● Convex hull, FFT (for math-heavy problems).
Resources:
1. Book: "Competitive Programming in C++" (Antti Laaksonen)
2. Advanced Tutorials: USACO Guide
Practice:
● Target Codeforces Div2 D/E and LeetCode Hard.
Phase 8: Master Contest Tactics (Month 18–20)
Goals:
● Achieve Codeforces Rating 1800+ and LeetCode Contest Rating 2000+.
Strategies:
● Solve 3–4 problems in Div2 contests consistently.
● Learn to debug quickly (use gdb or IDE debuggers).
● Memorize code snippets for common tasks (e.g., segment trees).
Practice:
● Virtual contests on Codeforces Gym.
Phase 9: Elite Competitions (Month 21–24)
Goals:
● Compete in ICPC/Google Code Jam/Codeforces Div1.
Preparation:
● Study past ICPC problems: ICPC Archive.
● Master advanced topics:
○ Persistent data structures.
○ Mo’s algorithm.
○ Heavy combinatorics.
Resources:
1. Advanced Books: "Algorithm Design Manual" (Skiena)
2. Mentorship: Join CP communities (e.g., Codeforces Discuss).
Final Practice:
● Solve 5–10 problems/day on Codeforces or Topcoder.
Tools & Habits
1. IDEs:
○ Python: VS Code with Jupyter Notebook.
○ C++: Code::Blocks, CLion, or OnlineGDB.
2. Debugging: Use print() in Python and gdb in C++.
3. Revision: Maintain a problem log (track mistakes and patterns).
4. Health: Code 4–6 hours daily, but avoid burnout (exercise, sleep).
Key Milestones
Timeline Target
3 months Solve 200+ problems in Python.
6 months Master DFS/BFS and basic DP.
1 year Codeforces Rating 1200+.
18 Transition to C++ and solve 100+ STL-based
months problems.
2 years Codeforces Rating 1900+ (Candidate Master).
Critical Resources
● Books:
○ "Competitive Programming 4" (Halim & Halim).
○ "Cracking the Coding Interview" (for problem patterns).
● Websites:
○ CP-Algorithms
○ USACO Guide
● YouTube Channels:
○ Errichto
○ SecondThread
Weekly Schedule (Example)
● Mon-Tue: Study new algorithms (e.g., segment trees).
● Wed-Thu: Solve 10 problems on the topic.
● Fri: Mock contest (virtual participation).
● Sat: Rest/review mistakes.
● Sun: Compete in live contests.
🚀
With this roadmap, you’ll progress from a beginner to a Candidate Master in 2 years.
Stay disciplined, embrace the grind, and learn from every wrong submission!
