Divide-and-Conquer Algorithms and Recurrence Relations. Niloufar Shafiei

Transcription

1 Divide-and-Conquer Algorithms and Recurrence Relations Niloufar Shafiei

2 Divide-and-conquer algorithms Divide-and-conquer algorithms: 1. Dividing the problem into smaller sub-problems 2. Solving those sub-problems 3. Combining the solutions for those smaller subproblems to solve the original problem Recurrences are used to analyze the computational complexity of divide-and-conquer algorithms. Example: Binary search is a divide-and-conquer algorithm. 1

3 Divide-and-conquer recurrence Assume a divide-and-conquer algorithm divides a problem of size n into a sub-problems. Assume each sub-problem is of size n/b. Assume f(n) extra operations are required to combine the solutions of sub-problems into a solution of the original problem. Let T(n) be the number of operations required to solve the problem of size n. T(n) = a T(n/b) + f(n) In order to make the recurrence well defined T(n/b) term will actually be either T( n/b ) or T( n/b ). The recurrence will also have to have initial conditions. (e.g. T(1) or T(0)) 2

4 Binary search: Search for 18 T(n) = T( n/2 ) + 2 T(1) = < = Determine which half of the list to choose and determine whether any terms of the list remain 3

5 Finding the maximum and minimum of a sequence: Consider the sequence a 1, a 2,, a n. If n=1, then a 1 is the maximum and the minimum. If n>1, split the sequence into two sequences, either where both have the same number of elements or where one of the sequences has one more element than the other. The problem is reduced to finding the maximum and minimum of each of the two smaller sequences. The solution to the original problem results from the comparison of the separate maxima and minima of the two smaller sequences. Find a recurrence T(n) that be the number of operations required to solve the problem of size n. Solution: The problem of size n can be reduced into two problems of size n/2 and n/2. Two comparisons are required to find the original solution from those sub-problems. T(1) = 1 T(n) = T( n/2 ) + T( n/2 ) + 2 4

6 Merge sort: The merge sort algorithm splits a list with n elements into two list with n/2 and n/2 elements. (The list with 1 element is considered sorted.) It uses less than n comparison to merge two sorted lists of n/2 and n/2 elements. Find a recurrence T(n) that represents the number of operations required to solve the problem of size n. (The merge sort may have less operations than T(n)) Solution: The problem of size n can be reduced into two problems of size n/2 and n/2. n comparisons are required to find the original solution from those subproblems. T(1) = 0 T(n) = T( n/2 ) + T( n/2 ) +n 5

7 Master theorem There is a theorem that gives asymptotic behavior of any sequence defined by a divide-and-conquer recurrence with f(n)=c.n d for constants c>0 and d 0. This theorem is sometimes called the master theorem. 6

8 Master theorem Theorem: Assume a sequence is defined by a recurrence equation T(n) = at(n/b) + cn d for n>1, where a 1, b 2, c>0 and d 0 are constants and n/b is either n/b or n/b, then one of the following holds. T(n) = (n d ) T(n) = (n d log n) T(n) = (n log ba ) if a < b d if a = b d if a > b d 7

9 Assume an algorithm behavior is determined using the following recurrence.give big-theta estimate for its complexity. T(1) = 1 T(n) = T( n/2 ) + 4, for n 2 Solution: a=1, b=2, c=4 and d=0 So, a = b d = 1. By Master theorem, T(n) = (n d log n) = (log n). 8

10 Assume an algorithm behavior is determined using the following recurrence.give big-theta estimate for its complexity. T(1) = 0 T(n) = T( n/2 ) + T( n/2 ) + 1, for n 2 Solution: a=2, b=2, c=1 and d=0 So, a > b d = 1. By Master theorem, T(n) = (n log b a ) = (n log 2 2 ) = (n). 9

11 Assume an algorithm behavior is determined using the following recurrence.give big-theta estimate for its complexity. x 0 = 0 x n = 7x n/5 + 9n 2, for n 1 Solution: a=7, b=5, c=9 and d=2 So, a < b d = 25. By Master theorem, T(n) = (n d ) = (n 2 ). 10

12 Give big-theta estimate for the merge sort algorithm. Solution: By previous example, we know the following recurrence represent the merge sort algorithm. T(1) = 0 T(n) = T( n/2 ) + T( n/2 ) +n for n>1. a=2, b=2, c=1 and d=1 So, a = b d = 2. By Master theorem, T(n) = (n d log n) = (n log n). 11

13 Give big-theta estimate for following recurrence. f(n) = 2f( ) + 1 when a perfect square n >1, f(2)=1. (Hint: assume m = log 2 n.) Solution: m = log 2 n 2 m = n f(2 m ) = 2 f((2 m ) 1/2 ) + 1 f(2 m ) = 2 f(2 m/2 ) + 1 g(m) = 2 g(m/2) + 1 a=2, b=2, c=1 and d=0 So, a > b d = 1. By Master theorem, g(m) = (m log b a ) = (m log 2 2 ) = (m). So, f(n) = (log 2 n). 12

14 Recommended exercises 7, 17,21,22 Eric Ruppert s Notes about Solving Recurrences ( 13