Sorting signed permutations by reversals, revisited

Transcription

1 Journal of Computer and System Scences 70 (2005) Sortng sgned permutatons by reversals, revsted Ham Kaplan, Elad Verbn School of Computer Scence, Tel Avv Unversty, Tel Avv, Israel Receved 7 August 2003; receved n revsed form 16 September 2004 Abstract The problem of sortng sgned permutatons by reversals (SBR) s a fundamental problem n computatonal molecular bology. The goal s, gven a sgned permutaton, to fnd a shortest sequence of reversals that transforms t nto the postve dentty permutaton, where a reversal s the operaton of takng a segment of the permutaton, reversng t, and flppng the sgns of ts elements. In ths paper we descrbe a randomzed algorthm for SBR. The algorthm tres to sort the permutaton by repeatedly performng a random orented reversal. Ths process s n fact a random walk on the graph where permutatons are the nodes and an arc from π to π corresponds to an orented reversal that transforms π to π. We show that f ths random walk stops at the dentty permutaton, then we have found a shortest sequence. We gve emprcal evdence that ths process ndeed succeeds wth hgh probablty on a random permutaton. To mplement our algorthm we descrbe a data structure to mantan a permutaton, that allows to draw an orented reversal unformly at random, and perform t n sub-lnear tme. Wth ths data structure we can mplement the random walk n O(n 3/2 log n) tme, thus obtanng an algorthm for SBR that almost always runs n subquadratc tme. The data structures we present may also be of ndependent nterest for developng other algorthms for SBR, and for other problems. Fnally, we present the frst effcent parallel algorthm for SBR. We obtan ths result by developng a fast mplementaton of the recent algorthm of Bergeron (Proceedngs of CPM, 2001, pp ) for sortng sgned permutatons by reversals that s parallelzable. Our mplementaton runs n O(n 2 log n) tme on a regular RAM, and n O(nlog n) tme on a PRAM usng n processors Elsever Inc. All rghts reserved. Keywords: Sortng by reversals; Genome rearrangements; Random algorthms; Parallel algorthms A prelmnary verson of ths paper has appeared as [18]. Ths work was partally supported by German Israel Foundaton (GIF) Grant no /2002, and Israel Scence Foundaton (ISF) Grant no Correspondng author. E-mal address: hamk@cs.tau.ac.l (H. Kaplan) /$ - see front matter 2005 Elsever Inc. All rghts reserved. do: /j.jcss

2 322 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) Introducton A permutaton over 1,...,n, where each element has a sgn, + or, s called a sgned permutaton. The problem of sortng sgned permutatons by reversals (SBR) s defned as follows. Gven a sgned permutaton, fnd a shortest sequence of reversals that transforms t to the postve dentty permutaton, d = (+1,...,+n), where a reversal s the operaton of takng a segment of the permutaton, reversng t, and flppng the sgns of ts elements. The reversal ρ(, j) transforms π = (π 1,...,π n ) nto π = (π 1,...,π 1, π j, π j 1,..., π, π j+1,...,π n ). The length of such a shortest sequence of reversals s denoted d(π), and called the reversal dstance of π from d. Ths problem of sortng sgned permutatons by reversals s of great nterest n computatonal bology, because t allows one to fnd a possble evolutonary path that transformed one speces nto another. For more detals on ths applcaton see the book by Pevzner [22]. The unsgned varant of the problem, n whch we deal wth unsgned permutatons, s NP-hard [7]. Somewhat surprsngly, Hannenhall and Pevzner [14], showed n 1995 that the problem of sortng a sgned permutaton by reversals s n fact polynomal. They proved a dualty theorem that equates the reversal dstance wth the sum of three combnatoral parameters assocated wth the permutaton. Based on ths theorem, Hannenhall and Pevzner descrbed an algorthm that sorts sgned permutatons by reversals n O(n 4 ) tme. Kaplan, et al. [17] smplfed the underlyng combnatoral structure and descrbed an algorthm that fnds a shortest sortng sequence n O(n 2 ) tme. Bergeron [5] n 2001 smplfed the combnatoral structure even further and descrbed a somewhat dfferent algorthm that runs n O(n 3 ) tme (whch can be reduced to O(n 2 ) on a bt-vector machne). Unfortunately, Bergeron has not been able to use her smplfed analyss of the underlyng structure to beat the O(n 2 ) algorthm of Kaplan et al., whch was stll the asymptotcally fastest when a prelmnary verson of ths paper appeared [18]. Ozery-Flato and Shamr [21] showed that both Bergeron s algorthm and the algorthm of Kaplan, Shamr, and Tarjan have permutatons on whch they spend Ω(n 2 ) tme. Recently, Tanner and Sagot [28] managed to beat the O(n 2 ) bound and present an algorthm for SBR that runs n O(n 3/2 log n)-tme. Ths new algorthm use the data structure we develop here, together wth addtonal new deas. We further note that one can compute d(π) wthout a sequence that realzes t n lnear tme [2]. Medans et al. [20] consder the problem of sortng sgned crcular permutatons. They show that the reversal dstance of a sgned crcular permutaton π of n elements s equal to the reversal dstance of a correspondng sgned lnear permutaton π of n 1 elements. Furthermore, they show that π can be derved from π n lnear tme. Ths mples that all algorthms thus far, ncludng the ones we present here, can be used to sort crcular permutatons wthn the same tme bounds. We have not run tests on crcular permutatons, but we expect that the performance would be smlar. Our frst result n ths paper s a randomzed algorthm for sortng by reversals. Ths algorthm repeatedly executes a random-walk process, whch we call SBR-RandWalk. Each run of SBR-RandWalk ether fnds a mnmum sortng sequence or fals. Emprcal tests on SBR-RandWalk ndcate that the average over all permutatons of the expected number of tmes we need to run SBR-RandWalk to get a mnmum sortng sequence s a small constant (namely, 1.6). We consder these emprcal results to be qute strong, n the sense that they ndcate that the success probablty s ndependent of the sze of the

3 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) permutaton. However, we could not fnd any mathematcal proof of ths observed behavor and analyzng SBR-RandWalk theoretcally s an open problem. We also descrbe a data structure for representng a permutaton so that we can draw a random orented reversal and apply t n O( n log n) tme, thus obtanng an mplementaton of SBR-RandWalk that runs n tme O(n 3/2 log n). Combnng ths wth the emprcal study we conjecture that the expected runnng tme of our algorthm on a random permutaton s O(n 3/2 log n). Snce the publcaton of the prelmnary verson of ths paper varants of our data structure have been proved useful to obtan other results. Hartman n the upcomng journal verson of [15] used ths data structure to mprove the runnng tme of a 1.5-approxmaton algorthm for Sortng by Transpostons. Hartman and Sharan [16] used t to effcently mplement a 1.5-approxmaton algorthm for Sortng by Transpostons and Transreversals. Also, the recent breakthrough result by Tanner and Sagot [28] that gves a new O(n 3/2 log n)-tme algorthm for SBR uses a varant of our data structure. Fnally, we descrbe a fast seral mplementaton of the algorthm of Bergeron for solvng SBR. We obtan ths mplementaton by reducng the score calculatons n each teraton of the algorthm to a well-studed geometrc problem called 2-set pont domnance countng (2SDC) n the plane. By explotng known solutons to the 2SDC problem we obtan a smple mplementaton that runs n O(n 2 log n) tme. Furthermore, by explotng effcent parallel soluton to the 2SDC problem we can parallelze our mplementaton to run n O(nlog n) tme n the CREW PRAM model, usng O(n) processors. Ths s the frst effcent parallel soluton for sortng sgned permutatons by reversals. The structure of the rest of ths paper s as follows. Secton 2 gves some defntons. In Secton 3 we descrbe SBR-RandWalk. Secton 4 gves the results of our emprcal tests on SBR-RandWalk. In Secton 5 we descrbe our data structure. In Secton 6 we descrbe our parallel algorthm for SBR. We gve our conclusons n Secton Prelmnares We begn wth some defntons and background that wll be used throughout the paper. We wll always augment our permutatons by defnng π 0 =+0, π n+1 = n + 1. Ths s common practce n SBR papers, and allows us to avod some specal cases. Suppose we want to sort a sgned permutaton, π. Now, to sort the permutaton we must begn by locatng a reversal that transforms π nto π, where d(π ) = d(π) 1 such a reversal s called a safe reversal. The underlyng combnatoral theory (dscovered by Bafna and Pevzner [3] and refned n [14,17]) dstngushes a class of reversals called orented reversals. An orented reversal s a reversal that makes consecutve elements and + 1 of the permutaton adjacent and dentcally sgned. Specfcally, for some j we ether get π j = and π j+1 = + 1orπ j = ( + 1) and π j+1 = as a result of performng the reversal. (We gve a precse defnton and an example, shortly.) Gven an augmented sgned permutaton, π = (+0, π 1, π 2,...,π n,n+ 1), we consder pars (π, π j ) so that <jand π, π j are consecutve ntegers (that s, π π j =±1). Such a par s called an orented par f ts elements are of opposte sgns, and an unorented par otherwse. Conventonally, 0 s consdered to be postve. Note that there are exactly n + 1 pars n π, and that there are no orented pars ff the permutaton s postve (.e. all of ts elements are postve). The reversal ρ = ρ(, j), whch changes the permutaton π = (π 0, π 1,...,π n+1 ) nto ρ π = (π 0,...,π 1, π j, π j 1,..., π, π j+1,...,π n+1 ) s orented f ether π + π j+1 =+1orπ 1 +

