How to Finish DSA in 3 Months If You're Starting from Zero (Exact Plan)
How to Finish DSA in 3 Months If You're Starting from Zero (Exact Plan)
By FinishDSA
Picture this.
It's 8 PM. You just watched a YouTube video called "DSA Roadmap for Beginners 2024." It was 47 minutes long. The guy had a nice setup, a calm voice, and listed 11 topics you should cover.
Arrays. Linked Lists. Stacks. Queues. Trees. Graphs. DP. Heaps. Tries. Backtracking. Bit Manipulation.
You took notes. You made a notion page. You put it in a new folder called "DSA Prep."
And then you sat there, staring at your screen, with absolutely no idea what to actually do next.
This is where 90% of students get stuck. Not because they're not smart. Not because they're lazy. Because they got a list when what they needed was a path.
A list tells you what exists. A path tells you where to walk.
This is the path.
First, let's agree on what "finishing DSA" actually means
There's a version of DSA that exists in competitive programming. That version is endless. It has no finish line. There are always harder problems, more niche data structures, more obscure algorithms.
That's not what we're talking about.
We're talking about placement-ready DSA. The DSA you need to clear an SDE-1 or SDE-2 coding round at a decent product company. The version that lets you solve problems in an interview without freezing up.
That version? It's actually finite.
It lives inside roughly 10 core patterns. And it takes about 250 well-chosen problems to get truly comfortable with those patterns.
Three months is enough. But only if you stop grinding and start finishing.
The core mistake (and why everyone makes it)
Open LeetCode right now. There are 3,000+ problems.
If you solve 2 problems a day, every day, it takes you over 4 years to do all of them.
Nobody has 4 years. You have 3 months.
So most students do what feels logical: they start with Easy problems. They solve 20, maybe 30. They feel good. Then they hit a Medium and get stuck. They watch a solution video. They kind of understand it. They move on. They solve another Easy. They feel good again.
Six weeks later, they've solved 80 problems, learned very little, and they still can't figure out why their solutions work when they work.
The problem isn't the number of problems. The problem is that they're building a collection, not building a skill.
You don't get better at chess by playing 300 games with no reflection. You get better by studying patterns, practicing positions, and understanding why a move works.
DSA is the same.
The 10 patterns that cover 80% of everything
Here's something that nobody in your college will tell you, but is completely true: almost every DSA interview problem is a variation of one of these 10 patterns.
1. Arrays and the Two Pointer trick Anytime you're working with sorted arrays or need to find a pair that satisfies some condition, two pointers. That's it. The logic is always the same: one pointer at the start, one at the end, move them toward each other based on what you find.
2. Sliding Window Anytime you're looking for something across a contiguous subarray or substring. Maximum sum of k elements. Longest substring without repeats. These all look different. They're all the same problem in different clothes.
3. Binary Search (not just on sorted arrays) Yes, binary search on a sorted array. But also binary search on the answer. "What's the minimum capacity required" or "what's the maximum number of days" type problems. When there's a monotonic search space, binary search it.
4. Hashmaps Hashmap is the answer to more problems than any other data structure. Frequency counts. Complement lookups. Prefix sums. Any time you need O(1) access, you need a hashmap.
5. Recursion and the recursion tree Every recursive solution has a tree in it. Once you can visualize that tree, you can write the code. The hard part isn't syntax. The hard part is trusting that the subproblem returns the right answer and building on top of it.
6. Trees and Tree traversal Inorder, preorder, postorder. Top-down vs bottom-up recursion. These five words will unlock 80% of tree problems you'll ever face in an interview.
7. Graphs: BFS and DFS BFS for shortest paths. DFS for exploring all paths. Once you write a BFS and DFS from scratch 10 times each, the template lives in your fingers. After that, every graph problem is just "which of these two templates do I reach for?"
8. Dynamic Programming Everyone says DP is hard. DP is hard when you try to memorize solutions. DP becomes manageable when you realize it's just recursion with memory. Start with the recursive solution. Add memoization. Optionally convert to tabulation. That's the entire playbook.
9. Stacks and Monotonic Stacks Next greater element. Largest rectangle in histogram. Daily temperatures. These are all the same monotonic stack pattern. Learn it once, apply it everywhere.
10. Heaps K-th largest. Merge K sorted lists. Any time you need to repeatedly access the max or min efficiently. Two heaps for median. That's the whole thing.
That's the syllabus. 10 patterns. Not 11 topics from a YouTube video. Not 3,000 LeetCode problems.
The exact 3-month plan
Here's what three months actually looks like when you're doing this right.
Month 1: Foundation (Weeks 1-4)
Goal: Get comfortable with the first 5 patterns. Solve 80 problems. Understand why your solutions work, not just that they work.
Week 1 is Arrays and Two Pointers. You're not trying to solve hard problems this week. You're trying to build the habit of sitting down, reading a problem, and thinking before coding.
Solve 5 problems on two pointers. Do them without looking at solutions. Struggle. That struggle is the whole point. The moment you look up a solution, copy it, and move on, you've learned nothing. The struggle is where the learning happens.
Week 2 is Sliding Window and Binary Search. These two patterns have something in common: they're both about reducing search space intelligently. Once you see that connection, both of them click faster.
Week 3 is Hashmaps and Prefix Sums. This week will feel easier. That's normal. Hashmap problems are everywhere and once the pattern clicks, it really clicks.
Week 4 is Recursion. This is the hardest week of Month 1 for most people. Don't skip it. Don't rush it. If you spend the entire week just on recursion problems and nothing else, that is time well spent. Everything downstream, including trees and DP, requires you to be comfortable with recursion first.
What to track: For every problem you solve this month, write one line: "The key insight was ___." If you can't write that one line, you don't understand the problem yet.
Month 2: Core Patterns (Weeks 5-8)
Goal: Cover the remaining 5 patterns. Solve another 100 problems. Start being able to identify which pattern applies within 2-3 minutes of reading a problem.
Week 5 and 6 are Trees. Give trees two full weeks. Trees come up constantly in interviews. Recursive tree problems are where the "trust the recursion" mental model either clicks or breaks. Use both weeks to make it click.
Week 7 is Graphs. BFS and DFS. Implement both from scratch every single day this week, even for problems that don't need both. By the end of the week, writing a BFS should take you 3 minutes, not 30.
Week 8 is Dynamic Programming. Start with the classic 1D DP problems: Fibonacci, climbing stairs, coin change, house robber. Don't jump to 2D DP yet. Understand the recursion-to-memoization-to-tabulation pipeline deeply before you go any further.
What changes this month: You should start timing yourself. Not because time pressure is good for learning, but because you need to know how fast you actually are. If you can solve an Easy in under 15 minutes and a Medium in under 35, you're in good shape for most placement rounds.
Month 3: Interview Readiness (Weeks 9-12)
Goal: Solve mixed problems without knowing the category first. Simulate interview conditions. Solidify weak spots. Solve your last 70 problems.
This month is fundamentally different from the previous two.
In months 1 and 2, you practiced by category. In month 3, you practice by not knowing the category.
This matters because an interviewer is not going to tell you "this is a sliding window problem." They're going to hand you a problem and wait. The skill you're building in month 3 is recognition: the ability to read a problem and within 2-3 minutes know which pattern to reach for.
Week 9 is about revisiting every pattern's hardest problems. Not the Hards on LeetCode. The hardest Mediums in each category. These are the problems that look unfamiliar on the surface but are just clever variations of patterns you already know.
Week 10 is mock practice. Set a timer. Pick a problem you haven't seen. Give yourself 45 minutes. Don't look at the solution until time is up, whether you solved it or not. Do this every day. This week will feel uncomfortable. That discomfort is the interview simulation working.
Week 11 is targeted fixing. By now, you know which patterns are still weak. Spend this entire week on just those. If graphs still feel shaky, do 15 more graph problems this week. Don't spread thin. Go deep on the weak spots.
Week 12 is light and consolidating. Solve 10-15 problems total. Sleep properly. Review your "key insight" notes from all 11 previous weeks. The night before your placement test, read your notes. Don't solve new problems.
The thing nobody tells you about month 2 specifically
There will be a week in month 2, probably around week 6 or 7, where nothing clicks.
You'll sit down to solve a tree problem and it'll feel like you've never seen a tree before. You'll read your own previous solutions and not understand them. You'll feel like you've been wasting your entire time.
This is not failure. This is consolidation.
The brain is not a hard drive. Information doesn't go in clean and stay there. It gets absorbed in waves. The week where nothing clicks is usually followed by the week where everything starts to connect.
The students who quit during that bad week never find out.
The students who push through, even by solving just one problem a day during that week, come out the other side with pattern recognition that actually sticks.
What does 250 problems actually look like?
Let's be specific.
Month 1: 80 problems Month 2: 100 problems Month 3: 70 problems
That's 250 total. At roughly 2-3 problems per day, 6 days a week, this is completely doable across 3 months.
The distribution across patterns should look roughly like this:
- Arrays and Two Pointers: 25 problems
- Sliding Window: 15 problems
- Binary Search: 15 problems
- Hashmaps: 25 problems
- Recursion: 20 problems
- Trees: 35 problems
- Graphs: 30 problems
- Dynamic Programming: 35 problems
- Stacks and Monotonic Stacks: 25 problems
- Heaps: 25 problems
More problems in Trees and DP because they're the most commonly tested and the hardest to master.
The daily habit that makes all of this work
Every day, 90 minutes. Non-negotiable.
First 10 minutes: Review yesterday's problems. Read your key insight notes. Do not skip this.
Next 60 minutes: Solve today's problems. Two to three problems depending on difficulty.
Last 20 minutes: For every problem you solved today, write the key insight. If you got stuck, write what you tried and where you got stuck. This log becomes your most valuable resource during week 12.
Consistency beats intensity every single time. A 90-minute session every day beats a 6-hour session twice a week, not just because of time, but because spaced practice is how long-term retention works.
One honest thing about this plan
This plan will not work if you treat problems as boxes to check.
It will work if you treat every single problem as a thing to understand deeply.
The difference between a student who finishes DSA and a student who finishes 300 problems without learning DSA is this: the first student, every time they solve something, asks "why does this work?" The second student just moves to the next problem.
One question. That's it.
Why does this work?
If you can answer that for every problem you solve across these 3 months, you will walk into your placement round with something most of your peers don't have: genuine understanding, not just a collection of memorized solutions.
You don't need 3000 problems. You need the right 250.
The students who crack placements from tier 2 and tier 3 colleges aren't the ones who solved the most problems. They're the ones who understood their problems deeply, practiced with structure, and built pattern recognition before the pressure hit.
That's all this is. Structure, depth, and the patience to finish what you started.
Stop grinding. Start finishing.
FinishDSA is built for exactly this. 250 problems. 10 patterns. An AI that adapts your roadmap based on how you're actually doing, not just how many problems you've done. If you've been looking for the path, not just the list, this is it.
