Approximation Algorithms for Sorting λ -Permutations by λ -Operations

: Understanding how different two organisms are is one question addressed by the compar-ative genomics ﬁeld. A well-accepted way to estimate the evolutionary distance between genomes of two organisms is ﬁnding the rearrangement distance, which is the smallest number of rearrangements needed to transform one genome into another. By representing genomes as permutations, one of them can be represented as the identity permutation, and, so, we reduce the problem of transforming one permutation into another to the problem of sorting a permutation using the minimum number of rearrangements. This work investigates the problems of sorting permutations using reversals and/or transpositions, with some additional restrictions of biological relevance. Given a value λ , the problem now is how to sort a λ -permutation, which is a permutation whose elements are less than λ positions away from their correct places (regarding the identity), by applying the minimum number of rearrangements. Each λ -rearrangement must have size, at most, λ , and, when applied to a λ -permutation, the result should also be a λ -permutation. We present algorithms with approximation factors of O ( λ 2 ) , O ( λ ) , and O ( 1 ) for the problems of Sorting λ -Permutations by λ -Reversals, by λ -Transpositions, and by both operations.


Introduction
One challenge in biology is to understand how species evolve, considering that new organisms arise from mutations that occurred in others. Using the principle of parsimony, the minimum number of rearrangements that transform one genome into another, called rearrangement distance, is a widely adopted way to estimate the evolutionary distance between two genomes. A genome rearrangement is a global mutation that alters the order and the orientation of the genes in a genome.
Depending on the genomic information available and the problems considered, a genome can be modeled in different ways. Considering that a genome has no repeated genes, we can model it as a permutation, with each element representing a gene. Each gene has an orientation inside the genome. Gene orientation is represented by a plus or minus sign in each element of the permutation. In this case, we say that the permutation is signed. Due to mapping problems in the genome, orientation information could not be available. In this scenario, we use unsigned permutations to represent the genomes. By representing one of the genomes as the identity permutation, we reduce the problem of transforming one permutation into another to the problem of sorting a permutation with the minimum number of rearrangements, which is called sorting rearrangement distance or simply distance.
A rearrangement model M is the set of valid rearrangements used to calculate the distance. A reversal rearrangement inverts a segment of the genome, and a transposition
We assume that there are two extra elements π 0 = 0 and π n+1 = n + 1 in π, but, for convenience, they are omitted from the permutation's representation. Given an integer λ ≥ 2 as input, we say that π is a λ-permutation if we have ||π i | − i| < λ for all 1 ≤ i ≤ n. We define the size of a permutation as the number of elements in it, without counting π 0 and π n+1 .
The goal of these problems is to transform a λ-permutation π into the identity permutation ι = (1 2 . . . n) by applying the minimum number of λ-operations, which defines the sorting distance, such that each permutation generated during the process is also a λ-permutation.
We denote by d λ r (π), d λ t (π), and d λ rt (π) the sorting distance for the sorting unsigned λ-permutation problems when we only have λ-reversals, λ-transpositions, and when we have both operations, respectively. Similarly, we denote by d λ r (π) and d λ rt (π) the sorting distance for the sorting signed λ-permutation problems when we only have λ-reversals and when we have both operations, respectively.

