Minimum Deletions to Make String K-Special

Minimum Deletions to Make String K-Special - Problem

Minimum Deletions to Make String K-Special

You are given a string word and an integer k. Your goal is to make the string k-special by deleting the minimum number of characters.

A string is considered k-special if the absolute difference between any two character frequencies is at most k. In other words, for any two characters in the string, |freq(char1) - freq(char2)| ≤ k.

Key Points:
• freq(x) represents how many times character x appears in the string
• You need to find the minimum number of deletions required
• After deletions, all remaining character frequencies must be within k of each other

Example: If word = "aabccc" and k = 2, the frequencies are: a=2, b=1, c=3. The maximum difference is |3-1|=2, which equals k, so no deletions needed!

Input & Output

example_1.py — Basic Case

$ Input: word = "aabccc", k = 2

› Output: 0

💡 Note: Character frequencies are: a=2, b=1, c=3. The maximum difference is |3-1| = 2, which equals k. No deletions needed.

example_2.py — Need Deletions

$ Input: word = "aabcccdd", k = 1

› Output: 2

💡 Note: Frequencies: a=2, b=1, c=3, d=2. Max difference is |3-1| = 2 > k. Delete 2 'c's to get frequencies [2,1,1,2], max diff = 1 ≤ k.

example_3.py — All Same Character

$ Input: word = "aaaa", k = 0

› Output: 0

💡 Note: Only one unique character 'a' with frequency 4. Since there's only one frequency, the difference is 0 ≤ k. No deletions needed.

Time & Space Complexity

Time Complexity

⏱️

O(n + c log c)

O(n) to count frequencies, O(c log c) to sort where c ≤ 26 is unique characters

⚡ Linearithmic

Space Complexity

O(c)

Space to store character frequencies, where c ≤ 26

✓ Linear Space

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters only
0 ≤ k ≤ 26
Time limit: 2 seconds

Asked in

The optimal approach uses a greedy strategy with frequency sorting. Count character frequencies, sort them, and for each possible minimum frequency, calculate the deletions needed to fit all frequencies in a range of size k. The key insight is that the optimal solution will always choose a contiguous range of frequencies where max - min ≤ k, minimizing total character removals.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Frequency Sorting	O(n + c log c)	O(c)	Count frequencies, sort them, and use sliding window to find optimal range
Brute Force (Try All Subsets)	O(2^n * c²)	O(n)	Generate all possible subsets of characters and check which ones are k-special
Binary Search on Answer	O(c² log n)	O(c)	Binary search on the number of deletions to find minimum

Greedy with Frequency Sorting — Algorithm Steps

Count frequency of each character in the string
Sort the frequency values in ascending order
Use sliding window to find the best contiguous range where max-min ≤ k
Calculate deletions needed to keep only characters in the optimal range

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each character appears

Sort Frequencies

Sort the frequency values in ascending order

Try Each Range

For each possible minimum frequency, find optimal deletions

Calculate Deletions

Count characters to remove for each range option

Code -

solution.c — C

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

#define MAX_CHARS 26

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

int min(int a, int b) {
    return a < b ? a : b;
}

int minimumDeletions(char* word, int k) {
    // Step 1: Count character frequencies
    int freq[MAX_CHARS] = {0};
    int n = strlen(word);
    
    for (int i = 0; i < n; i++) {
        freq[word[i] - 'a']++;
    }
    
    // Collect non-zero frequencies
    int frequencies[MAX_CHARS];
    int count = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > 0) {
            frequencies[count++] = freq[i];
        }
    }
    
    if (count == 0) return 0;
    
    // Sort frequencies
    qsort(frequencies, count, sizeof(int), compare);
    
    int minDeletions = n;
    
    // Step 2: Try each possible range [min_freq, min_freq + k]
    for (int i = 0; i < count; i++) {
        int minFreq = frequencies[i];
        int maxAllowed = minFreq + k;
        
        int totalKept = 0;
        for (int j = 0; j < count; j++) {
            if (frequencies[j] <= maxAllowed) {
                // Keep this entire frequency
                totalKept += frequencies[j];
            } else {
                // Keep only maxAllowed characters of this type
                totalKept += maxAllowed;
            }
        }
        
        int deletions = n - totalKept;
        minDeletions = min(minDeletions, deletions);
    }
    
    return minDeletions;
}

int main() {
    char word[1001];
    int k;
    scanf("%s %d", word, &k);
    
    // Remove quotes if present
    int len = strlen(word);
    if (word[0] == '"' && word[len-1] == '"') {
        word[len-1] = '\0';
        memmove(word, word+1, len-1);
    }
    
    printf("%d\n", minimumDeletions(word, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + c log c)

O(n) to count frequencies, O(c log c) to sort where c ≤ 26 is unique characters

⚡ Linearithmic

Space Complexity

O(c)

Space to store character frequencies, where c ≤ 26

✓ Linear Space

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters only
0 ≤ k ≤ 26
Time limit: 2 seconds

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with Frequency Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler