决策单调性优化
决策单调性优化
问题
在遇到一些分层 DP 与区间 DP 时,可能因为复杂度太高而无法解决,需要一些优化技巧。
思路
这些 DP 的复杂度太高,是因为需要三层枚举:第一层遍历 \(k\)(分第几段),因为只有得出上一层的 \(k-1\) 才能继续推导下一层的 \(k\);中间两层推导 \(\min_{1\le k\le i}\)。
我们思考如何减少复杂度,有什么是多余可以省略的操作,看起来没有。所以只有引出其他规律来能够推导出一些数据,从而不计算所有的数据,只计算需要的,以此简化复杂度。所以这个只适用于符合该规律的情况。因为这次讲的是决策单调性优化,所以我们引入的规律是决策点呈单调性的规律,即当 \(i\) 增大时,最小的最优决策点 \(k\) 不减。
此时需要引入四边形不等式(Monge 性质):对角之和 ≤ 包含之和。
对代价函数 \(w(j,i)\)(\(j\le i\)),如果对任意 \(a\le b\le c\le d\) 都成立:
意为:把决策点从 \(b\) 左移到 \(a\) 所付出的额外代价,随 \(i\)(\(c\to d\))不减。
四边形不等式可以推出决策单调性,反之不行。
决策单调性总结来说就是对于靠后的终点 \(i\),决策点只会向右或不变,不会左移。
四边形不等式的另一种写法
固定两个候选决策点 \(j_1<j_2\),看它们在行 \(i\) 上的差:
\(dp\) 那部分与 \(i\) 无关,所以只需要看代价。在四边形不等式里取 \(a=j_1+1,\ b=j_2+1,\ c=i,\ d=i'\)(需要 \(j_2<i\),这正是"\(j_2\) 是合法决策点"):
移项就得
定点四边不等式 ⟺ 任意两个决策点的代价差,随 \(i\) 单调不增。
\(i\) 越大,右边的决策点只会越来越优 ⇒ 决策点右移(分治);
一旦右边的是最优,左边的就不可能再次最优 ⇒ 每列至多交叉一次(二分栈)。
"最小最优决策"一定单调
引理:设 \(w\) 满足四边形不等式,\(\mathrm{opt}(i)\) 表示第 \(i\) 行最小的最优决策,则 \(\mathrm{opt}(i)\le \mathrm{opt}(i+1)\)。
证明:取 \(i<i'\),记 \(j_1=\mathrm{opt}(i)\)、\(j_2=\mathrm{opt}(i')\),反设 \(j_2<j_1\)。
- \(j_1\) 是第 \(i\) 行的最优决策 \(\Rightarrow M[i][j_1]\le M[i][j_2]\),即 \(\Delta(i)\le 0\);
- \(j_2\) 是第 \(i'\) 行的最优决策 \(\Rightarrow M[i'][j_2]\le M[i'][j_1]\),即 \(\Delta(i')\ge 0\);
- 上文说 \(\Delta\) 单调不增:\(\Delta(i')\le \Delta(i)\)。
于是 \(0\le \Delta(i')\le \Delta(i)\le 0\),全部取等号 ⇒ \(M[i][j_1]=M[i][j_2]\),说明 \(j_2\) 也是第 \(i\) 行的最优决策,但 \(j_2<j_1\),与 \(j_1\) 是最小的最优决策矛盾。
弱条件与强条件
矩阵本身的单调性有两个层次:弱条件与强条件。需要注意的是,两者都只是描述矩阵本身满足哪种性质,并非互斥的分类。完全单调性可以推出决策单调性,反之不行。题目可以同时满足决策单调性和完全单调性
补充:
四边形不等式 = quadrangle inequality / Monge 条件;
完全单调性 = totally monotone(任意两列至多交叉一次);
决策单调性 = monotone argmin。
矩阵视角
形象的看:我们把 DP 看做一个矩阵,固定一层 DP,转移为
- 行 \(i\):当前要算的状态。
- 列 \(j\):候选决策点。
决策单调性讨论的是:每行最小值所在的列,能不能随着行号单调。
弱条件:只要求"能挑出一条单调的路径"。
例如:
j=1 j=2 j=3
i=1: 1 1 9
i=2: 2 2 3
i=3: 3 4 4
当我取 \((1,1,1)\) (行号,下同)时单调,取 \((2,1,1)\) 不单调。两种取法每一行都取了最小值,但第二个取法的决策序列不是单调的。所以只能说存在一组单调的最优决策成立。
第二种是完全单调性:任意两列的优劣至多交叉一次。它保证的是"最左最优决策"和"最右最优决策"这两条极值序列各自单调。
并列时如何取
分治优化和二分栈的代码里,找最小值时通常写 < 而不是 <=(或反过来),这是在强制固定一种取法:
- 用
<:并列时保留先遇到的,等价于总是取最小列号的最优决策(最左最优决策)。 - 用
<=:并列时更新为后遇到的,等价于总是取最大列号的最优决策(最右最优决策)。
只要全程统一一种规则得到的决策序列就是单调的。
故决策单调性保证的是"存在一条单调的最优路径",代码用统一的并列处理规则去走那条存在的最优路径,而不是在并列处随机选。
但是二分栈还需要完全单调性。其实就是任意两列的优劣至多翻转一次。什么叫翻转:
j=1 j=2 j=3
i=1: 1 2 9
i=2: 3 1 2
i=3: 4 5 1
| 行 | j=1 | j=2 | 更优 |
|---|---|---|---|
| i=1 | 1 | 2 | j=1 |
| i=2 | 3 | 1 | j=2 |
| i=3 | 4 | 5 | j=1 |
\(j=1\) 和 \(j=2\) 的优劣关系是:\(j=1\) 优 → \(j=2\) 优 → \(j=1\) 优,翻转了两次,不满足完全单调性。
- 分治优化只依赖"最小最优决策单调",这个矩阵的最小最优决策是 \((1,2,3)\),单调,所以分治可以用。
- 二分栈依赖"任意两列优劣至多翻转一次"。
决策点优化主要针对两类 DP:分层 DP 与 区间 DP。
分层 DP
转移形式为:
固定层 \(g\) 时,\(\operatorname{opt}[g][i]\) 关于 \(i\) 单调不减。甚至跨层有更强的夹逼关系:
跨层夹逼
后一个不等式之前讲过,前一个跨层不等式是为什么:
首先明确 \(\operatorname{opt}[g][i]\) 是使 \(dp[g][i]\) 取到最小的 \(k\),含义是:把前 \(i\) 个元素分成 \(g\) 段时,最后一个切分在 \(k\) 和 \(k+1\) 之间,即前 \(k\) 个分成 \(g-1\) 段,\([k+1,i]\) 是第 \(g\) 段。
从直觉上来说:同一个前缀 \(i\),分成 \(g-1\) 段时,最后一段比较长,元素多;分成 \(g\) 段时,最后一段应该更短,最后一个切分位置应该更靠右。
证明是由引理:\(\mathrm{dp}[g][i] - \mathrm{dp}[g-1][i]\) 关于 \(i\) 单调不增。记 \(d_g(i) = \mathrm{dp}[g][i] - \mathrm{dp}[g-1][i]\)。显然 \(d_g(i) \le 0\),多分一段不会更差。\(i\) 越大,\(d_g(i)\) 越负(或不变),即多分一段带来的"节省量"随前缀变长而增大——元素越多,精细划分的收益越大。
(注:我的证明都没有严谨性,只是帮助理解,想了解严谨证明可以自己去搜一下)
同层单调是分治优化的核心,那跨层单调有什么用:
它不是分治优化所必需的,主要用于缩小初始范围:计算第 \(g\) 层时,已知 \(\operatorname{opt}[g-1][i]\),可以把 \(\operatorname{opt}[g][i]\) 的下界从 \(0\) 提到 \(\operatorname{opt}[g-1][i]\)。某些实现会利用这一点做常数优化。对于高阶算法作为理论保证:它说明 \(\operatorname{opt}\) 作为 \((g,i)\) 的二元函数是单调的,是 2D1D、SMAWK 这类结论的结构基础。
分治优化(离线,最通用)
步骤
对每一层,调用 solve(l, r, L, R):当前要算 \(i\in[l,r]\) 的 dp,已知它们的决策点落在 \([L,R]\) 内。
- 取 \(\mathrm{mid}=(l+r)/2\)。
- 暴力枚举 \(k\in[L,\min(R,\mathrm{mid}-1)]\),找出 \(\mathrm{mid}\) 的最优决策 \(k^*\)。
- 左半边决策点一定 \(\le k^*\),右半边一定 \(\ge k^*\)。
- 递归
solve(l, mid-1, L, k*)和solve(mid+1, r, k*, R)。
模版(最小化为例,不用局限于模版,理解原理后自己也能根据题目不同情况写出来)
const long long INF = 4e18; // 补上 INF 定义:要够大,且加法不溢出
// dp_prev[k] 是上一层结果,dp_cur[i] 是当前层待求
// cost(j, i) 表示区间 [j, i] 的代价
void solve(int l, int r, int L, int R) {
if (l > r) return;
int mid = (l + r) >> 1;
int bestK = L;
long long bestVal = INF;
for (int k = L; k <= min(R, mid - 1); ++k) {
long long val = dp_prev[k] + cost(k + 1, mid);
if (val < bestVal) { // 写 < :并列时取最左最优决策(全程只能选一种)
bestVal = val;
bestK = k;
}
}
dp_cur[mid] = bestVal;
solve(l, mid - 1, L, bestK);
solve(mid + 1, r, bestK, R);
}
复杂度:每层递归中,所有 mid 的枚举长度之和为 \(O(n)\),递归深度 \(O(\log n)\),故每层 \(O(n\log n)\);若有 \(G\) 层,总 \(O(Gn\log n)\)。
适用条件:离线;只要求决策单调性;代价函数支持随机访问或移动访问均可。
二分栈 / 二分队列(在线,要求完全单调性)
分治虽然通用,但必须离线,因为要先算出 mid 的决策才能递归两边。如果 \(dp[i]\) 依赖前面已经算出的 \(dp[j]\)(即 cost 中包含 \(dp[j]\) 值),就需要在线算法。
二分栈维护一个队列,每个元素 (决策点 v, 它支配的区间 [l, r]),表示在当前已加入的决策点中,\(i\in[l,r]\) 的最优决策是 \(v\)。由于完全单调性,每个决策点支配的是一段连续区间。
插入新决策 \(x\) 时的逻辑:
- 若队尾决策在它自己区间的左端点就已经不劣于 \(x\),直接弹出队尾。因为: \(\Delta\) 单调 ⇒ 在左端点优 ⇒ 整段 \([l,r]\) 都优 ⇒ 队尾移除;
- 若队尾决策在区间右端点仍优于 \(x\),\(x\) 无法进入,结束;
- 否则二分找到"\(x\) 开始优于队尾决策"的第一个位置 \(p\),把队尾区间截断到 \(p-1\),再压入
(x, p, n)。
代价函数必须是 \(O(1)\)。 二分栈的
cost调用是跳跃式的(二分的 mid 到处跳),用莫队式双指针维护会退化成 \(O(n^2)\)。这是它和分治最实质的区别。
struct Node { int l, r, v; }; // v 支配 [l, r]
deque<Node> q;
q.push_back({1, n, 0}); // 必须先压入初始决策点 0,否则下面第一个 q.front() 就是空队列
for (int i = 1; i <= n; ++i) {
// 弹出已过时的队首
while (!q.empty() && q.front().r < i) q.pop_front();
dp[i] = dp[q.front().v] + cost(q.front().v + 1, i);
// 插入决策点 i
// 由上面的结论可知:若 i 在队尾区间的左端点 l 就已经不劣于队尾的 v,
// 那么 i 在队尾的整个区间上都更优,队尾整段作废,直接弹出。
while (!q.empty() &&
dp[i] + cost(i + 1, q.back().l) <=
dp[q.back().v] + cost(q.back().v + 1, q.back().l))
q.pop_back();
if (q.empty()) {
if (i < n) q.push_back({i + 1, n, i});
continue;
}
int L = max(q.back().l, i + 1); // 左端不能小于 i+1:i 不能给"自己前面"当决策
int R = q.back().r, p = R + 1; // p 默认 R+1,表示 i 在这段里永远赢不了
while (L <= R) {
int mid = (L + R) >> 1;
if (dp[i] + cost(i + 1, mid) <=
dp[q.back().v] + cost(q.back().v + 1, mid)) {
p = mid; // 与上面的 <= 保持一致:并列时站新决策
R = mid - 1;
} else L = mid + 1;
}
if (p <= q.back().r) {
q.back().r = p - 1;
q.push_back({p, n, i});
}
}
区间 DP(合并模型)
转移形式:
若 \(w\) 满足四边形不等式且区间包含单调性(\(w(l,r)\) 随区间扩大不降),则不仅有 \(f\) 本身满足四边形不等式,还有跨区间夹逼:
因此计算 \(f[l][r]\) 时,决策枚举范围直接限定在 \([\operatorname{opt}[l][r-1],\ \operatorname{opt}[l+1][r]]\) 内。虽然单次枚举长度可能仍是 \(O(n)\),但可以证明总枚举次数为 \(O(n^2)\),从而把裸区间 DP 的 \(O(n^3)\) 降到 \(O(n^2)\)。
Knuth 优化
模版
for (int i = 1; i <= n; ++i) {
dp[i][i] = 0;
opt[i][i] = i;
}
for (int len = 2; len <= n; ++len) {
for (int l = 1; l + len - 1 <= n; ++l) {
int r = l + len - 1;
dp[l][r] = INF;
for (int k = opt[l][r - 1]; k <= opt[l + 1][r]; ++k) {
if (k >= r) continue; // 夹逼出来的右端可能是 r(=l+1 那层会碰到),必须挡掉
long long val = dp[l][k] + dp[k + 1][r] + w(l, r);
if (val < dp[l][r]) {
dp[l][r] = val;
opt[l][r] = k;
}
}
}
}
Knuth 依赖的是区间 DP 特有的跨区间单调性,而不是"固定层内 \(\mathrm{opt}[i]\) 随 \(i\) 单调"。
Knuth 的单调是 \(\operatorname{opt}\) 在两个方向(左端、右端)上分别单调,
是二维夹逼;分治用的是"同一层内 \(\operatorname{opt}[i]\) 随 \(i\) 单调"。
补充:名字来自 Knuth 1971 年对最优二叉搜索树的分析,理论化是 Yao 1980 的四边形不等式。
例题:CF868F
题意:给 \(n\) 个数,切成恰好 \(k\) 段(每段非空),最小化 \(\sum_{\text{每段}}(\text{段内相等元素对数})\)。\(n\le10^5\),\(k\le20\)。
为什么 cost 满足四边形不等式:设某段里值 \(v\) 出现 \(c_v\) 次,
则该段对数 \(=\sum_v\binom{c_v}{2}\)。把区间 \([l,r]\) 扩到 \([l,r+1]\) 时,新增对数 \(=\) 新元素在 \([l,r]\) 中出现过的次数;区间越长这个次数只会更多 ,所以分治合法。
cost 要用莫队双指针:\(w(l,r)\) 没法 \(O(1)\) 直接算,但加/删一个元素是 \(O(1)\) 的(add 时新增 cnt[x] 对,remove 时减少 cnt[x] 对),所以用分治 + 莫队式双指针。
复杂度:单层 \(O(n\log n)\),共 \(O(k\,n\log n)\);空间 \(O(kn)\)(可滚动成 \(O(n)\))。
#include<bits/stdc++.h>
#define int long long
#define endl "\n"
using namespace std;
const int N=1e5+5;
const int INF=1e18;
int n,k;
int a[N];
int dp[25][N];
int cnt[N];
int cs=0;
int curl=1,curr=0;
void add(int pos){
cs+=cnt[a[pos]];
cnt[a[pos]]++;
}
void remove(int pos){
cnt[a[pos]]--;
cs-=cnt[a[pos]];
}
int cost(int l,int r){
while(curr<r) add(++curr);
while(curl>l) add(--curl);
while(curr>r) remove(curr--);
while(curl<l) remove(curl++);
return cs;
}
void divide(int c,int L,int R,int l,int r){
if(l>r) return;
int mid=(l+r)>>1;
int bestk=L;
int bestval=INF;
for(int k=L;k<=min(R,mid-1);++k){
int val=dp[c-1][k]+cost(k+1,mid);
if(val<bestval){
bestval=val;
bestk=k;
}
}
dp[c][mid]=bestval;
divide(c,L,bestk,l,mid-1);
divide(c,bestk,R,mid+1,r);
}
void solve(){
cin>>n>>k;
for(int i=1;i<=n;++i){
cin>>a[i];
dp[0][i]=INF;
}
for(int i=1;i<=k;++i){
divide(i,0,n,1,n);
}
cout<<dp[k][n]<<endl;
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int T=1;
//cin>>T;
while(T--){
solve();
}
return 0;
}
如何判断 cost 函数满足四边形不等式
| 代价函数 | |
|---|---|
| \(\sum_{t=l}^{r} f(a_t)\)(区间和、平方和、权值和) | 满足,每个元素独立贡献,差值恒为常数 |
| \((S_r-S_{l-1})^2\)(\(S\) 单调) | 满足,凸二次型,\(S\) 越大增量越大 |
| 区间相同元素对数(CF868F) | 满足, \(\sum_v\binom{c_v}{2}\),\(\binom{x}{2}\) 是凸的 |
| 区间不同元素个数 | 反例 \(a=[1,2,1]\):\(w(1,2)+w(2,3)=2+2>w(1,3)+w(2,2)=2+1\) |
| 区间 \(\gcd\)、\(\min\) 这类"塌陷型" | 差值不单调,必须单独验证 |
| 带 \(\max\) / 绝对值的分段代价 | 不一定 |
- 逐元素贡献之和或凸函数套在可加量上,基本都可以;
- 去重 / 不同 / 最大最小这类非线性塌陷 ,不一定可以。
可以暴力测试一下。
习题
CF 321E Ciel and Gondolas
(后续会继续补充其他在此基础上的优化……)

浙公网安备 33010602011771号