LeetCode——第二百三十九题（python）：滑动窗口最大值

题目

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

进阶

你能在线性时间复杂度内解决此题吗？

示例

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:

提示

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

思路1（暴力法）

遍历数组nums，取出对应区间的最大值记录即可。

class Solution:
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        res = list()
        if not nums:
            return res
        
        for i in range(len(nums)-k+1):
            j = i + k
            res.append(max(nums[i:j]))
        return res

可见暴力法的时间复杂度较高，可以考虑进行优化

思路2（动态规划）

• 将输入数组分割成有 k 个元素的块。
• 情况一：开头元素为 i ，结尾元素为 j 的当前滑动窗口在一个块内，则建立数组 left， 其中 left[j] 是从块的开始到下标 j 最大的元素，方向 左->右
• 情况二：开头元素为 i ，结尾元素为 j 的当前滑动窗口在两个块中，则还需要数组 right，其中 right[j] 是从块的结尾到下标 j 最大的元素，方向 右->左
• right[i] 是左侧块内的最大元素， left[j] 是右侧块内的最大元素。因此滑动窗口中的最大元素为 max(right[i], left[j])
• 其中 i 取值范围为 (0, n - k + 1)

class Solution(object):
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
     
        n = len(nums)
        if n * k == 0:
            return []
        if k == 1:
            return nums
        
        left = [0] * n
        left[0] = nums[0]
        right = [0] * n
        right[n - 1] = nums[n - 1]
        for i in range(1, n):
            # from left to right
            if i % k == 0:
                # block start
                left[i] = nums[i]
            else:
                left[i] = max(left[i - 1], nums[i])
            # from right to left
            j = n - i - 1
            if (j + 1) % k == 0:
                # block end
                right[j] = nums[j]
            else:
                right[j] = max(right[j + 1], nums[j])
        
        output = []
        for i in range(n - k + 1):
            output.append(max(left[i + k - 1], right[i]))
            
        return output

可见，在空间复杂度变化不大的情况下，时间复杂度大大减小