The following content is
provided under a Creative
Commons license.
Your support will help
MIT OpenCourseWare
continue to offer high quality
educational resources for free.
To make a donation or
view additional materials
from hundreds of MIT courses,
visit MIT OpenCourseWare
at ocw.mit.edu.
PROFESSOR: All right.
Good morning, everyone.
Thanks for coming on quiz day.
I have to have someone
to throw Frisbees to.
Empty chairs would be difficult.
So we're going to be doing
dynamic programming, a notion
you've learned in 6006.
We'll look at three
different examples today.
The first one is really
at the level of 006,
a cute little problem on
finding the longest palindromic
sequence inside of
a longer sequence.
Sometimes it's called longest
palindromic subsequence.
And as we'll talk
about, subsequence
means that it can
be non-contiguous.
So you could skip letters
in a sequence of letters
and you would still have a
subsequence corresponding
to that.
Don't have to be contiguous.
And then we'll raise
the stakes a little bit.
So each of these problems gets
progressively more complicated,
more sophisticated.
And you'll probably
see problems here,
at least alternating coin
game, that are beyond 006
in the sense that
it wasn't covered.
Those kinds of notions
weren't covered in 006.
So just in terms of
review, I wrote this
up here because I don't want
to spend a whole lot of time
on it.
This is something that you
should have some familiarity
with from the
recitation, for example,
that you had on
Friday and from 006.
Dynamic programming is
this wonderful hammer.
It's an algorithmic
technique that you
can use to solve problems that
look exponential in complexity.
But if you can find this
optimum substructure associated
with the problem and its
connection to it's subproblems,
and if you can
characterize that,
then you can do a recursive
decomposition of the problem
where you show that you can
construct the optimum solution
from the subproblems.
And that's really the key
step in dynamic programming,
is step two.
Once you've made this
characterization,
you write this recurrence out
that relates the optimal value
of a bigger problem to the
optimal values of subproblems.
And you compute the value
of the optimal solution
through a recursive memoization.
And that memoization
is really what
gives you the
efficient algorithm,
because you don't repeat
the solution of subproblems.
You can also do this in
an iterative fashion.
Essentially, you're going to
be computing things bottom-up.
You might want to think
about it as top-down
when you write your recurrence.
But ultimately, when you
actually execute the program,
you'll be computing
things bottom-up,
and you'll be checking the memo
table to see if you actually
solved this problem before.
And that would be the
recursive memoized case,
which, in some sense,
is a little bit easier
to think about and translate
directly from the recurrence.
But the other way to do it
is to do it iteratively.
And we'll take a look
for this first problem
as to how you'd do the two
different ways at least
from a conceptual standpoint,
even though I might not
write out the code for
each of those cases.
So a couple of choices
here, recurse and memoize,
or essentially do
it iteratively.
And the smaller
subproblems would
have to get computed
first in both approaches.
The one thing that sometimes we
don't spend a whole lot of time
on is this last step, which
is getting the exact solution.
So a lot of the time,
you stop with saying,
I can compute the value
of the optimum solution,
the value in terms of
the length of the longest
palindromic sequence is 7 or 9.
But what is that
sequence or subsequence?
That requires some
additional coding,
some additional accounting.
The construction of
this optimal solution
typically requires
some back-tracing
and some information
to be kept track
of during the recurse
and memoize step
or during the iterative step.
So that's something
to keep in mind.
You're not quite
done once you've
found the value of
the optimum solution.
More often than not,
you want the solution.
So we'll talk about that
as well a little bit.
But let's just dive in and look
at this cute, little problem
of longest palindromic sequence.
And palindromes, of course,
read the same front to back
or back to front.
Radar is a palindrome.
Just as a trivial example, a
single letter is a palindrome.
Maybe I should have used a
since that's actually a word.
But here I got bb.
That's definitely not
a word, at least not
a word that-- acronym, maybe.
Radar is a palindrome.
Able was I 'ere I
saw Elba, right?
That's a palindrome.
That's, of course,
not a single word.
But it's a famous
palindrome, days of Napoleon.
But what we're
trying to do here is,
given that we have this
notion of a palindrome,
we'd like to discover
palindromes inside longer
words or longer sequences.
So what we have is a string,
and we'll call it x1 through n,
n greater than or equal to 1.
And we want to find the
longest palindrome that
is a subsequence.
And so here's an example
to get you guys warmed up.
We'll have a couple of
puzzles here in a second.
So character.
And you want to find
the longest palindrome.
And so you go, I'll pick c,
I'll skip h, I'll pick a,
I'll pick r, a, and c.
And carac, which I guess
is not a word either--
but it's the longest
palindrome that corresponds
to a subsequence of character.
Right?
So the game here,
as you can see,
is to pick the letters that
form the palindrome and drop
the ones that don't.
OK?
And we're going to have to use
dynamic programming to do this.
The answer will be greater
than or-- 1 in length
because we've defined a
single letter as a palindrome.
So it has to be-- if you have
one letter in the input, well,
you just pick that letter.
But regardless of how many
letters you have on the input,
greater than or
equal to 1, you know
that you're going to get
at least a one letter
palindrome at the output.
So here we go.
Let's say I have under-- and
this is thanks to Eric here.
I've got a couple of nice
words-- underqualified.
The person who gets me
the longest palindrome
wins a Frisbee.
And if you want to code dynamic
programming in the next two
minutes and run it
on your laptops,
that's perfectly fine with me.
That's not cheating.
So underqualified.
So u is a palindrome.
So we got that.
Right?
So one letter for sure.
What else?
What's the longest palindrome?
Shout it out.
Go ahead.
Shout it out.
[STUDENTS RESPOND]
PROFESSOR: D-E-I--
wow, that was quick.
Deified.
That's right.
So right?
Well, deified is to
make somebody a deity.
So that was you, a
couple of you guys?
Do you have a Frisbee yet?
AUDIENCE: No.
PROFESSOR: All right.
All right.
This is a little bit more
difficult. I tried this
on my daughter
yesterday, so I know
it's a little more
difficult. Turboventilator.
We'll call that a word.
Turboventilator.
Yell it out.
AUDIENCE: Rotor.
PROFESSOR: Sorry?
AUDIENCE: Rotor.
PROFESSOR: Rotor.
OK, well, that's five.
Can anybody beat that?
AUDIENCE: Rotator.
PROFESSOR: Rotator.
So rotator.
Rotator.
So R-O-T-A-T-O-R, rotator.
All right.
Who is the rotator?
You already have one?
I want to throw this one.
Right.
Good practice with
the quiz, guys.
Good practice with the quiz.
No, no, no.
These quiz jokes
never go over well.
I've been teaching for
27 years, and I still
haven't learned that you
don't joke about exams.
But so nothing like
this on the quiz.
I don't want you studying
the thesaurus as opposed
to the textbook for
the next few hours.
OK?
Nothing like this on the quiz.
All right.
Those of you who are missing
Python, who loved 6006
in Python, let's talk about
how you would actually solve
this using dynamic programming.
And so what we
want is lij, which
is the length of the longest
palindromic subsequence
for xij.
And we're going to have i
less than or equal to j.
So that's essentially
what we'd like to compute.
And essentially when I've said
this here, when I have lij,
I have decomposed the overall
problem into subproblems,
and it was kind of fairly
obvious in this case,
because I'm going to
have to go in order.
Right?
I mean that's the constraint.
A subsequence does maintain
the ordering constraint.
It's not like I can
invert these letters.
That would be a
different problem
if I allowed you to do that.
So I'm going to start somewhere,
and I'm going to end somewhere.
And I want to have a
non-null subsequence,
so I'm going to have i
less than or equal to j.
I'm good with i being
equal to j, because I still
have one letter, and, well,
that happens to be a palindrome,
and it'll have a length of 1.
So that's my lij.
And what I want to do is
define a recursive algorithm
that computes lij.
So we'll just try and figure out
what the recurrence looks like,
and then we can talk about
memoization or iteration.
So if i equals
equals j, then I'm
going to return
1, because I know
that that's a palindrome
by default. So that's easy.
And what do you think
the next check should be?
If I look at this
x sequence, and I
have i as the starting point
and j as the next point,
what do you think the next check
is going to be once I have--
if i is not equal to j?
AUDIENCE: If x of i equals x
of j, then j equals as well.
PROFESSOR: Sorry.
What was that again?
AUDIENCE: If x of
i equals x plus--
PROFESSOR: Beautiful.
You're just checking
to see-- you're just
checking to see whether the
two endpoints are equal or not.
Because if they're
equal, then you
can essentially
grab those letters
and say that you're
going to be looking
at a smaller subsequence that is
going to get you a palindrome.
And you're going to be able
to add these two letters that
are equal on either side
of the computed palindrome
from the subsequence.
So if x of i equals equals x
of j, then I'm going to say,
if i plus 1 equals
equals j, I'm going
to go ahead and return
2, because at that point,
I'm done.
There's nothing else to do.
Else I'm going to return 2
plus L of i plus 1 j minus 1.
So I'm going to look inside.
And I've got these two letters
on either side that are equal.
So I can always prepend
to the palindrome
I got from here the letter, and
then append the same letter.
And I got 2 plus whatever value
I got from this quantity here.
So so far, it's not
really particularly
interesting from a
standpoint of constructing
the optimum solution.
But this last line that we have
here, where we have the case
that the two letters
are not equal
is the most interesting
line of code.
That's the most interesting
aspect of this algorithm.
So does someone tell
me what this line
is going to be out here?
Yeah, go ahead.
AUDIENCE: If x of L i plus
1j or L i [INAUDIBLE].
PROFESSOR: Beautiful.
That's exactly right.
So what you're going to
do is you're going to say,
I need to look at two
different subproblems,
and I need to evaluate
both of these subproblems.
And the first subproblem is
I'm going to-- since these two
letters are different, I'm going
to have to drop one of them.
And I'm going to look inside.
I'm going to say--
in this case, I'm
going to drop the
i-th letter, and I'm
going to get L i plus 1j.
And in the second case, I'm
going to drop the j-th letter,
and I'm going to get ij minus 1.
And that's it.
So it's a max.
And there's nothing
that's being added here,
because those two letters, one
of them had to get dropped.
They weren't equal, so one
of them had to get dropped.
So you're not adding
anything to this.
So that's good.
And at this point,
you're kind of done.
Right?
Whoops.
Oh, nice catch.
But you did drop something.
All right.
So the thing that we've done
here is gotten to step three.
So just to be clear, we're
not done-done, in terms
of this chart here, because
we don't have the code there
that corresponds to actually
computing the sequence.
So it's not that hard.
I'm not going to go
over the code here.
You can certainly look
at it in the notes.
But you need a
little bit of tracing
backwards in this recursion
to actually compute things.
What is the complexity of
what I wrote up there, though?
Yeah?
AUDIENCE: Theta n squared?
PROFESSOR: Theta n squared.
Do people agree that the
complexity is theta n squared?
Or is this gentleman
an optimist?
Is the complexity
theta n squared?
Tell me why the complexity
is theta n squared?
AUDIENCE: Because
each subproblem
is-- that code right there just
executed by itself is constant.
But then there's theta
n squared subproblems.
PROFESSOR: Absolutely.
But if you actually implemented
this code, and you ran it,
and n was 100,
how long would you
wait for this code to complete?
Look at it.
What's missing?
AUDIENCE: The cache.
PROFESSOR: The cache, exactly.
Well, you fixed your
own little error there.
It was a trick question.
So there's no recursion-- I'm
sorry, there's recursion here,
but no memoization.
So this is exponential
complexity.
You will recur.
In fact, the recurrence for
that is something like T of n
equals 1 if n equals 1, and 2T
n minus 1 if n greater than 1.
And this would be 2 raised
to n minus 1 in complexity.
Now there's a
single line of code,
and you all know this,
that would fix this.
And that single line of code
is simply something that says,
right here, look at
the lij-- and I'm
writing this differently.
I'm calling this now a 2D array.
So that's why I have the open
brackets and close brackets.
So I'm overloading l here.
But it's a 2D
array that is going
to essentially be a cache for
the subproblem solution values.
And then if you want to do the
backtracing to actually compute
the solution, you
could certainly
have that as an additional
record that's connected
to this very same value.
But that's implementation,
and we won't really go there.
So look at lij and don't
recurse if lij already computed.
OK.
So that's important to remember.
Now, if you actually put that,
the cache lookup, hash table
lookup, array lookup,
whatever you want to call it,
out there, then what you
said is exactly correct.
So our formula for computing
the complexity of a DP,
that you've seen
a bunch of times
and I mentioned in the
very first lecture as well,
is number of
subproblems times time
to solve each
subproblem assuming
or given that smaller
ones are solved
or the lookup is Order 1.
So lookup.
Now you could say
that hash table
lookup is Order 1 on average,
et cetera, et cetera.
So what actually happens
in the worst case,
in this particular
case and in most DPs,
you can do things
like perfect caching
or, something that's even
simpler in this case,
is just a 2D array.
There's not going to be any
collisions if you just use i
and j as the indices
to the array.
So you will definitely get an
Order 1 lookup in this case,
in most problems
we'll look at in 046.
So if we just do that
computation, which
my friend over here
just described,
you do get your theta n
squared, because you have
theta n squared subproblems.
And time to solve
each subproblem, given
that the smaller
ones are solved,
is simply going to
be a computation
of a max and an addition.
So all of that is theta
1, because you're not
counting the recursive calls.
So this is our first example.
I'm done with it.
Any questions about it?
Any questions about
DP in general?
All right, good.
So little bit of review there.
Not a particularly
complicated question.
Let's go to a different
question corresponding
to optimal binary search trees.
It's a very different question.
I don't think I
need this anymore.
And it's kind of
cute in its own way.
One of things that's
interesting about this question
is it seems like a greedy
algorithm should work.
And we'll talk about that, as
to why the greedy algorithm
doesn't quite work.
So it's kind of similar
to the interval scheduling
and the weighted interval
scheduling problem
that we had back
in February, where
the regular interval scheduling
problem, greedy worked,
earliest finish time worked.
But when it came
to weights, we had
to graduate to
dynamic programming.
So here's our second
problem, optimal BSTs.
So what is an optimal BST?
We have a bunch of keys that
we want to store in the BST, K1
through Kn.
And we'll assume that
the way this is set up
is that K1 is less than K2,
da, da, da, less than Kn.
And just to make our life
easier in our examples,
we just assume that Ki equals i.
That's not necessarily
required for anything
we're going to do next.
It's just for the
sake of examples
and keeping things manageable.
So I got a bunch of keys.
And clearly there are many
different binary search trees
that can come, whether they're
balanced or unbalanced.
Many different
binary search trees
can be consistent with
a given set of keys.
If I choose the root
to be Kn, then I'm
going to get this
horribly unbalanced tree.
If I chose the root to be
somewhere in the middle,
then I'm going to
get something that
looks a little better, at
least at the top level.
But again, if I messed
it up at the next level,
I'd get something
that's unbalanced.
So there's clearly
many different BSTs.
I'm not talking about
balanced BSTs here.
But we're going to define an
optimality criterion that's
a little bit different
from balanced BSTs,
because it's going to
have this additional cost
function associated
with it that corresponds
to the weight of the keys.
So what is that?
Well, I'm going to
have weights associated
with each of these keys
corresponding to W1 through Wn.
And the easiest
way to motivate you
to think that these weights
are an interesting addition
to this problem is to
think about these weights
as being search probabilities.
So what you have,
for argument's sake,
is a static structure
that you've created.
I mean, you could modify it.
There's nothing that's
stopping you from doing that.
But let's just pretend for now
that it's a static structure
corresponding to this BST--
has a particular structure.
And chances are you're going
to be searching for some keys
more frequently than others.
And the Wi's tell you
what the probabilities
are in terms of searching
for a particular key Ki.
So you can imagine, and
we won't have this here,
that you take-- the
Wi's all sum up to 1,
if you want to think of
them as probabilities.
Or I'm just going
to give you numbers.
I don't want to deal with
fractions, don't particularly
like fractions.
So you can imagine that
each probability corresponds
to Wi divided by the sum
of all the Wi's, if you
want all of the
probabilities to sum up to 1.
So think of them as
search probabilities,
because then you'll see what
the point of this exercise is.
And the point of
this exercise is
to find the BST T-- so
we're actually constructing
a binary search tree here.
So it's a little more
interesting than a subsequence,
for example-- it has a richer
structure associated with it--
than an exponential number
of possible binary search
trees that are associated
with a given set of n keys
that are all binary
search trees.
They're consistent, unbalanced,
balanced-- unbalanced
in one way versus another
way, et cetera, et cetera.
So we want to find a
binary search tree T
that minimizes sigma
i equals 1 through n.
Obviously, we're going to have
this Wi that's the game here.
Depth in that T-- so this
depth is for that T. What
is the depth of the node?
And K of i plus 1.
And I'll explain
exactly what this
and tell you what
precisely the depth is.
But roughly speaking,
the depth of the root--
not roughly speaking.
The depth of the root is 0.
And the depth of
1 below the root
is 1, and so on and so forth.
And so, as you can
see, what you want
to do is collect in--
roughly speaking,
you want to collect the high
weight nodes to have low depth.
If Wi is high, you want
the multiplicative factor
corresponding to depth T
of that node, i, i-th node,
to be small.
And if Wi is small, then you
don't mind the depth number
to be higher.
You only have a certain
number of low-depth nodes.
You only have one
node of depth 0.
And you have two nodes of depth
1, which means that you only
have one node where
that quantity there
is going to be 1, because
you're doing 0 plus 1.
And you have two nodes
where the quantity
is going to be 2, and
so on and so forth.
So you have some room here
to play with corresponding
to the BST structure, and you
want to minimize that quantity.
Any questions so far?
All right, good.
So the search probabilities
would be an example.
So in terms of a more
concrete application,
you could imagine you had a
dictionary, English to French,
French to English,
what have you.
And there are obviously
words that are more common,
let's say, in common
speech than others,
and you do want to do the
translation in a dynamic way
using this data structure.
And you could imagine
that in this case,
the search probability
of a word is associated
with the occurrence of the
word, the number of times
over some normalized
number of words
that this particular
word occurs.
And that would be the way.
So it makes sense to
create a structure that
minimizes that function,
because it would minimize
the expected search
cost when you want
to take this entire
essay, for example,
and convert it from English
to French or vice versa.
So this can-- if these
are search probabilities,
then this would minimize--
this cost function here
would minimize
expected search cost.
Make sense?
Yeah.
So that's the definition
of the problem.
And now we have to talk about
why this is complicated,
why this requires
dynamic programming.
Why can't we just do something
fairly straightforward,
like a greedy algorithm?
And so let's look into that.
Let me give you a really
good sense for what's
going on here with respect
to this cost function
and maybe a little
abstract by giving you
a couple of concrete examples.
First off, we got exponentially
many trees, exponential in n.
Let's say that n equals 2.
So the number of nodes is 2.
Then remember that I'm assuming
that the Ki's are all i's,
that 1 and 2 would
be the case for n
equals 2 and 1, 2, 3 for
n equals 3, et cetera.
So I could have a tree
that looks like that.
And I could have a tree
that looks like this.
That's it.
n equals 2, I got 2 trees.
So in this case, my cost
function is W1 plus 2W2,
and in this case, my cost
function is 2W1 plus W2.
Just to be clear, what this
is the K, and it's also the i.
So the numbers that
you see inside,
those are the i
numbers, which happen
to be equal to the Ki numbers.
And the weight itself
would be the Wi.
So I put W1 here, and the reason
it only gets multiplied by 1
is because the depth here
is 0, and I add 1 to it.
The depth here is 1,
and I add 1 to it, which
is why I have a 2 out here.
Being a little pedantic here
and pointing things out,
because you're going to start
seeing some equations that
are a little more
complicated than this,
and I don't want you
to get confused as
to what the weight is and
what the key number is
and what the depth is.
There's three things
going on here.
So over here you see that
I'm looking at W1 here,
which is this key.
So the 1 corresponds to the 1.
And this has a depth of 1, so
I put a 2 in here, and so on.
So so far, so good?
When you get to n equals 3,
you start getting-- well,
at this point, you have 1, 2,
3, 4, 5-- you have five trees.
And the trees look like this.
I'll draw them
really quickly just
to get a sense of
the variety here.
But I won't write the
equations down for all of them.
There you go.
So those are the five binary
trees associated with n
equals 3, the
binary search trees.
And this is kind of cool.
It's nice and balanced.
The other ones aren't.
And I'm not looking at--
Should I have another one here?
I guess I should have.
This is a-- oh, no, no, no.
So I'm not doing mirrors.
So there are a
bunch of other trees
that have the same equation
associated with two-- no,
that's not true.
Because these are it.
I was going to say that
you could put 3 in here,
but that wouldn't be
a binary search tree.
So this is it.
And we've got a bunch of trees.
This one would be 2W1 plus W2
plus 2W3 by the same process
that I used to show you
that W1 plus 2W2 for the n
equals 2 case.
You just go off, and
that's the equation.
And so your goal here in
an algorithm-- clearly
this is not the
algorithm you want
to enumerate all the
exponentially many trees,
compute the equations
for each of those trees,
and pick the minimum.
I mean, that would work, but
it would take exponential time.
But that's what
you have to do now.
That's the goal.
You absolutely want the best
possible three that has,
for the given Wi's
that you're going
to be assigned as
constants, you do
want to find the one tree
that has the minimum sum,
and you want to do
that for arbitrary n,
and you want to do that
in polynomial time.
So the first thing that you
do when you have something
like this is forgetting
about the fact
that we're in a
dynamic programming
lecture or a dynamic programming
module of this class,
when you see a problem like
this in the real world,
you want to think about whether
a greedy algorithm would work
or not.
And you don't want to go off
and build this dynamic program
solution, which is,
chances are, going
to be more inefficient then
a greedy solution, which,
if it produces the optimum
answer, is the best way to go.
So an obvious greedy
solution would
be to pick K of r in
some greedy fashion.
And what is the obvious
way of picking K of r
to try and get a
greedy solution that
at least attempts to
minimize that cost function
that we have there?
AUDIENCE: Highest weight.
PROFESSOR: Highest
weight, right?
So just pick K of r
to be highest weight.
Because that goes back to what
I said about if Wi is high,
you want this value
here to be small.
So that's essentially
your greedy heuristic.
So K of r should be picked
in a greedy fashion.
So what you do is
you pick K of r
as the root in this
particular problem.
And you could certainly
apply this greedy technique
recursively.
So you do that for
every subproblem
that you find
because when you do
this choice of the root for
Kr in the current problem
that you have, you immediately
split the keys into two
sets, the sets that have to
go on the left-hand side of Kr
and the sets that have to go
on the right-hand side of Kr.
So in this case,
you know that you're
going to have a bunch of
keys here that correspond
to Ki to K4, and
over here, you're
going to have-- oh, Kr
minus 1, I should say,
because you already
have Kr out there.
And the keys here are going to
be Kr plus 1 to Kj, if overall
I'm going to say that eij is the
cost of the optimal BST on Ki,
Ki plus 1, all the way to Kj.
So I'm kind of already
setting myself up here
for dynamic programming.
But it also makes
sense in the case
of a greedy algorithm, where
this greedy heuristic is going
to be applied recursively.
So initially, you're
going to have E(1, n)--
so if you want to
compute E(1, n),
which is the cost of the optimal
BST on the original problem,
all the way from 1 to n,
you're going to look at it,
and you're going to say, I
have a bunch of keys here
of different weights that
correspond to K1 through Kn.
I'm going to pick the
Kr that corresponds
to the maximum
weight, and I'm going
to use that as the
root node, and I'm
going to stick that up there.
And the reason I did
that is because I believe
that this greedy heuristic
is going to work,
where this maximum
weight node should have
the absolute minimum depth.
So I stick that up there.
And then my BST invariant tells
me that Ki through Kr minus 1--
remember, these are
sorted, and they
go in increasing order,
as I have up here.
You're going to have
those on the left,
and you're going to
have those on the right.
And then you've got to
go solve this problem.
And you could certainly
apply the greedy heuristic
to solve this problem.
You could go essentially
find the K that
has the highest weight.
So you look at Wi
through Wr minus 1,
and you find the K that
has the highest weight.
Actually, you're not
going midway here.
It's quite possible
that Kr is K of n.
It just happens to
be Kr is K of n.
So that means that you have the
highest weight node up here,
but it's also the biggest key.
So all of the nodes are
going to be on the left.
So this greedy heuristic-- and
now you're starting to see,
maybe there's a problem here.
Because if you have a situation
where the highest weight
node is also the
largest node, you're
going to get a pretty
unbalanced tree.
So I can tell you that
greedy doesn't work.
And when I gave this
lecture, I think
it was a couple of years
ago, I made that statement,
and this annoying student
asked me for an example.
And I couldn't come up with one.
And so I kind of bailed
on it, went on, completely
dissatisfied, of course.
And by the end of the
lecture, the same student
came up with a counter-example.
So I'm going to have
put that up here
and thank the student who
sent me an email about it.
And so here's a
concrete example.
It turns out I was trying
to get a tree node example
for a few minutes and failed.
It's, I think,
impossible-- I haven't
proved this-- to
find a tree node
example with arbitrary weights
for which the greedy algorithm
fails.
But four nodes, it fails.
So that's the good news.
So here's the example,
thanks to Nick Davis.
And it looks like this.
So I claim that the
greedy algorithm
for the problem that is given
to me would produce this BST.
And the reason for
that is simple.
The highest weight
node happens to be node
2, which has a weight of 10.
So I would pick that, and
I would stick that up here,
which means, of
course, that I'm going
to have to have 1 on
this side, and I'm
going to have to have 4
and 3 on the other side.
And since 4 has a higher weight
than 3, I'd pick that first.
And then 3 would
have to go over here.
So if I go do the math, the
cost is going to be 1 times 2--
and I'll explain what
these numbers are.
I did tell you it was going
to get a little cluttered here
with lots of numbers.
But if you keep that
equation in mind,
then this should all work out.
So what do I have here?
I'm just computing-- this is W1.
So you see the first numbers in
each of these are the weights.
And so this would
be W2 and et cetera.
And you can see that
this is at depth 1, which
means I have to have
2 here, because I'm
adding 1 to the depth.
So I have 1 times 2, 10
times 1, because that's
at the root, 9
times 2, et cetera.
And I get 54.
It turns out the
optimum tree-- you
can do better than that if you
pick 3, and you go like this.
And so what you have here
is the cost equals 1 times
3 plus 10 times 2 plus 8 times
1 plus 9 times 2, and that's 49.
So I'll let you look at that.
The bottom line is
because of the way
the weights are set
up here, you really
want to use the top
three spots, which
have that the minimum depth,
for the highest weight nodes.
And so you can see that I could
make these weights arbitrary,
obviously, and I could
break a greedy algorithm
as this little example shows.
So we got no recurs here.
We got to do some more work.
We're going to have to use
DP to solve this problem.
The good news is DP
does solve this problem.
So let's take a look
at the decomposition.
And as with anything
else, the key
is the step that
corresponds to breaking up
the original problem
into two parts or more
that essentially give you
this sort of decomposition.
And we don't quite know.
So this is really the
key question here.
We don't quite know what the
root node is going to be.
So what do we do when we
don't know what to do?
What do we do in DP when
we don't know what to do?
This is a very
profound question.
What do you do?
AUDIENCE: Guess.
PROFESSOR: You guess.
And not only do yo guess,
you guess all outcomes.
You say, is it going
to come up heads?
Is it going to come up tails?
I'll guess both.
You have a die.
It's going to get rolled,
a 1, 2, 3, 4, 5, 6.
Guess them all, right?
So if you're going to have to
guess that the root node could
be any of the keys,
and it still--
I mean there's a linear
number of guesses there.
That's the good news.
It's going to stay
polynomial time.
So we're going to have to guess.
And once you do that
guess, it turns out
that decomposition
that you see up there
is exactly what we want.
It's just that the
greedy algorithm
didn't bother with all of
these different guesses.
And the DP is different
from the greedy algorithm
because it's going to do
each of those guesses,
and it's going to pick the
best one that comes out
of all of those guesses.
So it's really not that
different from greedy.
So we'll keep that up
there, leave that here.
Let's go over here.
So the recursion
here is not going
to be that hard, once you have
gotten the insight that you
just have to go make a linear
number of guesses corresponding
to the root node for your
particular subproblem,
and obviously this
happens recursively.
So there's a little
something here
that that I'll point
out with respect
to writing these equations out.
So what I have here,
just to be clear,
is what I wrote up there.
Even when I was talking
about the greedy algorithm,
I had the subproblems defined.
So the original problem
is E1 through n.
The subproblems
correspond to eij.
And given a subproblem,
once I make a root choice,
I get two subproblems that
result from the root choice.
And each of those
two subproblems
is going to be
something-- and this
is something to keep in mind as
we write these equations out--
they're going to be one
level below the root.
So keep in mind that the
original eij subproblem
corresponded to this
level, but that Ei
r minus 1 problem and
the E r plus 1j problem
are at one level below.
So keep that in mind as we
write these equations up.
And so what I want to do here
is just write the recurrence.
And after that, things
become fairly mechanical.
The fun is in the recurrence.
So I got Wi if i equals j.
And so I'm at this level.
And if I just have one node
left, then at that level,
I'm going to pay the weight
associated with that node,
and I'm going to have
to do a certain amount
of multiplication here
with respect to the depth.
But I'm just talking about
eij as the subproblem weight,
just focusing in
on that problem.
So if I only have one
node, it's the root node.
And that weight
is going to be Wi,
because the root
node has depth of 0,
and I'm going to add 1 to it.
So for that
subproblem, I got Wi.
Keep that in mind, because
that's the only subtlety here
with respect to these
equations, making sure
that our actual cost
function that we're computing
has the correct
depth multiplicands
associated with it.
So then we have our
linear guessing.
And I might have said
max at some point.
We want to get the min here.
And I had minimize
here, so I think
I wrote things down
correct, but at some point,
I think I might have said
we want to maximize cost.
But we do want to minimize
cost here corresponding
to the expected search.
So we're doing a linear,
and we're doing a min.
And we're going
to go off and look
at each of the different
nodes as being the root,
just like we discussed.
And what I'm going to do here is
I'm going to simply say, first,
that I'm going to
look at Ei r minus 1,
which corresponds to this, and
I'm going to have plus E of r
plus 1, j.
And at this point,
I don't quite have
what I want because
I haven't actually
taken into account the fact that
the depth of the Ei r minus 1
and the r plus 1j is
1 more than the eij.
So it's 1 more than that.
And I also haven't taken
into account the fact
that, in this case, I definitely
need to add a Wi as well.
Because the root node is part
of my solution in both cases.
In one case, it ended my
solution, the top case.
But in this case, it's
also the root node,
as you can see over
on the left, and I've
got to add that in there.
So I definitely need
to add a Wi here.
And what else do I need to add?
From a standpoint
of the weights,
what other weights do I
need to add to this line?
Yeah?
Go ahead.
AUDIENCE: First of all,
shouldn't that be a Wr?
PROFESSOR: First of
all, that should be
a Wr, you're exactly correct.
AUDIENCE: And you want
to add all the weights.
PROFESSOR: And you want to
add all the weights, right.
You're exactly right.
I have two more
Frisbees, but I need
to use them for something else.
So you get one next time.
Or do I have more than that?
No, no.
These are precious
Frisbees here.
Sorry, man.
And you corrected me, too.
Shoot.
This is sad.
So that needed to be a Wr.
But you also need to add up all
of the nodes that are in here,
because they're one more level.
And now you see why
I made the mistake.
I don't usually make mistakes.
But what I really
want-- actually it's
more like-- I don't
know, a few per lecture.
Constant order one mistakes.
I'm going to say this is
Wi, j, where Wi, j is simply
the sum of all of the
weights from i to j.
And this makes perfect
sense, because the nice thing
is that I don't even need
to put an r in there.
I could choose a particular r.
Wr will be in there.
But all of the other nodes are
going to be in there anyway.
So it doesn't really
matter what the r selection
is corresponding
to this term here.
I will put it inside
the minimization.
This bracket here
is closed with that,
but you can pull that
out, because that
doesn't depend on r.
It's just going to be there
for all of the cases, all
of the guesses.
So that's it.
That's our recurrence
relationship corresponding
to the DP for this
particular problem.
You can go figure out
what the complexity is.
I have other things to
do, so we'll move on.
But you can do the
same things, and these
are fairly mechanical at this
point to go write code for it,
trace the solution to get
the optimum binary search
tree, yadda, yadda, yadda.
Any questions about this
equation or anything else?
Do people get that?
Yeah, go ahead.
AUDIENCE: What is
the depth input?
PROFESSOR: So the depth is
getting added by the weights.
So basically what's happening
is that as I go deeper
into the recursion, I'm adding
the weights and potentially
multiple times,
depending on the depth.
So if you really think
about it, this Wij,
I added all of these weights.
But when you go
into this recursion,
into the ei of r
minus 1, well, you're
going to see i to r minus 1 in
the next level of recursion.
So you would have
added the weight again.
So it's not the case
that the weights are only
appearing once.
They're, in fact,
appearing this many times.
So that's what kind of
cute about this, the way
we wrote it.
Any other questions?
All right, good.
So we're done with that.
So one last example.
This is, again, a little bit
different from the examples
of DP we've looked at up until
now, because it's a game.
And you have an
opponent, and you
have to figure out
what the opponent is
going to do and try to win.
I suppose you could
try to lose as well.
But let's assume here, same
thing with minimization
and maximization,
most of the time
you can invert these
cost functions,
and DP will still work.
But let's assume here that
you want to win this game.
So the game is an
alternating coins game
where we have a row of n
coins of values V1 through Vn.
These are not necessarily
in any particular order.
And n is even.
And the goal here is
select the outer coins.
So select either the first
our last coin from the row,
and then the opponent plays.
Remove permanently, but
add it to your value
and receive the value.
So I need two volunteers
to play this game.
And you want to
maximize the value.
The winner gets a blue Frisbee.
The loser gets a purple
Frisbee, because blue
is greater than purple.
And you might ask, why is that.
Well, if you went to a beach,
and you saw water this color,
and you went to another beach,
and you saw water this color,
which beach would you pick?
Right?
This is Cozumel.
This is Boston Harbor.
So blue is greater than purple.
Don't use this proof
technique in the quiz.
So do I have a couple of
volunteers to play this game?
Two of them over there.
Are you waving for him?
Yeah.
I see one.
You can come down.
Another volunteer?
Yeah.
Over there.
You don't get your Frisbees yet.
So we're going to
make this really fair.
What's your name?
AUDIENCE: Josiah.
PROFESSOR: Josiah.
AUDIENCE: Tessa.
PROFESSOR: Tessa.
Josiah and Tessa, I'm going
to write out a bunch of-- it's
going to be a fairly short game.
And we're going
to be really fair,
and we're going to flip a coin
to decide whether Josiah goes
first-- you can pick
heads or tails--
or whether Tessa goes first.
Actually if you win, you can
let her go first if you want.
But you get to choose.
AUDIENCE: All right.
PROFESSOR: So pick.
AUDIENCE: Heads.
PROFESSOR: That's heads.
Do you want to go first, or do
you want to let Tessa go first?
[LAUGHTER]
AUDIENCE: You should go first.
PROFESSOR: All right.
So Tessa, you get to go first.
AUDIENCE: OK, 6.
PROFESSOR: 6, OK.
So let's just say T.
So you get to choose
either 25 or 4, Josiah.
AUDIENCE: I think I'd pick 25.
PROFESSOR: You think
you'll take 25.
So that's j.
So it's not on the 4 and 19 over
here because those are gone.
So your turn again.
AUDIENCE: OK.
Can I take a minute,
or should I just go?
PROFESSOR: Well, you
can take 30 seconds.
AUDIENCE: 19.
PROFESSOR: 19, OK.
AUDIENCE: 4.
[LAUGHTER]
AUDIENCE: All right, 4.
PROFESSOR: 4.
All right.
And 42?
AUDIENCE: Yeah.
PROFESSOR: All right, 42.
This is one strange game.
Now, we get to add
up the numbers.
This is going to be tight.
4 plus 39 is 43.
43 plus 25 is 68.
42 plus 19 is 61.
61 plus 6 is 67.
Ooh.
Well, you get Frisbees.
Well, blue for you.
I mean, you could give
her blue if you like.
AUDIENCE: I prefer purple.
PROFESSOR: You prefer purple.
Thanks.
Good job.
[APPLAUSE]
No offense is intended
to Josiah and Tessa,
but that was a classic example
of how not to play the game.
First off, Josiah could
have won regardless
of the coins that were
up there, regardless
of the values of the coins,
if he'd chosen to go first.
So this game, the
person who goes first
is guaranteed to not lose.
And by that, I mean you
may have a situation where
you can have a tie in
terms of the values,
but you're guaranteed
to not lose.
Now, he ended up winning
anyway, because there
were other errors
made during this,
and I don't have the time
to enumerate all of them.
[LAUGHTER]
So we're just going to go move
on and do the right thing.
So let me first tell
you, outside of DP, just
in case you play this game
over Spring Break or something,
how you can win this
game without having
to compute complicated
recursive memoization DP
programs for this case.
So let's say I have V1, V2,
V3, all the way to V n minus 1
and Vn.
And remember n is even.
So you've got to
pick n over 2 coins
if you're the first
player and n over 2
if you're the second player.
So what the first
player does is simply
compute V1-- take the odd
numbers-- and n is even,
so you've got V n
minus 1 being odd.
Compute V1 plus V3 all
the way to V n minus 1,
and compare that with
the even positions,
V2 plus V4 all the way Vn.
So in this particular
instance, Josiah,
who went second,
if you just look
at the odd positions, which
is, in fact, what he ended up
picking, it was 4 plus
39 plus 25, which was 68.
So you can do this
computation beforehand.
You compute this to
be 68, in our case.
Compare that with 67.
And you don't give up your
first-player advantage.
So you're going with
the first player.
But now you say, I know
that I can set this up--
and that wasn't
the order that he
did this-- but I know
I can set this up
so I always have a chance to
get V1, V3, V5, et cetera.
Because let's just say that
the first player Josiah
started first.
And he decided, in this
case, that the odd values
are the ones that win.
So let's say he picks V1.
At this point, Tessa
sees V2 through Vn.
So you're just looking at that.
Now Tessa could either pick
V2 or she could pick Vn.
In that case, Josiah,
who's the first player,
could pick V3 or Vn minus
1 and stick with his rule
of picking the odd coins.
So regardless of
what Tessa does,
the first player,
Josiah, could pick odd
if odd was the way to go or if
the values were such that, even
with the way to go,
he could go even.
So no reason for the
first player to lose.
But let's just say that you're
a nasty person, Michael Jordan
nasty.
You want to just
press your opponent.
You want to make sure they
never want to play you again.
So now you have a
maximization problem.
So this is clearly not DP.
You don't need DP to add
up a bunch of numbers.
But let's say that you want
to, given a set of coins,
V1 through Vn, you want
a dynamic strategy that
gives you the maximum value.
This odd versus even
is a bit constraining,
because you're stuck
to these positions.
And it's good to be
in that situation
if you just want to win and
you don't care how you win.
But if you want to
maximize, then it's
a more complicated problem.
And so we have to talk about
how you would do something that
would give-- maybe it would be
V1 and V4 and something else,
depends on the values.
How would you get
to a situation--
if you're the first player.
We'll just stick with
you're the first player.
You know you can't lose
using this strategy.
But not only do you
want to not lose,
you want to get as many
coins as possible--
let's say this is money.
More money is better,
and that's your goal.
So people understand that.
A little trick there with,
I guess, a greedy algorithm
you can think of.
Or it's not really
even something
that you might want
to call an algorithm.
It's a little computation.
And our goal now is to
maximize the amount of money
when assuming you move first.
And so this is going to be a
little bit different from all
of the other problems
we've looked at,
because we have to now think
about what the opponent would
do.
And there's going to be
a sequence of moves here.
You're going to move
first, so that one is easy.
You've got the whole problem.
But now you have to
say, the opponent
is going to move
and pick a coin.
And then you have to
think of your subproblems
as the potential rows of coins
that are going to be different,
depending on what
the opponent does.
And through this process, you
have to maximize the value.
So it's really pretty
different from the other couple
of examples that we looked at.
So we're going to have to
do a little bit of set-up
before we get to the point
where we can write something
like this, which is
the solution to our DP.
And so let me do that set-up.
But it's not super complicated.
And part of this is going
to look kind of the same
as previous problems
we've looked at.
So Vij is the max
value we can definitely
win if it is our turn.
And only coins Vi
through Vj remain.
And so we have Vii.
Then there's only one coin
left, and you just pick i.
Now, you might say,
but that's never
going to happen if there's
an even number of coins
and I'm playing first, because
the other player is going
to be at the end of the-- is
going to be the person who
picks the last coin.
But we need to
categorize Vii because we
need to model what the
other player is going to do.
So we can't just
say that we're going
to be looking at an even
number of coins in terms
of the row of coins that
you look at, which is true,
that when you get
to move, you only
see an even number of coins
if you're the first player.
But you do have to model
what the opponent does .
So we need the Vii.
And what you might
see, of course,
is a board that looks like Vi
i plus 1, for some arbitrary i.
So that's why I
have it up there.
But remember that you're only
picking coins on the outside,
so it's not like you're
going to have a gap.
I mean, you're not going to
have V3 left and V7 left.
There's no way that's
going to happen.
You're just going to keep
shrinking, taking things
from the left or the right.
So it's going to
be i and i plus 1.
That make sense?
And so in this case,
what would you pick?
Vi and i plus 1.
You just pick the max.
Because at the end of this,
either you did it right
or you did it wrong.
Either way, you're going
to improve your situation
by picking the max
of Vi or Vi i plus 1.
So there's no two
things about it.
So here, you're going to
pick the maximum of the two.
And you might have Vi i plus 2,
which is an odd number of coins
that your opponent might see.
It gets more complicated
for Vi and i plus 2.
We're going to have to now start
thinking in more general terms
as to what the
different moves are.
But we've got the
base cases here.
All I did here was take
care of the base case
or a couple of base
cases associated
with a single coin, which
is what your opponent will
see and pick, or two coins,
which is your last move.
So with DP, of
course, you always
have to go down
to your base case,
and that's when
things become easy.
So we have to talk
about two things
and put up our
recurrence together.
The two things we
have to talk about
are what you do when you
move, and that's actually
fairly easy, and
the second thing
is what the model
of the opponent
looks like when you're waiting
for him or her to move.
So let's take a
look at your move.
And I've got V1.
Let's look at Vi.
Vj here, dot dot dot, Vn.
So that's what you see.
And you're looking at i and j.
And at this point, you're
seeing all those other coins,
the outer coins have disappeared
into people's pockets.
And you're looking
at this interval.
So I'm going to write
out what Vij should be.
And keep in mind that we want
to maximize the amount of money.
And we want to say
that you should
be able to definitely win this
amount of money, regardless
of what the opponent does.
So I want to do
a max, obviously.
And I have two choices here.
I can pick Vi or I can pick Vj.
It's not like there's
a lot of choices here.
So if I pick Vi,
then-- let me go ahead
and say I pick Vi here.
And here, I pick Vj.
Let me draw this out
a little bit better.
So I've got to fill in these
two arguments to my max.
So this is easy.
I'm going to have
a plus Vi here.
Going to have a plus
Vj here because I
picked the appropriate value.
And now, this is also
not that difficult.
What exactly happens?
What can I put in
here if I pick Vi?
AUDIENCE: Vi plus 1.
PROFESSOR: Yeah.
Vi plus 1 to j.
So the range becomes i plus 1 j.
I have to be a little
careful here in terms
of whether I can argue
that it's actually
the V that I put in here.
So the subtlety here is
simply that the Vi plus 1 j
is not something that
I see in front of me.
This is the complication.
Vi plus 1 j is never a board
that I see in front of me,
whereas Vij was a board
that I saw in front of me.
So I have to model the boards
that I see in front of me,
because those are the boards
that I have control over
that I can maximize.
I cannot would be Vi
plus 1 j in there,
simply because I don't
quite know what that is,
because of what I get eventually
is not something I control.
It's going to be the board
after my opponent has moved.
So all I'm going to do is
I'm going to say the range
becomes-- range is i plus 1 j.
And I'm going to say something
else in a second here.
The range is i j minus 1.
And in both of these
cases, the opponent moves.
So in order to actually
write out my DP,
I'm going to have to now
look at the worst case
situation in terms of
the board I get back,
because the only times
I'm adding values
is when I see a board in
front of me and I pick a coin.
And I'm going to have to say
now the opponent is going
to see an i plus 1 j-- or
an i j minus 1, excuse me,
and might do something.
And I'm going to
get something back.
I'm going to assume that
the opponent is just
as smart as I am,
knows DP, taken
6046, et cetera, et cetera.
And I still want to
get the maximum value
that I can definitely win.
And so we need to look
inside of that a little bit.
And it's not that hard if
you just make the assumption
that I just did,
which is the opponent
is going to do-- I mean
might not necessarily
do the right thing.
But you have to assume that
the opponent knows just as much
as you do and is going to try
and do as well as possible.
So let's do that.
That's the last thing
that we have to do here.
And it's just one more equation.
So here's the solution.
We now have Vi plus 1 j
subproblem with the opponent
picking.
And the simple
observation is that we
are guaranteed the min
of Vi plus 1 j minus 1
or Vi plus 2 j.
In this case, the opponent
picks Vj, and in this case,
the opponent picks Vi plus 1.
And you're guaranteed
the minimum of these two,
because the opponent
can only pick one coin.
So that's the simple
observation that
lets you jump ahead to your
next move, which is really
what the DP is interested
in, because that's
the only time that you're
actually executing something
in terms of picking
coins from the board
and adding to your value.
But we did have to model that
as to what the maximum value was
that you could win,
jumping ahead of this move.
And you have the min
in here because you're
assuming that this is
a definite guarantee.
That's what we want.
It's possible that the
opponent plays a different game
from the one that we think
he or she is going to play,
which maximizes his or value.
But the min is guaranteed.
So now that you've
made this observation,
it turns out we just have to
take that, and we'll be done.
So let's see.
Let me erase this.
It's the last set of equations.
And it's just plugging
in that observation
into what I wrote before.
So we have Vi j equals max.
This is the outer max that
I had up there already,
so that's the same max.
And put these giant
brackets here.
And inside, I'm going to
plug in this min, which
is something that
corresponds to the value
that I would win
in the worst case
after the opponent plays
the best possible move.
And that would be Vi plus 1 j
minus 1, V1 plus 2 j plus Vi.
This Vi is the same
as this one up here.
And you've got a plus Vj here.
And I didn't actually
do this, but in terms
of writing out what the opponent
would do in other subproblem
case, but it's really
pretty straightforward.
You have a problem
that corresponds
to the i j minus 1 problem.
And the opponent
could pick the i-th
or could pick the j minus 1th.
If the opponent picks
the j minus 1th,
you get Vi j minus 2, and you
need to take the min of that.
In the other case, where the
opponent picks i, in which case
you get i plus 1 j minus 1.
And that's our DP.
That's our DP.
So the big difference
here was the modeling
that you had to
do in the middle.
We didn't actually have
to do that in any of DPs
we've covered in 046 at
least up until this point.
Before we talk about complexity,
that should just take a minute,
people buy that?
See that?
Good.
So with all of these
problems, the complexities
are fairly straightforward
to compute.
The complexity here
is simply, again, as
before, the number
of subproblems times
the time it takes to
solve the subproblem.
You can see here are that
these are all constant time
operations.
So assuming that the
Vij's have been computed,
it's theta 1 time to
compute a subproblem.
So that's your theta 1.
And as before, there are
n squared subproblems.
Sorry.
Let's just do number of
subproblems times theta 1.
It's just theta n squared.
So that was good.
All right.
So good luck for the quiz.
And don't worry
too much about it.
See you guys next week.
