POJ3268（Dijkstra）

Silver Cow Party

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 13103		Accepted: 5883

题目链接：http://poj.org/problem?id=3268

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个农场，每个农场有一头牛，现在有m条路（单源路），要在x农场办party，其他的牛要去参加，并且参加完返回自己的农场，规定牛很懒，所以走的一定是最短路。求牛总共所需的最长时间。

首先对于从x点到其他点的dis函数很好构造，但是从其他点到x点就有点困难，因为这样不是单源，是多源的。这是我们可以把所以边反向，在求一次从x到其他个点的最短路，这样就又是单源，可以套模板了。

从网上得到一个好办法，所有边反向可以把 g 的行和列调换下。

完整代码：

#include <functional>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <numeric>
#include <cstring>
#include <climits>
#include <cassert>
#include <complex>
#include <cstdio>
#include <string>
#include <vector>
#include <bitset>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <list>
#include <set>
#include <map>
using namespace std;

#pragma comment(linker, "/STACK:102400000,102400000")

typedef long long LL;
typedef double DB;
typedef unsigned uint;
typedef unsigned long long uLL;

/** Constant List .. **/ //{

const int MOD = int(1e9)+7;
const int INF = 0x3f3f3f3f;
const LL INFF = 0x3f3f3f3f3f3f3f3fLL;
const DB EPS = 1e-9;
const DB OO = 1e20;
const DB PI = acos(-1.0); //M_PI;
const int maxn = 1111;
int n , m , x;
int g[maxn][maxn];
int dis[maxn];
int undis[maxn];
int vis[maxn];

void init()
{
    for(int i = 1 ; i <= n ; i ++)
    {
        for(int j = 1 ; j <= n ; j ++)
        {
            if(i == j)
                g[i][j] = 0;
            else
                g[i][j] = INF;
        }
    }
}

int dijkstra()
{
    for(int i = 1 ; i <= n ; i ++)
    {
        dis[i] = g[x][i];
        undis[i] = g[i][x];
    }
    memset(vis , 0 , sizeof(vis));
    for(int i = 1 ; i <= n ; i ++)
    {
        int mark = -1;
        int mindis = INF;
        for(int j = 1 ; j <= n ; j ++)
        {
            if(!vis[j] && dis[j] < mindis)
            {
                mindis = dis[j];
                mark = j;
            }
        }
        vis[mark] = 1;
        for(int j = 1 ; j <= n ;  j ++)
        {
            if(!vis[j])
            {
                dis[j] = min(dis[j] , dis[mark] + g[mark][j]);
            }
        }
    }
    memset(vis , 0 , sizeof(vis));
    for(int i = 1 ; i <= n ; i ++)
    {
        int mark = -1;
        int mindis = INF;
        for(int j = 1 ; j <= n ; j ++)
        {
            if(!vis[j] && undis[j] < mindis)
            {
                mindis = undis[j];
                mark = j;
            }
        }
        vis[mark] = 1;
        for(int j = 1 ; j <= n ;  j ++)
        {
            if(!vis[j])
            {
                undis[j] = min(undis[j] , undis[mark] + g[j][mark]);
            }
        }
    }
    int maxx = -INF;
    for(int i = 1 ; i <= n ; i ++)
        if(dis[i] + undis[i] > maxx)
            maxx = dis[i] + undis[i];
    return maxx;
}


int main()
{
    #ifdef DoubleQ
    freopen("in.txt","r",stdin);
    #endif
    while(~scanf("%d%d%d",&n,&m,&x))
    {
        init();
        int x , y , k;
        for(int i = 0 ; i < m ; i ++)
        {
            scanf("%d%d%d",&x,&y,&k);
            g[x][y] = k;
        }
        printf("%d\n" , dijkstra());
    }
}