数据结构与算法——一个模板手撕滑动窗

一、滑动窗模板

参考自leetcode

def solution(s, t):
	# hash_记录t中字符出现的次数，window记录窗口中相应字符出现的次数
	hash_, window = {}, {}
	# 根据t构建hash_字典
	for c in t:
	    hash_[c] = hash_.get(c, 0) + 1
	# 初始化窗口左右边界，左闭右开区间 [left, right)
	left, right = 0, 0
	# valid表示窗口中满足要求的字符的个数
	valid = 0
	
	while right < len(s):
		# c是将移入窗口的字符
		c = s[right]
		# 窗口右移
		right += 1
		# 对窗口内数据进行更新
		...
		
		# 判断窗口是否需要收缩
		while (condition to shrink window):
			# d是将移除窗口的字符
			d = s[left]
			# 左移窗口
			left += 1
			# 窗口内数据更新
			...

二、无重复字符的最长子串

此题为leetcode第3题
思路：我们设置两个指针left和right，分别指向窗口window的左右边界。我们不断向右扩展右边界right，然后用一个哈希表计数出现的字符。如果当前字符出现次数大于等于2次，说明和前面的有重复了，我们需要收缩窗口的左边界，一直收缩到left所指字符出现的次数只有1次。这个时候更新一下窗口的最大长度。不断重复这个过程，直到循环到字符串结尾，返回窗口长度最大值。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if len(s) <= 1:
            return len(s)
        window = {}
        left, right = 0, 0
        res = 0
        while right < len(s):
            c = s[right]
            right += 1
            # 窗口数据更新
            window[c] = window.get(c, 0) + 1
            # 判断窗口是否收缩
            while window[c] > 1:
                d = s[left]
                left += 1
                window[d] -= 1
            res = max(res, right - left)
        return res

三、最小覆盖子串

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        if len(s) < len(t):
            return ''
        
        hash_, window = {}, {}
        for c in t:
            hash_[c] = hash_.get(c, 0) + 1
        left, right = 0, 0
        valid = 0
        INT_MAX = len(s) + 1
        start, length = 0, INT_MAX    # 记录最长子串的起始索引及其长度
        
        while right < len(s):
            c = s[right]
            right += 1
            # 更新窗口数据
            if c in hash_:
                window[c] = window.get(c, 0) + 1
                if window[c] == hash_[c]:
                    valid += 1
            # 判断窗口是否收缩
            while valid == len(hash_):
                # 更新一下结果
                if right - left < length:
                    start = left
                    length = right - left
                # 收缩left
                d = s[left]
                left += 1
                if d in hash_:
                    if window[d] == hash_[d]:
                        valid -= 1
                    window[d] -= 1
        if length == INT_MAX:   # 遍历完后仍然没有包含t的子串
            return ''
        else:
            return s[start:start+length]

四、找到字符串中所有字母异位词

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        hash_, window = {}, {}
        for c in p:
            hash_[c] = hash_.get(c, 0) + 1
        left, right = 0, 0
        valid = 0
        res = []
        
        while right < len(s):
            c = s[right]        # c是移入窗口的字符
            right += 1          # 右移窗口
            # 对窗口内数据进行更新
            if c in hash_:  # 如果c在p中
                # 更新window哈希表
                window[c] = window.get(c, 0) + 1
                # 如果c在window的个数等于在p中的个数
                if window[c] == hash_[c]:
                    valid += 1
            
            # 判断窗口是否要收缩
            while right - left >= len(p):
                # 如果匹配上了p
                if valid == len(hash_):
                    res.append(left)
                d = s[left]     # d是要移除窗口的字符
                left += 1       # 左移窗口
                # 对窗口内数据更新
                if d in hash_:  # 如果d在p中
                    if window[d] == hash_[d]:
                        valid -= 1
                    window[d] -= 1
        return res

五、字符串的排列

class Solution:
    def checkInclusion(self, t: str, s: str) -> bool:
        hash_, window = {}, {}
        for c in t:
            hash_[c] = hash_.get(c, 0) + 1
        left, right = 0, 0
        valid = 0
        while right < len(s):
            c = s[right]
            right += 1
            # 滑动窗更新数据
            if c in hash_:
                window[c] = window.get(c, 0) + 1
                if window[c] == hash_[c]:
                    valid += 1
            # 判断是否收缩滑动窗
            while right - left >= len(t):
                if valid == len(hash_):
                    return True
                d = s[left]
                left += 1
                # 滑动窗数据更新
                if d in window:
                    if window[d] == hash_[d]:
                        valid -= 1
                    window[d] -= 1
        return False