POJ1125 Stockbroker Grapevine【Floyd】

Stockbroker Grapevine

Time Limit: 1000MS
Memory Limit: 10000K

Total Submissions: 27977
Accepted: 15527

Description

Stockbrokers are known to overreact to rumours. You have been contracted to develop a method of spreading disinformation amongst the stockbrokers to give your employer the tactical edge in the stock
market. For maximum effect, you have to spread the rumours in the fastest possible way.

Unfortunately for you, stockbrokers only trust information coming from their "Trusted sources" This means you have to take into account the structure of their contacts when starting a rumour. It takes
a certain amount of time for a specific stockbroker to pass the rumour on to each of his colleagues. Your task will be to write a program that tells you which stockbroker to choose as your starting point for the rumour, as well as the time it will take for
the rumour to spread throughout the stockbroker community. This duration is measured as the time needed for the last person to receive the information.

Input

Your program will input data for different sets of stockbrokers. Each set starts with a line with the number of stockbrokers. Following this is a line for each stockbroker which contains the number of people who they have contact with, who these people are,
and the time taken for them to pass the message to each person. The format of each stockbroker line is as follows: The line starts with the number of contacts (n), followed by n pairs of integers, one pair for each contact. Each pair lists first a number referring
to the contact (e.g. a ‘1‘ means person number one in the set), followed by the time in minutes taken to pass a message to that person. There are no special punctuation symbols or spacing rules.

Each person is numbered 1 through to the number of stockbrokers. The time taken to pass the message on will be between 1 and 10 minutes (inclusive), and the number of contacts will range between 0 and one less than the number of stockbrokers. The number of
stockbrokers will range from 1 to 100. The input is terminated by a set of stockbrokers containing 0 (zero) people.

Output

For each set of data, your program must output a single line containing the person who results in the fastest message transmission, and how long before the last person will receive any given message after you give it to this person, measured in integer minutes.

It is possible that your program will receive a network of connections that excludes some persons, i.e. some people may be unreachable. If your program detects such a broken network, simply output the message "disjoint". Note that the time taken to pass the
message from person A to person B is not necessarily the same as the time taken to pass it from B to A, if such transmission is possible at all.

Sample Input

3

2 2 4 3 5

2 1 2 3 6

2 1 2 2 2

5

3 4 4 2 8 5 3

1 5 8

4 1 6 4 10 2 7 5 2

0

2 2 5 1 5

0

Sample Output

3 2

3 10

Source

Southern African 2001

题目大意:有N个股票经济人,他们之间可以传递信息,但是他们只相信他们认为可靠的人的信息。

现在由某个人开始传信息,怎么能在最短的时间内让所有人都接收到消息。这个时间取决于最后一

个人收到信息的时间。如果没有一个人能使所有人都接收到信息,则输出"disjoint",否则,就输出

最短的时间和这个人的编号。

思路:可以看做是N个点,M条单向边。建立一个图,然后用Floyd求多源最短路径。之后,遍历所

有的结点,找到符合要求的那个人编号。不存在就输出"disjoint"。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN = 110;
const int INF = 0xffffff0;

int Map[MAXN][MAXN], Dist[MAXN][MAXN];

void Floyd(int N)
{
    for(int i = 1; i <= N; ++i)
    {
        for(int j = 1; j <= N; ++j)
            Dist[i][j] = Map[i][j];
    }
    for(int k = 1; k <= N; ++k)
    {
        for(int i = 1; i <= N; ++i)
        {
            for(int j = 1; j <= N; ++j)
            {
                if(Dist[i][k] != INF && Dist[k][j] != INF && Dist[i][k] + Dist[k][j] < Dist[i][j])
                    Dist[i][j] = Dist[i][k] + Dist[k][j];
            }
        }
    }
}
int main()
{
    int N;
    while(~scanf("%d",&N) && N)
    {
        for(int i = 1; i <= N; ++i)
            for(int j = 1; j <= N; ++j)
                Map[i][j] = INF;
        for(int i = 1; i <= N; ++i)
        {
            int d;
            scanf("%d",&d);
            while(d--)
            {
                int to,dist;
                scanf("%d%d",&to,&dist);
                Map[i][to] = dist;
            }
        }
        Floyd(N);
        int ans = INF,pos,tMin;
        for(int i = 1; i <= N; ++i)
        {
            int flag = 0;
            tMin = 0;
            for(int j = 1; j <= N; ++j)
            {
                if(i != j && Dist[i][j] == INF)
                {
                    flag = 1;
                    break;
                }
                if(i != j && Dist[i][j] > tMin)
                {
                    tMin = Dist[i][j];
                }
            }
            if(flag == 0 && tMin < ans)
            {
                ans = tMin;
                pos = i;
            }
        }
        if(ans == INF)
            printf("disjoint\n");
        else
            printf("%d %d\n",pos,ans);
    }

    return 0;
}
时间: 2024-11-05 13:41:10

