Replace the Substring for Balanced String

Replace the Substring for Balanced String - Problem

You are given a string s of length n containing only four kinds of characters: 'Q', 'W', 'E', and 'R'.

A string is said to be balanced if each of its characters appears n / 4 times where n is the length of the string.

Return the minimum length of the substring that can be replaced with any other string of the same length to make s balanced.

If s is already balanced, return 0.

Input & Output

Example 1 — String with Excess Q

$ Input: s = "QWER"

› Output: 0

💡 Note: String length is 4, each character appears exactly 1 time = 4/4, so it's already balanced

Example 2 — Need to Replace Substring

$ Input: s = "QQWE"

› Output: 1

💡 Note: Q appears 2 times, W appears 1 time, E appears 1 time, R appears 0 times. Target is 1 each. Need to replace 1 Q with R, so minimum length is 1

Example 3 — Larger Imbalance

$ Input: s = "QQQQQWWW"

› Output: 4

💡 Note: Length 8, target is 2 each. Q appears 5 times (3 excess), W appears 3 times (1 excess), E and R appear 0 times each. Need to replace a substring containing at least 3 Q's and 1 W, minimum length is 4

Constraints

1 ≤ s.length ≤ 10⁵
s.length is a multiple of 4
s consists of only 'Q', 'W', 'E', and 'R'

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 M Microsoft 8

The key insight is that we only need to replace characters that appear more than n/4 times (excess characters). The optimal approach uses sliding window to find the minimum substring containing all excess characters. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Substrings

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

For each possible substring, simulate replacing it with optimal characters and check if the result is balanced. This requires checking all O(n²) substrings.

Sliding Window - Find Minimum Window

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

First identify which characters appear more than n/4 times (excess). Then use a sliding window to find the minimum substring that contains enough excess characters to make the string balanced when replaced.

Brute Force - Check All Substrings — Algorithm Steps

Count frequency of each character in original string
For each substring [i,j], calculate what characters we'd need to add/remove
Check if we can make the string balanced by replacing this substring
Return the minimum length that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Original

Count frequency of each character

Try Substrings

For each substring, simulate replacement

Check Balance

See if replacement makes string balanced

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    if (n % 4 != 0) return 0;
    
    int target = n / 4;
    int count[4] = {0}; // Q, W, E, R
    
    // Count frequency of each character
    for (int i = 0; i < n; i++) {
        if (s[i] == 'Q') count[0]++;
        else if (s[i] == 'W') count[1]++;
        else if (s[i] == 'E') count[2]++;
        else if (s[i] == 'R') count[3]++;
    }
    
    // If already balanced
    if (count[0] == target && count[1] == target && 
        count[2] == target && count[3] == target) {
        return 0;
    }
    
    // Try all possible substrings
    for (int length = 1; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            // Count characters in current substring
            int substrCount[4] = {0};
            
            for (int j = i; j < i + length; j++) {
                if (s[j] == 'Q') substrCount[0]++;
                else if (s[j] == 'W') substrCount[1]++;
                else if (s[j] == 'E') substrCount[2]++;
                else if (s[j] == 'R') substrCount[3]++;
            }
            
            // Check if replacing this substring can balance the string
            int remainingCount[4];
            for (int k = 0; k < 4; k++) {
                remainingCount[k] = count[k] - substrCount[k];
            }
            
            // Check if we can create a replacement substring to make it balanced
            int neededInReplacement[4] = {0};
            int totalNeeded = 0;
            
            for (int k = 0; k < 4; k++) {
                if (remainingCount[k] < target) {
                    int needed = target - remainingCount[k];
                    neededInReplacement[k] = needed;
                    totalNeeded += needed;
                }
            }
            
            // Check if we can fit the needed characters in the replacement substring
            if (totalNeeded <= length) {
                return length;
            }
        }
    }
    
    return n;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using fixed-size frequency arrays

✓ Linear Space

28.5K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler