ITCS 6114

Graph Algorithms

1 12/11/2018
 Graphs

● A graph G = (V, E)
■ V = set of vertices
■ E = set of edges = subset of V  V
■ Thus |E| = O(|V|2)

2 12/11/2018
 Graph Variations

● Variations:
■ A connected graph has a path from every vertex to
every other
■ In an undirected graph:
○ Edge (u,v) = edge (v,u)
○ No self-loops
■ In a directed graph:
○ Edge (u,v) goes from vertex u to vertex v, notated uv

3 12/11/2018
 Graph Variations

● More variations:
■ A weighted graph associates weights with either
the edges or the vertices
○ E.g., a road map: edges might be weighted w/ distance
■ A multigraph allows multiple edges between the
same vertices
○ E.g., the call graph in a program (a function can get
called from multiple points in another function)

4 12/11/2018
 Graphs

● We will typically express running times in

terms of |E| and |V| (often dropping the |’s)
■ If |E|  |V|2 the graph is dense
■ If |E|  |V| the graph is sparse
● If you know you are dealing with dense or
sparse graphs, different data structures may
make sense

5 12/11/2018
 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

6 12/11/2018
 Graphs: Adjacency Matrix

● Example:
A 1 2 3 4
1
a 1

2 d
4 2
3
b c
??
3 4

7 12/11/2018
 Graphs: Adjacency Matrix

● Example:
A 1 2 3 4
1
a 1 0 1 1 0

2 d
4 2 0 0 1 0
b c 3 0 0 0 0
3 4 0 0 1 0

8 12/11/2018
 Graphs: Adjacency Matrix

● How much storage does the adjacency matrix

require?
● A: O(V2)
● What is the minimum amount of storage
needed by an adjacency matrix representation
of an undirected graph with 4 vertices?
● A: 6 bits
■ Undirected graph  matrix is symmetric
■ No self-loops  don’t need diagonal
9 12/11/2018
 Graphs: Adjacency Matrix

● The adjacency matrix is a dense representation

■ Usually too much storage for large graphs
■ But can be very efficient for small graphs
● Most large interesting graphs are sparse
■ E.g., planar graphs, in which no edges cross, have
|E| = O(|V|) by Euler’s formula
■ For this reason the adjacency list is often a more
appropriate respresentation

10 12/11/2018
 Graphs: Adjacency List

● Adjacency list: for each vertex v  V, store a

list of vertices adjacent to v
● Example:
1
■ Adj[1] = {2,3}
■ Adj[2] = {3}
2 4
■ Adj[3] = {}
■ Adj[4] = {3}
3
● Variation: can also keep
a list of edges coming into vertex
 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
12 12/11/2018
 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.

13 12/11/2018
 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
14 12/11/2018
 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;
}
}
15 12/11/2018
Breadth-First Search: Example

r s t u

   

   
v w x y

16 12/11/2018
Breadth-First Search: Example

r s t u

 0  

   
v w x y

Q: s
17 12/11/2018
Breadth-First Search: Example

r s t u

1 0  

 1  
v w x y

Q: w r

18 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 

 1 2 
v w x y

Q: r t x

19 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 

2 1 2 
v w x y

Q: t x v

20 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 3

2 1 2 
v w x y

Q: x v u

21 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 3

2 1 2 3
v w x y

Q: v u y

22 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 3

2 1 2 3
v w x y

Q: u y

23 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 3

2 1 2 3
v w x y

Q: y
24 12/11/2018
Breadth-First Search: Example

r s t u

1 0 2 3

2 1 2 3
v w x y

Q: Ø
25 12/11/2018
 BFS: The Code Again
BFS(G, s) {
initialize vertices; Touch every vertex: O(V)
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;
that appears in v->d = u->d + 1;
some other vert’s v->p = u;
adjacency list Enqueue(Q, v);
}
u->color = BLACK; What will be the running time?
} Total running time: O(V+E)
}
26 12/11/2018
 BFS: The Code Again
BFS(G, s) {
initialize vertices;
Q = {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;
v->p = u;
Enqueue(Q, v);
} What will be the storage cost
u->color = BLACK; in addition to storing the tree?
} Total space used:
} O(max(degree(v))) = O(E)
27 12/11/2018