90-Day DSA Interview Prep: A Realistic Roadmap That Actually Works

Week 1 Arrays & Two Pointers

Why start here: Arrays appear in 60%+ of interviews. Master them first.

Core concepts to understand:

• Array traversal (forward, backward, both)
• Two pointers (same direction vs opposite directions)
• In-place modifications (when you can't use extra space)
• Subarray vs subsequence (contiguous vs not)

Problems to solve (do in this order):

1. Two Sum (brute force → hash map optimization)
2. Remove Duplicates from Sorted Array (two pointers)
3. Move Zeroes (in-place swapping)
4. Best Time to Buy and Sell Stock (one-pass tracking)
5. Container With Most Water (two pointers, greedy)
6. 3Sum (sorting + two pointers + duplicate handling)

Key skills you're building:

• Recognizing when two pointers help
• Converting O(n²) brute force to O(n) with hashing
• Handling edge cases (empty array, single element, all duplicates)

Daily practice pattern:

• Mon-Wed: 2 new problems/day (easy → medium)
• Thu-Fri: 1 new + review 2 older ones
• Sat: Harder problem + write pattern notes
• Sun: Review all week's problems without looking at code

Week 2 Strings & Sliding Window

The pattern: "Maintain a window of elements and slide it across the array/string while tracking some property."

When to use sliding window:

• Problem asks about contiguous subarrays/substrings
• Keywords: "longest," "shortest," "maximum," "minimum" + some condition
• You're tempted to write nested loops → try window instead

Must-solve problems:

1. Longest Substring Without Repeating Characters
2. Minimum Window Substring
3. Permutation in String
4. Find All Anagrams in String
5. Longest Repeating Character Replacement

Practice tip: For each problem, first write the brute force nested loop version, calculate its complexity, then optimize with window.

Week 3 Linked Lists & Stacks/Queues

Why this matters: Tests your pointer manipulation skills. If you can't reverse a linked list, you're not ready for interviews.

Before solving problems:

• Implement a singly linked list from scratch (no libraries)
• Implement a stack using array AND using linked list
• Practice drawing linked list operations on paper

Essential problems:

1. Reverse Linked List (iterative + recursive)
2. Linked List Cycle (Floyd's algorithm)
3. Merge Two Sorted Lists
4. Remove Nth Node From End
5. Reorder List
6. Valid Parentheses (stack)
7. Daily Temperatures (monotonic stack)

Pro tip: Always draw the linked list state before and after each operation. Helps catch null pointer bugs.

Week 4 Hash Maps & Hash Sets

The superpower: Turn O(n²) problems into O(n) with O(n) space.

Pattern recognition:

• "Have I seen this element before?" → Hash set
• "How many times does X appear?" → Hash map with counts
• "Find pair/triplet that sums to Y" → Hash map to store complements
• "Group elements by property Z" → Hash map of lists

Problems that cement the pattern:

1. Two Sum (review with hash map approach)
2. Group Anagrams
3. Longest Consecutive Sequence
4. Subarray Sum Equals K
5. Top K Frequent Elements
6. First Unique Character in String

Week 5 Binary Search Mastery

Beyond sorted arrays: Binary search is a thinking pattern, not just an algorithm.

Three types of binary search:

1. Search for value: "Find target in sorted array"
2. Search for boundary: "Find first/last occurrence"
3. Search in answer space: "Find minimum X such that condition(X) is true"

Essential problems:

• Binary Search (implement from memory every day)
• First Bad Version
• Search in Rotated Sorted Array
• Find Minimum in Rotated Sorted Array
• Koko Eating Bananas (binary search on answer)
• Capacity To Ship Packages Within D Days

Practice technique: Write a binary search template and use it for every problem. Modify as needed but keep the structure consistent.

Week 6 Trees & Recursion

Mental model: "A tree is just recursion with base cases."

Before anything else, memorize:

• Inorder traversal (left → root → right)
• Preorder traversal (root → left → right)
• Postorder traversal (left → right → root)
• Level-order (BFS with queue)

Core problems (in order):

1. Maximum Depth of Binary Tree
2. Same Tree
3. Invert Binary Tree
4. Diameter of Binary Tree
5. Balanced Binary Tree
6. Lowest Common Ancestor
7. Validate BST
8. Kth Smallest Element in BST
9. Binary Tree Level Order Traversal
10. Serialize and Deserialize Binary Tree

Pro tip: For every tree problem, first identify if you need DFS (recursion) or BFS (queue). 80% of the time it's DFS.

Week 7 Heaps & Priority Queues

When to use heaps:

• Problem mentions "Kth largest/smallest"
• Need to track min/max dynamically
• Merging K sorted things
• Finding median of stream

Key insight: Min-heap for Kth largest, max-heap for Kth smallest (counter-intuitive but true).

Must-solve:

• Kth Largest Element in Array
• Top K Frequent Elements
• K Closest Points to Origin
• Merge K Sorted Lists
• Find Median from Data Stream

Week 8 Intervals & Greedy + First Mock

Interval pattern: Almost always starts with sorting by one dimension.

Problems:

• Merge Intervals
• Insert Interval
• Non-overlapping Intervals
• Meeting Rooms
• Meeting Rooms II

Week 9 Graphs - BFS & DFS

The mindset: "Graph = nodes + edges. Most problems are about traversal or connectivity."

Before solving problems:

• Implement adjacency list representation from scratch
• Implement BFS with queue
• Implement DFS with stack and recursively

Essential problems:

1. Number of Islands
2. Clone Graph
3. Pacific Atlantic Water Flow
4. Course Schedule (cycle detection)
5. Course Schedule II (topological sort)
6. Graph Valid Tree
7. Number of Connected Components

Pattern recognition:

• Shortest path in unweighted graph → BFS
• Explore all possibilities → DFS
• Cycle detection → DFS with visited + recursion stack
• Topological sort → DFS + stack or Kahn's algorithm

Week 10 Dynamic Programming - Introduction

DP demystified: "Recursion + caching = DP. That's it."

The process (for every DP problem):

1. Write brute force recursion (identify subproblems)
2. Add memoization (cache results)
3. Convert to bottom-up tabulation (if needed)
4. Optimize space (if possible)

Start with 1D DP:

• Climbing Stairs
• House Robber
• House Robber II
• Longest Increasing Subsequence
• Coin Change
• Coin Change 2

Key skill: Define state clearly. "What does dp[i] represent?" must be crystal clear.

Week 11 Dynamic Programming - Advanced

2D DP problems:

• Unique Paths
• Longest Common Subsequence
• Edit Distance
• Distinct Subsequences
• Regular Expression Matching

Backtracking (DP's cousin):

• Subsets
• Subsets II
• Permutations
• Combination Sum
• Word Search
• N-Queens

Week 12 Final Review & Mock Marathon

This week is different: No new topics. Only review and mock interviews.

Daily structure:

• Morning (1 hour): Review weakest patterns from tracking
• Afternoon (1.5 hours): Solve 2-3 problems on timer
• Evening: Mock interview or watch your recorded mocks

Goal: Do 4-5 mock interviews this week. Get comfortable being uncomfortable.

Self-assessment checklist:

• Can solve 80%+ easy problems in <10 mins
• Can solve 60%+ medium problems in <25 mins
• Recognize pattern within first 2-3 mins of reading problem
• Can explain complexity without hesitation
• Ask clarifying questions automatically