Smallest Substring With Identical Characters I

Smallest Substring With Identical Characters I - Problem

You are given a binary string s of length n and an integer numOps.

You are allowed to perform the following operation on s at most numOps times:

Select any index i (where 0 <= i < n) and flip s[i]
If s[i] == '1', change s[i] to '0' and vice versa

You need to minimize the length of the longest substring of s such that all the characters in the substring are identical.

Return the minimum length after the operations.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: We can flip position 2 (0-indexed) to get "11000". The longest identical substring has length 2 (either "11" or "00").

Example 2 — No Operations Needed

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

› Output: 1

💡 Note: The string already alternates, so the longest identical substring is 1. No operations needed.

Example 3 — All Same Characters

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

› Output: 2

💡 Note: We can flip any position to get something like "1011". The longest identical substring becomes 2.

Constraints

1 ≤ n ≤ 1000
0 ≤ numOps ≤ n
s consists only of '0' and '1'

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use binary search on the answer space. We search for the minimum possible maximum substring length by checking if each candidate length is achievable with the given number of operations. The optimal approach uses binary search with greedy feasibility checking in O(n log n) time.

Common Approaches

✓ Binary Search on Answer

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

Use binary search to find the minimum possible maximum substring length. For each candidate length, check if it's possible to achieve using at most numOps flips.

Brute Force - Try All Combinations

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

Generate all possible combinations of at most numOps flips and check the longest identical substring for each combination. This explores the entire solution space.

Binary Search on Answer — Algorithm Steps

Binary search on answer from 1 to n
For each candidate length, check feasibility
Use greedy strategy to verify if length is achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Space

Binary search between 1 and string length

Check Feasibility

For each candidate, verify if achievable with given operations

Converge

Narrow down to minimum possible maximum length

Code -

solution.c — C

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

int getMinFlipsDP(const char* s, int maxLen) {
    int n = strlen(s);
    if (maxLen >= n) return 0;
    
    // Find all consecutive runs
    int runs[1001];
    int runCount = 0;
    int i = 0;
    
    while (i < n) {
        int j = i;
        while (j < n && s[j] == s[i]) {
            j++;
        }
        runs[runCount++] = j - i;
        i = j;
    }
    
    // Count flips needed to break runs longer than maxLen
    int flips = 0;
    for (i = 0; i < runCount; i++) {
        if (runs[i] > maxLen) {
            flips += (runs[i] - 1) / maxLen;
        }
    }
    
    return flips;
}

int canAchieve(const char* s, int maxLen, int numOps) {
    int n = strlen(s);
    if (maxLen >= n) return 1;
    
    int minFlips = INT_MAX;
    
    // Try both starting patterns
    char startChars[] = {'0', '1'};
    for (int k = 0; k < 2; k++) {
        char startChar = startChars[k];
        int flips = 0;
        int i = 0;
        char currentChar = startChar;
        
        while (i < n) {
            int segmentEnd = i + maxLen;
            if (segmentEnd > n) {
                segmentEnd = n;
            }
            
            // Count flips needed in this segment
            for (int j = i; j < segmentEnd; j++) {
                if (s[j] != currentChar) {
                    flips++;
                }
            }
            
            i = segmentEnd;
            currentChar = (currentChar == '0') ? '1' : '0';
        }
        
        if (flips < minFlips) {
            minFlips = flips;
        }
    }
    
    // Also try optimal segmentation
    int dpFlips = getMinFlipsDP(s, maxLen);
    if (dpFlips < minFlips) {
        minFlips = dpFlips;
    }
    
    return minFlips <= numOps;
}

int solution(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;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &numOps);
    printf("%d\n", solution(s, numOps));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search takes O(log n) iterations, each feasibility check takes O(n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

5.6K Views

Medium Frequency

~35 min Avg. Time

234 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler