决策单调性优化

决策单调性优化


问题

在遇到一些分层 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\) 都成立:

\[w(a,c)+w(b,d)\le w(a,d)+w(b,c) \]

\[w(a,c)-w(b,c)\le w(a,d)-w(b,d) \]

意为:把决策点从 \(b\) 左移到 \(a\) 所付出的额外代价,随 \(i\)(\(c\to d\))不减。

四边形不等式可以推出决策单调性,反之不行。

决策单调性总结来说就是对于靠后的终点 \(i\),决策点只会向右或不变,不会左移。

四边形不等式的另一种写法

固定两个候选决策点 \(j_1<j_2\),看它们在行 \(i\) 上的差:

\[M[i][j] = dp_{\text{prev}}[j] + w(j+1,\,i), \qquad \Delta(i) := M[i][j_2]-M[i][j_1] \]

\(dp\) 那部分与 \(i\) 无关,所以只需要看代价。在四边形不等式里取 \(a=j_1+1,\ b=j_2+1,\ c=i,\ d=i'\)(需要 \(j_2<i\),这正是"\(j_2\) 是合法决策点"):

\[w(j_1{+}1,i)+w(j_2{+}1,i') \le w(j_1{+}1,i')+w(j_2{+}1,i) \;\Longrightarrow\; \underbrace{w(j_2{+}1,i')-w(j_2{+}1,i)}_{\text{右边的增量}} \le \underbrace{w(j_1{+}1,i')-w(j_1{+}1,i)}_{\text{左边的增量}} \]

移项就得

\[\Delta(i') \le \Delta(i) \qquad (i<i') \]

定点四边不等式 ⟺ 任意两个决策点的代价差,随 \(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\)。

  1. \(j_1\) 是第 \(i\) 行的最优决策 \(\Rightarrow M[i][j_1]\le M[i][j_2]\),即 \(\Delta(i)\le 0\);
  2. \(j_2\) 是第 \(i'\) 行的最优决策 \(\Rightarrow M[i'][j_2]\le M[i'][j_1]\),即 \(\Delta(i')\ge 0\);
  3. 上文说 \(\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\) 是最小的最优决策矛盾。

弱条件与强条件

矩阵本身的单调性有两个层次:弱条件与强条件。需要注意的是,两者都只是描述矩阵本身满足哪种性质,并非互斥的分类。完全单调性可以推出决策单调性,反之不行。题目可以同时满足决策单调性和完全单调性

\[\text{四边形不等式} \Rightarrow \text{完全单调性(totally monotone)} \Rightarrow \text{决策单调性} \]

补充:
四边形不等式 = quadrangle inequality / Monge 条件;
完全单调性 = totally monotone(任意两列至多交叉一次);
决策单调性 = monotone argmin。

矩阵视角

形象的看:我们把 DP 看做一个矩阵,固定一层 DP,转移为

\[dp[i] = \min_{j<i} \bigl( dp_{\mathrm{prev}}[j] + \operatorname{cost}(j+1,i) \bigr) \]

\[\text{矩阵 } M[i][j] = dp_{\mathrm{prev}}[j] + \operatorname{cost}(j+1,i) \]

  • 行 \(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

转移形式为:

\[dp[g][i] = \min_{0 \le k < i} \bigl\{ dp[g-1][k] + \operatorname{cost}(k+1,i) \bigr\} \]

固定层 \(g\) 时,\(\operatorname{opt}[g][i]\) 关于 \(i\) 单调不减。甚至跨层有更强的夹逼关系:

\[\operatorname{opt}[g-1][i] \le \operatorname{opt}[g][i] \le \operatorname{opt}[g][i+1] \]

跨层夹逼

后一个不等式之前讲过,前一个跨层不等式是为什么:

首先明确 \(\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]\) 内。

  1. 取 \(\mathrm{mid}=(l+r)/2\)。
  2. 暴力枚举 \(k\in[L,\min(R,\mathrm{mid}-1)]\),找出 \(\mathrm{mid}\) 的最优决策 \(k^*\)。
  3. 左半边决策点一定 \(\le k^*\),右半边一定 \(\ge k^*\)。
  4. 递归 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(合并模型)

转移形式:

\[f[l][r] = \min_{l \le k < r} \bigl\{ f[l][k] + f[k+1][r] \bigr\} + w(l,r) \]

若 \(w\) 满足四边形不等式且区间包含单调性(\(w(l,r)\) 随区间扩大不降),则不仅有 \(f\) 本身满足四边形不等式,还有跨区间夹逼:

\[\operatorname{opt}[l][r-1] \le \operatorname{opt}[l][r] \le \operatorname{opt}[l+1][r] \]

因此计算 \(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

Problem - 868F - Codeforces

题意:给 \(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\) / 绝对值的分段代价 不一定
  1. 逐元素贡献之和或凸函数套在可加量上,基本都可以;
  2. 去重 / 不同 / 最大最小这类非线性塌陷 ,不一定可以。

可以暴力测试一下。

习题

CF 868F

P4767 [IOI2000] 邮局 加强版

CF 321E Ciel and Gondolas

P1912 [NOI2009] 诗人小G

P1880 [NOI1995] 石子合并

P3195 [HNOI2008] 玩具装箱

P17210 【模板】半在线决策单调性

(后续会继续补充其他在此基础上的优化……)

posted @ 2026-11-17 01:27  WuYong123  阅读(50)  评论(0)    收藏  举报