Given a string of lowercase alphabets and a number k, the task is to print the minimum value of the string after removal of ‘k’ characters. The value of a string is defined as the sum of squares of the count of each distinct character. For example consider the string “saideep”, here frequencies of characters are s-1, a-1, i-1, e-2, d-1, p-1 and value of the string is 1^2 + 1^2 + 1^2 + 1^2 + 1^2 + 2^2 = 9.

Expected Time Complexity: O(k*logn)

**Examples:**

Input : str = abccc, K = 1 Output : 6 We remove c to get the value as 1^{2}+ 1^{2}+ 2^{2}Input : str = aaab, K = 2 Output : 2

**Asked In : Amazon**

One clear observation is that we need to remove character with highest frequency. One trick is the character ma

A **Simple solution** is to use sorting technique through all current highest frequency reduce up to k times. For After every reduce again sort frequency array.

A **Better Solution** used to Priority Queue which has to the highest element on top.

- Initialize empty priority queue.
- Count frequency of each character and Store into temp array.
- Remove K characters which have highest frequency from queue.
- Finally Count Sum of square of each element and return it.

Below is the implementation of the above idea.

## C++

`// C++ program to find min sum of squares ` `// of characters after k removals ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `MAX_CHAR = 26; ` ` ` `// Main Function to calculate min sum of ` `// squares of characters after k removals ` `int` `minStringValue(string str, ` `int` `k) ` `{ ` ` ` `int` `l = str.length(); ` `// find length of string ` ` ` ` ` `// if K is greater than length of string ` ` ` `// so reduced string will become 0 ` ` ` `if` `(k >= l) ` ` ` `return` `0; ` ` ` ` ` `// Else find Frequency of each character and ` ` ` `// store in an array ` ` ` `int` `frequency[MAX_CHAR] = { 0 }; ` ` ` `for` `(` `int` `i = 0; i < l; i++) ` ` ` `frequency[str[i] - ` `'a'` `]++; ` ` ` ` ` `// Push each char frequency into a priority_queue ` ` ` `priority_queue<` `int` `> q; ` ` ` `for` `(` `int` `i = 0; i < MAX_CHAR; i++) ` ` ` `q.push(frequency[i]); ` ` ` ` ` `// Removal of K characters ` ` ` `while` `(k--) { ` ` ` `// Get top element in priority_queue, ` ` ` `// remove it. Decrement by 1 and again ` ` ` `// push into priority_queue ` ` ` `int` `temp = q.top(); ` ` ` `q.pop(); ` ` ` `temp = temp - 1; ` ` ` `q.push(temp); ` ` ` `} ` ` ` ` ` `// After removal of K characters find sum ` ` ` `// of squares of string Value ` ` ` `int` `result = 0; ` `// Initialize result ` ` ` `while` `(!q.empty()) { ` ` ` `int` `temp = q.top(); ` ` ` `result += temp * temp; ` ` ` `q.pop(); ` ` ` `} ` ` ` ` ` `return` `result; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `string str = ` `"abbccc"` `; ` `// Input 1 ` ` ` `int` `k = 2; ` ` ` `cout << minStringValue(str, k) << endl; ` ` ` ` ` `str = ` `"aaab"` `; ` `// Input 2 ` ` ` `k = 2; ` ` ` `cout << minStringValue(str, k); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to find min sum of squares ` `// of characters after k removals ` `import` `java.util.Comparator; ` `import` `java.util.PriorityQueue; ` `import` `java.util.Collections; ` `public` `class` `GFG { ` ` ` ` ` `static` `final` `int` `MAX_CHAR = ` `26` `; ` ` ` ` ` `// Main Function to calculate min sum of ` ` ` `// squares of characters after k removals ` ` ` `static` `int` `minStringValue(String str, ` `int` `k) ` ` ` `{ ` ` ` `int` `l = str.length(); ` `// find length of string ` ` ` ` ` `// if K is greater than length of string ` ` ` `// so reduced string will become 0 ` ` ` `if` `(k >= l) ` ` ` `return` `0` `; ` ` ` ` ` `// Else find Frequency of each character and ` ` ` `// store in an array ` ` ` `int` `[] frequency = ` `new` `int` `[MAX_CHAR]; ` ` ` `for` `(` `int` `i = ` `0` `; i < l; i++) ` ` ` `frequency[str.charAt(i) - ` `'a'` `]++; ` ` ` ` ` `// creating a priority queue with comparator ` ` ` `// such that elements in the queue are in ` ` ` `// descending order. ` ` ` `PriorityQueue<Integer> q = ` `new` `PriorityQueue<>(Collections.reverseOrder()); ` ` ` ` ` `// Push each char frequency into a priority_queue ` ` ` `for` `(` `int` `i = ` `0` `; i < MAX_CHAR; i++) { ` ` ` `if` `(frequency[i] != ` `0` `) ` ` ` `q.add(frequency[i]); ` ` ` `} ` ` ` ` ` `// Removal of K characters ` ` ` `while` `(k != ` `0` `) { ` ` ` `// Get top element in priority_queue, ` ` ` `// remove it. Decrement by 1 and again ` ` ` `// push into priority_queue ` ` ` `q.add(q.poll() - ` `1` `); ` ` ` `k--; ` ` ` `} ` ` ` ` ` `// After removal of K characters find sum ` ` ` `// of squares of string Value ` ` ` `int` `result = ` `0` `; ` `// Initialize result ` ` ` `while` `(!q.isEmpty()) { ` ` ` `result += q.peek() * q.poll(); ` ` ` `} ` ` ` ` ` `return` `result; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String args[]) ` ` ` `{ ` ` ` `String str = ` `"abbccc"` `; ` `// Input 1 ` ` ` `int` `k = ` `2` `; ` ` ` `System.out.println(minStringValue(str, k)); ` ` ` ` ` `str = ` `"aaab"` `; ` `// Input 2 ` ` ` `k = ` `2` `; ` ` ` `System.out.println(minStringValue(str, k)); ` ` ` `} ` `} ` `// This code is contributed by Sumit Ghosh ` |

