1 Introduction. 2 The Generic Push-Relabel Algorithm. Improvements on the Push-Relabel Method: Excess Scaling. 2.1 Definitions CMSC 29700

Transcription

1 CMSC 9700 Supervised Reading & Research Week 6: May 17, 013 Improvements on the Push-Relabel Method: Excess Scaling Rahul Mehta 1 Introduction We now know about both the methods based on the idea of Ford and Fulkerson (which gave rise to Edmonds and Karp s algorithm, as well as others) in addition to the PUSH-RELABEL method of Goldberg and Tarjan. However, we see that both of these algorithms have a bottleneck procedure; for Ford and Fulkerson s algorithm, efficiently finding good augmenting paths is a challenge that many have worked on (for a comprehensive list refer to []). For push-relabel algorithms, the bottleneck procedure has always been reducing the amount of nonsaturating pushes executed in the main body of the algorithm. The Relablel-to-Front algorithm reduced the number of nonsaturatng pushes to O(n 3 ) through using a FIFO vertex selection rule [], while Goldberg and Tarjan improved the running time of their original algorithm to O(mn + log(n /m)) by using Sleator and Tarjan s Dynamic Trees data structure to maintain the dynamic transitive closure of the flow network [1]. In this paper, Ahuja and Orlin further improve the running time of the push-relabel method by employing a scaling technique first developed by Edmonds and Karp [3], which introduced the concept of -scaling phases as a method of considering only a certain subset of arcs and/or vertices in the residual flow network G f. In this synopsis, we will first examine the generic push-relabel algorithm and take note of certain facts surrounding its time complexity. Then, we will consider the original scaling technique demonstrated by Edmonds and Karp in [3], and show how their notion of -scaling phases allows a significant improvement to be made in finding good augmenting paths. Finally, we show how Ahuja and Orlin modified this scaling technique to create an ingenious vertex selection rule for the push-relabel algorithms in [1]. The Generic Push-Relabel Algorithm As previously shown, the generic PUSH-RELABEL algorithm maintains a preflow f in place of a feasible flow (as in Ford and Fulkerson s method). This allows flow to be pushed from vertex to vertex and eventually enables us to refine a preflow to a feasible flow. Further, by an important result that states whenever a preflow f and a distance labeling 1 d are compatible, an s t path P in G f. This allows us to see, intuitively, that upon termination, the feasible flow f is indeed a maximum flow by the Max-Flow Min-Cut Theorem of Ford and Fulkerson []. More formally, we define a preflow and a distance labeling as follows;.1 Definitions Definition 1. A preflow on a flow nework G = (V, A) with capacity function c : A R + is a function f : A R + that maintains the following two conditions: (1) f(a) c(a) (capacity) () a v f(a) v a f(a) 0 (permissibility of overflow) 1 This is known as a height function in texts like [], but will be called a distance labeling for the duration of this synopsis. 1

2 Condition () gives rise to a second definition. Definition. The excess of a vertex v is defined as the difference in incoming and outgoing flow. We will denote this as e(v). A vertex v is overflowing or active if e(v) > 0. Definition 3. A distance labeling is a function d : V Z 0 such that: (1) d(t) = 0 () d(u) d(v) + 1, a = (u, v) A f Definition 4. An arc is admissible if and only if a = (u, v) A f : d(u) = d(v) + 1. All of the push-relabel algorithms attempt to push flow through admissible arcs when working towards transforming a preflow f into a feasible flow.. Algorithm and Observations GENERIC-PUSH-RELABEL(G, s, t, c) // G = (V, A), s, t V, c : A R + 1 INITIALIZE(G, s) while v V : e(v) > 0 3 PUSH or RELBAEL v accordingly 4 return f We have already shown the correctness and time complexity of GENERIC-PUSH-RELABEL, but there are some certain facts that are central to the improvements presented here. Fact 1. GENERIC-PUSH-RELABEL terminates with a valid flow f, since e(v) = 0 v V. Further, since an s t path in G f, the valid flow f is in fact a maximum flow. Fact. v V, h(v) < n. Since we can bound the vertex heights, it follows that there are O(n ) relabelings throughout the execution of GENERIC-PUSH-RELABEL. Now, we will consider the invocations of PUSH throughout the main body of GENERIC-PUSH-RELABEL. We will divide them into two categories; saturating pushes, and nonsaturating pushes. Fact 3. There are O(mn) saturating pushes in GENERIC-PUSH-RELABEL. Fact 4. There are O(n m) nonsaturating pushes in GENERIC-PUSH-RELABEL. We are able to achieve this bound through bounding the value of the potential function ϕ = v:e(v)>0 h(v). The overall running time for GENERIC-PUSH-RELABEL is O(n m). From this, it is immediately apparent that the number of nonsaturating pushes is the bottleneck operation here. We can rewrite this time bound as O(mn + T (n, m)), where T (n, m) is the number of nonsaturating pushes executed throughout the procedure. Our goal for improving the running time of GENERIC-PUSH-RELABEL is now immediately apparent. 3 Methods of Scaling Goal: Find a way to reduce then number of nonsaturating pushes that are executed throughout the algorithm. In other words, describe an algorithm such that T (n, m) < O(n m). Idea: Our idea for reducing the number of nonsaturating pushes is an adaptation of a method described by Edmonds and Karp in [3] to speed up the process of finding good augmenting paths (in this case, good means high-capacity augmenting paths). We will first introduce Edmonds and Karp s scaling algorithm, and will then show how Ahuja and Orlin extended this concept to scaling nonsaturating pushes in [1].

