Practice
1. You are given a list of buildings represented as triplets (left, right, height). The goal is to output the skyline formed by these buildings as a list of key points where the height changes. Which algorithmic approach guarantees an optimal solution with time complexity O(n log n) for this problem?
easy
Solution
Step 1: Understand problem constraints
The problem requires merging multiple building outlines efficiently, which suggests a divide and conquer strategy to combine partial skylines.Step 2: Compare approaches
Greedy and brute force approaches are either incorrect or inefficient (O(n * maxRight)). Dynamic programming does not naturally fit this problem. Divide and conquer achieves O(n log n) by recursively merging skylines.Final Answer:
Option A -> Option AQuick Check:
Divide and conquer merges partial results efficiently [OK]
Hint: Divide and conquer merges partial skylines efficiently [OK]
Common Mistakes:
- Believing greedy approach works optimally
- Thinking DP applies naturally here
- Assuming brute force is efficient enough
2. Examine the following modified code for Largest Rectangle in Histogram. Which line contains a subtle bug that can cause incorrect maximum area calculation?
def largestRectangleArea(heights):
stack = []
max_area = 0
heights.append(0) # Sentinel to flush stack at end
for i, h in enumerate(heights):
while stack and heights[stack[-1]] >= h:
height = heights[stack.pop()]
left = stack[-1] if stack else -1
width = i - left - 1
max_area = max(max_area, height * width)
stack.append(i)
heights.pop() # Restore original list
return max_area
medium
Solution
Step 1: Identify condition in while loop
The condition uses '>=' which causes bars of equal height to be popped prematurely, merging areas incorrectly.Step 2: Correct condition
Changing '>=' to '>' ensures bars of equal height remain on stack, preserving correct width calculations.Final Answer:
Option A -> Option AQuick Check:
Using '>=' pops equal height bars too early, causing wrong max area [OK]
Hint: Use '>' not '>=' to avoid premature popping [OK]
Common Mistakes:
- Using '>=' instead of '>' in while condition
- Miscomputing width boundaries
- Forgetting sentinel bar
3. What is the time complexity of the bitmask backtracking solution for the N-Queens problem, and why is it not simply O(n^n)?
medium
Solution
Step 1: Understand pruning effect on search space
Each queen placed reduces available columns, so permutations of columns are tried, not all combinations.Step 2: Recognize factorial complexity
Backtracking tries permutations of n columns for n rows, leading to O(n!) complexity, not exponential or polynomial.Final Answer:
Option C -> Option CQuick Check:
Pruning reduces search to permutations, not all subsets [OK]
Hint: N-Queens backtracking explores permutations -> O(n!) [OK]
Common Mistakes:
- Confusing subsets (2^n) with permutations (n!)
- Assuming polynomial due to board size
- Ignoring pruning effect
4. Suppose the LFU cache must support a new requirement: keys can be reinserted after eviction with their previous frequency preserved. Which modification to the brute force LFU cache implementation correctly supports this feature?
hard
Solution
Step 1: Understand reinsertion with preserved frequency
To preserve frequency on reinsertion, frequencies must be stored outside the cache entries so they survive eviction.Step 2: Update timestamps on reinsertion
When reinserting, update the timestamp to reflect recent access but keep the old frequency to maintain LFU semantics.Final Answer:
Option C -> Option CQuick Check:
Persistent frequency storage and timestamp update -> correct reinsertion behavior [OK]
Hint: Preserve frequency externally and update timestamp on reinsertion [OK]
Common Mistakes:
- Resetting frequency loses LFU property
- Ignoring frequency leads to incorrect eviction
- Not updating frequency on get breaks LFU semantics
5. Suppose the problem is modified so that words can be reused multiple times in pairs (i.e., pairs (i, j) where i == j are allowed). Which modification to the Trie-based solution correctly handles this variant without double counting pairs?
hard
Solution
Step 1: Understand reuse allowance
Allowing i == j pairs means removing the 'node.index != index' check to include self-pairs.Step 2: Avoid double counting
Removing the check causes duplicates; filtering duplicates after collecting results ensures correctness.Step 3: Evaluate other options
Keeping the check disallows self-pairs; storing multiple indices per node is unnecessary and complex.Final Answer:
Option A -> Option AQuick Check:
Removing check plus duplicate filtering correctly handles reuse [OK]
Hint: Allow self-pairs by removing check, then deduplicate results [OK]
Common Mistakes:
- Removing check without deduplication
- Keeping check and missing self-pairs
- Overcomplicating Trie nodes