bzoj1367 [Baltic2004]sequence（可并堆+中位数）

Description

Input

Output

一个整数R

Sample Input

7
9
4
8
20
14
15
18

Sample Output

13

HINT

所求的Z序列为6,7,8,13,14,15,18.
R=13

Source

[ Submit][ Status][ Discuss]

分析：
这道题就是论文中的例题
昨天看了半天都没有明白论文说的是什么（果然，听不会唱的歌时想的全是歌词了，完全没办法看东西）

以下内容参考自论文

所谓登高自卑，我们对于所有问题，都要由浅入深，从易到难
我们先考虑两种极端情况

• t[1] <= t[2] <= t[3] <= … <= t[n]
  显然最优解就是z[1]=t[1]，z[2]=t[2]，…，z[n]=t[n]
• t[1] >= t[2] >= t[3] >= … >= t[n]
  显然最优解就是t[1]，t[2]，…，t[n]的中位数
  为什么呢

所以我们可以隐隐约约有这样的一个想法：
把1…n分成m个部分，每一个部分的z值是相同的，记为w[1]…w[m]
并且满足w[1] <= w[2] <= … <= w[m]

那么w[i]就是第i个区间的中位数

这样上述的第一种情况就可以视为n=m
第二种情况就可以视为m=1

现在我们需要的是证明想法的正确性，并提出ta的可行性

我们先从简单的情况入手，如果我们把整个序列只分成两部分：
若序列前半部分a[1]，a[2]，…，a[n]的最优解是（u，u，…，u），后半部分a[n+1]，a[n+2]，…，a[m]的最优解是（w，w，…，w），那么整个序列的最优解：

情况一

如果u<=w，那么最优解显然是（u，u，…，u，w，w，…，w）

情况二

如果u>w，我们设整个序列的最优解为（b[1],b[2],…,b[m]）
则显然b[n] < u（如果比u还大，那么两个部分的解都取不到最优解了），同理，b[n+1]>=w

对于任一个序列a[1]，a[2]，…，a[n]，如果最优解是（u，u，…，u），那么在满足u<=u0<=b[1]或b[n]<=u0<=u的情况下，（b[1]，b[2]，…，b[n]）不会比（u0，u0，…，u0）更优
（毕竟感性的认知一下，越接近最优解，得到的解越优）

我们现在要证明这样一个问题：

设一个长度为n的序列，最优解是（u，u，…，u，w，w，…，w），且u>w，
这种情况下，找到一解（b[1]<=b[2]<=…<=b[n]）,满足u<=u0<=b[1]
如果我们把解改成（b[1],b[1],…b[1]），不会使解变差

证：
首先我们把解改成（b[1],b[1],…b[1]），如果解变坏了
由归纳假设可以可知u < w，那么最优解就是（u，u，…，u，w，w，…，w），与题设矛盾
然后我们把（b[1],b[1],…b[1]）改成（u0,u0,…,u0）
想一下|a[1]-x|+|a[2]-x|+…+|a[n]-x|的几何意义是数轴上x到各个点的距离和
且u<=u0<=b[1]，那么这个解是不会比之前的任何一个可行解差的
证毕
（b[n]<=u0<=u的情况也同理）

也就是说我们可以把序列的解改为（b[n]，b[n]，…，b[n]，b[n+1]，b[n+1]，…，b[n+1]）
再者，我们之前就已经证明过了，整个序列的最优解应该是序列的中位数，
因此b[n]=b[n+1]=中位数

---

啰嗦了这么一大堆，是为什么呢？
我们需要利用上面的证明，构造出一种解题思路
假设对于一个序列，我们已经处理好了a[1]~a[k]的最优解（分成了m个区间，每个区间耳朵最优解为w[i]）
现在我们需要添加元素a[k+1]

首先我们把a[k+1]看做一个单独的区间加入这个序列
如果a[k+1]>=w[m]，那么我们就构造完了

如果a[k+1] < w[m]
我们就把a[k+1]合并到上一个区间，直到w[1]<=w[2]<=…<=w[m]

那我们用什么数据结构实现这个算法呢：
这个算法中设计了两个操作：合并区间，查询中位数
于是我们选择：

左偏树

tip

其实这道题的代码非常的别扭
然而这道题的精髓在于ta的分析及思维

//这里写代码片
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define ll long long

using namespace std;

const int N=1000010;
int n,root[N],dis[N],L[N],R[N],sz[N],tot[N],lc[N],rc[N];
ll val[N];

int merge(int x,int y)
{
    if (!x) return y;
    if (!y) return x;
    if (val[x]<val[y]) swap(x,y);
    rc[x]=merge(rc[x],y);
    sz[x]=sz[lc[x]]+sz[rc[x]]+1;
    if (dis[lc[x]]<dis[rc[x]]) swap(lc[x],rc[x]);
    if (!rc[x]) dis[x]=0;
    else dis[x]=dis[rc[x]]+1;
    return x;
}

int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%lld",&val[i]),val[i]-=i;

    int cnt=0;
    for (int i=1;i<=n;i++)
    {
        cnt++;
        root[cnt]=i;
        tot[cnt]=1;         //当前堆维护的中位数控制的数的个数   
        L[cnt]=R[cnt]=i;    //代表的区间的左右端点  
        sz[root[cnt]]=1;    //堆中元素的个数 

        while (val[root[cnt]]<val[root[cnt-1]]&&cnt>1)    //必须保证不增 
        {
            cnt--;
            R[cnt]=R[cnt+1];                              //控制的范围变大 
            tot[cnt]+=tot[cnt+1];                         
            root[cnt]=merge(root[cnt],root[cnt+1]);

            while (sz[root[cnt]]*2>tot[cnt]+1)            //保证堆顶元素是当前区间的中位数 
                root[cnt]=merge(lc[root[cnt]],rc[root[cnt]]);
        }
    }

    ll ans=0;
    for (int i=1;i<=cnt;i++)
        for (int j=L[i];j<=R[i];j++)
            ans+=(ll)abs(val[j]-val[root[i]]);
    printf("%lld",ans);
    return 0;
}