Longest Substring with At Most K Distinct Characters

Longest Substring with At Most K Distinct Characters - Problem

You are given a string s and an integer k, and your task is to find the length of the longest substring that contains at most k distinct characters.

A substring is a contiguous sequence of characters within a string. For example, in the string "abcdef", some substrings include "abc", "cde", and "def".

Goal: Return the maximum length of any substring that has at most k unique characters.

Example: If s = "eceba" and k = 2, the answer is 3 because the substring "ece" has exactly 2 distinct characters ('e' and 'c') and is the longest such substring.

Input & Output

example_1.py — Basic Case

$ Input: s = "eceba", k = 2

› Output: 3

💡 Note: The longest substring with at most 2 distinct characters is "ece" which has length 3. It contains only 2 distinct characters: 'e' and 'c'.

example_2.py — All Same Characters

$ Input: s = "aaaa", k = 1

› Output: 4

💡 Note: The entire string "aaaa" has only 1 distinct character 'a', which is ≤ k=1, so the answer is the full length 4.

example_3.py — k=0 Edge Case

$ Input: s = "abc", k = 0

› Output: 0

💡 Note: When k=0, we cannot have any distinct characters, so no valid substring exists. The answer is 0.

Visualization

Tap to expand

Understanding the Visualization

Start Reading

Place your window at the beginning and start reading characters one by one

Expand Window

Keep widening your view to the right as long as you see at most k different characters

Hit the Limit

When you see too many different characters, slide the left edge of your window right

Track Maximum

Remember the largest window size you've seen that met the constraint

Key Takeaway

🎯 Key Insight: The sliding window technique transforms a potentially O(n³) brute force solution into an elegant O(n) algorithm by maintaining state efficiently and only shrinking the window when absolutely 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(k)

Hash map stores at most k+1 distinct characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
0 ≤ k ≤ 50
s consists of English letters
Follow up: Could you solve it in O(n) time?

Asked in

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

The optimal solution uses the sliding window technique with a hash map to maintain at most k distinct characters. We expand the window by moving the right pointer and shrink it from the left when we exceed k distinct characters. This achieves O(n) time complexity as each character is visited at most twice.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(k)	Use sliding window technique with hash map to track character frequencies
Brute Force (Check All Substrings)	O(n³)	O(n)	Check every possible substring and count distinct characters

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Initialize left and right pointers, hash map for character frequencies, and max_length
Expand window by moving right pointer and adding characters to hash map
If distinct characters > k, shrink window from left until ≤ k
Update max_length with current valid window size
Continue until right pointer reaches end of string
Return max_length

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Window

Move right pointer and add characters to hash map

Check Constraint

If distinct characters > k, shrink from left

Update Maximum

Track the maximum valid window size seen so far

Code -

solution.c — C

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

int lengthOfLongestSubstringKDistinct(char* s, int k) {
    int len = strlen(s);
    if (len == 0 || k == 0) return 0;
    
    int left = 0;
    int maxLength = 0;
    int charCount[256] = {0};
    int distinctCount = 0;
    
    for (int right = 0; right < len; right++) {
        // Add character to window
        if (charCount[s[right]] == 0) {
            distinctCount++;
        }
        charCount[s[right]]++;
        
        // Shrink window if too many distinct characters
        while (distinctCount > k) {
            charCount[s[left]]--;
            if (charCount[s[left]] == 0) {
                distinctCount--;
            }
            left++;
        }
        
        // Update maximum length
        int currentLength = right - left + 1;
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

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

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(k)

Hash map stores at most k+1 distinct characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
0 ≤ k ≤ 50
s consists of English letters
Follow up: Could you solve it in O(n) time?

52.4K Views

High Frequency

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

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler