Common Subsequence Problem Research Articles

Efficient polynomial-time algorithms for the constrained LCS problem with strings exclusion

In this paper, we revisit a recent variant of the longest common subsequence (LCS) problem, the string-excluding constrained LCS (STR-EC-LCS) problem, which was first addressed by Chen and Chao (J Comb Optim 21(3):383---392, 2011). Given two sequences $$X$$ and $$Y$$ of lengths $$m$$ and $$n,$$ respectively, and a constraint string $$P$$ of length $$r,$$ we are to find a common subsequence $$Z$$ of $$X$$ and $$Y$$ which excludes $$P$$ as a substring and the length of $$Z$$ is maximized. In fact, this problem cannot be correctly solved by the previously proposed algorithm. Thus, we give a correct algorithm with $$O(mnr)$$ time to solve it. Then, we revisit the STR-EC-LCS problem with multiple constraints $$\{ P_1, P_2, \ldots , P_k \}.$$ We propose a polynomial-time algorithm which runs in $$O(mnR)$$ time, where $$R = \sum _{i=1}^{k} |P_i|,$$ and thus it overthrows the previous claim of NP-hardness.

A Swarm Intelligence Heuristic Approach to Longest Common Subsequence Problem for Arbitrary Number of Sequences

Personalized cancer care strategies involving sequencing requires accuracy. We aimed to develop a novel approach to solve the longest common subsequence problem, which is a common computer science problem in the field of bioinformatics to facilitate the next generation sequencing of cancer biomarkers. We are using particle swarm optimization heuristic technique, which uses a novel “Occurrence Listing” (OL) technique as the evaluation function. This aims to keep lists of the sequence elements and offers criteria to evaluate randomly generated population of sequences.

A linear algorithm for 3-letter longest common weakly increasing subsequence

The problem of finding a longest weakly increasing common subsequence (LCWIS) of two sequences is a variant of the popular longest common subsequence (LCS) problem. While there are no known methods to find LCS in truly sub-quadratic time, there are faster algorithms to compute LCWIS if the alphabet size is small enough. We present a linear-time algorithm finding LCWIS over 3-letter alphabet. Up to now, the fastest known algorithm was O(min{m+nlogn,mloglogm}), where m≥n denote lengths of the sequences.

The substring inclusion constraint longest common subsequence problem can be solved in quadratic time

In this paper, we study some variants of the Constrained Longest Common Subsequence (CLCS) problem, namely, the substring inclusion CLCS (Substring-IC-CLCS) problem and a generalized version thereof. In the Substring-IC-CLCS problem, we are to find a longest common subsequence (LCS) of two given strings containing a third constraint string (given) as a substring. Previous solution to this problem runs in cubic time, i.e, O(nmk) time, where n,m and k are the length of the 3 input strings. In this paper, we present simple O(nm) time algorithms to solve the Substring-IC-CLCS problem. We also study the Generalized Substring-IC-LCS problem where we are given two strings of length n and m respectively and an ordered list of p strings and the goal is to find an LCS containing each of them as a substring in the order they appear in the list. We present an O(nmp) algorithm for this generalized version of the problem.

Efficient algorithms for the longest common subsequence problem with sequential substring constraints

In this paper, we generalize the inclusion constrained longest common subsequence (CLCS) problem to the hybrid CLCS problem which is the combination of the sequence inclusion CLCS and the string inclusion CLCS, called the sequential substring constrained longest common subsequence (SSCLCS) problem. In the SSCLCS problem, we are given two strings A and B of lengths m and n, respectively, formed by alphabet Σ and a constraint sequence C formed by ordered strings (C1,C2,C3,…,Cl) with total length r. The problem is that of finding the longest common subsequence D of A and B containing C1,C2,C3,…,Cl as substrings and with the order of the C’s retained. This problem has two variants, depending on whether the strings in C cannot overlap or may overlap. We propose algorithms with O(mnl+(m+n)(|Σ|+r)) and O(mnr+(m+n)|Σ|) time for the two variants. For the special case with one or two constraints, our algorithm runs in O(mn+(m+n)(|Σ|+r)) or O(mnr+(m+n)|Σ|) time, respectively—an order faster than the algorithm proposed by Chen and Chao.

Mining Longest Common Subsequence and other Related Patterns using DNA Operations

Longest Common Subsequence (LCS) and Shortest Common Subsequence (SCS) problems are to find subsequences in given sequences in which the subsequence is as long as possible and as short as possible subsequence respectively. These subsequences are not necessarily contiguous or unique. In this paper we have proposed two new approaches to find LCS and SCS, of N sequences parallely, using DNA operations. These approaches can be used to find LCS and SCS, of any window size, from any number of sequences, and from any type of input data. The proposed work can be applied to finding diverging patterns, constraint LCS, redescription mining, sequence alignment, speech recognition, find motifs in genetic data bases, pattern recognition, mine emerging patterns, contrast patterns in both scientific and commercial databases. Implementation results shown the correctness of the algorithms. Finally, the validity of the algorithms are checked and their time complexity is analyzed. General Terms Data Mining, Pattern Recognition, Molecular Computing.

Doubly-Constrained LCS and Hybrid-Constrained LCS problems revisited

We revisit two recently studied variants of the classic Longest Common Subsequence (LCS) problem, namely, the Doubly-Constrained LCS (DC-LCS) and Hybrid-Constrained LCS (HC-LCS) problems. We present finite automata based algorithms for both problems.

Quadratic-time algorithm for a string constrained LCS problem

The problem of finding a longest common subsequence of two main sequences with some constraint that must be a substring of the result (STR-IC-LCS) was formulated recently. It is a variant of the constrained longest common subsequence problem. As the known algorithms for the STR-IC-LCS problem are cubic-time, the presented quadratic-time algorithm is significantly faster.

Fast algorithms for computing the constrained LCS of run-length encoded strings

The constrained LCS (CLCS) problem, a recent variant of the longest common subsequence (LCS) problem, has gained much attention. Given two sequences X and Y of lengths n and m, respectively, and the constrained sequence P of length r, previous research shows that the CLCS problem can be solved by either an O(nmr)-time algorithm based upon dynamic programming (DP) techniques or an O(rRloglog(n+m))-time Hunt–Szymanski-like algorithm, where R is the total number of ordered pairs of positions at which the two strings match. In this paper, we investigate the case that X, Y and P are all in run-length encoded (RLE) format, where the numbers of runs are N, M and R, respectively. We first show that when the sequences are encoded, the CLCS problem can be solved by a simple algorithm in O(nmR+nMr+Nmr) time without decompressing the sequences. Then, we propose a more efficient algorithm with O(NMr+r×min{q1,q2}+q3) time, where q1 and q2 denote the numbers of elements in the south and east faces of the matched blocks on the first layer, respectively, and q3 denotes the number of face elements of all fully matched cuboids in the DP lattice.

A Fast On-Line Algorithm for the Longest Common Subsequence Problem with Constant Alphabet

This article presents an algorithm that solves an on-line version of the longest common subsequence (LCS) problem for two strings over a constant alphabet in O(d+n) time and O(m+d) space, where m is the length of the shorter string, the whole of which is given to the algorithm in advance, n is the length of the longer string, which is given as a data stream, and d is the number of dominant matches between the two strings. A new upper bound, O(p(m-q)), of d is also presented, where p is the length of the LCS of the two strings, and q is the length of the LCS of the shorter string and the m-length prefix of the longer string.

A hyper-heuristic for the Longest Common Subsequence problem

The Longest Common Subsequence Problem is the problem of finding a longest string that is a subsequence of every member of a given set of strings. It has applications in FPGA circuit minimization, data compression, and bioinformatics, among others. The problem is NP-hard in its general form, which implies that no exact polynomial-time algorithm currently exists for the problem. Consequently, inexact algorithms have been proposed to obtain good, but not necessarily optimal, solutions in an affordable time. In this paper, a hyper-heuristic algorithm incorporated within a constructive beam search is proposed for the problem. The proposed hyper-heuristic is based on two basic heuristic functions, one of which is new in this paper, and determines dynamically which one to use for a given problem instance. The proposed algorithm is compared with state-of-the-art algorithms on simulated and real biological sequences. Extensive experimental reveals that the proposed hyper-heuristic is superior to the state-of-the-art methods with respect to the solution quality and the running-time.

On the parameterized complexity of the repetition free longest common subsequence problem

Longest common subsequence is a widely used measure to compare strings, in particular in computational biology. Recently, several variants of the longest common subsequence have been introduced to tackle the comparison of genomes. In particular, the Repetition Free Longest Common Subsequence (RFLCS) problem is a variant of the LCS problem that asks for a longest common subsequence of two input strings with no repetition of symbols. In this paper, we investigate the parameterized complexity of RFLCS. First, we show that the problem does not admit a polynomial kernel. Then, we present a randomized FPT algorithm for the RFLCS problem, improving the time complexity of the existent FPT algorithm.

Algorithms for the Longest Common Subsequence Problem

Algorithms for the Longest Common Subsequence Problem

Approximation of RNA multiple structural alignment

In the context of non-coding RNA (ncRNA) multiple structural alignment, Davydov and Batzoglou (2006) introduced in [7] the problem of finding the largest nested linear graph that occurs in a set G of linear graphs, the so-called Max-NLS problem. This problem generalizes both the longest common subsequence problem and the maximum common homeomorphic subtree problem for rooted ordered trees. In the present paper, we give a fast algorithm for finding the largest nested linear subgraph of a linear graph and a polynomial-time algorithm for a fixed number ( k) of linear graphs. Also, we strongly strengthen the result of Davydov and Batzoglou (2006) [7] by proving that the problem is NP-complete even if G is composed of nested linear graphs of height at most 2, thereby precisely defining the borderline between tractable and intractable instances of the problem. Of particular importance, we improve the result of Davydov and Batzoglou (2006) [7] by showing that the Max-NLS problem is approximable within ratio O ( log m opt ) in O ( k n 2 ) running time, where m opt is the size of an optimal solution. We also present O ( 1 ) -approximation of Max-NLS problem running in O ( k n ) time for restricted linear graphs. In particular, for ncRNA derived linear graphs, a 1 4 -approximation is presented.

An improved algorithm for the longest common subsequence problem

The Longest Common Subsequence problem seeks a longest subsequence of every member of a given set of strings. It has applications, among others, in data compression, FPGA circuit minimization, and bioinformatics. The problem is NP-hard for more than two input strings, and the existing exact solutions are impractical for large input sizes. Therefore, several approximation and (meta) heuristic algorithms have been proposed which aim at finding good, but not necessarily optimal, solutions to the problem. In this paper, we propose a new algorithm based on the constructive beam search method. We have devised a novel heuristic, inspired by the probability theory, intended for domains where the input strings are assumed to be independent. Special data structures and dynamic programming methods are developed to reduce the time complexity of the algorithm. The proposed algorithm is compared with the state-of-the-art over several standard benchmarks including random and real biological sequences. Extensive experimental results show that the proposed algorithm outperforms the state-of-the-art by giving higher quality solutions with less computation time for most of the experimental cases.

Faster algorithms for computing longest common increasing subsequences

We present algorithms for finding a longest common increasing subsequence of two or more input sequences. For two sequences of lengths n and m, where m ⩾ n , we present an algorithm with an output-dependent expected running time of O ( ( m + n ℓ ) log log σ + Sort ) and O ( m ) space, where ℓ is the length of an LCIS, σ is the size of the alphabet, and Sort is the time to sort each input sequence. For k ⩾ 3 length- n sequences we present an algorithm which improves the previous best bound by more than a factor k for many inputs. In both cases, our algorithms are conceptually quite simple but rely on existing sophisticated data structures. Finally, we introduce the problem of longest common weakly-increasing (or non-decreasing) subsequences (LCWIS), for which we present an O ( min { m + n log n , m log log m } ) -time algorithm for the 3-letter alphabet case. For the extensively studied longest common subsequence problem, comparable speedups have not been achieved for small alphabets.

Parameterized complexity and approximability of the Longest Compatible Sequence problem

We introduce the Longest Compatible Sequence ( Slcs ) problem. This problem deals with p-sequences, which are strings on a given alphabet where each letter occurs at most once. The Slcs problem takes as input a collection of k p -sequences on a common alphabet L of size n , and seeks a p -sequence on L which respects the precedence constraints induced by each input sequence, and is of maximal length with this property. We investigate the parameterized complexity and the approximability of the problem. As a by-product of our hardness results for the Slcs problem, we derive new hardness results for the Longest Common Subsequence problem and other problems that are hard for the W -hierarchy.

Bit-Parallel Algorithm for the Constrained Longest Common Subsequence Problem

The problem of finding a constrained longest common subsequence (CLCS) for the sequences A and B with respect to the sequence P was introduced recently. Its goal is to find a longest subsequence C ...

A branch-and-cut approach to the repetition-free longest common subsequence problem

Abstract We present a branch-and-cut approach to solve the following problem. Given two sequences x and y over a finite alphabet, find a repetition-free longest common subsequence of x and y. Implementation details of an efficient separation routine and several heuristics are described. We can solve medium size instances of the problem to optimality.

Variants of constrained longest common subsequence

We consider a variant of the classical Longest Common Subsequence problem called Doubly-Constrained Longest Common Subsequence ( DC-LCS). Given two strings s 1 and s 2 over an alphabet Σ, a set C s of strings, and a function C o : Σ → N , the DC-LCS problem consists of finding the longest subsequence s of s 1 and s 2 such that s is a supersequence of all the strings in C s and such that the number of occurrences in s of each symbol σ ∈ Σ is upper bounded by C o ( σ ) . The DC-LCS problem provides a clear mathematical formulation of a sequence comparison problem in Computational Biology and generalizes two other constrained variants of the LCS problem that have been introduced previously in the literature: the Constrained LCS and the Repetition-Free LCS. We present two results for the DC-LCS problem. First, we illustrate a fixed-parameter algorithm where the parameter is the length of the solution which is also applicable to the more specialized problems. Second, we prove a parameterized hardness result for the Constrained LCS problem when the parameter is the number of the constraint strings ( | C s | ) and the size of the alphabet Σ. This hardness result also implies the parameterized hardness of the DC-LCS problem (with the same parameters) and its NP-hardness when the size of the alphabet is constant.