[BOI2004]Sequence 数字序列

嘟嘟嘟

 

这道题要是直接想正解实在太难了，还得从一些特殊的情况一点点入手。

1.如果ai本身就是递增的，那么令b_i = a_i即最优解。

2.如果a_i严格递减，则b₁ = b₂ = b₃ = ……= b_n = 中位数为最优解。这个可以用初中的几何证明：把 |b_i - a_i| 想象成数轴上两点间距离，那么 |x - a₁| + |x - a₂|的最优解x一定a₁和a₂之间；扩展到三项：|x - a₁| + |x - a₂| + |x - a₃|，那么x就是中位数；以此类推，x是中位数得证。

现在再想想一般情况：对于数列{a_n}，可能有一段递增，有一段递减，那么就把这些看成一段一段的：初始每一段的长度都为1，令中位数为c_i，则c_i = a_i。若c_i < c_i+1，那么就保持不变；否则将c_i和c_i+1所在的区间合并，取一个新的中位数，作为新区间的答案。就这样不断的合并，直到c_i不下降。

因此我们需要一个数据结构，支持合并、查询最大值和删除。为什么要查询最大值和删除呢？因为维护中位数可以只维护⌈1/2区间长度⌉小的数，用一个大根堆，则堆顶就是中位数。合并完两个区间后，就一直删除堆顶，直到元素个数 = ⌈1/2区间长度⌉。

那么就能想到用左偏树实现啦。所以左偏树并不是这道题的核心，实际上只起到了一个优化的作用。

最后一点，就是题中让求的是严格递增，然而我们一直是在不下降的前提下思考的。有一个巧妙的做法，就是开始a_i -= i，就转换成了不下降。

代码稍微参考了别人的题解（左偏树还是不太熟啊）。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e6 + 5;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) {last = ch; ch = getchar();}
  while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int n;

struct Node
{
  int root, l, r, siz;
  ll val;
}st[maxn];
int top = 0;

ll val[maxn];
int dis[maxn], ls[maxn], rs[maxn];
int merge(int x, int y)
{
  if(!x || !y) return x | y;
  if(val[x] < val[y]) swap(x, y);
  rs[x] = merge(rs[x], y);
  if(dis[rs[x]] > dis[ls[x]]) swap(rs[x], ls[x]);
  dis[x] = dis[rs[x]] + 1;
  return x;
}
int Del(int x)
{
  return merge(ls[x], rs[x]);
}

ll ans = 0;

int main()
{
  n =  read();
  for(int i = 1; i <= n; ++i) val[i] = read() - i;
  st[++top] = (Node){1, 1, 1, 1, val[1]};
  for(int i = 2; i <= n; ++i)
    {
      st[++top] = (Node){i, i, i, 1, val[i]};
      while(top && st[top].val < st[top - 1].val)
    {
      top--;
      st[top].root = merge(st[top].root, st[top + 1].root);
      st[top].siz += st[top + 1].siz;
      st[top].r = st[top + 1].r;
      while(st[top].siz > (st[top].r - st[top].l + 1 + 1) >> 1)    //向上取整 
        {
          st[top].siz--;
          st[top].root = Del(st[top].root);
        }
      st[top].val = val[st[top].root];
    }
    }
  for(int i = 1, j = 1; i <= n; ++i)
    {
      if(i > st[j].r) j++;
      ans += abs(st[j].val - val[i]);
    }
  write(ans); enter;
  for(int i = 1, j = 1; i <= n; ++i)
    {
      if(i > st[j].r) j++;
      write(st[j].val + i), space;
    }
  enter;
  return 0;
}