「笔记」斜率优化 DP

目录

• 写在前面
• 引入
• 分析
• 推导
• 代码
• 实现上的细节
• 总结
• 例题
  • P2900 [USACO08MAR]Land Acquisition G
  • 「SDOI2016」征途
  • CF311B Cats Transport
  • P2365 任务安排
  • 「SDOI2012」任务安排 3
• 写在最后

写在前面

个人认为有能力来学斜率优化的已经不需要过多对简单实现的解释了（
下文的重点是斜率优化的原理及推导过程。

图文无关

引入

一个经典题：「HNOI2008」玩具装箱 TOY。

给定一列有序的 \(n\) 个物品，第 \(i\) 个物品的价值为 \(c_i\)。
给定参数 \(L\)，要求将一列物品分成若干段，对于一段 \([l,r]\) 的代价为 \(\left(r + l + \sum\limits_{l\le i\le r} c_i - L\right) ^ 2\)。求分段的最小代价和。
\(1\le n\le 5\times 10^4\)，\(1\le L,c_i\le 10^7\)。
1S，128MB。

首先考虑暴力 DP，设 \(f_i\) 表示将前 \(i\) 个物品分配完的最小代价，转移时枚举上一段的结尾 \(j\)，将 \([j+1,i]\) 构成单独的一段，则有：

\[f_i = \min_{j=0}^{i-1}\{f_{j} + (i - j - 1 +\operatorname{sum}(j + 1,i) - L)^2\} \]

暴力直接做的复杂度是 \(O(n^2)\) 级别的，显然过不了。
发现方程包含了关于 \(i,j\) 的函数的乘积项，可以考虑使用斜率优化 DP。

分析

