斜率优化建图学习笔记 & JZOJ 地壳运动题解

本章学习斜率优化建图

请放心食用

引言

• 最小生成树($mst$) ($Algorithm: \text {Prim or Kruskal}$)
• 从裸题到一丁点技巧，再到丧心病狂的神仙题
• 原始时间复杂度 $O(N^2)$ 与 $O(M log M)$
• 永远的 $TLE$ ······

正话

本文第一句就是正话
像多次查询而你非得（无奈）每次重新建图，跑一边 $mst$ 的题
很多时候带有技巧性，优先考虑建图的优化
如果熟悉斜率优化 $dp$ 的话，像一些边有多种信息会产生贡献，如二维最小生成树（边有两条信息会在不同时候产生不一样的贡献）
可以考虑斜率那些事儿

配上例题，更好食用

地壳运动(mst)

$Description$

JZ是一个坐落在地壳运动活跃的山区的城市，常受地质灾害的袭击。
城市中建立了N个应急避难所以躲避灾害，这些避难所从1～N编号。此外有M条道路连接这些避难所，所有避难所间均可通过这M条道路直接或间接到达。由于是在规划良好的市区，道路可以由若干个平行于x或y坐标轴的线段组成，所以避难所xi和yi之间的道路可以用(ui,vi)来表示，道路的长度为ui+vi。由于地壳运动会导致地面拉伸或收缩，可用两个实数k1,k2描述城市的伸缩程度，此时某条道路的实际长度变为 $ui\times k1+vi\times k2$。有若干个独立的询问，每次询问给出k1和k2，政府都希望在此地壳运动前提下，以最小的花费维护其中一些道路，使得只用这些被维护的道路仍能使所有避难所间相互连通。因为花费与道路的实际总长成正比，所以你需要对每一次询问求出被维护道路的最短实际总长。

$Input$

第一行三个整数N,M,Q，分别表示避难所数量、道路数量、询问数量。
接下来M行每行四个整数xi,yi,ui,vi。xi,yi表示道路连接的两个避难所编号，ui,vi意义如上文所述。
最后Q行每行两个实数，表示每次询问的的k1和k2。

$Output$

输出Q行，每行一个实数，表示实际总长，保留三位小数。

$Sample Input$

4 8 3
2 1 3 6
3 2 0 7
4 1 7 0
1 4 4 6
2 1 2 7
1 2 2 10
2 2 5 5
4 4 8 9
0.626436771146 0.472537839745
0.977631137354 0.190235819672
0.418883351791 0.221987861358

$Sample Output$

12.253
9.671
6.878

解法

• $30$ 分，依题暴力，每次重新建图，重跑 $mst$
• $60$ 分，用脑袋想想，去掉那些无用的边，捡一些可能的较好边，然后愉快拿到全场第二高分（$sorry$ ， 有初一A掉的）
• $100$ 分，多样做法，下面介绍一种
  依题有两块地区的花费 $g(x,y) = u_i * k1 + v_i * k2$
  这让我们无法挑取好边，导致每次都要重新建图
  倘若我们把它当成一次函数
  化简它 $v_i = -\frac{k1}{k2} u_i + \frac{g(x,y)}{k2}$

你问我为何要化成这样，我只好回答你
1.参考其他人的解法
2.经验（虽然我没经验）
3.依题

前两点无可反驳，第三点怎个依题，愿闻其详
好，我们要找决策集合，所以一次函数的 $y$ 与 $x$ 要和 $\text{u_i v_i}$ 相关，而两地的实际长度由 $\text{k1 k2}$ 决定
也就是说靠 $\text{k1 k2}$ 来确定一条直线
就很自然想到拿这两个东西来当斜率或与截距相关
而本题要在两点间取最优边，基本套路就是用若干直线切决策点，最小化截距
因为 $k1 > 0 , k2 > 0$ 所以最小化截距就是最小化 $g(x,y)$
达到目的，看具体实现

既然要最小化截距，那么我们就要维护下凸壳，上凸的绝对没有下凸的优（自己画一下）
所以我们就有了一点思绪
对于 $(x,y)$ 这两地，我们需寻找其中的最优决策
而我们将在它的决策集合$\texttt{u_i v_i}$中挑选
基本会想到先将$\texttt{u_i v_i}$看成在平面直角坐标系中的一个点
然后配合化简的式子分析：$v_i = -\frac{k1}{k2} u_i + \frac{g(x,y)}{k2}$
先前提到最小化截距
那么我们将决策集合的点先按 $u_i$ 从小到大排序
然后单调队列维护下凸壳，也就是维护斜率单调递增
但尽管如此，我们的决策点仍旧是太多了，还是会超时
然后我们想想，如果斜率单调递增，那么对于斜率小于直线斜率的点对 $(x_1 , y_1)$ 和 $(x_2 , y_2)$
因为排过序了，所以有 $x_1 < x_2$
这两点你画画图，用直线去切，不难发现
$(x_1 , y_1)$ 和 $(x_2 , y_2)$，后者更优（此时的直线斜率更小）
这样的话，我们凭此弹掉队首的劣点，就能确定最优的点是谁了，直接 $O(1)$ 取队首
但前提是斜率单调递增
把 $-\frac{k1}{k2}$ 排个序就好了，升序

