Jumping Buildings-单调队列

原题链接：

Jumping Buildings

原题：

D. Jumping Buildings
time limit per test2.0 s
memory limit per test64 MB
inputstandard input
outputstandard output
Bob is developing a new game called jumping Lario. In this game the main protagonist, Lario, has to jump on top of buildings until he reaches the end of the level. The level is composed of N buildings of possibly different heights. The building where Lario starts is chosen randomly at the beginning of the game.

Bob started to write the code for his game but then realized that he didn’t know how to implement the jumps mechanics. The thing is, if Lario is currently on top of building X and the height of this building is h, then Lario should be able to reach building min(X + h, n) in one jump. Unless, of course, there’s a taller building somewhere on the path from building X to building X + h, then in this case, Lario would face smash the taller building on the path and end up landing right before it.

For example, in the image bellow, if Lario had started on the first building (of height 5), with one jump he should be able to reach building six. But on the path from building one to building six, he would end up hitting building five that has height 6. When doing so, he would land on building four (the one with height 3).

Given the heights for all the N buildings, your task is to figure out for every possible start position of Lario, how far he would be able to go with just one jump.

Input
The first line of the input contains a single integer N (1 ≤ N ≤ 105), indicating the number of buildings.

The second line of the input contains N integers h1, h2… hN (1 ≤ hi ≤ 105), indicating the height of each building.

Output
Output N integers. The i-th integer indicating the farthest building that Lario can reach with one jump if he starts on top of the i-th building.

Example
input
6
5 2 2 3 6 2
output
3 1 0 0 1 0

题意：

本题就是问你一串数中每个数，有几个数比他大（也不全是，题中限制了所跳的最远距离不能大于本身的数字，就是在输出答案时取个min就完事了），额~~，单调队列模拟题（因为朋友之前说过优先队列就是解决左右最大或者最小数的位置，（博主未曾考究，希望有巨巨不吝赐教，Orz））,具体看代码。

AC代码：

代码注释：
首先que[]数组指的是模拟的队列，arr是记录的原数组，ans记录的是答案，
代码核心：
就是在第二个for循环中通过累计判断原数组中 arri 与 arri-1 的大小进行比较如果仍然满足递增或者递减的趋势，就会将i记录在队列中。如果不满足 arri-1 <arr i，那么，需要将队列中每一个数与 arri 进行比较而又因为这是单调队列，所以可以有序的进行判断，防止无用判断发生(即while循环的作用)。
代码一是用的数组模拟的优先队列

#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
int n;
scanf("%d",&n);
int arr[n+1];
int que[n+1],ans[n+1];
memset(ans,0,sizeof ans);
for(int i=1;i<=n;i++)
{
    scanf("%d",&arr[i]);
}
int left=0;
for(int i=1;i<=n;i++)
{
    while(left>=1&&arr[que[left]]<arr[i])
    {
        ans[que[left]]=i;
        left--;
    }
    que[++left]=i;
}
for(int i=1;i<=n;i++)
{
    if(ans[i]==0)
        ans[i]=n+1;
}
for(int i=1;i<=n;i++)
{
    int tem=min(ans[i]-i-1,arr[i]);
    printf("%d ",tem);
}
}

代码二（用封装好的优先队列）

#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
int n;
scanf("%d",&n);
int arr[n+1];
int que[n+1],ans[n+1];
priority_queue<int>myq;
memset(ans,0,sizeof ans);
for(int i=1;i<=n;i++)
{
    scanf("%d",&arr[i]);
}
int left=0,top;
for(int i=1;i<=n;i++)
{
    if(!myq.empty()) top=myq.top();
    while(!myq.empty()&&arr[top]<arr[i])
    {
        ans[top]=i;
        myq.pop();
        top=myq.top();
    }
    myq.push(i);
for(int i=1;i<=n;i++)
{
    if(ans[i]==0)
        ans[i]=n+1;
}
for(int i=1;i<=n;i++)
{
    int tem=min(ans[i]-i-1,arr[i]);
    printf("%d ",tem);
}
}

另附运行时间参考

（上面的是STL，下面的数组模拟）
这里可以看出，stl不仅比较慢而且用的空间也比较大。（但是STL真心很好用，哈哈）。

总结：

百度了一下，好像堆这一种数据结构还没学会，额，又有事干了（QAQ）.

告诫：

保持那种求知的渴望！！！