Algorithms R OBERT S EDGEWICK | K EVIN W AYNE

4.2 D IRECTED G RAPHS

‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort
F O U R T H E D I T I O N

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
 Directed graphs

Digraph. Set of vertices connected pairwise by directed edges.

vertex of
outdegree 4
and indegree 2
0

6 8 7

directed path
from 0 to 2
1 2

3 9 10

4 directed cycle

5
11 12

3
Road network
To see all the details that are visible on the screen,use the
Address Holland Tunnel "Print" link next to the map.
New York, NY 10013
Vertex = intersection; edge = one-way street.

©2008 Google - Map data ©2008 Sanborn, NAVTEQ™ - Terms of Use

4
Political blogosphere graph

Vertex = political blog; edge = link.

The Political Blogosphere and the 2004 U.S. Election: Divided They Blog, Adamic and Glance, 2005
Figure 1: Community structure of political blogs (expanded set), shown using utilizing a GEM
layout [11] in the GUESS[3] visualization and analysis tool. The colors reflect political orientation, 5
red for conservative, and blue for liberal. Orange links go from liberal to conservative, and purple
Overnight interbank loan graph

Vertex = bank; edge = overnight loan.

GSCC

GWCC

GIN
GOUT

DC

Tendril

!"#$%& '( !&)&%*+ ,$-). -&/01%2 ,1% 3&4/&56&% 7'8 799:; <=>> ? #"*-/ 0&*2+@ A1--&A/&) A1541-&-/8
The Topology
B> ? )".A1--&A/&) A1541-&-/8 <3>> of?
the Federal
#"*-/ Funds
./%1-#+@ Market, A1541-&-/8
A1--&A/&) Bech and Atalay,
<CD ? 2008
#"*-/ "-EA1541-&-/8
<FGH ? #"*-/ 1$/E A1541-&-/; F- /I". )*@ /I&%& 0&%& JK -1)&. "- /I& <3>>8 L9L -1)&. "- /I& <CD8 :K
6
-1)&. "- <FGH8 J9 -1)&. "- /I& /&-)%"+. *-) 7 -1)&. "- * )".A1--&A/&) A1541-&-/;
Implication graph

Vertex = variable; edge = logical implication.

if x5 is true,
then x0 is true
~x2 x0

x6 ~x4 x3

~x5 ~x1 x1 x5

~x3 x4 ~x6

~x0 x2

7
Combinational circuit

Vertex = logical gate; edge = wire.

8
WordNet graph

Vertex = synset; edge = hypernym relationship.

event

happening occurrence occurrent natural_event

miracle
act human_ac on human_ac vity
change altera on modi ca on miracle

group_ac on
damage harm ..
impairment transi on increase forfeit forfeiture ac on

resistance opposi on transgression

leap jump salta on jump leap
change

demo on varia on
mo on movement move

locomo on travel descent

run running jump parachu ng

http://wordnet.princeton.edu dash sprint

9
The McChrystal Afghanistan PowerPoint slide

http://www.guardian.co.uk/news/datablog/2010/apr/29/mcchrystal-afghanistan-powerpoint-slide
10
Digraph applications

digraph vertex directed edge

transportation street intersection one-way street

web web page hyperlink

food web species predator-prey relationship

WordNet synset hypernym

scheduling task precedence constraint

financial bank transaction

cell phone person placed call

infectious disease person infection

game board position legal move

citation journal article citation

object graph object pointer

inheritance hierarchy class inherits from

control flow code block jump

11
Some digraph problems

s
Path. Is there a directed path from s to t ?

Shortest path. What is the shortest directed path from s to t ?

Topological sort. Can you draw a digraph so that all edges point upwards?

Strong connectivity. Is there a directed path between all pairs of vertices?

Transitive closure. For which vertices v and w is there a path from v to w ?

PageRank. What is the importance of a web page?

12
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
Digraph API

public class Digraph

Digraph(int V) create an empty digraph with V vertices