Complexity of Sorting λ-Permutations by λ-Operations
Next, we show an NP-Hardness proof for the sorting distance problem considering some rearrangement models. For this purpose, we define the following decision problems: • Sorting λ-Permutations by λ-Operations: given a positive integer λ, a rearrangement model M containing only λ-operations, a λ-permutation π, and a non-negative integer k, decide if it is possible to sort π using, at most, k operations that belong to M. • Sorting Permutations by Rearrangements: given a rearrangement model M, a permutation π, and a non-negative integer k, decide if it possible to sort π using, at most, k operations that belong to M. When λ = n, the problems of Sorting λ-Permutations by λ-Operations are NP-Hard (except for signed reversals), since they are equivalent to the sorting problems without restrictions in the size of operations. Next, we show that the problem is NP-Hard for a wide range of λ values. When the rearrangement model is clear from the context, it is omitted from the instance. Theorem 1. The problem of Sorting λ-Permutations by λ-Operations is NP-Hard when λ = cn d , for positive constants c and 0 < d ≤ 1, considering unsigned reversals, transpositions, transpositions and unsigned reversals, and transpositions and signed reversals.
Proof. Consider the model containing only unsigned reversals. The problem of Sorting Permutations by Unsigned Reversals is NP-Hard [2]. Now, we show a reduction from this problem to the problem of Sorting λ-Permutations by Unsigned λ-Reversals when λ = cn d , for positive constants c and 0 < d ≤ 1.
Given an instance (π, k), where π has size n, for Sorting Permutations by Unsigned Reversals, we create an instance (λ, M, π , k), where λ = n, M is a model with unsigned λ-reversals, and π = (π 1 π 2 . . . π n (n + 1) . . . n ), such that λ = n = cn d , which is a λpermutation. We note that, since c and d are constants, this is a polynomial-time reduction. Now, we show that the instance (π, k) is satisfied for Sorting Permutations by Unsigned Reversals iff d λ r (π ) ≤ k. (⇒) Suppose that there exists a sorting sequence S of reversals for π with k reversals or less. Note that π has size n, and all reversals in S are λ-reversals, since λ = n. The sequence S can sort the λ-permutation π ; therefore, d λ r (π ) ≤ k. (⇐) Suppose that there exists a sorting sequence S of λ-reversals for π with k operations or less. We now construct a sorting sequence S for π with k or less reversals. If all operations of S affect only elements between the positions 1 and n of π , then S = S is also a sorting sequence for π. Otherwise, there exists operations in S which affect the elements in the interval [n + 1, n ]. Let S = ρ 1 , ρ 2 , . . . , ρ , where is the length of S . We construct S = ρ 1 , ρ 2 , . . . , ρ , where ρ i starts at the first element of ρ i , from left to right, which is in π, and it ends at the last element of ρ i which is in π. Since S inverts the elements of π in the same order as they are inverted in π by S , this sequence sorts π. Note that the length of S is less than or equal to because S may have reversals which do not affect elements that are in π, which corresponds to an empty reversal in S that can be ignored.
The proof is analogous for the other three models.

Inversions
An inversion is defined as a pair of elements (π i , π j ) such that i < j and |π i | > |π j |. The number of inversions in π is denoted by Inv(π).

Proof.
A λ-reversal of length k can only change the inversions between elements of the segment affected by it. Therefore, the maximum number of inversions that a reversal of length k can remove is equal to ( k 2 ), since this is the maximum number of inversions between the elements of a segment of length k. By definition, the length of a λ-reversal is less than or equal to λ, so a λ-reversal can remove, at most, ( λ 2 ) inversions. Since the identity permutation is the only one with Inv(π) = 0, any sorting sequence has to remove all inversions of the permutation, which results in the lower bound d λ r (π) ≥ Inv(π) λ(λ−1)/2 . A λ-transposition τ(i, j, k) of length k also affects only the inversions between elements affected by it. Moreover, the inversions between elements on the segment π i , . . . , π j−1 are not changed. The same is valid for inversions between elements of the segment π j , . . . , π k−1 . So, if an inversion (π x , π y ), with x < y, is removed, then π x is in π i , . . . , π j−1 and π y is in π j , . . . , π k−1 . Therefore, the maximum number of inversions that a transposition can remove is equal to (j − i)(k − j) ≤ (k /2) 2 , since (j − i) + (k − j) = k . This bound is maximum when k = λ, which results in λ 2 /4. As before, this results in the lower bound d λ t (π) ≥ Inv(π) λ 2 /4 .
For the problems of sorting unsigned λ-permutations, if the strip's elements are in ascending (resp. descending) order, then we call it an increasing (resp. decreasing) strip. Strips containing only one element are considered to be increasing ones. For example, considering sorting unsigned λ-permutations by both operations and π = (6 4 5 3 2 1), we have two increasing strips (6) and (4 5), and a decreasing strip (3 2 1). Note, however, that segment (3 2 1) is not a decreasing strip for the problem of Sorting λ-Permutations by λ-Transpositions. This is because, direct from the definition of strips and breakpoints, there are no decreasing strips when this problem is being considered.
For the problems of sorting signed λ-permutations, if the strip's elements are positive, then we call it an increasing strip. Otherwise, the strip is called a decreasing strip. Strips containing only one element are considered to be increasing ones if such an element is positive. Otherwise, they are considered to be decreasing strips. For example, considering sorting signed λ-permutations and π = (+6 − 5 − 4 + 1 + 2 − 3), we have two increasing strips, (+6) and (+1 + 2), and two decreasing strips, (−5 − 4) and (−3). Note that, despite the elements of strip (−5 − 4) are in ascending order, it still is a decreasing strip, according to our definition.
The number of elements in a strip S of a λ-permutation π is denoted by |S|. We say that an element π i is out-of-place if |π i | = i.

