Constrained Longest Common Subsequence Problem Research Articles

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.

A dynamic programming solution to a generalized LCS problem

In this paper, we consider a generalized longest common subsequence problem, the string-excluding constrained LCS problem. For the two input sequences X and Y of lengths n and m, and a constraint string P of length r, the problem is to find a common subsequence Z of X and Y excluding P as a substring and the length of Z is maximized. The problem and its solution were first proposed by Chen and Chao (2011) [1], but we found that their algorithm cannot solve the problem correctly. A new dynamic programming solution for the STR-EC-LCS problem is then presented in this paper. The correctness of the new algorithm is proved. The time complexity of the new algorithm is O(nmr).

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.

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.

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.

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 ...

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.

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 of A and B such that P is a subsequence of C. Most of the algorithms solving the CLCS problem are based on dynamic programming. Bit-parallelism is a technique of using single bits in a machine word for concurrent computation. We propose the first bit-parallel algorithm computing a CLCS and/or its length which outperforms the other known algorithms in terms of speed.

New efficient algorithms for the LCS and constrained LCS problems

In this paper, we study the classic and well-studied longest common subsequence (LCS) problem and a recent variant of it, namely the constrained LCS (CLCS) problem. In the CLCS problem, the computed LCS must also be a supersequence of a third given string. In this paper, we first present an efficient algorithm for the traditional LCS problem that runs in O ( R log log n + n ) time, where R is the total number of ordered pairs of positions at which the two strings match and n is the length of the two given strings. Then, using this algorithm, we devise an algorithm for the CLCS problem having time complexity O ( p R log log n + n ) in the worst case, where p is the length of the third string.