Question 2 (Strongly Connected Components, 15 points). What are the strongly connected components of the graph below?

Transcription

1 Question 1 (Huffman Code, 15 points). Consider the following set of letters each occurring with the associated frequencies: A 2, B 3, C 7, D 8, E 10, F 15, G 20, H 40, I 50. Give the tree for the corresponding Huffman code. [It is suggested that you show your work so that it will be easier to assign partial credit if your answer is wrong.] We run the standard algorithm. A and B are lightest, so we combine them into a new node, AB of weight 5. Next we combine AB with C to form ABC of weight 12. D and E are combined to form DE of weight 18. Next ABC combines with F to form ABCF of weight 27. DE and G combine to DEG of weight 38. DEG and ABCF combine to form ABCDEFG of weight 65. H and I combine to form HI of weight 90. And finally ABCDEFG and HI combine to form the root of the tree. The final encoding tree is as shown below: 1

2 Question 2 (Strongly Connected Components, 15 points). What are the strongly connected components of the graph below? [It is suggested that you show your work so that it will be easier to assign partial credit if your answer is wrong.] Performing DFS on G R, we visit the vertices in the following order: A-B-F-H-H-I-I-F-B-A C-J-G-E-E-G-J-C D-D So reverse post-order is DCJGEABFIH Running explore on D, we find the first component, just D. Running explore on C, we find CGJE, the next component. The next new vertex is A. Running explore on A discovers the component AHFB. Finally, the remaining vertex I is an SCC. Thus, the strongly connected components are D, CGJE, AHFB, and I. 2

3 Question 3 (Distance Approximation, 15 points). Given a set of integers A of size n and an integer T, give an algorithm to find the smallest possible value of x y T over all pairs x, y A. For full credit your algorithm should run in time O(n log(n)) or better. Let B be the set of elements x + T for x A. This is equivalent to finding a pair a A and b B with a b as small as possible. We note that by sorting A B, these will necessarily be adjacent elements in the list. Our algorithm is as follows: Let B be the set of elements x+t for x in A Let C be obtained by sorting the lists A and B together BestSoFar <- Infinity For i = 1 to 2n-1 If one of C[i] and C[i+1] from A and the other from B BestSoFar <- min(bestsofar, C[i+1]-C[i]) Return BestSoFar The sorting takes O(n log(n)) time and the for loop takes O(n) time. Thus, the final runtime is O(n log(n)). 3

4 Question 4 (Board Game Probability, 15 points). Johnny is playing a board game. His piece is on a track and on every turn he rolls a fair six sided die and advances his piece that many squares. Johnny is attempting to reach a square n steps ahead of his current location. Give an algorithm to compute the probability that he will reach or pass this square within the next k turns and analyze the runtime of this algorithm. For full credit your algorithm should have runtime O(nk) or better. We solve this by dynamic programming. In particular, we let P (t, s) be the probability that Johnny will travel at least s squares in the next t turns. We note that P (t, s) = 1 if s 0 and that P (t, s) = 0 if s > 0 and t = 0. Otherwise for s, t 0, P (t, s) = 1/6(P (t 1, s 1) + P (t 1, s 2) + P (t 1, s 3) + P (t 1, s 4) + P (t 1, s 5) + P (t 1, s 6)) because after a single roll Johnny will have somewhere between s 1 and s 6 squares to travel in t 1 turns. The algorithm is as follows: Initialize array P[0...k,-5...n] for t = 0 to k for s = -5 to 0 P[t,s] <- 1 for s = 1 to n P[0,s] <- 0 for t = 1 to k for s = 1 to n P[t,s] <- (P[t-1,s-1]+P[t-1,s-2]+P[t-1,s-3]+P[t-1,s-4]+P[t-1,s-5]+P[t-1,s-6])/6 Return P[k,n] To show correctness, we note that the initial fills of the table are all the correct values of P (t, s). By induction, we show that all later fills of P [t, s] are with the correct value of P (t, s) by using the recurrence above. The runtime is dominated by the final nested loop which runs O(nk) times doing constant work per iteration, thus the final runtime is O(nk). 4

5 Question 5 (Shortest Simple Path, 20 points). Consider the following problem ShortestSimplePath, which given a weighted graph G (possibly with negative edge weights), and vertices s, t of G asks for the smallest weight of a path in G from s to t that uses no vertex more than once. Show that ShortestSimplePath is NP-Hard. We find a reduction from Hamiltonian Cycle. In particular, let G be a graph. Pick a vertex v in G, and create a new graph G from G by adding another vertex v whose neighbors are the same as the neighbors of v. Give all edges in G weight 1. We claim that G has a Hamiltonian cycle if and only if G has a simple path from v to v of length at most V. This would allow us to solve Hamiltonian Cycle on G if we could solve Shortest Simple Path on G. First, we note that a simple path in G uses each vertex at most once, and therefore uses at most V G 1 = V G edges with equality if and only if it uses each vertex exactly once. Since each edge has length 1, this path has length V G or smaller if and only if it uses each vertex of G once. If this path is turned into a path in G (making the final edge to v connect to v instead), we get a Hamiltonian Cycle in G. Thus, is G has a short simple path, G has a Hamiltonian Cycle. To go the other way, given a Hamiltonian Cycle in G, think of it as a path from v back to v. By making the last edge connect to v instead, we get a short simple path in G. 5

6 Question 6 (Closest Pair of Points, 20 points). Given an unweighted, undirected graph G and a set S of the vertices in G give an algorithm to compute the length of the shortest path connecting two different vertices of S. For full credit, your algorithm should run in linear time. We are going to run BFS starting at all elements of S simultaneously. We are also going to record for each vertex discovered, which vertex of S was the closest. The shortest path between vertices of S will be found when we find an edge connecting vertices closest to different members of S. The algorithm is as follows: Best <- Infinity Create Queue Q For v in S d(v) <- 0 closest(v) <- v enqueue(v) while(q non empty) u <- front(q) for (u,w) in E if d(w) undefined d(w) <- d(u) + 1 closest(w) <- closest(u) enqueue(w) else if closest(w) not closest(u) Best <- min(best,d(w)+d(u)+1) return Best The runtime analysis is similar to that of BFS, and is thus linear. To show correctness, we claim that for each vertex v, d(v) is set to the distance to the closest element of S and closest(v) to one of the closest elements of S. This is because elements are added to Q in increasing order of d. We can then prove by induction on the order of distance from v to S that d(v) is the correct distance with the correct closest element. This is because d(v) is set to be 1 more than the smallest d value of it s neighbor. This should be, by the inductive hypothesis, one less than the distance from v to the closest point in S. Furthermore, the closest points in S are assigned correctly. Next we claim that the returned answer is correct. Firstly, the answer is always of the form d(u)+d(w)+1 where u is within d(u) of some vertex of S, w is within d(w) of some different vertex of S and u and w are adjacent. It is clear that by going through the edge (u, w) that there is a path between these vertices of length d(u) + d(w) + 1. Furthermore, we claim that for any path of length l between distinct vertices of S that the returned value is at most l. This is because along this path there must be some edge (u, w) with closest(u) closest(w). For this pair d(u) + d(w) + 1 is at most l. This completes the proof. 6