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,
let's get started.
We return today to graph search.
Last time we saw breadth-first
search, today we're
going to do depth-first search.
It's a simple algorithm, but
you can do lots of cool things
with it.
And that's what I'll
spend most of today
on, in particular, telling
whether your graph has a cycle,
and something called
topological sort.
As usual, basically in
all graph algorithms
in this class, the input, the
way the graph is specified
is as an adjacency list, or I
guess adjacency list plural.
So you have a bunch of lists,
each one says for each vertex,
what are the vertices
I'm connected to?
What are the vertices I can
get to in one step via an edge?
So that's our
input and our goal,
in general, with graph search
is to explore the graph.
In particular, the
kind of exploration
we're going to be doing today
is to visit all the vertices,
in some order, and visit
each vertex only once.
So the way we did
breadth-first search,
breadth-first search
was really good.
It explored things
layer by layer,
and that was nice because
it gave us shortest paths,
it gave us the fastest
way to get to everywhere,
from a particular
source, vertex s.
But if you can't get
from s to your vertex,
than the shortest way to
get there is infinity,
there's no way to get there.
And BFS is good for detecting
that, it can tell you
which vertices are
unreachable from s.
DFS can do that as
well, but it's often
used to explore the
whole graph, not just
the part reachable
from s, and so
we're going to see
how to do that today.
This trick could be used
for be BFS or for DFS,
but we're going to do it
here for DFS, because that's
more common, let's say.
So DFS.
So depth-first search is kind
of like how you solve a maze.
Like, the other weekend
I was at the big corn
maze in central
Massachusetts, and it's
easy to get lost in
there, in particular,
because I didn't bring
any bread crumbs.
The proper way to solve a
maze, if you're in there
and all you can do is see which
way to go next and then walk
a little bit to
the next junction,
and then you have to
keep making decisions.
Unless you have a really
good memory, which I do not,
teaching staff can attest to
that, then an easy way to do it
is to leave bread
crumbs behind, say,
this is the last way
I went from this node,
so that when I
reach a deadend, I
have to turn around
and backtrack.
I reach a breadcrumb that
say, oh, last time you
went this way, next time
you should go this way,
and in particular, keep track
at each node, which of the edges
have I visited, which ones
are still left to visit.
And this can be done very easily
on a computer using recursion.
So high-level
description is we're
going to just recursively
explore the graph,
backtracking as necessary, kind
of like how you solve a maze.
In fact, when I was
seven years old,
one of the first
computer programs I wrote
was for solving a maze.
I didn't know it was
depth-first search at the time,
but now I know.
It was so much harder
doing algorithms
when I didn't know
what they were.
Anyway, I'm going to write some
code for depth-first search,
it is super simple code, the
simplest graph algorithm.
It's four lines.
That's it.
I'm going to write a little
bit of code after this,
but this is basic
depth-first search.
This will visit all
the vertices reachable
from a given source, vertex s.
So we're given the
adjacency list.
I don't know why I put v
here, you could erase it,
it's not necessary.
And all we do is, we
have our vertex b, sorry,
we have our vertex s.
We look at all of the
outgoing edges from s.
For each one, we'll
call it v, we check,
have I visited this
vertex already?
A place where we
need to be careful
is to not repeat vertices.
We need to do this
in BFS as well.
So, the way we're
going to do that
is by setting the
parent of a node,
we'll see what that
actually means later.
But for now, it's just, are you
in the parent structure or not?
This is initially, we've
seen s, so we give it
a parent of nothing, but it
exists in this dictionary.
If the vertex b that
we're looking at
is not in our dictionary,
we haven't seen it yet,
we mark it as seen by
setting its parent to s,
and then we
recursively visit it.
That's it.
Super simple, just recurse.
Sort of the magical part
is the preventing yourself
from repeating.
As you explore the graph,
if you reach something
you've already seen before
you just skip it again.
So you only visit every
vertex once, at most once.
This will not visit
the entire graph,
it will only visit the
vertices reachable from s.
The next part of the
code I'd like to give you
is for visiting all the
vertices, and in the textbook
this is called the DFS,
whereas this is just
called DFS visit, that's
sort of the recursive part,
and this is sort of a
top level algorithm.
Here we are going to use
the set of vertices, b,
and here we're just going
to iterate over the s's.
So it looks almost the same,
but what we're iterating over
is different.
Here we're iterating over
the outgoing edges from s,
here were iterating
over the choices of s.
So the idea here
is we don't really
know where to start our search.
If it's a disconnected graph or
not a strongly connected graph,
we might have to start
our search multiple times.
This DFS algorithm is finding
all the possible places
you might start the search
and trying them all.
So it's like, OK, let's
try the first vertex.
If that hasn't been visited,
which initially nothing's been
visited, then visit it,
recursively, everything
reachable from s.
Then you go on to
the second vertex.
Now, you may have already
visited it, then you skip it.
Third vertex, maybe
you visited it already.
Third, fourth
vertex, keep going,
until you find some vertex
you haven't visited at all.
And then you recursively visit
everything reachable from it,
and you repeat.
This will find all the
different clusters,
all the different strongly
connected components
of your graph.
Most of the work is being
done by this recursion,
but then there's
this top level, just
to make sure that all
the vertices get visited.
Let's do a little example,
so this is super clear,
and then it will also
let me do something
called edge classification.
Once we see every
edge in the graph
gets visited by DFS
in one way or another,
and it's really helpful to
think about the different ways
they can be visited.
So here's a graph.
I think its a similar
to one from last class.
It's not strongly
connected, I don't think,
so you can't get from
these vertices to c.
You can get from
c to everywhere,
it looks like, but not
strongly connected.
And we're going to run
DFS, and I think, basically
in alphabetical order
is how we're imagining--
these vertices have
to be ordered somehow,
we don't really care how, but
for sake of example I care.
So we're going to
start with a, that's
the first vertex in here.
We're going to recursively visit
everything reachable from a,
so we enter here
with s equals a.
So I'll mark this s1, to be the
first value of s at this level.
So we consider-- I'm going
to check the order here--
first edge we look at,
there's two outgoing edges,
let's say we look
at this one first.
We look at b, b has
not been visited yet,
has no parent pointer.
This one has a
parent pointer of 0.
B we're going to give a parent
pointer of a, that's here.
Then we recursively
visit everything for b.
So we look at all the outgoing
edges from b, there's only one.
So we visit this edge.
for b to e. e has
not been visited,
so we set as parent pointer to
b, an now we recursively visit
e.
e has only one outgoing edge, so
we look at it, over here to d.
d has not been visited, so
we set a parent pointer to e,
and we look at all the
outgoing edges from d.
d has one outgoing
edge, which is
to b. b has already
been visited,
so we skip that
one, nothing to do.
That's the else case
of this if, so we
do nothing in the else case,
we just go to the next edge.
But there's no next edge
for d, so we're done.
So this algorithm returns
to the next level up.
Next level up was
e, we were iterating
over the outgoing edges from e.
But there was only one, so
we're done, so e finishes.
Then we backtrack to b,
which is always going back
along the parent pointer,
but it's also just
in the recursion.
We know where to go back to.
We were going over the outgoing
edges from b, there's only one,
we're done.
So we go back to a.
We only looked at one
outgoing edge from a.
There's another outgoing
edge, which is this one,
but we've already visited
d, so we skip over that one,
too, so we're done
recursively visiting
everything reachable from a.
Now we go back to this
loop, the outer loop.
So we did a, next we look at b,
we say, oh b has been visited,
we don't need to do
anything from there.
Then we go to c, c
hasn't been visited
so we're going to loop
from c, and so this
is our second choice
of s in this recursion,
or in this outer loop.
And so we look at the
outgoing edges from s2,
let me match the
order in the notes.
Let's say first we go to f.
f has not been visited, so we
set its parent pointer to c.
Then we look at all the
outgoing edges from f.
There's one outgoing edge
from f, it goes to f.
I guess I shouldn't
really bold this, sorry.
I'll say what the bold
edges mean in a moment.
This is just a regular edge.
We follow the edge from f to f.
We see, oh, f has
already been visited,
it already has a parent
pointer, so there's
no point going down there.
We're done with f, that's
the only outgoing edge.
We go back to c, there's
one other outgoing edge,
but it leads to a vertex we've
already visited, namely e,
and so we're done with visiting
everything reachable from c.
We didn't visit
everything reachable
from c, because some of it
was already visited from a.
Then we go back to the outer
loop, say, OK, what about d?
D has been visited,
what about e?
E's been visited, what about f?
F's been visited.
So we're visiting
these vertices again,
but should only be twice
in total, and in the end
we visit all the vertices,
and, in a certain sense,
all the edges as well.
Let's talk about running time.
What do you think the running
time of this algorithm is?
Anyone?
Time to wake up.
AUDIENCE: Upper bound?
PROFESSOR: Upper bound, sure.
AUDIENCE: V?
PROFESSOR: V?
AUDIENCE: [INAUDIBLE].
PROFESSOR: V is a little bit
optimistic, plus e, good,
collaborative effort.
It's linear time, just like BFS.
This is what we
call linear time,
because this is the
size of the input.
It's theta V plus E
for the whole thing.
The size of the
input was v plus e.
We needed v slots
in an array, plus we
needed e items in these linked
lists, one for each edge.
We have to traverse
that whole structure.
The reason it's order v plus e
is-- first, as you were saying,
you're visiting every vertex
once in this outer loop,
so not worrying about the
recursion in DFS alone,
so that's order b.
Then have to worry
about this recursion,
but we know that whenever we
call DFS visit on a vertex,
that it did not have
a parent before.
Right before we
called DFS visit,
we set its parent
for the first time.
Right before we called
DFS visit on v here,
we set as parent
for the first time,
because it wasn't set before.
So DFS visit, and I'm
going to just write of v,
meaning the last argument here.
It's called once, at
most once, per vertex b.
But it does not
take constant time.
This takes constant time per
vertex, plus a recursive call.
This thing, this takes constant
time, but there's a for loop
here.
We have to pay for however
many outgoing edges
there are from b, that's
the part you're missing.
And we pay length of adjacency
of v for that vertex.
So the total in
addition to this v
is going to be the order, sum
overall vertices, v in capital
V, of length of the
adjacency, list for v,
which is E. This
is the handshaking
lemma from last time.
It's twice e for
undirected graphs,
it's e for directed graphs.
I've drawn directed graphs here,
it's a little more interesting.
OK, so it's linear time, just
like the BFS, so you could say,
who cares, but DFS offers a
lot of different properties
than BFS.
They each have their niche.
BFS is great for shortest paths.
You want to know the fastest
way to solve the Rubik's cube,
BFS will find it.
You want to find the fastest
way to solve the Rubik's cube,
DFS will not find it.
It's not following
shortest paths here.
Going from a to
d, we use the path
of length 3, that's
the bold edges.
We could have gone
directly from a
to d, so it's a
different kind of search,
but sort of the inverse.
But it's extremely useful,
in particular, in the way
that it classifies edges.
So let me talk about
edge classification.
You can check every edge
in this graph gets visited.
In a directed graph every
edge gets visited once,
in an undirected
graph, every edge
gets visited twice,
once from each side.
And when you visit
that edge, there's
sort of different categories
of what could happen to it.
Maybe the edge led to something
unvisited, when you went there.
We call those tree edges.
That's what the parent
pointers are specifying
and all the bold edges here
are called three edges.
This is when we visit a
new vertex via that edge.
So we look at the
other side of the edge,
we discover a new vertex.
Those are what we
call tree edges,
it turns out they form
a tree, a directed tree.
That's a lemma you can prove.
You can see it here.
We just have a path, actually a
forest would be more accurate.
We have a path abed,
and we have an edge cf,
but, in general, it's a forest.
So for example, if there
was another thing coming
from e here, let's modify my
graph, we would, at some point,
visit that edge and say,
oh, here's a new way to go,
and now that bold structure
forms an actual tree.
These are called tree edges,
you can call them forest edges
if you feel like it.
There are other edges in
there, the nonbold edges,
and the textbook distinguishes
three types, three types?
Three types, so many types.
They are forward edges,
backward edges, and cross edges.
Some of these are more useful
to distinguish than others,
but it doesn't hurt
to have them all.
So, for example, this edge I'm
going to call a forward edge,
just write f,
that's unambiguous,
because it goes, in some
sense, forward along the tree.
It goes from the root of
this tree to a descendant.
There is a path
in the tree from a
to d, so we call
it a forward edge.
By contrast, this edge I'm
going to call a backward edge,
because it goes from
a node in the tree
to an ancestor in the trees.
If you think of parents, I
can go from d to its parent
to its parent, and that's
where the edge goes,
so that's a backward
edge-- double check I
got these not reversed,
yeah, that's right.
Forward edge because I could
go from d to its parent
to its parent to its
parent and the edge
went the other way,
that's a forward edge.
So forward edge goes from a node
to a descendant in the tree.
Backward edge goes from a node
to an ancestor in the tree.
And when I say,
tree, I mean forest.
And then all the other
edges are cross edges.
So I guess, here,
this is a cross edge.
In this case, it goes from
one tree to another, doesn't
have to go between
different trees.
For example, let's say
I'm visiting d, then
I go back to e, I visit g,
or there could be this edge.
If this edge existed, it
would be a cross edge,
because g and d are
not ancestor related,
neither one is an
ancestor of the other,
they are siblings actually.
So there's, in
general, there's going
to be some subtree over
here, some subtree over here,
and this is a cross edge
between two different subtrees.
This cross edge is between two,
sort of, non ancestor related,
I think is the shortest way to
write this, subtrees or nodes.
A little puzzle for
you, well, I guess
the first question is, how do
you compute this structure?
How do you compute
which edges are which?
This is not hard, although I
haven't written it in the code
here.
You can check the textbook
for one way to do it.
The parent structure tells you
which edges are tree edges.
So that part we have done.
Every parent pointer corresponds
to the reverse of a tree edge,
so at the same time you could
mark that edge a tree edge,
and you'd know which
edges are tree edges
and which edges
are nontree edges.
If you want to know which are
forward, which are backward,
which are cross edges, the
key thing you need to know
is, well, in particular,
for backward edges, one way
to compute them is
to mark which nodes
you are currently exploring.
So when we do a DFS
visit on a node,
we could say at
the beginning here,
basically, we're starting
to visit s, say, start s,
and then at the end of
this for loop, we write,
we're finished with s.
And you could mark that
in the s structure.
You could say s dot in
process is true up here,
s dot in process
equals false down here.
Keep track of which nodes are
currently in the recursion
stack, just by marking
them and unmarking them
at the beginning and the end.
Then we'll know, if we follow
an edge and it's an edge
to somebody who's
already in the stack,
then it's a backward edge,
because that's-- everyone
in the stack is an ancestor
from our current node.
Detecting forward edges,
it's a little trickier.
Forward edges
versus cross edges,
any suggestions on an
easy way to do that?
I don't think I know
an easy way to do that.
It can be done.
The way the textbook does
it is a little bit more
sophisticated, in that when
they start visiting a vertex,
they record the time
that it got visited.
What's time?
You could think of it as
the clock on your computer,
another way to do
it is, every time
you do a step in this algorithm,
you increment a counter.
So every time anything happens,
you increment a counter,
and then you store
the value of that
counter here for s, that
would be the start time for s,
you store the finish
time for s down here,
and then this gives
you, this tells you
when a node was
visited, and you can
use that to compute when
an edge is a forward edge
and otherwise it's a cross edge.
It's not terribly exciting,
though, so I'm not
going to detail that.
You can look at the textbook
if you're interested.
But here's a fun puzzle.
In an undirected graph, which
of these edges can exist?
We can have a vote, do some
democratic mathematics.
How many people think tree edges
exist in undirected graphs?
You, OK.
Sarini does.
That's a good sign.
How many people
think forward edges
exist in an undirected graph?
A couple.
How many people
think backward edges
exist in an undirected graph?
Couple.
How many people
think cross edges
exist in undirected graph?
More people, OK.
I think voting worked.
They all exist, no,
that's not true.
This one can exist and
this one can exist.
I actually wrote the
wrong ones in my notes,
so it's good to trick you,
no, it's I made a mistake.
It's very easy to
get these mixed up
and you can think
about why this is true,
maybe I'll draw some
pictures to clarify.
This is something, you remember
the-- there was BFS diagram,
I talked a little bit
about this last class.
Tree edges better exist,
those are the things
you use to visit new vertices.
So that always happens,
undirected or otherwise.
Forward edges, though,
forward edge of
would be, OK, I visited
this, then I visited this.
Those were tree edges.
Then I backtrack and I
follow an edge like this.
This would be a forward edge.
And in a directed
graph that can happen.
In an undirected graph,
it can also happen, right?
Oh, no, it can't, it can't.
OK.
So confusing.
undirected graph, if
you look like this,
you start-- let's say this is s.
You start here, and suppose
we follow this edge.
We get to here, then we follow
this edge, we get to here.
Then we will follow this
edge in the other direction,
and that's guaranteed to
finish before we get back to s.
So, in order to
be a forward edge,
this one has to be
visited after this one,
from s, but in this scenario,
if you follow this one first,
you'll eventually
get to this vertex
and then you will come back,
and then that will be classified
as a backward edge in
an undirected graph.
So you can never have forward
edges in an undirected graph.
But I have a backward edge
here, that would suggest
I can have backward edges
here, and no cross edges.
Well, democracy did not work, I
was swayed by the popular vote.
So I claim, apparently,
cross edges do not exist.
Let's try to draw this.
So a cross edge typical
scenario would be either here,
you follow this
edge, you backtrack,
you follow another
edge, and then
you discover there's was an
edge back to some other subtree
that you've already visited.
That can happen in
an undirected graph.
For the same reason, if
I follow this one first,
and this edge exists undirected,
then I will go down that way.
So it will be actually tree
edge, not a cross edge.
OK, phew.
That means my
notes were correct.
I was surprised,
because they were
copied from the textbook,
uncorrect my correction.
Good.
So what?
Why do I care about these
edge classifications?
I claim they're super handy for
two problems, cycle detection,
which is pretty
intuitive problem.
Does my graph have any cycles?
In the directed case, this
is particularly interesting.
I want to know, does a graph
have any directed cycles?
And another problem
called topological sort,
which we will get to.
So let's start with
cycle detection.
This is actually a warmup
for topological sort.
So does my graph
have any cycles?
G has a cycle, I claim.
This happens, if and only if, G
has a back edge, or let's say,
a depth-first search of
that graph has a back edge.
So it doesn't matter
where I start from
or how this algorithm-- I run
this top level DFS algorithm,
explore the whole
graph, because I
want to know in the whole
graph is there a cycle?
I claim, if there's a back
edge, then there's a cycle.
So it all comes
down to back edges.
This will work for both
directed and undirected graphs.
Detecting cycles is pretty
easy in undirected graphs.
It's a little more subtle
with directed graphs,
because you have to worry
about the edge directions.
So let's prove this.
We haven't done a
serious proof in a while,
so this is still a pretty easy
one, let's think about it.
What do you think is
the easier direction
to prove here, left or right?
To more democracy.
How many people
think left is easy?
A couple.
How many people
think right is easy?
A whole bunch more.
I disagree with you.
I guess it depends
what you consider easy.
Let me show you
how easy left is.
Left is, I have a back edge, I
want to claim there's a cycle.
What is the back edge look like?
Well, it's an edge to
an ancestor in the tree.
If this node is a
descendant of this node
and this node is an ancestor
of this node, that's
saying there are
tree edges, there's
a path, a tree path, that
connects one to the other.
So these are tree
edges, because this
is supposed to be an
ancestor, and this
is supposed to be a descendant.
And that's the definition
of a back edge.
Do you see a cycle?
I see a cycle.
This is a cycle, directed cycle.
So if there's a back edge, by
definition, it makes a cycle.
Now, it's harder to say
if I have 10 back edges,
how many cycles are there?
Could be many.
But if there's a
back edge, there's
definitely at least one cycle.
The other direction
is also not too hard,
but I would hesitate
to call it easy.
Any suggestions if, I
know there is a cycle,
how do I prove that there's
a back edge somewhere?
Think about that,
let me draw a cycle.
There's a length k cycle.
Where do you think,
which of these edges
do you think is going
to be a back edge?
Let's hope it's
one of these edges.
Sorry?
AUDIENCE: Vk to v zero.
PROFESSOR: Vk to v zero.
That's a good idea, maybe
this is a back edge.
Of course, this is
symmetric, why that edge?
I labeled it in
a suggestive way,
but I need to say something
before I know actually which
edge is going to
be the back edge.
AUDIENCE: You have to
say you start to v zero?
PROFESSOR: Start at v zero.
If I started a search
of v zero, that
looks good, because
the search is
kind of going to go
in this direction.
vk will maybe be the
last thing to be visited,
that's not actually true.
Could be there's an edge
directly from v zero to vk,
but intuitively vk
will kind of later,
and then when this
edge gets visited,
this will be an ancestor
and it will be a back edge.
Of course, we may not
start a search here,
so calling it the
start of the search
is not quite right,
a little different.
AUDIENCE: First vertex
that gets hit [INAUDIBLE].
PROFESSOR: First vertex
that gets hit, good.
I'm going to start the
numbering , v zero,
let's assume v 0 is the
first vertex in the cycle,
visited by the
depth-first search.
Together, if you want some
pillows if you like them,
especially convenient
that they're in front.
So right, if it's
not v zero, say
v3 was the first one visited.
We will just change
the labeling,
so that's v zero, that's
v1, that's v, and so on.
So set this labeling,
so that v0 first one,
first vertex that gets visited.
Then, I claim that-- let me
just write the claim first.
This edge vkv0 will
be a back edge.
We'll just say, is back edge.
And I would say this is not
obvious, be a little careful.
We have to somehow exploit
the depth-first nature of DFS,
the fact that it goes deep-- it
goes as deep as it can before
backtracking.
If you think about
it, we're starting,
at this point we are starting a
search relative to this cycle.
No one has been visited,
except v zero just
got visited, has a parent
pointer off somewhere else.
What do we do next?
Well, we visit all the
outgoing edges from v zero,
there might be many
of them. it could
be edge from v zero to v1,
it could an edge from v zero
to v3, it could be an edge
from v zero to something else.
We don't know which one's
going to happen first.
But the one thing I
can claim is that v1
will be visited before we
finish visiting v zero.
From v zero, we might
go somewhere else,
we might go somewhere
else that might eventually
lead to v1 by some other
route, but in particular, we
look at that edge
from v zero to v1.
And so, at some point,
we're searching,
we're visiting all the things
reachable from v zero, that
includes v1, and
that will happen,
we will touch v1
for the first time,
because it hasn't
been touched yet.
We will visit it before
we finish visiting v zero.
The same goes actually for all
of v i's, because they're all
reachable from v zero.
You can prove this by induction.
You'll have to visit v1 before
you finish visiting v zero.
You'll have to visit v2
before you finish visiting
v1, although you might
actually visit v2 before v1.
You would definitely
finish, you'll
finished v2 before you
finish v1, and so on.
So vi will be visited before
you finish vi minus 1,
but in particular,
what we care about is
that vk is visited
before we finish v zero.
And it will be entirely visited.
We will finish
visiting vk before we
finish visiting v zero.
We will start decay vk
after we start to v zero,
because v zero is first.
So the order is going to
look like, start v zero,
at some point we will start vk.
Then we'll finish vk,
then we'll finish v zero.
This is something the
textbook likes to call,
and I like to call,
balanced parentheses.
You can think of it as, we
start v zero, then we start vk,
then we finish vk,
then we finish v zero.
And these match up
and their balanced.
Depth-first search
always looks like that,
because once you
start a vertex, you
keep chugging until you visited
all the things reachable
from it.
Then you finish it.
You won't finish v zero
before you finish vk,
because it's part
of the recursion.
You can't return
at a higher level
before you return
at the lower levels.
So we've just argued
that the order
is like this, because
v zero was first,
so vk starts after v zero, and
also we're going to finish vk
before we finish v zero, because
it's reachable, and hasn't
been visited before.
So, in here, we
consider vkv zero.
When we consider that edge,
it will be a back edge.
Why?
Because v zero is currently
on the recursion stack,
and so you will have marked v
zero as currently in process.
So when you look at that edge,
you see it's a back edge,
it's an edge to your ancestor.
That's the proof.
Any questions about that?
It's pretty easy once you set
up the starting point, which
is look at the first
time you visit the cycle,
than just think about how
you walk around the cycle.
There's lots of ways you
might walk around the cycle,
but it's guaranteed you'll
visit vk at some point,
then you'll look at the edge.
v0 is still in the stack,
so it's a back edge.
And so this proves
that having a cycle
is equivalent to
having a back edge.
This gives you an easy linear
time algorithm to tell,
does my graph have a cycle?
And if it does, it's
actually easy to find one,
because we find a back edge,
just follow the tree edges,
and you get your cycle.
So if someone gives
you a graph and say,
hey, I think this is acyclic,
you can very quickly say,
no, it's not, here's
a cycle, or say,
yeah, I agree, no back edges,
I only have tree, forward,
and cross edges.
OK, that was application 1.
Application 2 is
topological sort,
which we're going to
think about in the setting
of a problem called
job scheduling.
So job scheduling, we are
given a directed acyclic graph.
I want to order the vertices
so that all edges point
from lower order to high order.
Directed acyclic
graph is called a DAG,
you should know that from 042.
And maybe I'll
draw one for kicks.
Now, I've drawn the graph so
all the edges go left to right,
so you can see that
there's no cycles here,
but generally you'd run DFS and
you'd detect there's no cycles.
And now, imagine these
vertices represent
things you need to do.
The textbook has a funny example
where you're getting dressed,
so you have these
constraints that say,
well, I've got to put my socks
on before put my shoes on.
And then I've got to put
my underwear on before I
put my pants on, and all
these kinds of things.
You would code that as a
directed acyclic graph.
You hope there's no
cycles, because then you
can't get dressed.
And there's some
things, like, well, I
could put my glasses on
whenever, although actually I
should put my glasses on
before I do anything else,
otherwise there's problems.
I don't know, you could put
your watch on at any time,
unless you need to
know what time is.
So there's some disconnected
parts, whatever.
There's some unrelated
things, like, I
don't care the order between
my shirt and my pants
or whatever, some things
aren't constrained.
What you'd like to do is choose
an actual order to do things.
Say you're a
sequential being, you
can only do one
thing at a time, so I
want to compute a total order.
First I'll do g,
then I'll do a, then
I can do h, because I've done
both of the predecessors.
Then I can't do be,
because I haven't done d,
so maybe I'll do d first, and
then b, and than e, then c,
then f, then i.
That would be a valid order,
because all edges point
from an earlier number
to a later number.
So that's the goal.
And these are real job
scheduling problems
that come up, you'll
see more applications
in your problem set.
How do we do this?
Well, at this point we
have two algorithms,
and I pretty much
revealed it is DFS.
DFS will do this.
It's a topological sort, is
what this algorithm is usually
called.
Topological sort because
you're given a graph, which
you could think
of as a topology.
You want to sort it,
in a certain sense.
It's not like
sorting numbers, it's
sorting vertices in a graph,
so, hence, topological sort.
That's the name
of the algorithm.
And it's run DFS, and
output the reverse
of the finishing
times of vertices.
so this is another
application where you really
want to visit all the
vertices in the graph,
so we use this top level DFS,
so everybody gets visited.
And there are these
finishing times,
so every time I finish a vertex,
I could add it to a list.
Say OK, that one
was finished next,
than this one is finished,
than this one's finished.
I take that order
and I reverse it.
That will be a
topological order.
Why?
Who knows.
Let's prove it.
We've actually done pretty
much the hard work, which
is to say-- we're assuming
our graph has no cycles,
so that tells us by
this cycle detection
that there are no back edges.
Back edges are kind
of the annoying part.
Now they don't exist here.
So all the edges are tree edges,
forward edges, and cross edges,
and we use that to
prove the theorem.
So we want to prove that all
the edges point from an earlier
number to a later number.
So what that means
is for an edge,
uv, we want to show that
v finishes before u.
That's the reverse,
because what we're taking
is the reverse of
the finishing order.
So edge uv, I want to make
sure v finishes first,
so that u will be ordered first.
Well, there are two cases.
Case 1 is that u
starts before v. Case 2
is that he v before u.
At some point they
start, because we
visit the whole graph.
This top loop guarantees that.
So consider what order we visit
them first, at the beginning,
and then we'll think
about how they finish.
Well, this case is kind of
something we've seen before.
We visit u, we have
not yet visited v,
but v is reachable from
u, so maybe via this edge,
or maybe via some other
path, we will eventually
visit v in the recursion for u.
So before u finishes,
we will visit v, visit v
before u finishes.
That sentence is just
like this sentence,
so same kind of argument.
We won't go into detail,
because we already
did that several times.
So that means we'll visit v,
we will completely visit v,
we will finish v
before we finish u
and that's what we
wanted to prove.
So in that case is good.
The other cases is
that v starts before u.
Here, you might get
slightly worried.
So we have an edge, uv,
still, same direction.
But now we start at v, u
has not yet been visited.
Well, now we worry
that we visit u.
If we visit u, we're going to
finish u before we finish v,
but we want it to be
the other way around.
Why can't that happen?
AUDIENCE: [INAUDIBLE].
PROFESSOR: Because there's
a back edge somewhere here.
In particular, the graph
would have to be cyclic.
This is a cycle, so this
can't happen, a contradiction.
So v will finish before
we visit u at all.
So v will still finish first,
because we don't even touch u,
because there's no cycles.
So that's actually the proof
that topological sort gives you
a valid job schedule,
and it's kind of-- there
are even more things
you can do with DFS.
We'll see some in recitations,
more in the textbook.
But simple algorithm, can do
a lot of nifty things with it,
very fast, linear time.
