Week12 graph

Terminologies
V = {a,b,c,d,e,f}
E = {{a,b},{a,c},{b,d},
{c,d},{b,e},{c,f},
{e,f}}
• V1 is adjacent to v2 if and only if {v1,v2} ϵ E
• V1 is incident on e1 if an edge, e1, is connected
to a vertex, v1

Representation of Graph
• Adjacency matrix
– Use 2-dimensional matrix
• Adjacency list
– Use 1-dimensional array of Linked-list

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]=1 if there is an edge connecting vertices i and j.
Otherwise, A[i][j]=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
• 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.

Graph / Slide 6
Adjacency Matrix
2
4
3
5
1
7
6
9
8
0
0 1 2 3 4 5 6 7 8 9
0 0 0 0 0 0 0 0 0 1 0
1 0 0 1 1 0 0 0 1 0 1
2 0 1 0 0 1 0 0 0 1 0
3 0 1 0 0 1 1 0 0 0 0
4 0 0 1 1 0 0 0 0 0 0
5 0 0 0 1 0 0 1 0 0 0
6 0 0 0 0 0 1 0 1 0 0
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 / Slide 7
Adjacency List
2
4
3
5
1
7
6
9
8
0

Adjacency Matrix vs. Adjacency List
Adjacency Matrix
• Always require n2 space
• waste a lot of space if
the number of edges
are sparse
• Can quickly find if an
edge exists
Adjacency List
• More compact than
adjacency matrices if
graph has few edges
• Requires more time to
find if an edge exists

Path
• A path is a sequence of vertices
(v0,v1,v2,…,vk) such that {vk,vk+1} ϵ E
for 0 ≤ i < k.
• The length of path is the number of edges on
the path

Types of Path
• Simple path:
– if and only if it does not contain a vertex more
than once
• Cycle:
– if and only if v0= vk
– Beginning and end are the same vertex
A path contains a cycle if some vertex appears twice or
more

Graph traversal
1. Breadth First Search (BFS)
• Finding the shortest path
• …
2. Depth First Search (DFS)
• Topological sort
• Find cycle
• …

Graph / Slide 13
BFS + Path Finding
initialize all pred[v] to -1
Record where you
came from

Graph / Slide 14
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited
Table
(T/F)
F
F
F
F
F
F
F
F
F
F
Q = { }
Initialize visited
table (all False)
Initialize Pred to -1
Initialize Q to be empty
-1
1
-1
-1
-1
-1
-1
-1
-1
-1
Pred

Graph / Slide 15
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
F
F
T
F
F
F
F
F
F
F
Q = { 2 }
Flag that 2 has
been visited.
Place source 2 on the queue.
-
-
-
-
-
-
-
-
-
-
Pred

Graph / Slide 16
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
F
T
T
F
T
F
F
F
T
F
Q = {2} → { 8, 1, 4 }
Mark neighbors
as visited.
Record in Pred
that we came
from 2.
Dequeue 2.
Place all unvisited neighbors of 2 on the queue
Neighbors
-
2
-
-
2
-
-
-
2
-
Pred

Graph / Slide 17
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
F
T
F
F
F
T
T
Q = { 8, 1, 4 } → { 1, 4, 0, 9 }
Mark new visited
Neighbors.
Record in Pred
that we came
from 8.
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!
Neighbors
8
2
-
-
2
-
-
-
2
8
Pred

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

Graph / Slide 19
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
F
F
T
T
T
Q = { 4, 0, 9, 3, 7 } → { 0, 9, 3, 7 }
Dequeue 4.
-- 4 has no unvisited neighbors!
Neighbors
8
2
-
1
2
-
-
1
2
8
Pred

Graph / Slide 20
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
F
F
T
T
T
Q = { 0, 9, 3, 7 } → { 9, 3, 7 }
Dequeue 0.
Neighbors
8
2
-
1
2
-
-
1
2
8
Pred

Graph / Slide 21
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
F
F
T
T
T
Q = { 9, 3, 7 } → { 3, 7 }
Dequeue 9.
Neighbors
8
2
-
1
2
-
-
1
2
8
Pred

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

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

Graph / Slide 24
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
Q = { 5, 6} → { 6 }
Dequeue 5.
-- no unvisited neighbors of 5.
Neighbors
8
2
-
1
2
3
7
1
2
8
Pred

Graph / Slide 25
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
Q = { 6 } → { }
Dequeue 6.
-- no unvisited neighbors of 6.
Neighbors
8
2
-
1
2
3
7
1
2
8
Pred

Graph / Slide 26
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
Q = { } STOP!!! Q is empty!!!
Pred now can be traced backward
to report the path!
8
2
-
1
2
3
7
1
2
8
Pred

Graph / Slide 27
Path reporting
8
2
-
1
2
3
7
1
2
8
0
1
2
3
4
5
6
7
8
9
nodes visited from
Try some examples, report path from s to w:
myNode2.Path(0) =
myNode2.Path(6) =
myNode2.Path(1) =
The path returned is the shortest from s to w
(minimum number of edges).
w pred[w]

Graph / Slide 28
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?
8
2
-
1
2
3
7
1
2
8
0
1
2
3
4
5
6
7
8
9
nodes visited from
w pred[w]

Graph / Slide 29
DFS Algorithm
Flag all vertices as not
visited
Flag yourself as visited
For unvisited neighbors,
call RDFS(w) recursively
We can also record the paths using pred[ ].

