浅谈斜率优化

浅谈斜率优化

概论

列出状态转移方程,如果能化简为以下的形式:

dp[i]=min/max(c[i]+d[j]+C)

此时我们就可以利用单调队列优化从做 O(n2)O(n) 的复杂度。

现在考虑更一般的情况,如果化简为以下形式:

dp[i]=min/max(a[i]b[j]+c[i]+d[j]+C)

此时单调队列优化就不再适用,就需要使用斜率优化

斜率优化的思想就是通过剔除一些不可能成为最优解的决策点,使剩下的决策点形成一个凸包,再使用单调队列、二分、平衡树、CDQ 分治或者李超线段树来快速转移。

理论讲解

斜率优化有两种理解方式:

代数法

设决策点 j2 优于 j1

则有:(< 对应 max> 对应 min

a[i]b[j1]+c[i]+d[j1]+C</>a[i]b[j2]+c[i]+d[j2]+C

化简得:

a[i]b[j1]+d[j1]</>a[i]b[j2]+d[j2]

Y(x)=d[x]X(x)=b[x]k=a[i],再让 X(j2)>X(j1)

移项得(不等号要变号):

k>/<Y(j2)Y(j1)X(j2)X(j1)

这就是说,将两个决策点在平面直角坐标系中用两点表示出来,如果两点间斜率小于(或大于)k,那么后面的点优于前面的点。

现在我们考虑有如下位置关系的三个点:

如图,k2<k1

下面我们讨论 max 的情况。

  • k<k2<k1 时,则 CA 优,BC 优,B 最优。
  • k2kk1 时,则 AB 至少有一个比 C 优。
  • k2<k1<k 时,则 AC 优,CB 优,A 最优。

综上,无论何种情况,C 都不可能最优,可以删去。

推广以上的性质,对于所有的决策点:

删去所有不可能为最优的决策点,发现可能为最优解的点会形成如下的一个下凸包

同理,对于 min 的情况,会形成一个上凸包。

几何法

我们先讨论 max 的情况:

dp[i]=max(a[i]b[j]+c[i]+d[j]+C)

去掉 max,再移项得:

d[j]=a[i]b[j]+c[i]dp[i]+C

我们可以将 d[j] 看作纵坐标,a[i] 看作斜率,b[j] 看作横坐标,c[i]dp[i]+C 看作常数。

那么此时就可以把状态转移方程看作一个形如 y=kx+b 的直线方程,其中对于同一个 i 斜率 k=a[i] 是不变的。

要使 dp[i] 最大,就要使方程的截距 b 尽可能小。

将所有决策点 (b[j],d[j]) 在平面直角坐标系中表示出来:

寻找最优决策点的过程就可以看作平移一条斜率不变的直线,自下往上遇到的第一个点必然使截距最小,如图:

事实上,这个点就是和前面点斜率小于等于当前斜率,和后面点斜率大于等于当前斜率的点。

现在我们考虑改变直线斜率,发现可能是最优解的决策点当且仅当在下面的下凸包上:

不在下面的下凸包上的,无论斜率如何改变,都不可能是从下往上平移最小的点。

同理,对于 min 的情况,会形成一个上凸包。

个人更喜欢几何法,比较直观,所以下面的例题都会采用几何法论证。

代码实现

对于不同的情况,我们有不同的插入决策点及查询最优解的方式(具体的可以看下面的例题):

决策点横坐标(b[j])严格增,直线方程斜率(a[i])严格增

  • 插入:可以维护一个队列存储决策点编号 j,由于决策点横坐标(b[j])严格增,再根据凸包斜率严格增(或减)的性质,在插入时只要队列倒数第二元素和队尾的斜率小于(或大于)队尾和要插入的点的斜率,就弹出队尾,直到保证斜率严格增(或减)
  • 查询:根据最优决策点和前面点斜率小于(或大于)等于当前斜率,和后面点斜率大于(或小于)等于当前斜率的点,再根据直线方程斜率(a[i])严格增,所以最优决策点横坐标严格增,不用保存前面的决策点,因此只要队首的两个元素斜率小于(或大于)当前斜率,就弹出队首,直到不能弹为止,队首就是最优决策点
  • 复杂度:O(n)

决策点横坐标(b[j])严格增,直线方程斜率(a[i])不严格增

  • 插入:由于决策点横坐标(b[j])严格增不变,同上。
  • 查询:由于直线方程斜率(a[i])不严格增,所以最优决策点没有单调性了,此时只能根据凸包斜率的单调性二分找到和前面点斜率小于(或大于)等于当前斜率,和后面点斜率大于(或小于)等于当前斜率的点的点。
  • 复杂度:O(nlogn)

决策点横坐标(b[j])不严格增

由于横坐标都不严格增,也就是说可能加的点在两点之间,上面的方法就行不通了。

可以考虑利用动态维护凸包或者采用 CDQ 分治离线等方法,在此先不予陈述。

这里介绍一种思维含量低、代码量小、常数小的优秀算法:李超线段树

关于李超线段树本身的讲解可以看:浅谈李超线段树

事实上,李超线段树并不是维护动态凸包,而是利用本身的特性直接维护答案。

将一些不变量提出:

dp[i]=c[i]+C+min/max(b[j]a[i]+d[j])

我们将 min/max 中的式子看作一个直线方程 y=kx+b,其中 b[j] 是斜率,a[i] 是此时横坐标,d[j] 是截距。

发现此时就是要求若干个直线 y=b[j]x+d[j]x=a[i] 时的最值,而这恰好是李超线段树所维护的东西。

因此,每次我们只需将直线 y=b[j]x+d[j] 插入李超树,再查询所有直线在 x=a[i] 时的最值更新答案即可。

时间复杂度:O(nlogn)

例题

题目描述

机器上有 n 个需要处理的任务,它们构成了一个序列。这些任务被标号为 1n,因此序列的排列为 1,2,3n。这 n 个任务被分成若干批,每批包含相邻的若干任务。从时刻 0 开始,这些任务被分批加工,第 i 个任务单独完成所需的时间是 Ti。在每批任务开始前,机器需要启动时间 s,而完成这批任务所需的时间是各个任务需要时间的总和。

注意,同一批任务将在同一时刻完成。每个任务的费用是它的完成时刻乘以一个费用系数 Ci

请确定一个分组方案,使得总费用最小。

数据范围

T1:1n5000,0S50,1Ti,Ci100

T2:1n300000,0S512,1Ti,Ci100

T3:1n300000,0S512,0Ci512,512Ti512

解题思路

T1:

朴素 DP,不需要优化。

我们对 ct 做前缀和,用前缀和替代原来的数组。

  • 状态表示:dp[i] 表示完成前 i 个任务的最小费用。
  • 初始化:dp[0]=0
  • 状态转移:考虑分配成的最后一组,设最后一组为 j+1i,首先要在 dp[j] 的基础上加上 t[i](c[i]c[j]),但是 s 貌似比较难处理,发现 s 会对后面所有的任务产生影响,因此为方便处理,我们可以提前把它对后面的总贡献 s(c[n]c[j]) 直接算进当前区间,因此有状态转移方程:

    dp[i]=min(dp[j]+t[i](c[i]c[j])+s(c[n]c[j]))

  • 答案:dp[n]

时间复杂度:O(n2)

T2

因为 1n300000O(n2) 无法通过,发现状态转移方程符合斜率优化的条件,考虑斜率优化。

化简、移项得:

dp[j]=(t[i]+s)c[j]+dp[i]t[i]c[j]sc[n]

要使 dp[i] 更小,那么就要使截距尽可能小,因此决策点会形成一个下凸包。

由于 Ti,Ci1,因此前缀和严格增,所以横坐标 c[j] 严格增,截距 t[i]+s 严格增,应用第一种情况即可。

T3

此时 512Ti512,所以截距不严格增,其他不变,在查询时二分找决策点即可。

编码技巧:在处理斜率时为避免误差,可以写作乘积的形式

代码

T1

#include<bits/stdc++.h>
#define endl "\n"
#define ll long long
using namespace std;

const int N = 5010;

int n, s;
ll t[N], f[N];
ll dp[N];

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> s;
	for (int i = 1; i <= n; i++)
	{
		cin >> t[i] >> f[i];
		t[i] = t[i - 1] + t[i];
		f[i] = f[i - 1] + f[i];
	}
	memset(dp, 0x7f, sizeof dp);
	dp[0] = 0;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 0; j < i; j++)
		{
			dp[i] = min(dp[i], dp[j] + t[i] * (f[i] - f[j]) + s * (f[n] - f[j]));
		}
	}
	cout << dp[n] << endl;
	return 0;
}

