Graphs
● A graph G = (V, E)
■ V = set of vertices, E = set of edges
■ Dense graph: |E|  |V|2; Sparse graph: |E|  |V|
■ Undirected graph:
○ Edge (u,v) = edge (v,u)
○ No self-loops
■ Directed graph:
○ Edge (u,v) goes from vertex u to vertex v, notated uv
■ A weighted graph associates weights with either
the edges or the vertices
David Luebke
1
5/29/2016
Directed and Undirected Graph
2
2016/5/29
Representing Graphs
● Assume V = {1, 2, …, n}
● An adjacency matrix represents the graph as a
n x n matrix A:
■ A[i, j] = 1 if edge (i, j)  E (or weight of edge)
= 0 if edge (i, j)  E
■ Storage requirements: O(V2)
○ A dense representation
■ But, can be very efficient for small graphs
○ Especially if store just one bit/edge
○ Undirected graph: only need one diagonal of matrix
David Luebke
3
5/29/2016
Adjacency-matrix representation for directed graph
It is NOT symmetric.
1
4
2
5
(a)
3
6
1
2
3
4
5
6
1
0
1
0
1
0
0
2
0
0
0
0
1
0
3
0
0
0
0
1
1
4
0
1
0
0
0
0
5
0
0
0
1
0
0
6
0
0
0
0
0
1
(c)
4
2016/5/29
Adjacency-list representation for directed
graph
1
4
2
5
(a)
3
6
1
1,2
2
2,5 /
3
3,6
4
4,2
/
5
5,4
/
6
6,6
/
1,4
/
3,5
/
(b)
5
2016/5/29
Graph Searching
● Given: a graph G = (V, E), directed or
undirected
● Goal: methodically explore every vertex and
every edge
● Ultimately: build a tree on the graph
■ Pick a vertex as the root
■ Choose certain edges to produce a tree
■ Note: might also build a forest if graph is not
connected
David Luebke
6
5/29/2016
Breadth-First Search
● “Explore” a graph, turning it into a tree
■ One vertex at a time
■ Expand frontier of explored vertices across the
breadth of the frontier
● Builds a tree over the graph
■ Pick a source vertex to be the root
■ Find (“discover”) its children, then their children,
etc.
David Luebke
7
5/29/2016
Breadth-First Search
● Again will associate vertex “colors” to guide
the algorithm
■ White vertices have not been discovered
○ All vertices start out white
■ Grey vertices are discovered but not fully explored
○ They may be adjacent to white vertices
■ Black vertices are discovered and fully explored
○ They are adjacent only to black and gray vertices
● Explore vertices by scanning adjacency list of
grey vertices
David Luebke
8
5/29/2016
Review: Breadth-First Search
BFS(G, s) {
initialize vertices;
Q = {s};
// Q is a queue (duh); initialize to s
while (Q not empty) {
u = RemoveTop(Q);
for each v  u.adj {
if (v.color == WHITE)
v.color = GREY;
v.d = u.d + 1;
What does v->d represent?
v.p = u;
What does v->p represent?
Enqueue(Q, v);
}
u->color = BLACK;
}
}
David Luebke
9
5/29/2016
Breadth-First Search: Example
David Luebke
r
s
t
u








v
w
x
y
10
5/29/2016
Breadth-First Search: Example
r
s
t
u

0






v
w
x
y
Q: s
David Luebke
11
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0



1


v
w
x
y
Q: w
David Luebke
r
12
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2


1
2

v
w
x
y
Q: r
David Luebke
t
x
13
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2

2
1
2

v
w
x
y
Q:
David Luebke
t
x
v
14
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2
3
2
1
2

v
w
x
y
Q: x
David Luebke
v
u
15
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: v
David Luebke
u
y
16
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: u
David Luebke
y
17
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: y
David Luebke
18
5/29/2016
Breadth-First Search: Example
r
s
t
u
1
0
2
3
2
1
2
3
v
w
x
y
Q: Ø
David Luebke
19
5/29/2016
BFS: The Code Again
BFS(G, s) {
Touch every vertex: O(V)
initialize vertices;
Q = {s};
while (Q not empty) {
u = RemoveTop(Q);
u = every vertex, but only once
for each v  u.adj {
(Why?)
if (v.color == WHITE)
So v = every vertex v.color = GREY;
v.d = u.d + 1;
that appears in
some other vert’s v.p = u;
Enqueue(Q, v);
adjacency list
}
What will be the running time?
u->color = BLACK;
}
Total running time: O(V+E)
}
David Luebke
20
5/29/2016
Breadth-First Search: Properties
● BFS calculates the shortest-path distance to
the source node
● BFS builds breadth-first tree, in which paths to
root represent shortest paths in G
■ Thus can use BFS to calculate shortest path from
one vertex to another in O(V+E) time
David Luebke
21
5/29/2016
Depth-First Search
● Depth-first search is another strategy for
exploring a graph
■ Explore “deeper” in the graph whenever possible
■ Edges are explored out of the most recently
discovered vertex v that still has unexplored edges
■ When all of v’s edges have been explored,
backtrack to the vertex from which v was
discovered
David Luebke
22
5/29/2016
Depth-First Search
● Vertices initially colored white
● Then colored gray when discovered
● Then black when finished
David Luebke
23
5/29/2016
Depth-First Search: The Code
DFS(G)
{
for each vertex u  V
{
u.color = WHITE;
}
time = 0;
for each vertex u  V
{
if (u.color == WHITE)
DFS_Visit(u);
}
}
David Luebke
DFS_Visit(u)
{
u.color = GREY;
time = time+1;
u.d = time;
for each v  u.Adj
{
if (v.color == WHITE)
DFS_Visit(v);
}
u.color = BLACK;
time = time+1;
u.f = time;
}
24
5/29/2016
Depth-First Search: The Code
DFS(G)
{
for each vertex u  G->V
{
u->color = WHITE;
}
time = 0;
for each vertex u  G->V
{
if (u->color == WHITE)
DFS_Visit(u);
}
}
DFS_Visit(u)
{
u->color = GREY;
time = time+1;
u->d = time;
for each v  u->Adj[]
{
if (v->color == WHITE)
DFS_Visit(v);
}
u->color = BLACK;
time = time+1;
u->f = time;
}
What does u->d represent?
David Luebke
25
5/29/2016
Depth-First Search: The Code
DFS(G)
{
for each vertex u  G->V
{
u->color = WHITE;
}
time = 0;
for each vertex u  G->V
{
if (u->color == WHITE)
DFS_Visit(u);
}
}
DFS_Visit(u)
{
u->color = GREY;
time = time+1;
u->d = time;
for each v  u->Adj[]
{
if (v->color == WHITE)
DFS_Visit(v);
}
u->color = BLACK;
time = time+1;
u->f = time;
}
What does u->f represent?
David Luebke
26
5/29/2016
Depth-First Search: The Code
DFS(G)
{
for each vertex u  G->V
{
u->color = WHITE;
}
time = 0;
for each vertex u  G->V
{
if (u->color == WHITE)
DFS_Visit(u);
}
}
DFS_Visit(u)
{
u->color = GREY;
time = time+1;
u->d = time;
for each v  u->Adj[]
{
if (v->color == WHITE)
DFS_Visit(v);
}
u->color = BLACK;
time = time+1;
u->f = time;
}
Will all vertices eventually be colored black?
David Luebke
27
5/29/2016
Depth-First Search: The Code
DFS(G)
{
for each vertex u  G->V
{
u->color = WHITE;
}
time = 0;
for each vertex u  G->V
{
if (u->color == WHITE)
DFS_Visit(u);
}
}
DFS_Visit(u)
{
u->color = GREY;
time = time+1;
u->d = time;
for each v  u->Adj[]
{
if (v->color == WHITE)
DFS_Visit(v);
}
u->color = BLACK;
time = time+1;
u->f = time;
}
What will be the running time?
David Luebke
28
5/29/2016
Depth-First Search: The Code
DFS(G)
{
for each vertex u  G->V
{
u->color = WHITE;
}
time = 0;
for each vertex u  G->V
{
if (u->color == WHITE)
DFS_Visit(u);
}
}
DFS_Visit(u)
{
u->color = GREY;
time = time+1;
u->d = time;
for each v  u->Adj[]
{
if (v->color == WHITE)
DFS_Visit(v);
}
u->color = BLACK;
time = time+1;
u->f = time;
}
So, running time of DFS = O(V+E)
David Luebke
29
5/29/2016
Depth-First Search Analysis
● This running time argument is an informal
example of amortized analysis
■ “Charge” the exploration of edge to the edge:
○ Each loop in DFS_Visit can be attributed to an edge in
the graph
○ Runs once/edge if directed graph, twice if undirected
○ Thus loop will run in O(E) time, algorithm O(V+E)

Considered linear for graph, b/c adj list requires O(V+E) storage
■ Important to be comfortable with this kind of
reasoning and analysis
David Luebke
30
5/29/2016
DFS Example
source
vertex
David Luebke
31
5/29/2016
DFS Example
source
vertex
d
f
1 |
|
|
|
|
David Luebke
|
|
32
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
|
2 |
|
|
David Luebke
|
|
33
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
|
2 |
|
3 |
David Luebke
|
|
34
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
|
2 |
|
3 | 4
David Luebke
|
|
35
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
|
2 |
|
3 | 4
David Luebke
|
5 |
36
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
|
2 |
|
3 | 4
David Luebke
|
5 | 6
37
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
8 |
2 | 7
|
3 | 4
David Luebke
|
5 | 6
38
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
8 |
2 | 7
|
3 | 4
David Luebke
|
5 | 6
39
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
8 |
2 | 7
|
9 |
3 | 4
5 | 6
|
What is the structure of the grey vertices?
What do they represent?
David Luebke
40
5/29/2016
DFS Example
source
vertex
d
f
1 |
8 |
2 | 7
9 |10
3 | 4
David Luebke
|
5 | 6
41
|
5/29/2016
DFS Example
source
vertex
d
f
1 |
8 |11
2 | 7
9 |10
3 | 4
David Luebke
|
5 | 6
42
|
5/29/2016
DFS Example
source
vertex
d
f
1 |12
8 |11
2 | 7
9 |10
3 | 4
David Luebke
|
5 | 6
43
|
5/29/2016
DFS Example
source
vertex
d
f
1 |12
8 |11
2 | 7
9 |10
3 | 4
David Luebke
13|
5 | 6
44
|
5/29/2016
DFS Example
source
vertex
d
f
1 |12
8 |11
2 | 7
9 |10
3 | 4
David Luebke
13|
5 | 6
45
14|
5/29/2016
DFS Example
source
vertex
d
f
1 |12
8 |11
2 | 7
9 |10
3 | 4
David Luebke
13|
5 | 6
46
14|15
5/29/2016
DFS Example
source
vertex
d
f
1 |12
8 |11
2 | 7
9 |10
3 | 4
David Luebke
13|16
5 | 6
47
14|15
5/29/2016
DFS And Cycles
● How would you modify the code to detect cycles?
DFS(G)
{
for each vertex u  G.V
{
u.color = WHITE;
}
time = 0;
for each vertex u  V
{
if (u.color == WHITE)
DFS_Visit(u);
}
}
David Luebke
DFS_Visit(u)
{
u.color = GREY;
time = time+1;
u->d = time;
for each v  u.Adj[]
{
if (v.color == WHITE)
DFS_Visit(v);
}
u->color = BLACK;
time = time+1;
u->f = time;
}
48
5/29/2016
DFS And Cycles
● What will be the running time?
DFS(G)
{
for each vertex u  V
{
u.color = WHITE;
}
time = 0;
for each vertex u  V
{
if (u.color == WHITE)
DFS_Visit(u);
}
}
David Luebke
DFS_Visit(u)
{ u.color = GREY;
time = time+1;
u.d = time;
for each v  u.Adj
{
if(v.coclor == grey)
cycle exist.
if (v.color == WHITE)
DFS_Visit(v);
}
u.color = BLACK;
time = time+1;
u.f = time;
}
49
5/29/2016
DFS And Cycles
● What will be the running time?
● A: O(V+E)
● We can actually determine if cycles exist in
O(V) time:
■ In an undirected acyclic forest, |E|  |V| - 1
■ So count the edges: if ever see |V| distinct edges,
must have seen a back edge along the way
David Luebke
50
5/29/2016