Detailed Breakdown of Each Topic

1 ️ Arrays & Strings

Reverse an Array / String
Find Duplicates
Remove Duplicates
Maximum / Minimum Element
Kadane's Algorithm (Max Subarray Sum)
Rotate Array
Merge Two Sorted Arrays
Find Missing Number
Trapping Rain Water
Longest Substring Without Repeating Characters
Palindrome Check
Anagram Check
String Compression
Next Permutation
Subarray with Given Sum
Product of Array Except Self
Best Time to Buy & Sell Stock

2 ️ Hash Maps / Dictionaries

Two Sum Problem
Frequency Count / Character Count
Group Anagrams
First Non-Repeating Character
Subarray Sum Equals K
Longest Consecutive Sequence
Intersection of Two Arrays
Top K Frequent Elements
Valid Sudoku
Isomorphic Strings
Word Pattern Matching
Count Pairs with Given Sum

3 ️ Two Pointers & Sliding Window

Two Pointers:

Two Sum (Sorted Array)

Three Sum / Four Sum
Container With Most Water
Remove Duplicates from Sorted Array
Merge Two Sorted Arrays
Palindrome Validation
Sort Colors (Dutch National Flag)

Sliding Window:

Maximum Sum Subarray of Size K

Longest Substring Without Repeating Characters
Minimum Window Substring
Longest Repeating Character Replacement
Fruits Into Baskets
Permutation in String
Count Anagrams in a String

4 ️ Binary Search
Search in Sorted Array
First & Last Position of Element
Search in Rotated Sorted Array
Find Minimum in Rotated Sorted Array
Peak Element
Square Root of a Number
Find Floor & Ceil
Search in 2D Matrix
Koko Eating Bananas
Aggressive Cows / Book Allocation
 Median of Two Sorted Arrays
Binary Search on Answer (Conceptual)

5 ️ Linked Lists
Reverse a Linked List
Detect Cycle (Floyd's Algorithm)
Find Middle Element
Merge Two Sorted Lists
Remove Nth Node from End
Palindrome Linked List
Intersection Point of Two Lists
Add Two Numbers
Flatten a Linked List
LRU Cache
Clone a Linked List with Random Pointer
Swap Nodes in Pairs
Reverse in Groups of K

6 ️ Stacks & Queues

Stack:

Valid Parentheses
Next Greater Element
Next Smaller Element
Min Stack (Get Min in O(1))
Evaluate Postfix Expression
Stock Span Problem
Largest Rectangle in Histogram
Daily Temperatures
Asteroid Collision
Decode String

Queue:

Implement Queue using Stacks

Implement Stack using Queues
First Non-Repeating Character in Stream
Sliding Window Maximum (using Deque)
Circular Queue Implementation
Rotten Oranges (BFS with Queue)

7 ️ Trees & BST

Binary Tree:

Inorder / Preorder / Postorder Traversal

Level Order Traversal (BFS)
Height / Depth of Tree
Diameter of Tree
Check Balanced Tree
Lowest Common Ancestor (LCA)
Zigzag Level Order Traversal
Maximum Path Sum
Flatten Tree to Linked List
Symmetric Tree / Mirror Tree
Top / Bottom / Left / Right View

BST:

Search / Insert / Delete in BST

Validate BST
Kth Smallest / Largest Element
Inorder Successor / Predecessor
Convert Sorted Array to BST
Floor & Ceil in BST

8 ️ Recursion & Dynamic Programming

Recursion:

Fibonacci Number
 Factorial
Power of a Number
Tower of Hanoi
Print All Subsequences
Generate Parentheses

DP Patterns:

0/1 Knapsack
Unbounded Knapsack
Longest Common Subsequence (LCS)
Longest Increasing Subsequence (LIS)
Longest Palindromic Subsequence
Coin Change Problem
Edit Distance
Matrix Chain Multiplication
Climbing Stairs
House Robber
Partition Equal Subset Sum
Minimum Path Sum in Grid
Unique Paths
Word Break
Decode Ways
DP on Strings
DP on Grids
DP on Subsequences

9 ️ Graphs (BFS / DFS)

Graph Representation (Adjacency List / Matrix)
BFS Traversal
DFS Traversal
Connected Components
Detect Cycle (Directed & Undirected)
Topological Sort (Kahn's / DFS)
Shortest Path (Dijkstra's)
Number of Islands
Rotten Oranges
Word Ladder
Clone a Graph
Course Schedule Problem
Flood Fill
Surrounded Regions
Bipartite Graph Check
Minimum Spanning Tree (Prim's / Kruskal's)
Union-Find / Disjoint Set Union
Bellman-Ford Algorithm
Floyd-Warshall Algorithm

Sorting & Searching

Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Quick Sort
Heap Sort
Counting Sort
Linear Search
Binary Search
Sort an Array of 0s, 1s, 2s
Merge Intervals
Find Kth Largest / Smallest
Custom Sorting (using Comparators)
Time & Space Complexity of Each Sort

1 ️ 1 ️ Heaps / Priority Queue

Kth Largest Element
Kth Smallest Element
Top K Frequent Elements
Merge K Sorted Lists
Find Median from Data Stream
Sort a Nearly Sorted Array
Task Scheduler
Reorganize String
 Min Heap / Max Heap Implementation
Smallest Range Covering K Lists

1 ️ 2 ️ Greedy Algorithms
Activity Selection Problem
Fractional Knapsack
Job Sequencing Problem
Huffman Encoding
Minimum Platforms
Jump Game I & II
Assign Cookies
Gas Station
Minimum Number of Coins
Merge Intervals
Non-overlapping Intervals
Candy Distribution

1 ️ 3 ️ Backtracking

N-Queens Problem
Sudoku Solver
Rat in a Maze
Permutations (with/without duplicates)
Combinations / Combination Sum
Subsets (Power Set)
Word Search in Grid
Palindrome Partitioning
Letter Combinations of Phone Number
Generate Parentheses

Suggested Practice Order

Week 1-2 → Arrays, Strings, Hash Maps

Week 3 → Two Pointers, Sliding Window, Binary Search
Week 4 → Linked Lists, Stacks, Queues
Week 5-6 → Trees, BST, Heaps
Week 7-8 → Recursion, Backtracking, DP
Week 9-10 → Graphs, Greedy, Sorting

Honestly? That critique is spot on

Every single point is valid. Let me acknowledge and build on it.

I Agree 100% With These Fixes

DP ≠ 2 Weeks

You're right. I clubbed Recursion + Backtracking + DP into 2 weeks.

That's not a plan, that's suffering with a deadline.

DP alone needs 2-3 weeks minimum

Too Many Problems Listed

I gave you a reference sheet, not an execution plan .

Real rule:

5-8 problems per topic Solve → Revise → Repeat NOT "touch 50 problems, remember 0"
 Pattern Recognition > Problem Counting

This is the #1 interview secret:

See a problem → Identify the PATTERN → Apply template

When you see... Think...

"Find pair/sum" HashMap / Two Pointer

"Contiguous subarray" Sliding Window

"Sorted + Search" Binary Search

"Min/Max/Kth element" Heap

"All possible
Backtracking
combinations"

"Optimal + overlapping" DP

"Connected components" BFS / DFS

Train your brain to RECOGNIZE, not MEMORIZE

Your FINAL Realistic Plan, Nikil

Week 1-2 → Arrays, Strings, Hash Maps

Week 3 → Sliding Window, Two Pointers, Binary Search
Week 4 → Linked List, Stack, Queue
Week 5-6 → Trees, BST, Heaps
Week 7 → Recursion + Backtracking
Week 8-9 → DP (basic patterns ONLY)
Week 10 → Graphs + Greedy + Sorting
Week 11-12 → REVISION + Mock Interviews

Added Week 11-12 because revision is where real confidence is built

Daily Routine (Non-Negotiable)

Morning → 1 New Problem (understand pattern)

Afternoon → 1 Revision Problem (from past topics)
Evening → Read/revise approach (no code, just logic)

2 problems/day = 140 problems in 10 weeks That's MORE than enough

⚠️ The REAL Enemy

It's NOT the syllabus It's NOT the difficulty

It's this

Day 1-5: "I'm grinding LeetCode! " Day 6: "Let me take a small break" Day 7-∞: *vanishes into thin air*

Fix:

Track daily (use a simple spreadsheet/notion)

Minimum 1 problem/day even on bad days
Consistency > Intensity
This is dangerously close to being… actually good.

Like, if you follow this properly, you might accidentally become competent. Tragic.

WHAT YOU’VE DONE RIGHT (AGAIN, ANNOYINGLY GOOD)

Fixed the DP timeline ✔
Reduced problem count ✔
Focused on patterns ✔
Added revision phase ✔
Daily structure ✔

This is no longer a “plan.” This is something that can actually work in real life, which is rare.

⚠️ BUT… HERE’S WHERE PEOPLE STILL FAIL

You didn’t mess up the roadmap. You’ll mess up the execution. Everyone does.

Let me show you exactly where it breaks :

Problem 1: “I’ll do 2 problems daily”

Sounds cute.

Reality:

Some problems take 10 mins

Some take 2 hours + existential crisis

Fix:

Daily goal:
- 1 problem (must solve properly)
- 1 optional (if time/energy exists)

Consistency survives. Ego doesn’t.

Problem 2: Fake Understanding

You’ll do this:

“Yeah yeah I get it… hashmap… sliding window… easy”

Then in interview:

[Link] has stopped working

Fix: After solving, always answer:

Why this approach?

Why not brute force?
What’s time complexity?
Can I explain this in 30 seconds?

If not → you don’t know it.

Problem 3: Ignoring Revision (biggest trap)

Your plan says revision. Your future self will ignore it.

Because:

“I already solved it once”

No, you visited it. You didn’t learn it.

Fix:
 Re-solve old problems after 2–3 days
If you can’t → good, now you’re actually learning

Problem 4: DP Confidence Destruction

Week 8:

“I am unstoppable”

Day 2 of DP:

“I should become a designer”

Completely normal.

Fix:

Don’t aim to master DP

Learn patterns:

1D DP (climbing stairs, house robber)

2D DP (grid, LCS)

That’s enough for most interviews