Common Subsequence Problem Research Articles

Dominant point-based sequential and parallel algorithms for the multiple sequential substring constrained-LCS problem

The Longest Common Subsequence (LCS) problem is a well-known and studied problem in computer science and bioinformatics. It consists in finding the longest subsequence that is common to two or more given sequences. In this paper, we address the problem of finding all LCS for the Sequential Substring Constrained-LCS (SSCLCS) problem, called the Multiple SSCLCS problem. To solve this problem, we first propose a dominant point-based sequential algorithm, designed on a new Leveled Direct Acyclic Graph (DAG) that gives the correct evaluation order of subproblems to avoid redundancy due to overlap. Depending on whether the constraints may overlap or not, it requires O ( S | Σ | K + 1 + r + n | Σ |) and O ( S | Σ | K + 1 + n | Σ |) time with \(O(Max\_level+n|\Sigma |) \) space. S is the number of partial SSCLCS in a node, K is the number of DAG levels, n is the length of sequences, r is the total length of constraints, \(Max\_level \) is the number of nodes in the largest level of the DAG, and | Σ | is the length of the alphabet. Then, we derive a coarse-grained multicomputer parallel solution requiring \(O\left(\frac{S|\Sigma |^{K+1}+r+n|\Sigma |}{p}\right) \) and \(O\left(\frac{S|\Sigma |^{K+1}+n|\Sigma |}{p}\right) \) execution time, \(O(Max\_level+n|\Sigma |) \) memory space and O ( K ) communication rounds. p is the number of processors. Experimental results showed that the parallel algorithm is respectively 14.43 × and 19.19 × faster than the sequential algorithm on 32 and 64 processors.

Dynamic-MLCS: Fast searching for dynamic multiple longest common subsequences in sequence stream data

In recent years, data stream mining has become a popular research topic, wherein the dynamic multiple longest common subsequence problem for sequence streams (i.e., D-MLCS) is an important issue with a vast range of applications. However, the existing methods are only for static multiple longest common subsequence problem (i.e., S-MLCS) and there are no algorithms for the D-MLCS problem. Using the existing algorithms for the S-MLCS problem to solve the D-MLCS problem often leads to an overload of the main memory and is extremely time consuming as all the sequence segments should be stored into the main memory when the new segments flow in, and all updated problems should be resolved. To overcome this shortcoming, we designed a scheme for constructing dynamic Directed Acyclic Graphs (DAGs). It only needs to update the current DAG post each sequence segment flows in, without constructing the DAG from the beginning. We propose a novel algorithm for the D-MLCS problem called Dynamic-MLCS, which only needs to store a part of the key information of each streaming sequence segments, instead of storing all streaming sequence segments and scanning them repeatedly. Theoretical analyses demonstrate that the time and space complexities of the proposed algorithm are only relevant and linear to the number of the incomplete points and newly generated nodes, and the experiments conducted on the datasets of sequence streams indicate that the proposed Dynamic-MLCS is efficient and performs better than the compared state-of-the-art algorithms.

Reconstruction algorithms for DNA-storage systems

Motivated by DNA storage systems, this work presents the DNA reconstruction problem, in which a length-n string, is passing through the DNA-storage channel, which introduces deletion, insertion and substitution errors. This channel generates multiple noisy copies of the transmitted string which are called traces. A DNA reconstruction algorithm is a mapping which receives t traces as an input and produces an estimation of the original string. The goal in the DNA reconstruction problem is to minimize the edit distance between the original string and the algorithm’s estimation. In this work, we present several new algorithms for this problem. Our algorithms look globally on the entire sequence of the traces and use dynamic programming algorithms, which are used for the shortest common supersequence and the longest common subsequence problems, in order to decode the original string. Our algorithms do not require any limitations on the input and the number of traces, and more than that, they perform well even for error probabilities as high as 0.27. The algorithms have been tested on simulated data, on data from previous DNA storage experiments, and on a new synthesized dataset, and are shown to outperform previous algorithms in reconstruction accuracy.

Move schedules: fast persistence computations in coarse dynamic settings

