【算法思想·数组】滑动窗口终极模板

Captain823Jack

已于 2024-08-18 23:43:03 修改

阅读量278

点赞数 15

文章标签：算法

于 2024-08-18 18:45:22 首次发布

本文链接：https://blog.csdn.net/Captain823Jack/article/details/141303197

版权

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 条件是存在重复元素，换句话说收缩完成后一定保证窗口中没有重复嘛。

Captain823Jack

关注

15
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
【算法思想·数组】滑动窗口终极模板

滑动窗口本身思路上讲并不复杂，无非是left和right两个指针构建起一个动态window，再根据数据处理需要扩大或缩小窗口。但很多时候我们写滑动窗口总是难以尽善尽美，关键就在于对细节的把控，尤其是对窗口边界值处理不当和窗口变化机制的理解不够本文参考labuladong算法小抄[2、滑动窗口基本框架这个算法技巧的时间复杂度是 O(N)，比字符串暴力算法要高效得多。这两个...处的操作分别是扩大和缩小窗口的更新操作，等会你会发现它们操作是完全对称的。
复制链接

扫一扫