# Longest Common Anagram Subsequence

Given two strings str1 and str2 of length n1 and n2 respectively. The problem is to find the length of the longest subsequence which is present in both the strings in the form of anagrams.
Note: The strings contain only lowercase letters.

Examples:

```Input : str1 = "abdacp", str2 = "ckamb"
Output : 3
Subsequence of str1 = abc
Subsequence of str2 = cab
OR
Subsequence of str1 = bac
Subsequence of str2 = cab

These are longest common anagram subsequences.

Input : str1 = "abbcfke", str2 = "fbaafbly"
Output : 4
```

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

Approach: Create two hash tables say freq1 and freq2. Store frequencies of each character of str1 in freq1. Likewise, store frequencies of each character of str2 in freq2. Initilaize len = 0. Now, for each lowercase letter finds its lowest frequency from the two hash tables and accumulate it to len.

## C++

 `// C++ implementation to find the length of the  ` `// longest common anagram subsequence ` `#include ` ` `  `using` `namespace` `std; ` ` `  `#define SIZE 26 ` ` `  `// function to find the length of the  ` `// longest common anagram subsequence ` `int` `longCommomAnagramSubseq(``char` `str1[], ``char` `str2[], ` `                                ``int` `n1, ``int` `n2) ` `{ ` `    ``// hash tables for storing frequencies of ` `    ``// each character ` `    ``int` `freq1[SIZE], freq2[SIZE]; ` `    ``memset``(freq1, 0, ``sizeof``(freq1)); ` `    ``memset``(freq2, 0, ``sizeof``(freq2)); ` `     `  `    ``int` `len = 0; ` `     `  `    ``// calculate frequency of each character ` `    ``// of 'str1[]' ` `    ``for` `(``int` `i = 0; i < n1; i++) ` `        ``freq1[str1[i] - ``'a'``]++; ` `     `  `    ``// calculate frequency of each character ` `    ``// of 'str2[]' ` `    ``for` `(``int` `i = 0; i < n2; i++)     ` `        ``freq2[str2[i] - ``'a'``]++; ` `     `  `    ``// for each character add its minimum frequency ` `    ``// out of the two strings in 'len' ` `    ``for` `(``int` `i = 0; i < SIZE; i++)     ` `        ``len += min(freq1[i], freq2[i]); ` `     `  `    ``// required length ` `    ``return` `len;     ` `}                                 ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``char` `str1[] = ``"abdacp"``; ` `    ``char` `str2[] = ``"ckamb"``; ` `    ``int` `n1 = ``strlen``(str1); ` `    ``int` `n2 = ``strlen``(str2); ` `    ``cout << ``"Length = "` `         ``<< longCommomAnagramSubseq(str1, str2, n1, n2); ` `    ``return` `0;      ` `} `

## Java

 `// Java implementation to find ` `// the length() of the longest  ` `// common anagram subsequence ` `import` `java.io.*; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `SIZE = ``26``; ` `     `  `    ``// function to find the  ` `    ``// length() of the longest  ` `    ``// common anagram subsequence ` `    ``static` `int` `longCommomAnagramSubseq(String str1,  ` `                                       ``String str2, ` `                                       ``int` `n1, ``int` `n2) ` `    ``{ ` `        ``// hash tables for ` `        ``// storing frequencies  ` `        ``// of each character ` `        ``int` `[]freq1 = ``new` `int``[SIZE]; ` `        ``int` `[]freq2 = ``new` `int``[SIZE]; ` `         `  `        ``for``(``int` `i = ``0``; i < SIZE; i++) ` `        ``{ ` `            ``freq1[i] = ``0``; ` `            ``freq2[i] = ``0``; ` `        ``} ` `         `  `        ``int` `len = ``0``; ` `         `  `        ``// calculate frequency  ` `        ``// of each character of ` `        ``// 'str1[]' ` `        ``for` `(``int` `i = ``0``; i < n1; i++) ` `            ``freq1[(``int``)str1.charAt(i) - (``int``)``'a'``]++; ` `         `  `        ``// calculate frequency  ` `        ``// of each character  ` `        ``// of 'str2[]' ` `        ``for` `(``int` `i = ``0``; i < n2; i++)  ` `            ``freq2[(``int``)str2.charAt(i) - (``int``)``'a'``]++; ` `         `  `        ``// for each character add  ` `        ``// its minimum frequency  ` `        ``// out of the two Strings  ` `        ``// in 'len' ` `        ``for` `(``int` `i = ``0``; i < SIZE; i++)  ` `            ``len += Math.min(freq1[i],  ` `                            ``freq2[i]); ` `         `  `        ``// required length() ` `        ``return` `len;  ` `    ``}                              ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``String str1 = ``"abdacp"``; ` `        ``String str2 = ``"ckamb"``; ` `        ``int` `n1 = str1.length(); ` `        ``int` `n2 = str2.length(); ` `        ``System.out.print(``"Length = "` `+  ` `                ``longCommomAnagramSubseq(str1, str2,  ` `                                          ``n1, n2)); ` `    ``} ` `} ` ` `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) `

