Depth-First Search Depth-first search (DFS) is another way to traverse the graph.

Size: px

Start display at page:

Download "Depth-First Search Depth-first search (DFS) is another way to traverse the graph."

Sharlene McCormick
5 years ago
Views:

Depth-First Search Depth-first search (DFS) is another way to traverse the graph. Motivating example: In a video game, you are searching for a path from a point in a maze to the exit.

1 Depth-First Search Depth-first search (DFS) is another way to traverse the graph. Motivating example: In a video game, you are searching for a path from a point in a maze to the exit. The maze can be modeled by a graph: each square is a vertex and two adjacently connected squares provide an edge. Then you are trying to find a path connecting your current location to the exit on the graph. BFS will find the shortest path. But the order that BFS visits the vertices would require you to switch between distant vertices constantly. This is impractical. DFS Algorithm The DFS order makes this practical. DFS can be naturally defined by a recursion algorithm. The idea is extremely simple: From the current vertex, you explore each of the unvisited adjacent vertex v. After all adjacent vertices are visited, you go back.

2 Figure 1. Left: a graph. Right: the order that a particular DFS traversal on the graph. Lemma 1: There is a path from s to t if and only if visited[t] = true. Proof is the same as the BFS case so omitted here. (Do it as an exercise). Time complexity: Every time the explore function is called with u, the algorithm turns u s state from unvisited to visited. So explore is called exactly once with each reachable vertex u. The time spending on u within explore is the degree of u. Thus, total time = n + deg(u) = O(m + n). BFS guarantees to use the shortest path to reach every vertex. However, DFS cannot. But DFS has its own interesting applications. Stack Implementation Recall that recursion is executed in the run time environment through stack. When writing a program, some people are more comfortable with doing stacks themselves and thus avoiding the recursion. The following pseudocode is the DFS implementation with a stack. It will be identical to the recursion version if the loop for each neighbor v of u uses a reversed order as the one used in the recursion version. You should be comfortable with both implementations. Remark: When you work on super large graph, the recursion version may have too many levels of recursion calls, and potentially overflows the system stack. Having your own stack avoids this risk. DFS algorithm (Stack version): visited[v] false for every v V. Empty stack S. S.push(s); while S is nonempty u S.pop(); if (! visited[u]) visited[u] true for each neighbor v of u S.push(v). u V Exercise: Simulate on paper the recursion and stack versions of DFS on the graph of Figure 1.

3 DFS tree We can similarly define the DFS tree. A DFS tree contains all the edges (u, v) that is responsible for reaching v through u. The proof that all these edges form a tree is the same as the BFS tree. u is called the parent and v is called the child. The starting vertex s is called the root. We can use an array parent[v] to store this tree. The parent array can help backtrace the path that connects s to v. Remark: A graph may have many different DFS trees depending on the order to visit the neighbors of each vertex. We call u an ancestor of v, if u is on the path from v to the root of the tree. Conversely, v is called a descendant of u. We call an edge (u, v) a back edge, if it is between an ancestor and a descendant and is not on the tree (not parent-child). It is called back edge because it is first checked in the backward way (from descendant to the ancestor) during the DFS. In the Figure 1 example, (5,2) is a back edge. When vertex 2 is being explored, the algorithm checked (2,4) and entered 4, before checking (2,5). The same edge (5,2) is checked during the exploration of vertex 5. Starting and finishing time The time that the exploration of vertex u starts and finishes is an important property for some DFS based algorithms. We do not care about the physical time. We just use this word time as a convenient way to establish an order of visits. To achieve this, we keep a global counter called time. Remark: Global variable is bad programming practice. But you can avoid it by passing a reference to time as an argument of the explore function, or simply use the stack version of DFS to make the counter as a local variable. time = 1 start[u] = time; time time + 1; finish[u] = time; time time + 1;

4 Lemma 2 (parenthesis): For every two vertices u, v, the intevals [start(u), finish(u)] and [start(v), finish(v)] are either disjoint or one is contained in another. The latter case happens precisely when u, v are an ancestor-descendent pair. Sketch of Proof: If u, v are a pair of parent-child, then clearly the parent s interval contains the child s. So is the ancestor-descendant relation. If they are not a pair of ancestor-descendent, let w be their least common ancestor. Then u, v belongs to two different subtrees led by two siblings u and v. By the algorithm, the intervals of u and v are disjoint. So do the intervals of u and v because they are even smaller. Lemma 3 (back edges): All non-tree edges are back edges. Proof: Suppose by contradiction edge (u, v) does not belong to the DFS tree, and u, v are not an ancestor-descendant pair (see figure below). Without loss of generality, assume u has an earlier start time than v. Therefore, when u started, v has not been visited yet. Because of the existence of edge (u, v), the for loop in explore(u) will ensures that v is visited before u finishes: either v becomes visited before the for loop examines v, or v becomes a child of u when the for loop examines v. In both cases, v is a descendant of u. Corollary 4: All edges in the graph connects a pair of ancestor-descendant vertices. Proof: If the edge is on the tree, it connects parent-child. If not, the Lemma ensures that it connects a pair of ancestor-descendant. Remark: Recall that BFS tree ensures that the two vertices of an edge are in the same or two adjacent layers. Cycle Detection in Undirected Graph For undirected graph, it is fairly straightforward to determine whether it is acyclic. An acyclic undirected graph is a tree. And a tree with n vertices is a connected graph with precisely n 1 edges. Therefore, the yes/no answer can be obtained by the following two things: (1) checking connectivity, and (2) comparing the number of vertices and edges.

5 But for a cyclic undirected graph, how do you find a cycle? DFS and the back edge provides an convenient way. First, find the back edge (u, v). Suppose u is the ancestor of v. Follow the parenting relation to find the other path from v to u. The path and the edge (u, v) form a cycle. DFS in Directed Graph DFS in directed graph only requires a slight modification, as highlighted in red color in the following pseudocode. time = 1 start[u] = time; time time + 1; For each v such that (u, v) E finish[u] = time; time time + 1; If the graph is stored in adjacency list format, it is trivial to implement this modification. Time complexity is still the same as undirected graph. O( V + E ). We can still make use of the DFS to solve the reachability problem. DFS still reaches all reachable vertices starting from vertex s. For the DFS tree, recall that in undirected graph, 1. The start and finish time interval has the parenthesis property: For a pair of ancestor and descendants, the ancestor s interval includes the descendant s. For all other pairs of vertices, they do not overlap. This is still true for the directed graph. 2. Each edge connect a pair of ancestor and descendant on the DFS tree. In the directed graph, this is not anymore true.

Strongly connected: A directed graph is strongly connected if every pair of vertices are reachable from each other.

Strongly connected: A directed graph is strongly connected if every pair of vertices are reachable from each other. Directed Graph In a directed graph, each edge (u, v) has a direction u v. Thus (u, v) (v, u). Directed graph is useful to model many practical problems (such as one-way road in traffic network, and asymmetric