1 Introduction

In the minimum common string partition (MCSP) problem, we are given two related strings (S, T). Two strings are said to be related if the frequencies of each letter in the two strings match. A partition of a string S is defined as a sequence P = (b₁, b₂, …, b_c), where b_i are substrings of S whose concatenation is equal to S, i.e., b₁ b₂…b_c = S. Given a partition P of a string S and a partition Q of a string T, we say that the pair π = < P, Q > is a common partition of (S, T) if Q is a permutation of P. The minimum common string partition problem is to find a common partition of (S, T) with the minimum number of substrings, that is to minimize c. For example, if (S, T) = (atatgat,atgatat), then an optimal solution is π = {atgat,at} and the minimum common partition size is 2. The restricted version of MCSP where each letter occurs at most d times in each input string, is denoted by d-MCSP. A more detailed study of the application of MCSP can be found in [1], [2] and [3].

In this paper, we present an Integer Linear Programming (ILP) formulation for the MCSP problem. In particular, we use a graph mapping that was presented in our prior work [4] to solve the MCSP problem using the Ant Colony Optimization technique [5]. Here we exploit this graph to devise an ILP formulation for the problem. Then we implement the ILP formulation, conduct extensive experiments and compare the results with the state-of-the-art algorithms from the literature. As will be reported in a later section, the results clearly indicate that the ILP formulation is effective and provides excellent results. One of the intriguing findings of our work is the fact that our ILP formulation turns out to be more effective and accurate than our meta-heuristics approach presented in [4]. This is especially interesting because both the algorithms are based on the same graph that is constructed through an interesting mapping [4].

The rest of the paper is organized as follows. In Section 2 we present a brief literature review. Section 3 presents the notations and definitions used in this paper. In Section 4 we present the ILP formulation for the MCSP problem. We present our experimental results in Sections 5 followed by a brief relevant discussion in Section 6. Finally, we briefly conclude in Section 7.

2 Related Works

The 1-MCSP problem is essentially the breakpoint distance problem [6] between two permutations, which is solvable in polynomial time [1]. The 2-MCSP problem has been shown to be NP-hard and moreover APX-hard in [1]. The authors in [1] also have presented several approximation algorithms to solve the problem. In [2], Chen et al. have studied a generalization of the MCSP problem called the Signed Reversal Distance with Duplicates (SRDD). Furthermore, they have presented a 1.5-approximation algorithm for the 2-MCSP problem. In [7], Damaschke has analyzed the fixed-parameter tractability of the MCSP problem considering different parameters. The MCSP problem is also studied in [8], where it is termed as the true evolutionary distance problem between two genomes. In [9], the authors have investigated the d-MCSP problem along with two other variants, namely, MCSP^c, where the alphabet size is at most c and x-balanced MCSP, which requires that the length of blocks be at most x away from the average length. They have shown that MCSP^c is NP-hard when c ≥ 2. As for d-MCSP, they have presented an fixed parameter tractable (FPT) algorithm which runs in O*((d!)^k) time, where k is the number of blocks in the optimal common partition. The result has been improved by Bulteau et al. [10] by showing that MCSP can be solved in O(d^2k ⋅ kn) time. Recently, Bulteau and Komusiewicz [11] have introduced the first fixed-parameter algorithm for the MCSP problem using parameter k only.

Chrobak et al. [3] have analyzed a natural greedy heuristic for the MCSP problem: iteratively, at each step, it extracts a longest common substring from the input strings. They have shown that for the 2-MCSP problem, the approximation ratio (for the greedy heuristic) is exactly 3. They also have proved that for the 4-MCSP problem the ratio is log n and for the general case, it lies between Ω(n^0.43) and O(n^0.67). In [12], He has proposed an improved greedy algorithm based on the greedy strategy of [3], where the idea is to extract the longest common substring containing a symbol occurring only once at each step whenever there is such a symbol.

