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'.

You can delete any number of characters in s to make s balanced. A string is balanced if there is no pair of indices (i,j) such that i < j and s[i] = 'b' and s[j] = 'a'.

Return the minimum number of deletions needed to make s balanced.

Input & Output

Example 1 — Mixed String

$ Input: s = "aababbab"

› Output: 2

💡 Note: Remove the two 'b's at positions 2 and 4 to get "aaaabb" which is balanced: all 'a's come before all 'b's

Example 2 — Already Balanced

$ Input: s = "bbb"

› Output: 0

💡 Note: String contains only 'b's, so it's already balanced (no 'a' comes after 'b')

Example 3 — Reverse Order

$ Input: s = "baaba"

› Output: 3

💡 Note: One optimal solution is to delete 'b', 'a', and 'b' to get "aa" which is balanced

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either 'a' or 'b'

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 M Microsoft 8

The key insight is that a balanced string has all 'a's before all 'b's. We can solve this optimally in O(n) time by tracking the running count of 'b's and making deletion decisions when we encounter 'a's. Best approach is single pass with running balance. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Subsequences

⏱️ Time: O(2ⁿ × n) Space: O(n)

Try every possible combination of characters to keep, check if each resulting string is balanced, and find the minimum deletions needed.

Single Pass - Running Balance

⏱️ Time: O(n) Space: O(1)

Use a single pass to maintain a running count of characters. For each 'b', we can either keep it or delete it. For each 'a', we must decide based on the B's we've seen.

Two Pass - Count A's and B's

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

Make two passes through the string: first count A's from right to left, then scan left to right counting B's and find the position that minimizes total deletions.

Brute Force - Try All Subsequences — Algorithm Steps

Generate all possible subsequences of the string
For each subsequence, check if it's balanced (no 'b' before 'a')
Track the longest balanced subsequence
Return original length minus longest balanced length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n possible subsequences

Validate

Check each subsequence for balance (no 'b' before 'a')

Minimize

Find subsequence requiring minimum deletions

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    int minDeletions = n;
    
    // Try all possible subsequences using bit manipulation
    for (int mask = 0; mask < (1 << n); mask++) {
        char subsequence[1001] = {0};
        int idx = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[idx++] = s[i];
            }
        }
        
        // Check if subsequence is balanced
        bool isBalanced = true;
        bool foundB = false;
        for (int i = 0; i < idx; i++) {
            if (subsequence[i] == 'b') {
                foundB = true;
            } else if (subsequence[i] == 'a' && foundB) {
                isBalanced = false;
                break;
            }
        }
        
        if (isBalanced) {
            int deletions = n - idx;
            if (deletions < minDeletions) {
                minDeletions = deletions;
            }
        }
    }
    
    return minDeletions;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n subsequences, each takes O(n) time to validate

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and string storage for subsequences

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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 Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler