Prefix Block-Interchanges on Binary and Ternary Strings

The genome rearrangement problem computes the minimum number of operations that are required to sort all elements of a permutation. A block-interchange operation exchanges two blocks of a permutation which are not necessarily adjacent and in a prefix block-interchange, one block is always the prefix of that permutation. In this paper, we focus on applying prefix block-interchanges on binary and ternary strings. We present upper bounds to group and sort a given binary/ternary string. We also provide upper bounds for a different version of the block-interchange operation which we refer to as the `restricted prefix block-interchange'. We observe that our obtained upper bound for restricted prefix block-interchange operations on binary strings is better than that of other genome rearrangement operations to group fully normalized binary strings. Consequently, we provide a linear-time algorithm to solve the problem of grouping binary normalized strings by restricted prefix block-interchanges. We also provide a polynomial time algorithm to group normalized ternary strings by prefix block-interchange operations. Finally, we provide a classification for ternary strings based on the required number of prefix block-interchange operations.

READ FULL TEXT VIEW PDF

Authors

03/31/2022

Suffix tree-based linear algorithms for multiple prefixes, single suffix counting and listing problems

Given two strings T and S and a set of strings P, for each string p ∈ P,...
05/10/2022

Upper Bounds to Genome Rearrangement Problem using Prefix Transpositions

A Genome rearrangement problem studies large-scale mutations on a set of...
08/31/2020

Sorting by Prefix Block-Interchanges

We initiate the study of sorting permutations using prefix block-interch...
04/23/2018

Longest Common Factor Made Fully Dynamic

In the longest common factor (LCF) problem, we are given two strings S a...
08/08/2018

Permutation patterns in genome rearrangement problems

In the context of the genome rearrangement problem, we analyze two well ...
06/29/2020

The Number of Repetitions in 2D-Strings

The notions of periodicity and repetitions in strings, and hence these o...
05/02/2021

Divergence Scaling for Distribution Matching

Distribution matchers for finite alphabets are shown to have information...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Genome rearrangement has become a popular combinatorial problem in the field of computational biology which helps to trace the evolutionary distance between two species. The genome is structurally specific to each species, and it changes only slowly over time. Though the gene content of two genomes is almost identical, gene order can be quite different, which results in different species [6]. There are several genome rearrangement events such as reversal, transposition, block-interchanges, etc. [4, 10, 5, 9] that contribute much to such biological diversity. In this paper, we will only discuss block-interchanges and its variations.

In computational biology, a genome is often represented as a permutation consisting of all elements from 1 to , where is the length of the permutation. In an identity permutation, all elements are sorted in ascending order from 1 to

. A block-interchange involves swapping two blocks of a permutation which are not necessarily adjacent. A prefix block-interchange is a variation of block-interchange where one of the two blocks must be a prefix of the permutation. The prefix block-interchange distance between two permutations can be used to estimate the number of global mutations between genomes and can be used by molecular biologists to infer evolutionary and functional relationships.

Sorting by prefix block-interchanges is the problem of finding the minimum number of prefix block-interchange operations needed to transform a given permutation into the identity permutation.

A natural variant of the previously mentioned sorting problems is to apply genome rearrangement operations not on permutations but on strings over fixed size alphabets. A string over the alphabet is a sequence of symbols where repetitions of symbols in are allowed. This shift is inspired by the biological observation that multiple “copies” of the same gene can appear at various places along the genome [6].

The grouping problem of normalized strings by genome rearrangement operations provides upper bound i.e., the number of required operations to group all symbols of a string and the sorting problem computes the number of operations required to sort all grouped symbols of that normalized string by genome rearrangement operations. Indeed, some interesting works by Christie and Irving [4], Radcliffe et al. [1], Hurkens et al. [3], Dutta et al. [2], and Rahman and Rahman [8] have explored the consequences of switching from permutations to strings. Notably, such rearrangement operations on strings have been found to be interesting and important in the study of orthologous gene assignment [13], especially if the strings have only low level of symbol repetition. We provide a summary of results on grouping and sorting strings by genome rearrangement operations in Table 1.

Authors GR operation Type Grouping Sorting
Hurkens et al. [3] PR Binary
Ternary
Dutta et al. [2] PT Binary
Ternary
Rahman and
Rahman [8]
PSTR
Binary
Ternary
Chou et al. [14] PBI Binary
This article
RPBI
Binary X
RPBI
Ternary X
PBI
Binary
PBI Ternary
Table 1: A list of results on grouping and sorting strings by Genome Rearrangement (GR) operations. Here, is the length of the string. Other notations are as follows: -Not Available, -Prefix Reversal, -Prefix Transposition, -Prefix and Suffix TransReversal, -Prefix Block-Interchange and -Restricted Prefix Block-Interchange.

Chen et al. [13], presented polynomial-time algorithms for computing the minimum number of reversals and transpositions operations to sort a given binary string. They also gave exact constructive diameter results on binary strings. Radcliffe et al. [1] on the other hand gave refined and generalized reversal diameter results for non fixed size alphabets. Hurkens et al. [3] introduced grouping (a weaker form of sorting), where identical symbols need only be grouped together, while groups can be in any order. In the sequel, they gave a complete characterization of the minimum number of prefix reversals required to group (and sort) binary and ternary strings. Their proposed upper bound for grouping binary string is , where is the length of the binary string . Subsequently, Dutta et al. [2] followed up their work [3] on binary and ternary strings to apply prefix transpositions introducing relabeling. They gave a complete characterization of the minimum number of prefix transpositions required to group (and sort) binary and ternary strings. Their proposed upper bound to group a binary string is , where is the length of the string. It may be noted that, apart from being a useful aid for sorting, grouping itself is a problem of interest in its own right [7]. Chou et al. also proposed a bound only for binary strings applying prefix block-interchanges [14]. Their proposed bound to group binary strings is . They also proposed a linear time algorithm to sort binary strings. Finally, Rahman and Rahman [8] worked on prefix and suffix versions of transreversal operations and derived similar bounds for binary and ternary strings as in [2]. Their proposed bound to group binary strings considering one operation at a time is , where is the length of the string.

In this paper, we follow up the works of [2, 8, 3, 14] and consider prefix block-interchange operations to group and sort binary and ternary strings. Notably, as a future work in [3], the authors raised the issue of considering other genome rearrangement operators. The main contributions of this paper are as follows. We deduce the number of prefix block-interchanges required to group and sort binary strings (Section 3). Then we find the number of prefix block-interchanges required to group and sort ternary strings (Section 4). Our deduced bound to group fully binary normalized string is considering restricted prefix block-interchange operations where is the length of the string (Section 3.1). This is interesting because this bound is better than other proposed bounds for other rearrangement operations in the literature. We also provide a linear-time algorithm to group binary normalized strings by restricted prefix block-interchange operations. Then, we deduce the upper bound of to group fully normalized ternary strings by prefix block-interchanges, where is the length of the string. We also provide a polynomial time algorithm to group normalized ternary strings (Section 4). We also present a classification of normalized ternary strings (Section 4.1).

2 Preliminaries

We use the similar notations and definitions used in [2, 8, 3, 14], which are briefly reviewed below for the sake of completeness. We represent a binary string by such that or . Similarly, we represent a ternary string by such that or or .

We define block-interchange on a string of length , where and , as a rearrangement event that transforms into . When we consider prefix block-interchange, we actually perform . So, a prefix block-interchange event transforms into . The prefix block-interchange distance of is defined as the minimum number of prefix block-interchanges required to sort the string . Similarly, we define as the minimum number of prefix block-interchanges required to group all symbols of the string . After a prefix block-interchange operation, some adjacent symbols of the new formed string may be identical. We reduce all adjacent identical symbols to one symbol and get a string of reduced length which we call a normalized string. So, in a normalized string, there will be no identical adjacent symbols. We consider two strings to be equivalent if we can convert them to the same normalized string. As representatives of the equivalence classes we take the shortest string of each class. Clearly, these are normalized strings where adjacent symbols are always different. In our work, we only consider normalized strings as in [2, 8, 3]. This does not lose generality because we can convert any string to the respective normalized string, i.e., the representative of the class it belongs to.

For example, let us consider two strings ‘110001001011’ and ‘100100011101’ which are equivalent because these two strings have the same normalized string which is ‘1010101’. So, they belong to the same equivalence class where ‘1010101’ is the representative. We consider and we want to apply a prefix block-interchange operation on . Now, , , . Therefore, after applying the operation we get and finally get a reduced string as follows: .

A reduction that decreases the string length by after applying a prefix block interchange is called an -pblockInterchange. So, if , then we have a 0-pblockInterchange. The above example illustrates a 2-pblockInterchange.

A token is a string of one or more symbols (0, 1 or 2) that is significant as a group. A quantifier is a type of determiner that indicates quantity and it is basically applied after a token. For instance, ‘+’ is a quantifier which indicates one or more occurrences of the token after which ‘+’ is applied. Note that a token may also consist of one symbol only. For example, consider the string . Here, 10 is a token, ‘1’ and ‘0’ are symbols of the token 10 and ‘+’ is the quantifier. It means , or etc. belongs to the same representation class .

3 Grouping and Sorting Binary Strings

The task of sorting a string can be divided into two subproblems, namely, grouping

the identical symbols together and then putting the groups of identical symbols in the right order. The possible length of binary string is either even or odd. As strings are normalized, only 4 kinds of binary strings are possible, namely,

, , and . We achieve the following properties for binary strings.

Property 1

Let be a fully binary normalized string of length , where . Then, we will need to reduce symbols to group .

There will be at least one identical symbol in if . So, we need to reduce those symbols applying prefix block-interchanges and then reducing consecutive identical symbols which results in a normalized string. Finally, after completion of grouping, we will get either 01 or 10, where 01 is already sorted. If we get 10, we will need one extra operation to sort it.

Property 2

Let be a fully binary normalized string of length , where and . If we have a prefix block and another block such that all three of the following conditions (1-3) are satisfied, then we get a 3-pblockInterchange.

  • Condition 1:

  • Condition 2:

  • Condition 3:

Let be a fully normalized binary string of length such that . Then, we always get 3-pblockInterchange(s) using prefix block-interchange operations.

Proof.

Let be a binary normalized string, where . Suppose, represents a class of binary normalized strings where either and , or and . Now, if we exchange with (), we get a normalized string of which is a reduced string from the original one. Here, the length of reduced string is 2 which is 3 less than the original string, i.e., we have a 3-pblockInterchange here. Now, if we append any length of binary normalized string after , then according to Property 2, we always get a 3-pblockInterchange if we always perform provided that . So, the claim holds true. ∎

Let be a fully normalized binary string of length such that and we always perform prefix block-interchange operations, then .

Proof.

As we always get a 3-pblockInterchange when (lemma 3), then the length of the string will be reduced by 3 after each operation. Thus, the bound holds true. ∎

3.1 Grouping Binary Strings by Restricted Prefix Block-interchanges

Now, let us consider a different scenario where we always keep the first block of consecutive identical symbol(s) of a string fixed, i.e., we keep the first symbol of a normalized binary string fixed. So, while performing a restricted prefix block-interchange operation we actually mean . We refer to this operation as the restricted prefix block-interchange operation. The motivation for this apparently strange setting comes from the existence of circular genomes. While handling a circular permutation (genome), we need to keep the first position fixed. There exist some works where such circular permutations are considered [11, 12].

Property 3

Let be a fully binary normalized string of length , where . If we have a block and another block such that , , and , then we get a 4-pblockInterchange using the restricted prefix block-interchange operations.

For example, let . Since, , , and (i. e., and ), can be applied on as follows: .

Let be a fully normalized binary string of length such that . Then, we always get 4-pblockInterchange(s) using restricted prefix block-interchange operations.

Proof.

As is a fully normalized binary string, there are only four kinds of such strings: of even length, of even length, of odd length and of odd length. So, for all these strings, we always get that the first symbol is same as the fifth symbol, the second symbol is same as the fourth symbol, the fourth symbol is same as the sixth symbol and the third symbol is same as the seventh symbol. Then, according to Property 3, we always get a 4-pblockInterchange for each of the four possible combinations (such that ) which reduces the length of the string by 4. ∎

Let be a fully binary normalized string of length such that and we always perform restricted prefix block-interchange operations, then , where is the number of restricted prefix block-interchanges required to group all symbols of the string .

Proof.

First, we prove the bound for all fully normalized binary strings where , then we prove for . When , we need one prefix block interchange operation to group all symbols in . For this case, length of can be 3, 4, 5 or 6. We can easily group these strings as follow:

  • .

Note that 1010 and 0101 are in fact similar strings because we get the latter from the former by relabeling ‘0’ to ‘1’ and ‘1’ to ‘0’ as in [2, 8]. So, we need one restricted prefix block-interchange to group 010, 0101, 01010 and 010101 which satisfies the proposed bound. Now, when , we always get 4-pblockInterchange(s) to perform on (Lemma 3.1), which will reduce the length of by 4. Thus the proposed bound always holds true. ∎

Note that our deduced upper bound to group fully binary normalized string for restricted prefix block-interchanges is better than other results presented in Table 1. After grouping is done, we get either 01 or 10, where 01 is already sorted. So, if we get 10 then we treat it as a permutation and need one extra prefix block-interchange operation to sort it. Thus, , when we need to sort 10, otherwise .

We also present Algorithm 1 to compute the restricted prefix block-interchange distance to group fully normalized binary string(s). In Algorithm 1, swap and normalize operations take constant time [14]. We can perform the swap operation by exchanging one or two symbols with one or two symbols respectively. Similarly, normalize operation can be done always by checking first to seventh symbols in . So, the while loop will execute not more than times. Clearly, the time complexity of Algorithm 1 is . The problem of grouping fully normalized binary strings by restricted prefix block-interchanges can be solved by a linear-time algorithm.

Input: is a fully binary normalized string, where length of ,
;
while () do
       swap(, );
       normalize();
       ;
       ;
      
end swap(, );
;
normalize();
;
;
Algorithm 1 Algorithm to group fully normalized binary string by restricted prefix block-interchanges

4 Grouping and Sorting Ternary Strings

In this section, we deduce both the grouping and sorting distances for ternary strings. It can be noted that grouping ternary strings is not as simple as grouping binary strings. We start with an easy lemma.

In a fully normalized ternary string of length greater than 3, we can always perform a -pblockInterchange.

Proof.

Consider a normalized ternary string of length . So, , here it is obvious that . Now, we take as a prefix. As this is a normalized ternary string, somewhere we will find a block such that any one of the following conditions (1-3) is satisfied; and consequently, we get a 1-pblockInterchange.

  • Condition 1:

  • Condition 2:

  • Condition 3:

Since one of the above cases always occurs for fully ternary strings when , the result follows. ∎

Now, we assume that we can perform a -pblockInterchange on a string. Note that, instead of taking a prefix of length at least 2, we can always take a prefix of length 1 (i.e., the first symbol), and perform a 1-pblockInterchange. Thus, the presence of a 2-pblockInterchange always ensures that there is also a 1-pblockInterchange. For example, let’s consider 10201. There is a -pblockInterchange: . We could also get a 1-pblockInterchange as follows: .

The lower bound for the grouping of a ternary string remains the same as that of binary strings; but, as can be seen from Theorem 4 below, the upper bound differs. At first, we give an easy but useful lemma.

Suppose is a fully normalized ternary string. If we have a prefix such that and , then we have a 2-pblockInterchange.

Proof.

We have a fully normalized ternary string . After performing a prefix block-interchange on , will be adjacent to and will be adjacent to . Then, we will be able to eliminate one of or and one of or . This ensures that the length of will be reduced by 2 which completes the proof. ∎

(Grouping ternary strings applying prefix block-interchanges) Let be a fully normalized ternary string. Then, where is the length of the string.

Proof.

At first, we will prove the bound for all normalized ternary strings where . Then, we will describe the proof for all normalized ternary strings where . In what follows, we only consider strings starting with . This does not lose the generality since we can always use relabeling for strings starting with or . As strings are fully ternary, we do not need to work with . For , we require a 1-pblockInterchange and that is optimal, hence , and the upper bound is satisfied. We give all fully normalized ternary strings of length 4 starting with 1 in List (1). When , we can always perform either 1-pblockInterchange or 2-pblockInterchange and thus . Now, we apply prefix block-interchanges for , we always get . Supplementary Table 2 shows the derivation of the grouping distance for fully normalized ternary strings of length 5 and 6. It is easy to realize that, by Lemma 4, we can always satisfy the given upper bound. Thus the upper bound is proved for .

(1)

Now we consider . Note carefully that for any string starting with , we can only have one of the eight prefixes of length 4 from List (1).

For a string of length , if we can give a 2-pblockInterchange, the resulting reduced string will start with its previous starting symbol and it may be 1, 0 or 2. For the latter two cases (0 and 2), we can again use relabeling as mentioned before. Therefore we can safely assume that the reduced string will have any of the 8 prefixes of List (1). Hence, it suffices to prove the bound considering each of the prefixes of List (1). We will show the lists for 7 length fully normalized ternary strings each of which will have a 4 length prefix from List (1). Then we will provide arguments for each of the prefixes from List (1).

Firstly, it is easy to note that the prefixes 1010 and 1212 themselves are binary strings. So, they take one prefix block-interchange operation. Therefore, we can safely exclude one of them from the following discussion. Now, if we relabel to and to , then we get 1201 from 1021. Similarly, after relabeling we get 1202 from 1020 and 1210 from 1012. So, we can safely exclude these also from the following discussion. In what follows, when we refer to the prefixes of List (1), we would actually mean all the prefixes excluding 1201, 1202, 1210 and 1212.

1010

We first give all possible strings of length 7 having prefix in List (2). The possible 5 length strings having this prefix are and .

(2)

In List (2), all strings will have at least one -pblockInterchange. When we have a prefix symbol , we need to lookup somewhere for a symbol so that we can perform a -pblockInterchange. Similarly, when we have a prefix block , we need to lookup somewhere for a suffix block . In that case, we will be able to perform a -pblockInterchange. This is also true for longer prefix blocks.

Let us check this with examples. The string satisfies the bound as follows: . We see that, for , we need only two prefix block-interchanges holding the bound true. However, if we can reduce the string length by at least after each step, we will also achieve the desired bound. Here, all strings satisfy the bound. Let us see another example for string 1010212. The reduction steps are as follows: . This takes three steps which satisfies the bound. Now, if we add 0 or 1 after 1010212, then the resulting string will be 10102120 or 10102121 in which case we will be able to perform a -pblockInterchange. So, appending any length of ternary string(s) after 1010212 will also have -pblockInterchange in the reduction steps.

1012

Here, again we first give the list of 7 length strings having prefix 1012 (see List (3)). Here, the possible 5 length strings of this prefix are and .

(3)

In this case, we see that all strings having length 7, will have a -pblockInterchange as follows. When we have a prefix block , we need to lookup somewhere for a block in the latter part of that string. Similarly, when we have a prefix block , we need to lookup for a block in the latter part of that string. Then we will be able to perform a -pblockInterchange which will reduce the string length by 2. Then according to Lemma 4, we will get at least two consecutive pblockInterchange which will satisfy the bound. This is also true for higher length prefix blocks.

1020

We present all strings of 7 length having prefix in List (4).

(4)

Here, according to Lemma 4, all strings will have a -pblockInterchange. When we have a prefix block , we need to lookup for a block in the latter part of that string. Similarly, when we have a prefix block , we need to lookup for a block in the latter part of that string so that after applying a prefix block-interchange, we get a -pblockInterchange. Then, according to Lemma 4, the bound will be satisfied. Thus, if we append any length of ternary string(s) after 7 length strings having prefix , that will also have -pblockInterchange.

1021

We present all strings of 7 length having prefix in List (5).

(5)

If we observe the 7 length strings carefully based on Lemma 4, we find that all strings have at least one -pblockInterchange. Then it will be reduced to 5 length ternary strings in one step. According to Lemma 4, in the next two consecutive steps, these 5 length ternary strings will be reduced to 3 length strings after performing a -pblockInterchange appropriately in each step. As a result, the bound holds true. Through the reduction steps, if we can perform a single -pblockInterchange, the bound will hold true. Thus, if we append any length of ternary string after these 7 length normalized ternary strings, the bound always holds true.

This completes the proof. ∎

Input: , a fully normalized ternary string
;
;
while 3 do
       for do
             take the first symbol of input string ;
             take the symbol of the input string ;
             ;
             check whether this string is a substring of the current suffix ;
             for do
                   for do
                         ;
                         if then
                               perform a -pblockInterchange ;
                               ;
                               ;
                               ;
                              
                        end
                  end
            end if then
                   perform a -pblockInterchange ;
                   ;
                  
            end
      end ;
      
end
Algorithm 2 Algorithm to group fully normalized ternary string by prefix block-interchanges (s:input string)

We present Algorithm 2 to group fully normalized ternary strings in polynomial time. Here, denotes the length of the string . The outer while loop iterates until all the symbols of the string are grouped. We make the string apppending the symbol of the first position and the symbol of the position. Then, we make another string appending the symbol of the position and position such that . Now, if is equal to then we actually get that is equal and is equal to which are basically the conditions of Lemma 4. So, according to Lemma 4, we will get a -pblockInterchange here and thus the length of the string will be reduced by 2. If a -pblockInterchange is not found, we will perform a -pblockInterchange which is always possible according to Lemma 4 and thus the length of the string will be reduced by 1. When all symbols are grouped, the length of the string will be 3 for fully ternary normalized string and so the while loop will terminate. Clearly, our presented algorithm (Algorithm 2) will take time to execute, where is the length of the string.

We achieve the same bound as in Theorem 4, if we want to group normalized ternary strings applying restricted prefix block-interchanges. In supplementary Table 3, we show the derivations of the grouping distance for normalized ternary strings of length 5 and 6 applying restricted prefix block-interchanges.

(Sorting distance for ternary strings) Let be a fully normalized ternary string. Then, an upper bound for sorting ternary string is where is the length of the string.

Proof.

After grouping a ternary string, we can have one of the following grouped strings: and . Among these, is already sorted. We need one more prefix -pblockInterchange to sort and . We need two more prefix -pblockInterchanges to sort . Hence the result follows. ∎

4.1 Classification

In this section, following the trend of [2, 8], we will briefly identify two classes of fully normalized ternary strings. We have already shown in Theorem 4 that it needs at most prefix block-interchange operations to group fully normalized ternary strings. We will discuss two classes; the first one consists of the fully normalized ternary strings that require or prefix block-interchange operations (Class 1) and the other comprising strings that need roughly

or less operations (Class 2). We are not able to classify all the fully normalized ternary strings; however we provide below a classification of a large set thereof comprising infinite number of strings:

  • All strings of length 4 and 6 satisfy the bound , so we put them in Class 1 (see supplementary Table 2). Ternary strings reduced to any of these by a series of 1-pblockInterchange or 2-pblockInterchange operations will also belong to Class 1. Ternary strings reduced to any of these by a series of 3-pblockInterchange or 4-pblockInterchange will belong to Class 2.

  • , , , , belong to Class 1. We can apply relabeling on these to find strings starting with 0 or 2 and they also belong to Class 1. If a ternary string is reduced to any one of the previous strings by a series of consecutive -pblockInterchange, then that particular string also belongs to Class 1.

  • , , , belong to Class 2. We can apply one 0-pblockInterchange operation on these strings to get , , , , respectively. Now we see that prefix part in each of these strings is binary. So, we can apply 3-pblockInterchange or 4-pblockInterchange operations which will roughly require or less operations. We can apply relabeling on those to find strings starting with 0 or 2 which belong to Class 2.

5 Conclusion

In this paper, we have discussed grouping and sorting of fully binary and normalized ternary strings applying prefix block interchanges. In particular we have deduced that, for binary strings the grouping distance is using restricted prefix block-interchanges, which is better than existing results on binary strings applying other genome rearrangement operations [2, 3, 8, 14]. In addition, we have also provided a linear-time algorithm to sort fully normalized binary strings by restricted prefix block interchanges. We have deduced upper bounds applying prefix block-interchanges for grouping and sorting binary normalized strings as , when we need to sort 10, otherwise . We have also deduced upper bounds for both grouping and sorting normalized ternary strings as and respectively. We have also presented a time algorithm to group normalized ternary strings, where is the length of the string.

References

  • [1] A. J. Radcliffe, A. D. Scott and E. L. Wilmer, Reversals and transpositions over finite alphabets, SIAM J. Discrete Math., 19(1): 224-244, 2005.
  • [2] A. K. Dutta, M. Hasan and M. S. Rahman, Prefix Transpositions on Binary and Ternary Strings, Information Processing Letters, 113(8): 265-270, 2013.
  • [3] C. A. J. Hurkens, L. van Iersel, J. Keijsper, S. Kelk, L. Stougie and J. Tromp, Prefix Reversals on Binary and Ternary Strings, SIAM J. Discrete Math., 21(3):592-611, 2007.
  • [4] D. A. Christie and R. W. Irving, Sorting Strings by Reversals and by Transpositions, SIAM J. Discrete Math., 14(2):193-206, 2001.
  • [5] D. A. Christie, Sorting permutations by block-interchanges, Information Processing Letters 60(4): 165-169, 1996.
  • [6] D. Sankoff, Gene and genome duplication, Current Opinion in Genetics and Development, 11(6): 681-684, 2001.
  • [7] H. Eriksson, K. Eriksson, J. Karlander, L. J. Svensson and J. Wästlund, Sorting a Bridge Hand, Discrete Mathematics, 241(1-3):289-300, 2001.
  • [8] M. K. Rahman and M. S. Rahman, Prefix and suffix transreversals on binary and ternary strings, Journal of Discrete Algorithms, Elsevier, 33:160-170, 2015.
  • [9] M. Hasan, A. Rahman, M.K. Rahman, M.S. Rahman, M. Sharmin, R. Yeasmin, Pancake flipping and sorting permutations, Journal of Discrete Algorithms, 2015 Jul 1;33:139-49.
  • [10] T. Hartman and R. Sharan, A 1.5-approximation algorithm for sorting by transpositions and transreversals, Journal of Computer and System Sciences, 70(3):300-320, 2005.
  • [11] A. Bergeron, J. Mixtacki and J. Stoye, A unifying view of genome rearrangements, Algorithms in Bioinformatics, Springer Berlin Heidelberg, 163-173, 2006.
  • [12] A. Solomon, P. Sutcliffe and R. Lister, Sorting Circular Permutations by Reversal, In Proceedings of 8th International Workshop, WADS, pages 319-328, Ottawa, Ontario, Canada, July 30 - August 1, 2003.
  • [13] X. Chen, Z. Fu, T. Jiang, S. Lonardi, P. Nan, J. Zheng and Y. Zhong, Assignment of orthologous genes via genome rearrangement, IEEE/ACM Trans. Comput. Biology Bioinform., 2(4):302-315, 2005.
  • [14] S. W. Chou, C. H. Yang, K. T. Chen and C. L. Lu, Prefix Block-Interchanges on Binary Strings, Workshop on Healthcare and Bioinformatics, ICS, Taiwan, 2014.

Supplementary Tables

derivation
5 1
1
1
1
2
1
1
6 1
2
1
2
1
2
2
2
2
2
1
2
1
2
Table 2: (Supplementary) This table shows the derivation of the grouping distance for normalized ternary strings of length 5 and 6 deduced from List (1). is the length of normalized ternary strings and is the grouping distance. Here, binary strings like 101010 or 121212 are omitted.
derivation
5 1
1
1
1
1
1
1
6 1
2
1
2
1
2
1
1
1
2
1
1
1
2
Table 3: (Supplementary) This table shows the derivation of the grouping distance for normalized ternary strings of length 5 and 6 deduced from List (1). is the length of normalized ternary strings and is the grouping distance applying restricted prefix block-interchanges. Here, binary strings like 101010 or 121212 are omitted.