In our prior work [4], we have developed a meta-heuristc algorithm, namely, MAX-MIN ant system to solve the MCSP problem. In particular, in [4], we have mapped the instance of the MCSP problem into a graph, namely, the common substring graph. MAX-MIN Ant System has been implemented over this graph. Recently in [13], Blum et al. have proposed an iterative probabilistic tree search algorithm for solving this problem. The algorithm is an iterative probabilistic variant of the greedy algorithm of [3]. The authors have tested their approach with the dataset introduced in [4]. Subsequently, a common block based ILP formulation has been proposed in [14] by Blum et al. They have tested their ILP formulation on the previous benchmarks [4] as well as on a new benchmark of 7 larger instances.

3 Preliminaries

This section summarizes the definitions and notations used throughout the paper. Two strings (S, T), of equal length (n), over an alphabet ∑ are called related if the frequencies of the letters in the two strings match. We define a block B = [S, i, j], 0 ≤ i ≤ j < n, of a string S as a data structure where i and j denote the starting and ending positions of the block. A block, [S, i, j] represents a substring of S denoted as substring([S, i, j]) with length (j − i+1).

As an example, if we have two strings (S, T) = (atgcat,tgcata), then [S, 0, 1] and [S, 4, 5] both represent the substring at of S. In other words, substring([S, 0, 1]) = substring([S, 4, 5]) = at. We say that a block B matches with another block B′ if the two blocks represent the same substrings. Given a list of blocks l_b, matchList(l_b, B) is defined as a list of those blocks of l_b that match B. For the example stated above, let a list of blocks be l_b = {[S, 0, 1], [S, 1, 1], [S, 4, 5]} and B = [S, 0, 1]; then matchList(l_b, B) = {[S, 0, 1], [S, 4, 5]}.

We use the notion of a common substring graph as introduced in [4]. A common substring graph, G_cs(V, E, S) of two strings (S, T) is defined as follows. Here V is the vertex set of the graph and E is the edge set. Vertices are the positions of string S, i.e., for each v ∈ V, v ∈ {0, n − 1}. Two vertices v_i ≤ v_j are connected with an edge, i.e, (v_i, v_j) ∈ E, if the substring induced by the block [S, v_i, v_j] matches some substring of T. More formally, if S_T denotes the set of all substrings of T, we have:

In other words, each edge in the edge set corresponds to a block satisfying the above condition. For convenience, we will denote the edges as edge blocks and use the list of edge blocks (instead of edges) to define the edge set E.

For example, suppose (S, T) = (atgcta,atgcat). The corresponding common substring graph of the first string S, denoted by G_cs(V, E, S), will have vertex set, V = {0, 1, 2, 3, 4, 5} and edge set, E = {[S, 0, 0], [S, 1, 1], [S, 2, 2], [S, 3, 3], [S, 4, 4], [S, 5, 5], [S, 0, 1], [S, 1, 2], [S, 2, 3], [S, 0, 2], [S, 1, 3], [S, 0, 3]}.

4 ILP Formulation

Suppose we are given two related strings (S, T), each of length n. We create two graphs, namely, G_cs(V₁, E₁, S) and G_cs(V₂, E₂, T) of (S, T), where V₁ and V₂ are the vertex sets and E₁ and E₂ are the edge block sets of the two graphs respectively. We define two sets of binary variables, namely, x_t1 and y_t2 where t₁ ∈ E₁ and t₂ ∈ E₂. We also write δ_k(v)⁻ and δ_k(v)⁺ for the sets of incoming and outgoing edge blocks from E_k where v ∈ V_k and k ∈ {1, 2}. An incoming (outgoing) edge block is the one whose starting (ending) position i (j) is 0 (n − 1). With the above setting, we develop an ILP formulation (denoted as ILP_graph) for the MCSP problem using the common substring graph as follows: (1) (2) (3) (4) (5) (6) (7) (8)

5 Experiments

Except for one, we have conducted all our experiments in a computer with Intel(R) Core(TM) i5-2450M CPU @2.50 GHz having an installed memory (RAM) of 4.00 GB. There is one particular experiment that has been run in another machine with the same configuration except that the available RAM was higher, 8.00 GB. The operating system was Windows 8.1. The programming environment was Matlab. We have used SCIP (version 3.1.0) standalone solver [15] to solve ILP_graph.

