6.854J / J Advanced Algorithms Fall 2008

Transcription

1 MIT OpeCourseWare J / J Advaced Algorithms Fall 2008 For iformatio about citig these materials or our Terms of Use, visit:

2 18.415/6.854 Advaced Algorithms September 17, 2008 Lecturer: Michel X. Goemas Lecture 5 Today, we cotiue the discussio of the miimum cost circulatio problem. We first review the Goldberg-Tarja algorithm, ad improve it by allowig more flexibility i the selectio of cycles. This gives the Cacel-ad-Tighte algorithm. We also itroduce splay trees, a data structure which we will use to create aother data structure, dyamic trees, that will further improve the ruig time of the algorithm. 1 Review of the Goldberg-Tarja Algorithm Recall the algorithm of Golberg ad Tarja for solvig the miimum cost circulatio problem: 1. Iitialize the flow with f = Repeatedly push flow alog the miimum mea cost cycle Γ i the residual graph G f, util o egative cycles exist. We used the otatio µ(f) = mi cycle Γ E f c(γ) Γ to deote the miimum mea cost of a cycle i the residual graph G f. I each iteratio of the algorithm, we push as much flow as possible alog the miimum mea cost cycle, util µ(f) 0. We used ɛ(f) to deote the miimum ɛ such that f is ɛ-optimal. I other words ɛ(f) = mi{ɛ : potetial p : V R such that c p (v, w) ɛ for all edges (v, w) E f }. We proved that for all circulatios f, ɛ(f) = µ(f). A cosequece of this equality is that there exists a potetial p such that ay miimum mea cost cycle Γ satisfies c p (v, w) = ɛ(f) = µ(f) for all (v, w) Γ, sice the cost of each edge is bouded below by mea cost of the cycle. 1.1 Aalysis of Goldberg-Tarja Let us recall the aalysis of the above algorithm. This will help us to improve the algorithm i order to achieve a better ruig time. Please refer to the previous lecture for the details of the aalysis. We used ɛ(f) as a idicatio of how close we are to the optimal solutio. We showed that ɛ(f) is a o-icreasig quatity, that is, if f is obtaied by f after a sigle iteratio, the ɛ(f ) ɛ(f). It remais to show that ɛ(f) decreases sigificatly after several iteratios. Lemma 1 Let f be ay circulatio, ad f be the circulatio obtaied after m iteratios of the Goldberg-Tarja algorithm. The ( ) 1 ɛ(f ) 1 ɛ(f). We showed that if the costs are all iteger valued, the we are doe as soo as we reach ɛ(f) < 1. Usig these two facts, we showed that the umber of iteratios of the above algorithm is at most O(m log(c)). A alterative aalysis usig ɛ-fixed edges provides a strogly polyomial boud of O(m 2 log ) iteratios. Fially, the ruig time per a sigle iteratio is O(m) usig a variat of Bellma-Ford (see problem set). 5-1

3 1.2 Towards a faster algorithm I the above algorithm, a sigificat amout of time is used to compute the miimum cost cycle. This is uecessary, as our goal is simply to cacel eough edges i order to achieve a sigificat improvemet i ɛ oce every several iteratios. We ca improve the algorithm by usig a more flexible selectio of cycles to cacel. The idea of the Cacel-ad-Tighte algorithm is to push flows alog cycles cosistig etirely of egative cost edges. For a give potetial p, we push as much flow as possible alog cycles of this form, util o more such cycles exist, at which poit we update p ad repeat. 2 Cacel-ad-Tighte 2.1 Descriptio of the Algorithm Defiitio 1 A edge is admissible with respect to a potetial p if c p (v, w) < 0. A cycle Γ is admissible if all the edges of Γ are admissible. Cacel ad Tighte Algorithm (Goldberg ad Tarja): 1. Iitializatio: f 0, p 0, ɛ max (v,w) E c(v, w), so that f is ɛ-optimal respect to p. 2. While f is ot optimum, i.e., G f cotais a egative cost cycle, do: (a) Cacel: While G f cotais a cycle Γ which is admissible with respect to p, push as much flow as possible alog Γ. (b) Tighte: Update p to p ad ɛ to ɛ (, where ) p ad ɛ are chose such that c p (v, w) ɛ for all edges (v, w) E f ad ɛ 1 1 ɛ. Remark 1 We do ot update the potetial p every time we push a flow. The potetial p gets updated i the tighte step after possibly several flows are pushed through i the Cacel step. Remark 2 I the tighte step, we do ot eed to fid p ad ɛ such that ɛ is as small as possible; it is oly ecessary to decrease ɛ by a factor of at least 1 1. However, i practice, oe tries to decrease ɛ by a smaller factor i order to obtai a better ruig time. Why is it always possible to obtai improvemet factor of 1 1 i each iteratio? This is guarateed by the followig result, whose proof is similar to the proof used i the aalysis durig the previous lecture. Lemma 2 Let f be a circulatio ad f be the circulatio obtaied by performig the Cacel step. The we cacel at most m cycles, ad ( ) 1 ɛ(f ) 1 ɛ(f). Proof: Sice we oly cacel admissible edges, after ay cycle is caceled i the Cacel step: All ew edges i the residual graph are o-admissible, sice the edge costs are skew-symmetric; At least oe admissible edge is removed from the residual graph, sice we push the maximum possible amout of flow through the cycle. 5-2

4 Sice we begi with at most m admissible edges, we caot cacel more tha m cycles, as each cycle cacelig reduces the umber of admissible edges by at least oe. After the cacel step, every cycle Γ cotais at least oe o-admissible edge, say (u 1, v 1 ) Γ with c p (u 1, v 1 ) 0. The the mea cost of Γ is ( ) ( ) c(γ) 1 c p (u, v) ( Γ 1) ɛ(f) = 1 1 ɛ(f) 1 1 ɛ(f). Γ Γ Γ Γ (u1,v 1 )=(u,v) Γ ( ) Therefore, ɛ(f ) = µ(f 1 ) 1 ɛ(f). 2.2 Implemetatio ad Aalysis of Ruig Time Tighte Step We first discuss the Tighte step of the Cacel-ad-Tighte algorithm. I this step, we wish to fid a ew potetial ( ) fuctio p ad a costat ɛ such that c p (v, w) ɛ for all edges (v, w) E f ad ɛ 1 1 ɛ. We ca fid the smallest possible ɛ i O(m) time by usig a variat of the Bellma-Ford algorithm. However, sice we do ot actually eed to fid the best possible ɛ, it is possible to vastly reduce the ruig time of the Tighte step to O(), as follows. Whe the Cacel step termiates, there are o cycles i the admissible graph G a = (V, A), the subgraph of the residual graph with oly the admissible edges. This implies that there exists a topological sort of the admissible graph. Recall that a topological sort of a directed acyclic graph is a liear orderig l : V {1,..., } of its vertices such that l(v) < l(w) if (v, w) is a edge of the graph; it ca be achieved i O(m) time usig a stadard topological sort algorithm (see, e.g., CLRS page 550). This liear orderig eables us to defie a ew potetial fuctio p by the equatio p (v) = p(v) l(v)ɛ/. We claim that this potetial fuctio satisfies our desired properties. Claim 3 The ew potetial fuctio p (v) = p(v) l(v)ɛ/ satisfies the property that f is ɛ -optimal with respect to p for some costat ɛ (1 1/)ɛ. Proof: Let (v, w) E f, the c p (v, w) = c(v, w) + p (v) p (w) = c(v, w) + p(v) l(v)ɛ/ p(w) + l(w)ɛ/ = c p (v, w) + (l(w) l(v))ɛ/. We cosider two cases, depedig o whether or ot l(v) < l(w). Case 1: l(v) < l(w). The c p (v, w) = c p (v, w) + (l(w) l(v))ɛ/ ɛ + ɛ/ = (1 1/)ɛ. Case 2: l(v) > l(w), so that (v, w) is ot a admissible edge. The c p (v, w) = c p (v, w) + (l(w) l(v))ɛ/ 0 ( 1)ɛ/ = (1 1/)ɛ. I either case, we see that f is ɛ -optimal with respect to p, where ɛ (1 1/)ɛ. 5-3