AbstractMatrix reduction is the standard procedure for computing the persistent homology of a filtered simplicial complex with m simplices. Its output is a particular decomposition of the total boundary matrix, from which the persistence diagrams and generating cycles are derived. Persistence diagrams are known to vary continuously with respect to their input, motivating the study of their computation for time-varying filtered complexes. Computing persistence dynamically can be reduced to maintaining a valid decomposition under adjacent transpositions in the filtration order. Since there are $$O(m^2)$$ O ( m 2 ) such transpositions, this maintenance procedure exhibits limited scalability and is often too fine for many applications. We propose a coarser strategy for maintaining the decomposition over a 1-parameter family of filtrations. By reduction to a particular longest common subsequence problem, we show that the minimal number of decomposition updates d can be found in $$O(m \log \log m)$$ O ( m log log m ) time and O(m) space, and that the corresponding sequence of permutations—which we call a schedule—can be constructed in $$O(d m \log m)$$ O ( d m log m ) time. We also show that, in expectation, the storage needed to employ this strategy is actually sublinear in m. Exploiting this connection, we show experimentally that the decrease in operations to compute diagrams across a family of filtrations is proportional to the difference between the expected quadratic number of states and the proposed sublinear coarsening. Applications to video data, dynamic metric space data, and multiparameter persistence are also presented.

Longest common substring in Longest Common Subsequence’s solution service: A novel hyper-heuristic

The Longest Common Subsequence (LCS) is the problem of finding a subsequence among a set of strings that has two properties of being common to all and the longest. The LCS has applications in computational biology and text editing, among many others. Due to the NP-hardness of the general longest common subsequence, numerous heuristic algorithms and solvers have been proposed to give the best possible solution for different sets of strings. None of them has the best performance for all types of sets. In addition, there is no method to specify the type of a given set of strings. Besides that, the available hyper-heuristic is not efficient and fast enough to solve this problem in real-world applications. This paper proposes a novel hyper-heuristic to solve the longest common subsequence problem using a new criterion to classify a set of strings based on their similarity. To do this, we offer a general stochastic framework to identify the type of a given set of strings. Following that, we introduce the set similarity dichotomizer (S2D) algorithm based on the framework that divides the type of sets into two. This algorithm is introduced for the first time in this paper and opens a new way to go beyond the current LCS solvers. Then, we present our proposed hyper-heuristic that exploits the S2D and one of the internal properties of the given strings to choose the best matching heuristic among a set of heuristics. We compare the results on benchmark datasets with the best heuristics and hyper-heuristics. The results show that our proposed dichotomizer (i.e., S2D) can classify datasets with 98% of accuracy. Also, our proposed hyper-heuristic obtains competitive performance in comparison with the best methods and outperforms best hyper-heuristics for uncorrelated datasets in terms of both quality of solutions and run time factors. All supplementary files, including the source codes and datasets, are publicly available on GitHub.11https://github.com/BioinformaticsIASBS/LCS-DSclassification.

Linear-space S-table algorithms for the longest common subsequence problem

Given two sequences A and B of lengths m and n, respectively, the consecutive suffix alignment (CSA) problem is to compute the longest common subsequence (LCS) between A and each suffix of B. The data structure of two-dimensional matrix for solving the CSA problem is named S-table. The S-table would be infeasible due to its quadratic-space requirement for long sequences. The linear-space S-table, proposed by Alves et al. (2005), consists of the first row of the S-table and the changes between every two consecutive rows. However, there is no further discussions and practical applications for the linear-space S-table. This paper proposes algorithms for improving three problems, related to LCS and S-table, by using the linear-space S-table. Suppose that A = A(1)A(2) (concatenation of two substrings), and we are given the S-table of A(2) and B, as well as the alignment result (LCS length) of A(1) to each prefix of B. The concatenated LCS (CoLCS) problem is to find the alignment result of A and B. For the CoLCS problem, this paper proposes an O(n)-time algorithm with the technique of set union-find to achieve the linear space. Next, for merging two linear S-tables, we propose an O(nlog⁡n)-time algorithm with the technique of range query and update to improve the quadratic-time algorithm using quadratic-space S-tables. Then, we propose an O(n)-time algorithm to update the linear-space S-table of A and B to obtain the linear-space S-table of Aσ and B, where σ denotes a new character appended to the tail of A. For further applications to long sequences by using the linear-space S-table, the algorithms proposed in this paper are essential and necessary.

Provably Good Solutions to the Knapsack Problem via Neural Networks of Bounded Size

