// DS 320 · Algorithms for Data Science · Spring 2026

LeetCode Practice Problems

Problems mapped lecture-by-lecture. Each one requires only what has been taught up to that point — no forward knowledge needed.

Easy — builds intuition
Medium — exam-level
Hard — go beyond
50
Problems
14
Easy
24
Medium
12
Hard
22
Lectures
How to use this page: Problems are grouped by the exact lecture that teaches what you need to solve them. The small tag is a one-word nudge toward the key idea — no hints about the solution. Collapsed "Extra" sections contain closely related problems that don't perfectly match a single lecture. Click any row to open on LeetCode.

01Asymptotic Analysis & Sorting

Big-O / Ω / Θ · Insertion Sort · Loop invariants · Comparison-based lower bound
L1
Runtime Review & Asymptotic Notation
Big-O, Ω, Θ — expressing and comparing growth rates
#1
Two Sum
Can you beat O(n²)? Trade space for time and state the exact complexity.
runtime tradeoffEasy↗ #217
Contains Duplicate
Multiple approaches — compare their exact asymptotic cost.
O(·) comparisonEasy↗ #215
Kth Largest Element in an Array
Several approaches exist — state and compare the runtime of each one.
runtime analysisMedium↗
L2
Insertion Sort, Loop Invariants & Sorting Lower Bound
Correctness via loop invariants · Ω(n log n) comparison lower bound via decision trees
#147
Insertion Sort List
Implement insertion sort on a linked list — maintain and state the exact invariant from lecture.
loop invariantMedium↗ #75
Sort Colors
Single-pass Dutch partition — write down a loop invariant that guarantees correctness.
loop invariantMedium↗ #912
Sort an Array
Implement any O(n log n) comparison sort from scratch — why can't you do better?
comparison sortMedium↗

02Graphs — DFS, BFS & Topological Sort

Graph ADT · DFS pre/post-order & edge types · Topological ordering · BFS layers · Bipartiteness
L3
Abstract Data Types, Graphs & DFS Introduction
Adjacency list representation · Stack-based DFS · Visited array
#200
Number of Islands
DFS + visited array from scratch — mirrors the lecture pseudocode.
DFS / componentsMedium↗ #695
Max Area of Island
DFS while accumulating a value on the call stack — same traversal, richer bookkeeping.
DFSMedium↗ #133
Clone Graph
DFS with a map as your visited structure — almost exactly the lecture pseudocode.
DFS + visited mapMedium↗ #1971
Find if Path Exists
BFS/DFS in its simplest form — checking connectivity between two nodes.
connectivity / BFS / DFSEasy↗
L4
DFS — Pre/Post-order & Topological Sort
Timestamps · Tree / back / forward / cross edges · DAG ↔ no back edges · Topo sort via decreasing post-order
#207
Course Schedule
Has the schedule a valid ordering? Equivalent to: does the graph have a back edge?
cycle ↔ back edgeMedium↗ #802
Find Eventual Safe States
A node is safe iff it lies on no cycle — post-order DFS makes this precise.
post-order DFSMedium↗
L5
Topological Sort (continued) & BFS
BFS layer structure · BFS = shortest path in unweighted graphs · Bipartite testing via 2-coloring
#210
Course Schedule II
Output the actual topological order — Kahn's BFS or DFS post-order both work.
topological orderingMedium↗ #994
Rotting Oranges
Multi-source BFS — each orange is at most one layer beyond its rotting neighbour.
BFS layersMedium↗ #785
Is Graph Bipartite?
BFS 2-coloring — the exact algorithm proven in L5.
BFS 2-colouringMedium↗ #127
Word Ladder
BFS on an implicit graph — shortest path by number of edges, not weights.
unweighted shortest pathHard↗ #1203
Sort Items by Groups
Hierarchical topological sort — sort the groups first, then sort items within each group.
nested topo sortHard↗

03Greedy Algorithms

Dijkstra · Greedy stays ahead · Interval scheduling · Optimal caching · Greedy exchange · Minimising lateness
L6
Shortest Path & Greedy Stays Ahead
Dijkstra's algorithm · "Greedy stays ahead" proof technique
#743
Network Delay Time
Dijkstra on a directed weighted graph — classic application.
DijkstraMedium↗ #56
Merge Intervals
Sort by start, then scan — warm-up for interval scheduling next lecture.
interval processingMedium↗
L7
Dijkstra Correctness & Interval Scheduling
Full greedy-stays-ahead proof for Dijkstra · Interval scheduling maximisation (earliest-finish-time rule)
#1631
Path with Minimum Effort
Dijkstra with a different edge cost — the stays-ahead argument still applies.
Dijkstra variantMedium↗ #1514
Path with Maximum Probability
Dijkstra maximising product of edge weights — same proof skeleton, opposite direction.
Dijkstra generalisedMedium↗ #435
Non-overlapping Intervals
Maximise compatible tasks — earliest finish time rule from L7.
interval schedulingMedium↗ #452
Minimum Number of Arrows to Burst Balloons
Minimum covers of overlapping intervals — greedy on earliest end point.
interval coveringMedium↗
L8
Optimal Caching & Greedy Exchange Argument
Farthest-in-future eviction · Exchange argument: transform any solution into the greedy one without increasing cost
#146
LRU Cache
LRU is the practical proxy for Farthest-in-Future — implement it and think about the gap.
caching policyMedium↗ #2037
Minimum Moves to Seat Everyone
An exchange argument shows sorting both lists and pairing them is optimal.
exchange argumentEasy↗ #2144
Minimum Cost of Buying Candies with Discount
Prove by exchange that you should always give away the cheapest possible free candy.
greedy exchangeEasy↗
L9
Scheduling to Minimise Lateness
Earliest-deadline-first rule · Exchange argument: swapping adjacent inverted jobs monotonically reduces max lateness
#1353
Maximum Number of Events That Can Be Attended
Attend one event per day — greedily pick the soonest-ending available event (EDF).
earliest deadlineMedium↗ #621
Task Scheduler
Minimise total elapsed time with a cooling constraint — which tasks to schedule first?
lateness / schedulingMedium↗

04Divide & Conquer

MergeSort + strong induction · Master Theorem · Closest pair of points · Karatsuba / Strassen
L10
MergeSort & Solving Recurrences
Divide → Conquer → Combine · T(n) = 2T(n/2)+O(n) · Master Theorem (3 cases)
#148
Sort List
MergeSort on a linked list — implement the recurrence T(n) = 2T(n/2) + O(n) exactly.
merge sortMedium↗ #53
Maximum Subarray
D&C: answer is in the left half, right half, or crosses the midpoint — same recurrence as MergeSort.
D&CMedium↗ #23
Merge K Sorted Lists
Pair-and-merge D&C — write the recurrence and apply the Master Theorem.
D&C mergeHard↗
L11
Closest Pair of Points
Split, conquer each half, combine across the strip — O(n log n) from an O(n²) baseline
#973
K Closest Points to Origin
Euclidean distance practice — simpler than closest pair, but same geometric intuition.
closest pair spiritMedium↗ #327
Count of Range Sum
Counting pairs in the merge step — same "combine across split" idea as the closest pair strip.
D&C countingHard↗
L12
Integer & Matrix Multiplication — Karatsuba & Strassen
Karatsuba: T(n)=3T(n/2)+O(n) · Strassen: T(n)=7T(n/2)+O(n²) · Beating the "obvious" lower bound
#43
Multiply Strings
Arbitrary-precision multiplication — implement schoolbook first, then think about what Karatsuba's split saves.
integer multiplicationMedium↗ #50
Pow(x, n)
Fast exponentiation — the simplest T(n) = T(n/2) + O(1) recurrence in practice.
D&C recurrenceMedium↗
+ Extra — Divide & Conquer (broader than Karatsuba/Strassen) ▾
Great D&C problems, but this one is really about binary search rather than integer/matrix multiplication.
#4
Median of Two Sorted Arrays
O(log n) via binary search on a partition — identify the sub-problem and recurrence carefully.
binary search / D&CHard↗

05Dynamic Programming