T2

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;

const int N = 3e5 + 10;

int n, s;
int t[N], c[N];
int dp[N], q[N];

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> s;
	for (int i = 1; i <= n; i++)
	{
		cin >> t[i] >> c[i];
		t[i] += t[i - 1];
		c[i] += c[i - 1];
	}
	int hh = 0, tt = 0;
	q[0] = 0;
	for (int i = 1; i <= n; i++)
	{
		while (hh < tt && (dp[q[hh + 1]] - dp[q[hh]]) <= (t[i] + s) * (c[q[hh + 1]] - c[q[hh]]))
		{
			hh++;
		}
		dp[i] = dp[q[hh]] + t[i] * (c[i] - c[q[hh]]) + s * (c[n] - c[q[hh]]);
		while (hh < tt && (dp[q[tt]] - dp[q[tt - 1]]) * (c[i] - c[q[tt]]) >= (dp[i] - dp[q[tt]]) * (c[q[tt]] - c[q[tt - 1]]))
		{
			tt--;
		}
		q[++tt] = i;
	}
	cout << dp[n] << endl;
	return 0;
}

T3

#include<bits/stdc++.h>
#define endl "\n"
#define ll long long
using namespace std;

const int N = 3e5 + 10;

int n, s;
ll t[N], c[N];
ll dp[N], q[N];

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> s;
	for (int i = 1; i <= n; i++)
	{
		cin >> t[i] >> c[i];
		t[i] += t[i - 1];
		c[i] += c[i - 1];
	}
	int hh = 0, tt = 0;
	q[0] = 0;
	for (int i = 1; i <= n; i++)
	{
		int l = hh, r = tt;
		while (l < r)
		{
			int mid = (l + r) >> 1;
			if (dp[q[mid + 1]] - dp[q[mid]] > (t[i] + s) * (c[q[mid + 1]] - c[q[mid]]))
			{
				r = mid;
			}
			else
			{
				l = mid + 1;
			}
		}
		dp[i] = dp[q[r]] + t[i] * (c[i] - c[q[r]]) + s * (c[n] - c[q[r]]);
		while (hh < tt && (dp[q[tt]] - dp[q[tt - 1]]) * (c[i] - c[q[tt]]) >= (dp[i] - dp[q[tt]]) * (c[q[tt]] - c[q[tt - 1]]))
		{
			tt--;
		}
		q[++tt] = i;
	}
	cout << dp[n] << endl;
	return 0;
}

