Minimum Deletions to Make String K-Special

Minimum Deletions to Make String K-Special - Problem

You are given a string word and an integer k. We consider word to be k-special if |freq(word[i]) - freq(word[j])| <= k for all indices i and j in the string.

Here, freq(x) denotes the frequency of the character x in word, and |y| denotes the absolute value of y.

Return the minimum number of characters you need to delete to make word k-special.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Character frequencies: a=2, b=1. Since |2-1|=1 > 0, we need deletions. We can keep all characters of one type. Keeping 'a' (2 chars) requires deleting 1 'b'. Keeping 'b' (1 char) requires deleting 2 'a's. Minimum deletions = 1.

Example 2 — K-Special Already

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

› Output: 0

💡 Note: Character frequencies: a=2, b=2, c=2. All differences are |2-2|=0 ≤ 1, so string is already k-special. No deletions needed.

Example 3 — Larger K

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

› Output: 0

💡 Note: Character frequencies: a=3, b=3, c=3. All differences are 0 ≤ 2, so no deletions needed.

Constraints

1 ≤ word.length ≤ 10⁵
0 ≤ k ≤ 26
word consists only of lowercase English letters

Visualization

Tap to expand

Asked in

M Meta 12 G Google 8 A Amazon 6 M Microsoft 4

The key insight is to find the optimal range of character frequencies that minimizes deletions. Count frequencies, sort them, and use sliding window to find the longest valid range where max-min ≤ k. Best approach uses sliding window with Time: O(n + c log c), Space: O(c).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n) Space: O(n)

Generate all possible subsets of characters to delete, check if remaining string is k-special, and find minimum deletions. This approach exhaustively searches through all possibilities.

Frequency Count with Greedy Selection

⏱️ Time: O(n + c²) Space: O(c)

Count all character frequencies, sort them, and find the best contiguous range of frequencies that differ by at most k. This minimizes total deletions by keeping maximum characters.

Optimized Greedy with Sliding Window

⏱️ Time: O(n + c log c) Space: O(c)

After sorting frequencies, use a sliding window approach to find the longest valid range where max - min ≤ k. This avoids checking all possible ranges by expanding and contracting the window optimally.

Brute Force - Try All Combinations — Algorithm Steps

Count character frequencies
Generate all deletion combinations
Check if each combination makes string k-special
Return minimum deletions found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsets

Create all 2^n possible character combinations

Check K-Special

For each subset, verify frequency differences ≤ k

Find Minimum

Track the minimum deletions needed

Code -

solution.c — C

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

bool isKSpecial(const char* s, int k) {
    if (strlen(s) == 0) return true;
    int freq[26] = {0};
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    int frequencies[26];
    int count = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            frequencies[count++] = freq[i];
        }
    }
    
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            if (abs(frequencies[i] - frequencies[j]) > k) {
                return false;
            }
        }
    }
    return true;
}

int solution(const char* word, int k) {
    int n = strlen(word);
    int minDeletions = n;
    
    // Generate all possible subsets
    for (int mask = 0; mask < (1 << n); mask++) {
        char remaining[1001] = {0};
        int pos = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                remaining[pos++] = word[i];
            }
        }
        remaining[pos] = '\0';
        
        if (isKSpecial(remaining, k)) {
            int deletions = n - pos;
            if (deletions < minDeletions) {
                minDeletions = deletions;
            }
        }
    }
    
    return minDeletions;
}

int main() {
    char word[1001];
    int k;
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    scanf("%d", &k);
    printf("%d\n", solution(word, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Generates 2^n possible deletion combinations where n is string length

✓ Linear Growth

Space Complexity

O(n)

Stores character frequencies and current combination

✓ Linear Space

3.2K Views

Medium Frequency

~25 min Avg. Time

147 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler