Slope Trick：解决一类凸代价函数DP优化

【前言】

在补Codeforce的DP时遇到一个比较新颖的题，然后在知乎上刚好 hycc 桑也写了这道题的相关题解，这里是作为学习并引用博客的部分内容

这道题追根溯源发现2016年这个算法已经在APIO2016烟花表演与Codeforces 713C引入，自那之后似乎便销声匿迹了。相关题型数量也较少，因而在这里结合前辈们的工作做一些总结。---by hycc

问题引入：Codeforces 713C

题目链接：Here

题意：

给定 $n$ 个正整数 $a_i$ ，每次操作可以选择任意一个数将其 $+1$ 或 $-1$ ，问至少需要多少次操作可以使得 $n$ 个数保持严格单增。
数据范围：$1\le n\le 3000,1\le a_i\le 10^9$

对我来说这道题其实和曾经写过的 POJ-3666：求不升的DP是一样的

这个题是求升序的DP，那么有什么变化呢

不升的条件是：$a_i -a_j \ge 0$

升序的条件是：$a_i -a_j \ge i - j$ 对任意 $i,j$ 均满足

有没有理解到什么？移项有：$a_i - i \ge a_j - j$

所以将 $a$ 数字变形一下就和POJ3666就是一个题！

【AC Code】

const int N = 3100;

int n, m;

ll f[N][N], a[N], b[N];

int main() {

    cin.tie(nullptr)->sync_with_stdio(false);

    cin >> n;

    for (int i = 1; i <= n; ++i) {

        cin >> a[i];

        a[i] = a[i] - i;

        b[i] = a[i];

    }

    sort(b + 1, b + 1 + n);

    m = 1;

    for (int i = 2; i <= n; ++i) if (b[i] != b[i - 1]) b[++m] = b[i];

    memset(f, 0, sizeof(f));

    for (int i = 1; i <= n; ++i) {

        ll Min = LLONG_MAX;

        for (int j = 1; j <= m; j++) {

            Min = min(Min, f[i - 1][j]);

            f[i][j] = abs(b[j] - a[i]) + Min;

        }

    }

    ll ans = LLONG_MAX;

    for (int i = 1; i <= m; ++i) ans = min(ans, f[n][i]);

    cout << ans << "\n";

}

当然上面说的思路并不是本篇博客实际想表达，以下才是正文

对于朴素的 $\mathcal{O}(n^2)\ DP$ ：

一个显然的性质：如果不是“严格单增”而是“严格非降”，那么最终形成的严格非降序列，其中每个元素一定属于 $\{a_i\}$

将元素离散化后可以设计 $f_{i,j}$ 表示到第 $i$ 个数取 $j$ 的最少操作数

那么有转移 $f_{i,j} = \min\limits_{k\le j}f_{i-1,k} + | a_i - j|$ ，记录 $f_{i-1,*}$ 的前缀 $\min$ 即可做到 $\mathcal{O}(n^2)$

至于如何做到“严格非降”，$a_{i-1} < a_i,a_{i -1} \le a_i - i,a_{i-1}-(i-1)\le a_i - i$

于是令 $a_i = a_i - i$ 即可。

赛后的评论区中出现了一种 $\mathcal{O}(Nlog\ N)$的做法，也就是 Slope Trick算法的第一次现身（？）

Slope Trick：解决一类凸代价函数的DP优化问题

当序列DP的转移代价函数为

连续

分段线性函数

凸函数

时，可以通过记录分段函数的最右一段 $f_r(x)$ 以及其分段点 $L$ 实现快速维护代价的效果。

如：$f(x)=\left\{\begin{array}{rr}
-x-3 & (x \leq-1) \\
x & (-1<x \leq 1) \\
2 x-1 & (x>1)
\end{array}\right.$

可以仅记录 $f_r(x) = 2x - 3$ 与分段点 $L_f = \{-1,-1,1\}$ 来实现对该分段函数的存储。

注意：要求相邻分段点之间函数的斜率差为 $1$ ，也就是说相邻两段之间斜率差 $\ge 1$ 的话，这个分段点要在序列里出现多次。

优秀的性质：

$F(x),G(x)$ 均为满足上述条件的分段线性函数，那么 $H(x) =F(x)+G(x)$ 同样为满足条件的分段线性函数，且 $H_r(x) = F_r(x) + G_r(x),L_H = L_F \bigcup L_G$ 。

该性质使得我们可以很方便得运用数据结构维护 $L$ 序列。

回顾：Codeforces 713C

转移方程为 $f_{i,j} = \min\limits_{k\le j}f_{i-1,k} + |a_i - j|$

令 $F_{i}(x)=f_{i, x}, G_{i}(x)=\min\limits _{k \leq x} f_{i-1, k}=\min \limits_{k \leq x} F_{i-1}(k)$

那么有 $F_i(x) = G_i(x) + |x -a_i|$ ，其中 $F_i,G_i$ 均为分段线性函数。

$G_i$ 求的是 $F_{i-1}$ 的关于函数值的前缀最小值，由于 $F_{i-1}$ 是一个凸函数，因而其最小值应该在斜率 $=0$ 处取得，其后部分可以舍去。

而每次由 $G_i(x)$ 加上 $|x-a_i|$ ，等价于在 $L$ 中添加两个分段点 $\{a_i,a_j\}$

因而 $G_i$ 各段的函数斜率形如 $\{...,-3,-2,-1,0\}$ ，加上 $|x-a_i| $后斜率变为 $\{...,-3,-2,-1,0,1\}$ ，因而需要删除末尾的分段点。

具体实现中：使用大根堆维护分段点单调有序，每次加入两个 $a_i$ ，再弹出堆顶元素。

总复杂度：$\mathcal{O}(n\ log\ n)$

\[QAQ
\]

Codeforces 1534G

题意：

一个无限大的二维平面上存在 $n$ 个点 $(x_i,y_i)$ 均需要被访问一次，从 $(0,0)$ 出发，每次可以向右或向上移动一个单位。

可以在任意位置 $(X,Y)$ 访问 $(x_i,y_i)$ 并付出 $\max\{|X-x_i|,|Y-y_i|\}$ 的代价（访问后依然留在 $(X,Y)$ )。同一位置可以访问多个点。

