最小覆盖子串-滑动窗口

链接: 最小覆盖字串.

import collections
class Solution:
    def minWindow(self, s: str, t: str) -> str:
        need = collections.defaultdict(int)
        start = 0
        size = float('inf')
        for letter in t:
            need[letter] += 1
        count = len(t)

        win_l, win_r = 0, 0
        while win_r < len(s):
            cur_letter = s[win_r]
            need[s[win_r]] -= 1
            if need[s[win_r]] > 0:
                count -= 1
            elif need[s[win_r]] == 0:
                count -= 1

                if count == 0:
                    while win_l < len(s) and need[s[win_l]] + 1 <= 0:
                        need[s[win_l]] += 1
                        win_l += 1
                    if size > win_r - win_l + 1:
                        size = win_r - win_l + 1
                        start = win_l
                    if win_l != len(s) - 1:
                        need[s[win_l]] += 1
                        win_l += 1
                        count += 1

            win_r += 1
        return s[start:start + size] if size != float('inf') else ""

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char,int> need;
        int start = 0;
        int size = pow(10,5);
        for(auto letter : t){
            if(need.find(letter) != need.end()){
                need[letter] ++;
            }
            else{
                need[letter] = 1;
            }
        }
        int count = t.size();
        int sz= s.size();
        int win_l = 0, win_r = 0;
        while(win_r < sz){
            if(need.find(s[win_r]) != need.end()){
                need[s[win_r]] --;
            }else{
                need[s[win_r]] = -1;
            }
            if(need[s[win_r]] == 0){
                -- count;
                if(count == 0){
                    while(win_l < sz && need[s[win_l]] + 1 <= 0){
                        ++ need[s[win_l]];
                        ++ win_l;
                    }
                    if(size > win_r - win_l + 1){
                        size = win_r - win_l + 1;
                        start = win_l;
                    }
                    if(win_l != sz - 1){
                        ++ need[s[win_l]];
                        ++ win_l;
                        ++ count;
                    }
                }

            }
            else if (need[s[win_r]] > 0){
                count --;
            }
            ++win_r;
        }
        return size != pow(10,5) ? s.substr(start, size) : "";
    }
};