Constrained Longest Common Subsequence Research Articles

Faster space-efficient STR-IC-LCS computation

One of the most fundamental method for comparing two given strings A and B is the longest common subsequence (LCS), where the task is to find (the length) of an LCS of A and B. In this paper, we deal with the STR-IC-LCS1 problem which is one of the constrained LCS problems proposed by Chen and Chao [J. Comb. Optim, 2011]. A string Z is said to be an STR-IC-LCS of three given strings A, B, and P, if Z is a longest string satisfying that (1) Z includes P as a substring and (2) Z is a common subsequence of A and B. We present three efficient algorithms for this problem: First, we begin with a space-efficient solution which computes the length of an STR-IC-LCS in O(n2) time and O((ℓ+1)(n−ℓ+1)) space, where ℓ is the length of an LCS of A and B of length n. When ℓ=O(1) or n−ℓ=O(1), then this algorithm uses only linear O(n) space. Second, we present a faster algorithm that works in O(nr/log⁡r+n(n−ℓ+1)) time, where r is the length of P, while retaining the O((ℓ+1)(n−ℓ+1)) space efficiency. Third, we give an alternative algorithm that runs in O(nr/log⁡r+n(n−ℓ′+1)) time with O((ℓ′+1)(n−ℓ′+1)) space, where ℓ′ denotes the STR-IC-LCS length for input strings A, B, and P.

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.

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.

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.

Approximability of constrained LCS

The problem Constrained Longest Common Subsequence is a natural extension to the classical problem Longest Common Subsequence, and has important applications to bioinformatics. Given k input sequences A1,…,Ak and l constraint sequences B1,…,Bl, C-LCS(k,l) is the problem of finding a longest common subsequence of A1,…,Ak that is also a common supersequence of B1,…,Bl. Gotthilf et al. gave a polynomial-time algorithm that approximates C-LCS(k,1) within a factor mˆ|Σ|, where mˆ is the length of the shortest input sequence and |Σ| is the alphabet size. They asked whether there are better approximation algorithms and whether there exists a lower bound. In this paper, we answer their questions by showing that their approximation factor mˆ|Σ| is in fact already very close to optimal although a small improvement is still possible:1.For any computable function f and any ϵ>0, there is no polynomial-time algorithm that approximates C-LCS(k,1) within a factor f(|Σ|)⋅mˆ1/2−ϵ unless NP=P. Moreover, this holds even if the constraint sequence is unary.2.There is a polynomial-time randomized algorithm that approximates C-LCS(k,1) within a factor |Σ|⋅O(OPT⋅loglogOPT/logOPT) with high probability, where OPT is the length of the optimal solution, OPT⩽mˆ. For the problem over an alphabet of arbitrary size, we show that3.For any ϵ>0, there is no polynomial-time algorithm that approximates C-LCS(k,1) within a factor mˆ1−ϵ unless NP=P.4.There is a polynomial-time algorithm that approximates C-LCS(k,1) within a factor O(mˆ/logmˆ). We also present some complementary results on exact and parameterized algorithms for C-LCS(k,1).

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.

Finite automata based algorithms on subsequences and supersequences of degenerate strings

In this paper, we present linear-time algorithms for the construction two novel types of finite automata and show how they can be used to efficiently solve the Longest Common Subsequence (LCS), Shortest Common Supersequence (SCS) and Constrained Longest Common Subsequence (CLCS) problems for degenerate strings.

Generalized LCS

The Longest Common Subsequence (LCS) is a well studied problem, having a wide range of implementations. Its motivation is in comparing strings. It has long been of interest to devise a similar measure for comparing higher dimensional objects, and more complex structures. In this paper we study the Longest Common Substructure of two matrices and show that this problem is N P -hard. We also study the Longest Common Subforest problem for multiple trees including a constrained version, as well. We show N P -hardness for k > 2 unordered trees in the constrained LCS. We also give polynomial time algorithms for ordered trees and prove a lower bound for any decomposition strategy for k trees.

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.