算法（二十）数组之滑动窗口

leetcode

[hot] 239. 滑动窗口的最大值

题目

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。

示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]

解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

题解

直观思路解决问题，具体思路如下：

1. 构建目标数组res
2. 构建滑动窗口 indices，front为当前数组中最大的元素。
3. 赋值i -> [0, length)，进行遍历：
   1. 窗口滑动（i >= k），将indices.front放到res中；如果front不在当前滑动窗口中，indices需要弹出当前的front
   2. 维护index：indices中从front到back，必须是降序排列。
4. 遍历结束后需要把indices.front放入res，因为循环跳出时窗口的最后一个目标元素没有放入res中。

示例代码如下：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        deque<int> indices;

        for (int i = 0; i < nums.size(); ++i) {
            // 最大值弹出indices
            if (i >= k) {
                res.push_back(nums[indices.front()]);
                if (!indices.empty() && indices.front() <= i - k) {
                    indices.pop_front();
                }
            }

            // 保持indices倒序
            while (!indices.empty() && nums[i] >= nums[indices.back()]) {
                indices.pop_back();
            }

            indices.push_back(i);
        }

        // 不要漏掉最后一个元素！
        res.push_back(nums[indices.front()]);

        return res;
    }
};

复杂度

时间复杂度：$O(n)$
空间复杂度：$O(k)$，辅助deque的长度最长为k

[hot] 438. 找到字符串中所有字母异位词

题目

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。

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

示例 2:
输入:
s: "abab" p: "ab"
输出:
[0, 1, 2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

题解

滑动窗口解决问题，思路较为简单，直接给出示例代码：

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> res;
        vector<int> s_c(26, 0);
        vector<int> p_c(26, 0);
        int m = p.size();
        int n = s.size();
        if (m > n) {
            return res;
        }
        for (int i = 0; i < m; ++i) {
            ++s_c[s[i] - 'a'];
            ++p_c[p[i] - 'a'];
        }
        
        if (s_c == p_c) {
            res.emplace_back(0);
        }
        for (int i = m; i < n; ++i) {
            --s_c[s[i -m] - 'a'];
            ++s_c[s[i] - 'a'];
            if (s_c == p_c) {
                res.emplace_back(i - m + 1);
            }
        }

        return res;
    }
};

复杂度

时间复杂度：$O(n)$
空间复杂度：$O(constant)$