斜率优化建图学习笔记 & 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]);
}

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