BZOJ4540: [Hnoi2016]序列

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]的答案，怎么得到[l,r+1]的答案。

当右端点固定时，考虑枚举最小值，不难发现这类似一个跳跃的过程，每次跳到上一个比它小的位置，直到跳出边界。

那么我们只需要找到[l,r]的最小值就能得到最后一次停留的位置p了，每次跳跃的收益可以前缀和预处理出来，然后再额外加上A[p]*(p-l+1)这一部分的收益。

使用一下ST表就能做到O(NlogN+Nsqrt(N))了。

#include<cstdio>
#include<cctype>
#include<set>
#include<cmath>
#include<cstring>
#include<algorithm>
#define rep(i,s,t) for(int i=s;i<=t;i++)
#define dwn(i,s,t) for(int i=s;i>=t;i--)
#define ren for(int i=first[x];i;i=next[i])
using namespace std;
const int BufferSize=1<<16;
char buffer[BufferSize],*head,*tail;
inline char Getchar() {
	if(head==tail) {
		int l=fread(buffer,1,BufferSize,stdin);
		tail=(head=buffer)+l;
	}
	return *head++;
}
inline int read() {
    int x=0,f=1;char c=Getchar();
    for(;!isdigit(c);c=Getchar()) if(c=='-') f=-1;
    for(;isdigit(c);c=Getchar()) x=x*10+c-'0';
    return x*f;
}
set<int> S;
set<int>:: iterator it;
typedef long long ll;
const int maxn=100010;
int n,m,A[maxn],f[maxn],g[maxn],blo[maxn];
struct Solver {
	int val,pos;
	bool operator < (const Solver& ths) const {
		return val<ths.val;
	}
}B[maxn];
ll ans[maxn],suml[maxn],sumr[maxn],nowans;
struct Query {
	int l,r,id;
	bool operator < (const Query& ths) const {
		if(blo[l]!=blo[ths.l]) return l<ths.l;
		return r<ths.r;
	}
}Q[maxn];
int val[maxn],mn[20][maxn],Log[maxn];
int better(int a,int b) {return val[a]<val[b]?a:b;}
void init() {
	Log[0]=-1;rep(i,1,n) Log[i]=Log[i>>1]+1,mn[0][i]=i;
	for(int j=1;(1<<j)<=n;j++)
		for(int i=1;i+(1<<j)-1<=n;i++) 
		    mn[j][i]=better(mn[j-1][i],mn[j-1][i+(1<<j-1)]);
}
int query(int l,int r) {
	int k=Log[r-l+1];
	return better(mn[k][l],mn[k][r-(1<<k)+1]);
}
void updatel(int l,int r,int t) {
	int p=query(l,r);
	nowans+=t*(sumr[l]-sumr[p]+(ll)(r-p+1)*A[p]);
}
void updater(int l,int r,int t) {
	int p=query(l,r);
	nowans+=t*(suml[r]-suml[p]+(ll)(p-l+1)*A[p]);
}
int main() {
	n=read();m=read();int SIZE=(int)sqrt(n);
	rep(i,1,n) A[i]=read(),blo[i]=(i-1)/SIZE+1;
	rep(i,1,n) B[i]=(Solver){A[i],i};
	sort(B+1,B+n+1);S.insert(0);S.insert(n+1);
	rep(i,1,n) {
		int p=B[i].pos;val[p]=i;
		it=S.lower_bound(p);g[p]=(*it);
		it--;f[p]=(*it);
		S.insert(p);
	}
	rep(i,1,n) suml[i]=suml[f[i]]+(ll)(i-f[i])*A[i];
	dwn(i,n,1) sumr[i]=sumr[g[i]]+(ll)(g[i]-i)*A[i];
	init();
	rep(i,1,m) Q[Q[i].id=i].l=read(),Q[i].r=read();
	sort(Q+1,Q+m+1);int l=1,r=0;
	rep(i,1,m) {
		while(l>Q[i].l) updatel(--l,r,1);
		while(r<Q[i].r) updater(l,++r,1);
		while(l<Q[i].l) updatel(l++,r,-1);
		while(r>Q[i].r) updater(l,r--,-1);
		ans[Q[i].id]=nowans;
	}
	rep(i,1,m) printf("%lld\n",ans[i]);
	return 0;
}