题目链接：点击查看

题目大意：给出 n 个大楼的高度记为 h，现在需要从第一个大楼到达第 n 个大楼，问最小步数是多少，只有满足以下条件时才能从 i 移动到 j ，设 i < j：

题目分析：无后效性的最优解，显然是 dp 问题，但又不好直接进行转移，所以需要借助数据结构来维护

首先第一种情况的状态不用多说了，直接转移就好，对于后两种情况，假设从状态 dp[ i ] 转移到 dp[ j ] ，对于每个接受状态的 j 来说，需要找到一个 i ，满足其之间的数都要小于 h[ i ] 和 h[ j ] 或者大于 h[ i ] 和 h[ j ] ，其实这就用到了单调栈的一个性质，先稍微回顾一下单调栈，假如现在维护了一个非严格递增的单调栈（维护的是下标，其对应的高度严格递增），一个比较明显的结论就是，假如遍历到当前的位置为 cur，那么对于单调栈内的高度 h 大于等于 cur 的位置 pos 来说，( pos , cur ) 开区间内的数一定都大于 h[ pos ]，假设 ( pos , cur ) 内存在一个数 x 小于等于 h[ pos ]，由于维护的是非严格递增的栈，在之前遍历到 x 时，会将大于等于 x 的 数包括 h[ pos ] 直接弹出栈，所以与假设矛盾，故 ( pos , cur ) 内的数一定都大于 h[ pos ] ，又因为这个 pos 我们一开始取得是 h[ pos ] >= h[ cur ] ，所以满足了情况 3 ，也就是说明了 pos 的状态是可以直接转移到 cur 的状态的，同理可证情况 2

那么如何实现呢，接上一段继续说，如果到了位置 cur 时，现在的目标是需要找到所有 h[ pos ] >= h[ cur ] 的 pos 进行状态转移，而思考一下维护单调栈的过程，是需要将所有大于等于 h[ cur ] 的元素弹出栈，这也就对应了上面的状态转移，所以在弹栈的时候维护一下 dp 就可以了

最后需要注意的一个细节是，因为单调栈维护的是一个非严格递增的序列，显然在弹栈的时候的转移都是合法的，那么当维护好单调栈后，此时的栈顶是否合法呢，我们需要分情况讨论一下：

1. 如果在弹栈的时候，遇到了一个 h[ pos ] == h[ cur ] ，那么当弹完栈后，此时栈顶的位置到 cur 的位置之间一定是存在着一个位置 pos 使得 h[ pos ] == h[ cur ] 的，此时的栈顶无法给 cur 转移状态
2. 如果没有遇到的话，那么在弹完栈后，可以保证栈顶到 cur 之间的数都严格大于 h[ cur ]，证明还是和上面的反证法一样，假设存在一个数 x ∈ [ 栈顶 , cur ] ，且 x 小于等于 h[ cur ] ，那么在之前维护单调栈的时候，栈顶早就被弹出去了，所以得证，此时栈顶是可以向 cur 位置进行状态转移的

理论比较复杂，但是代码实现起来比较简单，我是用 stl 的栈写的，可能看起来比较绕一些

代码：
 

#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
#include<bitset>
using namespace std;
 
typedef long long LL;
 
typedef unsigned long long ull;
 
const int inf=0x3f3f3f3f;

const int N=3e5+100;

int h[N],dp[N];

stack<int>st1,st2;
 
int main()
{
#ifndef ONLINE_JUDGE
//  freopen("data.in.txt","r",stdin);
//  freopen("data.out.txt","w",stdout);
#endif
//  ios::sync_with_stdio(false);
	memset(dp,inf,sizeof(dp));
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",h+i);
	dp[1]=0;
	st1.push(1);
	st2.push(1);
	for(int i=2;i<=n;i++)
	{
		bool flag1=false,flag2=false;
		while(st1.size()&&h[st1.top()]>=h[i])
		{
			if(h[st1.top()]==h[i])
				flag1=true;
			dp[i]=min(dp[i],dp[st1.top()]+1);
			st1.pop();
		}
		if(st1.size()&&!flag1)
			dp[i]=min(dp[i],dp[st1.top()]+1);
		while(st2.size()&&h[st2.top()]<=h[i])
		{
			if(h[st2.top()]==h[i])
				flag2=true;
			dp[i]=min(dp[i],dp[st2.top()]+1);
			st2.pop();
		}
		if(st2.size()&&!flag2)
			dp[i]=min(dp[i],dp[st2.top()]+1);
		st1.push(i);
		st2.push(i);
	}
	printf("%d\n",dp[n]);



















	return 0;
}