# Longest common subsequence with permutations allowed

• Difficulty Level : Easy
• Last Updated : 05 Jul, 2022

Given two strings in lowercase, find the longest string whose permutations are subsequences of given two strings. The output longest string must be sorted.

Examples: ```Input  :  str1 = "pink", str2 = "kite"
Output : "ik"
The string "ik" is the longest sorted string
whose one permutation "ik" is subsequence of
"pink" and another permutation "ki" is
subsequence of "kite".

Input  : str1 = "working", str2 = "women"
Output : "now"

Input  : str1 = "geeks" , str2 = "cake"
Output : "ek"

Input  : str1 = "aaaa" , str2 = "baba"
Output : "aa"```

The idea is to count characters in both strings.

1. calculate frequency of characters for each string and store them in their respective count arrays, say count1[] for str1 and count2[] for str2.
2. Now we have count arrays for 26 characters. So traverse count1[] and for any index ‘i’ append character (‘a’+i) in resultant string ‘result’ by min(count1[i], count2[i]) times.
3. Since we traverse count array in ascending order, our final string characters will be in sorted order.

Implementation:

## C++

 `// C++ program to find LCS with permutations allowed` `#include` `using` `namespace` `std;`   `// Function to calculate longest string` `// str1     --> first string` `// str2     --> second string` `// count1[] --> hash array to calculate frequency` `//             of characters in str1` `// count --> hash array to calculate frequency` `//             of characters in str2` `// result --> resultant longest string whose` `// permutations are sub-sequence of given two strings` `void` `longestString(string str1, string str2)` `{` `    ``int` `count1 = {0}, count2= {0};`   `    ``// calculate frequency of characters` `    ``for` `(``int` `i=0; i

## Java

 `//Java program to find LCS with permutations allowed`   `class` `GFG {`   `// Function to calculate longest String` `// str1     --> first String` `// str2     --> second String` `// count1[] --> hash array to calculate frequency` `//             of characters in str1` `// count --> hash array to calculate frequency` `//             of characters in str2` `// result --> resultant longest String whose` `// permutations are sub-sequence of given two strings` `    ``static` `void` `longestString(String str1, String str2) {` `        ``int` `count1[] = ``new` `int``[``26``], count2[] = ``new` `int``[``26``];`   `        ``// calculate frequency of characters` `        ``for` `(``int` `i = ``0``; i < str1.length(); i++) {` `            ``count1[str1.charAt(i) - ``'a'``]++;` `        ``}` `        ``for` `(``int` `i = ``0``; i < str2.length(); i++) {` `            ``count2[str2.charAt(i) - ``'a'``]++;` `        ``}`   `        ``// Now traverse hash array` `        ``String result = ``""``;` `        ``for` `(``int` `i = ``0``; i < ``26``; i++) ``// append character ('a'+i) in resultant` `        ``// String 'result' by min(count1[i],count2i])` `        ``// times` `        ``{` `            ``for` `(``int` `j = ``1``; j <= Math.min(count1[i], count2[i]); j++) {` `                ``result += (``char``)(``'a'` `+ i);` `            ``}` `        ``}`   `        ``System.out.println(result);` `    ``}`   `// Driver program to run the case` `    ``public` `static` `void` `main(String[] args) {` `        ``String str1 = ``"geeks"``, str2 = ``"cake"``;` `        ``longestString(str1, str2);`   `    ``}` `}` `/* This java code is contributed by 29AjayKumar*/`

## Python3

 `# Python 3 program to find LCS` `# with permutations allowed`   `# Function to calculate longest string` `# str1     --> first string` `# str2     --> second string` `# count1[] --> hash array to calculate frequency` `#             of characters in str1` `# count --> hash array to calculate frequency` `#             of characters in str2` `# result --> resultant longest string whose` `# permutations are sub-sequence` `# of given two strings` `def` `longestString(str1, str2):`   `    ``count1 ``=` `[``0``] ``*` `26` `    ``count2 ``=` `[``0``] ``*` `26`   `    ``# calculate frequency of characters` `    ``for` `i ``in` `range``( ``len``(str1)):` `        ``count1[``ord``(str1[i]) ``-` `ord``(``'a'``)] ``+``=` `1` `    ``for` `i ``in` `range``(``len``(str2)):` `        ``count2[``ord``(str2[i]) ``-` `ord``(``'a'``)] ``+``=` `1`   `    ``# Now traverse hash array` `    ``result ``=` `""` `    ``for` `i ``in` `range``(``26``):`   `        ``# append character ('a'+i) in` `        ``# resultant string 'result' by` `        ``# min(count1[i],count2i]) times` `        ``for` `j ``in` `range``(``1``, ``min``(count1[i],` `                            ``count2[i]) ``+` `1``):` `            ``result ``=` `result ``+` `chr``(``ord``(``'a'``) ``+` `i)`   `    ``print``(result)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``str1 ``=` `"geeks"` `    ``str2 ``=` `"cake"` `    ``longestString(str1, str2)`   `# This code is contributed by ita_c`

