斜率优化 DP 总结

癹魃♭

已于 2024-02-29 16:46:35 修改

阅读量108

点赞数

分类专栏： # 斜率优化 DP 文章标签：算法 c++

于 2023-11-06 11:46:02 首次发布

本文链接：https://blog.csdn.net/qq_56326461/article/details/134240474

版权

斜率优化 DP 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

斜率优化 DP

顾名思义，运用数形结合的思想，将 DP 中求解的 最优值 问题转化为坐标系中相切问题，根据直线的斜率来求解

一般来说，斜率优化 DP 有几个前提：

朴素 DP 转移时需要枚举决策，可以将决策的 $O (n)$ 枚举优化到 $O (l o g)$ 甚至 $O (1)$ ，而 不可以在状态上进行优化
将外层的枚举变量当成常量后，转移方程可以写成阶段 $i$ 与决策 $j$ 的 一次函数，即：不包含其他未知量，不包含 非线性关系

通过具体题目来看

例 1 引入

传送门

在这里插入图片描述
一般来说，斜率优化DP 的题目会比较复杂，给的信息比较多，需要抽象出准确的转移式

设 $f [i]$ 表示完成前 $i$ 个任务的最小时间， $T [i]$ 表示时间的前缀和， $C [i]$ 表示费用前缀和

由任务是一段一段进行的，我们容易想到 对于当前 $i$ ，枚举以 $i$ 为结尾一段任务的开头，从而转移

但本题有个不太好处理的点，机器启动的时间 $S$ ，它会对后面的所有任务产生影响

运用一个技巧：费用提前计算

在当前阶段 $i$ 时，提前计算本次启动对后面所有任务费用的增量，直接加到 $f [i]$ 里

转移有： $f[i]=\min_{0\leq j<i} (\ f[j]\ + \ (C[i]-C[j])\times T[i]\ +\ S\ \times\ (C[n]-C[j]) )$

这就是斜率优化 DP 的第一步，写成朴素的 DP 转移式，标明决策上下界

第二步，我们对式子进行变形，去掉 $min$ ，分组、移项 $S\cdot C[j] = \underline{ T[i]\cdot C[j]} +f[i]-C[i]\cdot T[i]-S\cdot C[n]$

注意到，式子的左边只与 $j$ 有关，式子右边下划线是 $i$ 与 $j$ (有关) 的乘积，剩下则是要求的 $f [i]$ 和一些常数

如果令左侧为 $Y (j)$ ，右侧 $T [i]$ 为斜率 $k$ ， $C [j]$ 为 $X (j)$

就能得到： $Y(j)=k\cdot X(j)+b$ ，这就化成了关于 $j$ 的一次函数

回到问题，求 $\min f[j]$ ？等价于求 $b$ 最小，也就是截距最小

我们上图：

在这里插入图片描述
若干个黑色的 “决策” 构成了一条折线，对于当前 斜率确定 的直线，我们考虑找到使得截距最大的那个决策点

显然，它正是直线与折线 相切的位置
在这里插入图片描述
回忆单调队列优化 DP 的一个核心思想：排除无用决策，维护决策集合的高效和有序

这里我们也可以借用，显然由一些点是永远用不着的

最终，感性理解 + 理性证明，我们得出结论：只需要维护一条下凸折线

在这里插入图片描述

而下凸折线有着一条优秀的性质：斜率单调递增。

至于切点，我们可以发现就是 第一个斜率大于 $k$ 的位置。

这个是可以二分的。但本题还由一种更优秀的做法，发现枚举 $i$ 的过程中，直线的斜率 $T [i]$ 同样单调递增

那么只需实时维护队头元素即可，斜率小于当前 $k$ 时直接出队，队头就是最优决策

下面来说如何维护下凸折线
在这里插入图片描述
发现若当前新加入的点与队尾的连线斜率小了，可以把队头出队，直到斜率单调

具体实现来说，队列里放决策就行了， $X (j)$ ， $Y (j)$ ，或者斜率都可以现算

注意开 long long

