1. Announcement 2:
A 2 hour midterm (open book) will be given on March (Tuesday) during the lecture time.
2018/12/4

2. Single-Source Shortest Paths
Problem Definition
Shortest paths and Relaxation
Dijkstra’s algorithm (can be viewed as a greedy algorithm)
2018/12/4

3. Find a shortest path from A to B.
-need serious thinking to get a correct algorithm.
2018/12/4

4. Directed and Undirected Graph
2018/12/4

5. Adjacency-list representation for directed graph1 2 3 4 5 6 /
1,2
2,5
3,6
4,2
5,4
1,4
3,5
6,6
(b)
(a)
2018/12/4

6. Adjacency-matrix representation for directed graph It is NOT symmetric.6 2 1 4 5 3
(a)
2018/12/4

7. Problem Definition:
Real problem: A motorist wishes to find the shortest possible route from Chicago to Boston.Given a road map of the United States on which the distance between each pair of adjacent intersections is marked, how can we determine this shortest route?
Formal definition: Given a graph G=(V, E, W), where each edge has a weight, find a shortest path from s to v for some interesting vertices s and v.
s—source
v—destination.
2018/12/4

8. The cost of the shortest path from s to v is denoted as (s, v).
The weight of path p=<v0,v1,…,vk > is the sum of the weights of its constituent edges:
The cost of the shortest path from s to v is denoted as (s, v).
2018/12/4

9. Negative-Weight edges:
Edge weight may be negative.
negative-weight cycles– the total weight in the cycle (circuit) is negative.
If no negative-weight cycles reachable from the source s, then for all v V, the shortest-path weight remains well defined,even if it has a negative value.
If there is a negative-weight cycle on some path from s to v, we define =
2018/12/4

10. a b -4 h i 3 -1 2 4 3 c d 6 8 5 -8 3 5 11 g s -3 e 3 f 2 7 j -6
Figure1 Negative edge weights in a directed graph.Shown within each vertex is its
shortest-path weight from source s.Because vertices e and f form a negative-weight
cycle reachable from s,they have shortest-path weights of Because vertex g is
reachable from a vertex whose shortest path is ,it,too,has a shortest-path weight
of Vertices such as h, i ,and j are not reachable from s,and so their shortest-path
weights are , even though they lie on a negative-weight cycle.
2018/12/4

11. Representing shortest paths:
we maintain for each vertex vV , a predecessor
[ v] that is the vertex in the shortest path
right before v.
With the values of , a backtracking process can give the shortest path. (We will discuss that after the algorithm is given)
2018/12/4

12. Observation: (basic)
Suppose that a shortest path p from a source s to a vertex v can be decomposed into
s u v
for some vertex u and path p’. Then, the weight of a shortest path from s to v is
We do not know what is u for v, but we know u is in V and we can try all nodes in V in O(n) time.
Also, if u does not exist, the edge (s, v) is the shortest.
Question: how to find (s, u), the first shortest from s to some node?
2018/12/4

13. Relaxation:
The process of relaxing an edge (u,v) consists of testing whether we can improve the shortest path to v found so far by going through u and,if so,updating d[v] and [v].
RELAX(u,v,w)
if d[v]>d[u]+w(u,v)
then d[v] d[u]+w(u,v) (based on observation)
[v] u
2018/12/4

14. u v u v 2 2 5 9 5 6 RELAX(u,v) RELAX(u,v) u v u v 2 2 5 7 5 6 (a) (b)
Figure2 Relaxation of an edge (u,v).The shortest-path estimate of each vertex
is shown within the vertex. (a)Because d[v]>d[u]+w(u,v) prior to relaxation,
the value of d[v] decreases. (b)Here, d[v] d[u]+w(u,v) before the relaxation
step,so d[v] is unchanged by relaxation.
2018/12/4

15. Initialization:
For each vertex v  V, d[v] denotes an upper bound on the weight of a shortest path from source s to v.
d[v]– will be (s, v) after the execution of the algorithm.
initialize d[v] and [v] as follows: .
INITIALIZE-SINGLE-SOURCE(G,s)
for each vertex v  V[G]
do d[v]
[v] NIL
d[s]
2018/12/4

16. Dijkstra’s Algorithm:
Dijkstra’s algorithm assumes that w(e)0 for each e in the graph.
maintain a set S of vertices such that
Every vertex v S, d[v]=(s, v), i.e., the shortest-path from s to v has been found. (Intial values: S=empty, d[s]=0 and d[v]=)
(a) select the vertex uV-S such that
d[u]=min {d[x]|x V-S}. Set S=S{u}
D[u]= (s, u) at this moment! Why?
(b) for each node v adjacent to u do RELAX(u, v, w).
Repeat step (a) and (b) until S=V.
2018/12/4

