栈和队列6——滑动窗口最大值

题目

滑动窗口最大值

题目说明

给你一个整数数组 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

示例 2：

输入：nums = [1], k = 1
输出：[1]

提示：

• $1\le nums.length\le 105$
• $-104\le nums[i]\le 104$
• $1\le k\le nums.length$

题目背景

对于每个滑动窗口，我们可以使用 $O(k)$ 的时间遍历其中的每一个元素，找出其中的最大值。对于长度为 $n$ 的数组 $\text{nums}$ 而言，窗口的数量为 $n-k+1$，因此该算法的时间复杂度为 $O((n-k+1)k)=O(nk)$，会超出时间限制，因此我们需要进行一些优化。

我们可以想到，对于两个相邻（只差了一个位置）的滑动窗口，它们共用着 $k-1$ 个元素，而只有 11 个元素是变化的。我们可以根据这个特点进行优化。

方法一：优先队列

思路与算法

对于「最大值」，我们可以想到一种非常合适的数据结构，那就是优先队列（堆），其中的大根堆可以帮助我们实时维护一系列元素中的最大值。

对于本题而言，初始时，我们将数组 $\text{nums}$ 的前$k$ 个元素放入优先队列中。每当我们向右移动窗口时，我们就可以把一个新的元素放入优先队列中，此时堆顶的元素就是堆中所有元素的最大值。然而这个最大值可能并不在滑动窗口中，在这种情况下，这个值在数组 $\text{nums}$ 中的位置出现在滑动窗口左边界的左侧。因此，当我们后续继续向右移动窗口时，这个值就永远不可能出现在滑动窗口中了，我们可以将其永久地从优先队列中移除。

我们不断地移除堆顶的元素，直到其确实出现在滑动窗口中。此时，堆顶元素就是滑动窗口中的最大值。为了方便判断堆顶元素与滑动窗口的位置关系，我们可以在优先队列中存储二元组 ($\text{num}$, $\text{index})$，表示元素 $\text{num}$在数组中的下标为 $\text{index}$。

代码

C++

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        priority_queue<pair<int, int>> q;
        for (int i = 0; i < k; ++i) {
            q.emplace(nums[i], i);
        }
        vector<int> ans = {q.top().first};
        for (int i = k; i < n; ++i) {
            q.emplace(nums[i], i);
            while (q.top().second <= i - k) {
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

Python3

class Solution:
   def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
       n = len(nums)
       # 注意 Python 默认的优先队列是小根堆
       q = [(-nums[i], i) for i in range(k)]
       heapq.heapify(q)

       ans = [-q[0][0]]
       for i in range(k, n):
           heapq.heappush(q, (-nums[i], i))
           while q[0][1] <= i - k:
               heapq.heappop(q)
           ans.append(-q[0][0])
       
       return ans

复杂度分析

时间复杂度：O(n \log n)O(nlogn)，其中 nn 是数组 \textit{nums}nums 的长度。在最坏情况下，数组 \textit{nums}nums 中的元素单调递增，那么最终优先队列中包含了所有元素，没有元素被移除。由于将一个元素放入优先队列的时间复杂度为 O(\log n)O(logn)，因此总时间复杂度为 O(n \log n)O(nlogn)。

空间复杂度：O(n)O(n)，即为优先队列需要使用的空间。这里所有的空间复杂度分析都不考虑返回的答案需要的 O(n)O(n) 空间，只计算额外的空间使用。

方法二：单调队列

思路与算法

我们可以顺着方法一的思路继续进行优化。

由于我们需要求出的是滑动窗口的最大值，如果当前的滑动窗口中有两个下标 $i$ 和 $j$，其中 $i$在 $j$ 的左侧（$i<j$），并且 $i$对应的元素不大于 $j$ 对应的元素（$\text{nums}[i]\le \text{nums}[j]$），那么会发生什么呢？

当滑动窗口向右移动时，只要 $i$还在窗口中，那么 $j$一定也还在窗口中，这是 $i$在 $j$ 的左侧所保证的。因此，由于 $\text{nums}[j]$ 的存在，$\text{nums}[i]$ 一定不会是滑动窗口中的最大值了，我们可以将 $\text{nums}[i]$ 永久地移除。

因此我们可以使用一个队列存储所有还没有被移除的下标。在队列中，这些下标按照从小到大的顺序被存储，并且它们在数组 $\text{nums}$ 中对应的值是严格单调递减的。因为如果队列中有两个相邻的下标，它们对应的值相等或者递增，那么令前者为 $i$，后者为 jj，就对应了上面所说的情况，即 $\text{nums}[i]$ 会被移除，这就产生了矛盾。

当滑动窗口向右移动时，我们需要把一个新的元素放入队列中。为了保持队列的性质，我们会不断地将新的元素与队尾的元素相比较，如果前者大于等于后者，那么队尾的元素就可以被永久地移除，我们将其弹出队列。我们需要不断地进行此项操作，直到队列为空或者新的元素小于队尾的元素。

由于队列中下标对应的元素是严格单调递减的，因此此时队首下标对应的元素就是滑动窗口中的最大值。但与方法一中相同的是，此时的最大值可能在滑动窗口左边界的左侧，并且随着窗口向右移动，它永远不可能出现在滑动窗口中了。因此我们还需要不断从队首弹出元素，直到队首元素在窗口中为止。

为了可以同时弹出队首和队尾的元素，我们需要使用双端队列。满足这种单调性的双端队列一般称作「单调队列」。

C++

class Solution {
public:
   vector<int> maxSlidingWindow(vector<int>& nums, int k) {
       int n = nums.size();
       deque<int> q;
       for (int i = 0; i < k; ++i) {
           while (!q.empty() && nums[i] >= nums[q.back()]) {
               q.pop_back();
           }
           q.push_back(i);
       }

       vector<int> ans = {nums[q.front()]};
       for (int i = k; i < n; ++i) {
           while (!q.empty() && nums[i] >= nums[q.back()]) {
               q.pop_back();
           }
           q.push_back(i);
           while (q.front() <= i - k) {
               q.pop_front();
           }
           ans.push_back(nums[q.front()]);
       }
       return ans;
   }
};

python3

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        q = collections.deque()
        for i in range(k):
            while q and nums[i] >= nums[q[-1]]:
                q.pop()
            q.append(i)

        ans = [nums[q[0]]]
        for i in range(k, n):
            while q and nums[i] >= nums[q[-1]]:
                q.pop()
            q.append(i)
            while q[0] <= i - k:
                q.popleft()
            ans.append(nums[q[0]])
        
        return ans

复杂度分析

• 时间复杂度：$O(n)$，其中 nn 是数组 $\text{nums}$ 的长度。每一个下标恰好被放入队列一次，并且最多被弹出队列一次，因此时间复杂度为 $O(n)$。

• 空间复杂度：$O(k)$。与方法一不同的是，在方法二中我们使用的数据结构是双向的，因此「不断从队首弹出元素」保证了队列中最多不会有超过 $k+1$个元素，因此队列使用的空间为 $O(k)$。

方法三：分块 + 预处理

思路与算法

除了基于「随着窗口的移动实时维护最大值」的方法一以及方法二之外，我们还可以考虑其他有趣的做法。

我们可以将数组 $\text{nums}$从左到右按照 $k$ 个一组进行分组，最后一组中元素的数量可能会不足 $k$ 个。如果我们希望求出 $\text{nums}[i]$到 $\text{nums}[i+k-1]$ 的最大值，就会有两种情况：

• 如果 $i$ 是 $k$ 的倍数，那么 $\text{nums}[i]$到 $\text{nums}[i+k-1]$ 恰好是一个分组。我们只要预处理出每个分组中的最大值，即可得到答案；

• 如果 $i$不是 $k$ 的倍数，那么 $\text{nums}[i]$ 到 $\text{nums}[i+k-1]$ 会跨越两个分组，占有第一个分组的后缀以及第二个分组的前缀。假设 $j$ 是 $k$ 的倍数，并且满足 $i<j\le i+k-1$，那么 $\text{nums}[i]$到 $\text{nums}[j-1]$ 就是第一个分组的后缀，$\text{nums}[j]$ 到 $\text{nums}[i+k-1]$就是第二个分组的前缀。如果我们能够预处理出每个分组中的前缀最大值以及后缀最大值，同样可以在 $O(1)$ 的时间得到答案。

因此我们用 $\text{prefixMax}[i]$ 表示下标 $i$ 对应的分组中，以 $i$ 结尾的前缀最大值；$\text{suffixMax}[i]$ 表示下标 $i$对应的分组中，以 $i$开始的后缀最大值。它们分别满足如下的递推式

$$prefixMax[i]=\{\begin{array}{ll}nums[i],& \text{i 是 k 的倍数}\\ maxprefixMax[i-1],nums[i]& \text{i 不是 k 的倍数}\end{array}$$
​
以及

suffixMax [ i ] = { n u m s [ i ] , i+1   是   k   的倍数 , max ⁡ { suffixMax [ i + 1 ] , nums [ i ] } , i + 1 不是 k 的倍数 \textit{suffixMax}[i]=\begin{cases} nums[i], &\textit{i+1 是 k 的倍数}, & \quad \\ \max\{ \textit{suffixMax}[i+1], \textit{nums}[i] \}, & \quad i+1 不是 k 的倍数 \end{cases} suffixMax[i]={nums[i],max{suffixMax[i+1],nums[i]},​i+1 是 k 的倍数,i+1不是k的倍数​

需要注意在递推 $\text{suffixMax}[i]$ 时需要考虑到边界条件 $\text{suffixMax}[n-1]=\text{nums}[n-1]$，而在递推 $\text{prefixMax}[i]$ 时的边界条件 $\text{prefixMax}[0]=\text{nums}[0]$恰好包含在递推式的第一种情况中，因此无需特殊考虑。

在预处理完成之后，对于 $\text{nums}[i]$ 到 $\text{nums}[i+k-1]$ 的所有元素，如果 $i$不是 $k$的倍数，那么窗口中的最大值为 $\text{suffixMax}[i]$ 与 $\text{prefixMax}[i+k-1]$中的较大值；如果 $i$ 是$k$ 的倍数，那么此时窗口恰好对应一整个分组，$\text{suffixMax}[i]$ 和 $\text{prefixMax}[i+k-1]$都等于分组中的最大值，因此无论窗口属于哪一种情况，
m a x = { s u f f i x M a x [ i ] , p r e f i x M a x [ i + k − 1 ] } max = \left\{suffixMax[i],prefixMax[i+k−1]\right\} max={suffixMax[i],prefixMax[i+k−1]}

即为答案。

这种方法与稀疏表（Sparse Table）非常类似，感兴趣的读者可以自行查阅资料进行学习。

代码

c++

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> prefixMax(n), suffixMax(n);
        for (int i = 0; i < n; ++i) {
            if (i % k == 0) {
                prefixMax[i] = nums[i];
            }
            else {
                prefixMax[i] = max(prefixMax[i - 1], nums[i]);
            }
        }
        for (int i = n - 1; i >= 0; --i) {
            if (i == n - 1 || (i + 1) % k == 0) {
                suffixMax[i] = nums[i];
            }
            else {
                suffixMax[i] = max(suffixMax[i + 1], nums[i]);
            }
        }

        vector<int> ans;
        for (int i = 0; i <= n - k; ++i) {
            ans.push_back(max(suffixMax[i], prefixMax[i + k - 1]));
        }
        return ans;
    }
};

python3

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        prefixMax, suffixMax = [0] * n, [0] * n
        for i in range(n):
            if i % k == 0:
                prefixMax[i] = nums[i]
            else:
                prefixMax[i] = max(prefixMax[i - 1], nums[i])
        for i in range(n - 1, -1, -1):
            if i == n - 1 or (i + 1) % k == 0:
                suffixMax[i] = nums[i]
            else:
                suffixMax[i] = max(suffixMax[i + 1], nums[i])

        ans = [max(suffixMax[i], prefixMax[i + k - 1]) for i in range(n - k + 1)]
        return ans

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。我们需要 $O(n)$的时间预处理出数组 $\text{prefixMax}$，$\text{suffixMax}$ 以及计算答案。

• 空间复杂度：$O(n)$，即为存储 $\text{prefixMax}$和 $\text{suffixMax}$需要的空间。

​