Lecture 6: Shortest distance, Eulerian cycles, Maxflow

Transcription

1 DD2458, Problem Solving and Programming Under Pressure Lecture 6: Shortest distance, Eulerian cycles, Maxflow Date: Scribe(s): Adam Kull, David Vuorio Lecturer: Douglas Wikström 1 Shortest path from a given node Problem: Finding the shortest path from a source to every other node in a directed graph. As we saw in the previous lecture this can be solved efficiently with Dijkstra s algorithm, but with one condition: the graph has only positive edge weights. What happens if we try to run Dijkstra on a graph with negative weights? As Dijkstra is a greedy algorithm that only cares about the edges adjacent to the set of already visited vertices, it will not consider edges two steps away. As long as we only consider positive weights this will never be a problem. But when there are negative weights involved we are no longer guaranteed that we are choosing the best way in each step. This is because adding two edges together might actually produce a path with a smaller weight than just choosing the edge with the smallest value at the current step. Figure 1: Dijkstra As in figure?? we can see that Dijkstra would have chosen edge (b) because this currently has the smallest weight. But in reality the shortest path is via edge (a) and (c), as edge (c) is negative and thus the total weight will decrease. Dijkstra won t find this path as it does not "look" two steps away. Extending Dijkstra to look two edges ahead is however not a solution, as we might have to look arbitrary many edges away to find the shortest path. The solution to this is the Bellman-Ford algorithm. This algorithm works in a manner similar to Dijkstra, but it does so iteratively and updates the estimated distances several times. It will first update the distances to all the vertices using the 1

2 2 DD2458 Popup HT 2008 same approach as Dijkstra. We now know that these have the correct distances if we use a path with at most one edge. It will then continue to update all the vertices again, correcting distances along the way as it finds smaller distances. After each iteration i we know that the estimated distance for each vertex is correct if we use a path with at most i edges. This is repeated n 1 times, as the longest path in the graph has at most n 1 edges. So when the algorithm stops we are sure that each distance is correct as we are sure that we got the shortest distance for each vertex using at most i edges in each iteration and no path is longer than n 1 edges. Lemma: After i iterations in the for-loop is this true: If d(u) there exists a path of length d(u) from s to u. If there is a path from s to u with at most i edges, then d(u) is the length of a shortest path from s to u with at most i edges. By using this approach the distances will be corrected at each vertex as we find a path with a lower weight and the correct distances will propagate throughout the graph until we are sure that all the estimates are correct. Because we update all edges n 1 times the running time for this algorithm is O(nm), wich means that it is slower than Dijkstra. Algorithm 1: Bellman-Ford Input: A graph G with weighted edges and a start node s. Output: The minimum distance from a node s to all other nodes in G. BellmanFord(G, w( ), s) (1) p(u) and d(u) for u V. (2) d(s) 0 (3) for i = 1 to n 1 (4) foreach (u,v) E (5) if d(u) + w(u,v) < d(v) (6) d(v) d(u) + w(u,v) (7) p(v) u (8) return (d( ),p( )) Algorithm 2: Negative cycle detection. Input: A graph G with weighted edges and a start node s, and a Bellman- Ford solution (d( ),p( )) Output: true or false depending on whether G has a negative cycle or not. NegCycles(G,w( ),s,d( ),p( )) (1) foreach (u,v) E (2) if d(u) + w(u,v) < d(v) (3) return true (4) return false One problem arises when there is a negative cycle in the graph. A negative cycle means that there is some cycle in the graph that when we traverse it we will

