Question 1

How do I get better at pattern recognition for coding interviews?

Accepted Answer

Study patterns, not individual problems. For each pattern (Sliding Window, Two Pointers, BFS, DP, etc.), learn the template and the conditions that trigger it. When you see "sorted input", think binary search or two pointers. When you see "top K elements", think heap. After solving 3–5 problems per pattern, recognition becomes automatic.

Question 2

What data structure should I use for each type of problem?

Accepted Answer

Key heuristics: sorted input → binary search or two pointers; O(1) lookup needed → hash map or set; cycle detection or midpoint → fast/slow pointers; top/bottom K → heap; overlapping intervals → sort by start time; count ways or optimal split → dynamic programming; all subsets/permutations → backtracking.

Question 3

When should I use BFS vs DFS for tree and graph problems?

Accepted Answer

Use BFS when you need the shortest path, level-by-level traversal, or the minimum number of steps. Use DFS when you need to explore all paths, detect cycles, or traverse a tree recursively (pre/in/post-order). For disconnected graphs, both work — BFS is slightly easier to implement iteratively with a queue.

Question 4

How do I know when to use dynamic programming?

Accepted Answer

DP applies when: (1) the problem asks to count ways, maximize/minimize a value, or check feasibility; (2) the problem has overlapping subproblems (same sub-inputs are computed multiple times); and (3) there's an optimal substructure (optimal solution builds on optimal solutions to subproblems). If a greedy approach is provably correct, use that instead — it's simpler.

Question 5

What should I do when I am stuck on a coding interview problem?

Accepted Answer

Follow this order: (1) Work through a small example by hand. (2) State the brute-force O(n²) or O(2ⁿ) solution out loud — it shows you understand the problem. (3) Look for inefficiency: what are you recomputing? Can a hash map eliminate a nested loop? (4) Map to a known pattern using the condition → pattern heuristics. (5) Think about the data structure that matches the access pattern.

Question 6

How do I handle edge cases in coding interviews?

Accepted Answer

Always test: empty input, single element, all elements identical, negative numbers, maximum constraints (overflow), and the boundary conditions your algorithm depends on (e.g. window of size equal to array). Mention these before coding — it signals thoroughness. The most common bugs come from off-by-one errors (use < vs <=) and not handling the empty/null case.

Condition	Approach
Input is sorted	Binary search or two pointers
Need O(1) lookup or existence check	Hash table (set or map)
Problem requires in-place modification	Two pointers or index swap
Common prefix or string matching	Map counting or Trie
XOR, toggling, or bit flags	Bit manipulation

Condition	Approach
Max or min subarray sum or length	Dynamic programming or sliding window
Sliding window max or min	Monotonic deque
Next greater or smaller element	Monotonic stack
Range sum query	Prefix sum, Binary Indexed Tree, or segment tree

Condition	Approach
Tree traversal or path problem	DFS (recursion or stack) or BFS (queue)
Graph traversal or connected components	DFS / BFS / Union-Find
2D grid connectivity or shortest path	BFS or DFS or DP on grid
Grouping or merging disjoint sets	Union-Find or DFS
Task ordering with dependencies	Topological sort

Condition	Approach
Cycle detection or finding midpoint in a linked list	Fast and slow pointers
Need to simulate recursion iteratively	Explicit stack

Condition	Approach
Top K or least K elements	Min/max heap, Quickselect, or bucket sort
Merging multiple sorted sequences	Merge sort pattern or min-heap
Overlapping interval handling	Sort by start time, then sweep line
Processing a continuous data stream	Heap or custom data structure

Coding Interview Tips — How to Solve LeetCode Problems by Pattern

Arrays & Strings

Subarrays & Sequences

Trees & Graphs

Linked Lists & Stacks

Sorting & Intervals

Optimization

General

Condition	Approach
All permutations, combinations, or subsets	Backtracking
Count ways or divide problem optimally	Greedy (if provable) or Dynamic Programming

Condition	Approach
None of the above fit	Hash map or set — O(1) time, O(n) space
Want to avoid extra space	Sort the input first — O(n log n) time, O(1) space