Minimum Deletions to Make Character Frequencies Unique

Minimum Deletions to Make Character Frequencies Unique - Problem

Make Every Character Frequency Unique!

A string is considered "good" when no two different characters share the same frequency. Your mission is to find the minimum number of character deletions needed to transform any string into a good string.

What makes a string good?
• Each character must have a unique frequency
• No two different characters can appear the same number of times

Example: In string "aab", character 'a' appears 2 times and 'b' appears 1 time - this is already good! But in "aaabbbcc", both 'a' and 'b' appear 3 times, so we need deletions.

Goal: Return the minimum deletions to make the string good.

Input & Output

example_1.py — Basic Case

$ Input: s = "aab"

› Output: 0

💡 Note: Character 'a' appears 2 times and 'b' appears 1 time. Since all frequencies (2, 1) are already unique, no deletions are needed.

example_2.py — Conflict Resolution

$ Input: s = "aaabbbcc"

› Output: 2

💡 Note: Characters have frequencies: a=3, b=3, c=2. Since 'a' and 'b' both have frequency 3, we need to reduce one of them. Optimal solution: keep frequencies as [3, 2, 1], requiring 1 deletion from 'b' and 1 deletion from 'c'.

example_3.py — All Same Frequency

$ Input: s = "ceabaacb"

› Output: 2

💡 Note: Characters have frequencies: a=2, b=2, c=2, e=2. All characters have the same frequency! We need to make them unique: [2, 1, 0, 0], requiring 0+1+2+2 = 5 deletions. Wait, let's recalculate: optimal assignment is [2, 1, 0] for three chars, but we have 4 chars. So [2, 1, 0, and delete remaining] = 2+1+2 = 2 deletions.

Visualization

Tap to expand

Understanding the Visualization

Count Group Sizes

Group A wants 3 seats, Group B wants 3 seats, Group C wants 2 seats

Identify Conflicts

Groups A and B both want 3 seats - this creates a conflict!

Resolve Greedily

Give Group A 3 seats, Group B gets 2 seats, Group C gets 1 seat

Calculate Cost

Group B loses 1 seat, Group C loses 1 seat = 2 people removed total

Key Takeaway

🎯 Key Insight: The greedy strategy works because we always want to preserve as many seats (characters) as possible. By assigning the highest available unique number to each group, we minimize total removals.

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) for counting frequencies, O(k log k) for sorting frequencies where k ≤ 26

⚡ Linearithmic

Space Complexity

O(k)

Space for frequency map and used frequencies set, where k is number of unique characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s contains only lowercase English letters
Each character frequency must be unique in the final string

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a greedy approach with frequency counting and sorting. Count character frequencies, sort them in descending order, then greedily assign the highest available frequency to each character. This minimizes deletions because we preserve as many characters as possible. Time complexity: O(n + k log k) where k ≤ 26.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Greedy with Sorting	O(n + k log k)	O(k)	Count frequencies first, then sort and greedily reduce conflicts
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try all possible ways to delete characters and check if result is good
Optimized Greedy (Single Pass)	O(n + k log k)	O(k)	Count frequencies and use set to track used frequencies in optimal way

Two-Pass Greedy with Sorting — Algorithm Steps

Count character frequencies using hash map
Extract and sort frequencies in descending order
For each frequency, reduce it to highest available value
Keep track of total deletions needed
Return total deletions

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

First pass through string: a=3, b=3, c=2

Sort Descending

Sort frequencies: [3, 3, 2]

Greedy Reduction

Reduce each to highest available: 3→3, 3→2, 2→1

Calculate Deletions

Total deletions: 0 + 1 + 1 = 2

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_CHARS 26

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // descending order
}

int minimumDeletions(char* s) {
    // First pass: count frequencies
    int freqCount[MAX_CHARS] = {0};
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        freqCount[s[i] - 'a']++;
    }
    
    // Get non-zero frequencies
    int frequencies[MAX_CHARS];
    int count = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freqCount[i] > 0) {
            frequencies[count++] = freqCount[i];
        }
    }
    
    // Sort in descending order
    qsort(frequencies, count, sizeof(int), compare);
    
    int deletions = 0;
    int maxAllowed = frequencies[0]; // Start with highest frequency
    
    // Second pass: greedily reduce conflicts
    for (int i = 0; i < count; i++) {
        int freq = frequencies[i];
        if (freq <= maxAllowed) {
            maxAllowed = freq;
        } else {
            deletions += freq - maxAllowed;
        }
        
        // Next frequency must be at most maxAllowed - 1
        maxAllowed = maxAllowed > 0 ? maxAllowed - 1 : 0;
    }
    
    return deletions;
}

int main() {
    char s[100001];
    scanf("\"%100000[^\"]\"", s);
    
    printf("%d\n", minimumDeletions(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) to count frequencies, O(k log k) to sort where k is number of unique characters (at most 26 for lowercase letters)

⚡ Linearithmic

Space Complexity

O(k)

Space for frequency map and sorted frequency array, where k is number of unique characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s contains only lowercase English letters
Each character frequency must be unique in the final string

23.8K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Greedy with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler