poj 1125 Stockbroker（多源最短路径）

题目来源:POJ 1125

简单题目分析及思路：

题意比较难懂，但是思路是多源最短路径，采用Floyd算法。

Floyd是一种动态规划的算法，代码简洁易懂，对于稠密图效率要高于 Dijkstra算法，但是如果数据量过大，由于算法本身时间复杂度是O(n^3)，所以效率也很低。

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>

using namespace std;

const int MAXN=100+5;

const int myInf=999999;   //标记为不可连通

int map[MAXN][MAXN]; //路径矩阵，map[i][j]代表从i到j的最短路径

int main()
{
    int N;
    while(~scanf("%d",&N) && N!=0)
    {
        int i,j;
        for(i=1;i<=N;++i)
            for(j=1;j<=N;++j)   //Floyd算法一定要先初始化
        {
            if(i==j)
               map[i][j]=0;
            else
                map[i][j]=myInf;
        }
        for(i=1;i<=N;++i)
        {
            int a;
            scanf("%d",&a);
            for(j=1;j<=a;++j)
            {
                int b,c;
                scanf("%d %d",&b,&c);
                map[i][b]=c;
            }
        }
        int k;
        for(k=1;k<=N;++k)  //Floyd算法的核心代码只有5行，三重循环+DP
            for(i=1;i<=N;++i)
                for(j=1;j<=N;++j)
                    if(map[i][k]+map[k][j]<map[i][j])
                    map[i][j]=map[i][k]+map[k][j];
        int ans=myInf,curIndex=0;
        for(i=1;i<=N;++i)
        {
            int temp=-1;
            for(j=1;j<=N;++j)
            {
                if(map[i][j]>temp)
                    temp=map[i][j];
            }
            if(temp<ans)
            {
                ans=temp;
                curIndex=i;
            }
        }
        printf("%d %d\n",curIndex,ans);
    }
    return 0;
}

PS:补上一句，测试数据够水，代码并没有考虑非连通图依然AC.