题目描述

n 根柱子依次排列,每根柱子都有一个高度。第 i 根柱子的高度为 hi

现在想要建造若干座桥,如果一座桥架在第 i 根柱子和第 j 根柱子之间,那么需要 (hihj)2​​ 的代价。

在造桥前,所有用不到的柱子都会被拆除,因为他们会干扰造桥进程。第 i 根柱子被拆除的代价为 wi,注意 wi 不一定非负,因为可能政府希望拆除某些柱子。

现在政府想要知道,通过桥梁把第 1 根柱子和第 n 根柱子连接的最小代价。注意桥梁不能在端点以外的任何地方相交。

数据范围

2n105,0hi,|wi|106

解题思路

先用 w 的前缀和替代原来的序列。

考虑先列出 O(n2) 的状态转移方程:

  • 状态表示:dp[i] 表示用桥梁把前 i 根柱子连接的最小代价。
  • 初始化:dp[1]=0
  • 状态转移:考虑柱子 ij 相接,则有:

    dp[i]=min(dp[j]+(h[i]h[j])2+w[i1]w[j])

  • 答案:dp[n]

现在考虑斜率优化,移项:

dp[j]=2h[i]h[j]h[j]2w[j]+dp[i]h[i]2+w[i1]

发现由于原来的 h[i] 可以为 0,因此横坐标 h[j] 不严格增,只能用李超线段树优化。