4 324 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) π j = 1. Alternatvely, orented reversals can be derved from orented pars: f (π, π j ) s an orented par, then the reversal { ρ(, j 1) f π + π j =+1, ρ( + 1,j) f π + π j = 1, s an orented reversal; We can get all orented reversals ths way. Note that we get a specfc orented reversal from ether one or two dfferent orented pars. For example, n the permutaton π = (0, 4, 1, 3, 2, 5) there are exactly four orented pars: (0, 1), ( 1, 2), ( 4, 3), ( 4, 5), and exactly three orented reversals: ρ(1, 2), whch reverses the elements 4, 1, and ρ(2, 3) and ρ(1, 4), whch reverse 1, 3 and 4, 1, 3, 2, respectvely. Note that we got 1, 3 both when we wanted to make 3 adjacent to 4 and when we wanted to make 1 adjacent to 2, that s we got the same reversal from two dstnct pars. Let us present an mportant observaton: Proposton 1. A permutaton has an orented reversal ff t has a negatve element. The theory guarantees that: Proposton 2. If a permutaton has an orented reversal then t also has an orented reversal whch s safe. All exstng algorthms for solvng SBR nvest at least lnear tme n searchng for a safe orented reversal, performng t (.e. updatng the data structures so that they represent π rather than π), and repeatng the process. Snce the dstance of a permutaton s at most n + 2 (and s almost always Θ(n)) ths means that n order to get a sub-quadratc algorthm we must take a dfferent approach. Our approach wll be to choose a random orented reversal, and hope t s safe see Secton 3. There s one extra complcaton, though: For many permutatons the process of repeatedly pckng a safe orented reversal and applyng t wll ndeed generate a shortest sortng sequence. However, ths s not true for all permutatons. There are permutatons contanng structures called unorented components (whch we wll not defne here, see [17]), that ths process always fals to sort. For permutatons that contan unorented components all sequences of safe orented reversals termnate wth a permutaton that has no orented reversals (.e. a postve permutaton), but s not the dentty permutaton. The theory suggests algorthmc ways of handlng these specal permutatons: One can detect n lnear tme whether a permutaton contans unorented components or not. Furthermore, n case π contans unorented components one can fnd n lnear tme a good sequence of reversals that clears these components,.e. a sequence of t reversals that transforms π nto π that has no unorented components and d(π ) = d(π) t. It s also mportant to note that, accordng to the theory, an orented reversal s safe ff by applyng t we do not create new unorented components. The concluson from the background gven n the last paragraph s the followng observaton, whch s central to our algorthm: Observaton 3. If a sequence of orented reversals sorts a permutaton π, then t s a soluton for SBR on π.

5 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) Proof. If a sequence of orented reversals sorts π, then π contans no unorented components. Suppose, n contradcton, that one of the reversals n the sequence, was unsafe. Then t must create an unorented component whch cannot be later removed by orented reversals, and thus the sequence cannot be a sortng sequence (.e. one that ends wth the dentty permutaton). Therefore all reversals n the sequence are safe, and thus ths s a soluton for SBR on the permutaton. 3. Explotng randomzaton to sort by reversals The algorthm we defne n ths secton s motvated by the fact that, typcally, a very large porton of orented reversals are safe, and so we may be able to wave the complex task of fndng a safe orented reversal, nstead just pckng a random orented reversal and hopng t s safe. Exact calculatons done by Bergeron et al. [6, Theorem 4] show that for a random permutaton over n elements, the probablty that a randomly chosen orented reversal s unsafe s O(1/n 2 ). We next descrbe our algorthm. Gven a sgned permutaton, π, we frst clear the unorented components, f there are any, usng the method of [17]. To sort the cleared permutaton we terate the followng random walk -lke process, called SBR-RandWalk. Ths random walk repeatedly pcks a random orented reversal and apples t wthout botherng to check f t s safe or not. SBR-RandWalk repeats ths process untl t gets a permutaton wth no orented reversals,.e. a postve permutaton. The theory above, and Observaton 3 n partcular, mples that ths walk generates a shortest sortng sequence ff t ends wth the dentty permutaton. If SBR-RandWalk fals,.e. f we ended wth a postve permutaton that s not the dentty permutaton, we run SBR-RandWalk agan on the orgnal permutaton. If SBR-RandWalk fals f (n) tmes, where f (n) s some slowly growng functon of n, we resort to runnng one of the known algorthms (e.g. [17] or [5]) to sort the permutaton. The functon f (n) can be any functon that tends to as n, and only affects the worst-case runnng tme of the algorthm. For concreteness we use f (n) = log n. Alternatvely we can run a varant of ths procedure whch nstead of selectng a random orented reversal selects a random orented par and performs the orented reversal whch corresponds to t. Computatonally the two procedures are equvalent f we can select a random orented par then we can also select a random orented reversal n the same expected tme-complexty (up to a constant, of course), as follows: We pck a random orented par p that defnes an orented reversal ρ and check whether there s another orented par whch defnes ρ. If only one par defnes ρ, we return ρ. If two pars defne ρ, we flp a con; If the con comes out heads, we return ρ, and f tals, we pck at random a new orented par and repeat ths procedure. Clearly the average number of orented pars we need to draw to get a random orented reversal s no more than two. Lkewse, gven a method for choosng a random orented reversal we can select a random orented par n approxmately the same tme. It s easy to see that after at most n + 1 reversals SBR-RandWalk reaches a postve permutaton. However, a nave mplementaton of SBR-RandWalk would spend lnear tme per reversal. Ths mplementaton traverses the permutaton, fnds all orented reversals, and pcks one at random. Ths would gve us a total runnng tme of O(n 2 ). Another straghtforward mplementaton pcks a random orented par by drawng a random ndex [0,n] and checkng f the par whose elements are ± and ±( + 1) s orented. If t s, we select t; Otherwse, we draw another ndex and try agan. The latter method may be more effcent for some

6 326 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) permutatons, but there are permutatons for whch t stll takes Θ(n) expected tme to draw an orented reversal, n Θ(n) teratons, leadng to Θ(n 2 ) expected runnng tme on a worst case permutaton. 1 Fortunately, we found a data structure that mantans a sgned permutaton under reversals and allows us to draw a random orented reversal and perform t all n sub-lnear tme. In Secton 5.2 we descrbe ths data structure, whch allows us to draw a random orented reversal and perform t n tme O(n 1/2 log n). Usng ths representaton SBR-RandWalk can be mplemented to run n O(n 3/2 log n) tme n the worst case. Once we see that a sngle run of SBR-RandWalk can be mplemented to run n sub-quadratc tme, the next queston to ask s whether our suggested algorthm that repeats callng SBR-RandWalk up to f (n) tmes runs n sub-quadratc expected tme on the worst-case permutaton. Unfortunately ths s not the case. There are permutatons for whch wth very hgh probablty SBR-RandWalk fals a super-polynomal (n n) number of tmes. One such example s the permutaton π = (2, 4, 6,...,2k, 1, 3, 5,..., (2k 1)) of length n = 2k of Ozery-Flato and Shamr [21]. The reversal dstance of ths permutaton s n and no matter whch reversals we pck to sort t, throughout the sortng sequence we alternate between a permutaton n whch all orented reversals are safe (and symmetrc) and a permutaton wth exactly two orented reversals, only one of whch s safe. Therefore, the chances of succeedng n one run of SBR-RandWalk are extremely low, namely 1. 2 The probablty that we succeed n one out of f (n) 2 k trals s O( f(n) ) = O( log(2k) ) whch stll goes rapdly to zero wth k. So for ths permutaton our algorthm almost surely resorts to run one of the standard algorthms for SBR, both of whch take Ω(n 2 ) on 2 k 2 k most permutatons (ncludng ths one, see [21]). To conclude, the expected worst-case complexty of our algorthm s the same as the complexty of the fallback algorthm we choose to run. However, t could be that the permutatons for whch SBR-RandWalk fals f (n) tmes are rare and on a random permutaton the runnng tme s ndeed o(n 2 ). We address ths queston emprcally n the next secton. 4. Emprcal results and conjectures about SBR-RandWalk As prevously stated, we expect that teratng SBR-RandWalk would termnate fast for most permutatons. Ths s because typcally a large fracton of the orented reversals are safe. To support ths ntuton we measured emprcally the performance of our algorthm on random permutatons. Our results are summarzed n Table 1 and n Fg. 1. For a random permutaton wthout unorented components of sze rangng from 10 to 10,000 we estmated the probablty that a sngle run of SBR-RandWalk succeeds. We also estmated the average number of runs of SBR-RandWalk that our algorthm does untl t gets a sortng sequence. Specfcally, we drew many permutatons whle throwng away those that had unorented components (such permutatons are rare and have appeared only for smaller values of n). Then we ran SBR-RandWalk repeatedly untl success for each of the permutatons. Column 3 n Table 1 lsts the percentage of permutatons that were sorted n the frst run of SBR-RandWalk, and column 4 lsts the 1 One such example s a permutaton of Ozery-Flato and Shamr that wll be dscussed shortly. 2 Surprsngly, ths s not much better than an easly proved lower bound for the probablty of success of SBR-RandWalk on any permutaton wth no unorented components: That probablty s guaranteed to be at least 1 (n+1)!, snce the number of orented pars starts from at most n + 1 and decreases by at least 1 every tme a safe reversal s performed, and every permutaton wthout unorented components has at least one safe reversal.

