最短路 poj 1125 Stockbroker Grapevine

英文水平该提高了，开始死活读不懂啥意思

附上翻译

众所周知，证券经纪业依靠的就是过度的传言。您需要想出股票经纪人中传播假情报的方法，

 让您的雇主在股票市场的占据优势。为了获得最大的效果，你必须蔓延最快的方式谣言。不

 幸的是你，股票经纪人信息只信任他们的“可靠来源”，这意味着你在你传播谣言之前必须考

 虑到他们的接触结构。它需要特定股票经纪人和一定的时间把谣言传递给他的每一位同事。
 你的任务将是写一个程序，告诉您选择哪一个股票经纪人作为谣言的出发点和所花费多少时

 间将谣言扩散到整个社会的股票经纪人。这一期限是衡量过去的人收到信息所需的时间。 
  输入 
 你的程序包含多组股票经纪人的输入数据。每组以股票经纪人的人数开始。接下来的几行是

 每个经纪人与其他人接触的一些信息，接下来就有n对整数。每对整数列出的第一个数字指

 的是一个联系人（例如，一个'1'是指编号1的人），其次是在传递一个信息给那个人时所

 采取分钟的时间。没有特殊的标点符号或空格规则。 每个人的编号为1至经纪人数目。所

 花费的传递时间是从1到10分钟（含10分种）。股票经纪的人数范围是从1到100。
 当输入股票经纪人的人数为0时，程序终止。 
 输出 
 在对于每一组数据，你的程序必须输出一行，包括的信息有传输速度最快的人，以及在最

 后一个人收到消息后， 所总共使用的时间（整数分钟计算）。 
 你的程序可能会收到的一些关系会排除一些人，也就是有些人可能无法访问。如果你的程

 序检测到这样一个破碎的网络，只需输出消息“disjoint”。请注意，所花费的时间是从

 A传递消息到B，B传递信息到A不一定是花费同样的传递时间，但此类传播也是可能的。

#include <iostream>
#include <memory.h>
#include <stdio.h>
using namespace std;
#define Max_V  1005
const int IN = (1<<28);
int G[105][105];
int TimeCost[105];
int N;
void Floyd()
{
    for( int u = 1; u <= N; u++ )
        for( int v = 1; v <= N; v++ )
            for( int w = 1; w <= N; w++ )
            {
                if( G[v][w] > G[v][u] + G[u][w] )
                {
                    G[v][w] = G[v][u] + G[u][w];
                }
            }
}
int main()
{
    while( cin >> N, N!=0)
    {
        memset(G, 0, sizeof(G));
        memset(TimeCost, 0, sizeof(TimeCost));
        for( int i = 1; i <= N; i++ )
            for( int j = 1; j <= N; j++ )
        {
            if( i==j )
                G[i][j] = 0;
            else
                G[i][j] = IN;
        }
        for(int i = 1; i <= N; i++ )
        {
            int num;
            cin >> num;
            while( num-- )
            {
                int number,Time;
                cin >> number >> Time;
                if( Time < G[i][number] )
                    G[i][number] = Time;
            }
        }
        Floyd();
        int MinV = 0, Min = IN;
        for( int i = 1; i <= N; i++ )
        {
            for( int j = 1; j <= N; j++ )
            {
                TimeCost[i] = max(TimeCost[i], G[i][j]);
            }
        }
        for( int i = 1; i <= N; i++ )
        {
            if( TimeCost[i] < Min )
            {
                Min = TimeCost[i];
                MinV = i;
            }
        }
        if( Min == IN )
            cout << "disjoint" << endl;
        else
            cout << MinV << ' ' << Min << endl;
    }

    return 0;
}

最短路 poj 1125 Stockbroker Grapevine

猜你喜欢