Maximum Length Substring With Two Occurrences

Maximum Length Substring With Two Occurrences - Problem

Maximum Length Substring With Two Occurrences

You're given a string s, and your task is to find the maximum length of any substring where each character appears at most twice.

Think of it as finding the longest "balanced" portion of text where no character becomes too repetitive. For example, in the string "abcaba", the entire string is valid since each character ('a', 'b', 'c') appears at most 2 times, giving us a maximum length of 6.

Goal: Return the length of the longest valid substring
Input: A string s containing lowercase English letters
Output: An integer representing the maximum substring length

Input & Output

example_1.py — Basic Case

$ Input: s = "bcbbbcba"

› Output: 4

💡 Note: The optimal substring is "bcbb" with frequencies: b=3 (invalid), c=1. Actually, "cbbb" won't work either. The correct answer is "bcbb" -> "cbb" (length 3) or "bcb" (length 3) or "bbc" (length 3) or "cbbc" (length 4) where c=2, b=2. So maximum length is 4.

example_2.py — All Characters Valid

$ Input: s = "abcaba"

› Output: 6

💡 Note: The entire string is valid since character frequencies are: a=3 (invalid). Wait, let me recalculate: a appears at positions 0,3,5 (3 times), b appears at positions 1,4 (2 times), c appears at position 2 (1 time). Since 'a' appears 3 times, we need a substring. The longest valid substring is "bcab" or "caba" or "abca" (length 4) where no character appears more than twice.

example_3.py — Single Character

$ Input: s = "aa"

› Output: 2

💡 Note: The string "aa" has character frequency: a=2, which satisfies the constraint of at most 2 occurrences per character.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Each character can appear at most 2 times in a valid substring

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with an empty window at the beginning of the string

Expand Right

Keep adding characters to the right side of the window

Monitor Frequencies

Track how many times each character appears in the current window

Shrink When Invalid

When any character appears 3+ times, remove characters from the left

Track Maximum

Remember the largest valid window size encountered

Key Takeaway

🎯 Key Insight: The sliding window technique efficiently maintains a valid substring by expanding right and contracting left as needed, ensuring each character appears at most twice while tracking the maximum valid length.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a sliding window technique with a hash map to track character frequencies. We expand the window by moving the right pointer and shrink from the left when any character appears more than twice. This achieves O(n) time complexity since each character is visited at most twice.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring and count character frequencies
Sliding Window with Hash Map (Optimal)	O(n)	O(min(m, 26))	Use sliding window technique with character frequency tracking

Brute Force (Check All Substrings) — Algorithm Steps

Iterate through all possible starting positions
For each starting position, try all possible ending positions
Count character frequencies in the current substring
If all characters appear ≤ 2 times, update maximum length
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first position

Begin checking all substrings starting from index 0

Expand substring

For each starting position, try all possible ending positions

Count frequencies

Count character occurrences in current substring

Check validity

Verify no character appears more than twice

Update maximum

Keep track of the longest valid substring found

Code -

solution.c — C

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

int maximumLengthSubstring(char* s) {
    int n = strlen(s);
    int maxLength = 0;
    
    // Try all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count character frequencies in substring s[i:j+1]
            int charCount[26] = {0}; // for lowercase letters a-z
            int valid = 1;
            
            for (int k = i; k <= j; k++) {
                int c = s[k] - 'a';
                charCount[c]++;
                if (charCount[c] > 2) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid && j - i + 1 > maxLength) {
                maxLength = j - i + 1;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    printf("%d\n", maximumLengthSubstring(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for all substrings × O(n) to count frequencies for each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track counts and maximum length

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

845 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 (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler