bzoj4540【HNOI2016】序列

4540: [Hnoi2016]序列

Time Limit: 20 Sec   Memory Limit: 512 MB
Submit: 619   Solved: 302
[ Submit][ Status][ Discuss]

Description

　　给定长度为n的序列：a1,a2,…,an，记为a[1:n]。类似地，a[l:r]（1≤l≤r≤N）是指序列：a_l,a_l+1,…,a_r-
1,a_r。若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

28
17
11
11
17

HINT

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

莫队算法+单调栈+前缀和

考虑离线的莫队算法，面临的问题就是边界移动对于答案的影响如何计算。

实际上就是要求这个东西：对于区间[l,r]，固定左端点或者右端点，所有子区间的最小值的和。

暴力是可以O(n^2)求出的，显然太慢，考虑优化。

下面以固定左端点为例，右端点同理。

首先找出[l,r]的最小值所在的位置x。那么对于右端点是[x,r]的子串，最小值是a[x]，对答案贡献就是a[x]*(r-x+1)。

区间最小值用RMQ，O(nlogn)预处理，O(1)单次询问。

那剩余的部分呢？实际上每一个点i能影响的范围实际是[i,pi]，pi表示i后面第一个比他小的点，p数组可以用单调栈预处理。

相当于对于一个数a[x]，向他后面第一个小于它的数a[y]连边，边权a[x]*(y-x)，求a[l]到a[x]的距离。

这形成一个树形结构，对于树上的链维护一个前缀和，就可以O(1)询问了。这里一定可以保证x是l的祖先，想想为什么？

于是这道题就解决了，总时间复杂度O(n*logn+n*sqrt(n))。

#include
#include
#include
#include
#include
#include
#define F(i,j,n) for(int i=j;i<=n;i++)
#define D(i,j,n) for(int i=j;i>=n;i--)
#define ll long long
#define pa pair
#define N 100005
using namespace std;
int n,m,block,top,a[N],pl[N],pr[N],s[N],lg[N];
ll now,sl[N],sr[N],ans[N];
pa f[N][20];
struct data{int l,r,id,num;}q[N];
inline int read()
{
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
inline bool cmp(data a,data b)
{
	return a.num==b.num?a.rb.num;
}
inline int rmq(int l,int r)
{
	int t=lg[r-l+1];
	return min(f[l][t],f[r-(1<a[i]) pr[s[top]]=i,top--;
		s[++top]=i;
	}
	while (top) pr[s[top]]=n+1,top--;
	D(i,n,1)
	{
		while (top&&a[s[top]]>a[i]) pl[s[top]]=i,top--;
		s[++top]=i;
	}
	while (top) pl[s[top]]=0,top--;
	F(i,1,n) sl[i]=sl[pl[i]]+(ll)a[i]*(i-pl[i]);
	D(i,n,1) sr[i]=sr[pr[i]]+(ll)a[i]*(pr[i]-i);
	int l,r;
	F(i,1,m)
	{
		if (i==1||q[i].num!=q[i-1].num) r=(q[i].num-1)*block,l=r+1,now=0;
		while (rq[i].l) l--,now+=queryl(l,r);
		while (l