Find the length of the longest subsequence with first K alphabets having same frequency

Last Updated : 28 May, 2021

Given string str with uppercase characters and an integer K, the task is to find the length of the longest subsequence such that the frequency of the first K alphabet is the same.

Examples:

Input: str = "ACAABCCAB", K=3
Output: 6
Explanation: One of the possible subsequences is "ACABCB".

Input: str = "ACAABCCAB", K=4
Output: 0
Explanation: Since the string does not contain 'D', no such subsequence can be obtained.

Approach:
Traverse the string and find the least frequent of the first K alphabets. Once found, (frequency of that element) * K gives the desired result.
Below is the implementation of the above approach:

C++

// C++ program to find the longest 
// subsequence with first K 
// alphabets having same frequency 

#include <bits/stdc++.h> 
using namespace std; 

// Function to return the 
// length of the longest 
// subsequence with first K 
// alphabets having same frequency 
int lengthOfSubsequence(string str, 
                            int K) 
{ 
    // Map to store frequency 
    // of all characters in 
    // the string 
    map<char,int> mp; 
    for (char ch : str) { 
        mp[ch]++; 
    } 
    
    // Variable to store the 
    // frequency of the least 
    // frequent of first K 
    // alphabets 
    int minimum = mp['A']; 
    for (int i = 1; i < K; i++) { 
        minimum = min(minimum, 
                    mp[(char)(i + 'A')]); 
    } 
    
    return minimum * K; 
} 

int main() 
{ 
    string str = "ACAABCCAB"; 
    int K = 3; 
    
    cout << lengthOfSubsequence(str, K); 
    return 0; 
}

Java

// Java program to find the longest 
// subsequence with first K alphabets 
// having same frequency 
import java.util.*; 

class GFG{ 

// Function to return the 
// length of the longest 
// subsequence with first K 
// alphabets having same frequency 
static int lengthOfSubsequence(String str, 
                            int K) 
{ 
    
    // Map to store frequency 
    // of all characters in 
    // the string 
    Map<Character, Integer> mp = new HashMap<>(); 
    for(char ch : str.toCharArray()) 
    { 
        mp.put(ch, mp.getOrDefault(ch, 0) + 1); 
    } 

    // Variable to store the 
    // frequency of the least 
    // frequent of first K 
    // alphabets 
    int minimum = mp.get('A'); 
    for(int i = 1; i < K; i++) 
    { 
        minimum = Math.min(minimum, 
                        mp.get((char)(i + 'A'))); 
    } 
    return minimum * K; 
} 

// Driver code 
public static void main(String[] args) 
{ 
    String str = "ACAABCCAB"; 
    int K = 3; 
    
    System.out.println(lengthOfSubsequence(str, K)); 
} 
} 

// This code is contributed by offbeat

Python3

# Python3 program to find the longest 
# subsequence with first K alphabets 
# having same frequency 
from collections import defaultdict 

# Function to return the 
# length of the longest 
# subsequence with first K 
# alphabets having same frequency 
def lengthOfSubsequence(st, K): 

    # Map to store frequency 
    # of all characters in 
    # the string 
    mp = defaultdict(int) 
    for ch in st: 
        mp[ch] += 1
    
    # Variable to store the 
    # frequency of the least 
    # frequent of first K 
    # alphabets 
    minimum = mp['A'] 
    
    for i in range(1, K): 
        minimum = min(minimum, 
                    mp[chr(i + ord('A'))]) 
    
    return (minimum * K) 

# Driver code 
if __name__ == "__main__": 
    
    st = "ACAABCCAB"
    K = 3
    
    print(lengthOfSubsequence(st, K)) 

# This code is contributed by chitranayal

// C# program to find the longest
// subsequence with first K alphabets
// having same frequency
using System;
using System.Collections.Generic;

class GFG{

// Function to return the
// length of the longest
// subsequence with first K
// alphabets having same frequency
static int lengthOfSubsequence(string str,
                               int K)
{
    
    // Store frequency
    // of all characters in
    // the string
    Dictionary<char,
               int> mp = new Dictionary<char,
                                        int>();
    
    foreach(char ch in str.ToCharArray())
    {
        mp[ch] = mp.GetValueOrDefault(ch, 0) + 1;
    }

    // Variable to store the frequency
    // of the least frequent of first K
    // alphabets
    int minimum = mp['A'];
    for(int i = 1; i < K; i++) 
    {
        minimum = Math.Min(minimum, 
                           mp[(char)(i + 'A')]);
    }
    return minimum * K;
}

// Driver code
public static void Main(string[] args)
{
    string str = "ACAABCCAB";
    int K = 3;
    
    Console.Write(lengthOfSubsequence(str, K));
}
}

// This code is contributed by rutvik_56

JavaScript

<script>

// Javascript program to find the longest 
// subsequence with first K 
// alphabets having same frequency 

// Function to return the 
// length of the longest 
// subsequence with first K 
// alphabets having same frequency 
function lengthOfSubsequence(str, K) 
{ 
    // Map to store frequency 
    // of all characters in 
    // the string 
    var mp = new Map(); 

    str.split('').forEach(ch => {
        if(mp.has(ch))
            mp.set(ch, mp.get(ch)+1)
        else    
            mp.set(ch, 1)
    });
    
    // Variable to store the 
    // frequency of the least 
    // frequent of first K 
    // alphabets 
    var minimum = mp.get('A'); 
    for (var i = 1; i < K; i++) { 
        minimum = Math.min(minimum, 
                    mp.get(String.fromCharCode(i + 'A'.charCodeAt(0)))); 
    } 
    
    return minimum * K; 
} 

var str = "ACAABCCAB"; 
var K = 3; 

document.write( lengthOfSubsequence(str, K)); 



</script>