CS 350 Final Algorithms and Complexity. It is recommended that you read through the exam before you begin. Answer all questions in the space provided.

Transcription

1 It is recommended that you read through the exam before you begin. Answer all questions in the space provided. Name: Answer whether the following statements are true or false and briefly explain your answer in the space provided. 1. [TRUE / FALSE] Any algorithm with a pair of nested loops has a complexity of at least Θ(n 2 ). [5 pts] False; the loops may not be proportional to n. 2. [TRUE / FALSE] The dynamic programming approach to the {0,1} Knapsack problem is more [5 pts] feasible for large instances than the Integer Programming (branch and bound) approach. True, the dynamic programming approach is pseudopolynomial, while BnB is fully exponential. CS 350 Final Page 1 of 14

2 3. [TRUE / FALSE] A brute-force solution is always less efficient than a divide and conquer [5 pts] solution to the same problem. False, some problems do not get more efficient with DnC. 4. [TRUE / FALSE] All bounded optimization problems are reducible to decision problems in [5 pts] polynomial time. True, if the optimal value is bounded we can binary search for it with a polynomial number of calls to the decision problem. 5. [TRUE / FALSE] If P=NP, then NP EXPTIME. [5 pts] True, P EXPTIME. CS 350 Final Page 2 of 14

3 6. Consider problem 1 from homework 4: [10 pts] Given an unsorted array, A of all integers in the range 0...n except for one integer, denoted the missing number, find the missing number. Prove (without giving an algorithm) that this problem is in P. This problem reduces to sorting in polynomial time, and sorting is known to have a PTIME solution. 7. Prove that the general Integer Linear Programming (ILP) problem is NP-Complete. (Hint: [10 pts] reduce from one of the problems we ve seen a lot of.) The knapsack problem reduces to ILP where i x iw i W and i x iv i V, and is known to be in NP-Complete. CS 350 Final Page 3 of 14

4 8. (a) Briefly explain the difference between Memoization and Tabulation with regards to dynamic [4 pts] programming. Memoization is recursion that records values for reuse; Tabulation builds a table from the ground up. (b) When would memoization result in a faster run time than tabulation? When the recursive call tree is very sparse. [3 pts] (c) When would tabulation result in a faster running time? When the overhead of recursive calls dominates the runtime. [3 pts] 9. (a) What is the best case space complexity of Breadth-first Search? (You do not need to prove [5 pts] this, just briefly describe your reasoning.) Space complexity of a BFS on a graph with degree 1 is O(1) (b) What is the worst case space complexity of Depth-first Search? (You do not need to prove this, just briefly describe your reasoning.) Space complexity of a DFS on a graph with degree 1 is O( V ) [5 pts] CS 350 Final Page 4 of 14

5 10. Majority Element An array A[1...n] is said to have a majority element if more than half of its entries are the same. Given an array, design an algorithm to tell whether the input has a majority element, and, if so, to find that element. To compare elements you have access to a constant time transitive and reflexive oracle function, same(a, b) which returns true if a and b are in the same equivalence class and false otherwise. You may not compare elements of the input in any other way. [Sanjoy Dasgupta, Christos H. Papadimitriou, and Umesh Vazirani Algorithms (1 ed.). McGraw-Hill, Inc., New York, NY, USA.] (a) What is the complexity of the brute force solution? (Hint: there is no way of knowing how many distinct elements there are before you ve finished comparing them.) O(n 2 ) - in the worst case, each element must be compared to each other before we know for sure how many there are. We can take a running total of each as we do this. [5 pts] (b) Consider the following divide and conquer algorithm: majority(a): if A = 1: return A[1] l <- majority A[1:n/2] r <- majority A[n/2:n] count elements of A equal to l, if > n/2, return l count elements of A equal to r, if > n/2, return r if neither, exit What is this algorithm s runtime? Prove its correctness by induction. Base case: 1 element is definitely the majority. Inductive step: if we re given the majority of each half, one of these must be the majority if one exists. By checking, we guarantee that we return the right one (or none, if there is none.) [5 pts] CS 350 Final Page 5 of 14

6 (c) There is a more efficient divide and conquer approach. Consider the following subroutine: Pair the elements of A to get n 2 pairs. Look at each pair: if the two elements are different, discard both of them; if they are the same, keep just one. Show that after this procedure there are at most n 2 elements left, and that they have a majority element if A does. Describe an algorithm that uses this subroutine to find a majority element. What is its runtime? By the pigeonhole principle, if there is a majority element, at least two of it will end up paired. In the worst case, no elements mismatch, so the size of the new array is n 2. We recursively call this function on the remaining array until we have a single solution, the we check it in linear time like in part b. By the Master Theorem, or the observation that lg n i=1 ( n 2 )i is a geometric series that converges to 2n, this approach is O(n) [10 pts] CS 350 Final Page 6 of 14

