[笔记] Slope Trick：解决一类凸代价函数的DP优化问题

原理

当序列 DP 的转移代价函数满足

连续；

凸函数；

分段线性函数.

时，可以通过记录分段函数的最右一段 $f_r(x)$ 以及其分段点 $L$ 实现快速维护代价的效果。

如：$ f(x)= \begin{cases} -x-3 & (x \le -1) \ x &( -1 < x\le1)\ 2x-1 &(x > 1)\end{cases} $

可以仅记录 $f_r(x)=2x-1$ 与分段点 $L_f=\{-1,-1,1\}$ 来实现对该分段函数的存储。

注意：要求相邻分段点之间函数的斜率差为 $1$ ，也就是说相邻两段之间斜率差 $>1$ 的话，这个分段点要在序列里出现多次。

优秀的性质：

$F(x),G(x)$ 均为满足上述条件的分段线性函数，那么 $H(x)=F(x)+G(x)$ 同样为满足条件的分段线性函数，且 $H_r(x)=F_r(x)+G_r(x),L_H=L_F\cup L_G$。

该性质使得我们可以很方便得运用数据结构维护 $L$ 序列。

例题

CF713C Sonya and Problem Wihtout a Legend

给定一个有 $n$ 个正整数的数组，一次操作中，可以把任意一个元素加一或减一。（元素可被减至负数或 $0$），求使得原序列严格递增的求最小操作次数。

$n\le 3000,a_i\le10^9$

首先 $a_i=a_i-i$ 转成不降.

设 $f_{i,j}$ 表示第 $i$ 个数为 $j$ 的最小操作次数，则有

\[f_{i,j}=\min_{k\le j}\{f_{i-1, k}\}+|a_i-j|
\]

绝对值函数显然是满足条件的凸函数，所以考虑直接维护这个函数。

因为是求前缀最小值，同时绝对值函数最右直线的斜率为正，故不妨只留下斜率为 $0$ 的左侧函数。

那么每次转移就是向 $L_f$ 中插入 $\{a_i,a_i\}$，同时，这时最右直线的斜率到达 $1$，故删去最右分段点。

于是最后 $f_r$ 的截距 $b$ 就是答案。

点击查看代码

signed main(){

	read(n);

	lfor(i, 1, n) read(a[i]), a[i] -= i;

	lfor(i, 1, n){

		Q.push(a[i]), Q.push(a[i]);

		b += -a[i];

		int R = Q.top(); Q.pop();

		b += R;

	}

	cout << b << endl;

	return 0;

}

CF1534G A New Beginning

你在一个二维平面直角坐标系的原点 $(0,0)$ 上，可以向上或向右移动 $1$ 单位长度任意次。

现在给 $n$ 个点，第 $i$ 个点为 $(x_i,y_i)$，求对这 $n$ 个点都打上标记的最少花费。

具体的，在任意时刻，在 $(X,Y)$ 对 $(x,y)$ 打标记，需要花费 $\max(|X-x|,|Y-y|)$ 。

$1\leq n\leq8\times10^5;0\leq x_i,y_i\leq10^9;$

首先，将切比雪夫距离转换成曼哈顿距离，$(x,y)\rightarrow(\frac{x+y}{2},\frac{x-y}{2})$。

容易发现一个点一定是在走到 $X=x_i$ 的时候标记最优，故设 $f_{i,j}$ 表示 $X=x_i,Y=j$，且所以 $x_i\le X$ 的点已经全部标记的最小代价，则有

\[f_{i,j}=\min_{j-|x_{i+1}-x_i|\le k\le j+|x_{i+1}-x_i|}\{f_{i-1, k}\}+\sum_{(x,y),x=x_i}|j-y|
\]

那么考虑一次转移时，凸函数的变化是怎么样的。

即最低点往左右各延伸 $|x_{i+1}-x_i|$ 的单位长度，其他位置平移，然后加上 $\sum_{(x,y),x=x_i}|j-y|$。

直接用大根堆和小根堆分别维护斜率为 $0$ 的左右侧的分段点，平移就给整个堆打标记；与其他凸函数合并的时候，先直接按照大小加，然后讨论一下两个堆的分开位置是不是仍然斜率为 $0$，不是的话，讨论一下是要把哪个堆顶的一些分段点放到另一个堆中。

点击查看代码

