Week 1

• Meeting 1: Definition of the Stable Matching Problem. (Section 1.1 of the book)
• Meeting 2: Developing an algorithm for the Stable Matching Problem, and arguing it works (Section 1.1).
• Meeting 3: Implementation: Input representation, data structures, and running time (Section 2.3).
• Reading for the week: The material covered in class corresponds to Section 1.1 (not including the subsection titled `Extensions'), and Section 2.3. If you wish to review big-Oh notation and related material, see Section 2.2.

Week 2

• Meeting 1: Running time of Stable Matching Algorithm. General discussion of usefulness and applicability of analysis of worst case running time. Exercise 1 of Chapter 2.
• Meeting 2: Exercise 3 of Chapter 2. Graph concepts (Chapter 3)
• Reading for the week: Section 3.1

Week 3

• Meeting 1: Connected components in undirected graphs, and the breadth first search algorithm. (Section 3.2)
• Meeting 2: Breadth First Search: Correctness, Properties, and Implementation. (Sections 3.2 and 3.3)
• Meeting 3: Finding all connected components using BFS. The BFS tree. The Depth First Search Algorithm (Section 3.2).
• Reading for the Week: Sections 3.2 and 3.3

Week 4

• Meeting 1: Completing Depth First Seacch for undirected graphs. Directed graphs -- representation and generalizations of DFS and BFS. (Section 3.5)
• Meeting 2: Checking if a graph is strongly connected using DFS/BFS. (Section 3.5)
• Meeting 3: Topological Sort and Directed Acyclic Graphs. (Section 3.6)
• Reading for the week: Sections 3.5 and 3.6

Week 5

• Meeting 1: Topological Sort.
• Meeting 2: The random walk algorithm for checking connectivity. This is not from the book, and will not be quizzed on exams either. Interval scheduling from Section 4.1.
• Meeting 2: The greedy algorithm for interval scheduling. Interval Coloring. (Section 4.1)
• Reading for the week: Section 4.1

Week 6

• Meeting 1: The Interval Coloring problem. This corresponds to the portion of Section 4.1 titled `A Related Problem: Scheduling All Intervals'.
• Meeting 2: Scheduling to Minimize Lateness. Section 4.2 of the text.
• Meeting 3: Scheduling to Minimize lateness.
• Reading for the week: Section 4.2

Week 7

• Meeting 1: Problem solving in preparation for midterm.
• Meeting 2: Midterm 1
• Meeting 3: Recursive thinking -- prelude to Chapters 5 (Divide and Conquer) and Chapter 6 (Dynamic Programming). Recursive ways of thinking about insertion sort and bubble sort. Mergesort and Quicksort. Recursive algorithm for flipping pancakes.

Week 8

• Meeting 1: Using recurrence relations to bound worst case running time of recursive algorithms. Examples of pancake flipping and mergesort. This material corresponds to Section 5.1. The pancake flipping problem is however not discussed there.
• Meeting 2: Counting Inversion -- a divide-and-conquer algorithm from Section 5.3 of the text.
• Meeting 3: The Closest Pair problem, from Section 5.4 -- Key Ideas.
• Reading: Sections 5.1--5.4, especially 5.3 and 5.4.

Week 9

• Meeting 1: The Closest Pair Algorithm.
• Meeting 2: Integer Multiplication -- a divide and conquer algorithm. This is covered in Section 5.5 of the text, but we more closely followed the exposition in Chapter 1, Section 1.6 of Jeff Erickson's Notes.
• Meeting 3: Recursive thinking as a prelude to dynamic programming. A recursive algorithm for the subset sum problem. Our approach follows Section 3.3 of Chapter 3 of Jeff Erickson's Notes. Thinking about a recursive algorithm for weighted interval scheduling. This is similar to Section 6.1 of the textbook.
• Reading: The references above.

Week 10

• Meeting 1: A recursive algorithm for weighted interval scheduling. Running time. Getting organized about the interval we branch on in order to control the number of different subproblems solved.
• Meeting 2: Even though the number of different subproblems solved in the recursion is small, the number of subproblems solved is still large (exponential). Memoization as a way to get around this. Iteration over subproblems as a way of solving all subproblems withour using recursion. Sections 6.1 and 6.2 of the textbook develop the algorithms for weighted interval scheduling. Our development of these algorithms followed a slightly different logic, in that we derived the ordering in terms of finish time as a consequence of getting organized to control the number of distinct subproblems.
• Meeting 3: Memoization for the subset sum problem. Our algorithms for subset sum is very similar to the algorithm for subset sum in Section 6.4 of the text. Note, however, that the subset sum problem in class is slightly different from the subset sum problem in the text: rather than achieving the target exactly, the text requires that we get as close to the target as possible without exceeding it.
• Reading: Notes from class, or Sections 6.1, 6.2, and 6.4 from the text.

Week 11

• Meeting 1: Running time analysis for the memoized algorithm, and an iterative algorithm for subset sum.
• Meeting 2: A dynamic programming algorithm for a segmentation problem. This problem is not in the textbook, but is intended to substitute for the discussion in Section 6.2 of the text.
• Meeting 3: Reducing the segmentation problem from the previous meeting to the shortest path problem in directed graphs. Reducing the weighted interval scheduling problem to the maximum cost path problem in directed acyclic graphs.
• Reading: Notes on the algorithm for the segmentation problem

Week 12

• Meeting 1: Reviewing solutions to problems in Homework 5
• Meeting 2: Midterm 2
• Meeting 3: The maximum independent set problem from Chapter 8. Interval Scheduling is reducible to it. A recursive algorithm for solving maximum independent set

Week 13

• Meeting 1: CNF-Satisfiability problem. Modeling 2-colorability as CNF-satisfiability. A recursive algorithm for CNF-satisfiability.
• Meeting 2: A definition for polynomial time reducibility, and some consequences of it.
• Meeting 3: Reduction of CNF-Satisfiability to Independent Set. Discussion of CNF-Satisfiability.
• Reading: The material corresponds to Sections 8.1 and 8.2 of the text. The recursive algorithms for CNF-Sat and Independent Set, and the reduction from 2-colorability to CNF-Sat are not discussed in the text.

Week 14

• Meeting 1: Vertex Cover and Independent Set are reducible to each other. Vertex Cover is Reducible to Set Cover. Transitivity of Polynomial Time Reducibility.
• Meeting 2: Efficient Certifier/Verifier and the class NP
• Meeting 2: P vs. NP, and NP-Completeness.
• Reading: Sections 8.1--8.4.