BTech CSE Student Edition

DSA Mastery to
Dream Job
Roadmap

A precision-engineered, step-by-step plan to go from basics to placement-ready in the shortest time possible — using mostly free resources.

20
Weeks Total
7
Phases
450+
Problems
3–4h
Per Day
Start Reading
Visual Timeline
20-Week Journey at a Glance
Ph 0
Ph 1
Ph 2
Ph 3
Ph 4
Ph 5
Ph 6
Wk 1–2 · Foundation
Wk 3–5 · Core DS
Wk 6–8 · Core Algos
Wk 9–12 · DP + Advanced DS
Wk 13–15 · Projects
Wk 16–17 · Resume + Apply
Wk 18–20 · Mock Interviews
Step-by-Step Plan
The 7 Phases

Each phase builds directly on the last. Do not skip ahead — the sequence is the strategy.

0
🧱
Phase 0
Foundation — Language + Complexity
Build the bedrock. Everything else breaks without this.
Weeks 1–2
3–4 h/day
Week 1
Language Mastery (C++ / Java / Python)
  • Arrays, strings, loops, functions — cold
  • STL / Collections / Built-ins (sort, map, set, deque)
  • Pointers / references / memory layout
  • I/O formatting for competitive style
Week 2
Big O + Math Prerequisites
  • Time & space complexity — derive, don't memorize
  • Best / Average / Worst case distinction
  • Modular arithmetic, GCD, prime sieve
  • Logarithms, combinatorics basics, proof by induction
