[莫队 单调栈] BZOJ 4540 [Hnoi2016]序列

题解：http://www.cnblogs.com/Ngshily/p/5409337.html

给出一个序列，求某段区间的位置不同子串的最小值之和

对于前 40 40，我们可以 n2 n2预处然后 O(nn√) O(nn)

预处理中 zzz[i][j] zzz[i][j]表示以 i i开头，结尾最长到 j j的前缀子串的最小值之和

同理 fff[i][j] fff[i][j]表示倒过来的情况

考虑对预处理进行优化

对于一个区间 [l,r] [l,r]，以 l l开头，结尾最长到 r r的前缀可分为两部分计算，

设 x x为区间 [l,r] [l,r]中最小值所在位置

 对于结尾在区间 [x,r] [x,r]中的子串，对答案的贡献为 A[x]∗(r−x+1) A[x]∗(r−x+1)

对于结尾在区间 [l,x) [l,x)中的子串，我们先找到下一个比 A[l] A[l]小的位置 p1 p1，则对于结尾在区间 [l,p1) [l,p1)中的子串，对答案的贡献为 A[l]∗(p1−l) A[l]∗(p1−l)，再找到下一个比 A[p1] A[p1]小的位置 p2 p2类推，直到找到 x x为止

这就相当于对于一个数 A[x] A[x]，我们把下一个比它小的数 A[y] A[y]向它连边，边权为 A[x]∗(y−x) A[x]∗(y−x)，然后求树上的节点 l l到 x x的距离和

这个过程我们可以通过维护单调栈预处理出来

zzz[i] zzz[i]表示节点到 i i所属的树根的距离，因为可能是森林

从后往前枚举，当前值小于等于栈顶时弹栈，然后 zzz[i]=zzz[sta[top]]+A[i]∗(sta[top]−i) zzz[i]=zzz[sta[top]]+A[i]∗(sta[top]−i)

fff[i] fff[i]同理

然后莫队，，，复杂度 O(nlogn+nn√)

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;

inline char nc()
{
	static char buf[100000],*p1=buf,*p2=buf;
	if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
	return *p1++;
}

inline void read(int &x){
	char c=nc(),b=1;
	for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
	for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=100005;

namespace ST{
	const int K=20;
	int mini[N][K],Log[N];
	int *A;
	inline int Min(int a,int b){
		return A[a]<A[b]?a:b;
	}
	inline void Pre(int *a,int n){
		A=a;
		for (int i=2;i<=n;i++) Log[i]=Log[i>>1]+1;
		for (int i=1;i<=n;i++) mini[i][0]=i;
		for (int k=1;k<K;k++)
			for (int i=1;i<=n;i++)
			{
				mini[i][k]=mini[i][k-1];
				if (i+(1<<(k-1))<=n)
					mini[i][k]=Min(mini[i][k-1],mini[i+(1<<(k-1))][k-1]);
			}
	}
	inline int Query(int l,int r){
		int t=Log[r-l+1];
		return Min(mini[l][t],mini[r-(1<<t)+1][t]);
	}
}

struct event{
	int l,r,lpos;
	int idx;
	bool operator < (const event &B) const{
		return lpos==B.lpos?r<B.r:lpos<B.lpos;
	}
}eve[N];
int tot;

int n,B,a[N];
int Stk[N],pnt;

ll zzz[N],fff[N],Ans[N];

inline void Pre()
{
	Stk[pnt=0]=0;
	for (int i=1;i<=n;i++)
	{
		while (pnt && a[Stk[pnt]]>=a[i]) pnt--;
		fff[i]=fff[Stk[pnt]]+(ll)a[i]*(i-Stk[pnt]);
		Stk[++pnt]=i;
	}
	Stk[pnt=0]=n+1;
	for (int i=n;i;i--)
	{
		while (pnt && a[Stk[pnt]]>=a[i]) pnt--;
		zzz[i]=zzz[Stk[pnt]]+(ll)a[i]*(Stk[pnt]-i);
		Stk[++pnt]=i;
	}
}

inline ll call(int l,int r){
	int t=ST::Query(l,r);
	return (ll)a[t]*(r-t+1)+zzz[l]-zzz[t];
}
inline ll calr(int l,int r){
	int t=ST::Query(l,r);
	return (ll)a[t]*(t-l+1)+fff[r]-fff[t];
}

ll ans;

inline void Solve(){
	int l=1,r=0;
	for (int i=1;i<=tot;i++)
	{
		while (r<eve[i].r) ans+=calr(l,++r);
		while (r>eve[i].r) ans-=calr(l,r--);
		while (l<eve[i].l) ans-=call(l++,r);
		while (l>eve[i].l) ans+=call(--l,r);
		Ans[eve[i].idx]=ans;
	}
}

int main()
{
	freopen("t.in","r",stdin);
	freopen("t.out","w",stdout);
	read(n); read(tot); B=sqrt(n);
	for (int i=1;i<=n;i++) read(a[i]);
	ST::Pre(a,n);
	Pre();
	for (int i=1;i<=tot;i++)
	{
		read(eve[i].l); read(eve[i].r);
		eve[i].lpos=(eve[i].l-1)/B+1; eve[i].idx=i;
	}
	sort(eve+1,eve+tot+1);
	Solve();
	for (int i=1;i<=tot;i++)
		printf("%lld\n",Ans[i]);
	return 0;
}