Download presentation

Presentation is loading. Please wait.

Published byJulian Butler Modified over 2 years ago

1
2015-5-7chapter251 4.4 Single-Source Shortest Paths Problem Definition Shortest paths and Relaxation Dijkstra’s algorithm (can be viewed as a greedy algorithm)

2
2015-5-7chapter252 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 directed 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.

3
2015-5-7chapter253 Find a shortest path from station A to station B. -need serious thinking to get a correct algorithm. A B

4
2015-5-7chapter254 Shortest path: The weight of path p= 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).

5
2015-5-7chapter255 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 = -.

6
2015-5-7chapter256 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. 0 115 3 hi j 2 3-8 3 5 2 s -4 4 8 7 ab cd e f g 6 -3 3 -6

7
2015-5-7chapter257 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)

8
2015-5-7chapter258 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?

9
2015-5-7chapter259 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

10
2015-5-7chapter2510 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. 59 uv 57 uv 56 uv 56 uv 22 22 (a) (b) RELAX(u,v)

11
2015-5-7chapter2511 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] 0

12
2015-5-7chapter2512 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} (b) for each node v adjacent to u do RELAX(u, v, w). Repeat step (a) and (b) until S=V.

13
2015-5-7chapter2513 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)

14
2015-5-7chapter2514 Implementation: a priority queue Q stores vertices in V-S, keyed by their d[] values. the graph G is represented by adjacency lists.

15
2015-5-7chapter2515 0 10 5 2 1 34 2 6 9 7 s uv x y 88 88 (a)

16
2015-5-7chapter2516 0 5/s 10/s 10 5 2 1 34 2 6 9 7 s uv x y 8 8 (b) (s,x) is the shortest path using one edge. It is also the shortest path from s to x.

17
2015-5-7chapter2517 0 7/x 14/x 5/s 8/x 10 5 2 1 34 2 6 9 7 s uv x y (c)

18
2015-5-7chapter2518 0 7/x 13/y 5/s 8/x 10 5 2 1 34 2 6 9 7 s uv x y (d)

19
2015-5-7chapter2519 0 7/x 9/u 5/s 8/x 10 5 2 1 34 2 6 9 7 s uv x y (e)

20
2015-5-7chapter2520 0 7/x 9/u 5/s 8/x 10 5 2 1 34 2 6 9 7 s uv x y (f) Backtracking: v-u-x-s

21
2015-5-7chapter2521 Theorem: Consider the set S at any time in the algorithm’s execution. For each v S, the path P v is a shortest s-v path. Proof: We prove it by induction on |S|. 1.If |S|=1, then the theorem holds. (Because d[s]=0 and S={s}.) 2.Suppose that the theorem is true for |S|=k for some k>0. 3.Now, we grow S to size k+1 by adding the node v.

22
2015-5-7chapter2522 Proof: (continue) Now, we grow S to size k+1 by adding the node v. Let (u, v) be the last edge on our s-v path P v, i.e., d[v]=d[u]+w(u, v). Consider any other path from P: s,…,x,y, …, v. (red in the Fig.) Case 1: y is the first node that is not in S and x S. Since we always select the node with the smallest value d[] in the algorithm, we have d[v] d[y]. Moreover, the length of each edge is 0. Thus, the length of P d[y] d[v]. That is, the length of any path d[v]. s x y uv Set S Case 2: such a y does not exist. d[v]=d[u]+w(u, v) d[x]+w(x, v). That is, the length of any path d[v].

23
2015-5-7chapter2523 The algorithm does not work if there are negative weight edges in the graph. 1 2 -10 s v u S->v is shorter than s->u, but it is longer than s->u->v.

24
2015-5-7chapter2524 Time complexity of Dijkstra’s Algorithm: Time complexity depends on implementation of the Queue. 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. Method 2: The priority queue is implemented as a adaptable heap. It takes O(log n) time to do EXTRACT- MIN(Q) as well as | RELAX(u,v,w). The total running time is O(|E|log |V| ).

Similar presentations

Presentation is loading. Please wait....

OK

Single Source Shortest Paths

Single Source Shortest Paths

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on teachers day message Ppt on abstract art pictures Ppt on art of war Ppt on wind energy pdf Ppt on art and craft movement pottery Ppt on artificial intelligence free download Ppt on computer languages popularity Ppt on number system in maths Ppt on projectile motion class 11 Ppt on nature and human quotes