if you want to remove an article from website contact us from top.

# what is the time complexity of the brute force algorithm used to find the longest common subsequence?

Category :

### Mohammed

Guys, does anyone know the answer?

get what is the time complexity of the brute force algorithm used to find the longest common subsequence? from screen.

## Longest Common Subsequence

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

## Longest Common Subsequence | DP-4

Difficulty Level : Medium

Last Updated : 11 Oct, 2022

We have discussed Overlapping Subproblems and Optimal Substructure properties in Set 1 and Set 2 respectively. We also discussed one example problem in Set 3. Let us discuss Longest Common Subsequence (LCS) problem as one more example problem that can be solved using Dynamic Programming.

Given two sequences, find the length of longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. For example, “abc”, “abg”, “bdf”, “aeg”, ‘”acefg”, .. etc are subsequences of “abcdefg”.

In order to find out the complexity of brute force approach, we need to first know the number of possible different subsequences of a string with length n, i.e., find the number of subsequences with lengths ranging from 1,2,..n-1. Recall from theory of permutation and combination that number of combinations with 1 element are nC1. Number of combinations with 2 elements are nC2 and so forth and so on. We know that nC0 + nC1 + nC2 + … nCn = 2n. So a string of length n has 2n-1 different possible subsequences since we do not consider the subsequence with length 0. This implies that the time complexity of the brute force approach will be O(n * 2n). Note that it takes O(n) time to check if a subsequence is common to both the strings. This time complexity can be improved using dynamic programming.

It is a classic computer science problem, the basis of diff (a file comparison program that outputs the differences between two files), and has applications in bioinformatics.

Examples:

LCS for input Sequences “ABCDGH” and “AEDFHR” is “ADH” of length 3.

LCS for input Sequences “AGGTAB” and “GXTXAYB” is “GTAB” of length 4.

Recommended Problem

Longest Common Subsequence

Dynamic Programming Amazon Citrix +4 more Solve Problem

Submission count: 1.8L

The naive solution for this problem is to generate all subsequences of both given sequences and find the longest matching subsequence. This solution is exponential in term of time complexity. Let us see how this problem possesses both important properties of a Dynamic Programming (DP) Problem.

1) Optimal Substructure:

Let the input sequences be X[0..m-1] and Y[0..n-1] of lengths m and n respectively. And let L(X[0..m-1], Y[0..n-1]) be the length of LCS of the two sequences X and Y. Following is the recursive definition of L(X[0..m-1], Y[0..n-1]).

If last characters of both sequences match (or X[m-1] == Y[n-1]) then

L(X[0..m-1], Y[0..n-1]) = 1 + L(X[0..m-2], Y[0..n-2])

If last characters of both sequences do not match (or X[m-1] != Y[n-1]) then

L(X[0..m-1], Y[0..n-1]) = MAX ( L(X[0..m-2], Y[0..n-1]), L(X[0..m-1], Y[0..n-2]) )

Examples:

1) Consider the input strings “AGGTAB” and “GXTXAYB”. Last characters match for the strings. So length of LCS can be written as:

L(“AGGTAB”, “GXTXAYB”) = 1 + L(“AGGTA”, “GXTXAY”)

2) Consider the input strings “ABCDGH” and “AEDFHR. Last characters do not match for the strings. So length of LCS can be written as:

L(“ABCDGH”, “AEDFHR”) = MAX ( L(“ABCDG”, “AEDFHR”), L(“ABCDGH”, “AEDFH”) )

So the LCS problem has optimal substructure property as the main problem can be solved using solutions to subproblems.

2) Overlapping Subproblems:

Following is simple recursive implementation of the LCS problem. The implementation simply follows the recursive structure mentioned above.

## C++

/* A Naive recursive implementation of LCS problem */

#include

using namespace std;

/* Returns length of LCS for X[0..m-1], Y[0..n-1] */

int lcs( char *X, char *Y, int m, int n )

{

if (m == 0 || n == 0)

return 0;

if (X[m-1] == Y[n-1])

return 1 + lcs(X, Y, m-1, n-1);

else

return max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n));

} /* Driver code */ int main() {

char X[] = "AGGTAB";

char Y[] = "GXTXAYB";

int m = strlen(X); int n = strlen(Y);

cout<<"Length of LCS is "<< lcs( X, Y, m, n ) ;

return 0; }

// This code is contributed by rathbhupendra

## PHP

C Java Python3 C# PHP Javascript

Output

Length of LCS is 4

Time complexity of the above naive recursive approach is O(2^n) in worst case and worst case happens when all characters of X and Y mismatch i.e., length of LCS is 0.

Considering the above implementation, following is a partial recursion tree for input strings “AXYT” and “AYZX”

lcs("AXYT", "AYZX")

/ \

lcs("AXY", "AYZX") lcs("AXYT", "AYZ")

/ /

lcs("AX", "AYZX") lcs("AXY", "AYZ") lcs("AXY", "AYZ") lcs("AXYT", "AY")