Digraph(In in) create a digraph from input stream

void addEdge(int v, int w) add a directed edge v→w

Iterable<Integer> adj(int v) vertices pointing from v

int V() number of vertices

int E() number of edges

Digraph reverse() reverse of this digraph

String toString() string representation

In in = new In(args[0]); read digraph from

Digraph G = new Digraph(in); input stream

for (int v = 0; v < G.V(); v++) print out each

for (int w : G.adj(v)) edge (once)
StdOut.println(v + "->" + w);
15
Digraph API

tinyDG.txt
% java Digraph tinyDG.txt
V 0->5 5 1
13
E 0->1
22
4 2 2->0
2 3 adj[] 0 3
3 2
2->3
0
6 0 3->5
0 1 1 5 2
3->2
2 0 2
11 12
4->3 3 2
3
12 9 4->2
9 10 4 5->4 4
9 11 5
7 9
⋮
10 12 6 9 4 8 0
11->4
11 4 7 11->12
4 3 6 9
8 12-9
3 5
6 8 9
6
8 6 10
⋮5 4 11 11 10
0 5
6 4 12
6 9=
In in new In(args[0]); 12
read digraph from
7 6
Digraph G = new Digraph(in); input stream
4 12

for (int v = 0; v < G.V(); v++) 9

print out each
for (int w : G.adj(v)) edge (once)
StdOut.println(v + "->" + w);
16
 Adjacency-lists digraph representation

Maintain vertex-indexed array of lists.

tinyDG.txt
V 5 1
13
E
.txt 22
4
2
2
3 adj[]
5 1
0 3
E 3 2 0
6 0
1 5 2
2 0 1
2 0 2
adj[]
3 11 12 3 02 3
3
2 12 9 0
4
0 9 10 4
1
9 11 1 5 5 2
7 9
6 9 4 8 0
0 10 12 2
2 11 4 7 3 2
4 3 3 8
6 9
9 3 5
0 6 8 4 9
6 4
8 6 10
1 5 4 5
9 0 5 11 11 10
2 6 4 6 12 9 4 8 0
6 9 12
4 7 6 7
3 4 612 9
8
5
9 9
8 6 17
6
Adjacency-lists graph representation (review): Java implementation

public class Graph

{
private final int V;
private final Bag<Integer>[] adj; adjacency lists

public Graph(int V)
{ create empty graph
with V vertices
this.V = V;
adj = (Bag<Integer>[]) new Bag[V];
for (int v = 0; v < V; v++)
adj[v] = new Bag<Integer>();
}

add edge v–w

public void addEdge(int v, int w)
{
adj[v].add(w);
adj[w].add(v);
}
iterator for vertices
public Iterable<Integer> adj(int v) adjacent to v
{ return adj[v]; }
}
18
Adjacency-lists digraph representation: Java implementation

public class Digraph

{
private final int V;
private final Bag<Integer>[] adj; adjacency lists

public Digraph(int V)
{ create empty digraph
with V vertices
this.V = V;
adj = (Bag<Integer>[]) new Bag[V];
for (int v = 0; v < V; v++)
adj[v] = new Bag<Integer>();
}

add edge v→w

public void addEdge(int v, int w)
{
adj[v].add(w);

}
iterator for vertices
public Iterable<Integer> adj(int v) pointing from v
{ return adj[v]; }
}
19
Digraph representations

In practice. Use adjacency-lists representation.

Algorithms based on iterating over vertices pointing from v.
Real-world digraphs tend to be sparse.

huge number of vertices,

small average vertex degree

insert edge edge from iterate over vertices

representation space
from v to w v to w? pointing from v?

list of edges E 1 E E

adjacency matrix V2 1† 1 V

adjacency lists E+V 1 outdegree(v) outdegree(v)

† disallows parallel edges

20
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
Reachability

Problem. Find all vertices reachable from s along a directed path.

23
Depth-first search in digraphs

Same method as for undirected graphs.

