LeetCode Minimum Window Substring

class Solution {
private:
    int shd_cnt[256];
    int cur_cnt[256];
public:
    string minWindow(string S, string T) {
        int slen = S.length();
        int tlen = T.length();
        
        // array to store char stat info of string T
        for (int i=0; i<256; i++) shd_cnt[i] = cur_cnt[i] = 0;
        // collect char stat info of string T
        for (int i=0; i<tlen; i++) shd_cnt[T[i]]++;
        
        int shd_match_cnt = 0, cur_match_cnt = 0;
        for (int i=0; i<256; i++) shd_match_cnt += shd_cnt[i] != 0;
        
        int start = 0, end = 0;
        
        int mlen = INT_MAX, ps = 0, pe = 0;
        
        bool updated = true;
        
        while (updated) {
            updated = false;
            while (cur_match_cnt == shd_match_cnt && start < slen) {
                if (end - start < mlen) {
                    mlen = end - start;
                    ps = start, pe = end;
                }
                
                char ch = S[start];
                // whether current char is critical for matching
                // if so it could not be omitted
                if (cur_cnt[ch] - 1 < shd_cnt[ch]) break;

                updated = true;
                cur_cnt[ch]--;
                start++;
            }
            
            if (end < slen) {
                updated = true;
                char ch = S[end++];
                
                if (++cur_cnt[ch] == shd_cnt[ch]) { // using strict equal
                    cur_match_cnt++;
                }
            }
        }
        return S.substr(ps, pe - ps);
    }
};

"滑动窗口"...

重新写感觉不行啊

class Solution {
public:
    string minWindow(string s, string t) {
        int cnt[128] = {0};
        int distinct = 0;
        int slen = s.size();
        int tlen = t.size();
        
        for (int i=0; i<tlen; i++) {
            if (!cnt[t[i]]++) {
                distinct++;
            }
        }
        int matched = 0;
        int mcnt[128] = {0};
        int p=0;
        int q=0;
        
        int minlen = INT_MAX;
        int minstart = 0;
        
        while (q < slen) {
            char ch = s[q];
            if (cnt[ch]) {
                if (++mcnt[ch] == cnt[ch]) {
                    matched++;
                }
            }
            q++;
            if (matched != distinct) {
                continue;
            }
            while (p < q) {
                if (!cnt[s[p]]) {
                    p++;
                    continue;
                }
                if (mcnt[s[p]] > cnt[s[p]]) {
                    mcnt[s[p]]--;
                    p++;
                } else {
                    break;
                }
            }
            
            if (q - p < minlen) {
                minstart = p;
                minlen = q - p;
            }
        }
        minlen = distinct == matched ? minlen : 0;
        return s.substr(minstart, minlen);
    }
};