In justifying our matrix multiplication algorithm (Section 2.5), we claimed the

Use the divide-and-conquer integer multiplication algorithm to multiply the two binary integers 10011011 and 10111010.

Show that for any positive integers n and any base b, there must some power of b lying in the range [n, bn].

Section 2.2 describes a method for solving recurrence relations which is based on analyzing the recursion tree and deriving a formula for the work done at each level. Another (closely related) method is to expand out the recurrence a few times, until a pattern emerges. For instance, lets start with the familiar T(n) = 2T(n/2) + O(n). Think of O(n) as being cn for some constant c, so: T(n) 2T(n/2) + cn. By repeatedly applying this rule, we can bound T(n) in terms of T(n/2), then T(n/4), then T(n/8), and so on, at each step getting closer to the value of T() we do know, namely T(1) = O(1). T(n) 2T(n/2) + cn 2[2T(n/4) + cn/2] + cn = 4T(n/4) + 2cn 4[2T(n/8) + cn/4] + 2cn = 8T(n/8) + 3cn 8[2T(n/16) + cn/8] + 3cn = 16T(n/16) + 4cn . . . A pattern is emerging... the general term is T(n) 2 kT(n/2 k ) + kcn. Plugging in k = log2 n, we get T(n) nT(1) + cn log2 n = O(n log n). (a) Do the same thing for the recurrence T(n) = 3T(n/2) + O(n). What is the general kth term in this case? And what value of k should be plugged in to get the answer? (b) Now try the recurrence T(n) = T(n 1) + O(1), a case which is not covered by the master theorem. Can you solve this too?

Suppose you are choosing between the following three algorithms: Algorithm A solves problems by dividing them into five subproblems of half the size, recursively solving each subproblem, and then combining the solutions in linear time. Algorithm B solves problems of size n by recursively solving two subproblems of size n 1 and then combining the solutions in constant time. Algorithm C solves problems of size n by dividing them into nine subproblems of size n/3, recursively solving each subproblem, and then combining the solutions in O(n 2 ) time. What are the running times of each of these algorithms (in big-O notation), and which would you choose?

Solve the following recurrence relations and give a \(\Theta bound for each of them. 1. \(T(n)=2 T(n / 3)+1\) 2. \(T(n)=5 T(n / 4)+n\) 3. \(T(n)=7 T(n / 7)+n\) 4. \(T(n)=9 T(n / 3)+n^{2}\) 5. \(T(n)=8 T(n / 2)+n^{3}\) 6. \(T(n)=49 T(n / 25)+n^{3 / 2} \log n\) 7. \(T(n)=T(n-1)+2\) 8. \(T(n)=T(n-1)+n^{c}\), where \(c \geq 1\) is a constant 9. \(T(n)=T(n-1)+c^{n}\), where \(c>1\) is some constant 10. \(T(n)=2 T(n-1)+1\) 11. \(T(n)=T(\sqrt{n})+1\)

A linear, time-invariant system has the following impulse response: (a) Describe in words the effect of this system. (b) What is the corresponding polynomial?

What is the sum of the nth roots of unity? What is their product if n is odd? If n is even?

Practice with the fast Fourier transform. (a) What is the FFT of (1, 0, 0, 0)? What is the appropriate value of in this case? And of which sequence is (1, 0, 0, 0) the FFT? (b) Repeat for (1, 0, 1, 1).

Practice with polynomial multiplication by FFT. (a) Suppose that you want to multiply the two polynomials x + 1 and x 2 + 1 using the FFT. Choose an appropriate power of two, find the FFT of the two sequences, multiply the results componentwise, and compute the inverse FFT to get the final result. (b) Repeat for the pair of polynomials 1 + x + 2x 2 and 2 + 3x.

Find the unique polynomial of degree 4 that takes on values p(1) = 2, p(2) = 1, p(3) = 0, p(4) = 4, and p(5) = 0. Write your answer in the coefficient representation.

In justifying our matrix multiplication algorithm (Section 2.5), we claimed the following blockwise property: if X and Y are n n matrices, and X =  A B C D  , Y =  E F G H  where A, B, C, D, E, F, G, and H are n/2 n/2 submatrices, then the product XY can be expressed in terms of these blocks: XY =  A B C D   E F G H  =  AE + BG AF + BH CE + DG CF + DH  Prove this property.

How many lines, as a function of n \(\text { (in } \Theta(\cdot)\) form), does the following program print? Write a recurrence and solve it. You may assume n is a power of 2. function f(n) if n > 1: print line(“still going'') f(n/2) f(n/2)

A binary tree is full if all of its vertices have either zero or two children. Let Bn denote the number of full binary trees with n vertices. (a) By drawing out all full binary trees with 3, 5, or 7 vertices, determine the exact values of B3, B5, and B7. Why have we left out even numbers of vertices, like B4? (b) For general n, derive a recurrence relation for Bn. (c) Show by induction that Bn is (2n).

You are given an array of n elements, and you notice that some of the elements are duplicates; that is, they appear more than once in the array. Show how to remove all duplicates from the array in time O(n log n).

In our median-finding algorithm (Section 2.4), a basic primitive is the split operation, which takes as input an array S and a value v and then divides S into three sets: the elements less than v, the elements equal to v, and the elements greater than v. Show how to implement this split operation in place, that is, without allocating new memory.

You are given an infinite array A[] in which the first n cells contain integers in sorted order and the rest of the cells are filled with . You are not given the value of n. Describe an algorithm that takes an integer x as input and finds a position in the array containing x, if such a position exists, in O(log n) time. (If you are disturbed by the fact that the array A has infinite length, assume instead that it is of length n, but that you dont know this length, and that the implementation of the array data type in your programming language returns the error message whenever elements A[i] with i > n are accessed.)

Given a sorted array of distinct integers A[1, . . . , n], you want to find out whether there is an index i for which A[i] = i. Give a divide-and-conquer algorithm that runs in time O(log n).

Consider the task of searching a sorted array A[1 . . . n] for a given element x: a task we usually perform by binary search in time O(log n). Show that any algorithm that accesses the array only via comparisons (that is, by asking questions of the form is A[i] z?), must take (log n) steps.

A k-way merge operation. Suppose you have k sorted arrays, each with n elements, and you want to combine them into a single sorted array of kn elements (a) Heres one strategy: Using the merge procedure from Section 2.3, merge the first two arrays, then merge in the third, then merge in the fourth, and so on. What is the time complexity of this algorithm, in terms of k and n? (b) Give a more efficient solution to this problem, using divide-and-conquer.

Show that any array of integers x[1 . . . n] can be sorted in O(n + M) time, where M = max i xi min i xi . For small M, this is linear time: why doesnt the (n log n) lower bound apply in this case?

Mean and median. One of the most basic tasks in statistics is to summarize a set of observations {x1, x2, . . . , xn} R by a single number. Two popular choices for this summary statistic are: The median, which well call 1 The mean, which well call 2 (a) Show that the median is the value of that minimizes the function X i |xi |. You can assume for simplicity that n is odd. (Hint: Show that for any 6= 1, the function decreases if you move either slightly to the left or slightly to the right.) (b) Show that the mean is the value of that minimizes the function X i (xi ) 2 . One way to do this is by calculus. Another method is to prove that for any R, X i (xi ) 2 = X i (xi 2) 2 + n( 2) 2 . Notice how the function for 2 penalizes points that are far from much more heavily than the function for 1. Thus 2 tries much harder to be close to all the observations. This might sound like a good thing at some level, but it is statistically undesirable because just a few outliers can severely throw off the estimate of 2. It is therefore sometimes said that 1 is a more robust estimator than 2. Worse than either of them, however, is , the value of that minimizes the function max i |xi |. (c) Show that can be computed in O(n) time (assuming the numbers xi are small enough that basic arithmetic operations on them take unit time).

You are given two sorted lists of size m and n. Give an O(log m + log n) time algorithm for computing the kth smallest element in the union of the two lists.

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, the task is to design an efficient algorithm to tell whether the array has a majority element, and, if so, to find that element. The elements of the array are not necessarily from some ordered domain like the integers, and so there can be no comparisons of the form is A[i] > A[j]?. (Think of the array elements as GIF files, say.) However you can answer questions of the form: is A[i] = A[j]? in constant time. (a) Show how to solve this problem in O(n log n) time. (Hint: Split the array A into two arrays A1 and A2 of half the size. Does knowing the majority elements of A1 and A2 help you figure out the majority element of A? If so, you can use a divide-and-conquer approach.) (b) Can you give a linear-time algorithm? (Hint: Heres another divide-and-conquer approach: Pair up the elements of A arbitrarily, 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 of them Show that after this procedure there are at most n/2 elements left, and that they have a majority element if and only if A does.)

On page 66 there is a high-level description of the quicksort algorithm. (a) Write down the pseudocode for quicksort. (b) Show that its worst-case running time on an array of size n is (n 2 ). (c) Show that its expected running time satisfies the recurrence relation T(n) O(n) + 1 n nX1 i=1 (T(i) + T(n i)). Then, show that the solution to this recurrence is O(n log n).

In Section 2.1 we described an algorithm that multiplies two n-bit binary integers x and y in time n a , where a = log2 3. Call this procedure fastmultiply(x, y). (a) We want to convert the decimal integer 10n (a 1 followed by n zeros) into binary. Here is the algorithm (assume n is a power of 2): function pwr2bin(n) if n = 1: return 10102 else: z =??? return fastmultiply(z, z) Fill in the missing details. Then give a recurrence relation for the running time of the algorithm, and solve the recurrence. (b) Next, we want to convert any decimal integer x with n digits (where n is a power of 2) into binary. The algorithm is the following: function dec2bin(x) if n = 1: return binary[x] else: split x into two decimal numbers xL, xR with n/2 digits each return ??? Here binary[] is a vector that contains the binary representation of all one-digit integers. That is, binary[0] = 02, binary[1] = 12, up to binary[9] = 10012. Assume that a lookup in binary takes O(1) time. Fill in the missing details. Once again, give a recurrence for the running time of the algorithm, and solve it.

Professor F. Lake tells his class that it is asymptotically faster to square an n-bit integer than to multiply two n-bit integers. Should they believe him?

The square of a matrix A is its product with itself, AA. (a) Show that five multiplications are sufficient to compute the square of a 2 2 matrix. (b) What is wrong with the following algorithm for computing the square of an n n matrix? Use a divide-and-conquer approach as in Strassens algorithm, except that instead of getting 7 subproblems of size n/2, we now get 5 subproblems of size n/2 thanks to part (a). Using the same analysis as in Strassens algorithm, we can conclude that the algorithm runs in time O(n log2 5 ). (c) In fact, squaring matrices is no easier than matrix multiplication. In this part, you will show that if n n matrices can be squared in time S(n) = O(n c ), then any two n n matrices can be multiplied in time O(n c ). i. Given two n n matrices A and B, show that the matrix AB + BA can be computed in time 3S(n) + O(n 2 ). ii. Given two n n matrices X and Y , define the 2n 2n matrices A and B as follows: A =  X 0 0 0  and B =  0 Y 0 0  . What is AB + BA, in terms of X and Y ? iii. Using (i) and (ii), argue that the product XY can be computed in time 3S(2n) + O(n 2 ). Conclude that matrix multiplication takes time O(n c ).

The Hadamard matrices H0, H1, H2, . . . are defined as follows: H0 is the 1 1 matrix 1 For k > 0, Hk is the 2 k 2 k matrix Hk =  Hk1 Hk1 Hk1 Hk1  Show that if v is a column vector of length n = 2 k , then the matrix-vector product Hkv can be calculated using O(n log n) operations. Assume that all the numbers involved are small enough that basic arithmetic operations like addition and multiplication take unit time.

Suppose we want to evaluate the polynomial p(x) = a0 + a1x + a2x 2 + + anx n at point x. (a) Show that the following simple routine, known as Horners rule, does the job and leaves the answer in z. z = an for i = n 1 downto 0: z = zx + ai (b) How many additions and multiplications does this routine use, as a function of n? Can you find a polynomial for which an alternative method is substantially better?

This problem illustrates how to do the Fourier Transform (FT) in modular arithmetic, for example, modulo 7. (a) There is a number such that all the powers , 2 , . . . , 6 are distinct (modulo 7). Find this , and show that + 2 + + 6 = 0. (Interestingly, for any prime modulus there is such a number.) (b) Using the matrix form of the FT, produce the transform of the sequence (0, 1, 1, 1, 5, 2) modulo 7; that is, multiply this vector by the matrix M6(), for the value of you found earlier. In the matrix multiplication, all calculations should be performed modulo 7. (c) Write down the matrix necessary to perform the inverse FT. Show that multiplying by this matrix returns the original sequence. (Again all arithmetic should be performed modulo 7.) (d) Now show how to multiply the polynomials x 2 + x + 1 and x 3 + 2x 1 using the FT modulo 7.

In Section 1.2.3, we studied Euclids algorithm for computing the greatest common divisor (gcd) of two positive integers: the largest integer which divides them both. Here we will look at an alternative algorithm based on divide-and-conquer. (a) Show that the following rule is true. gcd(a, b) = 2 gcd(a/2, b/2) if a, b are even gcd(a, b/2) if a is odd, b is even gcd((a b)/2, b) if a, b are odd (b) Give an efficient divide-and-conquer algorithm for greatest common divisor. (c) How does the efficiency of your algorithm compare to Euclids algorithm if a and b are n-bit integers? (In particular, since n might be large you cannot assume that basic arithmetic operations like addition take constant time.)

In this problem we will develop a divide-and-conquer algorithm for the following geometric task. CLOSEST PAIR Input: A set of points in the plane, {p1 = (x1, y1), p2 = (x2, y2), . . . , pn = (xn, yn)} Output: The closest pair of points: that is, the pair pi 6= pj for which the distance between pi and pj , that is, q (xi xj ) 2 + (yi yj ) 2, is minimized. For simplicity, assume that n is a power of two, and that all the x-coordinates xi are distinct, as are the y-coordinates. Heres a high-level overview of the algorithm: Find a value x for which exactly half the points have xi < x, and half have xi > x. On this basis, split the points into two groups, L and R. Recursively find the closest pair in L and in R. Say these pairs are pL, qL L and pR, qR R, with distances dL and dR respectively. Let d be the smaller of these two distances. It remains to be seen whether there is a point in L and a point in R that are less than distance d apart from each other. To this end, discard all points with xi < xd or xi > x+d and sort the remaining points by y-coordinate. Now, go through this sorted list, and for each point, compute its distance to the seven subsequent points in the list. Let pM , qM be the closest pair found in this way. The answer is one of the three pairs {pL, qL}, {pR, qR}, {pM, qM }, whichever is closest. (a) In order to prove the correctness of this algorithm, start by showing the following property: any square of size d d in the plane contains at most four points of L. (b) Now show that the algorithm is correct. The only case which needs careful consideration is when the closest pair is split between L and R. (c) Write down the pseudocode for the algorithm, and show that its running time is given by the recurrence: T(n) = 2T(n/2) + O(n log n). Show that the solution to this recurrence is O(n log2 n). (d) Can you bring the running time down to O(n log n)?