The development of a satisfying and rigorous mathematical understanding of the performance of neural networks is a major challenge in artificial intelligence. Against this background, we study the expressive power of neural networks through the example of the classical NP-hard knapsack problem. Our main contribution is a class of recurrent neural networks (RNNs) with rectified linear units that are iteratively applied to each item of a knapsack instance and thereby compute optimal or provably good solution values. We show that an RNN of depth four and width depending quadratically on the profit of an optimum knapsack solution is sufficient to find optimum knapsack solutions. We also prove the following tradeoff between the size of an RNN and the quality of the computed knapsack solution: for knapsack instances consisting of n items, an RNN of depth five and width w computes a solution of value at least [Formula: see text] times the optimum solution value. Our results build on a classical dynamic programming formulation of the knapsack problem and a careful rounding of profit values that are also at the core of the well-known fully polynomial-time approximation scheme for the knapsack problem. A carefully conducted computational study qualitatively supports our theoretical size bounds. Finally, we point out that our results can be generalized to many other combinatorial optimization problems that admit dynamic programming solution methods, such as various shortest path problems, the longest common subsequence problem, and the traveling salesperson problem. History: Andrea Lodi, Area Editor for Design & Analysis of Algorithms–Discrete. An extended abstract of this article, including Figures 1 – 7 , appeared in the Proceedings of the AAAI Conference on Artificial Intelligence, vol. 35, 7685–7693 ( Hertrich and Skutella 2021 ); see https://ojs.aaai.org/index.php/AAAI/article/view/16939 ; copyright © 2021, Association for the Advancement of Artificial Intelligence. Funding: This work was supported by the Deutsche Forschungsgemeinschaft [Grants DFG-GRK 2434 and EXC-2046/1, Project 390685689] and the H2020 European Research Council [ScaleOpt-757481].

A two-step methodology for product platform design and assessment in high-variety manufacturing

The delayed product differentiation (DPD) recently rose as a hybrid production strategy able to overcome the main limits of make to stock (MTS) and make to order (MTO), guaranteeing the management of high variety and keeping low storage cost and quick response time by using the so-called product platforms. These platforms are a set of sub-systems forming a common structure from which a set of derivative variants can be efficiently produced. Platforms are manufactured and stocked following an MTS strategy. Then, they are customized into different variants, following an MTO strategy. Current literature proposes methods for platform design mainly using optimization techniques, which usually have a high computational complexity for efficiently managing real-size industrial instances in the modern mass customization era. Hence, efficient algorithms need to be developed to manage the product platforms design for such instances. To fill this gap, this paper proposes a two-step methodology for product platforms design and assessment in high-variety manufacturing. The design step involves the use of a novel modified algorithm for solving the longest common subsequence (LCS) problem and of the k-medoids clustering for the identification of the platform structure and the assignment of the variants to the platforms. The platforms are then assessed against a set of industrial and market metrics, i.e. the MTS cost, the variety, the customer responsiveness, and the variants production cost. The evaluation of the platform set against such a combined set of drivers enhancing both company and market perspectives is missing in the literature. A real case study dealing with the manufacturing of a family of valves exemplifies the efficiency of the methodology in supporting companies in managing high-variety to best balance the proposed metrics.

An Algorithm for the Longest Common Subsequence and Substring Problem

In this note, we first introduce a new problem called the longest common subsequence and substring problem. Let X and Y be two strings over an alphabet ∑. The longest common subsequence and substring problem for X and Y is to find the longest string, which is a subsequence of X and a substring of Y. We propose an algorithm to solve the problem.

Time-series anomaly detection using dynamic programming based longest common subsequence on sensor data

This study proposes a novel approach to time-series anomaly detection by solving the longest common subsequence (LCS) problem of two time-series data. The conventional LCS problem is used to measure the similarity of two input strings. However, it cannot be applied to real-time data collected from sensors in smart manufacturing, which are mostly real numbers instead of strings. Thus, two algorithms—an extension of fixed gap longest common subsequence (extent FGLCS) and the modified dynamic programming-based LCS (MDP-LCS) algorithm—are proposed to deal with real-time series data. Further, a gap search constraint is investigated to limit the search range in finding the LCS. This study also provides a threshold to define the matching of a pair that contains real numbers rather than a string in the conventional LCS or FGLCS problems. In addition, the proposed methods employ the gap search constraint and the threshold to reduce computational time. Furthermore, the proposed algorithms can be implemented on both univariate and multivariate time-series data. The LCS length, known as the similarity of the two time-series data, is used to detect the anomalies based on the user’s expectation. The accuracy and computational time of the proposed algorithm show a significant positive result compared with the exact solution provided by the dynamic programming-based LCS algorithm. Moreover, this study also uses the proposed methods for anomaly detection in a case study of big multisensory data in smart manufacturing. The result shows that the MDP-LCS can detect approximately 98% of normal data and more than 85% of anomalies with a shorter computational time.

