POJ 3268 Silver Cow Party

Silver Cow Party

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 26748		Accepted: 12232

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.

最短路。

题意：给你N个农场，每个农场的奶牛都要去X农场开party同时开会还要回去。每次走的都是最短路。

求来回路程最长是多少。

本来想跑一遍floyd然后直接计算就好，然而1000^3复杂度过高TLE了。

所以就只能dijkstra了

这题看似麻烦，因为全部从X点返回各自农场是一个X到其他所有点的最短路径问题，但是从各自点到X点貌似就是N个点各自的最短路了。但其实可以这样，从所有点到X点就是逆的X点到其他点的过程，只不过走的路径也是反的，那么其实就很简单了，正向建边用于计算从X点返回各自点，而反向建边构成一张新的图，也是计算从X点返回各点的最短路径，其实这些边本来是从各点到X，但是反向建之后就变成了X到各点了，然后就变成简单的一点到多点的最短路，就可以跑两遍最短路水过去了。（转）

//#include <bits/stdc++.h>
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <climits>
#include <cmath>
#define max(a,b) (a>b)?a:b
#define min(a,b) (a<b)?a:b
int N, M, X;
const int V = 1e3 + 10;
const int inf = 0x1010101;
int cost[V][V];
using namespace std;
void floyd()
{
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= N; j++)
            for(int k = 1; k <= N; k++)
                cost[i][j] = min(cost[i][j],cost[i][k] + cost[k][j]);
}
bool used[V];
int dis[V];
void dijkstra()
{
    memset(dis,0,sizeof(dis));
    memset(used,0,sizeof(used));
    for(int i = 1; i <= N; i++)
        dis[i] = cost[X][i];
    used[X] = 1;
    for(int i = 1; i < N; i++)
    {
        int v = -1;
        for(int j = 1; j <= N; j++)
            if(!used[j] && (v == -1 || dis[j] < dis[v]))
                v = j;
        used[v] = 1;
        for(int j = 1; j <= N; j++)
        {
            if(!used[j] && dis[j] > dis[v] + cost[v][j])
                dis[j] = dis[v] + cost[v][j];
        }
    }
}
int costsum[V];

int main()
{
    scanf("%d%d%d",&N, &M, &X);
    memset(cost,1,sizeof(cost));
    for(int i = 1; i <= N; i++)
        cost[i][i] = 0;
    while(M--)
    {
        int a,b,t;
        scanf("%d%d%d",&a, &b, &t);
        cost[a][b] = t;
    }
    dijkstra();//第一次dijkstra求X到其他农场的最短路
    for(int i = 1; i <= N; i++)
        costsum[i] += dis[i];
    for(int i = 1; i <= N; i++)
        for(int j = 1; j < i; j++)
            swap(cost[i][j],cost[j][i]);//对矩阵进行转置
    dijkstra();//第二次dijkstra求其他农场到X的最短路
    for(int i = 1; i <= N; i++)
        costsum[i] += dis[i];
    printf("%d\n",*max_element(costsum + 1, costsum + N + 1));
    return 0;
    
}