【问题描述】

$A$ 君有一个长度为 $n$ 的排列 $P$, 现在 $A$ 君想知道，有多少个连续整数组成的区间 $[l, r]$ 可以由 $P$ 中的两个区间 $[a, b], [c, d]$ 拼出，其中 $1 \le a \le b < c \le d \le n$。

例如 $P = [1, 5, 2, 4, 6, 3]$, 那么数字区间 $[5, 6]$ 可以由 $P$ 的区间 $[2, 2]$ 与 $[5, 5]$ 拼出。换句话说 $P$ 中这两个区间数字的并集为 $[l, r]$。

【数据范围】

$10\%$ 的数据： $n \le 20$

$40\%$ 的数据： $n \le 2000$

另有 $10\%$ 的数据： $P_i = i$

$100\%$ 的数据： $1 \le n \le 3 \times 10^5$

【题解】

首先我们考虑部分分的做法

一开始，我们会想到枚举 $a \le b \le c \le d$，并且看这两个区间的并是否是连续的数，期望得分：$10$。

然后，可以观察到题目问的是有多少区间 $[l,r]$ 满足题意，而不是求 $a,b,c,d$，因此我们考虑枚举区间 $[l,r]$，然后判断其在 $P$ 中是否为两个（或一个）区间，这样的复杂度是 $O(n^3)$ 的，也只有 $10$ 分。但是由于我们枚举的时候，其实是在确定 $l$ 的情况下，将 $[l,r]$ 不断从右侧加入一个数，因此我们可以维护一个 $\text{bool}$ 数组表示 $[l,r]$ 中的数字在 $P$ 里出现在那些位置。然后每加入一个数时，判断其两侧的数，如果两侧的数都不存在则段数 $+1$，都存在段数 $-1$，否则段数不变。最后统计段数小于三的区间 [l,r] 即可。复杂度 $O(n^2)$。

可是正解要能跑 $n \le 100000$ 啊，所以我们可能需要一个 $O(nlog(n))$ 的算法。我们发现其实按照原本这样写已经不好优化了，因此我们把这个暴力改写成我们习惯的 $\text{dp}$ 的形式，便于接下来的优化。

我们记 $i$ 在 $P$ 中的位置为 $\text{pos}$， $f_{l,r}$ 为区间 $[l, r]$ 会被分为 $P$ 中几段，那么由上可知 $\text{dp}$ 的方程，答案则是对于所有满足 $f_{i,j} \le 2$ 的数量。然后我们可以发现假定区间的右端点 $r$ 保持不变并且我们已知所有的 $f_{i-1,j}$，那么所有的 $f_{i,j}$ 可以由这样的更新方法来得到：

$\bullet$ 如果 $P_{pos−1}$ 与 $P_{pos+1}$ 中恰有一个数大于 $i$，令其为 $x$，则对于所有的 $i < j \le n$ 的 $j$，$f_{i,j} = f_{i-1,j} + 1$。

$\bullet$ 如果 $P_{pos−1}$ 与 $P_{pos+1}$ 中均小于 $i$，则对于所有的 $1 \le j \le n$ 的 $j$，$f_{i,j} = f_{i-1,j} + 1$。

（以上两种情况可以合并来考虑）

$\bullet$ 如果 $P_{pos−1}$ 与 $P_{pos+1}$ 中均大于 $i$，令其中小的那个数为 $x$，大的数为 $y$，则对于所有的$1 \le j \le x$ 的 $j$，$f_{i,j} = f_{i-1,j} - 1$，对于所有的$y < j \le n$ 的 $j$，$f_{i,j} = f_{i-1,j} + 1$，对于所有的$x < j \le y$ 的 $j$，$f_{i,j} = f_{i-1,j}$。

那么此时，如果我们把 $f_i$ 滚动掉会发生什么呢，是不是变成了一个一维的数组，然后你需要实现区间上的修改，并且对于每个 $i$ 查询数组内 $\le 2$ 的数字个数。

我们可以方便地使用线段树来维护这个数组，对于每个叶子节点我们存放 $f_j$ 的值，并且我们维护区间上的最小值，次小值及其个数即可。

于是你写个带区间修改的线段树就过了（

代码如下

#include <bits/stdc++.h>
#define R register
#define LL long long
#define Max(__a,__b) (__a<__b?__b:__a)
#define Min(__a,__b) (__a<__b?__a:__b)
using namespace std;
template<class TT>inline void read(R TT &x){
    x=0;R bool f=false;R char c=getchar();
    for(;c<48||c>57;c=getchar())f|=(c=='-');
    for(;c>47&&c<58;c=getchar())
        x=(x<<1)+(x<<3)+(c^48);
    (f)&&(x=-x);
}
int flag=1;
int n;
int P[300010],pos[300010];
char z[300010];
struct seg_tree{
    struct tree_node{
        int min[2],cnt[2],tag;
        inline void add(R int x){   
            min[0]+=x;
            min[1]+=x;
            tag+=x;
        }
    }t[1<<20];
    void build(R int l,R int r,R int i){
        t[i]=(tree_node){{0,1<<30},{r-l+1,0},0};
        if(l==r)return;
        R int mid=l+r>>1;
        build(l,mid,i<<1);
        build(mid+1,r,i<<1|1);
    }
    inline void push_down(R int i){
        if(t[i].tag){
            t[i<<1].add(t[i].tag);
            t[i<<1|1].add(t[i].tag);
            t[i].tag=0;
        }
    }
    void upd(R int l,R int r,R int i,R int ql,R int qr,R int qx){
        if(ql<=l&&r<=qr){
            t[i].add(qx);
            return;
        }
        push_down(i);
        R int mid=l+r>>1;
        if(qr<=mid)upd(l,mid,i<<1,ql,qr,qx);
        else if(ql>mid)upd(mid+1,r,i<<1|1,ql,qr,qx);
        else upd(l,mid,i<<1,ql,qr,qx),upd(mid+1,r,i<<1|1,ql,qr,qx);
        for(R int p=0,ml,mr,pl=0,pr=0;p<2;++p){
            ml=t[i<<1].min[pl];
            mr=t[i<<1|1].min[pr];
            if(ml<mr)t[i].min[p]=ml,t[i].cnt[p]=t[i<<1].cnt[pl++];
            else if(ml>mr)t[i].min[p]=mr,t[i].cnt[p]=t[i<<1|1].cnt[pr++];
            else t[i].min[p]=ml,t[i].cnt[p]=t[i<<1].cnt[pl++]+t[i<<1|1].cnt[pr++];
        }
    }
    int query(R int l,R int r,R int i,R int ql,R int qr){
        if(ql<=l&&r<=qr){return (t[i].min[0]<3?t[i].cnt[0]:0)+(t[i].min[1]<3?t[i].cnt[1]:0);}
        push_down(i);
        R int mid=l+r>>1;
        if(qr<=mid)return query(l,mid,i<<1,ql,qr);
        if(ql>mid)return query(mid+1,r,i<<1|1,ql,qr);
        return query(l,mid,i<<1,ql,qr)+query(mid+1,r,i<<1|1,ql,qr);
    }
}T;
int main(){
    read(n);
    for(R int i=1;i<=n;++i){
        read(P[i]);
        pos[P[i]]=i;
        if(P[i]!=i)flag=false;
    }
    if(flag)return (printf("%lld\n",(LL)n*(n-1)/2),0);
    R LL ans=0;
    T.build(1,n,1);
    for(R int r=1;r<=n;++r){
        R int t[2]={0},cnt=0;
        if(pos[r]>1&&P[pos[r]-1]<r)t[cnt++]=P[pos[r]-1];
        if(pos[r]<n&&P[pos[r]+1]<r)t[cnt++]=P[pos[r]+1];
        if(cnt<2)T.upd(1,n,1,t[0]+1,r,1);
        else{
            if(t[0]>t[1])swap(t[0],t[1]);
            T.upd(1,n,1,1,t[0],-1);
            T.upd(1,n,1,t[1]+1,r,1);
        }
        ans+=T.query(1,n,1,1,r);
    }
    printf("%lld\n",ans-n);
    return 0;
}