[LeetCode] 159. Longest Substring with At Most Two Distinct Characters 最多有两个不同字符的最长子串

Given a string S, find the length of the longest substring T that contains at most two distinct characters.
For example,
Given S = "eceba",
T is "ece" which its length is 3.

给一个字符串，找出最多有两个不同字符的最长子串。还是滑动窗口法，定义一个HashMap或者Array来存储出现过的字符个数，左右指针初始位子为0，右指针向右扫，扫到新字符不同字符数加1，存入HashMap，扫到出现过的字符，HashMap对应字符数量加1。如果不同字符数大于2了，就把左指针位置的字符在HashMap中的数量减1，注意不一定是这一个，如果此时这个字符的数量大于0，说明还有这个字符存在，左指针加1继续右移，扫到的字符以后不会在窗口里了，要在HashMap中减1，如果这个字符减1后为0了，说明这个字符在窗口中没有了，此时不同字符数就可减1，左指针在右移1位指向下一个字符，统计此时窗口长度与最大长度比较，保留最大值。重复上面步骤，直到右指针扫完所有字符。最后返回最大长度。

Java: T: O(n), S: O(1)

public int lengthOfLongestSubstringTwoDistinct(String s) {
    int max=0;
    HashMap<Character,Integer> map = new HashMap<Character, Integer>();
    int start=0;
  
    for(int i=0; i<s.length(); i++){
        char c = s.charAt(i);
        if(map.containsKey(c)){
            map.put(c, map.get(c)+1);
        }else{
            map.put(c,1);
        }
  
        if(map.size()>2){
            max = Math.max(max, i-start);
  
            while(map.size()>2){
                char t = s.charAt(start);
                int count = map.get(t);
                if(count>1){
                    map.put(t, count-1);
                }else{
                    map.remove(t);
                }
                start++;
            }
        }
    }
  
    max = Math.max(max, s.length()-start);
  
    return max;
}

Java:

public int lengthOfLongestSubstringTwoDistinct(String s) {
        Map<Character, Integer> map = new HashMap<>();
        int start = 0, end = 0;
        int counter = 0, len = 0;
        while(end < s.length()){
            char cur = s.charAt(end);
            if(!map.containsKey(cur)) map.put(cur, 0);
            map.put(cur, map.get(cur) + 1);
            if(map.get(cur) == 1) counter++;//new distinct char
            while(counter > 2){//
                char c2 = s.charAt(start);
                map.put(c2, map.get(c2) - 1);
                if(map.get(c2) == 0) counter--;
                start++;
            }
            len = Math.max(end - start + 1, len);
            end++;
        }
        return len;
    }

Python:

class Solution:
    def lengthOfLongestSubstringTwoDistinct(self, s):
        longest, start, distinct_count, visited = 0, 0, 0, [0 for _ in xrange(256)]
        for i, char in enumerate(s):
            if visited[ord(char)] == 0:
                distinct_count += 1
            visited[ord(char)] += 1
             
            while distinct_count > 2:
                visited[ord(s[start])] -= 1
                if visited[ord(s[start])] == 0:
                    distinct_count -= 1
                start += 1
   
            longest = max(longest, i - start + 1)
        return longest

C++:

class Solution {
public:
    int lengthOfLongestSubstringTwoDistinct(string s) {
        int res = 0, left = 0;
        unordered_map<char, int> m;
        for (int i = 0; i < s.size(); ++i) {
            ++m[s[i]];
            while (m.size() > 2) {
                if (--m[s[left]] == 0) m.erase(s[left]);
                ++left;
            }
            res = max(res, i - left + 1);
        }
        return res;
    }
};