BZOJ 1367 [Baltic2004]sequence (可并堆)

题面：BZOJ传送门

题目大意：给你一个序列$a$，让你构造一个递增序列$b$，使得$\sum |a_{i}-b_{i}|$最小，$a_{i},b_{i}$均为整数

神仙题..

我们先考虑b不递减的情况

假设现在有一段单调的序列$A$

如果$A$是递增的，显然$b[i]=a[i]$是最优解

如果$A$是递减的，$b$的每一项=序列$A$的中位数时是最优解

简单证明一下递减的情况：

1.序列$A$元素数量是奇数时，我们以中位数为对称轴，那么对称的两个数带来的贡献就是它们的差值，而中位数本身不会产生贡献，如果选取的不是中位数，必然会导致中位数产生贡献，而且对称的两个数还可能产生差值以外的贡献

2.序列$A$元素数量是偶数时，选取的数在中间的两个数之间即可，贡献都是一样的

我们如何利用这一性质呢？

我们把序列拆分成很多递减的段，递增子段的每一个数都是单独的一段

我们的目的是保证$b$不递减，即把每一段取的数画成一个函数来看是不递减的

每次我们在序列末尾加入一个数$a_{i}$，都看看这一段的中位数是否$\geq $前面一段的中位数，不满足就和前一段合并，然后依次重复此过程

为什么答案合并后不会变差？太弱了并不会证..感性理解一下吧。因为这两段原来取的就是最优解，但并不满足要求，我们也只能把两段合并，再用相同的方法求最优解了..

具体实现可以用左偏树维护大根堆，记录每一段较大的$\left \lceil \frac{n}{2} \right \rceil$个数，当两个奇数段合并时删除一次堆顶即可，记录每一段的信息可以用结构体

 #include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define N1 1000010
 #define ll long long
 using namespace std;
 const ll inf=0x3f3f3f3f3f3f3f3fll;

 template <typename _T> void read(_T &ret)
 {
     ret=; _T fh=; char c=getchar();
     while(c<''||c>''){ if(c=='-') fh=-; c=getchar(); }
     while(c>=''&&c<=''){ ret=ret*+c-''; c=getchar(); }
     ret=ret*fh;
 }

 struct Heap{
 int fa[N1],ch[N1][],h[N1]; ll val[N1];
 int merge(int x,int y)
 {
     if(!x||!y) return x+y;
     if(val[x]<val[y]) swap(x,y);
     //pushdown(x);
     ch[x][]=merge(ch[x][],y); fa[ch[x][]]=x;
     if(h[ch[x][]]<h[ch[x][]]) swap(ch[x][],ch[x][]);
     h[x]=h[ch[x][]]+;
     return x;
 }
 int del(int x)
 {
     fa[ch[x][]]=fa[ch[x][]]=;
     int y=merge(ch[x][],ch[x][]);
     ch[x][]=ch[x][]=;
     return y;
 }
 }h;

 ll a[N1];
 struct node{int l,r,x;};
 node stk[N1]; int n,tp;

 int main()
 {
     scanf("%d",&n);
     int i,j,x,y,len; node K; ll ans=,tmp;
     for(i=;i<=n;i++) read(a[i]);
     for(i=;i<=n;i++)
     {
         h.val[i]=a[i]-i; x=i; len=;
         while(tp)
         {
             K=stk[tp];
             if(h.val[x]>=h.val[K.x]) break;
             x=h.merge(x,K.x); tp--;
             if( (len&) && ((K.r-K.l+)&) ) x=h.del(x);
             len+=K.r-K.l+;
         }
         stk[++tp]=(node){i-len+,i,x};
     }
     for(i=;i<=tp;i++)
     for(j=stk[i].l;j<=stk[i].r;j++)
     {
         tmp=a[j]-(h.val[stk[i].x]+j);
         ans+=((tmp>)?tmp:-tmp);
     }
     printf("%lld\n",ans);
     return ;
 }