Smallest Substring With Identical Characters I

Smallest Substring With Identical Characters I - Problem

Transform Your Binary String Strategically!

You're given a binary string s of length n and a limited number of flip operations (numOps). Your mission is to strategically use these operations to minimize the length of the longest contiguous substring where all characters are identical.

🎯 Goal: After performing at most numOps flips (changing '0' to '1' or '1' to '0'), find the minimum possible length of the longest substring with all identical characters.

💡 Key Challenge: You need to decide which positions to flip to create the most balanced distribution of characters, preventing long runs of consecutive 0s or 1s.

Example: For string "111000" with numOps = 1, you could flip one character to get "111001", reducing the longest identical substring from 3 to 3, or flip strategically to achieve better results.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We have 4 consecutive 1s. With 1 flip operation, we can change one '1' to '0' (e.g., at position 1) to get "1011", making the longest identical substring length 2.

example_2.py — Mixed String

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

› Output: 1

💡 Note: The string already alternates, so the longest identical substring is already 1. No operations needed, but we can still achieve length 1.

example_3.py — Strategic Placement

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

› Output: 3

💡 Note: We have runs of length 3. With 1 operation, we can flip one position strategically, but we can't reduce the maximum run length below 3 with just 1 operation.

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

Find runs of consecutive identical characters that are too long

Binary Search Setup

Search between 1 (best case) and n (worst case) for the answer

Greedy Verification

For each candidate length, greedily place operations to achieve the target

Pattern Testing

Test both starting with '0' and '1' patterns, choose the better option

Optimal Result

Find the minimum length that's achievable within the operation limit

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy pattern matching allows us to efficiently find the optimal solution in O(n log n) time, avoiding the exponential complexity of trying all flip combinations.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search takes O(log n) iterations, and each verification takes O(n) time to scan the string

⚡ Linearithmic

Space Complexity

O(n)

Space to store the working copy of the string during verification

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
0 ≤ numOps ≤ n
s consists only of '0' and '1'
n is the length of string s

Asked in

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

The optimal approach uses binary search on the answer combined with greedy verification. We binary search on possible lengths (1 to n) and for each candidate length, use a greedy algorithm to check if it's achievable with the given number of operations. The key insight is testing both starting patterns ('0' and '1') and choosing the one requiring fewer operations. This achieves O(n log n) time complexity, much better than the exponential brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n log n)	O(n)	Binary search on the answer combined with greedy verification
Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Try all possible combinations of flip operations and find the minimum result

Binary Search on Answer — Algorithm Steps

Binary search on the answer from 1 to n
For each candidate length, check if it's achievable
Use greedy approach: scan the string and flip optimally to prevent runs longer than the target
If achievable with ≤ numOps flips, try a smaller answer; otherwise try larger

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Search Range

Binary search between 1 and n (string length)

Test Mid Value

Check if target length is achievable with given operations

Greedy Verification

Use greedy approach to count needed operations

Narrow Search

Update search range based on feasibility

Code -

solution.c — C

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

int checkPattern(const char* s, int maxLen, char startChar) {
    int n = strlen(s);
    int operations = 0;
    char expected = startChar;
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        if (s[i] == expected) {
            count++;
        } else {
            count = 1;
            operations++;
        }
        
        if (count >= maxLen) {
            if (i + 1 < n) {
                expected = (expected == '0') ? '1' : '0';
                count = 0;
                operations++;
            }
        }
    }
    
    return operations;
}

int canAchieve(const char* s, int maxLen, int numOps) {
    int opt1 = checkPattern(s, maxLen, '0');
    int opt2 = checkPattern(s, maxLen, '1');
    return (opt1 < opt2 ? opt1 : opt2) <= numOps;
}

int minLength(char* s, int numOps) {
    int n = strlen(s);
    int left = 1, right = n;
    int result = n;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieve(s, mid, numOps)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    int numOps;
    scanf("%s %d", s, &numOps);
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s+1, len-1);
        s[len-2] = '\0';
    }
    printf("%d\n", minLength(s, numOps));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search takes O(log n) iterations, and each verification takes O(n) time to scan the string

⚡ Linearithmic

Space Complexity

O(n)

Space to store the working copy of the string during verification

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
0 ≤ numOps ≤ n
s consists only of '0' and '1'
n is the length of string s

38.2K Views

High Frequency

~25 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler