Reference and Selective Reading
You do not need to read the source books front-to-back for this module. Use the concept pages and practice pages first. Open these local chunks only when you need alternate exposition, more worked examples, or a deeper exercise lane.
Source Roles
| Source | Role | Why it is here |
|---|---|---|
| The Algorithm Design Manual (Skiena) | Primary teaching source | Best operational explanations of paradigm selection, war-story debugging narratives, and practical algorithm intuition |
| Introduction to Algorithms (CLRS) | Formal support | Strongest formal definitions of asymptotic notation, rigorous loop-invariant proofs, Master Theorem cases, greedy and DP frameworks, and amortized analysis |
| Algorithms (Sedgewick) | Implementation support | Cleaner implementation perspectives; rarely needed in Module 1 but valuable for Module 2 |
| Grokking Algorithms (Bhargava) | Accessible alternate | Good for a very low-friction first pass on recursion, D&C, and DP |
| Competitive Programming (Halim) | Exercise and triage support | Compact paradigm guides and exercise volume |
Read Only If Stuck
Cluster 1: Asymptotic Analysis and Mathematical Foundations
- Skiena: The RAM model of computation
- Skiena: Big-Oh notation
- Skiena: Growth rates and dominance relations
- Skiena: Reasoning about efficiency
- Skiena: Logarithms and their applications
- Skiena: Logarithms and summations
- Skiena: Properties of logarithms
- Skiena: Solving divide-and-conquer recurrences
- CLRS: O, Omega, Theta notation
- CLRS: Asymptotic notation formal definitions
- CLRS: Standard notations and common functions
- CLRS: Substitution method
- CLRS: Recursion tree method
- CLRS: Master method
- CLRS: Aggregate analysis
- CLRS: Accounting method
- CLRS: Potential method
- CLRS: Dynamic tables (amortized example)
Cluster 2: Algorithm Correctness and Termination
- Skiena: Expressing algorithms
- Skiena: Induction and recursion
- Skiena: Prove sum i = n(n+1)/2 by induction
- Skiena: Recursive objects
- CLRS: Insertion sort (loop invariant)
- CLRS: Analyzing algorithms
- CLRS: Designing algorithms (D&C correctness)
Cluster 3: Design Paradigms (Search, D&C, Greedy, Backtracking)
- Skiena: Selecting the right jobs
- Skiena: Modeling the problem
- Skiena: Mergesort
- Skiena: Quicksort
- Skiena: Divide and conquer
- Skiena: Backtracking
- Skiena: Constructing all permutations
- Skiena: Search pruning
- Skiena: Sudoku (pruning case study)
- CLRS: Designing algorithms (D&C template)
- CLRS: Activity selection
- CLRS: Elements of the greedy strategy
- CLRS: Huffman codes
- Competitive Programming: Complete search
- Competitive Programming: Divide and conquer
- Competitive Programming: Greedy
- Competitive Programming: Greedy examples
Cluster 4: Dynamic Programming
- Skiena: Fibonacci by recursion
- Skiena: Fibonacci by caching
- Skiena: Approximate string matching
- Skiena: Edit distance by DP
- Skiena: Longest increasing subsequence
- Skiena: Limitations of DP (TSP)
- CLRS: Rod cutting
- CLRS: Matrix chain multiplication
- CLRS: Elements of dynamic programming
- CLRS: Offline caching (greedy vs DP)
- Competitive Programming: DP
- Competitive Programming: DP illustration
- Competitive Programming: DP classical examples
- Grokking: Dynamic programming (Part 1)
Cluster 5: Analysis in Practice
- Skiena: Reasoning about efficiency
- Skiena: Matrix multiplication
- Skiena: Esoteric functions
- Skiena: War story - Give me a ticket on an airplane
- Skiena: War story - Skiena for the defense
- Skiena: War story - Hard against the clock
- Skiena: War story - And then I failed
- Skiena: Chapter notes on algorithm design
- CLRS: Algorithms as a technology
- Competitive Programming: Do algorithm analysis
- Competitive Programming: Master the art of testing code
Optional Deep Dive
- CLRS: Akra-Bazzi recurrences - generalization of the Master Theorem for uneven splits.
- CLRS: Proof of the continuous master theorem - a full proof, not operationally required but useful for deeper understanding.
- Skiena: Strassen matrix multiplication (recurrence analysis) - faster-than-cubic recurrence with practical trade-offs.
- Skiena: Edit distance varieties - DP variants built off the same recurrence.
- Skiena: Longest common subsequence context - where LCS-style DPs appear in algorithm design catalogs.
- CLRS: Randomized algorithms (Chapter 5 material) - optional, for when you want a bridge to later probabilistic analysis.
Concept-to-Source Map
| Primary concept | Best source if stuck | Why this source |
|---|---|---|
| Big-O, Omega, and Theta bound growth | CLRS: Asymptotic notation formal definitions | Cleanest formal treatment with worked bound proofs |
| Loops and summations | Skiena: Logarithms and summations | Summations applied directly to algorithm analysis |
| Recurrences and Master Theorem | CLRS: Master method | Canonical reference with worked cases |
| Loop invariants | CLRS: Insertion sort | The textbook loop-invariant proof |
| Recursive correctness | Skiena: Induction and recursion | Strongest bridge from induction to recursion |
| Divide-and-conquer | Skiena: Divide and conquer | Operational template with several examples |
| Greedy with exchange | CLRS: Activity selection | Model exchange-argument proof |
| Optimal substructure + overlap | CLRS: Elements of dynamic programming | Formal treatment of the two properties |
| Memoization vs tabulation | CLRS: Rod cutting | Both implementations side-by-side |
| Debugging complex algorithms | Skiena: War story - And then I failed | Realistic failure narrative with the repair |
| Choosing a paradigm | Skiena: Modeling the problem | How to reshape a messy problem into paradigm-ready form |