将式子化为:

dp[i]=h[i]2+w[i1]+min(2h[j]h[i]+dp[j]+h[j]2w[j])

问题转化为:每次插入直线 y=2h[j]x+dp[j]+h[j]2w[j],求在 x=h[i] 时的最小值。

用李超线段树维护即可,时间复杂度 O(nlogn)

代码

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;

const int N = 1e5 + 10, M = 1e6 + 10;

int n;
long long h[N], w[N];
long long dp[N];

struct line
{
	long long k, b;
	
	inline long long calc(long long x)
	{
		return k * (x - 1) + b;
	}
} p[N];

struct SGT
{
	#define ls x << 1
	#define rs x << 1 | 1
	#define mid ((l + r) >> 1)
	int dat[M << 2];
	
	void update(int x, int l, int r, int k)
	{
		if (!dat[x])
		{
			dat[x] = k;
			return;
		}
		if (p[k].calc(mid) < p[dat[x]].calc(mid))
		{
			swap(k, dat[x]);
		}
		if (p[k].calc(l) < p[dat[x]].calc(l))
		{
			update(ls, l, mid, k);
		}
		if (p[k].calc(r) < p[dat[x]].calc(r))
		{
			update(rs, mid + 1, r, k);
		}
	}
	
	long long query(int x, int l, int r, int k)
	{
		if (r < k || l > k)
		{
			return 1e18;
		}
		long long res = p[dat[x]].calc(k);
		if (l == r)
		{
			return res;
		}
		return min(res, min(query(ls, l, mid, k), query(rs, mid + 1, r, k)));
	}
} t;

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	p[0].b = 1e18;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> h[i];
	}
	for (int i = 1; i <= n; i++)
	{
		cin >> w[i];
		w[i] = w[i] + w[i - 1];
	}
	p[1].k = -2 * h[1], p[1].b = h[1] * h[1] - w[1];
	t.update(1, 1, M, 1);
	for (int i = 2; i <= n; i++)
	{
		dp[i] = h[i] * h[i] + w[i - 1] + t.query(1, 1, M, h[i] + 1);
		p[i].k = -2 * h[i], p[i].b = dp[i] + h[i] * h[i] - w[i];
		t.update(1, 1, M, i);
	}
	cout << dp[n] << endl;
	return 0;
}

题目描述

Pine 开始了从 S 地到 T 地的征途。

S 地到 T 地的路可以划分成 n 段,相邻两段路的分界点设有休息站。

Pine 计划用 m 天到达 T 地。除第 m 天外,每一天晚上 Pine 都必须在休息站过夜。所以,一段路必须在同一天中走完。

Pine 希望每一天走的路长度尽可能相近,所以他希望每一天走的路的长度的方差尽可能小。

帮助 Pine 求出最小方差是多少。

设方差是 v,可以证明,v×m2 是一个整数。为了避免精度误差,输出结果时输出 v×m2

数据范围

1n3000

保证从 ST 的总路程不超过 3×104

