[HNOI2017]影魔（离线线段树好题）_影魔线段树-优快云博客

题面：https://www.luogu.com.cn/problem/P3722

题解

离线线段树好题

先想一下我们怎么求一个区间[l,r]的答案

可以发现这并不好做。。。。233333

于是我们会想到：固定一个端点，预处理出另一个端点的所在位置（当然，这两个端点会构成一个p1或p2型的区间）与它的贡献

说通俗（复杂）点就是把每一个端点对整个序列的贡献算出来

如图：（p2的贡献并没有算完整，可能还有一部分）（每个点贡献怎么计算后面会讲到）

于是我们发现，对于一个区间[l,r]，我们把[l,r]中的每个点对序列的贡献都算出来（线段树区间加），再用线段树对[l,r]求一个和就是区间[l,r]的答案。

为什么呢？

因为我们把每个位于[l,r]区间内的端点的贡献都加在了另一个端点上，所以一个贡献被累加当且仅当另一个端点也在[l,r]内。

由于每一个端点的贡献都是可以叠加并且可以相减的，所以我们就使用前缀和，用[1,r]的答案减去[1,l-1]的答案来计算[l,r]的答案

这样就把我们引导到了离线的路上：把所有询问离线下来，排序，计算

此时还有一个问题：怎么高效地计算一个点的贡献

由于一个点的贡献也比较难算

所以我们要思考：谁会对这个点的贡献造成影响

于是我们可以考虑枚举一个i作为一个区间的最大值

如图：

我们可以预处理出i左边第一个比i大的数的位置L[i]，与右边第一个比i大的数的位置R[i]

可以发现i可以作为三种区间的最大值：

1、[L[i]+1,R[i]-1]的最大值，p1

2、x属于[L[i]+1,i-1]，[x,R[i]]的最大值，p2

3、y属于[i+1,R[i]-1]，[L[i],x]的最大值，p2

其实还可以作为[x,y]的最大值，但是那种已经不会对答案造成影响，所以就不用统计了

把这些贡献分别统计到L[i]和R[i]上即可预处理出每一个端点的贡献

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
inline int gi()
{
	char c;int num=0,flg=1;
	while((c=getchar())<'0'||c>'9')if(c=='-')flg=-1;
	while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}
	return num*flg;
}

#define N 200005
#define lc i<<1
#define rc i<<1|1
#define LL long long
int L[N],R[N];
LL val[N],ans[N];
int qcnt,bcnt;
struct qnode{
	int pos,l,r,id,op;
	qnode(){}
	qnode(int x,int w,int u,int y,int z){pos=x;l=w;r=u;id=y;op=z;}
	bool operator < (const qnode &t)const{return pos<t.pos;}
}q[2*N];
struct anode{
	int pos,l,r,k;
	anode(){}
	anode(int x,int y,int z,int w){pos=x;l=y;r=z;k=w;}
	bool operator < (const anode &t)const{return pos<t.pos;}
}b[3*N];
struct node{
	int l,r,len;LL x,la;
}a[4*N];
void pushdown(int i)
{
	if(a[i].la&&a[i].len>1){
		a[lc].la+=a[i].la;a[lc].x+=a[i].la*a[lc].len;
		a[rc].la+=a[i].la;a[rc].x+=a[i].la*a[rc].len;
		a[i].la=0;
	}
}
void build(int i,int l,int r)
{
	a[i].l=l;a[i].r=r;a[i].len=r-l+1;
	if(l==r) return;
	int mid=(l+r)>>1;
	build(lc,l,mid);build(rc,mid+1,r);
}
void insert(int i,int l,int r,int k)
{
	if(a[i].l>r||a[i].r<l) return;
	pushdown(i);
	if(l<=a[i].l&&a[i].r<=r){
		a[i].la+=k;a[i].x+=1ll*k*a[i].len;
		return;
	}
	insert(lc,l,r,k);insert(rc,l,r,k);
	a[i].x=a[lc].x+a[rc].x;
}
LL query(int i,int l,int r)
{
	if(a[i].l>r||a[i].r<l) return 0ll;
	pushdown(i);
	if(l<=a[i].l&&a[i].r<=r)
		return a[i].x;
	return query(lc,l,r)+query(rc,l,r);
}

int main()
{
	int n,m,p1,p2,i,j,k,l,r;
	n=gi();m=gi();p1=gi();p2=gi();
	for(i=1;i<=n;i++)val[i]=gi();
	
	val[0]=val[n+1]=0x3f3f3f3f3f3f3f3fll;
	for(i=1;i<=n;i++){L[i]=i-1;while(val[L[i]]<val[i])L[i]=L[L[i]];}
	for(i=n;i>=1;i--){R[i]=i+1;while(val[R[i]]<val[i])R[i]=R[R[i]];}
	for(i=1;i<=n;i++){
		if(L[i]>0&&R[i]<=n)b[++bcnt]=anode(R[i],L[i],L[i],p1);
		if(L[i]+1<i&&R[i]<=n)b[++bcnt]=anode(R[i],L[i]+1,i-1,p2);
		if(i+1<R[i]&&L[i]>0)b[++bcnt]=anode(L[i],i+1,R[i]-1,p2);
	}
	for(i=1;i<=m;i++){
		l=gi();r=gi();
		q[++qcnt]=qnode(l-1,l,r,i,-1);
		q[++qcnt]=qnode(r,l,r,i,1);
		ans[i]=1ll*(r-l)*p1;
	}
	sort(b+1,b+bcnt+1);
	sort(q+1,q+qcnt+1);
	build(1,1,n);
	
	for(i=1,j=1,k=1;i<=n;i++){
		while(b[j].pos==i&&j<=bcnt){
			insert(1,b[j].l,b[j].r,b[j].k);
			j++;
		}
		while(!q[k].pos)k++;
		while(q[k].pos==i&&k<=qcnt){
			ans[q[k].id]+=query(1,q[k].l,q[k].r)*q[k].op;
			k++;
		}
	}
	for(i=1;i<=m;i++)
		printf("%lld\n",ans[i]);
}