学习笔记：斜率优化DP

作为数学渣，先复习一下已知两点\((x_1, y_1)\)， \((x_2, y_2)\)，怎么求过两点的一次函数的斜率...

待定系数法代入 \(y = kx + b\) 有：

\(x_1k + b = y_1\)

\(x_2k + b = y_2\)

两式相减有：

\(k = \frac{y_2 - y_1}{x_2 - x_1}\)

---

故事围绕着《算法竞赛进阶指南》的三一道例题展开：

引子

任务安排 1：

发现一个关键性质：

假如我们启动了一个任务\([l, r]\)，那么它会对后面造成\(S * \sum_{i = r + 1}^{n} C_i\)的费用。

所以我们可以使用费用提前计算的方式优化算法：

设\(st\)为 \(t\) 的前缀和，设\(sum\)为\(C\)的前缀和

\(f[i]\) 表示安排完前 \(i\) 个任务的最小花费：

$f[i] = min(f[j] + (sum[i] - sum[j]) * t[i] + (sum[n] - sum[j]) * S) $

时间复杂度\(O(N ^ 2)\)

情况1. 斜率、横坐标皆单调递增

任务安排 2：

将上题推出的转移式子得\(min\)去掉观察：

\(f[i] = f[j] + (sum[i] - sum[j]) * t[i] + (sum[n] - sum[j]) * S\)

发现我们无法优化\(dp\)的原因是有与 \(i, j\) 两者都有关的乘积项，导致我们没有最优策略：

\(- sum[j] * t[i]\)

斜率优化

考虑把这个式子拆开转换为一次函数：\(y = kx + b\) 的形式。

• 将与 \(i,\ j\) 都有关系的乘积项作为 \(kx\)，其中与 \(i\) 有关的作为 \(k\)，与 \(j\) 有关的作为 \(x\)
• 将只与 \(j\) 有关系的值作为 \(y\)
• 其余的当做 \(b\)

则以上式子可以化成：

\(\underline{f[j]}_y = \underline{(t[i] + S)}_k * \underline{sum[j]}_x + \underline{f[i] - sum[i] * t[i] - sum[n] * S}_b\)

发现当 \(i\) 确定后，该一次函数的斜率 \(k\) 确定，则截距 \(b\) 越小， \(f[i]\) 越小。

我们将 \((x, y)\) 即 \((sum[j], f[j])\) 放在坐标系上。

则形象化可理解为一条直线从下往上平移，所碰到的第一个点即为最优解。

发现一个点如果被另外两个点围起来，永远不可能作为最优解。

删除了这些点后，发现相邻点之间的斜率为单调递增的，即构成一个凸包：

发现一个斜率 \(k\) 固定的直线所匹配的最优点满足：

• 其右边的斜率都 $ > k$
• 其左边的斜率都 \(< k\)

由于这道题斜率 \(t[i] + S\)、横坐标 \(sum[j]\) 皆单调递增。

1. 由于横坐标递增，所以维护凸包时，每当加入一个点时：

• 若上面两个点构成的斜率大于这个点和上一个点的斜率，即不满足单调性，可以弹出队尾。即：

  \(\frac{y_{q[tt]} - y_{q[tt - 1]}}{x_{q[tt]} - x_{q[tt - 1]}} >= \frac{y_{i} - y_{q[tt]}}{x_{i} - x_{q[tt]}}\)

1. 由于斜率递增，所以 \(i + 1\) 的最优解一定在 \(i\) 的右边，所以一旦队头两个点构成的斜率 $ < $ 当前的斜率，可以弹出队头。即满足：

   \(\frac{y_{q[hh + 1]} - y_{q[hh]}}{x_{q[hh + 1]} - x_{q[hh]}} < t[i] + S\)

然后队头的元素即为最优选择。

时间复杂度 \(O(N)\)

\(Tips:\)

1. 由于除法会有精度问题，可以通过交叉相乘的形式比较大小

#include <cstring>
#include <cstdio>
#include <iostream>
#define x(a) (c[a])
#define y(a) (f[a])
#define k(a) (t[a] + S)
using namespace std;
typedef long long LL;
const int N = 300005;
int n, S;
LL t[N], c[N], q[N], f[N];
int main() {
    scanf("%d%d", &n, &S);
    for (int i = 1; i <= n; i++) scanf("%lld%lld", t + i, c + i);
    for (int i = 1; i <= n; i++) t[i] += t[i - 1], c[i] += c[i - 1];
    int hh = 0, tt = 0;
    q[0] = 0;
    for (int i = 1; i <= n; i++) {
        while(hh < tt && (y(q[hh + 1]) - y(q[hh])) <= ((t[i] + S) * (x(q[hh + 1]) - x(q[hh])))) hh++;
        f[i] = f[q[hh]] + (c[i] - c[q[hh]]) * t[i] + (c[n] - c[q[hh]]) * S;
        while(hh < tt && ((y(q[tt]) - y(q[tt - 1])) * (x(i) - x(q[tt])) >= ((y(i) - y(q[tt])) * (x(q[tt]) - x(q[tt - 1]))))) tt--;
        q[++tt] = i;
    }
    printf("%lld\n", f[n]);
    return 0;
}

情况2. 横坐标单调递增

任务安排3

此时的斜率不再递增了，也就是我们不能\(pop\_front\)了，不过我们仍可以维护凸包，然后保持单调性，二分。

时间复杂度\(O(Nlog_2N)\)

#include <cstring>
#include <cstdio>
#include <iostream>
#define x(a) (c[a])
#define y(a) (f[a])
#define k(a) (t[a] + S)
using namespace std;
typedef long long LL;
const int N = 300005;
int n, S, t[N], c[N], q[N];
LL f[N];
int main() {
    scanf("%d%d", &n, &S);
    for (int i = 1; i <= n; i++) scanf("%lld%lld", t + i, c + i);
    for (int i = 1; i <= n; i++) t[i] += t[i - 1], c[i] += c[i - 1];
    int hh = 0, tt = 0;
    q[0] = 0;
    for (int i = 1; i <= n; i++) {
        int l = hh, r = tt;
        while(l < r) {
            int mid = (l + r) >> 1;
            if((y(q[mid + 1]) - y(q[mid])) >= ((LL)k(i) * (x(q[mid + 1]) - x(q[mid])))) r = mid;
            else l = mid + 1;
        }
        f[i] = f[q[r]] + (LL)(c[i] - c[q[r]]) * t[i] + (LL)(c[n] - c[q[r]]) * S;
        while(hh < tt && ((y(q[tt]) - y(q[tt - 1])) * (x(i) - x(q[tt])) >= ((y(i) - y(q[tt])) * (x(q[tt]) - x(q[tt - 1]))))) tt--;
        q[++tt] = i;
    }
    printf("%lld\n", f[n]);
    return 0;
}

例题

运输小猫

设 \(d[i]\) 为从 \(1\) 走到 \(i\) 的距离。

那么每条小猫最佳的出发时间应为 \(a[i] = t[i] - d[h[i]]\)，如果要接上这只猫，必须大于这个时间出发。

我们将 \(a\) 数组排序，那么问题等价转换于把 \(m\) 个点划分成 \(p\) 个连续区间，使每一段到右端点的距离之和的总和最小。（内心 \(OS\)：这不就是摆渡车的变种吗？）

那么朴素 \(dp\) 便很好列出了：

\(f[k][i]\) 表示将前 \(i\) 只小猫分成 \(k\) 组的最小总和。

设 \(sumA\) 为 \(a\) 数组的前缀和。

\(f[k][i] = min(f[k - 1][j] + a[i] * (i - j) - sumA[i] + sumA[j]) (0 <= j < i)\)

---

由于这里面有一个非常讨厌的 \(a[i] * -j\)，所以我们考虑斜率优化：

\(\underline{f[k - 1][j] + sumA[j]}_y = \underline{a[i]}_k * \underline{j}_x + \underline{f[k][i] - a[i] * i + sumA[i]}_b\)

发现这里的横坐标、斜率都是单调递增，即情况 \(1\)。那么我们可以将不需要的直接踢出即可。

时间复杂度 \(O(PM)\)

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 100005, S = 105;
int n, m, P, d[N], a[N], q[N];
LL f[S][N], sum[N];
LL inline y(int i, int k) {
    return f[k - 1][i] + sum[i];
}
int main() {
    memset(f, 0x3f, sizeof f);
    scanf("%d%d%d", &n, &m, &P);
    for (int i = 0; i <= P; i++) f[i][0] = 0;
    for (int i = 2; i <= n; i++)
        scanf("%d", d + i), d[i] += d[i - 1];

    for (int i = 1, h, t; i <= m; i++) {
        scanf("%d%d", &h, &t); a[i] = t - d[h];
    }
    sort(a + 1, a + 1 + m);
    for (int i = 1; i <= m; i++) sum[i] = sum[i - 1] + a[i];
    for (int k = 1; k <= P; k++) {
        int hh = 0, tt = 0;
        for (int i = 1; i <= m; i++) {
            while (hh < tt && (y(q[hh + 1], k) - y(q[hh], k))  <= (LL)a[i] * (q[hh + 1] - q[hh])) hh++;
            f[k][i] = f[k - 1][q[hh]] + (LL)a[i] * (i - q[hh]) - (sum[i] - sum[q[hh]]);
            while (hh < tt && (y(q[tt], k) - y(q[tt - 1], k)) * (i - q[tt])  >= (y(i, k) - y(q[tt], k)) * (q[tt] - q[tt - 1])) tt--;
            q[++tt] = i;
        }
    }
    printf("%lld\n", f[P][m]);
}