Computer Algorithms. Merge Sort. Analysis of Merge Sort. Recurrences. Recurrence Relations. Iteration Method. Lecture 6

Size: px

Start display at page:

Download "Computer Algorithms. Merge Sort. Analysis of Merge Sort. Recurrences. Recurrence Relations. Iteration Method. Lecture 6"

Mitchell George
7 years ago
Views:

1 Computer Algorithms Lecture 6 Merge Sort Sorting Problem: Sort a sequence of n elements into non-decreasing order. Divide: Divide the n-element sequence to be sorted into two subsequences of n/ elements each Conquer: Sort the two subsequences recursively using merge sort. Combine: Merge the two sorted subsequences to produce the sorted answer. Recurrence Ch. 4 (till Master Theorem) Some of these slides are courtesy of D. Plaisted et al, UNC and M. Nicolescu, UNR Analysis of Merge Sort Running time T(n) of Merge Sort: Divide: computing the middle takes () Conquer: solving subproblems takes T(n/) Combine: merging n elements takes (n) Total: T(n) = () if n = T(n) = T(n/) + (n) if n > T(n) = (n lg n) Recurrences Running time of algorithms with recursive calls can be described using recurrences A recurrence is an equation or inequality that describes a function in terms of its value on smaller inputs. For divide-and-conquer algorithms: solving_trivial_problem if n Tn ( ) num_pieces Tn ( / subproblem_size_factor) dividing combining if n Example: Merge Sort () if n Tn ( ) Tn ( /) ( n) if n 3 4 Recurrence Relations Equation or an inequality that characterizes a function by its values on smaller inputs. Solution Methods (Chapter 4) Iteration Method Substitution Method. Recursion-tree Method. Master Method. Recurrence relations arise when we analyze the running time of iterative or recursive algorithms. Ex: Divide and Conquer. T(n) = () if n c T(n) = a T(n/b) + D(n) + C(n) otherwise Iteration Method T(n) = c + T(n/) T(n) = c + T(n/) T(n/) = c + T(n/4) = c + c + T(n/4) T(n/4) = c + T(n/8) = c + c + c + T(n/8) Assume n = k T(n) = c + c + + c + k times = clgn + = Θ(lgn) 5 6

2 Iteration Method Example T(n) = n + T(n/) Assume: n = k T(n) = n + T(n/) T(n/) = n/ + T(n/4) T(n) = n + T(n-) Iteration Method Example T(n) = n + T(n-) 7 8 Substitution method Substitution method Two steps Guess the form of the solution Use mathematical induction to find the constants and show the solution works Useful when it is easy to guess the form of the answer Can be used to establish either upper or lower bound on a recurrence Example: determine upper bound for T ( n) T ( n / ) n guess: T(n) = O(n lg n) prove: T(n) lg n for some c Guess a solution T(n) = O(g(n)) Induction goal: apply the definition of the asymptotic notation T(n) d g(n), for some d > 0 and n n 0 Induction hypothesis: T(k) d g(k) for all k < n Prove the induction goal Use the induction hypothesis to find some values of the constants d and n 0 for which the induction goal holds 9 0 Example Exact Function Recurrence: T(n) = if n = T(n) = T(n/) + n if n > Guess: T(n) = n lg n + n. Induction: Basis: n = n lgn + n = = T(n). Hypothesis: n = k/: T(k/) = (k/) lg (k/) + (k/) Inductive Step: n = k: T(k) = T(k /) + k = ((k /)lg(k /) + (k /)) + k = k (lg(k /)) + k = k lg k k + k = k lg k + k Example T(n) = T(n-) + n Guess: T(n) = O(n ) Induction goal: T(n) c n, for some c and n n 0 Induction hypothesis: T(n-) c(n-) Proof of induction goal: T(n) = T(n-) + n c (n-) + n

