MIDTERM I CMPS Winter 2013 Warmuth

Transcription

1 test I 1 MIDTERM I CMPS Winter 2013 Warmuth With Solutions NAME: Student ID: This exam is closed book, notes, computer and cell phone. Show partial solutions to get partial credit. Make sure you have answered all parts of a question. If your solutions are not written legibly, you won t get full credit. Clarity and succinctness will be rewarded. Question 1: (out of 15) Question 2: (out of 15) Question 3: (out of 10) Question 4: (out of 10) Question 5: (out of 10) Question 6: (out of 10) Question 7: (out of 10) Question 8: (out of 10) Question 9: (out of 10) Total: (out of 100)

2 test I 2 1. Short questions: (a) What is the recurrence for MergeSort and what is its running time in Θ notation? For some constant c>0, T(n)=2 T(n/2)+cn=Θ(nlogn). (b) What is the information theoretic lower bound for sorting and what is the key operation that the sorting algorithm is allowed to use for determining the order of keys? lg(n!) = Ω(n logn) comparisons. (c) What is the running time of RadixSort for sorting n numbers with d digits each, where each digit has the range from 0 to k 1. Θ(d(n+k)) (d) What are two good properties of QuickSort? In place - average case O(nlogn) with a very low constant - very little additional space: (O(logn) for stack if done right). (e) What is a bad property of HeapSort? High constant in average case - not stable

3 test I 3 2. Show by induction that the number of nodes in a binary tree is odd. Prove this by an induction on the number of nodes. Here a binary tree is any tree where each node has 0 or 2 children. Hints: Draw some small trees. Weak or strong induction? What is your base case? Proof A) Base case: Tree of 1 node which is odd. Strong induction: Assume any binary tree with n has an odd # of nodes. Induction step: Given a tree with n + 1 nodes. Remove the root. If tree was binary then tree splits into two binary trees with n nodes. By induction hypothesis both have an odd number of nodes. So by adding the root we get Proof B) Setup as above. odd # from left + root + odd # from right = odd total. Induction step: Given a binary tree with n + 1 nodes. Find a node with exactly 2 leaves. Remove both. You end up with a tree with n+1 2 n nodes. Note that the parity of n+1 and n+1 2 is the same. If n+1 2 is odd, then the smaller tree is binary and adding the 2 leaves keeps it binary. If n+1 2 is even, then the smaller tree is not binary and adding the 2 leaves back in results in a non-binary tree.

4 test I 4 3. Bucket Sort sorts n numbers that are distributed uniformly in the range [0,1) in O(n) expected time. Explain why the worst-case running time of Bucket Sort is Θ(n 2 ). In what case does the worst-case occur? When all n keys end up on the same bucket: In that case, InsertionSort requires Θ(n 2 ) to sort that bucket. What simple change to the algorithm preserves its linear average-case running time and makes its worst-case running time O(nlogn). Reason your answer. Apply a different sorting algorithm to each bucket that is O(n logn) in the worst-case (such as HeapSort). Since the function nlogn is convex, the worst-case still happens when all keys end up in the same bucket and the cost is O(nlogn). A smart variant is the following: Choose a cutoff n 0. If the size of the bucket is n 0, then apply InsertionSort. Otherwise sort bucket with HeapSort.

5 test I 5 4. Consider the following heap (a) Redraw the heap after inserting the key (b) Redraw the heap after doing a Deletemax operation to the heap on top of the page (c) Name two operation besides Deletemax and Changekey that can be done efficiently on a heap? ExtractMax and Insert. What are the running times of each of the two operations? ExtractMax is O(1) Insert is Θ(logn) in the worst-case.

6 test I 6 5. Show that n i=1 log(i+3) is Θ(nlogn). n i=1 log(i+3) n i=1 log(n+3) = nlog(n+3) nlog(4n) = nlogn+nlog4 = nlogn+o(n) = O(nlogn) n i=1 log(i+3) n i=1 logi n log n/2 i=n/2 = n/2logn/2 = n/2logn+n/2log1/2 max(n/2logn,n/2log1/2) = n/2 log n, for large enough n = Ω(nlogn)

7 test I 7 6. Use the below Master Theorem to give a tight asymptotic bound for the following recurrence: T(n) = 8 T(n/2)+10 n 2. a=8, b=2, log 2 8=3, and we can apply case 1 with ε=1: f(n)=n 2 = O(n 3 1 ). It follows that T(n)=Θ(n 3 ). Master Theorem. Let a 1 and b>1 be constants, let f(n) be a function, and let T(n) be defined on the nonnegative integers by the recurrence T(n)=aT(n/b)+ f(n). Then T(n) has the following asymptotic bounds: (a) If f(n)=o(n log b a ε ) for some constant ε>0, then T(n)=Θ(n log b a ). (b) If f(n)=o(n log b a ), then T(n)=Θ(n log b a lgn). (c) If f(n)=ω(n log b a+ε ), for some constant ε>0, and if a f(n/b) c f(n) for some constant c < 1 and all sufficiently large n, then T(n)=Θ( f(n)).

8 test I 8 7. You are given an n n array A(i, j) of numbers. After a certain preprocessing step, you should be able to compute queries of the following form in O(1) time: Input: i 1, i 2, j 1, j 2, such that 1 i 1 i 2 n, 1 j 1 j 2 n. Output: i 2 i=i1 j 2 j= j1 A(i, j). (a) What is the preprocessing you need to do? How do you do it? How expensive is it? Compute the sums S(r,s)= r i=1 s j=1 A(i, j) in O(n2 ) by noting the recurrence S(i+ 1, j+ 1) = A(i, j)+s(i+1, j)+s(i, j+ 1) S(i, j). The computation can be done in O(n 2 ) as we spend constant time on each element by making use of previously computed results and there are n 2 elements to compute. (b) With the preprocessing, how do you process a query? What is the running time? The query of form i 2 i=i1 j 2 j= j1 A(i, j) can be computed as S(i 2, j 2 ) S(i 1 1, j 2 ) S(i 2, j 1 1)+S(i 1 1, j 1 1). This is O(1) since S(.,.) is available.

9 test I 9 8. (a) What is the information theoretic lower bound on the number of comparisons needed for the following problem: Find the largest and second largest key out of a set of n keys? lg( number of outcomes ) = lg(n(n 1)) = Θ(lg n). This is weak bound. (b) Sketch an algorithm solving this problem with as few comparisons as possible. How many comparisons does your method require? Run a tournament on your n keys, requiring n 1 comparisons. The second largest must have lost against the winner. This occurs at all but the bottom level, i.e. lgn times. Choosing the largest among the lgn losers costs another lgn 1 comparisons - for a total of n+ lgn 2 comparisons.

10 test I Show that n+3 is o(nlnn). Use l Hospital s rule: n+3 lim n nlnn = lim n 1 lnn+n/n = lim lnn+1 = 0 n 1