CS302 Final Exam - Answers and Grading

James S. Plank - December 11, 2018

Question 1

A: Median of 0.12, 2.88 and 8.96: The answer is 2.88.
B: I did this on the exam sheet -- going through the vector from left to right and right to left, identifying what gets swapped:
```
6.67  0.66  9.91  0.95  8.26  5.15  9.81  2.72  5.69  8.17  0.88  0.46  6.05
               \           \        \           Stop       /     /     /
                \           \        \--------------------/     /     /
                 \           \---------------------------------/     /
                  \-------------------------------------------------/
```
When I'm done swapping, the array is:
```
6.67  0.66  6.05  0.95  0.46  5.15  0.88  2.72  5.69  8.17  9.81  8.26  9.91
```
I then swap 6.67 with 5.69, and make recursive calls with:
- start = 0, size = 8.
- start = 9, size = 4.
For partial credit, I used the following algorithm:
- There are 4 values > 6.67 and 8 values < 6.67. So if you put 6.67 into one of the two sets, rather than putting it in the correct place, then the answers would be 0-9-9-4 (if you put it in the first partition) or 0-8-8-5. Those answers received 2.5 points rather than three.
- Otherwise, any answer starting with 0-8, or 0-9, or any answer ending with 8-5 or 9-4 received a point.
- 5.69-9-8.17-4 received 2 points.
- A word to those studying from this exam. Please check the types of answers when they are in code. Here, start is an int, so floating point answers don't make sense.

C: Same thing -- you always swap 2.10. left to right and right to left, identifying what gets swapped:

2.10  3.39  1.19  1.19  2.10  3.39  3.39  3.39  1.19  2.10  2.10  2.10  2.10
      \                 \      \    \     \     /     /    /     /     /
       \                 \      \    \     \---/     /    /     /     /
        \                 \      \    \-------------/    /     /     /
         \                 \      \---------------------/     /     /
          \                 \--------------------------------/     /
           \------------------------------------------------------/

When I'm done swapping, the array is:

2.10  2.10  1.19  1.19  2.10  2.10  2.10  1.19  3.39  3.39  3.39  2.10  3.39

I swap the inial 2.10 with 1.19, and make recursive calls with:

start = 0, size = 7.
start = 8, size = 5.

For partial credit:

I gave two points to the following answers, as they were off by one of the 2.10's: 0-6-7-6, 0-6-6-7, 0-7-7-6, 0-8-8-5, 0-8-9-4.
I gave one point to 0-5-5-8, 0-5-6-7, 0-9-9-4, 0-9-10-3,.

D: With merge sort, you simply split the region that you're sorting in half:
- start = 6, size = 3.
- start = 9, size = 3.
E: When the recursive calls are over, elements 6 through 8 will be sorted, and elements 9 thorough 11 will be sorted. The answer is q:
```
3.71  6.35  6.51  5.44  1.43  7.42  0.47  2.97  5.28  0.42  4.42  7.03
```
I gave 0.5 points for g.
E: When you return, elements 6 through 11 will be sorted. The answer is p:
```
3.71  6.35  6.51  5.44  1.43  7.42  0.42  0.47  2.97  4.42  5.28  7.03
```
I gave 0.5 points for a.

Grading

15 points: 2, 3, 3, 3, 2, 2. See above for partial credit.

Question 2

P does more than return "halt." It also returns "infinite loop" if the program goes into an infinite loop.
A very important part of the halting problem is that P has to return in finite time. For that reason, it does not "run the program." Instead, it determines its answer in a finite period of time.
We know whether it's possible to write P: It is impossible.

Grading: Four points for getting one of the three. 10 points for getting two of the three. 12 for getting all three. If you didn't get two, but you tried to tell me the proof, you got two more points. All I cared about was stating the problem, not proving it.

Question 3

When you're answering a question like this, try to think about why I'm specifying the different graphs:

G is a "normal" graph, but it is connected. That means that E ≥ V-1, and O(V+E) will not apply. Anything that is O(V+E) on G will be O(E).
H is a directed, acyclic graph. That means that any problem which would have a Dijkstra-like solution can be solved with topological sort. This will be O(V+E), because we don't know the relationship between V and E.
J is also a directed, acyclic graph. So, like H, you can do those Dijkstra-like problems with topological sort. However, since each node has at most 3 edges coming out of it, E is O(V), so now the solutions are O(V) and not O(V+E). In these cases, I accepted O(V) and O(E) equivalently.
K is now an undirected graph, so the Dijkstra-like problems are O(E log(V)). However, like J, E is O(V), so they are really O(V log(V)). Calling them O(E log(V)) is imprecise, since E is O(V).

Given that:

A: Either Prim or Kruskal's algorithm is O(V log(V))
B: O(1) is a fine answer here, since I said the graph is conntected. Otherwise, you'd use Depth-First Search, which on G is O(E) rather than O(V+E).
C: Topological sort: O(V+E).
D: This is the same thing, but now E is O(V): O(V).
E: Modified Dijkstra: O(E log(V)).
F: Dijkstra, but E is O(V). O(V log(V)).
G: DFS: O(V+E).
H: BFS on G: O(E).
I: We can do this with topological sort: O(V).
J: Prim or Kruskal is O(E log(V)).

Grading: 2 points per part. Here's my partial credit table (the non-listed answers were always zero:

    O(1)  O(V)  O(E)  O(V+E)  O(Vlog(V))  O(Elog(E))
A.  0.0   0.0   0.0    0.0       2.0         1.5
B.  2.0   0.5   2.0    1.5       0.0         0.0
C.  0.0   0.5   1.5    2.0       0.5         1.0
D.  0.0   2.0   2.0    1.5       1.0         0.5
E.  0.0   0.0   0.0    0.0       1.0         2.0
F.  0.0   0.0   0.0    0.0       2.0         1.5
G.  0.0   0.5   1.5    2.0       0.0         0.0
H.  0.0   0.5   2.0    1.5       0.0         0.0
I.  0.0   2.0   2.0    1.5       1.0         0.5
J.  0.0   0.0   0.0    0.0       1.0         2.0

Question 4

Here is the graph for parts A through C:

Part A:

Print A.
A calls DFS on D.
  Print D.
  D calls DFS on C.
    Print C.
    C calls DFS on B.
      Print B.
      B calls DFS on E.
         Print E.
        E calls DFS on C, and C is already visited.
        E returns.
      B returns.
    C returns.
  D calls DFS on E, and E is already visited.
  D returns.
A calls DFS on F.
  Print F.
  F calls DFS on C, and C is already visited.
  F calls DFS on D, and D is already visited.
  F returns.
A returns.

The answer is: A, D, C, B, E, F. Grading: 3 points. If you gave me a valid DFS, ignoring the order of the adjacency lists, you got 1.5 points.

Part B:

Action                                                                  Queue
-----------------------------------------------------------------------------
A is put on the queue                                                   { A }
Pull A off the queuei, and print A.                                     { }
Push D and F on the queue                                               { D, F }
Pull D off the queue, and print D.                                      { F }
Push C and E on the queue                                               { F, C, E }
Pull F off the queue, and print F.                                      { C, E }
Push D on the queue (don't have to push C, because it's already there)  { C, E, D }
Pull C off the queue, and print C.                                      { E }
Push B on the queue                                                     { E, B }
Pull E off the queue, and print E.                                      { B }
Don't push C, because it has been processed already.                    { B }
Pull B off the queue, and print B.                                      { }
Don't push E, because it has been processed already.                    { }
Done.

The answer is: A, D, F, C, E, B. Grading 3 points, with partial credit to valid BFS's if you get the order of the adjacency list wong.

Part C: Start with labeling each node with its number of incident edges:

A B C D E F
0 1 3 2 1 1  (remember, there is no edge BE now)

You will always print a node with zero incident edges, and then decrement the incident edges for each edge on the node's adjacency list:

Action                                    Incident Edges: A B C D E F
----------------------------------------------------------------------
Start                                                     0 1 3 2 1 1
Print A and decrement incident edges for D and F          - 1 3 1 1 0
Print F and decrement incident edges for C and D          - 1 2 0 1 -
Print D and decrement incident edges for C and E          - 1 1 - 0 -
Print E and decrement incident edges for C                - 1 0 - - -
Print C and decrement incident edges for B                - 0 - - - -
Print B                                                   - - - - - -

The answer is: A, F, D, E, C, B.

Grading is 3 points. You got partial credit for starting with AF.

Here is the graph for parts D through F.

The best thing to do here is simply to process Dijkstra's algorithm:

Visit: Best Paths: 0  1  2  3  4  5  Visited: 0 1 2 3 4 5   Multimap:
-------------------------------------------------------------------
Start              0  -  -  -  -  -           N N N N N N   {0,0}
0                  0 15  9  -  - 28           Y N N N N N   {9,2},  {15,1}, {28,5}
2                  0 10  9 17 19 28           Y N Y N N N   {10,1}, {17,3}, {19,4} {28,5}
1                  0 10  9 17 13 28           Y Y Y N N N   {13,4}, {17,3}, {28,5}
4                  0 10  9 17 13 25           Y Y Y N Y N   {17,3}, {25,5}
3                  0 10  9 17 13 24           Y Y Y Y Y N   {24,5}
5                  0 10  9 17 13 24           Y Y Y Y Y Y