2mn+1,每段路的长度为不超过 3×104正整数

解题思路

考虑先化简最后答案的式子(a 表示输入的每段路的长度):

s2=(a¯a1)2+(a¯a2)2++(a¯am)2m

s2=ma¯22a¯(a1+a2++am)+a12+a22++am2m

s2=m(i=1maim)22(i=1maim)(i=1mai)+i=1mai2m

s2=(i=1mai)2m2+i=1mai2m

s2m2=(i=1mai)2+mi=1mai2

发现右边第一项是定值,因此只要右边第二项最小即可,也就是问题转化为求最小平方和

不妨用 a 的前缀和替代原来的序列。

于是开始动态规划:

  • 状态表示:由于分成几段也会影响答案,因此要开两维表示,dp[i][j] 表示前 i 项分成 j 段的最小平方和。
  • 初始化:dp[0][i]=0
  • 状态转移:设最后一段为 k+1i,则有:

    dp[i][j]=min(dp[k][j1]+(a[i]a[k])2)

  • 答案:把 dp[n][m] 代入上面的式子即可。

时间复杂度 O(n3),无法通过,考虑斜率优化。

将式子化为:

dp[k][j1]+a[k]2=2a[i]a[k]+dp[i][j]a[i]2

要使 dp[i][j] 更小,则截距就要更小,所以最优决策点组成一个下凸包

由于 a[i] 严格增,所以横坐标和斜率都严格增,应用第一种情况即可。

比较值得注意的是,因为这道题是二维的,我们优化的是第一维,所以可以先枚举第二维,然后跑 m 遍斜率优化。

时间复杂度 O(mlogn)

代码

#include<bits/stdc++.h>
#define endl "\n"
#define ll long long
using namespace std;

const int N = 3e3 + 10;

ll n, m;
ll a[N];
ll dp[N][N], q[N];

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		a[i] += a[i - 1];
		dp[i][1] = a[i] * a[i];
	}
	for (int j = 2; j <= m; j++)
	{
		int h = 0, t = 0;
		q[0] = 0;
		for (int i = 1; i <= n; i++)
		{
			while (h < t && (dp[q[h + 1]][j - 1] - dp[q[h]][j - 1] + a[q[h + 1]] * a[q[h + 1]] - a[q[h]] * a[q[h]]) <= 2 * a[i] * (a[q[h + 1]] - a[q[h]]))
			{
				h++;
			}
			dp[i][j] = dp[q[h]][j - 1] + (a[i] - a[q[h]]) * (a[i] - a[q[h]]);
			while (h < t && (dp[q[t]][j - 1] + a[q[t]] * a[q[t]] - dp[q[t - 1]][j - 1] - a[q[t - 1]] * a[q[t - 1]]) * (a[i] - a[q[t]]) >= (dp[i][j - 1] + a[i] * a[i] - dp[q[t]][j - 1] - a[q[t]] * a[q[t]]) * (a[q[t]] - a[q[t - 1]]))
			{
				t--;
			}
			q[++t] = i;
		}
	}
	cout << m * dp[n][m] - a[n] * a[n] << endl;
	return 0;
}

题目描述

小 Y 最近在一家金券交易所工作。该金券交易所只发行交易两种金券:A 纪念券(以下简称 A 券)和 B 纪念券(以下简称 B 券)。每个持有金券的顾客都有一个自己的帐户。金券的数目可以是一个实数。

每天随着市场的起伏波动,两种金券都有自己当时的价值,即每一单位金券当天可以兑换的人民币数目。我们记录第 K 天中 A 券和 B 券的价值分别为 AKBK(元/单位金券)。

为了方便顾客,金券交易所提供了一种非常方便的交易方式:比例交易法。

比例交易法分为两个方面:

a) 卖出金券:顾客提供一个 [0,100] 内的实数 OP 作为卖出比例,其意义为:将 OP% 的 A 券和 OP% 的 B 券以当时的价值兑换为人民币;

