牛客网：最小覆盖子串

思路是这样的：

我们维护一个快慢指针slow和fast，以及一个哈希表

哈希表的作用是记录在S[slow，fast]这个字符串区间中是否出现T中字符，如果出现则>=0，一开始全部初始化成-1。之后我们只会更新和T字符串相关元素，可以用unordered_map的一个函数count，若我们查找的元素在里面则返回1，如果不在则返回0

之后我们来维护这个区间，我们利用fast来遍历整个字符串S：

1.取出S[fast]，如果这个元素是T中的元素，则哈希表记录加一

2.如果在当前维护的区间[slow,fast]中出现了T中的所有字符，则将最短字符串的长度进行更新，并且更新要返回的区间[left, right]的值为[slow, fast]

更新完后，我们尝试缩小区间大小，即将左元素取出，将slow加1，更新哈希表，继续第二步最开始的判断

代码如下所示：

class Solution {
public:
    /**
     * 
     * @param S string字符串 
     * @param T string字符串 
     * @return string字符串
     */
    bool check(unordered_map<char, int> &hash){
        for(auto iter=hash.begin();iter!=hash.end();++iter){
            if(iter->second<0){
                return false;
            }
        }
        return true;
    }
    string minWindow(string S, string T) {
        int cnt=S.length()+1;
        unordered_map<char, int> hash;
        for(int i=0;i<T.length();++i){
            hash[T[i]] -= 1;
        }
        int slow=0,fast=0;
        int left=-1,right=-1;
        for(;fast<S.length();++fast){
            char c=S[fast];
            if(hash.count(c)){
                hash[c]++;
            }
            while(check(hash)){
                //如果长度小于当前记录最小值
                //更新区间值
                if(cnt > fast-slow+1){
                    cnt=fast-slow+1;
                    left=slow;
                    right=fast;
                }
                //只要是满足了出现t的所有字符的条件
                //就尝试是否能够缩小左区间
                char c=S[slow];
                if(hash.count(c)){
                    hash[c]--;
                }
                slow++;
            }
        }
        if(left==-1){
            return "";
        }
        return string(S.begin()+left, S.begin()+right+1);
    }
};