Document Sample
GRAPH Powered By Docstoc

Definitions (background):
Graph: nodes/vertices, and edges/arcs as pairs of nodes. {V, E}
e12=(v1, v2, l12)
The third term l12, if present, could be a label or the weight of an
Directed graph: edges are ordered pairs of nodes.
Weighted graph: each edge (directed/undirected) has a weight.
Path between a pair of nodes vi, vk: sequence of edges with vi, vk at
the two ends.
Simple path: covers no node in it twice.
Loop: a path with the same start and end node.
Path length: number of edges in it.
Path weight: total wt of all edges in it.
Connected graph: there exists a path between every node, no node
is disconnected.
Complete graph: edge between every pair of nodes [NUMBER OF
Acyclic graph: a graph with no cycles.

Graphs are one of the most used models of real-life problems for

Representations: Adjacency list (a link list or an array of
directly connected nodes for each node), and matrix are two
Matrix is O(N^2) for N nodes but easy to access, while
adjacency list is good for sparse graph (sparsely distributed
edges, less connected).
Problem size includes both |V| (number of nodes N), and |E|
(number of edges, in the worst case O(N2) for complete
graph, but not “fair” for a sparse graph).
Also, with matrix representation |E| is always N2, because
one has to go over all the pairs of nodes to check which
ones are in E.
Algorithm 1:
For each node v in V do
     -Steps-    // (|V|)

Algorithm 2:
For each node v in V do
     For each edge in E do
           -Steps- // (|V|*|E|)

Algorithm 3:
For each node v in V do
     For each edge e of v do
           -Steps-    // ( |E| ) with adjacency list,
                            but (|V|* |V| ) for matrix repres.

Algorithm 4:
For each node v in V do
     For each node w adjacent to v do
           -Steps-    // again, ( |E| ) with adjacency list

Algorithm 5:
For each node v in V do
     For each edge e of v do
           -Steps-    // ( |V|+|E| ) or ( max{|V|, |E| })

Input: directed acyclic graph
Output: sequentially order the nodes without violating any
arc ordering.
Note: you may have to check for cycles - depending on the
problem definition (input: directed graph).

Example: course pre-requisite graph, find a linear ordering
of courses.

An important data: indegree of each node - number of arcs
coming in (#courses pre-requisite to "this" course).

A first-pass strategy: Eliminate vertices with indegree
zero and their associated (outgoing) arcs (thus, reducing
indegrees of the connected nodes) - after attaching an
ordering-number (for output of topo-sort ordering) to these
nodes, keep doing it for number-of-nodes times.
If at any stage before finishing with all nodes there does not
exist any node with indegree zero, then a cycle is found!

A naïve way of finding vertices with indegree zero is to
scan the nodes that are still left in the graph. As the loop
runs for N times this leads to (N2) algorithm.
Input: A directed graph
Output: A sorting on the node without violating directions, or
Algorithm naïve-topo-sort
     For each node v ϵ V calculate indegree(v); // (N)

     counter = 0;
     While V≠ empty do // (N)
          find a node v ϵ V such that indegree(v)==0;
          // have to scan all nodes here: (N)
          // total: (N) x (while loop’s N) = O(N2)
          if there is no such v then return(Failure)
                 ordering-id(v) = ++counter;
                 V = V – v;
          For each edge (v, w) ϵ E do //nodes adjacent to v
          //adjacent nodes: (|E|), total for all nodes O(N or |E|)
                       decrement indegree(w);
                       E = E – (v, w);
          end if;
     end while;
End algorithm.
Complexity: dominating term O(N2)

A smarter way: notice indegrees become zero for only a
subset of nodes in a pass, but all nodes are being checked in
the above naïve algorithm.
Store those nodes (who have become “roots” of the
truncated graph) in a box and pass the box to the next
An implementation of this idea could be done by using a
Push those nodes whose indegrees have become zeros (as
you change those values), at the back of a queue.
Algorithm terminates when the queue is empty, but if it
becomes empty before assigning ordering-number to all
nodes: we got a cycle!
Algorithm better-topo-sort
    For each vertex v do
         calculate indegree(v); // (|E|) with adj. list
         if indegree(v) = =0 then push(Q, v);
    end for;

    counter = 0;
    While Q is not empty do
         // indegree becomes 0 once & only once for a node
         // each node goes to Q only once: (N)
         v = pop(Q);
         ordering-id(v) = ++counter;
         V = V – v;

                     // two loops together (max{N, |E|})
                     // each edge scanned once and only once
               E = E – (v, w);
               decrement indegree(w);
               if now indegree(w) = =0 then push(Q, w);
         end for;
    end while;

    if counter != N then return(Failure);
                // not all nodes are numbered yet, but Q is empty
                // cycle detected;
End algorithm.

Complexity: the body of the inner for-loop is executed at
most once per edge, even considering the outer while loop,
if adjacency list is used. The maximum queue length is N.
Complexity is (|E| + N).


Path length = number of edges on a path.

Compute shortest path-length from a given source node to
all nodes on the graph.

[FIG 9.10]

Strategy: starting with the source as the "current-nodes," in
each of the iteration expand children (adjacent nodes) of
"current-nodes." Assign the iteration# as the shortest path
length to each expanded node, if the value is not already
assigned. Also, assign to each child, its parent node-id in
this expansion tree (to retract the shortest path if

Input: Undirected graph, and source node
Output: Shortest path-length to each node from source
Algorithm naïve-shortest-path
     distance-of source = 0;    //source to source distance
     distance-of all other nodes = infinity; // (N)

     // let the current distance from source be called
     for curdist = 0 through N-1 do
             for each vertex v do // (N2)
                 if (v is not yet “visited” &&
                    distance-of v is curdist) then
                 // the first check is needed because a
                    //graph may have cycles– to avoid looping
                 // the second check is needed for expanding
                    //only the nodes at current level curdist

                  // not all the nodes, only adjacent ones
                   for each w adjacent to v do
                       // (N |E|), |E| from the two inner for-loops,
                       // N from the outermost loop
                       if distance-of w is yet unassigned then
                              distance-of w = curdist +1;
                              path-of w (from source) = v;
                              // w’s parent is v
                       end if;
                   end for;
                 end if;

              mark v as “visited”;
               // because its children have been just expanded
           end for;
     end for;

End algorithm.
This is a breadth-first traversal, nodes are expanded as
increasing distances from the source: 0, then 1, then 2, etc.

Exercise: HOW TO FIND SHORTEST PATH backward
Algorithm Find-Shortest-Path (vertex w, array path-of[])

Complexity: (N + N |E|) from the for-loops. [Could be

(N3) if |E| ~ O(N2) for a dense graph]

Once again,
a better idea is to have the children being pushed at the
back of a queue.

Input: Undirected graph, and source node
Output: Shortest path-length to each node from source
Algorithm q-based-shortest-path
     distance-of source s = 0;
     enqueue only s in Q; // (1), no loop, constant-time

     while (Q is not empty) do
       v = dequeue Q;
       for each vertex w adjacent to v do // (|E|)
          if distance-of w is yet unassigned then
             distance-of w = distance-of v + 1;
             path-of w = v;
             enqueue w in Q;
          end if;
       end for;
     end while;
End algorithm.

Complexity: (|E| + N), by a similar analysis as that of the
previous queue-based algorithm.

Exercise: Implement this algorithm


In previous problem weight (or cost) on each path was = 1.
Now any positive value (>0) may exist on each edge.

We will ignore negative weight for now, because the
problem of finding shortest path may not be well defined
when negative edge is allowed (you can loop infinitely and
keep reducing the path weight!).

Strategy: from the set of "unfinished" nodes, pick up the
node v whose path-weight (from the source) is shortest in
the set, mark this node v to be “finished” (shortest path is
now found for this node), and update the path-weights to
the other unfinished nodes adjacent to the just-finished
node v, using the direct edges from this node v.

Initialization: Each node not having an edge with the
source node is initialized with distance (shortest from the
source) = infinity, and the source is marked as finished.
Input: Weighted graph, a “source” node s [can not handle neg
Output: Shortest distance to all nodes from the source s
Algorithm Dijkstra
     s.distance = 0; // shortest distance from s
     mark s as “finished”; //shortest distance to s from s found
     For each node w do
      if (v, w) ϵ E then w.distance= Dsw else w.distance = inf;
                                             // O(N)

     While there exists a node not marked as finished do
     // (|N|), each node is picked once & only once
           v = node from unfinished list with
                 the smallest v.distance;
           // loop on unfinished nodes O(N): total O(N2)
           mark v as “finished”; // why?

          For each edge (v, w) ϵ E do //adjacent to v: (|E|)
            if (w is not “finished” &
              (v.distance + Dvw < w.distance)) then
                       w.distance = v.distance + Dvw;
                       // Dvw is the direct-distance from
                          // current node v to w
                       w.previous = v;
                       // v is parent of w on the shortest path
             end if;
          end for;
     end while;
End algorithm
An example run:     [GRAPH ON p 324, Weiss]

v1 (0)       v2 (inf)            v3 (inf)      v4 (inf)     v5 (inf)
v6 (inf)     v7 (inf)

*v1 (0)      v2 (2, v1)          v3 (inf)      v4 (1, v1)   v5 (inf)
v6 (inf)     v7 (inf)

*v1 (0)      v2 (2, v1)          v3 (1+2, v4) *v4 (1, v1) v5 (1+2, v4)
v6 (1+8, v4) v7 (1+4, v4)

*v1 (0)      *v2 (2, v1)        v3 (3, v4) *v4 (1, v1) v5 (3, v4)
v6 (9, v4)   v7 (5, v4) // tried, but no improvement via v2

*v1 (0)      *v2 (2, v1)         *v3 (3, v4) *v4 (1, v1) v5 (3, v4)
v6 (3+5, v3) v7 (5, v4)

*v1 (0)      *v2 (2, v1)       *v3 (3, v4) *v4 (1, v1) *v5 (3, v4)
v6 (8, v3)   v7 (5, v4) // no improvement via v5

v6 (5+1, v7) *v7 (5, v4)

// end run, runs for N-1=8-1=7 iterations after initialization
(1) the while loop runs N-1 times: [(N)], find-minimum-
distance-node v runs another (N) within it, thus the
complexity is (N2);
Can you reduce this complexity by a Queue?
(2) for-loop, as usual for adjacency list graph data structure,
runs for |E| times including the outside while loop.
Grand total: (|E| + N ) = (N ), as |E| is always  N .
                        2        2                       2

Findmin complexity could be reduced to (NlogN) from
(N2), by using a heap data-structure, but as distance
values get changed the heap needs to be kept reorganized,
thus, increasing the for-loop's complexity to (|E|log N).
Grand total: (|E|logN + NlogN) = (|E|logN), as |E| is
always  N in a connected graph.
Algorithm Dijkstra (heap-based)
     s.distance = 0;
     (all-other-nodes).distance = inf; // O(N)
     mark s as “finished”;

     build min-heap for all nodes
         by using their distances from s; // O(N)

     while there is a node marked as unfinished do //O(N)
          v = delete-min on heap // O(NlogN)
          mark v as “finished”;

          for each node w adjacent to v do//(|E|)
                if w is not “finished” then
                 if (v.distance + Dvw <
                             w.distance) then
                     w.distance = v.distance + Dcw;
                     // Dvw is the direct-distance from
                        // cur-node v to w
                     modify heap for updated w.distance;
                                              // O(|E|logN)
                     w.previous = v;
                     // parent on the shortest path
               end if (both);
         end for;
    end while;
End algorithm.
Proof of correctness (Why Dijkstra’s algorithm works)

(Induction base is trivial, written later.)

By induction: Suppose it works up to the k-th iteration. This
means that for k nodes the corresponding shortest paths
from source have been already identified (say, set F). Rest
of the nodes have their distances possibly reduced, but
shortest distances from source are not found for them yet
(say, set U).

Picking up the shortest-current-distance node (say, p) from
the set U makes p to be the one for which the shortest
distance is just found, and so, p should move into F. If this
were not true, then path via some other node in U could
improve its path. But all of them have a longer (or equal)
path than that for p currently, how could they improve it for
someone else. And, all the nodes in F already had their
chance to improve the path for p in the previous iterations;
so, no further improvement is possible via anyone of them.
That implies, the shortest path for p has been found.

Next, why do we use p, to improve paths for the nodes in
the set U-{p}? All other nodes in F had had their chance to
improve paths for the nodes in U, so they cannot be useful
anymore. And shortest paths for nodes in U-{p} have not
been found yet, so how can they find shortest paths for
others. Even though one of them (say, up) may improve
paths for other nodes in the set U, that path may have to be
changed later when path to such a node(u) gets improved
further. Hence, p is the only candidate, which should
improve path for others in the next iteration.

Thus, in the next iteration we have k+1 nodes (including
node p) for which shortest paths have been found (from the
k-node stage), and in the next iteration we are ready to
declare our (k+2)-th node to be included in the set F. This
will conclude this inductive proof, when we find an
induction base-case.

Induction base: Shortest distance for the source itself must
have been found – no other node can improve it, if all
edges have positive weights.

Exercise: Prove the unweighted shortest path q-based
algorithm’s correctness.
Graphs with negative-cost allowed on any edge

Example on a business management-related graph: Positive
edge may mean profit, negative edge may mean
expenditure /loss.

One can falsely think of “normalizing” edges by adding a
constant (say, the min negative value plus 1) to all edges.
But that is wrong because that constant gets multiplied k-
times in a path of length k, and creates undue imbalance for
path-weight values.
a-(1)->b-(1)->c-(1)->d is shorter than a-(4)->d, but add 2
to all as a normalizer (note additional 2 does not exist in
reality/input)! The result will not be the same.

Dijkstra does not work anymore; marking
finished/unfinished is useless when there is negative cost
on an arc. So, let a node update others if its “distance” is
updated anytime, and the algorithm “relaxes” until no more
update takes place.

Algorithm Dijkstra-negative
     Initialize Q with the source node;

     While Q not empty do
         v = pop(Q);
         For each w adjacent node to v do
              If (v.distance + Dvw < w.distance) then   (6)
                    w.distance = v.distance +Dvw;
                    w.parent = v;
                     if w is not already in Q do
                               // if it is already there in Q
                               // do not duplicate
                            enqueue w to Q;
               end if
          end for
     end while
End Algorithm.

Note, shortest-path is not defined when there is a negative
cycle. Negative cost on an edge or a path is all right, but
negative cycle is not allowed.
Cost reduces on looping around cycles, and suppose we
allow that. But how many looping do we allow? No node
should get a chance to update others more than N+1 times!
Because, there cannot be a simple (loop free) path of length
more than N.

Line 6 is guaranteed to happen once for any node in
but should be terminated if a node a gets N+1 times in the
queue, meaning that the graph has a negative-cost cycle
involving the node a.
Otherwise, the algorithm might be in an infinite loop (over
the cycle with negative path-weight).

Complexity is O(N*|E|), because each node may be
updated by each edge at most one time (if there is no
negative cycle).

Dijkstra for acyclic-graph
Traverse nodes in topo-sort order, starting from the given
source node downwards. No edge exists in the backward
direction; so distances for those nodes from source remains

The algorithm can be combined with the topo-sort
algorithm. This prevents even the necessity of a heap
management: next node in topo-sort has to be a node with
the next min-distance (for which the shortest-path is just
found, the one to-be-moved from set U to set F).

So, finding min-distance node (cause for (N2) or use of
heap) will be replaced by picking up next node from those
with indegree 0.

Thus, the complexity is (|E| + N).

A real-life example of the problem is in doing the critical-
path analysis in the project management area. The problem
there is to find longest path, but then positive cycles can
increase path-distances. But the problem with CPA is on
directed acyclic graph, so traversal according to
topological-sort will be all right.

[Fig 9.34, 9.35 together, in Weiss]

First calculate earliest completion time EC of each node
starting from source, where EC1 = 0. For every adjacent
node w to all nodes v (starting with 1),
ECw = max vw (ECv + cvw), max runs over v for each w.
[Fig 9.36, Weiss]

Once this is calculated, compute latest completion time
(without affecting the shortest finish time = EClast) starting
from the last node n backwards.
LCn = ECn, and LCv = min vw (LCw - cvw), minimum runs
over w here for each v.

[Fig 9.37]

Slack time for each edge is Slack vw = LCw - ECv - cvw, by
which an activity could be delayed without affecting
shortest finish time. Slack is zero on every node on the
critical path [WHY?].

Traversal is in topo-sort order. So, the complexity is the
same as that of topo-sort.

All-pairs shortest path algorithm

One can run Dijkstra’s algorithm for each node with total
complexity N times (N^2) (without heap) = (N^3).
However, Floyd’s algorithm runs with the same (N^3)
but is faster for dense graphs. (Read in Dynamic
Programming section of AlgType module).

Greedy Strategy

Dijkstra’s algorithm works with greedy strategy: pick up
the best of something to work with at every stage. Doesn’t
care the global implication: what is best now - may proved
to be a bad choice in the future. In case of single-source-
shortest-path Dijkstra’s algorithm is provably correct and
the strategy has worked. However, greedy strategy is not
always so lucky.

Maximum Flow Problem

A weighted diagraph, weights mean capacity of flow
(traffic, fluid, etc.) on an edge. Given also are source and
sink nodes. Find out the maximum flow possible from
source to sink including all paths between them, with a
constraint: for any node the total inflow should be equal to
the outflow from it.

A strategy: find a path from the source to the sink, subtract
the minimum weight on any edge on the path from the
weights of all edges on that path, eliminate any edge with
zero weight, repeat these steps until no more path from
source to sink exists. On every iteration, keep track of the
path, on a separate graph, with the weight that is being
subtracted on each of its edges (max flow). Calculate max-
flow between the source and the sink from this second

[Fig 9.41, 9.42, 9.43 together]

Above algorithm depends heavily on the order of picking
up of paths, and thus may not provide correct solution if a
wrong path is selected first.
[Fig 9.44]

A correct algorithm would involve using a greedy strategy
(work with the best-flow path in each iteration), but that
also may lead to non-optimal solution.

A greedy algorithm with the creation of a reverse edge with
the value that is subtracted (in addition to doing the actual
subtracting from the existing edge). This creates a
possibility of virtually backtracking of flows if that
becomes necessary. This strategy is guaranteed to find the
maximum flow. The proof is difficult.
Minimum Spanning Tree Problem

Spanning tree of a graph is a subgraph of the graph, which
(1) covers all the nodes in the graph and (2) is a tree.

For a weighted graph each of its spanning trees has an
aggregate weight of all its edges.

Minimum spanning tree is a spanning tree with the least
aggregate weight.

[Fig 9.48]

Problem: given a weighted graph find a minimum spanning
Solutions: Prim’s algorithm, and Kruskal’s algorithm.

Prim’s Algorithm

Strategy: Two sets of nodes from the graph: in the current
tree (T), not-yet-in the current tree (U).
Start with any node and put it in T.
At every stage pick up a node u from U such that it has the
minimum distance from any node in T.
Take it off from U, put it in T, and update min distances
(direct arc from u or a node in T, not the shortest path from
a source, there is no “source” now as in Dijkstra) of all
nodes in U from this node u.

Exactly the same algorithm as Dijkstra except the updating
of the distances (to all nodes w in U adjacent to u) is no
longer on paths, rather it is for shortest connection to T, dw
= min(dw, Duw) . Complexity is also the same as in Dijkstra.

[Weiss: Fig 9.49]

[Exercise: Write Prim’s algorithm by modifying Dijkstra’s

Kruskal’s algoritm

Strategy: Pick up the next available shortest edge and put it
on T if it does not form a cycle. Grows as a forest rather
than as a tree, eventually ends up as a min-spanning tree (T)
of the graph, if the latter is a connected one. Since forests
are merged gradually the disjoint-set data structure (for
faster union-find operation) can be used for efficiency,
otherwise one may sort the edges first and pick them up in
that order: O(|E|log|E|) = O(|E|logN). Set union will cost
additional O(NlogN).

[Weiss: Fig 9.57]

Algorithm Kruskal
     Input: graph G = (V, E).
     E1 = sort edges in G; // or better use heap
     repeat for N-1 edges // any Spanning Treee has
                            //exactly N-1 edges, |V|=N
          pick up next shortest edge e from the ordered E1;
          E1 = E1 – {e};
          if (T U {e}) does not have a cycle then
                     // by set matching algorithm (Union-find)
                T = T U {e};
     end repeat;

    return graph (V, T);
End algorithm.

Observation: pick up an edge d in E but not in T, add it to
T, you will have a cycle, say, c. Eliminate an edge other
than d from c, you have a different spanning tree of G.
Every spanning tree is “connected” to other by repetition of
this operation.

Proof sketch of Kruskal:
Suppose (V, T) is not an MST, but by adding e1 (not in T)
to T and then eliminating e2 (in T) from the respective
cycle we get an MST (V, T1).
Then, cost(T1) < cost(T), by assumption.
But, cost(T1) = cost(T) + cost(e1) – cost(e2).
So, cost(T) + cost(e1) – cost(e2) < cost(T),
i.e., cost(e1) – cost(e2) < 0,
or, cost(e1) < cost(e2).
But, then e1 should have been picked up before e2 by the
greedy strategy in Kruskal (without forming a cycle,
because e2 were not picked up yet).
But note that we added e1 to T and subtracted e2 from T, so
e2 must have been picked up before e1, implying
Thus, cost(T1)<cost(T) is not possible for any T1 other
than T itself.
Hence, (V, T) is an MST.
End proof.
Depth-first search on graphs and its use in some

Recursion stack implements depth-first traversal. So
typically dfs are implemented as recursive algorithm.

Graph-traversal needs additional check: in case a node is
already traversed - since there can be loops (which are not
there in a tree by definition).

Input: graph (V, E)
Output: a DFS spanning forest
Algorithm dfs(v)
     mark node v as visited;
     operate on v (e.g., print);
     for each node w adjacent to node v do
          if w is not marked as visited then
                dfs(w); // an iterative algorithm
                       //will maintain its own stack
     end for;
End algorithm.

Starter algorithm
     on a given graph call dfs(any/given node);
End starter.

Example: with an undirected graph on Weiss: Fig 9.60,
This algorithm will not be complete for not-connected
graph, or if directed but not strongly-connected graph.

One needs to restart it again and again until all nodes are
marked. So the starter algorithm looks like:
repeat until all nodes are marked
    pick up next unmarked node s;
end repeat;

Checking and finding unmarked node might be unduly

DFS produces a spanning-tree (or forest, for a directed
graph) of the graph: dfs-spanning-tree. This is utilized in
solving the following problems.

Algorithm Iterative-DFS
let start node be v;
initialize stack S with Push(S, v);

while stack S not empty do
    node r = Pop(S);
    mark r visited;
    for each node w adjacent to r do
          if w is not marked Push(S, w)
    end for;
end while;
End Algorithm

Complexity O(|E|) from the two loops.
Finding articulation points or detecting a biconnected

Biconnected graph: undirected connected graph where
removal of no vertex disconnects the rest of the graph.
Articulation points: vertex like the ones mentioned above.
So, biconnected graphs are graphs without articulation

Draw a dfs-spanning tree for the given graph starting from
any of its nodes.
Number them according to the order of their traversal
For each vertex v, find the lowest vertex# where one can go
from v (num(child(v))) by the dfs-spanning tree edges
(post-order) or by any other left-out edge (back-edge on
dfs-tree) from the original graph (low(would-have-been-
child(v))) => assign that min value as low(v)
If for any vertex v there is a child w such that num(v) 
low(w), then v is an articulation point, unless v is the root
in the dfs-ST.
If the root of the dfs-ST has two or more children in this
dfs-spanning-tree, then it is an articulation point.

Starting from any node will get you the same result.

Example: (Weiss 2nd ed) p359-361.

Exercise: Try starting from a different node.
Euler circuit

Problems: (1) Follow the edges of a graph (undirected)
without lifting the pen to cover all edges once & only once,
(2) problem 1, and have the start and end points both be the
same node.

Example: Figure 9.68, page 363-365.

Necessary and sufficient conditions for existence of a
For problem 2. Graph must be connected and every vertex
must have even number of edges (for the pen to come in
and then go out).
For problem 1. Relax the previous condition by allowing
exactly two nodes to have odd number of edges, which
must be the start and the end nodes.

Checking the conditions take linear time (one pass over
each node (N)).

Algorithm for drawing Euler circuit for problem 2 (i.e.,
ordering the nodes as they are traversed), knowing that
there exists one:
Step 1: Beginning from the start node traverse nodes DFS-
manner, eliminate edges as they are traversed (because
each edge can be used only once), until stuck at a node
because no more edge is left at this node
Step 2: If all edges are not yet covered, pick up the first
unfinished node X in the last path that has un-traversed
edges left, and starting from X traverse nodes DFS-manner,
eliminate edges as they are traversed, until X is reached
back and is finished. Insert this new path in the previous
path replacing X in the latter.
Step 3: Keep doing step 2 until all edges are covered.
End algorithm-sketch.

Example run of the algorithm: page 333-334, Figures 9.70-

Complexity: O(N + |E|), because all edges are covered only
once, (but note that some nodes may be covered multiple

Detecting “Hamiltonian circuit” over nodes is not easy!
DFS on directed graph

Could create forest of traversed trees

Until no unmarked nodes remain do
     pick up a unmarked node v;
     mark v as visited;
     for each adjacent node w to v do
           if w is not visited
                 traverse w recursively;
     end for;
end until-loop.

Finding Strongly-connected components in a Directed

Strongly-connected component: a subgraph in which there
is a path between every pair of nodes

Note: The whole graph could be strongly connected.
Note: Only a single node could form its own SCC.

SCC creates partition of nodes in a graph: every node is in
a SCC, & no node is outside all SCC’s.

A sub-graph of a SCC could be an SCC itself, although not

We are interested in finding the set of all SCC’s in a
directed graph
Strategy for finding SCC’s of a graph G:
Traverse G using DFS to create spanning forest of the
Number the nodes in the post-order traversal of the
Create Gr by reversing the directions of arcs in G;
Traverse using DFS the nodes of Gr in a decreasing order
of the numbers,
DFS spanning-forest from this second traversal creates the
set of SCC’s for G.

Intuition: First dfs-spanning-trees create a partition for
forward paths (v to w); The second dfs always start from
the roots (v) of the first dfs-trees and so, the second dfs-
trees guarantee reverse path (w to v); v to w double-
directed-paths guarantee SCC over each second dfs-tree.

To prove:
Theorem 1: Each Spanning Tree ST(Gr) is a strongly
connected component of G.

Theorem 2 (equivalent): for every pair of nodes (v, w) in
any Spanning Tree ST(Gr) there exists a path v->w and a
path w->v.

Theorem 3 (equivalent): above can be proved if we prove
for any pair of nodes (v, w) in ST(Gr) with the root r, there
exists a path from v -> r and from r -> w in G.
Theorem 4 (equivalent): above can be proved if we prove
that for any node v in ST(Gr) with the root r, there exists a
path r->v and a path v->r in G.

Lemma 1: every spanning tree ST(Gr) is a sub-tree of a
spanning tree ST(G).
Proof: by observation that backarcs between the spanning
trees ST(G) are in “forward” direction only. So when
directions of the graph is reversed in Gr, and you start DFS
traversal from Right to Left (in reverse post-order traversal
numbering of ST(G)), there is no way you can get to the
next tree from the current one (tree) – they are disconnected
with Gr’s directed arcs. So, each ST(Gr) is a sub-tree of the
corresponding ST(G). QED.

Lemma 2: root r of every ST(Gr) has a higher post-traversal
index (in ST(G)) than any node n of that ST(Gr).
Proof: Trivial. Traversal on Gr was done in that order.

Lemma 3: for any node v in an ST(Gr) whose root is r,
there exist a path v->r in G.
Proof: Trivial. Since there exists a path in r->v in Gr, there
exist a path v->r in G.

Lemma 4: for any node v in an ST(Gr) whose root is r,
there exist a path r->v in G.
Proof: Both r and v belongs to the same ST(G) by lemma 1.
And, post-ord-index(r)>post-ord-index(v) by lemma 2.
Thus, all the work of processing r was completed after the
work of processing v during DF-traversal of G. Since there
is a path from v->r in G by lemma 3, v must be descendant
of r in ST(G) – otherwise v would finish after r. In other
words, there exists a path r->v as indicated in ST(G) they
both belong to. QED. [Example from book: path exists F-
>B in G as suggested in ST(Gr), yet order(B)=6
>order(F)=5. So, there must be a path B->F in ST(G).]

Lemma 3 and 4 prove version (4) of the Theorem as above.

Example: Weiss, Fig 9.74-77, pp 366-368
Exercise: solve the problem in the example by creating a
different dfs-spanning-tree than that in the book.

Shared By: