Swap For Longest Repeated Character Substring

Swap For Longest Repeated Character Substring - Problem

You are given a string text. You can swap two of the characters in the text.

Return the length of the longest substring with repeated characters.

A substring is a contiguous sequence of characters within a string. After swapping two characters, you need to find the longest substring where all characters are the same.

Input & Output

Example 1 — Basic Case

$ Input: text = "ababa"

› Output: 3

💡 Note: We can swap the second 'b' with the last 'a' to get "aabaa", then the longest substring with repeated characters is "aaa" with length 3.

Example 2 — All Same Characters

$ Input: text = "aaaa"

› Output: 4

💡 Note: All characters are already the same, so no swap is needed. The entire string "aaaa" has length 4.

Example 3 — Two Different Characters

$ Input: text = "abab"

› Output: 3

💡 Note: We can swap one 'b' with one 'a' to get "aaab" or "abaa", giving us a longest repeated substring of length 3.

Constraints

1 ≤ text.length ≤ 1000
text consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15

The key insight is that we need to find the longest substring that can be made uniform with exactly one character swap. The optimal approach uses sliding window for each unique character to find the longest substring with at most one mismatch. Time: O(26n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Swaps

⏱️ Time: O(n⁴) Space: O(n)

For every pair of positions in the string, perform the swap, then check all possible substrings to find the longest one with all identical characters. This approach guarantees finding the optimal solution but is very slow.

Sliding Window with Character Frequency

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

For each unique character in the string, use a sliding window approach to find the longest substring that can contain all instances of that character with at most one swap. This reduces the time complexity significantly by avoiding the need to try all possible swaps.

Brute Force - Try All Swaps — Algorithm Steps

Try swapping characters at every pair of positions (i, j)
For each swap, scan all possible substrings
Find the maximum length substring with all same characters
Keep track of the overall maximum across all swaps

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with input string

Try All Swaps

For each pair (i,j), swap characters and check

Find Max Length

Return longest repeated substring found

Code -

solution.c — C

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

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

int solution(char* text) {
    int n = strlen(text);
    if (n <= 1) {
        return n;
    }
    
    int maxResult = maxRepeatedLength(text);
    
    // Try all possible swaps
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Swap characters at positions i and j
            char temp = text[i];
            text[i] = text[j];
            text[j] = temp;
            
            // Find max repeated length in swapped string
            int curr = maxRepeatedLength(text);
            if (curr > maxResult) {
                maxResult = curr;
            }
            
            // Swap back
            temp = text[i];
            text[i] = text[j];
            text[j] = temp;
        }
    }
    
    // For strings with all different characters, we can always achieve length 2
    if (maxResult == 1 && n >= 2) {
        maxResult = 2;
    }
    
    return maxResult;
}

int main() {
    char text[1001];
    if (fgets(text, sizeof(text), stdin) != NULL) {
        text[strcspn(text, "\n")] = '\0';
    }
    
    int result = solution(text);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n²) pairs to swap × O(n²) substrings to check × O(n) to verify each substring

✓ Linear Growth

Space Complexity

O(n)

Need to create a copy of string for each swap operation

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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 Swaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler