shortest paths definitions single source algorithms –bellman ford –dag shortest path algorithm...

Download Shortest Paths Definitions Single Source Algorithms –Bellman Ford –DAG shortest path algorithm –Dijkstra All Pairs Algorithms –Using Single Source Algorithms

Post on 20-Dec-2015

225 views

Category:

Documents

0 download

Embed Size (px)

TRANSCRIPT

  • Slide 1
  • Shortest Paths Definitions Single Source Algorithms Bellman Ford DAG shortest path algorithm Dijkstra All Pairs Algorithms Using Single Source Algorithms Matrix multiplication Floyd-Warshall Both of above use adjacency matrix representation and dynamic programming Johnsons algorithm Uses adjacency list representation
  • Slide 2
  • Single Source Definition Input Weighted, connected directed graph G=(V,E) Weight (length) function w on each edge e in E Source node s in V Task Compute a shortest path from s to all nodes in V
  • Slide 3
  • All Pairs Definition Input Weighted, connected directed graph G=(V,E) Weight (length) function w on each edge e in E We will typically assume w is represented as a matrix Task Compute a shortest path from all nodes in V to all nodes in V
  • Slide 4
  • Comments If edges are not weighted, then BFS works for single source problem Optimal substructure A shortest path between s and t contains other shortest paths within it No known algorithm is better at finding a shortest path from s to a specific destination node t in G than finding the shortest path from s to all nodes in V
  • Slide 5
  • Negative weight edges Negative weight edges can be allowed as long as there are no negative weight cycles If there are negative weight cycles, then there cannot be a shortest path from s to any node t (why?) If we disallow negative weight cycles, then there always is a shortest path that contains no cycles
  • Slide 6
  • Relaxation technique For each vertex v, we maintain an upper bound d[v] on the length of shortest path from s to v d[v] initialized to infinity Relaxing an edge (u,v) Can we shorten the path to v by going through u? If d[v] > d[u] + w(u,v), d[v] = d[u] + w(u,v) This can be done in O(1) time
  • Slide 7
  • Bellman-Ford Algorithm Bellman-Ford (G, w, s) Initialize-Single- Source(G,s) for (i=1 to V-1) for each edge (u,v) in E relax(u,v); for each edge (u,v) in E if d[v] > d[u] + w(u,v) return NEGATIVE WEIGHT CYCLE 3 5 7 -5 3 2 1 s 3 5 -5 3 2 1 s G1G1 G2G2
  • Slide 8
  • Running Time for (i=1 to V-1) for each edge (u,v) in E relax(u,v); The above takes (V-1)O(E) = O(VE) time for each edge (u,v) in E if d[v] > d[u] + w(u,v) return NEGATIVE WEIGHT CYCLE The above takes O(E) time
  • Slide 9
  • Proof of Correctness Theorem: If there is a shortest path from s to any node v, then d[v] will have this weight at end of Bellman-Ford algorithm Theorem restated: Define links[v] to be the minimum number of edges on a shortest path from s to v After i iterations of the Bellman-Ford for loop, nodes v with links[v] i will have their d[v] value set correctly Prove this by induction on links[v] Base case: links[v] = 0 which means v is s d[s] is initialized to 0 which is correct unless there is a negative weight cycle from s to s in which case there is no shortest path from s to s. Induction hypothesis: After k iterations for k 0, d[v] must be correct if links[v] k Inductive step: Show after k+1 iterations, d[v] must be correct if links[v] k+1 If links[v] k, then by IH, d[v] is correctly set after kth iteration If links[v] = k+1, let p = (e 1, e 2, , e k+1 ) = (v 0, v 1, v 2, , v k+1 ) be a shortest path from s to v s = v 0, v = v k+1, e i = (v i-1, v i ) In order for links[v] = k+1, then links[v k ] = k. By the inductive hypothesis, d[v k ] will be correctly set after the kth iteration. During the k+1st iteration, we relax all edges including edge e k+1 = (v k,v) Thus, at end of the k+1 st iteration, d[v] will be correct
  • Slide 10
  • Negative weight cycle for each edge (u,v) in E if d[v] > d[u] + w(u,v) return NEGATIVE WEIGHT CYCLE If no neg weight cycle, d[v] d[u] + w(u,v) for all (u,v) If there is a negative weight cycle C, for some edge (u,v) on C, it must be the case that d[v] > d[u] + w(u,v). Suppose this is not true for some neg. weight cycle C sum these (d[v] d[u] + w(u,v)) all the way around C We end up with v in C d[v] ( u in C d[u]) + weight(C) This is impossible unless weight(C) = 0 But weight(C) is negative, so this cannot happen Thus for some (u,v) on C, d[v] > d[u] + w(u,v)
  • Slide 11
  • DAG shortest path algorithm DAG-SP (G, w, s) Initialize-Single- Source(G,s) Topologically sort vertices in G for each vertex u, taken in sorted order for each edge (u,v) in E relax(u,v); 3 5 -4 3 8 1 s 5 4
  • Slide 12
  • Running time Improvement O(V+E) for the topological sorting We only do 1 relaxation for each edge: O(E) time for each vertex u, taken in sorted order for each edge (u,v) in E relax(u,v); Overall running time: O(V+E)
  • Slide 13
  • Proof of Correctness If there is a shortest path from s to any node v, then d[v] will have this weight at end Let p = (e 1, e 2, , e k ) = (v 1, v 2, v 3, , v k+1 ) be a shortest path from s to v s = v 1, v = v k+1, e i = (v i, v i+1 ) Since we sort edges in topological order, we will process node v i (and edge e i ) before processing later edges in the path.
  • Slide 14
  • Dijkstras Algorithm Dijkstra (G, w, s) /* Assumption: all edge weights non-negative */ Initialize-Single- Source(G,s) Completed = {}; ToBeCompleted = V; While ToBeCompleted is not empty u =EXTRACT- MIN(ToBeCompleted); Completed += {u}; for each edge (u,v) relax(u,v); 15 5 7 4 3 2 1 s
  • Slide 15
  • Running Time Analysis While ToBeCompleted is not empty u =EXTRACT-MIN(ToBeCompleted); Completed += {u}; for each edge (u,v) relax(u,v); Each edge relaxed at most once: O(E) Need to decrease-key potentially once per edge Need to extract-min once per node The nodes d[v] is then complete
  • Slide 16
  • Running Time Analysis contd Priority Queue operations O(E) decrease key operations O(V) extract-min operations Three implementations of priority queues Array: O(V 2 ) time decrease-key is O(1) and extract-min is O(V) Binary heap: O(E log V) time assuming E V decrease-key and extract-min are O(log V) Fibonacci heap: O(V log V + E) time decrease-key is O(1) amortized and extract-min is O(log V)
  • Slide 17
  • Compare Dijkstras algorithm to Prims algorithm for MST Dijsktra Priority Queue operations O(E) decrease key operations O(V) extract-min operations Prim Priority Queue operations O(E) decrease-key operations O(V) extract-min operations Is this a coincidence or is there something more here?
  • Slide 18
  • Proof of Correctness Assume that Dijkstras algorithm fails to compute length of all shortest paths from s Let v be the first node whose shortest path length is computed incorrectly Let S be the set of nodes whose shortest paths were computed correctly by Dijkstra prior to adding v to the processed set of nodes. Dijkstras algorithm has used the shortest path from s to v using only nodes in S when it added v to S. The shortest path to v must include one node not in S Let u be the first such node. suv Only nodes in S
  • Slide 19
  • Proof of Correctness The length of the shortest path to u must be at least that of the length of the path computed to v. Why? The length of the path from u to v must be < 0. Why? No path can have negative length since all edge weights are non-negative, and thus we have a contradiction. suv Only nodes in S
  • Slide 20
  • Computing paths (not just distance) Maintain for each node v a predecessor node p(v) p(v) is initialized to be null Whenever an edge (u,v) is relaxed such that d(v) improves, then p(v) can be set to be u Paths can be generated from this data structure
  • Slide 21
  • All pairs algorithms using single source algorithms Call a single source algorithm from each vertex s in V O(V X) where X is the running time of the given algorithm Dijkstra linear array: O(V 3 ) Dijkstra binary heap: O(VE log V) Dijkstra Fibonacci heap: O(V 2 log V + VE) Bellman-Ford: O(V 2 E) (negative weight edges)
  • Slide 22
  • Two adjacency matrix based algorithms Matrix-multiplication based algorithm Let L m (i,j) denote the length of the shortest path from node i to node j using at most m edges What is our desired result in terms of L m (i,j)? What is a recurrence relation for L m (i,j)? Floyd-Warshall algorithm Let L k (i,j) denote the length of the shortest path from node i to node j using only nodes within {1, , k} as internal nodes. What is our desired result in terms of L k (i,j)? What is a recurrence relation for L k (i,j)?
  • Slide 23
  • Conceptual pictures ij Shortest path using at most 2m edges Shortest path using at most m edges k Try all possible nodes k k ij Shortest path using nodes 1 through k Shortest path using nodes 1 through k-1 OR
  • Slide 24
  • Running Times Matrix-multiplication based algorithm O(V 3 log V) log V executions of matrix-matrix multiplication Not quite matrix-matrix multiplication but same running time Floyd-Warshall algorithm O(V 3 ) V iterations of an O(V 2 ) update loop The constant is very small, so this is a fast O(V 3 )
  • Slide 25
  • Johnsons Algorithm Key ideas Reweight edge weights to eliminate negative weight edges AND preserve shortest paths Use Bellman-Ford and Dijkstras algorithms as subroutines Running time: O(V 2 log V + VE) Better than earlier algorithms for sparse graphs
  • Slide 26
  • Reweighting Original edge weight is w(u,v) New edge weight: w(u,v) = w(u,v) + h(u) h(v) h(v) is a function mapping vertices to real numbers Key observation: Let p be any path fro

Recommended

View more >