Part D: 24.
- 3 points. Part E: 0, 2, 1, 4, 3, 5: Four points, with partial credit for answers that started with 0 and 2.

Part F The easiest thing here is simply to do Kruskals algorithm, going through the edges in increasing order of weight:

Edge                         Components         Action
----------------------------------------------------------
Start                        0 1 2 3 4 5
1-2                          0 12  3 4 5        Add to MST
1-4                          0 124 3   5        Add to MST
1-3                          0 1234    5        Add to MST
3-5                          0 12345            Add to MST
2-3 - Same component.        0 12345            Ignore
0-2                          012345             Add to MST
Done.
----------------------------------------------------------

The answer is: 1-2, 1-4, 1-3, 3-5, and 0-2. You can specify them in any order. Grading is 0.6 per correct edge.

Here is the graph for parts G through J.

Part G: There are only three paths through the graph with flow:

0-1-3-5 with a flow of 5.
0-1-2-3-5 with a flow of 13
0-1-2-4-3-5 with a flow of 8.

So the answer is 0-1-2-3-5.

Grading was 3 points, with 1 point to paths with flow that weren't maximal.

Part H: The minimum hop path is 0-1-3-5, with a flow of 5. So, the residual graph becomes (with changes in red):

  |  0  1  2  3  4  5 |
--| -- -- -- -- -- -- |
0 |  - 25  -  -  -  - |
1 |  5  - 22  -  -  - |
2 | 12  -  - 13  8  - |
3 |  -  5  -  -  - 40 |
4 |  -  -  - 22  -  - |
5 |  -  -  -  5 17  - |
--| -- -- -- -- -- -- |

Grading: 0.7 per correct edge/weight combo. 0.3 per correct edge/weight combo if you chose the path as 0-1-2-3-5 with a flow of 13, and 0.2 per correct edge/weight combo if you chose the path as 0-1-2-4-3-5 with a flow of 8.

Part I: As mentioned above, the cut is composed of edges (1-3), (2-3) and (2-4). Grading: Each of those was worth 1.2 points.

Part J: While you can go through the flow calculation for this formally, it's really easier to eyeball to see that edges (1-3), (2-3) and (2-4) compose the minimum cut. However, if you do go through it formally, you can process the paths above, and there will not be any more paths to process with residual edges:

The answer is 5+13+8 = 26. Grading: 3.2 points. There was some partial credit for 19, 25, 27, 18 and 13.

Grading

Question 5

Part A: Simply clear the cache and call DP(0, B, T):

  Cache.clear();
  return DP(0, B, T);

Some of you took the max of DP(i, B, T) for i going from 0 to N-1. That works too, although it's a little more inefficient. I gave that answer full credit:

Grading: 3 points for the DP() call. 1 for clearing the cache.

Part B: The arguments to DP() seem straightforward. I'd use sprintf():

   sprintf(buf, "%d %d %d", index, b, t);
   key = buf;

Grading: 2 points for the key, and 2 points for the code.

Part C: Again, simply reason through the arguments to get the base cases:

If b is less than zero, then return -1, because you've used up too much money. You didn't need to include this, because were I writing the code, I wouldn't make the recursion on this case. So, if you omitted it, you got two points. If you didn't omit it, you got a point if you returned 0, and two if you returned -1.
If t is zero, then you can return zero, because your team is done. Two points for the correct answer here. One if you got it or the return value wrong.
Otherwise, if index equals N, return -1 because you are out of athletes, but you still need to add more players. You got a point for spotting the base case, and another one if you returned the correct value.

Part D: You're going to make two recursive calls:

The first is when you don't include the player at index on the team:
```
DP(index+1, b, t);
```
The second is when you do include the player at index on the team:
```
DP(index+1, b-C[index], t-1);
```

You got four points for getting one of these, and two more for getting the other. If you had a loop that did the second call for all values of i from index+1 to N, you got full credit, so long as the rest of the details were correct.

Part E: It is the number of potential memoization strings (yes, it's less than that, but in terms of big-O, it will be that): O(N*B*T). Y'all didn't do well on this, answering N! and 2^N. The former is the number of permutations of N elements, and the second is the number of subsets of a set of N elements. Neither is the case here. You simply have N possible values of index, B values of b, and T values of t.