Phase 1
C++ & Complexity Foundations
Write, run, and put a price on small C++ programs before any data structure appears
Days 1-7
Get fluent enough with C++ and Big-O that every later problem is about the idea, not the syntax.
0/133 completed0%
146 study units · flexible pace
DSA with C++ — From Scratch to Advanced Problem Solving
A 146-unit C++ path from local beginner exercises to advanced DSA and competitive-programming practice. Preserve the Striver A2Z topic coverage, then extend into number theory, range queries, advanced graphs and DP. Learn through guided attempts, delayed recall, unlabelled transfer problems and an early contest routine. Generate lectures in batches of three and study each unit across as many sessions as needed. The 584 hours are a first-pass estimate; strong contest performance requires continuing practice, not a guaranteed rating.
Lectures & Notes
Guided attempts, spaced recall, practice banks, and quizzes
Projects
The contest-simulation capstone
Revision
Recall, trace, then check
Overall Progress
💻
Foundations
C++ & complexity, STL, recursion, sorting, and binary search
Phase 2
STL Foundations & Problem-Solving Reflex
Become fluent with the containers and algorithms you will reuse for the entire course
Days 8-13
Turn the standard library into muscle memory and build the reflex of translating a statement into clean code.
0/114 completed0%
Phase 3
Recursion Foundations
An unshakable grip on recursion over numbers, arrays and strings
Days 14-17
Make recursion second nature so every later tree, graph and DP topic stands on solid ground.
0/76 completed0%
Phase 4
Sorting Techniques
Implement the classic sorts, understand invariants, and use custom comparators fluently
Days 18-21
Know how sorting really works and wield sorting as a preprocessing weapon.
0/76 completed0%
Phase 5
Binary Search — on arrays & on the answer
Halving the search space, and the far more powerful binary-search-on-the-answer
Days 22-27
Master exact search and, crucially, recognizing the monotonic predicate that unlocks answer-search.
0/114 completed0%
🧱
Core Data Structures
Arrays, strings, sliding window, linked lists, backtracking, bits, stacks/queues, and heaps
Phase 6
Arrays: Easy to Medium to Hard
A deep bag of array techniques: prefix sums, two pointers, Kadane, intervals, matrix moves
Days 28-35
Build the bread-and-butter array toolkit every contest and interview leans on.
0/152 completed0%
Phase 7
Strings: Basic & Medium
Comfortable string manipulation and the medium classics (heavy algorithms come later)
Days 36-39
Handle strings fluently and solve the standard medium problems before advanced string algorithms.
0/76 completed0%
Phase 8
Two Pointers & Sliding Window
The window / two-pointer engine that solves a huge class of subarray and substring problems in O(n)
Days 40-44
Master the grow-shrink window and know exactly when it applies versus prefix sums.
0/95 completed0%
Phase 9
Linked List
Full command of singly and doubly lists and the pointer-manipulation classics
Days 45-50
Own the node-and-pointer model: slow/fast, reversal, cycle detection, and list arithmetic.
0/114 completed0%
Phase 10
Recursion Patterns & Backtracking
Turn recursion into a problem-solving engine: subsets, permutations, combinations, grid puzzles
Days 51-57
Wield the choose / explore / un-choose template on every enumeration and constraint problem.
0/133 completed0%
Phase 11
Bit Manipulation
Think in bits: masks, tricks, and the subset / XOR problems that appear constantly
Days 58-61
Get comfortable enough with bits that masks and XOR tricks become a first instinct.
0/76 completed0%
Phase 12
Stacks & Queues
Implement them, master expression evaluation, and the monotonic-stack pattern
Days 62-67
Discover the stack from a bracket problem, then wield monotonic stacks on the next-greater family.
0/114 completed0%
Phase 13
Heaps / Priority Queues
The binary heap and priority_queue for top-K, scheduling and streaming-median problems
Days 68-71
Understand the heap well enough to reach for it instantly on top-K and streaming problems.
0/76 completed0%
🌳
Trees, Graphs & DP
Greedy, binary trees, BST, tries, graphs, and dynamic programming
Phase 14
Greedy Algorithms
Recognize when local choices are globally optimal, and prove it
Days 72-75
Build the instinct to spot a greedy structure and back it with an exchange argument.
0/76 completed0%
Phase 15
Binary Trees
Total command of tree traversals and the medium/hard tree problems
Days 76-83
Make tree recursion automatic, the foundation for BST, tries, and tree DP.
0/152 completed0%
Phase 16
Binary Search Trees
Use the BST ordering property for fast search/insert/delete and the classic problems
Days 84-87
Exploit the left<node<right invariant, and know when to just use std::set/map.
0/76 completed0%
Phase 17
Tries
The prefix-tree structure for fast string-prefix queries and bitwise-XOR problems
Days 88-90
See how sharing prefixes in a tree turns repeated prefix work into O(length) queries.
0/57 completed0%
Phase 18
Graphs
Representations, BFS/DFS, toposort, shortest paths, MST and DSU, in a clean dependency order
Days 91-101
The biggest phase: build every core graph algorithm on top of the traversals, ending with DSU.
0/209 completed0%
Phase 19
Dynamic Programming
From recursion + memo to tabulation to space optimization across every major DP pattern
Days 102-113
The crown jewel: learn to define state, transition and base case for each DP family fast.
0/228 completed0%
🏆
Advanced & Contest Craft
Advanced strings, number theory, segment trees, advanced graphs/DP, and competitive programming
Phase 20
Advanced Strings
Linear-time string matching and structure: KMP, Z, hashing, Manacher
Days 114-117
Cross from O(nm) brute matching into O(n) algorithms and the problems built on them.
0/76 completed0%
Phase 21
Number Theory & Combinatorics
The math toolkit for CP: sieve, modular arithmetic, inverses, combinatorics, matrix exponentiation
Days 118-122
Acquire the arithmetic that gates a huge fraction of Codeforces problems above 1400.
0/95 completed0%
Phase 22
Advanced Data Structures
Range-query power tools: Fenwick, segment trees (+ lazy), sparse tables, Mo's
Days 123-128
Add the structures that answer range queries and updates in log time, plus when to use each.
0/114 completed0%
Phase 23
Advanced Graphs
The graph theory that separates strong CP: SCC, bridges, LCA, flows, matching
Days 129-134
Build the high-end graph algorithms on top of the DFS tree and low-link machinery.
0/114 completed0%
Phase 24
Advanced Dynamic Programming
The DP that wins contests: bitmask, digit, tree rerooting, SOS, and optimizations
Days 135-140
Layer the advanced DP families on top of the core, and recognize each from its constraints.
0/114 completed0%
Phase 25
Competitive Programming Craft & Contest Mastery
Turn technique into rating: constructive, game theory, interactive, and a real contest routine
Days 141-146
Build a sustainable contest and upsolving routine; distinguish CodeChef stars from Codeforces titles and measure progress without promising a rating.
0/114 completed0%