Phase-to-Resource Master Map¶
The single most common failure mode in self-directed DSA study is resource-hopping: switching materials every time something gets hard. This document makes the decision for you in advance. Each phase has one primary resource. You follow it until the phase ends. You pull in a supplement only if the primary genuinely cannot explain something after a second honest read. Everything else is noise.
The Rule¶
One primary resource per phase. Switch only if the primary genuinely fails you — not because you’re bored, not because someone on Reddit mentioned something shinier.
A resource “fails you” if: you’ve read a section twice, tried to apply it to 3 problems, and still cannot form a solution approach. That’s the threshold. Discomfort alone is not failure.
Timeline Overview¶
Phase |
Duration |
Dates |
Focus |
|---|---|---|---|
Phase 0 |
M1–M1.5 |
Jul 27 – Sep 10, 2026 |
Foundations — arrays, strings, basic recursion, complexity |
Phase 1 |
M1.5–M3 |
Sep 10 – Oct 27, 2026 |
Core patterns — two pointers, sliding window, hashing, stacks, queues |
Phase 2 |
M3–M4.5 |
Oct 27 – Dec 10, 2026 |
Trees, heaps, binary search |
Phase 3 |
M4.5–M6 |
Dec 10, 2026 – Jan 27, 2027 |
Graphs — BFS, DFS, shortest paths, MST |
Phase 4 |
M6–M7.5 |
Jan 27 – Mar 10, 2027 |
Dynamic programming — 1D, 2D, knapsack variants |
Phase 5 |
M7.5–M8.5 |
Mar 10 – Apr 10, 2027 |
Advanced topics — tries, segment trees, bit manipulation, string algorithms |
Phase 6 |
M8.5–M9 |
Apr 10 – Apr 27, 2027 |
Integration — mock interviews, timed sessions, weak point audit |
Phase 0 — Foundations (Jul 27 – Sep 10, 2026)¶
Duration: ~6 weeks | Hours/week: 10–15
Primary Resource¶
Striver’s A2Z DSA Sheet (takeuforward.org/data-structures/striver-a2z-dsa-course-sheet/)
Covers: Arrays, linked lists, basic recursion, basic sorting, strings
Why primary: Smooth difficulty curve, video explanations in Hindi/English, free, Indian community consensus. Perfect entry ramp for someone rebuilding foundations from scratch.
How to use: Follow sequentially. Watch video, code it yourself, then solve the tagged problems on LeetCode/GFG.
Supplement (pull in only if primary fails)¶
Grokking Algorithms (book, ~$30)
Pull in if: Visual explanation needed for a concept Striver doesn’t make intuitive (binary search, recursion tree, BFS/DFS overview).
Do NOT read cover to cover — use as a lookup.
Problem Bank¶
LeetCode (leetcode.com)
List: NeetCode Roadmap → Arrays & Hashing section (first 10 problems)
Target: 15–20 problems, all Easy, a few Medium
Metric: Can you explain your solution to someone who hasn’t seen it? If yes, move on.
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
Striver A2Z videos + notes |
4–5 |
Problem solving (LeetCode) |
5–6 |
Review + spaced repetition |
1–2 |
Community check-in |
0.5 |
Phase 1 — Core Patterns (Sep 10 – Oct 27, 2026)¶
Duration: ~7 weeks | Hours/week: 10–15
Primary Resource¶
NeetCode 150 (neetcode.io/practice)
Covers: Two pointers, sliding window, stack, queue, linked list, binary search (applied)
Why primary: Industry consensus as of 2026. Problems chosen for pattern coverage, not company prestige. Free.
How to use: Do NOT watch the solution video first. Attempt 25 minutes minimum. Then watch. Then code again from scratch without the video.
Supplement (pull in only if primary fails)¶
CP Handbook — Chapters 1–6 (Laaksonen, free PDF at cses.fi/book/book.pdf)
Pull in if: You need deeper algorithmic theory behind a pattern (e.g., formal proof of sliding window correctness, amortized analysis of stack operations).
Problem Bank¶
LeetCode — NeetCode 150 list, Two Pointers through Binary Search sections
Target: 40–50 problems, ratio ~60% Medium, 30% Easy, 10% Hard attempts
Do NOT move to a new pattern until you can solve a Medium in that pattern from scratch in ≤30 min.
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
NeetCode 150 problems |
6–8 |
Video review (post-attempt only) |
2–3 |
Pattern notes in problem log |
1 |
Community / contest |
1 |
Phase 2 — Trees, Heaps, Binary Search Deep (Oct 27 – Dec 10, 2026)¶
Duration: ~6 weeks | Hours/week: 10–15
Primary Resource¶
NeetCode 150 (Trees, Tries, Heap sections) + CP Handbook Chapters 7–10
NeetCode 150 is the problem structure; CP Handbook provides the theory backbone.
Covers: BST, AVL (conceptual), heaps/priority queues, binary search on answer, tries
Supplement¶
VisuAlgo (visualgo.net)
Use for: Tree traversals, heap operations — watch the animation before solving heap problems. Single-use per concept, not a crutch.
Problem Bank¶
CSES Problem Set — “Tree Algorithms” section (cses.fi/problemset/list/)
Start mixing CSES problems in alongside LeetCode. CSES trees section has ~16 problems, all meaningful.
LeetCode: Continue NeetCode 150 Trees (19 problems), Heap/Priority Queue (7 problems)
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
Problem solving (LeetCode + CSES) |
7–8 |
CP Handbook theory reading |
1–2 |
VisuAlgo review for new concepts |
0.5 |
Contest attempt (CF Div. 3 virtual) |
1–2 |
Phase 3 — Graphs (Dec 10, 2026 – Jan 27, 2027)¶
Duration: ~7 weeks | Hours/week: 10–15
Note: This phase spans the India winter holidays (Dec 25–Jan 1). Plan for ~5 hrs/week during that stretch, compensate in early January.
Primary Resource¶
CP-Algorithms.com — Graph section (cp-algorithms.com/graph/)
Covers: BFS, DFS, Dijkstra, Bellman-Ford, Floyd-Warshall, MST (Kruskal, Prim), topological sort, SCC
Why primary: The most thorough free reference for graph algorithms. Code examples included. Community-verified quality.
How to use: Read a section → implement from scratch → solve 2–3 CSES problems tagged to that algorithm.
Supplement¶
William Fiset — Graph Theory Playlist (YouTube: @williamfiset)
Pull in if: CP-Algorithms explanation of an algorithm isn’t clicking. William’s visual + code walkthroughs complement it well.
Problem Bank¶
CSES Problem Set — “Graph Algorithms” section (cses.fi/problemset/list/)
36 problems, structured by graph algorithm type. This is the primary problem bank for this phase.
LeetCode — NeetCode 150 Graphs section (13 problems) for interview-pattern exposure.
Codeforces — Start Div. 3 virtual contests. Target: solve A + B reliably, attempt C.
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
CSES graph problems |
5–6 |
CP-Algorithms reading |
2–3 |
Codeforces virtual contest |
2 |
LeetCode graph problems |
1–2 |
Phase 4 — Dynamic Programming (Jan 27 – Mar 10, 2027)¶
Duration: ~6 weeks | Hours/week: 10–15
DP is where most people stall. The fix: do not try to “invent” DP solutions. Learn the patterns. There are ~10 canonical DP patterns. Master them, then Hard problems become pattern identification problems.
Primary Resource¶
NeetCode 150 — 1D DP, 2D DP sections + Striver DP playlist (@takeUforward YouTube)
Striver’s DP playlist (50+ videos) is the most systematic free DP curriculum available as of 2026. Watch alongside attempting NeetCode problems.
Covers: Fibonacci variants, 0/1 knapsack, unbounded knapsack, LCS, LIS, partition DP, matrix chain, interval DP
Supplement¶
CP Handbook Chapters 6, 7 (DP chapter)
Pull in for: Formal state-transition proofs, bitmask DP, digit DP
Problem Bank¶
LeetCode — NeetCode 150 DP sections (1D: 12 problems, 2D: 11 problems, Advanced: 5 problems) CSES — “Dynamic Programming” section (cses.fi/problemset/list/) — 19 problems, excellent for classic DP patterns Codeforces — Virtual Div. 3 + start attempting Div. 2 A and B
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
Striver DP videos |
2–3 |
LeetCode DP problems |
4–5 |
CSES DP problems |
2–3 |
CF virtual contest |
1–2 |
Phase 5 — Advanced Topics (Mar 10 – Apr 10, 2027)¶
Duration: ~4 weeks | Hours/week: 10–15
This phase is not about coverage. It’s about depth in 3–4 topics that appear frequently in Hard LeetCode and CF Div. 2 C/D problems.
Primary Resource¶
CP-Algorithms.com — Data Structures + String sections
Segment tree: cp-algorithms.com/data_structures/segment_tree.html
Binary indexed tree: cp-algorithms.com/data_structures/fenwick.html
Z-function: cp-algorithms.com/string/z-function.html
Supplement¶
USACO Guide — Silver and Gold tiers for advanced data structures
usaco.guide/silver — segment trees, sorting, range queries section
Problem Bank¶
LeetCode — NeetCode 150 Tries (3 problems), Advanced Graphs (6 problems), Bit Manipulation (7 problems) CSES — “Range Queries” section (7 problems), “String Algorithms” section (10 problems) Codeforces — Div. 2 virtual contests, target solving C consistently
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
CP-Algorithms implementation |
4–5 |
LeetCode Hard attempts |
3–4 |
CSES advanced sections |
2–3 |
CF virtual contest |
1–2 |
Phase 6 — Integration (Apr 10 – Apr 27, 2027)¶
Duration: ~2.5 weeks | Hours/week: 10–15
No new concepts. Pure execution. This is where the 9 months get tested against the clock.
Primary Resource¶
Your own problem log — Revisit every problem you flagged “revisit” over 9 months.
Review patterns, not solutions. Can you reconstruct the approach from scratch?
Supplement¶
LeetCode Premium (if purchased) — Company-tag filters for mock interviews
If you haven’t bought it yet, this is the phase where it pays off.
Problem Bank¶
LeetCode — 2–3 timed mock interviews per week (pick 2 Mediums + 1 Hard, set 90-min timer) Codeforces — One real-time Div. 2 contest per week, not virtual
Weekly Hours Split¶
Activity |
Hours/week |
|---|---|
LeetCode timed mocks |
5–6 |
Problem log review |
2–3 |
CF real-time contest |
2 |
Weak spot drilling |
2–3 |
One-Page Summary Table¶
Phase |
Dates |
Primary Resource |
Supplement |
Problem Bank |
Weekly Problems |
|---|---|---|---|---|---|
0 |
Jul 27–Sep 10 |
Striver A2Z DSA |
Grokking Algorithms |
LeetCode Easy |
15–20 |
1 |
Sep 10–Oct 27 |
NeetCode 150 |
CP Handbook Ch1–6 |
LeetCode NeetCode150 |
20–25 |
2 |
Oct 27–Dec 10 |
NeetCode 150 + CP Handbook |
VisuAlgo |
CSES Trees + LC Trees |
15–20 |
3 |
Dec 10–Jan 27 |
CP-Algorithms.com Graphs |
William Fiset YouTube |
CSES Graphs + LC Graphs |
15–20 |
4 |
Jan 27–Mar 10 |
NeetCode 150 + Striver DP |
CP Handbook DP |
LC DP + CSES DP |
15–20 |
5 |
Mar 10–Apr 10 |
CP-Algorithms.com Advanced |
USACO Guide Silver |
CSES Range/String + LC Hard |
10–15 |
6 |
Apr 10–Apr 27 |
Your problem log |
LC Premium (company tags) |
LC Mocks + CF Div 2 live |
10–15 timed |
The Anti-Patterns to Avoid¶
Resource hopping: Switching primary resource mid-phase because progress feels slow. Hard is not the same as wrong.
Passive video watching: Watching a NeetCode or Striver video without attempting first = 0 retention. Attempt → struggle → watch → reattempt.
Completing a list vs. understanding a pattern: Solving 50 DP problems without being able to explain state transition = wasted time. Depth beats volume.
Ignoring the problem log: If you’re not writing down patterns after each problem, you’re practicing recognition without retention. The log is not optional.
Navigation: ← 05_paper_and_reference.md | ↑ Resources Index | → Communities →