Graph & BFS
Dr. Md Masbaul Alam Polash
Associate Professor
Computer Science and Engineering
Jagannath University
Graph & BFS / Slide 2
Graphs
Extremely useful tool in modeling problems
Consist of:
Vertices
Vertices can be
Edges D considered “sites”
E
or locations.
C
A Edges represent
F connections.
B
Vertex
Edge
Graph & BFS / Slide 3
Application
• Each vertex represents a city
• Each edge represents a direct
flight between two cities
• A query on direct flights = a
query on whether an edge exists
• A query on how to get to a
location = does a path exist from A
to B
• We can even associate costs to
edges (weighted graphs), then ask
“what is the cheapest path from A
to B”
Graph & BFS / Slide 4
Definition
A graph G=(V, E) consists a set of vertices, V, and a set of edges, E.
Each edge is a pair of (v, w), where v, w belongs to V
If the pair is unordered, the graph is undirected; otherwise it is directed
{a,b} {a,c}
{b,d} {c,d}
{b,e} {c,f}
{e,f}
An undirected graph
Graph & BFS / Slide 5
Terminology
1. If v1 and v2 are connected, they are said to be
adjacent vertices
v1 and v2 are endpoints of the edge {v1, v2}
2. If an edge e is connected to v, then v is said to
be incident on e. Also, the edge e is said to be
incident on v.
Graph & BFS / Slide 6
Terminology
In directed graphs, edges have direction
This means that {v ,v } ≠ {v ,v } . Directed
1 2 2 1
graphs are drawn with arrows between
edges.
This means {A,B} only, not {B,A}
A B
Graph & BFS / Slide 7
Graph Variations
Variations:
A connected graph has a path from every
vertex to every other
A complete graph is a graph in which each pair
of vertices is connected by an edge
Graph & BFS / Slide 8
Graph Variations
Variations:
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 uv
Graph & BFS / Slide 9
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)
Graph & BFS / Slide 10
Graphs
We will typically express running times in
terms of |E| and |V|
If |E| |V|2 the graph is dense
If |E| |V| the graph is sparse
Graph & BFS / Slide 11
Graph Representation
Two popular computer representations of a
graph. Both represent the vertex set and
the edge set, but in different ways.
1. Adjacency Matrix
Use a 2D matrix to represent the graph
2. Adjacency List
Use a 1D array of linked lists
Adjacency Matrix
Graph & BFS / Slide 12
2D array A[0..n-1, 0..n-1], where n is the number of vertices in the graph
Each row and column is indexed by the vertex id
e,g a=0, b=1, c=2, d=3, e=4
A[i][j]=1 if there is an edge connecting vertices i and j; otherwise, A[i][j]=0
The storage requirement is Θ(n2). It is not efficient if the graph has few edges. An
adjacency matrix is an appropriate representation if the graph is dense: |E|=Θ(|V|
2
)
We can detect in O(1) time whether two vertices are connected.
Graph & BFS / Slide 13
Adjacency List
If the graph is not dense, in other words, sparse, a better solution is an
adjacency list
The adjacency list is an array A[0..n-1] of lists, where n is the number of
vertices in the graph.
Each array entry is indexed by the vertex id
Each list A[i] stores the ids of the vertices adjacent to vertex i
Graph & BFS / Slide 14
Adjacency Matrix Example
0 0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0
8
1 0 0 1 1 0 0 0 1 0 1
2 9 2 0 1 0 0 1 0 0 0 1 0
1 3 0 1 0 0 1 1 0 0 0 0
4 0 0 1 1 0 0 0 0 0 0
3 7
6 5 0 0 0 1 0 0 1 0 0 0
4 6 0 0 0 0 0 1 0 1 0 0
5
7 0 1 0 0 0 0 1 0 0 0
8 1 0 1 0 0 0 0 0 0 1
9 0 1 0 0 0 0 0 0 1 0
Graph & BFS / Slide 15
Adjacency List Example
0 8
0
1 2 3 7 9
8
2 1 4 8
2 9 3 1 4 5
1 4 2 3
5 3 6
3 7
6 5 7
6
4 7 1 6
5
8 0 2 9
9 1 8
Graph & BFS / Slide 16
Storage of Adjacency List
The array takes up Θ(n) space
Define degree of v, deg(v), to be the number of edges
incident to v. Then, the total space to store the graph is
proportional to:
deg(v)
vertex v
Graph & BFS / Slide 17
Storage of Adjacency List
An edge e={u,v} of the graph contributes a count of 1 to
deg(u) and contributes a count 1 to deg(v)
So, Σvertex vdeg(v) = 2m, where m is the total number of edges
In all, the adjacency list takes up Θ(n+m) space
However, one cannot tell in O(1) time whether two vertices
are connected
Graph & BFS / Slide 18
Adjacency List vs. Matrix
Adjacency List
More compact than adjacency matrices if graph has few
edges
Requires more time to find if an edge exists
Adjacency Matrix
Always require n2 space
This can waste a lot of space if the number of edges are sparse
Can quickly find if an edge exists
Graph & BFS / Slide 19
Path between Vertices
A path is a sequence of vertices (v0, v1, v2,…
vk) such that:
For 0 ≤ i < k, {vi, vi+1} is an edge
Note: a path is allowed to go through the same vertex or the same
edge any number of times!
The length of a path is the number of edges
on the path
Graph & BFS / Slide 20
Types of paths
A path is simple if and only if it does
not contain a vertex more than once.
A path is a cycle if and only if v0= vk
The beginning and end are the same vertex!
A path contains a cycle as its sub-path if
some vertex appears twice or more
Graph & BFS / Slide 21
Path Examples Are these paths?
Any cycles?
What is the path’s length?
1. {a,c,f,e}
2. {a,b,d,c,f,e}
3. {a, c, d, b, d, c, f, e}
4. {a,c,d,b,a}
5. {a,c,f,e,b,d,c,a}
Graph & BFS / Slide 22
Graph Traversal
Given a graph representation and a vertex s
in the graph, find all paths from s to other
vertices
Two common graph traversal algorithms
Breadth-First Search (BFS)
Find the shortest paths in an unweighted graph
Depth-First Search (DFS)
Topological sort
Find strongly connected components
Graph & BFS / Slide 23
BFS and Shortest Path Problem
Given any source vertex s, BFS visits the other vertices at
increasing distances away from s. In doing so, BFS
discovers paths from s to other vertices
What do we mean by “distance”? The number of edges on
a path from s
Example
0
Consider s=vertex 1
8
2
Nodes at distance 1?
1 2 s 9 1 2, 3, 7, 9
1
1
Nodes at distance 2?
3 7 8, 6, 5, 4
1
6 2
4 Nodes at distance 3?
5
2 2 0
Graph & BFS / Slide 24
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
Graph & BFS / Slide 25
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.
Graph & BFS / Slide 26
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
Graph & BFS / Slide 27
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;
}
}
Graph & BFS / Slide 28
Breadth-First Search: Example
r s t u
v w x y
Graph & BFS / Slide 29
Breadth-First Search: Example
r s t u
0
v w x y
Q: s
Graph & BFS / Slide 30
Breadth-First Search: Example
r s t u
1 0
1
v w x y
Q: w r
Graph & BFS / Slide 31
Breadth-First Search: Example
r s t u
1 0 2
1 2
v w x y
Q: r t x
Graph & BFS / Slide 32
Breadth-First Search: Example
r s t u
1 0 2
2 1 2
v w x y
Q: t x v
Graph & BFS / Slide 33
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2
v w x y
Q: x v u
Graph & BFS / Slide 34
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: v u y
Graph & BFS / Slide 35
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: u y
Graph & BFS / Slide 36
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: y
Graph & BFS / Slide 37
Breadth-First Search: Example
r s t u
1 0 2 3
2 1 2 3
v w x y
Q: Ø
Graph & BFS / Slide 38
Exercise
Source Vertex: G
Graph & BFS / Slide 39
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’sv->p = u;
adjacency list Enqueue(Q, v);
}
u->color = BLACK; What will be the running time?
} Total running time: O(V+E)
}
Graph & BFS / Slide 40
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
Thank You