*chevron_right*

*filter_none*

## Python 3

`# Python3 program to find min sum of ` `# squares of characters after k removals ` `from` `queue ` `import` `PriorityQueue ` ` ` `MAX_CHAR ` `=` `26` ` ` `# Main Function to calculate min sum of ` `# squares of characters after k removals ` `def` `minStringValue(` `str` `, k): ` ` ` `l ` `=` `len` `(` `str` `) ` `# find length of string ` ` ` ` ` `# if K is greater than length of string ` ` ` `# so reduced string will become 0 ` ` ` `if` `(k >` `=` `l): ` ` ` `return` `0` ` ` ` ` `# Else find Frequency of each ` ` ` `# character and store in an array ` ` ` `frequency ` `=` `[` `0` `] ` `*` `MAX_CHAR ` ` ` `for` `i ` `in` `range` `(` `0` `, l): ` ` ` `frequency[` `ord` `(` `str` `[i]) ` `-` `97` `] ` `+` `=` `1` ` ` ` ` `# Push each char frequency negative ` ` ` `# into a priority_queue as the queue ` ` ` `# by default is minheap ` ` ` `q ` `=` `PriorityQueue() ` ` ` `for` `i ` `in` `range` `(` `0` `, MAX_CHAR): ` ` ` `q.put(` `-` `frequency[i]) ` ` ` ` ` `# Removal of K characters ` ` ` `while` `(k > ` `0` `): ` ` ` ` ` `# Get top element in priority_queue ` ` ` `# multiply it by -1 as temp is negative ` ` ` `# remove it. Increment by 1 and again ` ` ` `# push into priority_queue ` ` ` `temp ` `=` `q.get() ` ` ` `temp ` `=` `temp ` `+` `1` ` ` `q.put(temp, temp) ` ` ` `k ` `=` `k ` `-` `1` ` ` ` ` `# After removal of K characters find ` ` ` `# sum of squares of string Value ` ` ` `result ` `=` `0` `; ` `# initialize result ` ` ` `while` `not` `q.empty(): ` ` ` `temp ` `=` `q.get() ` ` ` `temp ` `=` `temp ` `*` `(` `-` `1` `) ` ` ` `result ` `+` `=` `temp ` `*` `temp ` ` ` `return` `result ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` `str` `=` `"abbccc"` ` ` `k ` `=` `2` ` ` `print` `(minStringValue(` `str` `, k)) ` ` ` ` ` `str` `=` `"aaab"` ` ` `k ` `=` `2` ` ` `print` `(minStringValue(` `str` `, k)) ` ` ` `# This code is contributed ` `# by Sairahul Jella ` |

*chevron_right*

*filter_none*

**Output:**

6 2

**Time Complexity: O(k*logn)**

This article is contributed by **Mr. Somesh Awasthi**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Maximum non-repeating characters after removing K characters
- Check if string remains palindrome after removing given number of characters
- Character replacement after removing duplicates from a string
- Minimize ASCII values sum after removing all occurrences of one character
- Minimum length of Run Length Encoding possible by removing at most K characters from a given string
- Print string after removing all (“10” or “01”) from the binary string
- Queries for counts of array elements with values in given range
- Lexicographically smallest subsequence possible by removing a character from given string
- Count of ungrouped characters after dividing a string into K groups of distinct characters
- Minimize cost to empty a given string by removing characters alphabetically
- Check if permutation of a given string can be made palindromic by removing at most K characters
- Minimum operations required to convert all characters of a String to a given Character
- Lexicographically smallest string formed by appending a character from the first K characters of a given string
- Reduce the number to minimum multiple of 4 after removing the digits
- Minimize the length of string by removing occurrence of only one character
- Lexicographically smallest string formed by removing at most one character
- Character whose frequency is equal to the sum of frequencies of other characters of the given string
- Balance a string after removing extra brackets
- Find the resultant String after replacing X with Y and removing Z
- Check if string is palindrome after removing all consecutive duplicates