POJ 1125_Stockbroker Grapevine

原题链接：http://poj.org/problem?id=1125

题目大意：要使消息最快传播到每个业务员。输入：第一行是表示有N个业务员，下面的N行，每一行表示第N个业务员与其他业务员传播消息的时间

3  //有三个业务员
2 2 4 3 5 //1号业务员可以跟2号业务员传播，时间是4分钟，可以和3号业务员传播，时间是5分钟
2 1 2 3 6
2 1 2 2 2

解题思路：实际是求一个无向图的最短路径，可以用Floyd算法。

Floyd是基于动态规划的算法

设D[i][j][k] 为从i到j只以1~K中的节点为中间节点的最短路径的长度，则有DP公式

D[i][j][k] = min(D[i][j][k-1], D[i][k][k-1] + D[k][j][k-1])。

所以我们只需要分别求出以每个业务员为起点所获得的Floyd结果中的最大值

然后取这些最大值中的最小值，该结果就是最短时间，并且该结果的业务员就是应该选择作为源头的业务员

详细请看代码：

#include <iostream>
using namespace std;


const int INF  = 20;
int N, g[101][101];


void floyd()
{
	for (int k=1; k<=N; k++)
		for (int i=1; i<=N; i++)
			for (int j=1; j<=N; j++)
				if (i!=j && g[i][j] > g[i][k] + g[k][j])
					g[i][j] = g[i][k] + g[k][j];


}




int main()
{
	while (1)
	{
		memset(g, INF, sizeof(g));  


		cin>>N;
		if (N == 0) break;
		
		//data in
		for (int i=1; i<=N; i++)
		{
			int a;
			cin>>a;
			for (int j=1; j<=a; j++)
			{
				int sb,time;
				cin>>sb>>time;
				g[i][sb] = time;
			}
		}
		//process
		floyd();
		int maxlength;
		int source_sb;
		int outtime = INF;
		for (int n=1; n<=N; n++)
		{
			maxlength = 0;
			for(int m=1; m<=N; m++)  
				if(n!=m && maxlength<g[n][m])   //寻找i到j的最长路径  
					maxlength = g[n][m];  
			if(outtime > maxlength)  
			{  
				outtime = maxlength;       //寻找最长路径中的最小值 
				source_sb = n;              //该短路所在路径的源头业务员
			}  
		}
		//data out
		if(outtime < INF)  
			cout<<source_sb<<' '<<outtime<<endl;  
		else  
			cout<<"disjoint"<<endl;  
	}
	return 0;
}