最大值_Leetcode2 | 滑动窗口最大值(Q239)

Sliding Window Maximum

Q 239

今天也是好心情

Problem Description

··· Difficulty···

You are given an array of integers 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 1:

Input: nums = [1,3,-1,-3,5,3,6,7], 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

暴力

遍历

Too Young

很朴素的循环遍历+调用库函数max找最值

也不出意外的TLE了:(

// Javascript版var maxSlidingWindow = function(nums, k) {    let max = [];    for(let i = 0; i < nums.length-k+1; i++){        let tmp = nums.slice(i,i+k);        max.push(Math.max(...tmp));    }    return max;};

代码实现起来真的很快很简单，但TLE也很快的显示了出来T^T

当我点进超时数据时，看傻了...(是我大意了)

Too Young Too Simple

官方

题解

优先队列

“优先队列(Heap)

可实时维护一系列元素中的最大/小值”

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

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

class Solution {public:    vector<int> maxSlidingWindow(vector<int>& nums, int k) {        int n = nums.size();        priority_queueint,         for (int i = 0; i < k; ++i) {            q.emplace(nums[i], i);        }        vector<int> ans = {q.top().first};        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(nlogn)

最坏情况下，数组nums 中的元素单调递增，那么最终优先队列中包含了所有元素，没有元素被移除。由于将一个元素放入优先队列的时间复杂度为O(logn)，因此总时间复杂度为O(nlogn)。

空间复杂度 O(n)

官方

题解

单调队列

“优先队列方法的优化版”

由于我们需要求出的是滑动窗口的最大值，如果当前的滑动窗口中有两个下标i和j，其中i在j的左侧(i

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

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

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

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

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

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

空间复杂度 O(n)

官方

题解

分块+预处理

“类似稀疏表(Sparse Table)的一种思路”

可以将数组 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

需要注意在递推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{suffixMax[i],prefixMax[i+k−1]}

即为所求

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

空间复杂度 O(n)