设当前枚举到 \(i\)，简记 \(s_i = \operatorname{sum}(1, i) + i\)，\(L' = L + 1\)，上式等于：

\[f_i = \min_{j=0}^{i-1}\{f_{j} + (s_i - s_j - L')^2\} \]

改变一下形式：

\[\begin{aligned} f_i - (s_i - L')^2 &= \min_{j=0}^{i-1}\left\{ \left(f_j + s_j^2\right) + 2(L' - s_i)s_j\right\} \end{aligned}\]

设函数：

\[\begin{aligned} x_i &= s_i\\ y_i &= f_i + s_i^2\\ k_i &= -2(L' - s_i)\\ b_i &= f_i - (s_i - L')^2 \end{aligned}\]

对于任意一个决策 \(f_a\)，有：

\[\begin{aligned} b_i &= y_a - k_ix_a\\ y_a &= k_ix_a + b_i \end{aligned}\]

显然为最小化 \(f_i\) 应最小化 \(b_i\)。考虑把所有决策一一对应到二维坐标系上的点上，决策 \(f_a\) 对应 \((x_a, y_a)\)。又对于确定的 \(i\)，\(k_i\) 是一个定值，找到最优决策的过程可以看做找到一条斜率为 \(k_i\) 的，经过点 \((x_0,y_0)\sim (x_{i-1}, y_{i-1})\) 中任意一个的直线，使其截距 \(b_i\) 最小的过程。

---

一种显然的想法是一条斜率为 \(k_i\) 的直线自下向上移动，移动过程中第一个出现在直线上的点即为最优的决策，如图所示。

图片来自：OI-Wiki

观察图像可以发现，该过程中最优决策点一定在点 \((x_0,y_0)\sim (x_{i-1},y_{i-1})\) 的下凸包上，证明见下。下凸包上相邻两点构成直线的斜率单调不降，结合直线自下向上移动的过程，最优的决策点 \((x_{p},y_{p})\) 一定满足：

• \(\dfrac{x - x_{p}}{x_{p'} - x_p} = \dfrac{y - y_p}{y_{p'} - y_p}\) 的斜率小于 \(k_i\)。
• \(\dfrac{x - x_{p}}{x_{p''} - x_p} = \dfrac{y - y_p}{y_{p''} - y_p}\) 的斜率大于 \(k_i\)。

上述 \((x_{p'}, y_{p'})\) 与 \((x_{p''}, y_{p''})\) 分别表示下凸包上 \((x_p, y_p)\) 前后的两个决策点。

又此题中 \(k_i\) 随 \(i\) 的增大而增大，根据上述结论可以考虑使用单调队列维护最优决策点，队首即为指向最优决策点的指针。相邻两点构成直线的斜率单调不降，指针在下凸包上只会单调右移。每次根据指针指向的元素转移，再将新的决策点加入凸包即可。

考虑如何快速维护下凸包，可以使用单调队列顺便维护。记新决策点、队列尾的点、队列尾的前一个点分别为 \(A\)，\(B\)，\(C\)，\(\operatorname{K}(A,B)\) 表示过点 \(A,B\) 的直线的斜率。为保证下凸包上线段的单调性，每次加入新决策点时，检查斜率 \(\operatorname{K}(A, C)\le \operatorname{K}(B,C)\) 是否成立。若等式成立则从队尾弹出 \(B\)，直到等式不成立时将 \(A\) 入队。
此过程实际上与求凸包的 Andrew 算法 是一致的，感兴趣的读者可以略作了解。

每个决策点最多进出队各一次，上述过程总复杂度为 \(O(n)\) 级别。

推导

简单推导最优决策点一定在下凸包上。

对于两个决策点 \(A(x_a, y_a)\) 与 \(B(x_b, y_b)\)（\(0\le a<b<i\)），若决策 \(B\) 优于 \(A\)，则有：

\[\begin{aligned} y_b - k_ix_b &< y_a - k_ix_a\\ y_b - y_a &< k(x_b - x_a)\\ k_i &> \dfrac{y_b - y_a}{x_b - x_a} \end{aligned}\]

考虑上式的实际意义。若过点 \(A\) 与 \(B\) 的直线的斜率小于 \(k_i\)，则决策 \(B\) 优于 \(A\)。

对于三个如下图所示的不下凸的决策点 \(A(x_a, y_a)\)、\(B(x_b, y_b)\) 与 \(C(x_c, y_c)\)（\(0\le a<b<c<i\)），显然有 \(\operatorname{K}(B,C) \le \operatorname{K}(A,B)\)。对它们与 \(k_i\) 的关系分类讨论：

• \(k_i\le \operatorname{K}(B,C) \le \operatorname{K}(A,B)\)：直线上移时一定先接触到 \(A\)，\(A\) 不劣于 \(B\)。
• \(\operatorname{K}(B,C) \le k_i\le \operatorname{K}(A,B)\)：原理同上，\(A\)、\(C\) 均不劣于 \(B\)。
• \(\operatorname{K}(B,C) \le \operatorname{K}(A,B)\le k_i\)：原理同上，\(C\) 不劣于 \(B\)。

则 \(B\) 不可能成为最优决策，故有贡献的决策点不可能呈现不下凸形状。

代码

代码下面罗列出了一些需要注意的细节，建议结合代码阅读。

//知识点：斜率优化
/*
By:Luckyblock
按照上述分析直接做。
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
#define LD long double
const int kN = 5e4 + 10;
//=============================================================
int n, h = 1, t, q[kN];
LL L, s[kN], f[kN];
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmin(LL &fir, LL sec) {
  if (sec < fir) fir = sec;
}
LD X(int x_) {
  return s[x_];
}
LD Y(int x_) {
  return f[x_] + s[x_] * s[x_];
}
LD K(int x_, int y_) {
  if (X(x_) == X(y_)) return (Y(y_) > Y(x_) ? 1e18 : -1e18);
  return (LD) ((Y(y_) - Y(x_)) / (X(y_) - X(x_)));
}
int Query(int now_) {
  LD know = -2 * (L - s[now_]);
  while (h < t && K(q[h], q[h + 1]) <= know) ++ h;
  return q[h];
}
void Insert(int now_) {
  while (h < t && K(q[t - 1], q[t]) >= K(q[t - 1], now_)) -- t;
  q[++ t] = now_;
}
//=============================================================
int main() { 
  n = read(), L = read() + 1;
  Insert(0);
  for (int i = 1, j = 0; i <= n; ++ i) {
    s[i] = s[i - 1] + read() + 1; j = Query(i);
    f[i] = f[j] + 1ll * (s[i] - s[j] - L) * (s[i] - s[j] - L);
    Insert(i);
  }
  printf("%lld\n", f[n]);
  return 0; 
}

实现上的细节

• 大部分情况下需要将决策点 \((x_0, y_0)\) 入队。
• 保证队列中至少有两个元素（构成直线），单调队列的判断条件要写成 h<t。
• 最优决策点在上凸包还是下凸包上根据具体方程具体分析。分析的思路参考上面代数推导部分。
• long double。
• 可能会出现仅满足 \(x_i\) 单调不降 的情况，此时会造成两直线的斜率相同。可以考虑在求斜率时写成 if (X(x_) == X(y_)) return (Y(y_) > Y(x_) ? 1e18 : -1e18); 以及判断决策优劣时写成 <= 和 >= 来解决。

总结

转移方程呈现 \(f_i = \operatorname{min}/\operatorname{max}(f_j - g_i \cdot h_j)\) 的形式，即方程中出现乘积项 \(g_i\cdot h_j\) 时，可以按照上述套路，略作变化得到 \(f_j = g_i\cdot h_j + f_i\)，将 \(g_i\) 看做斜率 \(k_i\)，将 \(h_j\) 看做自变量 \(x_j\)，\(f_j\) 看做函数值 \(y_j\)。

此时最小/最大化 \(f_i\) 的过程与最小/最大化过众多决策点之一的、斜率确定的函数截距的过程一致。可以看做一条斜率为 \(k_i\) 的直线自下向上移动，移动过程中第一个出现在直线上的点即为最优的决策。

可以考虑先维护包含最优决策点的凸包，再找到凸包上的最优决策点。当 \(k_i, x_i\) 均如例题一样单调时，可使用单调队列维护凸包并找到最优决策点。否则要考虑使用其他手段维护。\(k_i\) 不单调会影响最优决策点的位置，\(x_i\) 不单调会影响对凸包的维护，详见下方例题部分。

例题

P2900 [USACO08MAR]Land Acquisition G

\(k_i\)、\(x_i\) 均单调，单调队列。

给定无序的 \(n\) 个物品，第 \(i\) 个物品有两个属性，可以表示为 \((A_i,B_i)\)。
要求将这一列物品分成若干段集合，对于分出的一个集合 \(S = \{(A_i, B_i)\}\)，其代价为 \(\left(\max_{(A_i, B_i)\in S} A_i\right)\cdot \left(\max_{(A_i, B_i)\in S} B_i\right)\)，求划分的最小代价之和。
\(1\le n\le 5\times 10^4\)，\(1\le L,c_i\le 10^6\)。
1S，128MB。

纯暴力对正解并没有什么启发性，这里直接快进到如何斜率优化。

物品无序，考虑钦定一种物品的排列顺序，使得按此顺序划分时转移方程中出现乘积项。考虑将物品按 \(A_i\) 降序为第一优先级，\(B_i\) 升序为第二优先级排序，此时对于连续的一段 \([l,r]\)，其中 \(\max A_i\) 一定为 \(A_l\)，但 \(\max B\) 不确定。此时考虑通过削除无贡献元素使得第二维也存在单调性，使得 \(\max B_i\) 一定为 \(B_r\)。代码如下所示：

void Init() {
  n = read();
  for (int i = 1; i <= n; ++ i) a[i] = (Data) {read(), read()};
  std::sort(a + 1, a + n + 1, CMP);
  int tmp = 0;
  for (int i = 1; i <= n; ++ i) { //去除无贡献元素
    if (a[i].b > a[tmp].b) a[++ tmp] = a[i];
  }
  n = tmp;
}

此时对于划分出的一段 \([l,r]\)，其代价为 \(A_l\cdot B_r\)。考虑朴素 DP，设 \(f_i\) 表示按此顺序划分前 \(i\) 个物品的最小代价和，转移时枚举上一段的结尾，则有：

\[f_i = \min_{j=0}^{i-1}\left\{ f_j + A_{j + 1}\cdot B_i \right\} \]

这是一个斜率优化的经典形式，设：

\[\begin{aligned} x_i &= -A_{i+1}\\ y_i &= f_i\\ k_i &= B_i\\ b_i &= f_i \end{aligned}\]

代入方程，对于任意一个决策 \((x_j, y_j)\)，有：

\[b_i = y_j - k_i\cdot x_j \]

对于上式，显然应最小化截距 \(b_i\) 的值，可以使用与上面类似的代数推导法证明最优决策点一定位于下凸包上。又 \(x_j\)、\(k_i\) 均随 \(i\) 的增加不降，按照例题的套路用单调队列维护下凸包即可。
总时间复杂度 \(O(n\log n)\)，瓶颈是排序。

//知识点：斜率优化
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
#define LD long double
const int kN = 5e4 + 10;
//=============================================================
int n, h = 1, t, q[kN];
LL f[kN];
struct Data {
  int a, b;
} a[kN];
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmin(LL &fir, LL sec) {
  if (sec < fir) fir = sec;
}
bool CMP(Data fir_, Data sec_) {
  if (fir_.a != sec_.a) return fir_.a > sec_.a;
  return fir_.b < sec_.b;
}
LD X(int x_) {
  return -a[x_ + 1].a;
}
LD Y(int x_) {
  return f[x_];
}
LD K(int x_, int y_) {
  if (X(x_) == X(y_)) return (Y(y_) > Y(x_) ? 1e18 : -1e18);
  return (LD) ((Y(y_) - Y(x_)) / (X(y_) - X(x_)));
}
int Query(int now_) {
  LD know = a[now_].b;
  while (h < t && K(q[h], q[h + 1]) <= know) ++ h;
  return q[h];
}
void Insert(int now_) {
  while (h < t && K(q[t - 1], q[t]) >= K(q[t - 1], now_)) -- t;
  q[++ t] = now_;
}
void Init() {
  n = read();
  for (int i = 1; i <= n; ++ i) a[i] = (Data) {read(), read()};
  std::sort(a + 1, a + n + 1, CMP);
  int tmp = 0;
  for (int i = 1; i <= n; ++ i) { //去除无贡献元素
    if (a[i].b > a[tmp].b) a[++ tmp] = a[i];
  }
  n = tmp;
}
//=============================================================
int main() {
  Init();
  Insert(0);
  for (int i = 1, j = 0; i <= n; ++ i) {
    j = Query(i);
    f[i] = f[j] + 1ll * a[j + 1].a * a[i].b;
    Insert(i);
  }
  printf("%lld\n", f[n]);
  return 0; 
}

「SDOI2016」征途

\(k_i\)、\(x_i\) 均单调，单调队列。

王 道 征 途
「そうですね…やっぱり僕は、王道を征く、ソープ系ですか」

给定一列有序的 \(n\) 个物品，第 \(i\) 个物品的价值为 \(a_i\)。
给定参数 \(m\)，要求将一列物品分成 \(m\) 段，最小化每段长度之和的方差 \(v\)，输出 \(v\cdot m^2\)。
\(1\le n\le m\le 3000\)，\(\left(\sum a_i\right)\le 3\times 10^4\)。
1S，256MB。

记划分出的 \(m\) 段的和分别为 \(b_1\sim b_m\)，将 \(v\cdot m^2\) 展开一下：

\[\begin{aligned} v\cdot m^2 =& m^2\cdot \dfrac{\sum\limits_{i=1}^{m}\left(b_i - \overline{b}\right)^2}{m}\\ =& m\sum_{i=1}^{m} \left( b_i^2 - 2b_i\overline{b} + \overline{b}^2 \right)\\ =& m\sum_{i=1}^{m} \left( b_i^2 - 2b_i\dfrac{\sum_{i=1}^m b_i}{m} + \dfrac{\left(\sum_{i=1}^m b_i\right)^2}{m^2} \right)\\ =& m\sum_{i=1}^{m} b_i^2 - 2\left(\sum_{i=1}^m{b_i}\right)^2 + \left(\sum_{i=1}^m{b_i}\right)\\ =& m\sum_{i=1}^{m} b_i^2 - \left(\sum_{i=1}^{m}{b_i}\right)^2 \end{aligned}\]

发现最后的式子中 \(\left(\sum{b_i}\right)^2\) 等于 \(\left(\sum{a_i}\right)^2\)，是一个定值，仅需最小化第一项即可。

按传统先写个暴力，设 \(f_{i,j}\) 表示将前 \(i\) 个数划分为 \(j\) 段时 \(\sum b_i^2\) 的最小值，转移时枚举段数 \(k\) 和上一段的结尾 \(j\)，则有：

\[f_{i,k} = \min_{j=0}^{i-1} \left\{ f_{j,k-1} + \left(\sum_{l=j+1}^{i}a_l\right)^2\right\} \]

预处理前缀和后暴力转移复杂度 \(O(n^2m)\)，考虑优化。
发现后一项是一个区间和的平方的形式，它同时与 \(i,j\) 有关。考虑对 \(a\) 做一个前缀和，设 \(s_i = \sum_{i=1}^{i} a_i\)，将其代入原式：

\[\begin{aligned} f_{i,k} &= \min_{j=0}^{i-1} \left\{ f_{j,k-1} + \left( s_i - s_j \right)^2 \right\}\\ f_{i,k} &= \min_{j=0}^{i-1} \left\{ f_{j,k-1} + s_i^2 - 2s_is_j +s_j^2 \right\} \end{aligned}\]

考虑先通过枚举固定 \(k\)，对于每一个决策 \(f_{j,k}\)，都有：

\[f_{i,k} - s_{j}^2= \left(f_{j,k - 1} + s_j^2\right) - 2s_is_j \]

这是一个显然的斜率优化的形式，套路地设：

\[\begin{aligned} x_i &= s_i\\ y_i &= f_{i,k-1} + s_i^2\\ k_i &= 2s_i\\ b_i &= f_{i,k} - s_i^2 \end{aligned}\]

对于上式，显然应最小化截距 \(b_i\) 的值，易证最优决策点一定位于下凸包上。又 \(x_j\)、\(k_i\) 均随 \(i\) 的增加而增加，单调队列维护下凸包即可。注意一些初始化的小问题，详见代码。
总复杂度 \(O(nm)\) 级别。

//知识点：斜率优化
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
#define LD long double
const int kN = 3000 + 10;
//=============================================================
int n, m, h = 1, t, q[kN];
LL s[kN], f[kN][kN]; //代码中 f[j][i] 表示将前 i 个数划分为 j 段时 sum b_i^2 的最小值，与上述分析中相反。
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmin(LL &fir, LL sec) {
  if (sec < fir) fir = sec;
}
LD X(int x_) {
  return s[x_];
}
LD Y(int id_, int x_) {
  return f[id_][x_] + s[x_] * s[x_];
}
LD K(int id_, int x_, int y_) {
  if (X(x_) == X(y_)) return (Y(id_, y_) > Y(id_, x_) ? 1e18 : -1e18);
  return (LD) ((Y(id_, y_) - Y(id_, x_)) / (X(y_) - X(x_)));
}
int Query(int id_, int now_) {
  LD know = 2 * s[now_];
  while (h < t && K(id_, q[h], q[h + 1]) <= know) ++ h;
  return q[h];
}
void Insert(int id_, int now_) {
  while (h < t && K(id_, q[t - 1], q[t]) >= K(id_, q[t - 1], now_)) -- t;
  q[++ t] = now_;
}
//=============================================================
int main() { 
  n = read(), m = read();
  for (int i = 1; i <= n; ++ i) s[i] = s[i - 1] + read();
  memset(f, 63, sizeof(f));
  f[0][0] = 0;
  for (int k = 1; k <= m; ++ k) {
    h = 1, t = 0;
    Insert(k - 1, 0);
    for (int i = 1; i <= n; ++ i) {
      if (i >= k) {
        int j = Query(k - 1, i);
        f[k][i] = f[k - 1][j] + (s[i] - s[j]) * (s[i] - s[j]);
      }
      Insert(k - 1, i);
    }
  }
  printf("%lld\n", 1ll * m * f[m][n] - 1ll * s[n] * s[n]);
  return 0; 
}

CF311B Cats Transport

\(k_i\)、\(x_i\) 均单调，单调队列。

一条数轴上有 \(n\) 个点，第 \(i\) 个点与第 \(i-1\) 个点的距离为 \(d_i\)，有 \(p\) 个人在第 \(1\) 个点上。有 \(m\) 只 neko，第 \(i\) 只 neko 位于第 \(h_i\) 个点上，neko 会在 \(T_i\) 时间开始等待人的到来。
没个人可以从任意时间从第 \(1\) 个点出发，按编号顺序依次经过各点，速度为 1 个单位长度 1 秒，中间不停下。每经过一个点，就会将该点上处于等待状态的 neko 接上。
每只 neko 的等待时间为其被接上时间与开始等待时间的差。要求安排每个人出发的时间，最小化 neko 等待的时间之和。
\(2\le h_i\le n\le 10^5\)，\(1\le m\le 10^5\)，\(1\le p\le 100\)，\(1\le d_i\le 10^4\)，\(1\le T_i\le 10^9\)。
2S，256MB。

可以简单地 YY 出一个与 \(t\) 相关的 DP 状态，但 \(t\) 过大，猜测 DP 状态与 \(t\) 无关，考虑找下结论。可以发现每个人接上的 neko 中，至少有一只恰好刚开始等待人的到来。正确性显然，若所有 neko 都是等待了一段时间后再被接上，不如提前人的出发时间，直到有一只刚开始等待，在不影响接上了哪些 neko 的前提下减少等待时间之和。

前缀和预处理点 \(1\) 到各点的距离 \(\operatorname{dis}_i\)。对于每只 neko，容易求得一个人从何时出发能够恰好接上它，显然该时间为 \(t_i = T_i - \operatorname{dis}_{h_i}\)。
考虑将所有 neko 按照 \(t_i\) 排序。显然在满足一开始的结论的前提下，每个人接到的 neko 都对应排序后的一段区间 \([l,r]\)，刚开始等的 neko 一定是第 \(r\) 只 neko（即 \(t_i\) 最大的），则这个人的出发时间为 \(t_r\)，区间内 neko 的等待时间之和为 \(\sum t_r - t_i\)。
问题可以抽象为给定一长度为 \(m\) 的数列 \(t\)，要求将 \(t\) 分为 \(p\) 段，每段的代价为该段最右的数减去该段每个值的和，最小化代价和。

对于抽象后的问题，设 \(s_i = \sum_{j\le i}t_j\)，设 \(f_{i,j}\) 表示将前 \(i\) 个数分为 \(j\) 段的最小代价和，转移时先枚举段数 \(k\)，再枚举最后一段，则有：

\[\begin{aligned} f_{i,k} &= \min_{j = 0}^{i - 1} \left\{ f_{j, k - 1} + \sum_{l = j + 1}^{i} \left( t_i - t_l \right) \right\}\\ &= \min_{j = 0}^{i - 1} \left\{ f_{j, k - 1} + (i - j)t_i - (s_i - s_j) \right\}\\ &= i\cdot t_i -s_i + \min_{j = 0}^{i - 1} \left\{ \left(f_{j, k - 1} +s_j\right) - t_i\cdot j \right\} \end{aligned}\]

方程中出现了乘积项，先通过枚举固定 \(k\) 后，这显然是一个可以斜率优化的形式，套路地设：

\[\begin{aligned} x_i &= i\\ y_i &= f_{i,k - 1} + s_j\\ k_i &= t_i\\ b_i &= f_{i,k} - i\cdot t_i + s_i \end{aligned}\]

显然应最小化 \(b_i\)，又 \(x_i\) 与 \(k_i\) 都随 \(i\) 的增加单调不降，单调队列维护下凸包即可。
总复杂度 \(O(n + m\log m + pm)\) 级别。

//知识点：斜率优化
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
#define LD long double
const int kN = 1e5 + 10;
//=============================================================
int n, m, p, head = 1, tail, q[kN];
LL sumd[kN], t[kN], s[kN], f[kN][101];
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmin(LL &fir, LL sec) {
  if (sec < fir) fir = sec;
}
LD X(int x_) {
  return x_;
}
LD Y(int id_, int x_) {
  return f[x_][id_] + s[x_];
}
LD K(int id_, int x_, int y_) {
  if (X(x_) == X(y_)) return (Y(id_, y_) > Y(id_, x_) ? 1e18 : -1e18);
  return (LD) ((Y(id_, y_) - Y(id_, x_)) / (X(y_) - X(x_)));
}
int Query(int id_, int now_) {
  LD know = t[now_];
  while (head < tail && K(id_, q[head], q[head + 1]) <= know) ++ head;
  return q[head];
}
void Insert(int id_, int now_) {
  while (head < tail && 
         K(id_, q[tail - 1], q[tail]) >= K(id_, q[tail - 1], now_)) -- tail;
  q[++ tail] = now_;
}
void Init() {
  n = read(), m = read(), p = read();
  for (int i = 2; i <= n; ++ i) sumd[i] = sumd[i - 1] + read();
  for (int i = 1; i <= m; ++ i) {
    int h = read(), nowt = read();
    t[i] = nowt - sumd[h];
  }
  std::sort(t + 1, t + m + 1);
  for (int i = 1; i <= m; ++ i) s[i] = s[i - 1] + t[i];
}
//=============================================================
int main() { 
  Init();
  memset(f, 63, sizeof(f));
  f[0][0] = 0;
  for (int k = 1; k <= p; ++ k) {
    head = 1, tail = 0;
    Insert(k - 1, 0);
    for (int i = 1; i <= m; ++ i) {
      if (i >= k) {
        int j = Query(k - 1, i);
        f[i][k] = f[j][k - 1] + 1ll * (i - j) * t[i] - s[i] + s[j];
      }
      Insert(k - 1, i);
    }
  }
  printf("%lld\n", f[m][p]);
  return 0; 
}

P2365 任务安排

\(k_i\)、\(x_i\) 均单调，单调队列。

三 步 走 战 略

给定一列 \(n\) 个有序的物品，每个物品有两个属性 \((t_i, g_i)\)，给定参数 \(s\)。
要求将物品分为任意段，第 \(i\) 段 \([l_i,r_i]\) 的代价为 \(\left(is + \sum_{j=l_i}^{r_i} t_j\right)\cdot \sum_{k=l_i}^{r_i}\)，要求最小化分段的代价之和。
\(1\le n\le 5000\)，\(0\le s\le 50\)，\(1\le t_i,g_i\le 100\)。
1S，128MB。

发现分到第几段对答案有影响，设 \(f_{i,j}\) 表示将前 \(i\) 个任务分为 \(j\) 段的最小费用和，转移时枚举段数 \(k\) 和最后一段，则有：

\[f_{i,k} = \min_{j=0}^{i - 1} \left\{ f_{j,k-1} + \left(ks + \sum_{k=j+1}^{i} t_k \right)\sum_{l=j + 1}^{i} g_l \right\} \]

预处理前缀和，暴力转移时间复杂度 \(O(n^3)\)，空间复杂度 \(O(n^2)\)。空间和时间都菜爆了。

---

发现在上述算法中必须枚举分到第几段，考虑能否优化掉状态的这一维，并优化转移。
这里用到了一种叫做「费用提前计算」的思想。发现每次转移将 \([j + 1,i]\) 这段分出后，后续元素的代价里都会加上 \(k\cdot g\)，考虑在状态转移中加上这部分的影响。具体地，将状态删去一维，方程改写为如下所示：

\[f_i = \min_{j=0}^{i-1}\left\{ f_j + \sum_{k=1}^{i} t_k\sum_{l=j + 1}^{i} g_l + s\left( \sum_{k = j + 1}^{n} g_k\right)\right\} \]

状态转移方程很容易理解。此时已经无法准确定义 \(f\) 的含义了，但 \(f_n\) 一定表示将所有物品划分为某几段的最小代价和，且这样转移一定可以保证 \(f_n\) 的正确性。

预处理前缀和后暴力转移即可，时间复杂度 \(O(n^2)\)，空间复杂度 \(O(n)\)。

---

上述 \(O(n^2)\) 算法已经可以通过原题了，但这还不够。

记 \(st_x = \sum_{i=1}^{x} t_i\)，\(sg_x = \sum_{i=1}^x g_i\)，代入转移方程并略作变换：

\[\begin{aligned} f_i &= \min_{j=0}^{i-1}\left\{ f_j + st_i\left( sg_i - sg_j \right) + s\left( sg_n - sg_j\right)\right\}\\ f_i - st_i\cdot sg_i - s\cdot sg_n&= \min_{j=0}^{i-1} \left\{ \left(f_j - s\cdot sg_j \right) - st_i\cdot sg_j \right\} \end{aligned}\]

这是一个显然的斜率优化的形式，设：

\[\begin{aligned} x_i &= sg_i\\ y_i &= f_ i- s\cdot sg_i\\ k_i &= st_i\\ b_i &= f_i - st_i\cdot sg_i - s\cdot sg_n \end{aligned}\]

由于 \(0\le t_i,g_i\)，\(k_i\) 与 \(x_i\) 均单调递增，套路地单调队列维护下凸包即可。
总时空复杂度均为 \(O(n)\)。

 //知识点：斜率优化，费用提前计算
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
#define LD long double
const int kN = 5e3 + 10;
const LL kInf = 9e18 + 2077;
//=============================================================
int n, h = 1, t, q[kN];
LL s, ans = kInf, f[kN], sumt[kN], sumg[kN];
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmin(LL &fir, LL sec) {
  if (sec < fir) fir = sec;
}
LD X(int x_) {
  return sumg[x_];
}
LD Y(int x_) {
  return f[x_] - s * sumg[x_];
}
LD K(int x_, int y_) {
  if (X(x_) == X(y_)) return (Y(y_) > Y(x_) ? 1e18 : -1e18);
  return (LD) ((Y(y_) - Y(x_)) / (X(y_) - X(x_)));
}
int Query(int now_) {
  LD know = sumt[now_];
  while (h < t && K(q[h], q[h + 1]) <= know) ++ h;
  return q[h];
}
void Insert(int now_) {
  while (h < t && K(q[t - 1], q[t]) >= K(q[t - 1], now_)) -- t;
  q[++ t] = now_;
}
//=============================================================
int main() { 
  n = read(), s = read();
  for (int i = 1; i <= n; ++ i) {
    sumt[i] = sumt[i - 1] + read();
    sumg[i] = sumg[i - 1] + read();
  }
  Insert(0);
  for (int i = 1; i <= n; ++ i) {
    int j = Query(i);
    f[i] = f[j] + sumt[i] * (sumg[i] - sumg[j]) + 
                  s * (sumg[n] - sumg[j]);
    Insert(i);
  }
  printf("%lld\n", f[n]);
  return 0; 
}

「SDOI2012」任务安排 3

\(x_i\) 单调，\(k_i\) 不单调，单调栈，二分。

与上题仅有数据范围不同

给定一列 \(n\) 个有序的物品，每个物品有两个属性 \((t_i, g_i)\)，给定参数 \(s\)。
要求将物品分为任意段，第 \(i\) 段 \([l_i,r_i]\) 的代价为 \(\left(is + \sum_{j=l_i}^{r_i} t_j\right)\cdot \sum_{k=l_i}^{r_i}\)，要求最小化分段的代价之和。
\(1\le n\le 3\times 10^5\)，\(1\le s\le 2^8\)，\(|t_i|\le 2^8\)，\(0\le g_i\le 2^8\)。
1S，512MB。

考虑上题最后得到的斜率优化的式子。与上题不同的是，本题中可能出现 \(t_i< 0\)，\(k_i\) 是不单调的，这影响了最优决策点的选择，无法使用单调队列选择最优决策点。但 \(x_i\) 单调，使用单调队列维护下凸包的做法是正确的。

仍考虑使用单调队列维护下凸包，每次查询最优决策点时在凸包上二分，找到第一个使得左侧斜率小于 \(k_i\)，右侧斜率不小于 \(k_i\) 的位置即为最优决策点，不从队首弹出元素。可以发现此时的“单调队列”实际上是一个单调栈。我们实际上是在用 Andrew 算法 维护凸包。

总时间复杂度变为 \(O(n\log n)\)。

 //知识点：斜率优化
/*
By:Luckyblock
*/
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstring>
#define LL long long
#define LD long double
const int kN = 3e5 + 10;
const LL kInf = 9e18 + 2077;
//=============================================================
int n, h = 1, t, q[kN];
LL s, ans = kInf, f[kN], sumt[kN], sumg[kN];
//=============================================================
inline int read() {
  int f = 1, w = 0;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
  return f * w;
}
void Chkmin(LL &fir, LL sec) {
  if (sec < fir) fir = sec;
}
LD X(int x_) {
  return sumg[x_];
}
LD Y(int x_) {
  return f[x_] - s * sumg[x_];
}
LD K(int x_, int y_) {
  if (X(x_) == X(y_)) return (Y(y_) > Y(x_) ? 1e18 : -1e18);
  return (LD) ((Y(y_) - Y(x_)) / (X(y_) - X(x_)));
}
bool Check(LD know_, int mid_) {
  return know_ <= K(q[mid_], q[mid_ + 1]);
}
int Query(int now_) {
  LD know = sumt[now_];
  int ret = t;
  for (int l = h, r = t - 1; l <= r; ) {
    int mid = (l + r) >> 1;
    if (Check(know, mid)) {
      ret = mid; //q[ret] 是最靠右的使得 check 为 true 的位置，即 q[ret] 左侧斜率小于 k，右侧斜率不小于 k。 
      r = mid - 1;
    } else {
      l = mid + 1;
    }
  }
  return q[ret];
}
void Insert(int now_) {
  while (h < t && K(q[t - 1], q[t]) >= K(q[t - 1], now_)) -- t;
  q[++ t] = now_;
}
//=============================================================
int main() { 
  n = read(), s = read();
  for (int i = 1; i <= n; ++ i) {
    sumt[i] = sumt[i - 1] + read();
    sumg[i] = sumg[i - 1] + read();
  }
  Insert(0);
  for (int i = 1; i <= n; ++ i) {
    int j = Query(i);
    f[i] = f[j] + sumt[i] * (sumg[i] - sumg[j]) + 
                  s * (sumg[n] - sumg[j]);
    Insert(i);
  }
  printf("%lld\n", f[n]);
  return 0; 
}

写在最后

鸣谢：

【学习笔记】动态规划—斜率优化DP（超详细） - 辰星凌
斜率优化 - OI Wiki
P3195 [HNOI2008]玩具装箱TOY（斜率优化入门） - hhz6830975 的博客