
This a graduate course on algorithms and data structures. Topics that I plan to cover include: basic programming paradigms (recursion, divide and conquer, greedy, dynamic programming), data structures (unionfind, heaps), graph algorithms (shortest paths, spanning trees, network flows, matching, mincut), randomized algorithms, linear programming and duality, semidefinite programming, approximation algorithms, online algorithms. 

We will assume knowledge of the basics of algorithms and analysis and data structures, including basic sorting and searching algorithms, graph traversal, solving recurrences, bigoh notation, and NPcompleteness. These prerequisites may be obtained from the CLRS reference book. 

Classes will be held Tue 11:301 pm and Thu 4  5:30 in A201.
Classes begin on August 8th. Evaluation will be on the basis of assigments (40%), a midterm (20%), a final exam (30%), and a class presentation (10%). The weightage of these may be slightly modified later. 

The topics we cover will mostly be from the book Introduction to Algorithms by Cormen, Leiserson, Rivest, and Stein, for the first part of the course. However, our treatment and notation will differ. Other good reference materials are
Our treatment will often differ from that in books, and I may cover topics out of order. I will post an outline of topics covered in each lecture below, including source material. 


An O(n log n) algorithm for finding the closest pair of points in the plane. An O(n) algorithm for finding the median of a set of numbers.
References: Sections 33.4 and 9.3 from CLRS.  
An O(n log n) for polynomial multiplication using the Fast Fourier Transfom
References: Chapter 30 from CLRS.  
Integer multiplication by the Karatsuba algorithm. Matrix multiplication using Strassen's algorithm. Computing the min and max of an array, and lower bounds. Dynamic programming  the coin change problem.
References: For the Karatsuba algorithm, see the course handout by Babai. Strassen's matrix multiplication is from CLRS Section 4.2. The minmax problem is from CLRS Section 9.1.  
Lower bound for the min and max problem. Dynamic programming  optimal binary search trees. Greedy algorithms  activity selection and Huffman coding.
References: The lower bound proof is from the lecture notes of R. Chandrasekaran, available here. Optimal BSTS are from CLRS Section 15.5. The greedy algorithms are from Chapter 16 in CLRS.  
Matroids and greedy algorithms. The unitsize job scheduling problem. Dijkstra's algorithm for singlesource shortest path.
References: CLRS Chapter 16 for matroids, Section 24.3 for Dijkstra's algorithm.  
Faster algorithms using better data structures for Dijkstra's algorithm: min heaps and Fibonacci heaps.
References: CLRS Section 24.3 for Dijkstra's algorithm, Chapter 6 for min heaps, and Chapter 19 for Fibonacci heaps. My notes.  
A randomized primality testing algorithm by Miller and Rabin. Kavitha will be taking these classes.
References: CLRS Section 31.8.  
Kruskal's algorithm for minimum spanning trees, and the unionfind data structure.
References: Sariel HarPeled's notes, available here. My notes are here  
Redblack trees.
References: Class notes. There are a number of youtube videos that you may also find helpful.  
Maximum flows and minimum cuts. FordFulkerson, EdmondsKarp, and the preflowpush algorithms.
References: Class notes, as well as Sections 26.1, 26.2 from CLRS.  
The preflowpush algorithm.
References: Class notes, an example, as well as Section 26.4 from CLRS.  
Continuing the preflowpush algorithm. Maximum matching in bipartite graphs.
References: My notes. Lecture notes from a course taught by Naveen Garg.  
Maximum matching in general graphs. Berge's Lemma for general graphs, and Tutte's theorem.
References: My notes. Lecture notes from Naveen Garg.  
Global mincut  Karger's algorithm and KargerStein.
References: My notes. Lecture notes from a course by Russell Impagliazzo  
Randomized binary search trees, and a randomized algorithm for 2SAT.
References: My notes. Lecture notes from a course taught at Harvard.  
MaxSat, Set Balancing, and derandomization.  
Ballsandbins, and hashing.
References: My notes. For ballsandbins, the first of part Anupam Gupta's notes. For hashing, Section 8.4 of the book by Motwani and Raghavan.  
Hashing and Perfect (Static) Hashing.
References: My notes. Sections 8.4 and 8.5 of the book by Motwani and Raghavan.  
Linear programming: basic structure, exponential algorithms, and writing problems as LPs.
References: My notes. Jeff Erickson's notes, until Section 26.3.  
Linear programming: total unimodularity and duality.
References: My notes. Jeff Erickson's notes, continued from Section 26.3. We didn't do the proof of strong duality. I couldn't find a good reference for total unimodularity, so please refer to my notes.  
Linear programming: duality, complementary slackness, and application to maxflow mincut theorem.  
Kavitha took these classes on stable matching and matching polytopes.  
Complexity classes: P, NP, coNP, polynomialtime reductions and NPhardness. Hardness of independent set and subsetsum. An O(log n) approximation by a greedy algorithm for set cover.
References: My notes. Chapter 34 in CLRS, though not Lemma 34.6, Theorem 34.9, 34.10, 34.13 (and others). Theorem 34.15 shows hardness of subset sum. The greedy algorithm for set cover is from Section 35.3 (note that this does the unweighted version, but the proof is easily extendible to the weighted version).  
Primaldual and rounding algorithms for set cover
References: My notes. Chapters 14 and 15 from "Approximation Algorithms" by Vijay Vazirani. 





