CE 221
Data Structures and Algorithms
Chapter 9 : Graphs Part I
(Topological Sort & Shortest Path
Algorithms)
Text: Read Weiss, §9.1 – 9.3
Izmir University of Economics
1
Definitions - I
• A graph G=(V, E) consists of a set of vertices,
V, and a set of edges, E.
• Each edge is a pair (v, w), where v, w є V.
• If the pair is ordered then G is directed
(digraph).
• Vertex w is adjacent to v iff (v, w) є E.
• In an undirected graph with edge (v, w), w is
adjacent to v and v is adjacent to w.
• Sometimes and edge has a third component,
weight or cost.
Izmir University of Economics
2
Definitions - II
• A path in a graph is w1, w2,...,wN such that
(wi, wi+1) є E for 1≤i<N. The length of such
a path is the number of edges on the path.
If a path from a vertex to itself contains no
edges, then the path length is zero. If G
contains an edge (v, v), then the path v, v
is called a loop.
• A simple path is a path such that all
vertices are distinct, except that the first
and the last could be the same.
Izmir University of Economics
3
Definitions - III
• A cycle in a directed graph is a path of length at
least 1 such that w1=wN. This cycle is simple if the
path is simple. For undirected graphs, the edges are
required to be distinct (Why?).
• A directed graph is acyclic if it has no cycles (DAG).
• An undirected graph is connected if there is a path
from every vertex to every other vertex. A directed
graph with this property is called strongly
connected. If directed graph is not, but underlying
undirected graph is, it is weakly connected. A
complete graph is a graph in which there is an
edge between every pair of vertices.
Izmir University of Economics
4
Representation of Graphs - I
• One simple way is to use a twodimensional array (adjacency matrix
representation). If vertices are numbered
starting at 1, A[u][v]=true if (u, v) є E.
Space requirement is Θ(|V|2).
• If the graph is not dense (sparse),
adjacency lists may be used. The space
requirement is O(|E|+|V|).
Izmir University of Economics
5
Representation of Graphs - II
Izmir University of Economics
6
Topological Sort - I
•A topological sort is an ordering of vertices
in a DAG, such that if there is path from vi to
vj, then vj appears after vi in the ordering.
•A simple algorithm to find a topological
ordering is first to find any vertex with no
incoming edges. We can then print this vertex,
and remove it, along with its edges. Then apply
the same strategy to the rest of the graph. To
formalize this, define the indegree of a vertex
v as the number of edges (u, v).
Izmir University of Economics
7
Topological Sort – Initial Attempt
• running time of
the algorithm is
O(|V|2).
Izmir University of Economics
8
Topological Sort – A Better Algorithm
• We can remove the inefficiency by
keeping all the unassigned vertices
of indegree 0 in a special data
structure (queue or stack). When a
new vertex with degree zero is
needed, it is returned by removing
one from the queue, and when the
indegrees of adjacent vertices are
decremented, they are inserted into
the queue if the indegree falls to
zero. The running time is O(|E|+|V|)
Izmir University of Economics
9
Homework Assignments
• 9.1, 9.2, 9.3, 9.4, 9.38
• You are requested to study and solve the
exercises. Note that these are for you to
practice only. You are not to deliver the
results to me.
Izmir University of Economics
10
Shortest-Path Algorithms
• The input is a weighted graph: associated
with each edge (vi, vj) is a cost ci,j. The cost
of a path v1v2...vN is ∑ci,i+1 for i in [1..N-1].
This is weighted path length.
• Unweighted path length is merely the
number of edges on the path, namely, N-1.
• Single-source Shortest-Path Problem:
Given as input a weighted graph G=(V, E),
and a distinguished vertex, s, find the
shortest weighted path from s to every other
vertex in G.
Izmir University of Economics
11
Negative Cost Cycles
• In the graph to the left, the shortest path from v1 to v6 has a
cost of 6 and the path itself is v1v4v7v6. The shortest
unweighted path has 2 edges (v1 - v4) and (v4 - v6).
• In the graph to the right, we have a negative cost. The path
from v5 to v4 has cost 1, but a shorter path exists by following
the loop v5v4v2v5v4 which has cost -5. This path is still not the
shortest, because we could stay in the loop arbitrarily long.
Izmir University of Economics
12
Shortest Path Length: Problems
We will examine 4 algorithms to solve four versions of
the problem
1. Unweighted shortest path  O(|E|+|V|)
2. Weighted shortest path without negative edges 
O(|E|log|V|) using queues
3. Weighted shortest path with negative edges
O(|E| . |V|)

