POJ2823——Sliding Window 单调队列入门

Sliding Window

Time Limit: 12000MS		Memory Limit: 65536K
Total Submissions: 40596		Accepted: 11992
Case Time Limit: 5000MS

Description

An array of size n ≤ 10 ⁶ is given to you. 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 rightwards by one position. Following is an example:
The array is [1 3 -1 -3 5 3 6 7], and k is 3.

Window position	Minimum value	Maximum value
[1  3  -1] -3  5  3  6  7	-1	3
1 [3  -1  -3] 5  3  6  7	-3	3
1  3 [-1  -3  5] 3  6  7	-3	5
1  3  -1 [-3  5  3] 6  7	-3	5
1  3  -1  -3 [5  3  6] 7	3	6
1  3  -1  -3  5 [3  6  7]	3	7

Your task is to determine the maximum and minimum values in the sliding window at each position.

Input

The input consists of two lines. The first line contains two integers n and k which are the lengths of the array and the sliding window. There are n integers in the second line.

Output

There are two lines in the output. The first line gives the minimum values in the window at each position, from left to right, respectively. The second line gives the maximum values.

Sample Input

8 3
1 3 -1 -3 5 3 6 7

Sample Output

-1 -3 -3 -3 3 3
3 3 5 5 6 7

Source

以前做这题貌似用的RMQ，最近由于dp的需要，特意学了下单调队列

单调队列是一种支持队尾入队，两端可以出队的队，一般会维护一个索引值和value值

拿这题来说，我们以求最大为例，先把前k个入队，当然需要保证队列里是递减的，这样最大值才是队头，所以每次入队时，都要和队尾去比较，加入队尾太小，那么就要把队尾元素出队，直到可以把元素放进去

当然假如队头元素的索引值已经不在此时要求的窗口里，那么也要出队，每一个元素都在第i - k+1到第i个窗口，以此来判断队头是否要出队

由于这种单调性质，所以单调队列可以用来优化dp的转移

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1000010;
int a[N], b[N];
int arr[N];
int x[N], y[N];

int main()
{
	int n, k;
	while(~scanf("%d%d", &n, &k))
	{
		for (int i = 1; i <= n; ++i)
		{
			scanf("%d", &arr[i]);
		}
		if (k > n)
		{
			k = n;
		}
		int front1, rear1, front2, rear2;
		int c1 = 0, c2 = 0;
		front1 = front2 = rear1 = rear2 = 0;
		for (int i = 1; i < k; ++i)
		{
			while (front1 < rear1 && arr[a[rear1 - 1]] <= arr[i])
			{
				rear1--;
			}
			a[rear1++] = i;
			while (front2 < rear2 && arr[b[rear2 - 1]] >= arr[i])
			{
				rear2--;
			}
			b[rear2++] = i;
		}
		for (int i = k; i <= n; ++i)
		{
			while (front1 < rear1 && arr[a[rear1 - 1]] <= arr[i])
			{
				rear1--;
			}
			a[rear1++] = i;
			if (a[front1] < i - k + 1)
			{
				front1++;
			}
			x[++c1] = arr[a[front1]];
			while (front2 < rear2 && arr[b[rear2 - 1]] >= arr[i])
			{
				rear2--;
			}
			b[rear2++] = i;
			if (b[front2] < i - k + 1)
			{
				front2++;
			}
			y[++c2] = arr[b[front2]];
		}
		printf("%d", y[1]);
		for (int i = 2; i <= c2; ++i)
		{
			printf(" %d", y[i]);
		}
		printf("\n");
		printf("%d", x[1]);
		for (int i = 2; i <= c1; ++i)
		{
			printf(" %d", x[i]);
		}
		printf("\n");
	}
	return 0;
}