简单滑动窗口

前言

今天重新做了几道滑动窗口的题，被各种细节折磨。滑动窗口本身的思想非常简单，可一写起来对细节要求非常高，边界少加1 或 窗口长度计算错误等等，故写篇文章总结一下模板和思路。

---

理解

这里的难点在于抽象，将所想的抽象成程序的操作。
我们将滑动窗口写成左闭右开的形式，这很重要，我一开始以闭区间进行操作，最后边界的处理变得很复杂，有很多细节，而左闭右开可以减少一些细节。
约定：窗口为 [left, right)
所以窗口长度：right - left
用两个值指向 left 和 right（双指针的思想）
我们先移动 right 等满足条件 再收缩 left
可以看到滑动窗口的时间复杂度是 $O(n)$ 的，似乎和遍历差不多，然而它能做到遍历无法做到的。

---

题目1

leetcode438

 给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。
 不考虑答案输出的顺序。
异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例：
输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

最容易想到二重循环， $O(n^2)$的时间复杂度
而用滑动窗口，可以看出这是一个定长的窗口。
left right 从 0 开始。
need 统计 p 的字母出现次数，window统计窗口的字母出现次数
为了不让每次比较都要遍历 need 我们用 valid 动态计算合格的字母个数。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        unordered_map<char, int> need, window;
        vector<int> res;
        int valid = 0;
        for (auto &x : p) {
            ++need[x];
        }
        int left(0), right(0), n = s.size();
        char temp;
        while (right < n) {
            temp = s[right];
            ++right;
            if (need.count(temp)) {
                if (++window[temp] == need[temp])
                    ++valid;
            }
            // 维护定长的窗口，长度超出则缩小左边界
            // 长度为 right - left
            while (right - left >= p.size()) {
                if (valid == need.size()) {
                    res.emplace_back(left);
                }
                temp = s[left];
                if (need.count(temp)) {
                    if (window[temp] == need[temp])
                        --valid;
                    --window[temp];
                }
                ++left;
            }
        }
        return res;
    }
};

---

题目2

leetcode76

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。
如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

示例1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

这题不成体系的编写将会出现非常多的细节问题，如果面试的时候就出了这类型的题，很有可能您的面试就因此失败了。
而成体系得编写最后往往只要十分钟，像我写的时候完全没有debug，提交上去就对了。
需要注意，这题的滑动窗口是不定长的。
这里唯一需要思考的就是 valid 的条件，
为了避免 valid 的重复计算，我们只有 need[temp] == window[temp] 时才增加 valid

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char, int> need, window;
        for (auto &x : t) 
            ++need[x];
        int left(0), right(0);
        int valid = 0, m = s.size(), n = t.size();
        int len = INT_MAX, index;
        char temp;
        while(right < m) {
            temp = s[right++];
            if (need.count(temp)) {
                if (need[temp] == ++window[temp])
                    ++valid;
            }
            while (valid == need.size()) {
                if (len > right - left) {
                    len = right - left;
                    index = left;
                }
                temp = s[left];
                if (need.count(temp)) {
                    if (need[temp] == window[temp])
                        --valid;
                    --window[temp];
                }
                ++left;
            }
        }
        return len == INT_MAX ? "" : s.substr(index, len);
    }
};

---

题目3

leetcode3

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例1：
输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

这题思路是只要不能往右了就说明有重复字符了，就一直往左缩小窗口，直到那个字符不在窗口里。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_set<char> pool;
        int n = s.size(), left = 0, right = 0;
        char temp;
        int mmax = 0;
        while (right < n) {
            temp = s[right++];
            while (pool.count(temp)) {
                pool.erase(s[left++]);
            }
            mmax = max(mmax, right - left);
            pool.insert(temp);
        }
        return max(mmax, right - left);
    }
};