4. Weighted shortest path of acyclic graphs  linear
time
Izmir University of Economics
13
Unweighted Shortest Paths
• Using some vertex, s, which is an input
parameter, find the shortest path from s to all
other vertices in an unweighted graph. Assume
s=v3.
Izmir University of Economics
14
Unweighted Shortest Paths
• Algorithm: find vertices that are at
distance 1, 2, ... N-1 by processing
vertices in layers (breadth-first search)
Izmir University of Economics
15
Unweighted Shortest Paths
Izmir University of Economics
16
Unweighted Shortest Paths
• Complexity O(|V|2)
Izmir University of Economics
17
Unweighted Shortest Paths - Improvement
• At any point in time there
are only two types of
unknown vertices that
have dv≠∞. Some have
dv = currDist and the rest
have dv = currDist +1.
• We can make use of a
queue data structure.
• O(|E|+|V|)
Izmir University of Economics
18
Weighted Shortest Path Dijkstra’s
Algorithm
• With weighted shortest path,distance dv is
tentative. It turns out to be the shortest path
length from s to v using only known vertices as
intermediates.
• Greedy algorithm: proceeds in stages doing the
best at each stage. Dijkstra’s algorithm selects a
vertex v with smallest dv among all unknown
vertices and declares it known. Remainder of the
stage consists of updating the values dw for all
edges (v, w).
Izmir University of Economics
19
Dijkstra’s Algorithm - Example
►
►
►
Izmir University of Economics
20
Dijkstra’s Algorithm - Example
►
►
►
►
• A proof by contradiction will show that this
algorithm always works as long as no
edge has a negative cost.
Izmir University of Economics
21
Dijkstra’s Algorithm - Pseudocode
• If the vertices are
sequentially scanned to
find minimum dv, each
phase will take O(|V|) to
find the minimum, thus
O(|V|2) over the course
of the algorithm.
• The time for updates is
constant and at most
one update per edge for
a total of O(|E|).
• Therefore the total time
spent is O(|V|2+|E|).
• If the graph is dense,
OPTIMAL.
Izmir University of Economics
22
Dijkstra’s Algorithm-What if the graph
is sparse?
• If the graph is sparse |E|=θ(|V|), algorithm is too
slow. The distances of vertices need to be kept
in a priority queue.
• Selection of vertex with minimum distance via
deleteMin, and updates via decreaseKey
operation. Hence; O(|E|log|V|+|V|log|V|)
• find operations are not supported, so you need
to be able to maintain locations of di in the heap
and update them as they change.
• Alternative: insert w and dw with every update.
Izmir University of Economics
23
Graphs with negative edge costs
• Dijkstra’s algorithm does not work with
negative edge costs. Once a vertex u is
known, it is possible that from some other
unknown vertex v, there is a path back to
u that is very negative.
• Algorithm: A combination of weighted and
unweighted algorithms. Forget about the
concept of known vertices.
Izmir University of Economics
24
Graphs with negative edge costs - I
• O(|E|*|V|). Each vertex
can dequeue at most
O(|V|) times. (Why?
Algorithm computes
shortest paths with at
most 0, 1, ..., |V|-1 edges
in this order). Hence, the
result!
• If negative cost cycles,
then each vertex should
be checked to have been
dequeued at most |V|
times.
Izmir University of Economics
25
Acyclic Graphs
• If the graph is known to be acyclic, the
order in which vertices are declared
known, can be set to be the topological
order.
• Running time = O(|V|+|E|)
• This selection rule works because when a
vertex is selected, its distance can no
longer be lowered, since by topological
ordering rule it has no incoming edges
emanating from unknown nodes.
Izmir University of Economics
26
Shortest Path Algorithm for
Weighted Non-negative
Undirected Graphs
Dijkstra’s Example
By Joe James
Dijkstra Example
Problem: Find the shortest
distance from source S to all other
vertices given in the graph.
Step 1: Initialize distances from
source (S) to all other vertices. We
immedietely see the neighbors A,
D,and C of S.
Dijkstra Example
Step 2: Relax all out-edges from S.
Trace the neighbours of S and
compute the shortest distance to them
Step 3: Choose the closest
vertex to move to, which is D,
i.e., 5 < 6 < 8.
Dijkstra Example
Step 4: Relax all out-edges
from D
Step 5: Check out (relax) the shortest
out-edge out of D, which is D-A = 2.
Dijkstra Example
Step 6: Add the current distance (S-D) to the shortest out-edge of D,
which is D-A = 2. Now the shortest distance from S to A is 7 via vertex D
Dijkstra Example
Step 8: C is the next nearest vertex from S
Step 7: Process all the distances
from S to all out-edges of D.
C has anly one out-edge remaining, which
is C-F. The distance S-F via C is 9+6 and
via D is 5+4. Thus, C is also done.
Dijkstra Example
Step 9: The next shortest distance
from S to its neighbors is now A.
Step 10: A has one out-edge (A-E) left.
Hence, Distance from S to E over A is 8.
A is done and we jump to E, which has
two out-edges to relax, E-B and E-G.
Dijkstra Example
Step 11: We are done with E and
move to F, because it is the closest
node to the source that we have’nt
visited yet.
Step 12: F has one out-edge (F-G). So
we move to G. G has no edge to relax so
we move to B.
Dijkstra Example
Step 13: G has no edge to relax so we move to B, which also has no
edges to relax. So, we are done. This finalizes the shortest path from
sorurce S to every other vertices in the weighted graph.
Another Example of Dijkstra's
Shortest Path Algorithm
• Find shortest path from s to t.
24
2
9
s
3
18
14
6
2
6
30
11
4
19
5
15
5
6
16
20
7
36
44
t
Dijkstra's Shortest Path Algorithm
S={ }
PQ = { s, 2, 3, 4, 5, 6, 7, t }