Lemma 2.
Let π be a λ-permutation, and let |π j | = i be the smallest element out-of-place in π (i.e., |π j | is minimum and π j = j). The strip S that contains π j is such that |S| ≤ λ − 1.
Proof. First, suppose we have the increasing strip S = (π j . . . π k ). Let R = (π i . . . π j−1 ) be the segment of elements to the left of S. Note that the absolute value of any element in R is greater than any element in S. Therefore, When we have π j in a decreasing strip, the proof is analogous.

Inversions-Based Approximation Algorithms for Unsigned Permutations
In this section, we present approximation algorithms based on the concept of inversions for the sorting unsigned λ-permutations problems we are addressing.
The next lemma shows that it is always possible to remove at least one inversion from a λ-permutation by applying one λ-operation which results in a λ-permutation.
Proof. Let π j = i be the smallest element out-of-place in π. Initially, note we have inversion (π j−1 , π j ), since π j−1 > π j and j − 1 < j. Let σ be a 2-operation that swaps elements π j−1 and π j , and let π = π · σ. It is easy to see that Inv(π ) = Inv(π) − 1, since such inversion was removed, and note that there always exists a λ-reversal or a λ-transposition equivalent to σ, because the elements are adjacent, and, so, both only swap two elements.
Observe that, in π , element π j is closer to its correct position, since it was moved to the left. Hence, we follow by showing that π is a λ-permutation by considering two cases according to the values of π j−1 = π j .
A generic greedy approximation algorithm for the three problems we are addressing in this section is presented in the next theorem. It receives an integer λ ≥ 2 and a λpermutation π = ι as input. It is greedy because it always tries to decrease the largest amount of inversions in π. Since an unsorted permutation always contains inversions, the algorithm will finally sort π.

Theorem 2. There exist O(λ 2 )-approximation algorithms for the problems of Sorting Unsigned λ-Permutations by λ-Reversals, by λ-Transpositions, and by λ-Reversals and λ-Transpositions.
Proof. Let λ ≥ 2 be an integer, and let π = ι be a λ-permutation. Consider an algorithm which chooses a λ-operation σ, such that π · σ is a λ-permutation and Inv(π · σ) is as small as possible, and then it applies such operation over π. The algorithm repeats the same process over the resulting permutation until it reaches the identity permutation.
In the worst case, we always have one λ-operation reducing the number of inversions by one unit, as shown in Lemma 3. Therefore, the number of operations of such greedy algorithm is, at most, Inv(π), and the approximation factor follows immediately from Lemma 1.
Note that the distance is O(n 2 ) because any unsigned permutation can be sorted with O(n 2 ) λ-reversals or λ-transpositions. For Sorting Unsigned Permutations by λ-Reversals, at each step the algorithm considers O(λ 2 ) possible reversals that can be chosen. Since the variation in the number of inversions caused by an operation can be calculated in O(λ log λ) time [23], the algorithm has total time complexity O(n 2 λ 3 log λ). Using the same analysis, we conclude that the algorithms involving transpositions have total time complexity O(n 2 λ 4 log λ).