7 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) Table 1 The performance of SBR-RandWalk on a random permutaton n Number of permutatons Percentage of success Average number of tested at frst try runs untl success ,000, ,000, ,000, ,000, ,000, , , , , Fg. 1. Dstrbuton over 100,000 permutatons of length 500 of the number of runs of SBR-RandWalk untl fndng a sortng sequence. The maxmum number of runs was 13. The frst dagram gves the number of permutatons whch were sorted after k runs for k = 1,...,13. For example, for 1213 permutatons, whch s about 1.2% of the sample, only the ffth run of SBR-Rand- Walk found a sortng sequence. The second dagram shows the same data n a logarthmc scale, so we could clearly see that the decay s roughly exponental. Smlar dstrbutons of other values of n look smlar to these. average over the selected permutatons of the number of runs of SBR-RandWalk untl fndng a sortng sequence. Fg. 1 shows the dstrbuton of the number of runs untl success for 100,000 permutatons of sze 500. Results for other values of n are smlar and exhbt the same decay. Note that Fg. 1 shows that the number of runs untl success decays exponentally. Ths hnts that an overwhelmng majorty of the permutatons are successfully sorted by SBR-RandWalk.

8 328 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) The conclusons from our experments are as follows: If we select a random permutaton that has no unorented component unformly of all such permutatons of sze n and run Procedure SBR-RandWalk on t once then t has about 0.63 chance of success, regardless of n. Also, for a specfc permutaton the chance of success of SBR-RandWalk s wellbehaved, and s for almost all permutatons between 0.55 and 0.75, also regardless of n (data not shown). If we select a permutaton as above and run SBR-RandWalk repeatedly untl we get a sortng sequence we wll need roughly 1.6 runs on average, also regardless of n. When runnng a varant of SBR-RandWalk that chooses a random orented par nstead of a random orented reversal we obtaned roughly the same results. We also obtaned smlar results when we ran on a random permutaton havng no adjacences (whch are, n some sense, the only permutatons of true sze n), both when choosng random orented reversals and when choosng random orented pars. We leave open the queston of fndng analytcal support to our expermental fndngs. We conjecture that the followng statement holds. Conjecture 4. The average number of runs of SBR-RandWalk needed to fnd a sortng sequence of a unformly chosen sgned permutaton wth no unorented components of sze n s O(1). 5. Data structures for handlng permutatons Exstng algorthms for SBR mantan the current permutaton va two ntegers arrays, one contanng π and the other contanng π 1 (that s, the nverse array, whch for each element gves ts locaton n π, dsregardng ts current sgn). Wth ths representaton we can locate elements of the permutaton n O(1) tme, but t takes tme proportonal to j to perform the reversal ρ(, j),.e. to update the arrays so that they represent the permutaton after performng the reversal. So n the worst case, when j s large, t takes Θ(n) tme to perform the reversal. It follows that any algorthm for SBR that looks for one reversal at a tme and runs n sub-quadratc tme must manpulate the permutaton va a better representaton that allows to perform a reversal n o(n) tme. For a dscusson of the drawbacks of current algorthms that solve SBR, see [21]. Alternatvely we could represent π and π 1 as doubly lnked lsts. Wth ths representaton we can perform a reversal n O(1) tme (gven access to ts endponts), but t s harder to locate a partcular element of the permutaton. In partcular, t s not clear how usng ths representaton one would draw a random orented reversal n sub-lnear tme. It follows that we cannot mplement SBR-RandWalk to run n sub-quadratc tme wth ether of these two obvous representatons. In ths secton we present alternatve representatons that do allow faster mplementaton of SBR-RandWalk. Any such representaton should support two basc operatons: (1) Draw a random orented reversal (or say that none exsts), (2) perform a reversal ρ on π, both n sub-lnear tme. To get started we show two smple representatons that allow three operatons: (1) query: locatng π gven, (2) nverse query: locatng π 1 gven, (3) performng a reversal, all n sub-lnear tme. Ths allows us to demonstrate the basc technques n a smpler setup. Later we show how to use these

