1、概述
滑动窗口本身思路上讲并不复杂,无非是left和right两个指针构建起一个动态window,再根据数据处理需要扩大或缩小窗口。
但很多时候我们写滑动窗口总是难以尽善尽美,关键就在于对细节的把控,尤其是对窗口边界值处理不当和窗口变化机制的理解不够
本文参考labuladong算法小抄[我写了首诗,把滑动窗口算法变成了默写题]
2、滑动窗口基本框架
/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
// c 是将移入窗口的字符
char c = s[right];
// 增大窗口
right++;
// 进行窗口内数据的一系列更新
...
/*** debug 输出的位置 ***/
printf("window: [%d, %d)\n", left, right);
/********************/
// 判断左侧窗口是否要收缩
while (window needs shrink) {
// d 是将移出窗口的字符
char d = s[left];
// 缩小窗口
left++;
// 进行窗口内数据的一系列更新
...
}
}
}
这个算法技巧的时间复杂度是 O(N),比字符串暴力算法要高效得多。
这两个...
处的操作分别是扩大和缩小窗口的更新操作,等会你会发现它们操作是完全对称的。
3、一个滑窗框架,秒杀leetcode四题(1hard / 3mid)
76. 最小覆盖子串
给你一个字符串 s
、一个字符串 t
。返回 s
中涵盖 t
所有字符的最小子串。如果 s
中不存在涵盖 t
所有字符的子串,则返回空字符串 ""
。
注意:
- 对于
t
中重复字符,我们寻找的子字符串中该字符数量必须不少于t
中该字符数量。 - 如果
s
中存在这样的子串,我们保证它是唯一的答案。
示例 1:
输入:s = "ADOBECODEBANC", t = "ABC" 输出:"BANC" 解释:最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
示例 2:
输入:s = "a", t = "a" 输出:"a" 解释:整个字符串 s 是最小覆盖子串。
示例 3:
输入: s = "a", t = "aa" 输出: "" 解释: t 中两个字符 'a' 均应包含在 s 的子串中, 因此没有符合条件的子字符串,返回空字符串。
提示:
m == s.length
n == t.length
1 <= m, n <= 105
s
和t
由英文字母组成
【python 解法】
class Solution:
def minWindow(self, s: str, t: str) -> str:
'''
数据结构:字典
思路:
1、构造window和need两个字典
2、滑动窗口:外层r遍历s,内层满足need则l右滑
3、通过valid来判定是否窗口内满足target
'''
window = {}
need = {}
# 确定t中每个字母所需数量,用need来表示
for c in t:
need[c] = need.get(c, 0) + 1
# l和r构成window,start和end则作为结果备选
l = r = 0
start, end = 0, len(s)+1
# valid用以判断window内值是否满足need所需
valid = 0
while r < len(s):
c = s[r]
if c in need:
window[c] = window.get(c, 0) + 1
# 当window中某个字母满足need中对应字母数量则valid+1
if window[c] == need[c]:
valid += 1
# 当window中所有字母都满足need则开始收缩window左边界
while valid == len(need):
if r - l < end - start:
# 承接窗口两侧的值
start, end = l, r
tmp_c = s[l]
l += 1
# 由于左窗口收紧,需判断漏出去那个字母在不在need中
if tmp_c in need:
window[tmp_c] = window.get(tmp_c) - 1
if window[tmp_c] < need[tmp_c]:
valid -= 1
r += 1
return s[start:end+1] if end != len(s)+1 else ''
【反例】暴力解法导致timeout
class Solution:
def minWindow(self, s: str, t: str) -> str:
def is_in_str(tmp_str: str, tar: str) -> bool:
# 从'A'到'z',加上中间6个字符,共计58个字符
table = [0] * 58
for c in tmp_str:
table[ord(c) - ord('A')] += 1
for c in tar:
table[ord(c) - ord('A')] -= 1
for i in table:
if i < 0:
return False
return True
l = r = 0
size = len(s)
res = '!' * (size+1)
while r <= size:
# 判断窗口中每个字母是否符合need要求,多余无关字母也参与了判断
while is_in_str(s[l: r], t):
tmp_str = s[l: r]
res = tmp_str if len(tmp_str) < len(res) else res
l += 1
r += 1
return '' if len(res) == size+1 else res
【算法思路】
1、我们在字符串S
中使用双指针中的左右指针技巧,初始化left = right = 0
,把索引左闭右开区间[left, right)
称为一个「窗口」。
PS:理论上你可以设计两端都开或者两端都闭的区间,但设计为左闭右开区间是最方便处理的。因为这样初始化
left = right = 0
时区间[0, 0)
中没有元素,但只要让right
向右移动(扩大)一位,区间[0, 1)
就包含一个元素0
了。如果你设置为两端都开的区间,那么让right
向右移动一位后开区间(0, 1)
仍然没有元素;如果你设置为两端都闭的区间,那么初始区间[0, 0]
就包含了一个元素。这两种情况都会给边界处理带来不必要的麻烦。
2、我们先不断地增加right
指针扩大窗口[left, right)
,直到窗口中的字符串符合要求(包含了T
中的所有字符)。
3、此时,我们停止增加right
,转而不断增加left
指针缩小窗口[left, right)
,直到窗口中的字符串不再符合要求(不包含T
中的所有字符了)。同时,每次增加left
,我们都要更新一轮结果。
4、重复第 2 和第 3 步,直到right
到达字符串S
的尽头。
这个思路其实也不难,第 2 步相当于在寻找一个「可行解」,然后第 3 步在优化这个「可行解」,最终找到最优解,也就是最短的覆盖子串。左右指针轮流前进,窗口大小增增减减,窗口不断向右滑动,这就是「滑动窗口」这个名字的来历。
下面画图理解一下,needs
和window
相当于计数器,分别记录T
中字符出现次数和「窗口」中的相应字符的出现次数。
初始状态:
增加right
,直到窗口[left, right)
包含了T
中所有字符:
现在开始增加left
,缩小窗口[left, right)
:
直到窗口中的字符串不再符合要求,left
不再继续移动:
之后重复上述过程,先移动right
,再移动left
…… 直到right
指针到达字符串S
的末端,算法结束。
如果你能够理解上述过程,恭喜,你已经完全掌握了滑动窗口算法思想。现在我们来看看这个滑动窗口代码框架怎么用:
首先,初始化window
和need
两个哈希表,记录窗口中的字符和需要凑齐的字符:
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
然后,使用left
和right
变量初始化窗口的两端,不要忘了,区间[left, right)
是左闭右开的,所以初始情况下窗口没有包含任何元素:
int left = 0, right = 0;
int valid = 0;
while (right < s.size()) {
// 开始滑动
}
其中valid
变量表示窗口中满足need
条件的字符个数,如果valid
和need.size
的大小相同,则说明窗口已满足条件,已经完全覆盖了串T
。
现在开始套模板,只需要思考以下四个问题:
1、当移动right
扩大窗口,即加入字符时,应该更新哪些数据?
2、什么条件下,窗口应该暂停扩大,开始移动left
缩小窗口?
3、当移动left
缩小窗口,即移出字符时,应该更新哪些数据?
4、我们要的结果应该在扩大窗口时还是缩小窗口时进行更新?
如果一个字符进入窗口,应该增加window
计数器;如果一个字符将移出窗口的时候,应该减少window
计数器;当valid
满足need
时应该收缩窗口;应该在收缩窗口的时候更新最终结果。
下面是完整代码:
string minWindow(string s, string t) {
unordered_map<char, int> need, window;
for (char c : t) need[c]++;
int left = 0, right = 0;
int valid = 0;
// 记录最小覆盖子串的起始索引及长度
int start = 0, len = INT_MAX;
while (right < s.size()) {
// c 是将移入窗口的字符
char c = s[right];
// 扩大窗口
right++;
// 进行窗口内数据的一系列更新
if (need.count(c)) {
window[c]++;
if (window[c] == need[c])
valid++;
}
// 判断左侧窗口是否要收缩
while (valid == need.size()) {
// 在这里更新最小覆盖子串
if (right - left < len) {
start = left;
len = right - left;
}
// d 是将移出窗口的字符
char d = s[left];
// 缩小窗口
left++;
// 进行窗口内数据的一系列更新
if (need.count(d)) {
if (window[d] == need[d])
valid--;
window[d]--;
}
}
}
// 返回最小覆盖子串
return len == INT_MAX ?
"" : s.substr(start, len);
}
需要注意的是,当我们发现某个字符在window
的数量满足了need
的需要,就要更新valid
,表示有一个字符已经满足要求。而且,你能发现,两次对窗口内数据的更新操作是完全对称的。
当valid == need.size()
时,说明T
中所有字符已经被覆盖,已经得到一个可行的覆盖子串,现在应该开始收缩窗口了,以便得到「最小覆盖子串」。
移动left
收缩窗口时,窗口内的字符都是可行解,所以应该在收缩窗口的阶段进行最小覆盖子串的更新,以便从可行解中找到长度最短的最终结果。
至此,应该可以完全理解这套框架了,滑动窗口算法又不难,就是细节问题让人烦得很。以后遇到滑动窗口算法,你就按照这框架写代码,保准没有 bug,还省事儿。
567. 字符串的排列
【python 解法】
class Solution:
def checkInclusion(self, s1: str, s2: str) -> bool:
'''
数据结构:字典
思路:
1、构建window和need两个字典
2、双指针法:r外层遍历s2,直到s2右边界停下,
l内层遍历直到window长度大于s1长度即跳出循环
3、每满足s1中的一个字母则valid += 1
'''
window = {}
need = {}
for c in s1:
need[c] = need.get(c, 0) + 1
l = r = 0
valid = 0
while r < len(s2):
c = s2[r]
if c in need:
window[c] = window.get(c, 0) + 1
if window[c] == need[c]:
valid += 1
while valid == len(need):
if r - l + 1 == len(s1):
return True
tmp_c = s2[l]
l += 1
if tmp_c in need:
window[tmp_c] = window.get(tmp_c) - 1
if window[tmp_c] < need[tmp_c]:
valid -= 1
r += 1
return False
438. 找到字符串中所有字母异位词
【python 解法】
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
'''
数据结构:字典
思路:
1、构建window和need两个字典
2、双指针法:r遍历s,l遍历到window长度不为len(p)时跳出循环
3、用valid记录p中每一个字母的满足情况
'''
window = {}
need = {}
for c in p:
need[c] = need.get(c, 0) + 1
l = r = 0
valid = 0
res = []
while r < len(s):
c = s[r]
if c in need:
window[c] = window.get(c, 0) + 1
if window[c] == need[c]:
valid += 1
while valid == len(need):
if r - l + 1 == len(p):
res.append(l)
tmp_c = s[l]
l += 1
if tmp_c in need:
window[tmp_c] = window.get(tmp_c) - 1
if window[tmp_c] < need[tmp_c]:
valid -= 1
r += 1
return res
3. 无重复字符的最长子串
【python 解法】
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
'''
数据结构:字典
思路:
1、因题目要的是最长不含重复字符的子串,构建window字典即可,无需构建need
2、双指针法
3、不用判断valid,当window[c]>1即说明window中字符重复,可以收缩左侧窗口
'''
if not s:
return 0
window = dict()
l = r = 0
res_len = 0
while r < len(s):
# 每遍历一个字母就将其放入window中
c = s[r]
window[c] = window.get(c, 0) + 1
# 一旦window中某个字母数量大于1,则收缩左侧窗口
while window[c] > 1:
tmp_c = s[l]
l += 1
window[tmp_c] -= 1
# 比较当前窗口内子串长度和历史子串长度,右移窗口
res_len = max(res_len, r-l+1)
r += 1
return res_len
唯一需要注意的是,在哪里更新结果res
呢?我们要的是最长无重复子串,哪一个阶段可以保证窗口中的字符串是没有重复的呢?
这里和之前不一样,要在收缩窗口完成后更新res
,因为窗口收缩的 while 条件是存在重复元素,换句话说收缩完成后一定保证窗口中没有重复嘛。