3 Shortest distance, Eulerian cycles, Maxflow 3 end up with a lower total weight when we are back at the start node than we had when we started. This implies that going around and around in this cycle will result in an infinitely negative weight. This means that there is no shortest path between two nodes with a negative cycle somewhere between them as the total weight can always be made smaller. The presence of negative cycles can be quite easy to dectect in Bellman-Ford by running an extra iteration. When we are done with the n 1 iterations we know that all the vertices have correct values and therefore the extra iteration will not change any values. But if there are a negative cycle somewhere in the graph, running an additional iteration means that some vertices will be updated with a lower value as we can always walk this cycle one more time and always get a smaller value. 2 Shortest distance between all pairs of nodes If given any two nodes in a directed weighted graph, we would like to find the shortest path in between them, in the sense that it has a minimum total weight. One way to calculate this for all pairs of nodes would be to apply Dijkstra repeatedly, which works for non-negative weights. This takes O(nm log n) time. Alternatively, we can use Bellman-Ford repeatedly, which takes O(n 2 m) time. We note that applying any of these algorithms repeatedly leads to some amount of repeated efforts, so we may want to use dynamic programming instead. Let s define d k,u,v as the minimum distance from node u to node v, where only nodes 1,..., k (except u and v) can be passed. We can then make a recursive definition of d k,u,v like so: d 0,u,v = w(u, v) d k,u,v = min{d k 1,u,v, d k 1,u,k + d k 1,k,v } for k = 1,..., n d k 1,u,k + d k 1,k,v is the shortest path that includes node k (see figure??), whereas d k 1,u,v is the shortest path (if any, see figure??) that does not. Note that w(u, v) is considered to have an infinite value for any pairs of nodes that are not connected by an edge. d k 1,u,v will thus have a value of infinity if there is no path which does not include k. Figure 2: Shortest path, also considering node k Let s build an n 3 table D which in its final state has D[k, u, v] = d k,u,v,. Similarly we will have a table where P[k, u, v] denotes the last node in an optimal

4 4 DD2458 Popup HT 2008 Figure 3: Shortest path, not considering node k Algorithm 3: Floyd-Warshall, intialization Input: A graph G with weighted edges. Output: Nothing. Init(G) (1) foreach u V (2) foreach v V (3) for k = 0 to n (4) D[k,u,v] (5) P[k,u,v] (6) foreach u V (7) foreach k V (8) D[k,u,u] 0 (9) foreach (u,v) E (10) D[0,u,v] w(u,v) (11) P[0,u,v] u way from u to v, using only nodes 1,..., k. Then we can find the optimal way by backtracking. We could optimize the algorithm to require only n 2 space, since all updates only refer to D[k 1,, ] or P[k 1,, ]. Any earlier values can be thrown away. Note that u belongs to a negative cycle precisely if D[k, u, u] < Johnson s algorithm Floyd-Warshall takes time O(n 3 ), so Dijkstra (O(nm log n)) is faster for sparse graphs, here defined as m < n 2 /log n. Since Dijkstra cannot handle negative weights, we will need to make a trick first. This consist of adding a new node to the graph (see figure??), which is connected to all other nodes. Then, using Bellman-Ford, we will find out the minimum distance to every node from the "fake node". Using this information we can create a new set of non-negative weights for each edge and apply Dijkstra with that. (Obviously this strategy is not working if any negative cycles are involved.) As illustrated in figure?? we can have many paths between a source node s and a target node t, however the manipulations we apply (w (u, v) = w(u, v) + d(u) d(v)) at each step along the way are cancelled out (as indicated in the figure, the

5 Shortest distance, Eulerian cycles, Maxflow 5 Algorithm 4: Floyd-Warshall, complete algorithm. Input: A graph G with weighted edges. Output: The shortest path between each pair of nodes. Floyd-Warshall(G) (1) Init() (2) for k = 1 to n (3) foreach u V (4) if D[k 1,u,k] < (5) foreach v V (6) if D[k 1,u,k] + D[k 1,k,v] D[k 1,u,v] (7) D[k,u,v] D[k 1,u,v] (8) P[k,u,v] P[k 1,u,v] (9) else (10) D[k,u,v] D[k 1,u,k] + D[k 1,k,v] (11) D[k,u,v] P[k 1,k,v] (12) return (D[n,, ],P[n,, ]) Figure 4: Johnson s algorithm, adding a "fake node" Figure 5: Johnson s algorithm, creating new weights

6 6 DD2458 Popup HT 2008 Algorithm 5: Johnson s algorithm Input: A graph G with weighted edges. Output: The shortest path between all pairs of nodes. Johnson(G) (1) G (V {n + 1},E {(n + 1,u) : u V }) (2) (d,p) BellmanFord(G, w( ), n + 1) (3) Let w (u,v) = w(u,v) + d(u) d(v) (4) foreach u V (5) (D[u], P[u]) Dijkstra(G, u, w ) (6) return (D, P) sum of the new weights will be d(s) d(t)), leaving only d(s) and d(t) significant. In effect, this will make sure that a shortest path in the original graph is also shortest in the new graph. 3 Eulerian Path Algorithm 6: Eulerian Path Input: A graph G = (V,E). Output: An Eulerian path. EulerPath(G, u) (1) vis(e) = false for e E. (2) return EulerPathInner(G,u) In a graph (directed or undirected), an Eulerian path is a path in the graph that uses each edge exactly once. An Eulerian cycle is an Eulerian path which ends where it begins. (Observe the difference between an Eulerian cycle and a Hamilton cycle. The latter visits each node exactly once and is NP-hard to find.) Now, let G = (V, E) be an undirected graph. Determine if there is an Eulerian path and find it if there is one. We assume that isolated nodes are not present in the graph as these never have to be visited. Then it follows that: An undirected graph has: an Eulerian path if it s connected and all nodes except at most two have an even number of edges, and an Eulerian cycle if all nodes have an even number of edges. A directed graph has: an Eulerian path if it s connected, all nodes except at most two have as many incoming edges as outgoing edges, and the two special nodes (if any) have exactly one excessive incoming / outgoing edge each (e.g. one more outgoing edge than incoming edges), and

7 Shortest distance, Eulerian cycles, Maxflow 7 an Eulerian cycle if additionally all nodes have as many incoming as outgoing edges. Algorithm?? works by finding cycles in the graph until all nodes have been visited, and then connecting them as is illustrated in figure??. Figure 6: Eulerian cycle 4 Max flow Definition: A flow in a directed, weighted graph G = (V, E) from s V to t V is a function f : E R so that 0 f(e) w(e) for e E, and e In(u) f(e) = e Out(u) f(e) for each u s, t. The flow in a graph from one vertex (often called the source) to another vertex (the sink) can be understood as viewing the edges in a graph as pipes that we want to fill with as much water as possible. The weights of the edges then represents the capacity of the pipes. Using this analogy, finding the max flow means that we want to know how much water we can pump out from the source without overflowing the network. One consequence of this analogy is that the net flow in each vertex is always 0 (except for the source and sink, where the flow out of the source is equal to the flow into the sink), i.e. the flow out from a vertex is always as large as the flow into it. To be able to undo pushing flow through an edge, we add an edge in the opposite direction for every edge already in the graph. This starts with capacity 0 when the flow through the original edge is 0, and increases as the flow in the original edge increases. Going through this residue edge represents lowering the flow in the original edge. An algorithm for finding the maximum flow through a graph is Ford-Fulkerson. It works by finding a path from the source to sink where there still exists some unused capacity (easily done with BFS). Then we find the smallest capacity available along this path, and then fill each edge with this flow. This is then repeated until there are no paths to the sink with more capacity available (including residue

8 8 DD2458 Popup HT 2008 edges), at which point we know that we have pushed as much flow through the graph as we can. When running this algorithm a path can be found in O(m) time and, at least when dealing with integer capacities, in each step we increase the flow by at least 1. This means that the algorithm has a complexity of O(mf), where f is the maximum flow in the graph.

9 Shortest distance, Eulerian cycles, Maxflow 9 EulerPathInner(G, u) (1) if vis(u,v) = true for all (u,v) E(u) (2) return (3) else (4) Take (u,v) E with vis(u,v) = false. (5) vis(u, v) true. (6) x EulerPathInner(G,v) (7) t Conc(((u,v)),x) (8) p (9) foreach (u,v) E with vis(u,v) = false (10) x EulerPathInner(G,u) (11) p Conc(p,x) (12) return Conc(p,t) FlowFinder() (1) Let p = (e 1,...,e k ) with e 1 Out(s),e k In(t) and w(e i ) f(e i ) > 0 if possible, otherwise p =. (2) return p Algorithm 7: Ford-Fulkerson Input: A graph G = (V,E). Output: A maximum flow f. FordFulkerson(G) (1) f(e) 0 for e E. (2) while true (3) p FlowFinder() (4) if p = (5) return f (6) else (7) Expand (e 1,...,e k ) from p. (8) d min i {w(e i ) f(e i )} (9) for i = 1 to k (10) f(e i ) f(e i ) + d (11) f(e 1 i ) f(e 1 i ) d