# C++ Program for Longest Common Subsequence

• Difficulty Level : Medium
• Last Updated : 04 Dec, 2018

LCS Problem Statement: 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”. So a string of length n has 2^n different possible subsequences.

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.

Want to learn from the best curated videos and practice problems, check out the C++ Foundation Course for Basic to Advanced C++ and C++ STL Course for the language and STL. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

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.

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])

 `/* A Naive recursive implementation of LCS problem */``#include `` ` `int` `max(``int` `a, ``int` `b);`` ` `/* 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));``}`` ` `/* Utility function to get max of 2 integers */``int` `max(``int` `a, ``int` `b)``{``    ``return` `(a > b) ? a : b;``}`` ` `/* Driver program to test above function */``int` `main()``{``    ``char` `X[] = ``"AGGTAB"``;``    ``char` `Y[] = ``"GXTXAYB"``;`` ` `    ``int` `m = ``strlen``(X);``    ``int` `n = ``strlen``(Y);`` ` `    ``printf``(``"Length of LCS is %d\n"``, lcs(X, Y, m, n));`` ` `    ``return` `0;``}`
Output:
```Length of LCS is 4
```

Following is a tabulated implementation for the LCS problem.

 `/* Dynamic Programming C/C++ implementation of LCS problem */``#include `` ` `int` `max(``int` `a, ``int` `b);`` ` `/* Returns length of LCS for X[0..m-1], Y[0..n-1] */``int` `lcs(``char``* X, ``char``* Y, ``int` `m, ``int` `n)``{``    ``int` `L[m + 1][n + 1];``    ``int` `i, j;`` ` `    ``/* Following steps build L[m+1][n+1] in bottom up fashion. Note ``      ``that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */``    ``for` `(i = 0; i <= m; i++) {``        ``for` `(j = 0; j <= n; j++) {``            ``if` `(i == 0 || j == 0)``                ``L[i][j] = 0;`` ` `            ``else` `if` `(X[i - 1] == Y[j - 1])``                ``L[i][j] = L[i - 1][j - 1] + 1;`` ` `            ``else``                ``L[i][j] = max(L[i - 1][j], L[i][j - 1]);``        ``}``    ``}`` ` `    ``/* L[m][n] contains length of LCS for X[0..n-1] and Y[0..m-1] */``    ``return` `L[m][n];``}`` ` `/* Utility function to get max of 2 integers */``int` `max(``int` `a, ``int` `b)``{``    ``return` `(a > b) ? a : b;``}`` ` `/* Driver program to test above function */``int` `main()``{``    ``char` `X[] = ``"AGGTAB"``;``    ``char` `Y[] = ``"GXTXAYB"``;`` ` `    ``int` `m = ``strlen``(X);``    ``int` `n = ``strlen``(Y);`` ` `    ``printf``(``"Length of LCS is %d\n"``, lcs(X, Y, m, n));`` ` `    ``return` `0;``}`
Output:
```Length of LCS is 4
```

Please refer complete article on Dynamic Programming | Set 4 (Longest Common Subsequence) for more details!

My Personal Notes arrow_drop_up