Every undirected graph is a digraph (with edges in both directions).
DFS is a digraph algorithm.

DFS (to visit a vertex v)

Mark v as visited.
Recursively visit all unmarked
vertices w pointing from v.

24
Depth-first search demo

To visit a vertex v : 4→2

2→3
Mark vertex v as visited. 3→2
Recursively visit all unmarked vertices pointing from v. 6→0
0→1
2→0
0
11→12
12→9
6 8 7
9→10

1 2 9→11
8→9
10→12
11→4
3 9 10 4→3
3→5
4 6→8
8→6
5 5→4
11 12
0→5
6→4
a directed graph 6→9
7→6
25
Depth-first search demo

To visit a vertex v :
Mark vertex v as visited.
Recursively visit all unmarked vertices pointing from v.

0
v marked[] edgeTo[]

6 8 7 0 T –
1 T 0
1 2 reachable 2 T 3
from vertex 0 3 T 4
4 T 5
5 T 0
3 9 10 6 F –
7 F –
4 8 F –
9 F –
5 10 F –
11 12
11 F –
12 F –

reachable from 0

26
Depth-first search (in undirected graphs)

Recall code for undirected graphs.

public class DepthFirstSearch

{
private boolean[] marked; true if path to s

public DepthFirstSearch(Graph G, int s)

{
constructor marks
marked = new boolean[G.V()]; vertices connected to s
dfs(G, s);
}

private void dfs(Graph G, int v) recursive DFS does the work

{
marked[v] = true;
for (int w : G.adj(v))
if (!marked[w]) dfs(G, w);
}

client can ask whether any

public boolean visited(int v)
vertex is connected to s
{ return marked[v]; }
}

27
Depth-first search (in directed graphs)

Code for directed graphs identical to undirected one.

[substitute Digraph for Graph]

public class DirectedDFS

{
private boolean[] marked; true if path from s

public DirectedDFS(Digraph G, int s)

{
constructor marks
marked = new boolean[G.V()]; vertices reachable from s
dfs(G, s);
}

private void dfs(Digraph G, int v) recursive DFS does the work

{
marked[v] = true;
for (int w : G.adj(v))
if (!marked[w]) dfs(G, w);
}

client can ask whether any

public boolean visited(int v)
vertex is reachable from s
{ return marked[v]; }
}

28
Reachability application: program control-flow analysis

Every program is a digraph.

Vertex = basic block of instructions (straight-line program).
Edge = jump.

Dead-code elimination.
Find (and remove) unreachable code.

Infinite-loop detection.
Determine whether exit is unreachable.

29
Reachability application: mark-sweep garbage collector

Every data structure is a digraph.

Vertex = object.
Edge = reference.

Roots. Objects known to be directly accessible by program (e.g., stack).

Reachable objects. Objects indirectly accessible by program

(starting at a root and following a chain of pointers).

roots

30
Reachability application: mark-sweep garbage collector

Mark-sweep algorithm. [McCarthy, 1960]

Mark: mark all reachable objects.
Sweep: if object is unmarked, it is garbage (so add to free list).

Memory cost. Uses 1 extra mark bit per object (plus DFS stack).

roots

31
Depth-first search in digraphs summary

DFS enables direct solution of simple digraph problems.

✓ Reachability.
Path finding.
Topological sort.
Directed cycle detection.

Basis for solving difficult digraph problems.

2-satisfiability.
Directed Euler path.
Strongly-connected components.

SIAM J. COMPUT.
Vol. 1, No. 2, June 1972

DEPTH-FIRST SEARCH AND LINEAR GRAPH ALGORITHMS*

ROBERT TARJAN"
Abstract. The value of depth-first search or "bacltracking" as a technique for solving problems is
illustrated by two examples. An improved version of an algorithm for finding the strongly connected
components of a directed graph and ar algorithm for finding the biconnected components of an un-
direct graph are presented. The space and time requirements of both algorithms are bounded by
k 1V + k2E d- k for some constants kl, k2, and k a, where Vis the number of vertices and E is the number
of edges of the graph being examined.
Key words. Algorithm, backtracking, biconnectivity, connectivity, depth-first, graph, search,
spanning tree, strong-connectivity.
32
1. Introduction. Consider a graph G, consisting of a set of vertices U and a
Breadth-first search in digraphs