In the above partial recursion tree, lcs(“AXY”, “AYZ”) is being solved twice. If we draw the complete recursion tree, then we can see that there are many subproblems which are solved again and again. So this problem has Overlapping Substructure property and recomputation of same subproblems can be avoided by either using Memoization or Tabulation.

स्रोत : www.geeksforgeeks.org

## Longest Common Subsequence Questions and Answers

This set of Data Structure Multiple Choice Questions & Answers (MCQs) focuses on “Longest Common Subsequence”. 1. Which of the following methods can be used to solve the longest common subsequence problem? a) Recursion b) Dynamic programming c) Both recursion and dynamic programming d) Greedy algorithm 2. Consider the strings “PQRSTPQRS” and “PRATPBRQRPS”. What is ... Read more

## Data Structure Questions and Answers – Longest Common Subsequence

« Prev Next »

This set of Data Structure Multiple Choice Questions & Answers (MCQs) focuses on “Longest Common Subsequence”.

1. Which of the following methods can be used to solve the longest common subsequence problem?

a) Recursion

b) Dynamic programming

c) Both recursion and dynamic programming

2. Consider the strings “PQRSTPQRS” and “PRATPBRQRPS”. What is the length of the longest common subsequence?

3. Which of the following problems can be solved using the longest subsequence problem?

a) Longest increasing subsequence

b) Longest palindromic subsequence

c) Longest bitonic subsequence

d) Longest decreasing subsequence

Sanfoundry Certification Contest of the Month is Live. 100+ Subjects. Participate Now!

4. Longest common subsequence is an example of ____________

a) Greedy algorithm

b) 2D dynamic programming

c) 1D dynamic programming

d) Divide and conquer

5. What is the time complexity of the brute force algorithm used to find the longest common subsequence?

Check this: Programming Books | Computer Science Books

6. Consider the following dynamic programming implementation of the longest common subsequence problem:

#include#include

int max_num(int a, int b)

{ if(a > b) return a; return b; }

int lcs(char *str1, char *str2)

{ int i,j,len1,len2;

len1 = strlen(str1);

len2 = strlen(str2);

int arr[len1 + 1][len2 + 1];

for(i = 0; i <= len1; i++)

arr[i][0] = 0;

for(i = 0; i <= len2; i++)

arr[0][i] = 0;

for(i = 1; i <= len1; i++)

{

for(j = 1; j <= len2; j++)

{

if(str1[i-1] == str2[j - 1])

______________; else

arr[i][j] = max_num(arr[i - 1][j], arr[i][j - 1]);

} }

return arr[len1][len2];

} int main() {

char str1[] = " abcedfg", str2[] = "bcdfh";

int ans = lcs(str1,str2);

printf("%d",ans); return 0; }

Which of the following lines completes the above code?

a) arr[i][j] = 1 + arr[i][j].

b) arr[i][j] = 1 + arr[i – 1][j – 1].

c) arr[i][j] = arr[i – 1][j – 1].

d) arr[i][j] = arr[i][j].

7. What is the time complexity of the following dynamic programming implementation of the longest common subsequence problem where length of one string is “m” and the length of the other string is “n”?

#include

#include

int max_num(int a, int b)

{ if(a > b) return a; return b; }

int lcs(char *str1, char *str2)

{ int i,j,len1,len2;

len1 = strlen(str1);

len2 = strlen(str2);

int arr[len1 + 1][len2 + 1];

for(i = 0; i <= len1; i++)

arr[i][0] = 0;

for(i = 0; i <= len2; i++)

arr[0][i] = 0;

for(i = 1; i <= len1; i++)

{

for(j = 1; j <= len2; j++)

{

if(str1[i-1] == str2[j - 1])

arr[i][j] = 1 + arr[i - 1][j - 1];

else

arr[i][j] = max_num(arr[i - 1][j], arr[i][j - 1]);

} }

return arr[len1][len2];

} int main() {

char str1[] = " abcedfg", str2[] = "bcdfh";

int ans = lcs(str1,str2);

8. What is the space complexity of the following dynamic programming implementation of the longest common subsequence problem where length of one string is “m” and the length of the other string is “n”?

#include#include

int max_num(int a, int b)

{ if(a > b) return a; return b; }

int lcs(char *str1, char *str2)

{ int i,j,len1,len2;

len1 = strlen(str1);

len2 = strlen(str2);

int arr[len1 + 1][len2 + 1];

for(i = 0; i <= len1; i++)

arr[i][0] = 0;

for(i = 0; i <= len2; i++)

arr[0][i] = 0;

for(i = 1; i <= len1; i++)

{

for(j = 1; j <= len2; j++)

{

if(str1[i-1] == str2[j - 1])

arr[i][j] = 1 + arr[i - 1][j - 1];

else

arr[i][j] = max_num(arr[i - 1][j], arr[i][j - 1]);

} }

return arr[len1][len2];

} int main() {

char str1[] = " abcedfg", str2[] = "bcdfh";

int ans = lcs(str1,str2);

9. What is the output of the following code?

#include#include

int max_num(int a, int b)

{ if(a > b) return a; return b; }

int lcs(char *str1, char *str2)

{ int i,j,len1,len2;

len1 = strlen(str1);

len2 = strlen(str2);

int arr[len1 + 1][len2 + 1];

for(i = 0; i <= len1; i++)

arr[i][0] = 0;

for(i = 0; i <= len2; i++)

arr[0][i] = 0;

for(i = 1; i <= len1; i++)

{

for(j = 1; j <= len2; j++)

{

if(str1[i-1] == str2[j - 1])

स्रोत : www.sanfoundry.com

## What is the time complexity of the brute

Answer: The brute force algorithm? I’m pretty sure that whatever algorithm one might come up with, there is a version that also qualifies as “brute force” that is worse. For example, Wikipedia gives a “naive search” that is O( 2^{n_1} \sum_{i>1} n_i ) to LCS. [1] This algorithm looks at all the ...

What is the time complexity of the brute-force algorithm used to find the longest common subsequence?

Ad by Amazon Web Services (AWS)

AWS is how.

AWS removes the complexity of building, training, and deploying machine learning models at any scale.

Sort Mark Gritter

PhD dropout in Computer Science, Stanford University (Graduated 2006)Upvoted by

Christian Howard

, PhD Computer Science, University of Illinois at Urbana-Champaign (2024)Author has 5K answers and 7.6M answer views3y

The brute force algorithm? I’m pretty sure that whatever algorithm one might come up with, there is a version that also qualifies as “brute force” that is worse.

For example, Wikipedia gives a “naive search” that is

O( 2 n 1 ∑ i>1 n i ) O(2n1∑i>1ni) to LCS.

[1] This algorithm looks at all the subsequences of the first string, and attempts to find them in each of the remaining strings.

But, why stop there? You could also check all

min( n i ) min(ni)

-length words from characters in the source alphabet; if that’s non-zero bytes then we have an algorithm that’s

O( 255 n 1 ∑ n i ) O(255n1∑ni)

(assuming WLOG that the smallest

Footnotes

[1] Longest common subsequence problem - Wikipedia

Kunal Gupta

Related

What is the time complexity likely for a brute force array sorting algorithm to have?

Seeing this mathematically,

If I use brute force to sort an array,

I will scan through all permutations of the

n n

elements and then compare all elements, whether they are in order or not.

Now, the worst case possible would be iterating all n! permutations of the array.

So worst time complexity is likely to be

O(n!) O(n!)

Also the best case would be if the array is already sorted

giving O(1) O(1)

Now, coming to avera

Need an OCR library for Java-based applications?

Aspose.OCR for Java is powerful library capable of performing OCR on commonly used image types.

products.aspose.com Ryan Lam

Bachelor's Degree in Electrical and Computer EngineeringAuthor has 439 answers and 2.4M answer views6y

Related

What is brute force?

Think of a number between 1 and 2 billion, inclusive.

I can guess the number you’re thinking of using this One Weird Trick. (Computer Scientists Hate Me!)

As long as you tell me whether or not I’m right after each guess, this method is guaranteed to eventually find the number you’re thinking of.

Ready? Let’s begin. Is it 1? If not, is it 2? 3? 4? 5? 6? 7?

Surely it must be 8.

No? How about 9? 10? It must be 11. No? Is it 12 then? 13? 14? 15? …

See? Foolproof. Eventually I will have exhausted every number between 1 and 2 billion (inclusive), which means that assuming I keep this up, I am guaranteed to eventually g

Michal Forišek

Worked at Comenius University in Bratislava (2003–2020)Author has 1.2K answers and 10.1M answer views5y

Related

Is the longest common subsequence algorithm used to detect spam?

No, absolutely not. How would that even work? “If the new e-mail has a long common subsequence with a known spam, it is also spam?” That would be waaaaay too error-prone. It would have too many false negatives (essentially any spam you didn’t see before would go through) and also false positives (any message that contains many of the “innocent” words used in your spam would be marked as spam).

Historically, the very first spam filters were based on simple keyword search: if the e-mail contains “penis enlargement”, it is a spam. This brought us to the delightful world of “p3n1s enlagr3m3nt” e-ma

Jacob Kurien

Related

Can you add a large constant to a weighted graph with negative edges, so that all the weights become positive, then run Dijkstra's algorithm starting at node S, and return to the shortest path found to node T in order to still get the shortest path?

First i would say this is the kind of thinking(Trying to fit an efficient algorithm) you need to succeed in graph theory. That said, the approach you mentioned will not work, as shown below:

Lets say you have the following 2 paths from a -> c

So you will select the second path as that has the min cost.

Now lets add 3 to make all edges weights positive(in the hope we can run the Dijkstra’s algo):

See the shortest path now has become the path A(which is wrong). This happens due to the fact that path B has more nodes to reach from a->c. And hence we will be adding 3 to the path cost for all the edges

Looking for an open-source Python IDE?

PyScripter has all the features expected in a modern Python IDE in a lightweight package. Download now!

स्रोत : www.quora.com

Do you want to see answer or more ?
Mohammed 3 day ago

Guys, does anyone know the answer?