【ACWing】273. 分级（配数学证明）

题目地址：

https://www.acwing.com/problem/content/275/

给定长度为$n$的序列$a$，构造一个长度为$n$的序列$b$，满足：$b$非严格单调，即$b_1\le b_2\le \dots \le b_n$或$b_1\ge b_2\ge \dots \ge b_n$。最小化$s={\sum }_{i=1}^n|a_i-b_i|$。只需要求出这个最小值$s$。

输入格式：
第一行包含一个整数$N$。
接下来$N$行，每行包含一个整数$A_i$。

输出格式：
输出一个整数，表示最小$S$值。

数据范围：
$1\le N\le 2000$
$0\le A_i\le 10^6$

只考虑非降情形，可以证明最优解是存在的，这个较为显然，因为$S$必然是非负整数，而任意自然数集合一定是有最小值的。

法1：这个问题需要用到Slope Trick的技巧。先给几个定义：
考虑一元实值函数$f(x)$，如果$f$满足以下三条，我们就称其Slope Trickable：
1、$f(x)$连续；
2、$f(x)$可以分解为有限的若干子段，使得每一段里导数$f^{\prime }(x)$恒等于一个整数；
3、$f(x)$下凸，即$f^{\prime }(x)$单调增（严格的下凸函数定义并不等价导函数单调增，甚至可以导数不存在。这里不需要细究）。

不妨称这种函数为“好函数”。最经典的好函数是$|x-a|$，其满足上面的三个条件。容易证明，若干个好函数之和依然是好函数。

回到题目。设$f_i(x)$是只考虑$a_{1\sim i}$的情况下，并且$a_i\le x$，求得的$s$最小值。令$f_0(x)=0$。设$g_i(x)$也是只考虑$a_{1\sim i}$的情况下，并且$a_i=x$，求得的$s$最小值。显然有： { f i ( x ) = min ⁡ { g i ( t ) : t ≤ x } g i ( x ) = f i − 1 ( x ) + ∣ x − a i ∣ {fi(x)=min{gi(t):t≤x}gi(x)=fi−1(x)+|x−ai|

{fi​(x)=min{gi​(t):t≤x}gi​(x)=fi−1​(x)+∣x−ai​∣​我们证明$f_i(x)$也是好函数。可以用数学归纳法。$f_0$是好函数。假设对于$i\le k-1$，$f_i$是好函数，那么可以知道$g_i$也是好函数（好函数之和依然是好函数）。只需要证明如果$g$是好函数，则 h ( x ) = min ⁡ { g ( t ) : t ≤ x } h(x)=\min\{g(t):t\le x\} h(x)=min{g(t):t≤x}也是好函数。直观理解是很显然的，其实$h$满足，当$g$单调下降的时候，$h=g$，当$g$开始不下降的时候，$h$把那一段开始“拉平”，即斜率拉平为$0$。综上$f_i$是好函数。我们定义$f_i$的拐点多重集（下面简称“拐点集”），为其所有导数从左向右增加$1$的点，如果某个点处导数增加$k$，则将该点计入$k$次。例如$|x-1|$的拐点集为 { 1 , 1 } \{1,1\} {1,1}，因为在$1$的位置斜率由$-1\to 1$，变了$2$，所以$1$出现两次。

令$s_i=|a_1-b_1|+|a_2-b_2|+\cdot \cdot \cdot +|a_i-b_i|$，那么$s_i$能取到的最小值即为$t_i={\lim }_{x\to +\infty }{f}_i(x)$，所以我们本质上只需要每次求出$t_i$即可，最后返回$s=t_n$。注意到$f_{i-1}$右边充分远处导数一定为$0$，$g_i$右边充分远处导数一定为$1$。考虑$f_{i-1}$的最右边的不可导点（即$t_{i-1}$），分两种情况：
1、如果$a_i\ge t_{i-1}$，则$t_i=t_{i-1}$，比较显然。那么$f_i$的拐点集即在$f_{i-1}$的拐点集中加上$a_i$即可；
2、如果$a_i<t_{i-1}$，由于是加上了$|x-a_i|$这个函数，这个时候$t_i$的增加值其实就是$t_{i-1}-a_i$。那么$f_i$的拐点集中，$f_{i-1}$的最大拐点实际上拐的次数会少$1$（因为$|x-a_i|$在那个点的斜率为$1$），所以要将这个拐点从$f_{i-1}$拐点集中删除一次；而在$(a_i,t_{i-1})$这个区间内的拐点，次数是不变的，因为此区间内斜率都是增加$1$；然后$a_i$的拐点次数增加$2$；$(-\infty ,a_i)$里的拐点次数也是不变，因为斜率都是减$1$。

所以具体算法就是用一个最大堆维护拐点集，以求$s_i$。代码如下：

#include 
#include 
#include 
using namespace std;

const int N = 2010;
int n, a[N];

int solve() {
  int res = 0;
  priority_queue<int> heap;
  for (int i = 1; i <= n; i++) {
    heap.push(a[i]);
    if (a[i] < heap.top()) {
      res += heap.top() - a[i];
      heap.pop();
      // a[i]拐点次数需要增加2，所以这里要额外增加1次
      heap.push(a[i]);
    }
  }
  return res;
}

int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
  int res = solve();
  reverse(a + 1, a + 1 + n);
  printf("%d\n", min(res, solve()));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

时间复杂度$O(n\log n)$，空间$O(n)$。

法2：动态规划。可以证明，存在一个最优解$b$使得$b$中只出现$a$中的数字。证明参考https://blog.csdn.net/qq_46105170/article/details/126434918。设$a$从小到大排好序之后是$a^{\prime }$，设$f[i][j]$是只考虑$a_{1\sim i}$的，且$b_i=a_j^{\prime }$的时候，差的绝对值之和的最小值。那么可以按照$b_{i-1}$等于多少来分类，那么 b i − 1 ∈ { a 1 ′ , . . . , a i ′ } b_{i-1}\in\{a'_1,...,a'_i\} bi−1​∈{a1′​,...,ai′​}，所以 f [ i ] [ j ] = min ⁡ k ≤ j { f [ i − 1 ] [ k ] } + ∣ a j − a j ′ ∣ f[i][j]=\min_{k\le j}\{f[i-1][k]\}+|a_j-a'_j| f[i][j]=k≤jmin​{f[i−1][k]}+∣aj​−aj′​∣可以用一个变量维护$f[i-1][.]$的前缀最小值。代码如下：

#include 
#include 
using namespace std;

const int N = 2010, INF = 2e9;
int n, a[N], b[N];
int f[N][N];

int work() {
  for (int i = 1; i <= n; i++) b[i] = a[i];
  sort(b + 1, b + 1 + n);
  for (int i = 1; i <= n; i++) {
    int minv = INF;
    for (int j = 1; j <= n; j++) {
      minv = min(minv, f[i - 1][j]);
      f[i][j] = minv + abs(b[j] - a[i]);
    }
  }
  int res = INF;
  for (int i = 1; i <= n; i++) res = min(res, f[n][i]);
  return res;
}

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

  int res = work();
  reverse(a + 1, a + 1 + n);
  res = min(res, work());
  printf("%d\n", res);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

时空复杂度$O(n^2)$。