[BZOJ4826][HNOI2017]影魔-单调栈-线段树

影魔

Description

影魔,奈文摩尔,据说有着一个诗人的灵魂。事实上,他吞噬的诗人灵魂早已成千上万。千百年来,他收集了各式各样的灵魂,包括诗人、牧师、帝王、乞丐、奴隶、罪人,当然,还有英雄。

每一个灵魂,都有着自己的战斗力,而影魔,靠这些战斗力提升自己的攻击。奈文摩尔有 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
。

Input

第一行 n,m,p1,p2

第二行 n 个数:k[1],k[2],…,k

接下来 m 行,每行两个数 a,b,表示询问区间[a,b]中的灵魂对会为影魔提供多少攻击力。

1 <= n,m <= 200000;1 <= p1,p2 <= 1000

Output

共输出 m 行,每行一个答案,依次对应 m 个询问。

Sample Input

10 5 2 3

7 9 5 1 3 10 6 8 2 4

1 7

1 9

1 3

5 9

1 5

Sample Output

30

39

4

13

16

考场上脑洞了个莫队发现码力不足写不出……

写了个线段树忘记关输出信息……

0分滚粗……

看了题解的感受是:

差点看不懂……

思路:不妨先把所有的p1换成p2。

咱考虑把p2定义为:对一段区间，如果它的端点为该序列中最大的，则对序列有p2的贡献。

于是咱正反各求一遍左端点的贡献即可~

求法是单调栈求出所有点向左数第一个比自己大的数，记为ri。

则[i+1,ri]因此获得p2的贡献~

于是咱把询问按左端点排序，然后从右往左扫，扫到一个位置便在对应区间加上其贡献，处理所有左端点为该点的询问——值为[1,R]，加上即可~

然而还有问题:p1被当成了2p2……

观察，发现p1只有在[i,ri]区间才会出现，因此对于该端点加上p1-2p2。

然后输出答案就是了~

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

typedef long long ll;

inline int read()
{
int x=0;char ch=getchar();
while<
11ceb
/span>(ch<'0' || '9'<ch)ch=getchar();
while('0'<=ch && ch<='9')
{
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x;
}

const int N=200050;
const int Q=200050;

struct segment_tree
{
ll sum[N<<2],tag[N<<2];
int siz[N<<2];

void add(int pos,ll val)
{
sum[pos]+=(ll)siz[pos]*val;
tag[pos]+=val;
}

void push(int pos,int l,int r)
{
if(tag[pos])
{
if(l!=r)
{
add(pos<<1,tag[pos]);
add(pos<<1|1,tag[pos]);
}
tag[pos]=0;
}
}

void push_up(int n)
{
siz
=siz[n<<1]+siz[n<<1|1];
sum
=sum[n<<1]+sum[n<<1|1];
}

void update(int n,int l,int r,int dl,int dr,int val)
{
push(n,l,r);
if(dl==l && r==dr)
{
add(n,val);
push(n,l,r);
return;
}

int mid=l+r>>1;
if(dr<=mid)
update(n<<1,l,mid,dl,dr,val);
else if(mid<dl)
update(n<<1|1,mid+1,r,dl,dr,val);
else
update(n<<1,l,mid,dl,mid,val),update(n<<1|1,mid+1,r,mid+1,dr,val);

push_up(n);
}

ll query(int n,int l,int r,int dl,int dr)
{
if(dl==l && r==dr)
return sum
;

push(n,l,r);
int mid=l+r>>1;
if(dr<=mid)
return query(n<<1,l,mid,dl,dr);
if(mid<dl)
return query(n<<1|1,mid+1,r,dl,dr);
return query(n<<1,l,mid,dl,mid)+query(n<<1|1,mid+1,r,mid+1,dr);
}

void biu(int n,int l,int r)
{
tag
=0;
if(l==r)
{
sum
=0;
siz
=1;
return;
}

int mid=l+r>>1;
biu(n<<1,l,mid);
biu(n<<1|1,mid+1,r);

push_up(n);
}
}koishi;

struct qu
{
int id,l,r;

bool operator < (qu o)const
{
return l<o.l;
}
}q
;

int n,m,p1,p2;
ll res
,a
;
int r
,stk
,top;

void calc()
{
koishi.biu(1,1,n+1);
sort(q+1,q+m+1);
stk[top=0]=n+1;
a[n+1]=n+1;

for(int i=n;i>=1;i--)
{
for(;top && a[stk[top]]<a[i];--top);
r[i]=stk[top];
stk[++top]=i;
}

for(int i=n,cur=m;i>=1;--i)
{
koishi.update(1,1,n+1,i+1,r[i],p2);
koishi.update(1,1,n+1,r[i],r[i],p1-2*p2);

for (;cur && q[cur].l==i;--cur)
res[q[cur].id]+=koishi.query(1,1,n+1,1,q[cur].r);
}
}

int main()
{
n=read(),m=read(),p1=read(),p2=read();

for(int i=1;i<=n;i++)
a[i]=read();
for(int i=1;i<=m;i++)
q[i].l=read(),q[i].r=read(),q[i].id=i;

calc();
reverse(a+1,a+n+1);
for(int i=1;i<=m;i++)
{
q[i].l=n+1-q[i].l;
q[i].r=n+1-q[i].r;
swap(q[i].l,q[i].r);
}
calc();

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

return 0;
}