1 / 28

Divide-and-Conquer

7 2  9 4  2 4 7 9. 7  2  2 7. 9  4  4 9. 7  7. 2  2. 9  9. 4  4. Divide-and-Conquer. Outline and Reading. Divide-and-conquer paradigm (§5.2) Review Merge-sort (§4.1.1) Recurrence Equations (§5.2.1) Iterative substitution Recursion trees Guess-and-test

avital
Télécharger la présentation

Divide-and-Conquer

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. 7 2  9 4 2 4 7 9 7  2 2 7 9  4 4 9 7 7 2 2 9 9 4 4 Divide-and-Conquer Divide-and-Conquer

  2. Outline and Reading • Divide-and-conquer paradigm (§5.2) • Review Merge-sort (§4.1.1) • Recurrence Equations (§5.2.1) • Iterative substitution • Recursion trees • Guess-and-test • The master method • Integer Multiplication (§5.2.2) Divide-and-Conquer

  3. Divide-and conquer is a general algorithm design paradigm: Divide: divide the input data S in two or more disjoint subsets S1, S2, … Recur: solve the subproblems recursively Conquer: combine the solutions for S1,S2, …, into a solution for S The base case for the recursion are subproblems of constant size Analysis can be done using recurrence equations Divide-and-Conquer Divide-and-Conquer

  4. Merge-sort on an input sequence S with n elements consists of three steps: Divide: partition S into two sequences S1and S2 of about n/2 elements each Recur: recursively sort S1and S2 Conquer: merge S1and S2 into a unique sorted sequence Merge-Sort Review AlgorithmmergeSort(S, C) Inputsequence S with n elements, comparator C Outputsequence S sorted • according to C ifS.size() > 1 (S1, S2)partition(S, n/2) mergeSort(S1, C) mergeSort(S2, C) Smerge(S1, S2) Divide-and-Conquer

  5. Recurrence Equation Analysis • The conquer step of merge-sort consists of merging two sorted sequences, each with n/2 elements and implemented by means of a doubly linked list, takes at most bn steps, for some constant b. • Likewise, the basis case (n< 2) will take at most b steps. • Therefore, if we let T(n) denote the running time of merge-sort: • We can therefore analyze the running time of merge-sort by finding a closed form solution to the above equation. • That is, a solution that has T(n) only on the left-hand side. Divide-and-Conquer

  6. Iterative Substitution • In the iterative substitution, or “plug-and-chug,” technique, we iteratively apply the recurrence equation to itself and see if we can find a pattern: • Note that base, T(1)=b, case occurs when 2i=n. That is, i = log n. • So, • Thus, T(n) is O(n log n). Divide-and-Conquer

  7. The Recursion Tree • Draw the recursion tree for the recurrence relation and look for a pattern: Total time = bn + bn log n (last level plus all previous levels) Divide-and-Conquer

  8. Guess-and-Test Method • In the guess-and-test method, we guess a closed form solution and then try to prove it is true by induction: • Guess: T(n) < cn log n. • Wrong: we cannot make this last line be less than c n log n Divide-and-Conquer

  9. Guess-and-Test Method, Part 2 • Recall the recurrence equation: • Guess #2: T(n) < cn log2 n. • if c > b. • So, T(n) is O(n log2 n). • In general, to use this method, you need to have a good guess and you need to be good at induction proofs. Divide-and-Conquer

  10. Master Method • Many divide-and-conquer recurrence equations have the form: • The Master Theorem: Divide-and-Conquer

  11. Master Method, Example 1 • The form: • The Master Theorem: • Example: Solution: logba=2, so case 1 says T(n) is Θ(n2). Divide-and-Conquer

  12. Master Method, Example 2 • The form: • The Master Theorem: • Example: Solution: logba=1, so case 2 says T(n) is Θ(n log2 n). Divide-and-Conquer

  13. Master Method, Example 3 • The form: • The Master Theorem: • Example: Solution: logba=0, so case 3 says T(n) is Θ(n logn). Divide-and-Conquer

  14. Master Method, Example 4 • The form: • The Master Theorem: • Example: Solution: logba=3, so case 1 says T(n) is Θ(n3). Divide-and-Conquer

  15. Master Method, Example 5 • The form: • The Master Theorem: • Example: Solution: logba=2, so case 3 says T(n) is Θ(n3). Divide-and-Conquer

  16. Master Method, Example 6 • The form: • The Master Theorem: • Example: (binary search) Solution: logba=0, so case 2 says T(n) is Θ(log n). Divide-and-Conquer

  17. Master Method, Example 7 • The form: • The Master Theorem: • Example: (heap construction) Solution: logba=1, so case 1 says T(n) is Θ(n). Divide-and-Conquer

  18. Iterative “Proof” of the Master Theorem • Using iterative substitution, let us see if we can find a pattern: Divide-and-Conquer

  19. Iterative “Proof” of the Master Theorem • We then distinguish the three cases as • The first term is dominant • Each part of the summation is equally dominant • The summation is a geometric series Divide-and-Conquer

  20. Divide-and-Conquer

  21. Integer Multiplication • Algorithm: Multiply two n-bit integers I and J. • Divide step: Split I and J into high-order and low-order bits • We can then define I*J by multiplying the parts and adding: • So, T(n) = 4T(n/2) + n, which implies T(n) is Θ(n2). • But that is no better than the algorithm we learned in grade school. where did this come from? Divide-and-Conquer

  22. An Improved Integer Multiplication Algorithm • Algorithm: Multiply two n-bit integers I and J. • Divide step: Split I and J into high-order and low-order bits • Observe that there is a different way to multiply parts: • So, T(n) = 3T(n/2) + n, which implies T(n) is O(nlog23), by the Master Theorem. • Thus, T(n) is O(n1.585). requires only 3 mults! Divide-and-Conquer

  23. Matrix Multiplication • Given n x n matrices X and Y, wish to compute the product Z=XY. • Formula for doing this is • This runs in O(n3) time • In fact, multiplying an n x m by an m x q takes nmq operations Divide-and-Conquer

  24. Matrix Multiplication Divide-and-Conquer

  25. Matrix Multiplication • Using the decomposition on previous slide, we can computer Z using 8 recursively computed (n/2)x(n/2) matrices plus four additions that can be done in O(n2) time • Thus T(n) = 8T(n/2) + bn2 • Still gives T(n) is Θ(n3) Divide-and-Conquer

  26. Strassen’s Algorithm • If we define the matrices S1 through S7 as follows Divide-and-Conquer

  27. Strassen’s Algorithm • Then we get the following: • So now we can compute Z=XY using only seven recursive multiplications Divide-and-Conquer

  28. Strassen’s Algorithm • This gives the relation T(n)=7T(n/2)+bn2 for some b>0. • By the Master Theorem, we can thus multiply two n x n matrices in Θ(nlog7) time, which is approximately Θ(n2.808) . • May not seem like much, but if you’re multiplying two 100 x 100 matrices: • n3 is 1,000,000 • n2.808 is 413,048 • With added complexity, there are algorithms to multiply matrices in as little as Θ(n2.376) time • Reduces figures above to 56,494 Divide-and-Conquer

More Related