5.3 Results and Analysis

In an updated and extended version [19] (the preprint is available at [20]) of our earlier work [4], MAX-MIN ACO (referred to as MMAS henceforth) has been compared with the greedy algorithm of [3]. In [13], the authors have compared their two versions of iterative probabilistic tree search (TS1 and TS2) with Greedy and MMAS. Here we report only the best of the two tree search solutions (henceforth referred to as TS). Recently in [14], the authors have compared the results of their ILP formulation (ILP_orig) with Greedy, MMAS and TS. Here, we compare our ILP formulation, i.e., ILP_graph with MMAS [4, 19, 20], TS [13] and ILP_orig[14]. As for the greedy algorithm, we have considered the improved greedy approach in [12] (henceforth labelled as Greedy).

Table 1 presents the comparison among the results of ILP_graph and other competitive approaches for Group1-Group3 and Real dataset. For each group the first column is the instance number. The second, third and forth columns represent the common partition size by Greedy [12], MMAS [19] and TS [13] respectively. The fifth to eighth column summarize the results of ILP_orig. The result is obtained from [14]. The fifth column is the partition size. The sixth column is the time in second, presented as X/Y format only when the solver has been unable to find the optimal solution in 3600 cpu seconds; otherwise it is shown as a single value format reporting the time to get the optimal solution. The seventh column report the relative gap, where gap is defined as the difference between the value of the best valid solution (primal bound) and the lower bound (dual bound) of the problem. The relative gap is formulated as ∣(upperbound − lowerbound)/min(∣upperbound∣, ∣lowerbound∣)∣. The eighth column is the number of variables in the formulation for the instance. The last four columns report the result of our formulation, ILP_graph. The columns here reports the same information as the fifth to eighth columns. The best result for an instance is boldfaced.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Comparison for Group1-Group3 and Real dataset.

https://doi.org/10.1371/journal.pone.0130266.t001

From Table 1, it is easily verified that ILP_graph provides much better common partition size than other approaches. Out of 45 instances, it provides equal or better partition size than ILP_orig in 42 cases, amongst which 23 are strictly better. The improvement is not only in the solution size but also in computational time. Except for Group1, ILP_graph has been able to achieve improved solution in significantly less time than ILP_orig. The number of variables are also dramatically reduced in ILP_graph. Fig 1, shows the percentage of improvement of ILP_graph over the other five approaches considered. The significant improvement can be perceived from the figure.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Percentage of improvement of ILP_graph over Greedy, MMAS, TS and ILP_orig.

Top: Improvement in average solution. Bottom: Improvement in median solutions.

https://doi.org/10.1371/journal.pone.0130266.g001

Table 2 reports the average results of Group4 dataset. Here the average of the results of 10 instances for each length group having a particular alphabet size is reported. For example, the first row reports the average results of ten 100-length instances on an alphabet size of 4. The result of ILP_orig is collected through personal communication with the author of [14]. It is notable that for the Group4 dataset, ILP_orig was implemented using GCC 4.7.3 and IBM ILOG CPLEX V12.1. Moreover, as reported in [14], the corresponding experiments were conducted on a cluster of PCs with 2933MHz Intel(R) Xeon(R) 5670 CPUs having 12 nuclei and 32GB RAM. The third to seventh columns report the solution of ILP_orig while the eighth to thirteenth columns report the solution of ILP_graph. The columns report the same information as in Table 1 with four exceptions as follows. Firstly, the time when the first valid solution is achieved and the time when the best solution is achieved within the time limit (3600 sec) are presented in two different columns (labelled as ftime and time respectively). Secondly, for each formulation, how many among the 10 instances (represented by each row) have been solved optimally is reported in the column named #opt. Finally, the last two columns represent the percentage of improvement in average partition size and the percentage of decrease in the number of variables of ILP_graph over ILP_orig respectively.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Comparison of average results on Group4 dataset.

https://doi.org/10.1371/journal.pone.0130266.t002

