Sliding Window Maximum

Sliding Window Maximum

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.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

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

Therefore, return the max sliding window as [3,3,5,5,6,7].

Note: 
You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.

Follow up:
Could you solve it in linear time?

关联题目

Implement Queue using Stacks 用stack实现queue

Min Stack  提供一个以O(1)时间复杂度实现push,pop,getMin等操作的stack

/*
问题分解:
本题目核心思路是实现一个queue并以O(1)时间复杂度实现push,pop,getMax等操作
前面已经提供一个以O(1)时间复杂度实现push,pop,getMin等操作的stack,现在问题转化为如何用stack实现queue
*/

class MaxStack {
public:
	inline void clear()
	{
		stack_.clear();
		maxValues_.clear();
	}
	inline void assign(MaxStack const &  s)
	{
	    vector<int> const & ss = s.stack_;
	    int m =  INT_MIN ;
	    int const size = ss.size();
	    stack_.resize(size);
	    maxValues_.resize(size);
		for (int i = size -1,j = 0; i>= 0; --i,++j)
		{
		    int v = ss[i];
		    if(v > m)
		    {
		        m = v;
		    }
			stack_[j] = v;
			maxValues_[j] = m;
		}
	}
	inline size_t size()
	{
		return stack_.size();
	}
	inline bool empty()
	{
		return stack_.size() == 0;
	}
	inline void push(int x) 
	{
		if (stack_.empty())
		{
			maxValues_.push_back(x);
		}
		else if (maxValues_.back() > x)
		{
			maxValues_.push_back(maxValues_.back());
		}
		else
		{
			maxValues_.push_back(x);
		}
		stack_.push_back(x);
	}

	inline void pop() 
	{
		stack_.pop_back();
		maxValues_.pop_back();
	}

	inline int top() 
	{
		return stack_.back();
	}

	inline int getMax() 
	{
		return maxValues_.back();
	}
	vector<int> stack_;
	vector<int> maxValues_;
};

class MaxQueue {
public:
	inline void push(int x) 
	{
		stack1_.push(x);
	}
	inline void pushEx(int x)
	{
		stack2_.push(x);
	}
	

	inline void pop()
	{
	    if (stack2_.empty())
	    {		
	        adjust();
	    }
		stack2_.pop();
	}
	inline int getMax() 
	{
		if (stack1_.empty())
		{
			return stack2_.getMax();
		}
		if (stack2_.empty())
		{
			return stack1_.getMax();
		}
		return max(stack1_.getMax(), stack2_.getMax());
		
	}
	MaxStack stack1_;
	MaxStack stack2_;
private:
	inline void adjust()
	{
	    stack2_.assign(stack1_);
	    stack1_.clear();
	}
};

class Solution {
public:
	vector<int>  &  maxSlidingWindow(vector<int>& nums, int k)
	{
		MaxQueue q;
		for (int i = k -2; i >= 0; --i)
		{
			q.pushEx(nums[i]);
		}
		static vector<int> output;
		output.clear();
		for (int i = k-1; i < nums.size(); ++i)
		{
			q.push(nums[i]);
			output.push_back(q.getMax());
			q.pop();
		}
		return output;
	}
};