Lecture 6 - Graphs

Graphs
• Extremely useful tool in modeling problems
• Consist of:
• Vertices
• Edges
Vertices can be
D considered “sites”
E or locations.

C Edges represent
A connections.
F
B
Vertex
Edge
Applications
Air flight system

• Each vertex represents a city

• Each edge represents a direct flight between two cities
• A query on direct flights becomes a query on whether an edge exists
• A query on how to get to a location is “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”
 Another application
• Wireless communication

• Can be represented by a weighted complete graph (every two vertices are

connected by an edge).
• Each edge represents the Euclidean distance dij between two stations.
• Each station uses a certain power i to transmit messages. Given this power i,
only a few nodes can be reached (bold edges). A station reachable by i then
use its own power to relay the message to other stations not reachable by i.
• A typical wireless communication problem is: how to broadcast between all
stations such that they are all connected and the power consumption
is minimized.
 Definition
• Undirected graph
• An undirected graph is specified by an ordered pair (V,E), where V is the
set of vertices and E is the set of edges

{a,b} {a,c}

{b,d} {c,d}

{b,e} {c,f}

{e,f}
 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.

3. {v1, v2} = {v2, v1}*

*Later, we will talk about “directed graphs”, where edges have direction. This
means that {v1,v2} ≠ {v2,v1} . Directed graphs are drawn with arrows (called arcs)
between edges. A B This means {A,B} only, not {B,A}
 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

• 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
• An array entry A [i] [j] is equal to 1 if there is an edge connecting
vertices i and j. Otherwise, A [i] [j] is 0.
• The storage requirement is Θ(n2). Not efficient if the graph has few edges.
• We can detect in O(1) time whether two vertices are connected.
 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 (as with adjacency matrix)

• The list A[i] stores the ids of the vertices adjacent to i.

Examples

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 0 1 0 0 1 0 0 0 1 0
2 9
3 0 1 0 0 1 1 0 0 0 0
1
4 0 0 1 1 0 0 0 0 0 0
3 7 5 0 0 0 1 0 0 1 0 0 0
6 6 0 0 0 0 0 1 0 1 0 0
4
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
Examples

0 8
0
1 2 3 7 9
8
2 1 4 8
3
2 1 4 5
9 4
1 2 3
5
3 6
3 7 6
5 7
6 7
4 1 6
5 8
0 2 9
9
1 8
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

• An edge e={u,v} of the graph contributes a count of 1 to deg(u) and contributes

a count 1 to deg(v)

• Therefore, Σvertex vdeg(v) = 2m, where m is the total number of edges

• In all, the adjacency list takes up Θ(n+m) space.

• If m = O(n2), both adjacent matrix and adjacent lists use Θ(n2) space.
• If m = O(n), adjacent list outperform adjacent matrix

• However, one cannot tell in O(1) time whether two vertices are connected.
 Adjacency Lists vs. Matrix
• Adjacency Lists
• 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
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

• For 0 ≤ i < k-1, vi ≠ vi+2

That is, the edge {vi, vi+1} ≠ {vi+1, vi+2}

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

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 if some vertex appears twice or more

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 Traversal

• Application example
• 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

• Let’s first look at BFS . . .

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

Why use queue? Need FIFO

Example
Adjacency List Visited Table (T/F)
0 F

1 F
0
2 F
8 3 F

4 F
source 2 9 5 F

1 6 F

7 F

3 7 8 F
6 9 F
4
5
Initialize visited
table (all False)

Q= { }

Initialize Q to be empty
 Example
Adjacency List Visited Table (T/F)
0 F

1 F
0
2 T
8 3 F

4 F
source 2 9 5 F

1 6 F

7 F

3 7 8 F
6 9 F
4
5
Flag that 2 has
been visited.

Q= { 2 }

Place source 2 on the queue.

 Example
Adjacency List Visited Table (T/F)
0 F

1 T
0
2 T
Neighbors
8 3 F

4 T
source 2 9 5 F

1 6 F

7 F

3 7 8 T
6 9 F
4
5
Mark neighbors
as visited.

Q = {2} → { 8, 1, 4 }
Dequeue 2.
Place all unvisited neighbors of 2 on the queue
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 F

4 T
source 2 9 5 F

1 6 F

7 F

3 7 8 T
Neighbors
6 9 T
4
5
Mark new visited
Neighbors.

Q = { 8, 1, 4 } → { 1, 4, 0, 9 }

Dequeue 8.
-- Place all unvisited neighbors of 8 on the queue.
-- Notice that 2 is not placed on the queue again, it has been visited!
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0 Neighbors
2 T
8 3 T

4 T
source 2 9 5 F

1 6 F

7 T

