POJ 1125 Stockbroker Grapevine （Dijkstra求所有点的单源最短路径）

/**
*   Dijkstra:  其实这题可以用floy的。。写惯了dijkstra。就。。
*       理解了题意应该就可以A了，这题数据太太太水了。。我那种不连通的情况完全没有考虑也A了。
*   
* 题意： 直接抄discuss了。
*   首先，题目可能有多组测试数据，每个测试数据的第一行为经纪人数量N（当N=0时，
*   输入数据结束），然后接下来N行描述第i（1<=i<=N）个经纪人与其他经纪人的关系
*   （教你如何画图）。每行开头数字M为该行对应的经纪人有多少个经纪人朋友（该节点
*   的出度，可以为0），然后紧接着M对整数，每对整数表示成a,b,则表明该经纪人向第a
*   个经纪人传递信息需要b单位时间（即第i号结点到第a号结点的孤长为b），整张图为
*   有向图，即弧Vij 可能不等于弧Vji（数据很明显，这里是废话）。当构图完毕后，求
*   当从该图中某点出发，将“消息”传播到整个经纪人网络的最小时间，输出这个经纪
*   人号和最小时间。最小时间的判定方式为——从这个经纪人（结点）出发，整个经纪
*   人网络中最后一个人接到消息的时间。如果有一个或一个以上经纪人无论如何无法收
*   到消息，输出“disjoint”（有关图的连通性，你们懂得，但据其他同学说，POJ测试
*   数据中不会有，就是说，你不判定，一样能过，题目数据够水的）。
*
*   以第一样例为例：
*   3
*   2 2 4 3 5
*   2 1 2 3 6
*   2 1 2 2 2
*
*    总共3个经纪人，一号经纪人可向2个人传递信息，向2号传递所需时间为4分钟，向3号
*    传递需5分钟。二号经纪人可向2个人传递信息，向1号需2分钟，向3号需6分钟。三号
*    经纪人可向2人传递信息，向1号需2分钟，向2号需2分钟。（以上阿拉伯数字即为对
*    应数据）
*    将图画出，很容易得出，从3号出发，网络中最后一个得到消息的，需2分钟（可以同时向多人传递，有点不合情理）。所以输出为 3 2
*
*   做法就是求出从每个点的为起点到其他所有点的单源最短路径。
*   然后依次遍历每个结点到其他结点的最大值的最小值。  有点绕~
*   
*/

#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
#define DEBUG 0
#define INF 0x7fffffff
#define MAXS 101

typedef long long LL;
using namespace std;
int first[MAXS], d[MAXS][MAXS], vis[MAXS];
int next[10001], u[10001], v[10001], w[10001];
struct Node {
    int curd, u;
    bool operator < (const Node &a) const {
        return curd < a.curd;
    }
    Node() {}
    Node(int curdd, int uu) {curd = curdd; u = uu;}
};
priority_queue<Node> que;
int n, cntu, cntv, cntw;

void init() {
    cntu = cntv = cntw = 0;
    for(int i = 0; i <= n; i ++) {
        first[i] = -1;
        for(int j = 0; j <= n; j ++) {
            d[i][j] = INF;
        }
    }
}

void dijkstra(int x) {
    for(int i = 1; i <= n; i ++) vis[i] = 0;
    while(!que.empty()) que.pop();
    d[x][x] = 0;
    que.push(Node(d[x][x], x));
    Node cur;
    while(!que.empty()) {
        cur = que.top(); que.pop();
        if(vis[cur.u]) continue;
        vis[cur.u] = 1;
        for(int i = first[cur.u]; i != -1; i = next[i]) {
            if(d[x][v[i]] > w[i] + cur.curd) {
                d[x][v[i]] = w[i] + cur.curd;
                que.push(Node(d[x][v[i]], v[i]));
            }
        }
    }
}

int main()
{
    while(scanf("%d", &n), n) {
        init();
        for(int i = 1; i <= n; i ++) {
            int m; scanf("%d", &m);
            for(int j = 1; j <= m; j ++) {
                scanf("%d%d", &v[cntv], &w[cntw ++]);
                next[cntv] = first[i];
                first[i] = cntv ++;
            }
        }
        for(int i = 1; i <= n; i ++) {
            dijkstra(i);
        }
        int ans = INF;

        int pos;
        for(int i = 1; i <= n; i ++) {
            int curMax = 0;
            for(int j = 1; j <= n; j ++) {
                if(d[i][j] == INF) {
                    curMax = 0;
                    break;
                }
                if(d[i][j] > curMax)
                    curMax = d[i][j];
            }
            if(curMax != 0 && curMax < ans) {
                ans = curMax;
                pos = i;
            }
        }
        if(ans == INF) printf("disjoint\n");
        else printf("%d %d\n", pos, ans);
    }
    return 0;
}