具体来说，就是

• 维护每两个地区下凸壳
• 排序$-\frac{k1}{k2}$
• 每两个地区重新选边，弹去队首劣点，取新的队首作为最优决策
• 跑 $Prim$，算答案

代码（仍需开O）

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
 
const int N = 35 , Q = 200000;
const double INF = 1e18;
int n , m , q , p[N + 5][N + 5];
double ans[Q + 5] , dis[N + 5] , vis[N + 5] , g[N + 5][N + 5];
struct que{
	int id;
	double k1 , k2 , k;
}ask[Q + 5];
struct point{
	int x , y;
};
vector<point> vec[N + 5][N + 5] , e[N + 5][N + 5];
 
inline bool cmp(point x , point y) {return x.x < y.x;}
inline bool cmp1(que x , que y) {return x.k < y.k;}
 
inline void choose(que l)
{
	for(register int i = 1; i <= n; i++)
		for(register int j = 1; j <= n; j++)
			g[i][j] = INF;
	for(register int i = 1; i <= n; i++)
		for(register int j = i + 1; j <= n; j++)
		if (e[i][j].size())
		{
			if (e[i][j].size() - p[i][j] == 1) g[i][j] = 1.0 * e[i][j][p[i][j]].x * l.k1 + 1.0 * e[i][j][p[i][j]].y * l.k2;
			else {
				while (p[i][j] < e[i][j].size() - 1 && 1.0 * (e[i][j][p[i][j]].y - e[i][j][p[i][j] + 1].y) / (e[i][j][p[i][j]].x - e[i][j][p[i][j] + 1].x) < l.k)
					p[i][j]++;
				g[i][j] = 1.0 * e[i][j][p[i][j]].x * l.k1 + 1.0 * e[i][j][p[i][j]].y * l.k2;;
			}
			g[j][i] = g[i][j];
		}
}
 
inline double prim()
{
	for(register int i = 0; i <= n; i++) dis[i] = INF , vis[i] = 0;
	int k;
	double res = 0;
	dis[1] = 0;
	for(register int i = 1; i <= n; i++)
	{
		k = 0;
		for(register int j = 1; j <= n; j++) 
		if (!vis[j] && dis[j] < dis[k]) k = j;
		vis[k] = 1 , res += dis[k];
		for(register int j = 1; j <= n; j++)
		if (!vis[j] && dis[j] > g[k][j]) dis[j] = g[k][j];
	}
	return res;
}
 
int main()
{
//	freopen("mst.in" , "r" , stdin);
//	freopen("mst.out" , "w" , stdout);
	scanf("%d%d%d" , &n , &m , &q);
	int x , y , u , v , s;
	for(register int i = 1; i <= m; i++)
	{
		scanf("%d%d%d%d" , &x , &y , &u , &v);
		if (x == y) continue;
		if (x > y) swap(x , y);
		vec[x][y].push_back((point){u , v});
	}
	for(register int i = 1; i <= n; i++)
		for(register int j = i + 1; j <= n; j++)
		if (vec[i][j].size())
		{
			sort(vec[i][j].begin() , vec[i][j].end() , cmp);
			s = 0 , e[i][j].push_back(vec[i][j][0]);
			for(register int k = 1; k < vec[i][j].size(); k++)
			{
				if (vec[i][j][k].x == e[i][j][s].x) 
				{
					if (vec[i][j][k].y >= e[i][j][s].y) continue;
					else e[i][j].pop_back() , s--;
				}
				if (s == 0) s++ , e[i][j].push_back(vec[i][j][k]);
				else {
					while (s > 0 && 1.0 * (e[i][j][s].y - e[i][j][s - 1].y) / (e[i][j][s].x - e[i][j][s - 1].x) > 1.0 * (vec[i][j][k].y - e[i][j][s].y) / (vec[i][j][k].x - e[i][j][s].x))
						e[i][j].pop_back() , s--;
					s++ , e[i][j].push_back(vec[i][j][k]);
				}
			}
		}
	double k1 , k2;
	for(register int i = 1; i <= q; i++)
	{
		scanf("%lf%lf" , &k1 , &k2);
		ask[i].id = i , ask[i].k1 = k1 , ask[i].k2 = k2 , ask[i].k = -1.0 * k1 / k2;
	}
	sort(ask + 1 , ask + q + 1 , cmp1);
	for(register int i = 1; i <= q; i++)
		choose(ask[i]) , ans[ask[i].id] = prim();
	for(register int i = 1; i <= q; i++) printf("%.3lf\n" , ans[i]);
}

函数是很美妙的，关于斜率高深莫测的那些事儿，还得慢慢摸索