刷题记录 HOT100 子串-2：239. 滑动窗口最大值

题目：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

示例 2：

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

提示：

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104
• 1 <= k <= nums.length

一、模式识别

固定长度滑窗

方法一：堆排序

维护一个大小为k的堆，不断在栈顶找最大值

方法二：双端单调队列

维护一个栈顶位置在滑窗内的双端单调队列，在队列顶部找最大值

方法三：分块子串

以k为周期，k的倍数为节点，预处理计算出数组周期内的前缀最大值和后缀最大值，

每一个大小为k的窗口如果不与周期k重合必然横跨两个k周期，

则此时分别找滑窗头部的后缀最大值和滑窗尾部的前缀最大值便可以覆盖到整个滑窗找到整个滑窗的最大值

二、代码实现

1.堆排序

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        if k >= n: return [max(nums)]
        hp = [(-nums[i], i) for i in range(k)]
        heapq.heapify(hp)
        ans = [-hp[0][0]]
        for i in range(k, n):
            heapq.heappush(hp, (-nums[i], i))
            while hp[0][1] <= i - k: heapq.heappop(hp)
            ans.append(-hp[0][0])
        return ans

2.双端单调队列

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        n = len(nums)
        if k >= n: return [max(nums)]
        que = collections.deque()
        ans = [0] * (n - k + 1)
        for i, num in enumerate(nums):
            while que and nums[que[-1]] < num: que.pop()
            que.append(i)
            while que[0] <= i - k: que.popleft()
            if i >= k - 1: ans[i - k + 1] = nums[que[0]]
        return ans

3.分块子串 

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