PKU3268Silver Cow Party-双向dijkstra

Silver Cow Party

Time Limit : 4000/2000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 41   Accepted Submission(s) : 15

Problem 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
  
  

 

Source

PKU

 

题目是求牛到party的最短权值中的最大值，一开始没看懂到底要求什么，后来google得知，不过我现在还是看不懂。。。明明是longest time...

1.floyd超时

1.Dijkstra一般用于求单源最短路。先要求出x为终点，其余任意点为起点（多源）这些路的最小值，然后求x为起点，其余点为终点的最短路（单源），可以看到第一步是多源的，但是我们可以转置矩阵，将各条边的方向都转为逆向，这样x就是起点了，然后求出最短距离后，这个距离依然是x为终点，任意点为起点的最短距离，因为路还是那条路，不过是方向反了，所以大小依然不变。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
void dij();
#define N 1005
#define INF 0x3f3f3f3f

using namespace std;

int n,m,x;
int weight[N][N];
int dist[N];
int vis[N];
int d[N];
int dd[N];

int main ()
{
    int i,j,a,b,c,ma,t,temp;
    while(~scanf("%d%d%d",&n,&m,&x))
    {
        int ans;

        memset(weight,0x3f,sizeof(weight));

            for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            weight[a][b]=c;
        }

        ma=-1;

        dij();
        for(i=1;i<=n;i++)
            d[i]=dist[i];//记录x为起点单源时的各点到x的距离

        for(i=1;i<=n;i++)
            for(j=i+1;j<=n;j++)
        {
            temp=weight[i][j];
            weight[i][j]=weight[j][i];
            weight[j][i]=temp;
        }//转置矩阵

        dij();
        for(i=1;i<=n;i++)
            dd[i]=dist[i];//记录x为终点时各点到x的最短距离

        for(i=1;i<=n;i++)
        {
            t=d[i]+dd[i];//一个是以x为起点，一个是以x为终点
            if(t>ma&&t<INF)
            ma=t;
        }

        printf("%d\n",ma);

    }
    return 0;
}

void dij()
{
    int i,j,mi,now;

    memset(dist, 0x3f,sizeof(dist));
    memset(vis,0,sizeof(vis));

    dist[x]=0;

    for(i=1;i<=n;i++)
    {
        mi=INF;
        for(j=1;j<=n;j++)
            if(!vis[j]&&dist[j]<mi)
            {
                mi=dist[j];
                now=j;
            }
            vis[now]=1;

            for(j=1;j<=n;j++)
                if(dist[j]>dist[now]+weight[now][j])
                dist[j]=dist[now]+weight[now][j];
    }
}