[LeetCode] 340. Longest Substring with At Most K Distinct Characters

Given a string, find the length of the longest substring T that contains at most k distinct characters.

Example 1:

Input: s = "eceba", k = 2
Output: 3
Explanation: T is "ece" which its length is 3.

Example 2:

Input: s = "aa", k = 1
Output: 2
Explanation: T is "aa" which its length is 2.

Solution 1. Brute force, O(N^3) runtime

For each possible substring, check if it contains at most k distinct characters, then get the longest.

class Solution {
    public int lengthOfLongestSubstringKDistinct(String s, int k) {
        int max = 0;
        for(int i = 0; i < s.length(); i++) {
            for(int j = i + 1; j <= s.length(); j++) {
                String sub = s.substring(i, j);
                Set<Character> chars = new HashSet<>();
                for(int t = i; t < j; t++) {
                    chars.add(s.charAt(t));
                }
                if(chars.size() <= k) {
                    max = Math.max(max, sub.length());
                }
            }
        }
        return max;
}

 

Solution 2. O(N^2) runtime

One thing that can be optimized in solution 1 is to use checked substring's characters counts to determine if the next substring of the same length satisfies the condition, from O(N) to O(1). This is done by maintaining a hashmap of each distinct character's frequency. 

1. Initialize a hash map of each distinct character's frequency.

2. Starting from the possible maximum length n = s.length(), do the following.

　　a. from left to right, slide a window of length n to check if a substring meets the required condition. If it does, return; otherwise keep sliding one character at a time until reaching the right end.

　　b. reduce sliding window length by 1 and from right to left, slide a window of length n to check if a substring meets the required condition. If it does, return; otherwise keep sliding one character at a time until reaching the left end.

　　c. repeat a and b until n = 0.

 

class Solution {
    public int lengthOfLongestSubstringKDistinct(String s, int k) {        
        int[] counts = new int[256];
        for(int i = 0; i < s.length(); i++) {
            counts[s.charAt(i) - '\0']++;
        }
        int uniqueChars = 0;
        for(int i = 0; i < 256; i++) {
            if(counts[i] > 0) {
                uniqueChars++;
            }
        }
        int maxLen = s.length();
        boolean leftToRight = false;
         
        for(; maxLen > 0; maxLen--) {
            leftToRight = !leftToRight;
            if(leftToRight) {
                int leftIdx = 0, rightIdx = maxLen - 1;
                if(rightIdx + 1 < s.length()) {
                    counts[s.charAt(rightIdx + 1) - '\0']--;
                    if(counts[s.charAt(rightIdx + 1) - '\0'] == 0) {
                       uniqueChars--; 
                    }
                }
                if(uniqueChars <= k) {
                    return maxLen;
                }
                rightIdx ++;
                while(rightIdx < s.length()) {  
                    counts[s.charAt(leftIdx) - '\0']--;
                    if(counts[s.charAt(leftIdx) - '\0'] == 0) {
                        uniqueChars--;
                    }
                    leftIdx++;
                    
                    if(counts[s.charAt(rightIdx) - '\0'] == 0) {
                        uniqueChars++;
                    }
                    
                    counts[s.charAt(rightIdx) - '\0']++;                  
                    if(uniqueChars <= k) {
                        return maxLen;
                    }
                    rightIdx++;
                }               
            }
            else {
                int rightIdx = s.length() - 1, leftIdx = s.length() - maxLen;
                if(leftIdx >= 1) {
                    counts[s.charAt(leftIdx - 1) - '\0']--;
                    if(counts[s.charAt(leftIdx - 1) - '\0'] == 0) {
                       uniqueChars--; 
                    }                    
                }
                if(uniqueChars <= k) {
                    return maxLen;
                }
                leftIdx--;
                while(leftIdx >= 0) {  
                    counts[s.charAt(rightIdx) - '\0']--;
                    if(counts[s.charAt(rightIdx) - '\0'] == 0) {
                        uniqueChars--;
                    }
                    rightIdx--;
                    
                    if(counts[s.charAt(leftIdx) - '\0'] == 0) {
                        uniqueChars++;
                    }
                    counts[s.charAt(leftIdx) - '\0']++;                    
                    if(uniqueChars <= k) {
                        return maxLen;
                    }
                    leftIdx--;
                }               
            }
        }
        return maxLen;   
}

 

Solution 3. O(N) runtime

To further optimize solution 2, we have the this observation: for a substring that starts at index i, s[i, j - 1], if it meets the condition while s[i, j] does not, we do not need to backtrack j to i + 1.This is true because all the substring from index i + 1 to j - 1 are a smaller set of s[i, j - 1]. If s[i, j - 1] is a possible solution, it eliminates the need of checking a smaller solution. We just need to increment i by 1 and pick up where j stopped. 

 

For substrings that start at index i, there are two cases when we will stop incrementing j.

1. s[i, j] has more than k distinct characters; In this case, we need to update the frequency of s.charAt(i), increment i by 1 then repeat the same process.

2. j is out of bound, j == s.length();  In this case, we've found the answer as no other qualified substrings will have a longer length(i can only be incremented).

 

The runtime is O(N) as both the start index i and end index j only move forward, which means at any given iteration, either i or j is incremented. This takes linear time to finish.

 

class Solution {
    public int lengthOfLongestSubstringKDistinct(String s, int k) {       
        if(s == null || s.length() == 0 || k <= 0){
            return 0;
        }        
        int[] counts = new int[256];
        int distinctChars = 0;
        int endIdx = 0, maxLen = 0;
        for(int startIdx = 0; startIdx < s.length(); startIdx++) {
            while(endIdx < s.length()) {
                if(counts[s.charAt(endIdx) - '\0'] > 0) {
                    counts[s.charAt(endIdx) - '\0']++;
                }
                else if(distinctChars == k){
                    break;
                }
                else {
                    counts[s.charAt(endIdx) - '\0']++;
                    distinctChars++;
                }
                endIdx++;
            }
            maxLen = Math.max(maxLen, endIdx - startIdx);
            if(endIdx == s.length()) {
                break;
            }
            counts[s.charAt(startIdx) - '\0']--;
            if(counts[s.charAt(startIdx) - '\0'] == 0) {
                distinctChars--;
            }
        }
        return maxLen;
    }
}