3 Substitution Method. Summary Making a good guess Guess the form of the solution, then use mathematical induction to show it correct. Substitute guessed answer for the function when the inductive hypothesis is applied to smaller values hence, the name. Works well when the solution is easy to guess. No general way to guess the correct solution. Need experience and creativity Use recursion trees to generate good guesses If a recurrence is similar to one you are familiar, then guessing a similar solution is reasonable T ( n) T ( n / 7) T(n) = O(n lg n) Why? n 3 4 Recursion-tree Method Example Making a good guess is sometimes difficult with the substitution method. Use recursion trees to devise good guesses. Convert the recurrence into a tree: Each node represents the cost incurred at that level of recursion Sum up the costs of all levels Recursion Trees Show successive expansions of recurrences using trees. Keep track of the time spent on the subproblems of a divide and conquer algorithm. Help organize the algebraic bookkeeping necessary to solve a recurrence. Running time of Merge Sort: T(n) = () if n = T(n) = T(n/) + (n) if n > Rewrite the recurrence as T(n) = c if n = T(n) = T(n/) + if n > c > 0: Running time for the base case and time per array element for the divide and combine steps. 5 6 Recursion Tree for Merge Sort For the original problem, we have a cost of, plus two subproblems each of size (n/) and running time T(n/). Cost of divide and merge. Each of the size n/ problems has a cost of / plus two subproblems, each costing T(n/4). / / Recursion Tree for Merge Sort Continue expanding until the problem size reduces to. / / lg n /4 /4 /4 /4 T(n/) T(n/) Cost of sorting subproblems. T(n/4) T(n/4) T(n/4) T(n/4) 7 c c c c c c Total : lgn+ 8 3

4 Recursion Tree for Merge Sort Continue expanding until the problem size reduces to. / / Each level has total cost. Each time we go down one level, the number of subproblems doubles, but the cost per subproblem halves cost per level remains the same. T(n) = T(n/) + n T(n/) T(n/) T(n/4) T(n/4) T(n/4) T(n/4) T(n/)=(T/4)+(n/) T(n/4)=(T/8)+(n/4) /4 /4 /4 /4 c c c c c c There are lg n + levels, height is lg n. (Assuming n is a power of.) Can be proved by induction. Total cost = sum of costs at each level = (lg n + ) = lgn + = (n lgn). 9 Subproblem size at level i is: n/ i Subproblem size hits when = n/ i i= lgn Cost of the problem at level i = (n/ i ) No. of nodes at level i = i lgn lgn i i n lgn T ( n) T () n n n O( n) n O( n) n i T(n) = O(n ) 0 T(n) = 3T(n/4) + T(n) = T(n/3) + T(n/3) + n The longest path from the root to a leaf is: n (/3)n (/3) n Subproblem size hits when =(/3) i n i=log 3/ n Subproblem size at level i is: n/4 i Subproblem size hits when = n/4 i i= log 4 n Cost of a node at level i =? Number of nodes at level i =? Cost of the problem at level i =? T(n) =? T(n) =? Other Examples Use the recursion-tree method to determine a guess for the recurrences T(n) = 3T( n/4 ) + (n ). T(n) =T(n/3) + T(n/3) + O(n). Recursion Trees Caution Note Recursion trees only generate guesses. Verify guesses using substitution method. A small amount of sloppiness can be tolerated. Why? If careful when drawing out a recursion tree and summing the costs, can be used as direct proof

5 Recursion-Tree Method. Summary Recursion tree Each node represents the cost of a single subproblem somewhere in the set of recursive function invocations Each level denotes iteration Sum the costs within each level of the tree to obtain a set of per-level costs Sum all the per-level costs to determine the total cost of all levels of the recursion Useful when the recurrence describes the running time of a divide-and- conquer algorithm Useful for generating a good guess, which is then verified by the substitution method Use the recursion-tree method to guess the solution (rather than for proving) Example Recurrences T(n) = T(n-) + n Θ(n ) Recursive algorithm that loops through the input to eliminate one item T(n) = T(n/) + c Θ(lgn) Recursive algorithm that halves the input in one step T(n) = T(n/) + n Θ(n) Recursive algorithm that halves the input but must examine every item in the input T(n) = T(n/) + Θ(n) Recursive algorithm that splits the input into halves and does a constant amount of other work 5 6 Three methods for solving recurrences (obtaining asymptotic Θ or O bounds on the solution) Substitution method Recursion-tree method Master method Notes some technical details are neglected Assumption of integer arguments to functions: T(n) Boundary condition for small n T(n) is constant for small n Floors, ceilings Mathematical induction is used to prove our solution for recurrence Showing base case holds Assume the nth step is true Prove the (n+)th step by the result before the nth step 7 5

Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally

Recurrence Relations Many algorithms, particularly divide and conquer algorithms, have time complexities which are naturally modeled by recurrence relations. A recurrence relation is an equation which