Lecture 31 Handout

Learning Outcomes

At the end of this lecture, you’ll be able to:

• Define the neighborhood of a vertex.
• Identify a path from a source vertex to a destination vertex.
• State the General Graph Search problem.
• Identify reachable vertices in a graph, from a source vertex.
• Identify a general solution to the general graph search problem.
• Generate and trace Graph search types by specifying how to explore the neighbor in the general search algorithm.
• Describe, trace, and implement the Breadth-First Search algorithm.
• Describe, trace, and implement the Depth-First Search algorithm.
• Identify which data structure supports each traversal/search type: breadth-first, depth-first
• Analyze the time complexity of BFS and DFS for each Graph implementation (list vs. matrix)

Consider the following graph:

The set of all vertices in $G$ that are adjacent to a vertex $v$ is called the neighborhood of $v$ and denoted by $N(v)$.

$$ N_{\text{outgoing}}(A) = \{B, C\} $$

$$ N_{\text{incoming}}(C) = \{A, D\} $$

Exercise Name all the vertices adjacent to vertex $D$ in two groups – incoming neighbors and outgoing neighbors:

Alternatively, we can define “path” as a sequence of vertices where each vertex in the sequence is adjacent to the vertex next to it.

Consider the following graph:

Here are two pathes from $A$ to $C$: $(A, C)$ and $(A, B, D, C)$.

In this class, when I say “path”, I mean “simple path”.

Aside: In some references, what I defined as “path” is defined as “walk” and instead “simple path” is called, simply, “path”.

Exercise List the edges on a directed path from $B$ to $E$ and from $C$ to $E$.

The Graph Search problem, in a nutshell, is figuring out if a graph contains a path from one vertex to another.

Many fundamental algorithms on graphs (e.g finding shortest path, cycles, connected components, $\dots$) are applications of the graph search problem.

For example, consider the following graph: (It’s one graph with multiple connected components!)

The set of vertices reachable from $s$ is $\{s, u, v, w\}$.

Exercise Identify the set of vertices reachable from $s$ and from $x$, in the following graph:

Recall:

The following is a solution to this problem:

// Post: a vertex is reachable from s iff it is marked as explored.
mark s as "explored"; all other vertices as "unexplored"
while there is an edge (v, w) in E with v explored and w unexplored do 
    choose some such edge (v, w) // underspecified 
    mark w as explored

Notice the instruction marked as “underspecified”; depending on how we choose the edge, the search will be called:

• BFS (Breadth-First Search), or
• DFS (Depth-First Search).

According to the Dictionary of Algorithms and Data Structures:

Given a “source” vertex to initiate the search, BFS starts by visiting its adjacent nodes, then all nodes that can be reached by a path from the start node containing two edges, three edges, and so on.

The process is further elaborated using a demo:

The following animated visualization of BFS algorithm (made by Gerry Jenkins) does a good job of illustrating its behavior:

Consider the following graph:

Exercise Write the vertices of the above graph in the order in which they would be visited in a breadth-first traversal starting at node $0$. Assume neighbors are visited in numerical order.

Exercise Based on your understanding of the BFS process, complete the pseudocode of BFS!

mark s as explored;all other vertices as unexplored
______________ data structure, initialized with s 
while____is not empty do
  remove the vertex from ____________, call it v         
  for edge (v, w) in v's neighborhood do
    if ____________ then
      _________________________
      _________________________

mark s as explored, all other vertices as unexplored
Q := a queue data structure, initialized with s 
while Q is not empty do
  remove the vertex from the front of Q, call it v 
  for edge (v, w) in v's neighborhood do
    if w is unexplored then
      mark w as explored 
      add w to the end of Q

According to the Dictionary of Algorithms and Data Structures:

The main idea behind DFS is to explore deeper into the graph whenever possible. Starting at a vertex, DFS will take a path and explore it as far as it goes. It then backtracks until it reaches an unexplored neighbor (a branch on the path which it has not explored yet). This process continues until it has discovered every vertex that are reachable from the original source vertex.

You have seen this behavior in pre-order and post-order tree traversal (and in-order binary tree traversal).

The process is further elaborated using a demo:

The following animated visualization of DFS algorithm (made by Gerry Jenkins) does a good job of illustrating its behavior:

Consider the following graph:

Exercise Write the vertices of the above graph in the order in which they would be visited in a depth-first traversal starting at node $0$. Assume neighbors are visited in numerical order.

Exercise Based on your understanding of the DFS process, complete the pseudocode of DFS!

mark s as explored;all other vertices as unexplored
______________ data structure, initialized with s 
while____is not empty do
  remove the vertex from ____________, call it v         
  for edge (v, w) in v's neighborhood do
    if ____________ then
      _________________________
      _________________________

mark s as explored, all other vertices as unexplored
S := a stack data structure, initialized with s 
while S is not empty do
  pop the vertex from the top of S, call it v 
  for each edge (v, w) in v's neighborhood do
    if w is unexplored then
      mark w as explored 
      push w to the top of S

Here is a (more elaborate) pseudocode for solving the General Graph Search problem:

mark s as explored, all other vertices as unexplored
D := a queue or stack data structure, initialized with s 
while D is not empty do
  remove the vertex from the front/top of D, call it v 
  for edge (v, w) in v's neighborhood do
    if w is unexplored then
      mark w as explored 
      add w to the end/top of D

Exercise Analyze the complexity of BFS algorithm (use Big Oh notation).

mark s as explored, all other vertices as unexplored // O(1), O(N)
D := a queue or stack data structure, initialized with s // O(1)
while D is not empty do                              // total O(N)     
  remove the vertex from the front/top of D, call it v  // O(1)
  for edge (v, w) in v’s neighborhood do                // O(neighbors(v))
    if w is unexplored then                             // O(1)
      mark w as explored                                // O(1)
      add w to the end/top of D                         // O(1)

Note: It is common to modify the BFS/DFS algorithm to keep track of the edges instead of (or in addition to) the vertices (where each edge describes the nodes at each end). This is useful for e.g. reconstructing the traversed path after processing each node.

Aside: Both BFS & DFS can be implemented recursively. In particular, DFS easily lends itself to a recursive implementation. In fact, most resources describe DFS recursively! It is left as an exercise to you, to come up with recursive implementation of these algorithms.