POJ3268 Silver Cow Party

Silver Cow Party

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 20762		Accepted: 9496

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

题目讲的是有一群牛要去参加聚会，求从他们的家到聚会以及回来的时候的最短路径中用时最长的一个。分析可知，从聚会的地点回家，就等价于求一点到其他个点的最短距离，所以很明显的用dijkstra算法求解即可。稍微有点困难的就是求从家到聚会地点的最短路径，是求从多点到一点的最短路径，你首先可能会想到的是floyd算法，可是这个算法会超时，不妨换个思路想想，这些路径都是有向图，如果反过来求从多点到一点的最短路径，不就等价于求一点到多点的最短路径，所以再用一遍dijkstra算法即可。

#include <cstdio>
#include <cstring>
#define INF 100000005
using namespace std;

int map[1005][1005],dis[1005],vis[1005],d[1005];
int n,m,x;

void dijkstra(){
	int min,k;
	for(int i = 1; i < n; i ++){
		min = INF; k = 0;
		for(int j = 1; j <= n; j ++)
			if(!vis[j] && dis[j] < min){
				min = dis[j];
				k = j;
			}
		vis[k] = 1;
		
		for(int j = 1; j <= n; j ++){
			if(!vis[j] && dis[j] > dis[k] + map[k][j])
				dis[j] = map[k][j] + dis[k];
		}	
	}
}

void dijkstra1(){
	int min,k;
	for(int i = 1; i < n; i ++){
		min = INF; k = 0;
		for(int j = 1; j <= n; j ++)
			if(!vis[j] && d[j] < min){
				min = d[j];
				k = j;
			}
		vis[k] = 1;
		
		for(int j = 1; j <= n; j ++){
			if(!vis[j] && d[j] > d[k] + map[j][k])
				d[j] = map[j][k] + d[k];
		}	
	}
}

int main(){
	while(~scanf("%d%d%d",&n,&m,&x)){
		for(int i = 1; i <= n; i ++){
			for(int j = 1; j <= n; j ++){
				map[i][j] = (i == j ? 0 : INF);
			}
			vis[i] = 0;
		}
		
		int a,b,t;
		for(int i = 1; i <= m; i ++){
			scanf("%d%d%d",&a,&b,&t);
			if(map[a][b] > t)
				map[a][b] = t;
		}
		
		for(int i = 1; i <= n; i ++){
			dis[i] = map[x][i];
		}
		vis[x] = 1;
		
		dijkstra();

		for(int i = 1; i <= n; i ++){
			vis[i] = 0;
			d[i] = map[i][x];
		}
		vis[x] = 1;
		
		dijkstra1();
		
		dis[x] = 0;
		d[x] = 0;
				
		int MAX = 0;
		for(int i = 1; i <= n; i ++){
			if( i != x && dis[i] + d[i] > MAX && dis[i] < INF && d[i] < INF)
				MAX = dis[i] + d[i];
		}
		printf("%d\n",MAX);
	}
}