Lecture Schedule, Fall 2020

• [Sept 1: Lecture 1] (slides)
  Introduction and overview. The stable-matching problem.
  Reading: Section 1.2.
  
  
• [Sept 3: Lecture 2] (slides)
  HW1 out -- due Sep 16, 11:59pm
  Models of computation and measures of algorithmic complexity. Asymptotic notation. The stable-matching problem and the Gale-Shapley algorithm.
  Reading: Sections 1.1, 2.1, 2.2, and 2.4.
  
  
• [Sept 8: Lecture 3] (slides)
  Basic data structures. Graphs and basic graph algorithms. Breadth-first search (BFS).
  Reading: Sections 2.3, 3.1, and 3.2.
  
  
• [Sept 10: Lecture 4] (slides)
  BFS and applications (testing bipartiteness). Depth-first search (DFS). Implementing BFS and DFS.
  Reading: Sections 3.3 and 3.4.
  
  
• [Sept 15: Lecture 5] (slides)
  Connectivity in directed graphs and topological ordering. "Greedy" algorithms. Interval scheduling.
  Reading: Sections 3.5, 3.6, and 4.1.
  
  
• [Sept 17: Lecture 6] (slides)
  HW2 out -- due Sep 30, 11:59pm
  Variants/extensions of interval scheduling. Dijkstra's shortest-paths algorithm.
  Reading: Sections 4.2 and 4.4.
  
  
• [Sept 22: Lecture 7] (slides)
  Priority queues. Greedy algorithms for finding minimum spanning trees. Clustering.
  Reading: Sections 2.5, 4.5, and 4.7.
  
  
• [Sept 24: Lecture 8] (slides)
  "Divide-and-conquer" algorithms. Recurrence relations. Mergesort. Closest pair of points.
  Reading: Sections 5.1, 5.2, and 5.4.
  
  
• [Sept 29: Lecture 9] (slides)
  Fast exponentiation. Integer/matrix multiplication. The Fast Fourier Transform.
  Reading: Sections 5.5 and 5.6. (The material on fast exponentiation and Strassen's algorithm is not covered in the book.)
  
  
• [Oct 1: Lecture 10] (slides)
  Dynamic programming. Weighted interval scheduling. The knapsack problem.
  Reading: Sections 6.1, 6.2, and 6.4.
  
  
• [Oct 6: Lecture 11] (slides)
  Longest common subsequence. RNA secondary structure.
  Reading: Lecture 11 of Dave Mount's lecture notes; Section 6.5.
  
  
• [Oct 8: Lecture 12] (slides)
  Sequence alignment. Shortest paths with negative weights. The Bellman-Ford algorithm and distributed routing. Negative-weight cycles.
  Reading: Sections 6.6, 6.8, 6.9, and 6.10 (through page 304 only).
  
  
• [Oct 13]
  Midterm exam -- no lecture
  
  
• [Oct 15: Lecture 13] (slides)
  HW3 out -- due Oct 28, 11:59pm
  Network flow and the Ford-Fulkerson algorithm.
  Reading: Section 7.1.
  
  
• [Oct 20: Lecture 14] (slides)
  Max-flow/min-cut.
  Reading: Section 7.2.
  
  
• [Oct 22: Lecture 15] (slides)
  Optimizing the Ford-Fulkerson algorithm. Applications of network flow.
  Reading: Sections 7.3, 7.5 (through page 370), and 7.6.
  
  
• [Oct 27: Lecture 16] (slides)
  Circulations with demands, and further applications of network flow.
  Reading: Sections 7.7 and 7.8.
  
  
• [Oct 29: Lecture 17] (slides)
  HW4 out -- due Nov 11, 11:59pm
  P, NP, and NP-completeness. Reductions. NP-complete problems.
  Reading: Sections 8.1 and 8.3 (but note that our treatment does not line up exactly with that in the book).
  
  
• [Nov 3: Lecture 18] (slides)
  NP-complete problems.
  Reading: Sections 8.2 and 8.4.
  
  
• [Nov 5: Lecture 19] (slides)
  NP-complete problems.
  Reading: Sections 8.4 and 8.5.
  
  
• [Nov 10: Lecture 20] (slides)
  The complexity class coNP. Dealing with NP-hardness: fixed-parameter tractability and handling special cases.
  Reading: Sections 8.9, 10.1, and 10.2.
  
  
• [Nov 12: Lecture 21] (slides)
  HW5 out -- due Nov 30, 11:59pm
  Dealing with NP-hardness: Approximation algorithms.
  Reading: Sections 11.1, 11.2, and 11.4 (only the simplified version of the algorithm covered in class).
  
  
• [Nov 17: Lecture 22] (slides)
  Beyond NP: PSPACE and PSPACE-completeness. QSAT and two-player games.
  Reading: Sections 9.1-9.3 and 9.5.
  
  
• [Nov 19: Lecture 23] (slides)
  Planning. Randomized algorithms I: Probability review. Contention resolution.
  Reading: Sections 9.4, 13.1, and 13.12.
  
  
• [Nov 24: Lecture 24] (slides)
  Randomized algorithms II: A randomized min-cut algorithm. Randomized testing and Bayes's law.
  Reading: Sections 13.2 and 13.3. The article on COVID testing is here.
  
  
• [Dec 1: Lecture 25] (slides)
  Randomized algorithms III: The coupon-collector problem. A randomized algorithm for MAX-SAT. Markov's bound.
  Reading: Sections 13.3 and 13.4.
  
  
• [Dec 3: Lecture 26] (slides)
  Randomized algorithms IV: Quicksort. Hash tables, load balancing, and Chernoff bounds.
  Reading: Sections 13.5 (pages 731-734), 13.6, 13.9, and 13.10.
  
  
• [Dec 8: Lecture 27] (slides)
  Parallel/distributed algorithms.
  Reading: Uzi Vishkin's notes (you are only responsible for what we covered in class).
  Further reading: Lecture notes on parallel sorting; notes on MapReduce.
  
  
• [Dec 10: Lecture 28] (slides)
  Linear programming. (Note: you are not responsible for this material on the final exam.)
  Reading: Michel Goemans's lecture notes; Jeff Erickson's lecture notes.
  
  
• [Dec 17] Final exam (8-10am)
  
  

Web Accessibility