The meaning of the question: Give you a sequence of length n, and then use a window of length k to de-box (k<n) each time to save the maximum and minimum values in this window of k, and output.
Idea: The simplest on2 method of this question is definitely overtime. Then I thought of a nlogn method. Some people on the Internet said that it could be passed, but I didn't. question. The idea is actually very simple, the code is annotated, the scratch paper is ready, just read it.
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<sstream>
#include<cstring>
#include<bitset>
#include<cstdio>
#include<string>
#include<deque>
#include<stack>
#include<cmath>
#include<queue>
#include<set>
#include<map>
#define INF 0x3f3f3f3f
#define CLR(x,y) memset(x,y,sizeof(x))
#define LC(x) (x<<1)
#define RC(x) ((x<<1)+1)
#define MID(x,y) ((x+y)>>1)
using namespace std;
typedef pair<int,int> pii;
typedef long long ll;
const double PI=acos(-1.0);
const int maxn=1e6+10;
int fact[10]= {1,1,2,6,24,120,720,5040,40320,362880};
struct dian {
int val,pos;//value position
};
dian maxque[maxn],minque[maxn];//Structure simulation queue
int maxhead,maxtail,minhead,mintail;//decreasing queue (max) head and tail increment (max) head and tail
int maxans[maxn],minans[maxn];//output answer
int main() {
int n,k;
cin>>n>>k;
int x;
for(int i=0; i<k; i++) {
scanf("%d",&x);
while(maxhead<maxtail&&maxque[maxtail-1].val<=x)maxtail--;//If the previous one is smaller than the current input, the current large value must be selected when the window moves from front to back, so the previous one is smaller no need to save
maxque[maxtail].val=x;
maxque[maxtail++].pos=i;//Record the position to prepare for the movement of the window later
while(minhead<mintail&&minque[mintail-1].val>=x)mintail--;//同理
minque[mintail].val=x;
minque[mintail++].pos=i;
}
int cur=1;
for(int i=k; i<n; i++) {
minans[cur]=minque[minhead].val;//The record answer queue head holds the minimum value
maxans[cur++]=maxque[maxhead].val;
scanf("%d",&x);
while(maxhead < maxtail && maxque[maxhead].pos <= ik)maxhead++;//The position of the window does not meet the requirements and pop out
while(maxhead < maxtail && maxque[maxtail-1].val <= x)maxtail--;//The value is judged before
maxque[maxtail].val=x;
maxque[maxtail++].pos=i;
while (minhead <mintail && minque [minhead] .pos <= ik) minhead ++; // 同理
while(minhead < mintail && minque[mintail-1].val >= x)mintail--;
minque[mintail].val=x;
minque[mintail++].pos=i;
}
minans[cur]=minque[minhead].val;
maxans[cur++]=maxque[maxhead].val;
for (int i = 1; i < cur; ++i) {
if (i > 1) putchar(' ');
printf("%d", slips[i]);
}
printf("\n");
for (int i = 1; i < cur; ++i) {
if (i > 1) putchar(' ');
printf("%d", maxans[i]);
}
printf("\n");
}
Sliding Window
| Time Limit: 12000MS | Memory Limit: 65536K | |
| Total Submissions: 67150 | Accepted: 19065 | |
| Case Time Limit: 5000MS | ||
Description
An array of size
n
≤ 10
6
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.
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