239. Sliding Window Maximum

Description

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Return the max sliding window.

Example:

Input: nums = [1,3,-1,-3,5,3,6,7], and k = 3
Output: [3,3,5,5,6,7]
Explanation:

Window position Max

---

[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
Note:
You may assume k is always valid, 1 ≤ k ≤ input array’s size for non-empty array.

Follow up:
Could you solve it in linear time?

Problem URL

---

Solution

给一数组，和一个滑动窗口的大小，找到每一次滑动窗口后窗口内数的最大值。

A simple idea is to maintain a prioriyt queue which has the size of k. Feed to prioriyt queue to k first, then every time the window moves, we remove first number out or pq and add new number. Then the peek value in pq is max value of this window, store it to res array.

Code

class Solution {
     
    public int[] maxSlidingWindow(int[] nums, int k) {
     
        if (nums.length == 0 || k <= 0){
     
            return new int[0];
        }
        int len = nums.length;
        int[] res = new int[len - k + 1];
        Queue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>(){
     
            @Override
            public int compare(Integer n1, Integer n2){
     
                return Integer.compare(n2, n1);
            }
        });
        for(int i = 0; i < k; i++){
     
            pq.add(nums[i]);
        }
        res[0] = pq.peek();
        for (int i = k; i < len; i++){
     
            pq.remove(nums[i - k]);
            pq.add(nums[i]);
            res[i - k + 1] = pq.peek();
        }
        return res;
    }
}

Time Complexity: O(nk)
Space Complexity: O(k)

---

Review

Another linear time approach is to divide the nums array into subsequence size of k. Maintain two arrays which denote the max value from left to right and from right to left in each subsequence. The max value of a window start at I is Math.max(leftMax[i + k -1], rightMax[i]

class Solution {
     
    public int[] maxSlidingWindow(int[] nums, int k) {
     
        int len = nums.length;
        if (len == 0 || k <= 0){
     
            return new int[0];
        }
        int[] leftMax = new int[len];
        int[] rightMax = new int[len];
        int[] res = new int[len - k + 1];
        leftMax[0] = nums[0];
        rightMax[len - 1] = nums[len - 1];
        for (int i = 1, j = 0; i < len; i++){
     
            leftMax[i] = i % k == 0 ? nums[i] : Math.max(leftMax[i - 1], nums[i]);
            j = len - i - 1;
            rightMax[j] = j % k == 0 ? nums[j] : Math.max(rightMax[j + 1], nums[j]);
        }
        
        for (int i = 0, j = 0; i + k <= len; i++){
     
            res[j++] = Math.max(rightMax[i], leftMax[i + k - 1]);
        }
        return res;
    }
}

Time Complexity: O(n)
Space Complexity: O(n)
reference