Longest Substring with At Most Two Distinct Characters

Longest Substring with At Most Two Distinct Characters - Problem

Given a string s, return the length of the longest substring that contains at most two distinct characters.

This is a classic sliding window problem where you need to find the optimal window that satisfies the constraint. For example, in the string "eceba", the longest substring with at most two distinct characters is "ece" with length 3.

Goal: Find the maximum length of any substring containing ≤ 2 unique characters

Input: A string s consisting of lowercase English letters

Output: An integer representing the length of the longest valid substring

Input & Output

example_1.py — Basic case

$ Input: s = "eceba"

› Output: 3

💡 Note: The longest substring with at most 2 distinct characters is "ece" with length 3. Other valid substrings include "ec" (length 2), "ceb" (length 3), but "ece" and "ceb" both have maximum length.

example_2.py — All same characters

$ Input: s = "ccaabbb"

› Output: 5

💡 Note: The longest substring is "aabbb" with 2 distinct characters ('a' and 'b') and length 5. We could also have "ccaa" with length 4, but "aabbb" is longer.

example_3.py — Single character

$ Input: s = "a"

› Output: 1

💡 Note: With only one character, the longest substring with at most 2 distinct characters is the entire string with length 1.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with an empty window and HashMap at the beginning of the string

Expand

Move right pointer and add characters to HashMap while constraint is satisfied

Contract

When more than 2 distinct characters exist, shrink from left until valid

Track Maximum

Continuously update the maximum valid window size encountered

Key Takeaway

🎯 Key Insight: The sliding window technique allows us to solve this problem in O(n) time by maintaining a valid window that expands greedily and contracts only when necessary.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(1)

HashMap stores at most 3 characters (2 valid + 1 being removed)

✓ Linear Space

Constraints

0 ≤ s.length ≤ 10⁴
s consists of lowercase English letters only
Follow-up: Can you solve it in O(n) time?

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses the sliding window technique with a HashMap to track character frequencies. We maintain a window with at most 2 distinct characters by expanding the right pointer and shrinking from the left when needed. This achieves O(n) time complexity and O(1) space complexity since the HashMap stores at most 3 characters.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n²)	O(1)	Check every possible substring and count distinct characters
Sliding Window with HashMap (Optimal)	O(n)	O(1)	Use sliding window technique with HashMap to track character frequencies

Brute Force (Check All Substrings) — Algorithm Steps

For each starting index i from 0 to n-1
For each ending index j from i to n-1
Count distinct characters in substring s[i:j+1]
If distinct count ≤ 2, update maximum length
If distinct count > 2, break inner loop

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin checking substrings starting from index 0

Extend substring

Add characters one by one while counting distinct characters

Check constraint

If distinct characters ≤ 2, update max length

Move starting position

Repeat process starting from next index

Code -

solution.c — C

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

int lengthOfLongestSubstringTwoDistinct(char* s) {
    if (s == NULL || strlen(s) == 0) return 0;
    
    int n = strlen(s);
    int maxLength = 0;
    
    for (int i = 0; i < n; i++) {
        int charCount[256] = {0};
        int distinctCount = 0;
        
        for (int j = i; j < n; j++) {
            if (charCount[s[j]] == 0) {
                distinctCount++;
            }
            charCount[s[j]]++;
            
            if (distinctCount <= 2) {
                int currentLength = j - i + 1;
                if (currentLength > maxLength) {
                    maxLength = currentLength;
                }
            } else {
                break;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    printf("%d\n", lengthOfLongestSubstringTwoDistinct(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops, each can run up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and maximum length

✓ Linear Space

Constraints

0 ≤ s.length ≤ 10⁴
s consists of lowercase English letters only
Follow-up: Can you solve it in O(n) time?

41.3K Views

High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler