Graph Algorithms

Lec-15
Applied Algo, MS 2003 (Fall)

1
Graphs

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

2
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
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 multi-graph 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
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
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
Graphs: Adjacency Matrix

 Example:
A 1 2 3 4
1
a 1

2 d
4 2
Symmetric or un-symmetric?
3
b c
??
3 4

7
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
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

9
Breadth First Search
 In any application where you need to perform some
function on all the nodes connected to a given node;

 If you were trying to determine if there is a path from one

vertex to another;

 Implementing some sort of network, where you would

want to make sure that every vertex could be reached
from every other vertex.

 In short, in any situation where connectivity is important.

10
Breadth First Search: Word ladder
"flame" and "flake" are neighbors, but "plays" and "yelps" are not.

DS used with 5,757 words and 28,270 edges?

11
Review: Breadth-First Search
 Given a G=(V,E) and distinguished source vertex s,
BFS systematically explores the edges of G to
“discover” every vertex reachable from s.

 Creates a BFS tree rooted at s that contains all such

vertices.

 Expands the frontier between discovered and

undiscovered vertices uniformly across the breadth of
the frontier.

 The algorithm discovers all vertices at distance k from s

before discovering any vertices at distance k+1
12
Review: 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 and represent the frontier
between the discovered and the undiscovered.
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

13
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;
v->p = u;
Enqueue(Q, v);
}
u->color = BLACK;
}
}
14
Review: Breadth-First Search: Example

r s t u

   

   
v w x y

15
Breadth-First Search: Example
r s t u

 0  

   
v w x y

Q: s
16
Breadth-First Search: Example
r s t u

1 0  

 1  
v w x y

Q: w r
17
Breadth-First Search: Example
r s t u

1 0 2 

 1 2 
v w x y

Q: r t x
18
Breadth-First Search: Example
r s t u

1 0 2 

2 1 2 
v w x y

Q: t x v
19
Breadth-First Search: Example
r s t u

1 0 2 3

2 1 2 
v w x y

Q: x v u
20
Breadth-First Search: Example
r s t u

1 0 2 3

2 1 2 3
v w x y

Q: v u y
21
Breadth-First Search: Example
r s t u

1 0 2 3

2 1 2 3
v w x y

Q: u y
22
Breadth-First Search: Example
r s t u

1 0 2 3

2 1 2 3
v w x y

Q: y
23
Breadth-First Search: Example
r s t u

1 0 2 3

2 1 2 3
v w x y

Q: Ø
24
 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 vertexv->color = GREY;
that appears in v->d = u->d + 1;
v->p = u;
some other vert’s Enqueue(Q, v);
adjacency }list
u->color = BLACK;
What will be the running time?
}
} Total running time: O(V+E)
25
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 graph?
}
} Total space used:
O(max(degree(v))) = O(E) 26
Breadth-First Search: Properties
 BFS calculates the shortest-path distance to the
source node
Shortest-path distance (s,v) = minimum number of edges
from s to v, or  if v not reachable from s
Proof given in the book (p. 472-5)

 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

27