【爆刷力扣-数组】滑动窗口

滑动窗口知识点

滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

【leetcode 29】长度最小子数组（示例）

实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
窗口的起始位置如何移动：如果当前窗口的值大于等于s了，窗口就要向前即i移动了（也就是该缩小了）。
窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针即j，也就是for循环里的索引。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)

【leetcode 904】水果成篮

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size();
        unordered_map<int, int> cnt;

        int left = 0, ans = 0;
        for (int right = 0; right < n; ++right) {
            ++cnt[fruits[right]];
            while (cnt.size() > 2) {
                auto it = cnt.find(fruits[left]);
                --it->second;
                if (it->second == 0) {
                    cnt.erase(it);
                }
                ++left;
            }
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};

【leetcode 76】最小覆盖子串

class Solution {
public:
    // ori: 记录目标字符串t中每个字符的出现次数
    // cnt: 记录当前滑动窗口中每个字符的出现次数
    unordered_map <char, int> ori, cnt;

    // 检查当前窗口是否包含了目标字符串t的所有字符
    bool check() {
        for (const auto &p: ori) {
            // 如果窗口中某个字符的数量少于目标数量，返回false
            if (cnt[p.first] < p.second) {
                return false;
            }
        }
        // 所有字符都满足条件，返回true
        return true;
    }

    string minWindow(string s, string t) {
        // 初始化ori哈希表，统计目标字符串t中每个字符的出现次数
        for (const auto &c: t) {
            ++ori[c];
        }

        int l = 0, r = -1;  // 左右指针，初始窗口为空
        int len = INT_MAX, ansL = -1, ansR = -1;  // 记录最小窗口的长度和左右边界

        // 右指针向右移动，扩展窗口
        while (r < int(s.size())) {
            // 右指针右移一位，并检查该字符是否在目标字符串t中
            if (ori.find(s[++r]) != ori.end()) {
                // 如果在目标字符串中，增加该字符在窗口中的计数
                ++cnt[s[r]];
            }
            // 检查当前窗口是否满足条件，并且左指针不超过右指针
            while (check() && l <= r) {
                // 如果当前窗口长度更短，更新最小窗口的信息
                if (r - l + 1 < len) {
                    len = r - l + 1;
                    ansL = l;
                }
                // 尝试收缩左边界，移除左指针指向的字符
                if (ori.find(s[l]) != ori.end()) {
                    // 如果该字符在目标字符串中，减少窗口中该字符的计数
                    --cnt[s[l]];
                }
                // 左指针右移，缩小窗口
                ++l;
            }
        }

        // 如果没有找到符合条件的窗口，返回空字符串；否则返回最小覆盖子串
        return ansL == -1 ? string() : s.substr(ansL, len);
    }
};