【PTA】哈利·波特的考试 (25 分)

//事实上是多源最短路问题
//版本1：只需要映射0-N-1，不需要舍掉开头的元素空间
//且不需要特意用变量检测是否每行都无效，正常退出循环即可
#include <iostream>
#define INFINITY 200
using namespace std;

#define MAXN 110
int G[MAXN][MAXN];
int Nv,Ne;


int CreateG(){
    cin>>Nv>>Ne;

    for(int i=1;i<=Nv;i++){
        for(int j=1;j<=Nv;j++){
//对角元素设为0
            if(i!=j) G[i][j]=INFINITY;
            else     G[i][j]=0;
        }
    }

    int v1,v2,w;
    for(int i=0;i<Ne;i++){       
            cin>>v1>>v2>>w;
//无向有权图
            G[v1][v2]=w;
            G[v2][v1]=w;    
    }

}

int path[MAXN][MAXN],D[MAXN][MAXN];
void Floyd(){
//初始化
    for(int i=1;i<=Nv;i++){
        for(int j=1;j<=Nv;j++){
            D[i][j]=G[i][j];
            path[i][j]=-1;
        }
    }
//Floyd算法：三重循环
    for(int k=1;k<=Nv;k++){
        for(int i=1;i<=Nv;i++){
            for(int j=1;j<=Nv;j++){
                if(D[i][k]+D[k][j]<D[i][j]){
                    D[i][j]=D[i][k]+D[k][j];
                    path[i][j]=k;
                }
            }
        }
    }
}

int maxd[MAXN],maxk[MAXN];
void solve(){
//1：找到每行的最大dis，只要有一个元素不能变，则不满足，设为无效值,并退出该行
    int maxdis=0,maxid=-1;
    for(int i=1;i<=Nv;i++){
        maxdis=0,maxid=-1;
        for(int j=1;j<=Nv;j++){
            if(D[i][j]!=INFINITY){
                if(D[i][j]>maxdis){
                    maxdis=D[i][j];
                    maxid=j;
                }
            }else{
                maxdis=INFINITY;maxid=-1;
                break;
            }
        }
        maxd[i]=maxdis;maxk[i]=maxid;
    }

//检测是否每行都无效，则输出0，否则记录最小值，并输出
    int flag=0;
    int mindis=INFINITY,minid=-1;
    for(int i=1;i<=Nv;i++){
        if(maxk[i]!=-1){
            flag=1;
        }

        if(maxd[i]<mindis){
            mindis=maxd[i];
            minid=i;
        }  
    }

    if(!flag){
        cout<<0;
    }else{
        cout<<minid<<" "<<mindis;
    }

}


int main(){
    CreateG();
    Floyd();
    solve();

    return 0;
}

//版本2：改进版本1后
#include <iostream>
#define MAXN 110
#define W_INFINITY 110
using namespace std;

int G[MAXN][MAXN];
int nv,ne;

void CreateG(){
    cin>>nv>>ne;

    for(int i=0;i<nv;i++){
        for(int j=0;j<nv;j++){
            G[i][j]=W_INFINITY;
            if(i==j) G[i][j]=0;
        }
    }

    int v1,v2,w;
    for(int i=0;i<ne;i++){
        cin>>v1>>v2>>w;
        G[v1-1][v2-1]=w;
        G[v2-1][v1-1]=w;
    }
}

int dist[MAXN][MAXN];
//int path[MAXN][MAXN];
void Floyd(){
    for(int i=0;i<nv;i++){
        for(int j=0;j<nv;j++){
            dist[i][j]=G[i][j];
            //path[i][j]=-1;
        }
    }

    for(int k=0;k<nv;k++){
        for(int i=0;i<nv;i++){
            for(int j=0;j<nv;j++){
                if(dist[i][k]+dist[k][j]<dist[i][j]){
                    dist[i][j]=dist[i][k]+dist[k][j];
                    //path[i][j]=k;
                }
            }
        }
    }
}

int max_dist[MAXN],max_i[MAXN];
void Find_min(){
    int max_d=0,max_id=-1;
    for(int i=0;i<nv;i++){
        max_d=0;max_id=-1;
        for(int j=0;j<nv;j++){
            if(dist[i][j]==W_INFINITY){
                max_d=W_INFINITY;
                max_id=-1;
                break;
            }
            if(dist[i][j]>max_d){
                max_d=dist[i][j];
                max_id=j;
            }
        }
        max_dist[i]=max_d;max_i[i]=max_id;
    }

//不用检测是否每行都无效，因为没取等号，
//之前的Floyd检测到W_INFINITY也不会继续加，
//因此最大也就W_INFINITY
    int min_d=W_INFINITY,min_id=-1;
    for(int i=0;i<nv;i++){
        if(max_dist[i]<min_d){
            min_d=max_dist[i];
            min_id=i;
        }
    }
    if(min_id==-1) printf("0");
    else{
        printf("%d %d",min_id+1,min_d);
    }
}



int main(){
    CreateG();
    Floyd();
    Find_min();

    system("pause");
    return 0;
}