代码随想录训练营第五天|LeetCode 76 242 349 202 1

原来桶就是哈希，好的呢，今天的242就是桶，要是嫌占用空间大，那就用bool创建列表

有意思的是76 最小覆盖子串，不会做

最直接的思路是滑动窗口+边走边查+

那复杂度肯定就做不到O(m+n)，这样应该是O(mn)吧
 

class Solution(object):
    def minWindow(self, s, t):
        # 第一种方法：边查边走  最初要让整个dict_s先满足dict_t要求，再移动左窗口
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        min_len = 100000
        loc_l = loc_r = 0
        dict_t = dict()
        dict_s = dict()
        flag_satisfied = False

        for letter in t:
            dict_t[letter] = 1 if letter not in dict_t else dict_t[letter] + 1

        l = 0
        for r, letter in enumerate(s):
            dict_s[letter] = 1 if letter not in dict_s else dict_s[letter] + 1
            if r + 1 >= len(t):
                if not flag_satisfied:
                    flag_satisfied = self.check(dict_s, dict_t)
                if flag_satisfied:
                    while s[l] not in dict_t or (s[l] in dict_t and dict_s[s[l]] > dict_t[s[l]]):
                        dict_s[s[l]] -= 1
                        l += 1
                    if min_len > r - l + 1:
                        loc_l = l
                        loc_r = r
                        min_len = r - l + 1
            else:
                continue

        return s[loc_l: loc_r + 1] if flag_satisfied else ""

    def check(self, dict_s, dict_t):
        for letter in dict_t.keys():
            if letter not in dict_s or dict_s[letter] < dict_t[letter]:
                return False
        return True

然后看大佬的题解，O(m+n)，过阵子再回来敲一下可能更有收获

# 要求在O(m+n)时间内解决
class Solution(object):
    def minWindow2(self, s, t):
        # 第一种方法：边查边走  最初要让整个dict_s先满足dict_t要求，再移动左窗口
        """
        :type s: str
        :type t: str
        :rtype: str
        """
        min_len = 100000
        loc_l = loc_r = 0
        dict_t = dict()
        dict_s = dict()
        flag_satisfied = False

        for letter in t:
            dict_t[letter] = 1 if letter not in dict_t else dict_t[letter] + 1

        l = 0
        for r, letter in enumerate(s):
            dict_s[letter] = 1 if letter not in dict_s else dict_s[letter] + 1
            if r + 1 >= len(t):
                if not flag_satisfied:
                    flag_satisfied = self.check(dict_s, dict_t)
                if flag_satisfied:
                    while s[l] not in dict_t or (s[l] in dict_t and dict_s[s[l]] > dict_t[s[l]]):
                        dict_s[s[l]] -= 1
                        l += 1
                    if min_len > r - l + 1:
                        loc_l = l
                        loc_r = r
                        min_len = r - l + 1
            else:
                continue

        return s[loc_l: loc_r + 1] if flag_satisfied else ""

    def check(self, dict_s, dict_t):
        for letter in dict_t.keys():
            if letter not in dict_s or dict_s[letter] < dict_t[letter]:
                return False
        return True

    def minWindow(self, s, t):  # 第二种方法：走完再查
        ans = ""
        dict_t = dict()
        dict_s = dict()
        # 构建dict_t
        for letter in t:
            dict_t[letter] = dict_t.get(letter, 0) + 1

        cnt = 0  # 统计匹配上t中字符的个数
        l = 0
        for r, letter in enumerate(s):
            dict_s[letter] = dict_s.get(letter, 0) + 1
            if dict_t.get(letter, 0) and dict_s[letter] <= dict_t[letter]:
                cnt += 1
            while l <= r and dict_t.get(s[l], 0) < dict_s[s[l]]:
                dict_s[s[l]] -= 1
                l += 1
            if cnt == len(t):
                if ans == "" or len(ans) > r - l + 1:
                    ans = s[l: r + 1]

        return ans


if __name__ == '__main__':
    s = Solution()
    print(s.minWindow(s="a", t="b"))