「DP 浅析」斜率优化
斜率优化的简单讲解
#0.0 屑在前面
将结合经典例题 「HNOI2008」玩具装箱 以及 「NOI2007」货币兑换 进行讲解。
#1.0 简述
#1.1 适用情况
斜率优化一般适用于状态转移方程如下的 DP
其中 \(a_i,b_j,c_i, d_j\) 在计算 \(f_i\) 时都是常数（已知量）。
#1.2 大致思想
为了方便叙述，下文中的方程都采用 \(f_i=\min\limits_{0\leq j<i}\{a_i\cdot b_j + c_i + d_j\}\) 的形式。
假设我们从决策点 \(j\) 处转移到 \(i\)，那么应当有转移式
此时，对于众多可能的决策点 \((b_j,d_j)\)，将上式化作一个直线斜截式方程，于是有
换句话讲，其实这里的形式转换就是将只与 \(j\) 有关的项放到一边，剩下的放到另一边。
又因为 \(c_i\) 是一个已知的常数，于是我们的目的就变为了对于斜率 \(-a_i\)，在所有的决策点中，我们选择需要令直线的截距 \(f_i-c_i\) 尽可能小那一个。
此时，我们还不能仅利用上面的结论对 DP 的时间复杂度进行优化，我们还需要研究决策点的性质。首先，不难看出，仅有所有下凸包上的点是可能的决策点，如下图：
显然（相对较严谨的证明见 #1.3 关于决策一定在凸包上的证明）不在下凸包上的点，无论在哪种斜率下，在下凸包上都具有更好的替代品。
一个经典的结论是：对于指定斜率 \(k\) 的直线，与上/下凸包上相切确定的一条纵轴截距最大/最小。而由于下凸壳上的线段直线的斜率单调递增，于是一个点是切点当且仅当其左边的线段斜率 \(<k\) 而右边的 \(>k\)。
综上，我们在寻找最优决策点的时候就可以通过 \(O(n\log n)\) 维护整个下凸包，单次 \(O(\log n)\) 二分查询寻找最优决策点的位置，另一种写起来更加简洁的方式是采用 CDQ 分治。同时，如果决策点本身具有一定的特殊性质（如单调性），我们甚至可以不保存整个下凸包，对时间复杂度可能又有进一步的优化。这些在下文都会提到。
#1.3 关于决策一定在凸包上的证明
这里状态转移方程依旧都采用 \(f_i=\min\limits_{0\leq j<i}\{a_i\cdot b_j + c_i + d_j\}\) 的形式。
设 \(0\leq j_1<j_2<i\) 为 \(i\) 的两个决策点，且满足决策点 \(j_2\) 优于 \(j_1\)，那么有
接下来的一步是进行参变分离，将含有 \(j\) 的项视为常数，将含有 \(i\) 的项视为变量（即使它本身应当是常数），然后进行移项，尝试用含 \(j\) 的项表示出含 \(i\) 的项。
那么此时对于 \(b_{j_1},b_{j_2}\) 的大小分类讨论（不考虑 \(b_{j_1}=b_{j_2}\) 的情况）有
如果我们将决策点表示为 \((b_j,d_j)\)，那么此时不等号右边是斜率式的形式。
考虑位置关系如下的三个决策点：
设此时 \(A\) 与 \(B\) 两点之间的线段的斜率为 \(k_0\)，我们对 \(-a_i\) 进行分类讨论。
第一种情况是 \(k_0>-a_i\)，此时显然有 \(\overline {BC}\) 的斜率 \(k_1>k_0>-a_i\)，而根据 \((1)\)，如果 \(C\) 比 \(B\) 更优，应当有 \(k_1\leq-a_i\)，矛盾，于是此时应当点 \(B\) 更优。
第二种情况是 \(-a_i>k_0\)，此时显然有 \(\overline{AC}\) 的斜率 \(k_2<k_0<-a_i\)，根据 \((1)\)，如果 \(C\) 比 \(A\) 更优，应当有 \(k_1\geq-a_i\)，矛盾产生，于是此时必然有点 \(A\) 更优。
最后一种情况是 \(-a_i=k_0\)，设此时有 \(k_2<k_0=-a_i<k_1\)，于是 \(A,B\) 两点都要比 \(C\) 更优。
综上，我们可以知道，如果 \(C\) 不在凸包上，那么在凸包上一定存在两点可以替代 \(C\)。
同理，我们可以对于状态转移方程为 \(f_i=\max\limits_{0\leq j<i}\{a_i\cdot b_j + c_i + d_j\}\) 的决策进行证明。
#2.0 决策具有单调性
这里以 「HNOI2008」玩具装箱 作为例题。
#2.1 转移方程及转化
设 \(f_i\) 表示前 \(i\) 个物品的最小代价，不难写出状态转移方程：
设 \(S_i=i+\sum_{k=1}^iC_i,T=L+1\)，将上式简写为
假设从决策点 \(j\) 处转移，应当有
我们将上面的式子转化为如下形式
这正与 #1.0 简述 中的形式相对应，于是我们的目的是对于斜率 \(2S_i\) 找到一个决策点 \((S_j,f_j+2S_j\cdot T+S_j^2)\) 使得截距 \(f_i-(S_i-T)^2\) 尽可能小。此时已经可以做到 \(O(n\log n)\).
#2.2 决策单调性
我们注意到，\(C_i\) 一定是一个正数，于是 \(2S_i\) 一定单调递增，也意味着我们所需要的斜率一定是单调递增的，且对于所有决策点 \(j\)，其在坐标系上的位置一定是从左到右依次排布的；由上文我们可以知道，可行的决策点一定在凸包上，而下凸包上的线段斜率一定是单调递增的，于是最优决策点应当具有单调性。
同样，这一点我们也可以采用 四边形不等式 进行证明。
我们将 \((S_i-S_j-T)^2\) 作为 \(w(j,i)\)，下面证明 \(w(j,i)\) 满足四边形不等式：
要证明 \(w(j,i)\) 满足四边形不等式，我们只需证明[4] \(w(j,i)\) 满足 \(\forall \ell<r\)，有
证明：
设 \(\ell<r\)，有
于是，如果要证明 \(w(\ell, r)+w(\ell+1,r+1)\leq w(\ell,r+1)+w(\ell+1,r)\)，只需证明
而又有
又因为 \(C_{r+1},C_{\ell+1},r,\ell\in\mathbb Z^*\)，于是有
于是有 \((3)\) 成立，便可得 \((2)\) 成立，于是 \(w(j,i)\) 满足四边形不等式。
证毕.
于是，我们已知 \(w(j,i)\) 满足四边形不等式，便可以知道 \(f_i\) 具有决策单调性[5]。
我们便可以利用二分 + 类似单调队列的方式通过维护所有位置的可能最优决策点做到 \(O(n\log n)\)[6].
#2.3 最终实现
事实上， 这道题目不仅具有决策单调性，上面利用决策单调性的时间复杂度中的 \(\log n\) 是因为需要二分查找新的决策从什么时候开始作为可能的最优决策。
实际上， 本题不需要维护所有的最优决策点，我们还是回到斜率优化最富有内涵的图像上来，由于具有决策单调性，于是我们对于 \(i_1<i_2\)，所有在 \(i_1\) 的最优决策点前的决策点对于 \(i_2\) 都不是最优的，可以直接丢掉，这样将不合法的决策点删掉后，在最左边位置的决策点一定是最优决策点；而将 \(i_1\) 作为新决策点加入图像时，该决策点一定只会在右端加入且一定会加入，直接根据凸包的性质将右端不合法的决策点删去就可以了，于是我们可以直接有单调队列进行维护可能还有用的部分凸包，由于每个决策点最多只会入队、出队各一次，转移的时间复杂度为 \(O(1)\)，于是整体的均摊时间复杂度为 \(O(n)\).
#define ll long long
const int N = 100010;
const int INF = 0x3fffffff;
template <typename T> inline void read(T &x) {
x = 0; int f = 1; char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int n, q[N], frt = 0, tal = -1; ll L, c[N], s[N], f[N], val[N];
inline ll slope(int x, int y) {return (val[y] - val[x]) / (s[y] - s[x]);}
int main() {
read(n), read(L); L += 1, q[++ tal] = 0;
for (int i = 1; i <= n; ++ i) read(c[i]);
for (int i = 1; i <= n; ++ i) s[i] = s[i - 1] + c[i];
for (int i = 1; i <= n; ++ i) s[i] += i;
for (int i = 1; i <= n; ++ i) {
while (frt < tal && slope(q[frt], q[frt + 1]) < 2 * s[i]) ++ frt;
f[i] = val[q[frt]] - 2 * s[i] * s[q[frt]] + (s[i] - L) * (s[i] - L);
val[i] = f[i] + 2 * s[i] * L + s[i] * s[i];
while (frt < tal && slope(q[tal - 1], q[tal]) >= slope(q[tal - 1], i)) -- tal;
q[++ tal] = i;
}
printf("%lld", f[n]); return 0;
}
#3.0 决策无特殊性质
这里以 「NOI2007」货币兑换 作为例题。
#3.1 转移方程及转化
题目提示：必然存在一种最优的买卖方案满足：每次买进操作使用完所有的人民币，每次卖出操作卖出所有的金券。
设 \(f_i\) 表示到第 \(i\) 天可以拥有的最大钱数，先写出一个大概的转移方程
其中 \(num_A\) 与 \(num_B\) 分别表示持有的 \(A\) 金卷的数量与 \(B\) 金卷的数量，这两个数由 \(j\) 决定。显然，第 \(j\) 天买入时，能得到的金卷比例是一定的，于是当天买入时拥有的钱数越大越好，也就是 \(f_j\)，应当有
同理可得
于是我们可以写出完整的状态转移方程
注意到，转移方程中包含与 \(i\) 和 \(j\) 同时相关的项，优先考虑斜率优化，考虑从决策点 \(j\) 转移，有
即
此时，这个柿子就与我们上面的形式相吻合了，决策点在坐标系上的表示为 \(\left(\frac{f_j\cdot R_j}{R_j\cdot a_j+b_j},\frac{f_j}{R_j\cdot a_j+b_j}\right)\).
一个悲哀的事情出现了，这个式子并没有什么优美的性质，于是实现的恶心程度就上了天。
#3.2 直接维护凸包
首先是最朴素的方式，即采用平衡树维护整个凸包。
查找时，我们可以使用 #1.0 简述 提到的结论，利用二分查找找到以 \(-\frac{a_i}{b_i}\) 为斜率的直线在凸包上的切点。
至于修改时，我们可以先找到它应该插入的位置（凸包上横坐标在其左右的两个紧邻的决策点），然后利用向量叉积来确定当前点是否在当前维护的上凸包以下，如果是，那么直接返回即可；否则从找到的相邻决策点开始删掉不合法的点即可。
这种做法虽然比较好理解，但是实现较为繁琐，且难以直接套用 STL 的 set。
#3.3 CDQ 分治
\(\text{CDQ}(\ell, r)\) 表示计算 \(f_i,i\in[\ell, r]\)，设 \(mid= \left\lfloor\frac{1+ n}2\right\rfloor\)，那么考虑 \(\text{CDQ}(1,n)\)，有
对于 \(i\in[1, mid]\)，我们直接调用 \(\text{CDQ}(1, mid)\) 进行计算，得到这一部分的答案，然后显然 \(i\in [1,mid]\) 这一部分的所有转移点组成的凸壳已经被计算出来了，于是我们考虑 \([1,mid]\) 对于 \([mid+1,n]\) 中的贡献，可以直接建出凸包，然后挨个二分，但是这样实现复杂度又上了一个台阶，于是我们可以先对所有决策点的横坐标排序，再利用栈进行凸包的建立（只需要考虑最右边斜率），注意到凸包上的斜率是单调的，于是然后将 \([mid+1,r]\) 中的所有目标斜率进行排序，利用单调队列进行求解。
再来考虑 \(i\in[mid +1,n]\)，显然最优决策点在 \([1,mid]\) 中的点都已经被更新过了，于是 \([1,mid]\) 这一部分的斜率都已经没用了，可以直接被扔掉；然后直接调用 \(\text{CDQ}(mid + 1,n)\) 即可。
#define ld long double
const int N = 100010;
const int INF = 0x3fffffff;
template <typename T> inline void read(T &x) {
x = 0; int f = 1; char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T> inline T Max(T x, T y) {return x > y ? x : y;}
struct Point {
ld x, y;
inline Point() {}
inline Point(ld _x, ld _y) {x = _x, y = _y;}
inline bool operator < (const Point b) const {return x == b.x ? y < b.y : x < b.x;}
inline ld operator ^ (const Point b) const {return x * b.y - y * b.x;}
inline Point operator - (const Point b) const {return Point(x - b.x, y - b.y);}
} p[N];
int n, s, tmp[N], q[N], slp[N], slp_cp[N]; ld f[N], slope[N], a[N], b[N], r[N];
inline long double Y(int x) {return f[x] / (r[x] * a[x] + b[x]);}
inline long double X(int x) {return Y(x) * r[x];}
inline bool cmp1(int x, int y) {return p[x].x == p[y].x ? p[x].y < p[y].y : p[x].x < p[y].x;}
inline bool cmp2(int x, int y) {return slope[x] > slope[y];}
inline long double get_slope(int x, int y) {return (p[x].y - p[y].y) / (p[x].x - p[y].x);}
inline long double calc(int x, int y) {return p[y].x * a[x] + p[y].y * b[x];}
inline bool illegal(int x1, int x2, int y) {return ((p[y] - p[x2]) ^ (p[x1] - p[x2])) >= 0;}
void cdq(int x, int y) {
if (x == y) {f[x] = Max(f[x], f[x - 1]), p[x] = Point(X(x), Y(x)); return;}
int mid = x + y >> 1, frt = 0, tal = -1; cdq(x, mid);
for (int i = mid + 1; i <= y; ++ i) slp_cp[i] = slp[i];
sort(tmp + x, tmp + mid + 1, cmp1);
sort(slp_cp + mid + 1, slp_cp + y + 1, cmp2);
for (int i = x; i <= mid; ++ i) {
while (frt < tal && illegal(q[tal - 1], q[tal], tmp[i])) -- tal;
q[++ tal] = tmp[i];
}
for (int i = mid + 1; i <= y; ++ i) {
while (frt < tal && get_slope(q[frt], q[frt + 1]) > slope[slp_cp[i]]) ++ frt;
f[slp_cp[i]] = Max(f[slp_cp[i]], calc(slp_cp[i], q[frt]));
}
cdq(mid + 1, y);
}
int main() {
read(n), read(s); f[1] = s;
for (int i = 1; i <= n; ++ i)
scanf("%Lf%Lf%Lf", &a[i], &b[i], &r[i]);
for (int i = 1; i <= n; ++ i) slope[i] = - a[i] / b[i];
for (int i = 1; i <= n; ++ i) slp[i] = i, tmp[i] = i;
cdq(1, n); printf("%.3Lf", f[n]); return 0;
}
参考文章
- [1] 斜率优化 - OI Wiki
- [2] 【学习笔记】动态规划—斜率优化DP（超详细）- 辰星凌
- [3] 斜率优化 - T_X蒻
- [4] [5] [6] 「DP 浅析」四边形不等式优化 - Dfkuaid