b) 买入金券:顾客支付 IP 元人民币,交易所将会兑换给用户总价值为 IP 的金券,并且,满足提供给顾客的 A 券和 B 券的比例在第 K 天恰好为 RateK

例如,假定接下来 3 天内的 AK,BK,RateK 的变化分别为:

时间 AK BK RateK
第一天 1 1 1
第二天 1 2 2
第三天 2 2 3

假定在第一天时,用户手中有 100 元人民币但是没有任何金券。

用户可以执行以下的操作:

时间 用户操作 人民币(元) A 券的数量 B 券的数量
开户 100 0 0
第一天 买入 100 0 50 50
第二天 卖出 50% 75 25 25
第二天 买入 60 15 55 40
第三天 卖出 100% 205 0 0

注意到,同一天内可以进行多次操作。

小 Y 是一个很有经济头脑的员工,通过较长时间的运作和行情测算,他已经知道了未来 N 天内的 A 券和 B 券的价值以及 Rate。他还希望能够计算出来,如果开始时拥有 S 元钱,那么 N 天后最多能够获得多少元钱。

数据范围

N1050<AK100<BK100<RateK100MaxProfit109

必然存在一种最优的买卖方案满足:

每次买进操作使用完所有的人民币,每次卖出操作卖出所有的金券。

解题思路

考虑 DP。

  • 状态表示:dp[i] 表示前 i 天最多能获得多少钱。

  • 初始化:dp[0]=S

  • 状态转移:设现在是第 i 天,要使钱最多那么一定不买金券。

    • 不卖金券:dp[i]=dp[i1]

    • 卖金券:设现在卖出的金券是在第 j 天买入的,如果卖出有利润,那么当时就应该花光所有钱买金券以获得最大收益。

      设第 i 天最多能获得 xiA 券, yiB 券,则有:

      xi=dpiRiAiRi+Bi

      yi=dpi1AiRi+Bi

      所以:dp[i]=max(xjAi+yjBi)

    综上,状态转移方程为:

    dp[i]=max(dp[i1],max(xjAi+yjBi))

  • 答案:dp[n]

现在来考虑斜率优化,我们把它化成斜率优化能处理的式子(先不考虑不卖,最后把它算上即可):

yj=AiBixj+1Bidp[i]

发现 xj 没有单调性,因此考虑使用李超线段树。

变形得:

dp[i]=b[i]max(xjaibi+yj)

问题转化为:每次插入直线 y=xjx+yj,求在 x=aibi 时的最大值。

用李超线段树维护即可,时间复杂度 O(nlogn)

值得注意的是,这道题需要查询实数位置的最小值,可以离散化,再将李超线段树的 clac() 函数改写即可。

代码

#include<bits/stdc++.h>
#define endl "\n"
using namespace std;

const int N = 1e5 + 10;
const double eps = 1e-10;

int n;
double a[N], b[N], c[N], d[N], r[N];
double ans;

struct line
{
	double k, b;
	int id;
	
	inline double calc(int x)
	{
		return k * c[x] + b;
	}
} p[N];

struct SGT
{
	#define ls x << 1
	#define rs x << 1 | 1
	#define mid ((l + r) >> 1)
	int dat[N << 2];
	
	void update(int x, int l, int r, int k)
	{
		if (!dat[x])
		{
			dat[x] = k;
			return;
		}
		if (p[k].calc(mid) - p[dat[x]].calc(mid) > eps)
		{
			swap(k, dat[x]);
		}
		if (p[k].calc(l) - p[dat[x]].calc(l) > eps || (p[k].calc(l) == p[dat[x]].calc(l) && k < dat[x]))
		{
			update(ls, l, mid, k);
		}
		if (p[k].calc(r) - p[dat[x]].calc(r) > eps || (p[k].calc(r) == p[dat[x]].calc(r) && k < dat[x]))
		{
			update(rs, mid + 1, r, k);
		}
	}
	