0
s
24
2
9
18

14
3
6
2
6

30

11
4
19
5
15
5
6
16
20
7
37
distance
label

44
t

Dijkstra's Shortest Path Algorithm
S={ }
PQ = { s, 2, 3, 4, 5, 6, 7, t }
Here
0
s


24
2
9
18

14
3
6
2
6

30

11
4
19
5
15
5
6
16
20
7
38
distance
label

44
t

Dijkstra's Shortest Path Algorithm
S={s}
PQ = { 2, 3, 4, 5, 6, 7, t }
Node
discovered
X 9

0
s

24
2
9
18
X 14

14
3
6
2
6

30

11
4
19
5
15
5
6
16
20
7
39
distance
label
X
 15
44
t

Dijkstra's Shortest Path Algorithm
S={s}
PQ = { 2, 3, 4, 5, 6, 7, t }
Here

X 9

0
s
24
2
9
18
X 14

14
3
6
2
6

30

11
4
19
5
15
5
6
16
20
7
40
distance
label
X
 15
44
t

Dijkstra's Shortest Path Algorithm
S = { s, 2 }
PQ = { 3, 4, 5, 6, 7, t }

X 9

9
0
s
24
2
18
X 14

14
3
6
2
6

30

11
4
19
5
15
5
6
16
20
7
41
X
 15
44
t

Dijkstra's Shortest Path Algorithm
S = { s, 2 }
PQ = { 3, 4, 5, 6, 7, t }
Node
discovered
X
 33
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6

30

11
4
19
5
15
5
6
16
20
7
42
X
 15
44
t

Dijkstra's Shortest Path Algorithm
S = { s, 2 }
PQ = { 3, 4, 5, 6, 7, t }
X
 33
X 9

9
0
s
24
2
3
Here
18
X 14

14
6
2
6

30

11
4
19
5
15
5
6
16
20
7
43
X
 15
44
t

