1 / 20

Algorithms ( and Datastructures )

Algorithms ( and Datastructures ). Lecture 12 MAS 714 part 2 Hartmut Klauck. Ford Fulkerson. Input: flow network N=(G,C,s,t) Set f(u,v)=0 for all pairs u,v While there is an augmenting path p in N f : Compute C f (p) For all edges u,v on p: set f(u,v):=f(u,v)+C f (p)

dyan
Télécharger la présentation

Algorithms ( and Datastructures )

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. Algorithms (andDatastructures) Lecture 12 MAS 714 part 2 Hartmut Klauck

  2. Ford Fulkerson • Input: flow network N=(G,C,s,t) • Set f(u,v)=0 for all pairs u,v • While there is an augmenting path p in Nf: • Compute Cf(p) • For all edges u,v on p: • set f(u,v):=f(u,v)+Cf(p) • set f(v,u):=-f(u,v) • Output f

  3. Running time • Computing augmenting paths takes time O(m+n) • What is the number of iterations? • Depending on the choice of paths (and the capacities) FF need not terminate at all! • Running time can be (|f|m) where f is the max flow and capacities are integer • For integer weights no more than O(|f|) iterations are needed (augmenting paths add flow 1 at least)T • Example that (|f|) iterations can happen

  4. Running time • Network where 2M iterations can happen:

  5. Improving the running time • Improvement, choose the augmenting paths with BFS • Claim: • If in each iteration an augmenting path in Nf is chosen by BFS then running time is O(nm2) • Choosing paths by BFS means choosing augmenting paths with the smallest number of edges • Edmonds-Karp algorithm

  6. Running Time • Seach augmenting paths by BFS • Then: • Number of iterations is O(mn) • Ford-Fulkerson can be made to compute maximum flows in time O(m2n).

  7. Number of iterations • Lemma: • N a flow network • For all vertices v except s,t: • The distance (number of edges) from s to v increases monotonically when we switch to a residual network • Proof: • Assume (s,v) decreases in some iteration • f is flow before the iteration, f‘ afterwards • (s,v) distance in Nf ; (s,v) in Nf‘; v has minimum (s,v) among all v with (s,v)<(s,v) (*) • p: s to u to v a shortest path in Nf‘ • (s,u)=(s,v)-1 • (s,u)·(s,u) (*) • Then (u,v) is no edge in Nf : (u,v)2Nf then • (s,v)·(s,u)+1 • ·(s,u)+1 = (s,v); contradicton

  8. Number of iterations • Hence (u,v) in Nf‘and not in Nf • I.e. flow from v to u was increased • There is an augmenting path Pfad in Nfwith (v,u) • A shortest path from s to u with edge (v,u) exists! • Hence: • (s,v) • = (s,u)-1 • · (s,u)-1 • = (s,v)-2 • Contradiction to (s,v)<(s,v)

  9. Number of iterations • Theorem: • There are at most mn iterations • Proof: • Edges in Nfare critical, if the minimum capacity of an augmenting path p is the capacity of (u,v) in Nf • Critical edges are removed, i.e. are not in Nf' • Every augmenting path has at least one critical edge • Claim: an edge can be critical at most n/2-1 times • Since at most 2m edges are used there can be at most nm iterations

  10. Proof of the claim • (u,v) critical in Nffor the first time:(s,v)=(s,u)+1 • (u,v) vanishes in the iteration • (u,v) can only reappear if the flow from u to v is reduced • Then (v,u) is on an augmenting path; f‘ the flow at this time • (s,u)=(s,v)+1 • (s,v)·(s,v) • Hence: • (s,u)=(s,v)+1 • ¸(s,v)+1 • =(s,u)+2 • Distance s to u increases by 2, before (u,v) can be critical • Distance is integer between 0 and n-1 • (u,v) can be critical at most n/2-1 times.

  11. Conclusion • The Edmonds-Karp implementation of the Ford-Fulkerson approach computes maximum flows in time Zeit O(m2n)

  12. Maximum Matching • Inputs are undirected unweighted bipartite graphs G • A matching in G us a set of edges in which no vertex is in more than 1 edge • We look for a maximum matching in G

  13. Computing Max Matchings • Reduce the problem to Max Flow

  14. Finding large matchings • Introduce new vertices s,t • U,V are vertices of the bipartite graph • Edges: • (s,u) for all u in U • (v,t) for all v in V • (u,v) as in G • All capacities are 1

  15. Finding large matchings • The Max Flow Min Cut theorem implies that the maximum flow in the graph is equal to the maximum matching

  16. Finding large matchings • Problem: flows across edges are not integers • Definition: a flow is integral, if all f(u,v) are integers • Claim: • If M is a matching in G ist, then there is an integral flow f in the flow network for G, such that |f|=|M| • Conversely, for an integral flow f there is a matching gibt es ein matching with |f|=|M|

  17. Proof • 1) Matching to Flow • Define flow as follows: • f(u,v)=1 if (u,v) in the matching, also f(v,u)=-1, f(s,u)=1, f(v,t)=1 etc. • all other edges: f(u,v)=0 • This is a legal flow • Value is |M|

  18. Proof • 2) Flow to Matching • Let f be an integral flow • Set M={(u,v) with f(u,v)> 0} • C(s,u)=1, hence f(s,u)2{0,1} • f(u,v)2{0,1} • For u there is at most one v with f(u,v)=1 • M is a matching • |M|= |f|

  19. Integrality • TheoremIf all C(u,v) are integers, and a maximum flow is computed with Ford Fulkerson, then |f| and all f(u,v) are integers • Corollary: Maximum Bipartite Matchings can be computed in time O(m2n) And in time O(mn):Ford Fulkerson time O(|f|m) for the max flow f, and |f|· n • Better algorithm can do it in m sqrt n (Hopcroft Karp) • Proof: • Induction over the iterations • First iteration: there is an augmenting path with integral capacity Cp(f) • Nf is also a network with integral capacities

  20. Conclusion • Algorithm Design Techniques: • Divide and Conquer • Greedy • Dynamic Programming • Problems: • Sequences: Search, Sort, Compare • Graphs: • traversing graphs (BFS,DFS,Euler tours) • Spanning trees, shortest paths, Max Flow • Datastructures: • Lists, stacks, queues, priority queues, union find

More Related