Appendix K: 60-Day Study Plan
An accelerated plan for those with less time. Covers all essential topics with a faster pace.
Overview
- Duration: 8 weeks (56 days, including 4 rest days)
- Daily commitment: 4-5 hours
- Weekly pattern: 6 days learning + 1 day review (rest on days 15, 29, 45, 56)
- Total problems: ~200-250
- Goal: Solid coverage of all major DSA topics
Prerequisites
Before starting this plan, you should:
- Know at least one programming language (C++, Java, or Python)
- Understand basic data structures (arrays, linked lists, trees)
- Be comfortable with recursion
If you’re a complete beginner, consider the 90-day plan instead.
Week 1: Arrays, Strings, & Basic Data Structures (Days 1-7)
Day 1: Arrays & Two Pointers
- Array fundamentals, two-pointer technique
- Problems: Two Sum, Remove Duplicates, Valid Palindrome
- Practice: 3 problems
Day 2: Strings & Sliding Window
- String operations, sliding window technique
- Problems: Longest Substring Without Repeating Characters, Minimum Window Substring
- Practice: 3 problems
Day 3: Hashing & Prefix Sums
- Hash maps for frequency counting, prefix sums
- Problems: Group Anagrams, Subarray Sum Equals K
- Practice: 3 problems
Day 4: Linked Lists
- Singly linked list operations, fast/slow pointers
- Problems: Reverse Linked List, Detect Cycle, Merge Two Sorted Lists
- Practice: 3 problems
Day 5: Stacks & Queues
- Stack/queue operations, monotonic stack
- Problems: Valid Parentheses, Daily Temperatures, Min Stack
- Practice: 3 problems
Day 6: Practice Day
- Solve 5-6 mixed problems on topics covered
- Focus on medium difficulty
Day 7: Review Day
- Review all concepts from the week
- Redo any problems you couldn’t solve
- Update notes
Week 2: Trees & BST (Days 8-14)
Day 8: Binary Tree Basics
- Tree traversals (recursive and iterative)
- Problems: Maximum Depth, Invert Tree, Level Order Traversal
- Practice: 3 problems
Day 9: BST Operations
- BST search, insert, delete, validation
- Problems: Validate BST, Kth Smallest Element, Lowest Common Ancestor
- Practice: 3 problems
Day 10: Tree Construction & Serialization
- Build tree from traversals, serialize/deserialize
- Problems: Construct from Preorder/Inorder, Serialize/Deserialize
- Practice: 3 problems
Day 11: Advanced Tree Problems
- Path sum, diameter, max path sum
- Problems: Binary Tree Maximum Path Sum, Diameter of Binary Tree
- Practice: 3 problems
Day 12: Trie
- Trie implementation, prefix queries
- Problems: Implement Trie, Word Search II
- Practice: 3 problems
Day 13: Segment Tree & Fenwick Tree
- Range queries and updates
- Problems: Range Sum Query, Range Minimum Query
- Practice: 2 problems
Day 14: Review Day
- Review tree topics
- Redo challenging problems
- Update notes
Week 3: Graphs (Days 15-21)
Day 15: REST DAY
Day 16: Graph Basics & BFS
- Graph representation, BFS
- Problems: Number of Islands, Rotting Oranges, Clone Graph
- Practice: 3 problems
Day 17: DFS & Connected Components
- DFS, cycle detection, connected components
- Problems: Number of Connected Components, Graph Valid Tree
- Practice: 3 problems
Day 18: Topological Sort
- Kahn’s algorithm, DFS-based
- Problems: Course Schedule, Course Schedule II, Alien Dictionary
- Practice: 3 problems
Day 19: Shortest Path Algorithms
- Dijkstra, Bellman-Ford
- Problems: Network Delay Time, Cheapest Flights
- Practice: 3 problems
Day 20: Union-Find
- DSU with optimizations
- Problems: Redundant Connection, Number of Provinces
- Practice: 3 problems
Day 21: Review Day
- Review graph topics
- Redo challenging problems
- Update notes
Week 4: Dynamic Programming - Fundamentals (Days 22-28)
Day 22: DP Basics
- 1D DP, memoization vs tabulation
- Problems: Fibonacci, Climbing Stairs, House Robber
- Practice: 3 problems
Day 23: Knapsack & Subset Problems
- 0/1 Knapsack, subset sum
- Problems: Partition Equal Subset Sum, Coin Change
- Practice: 3 problems
Day 24: String DP
- LCS, Edit Distance
- Problems: Longest Common Subsequence, Edit Distance
- Practice: 3 problems
Day 25: Grid DP
- Unique paths, minimum path sum
- Problems: Unique Paths, Minimum Path Sum, Dungeon Game
- Practice: 3 problems
Day 26: LIS & Sequences
- Longest Increasing Subsequence
- Problems: LIS, Russian Doll Envelopes, Maximum Length of Repeated Subarray
- Practice: 3 problems
Day 27: DP on Strings
- Palindrome problems, regex matching
- Problems: Longest Palindromic Substring, Word Break
- Practice: 3 problems
Day 28: Review Day
- Review DP fundamentals
- Redo challenging problems
- Update notes
Week 5: Dynamic Programming - Advanced (Days 29-35)
Day 29: REST DAY
Day 30: Interval DP
- Matrix chain, burst balloons
- Problems: Burst Balloons, Palindrome Partitioning
- Practice: 2-3 hard problems
Day 31: Bitmask DP
- TSP, assignment problem
- Problems: Shortest Path Visiting All Nodes
- Practice: 2-3 hard problems
Day 32: Tree DP
- DP on trees
- Problems: House Robber III, Binary Tree Maximum Path Sum
- Practice: 3 problems
Day 33: Stock Problems
- Buy/sell stock variants
- Problems: Best Time to Buy/Sell Stock (all variants)
- Practice: 3 problems
Day 34: Greedy Algorithms
- Greedy choice property
- Problems: Jump Game, Jump Game II, Non-overlapping Intervals
- Practice: 3 problems
Day 35: Review Day
- Review advanced DP and greedy
- Redo challenging problems
- Update notes
Week 6: Binary Search, Sorting, & Heaps (Days 36-42)
Day 36: Binary Search Basics
- Standard binary search, variants
- Problems: Binary Search, Search Insert Position, Find Peak Element
- Practice: 3 problems
Day 37: Binary Search on Answer
- Binary search on answer space
- Problems: Capacity to Ship Packages, Koko Eating Bananas
- Practice: 3 problems
Day 38: Binary Search in Rotated Arrays
- Rotated array problems
- Problems: Find Minimum in Rotated Sorted Array, Search in Rotated Array
- Practice: 3 problems
Day 39: Sorting Algorithms
- Merge sort, quicksort, heapsort
- Problems: Sort an Array, Kth Largest Element
- Practice: 3 problems
Day 40: Heaps & Priority Queues
- Min-heap, max-heap applications
- Problems: Top K Frequent Elements, Find Median from Data Stream
- Practice: 3 problems
Day 41: Backtracking
- Subsets, permutations, combinations
- Problems: Subsets, Permutations, N-Queens
- Practice: 3 problems
Day 42: Review Day
- Review binary search, sorting, heaps, backtracking
- Redo challenging problems
- Update notes
Week 7: Math, Bits, & Advanced Topics (Days 43-49)
Day 43: Number Theory
- GCD, LCM, primes, modular arithmetic
- Problems: Count Primes, Super Pow
- Practice: 3 problems
Day 44: Combinatorics
- Factorials, combinations, Pascal’s triangle
- Problems: Pascal’s Triangle, Unique Paths (math)
- Practice: 3 problems
Day 45: REST DAY
Day 46: Bit Manipulation
- AND, OR, XOR, shifts, subset enumeration
- Problems: Single Number, Counting Bits, Subsets (bitmask)
- Practice: 3 problems
Day 47: String Matching
- KMP algorithm
- Problems: Implement strStr(), Repeated Substring Pattern
- Practice: 2-3 problems
Day 48: Design Problems
- LRU Cache, design patterns
- Problems: LRU Cache, Design Twitter
- Practice: 2-3 problems
Day 49: Review Day
- Review math, bits, advanced topics
- Redo challenging problems
- Update notes
Week 8: Final Review & Mock Interviews (Days 50-56, rest day 60)
Day 50: Mixed Practice
- Solve 5-6 mixed problems of varying difficulty
- Focus on problem identification
Day 51: Weak Areas
- Identify your weakest topics
- Review concepts and redo problems
Day 52: Mock Interview 1
- Full mock interview (45-60 minutes)
- Focus on communication and process
Day 53: Mock Interview 2
- Full mock interview (45-60 minutes)
- Focus on edge cases and testing
Day 54: Pattern Review
- Review all problem patterns
- Practice identifying which technique to use
Day 55: Final Review
- Review cheat sheets and notes
- Redo 3-4 most challenging problems
Day 56: REST DAY (Optional prep)
- Light review only
- Prepare for interviews
Key Differences from 90-Day Plan
| Aspect | 90-Day Plan | 60-Day Plan |
|---|---|---|
| Daily hours | 3-4 | 4-5 |
| Problems per topic | 5-8 | 3-5 |
| Rest days | 0 | 4 (every 2 weeks) |
| Coverage depth | Deep | Solid |
| Practice problems | ~300 | ~200-250 |
| Review time | More | Less |
Daily Schedule Template
| Time | Activity |
|---|---|
| 0:00-0:15 | Review yesterday’s material |
| 0:15-1:15 | Learn new concept (videos, reading) |
| 1:15-2:45 | Solve problems (3 problems) |
| 2:45-3:00 | Break |
| 3:00-4:00 | Solve additional problems or review |
| 4:00-4:30 | Update notes and cheat sheets |
Weekly Goals
| Week | Topic | Problems | Key Concepts |
|---|---|---|---|
| 1 | Arrays, Strings, Basics | 20 | Two pointers, sliding window, hashing |
| 2 | Trees & BST | 18-20 | Traversals, BST, trie, segment tree |
| 3 | Graphs | 18-20 | BFS, DFS, topo sort, shortest path, DSU |
| 4 | DP Fundamentals | 18-20 | 1D DP, knapsack, string DP, grid DP |
| 5 | DP Advanced | 12-15 | Interval DP, bitmask DP, greedy |
| 6 | Binary Search, Sorting, Heaps | 18-20 | Binary search variants, heaps, backtracking |
| 7 | Math, Bits, Advanced | 12-15 | Number theory, bit manipulation, design |
| 8 | Review & Mocks | 10-15 | Mixed problems, mock interviews |
Progress Tracking
| Week | Planned | Completed | Notes |
|---|---|---|---|
| 1 | 20 | ||
| 2 | 18-20 | ||
| 3 | 18-20 | ||
| 4 | 18-20 | ||
| 5 | 12-15 | ||
| 6 | 18-20 | ||
| 7 | 12-15 | ||
| 8 | 10-15 | ||
| Total | ~200-250 |
Tips for the 60-Day Plan
- Prioritize understanding over quantity — it’s better to deeply understand 3 problems than to superficially solve 10
- Use the rest days — burnout is real; rest days help consolidate learning
- Focus on patterns — learn to recognize problem types, not memorize solutions
- Practice explaining — being able to explain your approach is as important as solving
- Don’t skip reviews — review days are crucial for retention
This plan is intense but achievable. Stay consistent, and you’ll be well-prepared for interviews in 60 days.
Frequently Asked Questions
What if I fall behind?
If you miss a day or two, don’t try to double up. Instead, compress the review days — they’re your buffer. If you fall behind by more than a week, consider switching to the 90-day plan. The worst thing you can do is rush through topics without understanding them.
Should I use C++, Java, or Python?
For interviews, C++ and Java are preferred at most top companies because they demonstrate familiarity with memory management and type systems. Python is acceptable and often faster to write, but some interviewers may push back on its lack of explicit data structures. Choose the language you’re most comfortable with, but make sure you know its standard library well.
How do I know if I’m ready?
You’re ready when you can:
- Identify the pattern for a medium-difficulty problem within 5 minutes
- Code a clean solution in 15-20 minutes
- Explain your approach clearly in 2-3 minutes
- Handle follow-up questions about complexity and edge cases
If you can do this consistently across all major topics, you’re in good shape.
What if I already know some topics?
Skip the learning phase for topics you’re confident in and spend the time on practice problems instead. The plan is designed for comprehensive coverage, but if you’re already strong in trees, for example, move those days to your weak areas.
How many problems should I solve per day?
Aim for 3-5 problems per day. Quality matters more than quantity. It’s better to deeply understand 3 problems than to superficially solve 10. Each problem should teach you a pattern or reinforce an existing one.
Should I do contests during this plan?
If you’re already doing competitive programming, continue with contests on weekends. If you’re new to contests, skip them during the 60-day plan — they can be demoralizing and time-consuming when you’re still learning fundamentals. You can add contests after your interviews.
Week-by-Week Focus Areas
Weeks 1-2: Foundation Building
These weeks establish your core problem-solving skills. Focus on recognizing patterns, not memorizing solutions. By the end of week 2, you should be comfortable with arrays, strings, trees, and basic graph problems.
Weeks 3-4: Dynamic Programming Mastery
DP is the hardest topic for most people. Don’t rush it. Spend extra time on the state transition logic — if you can define the state and recurrence correctly, the implementation is straightforward. Practice drawing the DP table for small examples.
Weeks 5-6: Advanced Patterns
These weeks cover the remaining high-frequency topics. Binary search and heaps are relatively quick to learn. Backtracking requires practice with pruning. The key insight is that most backtracking problems follow the same template.
Weeks 7-8: Consolidation and Practice
The final two weeks are about integration. Solve mixed problems, do mock interviews, and fill gaps. This is where you transform knowledge into interview performance.
Recommended Resources
Problem Sources
- LeetCode — Primary practice platform. Focus on the “Top Interview 150” list.
- NeetCode — Curated problem lists with video explanations.
- Codeforces — For competitive programming practice (optional).
Learning Resources
- This book — Read the relevant chapters before each week.
- YouTube — Abdul Bari, Tushar Roy, and NeetCode for visual explanations.
- GeeksforGeeks — Good for quick reference and alternative implementations.
Tools
- Anki — Create flashcards for patterns and edge cases.
- Timer — Practice with a 45-minute timer to simulate interview pressure.
- Notes — Maintain a running document of patterns, mistakes, and insights.