POJ1125 Stockbroker Grapevine【Floyd】的相关文章

POJ1125 Stockbroker Grapevine 【Floyd】

Stockbroker Grapevine Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 27431   Accepted: 15201 Description Stockbrokers are known to overreact to rumours. You have been contracted to develop a method of spreading disinformation amongst th

POJ 1125 Stockbroker Grapevine【floyd】

很裸的floyd #include<cstdio> #include<string.h> #include<algorithm> #define maxn 201 #define inf 100000 using namespace std; int map[maxn][maxn],n,x,y,m;; int main() { while(1) { scanf("%d",&n); if(n==0)break; for(int i=1;i<

HDU1385 Minimum Transport Cost 【Floyd】+【路径记录】

Minimum Transport Cost Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7496    Accepted Submission(s): 1918 Problem Description These are N cities in Spring country. Between each pair of cities

【floyd】HDU 1874 畅通工程续

之后的题解偏重实用/总结性质,尽量理解算法本身而不是题,时间复杂度什么的也可以放放. 很久之前做过这个题,当时使用dijkstra做的,关于几个最短路算法,分类的话可以分为以下几种. 1.单源最短路:已知起点(终点),计算从源点到其他各个顶点的最短路径长度. 典型算法:Dijkstra,Bellman-Ford(可以算负的,比较慢),spfa(负权能用,加了松弛操作,速度比较炸天) 2.全局最短路:从一点到另一点,典型如Floyd,A*启发式算法. 重新用floyd写一遍: #include <

POJ2253 Frogger 【Floyd】

讲的是,一只雄青蛙要从一个石头到另外一个石头上去找某只雌青蛙,但是这两个石头隔得太远,青蛙跳不过去,所幸,湖面上还有很多其他石头,所以青蛙可以借助别的石头一步一步地跳向那只雌青蛙所在的石头.显然青蛙可能有多种路径,比如其中一条是 2,3,4,2,1 ,它跳了五次,数字代表每次跳的距离也就是路径上相邻两个石头之间的距离,那么这只青蛙的弹跳能力至少是4才能跳过去.在其他的路径中,可能要求青蛙的弹跳是5,是8,是1,是100,等等,这个问题求青蛙需要的最小弹跳能力.其实也就是个最大值中取最小的问题.

POJ1734 Sightseeing trip 【Floyd】+【最小环】+【路径记录】

Sightseeing trip Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 4830   Accepted: 1857   Special Judge Description There is a travel agency in Adelton town on Zanzibar island. It has decided to offer its clients, besides many other attra

HDU1869 六度分离 【Floyd】

六度分离 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4213    Accepted Submission(s): 1718 Problem Description 1967年,美国著名的社会学家斯坦利·米尔格兰姆提出了一个名为"小世界现象(small world phenomenon)"的著名假说,大意是说,任何2个素

POJ2263&amp;ZOJ1952--Heavy Cargo【Floyd】多源最短路变形

链接:http://poj.org/problem?id=2263 题意:有n个点,m条路,每条路双向的,现在卡车从某点到另一点,卡车的承载无上限,但是马路的承载有上限,问卡车应该承载多少才不会压坏马路. poj2253和它类似,链接:http://poj.org/problem?id=2253 解题报告:Here 就是在两点之间找一条路径,使路径中权值最小的那条边的权值最大,edge数组记录当前路径中最小权值边的权值 #include<cstring> #include<string&

poj1125 Stockbroker Grapevine 最短路 dijkstral + 优先队列

// poj1125 Stockbroker Grapevine 最短路 dijkstral + 优先队列 // // 一个模板吧,留着纪念 #include <cstdio> #include <iostream> #include <algorithm> #include <cstring> #include <queue> using namespace std; typedef pair<int,int> P; const i