9 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) technques to construct more complcated representatons that also allow to draw a random orented reversal n sub-lnear tme Mantanng the permutaton The two smple representatons we descrbe here are smlar to representatons of permutatons that were used by Chrobak et al. [8] and further nvestgated by Fredman et al. [13]. In both cases they were used to effcently mplement a common local mprovement heurstcs for the travellng salesman problem (lookng at a TSP tour as a permutaton over the vertex set of the graph). These data structures are qute practcal. The frst representaton s based on balanced bnary search trees. Usng ths representaton we can perform queres, nverse queres and reversals all n O(log n) tme. The second representaton s based on a partton of the permutaton nto blocks of sze Θ( n). Usng ths representaton we can perform queres n O(log n) tme, nverse queres n O(1) tme and reversals n O( n) tme. Our later data structure that allows to draw a random orented reversal borrows deas from both of these two smple structures Tree-based data structure A data structure as descrbed here can be based on any balanced search tree data structure that supports splt and concatenate operatons, such as splay trees [25], red black trees, 2 4 trees, and AVL trees. Fredman et al. used splay trees whch offer good constants and for whch the mplementatons of splt and concatenate are partcularly elegant. For smlar reasons our descrpton use splay trees as well. Snce splay trees have only logarthmc amortzed tme bounds, usng them, the runnng tme of our algorthm would be amortzed as well. We can obtan worst-case bounds usng a dfferent knd of search trees such as red black trees. In our representaton we hold a tree wth n nodes contanng the elements of the permutaton, such that an n-order traversal of the tree gves us the permutaton. We complcate matters by ntroducng a reverse flag for each node, whch, f turned on, ndcates that the subtree rooted at that node s read n reverse order, that s from rght to left, and the sgns of ts elements n t are flpped. Further reverse flags down the tree can once agan alter the order of the mpled permutaton. The nvarant we keep s that an n-order traversal of the tree, modfed by the reverse flags, always gves us the permutaton. Note that we can clear the reverse flag of an nternal node by exchangng ts chldren, flppng the reverse flag n each of these chldren, and flppng the sgn of the element resdng at the node. Ths procedure does not affect the permutaton represented by the tree. Smlarly, we can clear the reverse flag of a leaf by flppng the sgn of the element contaned n that leaf. One can vew ths procedure as pushng down the reverse flags. By clearng reverse flags we can mplement a rotaton n a splay tree so that t does not change the permutaton represented by the tree. Clearly a rotaton of an edge both whose endponts have reverse flags turned off does not change the permutaton. We perform a rotaton of an edge wth reverse flag turned on, n at least one of ts endpont, by frst clearng the reverse flags from the endponts of the edge beng rotated. Once we can mplement a rotaton n O(1) tme then we can perform all standard splay tree operatons ncludng splt and concatenate n O(log n) amortzed tme. To mplement queres on the permutaton we also mantan n each node the sze of ts subtree, and update these subtree szes when we do a rotaton. An example of the data structure s shown n Fg. 2.

10 330 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) rev 8 2 rev rev Fg. 2. A representaton of the permutaton π = (1, 2, 3, 4, 5, 6, 7, 8, 9). A rev besde a node means that the reverse flag of the node s on. Subtree szes are not shown. To fnd π we search for the th node n the (altered) n-order traversal usng subtree szes to drect the search. Snce we use splay trees, after the search the th node s the root of the tree. The element π s the element stored at the root f the reverse flag of the root s off, or mnus of that element, f the reverse flag of the root s on. Consder now an nverse query. That s, gven we want to fnd π 1 the ndex of ± n π. Suppose frst that we are gven a ponter to the node x contanng π n the splay tree representng the permutaton. Then we can fnd π 1 by splayng the node x. After the splay x s the root. If the reverse flag of x s off then π 1 s one larger than the subtree sze of the left chld of x, and f the reverse flag of x s on then π 1 s one larger than the subtree sze of the rght chld of x. We get the ponter to node x by keepng an addtonal array of ponters mappng an element to the node x contanng ±. Ths array s statc, as we keep each element nsde the same node at all tmes. Clearly the cost of the splay domnates the runnng tme of the nverse query, and therefore nverse query takes O(log n) amortzed tme. To execute a reversal ρ(, j) we splt the tree at the node correspondng to π j to a tree T 1 contanng all tems wth ndces at most j, and a tree T 2 contanng all tems wth ndces larger than j. Then we splt T 1 at π to a tree T 3 contanng all tems wth ndces smaller than and to a tree T 4 contanng all tems wth ndces at least. Fnally we flp the reverse flag of the root of T 4, concatenate T 3 to T 4 and concatenate the resultng tree to T 2. It s easy to see that the resultng tree represents the permutaton after we performed the reversal. Snce splay trees support splt and concatenate n O(log n) amortzed tme, we perform a reversal n O(log n) amortzed tme. Summng up, we get the followng theorem. Theorem 5. There exsts a data structure that mantans a (sgned) permutaton of n elements, such that we can fnd π, π 1, and perform a reversal ρ(, j), n logarthmc amortzed tme.the data structure s of sze lnear n n, and, gven a permutaton, one can ntalze t n lnear tme Block-based data structure The second data structure s n fact a two-level verson of the prevous structure. The structure s based on parttonng the permutaton nto blocks, each a contguous fragment of the permutaton of sze Θ( n). We assocate wth each block a reverse flag, whch, f on, ndcates that the block should be read n reversed drecton and the elements n t have opposte sgns. Ths way, we can reverse a block by

