Smallest Substring With Identical Characters II

Smallest Substring With Identical Characters II - Problem

You're given a binary string s of length n and an integer numOps representing the maximum number of operations you can perform.

In each operation, you can flip any character in the string:

If s[i] == '1', change it to '0'
If s[i] == '0', change it to '1'

Your goal is to minimize the length of the longest substring where all characters are identical. Think of it as trying to break up long streaks of consecutive identical characters by strategically flipping some bits.

Example: For string "111100" with numOps = 1, you could flip one character to get "111010", reducing the longest identical substring from 4 to 3.

Return the minimum possible length of the longest identical substring after performing at most numOps operations.

Input & Output

example_1.py — Basic case

$ Input: s = "111100", numOps = 1

› Output: 2

💡 Note: We can flip one '1' to get "101100". The longest identical substring now has length 2 (either "11" or "00").

example_2.py — Multiple operations

$ Input: s = "111111", numOps = 2

› Output: 2

💡 Note: With 2 operations, we can create "101101". The maximum identical substring length becomes 2.

example_3.py — No operations needed

$ Input: s = "101010", numOps = 1

› Output: 1

💡 Note: The string already has maximum identical substring length of 1, so no operations are needed.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ numOps ≤ n
s consists only of characters '0' and '1'

Visualization

Tap to expand

Understanding the Visualization

Identify Long Streaks

Find all consecutive segments of identical characters (traffic jams)

Binary Search Strategy

Instead of trying every possible intervention, search for the minimum achievable jam length

Greedy Validation

For each candidate max length, greedily determine minimum interventions needed

Optimize Both Directions

Consider strategies for both making mostly 0s and mostly 1s

Find Minimum

Return the smallest achievable maximum streak length

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy validation allows us to solve this efficiently in O(n log n) time instead of the exponential brute force approach.

Asked in

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

The optimal approach uses binary search on the answer combined with a greedy validation strategy. Instead of trying all possible flip combinations, we search for the minimum achievable maximum substring length. For each candidate length, we use a greedy algorithm to determine if it's achievable with the available operations, considering both strategies of making the string mostly 0s or mostly 1s.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n,k) * n) where k ≤ numOps	O(n)	Try all possible ways to flip characters and find the minimum result
Binary Search on Answer (Optimal)	O(n log n)	O(1)	Binary search for the minimum achievable maximum substring length

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible combinations of positions to flip (up to numOps positions)
For each combination, apply the flips to create a new string
Calculate the longest identical substring length for each resulting string
Return the minimum length found across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with the given binary string

Generate Combinations

Create all possible ways to flip up to numOps characters

Apply Flips

For each combination, flip the selected positions

Calculate Length

Find longest identical substring in each result

Track Minimum

Keep track of the smallest maximum length found

Code -

solution.c — C

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

int getLongestIdentical(char* s) {
    int len = strlen(s);
    if (len == 0) return 0;
    int maxLen = 1, currentLen = 1;
    for (int i = 1; i < len; i++) {
        if (s[i] == s[i-1]) {
            currentLen++;
            if (currentLen > maxLen) maxLen = currentLen;
        } else {
            currentLen = 1;
        }
    }
    return maxLen;
}

void generateCombinations(int* arr, int n, int k, int start, int* current, int currentSize, int* minResult, char* s) {
    if (k == 0) {
        char* temp = malloc((strlen(s) + 1) * sizeof(char));
        strcpy(temp, s);
        
        for (int i = 0; i < currentSize; i++) {
            int pos = current[i];
            temp[pos] = temp[pos] == '0' ? '1' : '0';
        }
        
        int result = getLongestIdentical(temp);
        if (result < *minResult) *minResult = result;
        
        free(temp);
        return;
    }
    
    for (int i = start; i <= n - k; i++) {
        current[currentSize] = i;
        generateCombinations(arr, n, k, i + 1, current, currentSize + 1, minResult, s);
    }
}

int minLength(char* s, int numOps) {
    int n = strlen(s);
    int minResult = getLongestIdentical(s);
    int* arr = malloc(n * sizeof(int));
    int* current = malloc(numOps * sizeof(int));
    
    for (int i = 0; i < n; i++) arr[i] = i;
    
    for (int ops = 1; ops <= (numOps < n ? numOps : n); ops++) {
        generateCombinations(arr, n, ops, 0, current, 0, &minResult, s);
    }
    
    free(arr);
    free(current);
    return minResult;
}

int main() {
    char s[1001];
    int numOps;
    
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    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';
    }
    
    scanf("%d", &numOps);
    
    printf("%d\n", minLength(s, numOps));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * n) where k ≤ numOps

We have C(n,numOps) combinations to try, and each takes O(n) time to evaluate

✓ Linear Growth

Space Complexity

O(n)

Space for storing the current string configuration

⚡ Linearithmic Space

26.1K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler