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

COSC 3101NJ. Elder All-Pairs Shortest Paths

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(V 2 E)—which is O(V 4 ) 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(V 3 lg V) if dense, We’ll see how to do in O(V 3 ) in all cases, with no fancy data structure.

All Pairs Shortest Path – Floyd-Warshall Algorithm 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 d ij (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 d ij (n).

Computing d ij (k) Base condition: d ij (0) = ? d ij (0) = w ij. For k>0: Let p= 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}.

Recursive Formulation for d ij (k)

Algorithm Running time = ? O(n 3 ). Memory required = ? O(n 2 ) (if we drop the superscripts).

Example

Step 1

Step 2

Step 3

Step 4

Step 5

All-Pairs Shortest Path: Johnson’s Algorithm 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(V 2 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.

COSC 3101NJ. Elder The Maximum Network Flow Problem

The Problem 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.

What is a Flow Network? 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,v 1 )=16; c(v 1,s)=0; c(v 2,v 3 )=0

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

Example of a Flow: f(v 2, v 1 ) = 1, c(v 2, v 1 ) = 4. f(v 1, v 2 ) = -1, c(v 1, v 2 ) = 10. f(v 3, s) + f(v 3, v 1 ) + f(v 3, v 2 ) + f(v 3, v 4 ) + f(v 3, t) = 0 + (-12) (-7) + 15 = 0 flow capacity

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

Example: |f| = f(s, v 1 ) + f(s, v 2 ) + f(s, v 3 ) + f(s, v 4 ) + f(s, t) = = 19 |f|= f(s, t) + f(v 1, t) + f(v 2, t) + f(v 3, t) + f(v 4, t) = = 19

A flow in a network 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.

Multiple Sources Network 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:

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

Example of residual capacities Network: Residual Network: Augmenting path

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

Augmenting Paths 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 - example The residual capacity of p = 4. Can improve the flow along p by 4.

Ford-Fulkerson Method

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

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

Cuts of Flow Networks 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.

The net flow through a cut (S,T) f(S,T) = 12 – = 19

The capacity of (S,T) c(S,T)= = 26

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

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

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

The Basic Ford-Fulkerson Algorithm

Example Resulting Flow = Original Network augmenting path 4

Example Resulting Flow = 4 Residual Network augmenting path

Example Residual Network Resulting Flow = 11

Example Resulting Flow = 11 Residual Network augmenting path

Example Residual Network Resulting Flow = 19

Example Resulting Flow = 19 Residual Network augmenting path

Example Residual Network Resulting Flow = 23

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

Analysis O(E)

Analysis 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!

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

Run Ford-Fulkerson on this example Augmenting Path Residual Network

Run Ford-Fulkerson on this example Augmenting Path Residual Network

Run Ford-Fulkerson on this example Repeat 999,999 more times…

The Edmonds-Karp Algorithm A small fix to the Ford-Fulkerson algorithm makes it work in polynomial time. Specify how to compute the path in line 4.

The Edmonds-Karp Algorithm Compute the path in line 4 using breadth-first search on residual network. The augmenting path p is the shortest path from s to t in the residual network (treating all edge weights as 1). Runs in time O(V E 2 ).

The Edmonds-Karp Algorithm - example Edmonds-Karp’s algorithm runs only 2 iterations on this graph.

Further Improvements Push-relabel algorithm ([CLRS, 26.4]) – O(V 2 E). The relabel-to-front algorithm ([CLRS, 26.5) – O(V 3 ).