3 3.1 The Original Edmonds-Karp Algorithm EDMONDS-KARP(G, s, t, c) 1 u, v V, f(u, v) = 0. construct G f from f 3 while an s t path P in G f 4 augment f along P 5 return f It has been shown that this algorithm runs in O(nm ) time when BFS is used to find the augmenting paths throughout execution. 3. Edmonds-Karp with Scaling However, we can improve the speed of the original EDMONDS-KARP algorithm by applying the following method; Consider some scaling factor K. If we are able to fix a value for K at each iteration of the algorithm, then we can find augmenting paths of at least capacity K in G f. This ensures that we have higher-capacity augmenting paths, and intuitively, that the algorithm terminates faster. Such an algorithm is described below. EDMONDS-KARP-SCALING(G, s, t, c) 1 u, v V, f(u, v) = 0 U = max{c(a) a A}, = lg U 3 while 1 4 while an s t path P of capacity in G f 5 augment f along P in G f 6 = / 7 return f The correctness argument for this procedure is similar to the original algorithm of Edmonds and Karp. It is omitted here for sake of brevity; for a complete correctness argument, see []. Lemma 1. EDMONDS-KARP-SCALING runs in O(m lg U) time. Proof. The procedure to find the augmenting path in a residual flow network based on G (which we will call G f ) was runs in O(m) time. Therefore, asserting that the inner while-loop runs only O(m) times for any given value of implies that only one augmentation will take place. We see that at any iteration, the max flow is at most m, and at each stage of augmentation, the flow will be augmented at least by. Therefore, each phase for augmentation takes only O(m) time. Due to the initialization of to be = lg U, we see that there will be at most m lg U flow augmentations. Further, we know that each augmentation will take O(m) time. Therefore, combining these two facts, we see that the overall running time is O(m lg U). Note: The fact that this algorithm s running time depends on U implies that it is only weakly polynomial. While in practice, this algorithm is quite efficient, especially when U = O(m), it still has the potential to be affected by a sufficiently large value of U. Consider the following flow network: 3

4 a s 1000 t b Although the maximum flow on the network is f = 4, lg 1000 = 10. This means that = 10 = 104 initially, as opposed to when considering only arcs with capacity. Although this is a specificallyconstructed example, this worst-case behavior is possible, and is a downside of having the running time dependent on the arc capacities. 4 Scaling in Push-Relabel Algorithms Several improvements have been made on the original PUSH-RELABEL algorithm. Several of these improvements use a FIFO vertex-selection rule for choosing vertices to push flow through [], while others make use of Sleater and Tarjan s dynamic trees data structure [1]. The FIFO algorithm (also known as RELABEL-TO-FRONT) runs in O(n 3 ) time, while the algorithm that makes use of the dynamic trees structure runs in O(mn + lg(n /m)). Clearly, Goldberg and Tarjan s contribution reduces the number of nonsaturating pushes to O(lg(n /m)). Here, Ahuja and Orlin are able to modify Edmonds and Karp s scaling technique to reduce the number of nonsaturating pushes to O(n lg U) [1]. Idea: We modify slightly the notion of a -scaling phase in terms of the push-relabel method. Instead of finding augmenting paths of capacity at least, we instead search for vertices where the excess e(v). This way, we are guaranteed to make large pushes throughout the execution of the algorithm relative to other vertices excesses. This allows us to improve the running time of the procedure by a significant factor. Below, we define the subroutines and the overall procedure for this algorithm. 4.1 Subroutines - Push, Relabel, and Select PUSH(u, v) // e(u) > 0 and (u, v) A f and d(u) = d(v) δ(u, v) = min{e(u), c f (u, v), e(v)} // If a = (u, v) is a forward arc if (u, v) A 3 f(u, v) = f(u, v) + δ(u, v) 4 else 5 f(v, u) = f(v, u) δ(u, v) 6 update e(u) and e(v) 7 if e(u) / 8 delete u from LIST[d(u)] 9 elseif u {s, t} and e(v) > / 10 add u to LIST[d(u)] 4

5 RELABEL(u) // e(u) > 0 1 delete u from LIST[d(u)] d(u) = 1 + min{d(v) (u, v) A f } 3 add u to LIST[d(u)] SELECT(u) 1 let (u, v) be the current arc of u, and found = FALSE while found TRUE and (u, v) NIL 3 if d(u) = d(v) + 1 then set found to TRUE 4 else replace (u, v) with the next arc adjacent to vertex u 5 if found = TRUE then PUSH(u, v) 6 else RELABEL(u) 4. The Ahuja-Orlin Algorithm The algorithm below utilizes the three subroutines from the previous section to implement a new maximum flow algorithm. AHUJA-ORLIN(G, s, t, c) 1 INITIALIZE(G, s) U = max{c(a) a A}, = lg U 3 while 1 4 while u V : e(u) / 5 let u = min{h(u) u V : e(u) /} 6 SELECT(u) to run either PUSH(u, v) or RELABEL(u) 7 = / 8 return f We will now prove two important facts about the AHUJA-ORLIN algorithm. First, we will show that the excess scaling algorithm satisfies two conditions vital to its running time, and then will show that the number of nonsaturating pushes that will occur at each -scaling phase is bounded above by 8n = O(n ). Lemma. The excess scaling algorithm satisfies the following two conditions: (1) Each nonsaturating push from u to v pushes at least / units of flow. () The excess of any vertex v does not increase more than after any push. Proof. For each push that sends flow through arc a = (u, v), we have e(u) / and e(v) /. This is due to the fact that u, according to our selection rule, is the node with the smallest distance labeling such that e(u) /. Further, since (u, v) is an admissible arc, d(j) = d(i) 1 < d(i). Therefore, we assign F = min{e(u), c f (u, v), e(v)} units of flow, which also is F min{ /, c f (u, v)}. Therefore, by this inequality, we see that we maintain (1) and send at least / units of flow in every nonsaturating push. Further, the push operation will only ever increase the excess flow at v after either a saturating or nonsaturating push. Let e (v) be the excess after a push operation. Then e (v) = e(v)+f e(v)+ e(v). Therefore, all node excesses remain less than or equal to after a push, and () is maintained. 5

6 Note: Conditions (1) and () allow us to see the push procedure, in the words of Ahuja and Orlin, as a restrained greedy approach. Intuitively, this means that in a push from u to v, u shows restraint. Instead of discharging all of its excess flow, u discharges as much flow as it can without causing e(v) to exceed. Lemma 3. If conditions (1) and () from Lemma are satisfied, then the number of nonsaturating pushes per scaling phase is at most 8n = O(n ). Proof. In a manner similar to Goldberg and Tarjan s initial analysis of nonsaturating pushes in GENERIC-PUSH-RELABEL, we will use a potential function to find an upper bound. Let ϕ be defined as follows: ϕ = e(u) d(u) u V The initial value of ϕ at the beginning of a -scaling phase is bounded by n. This is because e(u) at the beginning of a scaling phase, and that d(u) < n by Fact. When vertex u is considered, there are two cases that can occur. Case 1: an admissible arc (u, v) leaving u. This occurs when the current arc of u reaches the end of the list, and that all other arcs are found to be inadmissible. The arc remains inadmissible until u is relabeled and d(u) increases. A relabeling will increase ϕ by at least 1 unit. Since the total increase in d(u) is less than n for every u V, the total increase in ϕ is bounded by n in the scaling iteration. Case : The algorithm finds an admissible arc (u, v), and conducts either a saturating or nonsaturating push. In either case, it is obvious that ϕ decreases since e(u) will decrease. A nonsaturating push sends at least / units of flow, and since d(u) = d(v) + 1 d(v) = d(u) 1, ϕ decreases by at least 1/ units. As the initial value of ϕ is at most 4n, this will not occur more than 8n times. We see that this case dominates, so there are 8n = O(n ) nonsaturating pushes. Observation: There are lg U -scaling iterations throughout AHUJA-ORLIN. This is immediately obvious, since is initialized to lg U, and at the end of each scaling phase, = /. This means that there will be lg U scaling phases. Theorem 1. The complexity of AHUJA-ORLIN is O(mn + n lg U). Proof. This immediately follows from Lemma 3 as well as our previous observation. We cannot say obviously whether or not O(mn) dominates over O(n lg U) or not, since U is not directly proportional to either m or n. Therefore, the overall time complexity is O(mn + n lg U). References [1] R. K. Ahuja and James B. Orlin, A fast and simple algorithm for the maximum flow problem, Operations Research 37 (1989), no. 5, pp (English). [] T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to algorithms, 3rd ed., The MIT Press, 009. [3] Jack Edmonds and Richard M. Karp, Theoretical improvements in algorithmic efficiency for network flow problems, J. ACM 19 (197), no.,