	double query(int x, int l, int r, int k)
	{
		if (r < k || l > k)
		{
			return 0;
		}
		double res = p[dat[x]].calc(k);
		if (l == r)
		{
			return res;
		}
		return max(res, max(query(ls, l, mid, k), query(rs, mid + 1, r, k)));
	}
} t;

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> ans;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i] >> b[i] >> r[i];
		c[i] = d[i] = a[i] / b[i];
	}
	sort(c + 1, c + n + 1);
	for (int i = 1; i <= n; i++)
	{
		int sum = lower_bound(c + 1, c + n + 1, d[i]) - c;
		ans = max(ans, b[i] * t.query(1, 1, n, sum));
		p[i].k = ans * r[i] / (a[i] * r[i] + b[i]), p[i].b = ans / (a[i] * r[i] + b[i]);
		t.update(1, 1, n, i);
	}
	cout << fixed << setprecision(3) << ans << endl;
	return 0;
}

题目描述

猫国的铁路系统中有 n 个站点,从 1n 编号。小猫准备从 1 号站点出发,乘坐列车回到猫窝所在的 n 号站点。它查询了能够乘坐的列车,这些列车共 m 班,从 1m 编号。小猫将在 0 时刻到达 1 号站点。对于 i 号列车,它将在时刻 pi 从站点 xi 出发,在时刻 qi 直达站点 yi,小猫只能在时刻 pii 号列车,也只能在时刻 qii 号列车。小猫可以通过多次换乘到达 n 号站点。一次换乘是指对于两班列车,假设分别为 u 号与 v 号列车,若 yu=xv 并且 qupv,那么小猫可以乘坐完 u 号列车后在 yu 号站点等待 pvqu 个时刻,并在时刻 pv 乘坐 v 号列车。

小猫只想回到猫窝并且减少途中的麻烦,对此它用烦躁值来衡量。

  • 小猫在站点等待时将增加烦躁值,对于一次 t(t0) 个时刻的等待,烦躁值将增加 At2+Bt+C,其中 A,B,C 是给定的常数。注意:小猫登上第一班列车前,即从 0 时刻起停留在 1 号站点的那些时刻也算作一次等待。

  • 若小猫最终在时刻 z 到达 n 号站点,则烦躁值将再增加 z

形式化地说,若小猫共乘坐了 k 班列车,依次乘坐的列车编号可用序列 s1,s2,,sk 表示。该方案被称作一条可行的回家路线,当且仅当它满足下列两个条件:

  • xs1=1,ysk=n

  • 对于所有 j(1j<k),满足 ysj=xsj+1qsjpsj+1

对于该回家路线,小猫得到的烦躁值将为:

qsk+(A×ps12+B×ps1+C)+j=1k1(A(psj+1qsj)2+B(psj+1qsj)+C)

小猫想让自己的烦躁值尽量小,请你帮它求出所有可行的回家路线中,能得到的最 小的烦躁值。题目保证至少存在一条可行的回家路线。

数据范围

对于所有的测试点,保证 2n1051m1060A100B,C1071xi,yinxiyi0pi<qi4×104

解题思路

考虑 DP。

首先我们可以先不考虑到达 n 号站点增加的烦躁值,最后把它算上即可,因此下文指的最小烦躁值都不包含这一项。

  • 状态表示:这道题要在状态表示上做点文章,如果用 dp[i] 表示到达 i 站点的最小烦躁值,发现难以转移,而再加一维时间,时间和空间复杂度都难以接受,因此我们可以用 dp[i] 表示乘坐 i 号列车到达 yi 号站点的最小烦躁值,用一维就可以包含时间和空间。
  • 初始化:dp[0]=0
  • 状态转移:考虑从 j 列车换乘到 i 列车,则有:

    dp[i]=minxi=yj,pi>qj(dp[j]+A(piqj)2+B(piqj)+C)

  • 答案:minyi=n(dp[i]+qi)