An efficient algorithm for the longest common palindromic subsequence problem

The longest common palindromic subsequence (LCPS) problem is a variant of the longest common subsequence (LCS) problem. Given two input sequences A and B, the LCPS problem is to find the common subsequence of A and B such that the answer is a palindrome with the maximal length. The LCPS problem was first proposed by Chowdhury et al. (2014) [9], who proposed a dynamic programming algorithm with O(m2n2) time, where m and n denote the lengths of A and B, respectively. This paper proposes a diagonal-based algorithm for solving the LCPS problem with O(L(m−L)Rlog⁡n) time and O(RL) space, where R denotes the number of match pairs between A and B, and L denotes the LCPS length. In our algorithm, the 3-dimensional minima finding algorithm is invoked to overcome the domination problem. As experimental results show, our algorithm is efficient practically compared with some previously published algorithms.

A coarse-grained multicomputer parallel algorithm for the sequential substring constrained longest common subsequence problem

In this paper, we study the sequential substring constrained longest common subsequence (SSCLCS) problem. It is widely used in the bioinformatics field. Given two strings X and Y with respective lengths m and n, formed on an alphabet Σ and a constraint sequence C formed by ordered strings (c1,c2,…,cl) with total length r, the SSCLCS problem is to find the longest common subsequence D between X and Y such that D contains in an ordered way c1,c2,…,cl. To solve this problem, Tseng et al. proposed a dynamic-programming algorithm that runs in Omnr+(m+n)|Σ| time. We rely on this work to propose a parallel algorithm for the SSCLCS problem on the Coarse-Grained Multicomputer (CGM) model. We design a three-dimensional partitioning technique of the corresponding dependency graph to reduce the latency time of processors by ensuring that at each step, the size of the subproblems to be performed by processors is small. It also minimizes the number of communications between processors. Our solution requires Onmr+(m+n)|Σ|p execution time with O(p) communication rounds on p processors. The experimental results show that our solution speedups up to 59.7 on 64 processors. This is better than the CGM-based parallel techniques that have been used in solving similar problems.

Graph search and variable neighborhood search for finding constrained longest common subsequences in artificial and real gene sequences

We consider the constrained longest common subsequence problem with an arbitrary set of input strings as well as an arbitrary set of pattern strings. This problem has applications, for example, in computational biology where it serves as a measure of similarity for sets of molecules with putative structures in common. We contribute in several ways. First, it is formally proven that finding a feasible solution of arbitrary length is, in general, NP-complete. Second, we propose several heuristic approaches: a greedy algorithm, a beam search aiming for feasibility, a variable neighborhood search, and a hybrid of the latter two approaches. An exhaustive experimental study shows the effectivity and differences of the proposed approaches in respect to finding a feasible solution, finding high-quality solutions, and runtime for both, artificial and real-world instance sets. The latter ones are generated from a set of 12681 bacteria 16S rRNA gene sequences and consider 15 primer contigs as pattern strings.

The Algorithms for the Linear-Space S-Table on the Longest Common Subsequence Problem

The Algorithms for the Linear-Space S-Table on the Longest Common Subsequence Problem

Solving the Longest Common Subsequence Problem Concerning Non-Uniform Distributions of Letters in Input Strings

The longest common subsequence (LCS) problem is a prominent NP–hard optimization problem where, given an arbitrary set of input strings, the aim is to find a longest subsequence, which is common to all input strings. This problem has a variety of applications in bioinformatics, molecular biology and file plagiarism checking, among others. All previous approaches from the literature are dedicated to solving LCS instances sampled from uniform or near-to-uniform probability distributions of letters in the input strings. In this paper, we introduce an approach that is able to effectively deal with more general cases, where the occurrence of letters in the input strings follows a non-uniform distribution such as a multinomial distribution. The proposed approach makes use of a time-restricted beam search, guided by a novel heuristic named Gmpsum. This heuristic combines two complementary scoring functions in the form of a convex combination. Furthermore, apart from the close-to-uniform benchmark sets from the related literature, we introduce three new benchmark sets that differ in terms of their statistical properties. One of these sets concerns a case study in the context of text analysis. We provide a comprehensive empirical evaluation in two distinctive settings: (1) short-time execution with fixed beam size in order to evaluate the guidance abilities of the compared search heuristics; and (2) long-time executions with fixed target duration times in order to obtain high-quality solutions. In both settings, the newly proposed approach performs comparably to state-of-the-art techniques in the context of close-to-uniform instances and outperforms state-of-the-art approaches for non-uniform instances.