## C#

 `// C# program to find LCS with` `// permutations allowed` `using` `System;`   `class` `GFG` `{`   `// Function to calculate longest String` `// str1 --> first String` `// str2 --> second String` `// count1[] --> hash array to calculate` `//     frequency of characters in str1` `// count --> hash array to calculate` `//         frequency of characters in str2` `// result --> resultant longest String whose` `// permutations are sub-sequence of` `// given two strings` `static` `void` `longestString(String str1,` `                        ``String str2)` `{` `    ``int` `[]count1 = ``new` `int``;` `    ``int` `[]count2 = ``new` `int``;`   `    ``// calculate frequency of characters` `    ``for` `(``int` `i = 0; i < str1.Length; i++)` `    ``{` `        ``count1[str1[i] - ``'a'``]++;` `    ``}` `    ``for` `(``int` `i = 0; i < str2.Length; i++)` `    ``{` `        ``count2[str2[i] - ``'a'``]++;` `    ``}`   `    ``// Now traverse hash array` `    ``String result = ``""``;` `    ``for` `(``int` `i = 0; i < 26; i++)` `    `  `    ``// append character ('a'+i) in resultant` `    ``// String 'result' by min(count1[i],count2i])` `    ``// times` `    ``{` `        ``for` `(``int` `j = 1;` `                ``j <= Math.Min(count1[i],` `                            ``count2[i]); j++)` `        ``{` `            ``result += (``char``)(``'a'` `+ i);` `        ``}` `    ``}`   `Console.Write(result);` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``String str1 = ``"geeks"``, str2 = ``"cake"``;` `    ``longestString(str1, str2);` `}` `}`   `// This code is contributed` `// by PrinciRaj1992`

## PHP

 ` first string` `// str2     --> second string` `// count1[] --> hash array to calculate frequency` `//             of characters in str1` `// count --> hash array to calculate frequency` `//             of characters in str2` `// result --> resultant longest string whose` `// permutations are sub-sequence of given two strings` `function` `longestString(``\$str1``, ``\$str2``)` `{` `    ``\$count1` `= ``array_fill``(0, 26, NULL);` `    ``\$count2` `= ``array_fill``(0, 26, NULL);`   `    ``// calculate frequency of characters` `    ``for` `(``\$i` `= 0; ``\$i` `< ``strlen``(``\$str1``); ``\$i``++)` `        ``\$count1``[ord(``\$str1``[``\$i``]) - ord(``'a'``)]++;` `    ``for` `(``\$i` `= 0; ``\$i` `< ``strlen``(``\$str2``); ``\$i``++)` `        ``\$count2``[ord(``\$str2``[``\$i``]) - ord(``'a'``)]++;`   `    ``// Now traverse hash array` `    ``\$result` `= ``""``;` `    ``for` `(``\$i` `= 0; ``\$i` `< 26; ``\$i``++)`   `        ``// append character ('a'+i) in resultant` `        ``// string 'result' by min(count1[\$i],` `        ``// count2[\$i]) times` `        ``for` `(``\$j` `= 1; ``\$j` `<= min(``\$count1``[``\$i``],` `                            ``\$count2``[``\$i``]); ``\$j``++)` `            ``\$result` `= ``\$result``.``chr``(ord(``'a'``) + ``\$i``);`   `    ``echo` `\$result``;` `}`   `// Driver Code` `\$str1` `= ``"geeks"``;` `\$str2` `= ``"cake"``;` `longestString(``\$str1``, ``\$str2``);`   `// This code is contributed by ita_c` `?>`

## Javascript

 ``

Output

`ek`

Time Complexity: O(m + n), where m and n are lengths of input strings.
Auxiliary Space: O(1)

If you have another approach to solve this problem then please share.

This article is contributed by Shashank Mishra ( Gullu ). 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.