【BZOJ4540】【HNOI2016】序列（莫队）

题面

Description

　　给定长度为n的序列：a1,a2,…,an，记为a[1:n]。类似地，a[l:r]（1≤l≤r≤N）是指序列：al,al+1,…,ar-

1,ar。若1≤l≤s≤t≤r≤n，则称a[s:t]是a[l:r]的子序列。现在有q个询问，每个询问给定两个数l和r，1≤l≤r

≤n，求a[l:r]的不同子序列的最小值之和。例如，给定序列5,2,4,1,3，询问给定的两个数为1和3，那么a[1:3]有

6个子序列a[1:1],a[2:2],a[3:3],a[1:2],a[2:3],a[1:3]，这6个子序列的最小值之和为5+2+4+2+2+2=17。

Input

　　输入文件的第一行包含两个整数n和q，分别代表序列长度和询问数。接下来一行，包含n个整数，以空格隔开

,第i个整数为ai，即序列第i个元素的值。接下来q行，每行包含两个整数l和r，代表一次询问。

Output

　　对于每次询问，输出一行，代表询问的答案。

Sample Input

5 5

5 2 4 1 3

1 5

1 3

2 4

3 5

2 5

Sample Output

HINT

1 ≤N,Q ≤ 100000,|Ai| ≤ 10^9

题解

我其实本来不想写莫队来着

但是在网上找题解都是莫队

无奈。。。我也写莫队。。

莫队的重点就在于怎么$O(1)$转移状态

假设我们已经求出了$[L+1,R]$的答案

现在要扩展到$[L,R]$

考虑新产生的$[L..L],[L..L+1]...,[L...R]$的答案

我们先找到这段区间的最小值，假设其位置是$p$

那么右端点在$[p,R]$的子序列的贡献都是$a[p]$

接下来呢？把$[L,p-1]$继续考虑？

但是我们要做到转移$O(1)$，所以考虑怎么优化

我们设$f[i]$表示确定左端点为$i$时，到后面所有位置的贡献

利用单调栈求出右侧第一个比$i$位置小的数的位置$R[i]$

$[i,R[i]-1]$的贡献就是$a[i]$，而$[R[i],n]$的贡献则与$i$无关，

只与$R[i]$有关，因此，我们得到转移

\[f[i]=f[R[i]]+(R[i]-i)*a[i]
\]

所以，此时$[L,p)$的贡献就是$f[L]-f[p]$

考虑右侧的贡献同理

综上，时间复杂度$O(n\sqrt{n})$

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<set>

#include<map>

#include<vector>

#include<queue>

using namespace std;

#define ll long long

#define RG register

#define MAX 111111

inline int read()

{

    RG int x=0,t=1;RG char ch=getchar();

    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();

    if(ch=='-')t=-1,ch=getchar();

    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();

    return x*t;

}

int n,q,blk;

int L[MAX],R[MAX],S[MAX],top,a[MAX],lg[MAX];

ll f[MAX],g[MAX],ans[MAX],Ans;

struct Query{int i,l,r,blk;}Q[MAX];

bool operator<(Query a,Query b){if(a.blk!=b.blk)return a.blk<b.blk;return a.r<b.r;}

struct STable

{

	int p[18][MAX];

	void pre()

	{

		for(int j=1;j<=lg[n];++j)

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

				p[j][i]=a[p[j-1][i]]<=a[p[j-1][i+(1<<(j-1))]]?p[j-1][i]:p[j-1][i+(1<<(j-1))];

	}

	int Query(int l,int r)

	{

		int k=lg[r-l+1];

		return a[p[k][l]]<=a[p[k][r-(1<<k)+1]]?p[k][l]:p[k][r-(1<<k)+1];

	}

}ST;

ll CalcL(int l,int r)

{

	int p=ST.Query(l,r);

	return 1ll*(r-p+1)*a[p]+g[l]-g[p];

}

ll CalcR(int l,int r)

{

	int p=ST.Query(l,r);

	return 1ll*(p-l+1)*a[p]+f[r]-f[p];

}

int main()

{

	n=read();q=read();blk=sqrt(n);

	for(int i=1;i<=n;++i)a[i]=read();

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

	{

		while(top&&a[S[top]]>a[i])--top;

		L[i]=S[top];

		S[++top]=i;

	}

	for(int i=1;i<=n;++i)f[i]=f[L[i]]+1ll*(i-L[i])*a[i];

	S[top=0]=n+1;

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

	{

		while(top&&a[S[top]]>a[i])--top;

		R[i]=S[top];

		S[++top]=i;

	}

	for(int i=n;i>=1;--i)g[i]=g[R[i]]+1ll*(R[i]-i)*a[i];

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

	{

		int l=read(),r=read();

		Q[i]=(Query){i,l,r,(l-1)/blk};

	}

	for(int i=1;i<=n;++i)ST.p[0][i]=i;

	for(int i=2;i<=n;++i)lg[i]=lg[i>>1]+1;

	ST.pre();

	sort(&Q[1],&Q[q+1]);

	for(int i=1,L=1,R=0;i<=q;++i)

	{

		while(R<Q[i].r)Ans+=CalcR(L,++R);

		while(L>Q[i].l)Ans+=CalcL(--L,R);

		while(R>Q[i].r)Ans-=CalcR(L,R--);

		while(L<Q[i].l)Ans-=CalcL(L++,R);

		ans[Q[i].i]=Ans;

	}

	for(int i=1;i<=q;++i)printf("%lld\n",ans[i]);

	return 0;

}