时间复杂度 O(m2),考虑斜率优化:

dp[j]+Aqj2Bqj=2Apiqj+dp[i]Api2BpiC

我们先考虑两个限制如何处理:

  • 对于 xi=yj,我们只需n 个单调队列,查询从 xi 号单调队列中取,插入到第 yi 号单调队列即可。
  • 对于 pi>qj,我们可以考虑在查询时让单调队列中所有 qj 都小于等于 pi,具体地,由于 0pi,qi4×104,因此我们可以用桶存储代替堆,插入时先不插进单调队列,把它放进键值为 qi 的桶中,然后在查询的时候统一把键值小于 pi 的桶中的元素都插入单调队列。

发现对于第二个限制的处理方法,要求 pi 不降,于是我们一开始便可以将 pi 排序。

由于我们插入是按桶的顺序插入的,所以 qj 也顺带着不降了,因此斜率和横坐标都不降。

要使 dp[i] 更小,就要使截距更小,因此最优决策点构成一个下凸包,应用第一种情况即可。

时间复杂度 O(mlogm)

代码

#include<bits/stdc++.h>
#define endl "\n"
#define ll long long
using namespace std;

const int N = 1e5 + 10, M = 1e6 + 10;

struct node
{
	ll x, y, p, q;
} tr[M];

ll n, m, a, b, c, lst = 0, ans = LONG_LONG_MAX;
ll dp[M];
vector<int> e[N];

struct que
{
	int h = 0, t = -1;
	vector<ll> q;
	
	inline ll X(int x)
	{
		return tr[x].q;
	}
	
	inline ll Y(int x)
	{
		return dp[x] + a * tr[x].q * tr[x].q - b * tr[x].q;
	}
	
	ll query(int x)
	{
		if (h > t)
		{
			return -1;
		}
		while (h < t && (Y(q[h + 1]) - Y(q[h])) <= 2 * a * tr[x].p * (X(q[h + 1]) - X(q[h])))
		{
			h++;
		}
		return q[h];
	}
	
	void insert(int x)
	{
		while (h < t && (Y(q[t]) - Y(q[t - 1])) * (X(x) - X(q[t])) >= (Y(x) - Y(q[t])) * (X(q[t]) - X(q[t - 1])))
		{
			q.pop_back();
			t--;
		}
		q.push_back(x);
		t++;
	}
} q[N];

bool cmp(node x, node y)
{
	return x.p < y.p;
}

int main()
{
	ios :: sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	cin >> n >> m >> a >> b >> c;
	for (int i = 1; i <= m; i++)
	{
		cin >> tr[i].x >> tr[i].y >> tr[i].p >> tr[i].q;
	}
	sort(tr + 1, tr + m + 1, cmp);
	q[1].insert(0);
	for (int i = 1; i <= m; i++)
	{
		for (; lst <= tr[i].p; lst++)
		{
			for (auto it : e[lst])
			{
				q[tr[it].y].insert(it);
			}
		}
		int j = q[tr[i].x].query(i);
		if (j == -1)
		{
			continue;
		}
		dp[i] = dp[j] + a * (tr[i].p - tr[j].q) * (tr[i].p - tr[j].q) + b * (tr[i].p - tr[j].q) + c;
		e[tr[i].q].push_back(i);
		if (tr[i].y == n)
		{
			ans = min(dp[i] + tr[i].q, ans);
		}
	}
	cout << ans << endl;
	return 0;
}

结语

看了这么多,恭喜你学会了斜率优化!!!

有没有人和你说过,你学 OI 的样子真的很帅。

如果没有?

那么,就在上一秒,我对你说了。

posted @   I_LOVE_MATH  阅读(53)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· spring官宣接入deepseek,真的太香了~
点击右上角即可分享
微信分享提示