11 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) block lst element records blocks Fg. 3. A representaton of the permutaton π = (9, 8, 7, 6, 5, 4, 3, 2, 1). Note that we allow blocks szes to be between 2 and 6. The arrows represent the reverse flags. flppng ts reverse flag. We mantan the blocks n a lst. Wth each block we record ts sze, ts reverse flag, and a ponter to the lst of the tems t contans. Each tem ponts to the block contanng t. See Fg. 3. We also mantan the followng nvarant. Invarant 6. At the end of each operaton the number of elements n each block s between 1 2 n and 2 n. Note that ths mples that there are always Θ( n) blocks, each of sze Θ( n) Performng a reversal We perform a reversal ρ(, j) by the followng three steps: 1. We locate and j, and the blocks b() and b(j) contanng and j, respectvely. If b() contans elements that do not belong to the reversal then we splt b() nto two blocks: one that contans only elements that belong to the reversal, and the other contans only elements that do not belong to the reversal. Smlarly, we splt b(j) f t contans elements that do not belong to the reversal. Note that the new blocks may be small and therefore we may temporarly volate Invarant 6. We rensert the new blocks to the block-lst so that the blocks that contan the elements belongng to the reversal are consecutvely placed,.e. so that the data structure stll represents the same permutaton. 2. Now the reversal conssts of a subsequence of complete blocks. We reverse the order of these blocks n the block-lst, and flp ther reverse flags. It s easy to see that we now ndeed represent the permutaton after the reversal. 3. Fnally, we renstate Invarant 6 as follows. If one or more of the blocks that we have created n step (1) s of sze smaller than n 2, then we pck one such block and merge t wth one of ts neghbors. We repeat ths step untl no blocks are of sze smaller than n 2. Now some blocks may be larger than 2 n (but all are stll smaller than 3 n). We splt each such large blocks to two small ones that satsfy the Invarant 6. It s easy to see that usng our representaton we can perform these three steps n O( n) tme. Fg. 4 shows an example of ths process.

12 332 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) Fg. 4. Performng the reversal ρ(2, 8) on π = (9, 8, 7, 6, 5, 4, 3, 2, 1) results n π = (9, 2, 3, 4, 5, 6, 7, 8, 1). Note that we allow blocks szes to be between 2 and 6. The arrows represent the reverse flags Improvng query tmes It s easy to see how we can use ths data structure to answer queres and nverse queres n O( n) tme. However, we can speed up queres by mantanng the lst of blocks n a balanced search tree (of any knd), and representng the tems n each block n an array rather than a lnked lst. Wth each block n the search tree we mantan the total number of elements that resde n blocks n ts subtree. Usng ths representaton we can perform a query operaton n logarthmc tme: Gven we frst locate the block contanng π by a bnary search usng the tree representng the block lst. Then we can drectly access π n the array representng the block. It s also easy to see that we can update ths representaton n O( n) when we perform a reversal. We can mplement an nverse query n O(1) tme by mantanng wth each element ts ndex n the array representng ts block, and wth each block the total number of tems n blocks precedng t. To get the locaton π 1 of an element we add the ndex of wthn ts block to the prefx count of the block f the reverse flag of the block s off. Otherwse, we frst subtract the ndex of from the sze of the block to get the ndex of as f the block has been reversed, and then add t to the prefx count of the block. We thus proved the followng. As before, t s easy to check that we can update ths addtonal structure durng a reversal wthn the O( n) tme bound. Theorem 7. There exsts a data structure that mantans a (sgned) permutaton of n elements, and allows to fnd π gven n logarthmc tme, to fnd π 1 gven n constant tme, and to perform a reversal ρ(, j) n tme O( n). The data structure s of sze lnear n n, and, can be ntalzed n lnear tme Addng the ablty to draw a random orented par In ths secton we extend the data structures from Secton 5.1 so that we can draw an orented par unformly at random. Recall that n Secton 2 we showed how one can use a procedure that draws an orented par unformly at random to draw an orented reversal unformly at random wth only an expected

13 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) constant tme slowdown and vce versa. We draw pars snce they are easer to work wth: We can assocate a sngle par wth each specfc element of the permutaton. We present a data structure to mantan a sgned permutaton, that supports queres for π n logarthmc tme, queres for π 1 n O(1) tme, performng a reversal n O( n log n) tme, and drawng an orented par unformly at random n logarthmc tme. The data structure also allows to fnd the number of orented pars n π n constant tme, and requres lnear space. Note that for the purposes of mplementng SBR-RandWalk t suffces that we can draw a reversal and carry t out n O( n log n) tme. We can acheve that wthout the addtonal structure presented n Sectons and for speedng up queres The structure We buld upon the block-based structure of Secton 5.1.2, but add to each block a tree that stores the pars related to that block, and ther orentatons. We call each such tree a pars tree. See Fg. 5. Each pars tree s smlar to a sngle nstance of the data structure descrbed n Secton 5.1.1,.e. t s a balanced tree such as a splay tree. The pars tree of a block contans, for each element ±x n the block, the par whose elements are ±x and ±(x + 1). 3 Snce the element ±x belongs to the block, we refer to t as the local end of the par, and we refer to the element ±(x + 1) as the remote end of the par. The order of the pars n the tree s accordng to the order of ther remote ends along the permutaton. (That s, accordng to ncreasng order of π 1 (±(x + 1))). Thus gven an ndex j we can search for a par whose remote end mmedately precedng j n logarthmc tme. Wth each par n a pars tree we also store ts orentaton. Furthermore, each node n a pars tree has a reverse flag. If the reverse flag of a node v s on t means that the subtree T v rooted at v should be read n reverse order, and the orentatons of the pars n T v s opposte to what s ndcated by ther orentaton bts. As before, further reverse flags down the tree can agan alter the orentatons and the order of the pars. Thus, more precsely, our nvarant s that an n-order read that s approprately modfed by the reverse flags gves the remote ends of the pars n ncreasng order along the permutaton. In order to draw an orented reversal unformly at random we also keep wth each node v two counters. The frst counts the number of orented pars n the subtree rooted by v and the second counts the number of unorented pars n the subtree rooted by v. It s easy to see that the reverse flags and these counters can be mantaned whle dong a rotaton. Therefore we can perform all standard search tree operatons on a pars tree n logarthmc tme. Note that n partcular we mantan the total number of orented pars wthn each block. As n Secton each block has a reverse flag. Ths flag, f on, ndcates as before, that the order of the elements n the block s reversed and ther sgns are flpped. Furthermore, here t also ndcates that the orentatons (and not the order) of the pars assocated wth all of the block s elements (that s, the orentatons of the pars n the block s tree) are once agan opposte to what s ndcated by the tree correspondng to the block. Furthermore, n ths case the counters n all the nodes of the pars tree are n fact flpped. The counter of the orented pars stores the number of unorented pars n the correspondng subtree and vce versa. 4 For an example, see Fgs. 5 and 6. 3 Except, of course, for the element x = n + 1 whch does not have a par assocated wth t. 4 The reason for ths addtonal nterpretaton of the block s flag wll be clear when we descrbe how to perform a reversal.

