Swap For Longest Repeated Character Substring

Swap For Longest Repeated Character Substring - Problem

Given a string text, you can perform at most one swap of any two characters in the string. Your goal is to maximize the length of the longest substring containing repeated characters.

A substring is a contiguous sequence of characters within the string. After the optional swap, you want to find the longest possible substring where all characters are identical.

Example: In string "ababa", swapping positions 1 and 2 gives "aabba", creating a substring "aa" of length 2.

Note: You don't have to perform a swap if the original string already contains the optimal solution.

Input & Output

example_1.py — Basic case

$ Input: "ababa"

› Output: 3

💡 Note: We can swap positions 0 and 2 to get "abaab", then positions 2 and 4 to get "aabab". But optimally, swap positions 1 and 3 to get "aabaa", giving us a substring "aaa" of length 3.

example_2.py — All same characters

$ Input: "aaaa"

› Output: 4

💡 Note: The string already consists of repeated characters, so no swap is needed. The entire string has length 4.

example_3.py — Two character types

$ Input: "aaabbaaa"

› Output: 6

💡 Note: We can swap one 'b' with an 'a' to create a longer sequence of 'a's. For example, swap position 3 (first 'b') with position 4 (second 'b') doesn't help, but we can rearrange to get "aaaabaaa" giving us 4 consecutive 'a's, or "aaaaaaabb" giving us 6 consecutive 'a's by moving characters optimally.

Constraints

1 ≤ text.length ≤ 10⁵
text consists of lowercase English letters only
You can perform at most one swap operation

Visualization

Tap to expand

Understanding the Visualization

Analyze Original

Count each character type and find current longest repeated substring

For Each Character

Use sliding window to find longest achievable sequence for each character type

Simulate Swap

Allow at most one 'wrong' character in window that could be swapped out

Find Maximum

Return the maximum achievable length across all character types

Key Takeaway

🎯 Key Insight: Rather than actually performing swaps, we can simulate their effect using a sliding window that allows at most one character that could be 'swapped out' to achieve our target character sequence.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal solution uses a sliding window approach with character frequency counting. For each unique character, we maintain a window containing at most 2 different character types, where one must be our target character. The key insight is that we can simulate the effect of one swap by allowing one non-target character in our window, which could potentially be swapped with a target character from outside the window.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Character Counting	O(n)	O(1)	For each character, find the longest window allowing at most one swap
Brute Force (Try All Swaps)	O(n³)	O(1)	Try every possible swap and find the longest repeated substring in each case

Sliding Window with Character Counting — Algorithm Steps

Count frequency of each character in the string
For each unique character, use sliding window to find longest achievable substring
In each window, allow at most one character that differs from target
The differing character can potentially be swapped with target character from outside window
Return the maximum length found across all characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count frequency of each character in the string

For Each Character

Try to maximize substring for each unique character

Sliding Window

Maintain window with at most 2 different characters

Track Maximum

Keep track of maximum valid window size

Code -

solution.c — C

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

#define MAX_CHARS 26

int maxRepOpt1(char* text) {
    int n = strlen(text);
    
    // Count frequency of each character
    int charCount[MAX_CHARS] = {0};
    int uniqueChars[MAX_CHARS];
    int numUnique = 0;
    
    for (int i = 0; i < n; i++) {
        int idx = text[i] - 'a';
        if (charCount[idx] == 0) {
            uniqueChars[numUnique++] = idx;
        }
        charCount[idx]++;
    }
    
    int maxLength = 0;
    
    // Try to maximize substring for each unique character
    for (int u = 0; u < numUnique; u++) {
        int targetIdx = uniqueChars[u];
        char targetChar = 'a' + targetIdx;
        
        int left = 0;
        int usedChars[MAX_CHARS] = {0};
        int numUsed = 0;
        
        for (int right = 0; right < n; right++) {
            int idx = text[right] - 'a';
            if (usedChars[idx] == 0) numUsed++;
            usedChars[idx]++;
            
            // Shrink window if conditions violated
            while (numUsed > 2 ||
                   usedChars[targetIdx] > charCount[targetIdx] ||
                   (numUsed == 2 && usedChars[targetIdx] == 0)) {
                int leftIdx = text[left] - 'a';
                usedChars[leftIdx]--;
                if (usedChars[leftIdx] == 0) numUsed--;
                left++;
            }
            
            int currentLength = right - left + 1;
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char text[1001];
    fgets(text, sizeof(text), stdin);
    // Remove newline and quotes
    text[strcspn(text, "\n")] = 0;
    if (text[0] == '"' && text[strlen(text)-1] == '"') {
        memmove(text, text+1, strlen(text)-1);
        text[strlen(text)-1] = '\0';
    }
    printf("%d\n", maxRepOpt1(text));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(26 * n) in worst case, where 26 is number of possible characters, but effectively O(n) since we process each position constant times

✓ Linear Growth

Space Complexity

O(1)

Only storing character frequencies (at most 26 characters) and a few variables

✓ Linear Space

52.4K Views

High Frequency

~18 min Avg. Time

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

Sliding Window with Character Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler