Codeforces 982D

此题从从一个特定角度想，就很好做，而直接枚举可行解，复杂度太高。 

可以想到，将所有的长度从大到小排序，逐个放回原来所在位置，任何一个可行解，必然满足是比可行解大或者等于可行解的值是排序后序列的前缀，这样，逐个放回，统计剩余区间的长度和个数即可。

这是自己笨拙的代码

#include<cstdio>
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;

const int inf = 1e9 + 10;
const int maxn = 5e5+10;
#define lson rt<<1
#define rson rt<<1|1
struct node{
    int l , r , max , min;
}a[maxn];
void build(int l, int r ,int rt){
     a[rt].l=l ; a[rt].r = r; a[rt].min =  inf ;a[rt].max = 0;
     if(l == r) return ;
     int m =(l + r) / 2;
     build(l , m , rt<<1);
     build(m +1 , r , rt<<1|1);
}
void insert(int l ,int r ,int rt ,int pos , int val){
    if(l == r) {
          a[rt].max = a[rt].min = val;
          return ;
    }
    int m = (l + r)/2;
    if(pos <= m) insert(l , m , lson ,pos , val);
    else insert(m + 1 , r , rson , pos, val);
    a[rt].max = std::max(a[lson].max , a[rson].max);
    a[rt].min = std::min(a[lson].min , a[rson].min);
}
int find_l(int l, int r, int rt, int pos){
    if(a[rt].min > pos) return 0;
    if(l ==r ) return l;
    int m =(l +r)>>1;
    if(a[rson].min  < pos) return find_l(m + 1,r,rson,pos);
    else return find_l(l,m,lson,pos);
}
    int n;
int find_r(int l, int r, int rt, int pos){
    if(a[rt].max < pos) return n + 1;
    if(l ==r ) return l;
    int m =(l +r)>>1;
    if(a[lson].max  > pos) return find_r(l,m,lson,pos);
    else return find_r(m+1,r,rson,pos);
}
struct Snode{
   int pos , val;
   bool operator < (const Snode& rhs){
        return val!=rhs.val ? val > rhs.val : pos > rhs.pos;
   }
}st[(int)1e5 + 199];
int seg[(int)1e5 + 10];
int segc = 1 , high;
int now_max = 0,now_pos = 0;
void update(int pos , int val){
    if(pos != now_pos && val > now_max) now_max = val , now_pos = pos;
    if(pos == now_pos) now_max = val;
}
int main()
{
    cin>>n; build(1,n,1);
    for(int i=1;i<=n;i++) scanf("%d",&st[i].val),st[i].pos=i;
    sort(st + 1 , st+1+n);
    ++seg[n];
    high = st[1].val + 1;
    int cnt = 1;
    for(int i=1;i<=n;i++){
         int l = find_l(1,n,1,st[i].pos) + 1;
         int r = find_r(1,n,1,st[i].pos) - 1;
         int m = st[i].pos;
         if(r >= l) {
              --seg[r - l + 1];
              if(seg[r - l + 1] == 0)  --cnt;
              update(r - l + 1 ,seg[r - l + 1]);
              if(r > m) {
                   ++seg[r - m];
                   update(r - m ,seg[r - m]);
                   if(seg[r - m] == 1) ++cnt;
              }
              if(m > l){
                   ++seg[m - l];
                   update(m - l ,seg[m - l]);
                   if(seg[m - l] == 1) ++cnt;
              }
         }
         if(cnt ==1){
               if(i < n ){
                    if(st[i + 1].val < st[i].val) {
                           if(segc <= now_max){
                               segc = now_max; high = st[i + 1].val + 1;
                           }
                    }
               }
         }
         insert(1,n,1,m,m);
    }
    cout<<high<<endl;
    return 0;
}

附上别人的代码：（区别在于自己写了一遍查询上下界的数据结构，很久没用STL不会用了）

#include <bits/stdc++.h>
using namespace std;
pair<int,int> a[100009];
int n,i,u,v,d,mx,ans,f[100009];
int main()
{
    map<int,int> mp;
    map<int,int>::iterator it;
    for(scanf("%d",&n),i=0; i<n; ++i) scanf("%d",&a[i].first),a[i].second=i;
    for(sort(a,a+n),ans=a[0].first+1,mp[0]=n-1,f[n-1]=1,mx=d=0,i=n; --i;)
    {
        it=mp.upper_bound(a[i].second),--it,u=(it->first),v=(it->second),mp.erase(it),--f[v-u],d-=(!f[v-u]);
        if(u!=a[i].second) mp[u]=a[i].second-1,d+=(!f[a[i].second-1-u]),++f[a[i].second-1-u];
        if(v!=a[i].second) mp[a[i].second+1]=v,d+=(!f[v-a[i].second-1]),++f[v-a[i].second-1];
        if(!d) if(mx<=mp.size()) mx=mp.size(),ans=a[i-1].first+1;
    }
    printf("%d\n",ans),exit(0);
}