洛谷P1522 [USACO2.4] 牛的旅行 Cow Tours（并查集+floyd)
题目描述
Farmer John 的农场里有很多 牧区。有的路径连接一些特定的牧区。一片所有连通的牧区 称为一个 牧场。但是就目前而言，你能看到至少有两个牧区通过任何路径都不连通。这样，Farmer John 就有 多个 牧场了。
John 想在牧场里添加 恰好 一条路径。对这条路径有以下限制：
一个牧场的 直径 就是牧场中 最远 的两个牧区的距离（本题中所提到的所有距离指的都是 最短的距离）。考虑如下的有 5 个牧区的牧场，牧区用 * 表示，路径用直线表示。每一个牧区都有自己的坐标：
(15,15) (20,15)
D E
*-------*
| _/|
| _/ |
| _/ |
|/ |
*--------*-------*
A B C
(10,10) (15,10) (20,10)
这个牧场的直径大约是 12.07106，最远的两个牧区是 A 和 E，它们之间的最短路径是 A→B→E。
这里是 John 的另一个牧场：
*F(30,15)
/
_/
_/
/
*------*
G H
(25,10) (30,10)
在这个例子中，他刚好有这两个牧场。John 将会在这两个牧场中各选一个牧区（即从 {A,B,C,D,E} 中选择一个牧区，从 {F,G,H} 中选择一个牧区），然后用一条路径将它们连起来，使得连通后这个新的更大的牧场的直径尽可能小。
注意，如果两条路径中途相交，我们不认为它们是连通的。只有两条路径在同一个牧区相交，我们才认为它们是连通的。
输入文件包括牧区、它们各自的坐标，还有一个如下的对称邻接矩阵：
A B C D E F G H
A 0 1 0 0 0 0 0 0
B 1 0 1 1 1 0 0 0
C 0 1 0 0 1 0 0 0
D 0 1 0 0 1 0 0 0
E 0 1 1 1 0 0 0 0
F 0 0 0 0 0 0 1 0
G 0 0 0 0 0 1 0 1
H 0 0 0 0 0 0 1 0
其他邻接表中可能直接使用行列而不使用字母来表示每一个牧区。输入数据中不包括牧区的名字。
输入文件 至少 包括两个不连通的牧区。
请编程找出一条连接属于两个 不同牧场 的牧区的路径，使得连上这条路径后，这个更大的新牧场的直径尽可能小。输出在所有合法的连接方案中，新牧场直径的最小值。
输入格式
第一行一个整数 N（1≤N≤150），表示牧区数。
接下来 N 行，每行两个整数 X,Y（0≤X,Y≤105），表示 N 个牧区的坐标。注意每个牧区的坐标都是不一样的。
接下来 N 行，每行 N 个数字，代表邻接矩阵 M。第 i 行第 j 列的数字为 1，表示 i 号牧区和 j 号牧区之间存在一条道路直接相连；第 i 行第 j 列的数字为 0，表示 i 号牧区和 j 号牧区之间不存在直接相连的道路。
保证 Mi,j=Mj,i。
输出格式
只有一行，包括一个实数，表示所求直径。数字保留六位小数。
只需要打到小数点后六位即可，不要做任何特别的四舍五入处理。
输入输出样例
输入 #1复制
8
10 10
15 10
20 10
15 15
20 15
30 15
25 10
30 10
01000000
10111000
01001000
01001000
01110000
00000010
00000101
00000010
输出 #1复制
22.071068
说明/提示
样例对应题目描述中的情况。
最优解是连接 C 牧区和 G 牧区，连接后图上只有一个牧场。这个牧场的直径为 A→B→C→G→F，长度约为 22.071068。可以证明不存在更优的方案。
USACO 2.4
题目相对来说算难也不算难，我也花了点时间，接下来是ac码：
点击查看代码
#include<bits/stdc++.h>
using namespace std;
// 定义结构体 node 用于存储每个牧区的坐标
struct node{
int x,y;
}arr[155];
// mp 数组用于存储邻接矩阵信息，d 数组用于存储任意两点间的最短距离
double mp[155][155];
double d[155][155];
// 定义一个极大值 INF，用于表示两点间没有直接相连的路径
const double INF = 1e18;
// fa 数组用于并查集，记录每个点的父节点
int fa[155];
// grp 数组用于存储每个连通分量（牧场）包含的点
int grp[155][155];
// grp_sz 数组用于记录每个连通分量（牧场）包含的点的数量
int grp_sz[155];
// dia 数组用于记录每个连通分量（牧场）的直径
double dia[155];
//我是思考是写一个并查集，全部给一个根，这样就可以判断哪几个点是不是在同一个牧区，但是有一个问题，根点是在哪里
//找到所有点后，连接起来后，找到最远端距离即可（非欧拉距离）
//然后floyd解掉，最后把最远的两端的点找出来，算实际距离，即可。
// 计算两点间的欧几里得距离
double distace(int i, int j) {
return sqrt((arr[i].x - arr[j].x) * (arr[i].x - arr[j].x) + (arr[i].y - arr[j].y) * (arr[i].y - arr[j].y));
}
//重所周知，这题其实考虑点就是，找到牧场中欧拉距离最远的两端，然后floyd找到他们的最短路径，这个就是单个牧场的最大半径了
//但是有一个更重要的问题就是，加上新的牧场后，构造出来的新牧场就不是这样的了，所以我的想法也有一个，在新老牧场之中，找到各个点与点的距离
//然后把距离最远的两个点拉出来，而这样的时候只需要考虑各个点的欧拉距离就可以了，所以我建议是
//把各个点的欧拉距离算出来，反正时间复杂度不会超，找到最远点，然后把他们连接起来，且保证超过旧牧场的最大半径即可//现在开始实现
// 并查集的查找函数，用于查找节点 x 所在集合的根节点
int findl(int x) {
if(fa[x] == x) return x;
else return fa[x] = findl(fa[x]);
}
// 初始化并查集，将每个节点的父节点初始化为自身
void init(int n) {
for(int i = 1; i <= n; i++) fa[i] = i;
}
// 并查集的合并函数，将节点 i 和节点 j 所在的集合合并
void unionn(int i, int j) {
int i_fa = findl(i);
int j_fa = findl(j);
fa[i_fa] = j_fa;
}
int main() {
// 优化输入输出流的速度
ios::sync_with_stdio(false);
cin.tie(0);
// 读取牧区的数量
int n;
cin >> n;
// 读取每个牧区的坐标
for(int i = 1; i <= n; i++) {
cin >> arr[i].x >> arr[i].y;
}
// 初始化并查集
init(n);
// 读取邻接矩阵信息
for(int i = 1; i <= n; i++) {
string s;
cin >> s;
for(int j = 1; j <= n; j++) {
// 如果两点间有直接相连的路径，则记录它们的欧几里得距离，否则记录为 INF
mp[i][j] = (s[j-1] == '1') ? distace(i, j) : INF;
if(i != j && mp[i][j] != INF) {
// 如果两点间有直接相连的路径，则将它们合并到同一个集合中
unionn(i, j);
}
}
}
/* int aa,bb;
cin>>aa>>bb;
cout<<findl(aa)<<" "<<findl(bb);
*///到这里判断，并查集已经完全没有问题了，接下来就是floyd了
// 初始化最短距离矩阵 d，自己到自己的距离为 0，其他为 INF
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
d[i][j] = (i == j) ? 0 : INF;
}
}
// 将邻接矩阵中的距离信息更新到最短距离矩阵 d 中
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
if(mp[i][j] != INF) {
d[i][j] = mp[i][j];
}
}
}
// Floyd-Warshall 算法，计算任意两点间的最短距离
for(int k = 1; k <= n; k++) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
if(d[i][k] + d[k][j] < d[i][j]) {
d[i][j] = d[i][k] + d[k][j];
}
}
}
}
// 初始化每个连通分量（牧场）的大小为 0
memset(grp_sz, 0, sizeof(grp_sz));
// 将每个点分配到对应的连通分量（牧场）中
for(int i = 1; i <= n; i++) {
int root = findl(i);
grp[root][grp_sz[root]++] = i;
}
// 计算每个连通分量（牧场）的直径
for(int i = 1; i <= n; i++) {
if(grp_sz[i] > 0) {
double max_d = 0;
for(int j = 0; j < grp_sz[i]; j++) {
for(int k = 0; k < grp_sz[i]; k++) {
if(d[grp[i][j]][grp[i][k]] > max_d) {
max_d = d[grp[i][j]][grp[i][k]];
}
}
}
dia[i] = max_d;
}
}
// 初始化连接两个不同牧场后新牧场的最小直径为 INF
double min_dia = INF;
// 遍历所有不同的连通分量（牧场）对
for(int i = 1; i <= n; i++) {
for(int j = i + 1; j <= n; j++) {
if(grp_sz[i] > 0 && grp_sz[j] > 0) {
// 遍历两个连通分量（牧场）中的所有点对
for(int u = 0; u < grp_sz[i]; u++) {
for(int v = 0; v < grp_sz[j]; v++) {
// 计算连接这两个点的距离
double uv = distace(grp[i][u], grp[j][v]);
double cross_max = 0;
// 计算连接这两个点后新牧场中任意两点间的最大距离
for(int a = 0; a < grp_sz[i]; a++) {
for(int b = 0; b < grp_sz[j]; b++) {
cross_max = max(cross_max, d[grp[i][a]][grp[i][u]] + uv + d[grp[j][v]][grp[j][b]]);
}
}
// 计算连接这两个点后新牧场的直径
double candidate = max({dia[i], dia[j], cross_max});
if(candidate < min_dia) {
// 更新最小直径
min_dia = candidate;
}
}
}
}
}
}
// 输出连接两个不同牧场后新牧场的最小直径，保留六位小数
cout << fixed << setprecision(6) << min_dia << endl;
return 0;
}
点击查看代码
// 读取邻接矩阵信息
for(int i = 1; i <= n; i++) {
string s;
cin >> s;
for(int j = 1; j <= n; j++) {
// 如果两点间有直接相连的路径，则记录它们的欧几里得距离，否则记录为 INF
mp[i][j] = (s[j-1] == '1') ? distace(i, j) : INF;
if(i != j && mp[i][j] != INF) {
// 如果两点间有直接相连的路径，则将它们合并到同一个集合中
unionn(i, j);
}
}
}
点击查看代码
// 初始化最短距离矩阵 d，自己到自己的距离为 0，其他为 INF
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
d[i][j] = (i == j) ? 0 : INF;
}
}
// 将邻接矩阵中的距离信息更新到最短距离矩阵 d 中
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
if(mp[i][j] != INF) {
d[i][j] = mp[i][j];
}
}
}
// Floyd-Warshall 算法，计算任意两点间的最短距离
for(int k = 1; k <= n; k++) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
if(d[i][k] + d[k][j] < d[i][j]) {
d[i][j] = d[i][k] + d[k][j];
}
}
}
}
点击查看代码
// 计算每个连通分量（牧场）的直径
for(int i = 1; i <= n; i++) {
if(grp_sz[i] > 0) {
double max_d = 0;
for(int j = 0; j < grp_sz[i]; j++) {
for(int k = 0; k < grp_sz[i]; k++) {
if(d[grp[i][j]][grp[i][k]] > max_d) {
max_d = d[grp[i][j]][grp[i][k]];
}
}
}
dia[i] = max_d;
}
}
点击查看代码
// 初始化连接两个不同牧场后新牧场的最小直径为 INF
double min_dia = INF;
// 遍历所有不同的连通分量（牧场）对
for(int i = 1; i <= n; i++) {
for(int j = i + 1; j <= n; j++) {
if(grp_sz[i] > 0 && grp_sz[j] > 0) {
// 遍历两个连通分量（牧场）中的所有点对
for(int u = 0; u < grp_sz[i]; u++) {
for(int v = 0; v < grp_sz[j]; v++) {
// 计算连接这两个点的距离
double uv = distace(grp[i][u], grp[j][v]);
double cross_max = 0;
// 计算连接这两个点后新牧场中任意两点间的最大距离
for(int a = 0; a < grp_sz[i]; a++) {
for(int b = 0; b < grp_sz[j]; b++) {
cross_max = max(cross_max, d[grp[i][a]][grp[i][u]] + uv + d[grp[j][v]][grp[j][b]]);
}
}
// 计算连接这两个点后新牧场的直径
double candidate = max({dia[i], dia[j], cross_max});
if(candidate < min_dia) {
// 更新最小直径
min_dia = candidate;
}
}
}
}
}
}
// 输出连接两个不同牧场后新牧场的最小直径，保留六位小数
cout << fixed << setprecision(6) << min_dia << endl;
return 0;
}
浙公网安备 33010602011771号