POJ 1125 Stockbroker Grapevine 最短路

題意：首先，題目可能有多組測試數據，每個測試數據的第一行爲經紀人數量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。

package 最短路;
import java.io.BufferedInputStream;   
import java.util.Scanner;   

public class A1125 {
	    final static int disjoint = 1000;//最多100個人，每個人最多花費10分鐘   
	  
	    public static void main(String[] args) {   
	        Scanner scan = new Scanner(new BufferedInputStream(System.in));   
	        while (scan.hasNext()) {   
	            int n = scan.nextInt();   
	            if (n == 0) {   
	                break;   
	            }   
	            //初始化矩陣,默認不可達,stockbroker的編號是從1開始的   
	            int[][] times = new int[n + 1][n + 1];   
	            for (int i = 0; i < n + 1; i++) {   
	                for (int j = 0; j < n + 1; j++) {   
	                    times[i][j] = disjoint;   
	                }   
	            }   
	            for (int i = 1; i <= n; i++) {   
	                int stockbroker = i;   
	                int number = scan.nextInt();   
	                for (int j = 1; j <= number; j++) {   
	                    int contact = scan.nextInt();   
	                    int time = scan.nextInt();   
	                    times[stockbroker][contact] = time;   
	                }   
	            }   
	            //弗洛依德算法，頂點i到j經過k點   
	            for (int k = 1; k <= n; k++) {   
	                for (int i = 1; i <= n; i++) {   
	                    for (int j = 1; j <= n; j++) {   
	                        if (i != j && times[i][k] + times[k][j] < times[i][j]) {   
	                            times[i][j] = times[i][k] + times[k][j];   
	                        }   
	                    }   
	                }   
	            }   
	            //注意，單個頂點本身不應該有環,這裏是無窮大   
	            //求每個經紀人將信息傳遞給所有人知道所要花費的時間,存儲在第0列   
	            for (int i = 1; i <= n; i++) {   
	                times[i][0] = 0;//賦0方便比較大小   
	                for (int j = 1; j <= n; j++) {   
	                    if (times[i][j] > times[i][0] && i != j) {//求max   
	                        times[i][0] = times[i][j];   
	                    }   
	                }   
	            }   
	            //找出最小耗時,存在第0行第0列   
	            int index = 0;   
	            for (int i = 1; i <= n; i++) {   
	                if (times[i][0] < times[0][0] && times[i][0] != disjoint) {//求min   
	                    times[0][0] = times[i][0];   
	                    index = i;   
	                }   
	            }   
	            //輸出結果   
	            if (index == 0) {   
	                System.out.println("disjoint");   
	            } else {   
	                System.out.println(index + " " + times[0][0]);   
	            }   
	        }   
	    }   
}