6.006- Introduction to Algorithmscourses.csail.mit.edu/6.006/fall10/lectures/lecture16.pdf · –...
Transcript of 6.006- Introduction to Algorithmscourses.csail.mit.edu/6.006/fall10/lectures/lecture16.pdf · –...
6.006- Introduction to Algorithms
Lecture 16 Prof. Patrick Jaillet
Lecture overview Shortest paths III
– Bellman-Ford on a DAG (CLRS 24.2)
– Dijkstra algorithm for the case with non-negative weights (CLRS 24.3)
4
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
5
6
6
1
4
1 6
2
v1 v4
v2
-4
5
2
v3 2
This graph has a special structure: DAG. How to use it within Bellman-Ford?
E={(v1,v2); (v1,v4); (v2,v3); (v4,v2)}
v1 v4
v2
-4
5
2
v3 2
... from lecture 15: think about it for next time ...
... first use topological sorting ...
E={(v1,v2); (v1,v4); (v2,v3); (v4,v2)}
v1 v4
v2
-4
5
2
v3 2
v1 v2
v3
-4
5
2
v4 2
E={(v1,v2); (v1,v3); (v2,v3); (v3,v4)}
... Bellman-Ford ...
E={(v1,v2); (v1,v3); (v2,v3); (v3,v4)}
v1 v2
v3
-4
5
2
v4 2
0
∞ ∞
∞
2 ⁄ ⁄ 3
⁄ 5
1 ⁄ end of first iteration
the shortest paths from v1
and we are done !
Bellman-Ford algorithm on DAG
d[s] ← 0; π[s] ← s for each v ∈ V – {s}
do d[v] ← ∞; π[v] ← nil initialization
do for each edge (u, v) ∈ E do if d[v] > d[u] + w(u, v) then d[v] ← d[u] + w(u, v) π[v] ← u
one iteration of relaxation steps
for each edge (u, v) ∈ E do if d[v] > d[u] + w(u, v) then report a negative cycle
final steps not needed
O(n)
O(m)
topologically sort the vertices V ( f: V → {1, 2, …, |V |} such that (u,v) ∈ E ⇒ f (u) < f (v)) O(n+m) arrange E in lexicographical order of (f(e.a), f(e.b))
e.a e.be
... why does this work? ...
• there are no cycles in a dag => even with negative-weight edges, there are no negative-weight cycles ...
• topological ordering implies a linear ordering of the vertices; every path in a dag is a subsequence of topologically sorted vertex order; processing vertices in that order, an edge can’t be relaxed more than once ...
The case of non-negative weights Problem: Given a directed graph G = (V, E) with edge-weight function w : E → R+, and a node s, find the shortest-path weight δ(s, v) (and a corresponding shortest path) from s to each v in V.
Greedy iterative approach 1. maintain a set S of vertices whose shortest-path
distances from s are known. 2. at each step add to S the vertex v ∈ V – S whose
distance estimate from s is minimal. 3. update distance estimates of vertices adjacent to v.
Dijkstra’s algorithm d[s] ← 0 for each v ∈ V – {s}
do d[v] ← ∞ S ← ∅ Q ← V while Q ≠ ∅
do u ← EXTRACT-MIN(Q) S ← S ∪ {u} for each v ∈ Adj[u]
do if d[v] > d[u] + w(u, v) then d[v] ← d[u] + w(u, v)
relaxation steps
(Implicit DECREASE-KEY)
initialization
(Q min-priority queue maintaining V – S)
[Digression - Min- Priority Queue (see Lect 9)]
This is an abstract datatype implementing a set S of elements, each associated with a key, supporting the following operations:
decrease_key(S, x, k) :
insert element x into set S
return element of S with smallest key
return element of S with smallest key and remove it from S
change the key-value of element x to the value k (assumed to not larger than current value)
insert(S, x) :
min(S) :
extract_min(S) :
Dijkstra: Example
7 (∝,-)
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(∝,-)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
initialization (∝,-)
Q =V, a = EXTRACT-MIN(Q)
Dijkstra: Example 7 (∝,-)
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(5,a)
(8,a)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
1st iteration (3,a)+
(10,b)
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(3,a)+
(8,a)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
2nd iteration
(5,a)+
Dijkstra: Example
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(3,a)+ (10,b)
(9,d)
(∝,-)
(∝,-)
(∝,-)
(∝,-)
3rd iteration
(5,a)+
(7,d)+
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(5,a)+
(3,a)+
(7,d)+
(10,b)
(15,c)
(∝,-)
(∝,-)
(∝,-)
4th iteration
(9,d)+
Dijkstra: Example
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(3,a)+
(9,d)+
(15,c)
(∝,-)
(13,g)
(∝,-)
5th iteration
(5,a)+
(7,d)+
(10,b)+
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(5,a)+
(3,a)+
(7,d)+
(10,b)+
(15,c)
(16,f)
(∝,-)
6th iteration
(9,d)+ (13,g)+
Dijkstra: Example
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(3,a)+
(9,d)+
(16,f)
(13,g)+
(19,i)
7th iteration
(5,a)+
(7,d)+
(10,b)+
(14,i)+
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(5,a)+
(3,a)+
(7,d)+
(10,b)+
(14,i)+ (19,i)
8th iteration
(9,d)+ (13,g)+
(15,e)+
Dijkstra: Example
a
b
d
c
g
f
e h
i
j 3
8
5
5
2
7
5
8
4
5
6
6
1
4
1 6
2
(0,*)+
(3,a)+
(9,d)+
(15,e)+
(13,g)+
9th iteration
(17,h)+
(5,a)+
(7,d)+
(10,b)+
(14,i)+
(10,b)+
a
b
d
c
g
f
e h
i
j 3
5 2
7
4
1
4
1
2
(0,*)+
(5,a)+
(3,a)+
(7,d)+
(9,d)+
(14,i)+
(15,e)+
(13,g)+
(17,h)+
Shortest-path tree
Correctness — Part I Lemma. Initializing d[s] ← 0 and d[v] ← ∞ for all v ∈ V – {s} establishes d[v] ≥ δ(s, v) for all v ∈ V, and this invariant is maintained over any sequence of relaxation steps.
s u
v
d[u] w(u, v)
d[v]
Proof. Recall relaxation step:
if d[v] > d[u] + w(u, v) set d[v] ← d[u] + w(u, v)
Correctness — Part II Theorem. Dijkstra’s algorithm terminates with d[v] = δ(s, v) for all v ∈ V. Proof. • It suffices to show that d[v] = δ(s, v) for every v ∈ V when v is added to S • Suppose u is the first vertex added to S for which d[u] ≠ δ(s, u) . Let y be the first vertex in V – S along a shortest path from s to u, and let x be its predecessor:
s x
y
u
S, just before adding u.
Correctness — Part II (continued)
• Since u is the first vertex violating the claimed invariant, we have d[x] = δ(s, x) • Since subpaths of shortest paths are shortest paths, it follows that d[y] was set to δ(s, x) + w(x, y) = δ(s, y) just after x was added to S • Consequently, we have d[y] = δ(s, y) ≤ δ(s, u) < d[u] • But, d[y] ≥ d[u] since the algorithm chose u first => a contradiction
s x y
u S