Longest Substring of One Repeating Character

Longest Substring of One Repeating Character - Problem

You are given a string s and will perform a series of character update operations on it. After each update, you need to find the longest substring consisting of only one repeating character.

More specifically, you receive:

A 0-indexed string s
A string queryCharacters of length k containing the new characters
An array queryIndices of length k containing the positions to update

For the i-th query, you update s[queryIndices[i]] to queryCharacters[i], then find the length of the longest substring where all characters are identical.

Goal: Return an array where each element represents the longest repeating substring length after each respective query.

Example: If s = "babacc" and you change s[2] to 'b', the string becomes "babbc", and the longest repeating substring is "bb" with length 2.

Input & Output

example_1.py — Basic Update

$ Input: s = "babacc", queryCharacters = "bcb", queryIndices = [1,3,3]

› Output: [3, 3, 4]

💡 Note: Query 1: s[1] = 'b' → "bbbacc" (longest: "bbb" = 3). Query 2: s[3] = 'c' → "bbbccc" (longest: "bbb" or "ccc" = 3). Query 3: s[3] = 'b' → "bbbbc" then check → "bbbbc" + "c" = "bbbbcc" (longest: "bbbb" = 4)

example_2.py — Single Character

$ Input: s = "abcd", queryCharacters = "a", queryIndices = [0]

› Output: [1]

💡 Note: Query 1: s[0] = 'a' → "abcd" (already 'a', no change, longest repeating substring is still 1)

example_3.py — Creating Long Sequence

$ Input: s = "abab", queryCharacters = "aabb", queryIndices = [1,0,3,2]

› Output: [2, 3, 2, 4]

💡 Note: Query 1: "aaab" (longest: "aaa" = 2). Query 2: "aaab" (longest: "aaa" = 3). Query 3: "aaab" → "aaab" (longest: 2). Query 4: "aaaa" (longest: "aaaa" = 4)

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Identify all continuous segments of same-colored shirts

Fan Changes Color

A fan changes their shirt color, potentially splitting or merging segments

Update Segments

Efficiently update affected segments without checking entire stadium

Find Longest Wave

Query maximum segment length in logarithmic time

Key Takeaway

🎯 Key Insight: Maintain intervals of consecutive characters and update only affected regions instead of rescanning the entire string, achieving logarithmic time per query.

Time & Space Complexity

Time Complexity

⏱️

O(k × log n)

Each of k queries takes O(log n) time for segment tree operations

⚡ Linearithmic

Space Complexity

O(n)

Space for segment tree and interval tracking structures

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
k == queryCharacters.length == queryIndices.length
1 ≤ k ≤ 10⁵
queryCharacters consists of lowercase English letters only
0 ≤ queryIndices[i] < s.length

Asked in

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

The optimal approach uses segment trees or interval management to efficiently track consecutive character sequences. Instead of rescanning the entire string after each update (O(k×n)), we maintain intervals of identical characters and update only affected regions, achieving O(k×log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Rescan After Each Update)	O(k × n)	O(1)	After each character update, scan the entire string to find the longest repeating substring
Segment Tree (Optimal)	O(k × log n)	O(n)	Use segment tree to efficiently track intervals and handle updates in logarithmic time

Brute Force (Rescan After Each Update) — Algorithm Steps

For each query, update s[queryIndices[i]] = queryCharacters[i]
Scan the entire updated string from left to right
Track the current character and its consecutive count
Keep track of the maximum consecutive count seen so far
Store the result for this query and repeat for next query

Visualization

Tap to expand

Step-by-Step Walkthrough

Update Character

Change character at specified index

Scan String

Iterate through entire string counting consecutive characters

Track Maximum

Keep track of longest sequence found so far

Code -

solution.c — C

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

int* longestRepeating(char* s, char* queryCharacters, int* queryIndices, int queriesSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    int n = strlen(s);
    
    for (int i = 0; i < queriesSize; i++) {
        // Update character
        s[queryIndices[i]] = queryCharacters[i];
        
        // Find longest repeating substring
        int maxLen = 1;
        int currentLen = 1;
        
        for (int j = 1; j < n; j++) {
            if (s[j] == s[j-1]) {
                currentLen++;
                if (currentLen > maxLen) {
                    maxLen = currentLen;
                }
            } else {
                currentLen = 1;
            }
        }
        
        result[i] = maxLen;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

k queries × n characters to scan for each query

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum counts

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
k == queryCharacters.length == queryIndices.length
1 ≤ k ≤ 10⁵
queryCharacters consists of lowercase English letters only
0 ≤ queryIndices[i] < s.length

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Rescan After Each Update) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler