Skiena algorithm 2007 lecture12 topological sort connectivity

Lecture 12:
Depth-First Search
Steven Skiena

Department of Computer Science
State University of New York
Stony Brook, NY 11794–4400

http://www.cs.sunysb.edu/∼skiena

Problem of the Day
Prove that in a breadth-ﬁrst search on a undirected graph G,
every edge in G is either a tree edge or a cross edge, where a
cross edge (x, y) is an edge where x is neither is an ancestor
or descendent of y.

Depth-First Search
DFS has a neat recursive implementation which eliminates
the need to explicitly use a stack.
Discovery and ﬁnal times are a convenience to maintain.
dfs(graph *g, int v)
{
edgenode *p; (* temporary pointer *)
int y; (* successor vertex *)

if (ﬁnished) return; (* allow for search termination *)

discovered[v] = TRUE;
time = time + 1;
entry time[v] = time;

process vertex early(v);

p = g− >edges[v];
while (p ! = NULL) {
y = p− >y;

if (discovered[y] == FALSE) {
parent[y] = v;
process edge(v,y);
dfs(g,y);
}
else if ((!processed[y]) || (g− >directed))
process edge(v,y);

if (ﬁnished) return;

p = p− >next;
}

process vertex late(v);

time = time + 1;
exit time[v] = time;

processed[v] = TRUE;
}

The Key Idea with DFS
A depth-ﬁrst search of a graph organizes the edges of the
graph in a precise way.
In a DFS of an undirected graph, we assign a direction to each
edge, from the vertex which discover it:
2
1 3

1
2 6
4

3
5

4 6

5

Edge Classiﬁcation for DFS
Every edge is either:
3. A Forward Edge
1. A Tree Edge to a decendant

4. A Cross Edge
2. A Back Edge
to a different node
to an ancestor

On any particular DFS or BFS of a directed or undirected
graph, each edge gets classiﬁed as one of the above.

Edge Classification Implementation

int edge classification(int x, int y)
{
if (parent[y] == x) return(TREE);
if (discovered[y] && !processed[y]) return(BACK);
if (processed[y] && (entry time[y]¿entry time[x])) return(FORWARD);
if (processed[y] && (entry time[y]¡entry time[x])) return(CROSS);

printf(”Warning: unclassified edge (%d,%d)”,x,y);
}

DFS: Tree Edges and Back Edges Only
The reason DFS is so important is that it deﬁnes a very nice
ordering to the edges of the graph.
In a DFS of an undirected graph, every edge is either a tree
edge or a back edge.
Why? Suppose we have a forward edge. We would have
encountered (4, 1) when expanding 4, so this is a back edge.
1

2

3 4

No Cross Edges in DFS
Suppose we have a cross-edge
1

2 5 When expanding 2, we would discover
5, so the tree would look like:

3 4 6 1

2

3
4 5

6

DFS Application: Finding Cycles
Back edges are the key to finding a cycle in an undirected
graph.
Any back edge going from x to an ancestor y creates a cycle
with the path in the tree from y to x.
process edge(int x, int y)
{
if (parent[x] ! = y) { (* found back edge! *)
printf(”Cycle from %d to %d:”,y,x);
find path(y,x,parent);
finished = TRUE;
}
}

Articulation Vertices
Suppose you are a terrorist, seeking to disrupt the telephone
network. Which station do you blow up?

An articulation vertex is a vertex of a connected graph whose
deletion disconnects the graph.
Clearly connectivity is an important concern in the design of
any network.
Articulation vertices can be found in O(n(m+n)) – just delete
each vertex to do a DFS on the remaining graph to see if it is
connected.

A Faster O(n + m) DFS Algorithm
In a DFS tree, a vertex v (other than the root) is an articulation
vertex iff v is not a leaf and some subtree of v has no back
edge incident until a proper ancestor of v.
The root is a special case since
it has no ancestors.
X
X is an articulation vertex since
the right subtree does not have
a back edge to a proper ancestor.

Leaves cannot be
articulation vertices

Topological Sorting
A directed, acyclic graph has no directed cycles.
B D

A E
C

G F

A topological sort of a graph is an ordering on the vertices so
that all edges go from left to right.
DAGs (and only DAGs) has at least one topological sort (here
G, A, B, C, F, E, D).

Applications of Topological Sorting
Topological sorting is often useful in scheduling jobs in their
proper sequence. In general, we can use it to order things
given precidence constraints.
Example: Dressing schedule from CLR.

Example: Identifying errors in DNA fragment
assembly
Certain fragments are constrained to be to the left or right of
other fragments, unless there are errors.
A B R A C A D A B R A
A B R A C
A B R A C
A C A D A R A C A D
A D A B R A C A D A
D A B R A A D A B R
R A C A D D A B R A

Solution – build a DAG representing all the left-right
constraints. Any topological sort of this DAG is a consistant
ordering. If there are cycles, there must be errors.

Topological Sorting via DFS
A directed graph is a DAG if and only if no back edges are
encountered during a depth-ﬁrst search.
Labeling each of the vertices in the reverse order that they are
marked processed ﬁnds a topological sort of a DAG.
Why? Consider what happens to each directed edge {x, y} as
we encounter it during the exploration of vertex x:

Case Analysis

• If y is currently undiscovered, then we then start a DFS
of y before we can continue with x. Thus y is marked
completed before x is, and x appears before y in the
topological order, as it must.
• If y is discovered but not completed, then {x, y} is a back
edge, which is forbidden in a DAG.
• If y is completed, then it will have been so labeled before
x. Therefore, x appears before y in the topological order,
as it must.

Topological Sorting Implementation
process vertex late(int v)
{
push(&sorted,v);
}

process edge(int x, int y)
{
int class;

class = edge classiﬁcation(x,y);

if (class == BACK)
printf(”Warning: directed cycle found, not a DAG”);
}

We push each vertex on a stack soon as we have evaluated
all outgoing edges. The top vertex on the stack always has
no incoming edges from any vertex on the stack, repeatedly
popping them off yields a topological ordering.

Strongly Connected Components
A directed graph is strongly connected iff there is a directed
path between any two vertices.
The strongly connected components of a graph is a partition
of the vertices into subsets (maximal) such that each subset is
strongly connected.
a b e f

c d g h

Observe that no vertex can be in two maximal components,
so it is a partition.

There is an elegant, linear time algorithm to ﬁnd the strongly
connected components of a directed graph using DFS which
is similar to the algorithm for biconnected components.

Backtracking and Depth-First Search
Depth-ﬁrst search uses essentially the same idea as backtrack-
ing.
Both involve exhaustively searching all possibilities by
advancing if it is possible, and backing up as soon as there
is no unexplored possibility for further advancement. Both
are most easily understood as recursive algorithms.

Skiena algorithm 2007 lecture12 topological sort connectivity

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Skiena algorithm 2007 lecture12 topological sort connectivity (20)

More from zukun (20)

Recently uploaded (20)

Skiena algorithm 2007 lecture12 topological sort connectivity