Like Group1-Group3 and Real dataset, the results of Table 2 draw the same conclusion. The ILP_graph formulation provides better solutions than ILP_orig in almost every aspect. Numerically, ILP_graph gets equal or better average partition in 28 out of 30 instances of which 12 are strictly better. The number of instances solved optimally by ILP_graph is 172 (out of 300) which is 12 more than that of ILP_orig. The percentage of improvements in the average solutions also proves the superiority of ILP_graph. As it is evident from Table 2, the improvement gets more acute with the increase of the string length and the decrease of the alphabet size. This observation is also supported by Table 3 that reports the solutions of the two formulations for Group5 dataset. The 7 instances of Group5 were introduced in [14] to test the limit of their formulation. Their simulation [14] was conducted in a cluster of PCs with “Intel(R) Xeon(R) CPU 513” CPUs of 4 nuclei of 2000 MHz and 4 Gigabyte of RAM with the time limit of 12 hours. On the other hand, for this dataset, we have enforced 3600 seconds for the first 5 instances and 7200 seconds for the last two. ILP_orig could not achieve a valid solution for the last instance even within 12 hours whereas ILP_graph got a valid solution in 6100 seconds. From the percentage of improvement (%impr) it can be concluded that, ILP_graph achieves better partition size with less time as the length of the string increases. The number of variables also become intractable for ILP_orig as the length increases. All of these results speak in favor of ILP_graph.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Comparison result for Group5 dataset.

NSF means “No solutions found”.

https://doi.org/10.1371/journal.pone.0130266.t003

Finally, to further test the limit of our formulation, i.e., ILP_graph, we have conducted an experiment with an instance of length 3000 on the machine with 8GB of RAM. The time limit was set to 12 hours. ILP_graph has been able to get a valid solution of partition size 642 in 11 hours.

5.4 Running Time

In the previous section, we have shown that ILP_graph provides much better partition size. In this section we will explore the running time of ILP_graph. It is clear from Tables 1–3 that ILP_graph achieves faster solution in most of the cases even running on a slower processor having lesser memory. This is also true for the first valid solution it provides. Fig 2 shows the comparison of the average first valid solution time for three groups based on the alphabet size in Group4 dataset. From this figure it is clear that ILP_graph finds the first valid solution faster than ILP_orig and the difference in the running time becomes more apparent as the length of the string increases. Now we concentrate on comparing the running time of ILP_graph with the other four approaches. The running times of the two tree search algorithms (referred to as TS1 and TS2) are taken from [15]. The running time of MMAS is taken from [19]. The Greedy algorithm is very fast. It gives the output within few seconds. So, in the analysis, we will assume that the output of Greedy algorithm is readily available even at the beginning of the simulation. We have recorded the primal solution (partition size) of our algorithm periodically. Figs 3–6 show the detailed runtime comparison among the algorithms for Group1, Group2, Group3 and Real datasets respectively. For each group we have shown the average partition size dynamics with respect to time. The three points (“*”,“+”,“o”) in each of the figures are the plots of average partition size vs. the average time needed to achieve that partition size for MMAS, TS1 and TS2 approach respectively (data taken from [13], [19]). The dashed line represents the Greedy partition size.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Average time for the first valid solution found by ILP_graph on Group4 data.

Top: Alphabet size 4. Middle: Alphabet size 12. Bottom: Alphabet size 20.

https://doi.org/10.1371/journal.pone.0130266.g002

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Avg. solution Vs. time comparison (Group1).

https://doi.org/10.1371/journal.pone.0130266.g003

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Avg. solution Vs. time comparison (Group2).

https://doi.org/10.1371/journal.pone.0130266.g004

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Avg. solution Vs. time comparison (Group3).

https://doi.org/10.1371/journal.pone.0130266.g005

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Avg. solution Vs. time comparison (Real).

https://doi.org/10.1371/journal.pone.0130266.g006

