# Length of longest common subsequence containing vowels

Given two strings X and Y of length m and n respectively. The problem is to find the length of the longest common subsequence of strings X and Y which contains all vowel characters.

Examples:

```Input : X = "aieef"
Y = "klaief"
Output : aie

Input : X = "geeksforgeeks"
Y = "feroeeks"
Output : eoee
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: Generate all subsequences of both given sequences and find the longest matching subsequence which contains all vowel characters. This solution is exponential in term of time complexity.

Efficient Approach (Dynamic Programming): This approach is a variation to Longest Common Subsequence | DP-4 problem. The difference in this post is just that the common subsequence characters must all be vowels.

## C++

 `// C++ implementation to find the length of longest common ` `// subsequence which contains all vowel characters ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// function to check whether 'ch' ` `// is a vowel or not ` `bool` `isVowel(``char` `ch) ` `{ ` `    ``if` `(ch == ``'a'` `|| ch == ``'e'` `|| ch == ``'i'` `        ``|| ch == ``'o'` `|| ch == ``'u'``) ` `        ``return` `true``; ` `    ``return` `false``; ` `} ` ` `  `// function to find the length of longest common subsequence ` `// which contains all vowel characters ` `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]) && isVowel(X[i - 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] ` `    ``// which contains all vowel characters ` `    ``return` `L[m][n]; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``char` `X[] = ``"aieef"``; ` `    ``char` `Y[] = ``"klaief"``; ` ` `  `    ``int` `m = ``strlen``(X); ` `    ``int` `n = ``strlen``(Y); ` ` `  `    ``cout << ``"Length of LCS = "` `         ``<< lcs(X, Y, m, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to find the  ` `// length of longest common subsequence ` `// which contains all vowel characters ` `class` `GFG ` `{ ` ` `  `// function to check whether 'ch'  ` `// is a vowel or not ` `static` `boolean` `isVowel(``char` `ch)  ` `{ ` `    ``if` `(ch == ``'a'` `|| ch == ``'e'` `||  ` `        ``ch == ``'i'` `|| ch == ``'o'` `|| ` `        ``ch == ``'u'``) ` `        ``return` `true``; ` `    ``return` `false``; ` `} ` ` `  `// function to find the length of  ` `// longest common subsequence which ` `// contains all vowel characters ` `static` `int` `lcs(String X, String Y, ` `               ``int` `m, ``int` `n) ` `{ ` `    ``int` `L[][] = ``new` `int``[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.charAt(i - ``1``) == Y.charAt(j - ``1``)) &&  ` `                                ``isVowel(X.charAt(i - ``1``))) ` `                ``L[i][j] = L[i - ``1``][j - ``1``] + ``1``; ` ` `  `            ``else` `                ``L[i][j] = Math.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] ` `    ``// which contains all vowel characters ` `    ``return` `L[m][n]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String X = ``"aieef"``; ` `    ``String Y = ``"klaief"``; ` ` `  `    ``int` `m = X.length(); ` `    ``int` `n = Y.length(); ` ` `  `    ``System.out.println(``"Length of LCS = "` `+  ` `                          ``lcs(X, Y, m, n)); ` `} ` `} ` ` `  `// This code is contributed by Bilal `

## Python3

 `# Python3 implementation to find the  ` `# length of longest common subsequence  ` `# which contains all vowel characters ` ` `  `# function to check whether 'ch' ` `# is a vowel or not ` `def` `isVowel(ch): ` `    ``if` `(ch ``=``=` `'a'` `or` `ch ``=``=` `'e'` `or` `        ``ch ``=``=` `'i'``or` `ch ``=``=` `'o'` `or`  `        ``ch ``=``=` `'u'``): ` `        ``return` `True` `    ``return` `False` ` `  `# function to find the length of longest  ` `# common subsequence which contains all  ` `# vowel characters ` `def` `lcs(X, Y, m, n): ` ` `  `    ``L ``=` `[[``0` `for` `i ``in` `range``(n ``+` `1``)] ` `            ``for` `j ``in` `range``(m ``+` `1``)] ` `    ``i, j ``=` `0``, ``0` `  `  `    ``# 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 ``in` `range``(m ``+` `1``): ` `        ``for` `j ``in` `range``(n ``+` `1``): ` `            ``if` `(i ``=``=` `0` `or` `j ``=``=` `0``): ` `                ``L[i][j] ``=` `0` `            ``elif` `((X[i ``-` `1``] ``=``=` `Y[j ``-` `1``]) ``and` `                      ``isVowel(X[i ``-` `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] which  ` `    ``# contains all vowel characters ` `    ``return` `L[m][n] ` ` `  `# Driver Code ` `X ``=` `"aieef"` `Y ``=` `"klaief"` ` `  `m ``=` `len``(X) ` `n ``=` `len``(Y) ` ` `  `print``(``"Length of LCS ="``, lcs(X, Y, m, n)) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# implementation to find the  ` `// length of longest common subsequence ` `// which contains all vowel characters ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// function to check whether  ` `// 'ch' is a vowel or not ` `static` `int` `isVowel(``char` `ch)  ` `{ ` `    ``if` `(ch == ``'a'` `|| ch == ``'e'` `||  ` `        ``ch == ``'i'` `|| ch == ``'o'` `|| ` `        ``ch == ``'u'``) ` `        ``return` `1; ` `    ``return` `0; ` `} ` ` `  `// find max value ` `static` `int` `max(``int` `a, ``int` `b) ` `{ ` `    ``return` `(a > b) ? a : b; ` `} ` ` `  `// function to find the length of  ` `// longest common subsequence which ` `// contains all vowel characters ` `static` `int` `lcs(String X, String Y, ` `               ``int` `m, ``int` `n) ` `{ ` `    ``int` `[,]L = ``new` `int``[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]) &&  ` `                    ``isVowel(X[i - 1]) == 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] ` `    ``// which contains all vowel characters ` `    ``return` `L[m, n]; ` `} ` ` `  `// Driver Code ` `static` `public` `void` `Main(String []args) ` `{ ` `    ``String X = ``"aieef"``; ` `    ``String Y = ``"klaief"``; ` ` `  `    ``int` `m = X.Length; ` `    ``int` `n = Y.Length; ` ` `  `    ``Console.WriteLine(``"Length of LCS = "` `+  ` `                         ``lcs(X, Y, m, n)); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## PHP

 ` `

Output:

```Length of LCS = 3
```

Time Complexity: O(m*n).
Auxiliary Space: O(m*n).

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.