Codeforces1156 E. Special Segments of Permutation（单调栈，复杂度分析）

题意：

解法：

显然要预处理每个数作为最大值能扩展的最大左右位置L[i]和R[i],
这个可以用单调栈预处理.

一个暴力的做法是,枚举左边[L[i],i-1]中的数x,判断a[i]-x是否在[i+1,R[i]]中即可.

这样的话复杂度似乎是O(n^2)的,但是可以这样优化:
如果左边的数个数<右边的数个数,那么枚举左边,否则枚举右边.
这样的话每个数需要枚举的范围至多为最大扩展区间长度的一半.

这样每个数最多被枚举到log次,为什么呢?
对于[L[i],R[i]],假设区间长度为m,
选取小区间之后区间长度<=m/2,
在这个小区间内的数继续划分为更小区间之后,区间长度<=m/4,
...
所以是log次.

ps:
据说复杂度分析用笛卡尔树的知识比较好理解,
不过我还没学过笛卡尔树.

code：

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxm=2e6+5;
int L[maxm],R[maxm];
int pos[maxm];
int a[maxm];
int n;
void solve(){
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int i=1;i<=n;i++)pos[a[i]]=i;
    stack<int>s;
    a[0]=a[n+1]=1e9;
    for(int i=1;i<=n+1;i++){
        while(s.size()&&a[s.top()]<a[i]){
            R[s.top()]=i-1;s.pop();
        }
        s.push(i);
    }
    while(s.size())s.pop();
    for(int i=n;i>=0;i--){
        while(s.size()&&a[s.top()]<a[i]){
            L[s.top()]=i+1;s.pop();
        }
        s.push(i);
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        if(i-L[i]<R[i]-i){
            for(int j=L[i];j<i;j++){
                int x=a[i]-a[j];
                if(pos[x]>i&&pos[x]<=R[i]){
                    ans++;
                }
            }
        }else{
            for(int j=i+1;j<=R[i];j++){
                int x=a[i]-a[j];
                if(pos[x]>=L[i]&&pos[x]<i){
                    ans++;
                }
            }
        }
    }
    cout<<ans<<endl;
}
signed main(){
    ios::sync_with_stdio(0);cin.tie(0);
    solve();
    return 0;
}

---