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.
ERIK DEMAINE: All right, let's get started.
Today, we have another cool graph algorithm or problem.
Actually, we'll have two algorithms.
The problem is called minimum spanning tree.
You can probably guess from the title what it's trying to do.
We'll see two algorithms for doing it.
Both of them are in the category of greedy algorithms, which
is something we've seen a couple of times
already in 6.046, starting with lecture 1.
This is the definition of greedy algorithm from lecture 1,
roughly.
The idea is to always make greedy choices, meaning
the choice is locally best.
For right now, it seems like a good thing to do,
but maybe in the future it will screw you over.
And if you have a correct greedy algorithm,
you prove that it won't screw you over.
So it's sort of like Cookie Monster here, always
locally seems like a good idea to eat another cookie,
but maybe it'll bite you in the future.
So today we will embrace our inner Cookie Monster
and eat as many-- eat the largest cookie first,
would be the standard algorithm for Cookie Monster.
I don't know if you learned that in Sesame Street,
but-- all right.
So what's the problem?
Minimum spanning tree.
Can anyone tell me what a tree is?
Formally, not the outside thing.
In graph land.
Acyclic graph, close.
Connected acyclic graph, good.
That's important.
This is 604.2 stuff.
OK, so how about a spanning tree?
Sorry?
AUDIENCE: It contains all the vertices.
ERIK DEMAINE: It contains all the vertices.
Yeah.
So let me go over here.
Spanning means it contains all the vertices, so implicit here,
I guess, is subtree or subgraph.
You're given a graph.
You want a spanning tree of that graph.
It's going to be a tree that lives inside the graph.
So we're going to take some of the edges of G,
make a tree out of them, make a connected acyclic graph.
And that tree should hit all the vertices in G.
So this is going to be a subset of the edges, or subgraph.
Those edges should form a tree.
And, I'll say, hit all vertices of G.
OK, if I just said they should form a tree,
then I could say, well, I'll take no edges,
and here's a tree with one vertex.
That's not very interesting.
You want a vertex-- you want, basically,
the vertex set of the tree to be the same as the vertex
set of the graph.
That's the spanning property.
But you still want it to be a tree,
so you want it to be connected and you want it to be acyclic.
Now if G is disconnected, this is impossible.
And for that, you could define a spanning forest
to be like a maximal thing like this,
but we'll focus on the case here as G is connected.
That's the interesting case.
And so we can get a spanning tree.
All right?
So what is this minimum spanning tree problem?
Minimum spanning tree.
We're given a weighted graph, just like last time,
with shortest paths.
We have an edge weight function W giving me a real number, say,
for every edge.
And we want to find a spanning tree of minimum total weight.
So I'm going to define the weight of a tree T
to be the sum over all edges in T,
because I'm viewing a spanning tree as a set of edges,
of the weight of that edge.
OK, so pretty much what you would expect.
Minimum weight spanning tree.
It's a relatively simple problem,
but it's not so easy to find an algorithm.
You need to prove a lot to make sure that you really
find the right tree.
I guess the really naive algorithm here
would be to try all spanning trees,
compute the weight of each spanning tree
and return the minimum.
That sounds reasonable.
That's correct.
But it's bad, because-- n to the fourth, that would be nice.
It's larger than that.
Maybe not so obvious, but it can be exponential.
Here's a graph where the number of spanning trees
is exponential.
This is a complete bipartite graph
with two vertices on one side and n vertices on the other,
and so you can-- let's say we put these two
edges into the spanning tree.
And now, for each of these vertices,
we can choose whether it connects to the left vertex
or the right vertix.
It can only do one, but it could do either one independently.
So maybe this guy chooses the left one,
this one chooses the right one.
This one chooses the left one, and so on.
If I have n vertices down here, I have 2 to the n different
spanning trees.
So there can be an exponential number.
So that algorithm is not so good.
Exponential bad.
Polynomial good.
So today, we're going to get a polynomial algorithm.
In fact, we will get an almost linear time algorithm as fast
as Dijkstra's algorithm.
But we can't use Dijkstra's algorithm,
there's no shortest paths here.
Plus, one of the algorithms will actually look pretty similar.
Two lectures ago, the dynamic programming lecture,
we saw an example where we tried to do greedy,
and it gave the wrong answer, and so
we fell back on dynamic programming.
Today, we're going to try to do dynamic programming,
it's going to fail, and we're going to fall back on greedy.
It's like the reverse.
But the way it's going to fail is
we're going to get exponential time initially,
and then greedy will let us get polynomial time.
This is actually a bit unusual.
I would say more typically, dynamic programming
can solve anything, but, you know, with n
to the seventh running time, something slow.
And then you apply greedy, and you get down
to like n or n log n running time.
So that's more common.
But today, we're going to go from exponential
down to polynomial.
And that's pretty nice.
Cool.
So let me tell you a little bit about greedy algorithm
theory, so to speak.
This is from the textbook.
If your problem can be solved by greedy algorithm,
usually you can prove two properties
about that algorithm.
One of them is called optimal substructure.
And the other is called the greedy choice property.
Optimal substructure should be familiar idea
because it's essentially an encapsulation
of dynamic programming.
Greedy algorithms are, in some sense,
a special form of dynamic programming.
So this is saying something like,
if you can solve subproblems optimally,
smaller subproblems, or whatever, then you can
solve your original problem.
And this may happen recursively, whatever.
That's essentially what makes a recurrence
work for dynamic programming.
And with dynamic programming, for this to be possible,
we need to guess some feature of the solution.
For example, in minimum spanning tree,
maybe you guess one of the edges that's in the right answer.
And then, once you do that, you can reduce it
to some other subproblems.
And if you can solve those subproblems,
you combine them and get an optimal solution
to your original thing.
So this is a familiar property.
I don't usually think of it this way for dynamic programming,
but that is essentially what we're doing via guessing.
But with greedy algorithms, we're not going to guess.
We're just going to be greedy.
Eat the largest cookie.
And so that's the greedy choice property.
This says that eating the largest cookie
is actually a good thing to do.
If we keep making locally optimal choices,
will end up with a globally optimal solution.
No tummy ache.
This is something you wouldn't expect to be true in general,
but it's going to be true for minimum spanning tree.
And it's true for a handful of other problems.
You'll see a bunch more in recitation tomorrow.
This is sort of general theory, but I'm actually
going to have a theorem like this for minimum spanning tree
and a theorem like this for minimum spanning tree.
This is the prototype, but most of today is all about minimum
spanning tree.
And for minimum spanning tree, neither of these
is very obvious.
So I'm just going to show you these theorems.
They're fairly easy to prove, in fact, but finding them
is probably the tricky part.
Actually, I guess optimal substructure is probably
the least intuitive or the least obvious greedy choice.
You're probably already thinking,
what are good greedy choices?
Minimum weight edge seems like a good starting point,
which we will get to.
But there's even a stronger version
of that, which we will prove.
And first, optimal substructure.
So here, I'm going to think like a dynamic program.
Let's suppose that we know an edge that's in our solution.
Suppose we know an edge that lives
in a minimum spanning tree.
We could guess that.
We're not going to, but we could.
Either way, let's just suppose than an edge e--
I should mention, I guess I didn't say,
this graph is undirected.
A minimum spanning tree doesn't quite make sense
with directed graphs.
There are other versions of the problem
but here, the graph is undirected.
So probably, I should write this as a unordered set, u,
v. And there are possibly many minimum spanning trees.
There could be many solutions with the same weight.
For example, if all of these edges have weight 1,
all of these trees are actually minimum.
If all the edges have weight 1, every spanning tree
is minimum, because every spanning tree has exactly
n minus 1 edges.
But let's suppose we know an edge that's
guaranteed to be in some minimum spanning tree, at least one.
What I would like to do is take this, so let me draw a picture.
I have a graph.
We've identified some edge in the graph, e, that lives
in some minimum spanning tree.
I'm going to draw some kind of tree structure here.
OK.
The wiggly lines are the tree.
There are some other edges in here,
which I don't want to draw too many of them because it's ugly.
Those are other edges in the graph.
Who knows where they are?
They could be all sorts of things.
OK?
But I've highlighted the graph in a particular way.
Because the minimum spanning tree
is a tree, if I delete e from the tree, then
I get two components.
Every edge I remove-- I'm minimally connected.
So if I delete an edge, I disconnect into two parts,
so I've drawn that as the left circle and the right circle.
It's just a general way to think about a tree.
Now there are other unused edges in this picture,
who knows where they live?
OK?
What I would like to do is somehow simplify this graph
and get a smaller problem, say a graph with fewer edges.
Any suggestions on how to do that?
I don't actually know where all these white edges are,
but what I'd like to do is-- I'm supposing I know where e is,
and that's an edge in my minimum spanning tree.
So how could I get rid of it?
Yeah.
AUDIENCE: Find the minimum weight
spanning tree of the two edges.
ERIK DEMAINE: I'd like to divide and conquer.
Maybe find the minimum weight over
here, minimum weight over here.
Of course, I don't know which nodes are in what side.
So that's a little trickier.
But what do I do but E itself?
Let's start with that.
Yeah.
AUDIENCE: You remove it?
ERIK DEMAINE: You could remove it.
That's a good idea.
Doesn't work, but worth a Frisbee nonetheless.
If I delete this edge, one problem
is maybe none of these red edges exist and then my graph
is disconnected.
Well, maybe that's actually a good case.
That probably would be a good case.
Then I know how to divide and conquer.
I just look at the connected components.
In general, if I delete the edge,
and I have these red edges, then I maybe
find a minimum spanning tree on what remains.
Maybe I'll end up including one of these edges.
Maybe this edge ends up in the spanning tree,
and then I can't put E in.
So it's a little awkward.
Yeah?
AUDIENCE: Can you merge the two nodes into one?
Merge the two nodes into one.
Yes.
Purple Frisbee.
Impressive.
This is what we call contracting the edge.
It just means merge the endpoints.
Merge u and v. So I will draw a new version of the graph.
So this was u and v before.
You've got to put the label inside.
And now we have a new vertex here, which is uv.
Or you can think it as the set u, v. We
won't really need to keep track of names.
And whatever edges you had over here,
you're going to have over here.
OK?
Just collapse u and v. The edge e disappears.
And one other thing can happen.
Let me-- go over here.
We could end up with duplicate edges by this process.
So for example, suppose we have u and v,
and they have a common neighbor.
Might have many common neighbors, who knows.
Add some other edges, uncommon neighbors.
When I merge, I'd like to just have
a single edge to that vertex and a single edge to that vertex.
And what I'm going to do is, if I
have some weights on these edges, let's say a and b,
and c and d, I'm just going to take the minimum.
Because what I'm about to do is compute a minimum spanning tree
in this graph.
And if I take the minimum spanning tree here,
and I had multiple edges-- one weight a,
one weight b-- do you think I would choose the larger weight
edge?
It does-- they're exactly the same edge,
but one is higher weight.
There's no point in keeping the higher weight one,
so I'm just going to throw away the higher weight one.
Take them in.
So this is a particular form of edge contraction and graphs.
And I claim it's a good thing to do, in the sense
that if I can find a minimum spanning tree
in this new graph-- this is usually
called a G slash e, slash instead of negative, to remove
e.
I'm contracting e.
So this is G slash e.
This is G. If I can find a minimum spanning tree in G
slash e, I claim I can find one in the original graph G
just by adding the edge e.
So I'm going to say if G prime is
a minimum spanning tree, of G slash e,
then T prime union e is a minimum spanning tree of G.
So overall, you can think of this
as a recurrence in a dynamic program,
and let me write down that dynamic program.
It won't be very good dynamic program,
but it's a starting point.
This is conceptually what we want to do.
We're trying to guess an edge e that's
in a minimum spanning tree.
Then we're going to contract that edge.
Then we're going to recurse, find the minimum spanning tree
on what remains, and then we find the minimum spanning tree.
Then we want to decontract the edge,
put it back, put the graph back the way it was.
And then add e to the minimum spanning tree.
And what this lemma tells us, is that this
is a correct algorithm.
If you're lucky-- and we're going to force luckiness
by trying all edges-- but if we start with an edge that
is guaranteed to be in some minimum spanning tree, call it
a safe edge, and we contract, and we
find a minimum spanning tree on what remains,
then we can put e back in at the end,
and we'll get a minimum spanning tree of the original graph.
So this gives us correctness of this algorithm.
Now, this algorithm's bad, again,
from a complexity standpoint.
The running time is going to be exponential.
The number of sub problems we might have to consider here
is all subsets of edges.
There's no particular way-- because at every step,
we're guessing an arbitrary edge in the graph,
there's no structure.
Like, we can't say well, it's the first k edges,
or some substring of edges.
It's just going to be some subset of edges.
There's exponentially many subsets, 2 to the e,
so this is exponential.
But we're going to make a polynomial
by removing the guessing.
This is actually a really good prototype
for a greedy algorithm.
If instead of guessing, trying all edges,
if we could find a good edge to choose
that's guaranteed to be in a minimum spanning tree,
then we could actually follow this procedure,
and this would be like an iterative algorithm.
If you-- you don't guess-- you correctly
choose a good-- you take the biggest cookie,
you contract it, and then you repeat that process
over and over, that would be a prototype
for a greedy algorithm and that's what's going to work.
There's different ways to choose this greedy edge,
and we're going to get two different algorithms
accordingly.
But that's where we're going.
First, I should prove this claim, cause,
you know, where did edge contraction come from?
Why does it work?
It's not too hard to prove.
Let's do it.
Question?
Oh.
All right.
I should be able to do this without looking.
So--
Proof of optimal substructure.
So we're given a lot.
We're told that e belongs to a minimize spanning tree.
Let's give that spanning tree a name.
Say we have a minimum spanning tree T star, which contains e.
So we're assuming that exists, then we contract e.
And then we're given T prime, which
is a minimum spanning tree of G slash e.
And then we want to analyze this thing.
So I want to claim that this thing is
a minimum spanning tree, in other words,
that the weight of that spanning tree
is equal to the weight of this spanning tree,
because this one is minimum.
This is a minimum spanning of G. And this is also
supposed to be a minimum spanning tree of G.
OK.
Sounds easy, right?
I'm going to cheat, sorry.
I see.
Right.
Duh.
Easy, once you know how.
So what we're going to do is think about contracting e.
OK, we already know we're supposed
to be thinking about contracting e in the graph.
Let's look at how it changes that given minimum spanning
tree.
So we have T star, minimum spanning
tree of the whole graph, and then I'm going to contract e.
What I mean is, if that edge happens
to be in the spanning tree-- it is, actually.
We assumed that e is in there.
So I'm basically removing, I'm just deleting that edge,
maybe I should call it minus e.
Then that should be a spanning tree of G slash e.
So when I contract the edge in the graph,
if I throw away the edge from this spanning tree,
I should still have a spanning tree,
and I don't know whether it's minimum.
Probably, it is, but we won't prove that right now.
I claim it's still a spanning tree.
What would that take?
It still hits all the vertices, because if I removed the edge,
things would not be connected together.
But this edge was in the spanning tree,
and then I fused those two vertices together,
so whatever spanning-- I mean, whatever was connected
before is still connected.
Contraction generally preserves connectivity.
If these things were already connected directly by an edge
when I contract, I still have a connected structure,
so I'm still hitting all the vertices.
And also, the number of edges is still exactly right.
Before, I had n minus 1 edges.
Afterwards, I'll still have n minus 1 edges,
because I removed one edge and I removed one vertex,
in terms of the count.
So that proves that it's still a spanning tree,
using properties of trees.
Cool.
So that means the minimum spanning tree, this thing,
T prime, the minimum spanning tree of G slash e,
has a smaller weight than this one.
Because this is a spanning tree, the minimum
is smaller than all spanning trees.
So we know the weight of T prime is
less than or equal to the weight of T star minus e.
Cool.
And now we want to know about this thing, the weight of T
prime plus e.
Well, that's just the weight of T prime plus the weight of e,
because the weight of a tree is just
the sum of the weights of the edges.
So this is less than or equal to w
of T star minus e plus e, which is just the weight of T star.
So we proved that the weight of our proposed spanning tree
is less than or equal to the weight of the minimum
spanning tree in G, and therefore, T prime union
e actually is a minimum spanning tree.
OK?
This is really easy.
It actually implies that all of these inequalities
have to be equalities, because we
started with something minimum.
Clear?
That's the easier half.
The
More interesting property is going to be this greedy choice
property.
This is sort of where the action is for greedy algorithms,
and this is usually the heart of proving
greedy algorithms are correct.
We don't yet have a greedy algorithm,
but we're thinking about it.
We need some way to intelligently choose an edge e,
and I'm going to give you a whole bunch of ways
to intelligently choose an edge e.
So here's a really powerful lemma,
and we're going to make it even stronger in a moment.
So I'm going to introduce the notion of a cut, that's
going to be a similar picture to what I had before.
I'm going to look at some set of vertices.
S here is a subset of the vertices,
and that leaves in the graph, everything else.
This would be V minus S. OK, so there's
some vertices over here, some vertices over here,
there's some edges that are purely
inside one side of the cut.
And then what I'm interested in are
the edges that cross the cut.
OK, whatever they look like, these edges.
If an edge has one vertex in V and one vertex not in V,
I call that edge a crossing edge.
OK, so let's suppose that e is a least-weight edge crossing
the cut.
So let's say, let me be specific, if e is uv,
then I want one of the endpoints, let's u, to be in S,
and I want the other one to be not in S,
so it's in capital V minus S. And that
would be a crossing edge, and among all the crossing edges,
I want to take one of minimum weight.
There might be many, but pick any one.
Then I claim that edge is in a minimum spanning tree.
This is our golden ticket, right?
If we can guarantee an edge is in the minimum spanning tree,
then we plug that in here.
Instead of guessing, we'll just take that edge--
we know it's in a minimum spanning tree--
and then we'll contract it and repeat this process.
So the tricky part-- I mean, it is true that the minimum weight
edge is in a minimum spanning tree, I'll give that away.
But the question is, what you do then?
And I guess you contract and repeat
but, that will be Kruskal's algorithm.
But this is, in some sense, a more general tool
that will let us identify edges that are guaranteed
to be in the minimum spanning tree,
even after we've already identified some edges as being
in the minimum spanning tree, so it's a little more powerful.
Let's prove this claim.
This is where things get particularly cool.
And this is where we're going to use something
called a c and paste argument.
And if you are ever trying to prove
a greedy algorithm correct, the first thing
that should come to your mind is cut and paste.
This is almost universally how you prove greedy algorithms
to be correct, which is, suppose you have some optimal solution
which doesn't have the property you want,
like that it includes e here.
And then you modify it, usually by cutting out
one part of the solution and pasting in a different part,
like e, and prove that you still have an optimal solution,
and therefore, there is an optimal solution.
There is an MST that has the property you want.
OK, so we're going to do that by starting from an arbitrary
minimum spanning tree.
So let T star be a minimum spanning tree of G,
and if the edge e is in there, we're done.
So presumably, e is not in that minimum spanning tree.
We're going to modify T star to include e.
So again, let me draw the cut.
There's S and V minus S. We have some edge e
which crosses the cut, goes from u to v,
that's not in the minimum spanning tree.
Let's say in blue, I draw the minimum spanning tree.
So you know, the minimum spanning tree
connects everything together here.
I claim it's got to have some edges that cross the cut,
because if it has no edges that cross the cut,
it doesn't connect vertices over here with vertices over here.
So it may not use e, but some of the edges must cross the cut.
So here's a possible minimum spanning tree.
It happens to have sort of two components over here
in S, maybe.
Who knows?
But there's got to be at least one edge the crosses over.
In fact, the minimum spanning tree, T star,
has to connect vertex u to vertex v, somehow.
It doesn't use e, but there's got to be-- it's a tree,
so in fact, there has to be a unique path from u
to v in the minimum spanning tree.
And now u is in S, v is not in S. So if you look at that path,
for a while, you might stay in S,
but eventually you have to leave S, which
means there has to be an edge like this one, which
I'll call it e prime, which transitions
from S to V minus S.
So there must be an edge e prime in the minimum spanning tree
that crosses the cut, because u and v are connected by a path
and that path starts in S, ends not in S, so it's got
to transition at least once.
It might transition many times, but there has
to be at least one such edge.
And now what I'm going to do is cut and paste.
I'm going to remove e prime and add an e instead.
So I'm going to look at T star minus e prime plus e.
I claim that is a minimum spanning tree.
First I want to claim, this is maybe the more annoying part,
that it is a spanning tree.
This is more of a graph theory thing.
I guess one comforting thing is that you've
preserved the number of edges, so it should still
be if you get one property, you get
the other, because I remove one edge, add in one edge,
I'm still going to have n minus 1 edges.
The worry, I guess, is that things become disconnected
when you do that, but that's essentially not
going to happen because if I think
of removing e prime, again, that disconnects the tree into two
parts.
And I know, by this path, that one part contains this vertex,
another part contains this vertex,
and I know that this vertex is connected to u
and this vertex is connected to v. Maybe I should
call this u prime and v prime.
I know u and u prime are connected by a path.
I know v and v prime are connected by a path.
But I know that by deleting e prime,
u prime and v prime are not connected to each other.
Therefore, u and v are not connected to each other,
after removing e prime.
So when I add in e, I newly connect u and v again,
and so everything's connected back together.
I have exactly the right number of edges.
Therefore, I'm a spanning tree.
So that's the graph three theory part.
Now the interesting part from a greedy algorithm
is to prove to this is minimum, that the weight is not too big.
So let's do that over here.
So I have the weight of T star minus e plus-- minus e
prime plus e.
By linearity, this is just the weight
of T star minus the weight e prime plus the weight of e.
And now we're going to use this property,
we haven't that yet, e is a least-weight edge crossing
the cut.
So e prime crosses the cut, so does e,
but e is the smallest possible weight you
could have crossing the cut.
That means that-- I'll put that over here-- the weight of e
is less than or equal to the weight of e
prime, because e prime is a particular edge crossing
the cut, e was the smallest weight of them.
So that tells us something about this.
Signs are so difficult. I think that means
that this is negative or zero.
So this should be less than or equal to w of T star,
and that's what I want, because that
says the weight of this spanning tree is less than
or equal to the optimum weight, the minimum weight.
So that means, actually, this must be minimum.
So what I've done is I've constructed a new minimum
spanning tree.
It's just as good as T star, but now it includes my edge e,
and that's what I wanted to prove.
There is a minimum spanning tree that
contains e, provided e is the minimum weight
edge crossing a cut.
So that proves this greedy choice property.
And I'm going to observe one extra feature of this proof,
which is that-- so we cut and paste,
in the sense that we removed one thing, which was e prime,
and we added a different thing, e.
And a useful feature is that the things that we change only
are edges that cross the cut.
So we only, let's say, modified edges that cross the cut.
I'm going to use that later.
We removed one edge that crossed the cut, and we put in the one
that we wanted.
OK so far?
There's a bunch of lemmas.
Now we actually get to do algorithms using these lemmas.
We'll start with maybe the less obvious algorithm,
but it's nice because it's very much like Dijkstra.
It follows very closely to the Dijkstra model.
And then we'll get to the one that we've all
been thinking about, which was choose a minimum weight
edge, contract, and repeat.
That doesn't-- well, that does work, but the obvious way is,
maybe, slow.
We want to do it in near linear time.
Let's start with the Dijkstra-like algorithm.
This is Prim's algorithm.
Maybe I'll start by writing down the algorithm.
It's a little long.
In general, the idea-- we want to apply this greedy choice
property.
To apply the greedy choice property,
you need to choose a cut.
With Prim, we're going to start out with an obvious cut, which
is a single vertex.
If we have a single vertex S, and we
say that is our set capital S, then you know,
there's some images coming out of it.
There's basically S versus everyone else.
That's a cut.
And so I could take the minimum weight edge
coming out of that cut and put that
in my minimum spanning tree.
So when I do that, I put it in my minimum spanning tree
because I know it's in some minimum spanning tree.
Now, I'm going to make capital S grow a little bit to include
that vertex, and repeat.
That's actually also a very natural algorithm.
Start with a tiny s and just keep growing it one by one.
At each stage use this lemma to guarantee the edge I'm adding
is still in the minimum spanning tree.
So to make that work out, we're always
going to need to choose the minimum weight edge that's
coming out of the cut.
And we'll do that using a priority queue,
just like we do in Dijkstra.
So for every vertex that's in V minus S,
we're going to have that vertex in the priority queue.
And the question is, what is the key value of that node
stored in the priority queue?
So the invariant I'm going to have is that the key of v
is the minimum of the weights of the edges
that cross the cut into v. So for vertex v,
I want to look at the-- I'm not going
to compute this every time, I'm only going to maintain it.
I want the minimum weight of an edge that starts in S
and goes to v, which is not in S because v in Q-- Q only stores
vertices that are not in S-- I want the key value
to be that minimum weight so if I choose
the overall minimum vertex, that gives me
the edge of minimum weight that crosses the cut.
OK?
I've sort of divided this minimum vertex by vertex.
For every vertex over here, I'm going
to say, what's the minimum incoming weight from somebody
over here?
What's the minimum incoming weight
from someone over here to there?
To here?
Take the minimum of those things.
And of course, the min of all those
will be the min of all those edges.
OK, that's how I'm dividing things up.
And this will be easier to maintain, but let me
first initialize everything.
OK, I guess we're going to actually initialize
with S being the empty set, so Q will store everybody,
except I'm going to get things started by setting
for particular vertex little s.
I'm going to set its key to zero.
It doesn't matter who little s is.
That's just your start vertex.
Just pick one vertex and set its key to zero.
That will force it to be chosen first
because for everyone else, for v not equal to S,
I'm going to set the key to infinity,
because we haven't yet seen any edges that go in there,
but we'll change that in a moment.
OK, so that was the initialization, now
we're going to do a loop.
We're going to keep going until the Q is empty,
because when the Q is empty, that means S is everybody,
and at that point, we'll have a spanning tree
on the whole graph, and it better be minimum.
OK, and we're going to do that by extracting
the minimum from our priority Q. When
we remove Q-- we remove vertex u from the queue Q,
this means that we're adding u to S. OK,
by taking it out of Q, that means it enters S,
by the invariant at the top.
So now we need to update this invariant,
that all the key values are correct.
As soon as we move a vertex into S,
now there are new edges we have to consider from S to not S,
and we do that just by looking at all of the neighbors of u.
I haven't written this in a long time,
but this is how it's usually written in Dijkstra,
except in Dijkstra, these are the outgoing edges from u
and v are the neighbors.
Here, it's an undirected graph, so these are
all of the neighbors v of u.
This as an adjacency list.
OK, so we're looking at u, which has just been added to S,
and we're looking at the edges.
We want to look at the edge as they go to V minus S, only
those ones.
And then for those vertices v, we need to update their keys,
because it used to just count all of these edges that
went from the rest of S to v. And now we have a new edge
uv that v needs to consider, because u just got added to S.
So the first thing I'm going say is if v in in Q.
So we're just going to store a Boolean for every vertex
about whether it's in the queue, and so
when I extract it from the queue,
I just set that Boolean to false.
Being in the queue is the same as being not in S,
this is what Q represents.
So Q is over here, kind of.
So if we're in the queue, same as saying v is not in S,
then we're going to do a check which
lets us compute the minimum.
This is going to look a lot like a relaxation.
Sorry.
A couple things going on because I
want to compute not just the value
of the minimum spanning tree, I actually
want to find the minimum spanning tree,
so I'm going to store parent pointers.
But this is just basically taking a min.
I say, if the weight of this edge
is smaller than what's currently in the key,
then update the key, because the key is supposed to be the min.
OK, that's all we need to do to maintain this invariant, this
for loop.
After the for loop, this property will be restored,
v dot key will be that minimum.
And furthermore, we kept track of where the minimums came
from, so when you end up extracting a vertex,
you've already figured out which edge you
added to put that into the set.
So in fact, u already had a parent,
this would be u dot parent, and we
want to add that edge into the minimum spanning tree
when we add u to S. Overall, let me write why this is happening.
At the end of the algorithm, for every vertex v,
we want the v dot parent.
And that will be our minimum spanning tree.
Those are the edges that form the minimum spanning tree.
Let's prove that this works.
Actually, let's do an example.
We've done enough proofs for a while.
Let's do it over here.
I need a little break.
Examples are fun, though easy to make mistakes, so correct me
if you see me making a mistake.
And let me draw a graph.
OK, weights.
14, 3, 8, 5, 6, 12, 7, 9, 15.
10.
OK.
Colors.
So I want to start at this vertex
just because I know it does an interesting thing,
or it's a nice example.
Here's my weighted undirected graph.
I want to compute minimum spanning tree.
I'm going to start with a capital
S being-- well actually, I start with capital S being nothing,
and all of the weights-- all of the key values
are initially infinity.
So I'm going to write the key values in blue.
So initially everything is infinity for every vertex,
except for S the value is zero.
So all of these things are in my priority queue,
and so when I extract from the queue, I of course get S. OK,
that's the point of that set up.
So that's when I draw the red circle containing little s.
The red circle here is supposed to be capital S.
So at this point, I've added capital S-- little s
to capital S, and then I look at all of the neighbors v of S.
And I make sure that they are outside of S. In this case,
they all are.
All three neighbors, these three guys, are not in S.
And then I look at the weights of the edges.
Here I have a weight 7 edge.
That's smaller than infinity, so I'm
going to cross out infinity and write 7.
And 15 is smaller than infinity, so I'm
going to cross out infinity and write 15.
And 10, surprise, is smaller than infinity.
So I'm going to cross out infinity rate 10.
So now I've updated the key values for those three nodes.
I should mention in the priority queue,
to do that, that is a decrease-key operation.
This thing here is a decrease-key.
You need to update the priority queue to say,
hey look, the key of this node changed.
And so you're going to have to move it around in the heap,
or whatever.
Just like Dijkstra, same thing happens.
OK, so I've decreased the key of those three nodes.
Now I do another iteration.
I look at all of the key values stored.
The smallest one is 7, because this node's no longer in there.
So I'm going to add this node to capital S.
So capital S is going to grow to include that node.
I've extracted it from the queue.
And now I look at all the neighbors of that node.
So, for example, here's a neighbor.
9 is less than infinity, so I write 9.
Here's a neighbor.
12 is less than infinity, so I write 12.
5 is less than infinity, so I write 5.
Here's a neighbor, but s is in big S,
so we're not going to touch that edge.
I'm not going to touch s.
OK?
I will end up looking at every edge twice, so no big deal.
Right now, who's smallest?
5, I think.
It's the smallest blue key.
So we're going to add 5 to the set.
Sorry, add this vertex to the set S,
and then look at all of the outgoing edges from here.
So 6 is actually less than 12, so this edge
is better than that one was.
Then, what's that, an 8?
8 Is less than 10.
14 is definitely less than infinity.
And we look at this edge, but that edge
stays inside the red set, so we forget about it.
Next smallest value is 6.
So 6, we add this guy in.
We look at the edges from that vertex,
but actually nothing happens because all those vertices
are inside capital S, so we don't care about those edges.
Next one is 8, so we'll add in this vertex.
And there's only one edge that leaves the cut, so that's 3,
and 3 is indeed better than 14.
So never mind.
Stop.
So good, now I think the smallest key is 3.
Notice smallest key is smaller than anything
we've seen before, other than 0, but that's OK.
I'll just add it in, and there's no edges
leaving the cut from there.
And then over here, we have 9 and 15.
So first we'll add 9.
There's no edges there.
Then we add 15.
OK, now s is everything.
We're done.
Q is empty.
Where's the minimal spanning tree?
I forgot to draw it.
Luckily, all of the edges here have different numbers
as labels.
So when I have a 3 here, what I mean is,
include 3 in the minimum spanning tree,
the edge that was labeled 3.
OK, so this will be a minimum spanning tree edge.
5 will be a minimum spanning tree edge.
These are actually the parent pointers.
6 will be a minimum spanning tree edge.
7, 9, 15, and 8.
Every vertex except the starting one
will have a parent, which means we'll have exactly n minus 1
edges, that's a good sign.
And in fact, this will be a minimum spanning tree.
That's the claim, because every time we grew the circle
to include a bigger thing, we were
guaranteed that this edge was in the minimum spanning tree
by applying this property with that cut.
Let me just write that down.
OK, to prove correctness, you need
to prove an invariant that this key, the key of every vertex,
always remains this minimum.
So this is an invariant.
You should prove that by induction.
I won't prove it here.
But we have another invariant, a more interesting one
from an MST perspective, you know,
it's just a sort of algorithm implementation detail,
that the tree T sub S, within S is always contained
in a minimum spanning tree of G. So over here,
we have this way of computing minimum spanning tree
for all vertices v, but what I'd like
to do is just look at v that's currently
in S. By the end, that will be the whole thing,
but if I look at v in S, and I always look at the edge from v
to v dot parent, that gives me this tree TS.
I claim it will be contained in a minimum spanning tree
of the entire graph, proof by induction.
So by induction, let's assume-- induction hypothesis will
be that, let's say there is a minimum spanning tree T
star, which contains T sub S, and then what
the algorithm does, is it repeatedly grows S by adding
this vertex u to S. So let's suppose that it adds u to S.
So I'm actually going to look at the edge that it adds.
So we have S and V minus S, and we do this thing, like we just
saw, of growing by one.
We add one new vertex over here to S,
and that vertex has a parent edge, has a parent pointer.
So this edge, I'm going to call e.
So we're adding some vertex u that we extract at the minimum,
and we also added an edge e to this TS,
because we grew S by 1.
OK, when I do that, all I do is say, look,
greedy choice property guarantees
there's a minimum spanning tree that contains e.
Because we extracted the min from the queue,
and the key values are this, as I was arguing before,
that is the minimum overall edge that crosses the cut.
e is a minimum weight edge that crosses the cut,
and so by greedy choice property,
there is some minimum spanning tree that contains e.
But actually, I need that the minimum spanning tree
not only contains e, but also contains all the other spanning
tree edges that we had already said were in T star.
OK, so here's where I'm going to use the stronger property.
I can modify T star to include e and T sub S.
So we already assumed that T star includes T sub S. I just
don't want to break that.
And if you remember the proof of this greedy choice property,
we said, well all we need to do is remove one edge that crosses
the cut and replace it with e.
So here what I'm saying is there's some edge,
yeah, maybe there's some edge over here in T star
that we had to remove, and then we put e in.
And then we get a minimum spanning tree again,
T star prime.
OK, this edge that I remove cannot be one of the TS edges
because the TS edges are all inside S.
So because I'm only removing an edge that crosses the cut,
I'm not disturbing TS.
TS will remain inside T star, but then I get the new property
that e is inside T star, and so I prove this invariant holds.
OK?
I keep changing T star, but I always preserve the property
that all of the spanning tree edges that are inside S
are contained in some minimum spanning tree of G. Maybe
I'll add in some for emphasis.
Cool?
So that's how we use the greedy choice
property to get correctness of Prim's algorithm.
What's the running time of Prim's algorithm?
Same as Dijkstra, good answer.
I guess it depends what priority queue you use,
but whatever priority queue you use, it's the same as Dijkstra.
And so in particular, if we use Fibonacci heaps, which,
again, we're not covering, we get V log V plus E. In general,
for every edge, we have to do a decrease-key.
Actually, for every edge we do two decrease-key operations,
potentially, if you think about it.
But this for loop over the adjacency, the cost
of this stuff is constant.
The cost of this is the degree of the vertex u.
And so we're basically doing the sum
of the degrees of the vertices, which
is the number of edges times 2.
That's the handshaking lemma.
So for every edge, we're potentially
doing one decrease-key operation,
and with Fibonacci heaps, that's constant time.
But we're also doing V extract mins those cost log V time,
cause the size of the queue is at most
V, and so that is actually the right running time.
Just like Dijkstra, so easy formula to remember.
All right, let's do one more algorithm, Kruskal's algorithm.
Kruskal's algorithm is a little bit weirder from the S
perspective, I guess.
We'll see what cuts we're using in a moment,
but it's based around this idea of,
well, the globally minimum weight
edge is the minimum weight edge for all cuts that cross it,
or for all cuts that it crosses.
The globally minimum weight edge is going to be a valid choice,
and so, by this theorem, you pick
some S that partitions the endpoints of e,
therefore e is in a minimum spanning tree.
So let's choose that one first, and then repeat.
Conceptually, what we want to do is that DP idea of contract
the vertex, sorry, contract the edge
and then find the minimum weight edge that remains.
But the way I'm going to phrase it doesn't explicitly contract,
although implicitly, it's doing that.
And there's a catch.
The catch is suppose I've picked some edges out to be
in my minimum spanning tree.
Suppose this was the minimum weight
and this was the next minimum, next minimum, next minimum,
next minimum.
Suppose that the next lar-- at this point,
after contracting those edges, the minimum weight edge
is this one.
Do I want to put this edge in my minimum spanning tree?
No.
That would add a cycle.
Cycles are bad.
This is the tricky part of this algorithm.
I have to keep track of whether I should actually
add an edge, in other words, whether this vertex
and this vertex have already been connected to each other.
And it turns out you've already seen a data structure
to do that.
This is what I call union-find and the textbook
calls it disjoint-set data structure.
So it's in recitation.
Recitation 3.
So I want to maintain for my MST so far,
so I'm adding edges one at a time.
And I have some tree-- well, it's actually a forest,
but I'm still going to call it T,
and I'm going to maintain it in a union-find structure,
disjoint-set set data structure.
Remember, this had three operations, make set, union,
and find set.
Tell me given an item which set does it belong to?
We're going to use that, the sets are going
to be the connected components.
So after I've added these edges, these guys, these vertices
here, will form one connected component,
and, you know, everybody else will just
be in its own separate component.
So to get started, I'm not going to have any edges in my tree,
and so every vertex is in its own connected component.
So I represent that by calling make-set v for all vertices.
So every vertex lives in its own singleton set.
OK, now I'd like to do the minimum weight edge, and then
the next minimum weight edge, and the next minimum weight
edge.
That's also known as sorting, so I'm
going to sort E by weight, increasing weight,
so I get to start with the minimum weight edge.
So now I'm going to do a for-loop over the edges,
increasing order by weight.
Now I want to know-- I have an edge,
it's basically the minimum weight edge among the edges
that remain, and so I want to know whether I should add it.
I'm going to add it provided the endpoints of the edge
are not in the same connected component.
How can I find out whether two vertices
are in the same connected component, given this setup?
Yeah?
AUDIENCE: Call find-set twice and then--
ERIK DEMAINE: Call find-set twice and see
whether they're equal, exactly.
Good answer.
So if you find-set of u is from find-set of v,
find-set just returns some identifier.
We don't really care what it is, as long
as it returns the same thing for the same set.
So if u and v are in the same set, in other words,
they're in the same connected component,
then find-set will return the same thing for both.
But provided they're not equal, then
we can add this edge into our tree.
So we add e to the set T, and then
we have to represent the fact that we just
merged the connected components of u and v,
and we do that with a union call.
And if you're ever wondering what
the heck do we use union-find for, this is the answer.
The union-find data structure was invented in order
to implement Kruskal's algorithm faster, OK?
In fact, a lot of data structures
come from graph algorithms.
The reason Fibonacci heaps were invented
was because there was Dijkstra's algorithm
and we wanted it to run fast.
So same deal here, you just saw it in the reverse order.
First you saw union-find.
Now, union-find, you know you can solve v
in alpha of n time, the inverse Ackermann function,
super, super tiny, slow growing function, smaller than log
log log log log log log.
Really small.
But we have this sorting, which is kind of annoying.
So the overall running time-- we'll
worry about correctness in a moment.
We have to sort-- to sort E by weight.
So I'll just call that's sort of E.
Then we have to do some unions.
I guess for every edge, potentially, we do a union.
I'll just write E times alpha of v. And then we have to do,
well, we also have to find-sets, but same deal.
So find-set and union cost alpha amortized,
so the total cost for doing this for all edges
is going to be the number of edges times alpha,
and then there's like plus v, I guess, but that's smaller.
That's a connected graph.
So other than the sorting time, this algorithm is really good.
It's faster.
But if you're sorting by an n log n algorithm,
this is not so great.
That's how it goes.
I think you can reduce this to sorting just v things, instead
of E things, with a little bit of effort,
like doing a select operation.
But when this algorithm is really good
is if your weights are integers.
If You have weights, let's say weight of e is 0 or 1
or, say, n to the c, for some constant c,
then I can use rate x sort, linear time sorting,
and then this will be linear time,
and I'm only paying E times alpha.
So if you have reasonably small weights,
Kruskal's algorithm is better.
Otherwise, I guess you prefer Prim's algorithm.
But either away.
I actually used a variation of this algorithm recently.
If you want to generate a random spanning tree,
then you can use exactly the same algorithm.
You pick a random manage that you haven't picked already, you
see, can I add this edge with this test?
If you can, add it and repeat.
That will give you a random spanning tree.
It will generate all spanning trees uniform leap likely.
So that's a fun fact, useful thing for union-find.
Let me tell you briefly about correctness.
Again, we proved correctness with an invariant.
Claim that at all times the tree T
of edges that we've picked so far
is contained in some minimum spanning tree, T star.
T start is going to change, but I always
want the edges I've chosen to be inside a minimum spanning tree.
Again, we can prove this by induction.
So assume by induction that this is true
so far, and then suppose that we're adding an edge here.
So we're converting T into T prime, which is T union e.
By the data structural setup, I know
that the endpoints of e, u, and v
are in different connected components.
In general, what my picture looks like,
is I have some various connected components,
maybe there's a single vertex, whatever.
I've built a minimum spanning tree for each one.
I built some tree, and I actually
know that these trees are contained in one global minimum
spanning tree.
OK, and now we're looking at an edge that
goes from some vertex u in one connected component
to some vertex v in a different connected component.
This is our edge e.
That's our setup.
Because the union-find data structure
maintains connected components, that's
another invariant to prove.
We're considering adding this edge, which connects two
different connected components.
So I want to use the greedy choice property with some S.
What should S be?
I want e to cross a cut, so what's a good cut?
Yeah?
AUDIENCE: The connected component
of u and then everything else.
ERIK DEMAINE: Connected component
of u and everything else?
AUDIENCE: Yeah.
ERIK DEMAINE: That would work, which
is also the opposite of the connected component containing
v. There are many choices that work.
I could take basically this cut, which
is the connected component of you with everything
else versus the connected component of v.
I could take this cut, which is the connected component of u
only versus everybody else.
Either of those will work.
Good.
Good curve, all right.
So let's say S equals the connected component of u,
or connected component of v. e crosses that, all right?
Because it goes from u to v, and u is on one side,
v is on the other side.
I wanted to include an entire connected component
because when I apply the greedy choice property,
I modify T star, and I don't want
to modify, I don't want to delete any of these edges that
are already in my connected components,
that I've already put in there.
But if I choose my cut to just be this,
I know that the edge that I potentially remove
will cross this cut, which means it
goes between connected components, which means
I haven't added that yet to T.
So when I apply this greedy choice property,
I'm not deleting anything from T. Everything that
was in T is still in T star.
So that tells me that T prime is contained in T star prime.
The new T star that I get when I apply the cut and paste
argument, I modify T star potentially
by removing one edge and putting e in.
And the edge that I remove was not
already in T, which means I preserve this part,
but I also get that my new edge e is
in the minimum spanning tree.
And so that's how you prove by induction that at all times
the edges that you've chosen so far are in T star.
Actually, to apply the greedy choice property,
I need not only that e is cut-- sorry, that e crosses the cut,
I also need that e is the minimum weight
edge crossing the cut.
That's a little more argument to prove.
The rough idea is that if you forget
about the edges we've already dealt with,
e is the globally minimum weight edge.
OK, but what about the edges we've already dealt with?
Some of them are in the tree.
The edges that are in these-- that are in T, those
obviously don't cross the cut.
That's how we designed the cut.
The cup was designed not to cross,
not two separate any of these connected components.
So all the edges that we've added to T, those are OK.
They're not related to the edges that cross this cut.
But we may have already considered some lower weight
edges that we didn't add to T. If we didn't add an edge to T,
that means actually they were in the same set, which
means also those are-- I'm going to use my other color, blue.
Those are extra edges in here that
are inside a connected component,
have smaller weight than e, but they're
inside the connected component.
So again, they're not crossed.
So they don't cross the cut, rather.
So e is basically the first edge that we're
considering that crosses this cut,
because otherwise we would have added that other edge first.
So here, we have to do sort of the greedy argument again,
considering edges by weight and e
is going to be the first edge that
crosses this particular cut, which
is this connected component versus everyone else.
So e has to be the minimum weight edge crossing the cut,
so the greedy choice property applies.
So we can put e in the minimum spanning tree,
and this algorithm is correct.
OK?
So we've used that lemma a zillion times by now.
That's minimum spanning tree and nearly linear time.