leetcode 239-滑动窗口最大值

前言

对于每个滑动窗口，我们可以使用 $O(k)$ 的时间遍历其中的每一个元素，找出其中的最大值。对于长度为 $n$ 的数组 $nums$ 而言，窗口的数量为 $n-k+1$，因此该算法的时间复杂度为 $O((n-k+1)k)=O(nk)$，会超出时间限制，因此我们需要进行一些优化。
我们可以想到，对于两个相邻（只差了一个位置）的滑动窗口，它们共用着 $k-1$ 个元素，而只有 $1$ 个元素是变化的，我们可以根据这个特点进行优化。

方法一：优先队列

思路与算法

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

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

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

代码

class Solution{
public:
	vector<int> maxSlidingWindow(vector<int>& nums, int k){
		priority_queue<pair<int, int>> q;
		for(int i = 0; i < k; ++i){							//将nums的前k个元素放入优先队列中
			q.emplace(nums[i], i);
		}
		vector<int> ans = {q.top().first};					//将前k个元素的最大值放入结果列表
		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;
	}
};

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是 $nums$ 的长度。在最坏情况下，数组 $nums$ 中的元素单调递增，那么最终优先队列中包含了所有元素，没有元素被移除。由于将一个元素放入优先队列的时间复杂度为 $O(\log n)$，因此总时间复杂度为 $O(n\log n)$。
• 空间复杂度：KaTeX parse error: Expected 'EOF', got '}' at position 4: O(n}̲，即为优先队列需要使用的空间。

方法二：单调队列

思路与算法

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

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

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

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

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

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

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

代码

class Solution{
public:
	vector<int> maxSlidingWindow(vector<int>& nums, int k){
		deque<int> q;
		for(int i = 0; i <  k; ++i){							//将前k个元素放入队列中，保持严格单调递减
			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;
	}
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $nums$ 的长度。每一个下标恰好被放入队列一次，并且最多被弹出队列一次，因此时间复杂度为 $O(n)$。
• 空间复杂度：$O(k)$。与方法一不同的是，在方法二中我们使用的数据结构是双向的，因此 不断从队首弹出元素 保证了队列中最多不会有超过 $k+1$ 个元素。

方法三：分块 + 预处理

思路与算法

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

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

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

因此我们使用 $preifxMax[i]$ 表示下标 $i$ 对应的分组中，以 $i$ 结尾的前缀的最大值；$suffixMax[i]$ 表示下标 $i$ 对应的分组中，以 $i$ 开始的后缀最大值。它们分别满足如下的递推式。
p r e f i x M a x [ i ] = { n u m s [ i ] ， i 是 k 的倍数 max { p r e f i x M a x [ i − 1 ] , n u m s [ i ] } ， i 不是 k 的倍数 prefixMax[i]=\begin{cases} nums[i]，i 是 k 的倍数\\ \text{max}\{prefixMax[i-1], nums[i]\}，i 不是 k 的倍数\end{cases} prefixMax[i]={nums[i]，i是k的倍数max{prefixMax[i−1],nums[i]}，i不是k的倍数​
以及
s u f f i x M a x [ i ] = { n u m s [ i ] ， i + 1 是 k 的倍数 max { s u f f i x M a x [ i + 1 ] , n u m s [ i ] } ， i + 1 不是 k 的倍数 suffixMax[i]=\begin{cases} nums[i]，i+1 是 k 的倍数\\ \text{max}\{suffixMax[i+1], nums[i]\}，i+1 不是 k 的倍数\end{cases} suffixMax[i]={nums[i]，i+1是k的倍数max{suffixMax[i+1],nums[i]}，i+1不是k的倍数​
需要注意在递推 $suffixMax[i]$ 时需要考虑到边界条件 $suffixMax[n-1]=nums[n-1]$，而在递推 $prefixMax[i]$ 时，的边界条件 $prefixMax[0]=nums[0]$ 恰好包含在递推式的第一种情况中，因此无需特殊考虑。

在预处理完成后，对于 $nums[i]$ 到 $nums[i+k-1]$ 的所有元素：

• 如果 $i$ 不是 $k$ 的倍数，那么窗口中的最大值为 $suffixMax[i]$ 与 $prefixMax[i+k-1]$ 中的较大值；
• 如果 $i$ 是 $k$ 的倍数，那么此时窗口恰好对应一整个分组，$suffixMax[i]$ 与 $prefixMax[i+k-1]$ 都等于分组中的最大值

因此无论窗口属于哪一种情况， max { s u f f i x M a x [ i ] , p r e f i x M a x [ i + k − 1 ] } \text{max}\{suffixMax[i], prefixMax[i+k-1]\} max{suffixMax[i],prefixMax[i+k−1]} 都为答案。

这种方法与稀疏表十分类似。

代码

class Solution{
public:
	vector<int> maxSlidingWindow(vector<int>& nums, int k){
		vector<int> prefixMax(n), suffixMax(n);
		for(int i = 0; i < nums.size(); 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;
	}
};

复杂度分析

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