14 334 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) or or (8,9) unor (10,11) or (7,8) (11,12) or or (2,3) (3,4) unor (1,2) unor (4,5) rev, unor (6,7) rev, or or (5,6) (9,10) Fg. 5. A representaton of the permutaton π = ( 11, 10, 4, 8, 2, 7, 1, 3, 9, 6, 12, 5). The arrows under the blocks represent the reverse flags of the blocks. A rev besde a node means that the reverse flag of the node s on. Note that both nodes n the frst block are labelled orented although the pars are unorented. Ths s because we defne the reversed flag of the block to also reverse the orentatons of all pars n the block. rev, or (1,2) rev, or or (7,8) (8,9) or unor (2,3) (4,5) unor (3,4) Fg. 6. Another representaton of the pars tree of the mddle block Query Searchng for π and π 1 n O( n) tme s straghtforward. As n Secton usng an addtonal search tree over the blocks, and usng arrays to represent the elements n each block we can reduce the tme of the queres Draw an orented reversal unformly at random The structure as descrbed so far already allows to draw a random orented reversal n O( n) tme. We do that by summng up the number of orented pars n all blocks. Then we draw an ndex of one of the pars unformly at random and locate the par, by frst locatng the block contanng t, and then fndng the par tself by searchng the par tree of the block tself. We can speed up ths process f we mantan a search tree over the blocks as ndcated n Secton Wth each block we also keep the total number of orented pars n the blocks of ts subtree. In partcular, we have the total number of orented pars n the permutaton at the root. Usng ths tree once we draw a random ndex of an orented par we can locate the block contanng the par, and the par tself n logarthmc tme Performng a reversal We perform a reversal ρ(, j) usng smlar steps as n Secton When blocks are splt and concatenated we rebuld the pars trees assocated wth them. Ths takes tme lnear n the sze of the trees nvolved, that s Θ( n).

15 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) In addton we have to update the pars trees (both those assocated wth blocks that are n the segment defnng the reversal and those assocated wth blocks that are out of the reversal) so that the orentatons and the order of pars nsde these trees wll correspond to the permutaton after the reversal (We may assume now that the reversal spans complete blocks, wthout fractons of blocks). To complete performng ρ(, j) we go over all blocks. For each block we splt ts pars tree nto at most three trees, much lke we dd n Theorem 5. The mddle tree contans all pars whose remote end s part of the reversal, and the other two trees wll contan the pars whose remote end s not n the reversal. We then flp the reverse flag of the root of the mddle tree, swtch the values of the counters of the orented and unorented reversals, and concatenate the trees n ther orgnal order. It s easy to see that the order of the pars n all trees s consstent wth the new permutaton. Consder the orentatons of the pars and the counters of orented and unorented pars at the nodes. For blocks outsde of the reversal these ndeed correspond to the new permutaton. However for blocks nsde the reversal the orentatons of the pars are exactly opposte of ther correct settng, and smlarly the counters of orented and unorented pars at the nodes are flpped. Ths s because n these blocks we flpped the orentaton of those pars wth both ends n the reversal and have not changed the orentaton of the others. Recall however that we expanded the role of the blocks reverse flags to ndcate that the orentatons of the block s pars are flpped. Therefore, snce we flp the reversal bt of the blocks n the reversal we ndeed have a correct representaton of the new permutaton. In case we mantan an addtonal tree over the blocks to speed up queres, and the draw of a random orented reversal, we have to update ths tree when we perform a reversal. Ths can be done easly wthn the tme bound as the sze of ths tree s O( n) A small adjustment We use block sze of Θ( n) n the structure of Secton to balance the cost of splttng and concatenatng the blocks contanng the ends of the reversal wth the cost of rearrangng the blocks themselves. In the structure we present here f we use blocks of sze Θ( n) then the cost of performng a reversal s Θ( n log n) snce we have to perform a constant number of operatons on each of the Θ( n) pars tree. However the cost of splttng and concatenatng a block s stll O( n). Ths ndcates that a block sze of Θ( n) s not optmal here and we would reduce the tme bound f we choose a slghtly larger block sze so that the total number of blocks decreases. n log n To get the best trade-off n ths data structure we mantan the szes of the blocks between 2 and 2 n log n. Ths makes the entre procedure of performng an orented reversal run n O( n log n) tme. It takes O( n log n) tme to perform the operatons on the part of the data structure that we nherted from Theorem 5.2, and addtonal O( n log n) tme to update Θ( n log n ) trees as outlned above, n logarthmc tme per tree. Thus we have proved the followng: Theorem 8. There exsts a data structure that mantans a (sgned) permutaton of n elements, supportng a query for π n logarthmc tme, a query for π 1 n constant tme, and allows to perform a reversal ρ(, j) n tme O( n log n). Ths data structure also allows to report the number of orented pars n

