Smallest Substring With Identical Characters II

Smallest Substring With Identical Characters II - 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 = "1110", numOps = 1

› Output: 1

💡 Note: We can flip s[1] to get "1010". The longest identical substring is now "1" with length 1, which is the minimum possible.

Example 2 — Multiple Operations

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

› Output: 2

💡 Note: We can flip positions 1 and 4 to get "010101". Now the longest identical substring has length 1. Or flip position 2 to get "001111" then position 5 to get "001110", giving max length 2.

Example 3 — No Operations Needed

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

› Output: 1

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

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of '0' and '1'
0 ≤ numOps ≤ s.length

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8 M Microsoft 6

The key insight is to use binary search on the answer space. If we can achieve a maximum identical substring length of k, we can also achieve any length > k. The optimal approach uses binary search with sliding window validation to check if each candidate answer is achievable within the operation limit. Time: O(n log n), Space: O(1).

Common Approaches

✓ Binary Search on Answer

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

The key insight is that if we can achieve a maximum identical substring length of k, we can also achieve any length > k. So we binary search on the answer space [1, n] and for each candidate answer, use a sliding window to check if it's achievable with at most numOps flips.

Brute Force

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

Generate all possible ways to flip at most numOps bits, then for each combination calculate the longest identical substring length. This explores all 2^numOps possibilities but is exponentially slow.

Binary Search on Answer — Algorithm Steps

Binary search on answer: left=1, right=n
For each mid value, check if we can achieve max length ≤ mid
Use sliding window: for each possible max length, find minimum flips needed
If achievable with ≤ numOps flips, try smaller answer; otherwise try larger

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Setup

Search space [1, n] for minimum achievable max length

Validation

For each candidate, check if achievable with ≤ numOps flips

Convergence

Narrow down to optimal answer

Code -

solution.c — C

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

int canAchieve(char* s, int numOps, int maxLen) {
    int n = strlen(s);
    
    // Greedy approach: break long runs optimally
    int flips = 0;
    int i = 0;
    
    while (i < n) {
        int j = i;
        while (j < n && s[j] == s[i]) {
            j++;
        }
        int runLength = j - i;
        
        if (runLength > maxLen) {
            // Need to break this run
            // Correct formula: runLength / (maxLen + 1)
            flips += runLength / (maxLen + 1);
        }
        
        i = j;
    }
    
    return flips <= 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, numOps, mid)) {
            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 O(log n) iterations, each validation takes O(n) sliding window

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for binary search and sliding window

✓ Linear Space

15.4K Views

Medium Frequency

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