5 2.2.2 Cacel Step We ow shift our attetio to the implemetatio ad aalysis of the Cacel step. Naïvely, it takes O(m) time to fid a cycle i the admissible graph G a = (V, A) (e.g., usig Depth-First Search) ad push flow alog it. Usig a more careful implemetatio of the Cacel step, we shall show that each cycle i the admissible graph ca be foud i a amortized time of O(). We use a Depth-First Search (DFS) approach, pushig as much flow as possible alog a admissible cycle ad removig saturated edges, as well as removig edges from the admissible graph wheever we determie that they are ot part of ay cycle. Our algorithm is as follows: Cacel(G a = (V, A)): Choose a arbitrary vertex u V, ad begi a DFS rooted at u. 1. If we reach a vertex v that has o outgoig edges, the we backtrack, deletig from A the edges that we backtrack alog, util we fid a acestor r of v for which there is aother child to explore. (Notice that every edge we backtrack alog caot be part of ay cycle.) Cotiue the DFS by explorig paths outgoig from r. 2. If we fid a cycle Γ, the we push the maximum possible flow through it. This causes at least oe edge alog Γ to be saturated. We remove the saturated edges from A, ad start the depth-first-search from scratch usig G a = (V, A ), where A deotes A with the saturated edges removed. Every edge that is ot part of ay cycle is visited at most twice (sice it is removed from the admissible graph the secod time), so the time take to remove edges that are ot part of ay cycle is O(m). Sice there are vertices i the graph, it takes O() time to fid a cycle (excludig the time take to traverse edges that are ot part of ay cycle), determie the maximum flow that we ca push through it, ad update the flow i each of its edges. Sice at least oe edge of A is saturated ad removed every time we fid a cycle, it follows that we fid at most m cycles. Hece, the total ruig time of the Cacel step is O(m + m) = O(m) Overall Ruig Time From the above aalysis, we see that the Cacel step requires O(m) time per iteratio, whereas the Tighte step oly requires O(m) time per iteratio. I the previous lecture, we determied that the Cacel-ad-Tighte algorithm requires O(mi( log(c), m log )) iteratios. Hece the overall ruig time is O(mi(m 2 log(c), m 2 2 log )). Over the course of the ext few lectures, we will develop data structures that will eable us to reduce the ruig time of a sigle Cacel step from O(m) to O(m log ). Usig dyamic trees, we ca reduce the ruig time of the Cacel step to a amortized time of O(log ) per cycle caceled. This will reduce the overall ruig time to O(mi(m log(c) log, m 2 log 2 )). 3 Biary Search Trees I this sectio, we review some of the basic properties of biary search trees ad the operatios they support, before itroducig splay trees. A Biary Search Tree (BST) is a data structure that maitais a dictioary. It stores a collectio of objects with ordered keys. For a object (or ode) x, we use key[x] to deote the key of x. Property of a BST. The followig ivariat must always be satisfied i a BST: If y lies i the left subtree of x, the key[y] key[x] If z lies i the right subtree of x, the key[z] key[x] 5-4

6 Operatios o a BST. Here are some operatios typically supported by a BST: Fid(k): Determies whether the BST cotais a object x with key[x] = k; if so, returs the object, ad if ot, returs false. Isert(x): Iserts a ew ode x ito the tree. Delete(x): Deletes x from the tree. Mi: Fids the ode with the miimum key from the tree. Max: Fids the ode with the miimum key from the tree. Successor(x): Fid the ode with the smallest key greater tha key[x]. Predecessor(x): Fid the ode with the greatest key less tha key[x]. Split(x): Returs two BSTs: oe cotaiig all the odes y where key[y] < key[x], ad the other cotaiig all the odes z where key[z] key[x]. Joi(T 1, x, T 2 ): Give two BSTs T 1 ad T 2, where all the keys i T 1 are at most key[x], ad all the keys i T 2 are at least key[x], returs a BST cotaiig T 1, x ad T 2. For example, the procedure Fid(k) ca be implemeted by traversig through the tree, ad brachig to the left (resp. right) if the curret ode has key greater tha (resp. less tha) k. The ruig time for may of these operatios is liear i the height of the tree, which ca be as high as O() i the worst case, where is the umber of odes i the tree. A balaced BST is a BST whose height is maitaied at O(log ), so that the above operatios ca be ru i O(log ) time. Examples of BSTs iclude Red-Black trees, AVL trees, ad B-trees. I the ext lecture, we will discuss a data structure called splay trees, which is a self-balacig BST with amortized cost of O(log ) per operatio. The idea is that every time a ode is accessed, it gets pushed up to the root of the tree. The basic operatios of a splay tree are rotatios. They are illustrated the followig diagram. y x x zig (right rotatio) y C zag (left rotatio) A A B B C 5-5