问：至少需要花费多少代价才能使得所有点均被访问？

数据范围： $1\le n\le 800000,0\le x_i,y_i\le 10^9$

结合上图可以看出，对于点 $(X,Y)$ ，一定会选择路径与直线 $x+y=X+Y$（红线）的交点 $(x,y)$ 处作为访问的发起点（在这条线上 $|X-x| = |Y-y|$ )。

考虑到这条红线是倾斜的，因而将坐标系顺时针翻转 $45^°$，即 $(x+y,x-y)$ 代替 $(x,y)$

此时，每次移动变为 $(x+1,y-1)$ 或 $(x+1,y+1)$

把所有点按新的 $x$ 坐标排序，即可转为序列上的问题。

设值域为 $M$ ，则很容易写出 $\mathcal{O}(nM)$ 的转移方程：

$f_{i,Y}$ 表示从左到右考虑到横坐标为 $x_i$ 的所有点，当前路径到了 $(x_i,Y)$ 的最小代价，

那么有

$f_{i,Y}=\min\limits_{Y-\left|x_{i}-x_{i-1}\right|\leq k\leq Y+\left|x_{i}-x_{i-1}\right|}f_{i-1, k}+\sum\limits_{(x, y), x=x_{i}}|Y-y| $

同样，设 $F_{i}(x)=f_{i, x}, G_{i}(x)=\sum\limits_{x-\left|x_{i}-x_{i-1}\right| \leq k \leq x+\left|x_{i}-x_{i-1}\right|} f_{i-1, k}$

那么 $F_{i}(x)=G_{i}(x)+\sum_{\left(x^{\prime}, y^{\prime}\right), x^{\prime}=x_{i}}\left|x-y^{\prime}\right|$

主要问题在于 $G_i(x)$ 的维护，是取一个区间范围 $[L,R]$ 内的最小值。

若斜率为 $0$ 的两端点在 $[L,R]$ 内，那么直接取最小值即可。

若斜率为 $0$ 的两端点在 $L$ 左侧，需要取 $L$ 处的值作为最小值。

若斜率为 $0$ 的两端点在 $R$ 右侧，需要取 $R$ 处的值作为最小值。

因而，需要维护斜率为 $0$ 的折线的两侧分割点 $(a,b)$ ，同时还需要支持从斜率为 $0$ 处向两侧访问，因而使用小根堆与大根堆分别维护 $b$ 右侧以及 $a$ 左侧的点。

每次添加新的分割点时，根据新分割点与 $a,b$ 的大小关系决定插入小根堆or大根堆，同时调整 $a,b$ ，每次调整复杂度是 $\mathcal{O}(1)$ 的（从小根堆中取出塞入大根堆或反之)

【AC Code】借用 jiangly的代码

#include <bits/stdc++.h>

using i64 = long long;

int main() {

    std::ios::sync_with_stdio(false);

    std::cin.tie(nullptr);

    int n;

    std::cin >> n;

    std::vector<std::pair<int, int>> a;

    for (int i = 0; i < n; i++) {

        int x, y;

        std::cin >> x >> y;

        a.emplace_back(x + y, x);

    }

    std::priority_queue<i64> hl;

    std::priority_queue<i64, std::vector<i64>, std::greater<>> hr;

    for (int i = 0; i < n + 5; i++) {

        hl.push(0);

        hr.push(0);

    }

    i64 tag = 0, mn = 0;

    int last = 0;

    std::sort(a.begin(), a.end());

    for (auto [s, x] : a) {

        int d = s - last;

        last = s;

        tag += d;

        if (x <= hl.top()) {

            mn += hl.top() - x;

            hl.push(x);

            hl.push(x);

            hr.push(hl.top() - tag);

            hl.pop();

        } else if (x >= hr.top() + tag) {

            mn += x - (hr.top() + tag);

            hr.push(x - tag);

            hr.push(x - tag);

            hl.push(hr.top() + tag);

            hr.pop();

        } else {

            hl.push(x);

            hr.push(x - tag);

        }

    }

    std::cout << mn << "\n";

    return 0;

}