303 CSCI Homework 2
Problem 1 (4.3-2): The recurrence T (n) = 7T (n/2) + n2 describes the running time of an algorithm A. A competing algorithm A has a running time of T (n) = aT (n/4) + n2 . What is the largest integer value for a such that A is asymptotically faster than A? Solution 1: By the master theorem, the worst-case asymptotic complexity of A is (nlg 7 ) (n2.80735 ), and the worst-case asymptotic complexity of A is (nlog4 a ), if a > 16. For A to be asymptotically faster than A, log4 a < lg 7 = log4 49. Therefore, the largest integer value for a such that A is asymptotically faster than A is 48. Problem 2 (Derived from 4-1 and 4-4): Give asymptotic upper and lower bounds for T (n) in each of the following recurrences. Make your bounds as tight as possible, and justify your answers. a. T (n) = 2T (n/2) + n3 . b. T (n) = 16T (n/4) + n2 . c. T (n) = 7T (n/3) + n2 . d. T (n) = 7T (n/2) + n2 . e. T (n) = 2T (n/4) + n. f. T (n) = 3T (n/2) + n lg n. g. T (n) = 4T (n/2) + n2 n. h. T (n) = T (9n/10) + n. Solution 2: Use the master method to solve these recurrences. a. Case 3 of master theorem. T (n) = (n3 ). b. Case 2 of master theorem. T (n) = (n2 lg n). c. Case 3 of master theorem. T (n) = (n2 ). d. Case 1 of master theorem. T (n) = (nlg 7 ). e. Case 2 of master theorem. T (n) = ( n lg n). f. Case 1 of master theorem. T (n) = (nlg 3 ). g. Case 3 of master theorem. T (n) = (n2 n). h. Case 3 of master theorem. T (n) = (n). Problem 3 (Derived from 4-1 and 4-4): Give asymptotic upper and lower bounds for T (n) in each of the following recurrences. Make your bounds as tight as possible, and justify your answers. You may assume that T (1) is a constant. a. T (n) = T (n - 1) + n.
1
b. T (n) = T (n - 1) + 1/n. c. T (n) = T (n - 1) + lg n. d. T (n) = 2T (n/2) + n lg n. e. T (n) = 5T (n/5) + n/ lg n. Solution 3: For these recurrences, the master theorem does not apply. a. Assume T (1) = 1, then unroll the recurrence: T (n) = T (n - 1) + n = n + (n - 1) + (n - 2) + + 2 + T (1)
n
=
k=1
k
=
n(n + 1) 2 = (n2 )
b. Assume T (1) = 1, then unroll the recurrence: T (n) = T (n - 1) + = =
k=1 1 1 n + n-1 n 1 n 1 n-2
+
+ +
1 2
+
1 T (1)
1 k
We can bound this sum using integrals (see appendix A.2 in the book, equations A.11A.14).
n
T (n) =
1
k=1 n+1
1 k
n
T (n) =
k=1
1 k
n
1 dx x
=1+
k=2 n
1 k 1 dx x
= ln(n + 1) ln n = (ln n)
1+
1
= 1 + ln n = O(ln n)
T (n) = (ln n) = (lg n)
2
c. Assume T (1) = 1, then unroll the recurrence: T (n) = T (n - 1) + lg n = lg n + lg(n - 1) + lg(n - 2) + + lg 2 + lg 1
n
=
k=1
lg k
n
= lg
k=1
k
= lg(n!) = (n lg n) By Stirling's approximation (see section 3.2 in the book, equation 3.18). d. Assume n = 2m for some m and T (1) = c, then unroll the recurrence: T (n) = 2T
n 2
+ n lg n
n 4
= 2 2T
+
n 8
n 2
lg n + n lg n 2
n 4
= 2 2 2T
+
lg n + 4
n 2
lg n + n lg n 2
n 4
= 2 2 2 (2 (2T (1) + 2 lg 2) + 4 lg 4) + + = n(c + lg 2 + lg 4 + + lg n + lg n + lg n) 4 n
lg 2
lg n + 4
n 2
lg n + n lg n 2
=n c+
k=1
k
lg2 n+lg n 2
=n c+
= 1 n lg2 n + 1 n lg n + cn 2 2 = (n lg2 n) e. Assume n = 5m for some m and T (1) = c, then unroll the recurrence: T (n) = 5T
n 5
+ n/ lg n
n 25
= 5 5T
+ n / lg n + n/ lg n 5 5
n n 25 / lg 25
= 5 5 5 (5 (5T (1) + 5/ lg 5) + 25/ lg 25) + +
+ n / lg n + n/ lg n 5 5
n = n(c + 1/ lg 5 + 1/ lg 52 + + 1/ lg 52 + 1/ lg n + 1/ lg n 5 log5 n 1 = n c + lg 5k k=1
n = nc + lg 5
log5 n k=1
1 k
= (n lg lg n)
Problem 4 (Not in book): The following algorithm uses a divide-and-conquer strategy to search an unsorted list of numbers.
3
Given a list of numbers A and a target number t, the algorithm returns 1 if t it is in the list, and 0 otherwise. Unsorted-Search(A, t, p, q) if q - p < 1 if A[p] = t return 1 else return 0 if Unsorted-Search(A, t, p, p+q ) = 1 return 1 2 if Unsorted-Search(A, t, p+q + 1, q) = 1 return 1 2 return 0 Analyze this algorithm with respect to worst-case asymptotic complexity, and give the worst-case running time in terms of notation. How does this algorithm compare to the naive algorithm that simply iterates through the list to look for the target? Solution 4: The algorithm is given an array of n numbers and a target number. The first two lines take constant time, call it c. The next two lines recursively call Unsorted-Search on inputs of size n/2. Therefore, the worst-case asymptotic complexity is T (n) = 2T (n/2) + c Using case 1 of the master theorem, we see that T (n) = (n). This is the same worst-case asymptotic complexity as the naive algorithm, although in practice the naive algorithm would probably run more quickly. Problem 5 (28.2-4): V. Pan has discovered a way of multiplying 68 68 matrices using 132,464 multiplications, a way of multiplying 70 70 matrices using 143,640 multiplications, and a way of multiplying 72 72 matrices using 155,424 multiplications. Which method yields the best asymptotic running time when used in a divide-and-conquer matrix-multiplication algorithm? How does it compare to Strassen's algorithm? Solution 5: For each case, we write the recurrence and solve it using the master theorem: (1) (2) (3) T (n) = 132464T (n/68) + n2 T (n) = 143640T (n/70) + n2 T (n) = 155424T (n/72) + n2 T (n) = (nlog68 132464 ) (n2.795128 ) T (n) = (nlog70 143640 ) (n2.795123 ) T (n) = (nlog72 155424 ) (n2.795147 )
Strassen's algorithm runs in (nlg 7 ) (n2.81 ), so all these algorithms outperform Strassen. Problem 6 (28.2-6): Show how to multiply the complex numbers a + bi and c + di using only three real multiplications. The algorithm should take a, b, c, and d as input and produce the real component ac - bd and the imaginary component ad + bc separately. Solution 6: Let r = (a + b)(c + d) = ac + ad + bc + bd, let s = ac, and let t = bd. Then the real component of the product of the two complex numbers is ac - bd = s - t and the imaginary component of the two complex numbers is ad + bc = r - s - t.
4