牛客:阿强的路
跟 最小密度路径 这道题类似,需要维护的两点间路径由两个因素影响
- 最小的 (路径最大点权乘以路径最大边权)(
语文要学好)
期望上我们希望 路径最大点权 d w dw dw 尽可能小,路径最大边权 e w ew ew 也尽可能小
但普通的 Floyd 不好同时维护这两个变量
观察下它的结构:
定义:
-
枚举任意两两点,用 n 个 第三点 尝试更新两两点之间的距离
-
最开始只允许经过 1 号顶点进行中转,接下来只允许经过 1 和 2 号顶点进行中转……允许经过 1 ~ n 号所有顶点进行中转,求任意两点之间的最短路程
-
用一句话概括就是:从 i 号顶点到 j 号顶点 只经过前 k 号点 的最短路程
这 n 个点只需要都枚举到,尝试更新即可,并没有严格的顺序要求
所以:
-
我们把 n 个点从小到大排序(基于期望),在枚举 n 个 第三点 时,使得点权值从小到大枚举
-
当且仅当 i 、 j i、j i、j 两点间的 路径最大边权 大于 m a x ( k − i , k − j ) max(k-i,k-j) max(k−i,k−j)路径最大边权时,我们才更新 i 、 j i、j i、j 两点间的 路径最大边权(使其尽可能小),同时尝试更新 两点间难度
-
可能会有疑问 —— 这不是只维护了两点间 路径最大边权 吗,两点间 路径最大点权 不需要维护吗?
-
可以发现 路径 是由这排好序后的 n 个点更新的,这 n 个点每次被拿出来时越来越大;任意两点间 路径上最大点权 只取决于 m a x ( d [ i ] , d [ j ] , d [ k ] ) max(d[i],d[j],d[k]) max(d[i],d[j],d[k]),所有其余的点的权值都会小于 d [ k ] 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;
}
巧妙至极!