Codeforces Round #305 (Div. 2)——D单调/路径压缩——Mike and Feet

Mike is the president of country What-The-Fatherland. There are n bears living in this country besides Mike. All of them are standing in a line and they are numbered from 1 to n from left to right. i-th bear is exactly ai feet high.

A group of bears is a non-empty contiguous segment of the line. The size of a group is the number of bears in that group. The strengthof a group is the minimum height of the bear in that group.

Mike is a curious to know for each x such that 1 ≤ x ≤ n the maximum strength among all groups of size x.

Input

The first line of input contains integer n (1 ≤ n ≤ 2 × 105), the number of bears.

The second line contains n integers separated by space, a1, a2, ..., an (1 ≤ ai ≤ 109), heights of bears.

Output

Print n integers in one line. For each x from 1 to n, print the maximum strength among all groups of size x.

Sample test(s)

input

10
1 2 3 4 5 4 3 2 1 6

output

6 4 4 3 3 2 2 1 1 1 
法一：
大意：对于size从1到n，让你求对应于每一个size的区间内最小的值里面的最大的值，比如size = 2  最小就分别为 1 2 3 4 4 3 2 1 1所以第二个值为4
用了单调栈的思想，让下标对于的值严格减，那么对于每一个值而言，前面已经标记过的都是比他大的，而其他都是比他小的或者相等，这样得到的区间就是最小的区间而值最大，（容易看出区间越小值就应该让他越大比如 1 3 5  size为1可以取到5，而size为2时就是次大），防止TLE，压缩寻找的时候的路径
O（nlogn)

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

const int maxn = 200010;

int l[maxn],r[maxn],ord[maxn];

int a[maxn],ans[maxn],vis[maxn];

bool cmp(int i,int j){

    return a[i] > a[j];

}

int find_l(int x){

    if(!vis[l[x]-1])

        return l[x];

    else {

        return l[x] = find_l(l[x]-1);

    }

}

int find_r(int x){

    if(!vis[r[x]+1])

        return r[x];

    else {

        return r[x] = find_r(r[x]+1);

    }

}

int main()

{

    int n;

    while(~scanf("%d%",&n)){

        memset(vis,0,sizeof(vis));

        for(int i = 1; i <= n ;i++)

            scanf("%d",&a[i]);

        for(int i = 1; i <= n ;i++){

            l[i] = r[i] = ord[i] = i;

        }

        sort(ord+1,ord+n+1,cmp);

       // for(int i = 1; i <= n;i++)

       //     printf("%d ",ord[i]);

        int j = 1;

        for(int i = 1; i <= n ;i++){

            int tmp = ord[i];

            vis[tmp] = 1;

            while(j <= find_r(tmp) - find_l(tmp) + 1){

                ans[j] = a[ord[i]];

             //   printf("%d %d\n",find_r(i),find_l(i));

                j++;

               // printf("%d ",j);

            }

        }

        for(int i = 1; i <= n; i++){

        if(i == 1) printf("%d",ans[i]);

        else printf(" %d",ans[i]);

        }

        puts("");

    }

    return 0;

}

　法二：用路径压缩的思想，对于每一个a[i]都能得出他的l[i]跟r[i]，那么用一个res数组来保存以该长度的值，比这个长度小的都可以更新成这个数（因为长度都是由a[i]产生的），之后倒着对res更新

O（n）

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

const int maxn = 200010;

int l[maxn],r[maxn];

int a[maxn],res[maxn];

int main()

{

    int n;

    while(~scanf("%d",&n)){

        for(int i = 1; i <= n ;i++){

            scanf("%d",&a[i]);

            l[i] = r[i] = i;

        }

        for(int i = 1; i <= n ;i++){

            while(l[i]-1 >= 1 && a[l[i]-1] >= a[i])

                l[i] = l[l[i]-1];

        }

        for(int i = 1; i <= n ;i++){

            while(r[i]+1 <= n && a[r[i]+1] >= a[i])

                r[i] = r[r[i]+1];

        }

        for(int i =1 ; i<= n; i++)

            res[r[i]-l[i]+1] = a[i];

        for(int i = n-1 ;i >= 1; i--)

            res[i] = max(res[i],res[i+1]);

        for(int i = 1; i <= n ;i++){

            if(i == 1) printf("%d",res[i]);

            else printf(" %d",res[i]);

        }

        puts("");

    }

        return 0;



}