Although the reported time of ILP_graph (in Table 1) is higher than that of Greedy, TS1 and TS2 approaches in some instances but from the Figs 3–6, it can be easily observed that the ILP_graph algorithm reaches to better solutions much earlier. From the figures it is clear that ILP_graph is better than Greedy at any stage of time. Even if we stop the algorithm at or earlier than the average runtime of MMAS, TS1 or TS2, the ILP_graph provides better solutions.

6 Discussion

At this point a brief discussion on the number of variables in the two ILP formulations, namely, ILP_orig and ILP_graph, is in order. In Fig 7, we show the comparison of the number of variables between the two formulations for Group4 dataset. Although both formulations have O(n²) variables, we observe a significant decrease in the number of variables in ILP_graph than ILP_orig. The average improvement in the number of variables are reported in the last column of Tables 2 and 3 for Group4 and Group5 datasets respectively. For the Group4 dataset the maximum and minimum percentage of decrease in the number of variables are 97.06% and 57.55% with the average improvement of 88.24% while for the Group5 dataset the maximum and minimum are 98.22% and 96.48% with an average of 97.52%.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. Comparison of average number of variables between ILP_orig and ILP_graph for Group4 dataset.

Top: Alphabet size 4. Middle: Alphabet size 12. Bottom: Alphabet size 20.

https://doi.org/10.1371/journal.pone.0130266.g007

The drastic improvement in the number of variables for ILP_graph and the lack thereof for ILP_orig can easily be understood by analyzing the variable set of the two formulations. ILP_orig is based on common blocks. A common block b of two strings (S, T) is defined in [14] as a triple (t, k₁, k₂). Here t is a common substring of (S, T) that appeared at position k₁ of S and k₂ of T where 0 ≤ k₁, k₂ ≤ n − 1. B = {B₁, B₂,…B_m} is the (ordered) set of all common blocks of (S, T). This set is the variable set of ILP_orig. For an example, if (S, T) = (aaagggccc,gggaaaccc), then the number of common blocks would be 42. To find this, first concentrate on a common substring from S and T, namely aaa. The common blocks resulting from this common substring are, B = {[a, 0, 3], [a, 0, 4], [a, 0, 5], [a, 1, 3], [a, 1, 4], [a, 1, 5], [a, 2, 3], [a, 2, 4], [a, 2, 5], [aa, 0, 3], [aa, 0, 4], [aa, 1, 3], [aa, 1, 4], [aaa, 0, 3]}. Similar common blocks can be computed for the other two common substrings (ggg and ccc) too. On the other hand the number of variables in ILP_graph depends on the number of edges in the common substring graph. Thus, for the above example, if we construct the common substring graph on S, we have 18 edge blocks, E = {[S, 0, 0], [S, 0, 1], [S, 0, 2], [S, 1, 1], [S, 1, 2], [S, 2, 2], [S, 3, 3], [S, 3, 4], [S, 3, 5], [S, 4, 4], [S, 4, 5], [S, 5, 5], [S, 6, 6], [S, 6, 7], [S, 6, 8], [S, 7, 7], [S, 7, 8], [S, 8, 8]}. Thus ILP_graph reduces the number of variables significantly.

7 Conclusion and Future works

In this paper, we have presented an ILP formulation for the MCSP problem. We have conducted extensive experiments and compared the results with the state-of-the-art algorithms in the literature. The results clearly indicate that the ILP formulation is effective and provides excellent results. The observations of Section 5.4 bear important research directions. The research on this field should now be focussed on finding MCSP for larger instances in reasonable time. As ILP_graph provides better solution faster than the other competitive approaches, one idea is to stop the solver as soon as it gets the first solution. This solution or possibly a set thereof can be used as the initial solution(s) for existing and new meta-heuristic approaches developed to solve this problem including the ones reported in [4] and [13]. Another research direction could be as follows. So, far MCSP has been studied mostly in the context of operations research. However, it has important applications in genome comparison and rearrangement. So, datases from comparative genomics applications could be gathered for further experimental analysis and comparison with relevant algorithms (e.g., [10]) in the field of computational biology.

Supporting Information

Acknowledgments

One of the authors, M. Sohel Rahman is currently on a sabbatical leave from Bangladesh University of Engineering and Technology (BUET).