【ROI2018】抄本【RMQ，分治，单调栈】

分析

这个题涉及到静态区间的最值，所以考虑用ST表解决，$f1[i][j],f2[i][j]$ 分别表示以 $i$ 开头，长度为 $2^j$ 的区间最大/最小值的下标，下标就定义一个比较函数返回值即可。只需要nlogn的预处理就行。递推式：$f[i][j]=max/min(f[i][j-1],f[i+(1<<(j-1))][j-1])$

然后只需要进行一边分治一边查询最值，对于一个区间[l,r]，如果最小值在最大值的左边（包括既是最小值是最大值），那就将这一段划分为一个区间，显然整个区间的最小值只能作为某段开头，最大值只能作为某段结尾，也就是说这已经是一个最优段（不能向前或向后扩展）。如果最大值在最小值的左边那就划分为三段，分别是[l,max],[max+1,min-1],[min,r]。显然这里也是将整个大区间的最大值作为某段结尾，最小值作为某段开头。我们可以知道，最小的区间是长度为1的，这个作为边界。

注意：我们在比较最小值的时候要让相等的最小值取最左边那个，让相等的最大值取右边那个。在比较函数当中有这个细节。

另外，这个程序Windows是过不了构造数据的（300000~1降序排列），栈空间会爆掉，不知道实际评测怎么样

$Update1:$ 我将分治的时候的实现改成了用BFS，就可以过掉构造数据了。

$Update2:$
另外一种更好的方法就是用单调栈实现。我们考虑对于某一个数，以他为结尾的段的开头是哪个数。有两个限制条件：1. 中间不能有比他大的，记为wall，也就是说要找到前面第一个比他大的数作为范围。2. 在范围内找到最小的数当中最靠左边的那个。

所以考虑维护两个单调队列，一个递增一个递减，但是又看到队头并不会出队（没有范围限制），所以本质上是一个单调栈。递减的方便取出前面比他大的第一个数，然后在递增的栈当中找下标比wall大的第一个数，也就是最小数，因为单调性，所以可以用二分查找实现。复杂度 $O(n\ast lo{g}_{2}n)$

上代码

DFS:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;

int n,a[300010],ans;
int f1[300010][21],f2[300010][21];
int lg[300010];

int mx(int x,int y)
{
	if(a[x]>a[y]) return x;
	else return y;
}
int mn(int x,int y)
{
	if(a[x]<=a[y]) return x;
	else return y;
}

void dfs(int l,int r)
{
	if(l>r) return;
	int k=lg[r-l+1]; 
	int s=mn(f2[l][k],f2[r-(1<<k)+1][k]);
	int t=mx(f1[l][k],f1[r-(1<<k)+1][k]);
	if(s<=t)
	{
		//cout<<s<<' '<<t<<endl; 
		ans++;
		dfs(l,s-1);
		dfs(t+1,r); 
	}
	else
	{
		dfs(l,t);
		dfs(t+1,s-1);
		dfs(s,r);
	}
}

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		f1[i][0]=i;
		f2[i][0]=i;
	}
	lg[1]=0;
	for(int i=2;i<=n;i++) lg[i]=lg[i>>1]+1;
	for(int j=1;j<=lg[n];j++)
	{
		for(int i=1;i+(1<<j)-1<=n;i++)
		{
			f1[i][j]=mx(f1[i][j-1],f1[i+(1<<(j-1))][j-1]);
			f2[i][j]=mn(f2[i][j-1],f2[i+(1<<(j-1))][j-1]);
		}
	}
	dfs(1,n);
	cout<<ans;
	return 0;
}

BFS:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
typedef long long ll;

struct node
{
	int l,r;
}b[100010];

queue<node> q;

int n,a[300010],ans;
int f1[300010][21],f2[300010][21];
int lg[300010];

int mx(int x,int y)
{
	if(a[x]>a[y]) return x;
	else return y;
}
int mn(int x,int y)
{
	if(a[x]<=a[y]) return x;
	else return y;
}

void bfs()
{
	while(!q.empty())
	{
		node tmp=q.front();
		q.pop();
		if(tmp.l>tmp.r) continue;
		int k=lg[tmp.r-tmp.l+1]; 
		int s=mn(f2[tmp.l][k],f2[tmp.r-(1<<k)+1][k]);
		int t=mx(f1[tmp.l][k],f1[tmp.r-(1<<k)+1][k]);
		if(s<=t)
		{
			//cout<<s<<' '<<t<<endl; 
			ans++;
			q.push((node){tmp.l,s-1});
			q.push((node){t+1,tmp.r});
		}
		else
		{
			q.push((node){tmp.l,t});
			q.push((node){t+1,s-1});
			q.push((node){s,tmp.r});
		}
	}
	
}

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		f1[i][0]=i;
		f2[i][0]=i;
	}
	lg[1]=0;
	for(int i=2;i<=n;i++) lg[i]=lg[i>>1]+1;
	for(int j=1;j<=lg[n];j++)
	{
		for(int i=1;i+(1<<j)-1<=n;i++)
		{
			f1[i][j]=mx(f1[i][j-1],f1[i+(1<<(j-1))][j-1]);
			f2[i][j]=mn(f2[i][j-1],f2[i+(1<<(j-1))][j-1]);
		}
	}
	q.push((node){1,n});
	bfs();
	cout<<ans;
	return 0;
}

单调栈：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

const int N=300010;//这样定义数组就省了时间 
int n,a[N],ans;
int up[N],down[N],top1,top2;
int pre[N];

int main()
{
	scanf("%d",&n); 
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		while(top1&&a[down[top1]]<=a[i]) top1--;//尽量放前面 
		down[++top1]=i;
		int wall=top1-1;
		while(top2&&a[up[top2]]>a[i]) top2--;//严格大于才行，尽量往后面放(增加可用长度) 
		up[++top2]=i;
		int ff=upper_bound(up+1,up+top2+1,down[wall])-up;
		pre[i]=up[ff];//存最前面的合法下标 
	}
	for(int i=n;i>=1;i=pre[i]-1) ans++;
	printf("%d",ans);
	return 0;
}