3 7 8 T
6 9 T
4
5
Mark new visited
Neighbors.

Q = { 1, 4, 0, 9 } → { 4, 0, 9, 3, 7 }

Dequeue 1.
-- Place all unvisited neighbors of 1 on the queue.
-- Only nodes 3 and 7 haven’t been visited yet.
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T

4 T
Neighbors
source 2 9 5 F

1 6 F

7 T

3 7 8 T
6 9 T
4
5

Q = { 4, 0, 9, 3, 7 } → { 0, 9, 3, 7 }

Dequeue 4.
-- 4 has no unvisited neighbors!
Example
Adjacency List Visited Table (T/F)
0 T
Neighbors
1 T
0
2 T
8 3 T

4 T
source 2 9 5 F

1 6 F

7 T

3 7 8 T
6 9 T
4
5

Q = { 0, 9, 3, 7 } → { 9, 3, 7 }

Dequeue 0.
-- 0 has no unvisited neighbors!
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T

4 T
source 2 9 5 F

1 6 F

7 T

3 7 8 T
6 Neighbors 9 T
4
5

Q = { 9, 3, 7 } → { 3, 7 }

Dequeue 9.
-- 9 has no unvisited neighbors!
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T
Neighbors
4 T
source 2 9 5 T

1 6 F

7 T

3 7 8 T
6 9 T
4
5
Mark new visited
Vertex 5.

Q = { 3, 7 } → { 7, 5 }

Dequeue 3.
-- place neighbor 5 on the queue.
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T

4 T
source 2 9 5 T

1 6 T

Neighbors 7 T

3 7 8 T
6 9 T
4
5
Mark new visited
Vertex 6.

Q = { 7, 5 } → { 5, 6 }

Dequeue 7.
-- place neighbor 6 on the queue.
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T

4 T
source 2 9 Neighbors 5 T

1 6 T

7 T

3 7 8 T
6 9 T
4
5

Q = { 5, 6} → { 6 }

Dequeue 5.
-- no unvisited neighbors of 5.
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T

4 T
source 2 9 5 T

1 Neighbors 6 T

7 T
3 7
8 T
6
4 9 T
5

Q= {6}→{ }

Dequeue 6.
-- no unvisited neighbors of 6.
Example
Adjacency List Visited Table (T/F)
0 T

1 T
0
2 T
8 3 T

4 T
source 2 9 5 T

1 6 T

7 T

3 7 8 T
6 9 T
4
5

What did we discover?

Look at “visited” tables.

Q= { } STOP!!! Q is empty!!!
There exists a path from source
vertex 2 to all vertices in the graph.
 Time Complexity of BFS
(Using adjacency list)
• Assume adjacency list
• n = number of vertices m = number of edges

O(n + m)

Each vertex will enter Q at most once.

Each iteration takes time proportional to deg(v)

+ 1 (the number 1 is to include the case where
deg(v) = 0).
Running time

• Given a graph with m edges, what is the total degree?

Σvertex v deg(v) = 2m

• The total running time of the while loop is:

O( Σvertex v (deg(v) + 1) ) = O(n+m)

this is summing over all the iterations in the while loop!

 Time Complexity of BFS
(Using adjacency matrix)
• Assume adjacency list
• n = number of vertices m = number of edges

O(n2)

Finding the adjacent vertices of v requires

checking all elements in the row. This takes
linear time O(n).

Summing over all the n iterations, the total

running time is O(n2).

So, with adjacency matrix, BFS is O(n2)

independent of number of edges m.
With adjacent lists, BFS is O(n+m); if m=O(n2)
like a dense graph, O(n+m)=O(n2).
Shortest Path Recording

• BFS we saw only tells us whether a path exists from source s,

to other vertices v.
• It doesn’t tell us the path!
• We need to modify the algorithm to record the path.

• How can we do that?

• Note: we do not know which vertices lie on this path until we reach v!
• Efficient solution:
• Use an additional array pred[0..n-1]
• Pred[w] = v means that vertex w was visited from v
BFS + Path Finding

initialize all pred[v] to -1

Record where you

came from
Example
Adjacency List Visited Table (T/F)
0 F -

1 F -
0
2 F -
8 3 F -

4 F -
source 2 9 5 F -

1 6 F -

7 F -

3 7 8 F -
6 9 F -
4
5 Pred
Initialize visited
table (all False)

Q= { } Initialize Pred to -1

Initialize Q to be empty
Example
Adjacency List Visited Table (T/F)
0 F -

1 F -
0
2 T -
8 3 F -

4 F -
source 2 9 5 F -

1 6 F -

7 F -

3 7 8 F -
6 9 F -
4
5 Pred
Flag that 2 has
been visited.

