BZOJ4826: [Hnoi2017]影魔

影魔,奈文摩尔,据说有着一个诗人的灵魂。

事实上,他吞噬的诗人灵魂早已成千上万。

千百年来,他收集了各式各样的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英雄。

每一个灵魂,都有着自己的战斗力,而影魔,靠这些战斗力提升自己的攻击。

奈文摩尔有 n 个灵魂,他们在影魔宽广的体内可以排成一排,从左至右标号 1 到 n。

第 i个灵魂的战斗力为 k[i],灵魂们以点对的形式为影魔提供攻击力,对于灵魂对 i,j(i<j)来说,若不存在 k[s](i<s<j)大于 k[i]或者 k[j],则会为影魔提供 p1 的攻击力

(可理解为:当 j=i+1 时,因为不存在满足 i<s<j 的 s,从而 k[s]不存在,这时提供 p1 的攻击力;当 j>i+1 时,若max{k[s]|i<s<j}<=min{k[i],k[j]} , 则提供 p1 的攻击力 );

另一种情况 , 令 c 为k[i+1],k[i+2],k[i+3]......k[j-1]的最大值,若 c 满足:k[i]<c<k[j],或者 k[j]<c<k[i],则会为影魔提供 p2 的攻击力,当这样的 c 不存在时,自然不会提供这 p2 的攻击力;

其他情况的点对,均不会为影魔提供攻击力。

影魔的挚友噬魂鬼在一天造访影魔体内时被这些灵魂吸引住了。

他想知道,对于任意一段区间[a,b],1<=a<b<=n,位于这些区间中的灵魂对会为影魔提供多少攻击力,即考虑所有满足a<=i<j<=b 的灵魂对 i,j 提供的攻击力之和。

顺带一提,灵魂的战斗力组成一个 1 到 n 的排列:k[1],k[2],...,k[n]。

我们发现要处理一堆区间$emmm...$

话说这题能不能用区间神器莫队呢？

好像不能欸，因为我没有想出来区间和值不好转变。

我们发现对于$p_1$类型的区间$[i,j]$。

如果$j>i$那么$j$一定是$i$右侧第一个比它大的点。

什么？$j<i$？，反转区间可以转化成情况一。

再考虑$p_2$情况类型的区间$[i,j]$

如果$i$小于$j$，则$i$一定是这样的点：它在区间$(p,q)$之间

$(p,q)$是开区间！！！

其中$[q.j]$是一个$p_1$类型的区间，$p$是$q$左侧第一个比q大的点。

同理$i>j$是可以反转区间转换为情况一。

通过反证法我们可以很容易的证明上面的说法可以不重不漏的

枚举出所有的$p_1,p_2$（假设有一个不符合条件的区间，发现很快就会出矛盾）。

发现上述一套花里胡哨的定义只需要两个信息：

点$i$左侧第一个比他大的点是谁；

点$i$右侧第一个比他大的点是谁。

这。。。当然单调栈$O(n)$预处理啊。。。

接下来是统计区间。

发现在线处理会直接晕掉，考虑离线处理。。。

把询问按右端点排序，之后每次拓展右端点。

更新所有合法的左端点即可。

然后我们发现$p_1$是单点修改，$p_2$是区间修改。

结果一堆大佬直接树状数组。。。

本蒟蒻表示根本不会。。。

于是直接上线段树。。。

然后线段树求一下就是结果了。

$BUT$！上述只处理了一半，即$i$小于$j$。

那另外一半呢？

我们可以把区间和询问统统反转，处理下一半情况。