signed main(){

	read(n);

	lfor(i, 1, n){

		int x, y; read(x), read(y);

		p[i] = {x + y, x - y}, uni[++tot] = p[i].x;

	}

	sort(p + 1, p + n + 1, [&](pal a, pal b){ return a.x < b.x; });

	sort(uni + 1, uni + tot + 1), tot = unique(uni + 1, uni + tot + 1) - uni - 1;

	lfor(i, 1, n) v[lsh(p[i].x)].pb(p[i].y);

	lfor(i, 1, tot){

		if(i > 1) More(uni[i] - uni[i - 1]);

		for(int it : v[i]){

			K += 1, B += -it;

			if(!Q2.empty() && it <= Q2.top() + det2){

				Q1.push(it - det1), Q1.push(it - det1);

			}else Q2.push(it - det2), Q2.push(it - det2);

		}

		while(Q2.size() < K) Q2.push(Q1.top() + det1 - det2), Q1.pop();

		while(Q2.size() > K) Q1.push(Q2.top() + det2 - det1), Q2.pop();

	}

	while(Q2.size()) stk[++top] = Q2.top() + det2, Q2.pop();

	while(top) K--, B += stk[top--];

	cout << B / 2 << endl;

	return 0;

}

CF1210G Mateusz and Escape Room

给出一个 $n$ 个点的环，每个点上都有一堆石子，其中第 $i$ 个点上的石子个数为 $a_i$ 。

每次操作可以选择一堆石子，将其中的一颗石子向左或是向右移到相邻的石子堆中。

要求在进行一系列操作后，位置 $i$ 的石子个数要在 $[L_i,R_i]$ 之间，问最少操作次数?

$n,a_i,L_i,R_i\le 35000$.

我们可以设 $x_i$ 表示第 $i$ 堆石子向第 $i+1$ 堆石子移动了个石子 ( 可以为负 )，则最终状态下每个位置的石子数就是 $b_i=a_i-x_i+x_{i-1}$，而答案就是 $\sum_{i=1}^n|x_i|$。

那么如果枚举 $x_1$，就可以用 dp 解决这个问题了，设 $f_{i,j}$ 已经确定了$x_{1\sim i}$ ，且 $2\sim i$ 已经合法的最小操作次数，则有：

\[f_{i,j}=\min_{j-(L_i-a_i)\le k\le j-(R_i-a_i)}\{f_{i-1, k}\}+|j|
\]

用上一题类似的方式维护即可。

其次因为答案关于 $x_1$ 是单峰的，所以可以三分 $x_1$，最终 $O(n\log n\log \sum a_i)$ 解决问题。

点击查看代码

LL solve(int x1){

	K = B = det1 = det2 = 0;

	K = n + 10, B = abs(x1) - K * x1;

	lfor(i, 1, K) Q1.push(x1), Q2.push(x1); 

	lfor(i, 2, n){

		det1 -= (r[i] - a[i]), det2 -= (l[i] - a[i]), B += K * (l[i] - a[i]);

		K += 1;

		if(!Q2.empty() && 0 <= Q2.top() + det2) Q1.push(-det1), Q1.push(-det1);

		else Q2.push(-det2), Q2.push(-det2);

		while(Q2.size() < K) Q2.push(Q1.top() + det1 - det2), Q1.pop();

		while(Q2.size() > K) Q1.push(Q2.top() + det2 - det1), Q2.pop();

	}

	int top = 0, L = l[1] - a[1] + x1, R = r[1] - a[1] + x1; LL sum = INF;

	while(!Q2.empty()) stk[++top] = Q2.top() + det2, Q2.pop();

	while(!Q1.empty()) stk[++top] = Q1.top() + det1, Q1.pop();

	sort(stk + 1, stk + top + 1);

	stk[top + 1] = INF, stk[0] = -INF;

	if(stk[top] < L) sum = min(sum, K * L + B);

	for(int i = top; i >= 1;){

		LL x = stk[i];

		LL y = K * x + B;

		if(L <= x && x <= R) sum = min(sum, y);

		while(stk[i] == x && i >= 1) --K, B += x, --i;

		if(stk[i] < L && L < x) sum = min(sum, K * L + B);

		if(stk[i] < R && R < x) sum = min(sum, K * R + B);

	}

	if(R < stk[0]) sum = min(sum, K * R + B);

	return Ans = min(Ans, sum), sum;

}

int main(){

	read(n);

	lfor(i, 1, n) read(a[i]), read(l[i]), read(r[i]), A += a[i];

	LL l = -A, r = A, mid;

	while(l <= r){

		mid = l + r >> 1;

		if(solve(mid - 1) > solve(mid)) l = mid + 1;

		else r = mid - 1;

	}

	cout << Ans << endl;

	return 0;

}

P3642 [APIO2016]烟火表演（咕）

注意

直线 $kx+b$ 向右平移 $\Delta$ 得到的是 $k(x-\Delta)+b$，所以应当是 $b\gets b-k\cdot\Delta$.
由 $(k-1)x+b'=kx+b$，得到从右往左推算函数表达式时，$b'\gets b+x$.
如果初始条件是 $x$ 处为 $v$，其他地方为 $\infty$，可以在堆中加入若干 $x$，让斜率陡升。
答案只能从区间 $[L,R]$ 中取得时，注意在无法取 $0$ 的情况下是否真的取到了 $L/R$。
如果斜率变化很大，也许可以用 $(x,cnt)$ 的形式来维护。