Algorithms Based on Inversions and Entropy for Signed λ-Permutations
The entropy of an element π i from a permutation π is given by ent(π i ) = ||π i | − i|, that is, the distance between π i and its position in ι. We denote by E even − π the set of negative elements in π such that ent(π i ) is even, for all 1 ≤ i ≤ n. Similarly, we denote by E odd + π the set of positive elements in π such that ent(π i ) is odd. For example, given , since −1 and −2 are negative elements with even entropy (ent(−1) = ent(−2) = 2), and +3 is a positive element with odd entropy (ent(+3) = 1), respectively. Fact 2. [16] Let π be a signed permutation, and let σ be a 2-reversal. We have |E even − [24] Let π be a signed permutation, and let σ be a λ-operation.
The score of a λ-operation σ over a signed permutation π is given by score(π, σ) = (Inv(π) . Combining Fact 3 with the fact that a λ-reversal and a λ-transposition can remove, at most, inversions, we have an upper bound for the score of a permutation in Lemma 4. This upper bound implies Corollary 1.
We follow by showing in Lemma 5 that there always exists a λ-operation with score at least 1. Having this in mind, a generic greedy approximation algorithm for the two sorting signed permutations problems we are addressing is presented in next theorem. It receives an integer λ ≥ 2 and a λ-permutation π = ι as input. It is greedy because it always chooses a λ-operation with the largest score. Since the only permutation with Inv(π) = |E even − π | = |E odd + π | = 0 is the identity, it will, eventually, sort π.
Proof. The proof is divided into two cases, according to Inv(π).
In the worst case, as shown in Lemma 5, we always have one λ-reversal with score 1. Therefore, the number of operations of such greedy algorithm is, at most, Inv(π) + |E even − π | + |E odd + π |, and the approximation factor follows immediately from Corollary 1.
Since Inv(π) + |E even − π | + |E odd + π | is O(n 2 ) and the time to calculate the variation in the number of |E even − π | + |E odd + π | is O(λ), the analysis of time complexity is analogous to the algorithms previously presented for the sorting unsigned permutation problems.

Breakpoints-Based Approximation Algorithms
In this section, we present approximation algorithms based on the concept of breakpoints for the five problems we are addressing.
In the next lemma, we suppose that the smallest element out-of-place is in an increasing strip of a λ-permutation π = ι. We show how to reduce the number of breakpoints of π by moving this strip to its correct position using an operation that may not be a λ -operation, but assuring that the resulting permutation is also a λ-permutation. Lemma 6. Let π be a λ-permutation. Let |π j | = i be the smallest element out-of-place in π. Suppose that π j is in an increasing strip S = (π j . . . π k ). Then, π · τ(i, j, k + 1) is a λ-permutation, b(π · τ(i, j, k + 1)) ≤ b(π) − 1, and (k + 1 − i) ≤ 2(λ − 1).
Proof. Let R = (π i . . . π j−1 ) be the segment of elements in π that will be transposed with S. Observe that the absolute value of any element in R is greater than any element in S, so π · τ(i, j, k + 1) is a λ-permutation, since greater elements (in their absolute values) are moved to the right and smaller elements to the left. In addition, observe that, in π, we have the three breakpoints (π i−1 , π i ), (π j , π j+1 ), and (π k−1 , π k ), where the first one is because π i−1 = π j − 1 = i − 1 and |π i | > i = π j , and the second and third ones are because the strip's start and strip's end are at positions j and k, respectively. Transposition τ(i, j, k + 1) moves the elements of S to their correct positions by transposing them with elements of R, thus removing at least breakpoint (π i−1 , π i ). Since a transposition can add, at most, three breakpoints, but we already had all of them and we removed at least (π i−1 , π i ), we have b(π · τ(i, j, k + 1)) ≤ b(π) − 1.
By Lemma 2, we have |S| ≤ λ − 1; thus, k + 1 − j ≤ λ − 1. Since π is a λ-permutation, we have ||π j | − j| ≤ λ − 1, and, by construction, π j = i; thus, |i − j| For a λ-permutation π with only increasing strips, the next lemma shows that it is possible to find a sequence with, at most, 4 transpositions that decreases the number of breakpoints in π, assuring that all permutations generated in the process are λ-permutations. Using these operations, we can create an algorithm that sorts π using, at most, 4b(π) λ-transpositions.
The idea is to apply a sequence with, at most, four λ-transpositions that divide both segments R = (π i . . . π j−1 ) and S = (π j . . . π k ) into, at most, two parts each, where each part has, at most, λ/2 elements, and then exchange each part of S, at most, twice (and at least once), with the (possible) two parts of R. If we had exactly λ − 1 elements in each of S and R, such sequence would be τ(i + λ/2 , j, j + λ/2 ), τ(i, i + λ/2 , j), τ(j, j + λ/2 , k + 1), τ(i + λ/2 , j, j + λ/2 ). Now, we have to show that, after each of the, at most, four operations is applied, we have a λ-permutation as result.
Observe that the absolute value of any element in R is greater than any element in S. Since each λ-transposition puts elements of S closer to their correct positions by transposing them with greater elements (in their absolute values) of R, we have a λ-permutation after each λ-operation applied. After all λ-transpositions are applied, the elements of S are at positions from i to i + k − j, and the elements of R are at positions from i + k − j + 1 to k, resulting in π · τ(i, j, k + 1), which is a λ-permutation with at least b(π) − 1 breakpoints, as shown in Lemma 6.
For a λ-permutation π with only increasing strips, the next lemma shows how to decrease the number of breakpoints in π using only λ-reversals, also assuring that all permutations generated in the process are λ-permutations. Lemma 8. Let π be a λ-permutation. Let |π j | = i be the smallest element out-of-place in π. Suppose that π only has increasing strips and that π j is in a strip S = (π j . . . π k ). It is always possible to obtain a λ-permutation π · τ(i, j, k + 1) with, at most, b(π) − 1 breakpoints by applying, at most, 5 + λ − 1 λ-reversals such that all intermediary permutations are λ-permutations.
The idea is to move elements from S to their correct positions by applying, at most, two sequences of pairs of λ-reversals, where each one puts, at most, λ/2 elements of S in their correct positions at a time.
In the first sequence of λ-reversals, there are two possibilities. If |S| ≤ λ/2 , then the first operation of each pair reverses |S| elements contained in both S and R. If |S| > λ/2 , then it reverses λ/2 elements contained in both S and R. In any case, the second operation of each pair reverses back the elements of R affected by the first one, in order to leave π with only increasing strips again (except for the elements of S which were affected by the first operation).
After the sequence is applied, we have, at most, λ/2 elements of S from positions i to i + min( λ/2 , |S|), and, maybe, they are in a decreasing strip. If this is the case, then one more λ-reversal has to be applied to put these elements in their correct places, by reversing such decreasing strip.
The second sequence of λ-reversals puts the (at most) λ/2 remaining elements of S in their correct positions, following the same idea, and, also, maybe one extra λ-reversal will be necessary after it is applied. Note that, if there are no remaining elements (in case of |S| ≤ λ/2 ), this sequence is not necessary.
The largest amount of operations needed in the process described above happens when we have λ/2 + 1 elements in S. Since |S| > λ/2 , our process starts by moving the first λ/2 elements of S to their correct positions. Observe that, for each pair of reversals applied in the first sequence, one of them moves λ/2 elements λ/2 positions to the left (except, maybe, by the last pair), and then the other one reverses again the elements of R affected by the first reversal. Besides that, by the definition of λ-permutations, the elements of S are, at most, λ − 1 positions away from their correct positions, and, so, at most, 2 pairs of reversals are needed to put them at position i. As we have told before, maybe such elements of S ended up in reversed order and, in order to fix it, one more reversal is needed. Hence, we already have a total of, at most, 5 reversals applied.
To move the remaining element of S to its correct position, all the λ-reversals of the second sequence will have size 2 (note that, in this case, we do not need the second operation of each pair), which means such element will be moved only 1 position to the left per operation, giving an extra amount of λ − 1 λ-reversals. Therefore, the number of λ-reversals to move S to its correct position is, at most, 5 + λ − 1. Now, we have to show that, after applying each operation, we have a λ-permutation as result and, after the last operation is applied, we have π · τ(i, j, k + 1).
Observe that any element in R is greater than any element in S. Then, since the first operation of each pair moves elements of R to the right and elements of S to the left, all elements affected will be closer to their correct positions, resulting in a λ-permutation. The second operation of each pair reverses elements of R to ascending order again, so it also results in a λ-permutation. After both sequences of λ-reversals are applied, all elements of S are at positions from i to i + k − j and all elements of R are at positions from i + k − 1 to k, resulting in π · τ(i, j, k + 1), which is a λ-permutation with at least one less breakpoint than π, as shown in Lemma 6.
Lemma 9 shows how to decrease the number of breakpoints of a λ-permutation π, considering that the smallest element out-of-place of π is in a decreasing strip. Since Lemma 8 deals with the case where π has no decreasing strips, we can use these two lemmas together to develop an algorithm to sort a λ-permutation π using only λ-reversals. Lemma 9. Let |π k | = i be the smallest element out-of-place in a λ-permutation π. Suppose that π k is in a decreasing strip S = (π j . . . π k ). It is always possible to obtain a λ-permutation with, at most, b(π) − 1 breakpoints by applying, at most, one λ-transposition and one λ-reversal.
Let R = (π i . . . π j−1 ) be the segment of elements that should be moved in order to put S in its correct position. Observe that the absolute value of any element in R is greater than any element in S. The first operation, a λ-transposition, transposes S only with greater elements (in their absolute values); thus, the result is a λ-permutation. The second operation, a λ-reversal, just reverses a decreasing strip to put the elements of S in their correct positions; thus, it also results in a λ-permutation. Hence, we have as result a λ-permutation with at least one less breakpoint.
The next theorems describe approximation algorithms for the problems we are addressing. Lemma 10 is auxiliary to Theorem 4. The algorithms receive an integer λ ≥ 2 and a λ-permutation π = ι as input. The goal is to decrease at least one unit on the number of breakpoints in π by moving elements to their correct positions (applying Lemmas 7 and 9). Since the only permutation with no breakpoints is the identity, they will, eventually, sort π. Lemma 10. Let π be a λ-permutation. Let S = (j . . . i) be a decreasing strip in π (thus, i < j). Let π = π · ρ(π −1 |j| , π −1 |i| ) be the resulting permutation after reversing S in π. Then, π is a λ-permutation.
Proof. First, note that element π j is to the right of element π i . We show that the lemma follows by considering four cases, according to the positions of elements i and j in relation with the elements π |i| and π |j| .
Case (i), |i| < |j| < π −1 |j| < π −1 |i| : note that both π |i| and π |j| are to the left of S. Then, after reversing S, element i is closer to its correct position, while element j is moved away from its correct position. Despite this, the distance between π |j| and j in π is smaller than the distance between π |i| and i in π, and, so, if π is a λ-permutation, π is also a λ-permutation.
Case (ii), |i| < π −1 |j| ≤ |j| < π −1 |i| : note that π |i| is to the left of S, and π |j| is in S. Then, after reversing S, the element i is closer to its correct position and the distance of j to its correct position will still be less than λ, since the size of S is, at most, λ, as Lemma 2 shows.
Case (iii), π −1 |j| ≤ |i| < π −1 |i| ≤ |j|: similar to (ii). Case (iv), π −1 |j| < π −1 |i| ≤ |i| < |j|: similar to (i). Proof. Let λ ≥ 2 be an integer and π = ι be a λ-permutation. Consider an algorithm which first applies one λ-reversal over each decreasing strip of π in order to get a λ-permutation with only increasing strips. By Lemma 10, we guarantee that all intermediary permutations generated by these λ-reversals are λ-permutations. Then, the algorithm will repeatedly take the smallest element out-of-place and move the increasing strip that contains it to its correct position, obtaining a λ-permutation with at least one less breakpoint, until it reaches the identity permutation.
As shown in Lemma 8, at most 5 + λ − 1 λ-reversals are needed to move each strip to its correct position. Since, maybe, one extra λ-reversal could have been applied in the beginning of the algorithm to transform such strip into an increasing one, we have that, at most, 6 + λ − 1 λ-reversals can be applied to remove at least one breakpoint. Therefore, the number of operations of our algorithm is, at most, for β ∈ {r,r}, and the inequality follows from Fact 1.
Proof. Let λ ≥ 2 be an integer, and let π = ι be a λ-permutation. The algorithm will repeatedly take the smallest element out-of-place and move the increasing strip that contains such element to its correct position, obtaining a λ-permutation with at least one less breakpoint, until it reaches the identity permutation. As shown in Lemma 7, at most, 4 λ-transpositions are needed to move each strip to its correct position. Then, in the worst case, we remove 1 breakpoint every 4 λ-transpositions applied. With this and Fact 1, the number of operations of our algorithm is, at most, 4b(π) ≤ 12d λ t (π). Proof. Let λ ≥ 2 be an integer, and let π = ι be a λ-permutation. Let π j = i be the smallest element out-of-place in π.
We have two cases to consider: when the strip which contains π j is decreasing or not. In both cases, we can at least remove breakpoint (π i−1 , π i ) from π without adding other ones by applying, at most, 4 λ-transpositions (if the strip is increasing) or, at most, 2 λ-operations (if the strip is decreasing), as shown in Lemmas 7 and 9, respectively.
Then, considering both cases described, the algorithm will repeatedly take the smallest element out-of-place and move the strip that contains it to its correct position, decreasing at least one breakpoint at a time, until it reaches the identity permutation.
Note that, in the worst case, we remove 1 breakpoint every 4 λ-transpositions, and, so, the result is analogous to Theorem 5.
Note that b(π) is O(n) and the time complexity to find the strip with the smallest element out-of-place in π is O(n). So, we conclude that the time complexity for the O(1)approximation algorithms and the O(λ)-approximation algorithm are O(n(n + λ)) and O(n(n + λ 2 )), respectively.

Experimental Results
In order to analyze how the proposed algorithms work from a practical perspective, we have implemented the inversions-based (Theorems 2 and 3) and the breakpoints-based (Theorems 4-6) greedy algorithms.
We can also achieve an approximation factor of O(λ 2 ) with algorithms that always apply an operation of size 2 according to Lemma 3, for unsigned permutations, or Lemma 5, for signed permutations. There exists a way to implement such algorithms so that they have time complexity of O(n log n) [25]. We also implemented these algorithms, which we named super short algorithms, for comparison purposes. The difference between the super short algorithms and the inversions-based algorithms from Theorems 2 and 3 is that the super short algorithms only use operations of size 2, while the algorithms from Theorems 2 and 3 use, at each iteration, the operation that most decrease the number of inversions, which can have size, at most, λ.
We performed experiments considering a total of 1000 signed and unsigned λ-permutations, with size equal to 100 and values of λ ∈ {5, 10, 15, . . . , 100}, as input for the algorithms. The considered λ-permutations were generated in two different ways: (i) totally random, and (ii) by applying 20 random λ-operations (according to the rearrangement model of each problem) over the identity. We reinforce that all generated permutations in both cases, including the intermediary ones of case (ii), are λ-permutations. For (i), the λ-permutations tend to have a high amount of breakpoints, and for (ii) they tend to have a high amount of strips and, moreover, we know the distance is, at most, 20. Then, we compared the results according to the average and maximum approximation factors obtained for all permutations. For each permutation, we calculated the approximation factor by dividing the size of the sorting sequence by the maximum value of lower bound between the ones shown in Lemma 1 and Fact 1.
We show the results for totally random λ-permutations in Figures 1 and 2, and for λ-permutations generated from the identity in Figures 3 and 4.       λ-operations are allowed, considering the breakpoints-based and the inversions-based algorithm, respectively. Furthermore, for this second type of λ-permutations, the maximum approximation factors of the inversions-based algorithm for the sorting signed λ-permutations problems and for the Sorting Unsigned λ-Permutations by λ-Reversals were considerably greater when compared with their average approximation factors. Despite that, the average and maximum factors given by the inversions-based algorithm were better for the two sorting unsigned λ-permutations problems which allow λ-transpositions. For both problems which allow only λ-reversals, the breakpoints-based algorithm had better average and maximum approximation factors. For Sorting Signed λ-Permutations by λ-Reversals and λ-Transpositions, both algorithms had similar average approximation factor, but the breakpoints-based algorithm had a better and more constant maximum approximation factor.
Our experiments reveal that the average approximation factor for the breakpoint-based algorithms slight increases for the interval λ ∈ [30..100], while the average approximation for the inversion-based algorithms has a greater increase in the same interval. This occurred because there are more λ-reversals that decreases a breakpoint, when using bigger values of λ, since the strips tend to get smaller compared to the value of λ, which is a crucial point in Lemmas 8 and 9. A similar relation is not so common for inversions, since extending the segment to be inverted may lead to inversions being added.

Conclusions
In this work, we introduced the problems of Sorting λ-Permutations by λ-Operations, considering reversals and transpositions on signed and unsigned permutations.
We presented an NP-hardness proof for the models containing unsigned reversals, transpositions, and the combination of (signed or unsigned) reversals and transpositions, when λ = cn d for positive constants c and 0 < d ≤ 1. We developed algorithms with approximation factors of O(λ 2 ), O(λ), and O(1) for all problems studied. Besides that, experiments were also performed in order to see their performance on simulated data. Tables 1 and 2 summarize these results.
For future work, we intend to develop approximation algorithms with better approximation factors for the problems of Sorting λ-Permutations by λ-Operations. Another direction of future work is to study the complexity for the model containing only signed reversals and other values of λ. Table 1. Summary of the approximation results for the problems considering signed permutations. The columns "Approx." and "Time" refer to the theoretical approximation factor and the worst-case complexity time, respectively.

Reversals Reversals and Transpositions
Approx.

Time Approx. Time
Breakpoints-based 10 + 2λ O(n(n + λ 2 )) 12 O(n(n + λ)) Inversions-based Table 2. Summary of the approximation results for the problems considering unsigned permutations. The columns "Approx." and "Time" refer to the theoretical approximation factor and the worst-case complexity time, respectively.

Reversals Transpositions Reversals and Transpositions
Approx. Time Approx.

Conflicts of Interest:
The authors declare no conflict of interest.