Graph / Slide 30
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
F
F
F
F
F
F
F
F
F
F
Initialize visited
table (all False)
Initialize Pred to -1
-
-
-
-
-
-
-
-
-
-
Pred

Graph / Slide 31
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
F
F
T
F
F
F
F
F
F
F
Mark 2 as visited
-
-
-
-
-
-
-
-
-
-
Pred
RDFS( 2 )
Now visit RDFS(8)

Graph / Slide 32
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
F
F
T
F
F
F
F
F
T
F
Mark 8 as visited
mark Pred[8]
-
-
-
-
-
-
-
-
2
-
Pred
RDFS( 2 )
RDFS(8)
2 is already visited, so visit RDFS(0)
Recursive
calls

Graph / Slide 33
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
F
T
F
F
F
F
F
T
F
Mark 0 as visited
Mark Pred[0]
8
-
-
-
-
-
-
-
2
-
Pred
RDFS( 2 )
RDFS(8)
RDFS(0) -> no unvisited neighbors, return
to call RDFS(8)
Recursive
calls

Graph / Slide 34
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
F
T
F
F
F
F
F
T
F
8
-
-
-
-
-
-
-
2
-
Pred
RDFS( 2 )
RDFS(8)
Now visit 9 -> RDFS(9)
Recursive
calls
Back to 8

Graph / Slide 35
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
F
T
F
F
F
F
F
T
T
Mark 9 as visited
Mark Pred[9]
8
-
-
-
-
-
-
-
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
-> visit 1, RDFS(1)
Recursive
calls

Graph / Slide 36
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
F
F
F
F
F
T
T
Mark 1 as visited
Mark Pred[1]
8
9
-
-
-
-
-
-
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
visit RDFS(3)
Recursive
calls

Graph / Slide 37
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
F
F
F
F
T
T
Mark 3 as visited
Mark Pred[3]
8
9
-
1
-
-
-
-
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
visit RDFS(4)
Recursive
calls

Graph / Slide 38
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
RDFS(4)  STOP all of 4’s neighbors have been visited
return back to call RDFS(3)
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
F
F
F
T
T
Mark 4 as visited
Mark Pred[4]
8
9
-
1
3
-
-
-
2
8
Pred
Recursive
calls

Graph / Slide 39
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
F
F
F
T
T
8
9
-
1
3
-
-
-
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
visit 5 -> RDFS(5)
Recursive
calls
Back to 3

Graph / Slide 40
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
F
F
T
T
8
9
-
1
3
3
-
-
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
RDFS(5)
3 is already visited, so visit 6 -> RDFS(6)
Recursive
calls
Mark 5 as visited
Mark Pred[5]

Graph / Slide 41
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
F
T
T
8
9
-
1
3
3
5
-
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
RDFS(5)
RDFS(6)
visit 7 -> RDFS(7)
Recursive
calls
Mark 6 as visited
Mark Pred[6]

Graph / Slide 42
Example
2
4
3
5
1
7
6
9
8
0
Adjacency List
source
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
RDFS(5)
RDFS(6)
RDFS(7) -> Stop no more unvisited neighbors
Recursive
calls
Mark 7 as visited
Mark Pred[7]

Graph / Slide 43
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
RDFS(5)
RDFS(6) -> Stop
Recursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 44
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3)
RDFS(5) -> Stop
Recursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 45
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1)
RDFS(3) -> Stop
Recursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 46
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9)
RDFS(1) -> Stop
Recursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 47
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8)
RDFS(9) -> StopRecursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 48
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 )
RDFS(8) -> Stop
Recursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 49
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
RDFS( 2 ) -> Stop
Recursive
calls
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 50
Example
Adjacency List
0
1
2
3
4
5
6
7
8
9
Visited Table (T/F)
T
T
T
T
T
T
T
T
T
T
8
9
-
1
3
3
5
6
2
8
Pred
Try some examples.
Path(0) ->
Path(6) ->
Path(7) ->
Check our paths, does DFS find valid paths? Yes.
2
4
3
5
1
7
6
9
8
0
source

Graph / Slide 51
Time Complexity of DFS
(Using adjacency list)
 We never visited a vertex more than once
 We had to examine all edges of the vertices
 We know Σvertex v degree(v) = 2m where m is the number of
edges
 So, the running time of DFS is proportional to the
number of edges and number of vertices (same as BFS)
 O(n + m)
 You will also see this written as:
 O(|v|+|e|) |v| = number of vertices (n)
|e| = number of edges (m)

Graph / Slide 52
DFS Tree
Resulting DFS-tree.
Notice it is much “deeper”
than the BFS tree.
Captures the structure of the recursive calls
- when we visit a neighbor w of v, we add w as
child of v
- whenever DFS returns from a vertex v, we
climb up in the tree from v to its parent

Spanning tree
unweighted Graph
• Through Breadth-First-Search & Depth-First-
Search

Spanning tree
unweighted Graph

Weighted graph
https://dzone.com/articles/algorithm-week-dijkstra

Kruskal’s algorithm
T={(a, d)}

T={(a, d), (d, c)}

T={(a, d), (d, c), (d, e)}

T={(a, d), (d, c), (d, e), (d, b)}

T={(a, d), (d, c), (d, e), (d, b)}
=7 + 9 + 23 + 32 = 71

Week12 graph

More Related Content

What's hot (19)

Similar to Week12 graph (20)

More from IIUM (20)

Recently uploaded (20)

Week12 graph