数据结构 07-图4 哈利·波特的考试 (25 分)

哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数N (≤100)和M，其中N是考试涉及的动物总数，M是用于直接变形的魔咒条数。为简单起见，我们将动物按1~N编号。随后M行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100)，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

 

输出样例:

4 70

 

 

 

如果图是连通图, 计算每个点到其他点的最短路径, 保存 每个点 到其他点 最短路径的最大值

　　输出 到其他点最短路径的最大值最小的 点 和这个点的到其他点的 最大路径值

不是连通图输出0

其中 图的连通性用BFS或者DFS遍历

最短路径使用floyd算法计算

floyd算法

floyd算法是迭代计算从0开始计数的各点到其他点的最短路径, 比较的是第i , j 点的 连通点的和 是否小于当前点的路径值, 因为是小于比较, 所以数组初始化是 不连通的点不能为0

如果两个点不连通 ,需要手动排除, 因为数组初始化时应该给定远大于路径的值, 题目默认两点的最大路径不超过100, 这里给了远大于最大路径的值 9999,因此判定两点联通的条件应该是<=100

floyd计算两点距离时, 同样不应该计算data[i][i] , 因此 i!=j 

两点距离为0时是点本身, 判定连通时应该跳过

 

Floyd算法核心

for(int k=0;k<n;k++){
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    if(data[i][j]>data[i][k]+data[k][j]){
                        data[i][j]=data[i][k]+data[k][j];
                    }
                }
            }
        }

 

 

#include <iostream>
#include <vector>
#include <map>
#include <math.h>
#include <iomanip>
#include <algorithm>
using namespace std;
bool compare(vector<int> l,vector<int>r){//true不变 false互换位置
    if(l[1]==r[1]){
        return l[0]<r[0];
    }else{
        return l[1]<r[1];
    }
}
class MatricGraphic{//邻接矩阵
public:
    vector<vector<int>> data;
    MatricGraphic()=default;
    void build(int n,int m){
        data=vector<vector<int>>(n,vector<int>(n,9999));
        int a,b,c;
        for(int i=0;i<m;i++){
            scanf("%d %d %d",&a,&b,&c);
            data[a-1][b-1]=c;
            data[b-1][a-1]=c;
        }
        for(int i=0;i<n;i++){
            data[i][i]=0;
        }
    }
    void floyd(int n){
        for(int k=0;k<n;k++){
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    if(data[i][j]>data[i][k]+data[k][j]&&i!=j){
                        data[i][j]=data[i][k]+data[k][j];
                    }
                }
            }
        }
    }
    void BFS(int index,vector<int> VertexMap,vector<int> &visited){
        vector<int> toCheck;
        toCheck.push_back(index);
        while(toCheck.size()){
            visited[toCheck.front()]=1;
            for(int i=0;i<data[toCheck.front()].size();i++){
                if(data[toCheck.front()][i]&&data[toCheck.front()][i]<=100&&!visited[i]){
                    visited[i]=1;
                    toCheck.push_back(i);
                }
            }
            toCheck.erase(toCheck.begin());
        }
    }

    void BFSTraversal(){
        vector<int> visited(data.size(),0);
        vector<vector<int>> result;
        int maxLen{0};
        bool flag=true;
        for(int i=0;i<data.size();i++){
            vector<int> tempVisited=visited;
            BFS(i,data[i],tempVisited);
            for(int i=0;i<tempVisited.size();i++){
                if(!tempVisited[i])flag=false;
            }
            if(flag){
                break;
            }
        }
        if(flag){
            floyd(data.size());
            for(int i=0;i<data.size();i++){
                maxLen=0;
                for(int j=0;j<data.size();j++){
                    if(data[i][j]>maxLen){
                        maxLen=data[i][j];
                    }
                }
                result.push_back({i+1,maxLen});
            }
            sort(result.begin(),result.end(),compare);
            cout << result.front()[0] <<" "<< result.front()[1]<<endl;
        }else{
            cout << "0"<<endl;
        }
    }
};
int main(){
    int n,m;
    cin >> n >> m;
    MatricGraphic MG;
    MG.build(n, m);
    MG.BFSTraversal();
    return 0;
}