2021辽宁省大学生程序设计竞赛 B. 阿强的路（多条件状态转移 + Floyd变式）

牛客：阿强的路

跟 最小密度路径 这道题类似，需要维护的两点间路径由两个因素影响

• 最小的 （路径最大点权乘以路径最大边权）（语文要学好 ）

期望上我们希望 路径最大点权 $dw$ 尽可能小，路径最大边权 $ew$ 也尽可能小

但普通的 Floyd 不好同时维护这两个变量

观察下它的结构：

定义：

• 枚举任意两两点，用 n 个 第三点 尝试更新两两点之间的距离

• 最开始只允许经过 1 号顶点进行中转，接下来只允许经过 1 和 2 号顶点进行中转……允许经过 1 ~ n 号所有顶点进行中转，求任意两点之间的最短路程

• 用一句话概括就是：从 i 号顶点到 j 号顶点 只经过前 k 号点 的最短路程

这 n 个点只需要都枚举到，尝试更新即可，并没有严格的顺序要求

所以：

• 我们把 n 个点从小到大排序（基于期望），在枚举 n 个 第三点 时，使得点权值从小到大枚举

• 当且仅当 $i、j$ 两点间的 路径最大边权 大于 $max（k-i，k-j）$路径最大边权时，我们才更新$i、j$ 两点间的 路径最大边权（使其尽可能小），同时尝试更新 两点间难度

• 可能会有疑问 —— 这不是只维护了两点间 路径最大边权 吗，两点间 路径最大点权 不需要维护吗？

• 可以发现 路径 是由这排好序后的 n 个点更新的，这 n 个点每次被拿出来时越来越大；任意两点间 路径上最大点权 只取决于$max（d[i],d[j],d[k]）$，所有其余的点的权值都会小于$d[k]$

由此我们的魔改 Floyd 就处理完了，代码如下：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul (u << 1)
#define ur (u << 1 | 1)
#define fx first
#define fy second
//#pragma GCC optimize(2)
//[博客地址](https://blog.csdn.net/weixin_51797626?t=1) 
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;
typedef pair <ll, PII> PI;

const int N = 510, M = 1000010, MM = N;
int INF = 0x3f3f3f3f, mod = 100003;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S, D;
int g[N][N];//两点间路径最大边权
ll f[N][N];//两点间的难度
struct node
{
	int w, i;
	bool operator <(const node& nn)const { return w < nn.w; }
}d[N];//根据点权排序后的 n 个点
int dw[N];//初始 n 个点

void floyd() {
	for (int k = 1; k <= n; k++)
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				if (g[i][j] > max(g[i][d[k].i], g[d[k].i][j])) {
					g[i][j] = max(g[i][d[k].i], g[d[k].i][j]);
					//若通过第三点转移的路径最大边权 比 原来的要小，那就维护最小

					//虽然边权变小了，dw[i],dw[j]是原本就存在的，点权取决于d[k].w，可能较大也可能较小，乘起来的结果不确定
					f[i][j] = f[j][i] = min(f[i][j], (ll)g[i][j] * max({ dw[i],dw[j],d[k].w }));
					//所以取min，尝试更新两点间最小难度
					// 
					//不需要维护 路径最大点权，因为 d[k].w 肯定是路径中除了起点终点外，最大权值的的点
				}
}

int main() {
	cinios;

	cin >> n >> m;
	mem(g, 0x3f);//初始化
	mem(f, 0x3f);

	for (int i = 1; i <= n; i++) {
		cin >> d[i].w;
		d[i].i = i, dw[i] = d[i].w;//初始和排序都记录

		f[i][i] = g[i][i] = 0;
	}
	sort(d + 1, d + 1 + n);

	for (int i = 0; i < m; i++) {
		int a, b, x;
		cin >> a >> b >> x;
		g[a][b] = g[b][a] = min(g[a][b], x);//维护最小边权
		f[a][b] = f[b][a] = min(f[a][b], (ll)g[a][b] * max(dw[a], dw[b]));
		//显然有边权有点权，最小难度也存在
	}

	floyd();

	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++)
			cout << f[i][j] << ' ';
		cout << '\n';
	}

	return 0;
}

巧妙至极！