最短路—D - Silver Cow Party

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 Ti (1 ≤ Ti ≤ 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: Ai, Bi, and Ti. The described road runs from farm Ai to farm Bi, requiring Ti 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.

题目大意：有编号为1—n的牛要去x号农场参加聚会，参加完聚会还要回家。由于牛非常懒，所以他们会选择最短的时间走来回，由于路都是单向的，即从1->2和从2->1可能所走的路程不是一样的。所以往返的路径也是不同的。现在让你找出这些牛中走的路最多的那头牛所花费的时间。

思路：肯定用最短路的只是解答，由于路是单向的，且要从 家->x 再从 x->家。所以置换了矩阵。把e [ i ] [ j ] 与e [ j ] [ i ] 的值调换，则又是最短路。然后把来回的时间相加找出和为最大的值。

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;

const int inf=99999999;
int minn,u,n,m,x;

//dis表示的是各个点到x的距离，way表示的是x到各个点的距离
int e[1100][1100],dis[1100],book[1100],way[1100];
void Dijkstra(int x)
{
    for(int i=1; i<=n; i++)//book标记查询过的点
        book[i]=0;
    book[x]=1;

    for(int i=1; i<=n; i++)//一定不要把顺序搞错，这时的e[i][j]与e[j][i]不一定一样。
        dis[i]=e[x][i];

    for(int i=2; i<=n; i++)
    {
        minn=inf;
        for(int j=1; j<=n; j++)
        {
            if(!book[j]&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
        }
        book[u]=1;
        for(int v=1; v<=n; v++)
        {
            if(!book[v]&&dis[v]>dis[u]+e[u][v])
                dis[v]=dis[u]+e[u][v];
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&x))
    {
        int ans=0;
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
            {
                if(i==j)
                    e[i][j]=0;
                else
                    e[i][j]=inf;
            }

        int a,b,t;
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&a,&b,&t);
            if(e[a][b]>t)
                e[a][b]=t;
        }

        Dijkstra(x);//第一次使用Dijkstra算法来找出从家到x农场的最短路径

        for(int i=1; i<=n; i++)
            way[i]=dis[i];

        for(int i=1; i<=n; i++)//置换矩阵的值，也就是调换e[i][j]与e[j][i]的值。
        {
            for(int j=i+1; j<=n; j++)
            {
                int tmp;
                tmp=e[j][i];
                e[j][i]=e[i][j];
                e[i][j]=tmp;
            }
        }

        Dijkstra(x);//第二次使用Dijkstra算法来找出从x农场到家的最短路径

        for(int i=1; i<=n; i++)
        {
            ans=max(ans,way[i]+dis[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}