[HNOI2017]影魔

题目大意

给定一个长度为$n$的排列，对于一个区间，如果两个端点分别是这个区间的最大值和次大值，有$p_1$的贡献，否则如果其中一个端点是这个区间的最大值，有$p_2$的贡献。
现在给你$q$个询问，每次询问一个区间$[L,R]$，问所有被区间完全包含的区间的贡献和。

$1\le n,q\le2\times10^5,1\le p_1,p_2\le10^3$

---

题目分析

首先，我们可以考虑把$p_1$这种贡献先算在$p_2$里面，具体是怎么样呢？
我们将贡献$p_2$重定义为：一个区间，如果它有一个端点比这个区间内除了端点的数都大，那么对答案就有一个$p_2$的贡献，注意，左端点和右端点可能都对答案有贡献。
这个怎么计算呢？显然我们要正着做一遍反着做一遍来把左右端点的贡献都给求出来，这里只讨论正着做，反着的话你把数组reverse一下，把询问区间翻转一下就一样了。
首先我们用单调栈处理出一个点后面的第一个比它大的数的位置，记为$r_i$。然后我们把询问都按照左端点排序，然后从右到左扫描线。扫到一个位置，现在线段树$[i+1,r_i]$位置区间加上$p_2$，然后处理挂在这个左端点的所有询问，左端点对于这个询问的贡献就是线段树上$[1,R]$（$R$是查询的右端）的和。
这样做，我们能把所有$p_2$都很好地求出来，可是$p_1$都被我们当成了两倍的$p_2$，怎么办呢？可以发现，我们枚举作为次大值的左/右端点，那这种区间只会有一个，就是$[i,r_i]$，因此我们在做上面扫描线过程中，除了区间加之外，还给位置$r_i$单点减去$p_1-2p_2$就好了。
时间复杂度$\mathrm O(q\log n)$。

---

代码实现

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cctype>

using namespace std;

typedef long long LL;

int read()
{
    int x=0,f=1;
    char ch=getchar();
    while (!isdigit(ch)) f=ch=='-'?-1:f,ch=getchar();
    while (isdigit(ch)) x=x*10+ch-'0',ch=getchar();
    return x*f;
}

int buf[30];

void write(LL x)
{
    if (x<0) putchar('-'),x=-x;
    for (;x;x/=10) buf[++buf[0]]=x%10;
    if (!buf[0]) buf[++buf[0]]=0;
    for (;buf[0];putchar('0'+buf[buf[0]--]));
}

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

struct segment_tree
{
    LL tag[N<<2],sum[N<<2];
    int size[N<<2];

    void ADD(int x,LL delta){sum[x]+=1ll*delta*size[x],tag[x]+=delta;}

    void clear(int x,int l,int r)
    {
        if (tag[x])
        {
            if (l!=r) ADD(x<<1,tag[x]),ADD(x<<1|1,tag[x]);
            tag[x]=0;
        }
    }

    void update(int x){size[x]=size[x<<1]+size[x<<1|1],sum[x]=sum[x<<1]+sum[x<<1|1];}

    void modify(int x,int st,int en,int l,int r,int delta)
    {
        clear(x,l,r);
        if (st==l&&en==r)
        {
            ADD(x,delta),clear(x,l,r);
            return;
        }
        int mid=l+r>>1;
        if (en<=mid) modify(x<<1,st,en,l,mid,delta);
        else if (mid+1<=st) modify(x<<1|1,st,en,mid+1,r,delta);
        else modify(x<<1,st,mid,l,mid,delta),modify(x<<1|1,mid+1,en,mid+1,r,delta);
        update(x);
    }

    LL query(int x,int st,int en,int l,int r)
    {
        clear(x,l,r);
        if (st==l&&en==r) return sum[x];
        int mid=l+r>>1;
        if (en<=mid) return query(x<<1,st,en,l,mid);
        else if (mid+1<=st) return query(x<<1|1,st,en,mid+1,r);
        else return query(x<<1,st,mid,l,mid)+query(x<<1|1,mid+1,en,mid+1,r);
    }

    void build(int x,int l,int r)
    {
        tag[x]=0;
        if (l==r)
        {
            sum[x]=0,size[x]=1;
            return;
        }
        int mid=l+r>>1;
        build(x<<1,l,mid),build(x<<1|1,mid+1,r),update(x);
    }
}t;

LL res[Q];
int stack[N],a[N],R[N];
int top,n,q,p1,p2;

struct qy
{
    int l,r,id;

    bool operator<(qy const x)const{return l<x.l;}
}ask[Q];

void calc()
{
    t.build(1,1,n+1),sort(ask+1,ask+1+q),a[stack[top=0]=n+1]=n+1;
    for (int i=n;i>=1;--i)
    {
        for (;top&&a[stack[top]]<a[i];--top);
        R[i]=stack[top],stack[++top]=i;
    }
    for (int i=n,cur=q;i>=1;--i)
    {
        t.modify(1,i+1,R[i],1,n+1,p2),t.modify(1,R[i],R[i],1,n+1,p1-2*p2);
        for (;cur&&ask[cur].l==i;--cur) res[ask[cur].id]+=t.query(1,1,ask[cur].r,1,n+1);
    }
}

int main()
{
    freopen("sf.in","r",stdin),freopen("sf.out","w",stdout);
    n=read(),q=read(),p1=read(),p2=read();
    for (int i=1;i<=n;++i) a[i]=read();
    for (int i=1;i<=q;++i) ask[i].l=read(),ask[i].r=read(),ask[i].id=i;
    calc(),reverse(a+1,a+1+n);
    for (int i=1;i<=q;++i) ask[i].l=n+1-ask[i].l,ask[i].r=n+1-ask[i].r,swap(ask[i].l,ask[i].r);
    calc();
    for (int i=1;i<=q;++i) write(res[i]),putchar('\n');
    fclose(stdin),fclose(stdout);
    return 0;
}