CPSC 327 Syllabus

Week 1: 1/17-1/21

Topics: introduction; algorithm analysis

Thinking Problem: An algorithm takes n English words as input. Is the number of words a fair measure of input size? Explain.

Notes: time complexity

Week 2: 1/24-1/28

Topics: algorithm analysis

Notes: homework 1, T(n) from algorithms

Week 3: 1/31-2/4

Topics: iterative algorithms

Thinking Problem: The algorithm development steps presented in the chapter help you figure out the algorithm, but they don't directly produce pseudocode or code. Write pseudocode or Java code for the binary search algorithm developed in example 1.4.3 (pages 24-25), then point out how that matches up with the 13 steps given. (The idea here is to think about how the pieces of information from each step come together into the complete algorithm.)

Notes: steps for developing iterative algorithms

Thinking Problem: Give a more-of-the-input style loop invariant for the following problem: A is a sorted array of length n and B is a sorted array of length m. Produce C, a sorted array containing the elements from A and B (including duplicates, if there are any).

Notes: using the steps to develop iterative algorithms

Notes: basic steps, measures of progress, and loop invariants

Week 4: 2/7-2/11

Topics: iterative algorithms; greedy algorithms

Thinking Problem: Exercise 16.1.1 (page 235). Justify your answer in the style of the proof in the chapter (a proof or a counterexample) - don't just state "yes" or "no".

Week 5: 2/14-2/18

Topics: greedy algorithms; ADTs

Thinking Problem: Categorize the ADTs presented in the reading according to how elements are positioned and the primary kinds of methods the collection supports:

• how elements are positioned: algorithmically (the ADT determines how elements are arranged) or manually (the user of the ADT has control over how elements are arranged)
• what methods the collection supports: determine if an element is a member of the collection, after/before (methods based on ordering of elements), access elements with highest priority, access elements at any position, access elements only at ends (first/last)

Notes: a couple of comments on hw #6 but mostly ADTs and thinking about implementation details

Week 6: 2/21-2/25

Topics: implementing ADTs

Notes: priority queues and heaps

• AVL trees: source 1, source 2
• 2-4 trees: source 1, source 2

Thinking Problems:

1. Insert the elements 50, 60, 70, 20, 10, 25, 40, 30, 28 into an initially empty AVL tree, drawing the tree after each step.
2. Insert the elements 5, 16, 22, 45, 2, 10, 18, 30, 50, 12, 1 into an initially empty 2-4 tree, drawing the tree after each step.

Notes: array implementation of heaps, AVL trees

Week 7: 2/28-3/4

Topics: implementing ADTs

Thinking Problems:

• How do you delete an element from a hashtable?
• How likely are collisions? Do a calculation: assuming that each day is equally likely as someone's birthday, what is the probability that there are no shared birthdays in a class of 30 students?

Notes: hashtables

Week 8: 3/7-3/11

Topics: graphs and graph algorithms

Thinking Problem: exercise 14.1.1 (page 178) - for each search technique, start with node s and list the nodes in the order in which they are handled

Notes: graphs; Graph ADT; implementing the Graph ADT

Thinking Problem: exercise 14.3.3, parts #4 and #5 only (page 188)

Notes: reachability (and another example of developing iterative algorithms + runtime)

Spring Break

Week 9: 3/21-3/25

Topics: graph algorithms; recursion

Notes: weighted shortest path (Dijkstra's algorithm), minimum spanning tree (Kruskal's algorithm)

Thinking Problem: Construct a recursive algorithm for the task of finding the smallest element in an array. (Yes, I know there is a simple iterative algorithm. That's not the point here.) Write your algorithm in code or pseudocode, and demonstrate that you've satisfied the checklist for recursive algorithms given in section 8.5.

Notes: developing recursive algorithms

Week 10: 3/28-4/1

Topics: recursion and recurrence relations

Thinking Problem: Do either #1 or #2 and any one of #3-#7 (two problems total) from exercise 27.1.1 (pages 400-401) - without looking at the solution in the back of the book.

Notes: solving recurrence relations

Thinking Problem: In general, having fewer subproblems and reducing the amount of work needed to create and combine subproblems will make a recursive algorithm run faster. But what about specific advice? Imagine that you've developed a recursive algorithm with a time T(n) = a T(n/b) + f(n). Would it be more productive to think about how to reduce the number of subproblems (as was done in the exponentiation, multiplication, and matrix multiplication examples) or how to reduce the work done splitting/combining? Does your answer depend on the particular equation for T(n)? If so, how?

Notes: messy sums and recurrence relations that don't fit the table

Week 11: 4/4-4/8

Topics: divide-and-conquer

Week 12: 4/11-4/15

Topics: recursive backtracking and branch-and-bound

Thinking Problem: exercise 17.5.1 (page 265), without looking at the solutions in the back of the book

Notes: recursive backtracking

Week 13: 4/18-4/22

Topics: dynamic programming

Thinking Problems:

1. The book discusses turning a recursive backtracking algorithm into an iterative dynamic programming algorithm. Does a dynamic programming algorithm have to be iterative? That is, could you write it recursively without changing the big-Oh? Explain.
2. Where does the polynomial running time come from?

Notes: a couple of notes of determining running times of algorithms, branch and bound wrapup, dynamic programming

Thinking Problem: List two pieces of advice and/or strategies for developing dynamic programming algorithms.

Notes: dynamic programming (longest common subsequence)

Notes: dynamic programming (weighted event scheduling, matrix chain product)

Week 14: 4/25-4/29

Topics: dynamic programming; complexity

Thinking Problem: exercise 19.8.1 (just explain how map the elephant problem to the graph problem, and how to turn a solution to the graph problem into a solution for the elephant problem - you do not need to repeat how to solve the graph problem)

Notes: solving problems; reductions

Thinking Problem: exercise 20.1.1 (choose three of the parts)

Notes: reductions (event tour, elephants, billboards)

Week 15: 5/2-5/3

Topics: complexity; wrapup

Exams: 5/7-5/10

last updated: --Tue May 3 21:22:53 EDT 2011--
page owned by: bridgeman@hws.edu