0:00

In this series of videos we'll study the master method.

Which is a general mathematical tool for analyzing the running time of divide and

conquer algorithms.

We'll begin in this video motivating the method.

Then we'll give its formal description.

That'll be followed by a video working through six examples.

Finally we'll conclude with three videos that discuss proof of the master method.

With a particular emphasis on the conceptual interpretation of the master

method's three cases.

So let me say at the outset that this lecture's a little bit more mathematical

than the previous two.

But it's certainly not just math for math's sake.

We'll be rewarded for our work with this powerful tool, the master method,

which has a lot of predictive power.

It'll give us good advice about which divide and conquer algorithms

are likely to run quickly and which ones are likely to run less quickly.

Indeed it's sort of a general truism that novel algorithmic ideas often

require mathematical analysis to properly evaluate.

This lecture will be one example of that truism.

0:52

As a motivating example consider the computational problem of multiplying two n

digit numbers.

Recall from our first set of lectures that we all learned the iterative

grade school multiplication algorithm.

And that that requires a number of basic operations, additions and multiplications,

between single digits.

Which grows quadratically with the number of digits, n.

1:12

On the other hand we also discussed an interesting recursive approach

using the divide and conquer paradigm.

So recall, divide and conquer necessitates identifying smaller sub-problems.

So for integer multiplication,

we need to identify smaller numbers that we want to multiply.

So we proceed in the obvious way, breaking each of the two numbers into

its left half of the digits, and its right half of the digits.

For convenience, I'm assuming that the number of digits n is even, but

it really doesn't matter.

Having decomposed x and y in this way, we can now expand the product and

see what we get.

1:44

So let's put a box around this expression and call it *.

So we begin with the sort of obvious recursive algorithm where we just

evaluate the expression * in the straightforward way.

That is, * contains four products involving n over two digit numbers,

ac, ad, bc, and bd.

So we make four recursive calls to compute them.

And then we complete the evaluation in the natural way.

Namely, we append 0s as necessary, and

add up these three terms to get the final result.

2:12

The way we reason about the running time of recursive algorithms like this one

is using what's called a recurrence.

So to introduce a recurrence, let me first make some notation T(n).

This is going to be the quantity that we really care about.

The quantity that we want to upper bound.

Namely this will be the worst case number of operations

that this recursive algorithm requires to multiply two n-digit numbers.

This is exactly what we want to upper bound.

A recurrence, then,

is simply a way to express T(n) in terms of T of smaller numbers.

That is the running time of an algorithm in terms of the work done by its recursive

calls.

So every recurrence has two ingredients.

First of all it has a base case describing the running time when there's no further

recursion.

And in this integer multiplication algorithm, like in most divide and

conquer algorithms, the base case is easy.

Once you get down to a small input, in this case two one digit numbers,

then the running time is just constant.

All you do is multiply the two digits and return the result.

3:08

So I'm going to express that by just declaring the T(1),

the time needed to multiply one digit numbers, as bounded above by a constant.

I'm not going to bother to specify what this constant is.

You can think of it as one or two if you like.

It's not going to matter for what's to follow.

The second ingredient in a recurrence is the important one.

And it's what happens in the general case when you're not in the base case, and

you make recursive calls.

And all you do is write down the running time in terms of two pieces.

First of all the work done by the recursive calls, and

second of all the work that's done right here now.

Work done outside of the recursive calls.

3:40

So on the left hand side of this general case, we just write T(n).

And then we want an upper bound on T(n) in terms of the work done by recursive calls

and the work done outside of recursive calls.

And I hope it's self evident what the recurrence should be in this

recursive algorithm for integer multiplication.

As we discussed, there are exactly four recursive calls.

And each is invoked on a pair of n/2 digit numbers.

So that gives us 4 times the time needed to multiply n/2 digit numbers.

So what do we do outside of the recursive call?

Well, we pad the results of the recursive calls with a bunch of zeros and

we add them up.

And I'll leave it to you to verify that grade school addition, in fact,

runs in time linear in the number of digits.

So putting it all together the amount of work we do outside of the recursive calls

is linear.

That is, it's O(n).

4:27

Let's move on to the second, more clever, recursive algorithm for

integer multiplication, which dates back to Gauss.

Gauss's insight was to realize in the expression * that we're trying to

evaluate, there's really only three fundamental quantities that we care about.

The coefficients for each of the three terms in the expression.

So this, leads us to hope that perhaps we can compute these three quantities

using only three recursive calls, rather than four.

And indeed, we can.

5:06

And the very cute fact is if we number these three products, one, two, and three.

That the final quantity that we care about,

the coefficient of the 10 to the n/2 term, namely ad + bc.

Is nothing more than the third product minus each of the first two.

5:57

A couple of quick comments.

So first of all, I'm being a little bit sloppy when

I say there's three recursive calls, each on numbers with n/2 digits.

When you take the sums a + b and c + d, those might well have n/2 plus 1 digits.

Amongst friends, let's ignore that.

Let's just call it n/2 digits in each of the recursive calls.

As usual, the extra plus one is not going to matter in the final analysis.

Secondly I'm ignoring exactly what the constant factor is in the linear work done

outside of the recursive calls.

Indeed it's a little bit bigger in Gauss's algorithm than it is in the naive

algorithm with four recursive calls.

But it's only by a constant factor.

And that's going to be suppressed in the big O notation.

Let's look at this recurrence and compare it to two other reccurrences, one bigger,

one smaller.

So first of all, as we noted, it differs from the previous recurrence of the naive

recursive algorithm in having one fewer recursive call.

So, we have no idea what the running time is on either of these

two recursive algorithms.

But we should confident that this one certainly can only be better.

That's for sure.

Another point of contrast is merge sort.

So think about what the recurrence would look like for the merge sort algorithm.

It would be almost identical to this one except instead of a three we'd have a two.

Right? Merge sort makes two recursive calls,

each on an array of half the size.

And outside of the recursive calls it does linear work, namely for

the merge sub-routine.

We know the running time of merge sort.

It's n log n.

So this algorithm, Gauss's algorithm, is going to be worse, but

we don't know by how much.

7:25

So while we have a couple clues about what the running time of this algorithm might

be more or less than.

Honestly we have no idea what the running time of Gauss's recursive algorithm for

integer multiplication really is.

It is not obvious.

We currently have no intuition for it.

We don't know what the solution to this recurrence is.

But it will be one super-special case of the general master method,

which we'll tackle next.