Divide and conquer
Download
1 / 28

Divide-and-Conquer - PowerPoint PPT Presentation


  • 148 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Divide-and-Conquer' - avital


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
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

Divide-and-Conquer


Outline and reading
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


Divide and conquer1

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


Merge sort review

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


Recurrence equation analysis
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


Iterative substitution
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


The recursion tree
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


Guess and test method
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


Guess and test method part 2
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


Master method
Master Method

  • Many divide-and-conquer recurrence equations have the form:

  • The Master Theorem:

Divide-and-Conquer


Master method example 1
Master Method, Example 1

  • The form:

  • The Master Theorem:

  • Example:

Solution: logba=2, so case 1 says T(n) is Θ(n2).

Divide-and-Conquer


Master method example 2
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


Master method example 3
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


Master method example 4
Master Method, Example 4

  • The form:

  • The Master Theorem:

  • Example:

Solution: logba=3, so case 1 says T(n) is Θ(n3).

Divide-and-Conquer


Master method example 5
Master Method, Example 5

  • The form:

  • The Master Theorem:

  • Example:

Solution: logba=2, so case 3 says T(n) is Θ(n3).

Divide-and-Conquer


Master method example 6
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


Master method example 7
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


Iterative proof of the master theorem
Iterative “Proof” of the Master Theorem

  • Using iterative substitution, let us see if we can find a pattern:

Divide-and-Conquer


Iterative proof of the master theorem1
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



Integer multiplication
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


An improved integer multiplication algorithm
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


Matrix multiplication
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


Matrix multiplication1
Matrix Multiplication

Divide-and-Conquer


Matrix multiplication2
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


Strassen s algorithm
Strassen’s Algorithm

  • If we define the matrices S1 through S7 as follows

Divide-and-Conquer


Strassen s algorithm1
Strassen’s Algorithm

  • Then we get the following:

  • So now we can compute Z=XY using only seven recursive multiplications

Divide-and-Conquer


Strassen s algorithm2
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


ad