Weighted interval scheduling · 0/1 Knapsack · Segmented least squares · Bellman-Ford shortest paths
L13
DP I — Weighted Interval Scheduling
OPT(j) = max(v_j + OPT(p(j)), OPT(j−1)) · Memoisation vs bottom-up · Backtracking the solution
#198
House Robber
"Include this house or skip to the previous compatible one" — the weighted IS recurrence in disguise.
OPT(j) recurrenceMedium↗ #740
Delete and Earn
Reduce to House Robber by reformulating compatibility — a clean reduction exercise.
weighted IS reductionMedium↗ #1235
Maximum Profit in Job Scheduling
This is the exact weighted interval scheduling problem from L13 — sort by finish time, binary search for p(j).
weighted IS — exact matchHard↗
L14
DP II — Knapsack
OPT(i,W) — 2D DP table · "Take item i or don't" · Pseudopolynomial runtime
#322
Coin Change
Unbounded knapsack — items can be reused. Define OPT(amount) and fill the table.
knapsack (unbounded)Medium↗ #416
Partition Equal Subset Sum
0/1 Knapsack — can you fill capacity exactly W/2? Direct application of OPT(i,W).
0/1 knapsack — exactMedium↗ #474
Ones and Zeroes
Two-dimensional capacity — generalise OPT(i,W) to OPT(i,m,n).
2D knapsackMedium↗ #494
Target Sum
Count the number of +/− assignments hitting the target — knapsack counting, not maximising.
knapsack countingMedium↗
L15
DP III — Segmented Least Squares
OPT(j) = min_{i≤j} {e(i,j) + c + OPT(i−1)} · Partition a sequence minimising cost + segment penalty
#1105
Filling Bookcase Shelves
Partition books into shelves — OPT(j) = min over split point i of {shelf_cost(i..j) + OPT(i−1)}.
segmented LS — directMedium↗ #1547
Minimum Cost to Cut a Stick
Interval DP with cost depending on segment size — same partition-into-segments flavour.
interval / segment DPHard↗
L16
DP IV — Shortest Paths & Bellman-Ford
OPT(v,i) = shortest path with ≤i edges · Negative cycle detection (extra column trick) · O(nm) runtime
#787
Cheapest Flights Within K Stops
Bellman-Ford with at most K+1 edges — compute OPT(dst, K+1) by running K+1 relaxation rounds.
Bellman-Ford — exactMedium↗ #1334
Find the City with Smallest Reachable Cities
All-pairs shortest paths — run Bellman-Ford from each source, or use the Floyd-Warshall 3D DP.
all-pairs SPMedium↗
+ Extra — Dynamic Programming (classic DP problems not tied to a specific lecture's algorithm) ▾
These are essential DP patterns but don't map directly to a specific algorithm (Knapsack/Segmented LS/Bellman-Ford). Work on them after finishing L13–16.
#300
Longest Increasing Subsequence
OPT(i) = 1 + max OPT(j) for j<i with A[j]<A[i] — a canonical sequence DP to know cold.
sequence DPMedium↗ #72
Edit Distance
2D DP on strings — OPT(i,j) = min edits to align first i of s1 with first j of s2. Classic after Bellman-Ford solidifies 2D DP thinking.
2D string DPMedium↗

06NP-Completeness & Reductions

3-SAT · Independent Set · 3-SAT ≤_P Independent Set · P vs NP · Certificate verification
L17
NP-Completeness, Independent Set & P vs NP
Reductions · 3-SAT is NP-complete · 3-SAT ≤_P Independent Set · Verifying vs. solving
#990
Satisfiability of Equality Equations
A structured, polynomial-time solvable form of satisfiability — think about why this is tractable while 3-SAT is not.
structured SATMedium↗ #698
Partition to K Equal Sum Subsets
NP-hard in general (bin packing reduction) — yet tractable here via backtracking. What structure makes this feasible?
NP-hard in generalMedium↗ #1349
Maximum Students Taking Exam
Independent set on a grid — NP-hard on general graphs, polynomial here due to row structure (bitmask DP).
ind. set (structured)Hard↗ #140
Word Break II
Looks exponential but DP makes it polynomial — contrast with why general SAT enumeration cannot do this.
structure → tractabilityHard↗

07Linear Programming, Game Theory & Online Learning

LP formulations · LP duality · Zero-sum games · Minimax theorem · MWU / Regret
L20–21
LP Duality & The Minimax Theorem
Weak/strong duality · Complementary slackness · Zero-sum games · Minimax = maximin via LP duality
#292
Nim Game
The simplest zero-sum game — pure optimal strategy, verify it fits the Minimax Theorem.
zero-sum gameEasy↗ #486
Predict the Winner
Two-player zero-sum minimax — the Minimax Theorem guarantees an optimal strategy exists.
minimaxMedium↗ #877
Stone Game
Is there a dominant pure strategy, or must you reason about minimax?
game theoryMedium↗ #375
Guess Number Higher or Lower II
Minimise worst-case cost — adversary picks the answer, you minimise. Pure minimax / LP dual flavour.
minimax / LP dualMedium↗ #714
Best Time to Buy and Sell Stock with Transaction Fee
Online decision at each time step — think about what "regret" means in this setting.
online decision-makingMedium↗

Beyond the Curriculum

not in DS 320
Important techniques that DS 320 doesn't cover, but that are foundational for algorithm design more broadly and extremely common in interviews and competitive programming. These complement what you've learned — treat them as electives after finishing the course material.
🔗
Union-Find (Disjoint Set Union)
Near-O(1) amortised connectivity queries — powers Kruskal's MST and many graph problems
#547
Number of Provinces
Connected components — implement DSU with union by rank and path compression.
DSU basicsMedium↗ #684
Redundant Connection
Find the edge that creates a cycle — the union operation tells you when two nodes are already connected.
DSU cycle detectionMedium↗ #721
Accounts Merge
Union accounts sharing an email — DSU on strings.
DSU on stringsMedium↗
📊
Monotonic Stack / Queue
O(n) answers to "next greater element" and sliding-window extrema queries
#739
Daily Temperatures
Next warmer day for each entry — the classic monotonic stack starter.
monotonic stackMedium↗ #84
Largest Rectangle in Histogram
Maintain a stack of "active" bars — the hardest classic monotonic stack problem.
monotonic stackHard↗ #239
Sliding Window Maximum
Monotonic deque for max in O(1) per step — pairs with sliding window technique.
monotonic dequeHard↗
🪟
Sliding Window & Two Pointers
O(n) subarray / substring problems — a must-know technique missing from the theory curriculum
#3
Longest Substring Without Repeating Characters
Expand right, shrink left when you hit a duplicate — the sliding window template.
sliding windowMedium↗ #76
Minimum Window Substring
Variable-size sliding window with a frequency map — the hardest window problem.
sliding windowHard↗ #15
3Sum
Sort, fix one element, two-pointer scan — O(n²) vs O(n³) brute force.
two pointersMedium↗
🌳
Trie (Prefix Tree)
O(L) string search/insert where L = key length — key data structure for autocomplete and word searches
#208
Implement Trie (Prefix Tree)
Build the data structure from scratch — insert, search, startsWith.
trie constructionMedium↗ #212
Word Search II
DFS on a grid pruned by a trie — combines L3 DFS with this new data structure.
trie + DFSHard↗
↩️
Backtracking
Exhaustive search with pruning — the algorithmic foundation behind NP-hard solvers
#46
Permutations
Generate all permutations — the canonical backtracking template.
backtrackingMedium↗ #78
Subsets
Enumerate all 2ⁿ subsets — connects to the certificate verification idea from L17.
backtracking / subsetsMedium↗ #37
Sudoku Solver
Constraint-propagation + backtracking — an NP-complete problem solved in practice with smart pruning.
backtracking + pruningHard↗
💡
Bit Manipulation
O(1) tricks with XOR, masks, and shifts — often the key to clean O(n) solutions
#136
Single Number
XOR every element — the unique one survives because x⊕x=0.
XOR trickEasy↗ #191
Number of 1 Bits
Count set bits — Kernighan's trick (n & (n-1) clears the lowest set bit) makes this O(popcount).
bit countingEasy↗ #371
Sum of Two Integers
Add without + or − using XOR and carry — forces you to think at the bit level.
bit arithmeticMedium↗
Textbook references: Greedy (L6–9) → KT §4. D&C (L10–12) → KT §5. DP (L13–16) → KT §6 & CLRS §15 & §24. NP (L17) → KT §8. LP (L18–22) → LP Guide on the course site. LeetCode explore cards for Graphs and Dynamic Programming are excellent companions.