1 / 56

Single Source Shortest-Path: The General Case (with negative edges)

Bellman-Ford algorithm. Iteratively relax all edges |V|-1 times. Single Source Shortest-Path: The General Case (with negative edges). Running time? O(VE). All-Pairs Shortest Paths. Given a directed graph G = (V, E), weight function w : E → R, |V| = n. Assume no negative weight cycles.

thetis
Download Presentation

Single Source Shortest-Path: The General Case (with negative edges)

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. Bellman-Ford algorithm. Iteratively relax all edges |V|-1 times Single Source Shortest-Path: The General Case (with negative edges) • Running time? • O(VE).

  2. All-Pairs Shortest Paths

  3. Given a directed graph G = (V, E), weight function w : E → R, |V| = n. Assume no negative weight cycles. Goal: create an n × n matrix of shortest-path distances δ(u, v). Could run BELLMAN-FORD once from each vertex: O(V2E)—which is O(V4) if the graph is dense (E = (V2)). If no negative-weight edges, could run Dijkstra’s algorithm once from each vertex: O(V E lg V) with binary heap—O(V3 lg V) if dense, We’ll see how to do in O(V3) in all cases, with no fancy data structure. All-Pairs Shortest Paths

  4. Dynamic programming approach. Use optimal substructure of shortest paths: Any subpath of a shortest path is a shortest path. Create a 3-dimensional table: Let dij(k) –shortest path weight of any path from i to j where all intermediate vertices are from the set {1,2, …, k}. Ultimately, we would like to know the values of dij(n). All Pairs Shortest Path – Floyd-Warshall Algorithm

  5. Base condition: dij(0) = ? dij(0) = wij. For k>0: Let p=<vi, . . . , vj> be a shortest path from vertex i to vertex j with all intermediate vertices in {1,2, …, k}. If k is not an intermediate vertex, then all intermediate vertices are in {1,2, …, k-1}. If k is an intermediate vertex, then p is composed of 2 shortest subpaths drawn from {1,2, …, k-1}. Computing dij(k)

  6. Recursive Formulation for dij(k)

  7. Running time = ? O(n3). Memory required = ? O(n2) (if we drop the superscripts). Algorithm

  8. Example

  9. Step 1

  10. Step 2

  11. Step 3

  12. Step 4

  13. Step 5

  14. Idea: If the graph is sparse (|E|<<|V|2), it pays to run Dijkstra’s algorithm once from each vertex. O(VE log V) using binary heap, O(V2 log V + V E) using Fibonacci heap. But Dijkstra’s algorithm does not handle negative edges. Johnson’s Algorithm: reweight edges to form equivalent graph with non-negative edges. Floyd-Warshall still has advantages: very simple implementation no fancy data structures small constant. All-Pairs Shortest Path: Johnson’s Algorithm

  15. The Maximum Network Flow Problem

  16. Use a graph to model material that flows through conduits. Each edge represents one conduit, and has a capacity, which is an upper bound on the flow rate = units/time. Can think of edges as pipes of different sizes. But flows don’t have to be of liquids. Want to compute max rate that we can ship material from a designated source to a designated sink. The Problem

  17. Each edge (u,v) has a nonnegative capacity c(u,v). If (u,v) is not in E, assume c(u,v)=0. We have a source s, and a sink t. Assume that every vertex v in V is on some path from s to t. c(s,v1)=16; c(v1,s)=0; c(v2,v3)=0 What is a Flow Network?

  18. For each edge (u,v), the flow f(u,v) is a real-valued function that must satisfy 3 conditions: What is a Flow in a Network? • Note that skew symmetry condition implies that f(u,u)=0.

  19. f(v2, v1) = 1, c(v2, v1) = 4. f(v1, v2) = -1, c(v1, v2) = 10. f(v3, s) + f(v3, v1) + f(v3, v2) + f(v3, v4) + f(v3, t) = 0 + (-12) + 4 + (-7) + 15 = 0 flow capacity Example of a Flow:

  20. The value of a flow is given by The Value of a flow • This it the total flow leaving s = the total flow arriving in t.

  21. |f| = f(s, v1) + f(s, v2) + f(s, v3) + f(s, v4) + f(s, t) = 11 + 8 + 0 + 0 + 0 = 19 |f|= f(s, t) + f(v1, t) + f(v2, t) + f(v3, t) + f(v4, t) = 0 + 0 + 0 + 15 + 4 = 19 Example:

  22. We assume that there is only flow in one direction at a time. Sending 7 trucks from Edmonton to Calgary and 3 trucks from Calgary to Edmonton has the same net effect as sending 4 trucks from Edmonton to Calgary. A flow in a network

  23. We have several sources and several targets. Want to maximize the total flow from all sources to all targets. Reduce to max-flow by creating a supersource and a supersink: Multiple Sources Network

  24. Try to improve the flow, until we reach the maximum. The residual capacity of the network with a flow f is given by: The Ford-Fulkerson Method Always nonnegative (why?)

  25. Network: Residual Network: Augmenting path Example of residual capacities

  26. The edges of the residual network are the edges on which the residual capacity is positive. The residual network

  27. An augmenting path p is a simple path from s to t on the residual network. We can put more flow from s to t through p. We call the maximum capacity by which we can increase the flow on p the residual capacity of p. Augmenting Paths

  28. The residual capacity of p = 4. Can improve the flow along p by 4. Augmenting Paths - example

  29. Ford-Fulkerson Method

  30. Flow(1) Residual(1) No more augmenting paths  max flow attained. Flow(2) Residual(2) Example

  31. The maximum possible flow through the cut = 12 + 7 + 4 = 23 Augmenting Paths – example Flow(2) The network has a capacity of at most 23. This is called a minimum cut.

  32. A cut in a network is a partition of V into S and T=V-S so that s is in S and t is in T. Cuts of Flow Networks

  33. f(S,T) = 12 – 4 + 11 = 19 The net flow through a cut (S,T)

  34. c(S,T)= 12+ 0 + 14 = 26 The capacity of (S,T)

  35. For any cut (S,T), the net flow across (S,T) is f(S,T)=|f|. Lemma 26.5

  36. The value of any flow f in a flow network G is bounded from above by the capacity of any cut of G. Corollary 26.6

  37. If f is a flow in a flow network G=(V,E), with source s and sink t, then the following conditions are equivalent: f is a maximum flow in G. The residual network Gf contains no augmented paths. |f| = c(S,T) for some cut (S,T) (a min-cut). Theorem 26.7 (Max-flow min-cut theorem)

  38. The Basic Ford-Fulkerson Algorithm

  39. augmenting path Original Network Resulting Flow = Example 4

  40. 4 augmenting path Residual Network Resulting Flow = Example

  41. Example Residual Network Resulting Flow = 11

  42. Resulting Flow = 11 augmenting path Residual Network Example

  43. Residual Network Resulting Flow = Example 19

  44. Resulting Flow = 19 augmenting path Residual Network Example

  45. Residual Network Resulting Flow = Example 23

  46. Resulting Flow = 23 No augmenting path: Maxflow=23 Residual Network Example

  47. O(E) O(E) Analysis

  48. If capacities are all integer, then each augmenting path raises |f| by ≥ 1. If max flow is f*, then need ≤ |f*| iterations ⇒ time is O(E|f*|). Note that this running time is not polynomial in input size. It depends on |f*|, which is not a function of |V| or |E|. If capacities are rational, can scale them to integers. If irrational, FORD-FULKERSON might never terminate! Analysis

  49. With time O ( E |f*|), the algorithm is not polynomial. This problem is real: Ford-Fulkerson may perform very badly if we are unlucky: The basic Ford-Fulkerson Algorithm |f*|=2,000,000

  50. Run Ford-Fulkerson on this example Augmenting Path Residual Network

More Related