Minimum Deletions to Make String Balanced

Minimum Deletions to Make String Balanced - Problem

You are given a string s consisting only of characters 'a' and 'b'. Your task is to make the string balanced by deleting the minimum number of characters.

A string is considered balanced if there is no pair of indices (i, j) such that i < j, s[i] = 'b', and s[j] = 'a'. In other words, all 'a' characters must appear before all 'b' characters.

Goal: Return the minimum number of deletions needed to make the string balanced.

Example: In string "baaba", we have 'b' at index 0 followed by 'a' at indices 1, 2, and 4, making it unbalanced. We need to delete 2 characters to get "aab" which is balanced.

Input & Output

example_1.py — Basic Case

$ Input: s = "aababbab"

› Output: 2

💡 Note: We can delete the first 'b' and last 'b' to get "aaabab" → "aaaaab". Actually, we delete 2 characters to make it "aababa" → "aaaba" (remove one 'b' in middle and last 'b').

example_2.py — Simple Case

$ Input: s = "baba"

› Output: 2

💡 Note: We can delete the 'b' at index 0 and 'a' at index 3, leaving "aa". Or delete both 'a's leaving "bb". Both need 2 deletions.

example_3.py — Already Balanced

$ Input: s = "aaabbb"

› Output: 0

💡 Note: The string is already balanced (all 'a's come before all 'b's), so no deletions are needed.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either 'a' or 'b'
The string contains only lowercase characters 'a' and 'b'

Visualization

Tap to expand

Understanding the Visualization

Scan Left to Right

Process each character while maintaining balance

Count B's

Keep track of how many 'b's we've seen

Resolve Conflicts

When we see 'a' after 'b', delete optimally

Update Counters

Maintain running count of deletions and conflicts

Key Takeaway

🎯 Key Insight: At each 'a', we face a choice: delete this 'a' or delete previous 'b's. The optimal strategy is to always resolve conflicts immediately by deleting the 'a', which gives us O(n) time complexity.

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses dynamic programming with a greedy approach. Scan left to right, track the count of 'b's seen so far. For each 'a', if there are previous 'b's, we must resolve the conflict by deleting either this 'a' or one of the previous 'b's - we choose optimally. This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possibilities)	O(2^n)	O(n)	Try all possible ways to delete characters and find the minimum
Dynamic Programming (Optimal)	O(n)	O(1)	Track 'b' count and make optimal decisions for each 'a'

Brute Force (Try All Possibilities) — Algorithm Steps

Generate all possible subsequences using bit manipulation or recursion
For each subsequence, check if it's balanced (no 'b' before 'a')
Calculate deletions needed for each valid subsequence
Return the minimum deletions found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsequences

Use bitmask to represent which characters to keep/delete

Check Balance

For each subsequence, verify no 'b' appears before 'a'

Track Minimum

Keep track of the minimum deletions among valid subsequences

Code -

solution.c — C

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

int minimumDeletions(char* s) {
    int n = strlen(s);
    int minDeletions = INT_MAX;
    
    // Try all possible bitmasks
    for (int mask = 0; mask < (1 << n); mask++) {
        char subsequence[1001];
        int subLen = 0;
        int deletions = 0;
        
        // Build subsequence based on mask
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = s[i];
            } else {
                deletions++;
            }
        }
        subsequence[subLen] = '\0';
        
        // Check if subsequence is balanced
        int isBalanced = 1;
        for (int i = 0; i < subLen && isBalanced; i++) {
            for (int j = i + 1; j < subLen; j++) {
                if (subsequence[i] == 'b' && subsequence[j] == 'a') {
                    isBalanced = 0;
                    break;
                }
            }
        }
        
        if (isBalanced && deletions < minDeletions) {
            minDeletions = deletions;
        }
    }
    
    return minDeletions;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    printf("%d\n", minimumDeletions(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all 2^n possible subsequences of the string

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth or space to store current subsequence

⚡ Linearithmic Space

42.2K Views

Medium-High Frequency

~15 min Avg. Time

1.8K 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 Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler