Lecture 1:
	* what is an algorithm?
	* worst-case running time
	* big-O notation, \Omega, little-Oh, \Theta
	* some common running time
	* Find the MAX
	* Merge two sorted list of n numbers each
	* Mergesort: O(nlogn)
	* Find the closest pair in O(n^2) time
	* Find the maximum independent set in O(2^n) time
	* binary search in O(logn) time
Lecture 2 & 3:
	* Priority queue, heap, heapsort
	* graphs, trees, connectivity
	* graph representation
	* breadth-first search, queue
	* depth-first search, stack
	* test whether a graph is bipartite or not
	* directed acyclic graph (DAG)
	* test whether a graph is strongly connected
	* compute a topological ordering of a DAG
Lecture 4:
	* greedy algorithm
	* interval scheduling (prove that the solution is "no worse" than the optimal solution
	* classroom assignment problem (argue a lower bound and show the algorithm achives that lower bound)
	* job scheduling with deadlines (exchange argument, turn from an OPT solution to the solution by the greedy algorithm, maintaining the optimality during the transformation)
	* optimal offline caching (minimimize the # cache misses)
Lecture 5 & 6:
	* shortest path algorithm (dijkstra algorithm)
	* minimum spanning tree (cut property, Kruskal's algorithm, Prim's algorithm)
	* implementation of the kruskal's algorithm
	* union-find data structures
	* amortized analysis
Lecture 7:
	* minimum steiner tree
	* P v.s. NP, NP-hard, NP-complete
	* 2-approximation algorithm for minimum Steiner tree
Lecture 8:
	* divide and conquer
	* master's theorem
	* mergesort
	* counting inversions
	* finding the closest pair of points in R^2
Lecture 9:
	* median and quicksort
	* randomized algorithm
	* deterministic algorithm to find median in O(n) time
Lecture 10:
	* lower bound argument
	* decision trees (find the lower bound for comparison based sorting)
	* adversarial argument (find the lower bound for FindingMAX)
	* matrix multiplication
Lecture 11:
	* dynamic programming
	* Fibonacci numbers
	* Knapsack problem
	* Weighted interval scheduling to maximize the profit
	* String algorithm (edit distance)
Lecture 12:
	* matrix chain multiplication
	* minimum weight triangulation
	* shortest path in graphs with negative weights
Lecture 13:
	* Bellman-ford algorithm
	* Distributed implementation  
Lecture 14:
	* Flow algorithms
	* Ford Fulkerson Algorithm
	* residual graph, augmenting path
Lecture 15:
	* max flow min cut theorem
	* flow algorithm: choose the max bottleneck edge 
Lecture 16:
	* Edmonds-Karp Algorithm: choose the shortest path
	* bipartite matching
Lecture 17:
	* edge disjoint paths
	* feasible circulation
Lecture 18:
	* NP-complete, NP-hard
	* polynomial reduction
	* 3SAT, vertex cover, independent set
Lecture 19:
	* polynomial reduction
	* Hamiltonian cycle, TSP, 3-coloring
Lecture 20:
	* Subset Sum, Knapsack problem
	* PTAS for knapsack problem
Lecture 21:
	* approximation algorithms
	* load balancing
	* k-center
Lecture 22:
	* Greedy algorithm for set cover with O(log n) approximation factor
	* 2-approximation for set cover: a greedy algorithm
	* linear programming
Lecture 23:
	* LP rounding
	* vertex cover, set cover by LP rounding
Lecture 24:
	* randomized algorithm
	* contention resolution
	* global min cut