17. Continue: DIJKSTRA(G,w,s): INITIALIZE-SINGLE-SOURCE(G,s) S Q V[G]
while Q
do u EXTRACT -MIN(Q)
S S {u}
for each vertex v  Adj[u]
do RELAX(u,v,w)
2018/12/4

18. Implementation:
a adaptable priority queue Q stores vertices in V-S, keyed by their d[] values.
the graph G is represented by adjacency lists so that it takes O(1) time to find an edge (u, v) in (b).
2018/12/4

19. u v 10 5 2 1 3 4 6 9 7 8 s
Single Source Shortest Path Problem x y
(a)
2018/12/4

20. u v 1 10 8 10 9 s 2 3 4 6 7 5 5 8 2 x y
(b)
(s,x) is the shortest path using one edge. It is also the shortest path from s to x.
2018/12/4

21. Assume EXTRACT -MIN(Q)=x. (s,x) is the shortest path using one edge.
Why? Since (s, x) is the shortest among all edges starting from s.
It is also the shortest path from s to x.
Proof: (1) Suppose that path P: s->u…->x is the shortest path. Then w (s,u) w(s, x).
(2) Since edges have non-negative weight, the total weight of path P is at least w(s,u) w(s, x).
(3) So, the edge (s, x) is the shortest path from s to x.
2018/12/4

22. u v 1 8 14 10 9 s 2 3 4 6 7 5 5 7 2 x y
(c)
2018/12/4

23. u v 1 8 13 10 9 s 2 3 4 6 7 5 5 7 2 x y
(d)
2018/12/4

24. 7 9 5 8 10 2 1 3 4 6 s u v x y
(e)
2018/12/4

25. u v 1 8 9 10 9 s 2 3 4 6 7 5 5 7 2 x y
(f)
2018/12/4

26. Time complexity of Dijkstra’s Algorithm:
Time complexity depends on implementation of the adaptable priority.
Method 1: Use an array to story the Queue
EXTRACT -MIN(Q) --takes O(|V|) time.
Totally, there are |V| EXTRACT -MIN(Q)’s.
time for |V| EXTRACT -MIN(Q)’s is O(|V|2).
RELAX(u,v,w) --takes O(1) time.
Totally |E| RELAX(u, v, w)’s are required.
time for |E| RELAX(u,v,w)’s is O(|E|).
Total time required is O(|V|2+|E|)=O(|V|2)
Backtracking with [] gives the shortest path in inverse order. .
2018/12/4

27. Time complexity of Dijkstra’s Algorithm:
Time complexity depends on implementation of the adaptable priority.
Method 2: The adaptable priority queue is implemented as a heap. It takes O(log |V|) time to do EXTRACT-MIN(Q) and O(log |V|) time for each RELAX(u, v, w)’s. The total running time is O((|V|+|E|)log |V|)=O(|E|log |V|) assuming the graph is connected.
When |E| is O(|V|) the second implementation is better. If |E|=O(|V|2), then the first implementation is better.
Note that lots of maps are sparse graphs in which |E|=O(|V|).
2018/12/4

28. Method 3: The priority queue is implemented as a Fibonacci heap
Method 3: The priority queue is implemented as a Fibonacci heap. It takes O(log |V|) time to do EXTRACT-MIN(Q) and O(1) time to decrease the key value of an entry. The total running time is O(|V|log |V|+|E|). (not required)
2018/12/4

29. Adaptable Heap:
class ArrayNode { double key; String value; // value stored at this position int id; // identificsation of the entry id=1,2, 3, …, n add necessary methods here } public class MyAdaptableHeap{ protected ArrayNode T[]; // array of elements stored in the tree protected int maxEntries; // maximum number of entries protected int numEntries; //num of entries in the heap protected int location[]; // an array with size=T.length. here location[id] stores the rank of entry id in T[]. Add necessary methods here. In particular, we need Replace(id, k) (The key of entry id is updated to be key=k and we assume that the entry is already in the heap.)
Binary Search Trees

30. Array-based rep of the complete binary tree T[]
Adaptable Heap:
Replace (id, k) =replace (4, 25):
go to location[4] to find the rank=3 of entry 4 and goto T[rank]=T[3] and update T[3]=25. After change T[3] from 13 to 25, the binary tree is not a heap any more.
11/6
13/4
12/7
15/3
14/1
16/2
17/5
Array-based rep of the complete binary tree T[] 11 12 13 14 15 1 2 3 4 5 6 7 16 17
Key value
Rank of the node 4 6 5 3 7 1 2
location
id-name of a node
Binary Search Trees