CS302 Final Exam: December 4, 2008 - Answers and Grading.

Question 1 (Six Points)

It's also clear that the only edges in the flow graph that compose a cut in the original graph are CE, CD and AB.

Grading

• Part 1: Three points. If you missed a path, you lost 1.5 points.
• Part 2: Three points. If you included the edge DA (which many of you did by drawing a picture), you lost a point.

Scores

Question 2 (Nine Points)

• Problem 1: This is a shortest path problem on a weighted graph: g.
• Problem 2: This is directly from the lecture notes: d.
• Problem 3: While not from the lecture notes, this is the same thing -- if we can characterize the input, we can predict roughly where a number will be, and then clean it up with insertion sort. It will run faster than Quicksort: d.
• Problem 4: When we have no clue, Quicksort will be the fastest: c. I gave 0.5 points for a in case you were thinking of the STL's sort() algorithm, which is different from sets and maps.
• Problem 5: This is depth-first search -- just as in the connected components example from the lecture notes. Breadth-first search would work also. Disjoint Sets do not work here, because you have to add every edge. Think about performance -- if there are only a few nodes connected to the node, depth-first search will finish very quickly. A disjoint-set implementation will have to go through every edge in the graph before it can make that determination, and then you still have to perform find operations to figure out which node is in the same set as the given node: e or f. I gave 0.5 points for j.
• Problem 6: Straight from the lecture notes: j.

Scores

Question 3 (Six Points)

Part 2: Prim's algorithm is like Dijkstra's. You maintain a map of nodes not in the tree ordered by their distance from the tree. I'm also keeping the backedges of how the nodes got into the map. Here is each iteration:

Grading

Scores

Question 4 (Nine Points)

• ABCFI
• ABEFI
• ADGHI
• ADHFI

Part 2: The Max Flow Path: The maximum flow path through the graph is ABCFI with a flow of 82. After that, you have to start with edge AD, and finish with edge HI, because edge FI's remaining capacity is 24. The path ADHI uses both of those edges and has the maximum flow of 26. The answer is g.

Part 3: Greedy DFS: If we do a depth-first search where we always use the maximum capacity edge from a node, the first path will be ADHFI with a flow of 38. The next path will be ABCFI with a flow limited by edge FI, whose capacity is now 68. Thus, the answer is u.

Grading

• Part 1: Three for y, 1.5 for z, 1.5 for 1, 1.5 for 2, 1 for 3, 1 for 4.
• Part 2: Three for g, 2 for e, 1.5 for f, 1 for h, 1 for i, 1 for j, 1 for k.
• Part 3: Three for u, 2 for v, 1 for w, 1 for x.

Scores

Question 5 (12 points)

1. Use insertion sort when the array is sufficiently small. In the lecture notes, that size was 7. If you did any reasonable size, it counted.

2. Choose the pivot to be the median of the first, last and middle elements.

void quick_sort(double *array, int size)
{
  double p[3];
  int index;

  if (size <= 7) {
    insertion_sort(array, size);
    return;
  } 
  
  p[0] = array[0];
  p[1] = array[size-1];
  p[2] = array[size/2];
  insertion_sort(p, 3);
  index = partition(array, size, p[1]);
  quick_sort(array, index);
  quick_sort(array+index, size-index);
}

Grading

• Using insertion sort lower than a threshold value: 2 points if the threshold value is bigger than three. If it was three, and you were doing it for correctness rather than performance, then you got 1.5 points.
• Finding a pivot that is the middle of the first/last/middle elements: 4 points
• Correct partition call: 2 point
• Correct recursive calls: 4 points

Scores

Question 6 (17 points)

list <Edge *> Graph::Min_Hop_Path()
{
  list <Node *> bfsq;
  list <Node *>::iterator bit;
  list <Edge *>::iterator ait;
  list <Edge *> path;
  Node *n, *n2;
  Edge *e;

  source->tmp = 1;
  bfsq.push_back(source);

  while (1) {

    if (bfsq.empty()) return path;

    bit = bfsq.begin();
    n = *bit;
    bfsq.erase(bit);
    
    if (n != sink) {
      for (ait = n->adj.begin(); ait != n->adj.end(); ait++) {
        e = *ait;
        n2 = e->to;
        if (n2->tmp == 0) {
          n2->tmp = 1;
          n2->backedge = e;
          bfsq.push_back(n2);
        }
      }
    } else {
      while (n != source) {
        path.push_front(n->backedge);
        n = n->backedge->from;
      }
      return path;
    }
  }
}

Grading

• Initialization: 2
• Handling an empty queue: 2
• Getting the first node on the queue and erasing it: 3
• Traversing the edges and pushing the nodes onto the queue: 6
• Handling the sink: finding and returning the path: 4

Scores