[线段树] poj2823 Sliding Window

Sliding Window
Time Limit: 12000MS Memory Limit: 65536K
Total Submissions: 46075 Accepted: 13317
Case Time Limit: 5000MS
Description

An array of size n ≤ 106 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

给一个长度为n的数组，有一个长度为k的滑动窗口，滑动窗口从最左端开始向右移动，每个窗口中有最大值和最小值，求每次窗口滑动时，出现在窗口中的最小值和最大值。

这道题目也可以用线段树做，不过时间卡的比较紧。。裸的最大最小值模板，套上去就可以用了。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=1000010;
const int INF=0x3f3f3f3f;
int minx,maxx;

struct Tree{
    int l,r;
    int minx,maxx;
}tree[N<<2];

void build(int L,int R,int rt){
    tree[rt].l=L;
    tree[rt].r=R;
    if(tree[rt].l==tree[rt].r){
        scanf("%d",&tree[rt].minx);
        tree[rt].maxx=tree[rt].minx;
        return ;
    }
    int mid=(L+R)>>1;
    build(L,mid,rt*2);
    build(mid+1,R,rt*2+1);
    tree[rt].minx=min(tree[rt*2].minx,tree[rt*2+1].minx);
    tree[rt].maxx=max(tree[rt*2].maxx,tree[rt*2+1].maxx);
}


void QueMin(int L,int R,int rt){
    if(L<=tree[rt].l && tree[rt].r<=R){
        minx=min(minx,tree[rt].minx);
        return ;
    }
    int mid=(tree[rt].l+tree[rt].r)>>1;
    if(R<=mid)
        QueMin(L,R,rt*2);
    else if(L>=mid+1)
        QueMin(L,R,rt*2+1);
    else{
        QueMin(L,mid,rt*2);
        QueMin(mid+1,R,rt*2+1);
    }
}

void QueMax(int L,int R,int rt){
    if(L<=tree[rt].l && tree[rt].r<=R){
        maxx=max(maxx,tree[rt].maxx);
        return ;
    }
    int mid=(tree[rt].l+tree[rt].r)>>1;
    if(R<=mid)
        QueMax(L,R,rt*2);
    else if(L>=mid+1)
        QueMax(L,R,rt*2+1);
    else{
        QueMax(L,mid,rt*2);
        QueMax(mid+1,R,rt*2+1);
    }
}

int main(){

    //freopen("input.txt","r",stdin);

    int n,k;
    while(~scanf("%d%d",&n,&k)){
        build(1,n,1);  //对1~n的范围建树
        int m=n-k,r;  //每次循环窗口的初始值到m就可以停止了
        for(int l=1;l<=m;l++){
            r=l+k-1;   // r是当前窗口最右边的长度
            minx=INF;  //记得初始化
            QueMin(l,r,1); //访问当前窗口的最小值
            printf("%d ",minx);
        }
        //最后一组的数据
        minx=INF;
        QueMin(n-k+1,n,1);
        printf("%d\n",minx);

        //同上，这次是处理最大值
        for(int l=1;l<=m;l++){
            r=l+k-1;
            maxx=-INF;
            QueMax(l,r,1);
            printf("%d ",maxx);
        }
        maxx=-INF;
        QueMax(n-k+1,n,1);
        printf("%d\n",maxx);

    }

    return 0;
}