Dijkstra's Shortest Path Algorithm
S = { s, 2, 6 }
PQ = { 3, 4, 5, 7, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30

44
X

11
4
19
5
15
5
6
16
20
7
44
X
 15
44
t

Dijkstra's Shortest Path Algorithm
S = { s, 2, 6 }
PQ = { 3, 4, 5, 7, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30

44
X

11
4
19
5
15
5
6
16
20
7
45
X
 15
44
Here
t

Dijkstra's Shortest Path Algorithm
S = { s, 2, 6, 7 }
PQ = { 3, 4, 5, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 35
X


11
4
19
5
15
5
6
16
20
7
46
X
 15
44
t

59 X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 6, 7 }
PQ = { 3, 4, 5, t }
Here
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 35
X


11
4
19
5
15
5
6
16
20
7
47
X
 15
44
t

59 X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 6, 7 }
PQ = { 4, 5, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X


11
4
19
5
15
5
6
16
20
7
48
X
 15
44
t
51 59

X X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 6, 7 }
PQ = { 4, 5, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X


11
4
19
5
15
5
6
20
7
49
X
 15
16
Here
44
t
51 59

X X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 5, 6, 7 }
PQ = { 4, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X

45 X

11
4
19
5
15
5
6
16
20
7
50
X
 15
44
t
50 51

X 59
X X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 5, 6, 7 }
PQ = { 4, t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
30
44
X 34
X 35
X

45 X

4
11
5
15
6
2
19
Here
5
6
16
20
7
51
X
 15
44
t
50 51

X 59
X X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7 }
PQ = { t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X

45 X

11
4
19
5
15
5
6
16
20
7
52
X
 15
44
t
50 51

X 59
X X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7 }
PQ = { t }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X

45 X

11
4
19
5
15
5
6
16
20
7
53
X
 15
t
44
Here
50 51

X 59
X X
Dijkstra's SShortest
Path Algorithm
= { s, 2, 3, 4, 5, 6, 7, t }
PQ = { }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X

45 X

11
4
19
5
15
5
6
16
20
7
54
X
 15
44
t
50 51

X 59
X X
Dijkstra's Shortest Path Algorithm
S = { s, 2, 3, 4, 5, 6, 7, t }
PQ = { }
32
X
 33
X
X 9

9
0
s
24
2
18
X 14

14
3
6
2
6
30
44
X 34
X 35
X

45 X

11
4
19
5
15
5
6
16
20
7
55
X
 15
44
t
50 51

X 59
X X
The Algoritm
• 1. Assign to every node a distance value.
Set it to zero for our initial node and to
infinity (-9999) for all other nodes.
• 2. Mark all nodes as unvisited. Set initial
node as current.
• 3. For current node, consider all its
unvisited neighbors and calculate their
distance (from the initial node). For
example, if current node (A) has distance
56
of 6, and an edge connecting it with
Pseudo Code of the Dijkstra’s Alg
• Algorithm Dijkstra(Graph, source):
• for each vertex v in Graph:
// Initializations
•
dist[v] := infinity
// Unknown distance function from source to v
•
previous[v] := undefined
// Previous node in optimal path from source
•
dist[source] := 0
// Distance from source to source
•
Q := the set of all nodes in Graph
•
// All nodes in the graph are unoptimized - thus are in Q
• while Q is not empty:
// The main loop
•
u:= dequeue (Q) // u := vertex in Q with smallest dist[]
•
if dist[u] = infinity:
•
break
// all remaining vertices are inaccessible from source
•
dequeue(u,Q) // remove u from Q
•
for each neighbor v of u: // where v has not yet been removed from Q.
•
alt := dist[u] + dist_between(u, v) // Dist. from start point to neighbor
•
if alt < dist[v]:
// Relax (u,v)
•
dist[v] := alt
57
•
previous[v] := u
•
return dist
Homework Assignments
• 9.5, 9.7, 9.10, 9.40, 9.42, 9.44, 9.46, 9.47,
9.52
• You are requested to study and solve the
exercises. Note that these are for you to
practice only. You are not to deliver the
results to me.
Izmir University of Economics
58