Provably Good Solutions to the Knapsack Problem via Neural Networks of Bounded Size

The development of a satisfying and rigorous mathematical understanding of the performance of neural networks is a major challenge in artificial intelligence. Against this background, we study the expressive power of neural networks through the example of the classical NP-hard Knapsack Problem. Our main contribution is a class of recurrent neural networks (RNNs) with rectified linear units that are iteratively applied to each item of a Knapsack instance and thereby compute optimal or provably good solution values. We show that an RNN of depth four and width depending quadratically on the profit of an optimum Knapsack solution is sufficient to find optimum Knapsack solutions. We also prove the following tradeoff between the size of an RNN and the quality of the computed Knapsack solution: for Knapsack instances consisting of n items, an RNN of depth five and width w computes a solution of value at least 1 - O(n^2 sqrt(w)) times the optimum solution value. Our results build upon a classical dynamic programming formulation of the Knapsack Problem as well as a careful rounding of profit values that are also at the core of the well-known fully polynomial-time approximation scheme for the Knapsack Problem. Finally, we point out that our results can be generalized to many other combinatorial optimization problems that admit dynamic programming solution methods, such as various Shortest Path Problems, the Longest Common Subsequence Problem, and the Traveling Salesperson Problem.

New Construction of Family of MLCS Algorithms.

The multiple longest common subsequence (MLCS) problem involves finding all the longest common subsequences of multiple character sequences. This problem is encountered in a variety of areas, including data mining, text processing, and bioinformatics, and is particularly important for biological sequence analysis. By taking the MLCS problem and algorithms for its solution as research domain, this study analyzes the domain of multiple longest common subsequence algorithms, extracts features that algorithms in the domain do and do not have in common, and creates a domain feature model for the MLCS problem by using generic programming, domain engineering, abstraction, and related technologies. A component library for the domain is designed based on the feature model for the MLCS problem, and the partition and recur (PAR) platform is used to ensure that highly reliable MLCS algorithms can be quickly assembled through component assembly. This study provides a valuable reference for obtaining rapid solutions to problems of biological sequence analysis and improves the reliability and assembly flexibility of assembling algorithms.

A Branch Elimination-based Efficient Algorithm for Large-scale Multiple Longest Common Subsequence Problem

A Branch Elimination-based Efficient Algorithm for Large-scale Multiple Longest Common Subsequence Problem

An A⁎ search algorithm for the constrained longest common subsequence problem

The constrained longest common subsequence (CLCS) problem was introduced as a specific measure of similarity between molecules. It is a special case of the constrained sequence alignment problem and of the longest common subsequence (LCS) problem, which are both well-studied problems in the scientific literature. Finding similarities between sequences plays an important role in the fields of molecular biology, gene recognition, pattern matching, text analysis, and voice recognition, among others. The CLCS problem in particular represents an interesting measure of similarity for molecules that have a putative structure in common. This paper proposes an exact A⁎ search algorithm for effectively solving the CLCS problem. This A⁎ search is guided by a tight upper bound calculation for the cost-to-go for the LCS problem. Our computational study shows that on various artificial and real benchmark sets this algorithm scales better with growing instance size and requires significantly less computation time to prove optimality than earlier state-of-the-art approaches from the literature.

Solving longest common subsequence problems via a transformation to the maximum clique problem

Longest common subsequence problems find various applications in bioinformatics, data compression and text editing, just to name a few. Even though numerous heuristic approaches were published in the related literature for many of the considered problem variants during the last decades, solving these problems to optimality remains an important challenge. This is particularly the case when the number and the length of the input strings grows. In this work we define a new way to transform instances of the classical longest common subsequence problem and of some of its variants into instances of the maximum clique problem. Moreover, we propose a technique to reduce the size of the resulting graphs. Finally, a comprehensive experimental evaluation using recent exact and heuristic maximum clique solvers is presented. Numerous, so-far unsolved problem instances from benchmark sets taken from the literature were solved to optimality in this way.