Niu's Travel (Pase de un libro para los Juegos Olímpicos de Informática-T1343)

Título Descripción
La granja del granjero John tiene muchas áreas pastorales, y algunos caminos conectan áreas pastorales específicas, y todas las áreas pastorales conectadas se denominan pastos.

Pero por ahora, puede ver que al menos dos áreas pastorales están desconectadas. Ahora, John quiere agregar un camino a la granja (tenga en cuenta que hay exactamente uno).

Existe tal restricción en este camino: el diámetro de un pastizal es la distancia más corta entre los dos pastos más lejanos del pastizal.

Considere los siguientes dos pastos. La Figura 1 es un pastizal con 5 áreas pastorales. Las áreas pastorales están representadas por "*", el camino está representado por una línea recta y cada área pastoral tiene sus propias coordenadas:

El diámetro del pasto que se muestra en la Figura 1 es aproximadamente 12.07106, las dos áreas pastorales más alejadas son A y E, y el camino más corto entre ellas es ABE.

Ambos ranchos están en la granja de John,

John elegirá un área de pasto en cada uno de los dos pastos y luego los conectará por un camino para que el nuevo pasto más grande tenga el diámetro más pequeño después de la conexión.

Nótese que si dos caminos se cruzan a la mitad, no los consideramos conectados, solo cuando dos caminos se cruzan en la misma área pastoral podemos considerarlos conectados.

Ahora pida que programe para encontrar un camino que conecte dos pastos diferentes, de modo que después de conectar este camino, este nuevo pastizal más grande tenga el diámetro más pequeño.

Formato de entrada
Línea 1: Un número entero N, que representa el número de áreas pastorales;
Línea 2 a N + 1: Dos números enteros X, Y en cada línea, que representan las coordenadas de N áreas pastorales. Las coordenadas de cada área pastoral son diferentes.
Fila N + 2 a Fila 2 * N + 1: Cada fila incluye N números (0 o 1) para indicar una matriz de adyacencia simétrica.

Por ejemplo, la descripción de la matriz de los dos pastos en la descripción del título es la siguiente:

ABCDEFGH
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

Los datos de entrada incluyen al menos dos áreas pastorales desconectadas.

El formato de salida es
solo una línea, incluido un número real, que representa la respuesta deseada. El número tiene seis lugares decimales.

Ejemplo de entrada
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

Salida de muestra
22.071068

Rango de datos
1 ≤ N ≤ 150
0 ≤ X, Y ≤ 10 ⁵

---

Solución del problema
Floyd:

解题步骤：

1. Hágalo de nuevo Floyd, encuentre la distancia más lejana MAX_len[i]que puede alcanzar cada punto y encuentre el diámetro más grande del pasto R;
2. Atravesando todos los puntos no conectados, si i、jno están conectados, la conexión se puede lograr después de la distancia máxima MAX_len[i] + get_distance(i, j) + MAX_len(j);
3. Debido a que la distancia de conexión puede ser menor que el diámetro máximo del pasto original, por lo tanto, encienda Ry 连线后的距离最小值tome max;

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;

typedef pair<int, int> PII;

const int N = 160;
const double INF = 0x3f3f3f3f;

int n;
PII q[N];
double d[N][N], MAX_len[N];
char g[N][N];

double get_distance(int a, int b)
{
    
    
    int dx = q[a].first - q[b].first;
    int dy = q[a].second - q[b].second;
    return sqrt(dx * dx + dy * dy);
}

int main()
{
    
    
    cin >> n;
    for (int i = 1; i <= n; i ++) cin >> q[i].first >> q[i].second;
    for (int i = 1; i <= n; i ++) cin >> g[i] + 1;
    
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= n; j ++)
            if(i != j)
            {
    
    
                if(g[i][j] == '1') d[i][j] = get_distance(i, j);
                else d[i][j] = INF;
            }
            
    for (int k = 1; k <= n; k ++)
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= n; j ++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
          
    double R = 0;            
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= n; j ++)
            if(d[i][j] != INF)
            {
    
    
                MAX_len[i] = max(MAX_len[i], d[i][j]);
                R = max(R, MAX_len[i]);    
            }
                
    double ans = INF;
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= n; j ++)
            if(d[i][j] == INF)
                ans = min(ans, get_distance(i, j) + MAX_len[i] + MAX_len[j]);
                
    printf("%.6f", max(R, ans));            
    return 0;
}