16 336 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) O(1) tme, and to draw an orented par unformly at random n O(log n) tme.the data structure s of sze lnear n n, and, gven a permutaton, we can ntalze t n lnear tme. 6. An effcent parallel algorthm for SBR In ths secton we present a new mplementaton of the algorthm of Bergeron [5] for the problem of sortng sgned permutatons by reversals. Our mplementaton s smple, and n contrast wth prevous algorthms t s parallelzable. The algorthm runs n O(n 2 log n) tme, and ts parallelzaton (on a CREW PRAM) runs n O(nlog n) tme usng n processors (.e. performs O(n 2 log n) work). We can easly adapt our algorthm to varous other parallel models, such as the reconfgurable mesh, wth smlar tme bounds. A PRAM (Parallel Random Access Machne) s a theoretcal model for a mult-processor computer. In ths model the number of processors s a resource that may grow wth the nput sze, and processors communcate va shared memory. A CREW (Concurrent Read, Exclusve Wrte) PRAM, s a specal case where a memory cell can be read by several processors at the same tme, but only one processor can wrte nto a memory cell at the same tme. See [12] for more nformaton on PRAMs. Let π be a permutaton and ρ an orented reversal of π. Bergeron defnes the score of ρ as the number of orented pars n ρ π, the permutaton that results from applyng ρ on π. We also defne the delta-score of ρ as the dfference between the number of orented pars n ρ π and the number of orented pars n π. A postve delta-score means that the amount of orented pars ncreases when the reversal s appled. We sometmes refer to the score of an orented par. By ths we mean the score of the reversal that s derved from the par. Bergeron proved the followng theorem: Theorem 9 (Bergeron [5]). Gven a permutaton π, each orented reversal of π wth maxmum score s a safe reversal. Based on ths Theorem, Bergeron suggested the followng algorthm to fnd a shortest sortng sequence of a sgned permutaton wth no unorented components. (Recall that unorented components can be cleared from π as e.g. n [17]. We also assume, as before, that π s extended wth 0 to the left and n + 1 to the rght). Whle (π = d) Choose an orented par wth maxmum score. Perform the reversal that corresponds to that par. Bergeron gave an O(n 2 ) tme mplementaton of her method on a bt-vector machne, 5 butonaram the only mplementaton suggested was the trval one, whch takes O(n 3 ) tme. In ths straghtforward mplementaton there are O(n) steps one for fndng each safe reversal; n each step we calculate scores of O(n) reversals, where each score calculaton takes O(n) tme. We wll show how the delta-scores of all orented reversals of a permutaton can be calculated n O(nlog n) tme, resultng n a O(n 2 log n) seral mplementaton of Bergeron s Method. Then we show 5 A bt-vector machne s a RAM that can operate on bt-vectors of sze O(n) n unt tme. In a sense, t s a parallel model too because a bt-vector machne actually models a computer wth one processor and one memory-pool but many ALUs (an ALU s the processor component that performs the actual arthmetc operatons).

17 H.Kaplan, E.Verbn / Journal of Computer and System Scences 70 (2005) j j j j j j j 2* Dom ((,)) Dom ((j,j)) Dom ((,j)) f (ρ) Fg. 7. Graphcal Representaton of Eqs. (1) and (2). how to parallelze ths mplementaton, so that calculatng the delta-scores of all orented reversals takes O(log n) tme usng n processors. Ths yelds an O(nlog n)-tme CREW-PRAM algorthm for SBR that runs on n processors. Frst note that there s a natural correspondence between the pars of a permutaton and ponts of the grd [1,n] 2, whereby the par (π, π j ) s dentfed wth the pont (, j). Note that snce, by our defnton of a par, <j, then all ponts correspondng to the pars le above the lne = j. A reversal and a par are sad to be overlappng when the reversal contans one element of the par but not the other. It s easy to see that a reversal turns every orented par that overlaps wth t to unorented, and turns every unorented par that overlaps wth t to orented. We denote by f O (ρ) (resp. f U (ρ)) the number of newly orented (resp. unorented) pars created by applyng ρ. The dfference f O (ρ) f U (ρ) s the delta-score of ρ, and Theorem 9 mples that argmax ρ (f O (ρ) f U (ρ)) s safe. To calculate delta-scores we wll fnd for each orented reversal, how many orented and unorented pars t overlaps wth Reducng the score calculaton to two-set domnance countng We reduce the problem of fndng, for each orented reversal, how many orented and unorented pars t overlaps to a well-known problem n computatonal geometry called 2-set pont domnance countng n the plane (2SDC). The 2SDC problem s defned as follows. Let be the relaton on R 2 where (x 1,y 1 ) (x 2,y 2 ) ff (x 2 < x 1 ) (y 1 < y 2 ). 6 Gven two sets, A, B R 2, of total sze n, the 2SDC problem s to compute for each pont (x 1,y 1 ) A, the number Dom((x 1,y 1 ), B) {(x 2,y 2 ) B s.t. (x 1,y 1 ) (x 2,y 2 )}. Let B O be the set of ponts correspondng to orented pars, and let B U be the set of ponts correspondng to unorented pars. It s easy to verfy that for a reversal ρ = ρ(, j) and f U (ρ) = Dom((, ), B O ) + Dom((j, j), B O ) 2 Dom((, j), B O ) (1) f O (ρ) = Dom((, ), B U ) + Dom((j, j), B U ) 2 Dom((, j), B U ). (2) Ths s depcted n Fg. 7. Let A be the set that contans, for each orented reversal ρ = ρ(, j) of π the ponts (, ), (j, j) and (, j). It follows from Eqs. (1) and (2) that by solvng the 2SDC problem once for A and B = B U and also for A and B = B O, we can calculate f U (ρ) and f O (ρ), and delta-score(ρ) = f O (ρ) f U (ρ) for every ρ A from the results of the 2SDC computaton n lnear tme. 6 Note the non-standard, asymmetrc, defnton of. Ths s done to ease the presentaton later on.