【FLOYD+并查集】蓝桥杯算法提高 Degrees of Separation

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<algorithm>
#include<set>
#include<sstream>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f
int dis[55][55];//两点间距离
int fa[55];//并查集 模板
int finds(int a){
    int aa=a;//保存一下查找的点 也就是路径的底部
    if(a!=fa[a]){
        fa[a]=finds(fa[a]);//找到了根节点
    }
    while(aa!=fa[a]){//向上更新整条路径
        int temp=fa[aa];//先存储路径的下一个点
        fa[aa]=fa[a];//路径压缩一个
        aa=temp;//再压缩下一个点

    }
    return fa[a];
}

void unions(int x,int y){
    int fx=finds(x);
    int fy=finds(y);
    if(fx!=fy){
        fa[fx]=fy;
    }
}
void init(){//初始化fa数组 dis数组 便于多次

    for(int i=0;i<55;++i){
            fa[i]=i;
        for (int j=0;j<55;++j){
            if(i==j){
                dis[i][j]=0;//自己到自己距离为0
            }else{
                dis[i][j]=INF;
            }

        }
    }

}
int main(){
    int x,y;
    int cas=0;//输出第几个网络
    while(cin>>x>>y){
        cin.get();//读取一个空格
        if(!x&&!y){
            break;
        }
        init();//初始化
        string temp;
        getline(cin,temp);
        stringstream str(temp);
        string word1,word2;
        map<string,int>m;
        int num=0;
        while(str>>word1>>word2){
            if(m.find(word1)==m.end()){
                m.insert(make_pair(word1,num++));
            }
            if(m.find(word2)==m.end()){
                m.insert(make_pair(word2,num++));
            }
            int a=m[word1];
            int b=m[word2];
            unions(a,b);//并查集
            dis[a][b]=1;
            dis[b][a]=1;
        }

        //判断是否连通

        if(num<x){//点少于总点数 肯定不联通
            printf("Network %d: DISCONNECTED\n", ++cas);
            cout<<endl;
            continue;
        }

        int sum=0;//用并查集看是否属于同一个集合
        for(int i=0;i<x;++i){
            if(sum>1){
                break;
            }
            if(fa[i]==i){
                sum++;
            }
        }
        if(sum!=1){
             printf("Network %d: DISCONNECTED\n", ++cas);
             cout<<endl;
            continue;
        }
        //floyd 计算最短路径
        for(int k=0;k<x;++k){//中转点
            for(int i=0;i<x;++i){//每一对邻接点
                for(int j=0;j<x;++j){
                    dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
                }
            }
        }
        int maxdis=-INF;
        for(int i=0;i<x;++i){//每一对邻接点
                for(int j=0;j<x;++j){
                    maxdis=max(dis[i][j],maxdis);
                }
            }
        printf("Network %d: %d\n", ++cas, maxdis);
        cout<<endl;

        }

    return 0;
}

Code详细解释：

1. 全局变量与数据结构

dis数组 ：初始化为INF（无穷大），表示初始不可达；对角线dis[i][i]设为0（自己到自己距离为0）。
fa数组：并查集的父节点数组，用于快速判断连通性。

2. 并查集操作

路径压缩：确保查找操作的时间复杂度接近O(1)。
合并操作：将两个节点所在的集合合并，用于后续连通性判断。

3. 初始化函数 `init()`

作用：每次测试用例开始前，重置并查集和距离矩阵。

4. 节点映射与边处理

使用map<string, int>将节点名转换为连续的整数ID（如0, 1, 2,...）。
对于每对节点，设置dis[a][b] = dis[b][a] = 1，表示直接相连。

5.连通性检测

条件1 ：num < x：若实际节点数少于输入的x，说明输入数据不完整，网络不连通。
条件2 ：通过并查集统计根节点数量。若根节点数sum != 1，说明存在多个连通分量。

6.Floyd算法

原理：三重循环遍历所有可能的中间节点k，更新所有点对的最短路径。
正确性：确保所有路径的最小值被计算。

7.最大分离度计算

遍历所有点对，排除i == j的情况，取最大值maxdis。