## Python 3

 `# Python 3 implementation to find  ` `# the length of the longest common  ` `# anagram subsequence ` ` `  `SIZE ``=` `26` ` `  `# function to find the length of the  ` `# longest common anagram subsequence ` `def` `longCommomAnagramSubseq(str1, str2, ` `                                ``n1, n2): ` ` `  `    ``# List for storing frequencies  ` `    ``# of each character ` `    ``freq1 ``=` `[``0``] ``*` `SIZE ` `    ``freq2 ``=` `[``0``] ``*` `SIZE ` `     `  `    ``l ``=` `0` `     `  `    ``# calculate frequency of each  ` `    ``# character of 'str1[]' ` `    ``for` `i ``in` `range``(n1): ` `        ``freq1[``ord``(str1[i]) ``-` `              ``ord``(``'a'``)] ``+``=` `1` `     `  `    ``# calculate frequency of each ` `    ``# character of 'str2[]' ` `    ``for` `i ``in` `range``(n2) :  ` `        ``freq2[``ord``(str2[i]) ``-`  `              ``ord``(``'a'``)] ``+``=` `1` `     `  `    ``# for each character add its  ` `    ``# minimum frequency out of  ` `    ``# the two strings in 'len' ` `    ``for` `i ``in` `range``(SIZE):  ` `        ``l ``+``=` `min``(freq1[i], freq2[i]) ` `     `  `    ``# required length ` `    ``return` `l                              ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``str1 ``=` `"abdacp"` `    ``str2 ``=` `"ckamb"` `    ``n1 ``=` `len``(str1) ` `    ``n2 ``=` `len``(str2) ` `    ``print``(``"Length = "``,  ` `           ``longCommomAnagramSubseq(str1, str2,  ` `                                       ``n1, n2)) ` ` `  `# This code is contributed by ita_c `

## C#

 `// C# implementation to find ` `// the length of the longest  ` `// common anagram subsequence ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``static` `int` `SIZE = 26; ` `     `  `    ``// function to find the  ` `    ``// length of the longest  ` `    ``// common anagram subsequence ` `    ``static` `int` `longCommomAnagramSubseq(``string` `str1,  ` `                                       ``string` `str2, ` `                                       ``int` `n1, ``int` `n2) ` `    ``{ ` `        ``// hash tables for ` `        ``// storing frequencies  ` `        ``// of each character ` `        ``int` `[]freq1 = ``new` `int``[SIZE]; ` `        ``int` `[]freq2 = ``new` `int``[SIZE]; ` `         `  `        ``for``(``int` `i = 0; i < SIZE; i++) ` `        ``{ ` `            ``freq1[i] = 0; ` `            ``freq2[i] = 0; ` `        ``} ` `         `  `        ``int` `len = 0; ` `         `  `        ``// calculate frequency  ` `        ``// of each character of ` `        ``// 'str1[]' ` `        ``for` `(``int` `i = 0; i < n1; i++) ` `            ``freq1[str1[i] - ``'a'``]++; ` `         `  `        ``// calculate frequency  ` `        ``// of each character  ` `        ``// of 'str2[]' ` `        ``for` `(``int` `i = 0; i < n2; i++)  ` `            ``freq2[str2[i] - ``'a'``]++; ` `         `  `        ``// for each character add  ` `        ``// its minimum frequency  ` `        ``// out of the two strings  ` `        ``// in 'len' ` `        ``for` `(``int` `i = 0; i < SIZE; i++)  ` `            ``len += Math.Min(freq1[i],  ` `                            ``freq2[i]); ` `         `  `        ``// required length ` `        ``return` `len;  ` `    ``}                              ` `     `  `    ``// Driver Code ` `    ``static` `void` `Main() ` `    ``{ ` `        ``string` `str1 = ``"abdacp"``; ` `        ``string` `str2 = ``"ckamb"``; ` `        ``int` `n1 = str1.Length; ` `        ``int` `n2 = str2.Length; ` `        ``Console.Write(``"Length = "` `+  ` `                ``longCommomAnagramSubseq(str1, str2,  ` `                                        ``n1, n2)); ` `    ``} ` `} ` ` `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) `

## PHP

 ` `

Output:

```Length = 3
```

Time Complexity: O(n).
Auxiliary Space: O(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.

Improved By : manishshaw1, chitranayal

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.