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

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

奈文摩尔有 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]。

输入文件名为 sf.in。

第一行 n,m,p1,p2

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

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

30%：1<= n,m <= 500。

另 30%: p1=2*p2。

100%:1 <= n,m <= 200000；1 <= p1,p2 <= 1000。 

题解：

首先满足答案的条件很容易想，但一直不会打主席树，所以不知道怎么统计，今天学到了线段树解法.

设R[i]为i之后大于a[i]的第一个数的位置.L[i]为i之前大于a[i]的第一个数的位置.

容易想到:

1.每组[i,L[i]] [R[i],i] [i,i+1]可以贡献p1

2.[L[i],j] (i+1<=j<=R[i]-1)  [j,R[i]](L[i]+1<=j<=i-1) 都可以贡献p2

然后就是统计:

这里都是考虑i作为有p2贡献的区间中，两端点中较大的一个.

我们假设i和[i+1,R[i]-1]之间的数都可以搭配成p2的条件,然后我们就在线段树中把[i+1,R[i]-1]加上p2.

但是并不一定满足p2的条件 ，我们先不考虑，

明显的：在i作为较大的一方时，i和R[i]不可以形成p2的形式，但是肯定可以产生p1的贡献，所以加上p1减去p2，使得之前不合法的计算都抵消了.

然后再反转数组.

求出i和L[i]搭配的答案.

程序流程就是：

1.i从n到1枚举 每一次把[i+1,R[i]-1]加上p2，并且把R[i]处加上p1-p2.

2.L端点在i的询问就+=[1,R]的和  R为询问的端点.

3.反转数组和询问 进行相同操作.

 

代码不过100行：

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #include<algorithm>
 5 using namespace std;
 6 typedef long long ll;
 7 const int N=200005;
 8 int gi(){
 9     int str=0;char ch=getchar();
10     while(ch>'9' || ch<'0')ch=getchar();
11     while(ch>='0' && ch<='9')str=str*10+ch-'0',ch=getchar();
12     return str;
13 }
14 int L[N],R[N],n,m,p1,p2,a[N],q[N];
15 ll Tree[N*4],mark[N*4],ans[N];
16 struct AKK{
17     int id,l,r;
18 }ques[N];
19 #define ls (node<<1)
20 #define rs (node<<1|1)
21 void pushdown(int node,int l,int r)
22 {
23     if(!mark[node])return ;
24     int sizels=((l+r)>>1)-l+1,sizers=r-((l+r)>>1);
25     Tree[ls]+=mark[node]*sizels;Tree[rs]+=mark[node]*sizers;
26     mark[ls]+=mark[node];mark[rs]+=mark[node];
27     mark[node]=0;
28 }
29 void updata(int node){Tree[node]=Tree[ls]+Tree[rs];}
30 void change(int l,int r,int node,int sa,int se,int ad)
31 {
32     if(r<sa || l>se)return ;
33     if(sa<=l && r<=se)
34     {
35         Tree[node]+=(ll)ad*(r-l+1);mark[node]+=ad;
36         return ;
37     }
38     pushdown(node,l,r);
39     int mid=(l+r)>>1;
40     change(l,mid,ls,sa,se,ad);
41     change(mid+1,r,rs,sa,se,ad);
42     updata(node);
43 }
44 ll getsum(int l,int r,int node,int sa,int se)
45 {
46     if(r<sa || l>se)return 0;
47     if(sa<=l && r<=se)return Tree[node];
48     pushdown(node,l,r);
49     int mid=(l+r)>>1;
50     return getsum(l,mid,ls,sa,se)+getsum(mid+1,r,rs,sa,se);
51     updata(node);
52 }
53 void pf()
54 {
55     int r=0;
56     q[r]=n+1;
57     for(int i=n;i>=1;i--)
58     {
59         while(r>0 && a[i]>=a[q[r]])r--;
60         R[i]=q[r];
61         q[++r]=i;
62     }
63 }
64 void work()
65 {
66     pf();
67     int k=m;
68     for(int i=n;i>=1;i--)
69     {
70         if(i+1<=R[i]-1)
71         change(1,n+1,1,i+1,R[i]-1,p2);change(1,n+1,1,R[i],R[i],p1-p2);
72         while(k>0 && ques[k].l==i)ans[ques[k].id]+=getsum(1,n+1,1,1,ques[k].r),k--;
73     }
74 }
75 void Clear(){memset(Tree,0,sizeof(Tree));memset(mark,0,sizeof(mark));}
76 bool comp(const AKK &p,const AKK &qq){return p.l<qq.l;}
77 int main()
78 {
79     n=gi();m=gi();p1=gi();p2=gi();
80     for(int i=1; i<=n; i++)a[i]=gi();
81     for(int i=1;i<=m;i++)ques[i].l=gi(),ques[i].r=gi(),ques[i].id=i;
82     sort(ques+1,ques+m+1,comp);
83     work();
84     for(int i=1;i<=m;i++)ques[i].l=n+1-ques[i].l,ques[i].r=n+1-ques[i].r,swap(ques[i].l,ques[i].r);
85     reverse(a+1,a+n+1);
86     sort(ques+1,ques+m+1,comp);
87     Clear();
88     work();
89     for(int i=1;i<=m;i++)printf("%lld\n",ans[i]);
90     return 0;
91 }