CPSC 450 Syllabus

Week 1: 1/21-1/25

Topics: algorithm analysis

Order the following list of functions by the big-Oh notation, from slowest-growing to fastest. Group together those functions that are big-Theta of one another.

Justify your ordering by stating values of c and n₀ which satisfy the definition of big-Oh for each consecutive pair of functions in your ordering. (i.e. if you claim that f(n) grows more slowly than g(n), which grows more slowly than h(n), you need to demonstrate the f(n) = O(g(n)) and that g(n) = O(h(n))) Keep in mind that to demonstrate big-Theta, you need to show both f(n) = O(g(n)) and g(n) = O(f(n)).

Week 2: 1/28-2/1

Topics: the running times of common ADT operations; searching and lookup: hashtables, binary search trees, balanced binary search trees

What is the big-Oh running time of the classic binary search algorithm (algorithm 3.1, page 143) when applied to a linked list instead of an array? Carry out the algorithm as described, so that key(mid) and elem(mid) involve counting from the beginning of the list in order to locate the key (or element) with the specified key.

Consider an alternative implementation of binary search, written in terms of the Sequence ADT. The idea is to keep track of the number of elements in the range so that the midpoint can be computed, but to then scan from the current location to the midpoint instead of starting at the beginning each time. What is the running time of this algorithm, if the Sequence is implemented using a doubly-linked list?

algorithm binarySearch ( S, k ) :
  input:  sequence S storing n items; search key k
  output:  position containing key k, or null if no such position

  /* initialize current location and range information */
  size = S.size()           /* number of elements in current range */
  current = S.first()       /* marks one end of current range */
  forward = true            /* if true, current is at beginning of range;
                               if false, current is at end */

  while size >= 1 do
    /* find middle of range */
    for count <- 1 to size/2
      if forward then
        current <- S.after(current)
      else
        current <- S.before(current)

    /* update range */
    if current.key() > k then
      if S.isFirst(current) then
        return null   /* if k is before the first thing, it's not there */
      current = S.before(current)
      size = size/2
      forward = false
    else if current.key() < k then
      if S.isLast(current) then
        return null   /* if k is after the last thing, it's not there */
      current = S.after(current)
      size = (size-1)/2
      forward = true
    else 
      return current

  return null

Consider a third alternative implementation of binary search, which avoids having to keep track of the size of the current range. The idea is to find the middle element by simultaneously counting forward and backward from the ends of the range. What is the running time of this algorithm, if the Sequence is implemented using a doubly-linked list?

algorithm binarySearch ( S, k ) :
  input:  sequence S storing n items; search key k
  output:  position containing key k, or null if no such position

  /* initialize range */
  first <- S.first()
  last <- S.last()

  while first != last do
    /* find middle of range */
    middle1 <- first
    middle2 <- last
    while middle1 != middle2 and middle2 != S.after(middle1) do
      middle1 = S.after(middle1)
      middle2 = S.before(middle2)

    /* update range - either middle1 == middle2 (odd number of things) or 
       middle1 is immediately before middle2 (even number of things) */
    if middle1.key() > k then
      last = S.before(middle1)
    else if middle1.key() < k then
      first = S.after(middle1)
    else 
      return middle1

  return null

Week 3: 2/4-2/8

Topics: balanced trees - AVL trees, 2-4 trees, splay trees

Week 4: 2/11-2/15

Topics: skip lists; priority queues and heaps

Week 5: 2/18-2/22

Topics: sorting, recurrence relations, selection; greedy algorithms

  ~bridgeman/cs450/sortdetective/run-sortdetective

Week 6: 2/25-2/29

Topics: greedy algorithms

midterm exam

Week 7: 3/3-3/7

Topics: divide-and-conquer; the master method for solving recurrence relations

Week 8: 3/10-3/14

Topics: divide-and-conquer; dynamic programming

3/17-3/21

spring break

Week 9: 3/24-3/28

Topics: dynamic programming

Files for the splay tree / ordered dictionary project can be found in ~bridgeman/cs450/dictionary - the files include the abstract OrderedDictionary class and header and .o files for several implementations (2-4 tree, AVL tree, skip list, splay tree, sorted vector). In addition, there is a sample of how to get timing information - timer-example.cc uses the times system call to get the time before and after an operation (in the example, the operation is inserting the numbers 0-499 in that order) so the elapsed time can be computed. Finally, there's a tester tester.cc - it's something of an automated tester, as it performs a number of operations and calls a check method belonging to each structure to verify the structure's correctness after each operation. As it is often easier to check that the structure is valid than it is to ensure that the insertion/removal/etc is correct, this is a useful strategy for building one's confidence in the correctness of the structure (though it doesn't prove that the operations are implemented correctly).

Week 10: 3/31-4/4

Topics: dynamic programming

Week 11: 4/7-4/11

Topics: graphs: ADT, implementation, traversals

Week 12: 4/14-4/18

Topics: graphs and graph algorithms

midterm exam, date TBD

Week 13: 4/21-4/25

Topics: graphs and graph algorithms

Write a program to solve Problem A ("Low Cost Air Travel") from the 2006 World Finals of the ACM International Collegiate Programming Contest.

Your program should read input in the format specified, and produce output in the format specified. You should implement any data structures you need if there are not standard versions available (such as the STL vector and stack classes). Strive for an efficient solution - choose an algorithm, data structures, and implementations accordingly. (The appropriateness of your choices, as well as the correctness of your implementation, both count.)

Also hand in a description of your algorithm, and (as usual) justify its correctness and state/justify its running time.

Week 14: 4/28-5/2

Topics: backtracking, branch-and-bound

Week 15: 5/5-5/6

Topics:

Reading Period and Exams: 5/7-5/13

final exam due Tue 5/13 9am

last updated: --Thu May 1 13:42:51 EDT 2008--
page owned by: bridgeman@hws.edu