POJ1125 Stockbroker Grapevine

题意：
现有N个股票经纪人，他们之间存在单向的通信路径，不同通信路径有不同的长度。现在有一个消息要在他们中进行传递。问要从哪一个人开始出发，才能使消息传遍所有人并且用时最短。如果不存在这样一个人，输出disjoint。

思路：利用floyd算法，求出所有节点之间的最短路径。计算每个人开始传递所需要的时间，取最小值。
注意：消息的传递可以同时进行。

代码如下：

#include <iostream>
#define INT_MAX 100000

using namespace std;

#define MAXNUM 110

void Floyd(int num,int G[MAXNUM][MAXNUM],int path[MAXNUM][MAXNUM],int dis[MAXNUM][MAXNUM])
{
    //Floyd算法求i,j之间的最短路径（动态规划求解）
    //初始化
    for(int i = 0; i < num; i++)
    {
        for(int j = 0; j < num; j++)
        {
            if(G[i][j] != INT_MAX)    //i,j直接相连
            {
                path[i][j] = j;
                dis[i][j] = G[i][j];
            }
            else
            {
                path[i][j] = -1;
                dis[i][j] = INT_MAX;
            }
        }
    }

    for(int k = 0; k < num; k++)
    {
        for(int i = 0; i < num; i++)
        {
            for(int j = 0; j < num; j++)
            {
                if(dis[i][j] > dis[i][k] + dis[k][j])
                {
                    dis[i][j] = dis[i][k] + dis[k][j];
                    path[i][j] = path[i][k];
                }
            }
        }
    }
}

void GetInput(int num,int G[MAXNUM][MAXNUM])
{
    //初始化
    int n = 0;
    int node = 0;
    int len = 0;
    for(int i = 0; i < num; i++)
    {
        for(int j = 0; j < num; j++)
        {
            if(i == j)
            {
                G[i][j] = 0;
            }
            else
            {
                G[i][j] = INT_MAX;
            }
        }
    }

    for(int i = 0; i < num; i++)
    {
        cin>>n;
        for(int j = 0; j < n; j++)
        {
            cin>>node>>len;
            G[i][node - 1] = len;
        }
    }
}

void Output(int num,int path[MAXNUM][MAXNUM],int dis[MAXNUM][MAXNUM])
{
    //输出搜索结果
    int node = 0;
    int maxlen[MAXNUM] = {0};
    int ans = INT_MAX;
    for(int i = 0; i < num; i++)
    {
        for(int j = 0; j < num; j++)
        {
            if(maxlen[i] < dis[i][j])
            {
                maxlen[i] = dis[i][j];
            }
        }
    }
    for(int i = 0; i < num; i++)
    {
        if(ans > maxlen[i])
        {
            ans = maxlen[i];
            node = i + 1;
        }
    }

    if(ans == INT_MAX)
    {
        cout<<"disjoint"<<endl;
    }
    else
    {
        cout<<node<<" "<<ans<<endl;
    }
    /*for(int i = 0; i < num; i++)
    {
        for(int j = 0; j < num; j++)
        {
            cout<<i+1<<"->"<<j+1<<"; "<<dis[i][j]<<endl;
        }
    }*/
}

int main()
{
    int G[MAXNUM][MAXNUM] = {0};    //图的邻接矩阵
    int num = 0;                    //节点数量
    int path[MAXNUM][MAXNUM] = {0}; //存放最短路径，从i到j的最短路径首先经过k
    int dis[MAXNUM][MAXNUM] = {0};  //存放最短路径值
    while(1)
    {
        cin>>num;
        if(num == 0)
        {
            break;
        }
        GetInput(num,G);                     //初始化邻接矩阵
        Floyd(num,G,path,dis);          //Floyd算法
        Output(num,path,dis);                       //输出结果
    }
    return 0;
}