1 / 30

Shortest path

Shortest path. Graph with Length. Dijkstra’s Algorithm. Edge with Length. 3. 4. Distance / time / resource ,etc. 4. 10. 3. 2. 2. Pattaya. Finding Shortest Path. BFS can give us the shortest path Just convert the length edge into unit edge. 2. B. D. B. D. 2. A. 2. A. 1. 3.

mareo
Download Presentation

Shortest path

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Shortest path

  2. Graph with Length Dijkstra’s Algorithm

  3. Edge with Length 3 4 Distance / time / resource ,etc.. 4 10 3 2 2 Pattaya

  4. Finding Shortest Path • BFS can give us the shortest path • Just convert the length edge into unit edge 2 B D B D 2 A 2 A 1 3 1 C E C E 4 However, this is very slow Imagine a case when the length is 1,000,000

  5. Alarm Clock Analogy • No need to walk to every node • Since it won’t change anything • We skip to the “actual” node • Set up the clock at alarm at the target node A 100 S 50 200 B A S B

  6. Alarm Clock Algorithm • Set an alarm clock for node s at time 0. • Repeat until there are no more alarms: • Say the next alarm goes off at time T, for node u. Then: • The distance from s to u is T. • For each neighbor v of u in G: • If there is no alarm yet for v set one for time T + w(u, v). • If v's alarm is set for later than T + w(u, v), then reset it to this earlier time.

  7. Dijkstra’sAlgo from BFS procedure dijkstra(G, w, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V; positive edge lengths w // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all v  V dist[v] = + prev[v] = nil dist[s] = 0 Priority_Queue H = makequeue(V) // enqueue all vertices (using dist as keys) while H is not empty v = H.deletemin() for each edge (v,u)  E if dist[u] > dist[v] + w(v, u) dist[u] = dist[v] + w(v, u) prev[u] = v H.decreasekey(v,dist[v]) // change the value of v to dist[v]

  8. Another Implementation of Dijkstra’s • Growing from Known Region of shortest path • Given a graph and a starting node s • What if we know a shortest path from s to some subset S’  V? • Divide and Conquer Approach?

  9. Dijktra’sAlgo #2 procedure dijkstra(G, w, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V; positive edge lengths w // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all u  V : dist[u] = + prev[u] = nil dist[s] = 0 R = {} // (the “known region”) while R ≠ V : Pick the node v  R with smallest dist[] Add v to R for all edges (v,u)  E: if dist[u] > dist[v] + w(v,u) dist[u] = dist[v] + w(v,u) prev[u] = v

  10. Analysis • There are |V|ExtractMin • Need to check all edges • At most |E|, if we use adjacency list • Maybe |V2|, if we use adjacency matrix • Value of dist[] might be changed • Depends on underlying data structure

  11. Choice of DS • Using simple array • Each ExtractMin uses O(V) • Each change of dist[] uses O(1) • Result = O(V2 + E) = O(V2) • Using binary heap • Each ExtractMin uses O(lg V) • Each change of dist[] uses O(lg V) • Result = O( (V + E) lg V) • Beware!!! Can be O (V2 lg V) • if the graph is not sparse Might be V2 Good when the graph is sparse

  12. Fibonacci Heap • Using Fibonacci Heap • Each ExtractMin uses O( lg V) (amortized) • Each change of dist[] uses O(1) (amortized) • Result = O(Vlg V + E)

  13. Graph with Negative Edge • Disjktra’s works because a shortest path to v must pass through a node closer than v • Shortest path to A pass through B which is… in BFS sense… is further than A A 3 S -2 4 B

  14. Negative Cycle • A graph with a negative cycle has no shortest path • The shortest.. makes no sense.. • Hence, negative edge must be a directed

  15. Key Idea in Shortest Path • Update the distance if (dist[z] > dist[v] + w(v,z)) dist[z] = dist[v] + w(v,z) • This is safe to perform

  16. Another Approach to Shortest Path • A shortest path must has at most |V| - 1 edges • Writing a recurrent • d(n, v) = shortest distance from s to v using at most n edges • d(n,v) = min of • d(n – 1, v) • min( d(n – 1, u) + w(u,v) ) over all edges (u,v) • Initial d(*,s) = 0, d(0,v) = 

  17. Bellman-Ford Algorithm • Dynamic Programming • Since d(n,*) use d(n – 1,*), we use only 1D array to store D

  18. Bellman-Ford Algorithm procedure BellmanFord(G, w, s) //Input: Graph G = (V,E), directed; vertex s  V; edge lengths w (may be negative), no negative cycle // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all u  V : dist[u] = + prev[u] = nil dist[s] = 0 repeat |V| - 1 times: for all edges (a,b)  E: if dist[b] > dist[a] + w(a,b) dist[b] = dist[a] + w(a,b) prev[b] = a

  19. Analysis • Very simple • Loop |V| times • Each loop takes |E| iterations • O(V E) • Dense graph O(V3) • Bellman-Ford is slower but can detect negative cycle

  20. Detecting Negative Cycle • After repeat the loop |V|-1 times • If we can still do • dist[v] = dist[u] + w(y,v) • Then, there is a negative cycle • Because there is a shorter path eventhough we have repeat this |V|-1 time for all edges (a,b)  E if dist[b] > dist[a] + w(a,b) printf(“negative cycle\n”)

  21. Shortest Path in DAG • Path in DAG appears in linearized order procedure dag-shortest-path(G, w, s) //Input: DAG G = (V,E), vertex s  V; edge lengths w (may be negative) // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all u  V dist[u] = + prev[u] = nil dist[s] = 0 Linearize G For each u  V , in linearized order: for all edges (u,v)  E: if dist[v] > dist[u] + w(u,v) dist[v] = dist[u] + w(y,v) prev[b] = a

  22. All Pair Shortest Path

  23. All Pair Shortest Path Problem • Input: • A graph • Output: • A matrix D[1..v,1..v] giving the shortest distance between every pair of vertices

  24. Approach • Standard shortest path gives shortest path from a given vertex s to every vertex • Repeat this for every starting vertex s • Dijkstra O(|V| * (|E| log |V|) ) • Bellman-Ford O(|V| * (|V|3) ) • Dynamic Algorithm Approach • Floyd-Warshall

  25. Dynamic Algorithm Approach • Using the previous recurrent • d(n, v) = shortest distance from s to v using at most n edges • Change to • dn(a,b) = shortest distance from a to b using at most n edges • dn(a,b) = min of • dn-1(a,b) • min(dn-1(a,k) + w(k,b) ) over all edges (k,b) • Initial d0(a,a) = 0, d0 (a,b) = , d1(a,b) = w(a,b)

  26. Dynamic Algorithm Approach • Again, A shortest path must has at most |V| - 1 edges • What we need to find is d|V|(a,b) • Let D{M} be the matrix dm(a,b) • Start with D{1} and compute D{2} • Similar to computation of dist[] in Bellman-Ford • Repeat until we have D{|V|}

  27. Floyd-Warshall • Use another recurrent • dk(a,b) is a shortest distance from a to b that can travel via a set of vertex {1,2,3,…,k} • d0(a,b) = l(a,b) because it can not go pass any vertex • d1(a,b) means a shortest distance that the path can have only vertex 1 (not including a and b)

  28. Recurrent Relation • dk(a,b) = min of • dk-1(a,b) • dk-1(a,k) + dk-1 (k,b) • Initial d0(a,b) = l(a,b)

  29. Floyd-Warshall procedure FloydWarshall(G, l) //Input: Graph G = (V,E); vertex s  V; edge lengths w (may be negative), no negative cycle // Output: dist[u,v] is the shortest distance from u to v. dist = w for k = 0 to |V| - 1 for i = 0 to |V| - 1 for j = 0 to |V| - 1 dist[i][j] = min (dist[i][j], dist[i][k] + dist[k][j])

  30. Analysis • Very simple • 3 nested loops of |V| • O(|V|3)

More Related