Q= { 2 }

Place source 2 on the queue.

Example
Adjacency List Visited Table (T/F)
0 F -

1 T 2
0
2 T -
Neighbors
8 3 F -

4 T 2

source 2 9 5 F -

-
1 6 F

7 F -

3 7 8 T 2
6 9 F -
4
5 Pred
Mark neighbors
as visited.

Q = {2} → { 8, 1, 4 } Record in Pred

that we came
Dequeue 2.
from 2.
Place all unvisited neighbors of 2 on the queue
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 F -

4 T 2
source 2 9 5 F -

1 6 F -

7 F -

3 7 Neighbors 8 T 2
6 9 T 8
4
5 Pred
Mark new visited
Neighbors.

Q = { 8, 1, 4 } → { 1, 4, 0, 9 } Record in Pred
that we came
Dequeue 8.
from 8.
-- Place all unvisited neighbors of 8 on the queue.
-- Notice that 2 is not placed on the queue again, it has been visited!
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0 Neighbors
2 T -

8 3 T 1

4 T 2

source 2 9 5 F -

-
1 6 F

7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred
Mark new visited
Neighbors.

Q = { 1, 4, 0, 9 } → { 4, 0, 9, 3, 7 } Record in Pred
that we came
Dequeue 1.
from 1.
-- Place all unvisited neighbors of 1 on the queue.
-- Only nodes 3 and 7 haven’t been visited yet.
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 T 1

4 T 2
Neighbors
source 2 9 5 F -

1 6 F -

7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred

Q = { 4, 0, 9, 3, 7 } → { 0, 9, 3, 7 }

Dequeue 4.
-- 4 has no unvisited neighbors!
Example
Adjacency List Visited Table (T/F)
0 T 8
Neighbors
1 T 2
0
2 T -
8 3 T 1

4 T 2
source 2 9 5 F -

1 6 F -

7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred

Q = { 0, 9, 3, 7 } → { 9, 3, 7 }

Dequeue 0.
-- 0 has no unvisited neighbors!
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 T 1

4 T 2
source 2 9 5 F -

1 6 F -

7 T 1

3 7 8 T 2
6 Neighbors 9 T 8
4
5 Pred

Q = { 9, 3, 7 } → { 3, 7 }

Dequeue 9.
-- 9 has no unvisited neighbors!
Example
Adjacency List Visited Table (T/F)
0 T
8
1 T
0 2
2 T
-
8 3 T
Neighbors 1
4 T
2
source 2 9 5 T
3

1 6 F
-
7 T
1
3 7 8 T
2
6 9 T
4 8
5
Pred
Mark new visited
Vertex 5.
Q = { 3, 7 } → { 7, 5 }
Record in Pred
Dequeue 3. that we came
-- place neighbor 5 on the queue. from 3.
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 T 1

4 T 2
source 2 9 5 T 3

1 6 T 7

Neighbors 7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred
Mark new visited
Vertex 6.
Q = { 7, 5 } → { 5, 6 }
Record in Pred
Dequeue 7. that we came
-- place neighbor 6 on the queue. from 7.
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 T 1

4 T 2
source 2 9 Neighbors 5 T 3

1 6 T 7

7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred

Q = { 5, 6} → { 6 }

Dequeue 5.
-- no unvisited neighbors of 5.
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 T 1

4 T 2
source 2 9 5 T 3

1 Neighbors
6 T 7

7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred

Q= {6}→{ }

Dequeue 6.
-- no unvisited neighbors of 6.
Example
Adjacency List Visited Table (T/F)
0 T 8

1 T 2
0
2 T -
8 3 T 1

4 T 2
source 2 9 5 T 3

1 6 T 7

7 T 1

3 7 8 T 2
6 9 T 8
4
5 Pred

Pred now can be traced backward

Q= { } STOP!!! Q is empty!!! to report the path!
Path reporting

nodes visited from

0 8

1 2

2 -

3 1

4 2

5 3

6 7

7 1

8 2

9 8

Try some examples, report path from s to v:

Path(0) ->
Path(6) ->
Path(1) ->
The path returned is the shortest from s to v (minimum
number of edges).
BFS tree

• The paths found by BFS is often drawn as a rooted tree (called BFS tree),
with the starting vertex as the root of the tree.
BFS tree for vertex s=2.

Question: What would a “level” order traversal tell you?

How do we record the shortest
distances?

d(v) = ;

d(s) = 0;

d(w)=d(v)+1;
Application of BFS

• One application concerns how to find

connected components in a graph

• If a graph has more than one connected components, BFS builds a

BFS-forest (not just BFS-tree)!
• Each tree in the forest is a connected component.