Poj 3268 Silver Cow Party【dijkstra+逆向建图】

Silver Cow Party

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 17171		Accepted: 7843

Description

One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1..N is going to attend the big cow party to be held at farm #X (1 ≤ X ≤ N). A total of M (1 ≤ M ≤ 100,000) unidirectional (one-way roads connects pairs of farms; road i requires T_i (1 ≤ T_i ≤ 100) units of time to traverse.

Each cow must walk to the party and, when the party is over, return to her farm. Each cow is lazy and thus picks an optimal route with the shortest time. A cow's return route might be different from her original route to the party since roads are one-way.

Of all the cows, what is the longest amount of time a cow must spend walking to the party and back?

Input

Line 1: Three space-separated integers, respectively:  N,  M, and  X 
Lines 2.. M+1: Line  i+1 describes road  i with three space-separated integers:  A_i,  B_i, and  T_i. The described road runs from farm  A_i to farm  B_i, requiring  T_i time units to traverse.

Output

Line 1: One integer: the maximum of time any one cow must walk.

Sample Input

4 8 2
1 2 4
1 3 2
1 4 7
2 1 1
2 3 5
3 1 2
3 4 4
4 2 3

Sample Output

10

Hint

Cow 4 proceeds directly to the party (3 units) and returns via farms 1 and 3 (7 units), for a total of 10 time units.

Source

USACO 2007 February Silver

题意:

n 头牛，m条路连接某些牛的住处，在x 处会有一个聚会，每头牛都要去，路是单行道，而且回来的时候，每头牛都不想沿着原来的路返回，但是每头牛都会选尽量短的路回家

问这么多牛中，总共花费时间最长的那头牛花费了多长时间。

题解：

首先想到的是最短路问题，但是要求回来的时候路不一样，回来的路也要是最短的，每条边都是有向图，可以考虑再建立一个反向图（转置矩阵），对两图分别进行两次最短路操作，最后得到的便是来回的最短路，更新找到耗时最长的就可以了。

/*
http://blog.csdn.net/liuke19950717
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=1005;
int grax[maxn][maxn],gray[maxn][maxn];
int distx[maxn],disty[maxn];
void init(int n)
{
	memset(grax,inf,sizeof(grax));
	memset(gray,inf,sizeof(gray));
	memset(distx,inf,sizeof(distx));
	memset(disty,inf,sizeof(disty));
	for(int i=1;i<=n;++i)
	{
		grax[i][i]=gray[i][i]=0;
	}
}
void dijkstra(int graph[][maxn],int dist[],int n,int st)
{
	int vis[maxn]={0};//这里千万不要标记起点！！
	dist[st]=0;
	while(1)
	{
		int v=-1;
		for(int u=1;u<=n;++u)
		{
			if(!vis[u]&&(v==-1||dist[u]<dist[v]))
			{
				v=u;
			}
		}
		if(v==-1)
		{
			break;
		}
		vis[v]=1;
		for(int u=1;u<=n;++u)
		{
			dist[u]=min(dist[u],dist[v]+graph[v][u]);
		}
	}
}
int main()
{
	int n,m,x;
	while(~scanf("%d%d%d",&n,&m,&x))
	{
		init(n);
		for(int i=0;i<m;++i)
		{
			int a,b,c;
			scanf("%d%d%d",&a,&b,&c);//貌似是有向图 
			grax[a][b]=min(grax[a][b],c);
			gray[b][a]=min(gray[b][a],c);
		}
		dijkstra(grax,distx,n,x);
		dijkstra(gray,disty,n,x);
		int ans=0;
		for(int i=1;i<=n;++i)
		{
			ans=max(ans,distx[i]+disty[i]);
		}
		printf("%d\n",ans);
	}
	return 0;
}