dsa2 min read
Max Consecutive Ones III — Sliding Window with K Flips [Google, Meta Medium]
Find maximum consecutive ones if you can flip at most k zeros to one. Variable sliding window O(n) solution.
Read →
Medium
348 articles
dsa14 min read
3Sum — The Deduplication Problem Every FAANG Interviewer Loves [LC 15]
Learn why 3Sum is a FAANG interview staple — how sorting enables two pointers, why deduplication trips up even strong candidates, a full visual dry run, and every common bug explained with Python and JavaScript solutions.
Read →
dsa15 min read
Container With Most Water — Greedy Two-Pointer Proof [Google, Amazon, Meta]
LeetCode 11 explained from scratch: why this is a greedy problem, the formal proof that you must always move the shorter pointer, a full step-by-step dry run, common traps, and clean Python + JavaScript solutions. Master the pointer-elimination pattern that appears throughout FAANG interviews.
Read →
dsa15 min read
Product of Array Except Self — The Prefix × Suffix Trick That Google Loves
LeetCode 238 is one of the most frequently asked medium problems at Google and Meta. Learn why the no-division constraint is intentional, how the prefix × suffix insight unlocks the O(n) solution, and how a single running variable eliminates the extra O(n) space entirely.
Read →
dsa12 min read
Merge Intervals — The Definitive Guide (LeetCode 56) [Google, Meta, Amazon, Microsoft]
Master the classic Merge Intervals problem (LeetCode 56) asked at Google, Meta, Amazon, and Microsoft. Learn why sorting by start time is the key insight, the exact overlap condition (c ≤ b), a step-by-step visual dry run, 4 common mistakes, Python and JavaScript solutions, and follow-up problems including Insert Interval, Non-overlapping Intervals, and Meeting Rooms II.
Read →
dsa16 min read
Spiral Matrix — Boundary Shrinking Mastery [Google, Microsoft, Amazon]
Traverse an m×n matrix in spiral order. Master the boundary-shrinking technique — maintain top, bottom, left, right walls and peel layer by layer. Covers edge cases, visual dry run, common bugs, Python & JavaScript solutions, and follow-ups like Spiral Matrix II.
Read →
dsa13 min read
Group Anagrams — Hashmap Key Design Mastery [Amazon, Google, Meta]
Group strings that are anagrams of each other using two canonical approaches: sorted string key O(n·k·log k) and character frequency tuple key O(n·k). Understand when the difference matters, trace through a dry run, dodge the common traps, and leave any interview with both solutions ready to go.
Read →
dsa13 min read
Longest Substring Without Repeating Characters — Sliding Window [Google, Amazon, Meta]
Master LeetCode 3 — the canonical sliding window problem. Understand the "shrink from left" insight, the critical stale-index bug with max(), and both set-based and hashmap-optimized solutions in Python and JavaScript. Includes a full step-by-step dry run and follow-up problems LC 340 and LC 159.
Read →
dsa13 min read
Subarray Sum Equals K — Why Prefix Sum + HashMap Beats Everything [LC 560]
LeetCode 560 is one of the most-asked FAANG problems because it teaches the prefix sum + hashmap pattern — a technique that handles negative numbers, generalizes to a dozen follow-ups, and cannot be replaced by sliding window. Learn the insight, the dry run, the common mistakes, and the O(n) solution in Python and JavaScript.
Read →
dsa15 min read
Search in Rotated Sorted Array — The Binary Search Problem Every FAANG Interviewer Loves
LeetCode 33 is a rite of passage in FAANG interviews. Learn the one invariant that makes O(log n) possible on a rotated array, trace through a dry run, avoid the 4 most common bugs, and master the full family of follow-up problems (LC 81, LC 153, LC 154).
Read →
dsa14 min read
Jump Game — Greedy Max Reach O(n) Explained (The Definitive Guide) [Amazon, Google, Meta]
LeetCode 55 is a classic FAANG greedy problem that tests whether you can compress O(n²) DP thinking into a single O(n) pass. Learn the "max reachable index" insight, why greedy beats DP here, a full visual dry run, common traps, and every follow-up question interviewers ask next.
Read →
dsa21 min read
Rotate Array — Triple Reverse O(1) Space Deep Dive (Definitive Guide) [Microsoft, Amazon, Google]
LeetCode 189 looks trivial — until the interviewer asks for O(1) space. Learn why three distinct approaches exist, the mathematical reason triple-reverse works, every common pitfall (wrong k, direction confusion, off-by-one), a full visual dry run, and how this trick unlocks Rotate String, Rotate Image, and beyond.
Read →
dsa1 min read
Find Minimum in Rotated Sorted Array — Binary Search O(log n) [Google, Microsoft]
Find the minimum element in a rotated sorted array with no duplicates. Binary search: the minimum is in the unsorted half. O(log n) time O(1) space.
Read →
dsa23 min read
Top K Frequent Elements — Three Approaches from O(n log n) to O(n) [Google, Amazon, LinkedIn]
LeetCode 347 asks for k most frequent elements with a constraint: beat O(n log n). Learn why naive sort fails, how a min-heap of size k achieves O(n log k), and the elegant bucket sort insight that delivers true O(n) — with full visual dry run, common mistakes, and Python/JavaScript solutions for all three approaches.
Read →
dsa18 min read
Maximum Product Subarray — Why Kadane's Fails and How to Fix It [Google, Amazon, Microsoft]
LeetCode 152 looks like a simple extension of Maximum Sum Subarray — until you hit negative numbers. A negative times a negative is positive, which means the current minimum can instantly become the new maximum. Learn why tracking BOTH cur_max and cur_min is the essential insight, how zeros act as hard resets, the four bugs every candidate makes, and step-by-step dry runs on key examples. Python and JavaScript solutions from O(n²) brute force to the elegant O(n) DP approach.
Read →
dsa13 min read
Rotate Image 90° Clockwise — Transpose + Reverse, In-Place O(n²) [Amazon, Microsoft, Google]
Learn how to rotate an n×n matrix 90° clockwise in-place using the elegant transpose-then-reverse trick. Understand the math behind it, see the 4-cell direct rotation alternative, dry-run through a worked example, avoid the four most common mistakes, and get clean Python + JavaScript solutions.
Read →
dsa16 min read
Next Permutation [Medium] — The In-Place Algorithm That Trips Up Senior Engineers [Google, Facebook, Amazon]
Next Permutation is not just an array problem — it is a test of systematic algorithmic thinking under pressure. Learn why you scan from the right, why you swap with the smallest larger element, and why the suffix is reversed rather than sorted. Includes full visual dry runs, the 4 most common bugs, and Python + JavaScript solutions.
Read →
dsa18 min read
Find the Duplicate Number — Floyd's Cycle Detection Fully Explained [Google, Amazon Hard-Medium]
LeetCode 287 eliminates every naive approach through three hard constraints: no array modification, O(1) space, O(n) time. The solution — treating the array as an implicit linked list and running Floyd's tortoise-and-hare cycle detection — is one of the most elegant algorithm mappings in all of DSA. Full proof, visual dry run, Python and JavaScript solutions.
Read →
dsa14 min read
Sort Colors [Medium] — Dutch National Flag Algorithm Explained
Master Dijkstra's Dutch National Flag algorithm to sort 0s, 1s, and 2s in a single pass with O(1) space. Understand the three-pointer invariants, the critical bug most candidates make, and how this pattern unlocks a family of partition problems.
Read →
dsa2 min read
Insert Interval [Medium] — Sweep and Merge
Insert a new interval into a sorted non-overlapping list and merge any overlaps in a single sweep.
Read →
dsa2 min read
Non-overlapping Intervals [Medium] — Greedy Scheduling
Find the minimum number of intervals to remove so the rest are non-overlapping, using a greedy earliest-end-time strategy.
Read →
dsa2 min read
Combination Sum [Medium] — Backtracking with Pruning
Find all unique combinations that sum to a target, using backtracking with candidate reuse allowed.
Read →
dsa2 min read
Permutations [Medium] — Backtracking via Swap
Generate all permutations of distinct integers using in-place swap backtracking.
Read →
dsa2 min read
Subsets [Medium] — Backtracking & Bit Manipulation
Generate the power set of distinct integers using backtracking or bitmask enumeration.
Read →
dsa2 min read
Minimum Size Subarray Sum [Medium] — Sliding Window
Find the smallest contiguous subarray with sum >= target using the shrinkable sliding window technique.
Read →
dsa2 min read
Find All Duplicates in an Array [Medium] — Index as Hash
Find all integers that appear twice using index-sign-marking trick in O(n) time and O(1) extra space.
Read →
dsa2 min read
Decode String [Medium] — Stack-Based Expansion
Decode a run-length-encoded string like "3[a2[bc]]" = "abcbcabcbcabcbc" using a stack for nested brackets.
Read →
dsa2 min read
Combination Sum II [Medium] — Backtracking with Duplicate Skip
Find all unique combinations that sum to target where each number may be used once, skipping duplicates at each recursion level.
Read →
dsa2 min read
Word Search [Medium] — DFS Backtracking on Grid
Search for a word in a 2D grid using DFS backtracking with in-place visited marking.
Read →
dsa2 min read
Increasing Triplet Subsequence [Medium] — Greedy Two Trackers
Determine if there exists an increasing subsequence of length 3 using two greedy variables in O(n) time O(1) space.
Read →
dsa2 min read
4Sum [Medium] — Sort + Two Pointers
Find all unique quadruplets summing to target by extending the 3Sum pattern with an outer loop and duplicate skipping.
Read →
dsa2 min read
Jump Game II [Medium] — Greedy BFS-Level Jumps
Find minimum number of jumps to reach the last index using greedy BFS-style level tracking.
Read →
dsa2 min read
Gas Station [Medium] — Greedy Linear Scan
Determine the unique starting gas station for a circular route using a greedy one-pass algorithm.
Read →
dsa16 min read
Daily Temperatures [Medium] — Monotonic Stack Masterclass [Amazon, Google]
LeetCode 739 — Find the number of days until a warmer temperature for each day using a monotonic decreasing stack. The key insight: store indices, not temperatures, in the stack. When a warmer day arrives, it is the "next greater element" for every cooler day still waiting on the stack — a fundamental pattern that appears in at least six other LeetCode problems.
Read →
dsa13 min read
Longest Consecutive Sequence [Medium] — HashSet O(n) [Google, Amazon, Facebook]
LeetCode 128 — Find the longest consecutive integer sequence in O(n) using a HashSet. The trick: only start counting from numbers where num-1 is NOT in the set, so each element is visited at most twice total across the entire algorithm.
Read →
dsa2 min read
Partition Labels [Medium] — Greedy Last Occurrence
Partition a string into the maximum number of parts where each letter appears in at most one part, using last occurrence mapping.
Read →
dsa2 min read
Task Scheduler [Medium] — Greedy Frequency Buckets
Calculate minimum CPU intervals for tasks with cooldown using a greedy formula based on the most frequent task count.
Read →
dsa1 min read
Minimum Number of Arrows to Burst Balloons [Medium] — Greedy Intervals
Find the minimum arrows needed to burst all balloons arranged as intervals using a greedy sort-by-end approach.
Read →
dsa1 min read
Maximum Swap [Medium] — Rightmost Digit Tracking
Maximize a number by making at most one swap, using a last-occurrence map to find the optimal swap greedily.
Read →
dsa1 min read
Find Peak Element [Medium] — Binary Search on Slope
Find a peak element in O(log n) by binary searching on the slope direction — always move toward the higher neighbor.
Read →
dsa1 min read
Missing Number [Medium] — Math Sum / XOR Trick
Find the missing number in [0..n] using the Gauss sum formula or XOR in O(n) time O(1) space.
Read →
dsa2 min read
Majority Element II [Medium] — Extended Boyer-Moore Voting
Find all elements appearing more than n/3 times using Extended Boyer-Moore Voting with two candidate trackers.
Read →
dsa1 min read
Wiggle Sort II [Medium] — Virtual Index Mapping
Rearrange an array so nums[0] `<` nums[1] > nums[2] `<` nums[3]... using virtual index mapping and nth_element for O(n) time.
Read →
dsa1 min read
Minimum Moves to Equal Array Elements II [Medium] — Median Target
Find the minimum total moves to make all array elements equal by targeting the median value.
Read →
dsa1 min read
Array Nesting [Medium] — Cycle Length Tracking
Find the longest nested set S(k) in a permutation array by tracing cycles with visited marking in O(n) time.
Read →
dsa2 min read
Advantage Shuffle [Medium] — Greedy Strongest Beat Weakest
Rearrange nums to maximize advantage over B using a greedy strategy: assign the smallest winning card, else discard the smallest.
Read →
dsa1 min read
Subsets II [Medium] — Backtracking with Duplicate Skip
Generate all unique subsets from an array with duplicates by sorting and skipping repeated elements at each recursion level.
Read →
dsa1 min read
Repeated String Match [Medium] — Minimum Repetitions
Find the minimum times A must repeat so that B is a substring, using a tight bound on the number of repeats needed.
Read →
dsa1 min read
Longest Subarray of 1s After Deleting One Element [Medium] — Sliding Window
Find the longest subarray of 1s after deleting exactly one element using a sliding window that tracks the count of zeros.
Read →
dsa1 min read
Shortest Unsorted Continuous Subarray [Medium] — Linear Scan
Find the shortest subarray that when sorted makes the whole array sorted, using a single linear scan tracking violated boundaries.
Read →
dsa1 min read
Number of Subarrays with Bounded Maximum [Medium] — Counting Pattern
Count subarrays where max element is in [L,R] using a clever counting formula with two linear scans.
Read →
dsa1 min read
Minimum Domino Rotations For Equal Row [Medium] — Greedy Check
Find the minimum rotations to make all tops or bottoms equal by checking if a target value (from first domino) can unify the entire row.
Read →
dsa1 min read
Find First and Last Position — Dual Left/Right Boundary
Find the starting and ending positions of a target in a sorted array using two separate binary searches.
Read →
dsa2 min read
Search in Rotated Sorted Array — Half-Sorted Check
Search in a rotated sorted array by identifying which half is sorted and narrowing accordingly.
Read →
dsa1 min read
Find Minimum in Rotated Sorted Array — Left Boundary on Rotation
Find the minimum element in a rotated sorted array by comparing mid with right boundary to locate the rotation point.
Read →
dsa1 min read
Search a 2D Matrix — Treat as 1D Sorted Array
Search a row-column sorted 2D matrix in O(log(m*n)) by treating it as a virtual 1D sorted array.
Read →
dsa1 min read
Koko Eating Bananas — Binary Search on Answer (Speed)
Find the minimum eating speed for Koko to finish all bananas in h hours using binary search on the answer space.
Read →
dsa1 min read
Capacity to Ship Packages Within D Days — BS on Answer
Find the minimum ship capacity to ship all packages within d days using binary search on capacity.
Read →
dsa1 min read
Find Peak Element — Binary Search on Slope
Find any peak element in O(log n) by always moving toward the uphill neighbor, which guarantees finding a peak.
Read →
dsa1 min read
Find K Closest Elements — BS on Left Window Boundary
Find the k closest elements to x in a sorted array by binary searching for the optimal left window boundary.
Read →
dsa1 min read
Single Element in a Sorted Array — Parity Index Binary Search
Find the single non-duplicate element in O(log n) by observing that pairs shift the parity of indices after the singleton.
Read →
dsa1 min read
Longest Increasing Subsequence — Patience Sort Binary Search
Find the length of LIS in O(n log n) using patience sorting: binary search to maintain a sorted tails array.
Read →
dsa1 min read
Split Array Largest Sum — Binary Search on Answer
Minimize the largest subarray sum when splitting into k parts using binary search on the possible answer range.
Read →
dsa1 min read
Search in Rotated Sorted Array II — Handle Duplicates
Search in a rotated sorted array that may contain duplicates by skipping lo++ when mid equals both boundaries.
Read →
dsa1 min read
Minimum Number of Days to Make m Bouquets — BS on Answer
Find the minimum day to make m bouquets of k adjacent flowers using binary search on the day value.
Read →
dsa1 min read
H-Index II — Binary Search on Sorted Citations
Find h-index from a sorted citations array in O(log n) using left-boundary binary search.
Read →
dsa1 min read
Successful Pairs of Spells and Potions — Sort + Binary Search
Count spell-potion pairs with product >= success by sorting potions and binary searching for each spell's threshold.
Read →
dsa1 min read
Kth Smallest Element in a Sorted Matrix — Binary Search on Value
Find the kth smallest element in a row-column sorted matrix by binary searching on the value range.
Read →
dsa1 min read
Magnetic Force Between Two Balls — BS on Minimum Distance
Maximize the minimum distance between m balls in baskets using binary search on the answer (minimum distance).
Read →
dsa1 min read
Minimize the Maximum of Subarrays After Splits — BS on Answer
Minimize the maximum value after performing k operations (average adjacent elements) using binary search on the answer.
Read →
dsa1 min read
Maximum Value at Given Index — Binary Search on Peak Value
Maximize nums[index] given array length n, sum constraint maxSum, and each element >= 1 using binary search on the peak value.
Read →
dsa1 min read
Missing Element in Sorted Array — Binary Search on Missing Count
Find the kth missing number in a sorted array by binary searching on the number of missing elements up to each index.
Read →
dsa1 min read
Search a 2D Matrix II — Staircase Search O(m+n)
Search a row-column sorted 2D matrix in O(m+n) using the staircase technique from top-right corner.
Read →
dsa1 min read
Find Smallest Letter Greater Than Target — Circular Binary Search
Find the smallest letter in a circular sorted list that is greater than the target using left-boundary binary search.
Read →
dsa1 min read
Online Election — Precompute Leader + Binary Search
Answer election queries for who is leading at time t by precomputing the leader at each vote and binary searching.
Read →
dsa1 min read
Find the Duplicate Number — Binary Search on Count
Find the duplicate in array of n+1 integers in [1,n] using binary search on value with count-of-smaller logic.
Read →
dsa1 min read
Time Based Key-Value Store — Binary Search on Timestamps
Implement get(key, timestamp) using binary search on stored sorted timestamps for O(log n) retrieval.
Read →
dsa1 min read
Maximum Number of Events Attended — Greedy + Binary Search
Maximize events attended by greedily attending the event with the earliest end date each day using binary search.
Read →
dsa1 min read
Minimum Speed to Arrive on Time — BS on Train Speed
Find the minimum train speed to arrive on time given n rides (last ride doesn't wait) using binary search on speed.
Read →
dsa1 min read
Single Number II — 3-State Bit Counting
Every element appears 3 times except one. Track bit counts mod 3: ones and twos bitmasks, or count each bit position.
Read →
dsa1 min read
Single Number III — XOR Partition
Two numbers appear once, rest appear twice. XOR all to get a^b, then use any set bit to partition numbers into two groups.
Read →
dsa1 min read
Sum of Two Integers — Bit Addition
Add two integers without + or - operators. Simulate: sum = a XOR b (no carry), carry = (a AND b) << 1. Repeat until carry = 0.
Read →
dsa1 min read
Subsets — Bitmask Enumeration
Generate all subsets of an array. Each subset corresponds to a bitmask of n bits where bit i = 1 means element i is included.
Read →
dsa1 min read
Partition to K Equal Sum Subsets — Bitmask DP
Can array be partitioned into k equal-sum subsets? Bitmask DP: dp[mask] = sum filled so far. O(2^n * n) instead of O(k^n) DFS.
Read →
dsa1 min read
Total Hamming Distance — Bit Position Analysis
Sum of Hamming distances between all pairs. For each bit position, count 0s and 1s: contribution = count_0 * count_1.
Read →
dsa1 min read
Bitwise AND of Numbers Range — Common Prefix
AND of all numbers in [left, right]. Result is the common prefix of left and right: keep shifting right until equal, then shift back.
Read →
dsa1 min read
Gray Code — Binary XOR Construction
Generate n-bit Gray code sequence where adjacent codes differ by exactly 1 bit. Formula: gray(i) = i ^ (i >> 1).
Read →
dsa1 min read
Repeated DNA Sequences — Rolling Hash
Find all 10-letter DNA sequences that appear more than once. Use rolling hash (4-bit per char) or set of seen substrings.
Read →
dsa1 min read
Maximum Product of Word Lengths — Bitmask Intersection
Find max product of lengths of two words with no common letters. Encode each word as bitmask; two words share letters if AND != 0.
Read →
dsa1 min read
House Robber — Skip Adjacent DP
Maximize amount robbed without robbing adjacent houses. Classic skip-one DP: dp[i] = max(dp[i-1], dp[i-2] + nums[i]).
Read →
dsa1 min read
House Robber II — Circular Array DP
Houses arranged in a circle: first and last are adjacent. Run linear House Robber twice: once excluding last house, once excluding first.
Read →
dsa1 min read
Delete and Earn — House Robber on Frequency Array
Picking value k deletes all k-1 and k+1 elements. Map to House Robber: earn[k] = k * count(k), then max non-adjacent sum.
Read →
dsa1 min read
Maximum Product Subarray — Kadane with Min/Max
Find maximum product of a contiguous subarray. Track both min and max at each position because a negative * negative becomes positive.
Read →
dsa2 min read
Coin Change — Unbounded Knapsack DP
Find minimum coins to make amount. Unbounded knapsack DP: dp[amount] = min(dp[amount-coin]+1) over all coins. Bottom-up from 0 to amount.
Read →
dsa1 min read
Coin Change II — Count Ways Unbounded Knapsack
Count number of combinations making up amount. Process each coin denomination completely (outer loop = coin) to avoid counting permutations.
Read →
dsa1 min read
Perfect Squares — Coin Change with Squares
Minimum perfect squares summing to n. Isomorphic to Coin Change where coins = all perfect squares ≤ n.
Read →
dsa1 min read
Jump Game — Greedy Reachability
Check if you can reach the last index. Greedy: track furthest reachable index. If current position > reach, stuck.
Read →
dsa1 min read
Jump Game II — Minimum Jumps Greedy
Find minimum jumps to reach the last index. Greedy: at each jump boundary, extend to the farthest reachable position.
Read →
dsa1 min read
Decode Ways — Counting DP
Count ways to decode a digit string as letters (A=1,...,Z=26). DP: single digit + valid double digit transitions.
Read →
dsa1 min read
Word Break — Reachability DP
Check if string can be segmented into dictionary words. DP: dp[i]=true if some dp[j] is true and s[j:i] is in wordDict.
Read →
dsa2 min read
Longest Increasing Subsequence — O(n log n) Patience Sorting
Find the length of the longest strictly increasing subsequence. O(n²) DP or O(n log n) patience sorting with binary search.
Read →
dsa1 min read
Palindromic Substrings — Expand Around Center
Count palindromic substrings. Expand around each center (n odd-length + n-1 even-length centers), count valid expansions.
Read →
dsa1 min read
Longest Palindromic Subsequence — 2D DP
Find longest palindromic subsequence length. 2D DP: if s[i]==s[j], dp[i][j] = dp[i+1][j-1]+2, else max of neighbors. Fill diagonally.
Read →
dsa2 min read
Partition Equal Subset Sum — 0/1 Knapsack
Can array be partitioned into two equal-sum subsets? 0/1 knapsack: can we pick some numbers summing to total/2? Bitset or DP boolean array.
Read →
dsa1 min read
Target Sum — DP Count Ways
Assign + or - to each number to reach target sum. DP counts ways to reach each sum. Reduces to 0/1 knapsack subset sum count.
Read →
dsa1 min read
Longest Common Subsequence — 2D DP Preview
LCS of two strings: dp[i][j] = LCS of first i chars of s1 and first j chars of s2. Full 2D DP treatment in the 2D DP section.
Read →
dsa1 min read
Unique Paths — Grid Path Count DP
Count paths from top-left to bottom-right moving only right or down. dp[i][j] = dp[i-1][j] + dp[i][j-1]. Math formula O(1) also works.
Read →
dsa1 min read
Unique Paths II — Grid with Obstacles
Count paths avoiding obstacle cells. Same DP but obstacles block cell (dp[i][j]=0) and obstacle at start/end returns 0.
Read →
dsa1 min read
Minimum Path Sum — Grid DP
Find minimum cost path from top-left to bottom-right moving right or down. dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1]).
Read →
dsa1 min read
Triangle — Bottom-Up 1D DP
Minimum path sum from top to bottom of triangle. Bottom-up DP: dp[j] = triangle[i][j] + min(dp[j], dp[j+1]).
Read →
dsa1 min read
Longest Common Subsequence — LCS 2D DP
Classic LCS: dp[i][j] = LCS length of s1[:i] and s2[:j]. If chars match add 1 to diagonal; else take max of skip either string.
Read →
dsa1 min read
Best Time Buy/Sell Stock II — Unlimited Transactions
Maximize profit with unlimited buy-sell transactions (but hold at most 1 share). Greedy: collect every upward slope.
Read →
dsa1 min read
Best Time Buy/Sell Stock Cooldown — State DP
Unlimited transactions with 1-day cooldown after selling. 3-state DP: hold, sold (cooldown), rest.
Read →
dsa1 min read
Best Time Buy/Sell Stock With Fee — State DP
Unlimited transactions with transaction fee per sell. 2-state DP: cash (not holding) and hold (holding stock).
Read →
dsa1 min read
Interleaving String — 2D DP
Check if s3 is formed by interleaving s1 and s2. dp[i][j] = can s3[:i+j] be formed from s1[:i] and s2[:j].
Read →
dsa1 min read
Ones and Zeroes — 2D 0/1 Knapsack
Find maximum strings using at most m zeros and n ones. 2D 0/1 knapsack: dp[i][j] = max strings using i zeros and j ones.
Read →
dsa1 min read
Minimum Falling Path Sum — Grid DP
Find minimum sum falling path from top row to bottom row, moving to adjacent diagonal cells. DP row by row.
Read →
dsa1 min read
Non-overlapping Intervals — Interval Scheduling
Minimum removals to make intervals non-overlapping. Sort by end time; greedily keep earliest-ending intervals, count conflicts.
Read →
dsa1 min read
Minimum Number of Arrows to Burst Balloons
Find minimum arrows to burst all balloons (intervals). Sort by end; one arrow can burst all overlapping intervals. Count arrows needed.
Read →
dsa1 min read
Gas Station — Greedy Circular
Find starting gas station index to complete circular route. If total gas >= total cost, a solution exists. Track running balance; reset start when negative.
Read →
dsa1 min read
Daily Temperatures — Monotonic Stack Waiting Days
For each day find how many days until a warmer temperature. Monotonic decreasing stack of indices; pop when warmer temperature found.
Read →
dsa1 min read
Remove Duplicate Letters — Greedy Monotonic Stack
Remove duplicates to get smallest lexicographic subsequence with all chars. Greedy: use monotonic stack, only pop if char appears later.
Read →
dsa1 min read
Remove K Digits — Greedy Monotonic Stack
Remove k digits to get smallest number. Monotonic increasing stack: pop larger digits when they appear before a smaller one. Remove remaining from end.
Read →
dsa1 min read
Sum of Subarray Minimums — Monotonic Stack Contribution
Sum of minimums of all subarrays. For each element, count how many subarrays have it as minimum using previous/next smaller element positions.
Read →
dsa1 min read
Maximum Width Ramp — Monotonic Stack + Two Pass
Find max j-i where i<j and nums[i]<=nums[j]. Build decreasing monotonic stack for left candidates, then scan from right to match.
Read →
dsa1 min read
132 Pattern — Monotonic Stack from Right
Find i<j<k where nums[i]<nums[k]<nums[j]. Scan right-to-left with decreasing stack; track max popped element as potential 'nums[k]' candidate.
Read →
dsa1 min read
Next Greater Element II — Circular Monotonic Stack
Next greater element in circular array. Iterate twice (2n) but use index mod n. Same decreasing stack pattern.
Read →
dsa1 min read
Minimum Cost to Connect Sticks — Min-Heap Greedy
Minimum cost to connect all sticks. Always connect the two cheapest (Huffman coding variant). Min-heap greedy: cost = sum of merged sticks each round.
Read →
dsa1 min read
Partition Labels — Greedy Interval Merge
Partition string so each letter appears in at most one part. Track last occurrence of each char; greedily extend current partition end.
Read →
dsa1 min read
Queue Reconstruction by Height — Greedy Sort + Insert
Reconstruct queue where [h,k] means person of height h has k taller/equal people in front. Sort by height desc (then k asc), insert at index k.
Read →
dsa1 min read
Jump Game VI — Greedy + Monotonic Deque
Maximum score to reach end where each jump is 1..k steps. Monotonic deque (sliding window maximum) of DP values for O(n) solution.
Read →
dsa1 min read
Max Chunks to Make Sorted — Greedy Max Tracking
Find max chunks of array that when sorted individually give fully sorted array. A chunk boundary exists when max(chunk so far) == current index.
Read →
dsa1 min read
Find Duplicate File in System [Medium] — Content HashMap
Find all groups of duplicate files by parsing path strings and grouping files by their content using a HashMap.
Read →
dsa1 min read
Group Anagrams [Medium] — Sorted Key HashMap
Group strings that are anagrams together by using their sorted form as a HashMap key.
Read →
dsa2 min read
Top K Frequent Elements [Medium] — Bucket Sort O(n)
Find the k most frequent elements in O(n) using bucket sort by frequency instead of a heap.
Read →
dsa2 min read
LRU Cache [Medium] — Doubly Linked List + HashMap
Design a Least Recently Used cache with O(1) get and put operations using a HashMap combined with a doubly linked list.
Read →
dsa1 min read
Subarray Sum Equals K [Medium] — Prefix Sum HashMap
Count subarrays with sum exactly k using prefix sums stored in a HashMap to find valid starting positions in O(n).
Read →
dsa1 min read
Continuous Subarray Sum [Medium] — Prefix Modulo Map
Check if a continuous subarray of length >= 2 sums to a multiple of k using prefix sum modulo k with a HashMap.
Read →
dsa1 min read
Longest Consecutive Sequence [Medium] — HashSet O(n)
Find the longest consecutive integer sequence in O(n) by using a HashSet and only starting sequences from their minimum element.
Read →
dsa2 min read
Insert Delete GetRandom O(1) [Medium] — Array + HashMap Design
Design a set with O(1) insert, delete, and getRandom using a dynamic array combined with a HashMap for index tracking.
Read →
dsa2 min read
Find All Anagrams in a String [Medium] — Fixed Window + Freq Match
Find all starting indices of anagram substrings by using a fixed window with character frequency comparison.
Read →
dsa1 min read
Random Pick with Weight [Medium] — Prefix Sum + Binary Search
Implement weighted random selection by building a prefix sum array and using binary search to find the sampled index.
Read →
dsa1 min read
Brick Wall [Medium] — Gap Position Frequency Map
Find the vertical line that crosses the fewest bricks by counting the most frequent gap position using a HashMap.
Read →
dsa2 min read
Count Wonderful Substrings — Bitmask + Prefix XOR Map
Count substrings with at most one odd-frequency letter using bitmask prefix XOR and a hash map.
Read →
dsa2 min read
Equal Row and Column Pairs — Hash Tuple Rows and Columns
Count (row, col) pairs that are equal by hashing each row tuple and each column tuple.
Read →
dsa2 min read
Two Sum IV - BST — Hash Set + In-Order Traversal
Find if a BST contains two nodes summing to target using a hash set during DFS traversal.
Read →
dsa2 min read
Longest Arithmetic Subsequence — DP + Hash Map per Index
Find the longest arithmetic subsequence using dp[i][diff] = length ending at index i with given difference.
Read →
dsa2 min read
Count Bad Pairs — Complement Counting with HashMap
Count pairs (i,j) where j-i != nums[j]-nums[i] by counting good pairs via frequency map of nums[i]-i.
Read →
dsa2 min read
Make Sum Divisible by P — Prefix Mod + HashMap
Find the smallest subarray to remove so the remaining sum is divisible by p using prefix modular arithmetic.
Read →
dsa2 min read
Tuple with Same Product — Product Frequency Map
Count tuples (a,b,c,d) where a*b=c*d by counting pairs with each product using a frequency map.
Read →
dsa2 min read
Encode and Decode TinyURL — HashMap Bidirectional Mapping
Design a URL shortener using two hash maps for O(1) encode and decode operations.
Read →
dsa2 min read
Fraction to Recurring Decimal — Remainder Tracking HashMap
Convert a fraction to decimal string with recurring part detected via remainder position tracking.
Read →
dsa1 min read
Find Duplicate Subtrees — Serialize + HashMap
Find all duplicate subtrees by serializing each subtree and tracking serialization counts in a hash map.
Read →
dsa2 min read
Design HashMap — Chaining with Linked Lists
Implement a hash map from scratch using an array of buckets with chaining for collision resolution.
Read →
dsa2 min read
Design HashSet — Bit Array or Chaining Approach
Implement a hash set from scratch supporting add, remove, and contains in O(1) average time.
Read →
dsa2 min read
Random Pick Index — Reservoir Sampling
Pick a random index of a target value with equal probability using reservoir sampling over the array.
Read →
dsa1 min read
Most Common Word — Normalize + Frequency Map
Find the most common word not in a banned list by normalizing input and using a frequency counter.
Read →
dsa2 min read
Hand of Straights — Greedy with Ordered Frequency Map
Determine if cards can be rearranged into consecutive groups of size groupSize using a sorted frequency map.
Read →
dsa1 min read
Subarray Sum Divisible by K — Prefix Mod HashMap
Count subarrays with sum divisible by k using prefix mod frequencies and the complement map pattern.
Read →
dsa2 min read
Count Good Meals — Power-of-Two Complement HashMap
Count pairs summing to a power of 2 by checking all 22 powers-of-2 against a running frequency map.
Read →
dsa2 min read
Time Based Key-Value Store — HashMap + Binary Search
Design a time-stamped key-value store supporting set and get(key, timestamp) using binary search on sorted timestamps.
Read →
dsa2 min read
4Sum II — Two-Map Split and Match
Count 4-tuples summing to zero by splitting into two pairs and using a frequency map of pair sums.
Read →
dsa3 min read
Find K Closest Elements
Find K closest elements to x in a sorted array using binary search to find the optimal left boundary.
Read →
dsa2 min read
Kth Largest Element in an Array
Find the Kth largest element using quickselect O(n) average or a min-heap of size K in O(n log k).
Read →
dsa2 min read
Top K Frequent Elements
Return the K most frequent elements using a frequency map plus min-heap, or bucket sort for O(n) solution.
Read →
dsa1 min read
Sort Characters By Frequency
Sort characters in a string by decreasing frequency using a frequency counter and max-heap or bucket sort.
Read →
dsa2 min read
K Closest Points to Origin
Find K points closest to the origin using a max-heap of size K or quickselect for O(n) average.
Read →
dsa2 min read
Task Scheduler
Find minimum CPU intervals to schedule tasks with cooldown using a greedy max-heap simulation.
Read →
dsa3 min read
Reorganize String
Rearrange a string so no two adjacent characters are the same using a greedy max-heap approach.
Read →
dsa3 min read
Kth Smallest Element in a Sorted Matrix
Find the Kth smallest element in an n×n row-and-column sorted matrix using binary search on value range or heap.
Read →
dsa2 min read
Find K Pairs with Smallest Sums
Find K pairs (u, v) with smallest sums from two sorted arrays using a min-heap initialized with first row candidates.
Read →
dsa2 min read
Ugly Number II
Find the nth ugly number (only prime factors 2, 3, 5) using three pointers for the 2x, 3x, 5x merge streams.
Read →
dsa2 min read
Meeting Rooms II
Find minimum conference rooms required by tracking room end times with a min-heap of ongoing meeting endings.
Read →
dsa2 min read
Minimum Cost to Connect Sticks
Find minimum cost to connect all sticks by greedily always merging the two shortest sticks first.
Read →
dsa2 min read
Car Pooling
Check if a car can pick up all passengers by processing start/end events with a sorted timeline or heap.
Read →
dsa2 min read
Furthest Building You Can Reach
Greedily use ladders for the largest climbs and bricks for smaller gaps, managed with a min-heap of ladder sizes.
Read →
dsa3 min read
Process Tasks Using Servers
Assign tasks to available servers using two heaps: one for free servers and one for busy servers sorted by free time.
Read →
dsa2 min read
Super Ugly Number
Find the nth super ugly number with prime factors only from a given list using K-pointer dynamic programming.
Read →
dsa3 min read
Design Twitter
Design a simplified Twitter with follow/unfollow and a news feed showing the 10 most recent tweets from followed users.
Read →
dsa2 min read
Ugly Number III
Find the nth number divisible by a, b, or c using binary search with inclusion-exclusion counting formula.
Read →
dsa2 min read
Longest Happy String
Build the longest string with at most 2 consecutive identical characters by always using the most frequent available character.
Read →
dsa1 min read
Find Right Interval
For each interval find the interval with the smallest start point >= the end point using sorted starts and binary search.
Read →
dsa1 min read
Kth Largest Sum in a Binary Tree
Find the kth largest level sum in a binary tree using BFS to compute level sums then sorting or using a heap.
Read →
dsa2 min read
Total Cost to Hire K Workers
Minimize total hiring cost by always choosing the cheapest candidate from the first or last p candidates using two min-heaps.
Read →
dsa1 min read
Seat Reservation Manager
Design a seat manager that reserves the lowest numbered available seat and unreserves seats using a min-heap.
Read →
dsa1 min read
Stock Price Fluctuation
Track stock prices with corrections by maintaining a sorted multiset and a timestamp-to-price map.
Read →
dsa1 min read
Reduce Array Size to At Least Half
Find the minimum number of elements to remove to reduce array size by half by greedily removing most frequent elements.
Read →
dsa1 min read
Remove Nth Node From End of List — Fast/Slow with Dummy
Remove the nth node from the end in one pass using two pointers offset by n steps and a dummy head.
Read →
dsa1 min read
Swap Nodes in Pairs — In-Place Pointer Rewiring
Swap every two adjacent nodes in a linked list without modifying node values using pointer rewiring.
Read →
dsa1 min read
Odd Even Linked List — Two Chain In-Place
Group all odd-indexed nodes before even-indexed nodes in O(n) time and O(1) space using two pointer chains.
Read →
dsa2 min read
Rotate List — Find Length and Reconnect
Rotate a linked list to the right by k places by finding length, computing effective rotation, and rewiring.
Read →
dsa1 min read
Reorder List — Split, Reverse, Merge
Reorder a linked list into L0→Ln→L1→Ln-1 pattern by splitting at middle, reversing second half, then merging.
Read →
dsa1 min read
Add Two Numbers — Simulate Carry with Dummy Head
Add two numbers represented as reversed linked lists by simulating digit addition with carry propagation.
Read →
dsa2 min read
Add Two Numbers II — Stack to Handle Forward Order
Add two numbers given in forward order by pushing digits to stacks, then building the result list in reverse.
Read →
dsa1 min read
Partition List — Two Dummy Head Chains
Partition a linked list around value x into less-than and greater-than-or-equal chains, then join them.
Read →
dsa2 min read
Sort List — Top-Down Merge Sort
Sort a linked list in O(n log n) time and O(log n) space using top-down merge sort with fast/slow split.
Read →
dsa1 min read
Remove All Duplicates from Sorted List II — Dummy + Skip
Remove all nodes that have duplicate numbers from a sorted linked list using a dummy head and skip logic.
Read →
dsa2 min read
Copy List with Random Pointer — HashMap or Interleave
Deep copy a linked list with random pointers using either a hash map or the O(1) space interleave technique.
Read →
dsa2 min read
Flatten Multilevel Doubly Linked List — DFS Stack
Flatten a multilevel doubly linked list by inserting child sub-lists inline using DFS or an explicit stack.
Read →
dsa2 min read
Linked List Cycle II — Floyd's Cycle Start Detection
Find the node where a cycle begins using Floyd's algorithm: detect meeting point, then reset one pointer to head.
Read →
dsa1 min read
Find the Duplicate Number — Floyd's on Array as Linked List
Find the duplicate in an array of n+1 integers in O(1) space by treating indices as a linked list with Floyd's cycle detection.
Read →
dsa1 min read
Next Greater Node in Linked List — Monotonic Stack
Find the next greater value for each node in a linked list using a monotonic decreasing stack of indices.
Read →
dsa1 min read
Design Linked List — Sentinel Doubly Linked List
Implement a doubly linked list with sentinel head and tail nodes for clean O(1) insertions and deletions.
Read →
dsa1 min read
Swapping Nodes in a Linked List — Find Kth from Front and Back
Swap the kth node from the front with the kth node from the end by finding both with two pointers.
Read →
dsa1 min read
Remove Zero Sum Consecutive Nodes — Prefix Sum Map
Remove consecutive nodes that sum to zero by tracking prefix sums in a map and relinking past zero-sum runs.
Read →
dsa2 min read
Split Linked List in Parts — Even Distribution
Split a linked list into k consecutive parts as evenly as possible, front parts get the extra nodes.
Read →
dsa2 min read
Reverse Linked List II — In-Place Partial Reversal
Reverse the portion of a linked list between positions left and right in one pass using careful pointer manipulation.
Read →
dsa2 min read
Maximum Twin Sum of a Linked List — Split and Reverse
Find the maximum sum of twin nodes (node i + node n-1-i) by reversing the second half and comparing pairs.
Read →
dsa1 min read
Merge Nodes In Between Zeros — Pointer Walk
Merge all nodes between 0s into a single node with their sum, modifying the list in-place.
Read →
dsa1 min read
Delete the Middle Node — Fast/Slow with Prev Pointer
Delete the middle node of a linked list using a prev-pointer variant of the fast/slow technique.
Read →
dsa2 min read
Reverse Nodes in Even-Length Groups — Group Counting
Reverse nodes in each even-length group of a linked list by counting group sizes and selectively reversing.
Read →
dsa2 min read
Insert into a Sorted Circular List — Pointer Scan
Insert a value into a sorted circular linked list by finding the correct position with careful edge case handling.
Read →
dsa1 min read
Linked List Components — HashSet Membership Check
Count the number of connected components of a linked list that consist of nodes in a given set.
Read →
dsa2 min read
Flatten Binary Tree to Linked List — Morris Traversal
Flatten a binary tree in-place into a linked list following pre-order using the Morris traversal approach.
Read →
dsa1 min read
Convert Sorted List to BST — Fast/Slow + Recursion
Convert a sorted linked list to a height-balanced BST by repeatedly finding the middle node as root.
Read →
dsa1 min read
Range Sum Query Mutable — BIT / Segment Tree
Support point updates and range sum queries. BIT (Fenwick Tree) gives O(log n) both operations with elegant implementation.
Read →
dsa1 min read
My Calendar I — Sorted Dict / Segment Tree
Book events without double-booking. Use sorted dictionary to find previous and next events; check overlap with both.
Read →
dsa1 min read
Number of Longest Increasing Subsequences — DP + BIT
Count all LIS of maximum length. DP: track length and count. Segment tree on values enables O(n log n) solution.
Read →
dsa1 min read
Shifting Letters II — Difference Array
Apply range shift operations to letters. Difference array: mark +1 at start and -1 at end+1, prefix sum gives net shift at each position.
Read →
dsa1 min read
Range Sum Query 2D Immutable — 2D Prefix Sum
Sum of rectangle region. Precompute 2D prefix sums: prefix[i][j] = sum of all cells from (0,0) to (i-1,j-1). Inclusion-exclusion for query.
Read →
dsa1 min read
Longest Subarray with Sum ≤ K — Monotonic Queue + Prefix
Find longest subarray with sum <= k. Build prefix sums, use monotonic deque for decreasing prefix sums to efficiently find left boundaries.
Read →
dsa1 min read
Product of Array Except Self — Prefix + Suffix Products
For each element compute product of all other elements. Two-pass: left prefix products then multiply with right suffix products.
Read →
dsa2 min read
Daily Temperatures — Monotonic Decreasing Stack
Find how many days until a warmer temperature using a monotonic decreasing stack of unresolved day indices.
Read →
dsa1 min read
Next Greater Element I — Monotonic Stack with HashMap
Find the next greater element for each query in O(n+m) using a monotonic stack on nums2 and a lookup map.
Read →
dsa1 min read
Next Greater Element II — Circular Array Monotonic Stack
Find the next greater element in a circular array by iterating twice (0 to 2n) and using a monotonic stack.
Read →
dsa1 min read
Online Stock Span — Monotonic Stack with Accumulated Span
Calculate the stock price span (consecutive days <= today) using a monotonic stack that accumulates spans.
Read →
dsa2 min read
Remove K Digits — Monotonic Increasing Stack
Remove k digits to form the smallest number by maintaining a monotonic increasing stack and greedy removal.
Read →
dsa2 min read
Decode String — Stack for Counts and Strings
Decode a string with nested encodings like 3[a2[bc]] using two stacks: one for counts and one for partial strings.
Read →
dsa1 min read
Evaluate Reverse Polish Notation — Operand Stack
Evaluate an RPN expression by pushing numbers and applying operators to the top two stack elements.
Read →
dsa2 min read
Sliding Window Maximum — Monotonic Deque
Find the maximum in each sliding window of size k using a monotonic decreasing deque storing indices.
Read →
dsa1 min read
Asteroid Collision — Stack Simulation
Simulate asteroid collisions using a stack where right-moving asteroids wait and left-moving ones destroy smaller ones.
Read →
dsa2 min read
Sum of Subarray Minimums — Monotonic Stack with Contribution
Sum the minimums of all subarrays by computing each element's contribution as the minimum using previous and next smaller element spans.
Read →
dsa1 min read
Score of Parentheses — Stack Depth Doubling
Calculate the score of balanced parentheses where () = 1 and AB = A+B and (A) = 2*A using a stack depth trick.
Read →
dsa1 min read
Task Scheduler — Greedy with Most Frequent First
Find the minimum intervals to execute all tasks with cooldown n by greedily scheduling the most frequent task first.
Read →
dsa1 min read
Rotting Oranges — Multi-Source BFS
Find minutes until all oranges rot using multi-source BFS starting from all initially rotten oranges simultaneously.
Read →
dsa1 min read
Number of Islands — BFS or DFS Flood Fill
Count islands in a 2D grid using BFS or DFS to flood-fill connected land cells, marking them visited.
Read →
dsa1 min read
Course Schedule — Topological Sort BFS (Kahns Algorithm)
Detect if all courses can be finished (no cycle) using Kahn's algorithm: BFS on in-degree zero nodes.
Read →
dsa1 min read
Course Schedule II — Topological Order via BFS
Return a valid course order using Kahn's BFS topological sort, or empty array if a cycle exists.
Read →
dsa2 min read
Word Ladder — BFS Shortest Transformation Path
Find the shortest word transformation sequence using BFS where each step changes exactly one character.
Read →
dsa1 min read
Basic Calculator II — Stack with Operator Precedence
Evaluate a string expression with +, -, *, / using a stack that handles operator precedence without parentheses.
Read →
dsa1 min read
132 Pattern — Monotonic Stack from Right
Detect a 132 pattern (i < j < k, nums[i] < nums[k] < nums[j]) using a monotonic stack scanning right to left.
Read →
dsa1 min read
Number of Visible People in Queue — Monotonic Stack
Count visible people in a queue for each person using a monotonic decreasing stack scanning right to left.
Read →
dsa1 min read
Design Circular Queue — Array with Head and Tail Pointers
Implement a circular queue using a fixed-size array with head and tail pointers and a size counter.
Read →
dsa2 min read
Pacific Atlantic Water Flow — Reverse BFS from Both Oceans
Find cells that can flow to both oceans by doing reverse BFS from each ocean's borders and finding the intersection.
Read →
dsa1 min read
Jump Game VI — DP + Monotonic Deque
Maximize score jumping through an array with window k by combining DP with a monotonic decreasing deque.
Read →
dsa1 min read
Walls and Gates — Multi-Source BFS from All Gates
Fill each empty room with its distance to nearest gate using simultaneous multi-source BFS from all gates.
Read →
dsa1 min read
Flatten Nested List Iterator — Stack-Based Lazy Expansion
Implement an iterator for a nested list using a stack that lazily expands nested lists as elements are consumed.
Read →
dsa1 min read
Remove All Adjacent Duplicates in String II — Stack with Counts
Remove k adjacent identical characters repeatedly using a stack that tracks (character, count) pairs.
Read →
dsa1 min read
Binary Tree Level Order Traversal — BFS Queue
Return values grouped by level using BFS with a queue, processing each level in a batch loop.
Read →
dsa1 min read
Binary Tree Zigzag Level Order — Alternating Direction BFS
Traverse a binary tree in zigzag level order by toggling insertion direction at each level.
Read →
dsa1 min read
Binary Tree Right Side View — BFS Last Element Per Level
Find the rightmost node at each level using BFS and taking the last element seen at each depth.
Read →
dsa1 min read
Path Sum II — DFS Backtracking All Paths
Collect all root-to-leaf paths with a given sum using DFS backtracking, appending and removing the current node.
Read →
dsa1 min read
Diameter of Binary Tree — Tree DP Height Trick
Find the diameter (longest path between any two nodes) using a depth function that tracks the maximum path through each node.
Read →
dsa1 min read
Validate Binary Search Tree — Min/Max Bounds DFS
Validate a BST by passing down min and max bounds through DFS, ensuring every node falls strictly within its valid range.
Read →
dsa1 min read
Kth Smallest Element in a BST — Inorder Traversal
Find the kth smallest element in a BST using inorder traversal (left-root-right) which visits nodes in sorted order.
Read →
dsa1 min read
Lowest Common Ancestor of Binary Tree — Post-Order DFS
Find the LCA of two nodes using post-order DFS: return root when found, propagate upward and split at the ancestor.
Read →
dsa1 min read
Lowest Common Ancestor of BST — BST Property Navigation
Find the LCA in a BST in O(h) by navigating left or right based on whether both nodes are in the same subtree.
Read →
dsa1 min read
Construct Binary Tree from Preorder and Inorder — HashMap Index
Build a binary tree from preorder and inorder traversals by using the preorder root and inorder index to split left/right subtrees.
Read →
dsa1 min read
Path Sum III — Prefix Sum HashMap on Tree
Count paths in a binary tree summing to target (not necessarily root-to-leaf) using a prefix sum frequency map.
Read →
dsa3 min read
Delete Node in a BST
Find and delete a node from a BST while maintaining BST properties using in-order successor.
Read →
dsa2 min read
Flatten Binary Tree to Linked List
Flatten a binary tree to a linked list in-place using pre-order traversal order.
Read →
dsa2 min read
Populating Next Right Pointers in Each Node
Connect each node to its next right node using BFS level order or O(1) space pointer manipulation.
Read →
dsa3 min read
All Nodes Distance K in Binary Tree
Find all nodes at distance K from a target node by building parent pointers then doing BFS.
Read →
dsa2 min read
Sum Root to Leaf Numbers
Compute the total sum of all root-to-leaf numbers formed by concatenating digits along each path.
Read →
dsa3 min read
Maximum Width of Binary Tree
Find the maximum width of a binary tree where width is measured from leftmost to rightmost non-null node per level.
Read →
dsa2 min read
Count Good Nodes in Binary Tree
Count nodes where no node on the root-to-node path has a value greater than the node itself.
Read →
dsa2 min read
Convert BST to Greater Tree
Replace each node value with the sum of all values greater than or equal to it using reverse in-order traversal.
Read →
dsa2 min read
Find Duplicate Subtrees
Find all duplicate subtrees by serializing each subtree and using a hash map to detect duplicates.
Read →
dsa2 min read
Unique Binary Search Trees II
Generate all structurally unique BSTs with values 1 to n using divide and conquer with memoization.
Read →
dsa2 min read
Trim a Binary Search Tree
Trim a BST so all values lie within [low, high] by recursively pruning out-of-range subtrees.
Read →
dsa3 min read
Serialize and Deserialize BST
Serialize a BST to a compact preorder string and reconstruct it using the min-max BST property.
Read →
dsa2 min read
Vertical Order Traversal of a Binary Tree
Group tree nodes by vertical column then row, sorting by value within same position using BFS with coordinates.
Read →
dsa3 min read
Step-By-Step Directions From a Binary Tree Node to Another
Find path directions between two tree nodes by finding LCA then building paths from LCA to each target.
Read →
dsa2 min read
Check Completeness of a Binary Tree
Verify a binary tree is complete using BFS: once a null child is seen, no more non-null nodes should follow.
Read →
dsa2 min read
Recover Binary Search Tree
Find and swap the two misplaced nodes in a BST using in-order traversal to detect the violations.
Read →
dsa2 min read
House Robber III
Maximize robbery from a tree-structured neighborhood where adjacent (parent-child) nodes cannot both be robbed.
Read →
dsa2 min read
Distribute Coins in Binary Tree
Count minimum moves to distribute coins evenly by tracking excess/deficit coins flowing through each edge.
Read →
dsa3 min read
Kth Ancestor of a Tree Node
Find the Kth ancestor of any tree node in O(log k) per query using binary lifting (sparse table DP).
Read →
dsa2 min read
Construct Binary Search Tree from Preorder Traversal
Reconstruct a BST from its preorder traversal in O(n) using min-max bounds to place each node.
Read →
dsa2 min read
Find Leaves of Binary Tree
Collect leaves by height (distance from leaf) repeatedly, returning all leaves at each height level.
Read →
dsa2 min read
Count Complete Tree Nodes
Count nodes in a complete binary tree in O(log^2 n) by comparing left and right heights to identify full subtrees.
Read →
dsa2 min read
Minimum Time to Collect All Apples in a Tree
Find minimum seconds to collect all apples in a tree by DFS: include a subtree path only if it contains apples.
Read →
dsa2 min read
Maximum Difference Between Node and Ancestor
Find the maximum |a - b| for any ancestor-descendant pair by tracking min and max values along each root-to-leaf path.
Read →
dsa2 min read
Longest ZigZag Path in Binary Tree
Find the longest zigzag path in a binary tree where you alternate left-right directions at each step.
Read →
dsa2 min read
Unique Binary Search Trees
Count the number of structurally unique BSTs with n nodes using Catalan numbers and DP.
Read →
dsa2 min read
N-ary Tree Level Order Traversal
Perform level-order traversal of an N-ary tree using BFS, collecting all children at each level.
Read →
dsa1 min read
Binary Tree Pruning
Remove all subtrees that do not contain a 1 by recursively returning null for subtrees with only zeros.
Read →
dsa2 min read
Maximum Level Sum of a Binary Tree
Find the level with the maximum sum using BFS level-order traversal to compute each level's total.
Read →
dsa2 min read
Smallest String Starting From Leaf
Find lexicographically smallest string from any leaf to root by collecting and comparing reversed paths.
Read →
dsa2 min read
Amount of Time for Binary Tree to Be Infected
Find time for infection to spread through entire tree from a start node by converting to graph then doing BFS.
Read →
dsa3 min read
Minimum Number of Operations to Sort Binary Tree by Level
Find minimum swaps to sort each level of a binary tree using BFS and cycle-detection in permutation sorting.
Read →
dsa2 min read
Binary Search Tree Iterator
Implement an in-order BST iterator with O(h) space using a stack to simulate recursive in-order traversal.
Read →
dsa2 min read
Binary Tree Upside Down
Transform a binary tree so every right child becomes a sibling and left child becomes parent using iterative rotation.
Read →
dsa1 min read
Inorder Successor in BST II
Find the inorder successor of a node in a BST when you have access to parent pointers.
Read →
dsa2 min read
Add One Row to Tree
Insert a new row of nodes at a given depth in a binary tree using BFS to reach the target depth level.
Read →
dsa1 min read
Deepest Leaves Sum
Sum all nodes at the deepest level of a binary tree using BFS to process level by level.
Read →
dsa2 min read
Number of Nodes in a Complete Binary Tree (Optimized)
Count nodes in complete binary tree in O(log^2 n) by comparing left vs right subtree heights recursively.
Read →
dsa1 min read
Insert into a Binary Search Tree
Insert a value into a BST by traversing left/right based on comparisons until reaching a null position.
Read →
dsa2 min read
Construct Quad Tree
Build a quad tree from a 2D grid by recursively checking if a region is uniform and splitting into four quadrants.
Read →
dsa1 min read
Count Nodes Equal to Average of Subtree
Count nodes where node value equals the average of all values in its subtree using post-order DFS returning sum and count.
Read →
dsa2 min read
Implement Trie (Prefix Tree) — Insert/Search/StartsWith
Implement a Trie with insert, search, and startsWith operations. Core data structure for all prefix-based problems.
Read →
dsa1 min read
Design Add and Search Words — Trie with Wildcard DFS
Trie that supports wildcard '.' matching any character. DFS through trie when '.' encountered, trying all children.
Read →
dsa1 min read
Replace Words — Trie Shortest Prefix Replacement
Replace each word in sentence with its shortest root from dictionary. Insert roots into trie; for each sentence word find shortest matching prefix.
Read →
dsa1 min read
Maximum XOR of Two Numbers — Binary Trie
Find maximum XOR of any two numbers in array. Binary trie (bit by bit from MSB): for each number greedily choose opposite bit to maximize XOR.
Read →
dsa1 min read
Search Suggestions System — Trie with Sorted Lists
After each character typed, return up to 3 lexicographically smallest matching products. Sort products, insert into trie, store sorted lists at each node.
Read →
dsa1 min read
Longest Word in Dictionary — Trie BFS/DFS
Find longest word where all prefixes exist in dictionary. Trie: only follow nodes where is_end=True, track max depth.
Read →
dsa1 min read
Short Encoding of Words — Trie Suffix Dedup
Encode word list as shortest string where each word is a suffix. Words that are suffixes of others need not be separately encoded. Use trie of reversed words.
Read →
dsa1 min read
Map Sum Pairs — Trie with Value Propagation
Implement insert(key, val) and sum(prefix) returning sum of values for all keys with given prefix. Trie with value at end node.
Read →
dsa1 min read
Find Length of Longest Common Prefix — Digit Trie
Find the longest common prefix length between any number in arr1 and any number in arr2. Build trie from arr1 digits, query with arr2.
Read →
dsa1 min read
Count Distinct Substrings — Suffix Trie / Rolling Hash
Count distinct substrings. Naive: insert all suffixes into trie and count nodes. Optimal: suffix automaton or rolling hash.
Read →
dsa2 min read
Max Consecutive Ones III [Medium] — Sliding Window with K Zeros
Find the maximum number of consecutive 1s achievable by flipping at most k zeros, using a variable sliding window.
Read →
dsa2 min read
Longest Substring Without Repeating Characters [Medium] — HashSet Window
Find the longest substring without duplicate characters using a HashSet-backed shrinkable sliding window.
Read →
dsa2 min read
Longest Repeating Character Replacement [Medium] — Max-Freq Window
Find the longest substring with at most k character replacements by tracking the maximum frequency char in the window.
Read →
dsa2 min read
Permutation in String [Medium] — Fixed Window Character Count
Check if any permutation of s1 is a substring of s2 using a fixed-size sliding window with character frequency comparison.
Read →
dsa2 min read
Fruit Into Baskets [Medium] — Longest Subarray with 2 Distinct
Find the maximum fruits you can collect starting from any tree with two baskets (at most 2 distinct fruit types) using a sliding window.
Read →
dsa1 min read
Maximum Erasure Value [Medium] — Sliding Window with HashSet
Find the maximum sum of a subarray with all unique elements using a sliding window backed by a HashSet.
Read →
dsa1 min read
Minimum Size Subarray Sum [Medium] — Shrinkable Sliding Window
Find the smallest subarray with sum >= target using a variable sliding window that shrinks from the left when the condition is met.
Read →
dsa1 min read
4Sum II [Medium] — Split and Hash
Count tuples (i,j,k,l) where nums1[i]+nums2[j]+nums3[k]+nums4[l]=0 by hashing all pairs from first two arrays.
Read →
dsa1 min read
Container with Most Water [Medium] — Greedy Two Pointers
Maximize water trapped between two vertical lines using inward two pointers that always move the shorter line inward.
Read →
dsa1 min read
Boats to Save People [Medium] — Greedy Two Pointers Sort
Find minimum boats to save everyone where each boat carries at most 2 people with total weight <= limit, using sort + greedy two pointers.
Read →
dsa2 min read
3Sum [Medium] — Sort + Two Pointer Scan
Find all unique triplets summing to zero by sorting and using two pointers for each fixed element with careful duplicate skipping.
Read →
dsa1 min read
Two Sum II — Input Array Is Sorted [Medium] — O(1) Space Two Ptr
Find two numbers summing to target in a 1-indexed sorted array using inward two pointers in O(n) time O(1) space.
Read →
dsa1 min read
Subarray Product Less Than K [Medium] — Sliding Window
Count contiguous subarrays with product < k using a sliding window that divides from the left when product exceeds the limit.
Read →
dsa1 min read
Maximum Points You Can Obtain from Cards [Medium] — Complement Window
Maximize card points taken from both ends of an array by finding the minimum-sum subarray of size n-k in the middle.
Read →
dsa1 min read
Count Number of Nice Subarrays [Medium] — atMost(k)−atMost(k−1)
Count subarrays with exactly k odd numbers using the at-most(k) minus at-most(k-1) sliding window formula.
Read →
dsa1 min read
Binary Subarrays With Sum [Medium] — Prefix Sum / atMost
Count binary subarrays with exactly the given sum using prefix sum with HashMap or the atMost(k)-atMost(k-1) trick.
Read →
dsa1 min read
Frequency of the Most Frequent Element [Medium] — Sorted Window
Find the maximum frequency of any element after at most k increments by sorting and using a sliding window with a running sum.
Read →
dsa2 min read
Minimum Operations to Reduce X to Zero [Medium] — Complement Window
Find minimum operations to reduce X to zero from either end by finding the longest middle subarray with sum = total-X.
Read →
dsa1 min read
Longest Mountain in Array [Medium] — Two Pass Expand
Find the longest mountain subarray (strictly increasing then decreasing) using two separate forward scans for up and down slopes.
Read →
dsa1 min read
Longest Turbulent Subarray [Medium] — Two Pointer Direction Track
Find the longest turbulent subarray where comparisons alternate between > and < using two-pointer direction tracking.
Read →
dsa1 min read
Replace the Substring for Balanced String [Medium] — Two Ptr
Find the minimum length substring to replace so that a string of QWER has equal frequencies, using a shrinkable two-pointer approach.
Read →
dsa2 min read
Min Flips for Alternating Binary String [Medium] — Circular Window
Find minimum character flips to make a binary string alternating by applying a fixed circular sliding window of size n.
Read →
dsa1 min read
Maximum Number of Vowels in a Substring of Given Length [Medium]
Find the maximum number of vowels in any substring of length k using a fixed sliding window with vowel count.
Read →
dsa1 min read
Minimum Swaps to Group All 1s Together II [Medium] — Fixed Window
Find minimum swaps to group all 1s together in a circular binary array using a fixed-size sliding window equal to the count of 1s.
Read →
dsa1 min read
Take K of Each Character From Left and Right [Medium] — Middle Window
Find minimum minutes to collect at least k of each character from ends by finding the longest middle window that can be excluded.
Read →
dsa1 min read
Grumpy Bookstore Owner [Medium] — Fixed Window Bonus
Maximize customer satisfaction by finding the best k-minute window for the bookstore owner to stay non-grumpy.
Read →
dsa1 min read
Get Equal Substrings Within Budget [Medium] — Variable Window Cost
Find the maximum length substring you can transform from s to t within a given cost budget using a sliding window on character change costs.
Read →
dsa1 min read
Number of Substrings Containing All Three Characters [Medium]
Count substrings containing at least one a, b, and c using the last-seen indices shortcut for O(n) time.
Read →
dsa1 min read
Subarray Sum Divisible by K [Medium] — Prefix Sum Modulo
Count subarrays with sum divisible by k using prefix sum modulo k and a frequency map of remainders.
Read →
dsa1 min read
Find K Closest Elements [Medium] — Binary Search + Two Ptr
Find k closest integers to x in a sorted array using binary search to locate the optimal left boundary of the window.
Read →
dsa1 min read
Max Consecutive Ones [Medium] — K-Flip Sliding Window
Find the maximum consecutive ones in a binary array when you can flip at most k zeros, identical to the Max Consecutive Ones III pattern.
Read →
dsa1 min read
Sort Vowels in a String [Medium] — Extraction and Replace
Sort only the vowels in a string while keeping consonants in place by extracting vowels, sorting, then reinserting.
Read →
dsa1 min read
Minimum Consecutive Cards to Pick Up [Medium] — HashMap Window
Find the minimum number of consecutive cards that contain a matching pair using a HashMap tracking last seen positions.
Read →
dsa1 min read
Longest Subarray of Ones After Deleting One Element [Medium]
Find the longest contiguous subarray of 1s after deleting exactly one element using a sliding window allowing at most one zero.
Read →
dsa1 min read
Sort Colors / Dutch National Flag [Medium] — 3-Pointer Review
Sort an array of 0s, 1s, and 2s in one pass using the Dutch National Flag 3-pointer algorithm.
Read →
dsa1 min read
Valid Palindrome II [Medium] — Delete At Most One Character
Check if a string can become a palindrome by deleting at most one character using recursive two-pointer palindrome checking.
Read →
dsa2 min read
Mock Week 1 — Easy + Medium Mix with Communication Focus
Week 1 mock session: two carefully chosen easy/medium problems designed to build communication habits. Full problem walkthrough with example think-aloud scripts.
Read →
dsa2 min read
Mock Week 2 — Medium Problems with Optimization Round
Week 2 mock: solve medium problems then optimize. Practice the full interview loop of brute force → optimal → follow-up questions. Includes common interviewer follow-up prompts.
Read →