牛的旅行 Cow Tours——floyd+连通块

P1522 [USACO2.4] 牛的旅行 Cow Tours - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

 

一、题意分析

1. 牧区： 对应一个点。
2. 牧区之间的距离：实际上是两点之间的 最短路。 不要理解成欧几里得距离。只有 直接连接 的时候，才可以计算欧几里得距离。
3. 牧场： 一个连通块。
4. 牧场直径： 一个牧场的直径是这个牧场所有的牧区（点）之间 距离 的最大值。 说的绕一点就是 最短路的最大值。
5. 使用一条边连接两个牧场，使得合成的一个新的牧场的直径最小。意思是加入一条边之后，使得新的牧场的所有点对之间 最短路 的最大值 最小

 

二、解法

1. 使用 DFS 对连通块染色标记：区分牧场。O(V + E) = O(n^2)O(V+E)=O(n2)
2. 使用 Floyd-Warshall 算法计算所有点对之间的 最短路。 O(n^3)O(n3)
3. 计算每个牧场中，每个牧区点到其他点的 最短路 的最大值。（后面加边的时候要用）
4. 计算每个牧场中，所有最短路的最大值，即每个牧场的直径。 这个可以与 3 一起计算。 O(n^2)O(n2)
5. 最后是找答案：对任意两个点，先判断是否同一个牧场。如果不是，考虑加入一条边，变成一个新的牧场。可以直接计算出通过这条边的最短路的最大值。 需要注意的是，通过这条边的最短路的最大值不一定是新牧场的所有最短路的最大值。这里需要比较三个值（牧场 A 的所有最短路的最大值； 牧场 B 的所有最短路的最大值， 加边后通过这条边的最短路的最大值），才能得到正确的新牧场的直径。 遍历所有点对（或者一半）， 找出 “新直径” 的最小值。 O(n^2)O(n2)

最后的时间复杂度是 O(n^3)O(n3)。 空间复杂度也只是 O(n^2)O(n2)。

 

太恶心了，没注意到double类型数组memset不能用0x3f，啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊气死我了气死我了气死我了，卡了一个小时，气死我了气死我了！！！！！！！！！！！！！！！！！！！！

 

#include <bits/stdc++.h>
using namespace std;
inline int read()
{
    int sum=0;char a=getchar();
    while(a<'0'||a>'9')a=getchar();
    while(a>='0'&&a<='9')
    {
        sum=(sum<<3)+(sum<<1)+a-'0';
        a=getchar();
    }
    return sum;
}

const int N=160;
const double INF=1e20;
int n,field[N];
double dist[N][N],zhijing[N],maxspace[N];

struct node
{
    int x,y;
    double distance(const node &b)
    {
        return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
    }
}a[N];

void dfs(int i,int id)
{
    field[i]=id;
    for(int j=0;j<n;j++)
    {
        if(!field[j]&&dist[i][j]<INF)dfs(j,id);
    }
}

void floyd()
{
    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
        }
    }
}


int main()
{
    n=read();
    for(int i=0;i<n;i++)
        a[i].x=read();a[i].y=read(); 
    
    for(int i=0;i<n;i++)
    {
        printf("%d %d\n",a[i].x,a[i].y);
    }
    
    char b[N];
    for(int i=0;i<n;i++)
    {
        scanf("%s",b);
        for(int j=0;j<n;j++)
        {
            if(i==j)dist[i][j]=0;
            else if(b[j]=='1')dist[i][j]=a[i].distance(a[j]);
            else dist[i][j]=INF;
        }
        
    }
    
    int id=0;        //bfs求连通块 
    for(int i=0;i<n;i++)
    {
        if(!field[i])dfs(i,++id);
    }
    
    floyd();    //floyd求任意两点之间的最短距离 
    
    for (int i = 0; i < n; ++i)    //求每个连通块内部的直径 
    {
        maxspace[i] = 0.0;
        for (int j = 0; j < n; ++j)
            if (dist[i][j] < INF)
                maxspace[i] = max(maxspace[i], dist[i][j]);
        zhijing[field[i]] = max(zhijing[field[i]], maxspace[i]);
    }
    
    double min_d = INF, max_d;
    for(int i=0;i<n;i++)        //求最后答案 
    {
        for(int j=i+1;j<n;j++)
        {
            if(field[i]!=field[j])
            {
                max_d = max(max(zhijing[field[i]], zhijing[field[j]]),
                            maxspace[i] + a[i].distance(a[j]) + maxspace[j]);
                min_d = min(min_d, max_d);
            }
        }
    }
    
    printf("%.6lf\n",min_d);
    return 0;
}