Shortest Paths Credit Dr George Bebis 2 Shortest Path Problems How can we find the shortest route between two points on a road map Model the problem as a graph problem Road map is a weighted graph ID: 759767
Download Presentation The PPT/PDF document "CS 253: Algorithms Chapter 24" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.
Slide1
CS 253: Algorithms
Chapter 24Shortest Paths
Credit
: Dr. George
Bebis
Slide22
Shortest Path Problems
How can we find the shortest route between two points on a road map?
Model
the problem as a graph problem:
Road map is a weighted graph:
vertices
= cities
edges
= road segments between cities
edge weights
= road distances
Goal: find a shortest path between two vertices (cities)
Slide3Shortest Path Problem
Input:Directed graph G = (V, E)Weight function w : E → RWeight of path p = v0, v1, . . . , vkShortest-path weight from u to v: δ(u, v) = min w(p) : u v if there exists a path from u to v ∞ otherwise Note: there might be multiple shortest paths from u to v
p
0
3
9
5
11
3
6
5
7
6
s
t
x
y
z
2
2
1
4
3
Slide44
Negative-Weight Edges
Negative-weight edges may form negative-weight cyclesIf such cycles are reachable from the source, then δ(s, v) is not properly defined!Keep going around the cycle, and get w(s, v) = - for all v on the cycleTherefore, negative-weight edges will not be considered here
0
3
-4
2
8
-6
s
a
b
e
f
-3
y
3
5
6
4
7
c
d
g
Slide5Cycles
Can shortest paths contain cycles
?
No!
Negative-weight cycles
Shortest path is not well
defined (
we will not consider this case
)
If there is a positive-weight cycle, we
can get a shorter path
by removing the cycle.
Zero-weight cycles?
No reason to use them
Can remove them
and obtain
a path with
the same
weight
Slide6Shortest-Paths Notation
For each vertex v V:δ(s, v): shortest-path weightd[v]: shortest-path weight estimateInitially, d[v]=∞d[v]δ(s,v) as algorithm progresses[v] = predecessor of v on a shortest path from sIf no predecessor, [v] = NIL induces a tree—shortest-path tree
0
3
9
5
11
3
6
5
7
6
s
t
x
y
z
2
2
1
4
3
Slide77
Initialization
Alg.:
INITIALIZE-SINGLE-SOURCE(V, s)
for
each v
V
do
d[v] ←
[v] ← NIL
d[s] ← 0
All the shortest-paths algorithms start with INITIALIZE-SINGLE-SOURCE
Slide8Relaxation Step
Relaxing an edge (u, v) = testing whether we can improve the shortest path to v found so far by going through u If d[v] > d[u] + w(u, v) we can improve the shortest path to v d[v]=d[u]+w(u,v) [v] ← u
5
9
2
u
v
5
7
2
u
v
RELAX(u, v, w)
5
6
2
u
v
5
6
2
u
v
RELAX(u, v, w)
After
relaxation:
d[v
]
d[u] + w(u, v)
s
s
no change
Slide9Dijkstra’s Algorithm
Single-source shortest path problem:
No negative-weight edges: w(u, v) > 0,
(u, v)
E
Vertices
in
(V
–
S)
reside in a
min-priority queue
Keys in Q are estimates of shortest-path weights d[u]
Repeatedly select a vertex u
(V
–
S),
with the minimum shortest-path estimate
d[u]
Relax all edges leaving u
STEPS
Extract a vertex
u
from Q (i.e., u has the highest priority)
Insert
u
to S
Relax all edges leaving
u
Update Q
Slide1010
Dijkstra (G, w, s)
0
10
1
5
2
s
t
x
y
z
2
3
9
7
4
6
0
10
1
5
2
s
t
x
y
z
2
3
9
7
4
6
10
5
S=<>
Q
=<
s,t,x,z,y
>
S=<s> Q=<
y,t,x,z
>
Slide11Example (cont.)
0
10
5
10
1
5
2
s
t
x
y
z
2
3
9
7
4
6
8
14
7
0
8
14
5
7
10
1
5
2
s
t
x
y
z
2
3
9
7
4
6
13
S=<
s,y
>
Q
=<
z,t,x
>
S=<
s,y,z
>
Q
=<
t,x
>
Slide12Example (cont.)
0
8
13
5
7
10
1
5
2
s
t
x
y
z
2
3
9
7
4
6
9
0
8
9
5
7
10
1
5
2
s
t
x
y
z
2
3
9
7
4
6
S=<
s,y,z,t
>
Q
=<x>
S=<
s,y,z,t,x
>
Q
=<>
Slide13Dijkstra (G, w, s)
INITIALIZE-SINGLE-SOURCE(V, s)S ← sQ ← V[G] while Q do u ← EXTRACT-MIN(Q) S ← S {u} for each vertex v Adj[u] do RELAX(u, v, w) Update Q (DECREASE_KEY)
(V)
(V) build min-heap
Executed (V) times
(
lgV
)
(
E
) times (max)
(
lgV)
(
VlgV
)
(
ElgV)
Running time:
(
VlgV
+
ElgV
) =
(
ElgV
)
Slide14Dijkstra’s
SSSP Algorithm (adjacency matrix)
b
a
d
c
f
e
1
1
1
5
5
3
2
4
2
a b c d e f
a
0 1 3
2
b
1 0 5 1
c
3 5 0 2 1 d 1 2 0 4 e 1 4 0 5f 2 5 0
a b c d e f L [.] = 1 0 5 1
S
new L[
i
] =
Min
{ L[
i
], L[k] + W[k,
i
] }
where k is the newly-selected intermediate node
and W[.] is the distance between k and
i
Slide15b
a
d
c
f
e
1
1
1
5
5
3
2
4
2
a b c d e f
a
0 1 3
2
b
1 0 5 1
c
3 5 0 2 1
d 1 2 0 4 e 1 4 0 5f 2 5 0
a b c d e f L [.] = 1 0 5 1
a
b c d e f
new L [.] = 1 0 3 1 5
SSSP cont.
new L[
i
] =
Min
{ L[
i
], L[k] + W[k,
i
] }
where k is the newly-selected intermediate node
and W[.] is the distance between k and
i
Slide16b
a
d
c
f
e
1
1
1
5
5
3
2
4
2
a b c d e f
a
0 1 3
2
b
1 0 5 1
c
3 5 0 2 1
d 1 2 0 4 e 1 4 0 5f 2 5 0
a
b c d e f L [.] = 1 0 3 1 5
a
b c d e f new L [.] = 1 0 3 1 5 3
new L[
i
] =
Min
{ L[
i
], L[k] + W[k,
i
] }
where k is the newly-selected intermediate node
and W[.] is the distance between k and
i
Slide17b
a
d
c
f
e
1
1
1
5
5
3
2
4
2
a b c d e f
a
0 1 3
2
b
1 0 5 1
c
3 5 0 2 1
d
1 2 0 4 e 1 4 0 5f 2 5 0
a
b c d e f L [.] = 1 0 3 1 5 3
a
b c d e f new L [.] = 1 0 3 1 4 3
Slide18b
a
d
c
f
e
1
1
1
5
5
3
2
4
2
a b c d e f
a
0 1 3
2
b
1 0 5 1
c
3 5 0 2 1
d
1 2 0 4 e 1 4 0 5f 2 5 0
a
b c d e f L [.] = 1 0 3 1 4 3
a
b c d e f new L [.] = 1 0 3 1 4 3
Slide19b
a
d
c
f
e
1
1
1
5
5
3
2
4
2
a b c d e f
a
0 1 3
2
b
1 0 5 1
c
3 5 0 2 1
d
1 2 0 4
e 1 4 0 5f 2 5 0
a
b c d e f L [.] = 1 0 3 1 4 3
a
b c d e f new L [.] = 1 0 3 1 4 3
Running time:
(V2) (array representation) (ElgV) (Min-Heap+Adjacency List)
Which one is better?
Slide20All-Pairs Shortest Paths
Given:Directed graph G = (V, E)Weight function w : E → RCompute: The shortest paths between all pairs of vertices in a graphResult: an n × n matrix of shortest-path distances δ(u, v)We can run Dijkstra’s algorithm once from each vertex:O(VElgV) with binary heap and adjacency-list representationif the graph is dense O(V3lgV)We can achieve O(V3) by using an adjacency-matrix.
1
2
3
5
4
3
3
7
6
2
4
1
9
8
Slide2121
Problem 1
We
are given a directed graph G=(V
, E
) on which each edge (
u,v
) has an associated value r(
u,v
), which is a real number in the range
0
≤ r(
u,v
)
≤ 1
that represents the
reliability
of a communication channel from vertex u to vertex v.
We
interpret r(
u,v
) as the probability that the channel from u to v will not fail, and we assume that these probabilities are independent.
Design an
efficient algorithm to find the most reliable path between two given vertices.
Slide2222
Problem 1 (cont.)
r(
u,v
)
=
Pr
(
channel from u to v will not fail
)
Assuming that the probabilities are independent, the reliability of a path p=<v
1
,v
2
,…,
v
k
> is:
r(v
1
,v
2
) r(v
2
,v
3
) … r(v
k-1
,v
k
)
Solution
1
:
modify
Dijkstra’s
algorithm
Perform relaxation as follows:
if
d[v] < d[u] w(
u,v
) then
d[v] = d[u] w(
u,v
)
Use “EXTRACT_MAX” instead of “EXTRACT_MIN”
Slide23Problem 1 (cont.)
Solution 2: use Dijkstra’s algorithm without any modifications!We want to find the channel with the highest reliability, i.e., But Dijkstra’s algorithm computesTake the log
Slide24Problem 1 (cont.)
Turn this into a minimization problem by taking the negative:Run Dijkstra’s algorithm using