Daily Schedule
1h — Theory lecture
1.5h — Implement concepts
1h — 5 easy LeetCode problems
30m — Complexity review
Key Rule: Write every complexity as T(n) = … before coding anything. Make this a reflex, not an afterthought.
Resources:
CS50 Week 0–2 (YouTube) Abdul Bari — Complexity Lectures MIT OCW 6.006 Lecture 1
1
🗂️
Phase 1
Core Data Structures
Build every structure from scratch. Understanding internals beats API-level use.
Weeks 3–5
4 h/day
~60 Problems
Week 3 · Days 1–3
Arrays, Strings, Linked Lists
  • Prefix sums, difference arrays
  • Two-pointer & sliding window intro
  • Singly / doubly linked list from scratch
  • Fast & slow pointers (Floyd's cycle)
Week 3 · Days 4–7
Stacks & Queues
  • Implement with array AND linked list
  • Monotonic stack — the interview darling
  • Deque, circular queue
  • Balanced parentheses, next greater element
Week 4 · Days 1–4
Hash Maps & Sets
  • Hash function internals, collision handling
  • Load factor, rehashing concept
  • Anagram, two-sum, frequency patterns
  • Custom hash for pairs/tuples
Week 4–5
Trees + Heaps
  • BT, BST — all traversals iteratively
  • Height, diameter, LCA, level-order
  • Min-heap built from scratch (heapify up/down)
  • K-th largest, median of stream
Daily Schedule
1h — Implement structure from scratch
2h — LeetCode problems (4–5/day)
1h — Review + pattern journaling
Target LeetCode problems:
#206#141#42#84 #1#49#102#104 #236#295
Resources:
William Fiset (YouTube) Visualgo.net NeetCode YouTube
2
⚡
Phase 2
Core Algorithms — The Interview Essentials
These 6 families cover 70% of all coding interview questions at product companies.
Weeks 6–8
4–5 h/day
~80 Problems
Week 6 · Days 1–2
Binary Search (on answers, not just arrays)
  • Classic, rotated array, leftmost/rightmost
  • Binary search on the answer space
  • Minimize the max / maximize the min
Week 6 · Days 3–5
Two Pointers + Sliding Window
  • Fixed window, variable window patterns
  • 3Sum, container with most water
  • Longest subarray with constraint
Week 6–7
Sorting Algorithms
  • Implement merge sort, quicksort, heap sort
  • Stability, in-place, when to use which
  • Counting sort, radix sort for O(n)
Week 7
Recursion + Backtracking
  • Decision tree mental model — always draw it
  • Subsets, permutations, combinations
  • N-Queens, Sudoku solver, pruning
Week 8
BFS & DFS on Graphs
  • Adjacency list vs matrix — when each wins
  • Islands, shortest path, connected components
  • Topological sort (Kahn's + DFS)
  • Cycle detection (directed + undirected)
Week 8 (end)
Greedy Algorithms
  • Exchange argument — prove greedy is correct
  • Interval scheduling, jump game
  • Activity selection, Huffman coding concept
Daily Schedule
1h — Theory + derivation
2.5h — 5–6 problems
30m — Pattern notebook entry
Sunday — re-solve 5 prior problems
Target LeetCode problems:
#875#153#3#76 #46#51#200#207 #417#435
30-Minute Rule: If zero progress after 30 min, read the approach — not the code. Then implement it yourself. This is how your pattern library grows 5× faster.
3
🧠
Phase 3
Dynamic Programming + Advanced Structures
The hardest phase. 80% of candidates quit here. Push through — this is the biggest differentiator.
Weeks 9–12
5 h/day
~100 Problems
Week 9 · 1D DP
Fibonacci Family + Linear DP
  • Climbing stairs, house robber, decode ways
  • Coin change, word break
  • Always define state in English FIRST
Week 9–10 · 2D DP
Grid + String DP
  • Unique paths, minimum path sum
  • Edit distance, LCS, LIS
  • Regular expression matching
Week 10 · Knapsack
0/1, Unbounded, Subset Sum
  • Partition equal subset sum
  • Target sum, last stone weight II
  • Unbounded knapsack variants
Week 11
Interval DP + DP on Trees
  • Burst balloons, palindrome partitioning
  • Tree DP: house robber III, diameter
  • Max path sum in binary tree
Week 11–12
Tries
  • Build from scratch (TrieNode structure)
  • Word search II, autocomplete, prefix matching
  • Design add and search word
Week 12
Union-Find (DSU)
  • Path compression + union by rank
  • Number of islands (DSU approach)
  • Redundant connections, accounts merge
Daily Schedule (DP Focus)
30m — State + recurrence (no code yet)
2h — Implement top-down (memoization)
1h — Convert to bottom-up (tabulation)
30m — Space optimization
1h — 2 new problems cold
The DP Framework (every single time):
1. Define state in English   2. Write recurrence   3. Base cases   4. Top-down first   5. Optimize space
Target LeetCode problems:
#70#198#322#1143 #72#416#494#312 #337#212
Resources:
NeetCode DP Playlist (YouTube) Aditya Verma DP Series (YouTube) CP-Algorithms.com
4
🏗️
Phase 4
Projects + System Design Basics
Technical skills alone don't get jobs. You need proof-of-work and system thinking.
Weeks 13–15
3h DSA + 2h Project
2 Projects Done
Week 13
Project 1 — DSA Visualizer or CLI Tool
  • Build something that uses what you've learned
  • Example: pathfinding visualizer, expression evaluator
  • Python or C++ — simple but functional
  • Push to GitHub with a clean README
Week 14–15
Project 2 — Backend / Full-Stack Showcase
  • REST API with a real database (Node/FastAPI)
  • Auth, CRUD, pagination — interview talking points
  • Deploy on Railway/Render (free tier)
  • Document tech decisions in README
Week 15
System Design Intro (Entry Level)
  • Load balancer, caching (Redis concept), CDN
  • SQL vs NoSQL decision factors
  • URL shortener, parking lot designs
  • CAP theorem — understand, don't memorize
Project Rule: Each project must solve a real problem you can explain in 1 sentence. Interviewers ask "why did you build this?" — have a real answer.
Resources:
GitHub Student Pack (free) Roadmap.sh — Backend (free) ByteByteGo YouTube (free)
5
📋
Phase 5
Resume, LinkedIn & Applications
The best DSA skills won't land interviews if your resume is invisible to recruiters.
Weeks 16–17
2h DSA + 2h Job Hunt
50+ Applications
Week 16
Resume (1 Page, ATS-Optimized)
  • Use Jake's Resume template (LaTeX, free)
  • Each bullet: "Did X using Y, resulting in Z"
  • Projects section with GitHub + live demo links
  • Skills: list languages & frameworks, no stars/bars
  • LeetCode stats if 200+ solved with good acceptance
Week 16–17
LinkedIn + Online Presence
  • LinkedIn: complete all sections, "Open to Work"
  • GitHub: pin 2 best projects, fill contribution graph
  • Codeforces/LeetCode profile on resume
  • Connect with 20 engineers at target companies
Week 17
Application Strategy
  • Tier A: Dream companies (Google, Microsoft, etc.)
  • Tier B: Mid-tier product (Zomato, Razorpay, etc.)
  • Tier C: Service companies as safety net
  • Apply to 5–10 per day, track in a spreadsheet
  • Referrals > cold applications — 10× response rate
Resources:
Jake's Resume (overleaf.com) Levels.fyi for salary research LinkedIn Easy Apply
6
🎯
Phase 6
Mock Interviews + Final Sprint
Coding ability ≠ interview ability. This phase converts knowledge into offers.
Weeks 18–20
5 h/day
Get The Offer
Week 18
Timed Problem Solving
  • LeetCode contests every Saturday & Sunday
  • 45 min per problem — no hints, no Google
  • Practice thinking aloud (record yourself)
  • Clarify constraints before coding every time
Week 19
Mock Interviews
  • Pramp.com — free peer mock interviews
  • Interviewing.io — free anonymous practice
  • 2 mocks per day, take all feedback seriously
  • Behavioral: STAR format for each story
Week 20
CS Fundamentals + Company Prep
  • DBMS: normalization, transactions, indexing
  • OS: process vs thread, deadlocks, scheduling
  • CN: TCP/IP, DNS, HTTP/HTTPS basics
  • OOP: SOLID principles, design patterns (basic)
  • Review company's recent LeetCode Discuss posts
Final Sprint Daily Routine
1h — CS fundamentals (OS/DBMS/CN rotation)
2h — 3 LeetCode problems timed (no hints)
1h — Mock interview or STAR story practice
1h — Review errors from previous day
Interview Communication Script: Clarify → State approach + complexity → Code → Test with example → Mention edge cases → Discuss tradeoffs.
Say this out loud every time, even alone. Silence in an interview is the #1 failure mode.
Resources:
Pramp.com (free mocks) Interviewing.io (free) LeetCode Discuss (company OAs) GeeksForGeeks CS subjects
Checkpoints
Job-Readiness Milestones

Binary gates — don't apply until you can check every box in each milestone.

✅
Month 1 Gate
Solve LeetCode Easy in under 15 min. Know complexity of everything you write. All core data structures implemented from scratch.
End of Week 5
🟡
Month 2 Gate
Solving LeetCode Medium in 30–40 min consistently. Can explain approach + complexity before coding. 100+ problems solved.
End of Week 8
🔵
Month 3 Gate
DP problems no longer feel like guesswork. 200+ problems done. Trie, DSU implemented cold. Ready for mid-tier company OAs.
End of Week 12
🟣
Interview-Ready Gate
2 GitHub projects live. Resume done. Can solve 2 LeetCode Mediums in 45 min under pressure. CS fundamentals solid.
End of Week 17
🏆
Offer Gate
Passing mock interviews consistently. Behavioral answers polished. 50+ applications out. Follow-ups sent. Negotiation ready.
End of Week 20
The System
Non-Negotiable Daily Habits

These compound. Miss them for a week and you'll feel it. Do them daily and they become automatic.

1
State Complexity Before Coding
Before writing a single line, declare the target time and space complexity out loud. Makes you think before you type.
2
The 30-Minute Rule
If zero progress after 30 min, read the approach — not the code. Then implement yourself. Builds your pattern library 5× faster.
3
Sunday Re-Solves
Every Sunday, re-solve 5 problems from the past 2 weeks with zero reference. Spaced repetition is the only reliable way to retain patterns.
4
Pattern Notebook
Every new pattern: name, when to apply, template code, 3 example problems. By month 3, this becomes your most valuable asset.
5
Classify After Every Solve
"This was a sliding window problem because the constraint is a contiguous subarray with a variable bound." One sentence, every time.
6
Teach It Weekly
Pick one concept per week, explain it as if teaching a first-year student. You'll discover every gap you didn't know you had.
Free Stack
Complete Resource Guide

Everything you need. Budget: ₹0 for 90% of it.

ResourceCostBest ForPhase
LeetCodeFREEProblem practice, interview patternsAll
NeetCode (YouTube)FREELeetCode solutions with pattern explanation1–3
Abdul Bari (YouTube)FREEAlgorithm theory, complexity, DAA0–2
Aditya Verma DP SeriesFREEBest DP series available (Hindi+English)3
William Fiset (YouTube)FREEGraph algorithms, data structures from scratch1–2
MIT OCW 6.006 + 6.046FREERigorous algorithm theory and proofs0, 2
Visualgo.netFREEVisual algorithm traces for intuition1–2
CP-Algorithms.comFREEAdvanced algorithms reference3+
CSES Problem SetFREE300 structured high-quality problems2–4
Pramp.comFREEFree peer-to-peer mock interviews6
ByteByteGo (YouTube)FREESystem design fundamentals4
GeeksForGeeksFREECS fundamentals: OS, DBMS, CN6
Jake's Resume TemplateFREEATS-optimized LaTeX resume on Overleaf5
Grokking Algorithms (book)~₹800Visual beginner-friendly introduction0
LeetCode Premium~₹2800/moCompany-specific problems (optional)6