Same method as for undirected graphs.

Every undirected graph is a digraph (with edges in both directions).
BFS is a digraph algorithm.

BFS (from source vertex s)

Put s onto a FIFO queue, and mark s as visited.

Repeat until the queue is empty:
- remove the least recently added vertex v
- for each unmarked vertex pointing from v:
add to queue and mark as visited.

Proposition. BFS computes shortest paths (fewest number of edges)

from s to all other vertices in a digraph in time proportional to E + V.
33
Directed breadth-first search demo

Repeat until queue is empty:

Remove vertex v from queue.
Add to queue all unmarked vertices pointing from v and mark them.

tinyDG2.txt
V
0 2 6 E
8
5 0
2 4
1 3 2
1 2
0 1
3 4 3
5 4 3 5
0 2

graph G

34
Directed breadth-first search demo

Repeat until queue is empty:

Remove vertex v from queue.
Add to queue all unmarked vertices pointing from v and mark them.

0 2
v edgeTo[] distTo[]

0 – 0
1 0 1
1 2 0 1
3 4 3
4 2 2
3 5 3 4
5 4

done

35
Multiple-source shortest paths
tinyDG.txt
V
Multiple-source shortest paths.13Given a digraph and a set of source
E
22
vertices, find shortest path from any vertex in the set to each other vertex.
4 2
2 3 adj
Ex. S = { 1, 7, 10 }. 3 2 0
6 0
Shortest path to 4 is 7→6→4. 1
0 1
Shortest path to 5 is 7→6→0→5.
2 0 2
11 12
Shortest path to 12 is 10→12. 3
12 9
… 9 10 4
9 11 5
7 9
10 12 6
11 4 7
4 3
8
3 5
6 8 9
8 6 10
5 4
Q. How to implement multi-source shortest paths algorithm? 11
0 5
A. Use BFS, but initialize by enqueuing
6 4 all source vertices. 12
6 9 36
7 6
Breadth-first search in digraphs application: web crawler

Goal. Crawl web, starting from some root web page, say www.princeton.edu.

25
0 34
Solution. [BFS with implicit digraph]
7
Choose root web page as source s. 10
2
40

Maintain a Queue of websites to explore. 41

29 15
19 33
49
8
Maintain a SET of discovered websites. 44
45

Dequeue the next website and enqueue 28

1 14

websites to which it links 39

22 48

18 6 21

(provided you haven't done so before).

42 13
23
31 47
11 12
32
30
26
5 37
27
9 16
43

24
4
38
3 17
35
36
46
Q. Why not use DFS? 20

How many strong components are there in this digraph? 37

Bare-bones web crawler: Java implementation

Queue<String> queue = new Queue<String>(); queue of websites to crawl

SET<String> marked = new SET<String>(); set of marked websites

String root = "http://www.princeton.edu";

queue.enqueue(root); start crawling from root website
marked.add(root);

while (!queue.isEmpty())
{
String v = queue.dequeue();
read in raw html from next
StdOut.println(v);
website in queue
In in = new In(v);
String input = in.readAll();

String regexp = "http://(\\w+\\.)*(\\w+)";

Pattern pattern = Pattern.compile(regexp); use regular expression to find all URLs
Matcher matcher = pattern.matcher(input); in website of form http://xxx.yyy.zzz
while (matcher.find()) [crude pattern misses relative URLs]
{
String w = matcher.group();
if (!marked.contains(w))
{
marked.add(w);
if unmarked, mark it and put
queue.enqueue(w);
on the queue
}
}
}
38
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
Precedence scheduling

Goal. Given a set of tasks to be completed with precedence constraints,

in which order should we schedule the tasks?

Digraph model. vertex = task; edge = precedence constraint.

0. Algorithms 0
1. Complexity Theory
2. Artificial Intelligence 2 5 1
3. Intro to CS
4. Cryptography 3 4
5. Scientific Computing
6. Advanced Programming 6

tasks precedence constraint graph

feasible schedule 41
Topological sort

DAG. Directed acyclic graph.

Topological sort. Redraw DAG so all edges point upwards.

0→5 0→2 0

0→1 3→6
3→5 3→4 2 5 1

5→2 6→4
3 4
6→0 3→2
1→4 6

directed edges DAG

Solution. DFS. What else?

topological order 42
Topological sort demo

Run depth-first search.

Return vertices in reverse postorder.

0
0→5
0→2
0→1
3→6
2 5 1 3→5
3→4
5→2
6→4
3 4
6→0
3→2
1→4
6

a directed acyclic graph

43
Topological sort demo

Run depth-first search.

Return vertices in reverse postorder.

postorder

4 1 2 5 0 6 3

2 5 1 topological order

3 6 0 5 2 1 4

3 4

done

44
Depth-first search order

public class DepthFirstOrder

{
private boolean[] marked;
private Stack<Integer> reversePost;

public DepthFirstOrder(Digraph G)
{
reversePost = new Stack<Integer>();
marked = new boolean[G.V()];
for (int v = 0; v < G.V(); v++)
if (!marked[v]) dfs(G, v);
}

private void dfs(Digraph G, int v)

{
marked[v] = true;
for (int w : G.adj(v))
if (!marked[w]) dfs(G, w);
reversePost.push(v);
}

public Iterable<Integer> reversePost() returns all vertices in

{ return reversePost; } “reverse DFS postorder”
}

45
Topological sort in a DAG: correctness proof

Proposition. Reverse DFS postorder of a DAG is a topological order.

Pf. Consider any edge v→w. When dfs(v) is called:
dfs(0)
dfs(1)
dfs(4)
Case 1: dfs(w) has already been called and returned. 4 done
1 done
Thus, w was done before v. dfs(2)
2 done
dfs(5)
Case 2: dfs(w) has not yet been called. check 2
5 done
dfs(w) will get called directly or indirectly 0 done
check 1
by dfs(v) and will finish before dfs(v). check 2
v=3 dfs(3)
Thus, w will be done before v. check 2
case 1 check 4
check 5
Case 3: dfs(w) has already been called, case 2 dfs(6)
check 0
but has not yet returned. check 4
6 done
Can’t happen in a DAG: function call stack contains 3 done
check 4
path from w to v, so v→w would complete a cycle. check 5
check 6
all vertices pointing from 3 are done before 3 is done, done
so they appear after 3 in topological order 46
Directed cycle detection

Proposition. A digraph has a topological order iff no directed cycle.

Pf.
If directed cycle, topological order impossible.
If no directed cycle, DFS-based algorithm finds a topological order.

marked[]
0 1 2 3 4
dfs(0)
dfs(5) 1 0 0 0 0
dfs(4) 1 0 0 0 0
dfs(3) 1 0 0 0 1
check 5 1 0 0 1 1

a digraph with a directed cycle Finding a directed cycle

Goal. Given a digraph, find a directed cycle.

Solution. DFS. What else? See textbook.
47
Directed cycle detection application: precedence scheduling

Scheduling. Given a set of tasks to be completed with precedence

constraints, in what order should we schedule the tasks?

http://xkcd.com/754

Remark. A directed cycle implies scheduling problem is infeasible.

48
Directed cycle detection application: cyclic inheritance

The Java compiler does cycle detection.

public class A extends B % javac A.java

{ A.java:1: cyclic inheritance
... involving A
} public class A extends B { }
^
1 error
public class B extends C
{
...
}

public class C extends A

{
...
}

49
Directed cycle detection application: spreadsheet recalculation

Microsoft Excel does cycle detection (and has a circular reference toolbar!)

50
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
Strongly-connected components

Def. Vertices v and w are strongly connected if there is both a directed path
from v to w and a directed path from w to v.

Key property. Strong connectivity is an equivalence relation:

v is strongly connected to v.
If v is strongly connected to w, then w is strongly connected to v.
If v is strongly connected to w and w to x, then v is strongly connected to x.

Def. A strong component is a maximal subset of strongly-connected vertices.

53
A digraph and its strong components
 Connected components vs. strongly-connected components

v and w are connected if there is v and w are strongly connected if there is both a directed
a path between v and w path from v to w and a directed path from w to v

A graph3 and its connected

connected components
components A digraph and
A5its strongand
digraph components
its strongcomponents
strongly-connected components

connected component id (easy to compute with DFS) strongly-connected component id (how to compute?)

0 1 2 3 4 5 6 7 8 9 10 11 12 0 1 2 3 4 5 6 7 8 9 10 11 12
cc[] 0 0 0 0 0 0 1 1 1 2 2 2 2 scc[] 1 0 1 1 1 1 3 4 3 2 2 2 2

public int connected(int v, int w) public int stronglyConnected(int v, int w)

{ return cc[v] == cc[w]; } { return scc[v] == scc[w]; }

constant-time client connectivity query constant-time client strong-connectivity query

54
Strong component application: ecological food webs

Food web graph. Vertex = species; edge = from producer to consumer.

http://www.twingroves.district96.k12.il.us/Wetlands/Salamander/SalGraphics/salfoodweb.gif

Strong component. Subset of species with common energy flow.

55
Strong component application: software modules

Software module dependency graph.

Vertex = software module.
Edge: from module to dependency.

Firefox Internet Explorer

Strong component. Subset of mutually interacting modules.

Approach 1. Package strong components together.
Approach 2. Use to improve design!
56
Strong components algorithms: brief history

1960s: Core OR problem.

Widely studied; some practical algorithms.
Complexity not understood.

1972: linear-time DFS algorithm (Tarjan).

Classic algorithm.
Level of difficulty: Algs4++.
Demonstrated broad applicability and importance of DFS.

1980s: easy two-pass linear-time algorithm (Kosaraju-Sharir).

Forgot notes for lecture; developed algorithm in order to teach it!
Later found in Russian scientific literature (1972).

1990s: more easy linear-time algorithms.

Gabow: fixed old OR algorithm.
Cheriyan-Mehlhorn: needed one-pass algorithm for LEDA.
57
Kosaraju-Sharir algorithm: intuition

Reverse graph. Strong components in G are same as in GR.

Kernel DAG. Contract each strong component into a single vertex.

how to compute?
Idea.
Compute topological order (reverse postorder) in kernel DAG.
Run DFS, considering vertices in reverse topological order.

first vertex is a sink

(has no edges pointing from it)

Kernel DAG in reverse topological order

A digraph and its strong components
digraph G and its strong components kernel DAG of G (in reverse topological order)
58
Kosaraju-Sharir algorithm demo

Phase 1. Compute reverse postorder in GR.

Phase 2. Run DFS in G, visiting unmarked vertices in reverse postorder of GR.

6 8 7

1 2

3 9 10

5
11 12

digraph G

59
Kosaraju-Sharir algorithm demo

Phase 1. Compute reverse postorder in GR.

1 0 2 4 5 3 11 9 12 10 6 7 8

6 8 7

1 2

3 9 10

5
11 12

reverse digraph GR

60
Kosaraju-Sharir algorithm demo

Phase 2. Run DFS in G, visiting unmarked vertices in reverse postorder of GR.

1 0 2 4 5 3 11 9 12 10 6 7 8

0
v scc[]

6 8 7 0 1
1 0
1 2 2 1
3 1
4 1
5 1
3 9 10 6 3
7 4
4 8 3
9 2
5 10 2
11 12
11 2
12 2

done

61
 Kosaraju-Sharir algorithm

Simple (but mysterious) algorithm for computing strong components.

Phase 1: run DFS on GR to compute reverse postorder.
Phase 2: run DFS on G, considering vertices in order given by first DFS.

DFS in reverse digraph GR

check unmarked vertices in the order reverse postorder for use in second dfs()
0 1 2 3 4 5 6 7 8 9 10 11 12 1 0 2 4 5 3 11 9 12 10 6 7 8

dfs(0)
dfs(6)
dfs(8)
check 6
8 done
dfs(7)
7 done
6 done
dfs(2)
dfs(4)
dfs(11)
dfs(9)
dfs(12)
check 11
dfs(10)
check 9
10 done
12 done
check 7
check 6
... 9 done 62
11 done
check 6
 Kosaraju-Sharir algorithm

Simple (but mysterious) algorithm for computing strong components.

Phase 1: run DFS on GR to compute reverse postorder.
Phase 2: run DFS on G, considering vertices in order given by first DFS.

DFS in original digraph G

check unmarked vertices in the order

1 0 2 4 5 3 11 9 12 10 6 7 8
dfs(1) dfs(0) dfs(11) dfs(6) dfs(7)
1 done dfs(5) check 4 check 9 check 6
dfs(4) dfs(12) check 4 check 9
dfs(3) dfs(9) dfs(8) 7 done
check 5 check 11 check 6 check 8
dfs(2) dfs(10) 8 done
check 0 check 12 check 0
check 3 10 done 6 done
2 done 9 done
3 done 12 done
check 2 11 done
4 done check 9
5 done check 12
check 1 check 10
0 done
check 2
check 4
check 5
check 3

63
Kosaraju-Sharir algorithm

Proposition. Kosaraju-Sharir algorithm computes the strong components of

a digraph in time proportional to E + V.

Pf.
Running time: bottleneck is running DFS twice (and computing GR).
Correctness: tricky, see textbook (2nd printing).
Implementation: easy!

64
Connected components in an undirected graph (with DFS)

public class CC
{
private boolean marked[];
private int[] id;
private int count;

public CC(Graph G)
{
marked = new boolean[G.V()];
id = new int[G.V()];

for (int v = 0; v < G.V(); v++)

{
if (!marked[v])
{
dfs(G, v);
count++;
}
}
}

private void dfs(Graph G, int v)

{
marked[v] = true;
id[v] = count;
for (int w : G.adj(v))
if (!marked[w])
dfs(G, w);
}

public boolean connected(int v, int w)

{ return id[v] == id[w]; }
}
65
Strong components in a digraph (with two DFSs)

public class KosarajuSharirSCC

{
private boolean marked[];
private int[] id;
private int count;

public KosarajuSharirSCC(Digraph G)
{
marked = new boolean[G.V()];
id = new int[G.V()];
DepthFirstOrder dfs = new DepthFirstOrder(G.reverse());
for (int v : dfs.reversePost())
{
if (!marked[v])
{
dfs(G, v);
count++;
}
}
}

private void dfs(Digraph G, int v)

{
marked[v] = true;
id[v] = count;
for (int w : G.adj(v))
if (!marked[w])
dfs(G, w);
}

public boolean stronglyConnected(int v, int w)

{ return id[v] == id[w]; }
}
66
Digraph-processing summary: algorithms of the day

single-source
reachability DFS
in a digraph

topological sort
DFS
in a DAG

0
6
7 8
strong 1 2 Kosaraju-Sharir
components 9 10
DFS (twice)
in a digraph 3
4
11 12
5

67
 4.2 D IRECTED G RAPHS
‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu
Algorithms R OBERT S EDGEWICK | K EVIN W AYNE

4.2 D IRECTED G RAPHS

‣ introduction
‣ digraph API
‣ digraph search
Algorithms
‣ topological sort
F O U R T H E D I T I O N

R OBERT S EDGEWICK | K EVIN W AYNE

‣ strong components
http://algs4.cs.princeton.edu