Related Articles

# Longest common subsequence with permutations allowed

• Difficulty Level : Easy
• Last Updated : 20 Jul, 2021

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.

## 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.