Next, we're going to talk about breadth first search which

is a completely different way to process all the vertices to a given vertex.

It'll get the job done but it has a totally different properties that

are useful in different ways for different applications.

To understand breadth-first search we will start with a demo.

So breadth-first is not a recursive algorithm, it uses a queue

as a axillary data structure And it's also quite simple to explain.

So what we're going to do is we're going to put the source

vertex on a queue and then repeat the following until the queue is empty.

Remove the next vertex from the queue in order.

Then add to the queue all unmarked vertices that are adjacent to these and

mark them and just keep doing that until the queue is empty.

Let's see how that works on our example.

This is a smaller example, just a six vertex

graph with eight edges, so I add 0 to the queue.

So we just take 0 and put it on the queue, that's where we start.

And now we're going to repeat until queue is empty or remove a vertex,

add all unmarked vertex adjacent and mark them.

So we did queue 0 and then in order to process 0 we need to

check all of the adjacent vertices, so in this case that's 2, 1, and 5.

And again the order depends on how the bag was constructed for

vertices adjacent to zero.

So we check 2 nd that is not marked,

so we have to add it to the queue.

And then we check 1, that's not marked so we add it to the queue.

And then we check 5, and that's not marked so we add it to the queue So

we finished process, 0,0 is done.

So now remove the next vertex from the queue.

In this case it's 2, we're going to take 2 off the queue and process it by

adding to the queue all the unmarked vertices that are adjacent.

So to process 2, we have to check at 0, 1,

3, and 4, we check 0 that's already mark so, we going to do anything.

We check 1, that's also already marked so,

we don't do anything in fact the time to queue.

We check 3 and that one is unmarked so, we mark it and added to the queue and

then we check 4 that one's unmarked, so we mark it and add it to the queue.

So by the way, I didn't mention, but

we're also keeping track of 2 auxiliary data structures for this.

One is the edge to our array,

which is the same as before, what edge did we use to get to this?

So 4, and we got to 4 from 2 and 2 we have to do from 0,

so again that's going to be a tree that gives us a path back to the source.

And instead of marked, we also keep a more detailed information which is

the length of the path because we do it because it's easy to do it.

Okay, so four, we check four and add it to the queue and now we're done with two.

So now we have 1, 5, 3, and 4 are all in the queue and we're going to process them.

And since we've marked everything, all we're going to be doing now is

checking vertices that are marked, so for 1 we check 0 and that's marked.

Then we check 2 and that's marked, so then we're done with 1.

Next thing off the queue is 5 and we checked 3 and

that's marked and we checked 0 and that's marked so we're done with 5 and then 3.

We gotta check 5 and

then 4 and then two and they're all marked and now we're done with three.

And then finally the last one, always the last one, everybody else is marked, so

connected.

Check three, check two, it's marked and we're done.

So what this process [COUGH] the result of this computation,

again, Is a tree rooted at the source, we can follow back

through the tree to get paths from each node to the source.

And not only that, we can get the distance,

the number of edges on the path from each node to the source.

So that's a demo of breadth first search, and

next we'll take a look at properties of this algorithm.

All right, so now we have considered two different methods for

processing our vertices in the graph.

And actually they are quite closely related eventhough the computations

are quite different.

Essentially depth-first search uses recursion so

it corresponds to putting unvisited vertices on a stack.

Breadth-first search explicitly we put the unvisited vertices on the queue.

And actually, breadth-first search solves another problem

that often we want to solve called the shortest path problem.

Actually, the path that you get back from breadth-first search is the path from

the source to the given vertex that uses the fewest number of edges.

And we'll look at that in just a minute and the idea is that the Breath-first

search examines the vertices in the graph in increasing distance from the source.

So let's take a look at that, so

a breadth-first search computes shortest path.

That is it builds the data structure that we can answer sure as path

queries from the source with.

From s to all other vertices in the graph in time proportional to e + v,

then there are plus some more vertices and so let's look at why that's the case.

So first thing is, how do we know that it computes, has shortest pass?

Well the intuition is, and you can fill in the details,

the queue always contains some vertices of

distance k from the source, followed by some vertices of distance k plus one.

So they're on a queue, we're processing them in first and first out order.

So say we're at a state when all of these vertices are on the queue.

We're going to have processed vertex 0 as soon as we get this one

we'll delete vertex 0 from the queue and then we're putting these adjacent ones on.

We're adding the length of distance too but we're not going to

process any of those until we're done with the ones at distance 1 and so forth.

So it's not hard to show that always,

you have either one of the two distances from the source on the queue.

And that means the first time we get to a vertex,

that's the shortest path to that vertex.

And, again, the running time, we only visit vertices once because we mark them.

So, it's time proportional to the number of vertices

plus the number of edges in the graph.

So, that's breadth-first search properties and

then here's the implementation, which is simply code for

the basic method that we outlined in pseudocode.

So our private instance variables are marked, or

in the demo we used disk to, but just for simplicity let's use marked.

Edge two then is how we get to the frist vortex and then the source.

And so I have a constructor that builds those arrays the same way as before and

then calls BFS.

So BFS builds a queue, that's what it's going to use and

queues the source and marks the source.

And then this is just in code what we said in words before, while the queue is

not empty, we pull off the next vertex from the queue, call it v.

For everybody adjacent to v, we go ahead and check.

If it's marked, we ignore it and move to the next If it's not marked,

then we put it on the queue, mark it, and remember the edge.

And again, this is an example of the power of abstraction and

utility of our design pattern.

All we're doing in terms of

data type as being a client to go through all the adjacent vertices.

But it allows us to implement this completely different algorithm

in really an accessible way.

So that's the implementation of for search and then the client for

getting the paths back.

It's going to be the same as for depths for search, so

here's an old example of breadth-first search.

And in computer networks it's very important when you're communicating

from one place to another you want to get there in the fewest number of hops.

This is the ARPANET the predecessor to the internet as of

July 1977 when things were slow and computers were small and

slow, it's important to do these things in a small number of hops.

And with breadth-first search, you could take this graph and

figure out the shortest way to get from one place to another.

That's a typical application of breadth-first search.

Here's another one, so-called Kevin Bacon number, and nowadays actually

you can type Bacon and an actor's name and get the answer to this.

So there's,

if you're not familiar with it, you can become familiar with it by Kevin Bacon,

or the idea is you have a graph where the vertices are actors.

And the edge,

you think of an edge connecting two actors, if they were in a movie together.

And so, what you want to find is given an actor,

[COUGH] what's the shortest way to get to

Kevin Bacon connected by, so, we have ed is for

actors and edge is for movies in a connection of actors in the movie.

So Buzz Mauro and Tina Ramirez were in Sweet Dreams together and

these two actors were in this movie together and so forth.

And you get away to Kevin Bacon from any actor and

this is another pop culture application.

This is the so-called six degrees, which you can get to anyone with six steps

in this way, so that's all implementation of breadth first search.

On the Kevin Bacon graph, where we include one vertex for

each performer, one vertex for each movie.

Connect the movie to all performers that appear in the movie, and the shortest

path from Kevin Bacon to every actor if you follow back through that path.

You get the proof of the got a Kevin Bacon number for

each actor and we have implementation of that on the book site.

So that's another example, and actually there's a maybe even older service,

at least similar age example that mathematicians are fond of.

And that's called the so-called Erdos number.

So, in this one it's mathematicians, the nodes are mathematicians and

there's an edge if the two mathematicians have co-authored a paper and

Paul was a very productive Hungarian mathematician.

Who travelled the world co-authoring papers with people all over the world.

A very interesting and prolific character who actually did

quite a bit of research on properties of and maybe even more so than Kevin Bacon.

The idea that he was so prolific that pretty much every

mathematician has a pretty low Erdos number.

So that's our second example of a graph processing algorithm,

breadth-first search.

Breadth-First Search

Algorithms, Part II

Meet the Instructors