蓝桥杯 ADV-264 Degrees of Separation （试题解析 BFS+BFS）

试题 算法提高 Degrees of Separation

提交此题   评测记录  

资源限制

时间限制：1.0s   内存限制：256.0MB

问题描述

　　在我们联系日益紧密的世界里，人们推测每个人和其他人的分离度不超过六（六度分离）。在这个问题里，你需要写一个程序来找出人们的关系网络中最大的分离度。
　　对于任意两个人，他们的分离度是联系两个人需要经过的最小的关系数。对于一个关系网络，最大的分离度是网络中任意两人的分离度的最大值。如果一个网络中有两个人没有通过关系链连接起来，这个网络是不连通的。
　　如下图所示，一个网络可以用一些连接两个人的对称关系来描述。一条线段表示两个人之间有联系。网络A描述了一个分离度最大值为2的网络，网络B没有连通。

图略

输入格式

　　输入包含多组描述关系网络的数据，对于每组数据，第一行有两个数P，表示网络中人的数目，和R，关系的对数。接下来一行是R个关系。每个关系用两个字符串表示，代表网络中有关系的两个人的名字。每个名字是不同的，并且中间没有空格。因为一个人可能和多个人有联系，一个名字可能在一组数据中出现多次。
　　最后以一行两个0表示结束。

输出格式

　　对于每个网络，输出网络中最大的分离度。如果这个网络是不连通的，输出DISCONNECTED。每一个网络输出后再输出一个回车。按照样例输出中的格式输出。

样例输入

4 4
Ashok Kiyoshi Ursala Chun Ursala Kiyoshi Kiyoshi Chun
4 2
Ashok Chun Ursala Kiyoshi
6 5
Bubba Cooter Ashok Kiyoshi Ursala Chun Ursala Kiyoshi Kiyoshi Chun
0 0

样例输出

Network 1: 2

Network 2: DISCONNECTED

Network 3: DISCONNECTED

数据规模和约定

　　30%的数据2<=P<=15
　　100%的数据2<=P<=50，R>=1

解题思路：用C++ STL 库中的map 容器，初始化每个人的编号，再构图。之后先用BFS 判断 图是否联通。若不联通，则把 -1 存放到结果向量 res 中，进行标记DISCONNECTED。若联通，则对每个节点 BFS 找最深的路径，遍历1->P，选取最大值。注意最后得到的 level 是最深路径中的节点数，求关系也就是求边的数量，所以边数=level-1。（如何求level值，参考数据结构 六度空间 问题）。

AC代码如下：

#include <iostream>
#include <map>
#include <algorithm>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

#define INF 65535
map<string,int>    M;
int vis[55];
int G[55][55];
int d[55][55];
int P,R;
vector<int>    res;

void init(){
    memset(vis,0,sizeof(vis));    
    for(int i=0;i<=P;i++){
        for(int j=0;j<=P;j++){
            G[i][j]=INF;
        }
    }
    M.clear();    
}

void Read(){    
    int cnt=1;
    for(int i=0;i<R;i++){
        string s1,s2;
        cin>>s1>>s2;
        if(!M[s1]){
            M[s1]=cnt++;
        }
        if(!M[s2]){
            M[s2]=cnt++;
        }
        int p1=M[s1],p2=M[s2];        
        G[p1][p2]=G[p2][p1]=1;
    }    
}

bool BFS(){
    memset(vis,0,sizeof(vis));    
    queue<int>    Q;
    Q.push(1);
    vis[1]=1;
    
    int cnt=0;    
    while(!Q.empty()){
        int V=Q.front();
        Q.pop();
        cnt++;    
        for(int W=1;W<=P;W++){
            if( G[V][W]!=INF && vis[W]==0){
                Q.push(W);
                vis[W]=1;
            }
        }
    }
    for(int i=1;i<=P;i++)
        if(vis[i]==0)
            return false;
    
    return true;
}

int viaBFS(int S){
    memset(vis,0,sizeof(vis));
    queue<int>    Q;
    Q.push(S);
    vis[S]=1;
    int count=1;
    int level=0;
    int last=S;
    int tail=0;    
    while(!Q.empty()){
        int V=Q.front();
        Q.pop();        
        for(int W=1;W<=P;W++){            
            if(G[V][W]!=INF && vis[W]==0){
                vis[W]=1;
                Q.push(W);
                count++;
                tail=W;                
            }            
        }        
        if(V==last){
            level++;
            last=tail;        
        }
    }    
    return level-1;    //T个点，T-1端线     
}

void findMaxNet(){    
    int maxNet=0;
    for(int i=1;i<=P;i++){
        int nets=viaBFS(i);
        maxNet=max(maxNet,nets);
    }    
    res.push_back(maxNet);    
}

void OPT(){    
    if( !BFS()){
        res.push_back(-1);
    }
    else{
        findMaxNet();
    }    
}

int main(int argc, char** argv) {    
    while(1){
        cin>>P>>R;
        if(P==0 && R==0 )
            break;
        
        init();
        Read();
        OPT();
    }

    for(int i=0;i<res.size();i++){
        cout<<"Network "<<i+1<<": ";
        if(res[i]==-1)
            cout<<"DISCONNECTED"<<endl; 
        else
            cout<<res[i]<<endl;        
        cout<<endl;
    }    
    return 0;
}