代码：( 灰常臃肿）

#include<bits/stdc++.h>
using namespace std ;

const int N = 51000 , inf = 1e9 ;
typedef long long LL ;
// 费用提前计算 
int n ;
LL f[N] , T[N] , C[N] , S ; 
deque<int> q ;

int main()         
{
	scanf("%d%lld" , &n , &S ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		scanf("%lld%lld" , &T[i] , &C[i] ) ;
		T[i] += T[i-1] ; C[i] += C[i-1] ;
	}
	q.push_front( 0 ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		while( q.size() > 1 && f[q[1]]-f[q[0]] <= (C[q[1]]-C[q[0]])*(T[i]+S) ) q.pop_front() ;// 维护队头 
		f[i] = f[q.front()] + (C[i]-C[q.front()])*(T[i]) + S*(C[n]-C[q.front()]) ;
		while( q.size() > 1 && (f[q[q.size()-1]]-f[q[q.size()-2]])*(C[i]-C[q[q.size()-1]]) >= (f[i]-f[q[q.size()-1]])*(C[q[q.size()-1]]-C[q[q.size()-2]]) ) q.pop_back() ;
		q.push_back( i ) ;
	}
	printf("%lld" , f[n] ) ;
  	return 0 ;
}

其实本题能这么斜率优化还是有一些性质的：

观察 $X (j) = C [j]$ ，同样单增，这是斜率优化的 必要条件，即新加入决策点的横坐标务必单增，否则_{可能需要一些横纵坐标互换，转化坐标系的技巧或者高级数据结构}，简单说就是暂时搞不了
所求直线的斜率单调递增，这使得我们可以实时维护队头来确保最优决策，但是当斜率不单增时，就不得不使用二分了

例 2 二分

传送门

本题由于 $T [i]$ 不再单增，需要二分。

在这里插入图片描述
细节很多

#include<bits/stdc++.h>
using namespace std ;

const int N = 3e5 + 100 ;
typedef long long LL ;

int n ;
LL s , T[N] , C[N] , f[N] ;
deque<int> q ;

int main()         
{
	scanf("%d%lld" , &n , &s ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		scanf("%lld%lld" , &T[i] , &C[i] ) ;
		T[i] += T[i-1] , C[i] += C[i-1] ;
	} 
	q.push_back( 0 ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		LL nowK = T[i]+s ;
		// 二分查第一个大于当前斜率的决策 
		int l = 0 , r = q.size()-1 , mid ;
		while( l+1 < r ) {
			mid = ( l + r ) >> 1 ;
			if( f[q[mid+1]]-f[q[mid]] < nowK*(C[q[mid+1]]-C[q[mid]]) ) l = mid ;
			else r = mid ;
		}
		int j ;
		if( f[q[l+1]]-f[q[l]] > nowK*(C[q[l+1]]-C[q[l]]) ) j = l ;
		else j = r ;
		// 更新
		f[i] = f[q[j]] + s*(C[n]-C[q[j]]) + T[i]*(C[i]-C[q[j]]) ;
		while( q.size() > 1 && (f[i]-f[q[q.size()-1]])*(C[q[q.size()-1]]-C[q[q.size()-2]]) <= (f[q[q.size()-1]]-f[q[q.size()-2]])*(C[i]-C[q[q.size()-1]]) ) q.pop_back() ; 
		q.push_back( i ) ;
	}
	printf("%lld\n" , f[n] ) ;
  	return 0 ;
}

例 3 决策带限制

在这里插入图片描述
同样是 “一段一段” 的 DP，唯一需要注意的是决策上界

类似单队的技巧，决策合法时再加入队列

#include<bits/stdc++.h>
using namespace std ;

#define Y(y) (f[y]-S[y]+a[y+1]*(y))  
#define X(x) (a[x+1])
#define tt (q.size()-1)

typedef long long LL ;
const int N = 5e5 + 100 ;
const LL inf = 0x3f3f3f3f3f3f3f3f ;

int T ;
int n , K ;
LL f[N] , S[N] , a[N] ;
deque<int> q ;

int main()         
{
	scanf("%d" , &T ) ;
	while( T -- ) {
		scanf("%d%d" , &n , &K ) ;
		for(int i = 1 ; i <= n ; i ++ ) {
			scanf("%lld" , &a[i] ) ;
			S[i] = S[i-1] + a[i] ;
		}
		q.clear() ;
		q.push_back( 0 ) ;
		memset( f , 0x3f , sizeof f ) ;// 要么入队前判，要么初值赋小点，防爆
//		for(int i = 1 ; i <= n ; i ++ ) f[i] = 1e12 ;
		f[0] = 0 ;
		for(LL i = K ; i <= n ; i ++ ) {
			while( q.size()>1 && (Y(q[1])-Y(q[0])) <= (X(q[1])-X(q[0]))*i ) {
				q.pop_front() ;
			}
			int j = q.front() ; 
			f[i] = f[j] + S[i]-S[j] - a[j+1]*(i-j) ;
			if( f[i-K+1] < inf ) { // 十分关键
				while( q.size()>1 && ( ((Y(q[tt])-Y(q[tt-1]))*(X(i-K+1)-X(q[tt])) >= (Y(i-K+1)-Y(q[tt]))*(X(q[tt])-X(q[tt-1]))) ) ) {
					q.pop_back() ;
				}
				q.push_back( i-K+1 ) ;
			}
		}
		printf("%lld\n" , f[n] ) ;
	} 
  	return 0 ;
}