细节看代码吧，不看代码刚才讲的好多细节没有。。。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#define LSON rt<<1
#define RSON rt<<1|1
#define DATA(x) a[x].data
#define SIGN(x) a[x].c
#define LSIDE(x) a[x].l
#define RSIDE(x) a[x].r
#define WIDTH(x) (RSIDE(x)-LSIDE(x)+1)
#define MAXN 200010
using namespace std;
int n,m,top;
int next[MAXN],stack[MAXN];
long long p1,p2,val[MAXN],ans[MAXN];
struct Sg_Tree{
	long long data,c;
	int l,r;
}a[MAXN<<2];
struct node{
	int l,r,id;
}que[MAXN];
inline int read(){
	int date=0,w=1;char c=0;
	while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
	while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
	return date*w;
}
bool cmp(const node &x,const node &y){
	if(x.l==y.l)return x.r<y.r;
	return x.l<y.l;
}
inline void pushup(int rt){
	DATA(rt)=DATA(LSON)+DATA(RSON);
}
inline void pushdown(int rt){
	if(!SIGN(rt)||LSIDE(rt)==RSIDE(rt))return;
	SIGN(LSON)+=SIGN(rt);
	DATA(LSON)+=SIGN(rt)*WIDTH(LSON);
	SIGN(RSON)+=SIGN(rt);
	DATA(RSON)+=SIGN(rt)*WIDTH(RSON);
	SIGN(rt)=0;
}
void buildtree(int l,int r,int rt){
	int mid;
	LSIDE(rt)=l;
	RSIDE(rt)=r;
	SIGN(rt)=0;
	if(l==r){
		DATA(rt)=0;
		return;
	}
	mid=l+r>>1;
	buildtree(l,mid,LSON);
	buildtree(mid+1,r,RSON);
	pushup(rt);
}
void update(int l,int r,long long c,int rt){
	int mid;
	if(l<=LSIDE(rt)&&RSIDE(rt)<=r){
		SIGN(rt)+=c;
		DATA(rt)+=c*WIDTH(rt);
		return;
	}
	pushdown(rt);
	mid=LSIDE(rt)+RSIDE(rt)>>1;
	if(l<=mid)update(l,r,c,LSON);
	if(mid<r)update(l,r,c,RSON);
	pushup(rt);
}
long long query(int l,int r,int rt){
	int mid;
	long long ans=0;
	if(l<=LSIDE(rt)&&RSIDE(rt)<=r)return DATA(rt);
	pushdown(rt);
	mid=LSIDE(rt)+RSIDE(rt)>>1;
	if(l<=mid)ans+=query(l,r,LSON);
	if(mid<r)ans+=query(l,r,RSON);
	return ans;
}
int half_find(int x){
	int left=1,right=m+1,mid;
	while(left<=right){
		mid=left+right>>1;
		if(que[mid].l<x)left=mid+1;
		else right=mid-1;
	}
	return left;
}
void work(){
	top=0;
	stack[top]=n+1;
	buildtree(1,n+1,1);
	for(int i=n;i>=1;i--){
		while(top&&val[stack[top]]<val[i])stack[top--]=0;
		next[i]=stack[top];
		stack[++top]=i;
	}
	for(int i=n;i>=1;i--){
		if(next[i]>i){
			update(i+1,next[i],p2,1);
			update(next[i],next[i],p1-p2*2,1);
		}
		int pos=half_find(i);
		while(que[pos].l==i){
			ans[que[pos].id]+=query(i+1,que[pos].r,1);
			pos++;
		}
	}
}
void init(){
	n=read();m=read();p1=read();p2=read();
	for(int i=1;i<=n;i++)val[i]=read();
	for(int i=1;i<=m;i++){
		que[i].l=read();que[i].r=read();
		que[i].id=i;
	}
	sort(que+1,que+m+1,cmp);
	work();
	for(int i=1;i<=n/2;i++)swap(val[i],val[n-i+1]);
	for(int i=1;i<=m;i++){
		swap(que[i].l,que[i].r);
		que[i].l=n-que[i].l+1;
		que[i].r=n-que[i].r+1;
	}
	sort(que+1,que+m+1,cmp);
	work();
	for(int i=1;i<=m;i++)printf("%lld
",ans[i]);
}
int main(){
	init();
	return 0;
}

BZOJ4826: [Hnoi2017]影魔

Description

Input

Output

Sample Input

Sample Output