7 It is recommended that you read through the exam before you begin. Choose just one of the following questions. Circle your chosen question and write your solution on the following pages. Be sure to specify the parameters you are using to measure the input size and identify the basic operation. Name: 1. Write an algorithm that implements the word wrap operation. It should take a string and an [40 pts] integer representing the screen width. The output should be a list of strings, each representing a line of text. Make sure your algorithm doesn t split any strings and correctly handles new line characters that are encountered. Find the time and space complexity of your algorithm. ww(s, w): n : ls [], l, word for c 1.. S : word word + c if c = : if c = if l + word w: l l + word word else if l + word = w + 1: else: ls l + word[: word ] l word ls ls + l l word word if l + word w + 1: else: ls l + word[: word ] l word ls ls + l + word l word CS 350 Final Page 7 of 14

8 This algorithm is O( S ) time and space. Its basic operation is string concatenation. Note that using subroutines such as split requires specifying that these are, similarly, O( S ) (if they are.) CS 350 Final Page 8 of 14

9 CS 350 Final Page 9 of 14

10 2. Suppose you are investing. You want to buy low and sell high to maximize your profit. Thanks [40 pts] to the magic of time travel you have acquired an array of future prices, but can only perform two trades, one buy and one sell. Your array of prices is in chronological order and your buy order must precede your sell order. Design a O(n log n) divide and conquer algorithm for finding the maximum profit you can make. Find the space complexity of your algorithm. Solution Discussed in class - recursively solve the left and right sides, then recursively solve the space between those solutions, and compare each combination of buy/sell pairs in these three solutions. The DnC question on the actual final will not require spanning the gap in this way, which means complexity analysis will be much simpler. CS 350 Final Page 10 of 14

11 CS 350 Final Page 11 of 14

12 3. Design an algorithm to implement the paint fill function that one might see on many image [40 pts] editing programs. That is, given a screen (represented by a two dimensional array of colors), a point, and a new color, fill in the surrounding area until the color changes from the original color. Find the time and space complexity of your algorithm. Solution Convert the screen into a graph such that each pixel is a vertex, marked with its color, with edges between it and the pixels up, down, left, and right of it. Use either breadth-first or depth-first search to traverse the graph from the starting point, stopping when you reach a vertex of a different color, while updating each visited vertex to the original. Complexities are in terms of h and w, the height and width of the screen. Either algorithm has time complexity O(hw). If you use depth-first approach, space complexity is O(h + w), as the deepest we can get is a path to a corner ( h+w 2, to be exact). In a breath-first approach the queue will hold 2(h + w) vertices in the worst case - so still O(h + w). In either case, the basic operation is checking/marking the vertex labels. Note that for the exam you would only need to give one of these. CS 350 Final Page 12 of 14

13 CS 350 Final Page 13 of 14

14 4. Given a string, write an algorithm to find the longest substring that is a palindrome. Find the [40 pts] time and space complexity of your algorithm. Example: suppose the input is: sampleracecartest, you should return racecar. (Note: The optimal solution for this problem with use dynamic programming and use Θ(n 2 ) time and space. Partial credit will be awarded for less efficient solutions, with a max of 35 points being available.) Solution We define the problem recursively as looking for a palindrome possibly using the first element of S, and recursively calling on the rest of S So the non-memoized recursive algorithm is: pal(a): m 0 for i A : return m if A[1] = A[i] and pal(a[2 : i]) = i-2: m max(m, i) But we can see that there is overlapping work here, in that when we find the same palindrome candidates multiple times we recompute their lengths. If we update this with memoization (letting s and e be start and end markers): T n x n array of NULL pal(a, s, e): if T [s + 1, e] = NULL: T [s + 1, e] pal(a, s + 1, e) m T [s + 1, e] for i s + 1..e: return m if A[s] = A[i]: Tabulation is less intuitive. Case where we don t use s Cases where we might if T [s + 1, i 1] = NULL: T [s + 1, i 1] pal(a, s + 1, i 1) if T [s + 1, i 1] = i-s-2: m max(m, i) Track best T is an n x n table, and in the worst case half of its cells will be accessed, so runtime and space complexity are both O(n 2 ) The basic operation is comparison, at the line A[s] = A[i], and hidden in the max() function; it happens twice per loop and an additional time outside, in each recursive call; the instances inside the loop can be thought of as outside the other recursive call, so it s roughly constant per call. Thus the number of calls is the dominant term and an appropriate measure of runtime. CS 350 Final Page 14 of 14