# Frequency of maximum occurring subsequence in given string

Given a string str of lowercase English alphabets, our task is to find the frequency of occurrence a subsequence of the string which occurs the maximum times.
Examples:

Input: s = “aba”
Output:
Explanation:
For “aba”, subsequence “ab” occurs maximum times in subsequence ‘ab’ and ‘aba’.
Input: s = “acbab”
Output:
Explanation:
For “acbab”, “ab” occurs 3 times which is the maximum.

Approach: The problem can be solved using Dynamic Programming. To solve the problem mentioned above the key observation is that the resultant subsequence will be of length 1 or 2 because frequency of any subsequence of length > 2 will be lower than the subsequence of length 1 or 2 as they are also present in higher length subsequences. So we need to check for the subsequence of length 1 or 2 only. Below are the steps:

1. For length 1 count the frequency of each alphabet in the string.
2. For length 2 form a 2D array dp, where dp[i][j] tells frequency of string of char(‘a’ + i) + char(‘a’ + j).
3. The recurrence relation is used in the step 2 is given by:

dp[i][j] = dp[i][j] + freq[i]
where,
freq[i] = frequency of character char(‘a’ + i)
dp[i][j] = frequency of string formed by current_character + char(‘a’ + i).

4. The maximum of frequency array and array dp[][] gives the maximum count of any subsequence in the given string.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach  ` `#include   ` `#define ll long long  ` `using` `namespace` `std;  ` ` `  `// Function to find the frequency  ` `ll findCount(string s)  ` `{  ` `    ``// freq stores frequnecy of each  ` `    ``// english lowercase character  ` `    ``ll freq;  ` ` `  `    ``// dp[i][j] stores the count of  ` `    ``// subsequnce with 'a' + i  ` `    ``// and 'a' + j character  ` `    ``ll dp;  ` ` `  `    ``memset``(freq, 0, ``sizeof` `freq);  ` ` `  `    ``// Intialize dp to 0  ` `    ``memset``(dp, 0, ``sizeof` `dp);  ` ` `  `    ``for` `(``int` `i = 0; i < s.size(); ++i) {  ` ` `  `        ``for` `(``int` `j = 0; j < 26; j++) {  ` ` `  `            ``// Increment the count of  ` `            ``// subsequence j and s[i]  ` `            ``dp[j][s[i] - ``'a'``] += freq[j];  ` `        ``}  ` ` `  `        ``// Update the frequency array  ` `        ``freq[s[i] - ``'a'``]++;  ` `    ``}  ` ` `  `    ``ll ans = 0;  ` ` `  `    ``// For 1 length subsequence  ` `    ``for` `(``int` `i = 0; i < 26; i++)  ` `        ``ans = max(freq[i], ans);  ` ` `  `    ``// For 2 length subsequence  ` `    ``for` `(``int` `i = 0; i < 26; i++) {  ` `        ``for` `(``int` `j = 0; j < 26; j++) {  ` ` `  `            ``ans = max(dp[i][j], ans);  ` `        ``}  ` `    ``}  ` ` `  `    ``// Return the final result  ` `    ``return` `ans;  ` `}  ` ` `  `// Driver Code  ` `int` `main()  ` `{  ` `    ``// Given string str  ` `    ``string str = ``"acbab"``;  ` ` `  `    ``// Function Call  ` `    ``cout << findCount(str);  ` ` `  `    ``return` `0;  ` `}  `

## Java

 `// Java program for the above approach ` `class` `GFG{ ` ` `  `// Function to find the frequency ` `static` `int` `findCount(String s) ` `{ ` `     `  `    ``// freq stores frequnecy of each ` `    ``// english lowercase character ` `    ``int` `[]freq = ``new` `int``[``26``]; ` ` `  `    ``// dp[i][j] stores the count of ` `    ``// subsequnce with 'a' + i  ` `    ``// and 'a' + j character  ` `    ``int` `[][]dp = ``new` `int``[``26``][``26``]; ` ` `  `    ``for``(``int` `i = ``0``; i < s.length(); ++i)  ` `    ``{ ` `        ``for``(``int` `j = ``0``; j < ``26``; j++) ` `        ``{ ` ` `  `            ``// Increment the count of ` `            ``// subsequence j and s[i] ` `            ``dp[j][s.charAt(i) - ``'a'``] += freq[j]; ` `        ``} ` ` `  `        ``// Update the frequency array ` `        ``freq[s.charAt(i) - ``'a'``]++; ` `    ``} ` ` `  `    ``int` `ans = ``0``; ` ` `  `    ``// For 1 length subsequence ` `    ``for``(``int` `i = ``0``; i < ``26``; i++) ` `        ``ans = Math.max(freq[i], ans); ` ` `  `    ``// For 2 length subsequence ` `    ``for``(``int` `i = ``0``; i < ``26``; i++) ` `    ``{ ` `        ``for``(``int` `j = ``0``; j < ``26``; j++)  ` `        ``{ ` `            ``ans = Math.max(dp[i][j], ans); ` `        ``} ` `    ``} ` ` `  `    ``// Return the final result ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// Given String str ` `    ``String str = ``"acbab"``; ` ` `  `    ``// Function call ` `    ``System.out.print(findCount(str)); ` `} ` `} ` ` `  `// This code contributed by amal kumar choubey `

Output:

```3
```

Time Complexity: O(26*N), where N is the length of the given string.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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 : Amal Kumar Choubey