Season 1 — Striver A2Z DSA (the 17-week plan)

Goal: finish Striver's A2Z DSA Sheet — 474 problems, 18 steps — in ~4 months. Start: 2026-06-19 · Target finish: ~mid-October 2026. Committed pace: 450 problems over 17 weeks (~3.8/day average). The remaining ~24 are deliberate slack for review, spillover, and skipping trivial duplicates.

The two rules that make this survivable

Minimum viable day = 1 problem + 1 commit. On a bad day, solve one problem and commit it. That keeps the streak alive. Never zero.
The weekly target is the real commitment — not the daily one. You can have a 1-problem day and make it up later in the week, but you owe the week its number. This is what lets life happen without the whole thing collapsing.

The shape: front-load hard, decelerate into difficulty

You're a backend engineer who's rusty, not new. The early steps (basics, sorting, arrays, binary search, strings, linked list, recursion, bit, stack/queue) are reactivation reps — you already know the data structures, you just need the muscle back. So we cash that speed in early at 5–6/day and bank a buffer.

The back half (binary trees deep, BST, graphs, DP, tries, hard strings) drops to 2–4/day on purpose. These reward understanding-per-problem over volume — rushing them just manufactures forgotten solutions. The schedule is hardest-feeling exactly where it should be (graphs/DP) but never asks for high volume there.

Three consolidation beats are built in: week 4 ends on easy strings (cool-down after binary-search-on-answer), week 9 is a deliberate light week before the hard back half, week 15 keeps the hardest DP at the lowest target so the mountain never becomes a death march.

Week-by-week

Wk	Steps	Target	Pace	Load	The point of the week
1	Learn the basics, Sorting	42	6/day	heavy	Pure warm-up. Basics is easy math/loops + sorts you know cold. Blast through, dump momentum into the streak.
2	Basics tail, Sorting, Arrays	40	6/day	heavy	Finish basics + sorting (merge sort, count inversions), open Arrays (rotations, leaders, prefix sums) while it's cheap.
3	Arrays	40	5–6/day	heavy	Mid/hard arrays: Kadane, merge intervals, majority, subarray-sum tricks. Rewards pattern recall.
4	Binary Search, Strings Basic	36	5/day	normal	Binary-search-on-answer (allocate pages, koko, median of two arrays) is the first real think-hard set. End on easy strings as a cool-down.
5	Linked List	32	5/day	normal	Pointer muscle memory: reversal, Floyd cycle, merge. A few (random-pointer copy, reverse-in-groups) deserve real time.
6	Recursion, Bit Manipulation	30	5/day	normal	Backtracking (subsets, permutations, N-queens, sudoku) is where rusty bites. Pair with quick bit-trick wins to keep the count up.
7	Bit tail, Stack & Queue	28	4/day	normal	Monotonic-stack problems (next greater, histogram, stock span) are genuine mediums. Pace inflection point — drop to 4/day.
8	Stack/Queue, Sliding Window + 2Ptr	28	4/day	normal	LRU/LFU cache, sliding-window-max, then the window/two-pointer template. High-value pattern set — make it stick.
9	Heaps, Greedy	24	3–4/day	light	Intentional consolidation before the hard half. Heaps (Kth, median stream, top-K) + greedy (jump game, meetings). Slack to re-review shaky topics.
10	Binary Trees	22	3/day	normal	Traversals are trivial; views, LCA, diameter, construct-from-traversal need thought. Quality > count.
11	Binary Trees, BST	20	3/day	normal	Hard trees (max path sum, serialize, burn-tree) → BST (validate, kth smallest, LCA). Let the recursion intuition land before graphs.
12	Graphs	24	3–4/day	heavy	Graphs opens — biggest, hardest step (53). Traversal/BFS-DFS, components, cycle detection, topo sort. Front is approachable; long sittings ahead.
13	Graphs	20	3/day	heavy	Hard core: Dijkstra, Bellman-Ford, Floyd-Warshall, MST (Prim/Kruskal), DSU. Understand the algorithm before grinding variants.
14	Graphs, DP	22	3/day	heavy	Close graphs (Kosaraju, bridges, articulation), begin DP (1D/2D fundamentals). Establish the memoize→tabulate→optimize ritual now.
15	Dynamic Programming	16	2–3/day	light	Hardest material, lightest target — deliberate. DP on subsequences, knapsack, partitions. Deep derivation beats rushing. Anti-burnout buffer.
16	Dynamic Programming	20	2–3/day	heavy	DP endgame: LIS variants, MCM/partition DP, stocks, edit distance, DP on squares. Re-derive recurrences, don't memorize answers.
17	Tries, Strings Hard	6	1–2/day	light	Victory lap. Tries (maxXOR, complete-word) + hard strings (KMP, Z-function, Rabin-Karp). Small, satisfying, leaves slack for a final review sweep.

Running total: 42 → 82 → 122 → 158 → 190 → 220 → 248 → 276 → 300 → 322 → 342 → 366 → 386 → 408 → 424 → 444 → 450 ✓

When a topic doesn't click

Watch the Striver A2Z YouTube playlist lecture for that exact step (it maps 1:1 to the sheet). For the theory behind an algorithm, go to CP-Algorithms. See ../../resources.md for the full toolkit.

Retention (so you don't solve-once-and-forget)

For every non-trivial problem, make one Anki card capturing the trigger/pattern and the key insight — not the full code. The pattern ("sorted + find boundary → binary search on answer") is what you need to recall under pressure, and it resurfaces on a forgetting-curve schedule instead of being lost.