239.滑动窗口最大值暴力哈希表优化、双端队列、堆/优先队列三解！

最新推荐文章于 2024-12-01 22:12:06 发布

清风Python

最新推荐文章于 2024-12-01 22:12:06 发布

阅读量299

点赞数

文章标签：算法 python 数据结构 java leetcode

本文链接：https://blog.youkuaiyun.com/BreezePython/article/details/120648517

版权

239.滑动窗口最大值

https://leetcode-cn.com/problems/sliding-window-maximum/solution/239hua-dong-chuang-kou-zui-da-zhi-bao-li-z4q2/

难度：困难

题目

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

返回滑动窗口中的最大值。

提示：

1 <= nums.length <= 10 ^ 5
-10 ^ 4 <= nums[i] <= 10 ^ 4
1 <= k <= nums.length

示例

示例 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]

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

示例 4：
输入：nums = [9,11], k = 2
输出：[11]

示例 5：
输入：nums = [4,-2], k = 2
输出：[4]

分析

暴力解题

除非拿到题目，你一眼就能看到该用什么方法来解决，不然先尝试暴力也不失为一种方法。
首先如果我们想暴力解题，从零开始依次获取nums长度为K的子数组，然后求最大值。
由于1 <= K <= N 10 ^ 5 ,需要计算(N - K) * K，即N * K = 10 ^ 10次必然要超时。
那能否适当优化，使得暴力有通关的可能？
遍历数组N是没办法避免的，所以只能在长度为K的子数组获取最大值方面入手优化了。

首先，我们需要创建一个ret数组用于返回结果
之后，维护一个cur记录当前最大值
使用哈希表进行添加删除操作与查询操作，可以适当的压缩时间
当下标小于K- 1时，默认添加至r哈希表
若本次扫描的元素比cur大时，更新cur，然后将cur加入ret中
此时，我们该删除滑窗左边界的值了，若左边界删除后元素 == 0，则删掉这个键
如果左边界的值等于cur，则需要重新扫描一次哈希表求最大值
最终返回ret

通过上面的适当优化，我们可以压线通关。至于复杂度只能说在N * K的基础上略有缩减，且跟用例有关

时间复杂度：最优复杂度，即nums为递增数组，则复杂度为O(N),最坏为O(NK)
空间复杂度： O(K)

双端队列

暴力解题中我们使用了哈希表和临时变量来每次更新最大值，有没有更为简洁的办法呢？
大家如果之前做过 739.每日温度 这道题目，就会有单调栈的这个思路了，唯一不同的是，这道题目固定了长度K，所以单纯使用栈不行了，替换成双端队列即可。

我们创建一个双端队列q ,以及待返回的数组ret
在遍历数组的过程中，将元素添加至队列q中，当然添加不是无条件的
当队列不为空，且队尾元素比当前遍历的元素小时，队尾出队
当对列q[0] 下标小于等于 i - k 时，表示滑窗左边界溢出了，我们需要队首出队
执行完3 、 4 步后，q[0]为当前队列最大的值，将nums[q[0]]加入ret
最终返回ret即可

时间复杂度： O(N)
空间复杂度： O(K)

堆/优先队列

看到K个最大/小、前K个等包含K这个关键字的时候，其实我们应该第一时间想到堆这个操作。
之前整理过关于K的文章： K个数、K个点、K个元素，3K堆排序，类比同类三解题！
同样的，这道题我们可以将上面的双端队列替换为优先队列的数据结构完成解题。
代码几乎没什么大的差别，只需要注意下Python不支持大根堆，入堆时使用-num即可。
同时为了快速获取元素下标，需要入堆[-num, index]这样的结构。

时间复杂度： O(Nlog(N))
空间复杂度： O(N)

解题

暴力解题:

class Solution:
    def maxSlidingWindow(self, nums, k):
        if k == 1:
            return nums
        dic, cur, ret = defaultdict(int), nums[0], []
        for i, j in enumerate(nums):
            dic[nums[i]] += 1
            if i < k - 1:
                cur = max(cur, j)
                continue
            if nums[i] > cur:
                cur = nums[i]
            ret.append(cur)
            left = nums[i - k + 1]
            dic[left] -= 1
            if dic[left] == 0:
                del dic[left]
                if left == cur:
                    cur = max(dic)
        return ret

双端队列:

class Solution:
    def maxSlidingWindow(self, nums, k):
        q, ret = deque(), []
        for i, j in enumerate(nums):
            while q and nums[q[-1]] < j:
                q.pop()
            if q and q[0] <= i - k:
                q.popleft()
            q.append(i)
            if i >= k - 1:
                ret.append(nums[q[0]])
        return ret

堆/优先队列

class Solution:
    def maxSlidingWindow(self, nums, k):
        hp, ret = [], []
        for i, j in enumerate(nums):
            while hp and hp[0][1] <= i - k:
                heapq.heappop(hp)
            heapq.heappush(hp, [-j, i])
            if i >= k - 1:
                ret.append(-hp[0][0])
        return ret

欢迎关注我的公众号: 清风Python，带你每日学习Python算法刷题的同时，了解更多python小知识。

我的个人博客：https://qingfengpython.cn

力扣解题合集：https://github.com/BreezePython/AlgorithmMarkdown