POJ 3268 Silver Cow Party 正反图最短路

题目：click here

题意：

　　给出n个点和m条边，接着是m条边，代表从牛a到牛b需要花费c时间，现在所有牛要到牛x那里去参加聚会，并且所有牛参加聚会后还要回来，给你牛x，除了牛x之外的牛，他们都有一个参加聚会并且回来的最短时间，从这些最短时间里找出一个最大值输出。

分析：

　　最短路径只需要从x到i的最短路径代表他们返回的最短路径，然后将所有边反过来，再从x到i的最短路径代表他们来参加聚会的最短路径，这样对应相加找出一个最大值就可以了，当然其实不需要将所有边反过来，只需要将map的行和列对换一下就可以了，数据比较大，所以floyd超时，用dijkstra比较好点。

邻接矩阵：~~~不知道这个题为什么邻接矩阵会比邻接表快~~~

 #include <iostream>
 #include <cstring>
 #include <vector>
 #include <cstdio>
 #include <queue>
 #include <algorithm>

 using namespace std;
 typedef pair<int,int> P;
 const int INF = 1e9+;
 const int M = 1e3+;

 int n, m, x;
 int f, t, c;
 int cost[M][M];
 int costb[M][M];
 int d[M];
 int db[M];
 bool vis[M];

 void dijkstra( int s, int *dist, int field[M][M] )  {
     fill( dist, dist+n+, INF );
     memset( vis, false, sizeof(vis) );
     vis[s] = true;
     dist[s] = ;
     int tm = n;
     while( tm-- )   {
         int minn = INF, k = s;
         for( int i=; i<=n; i++ )   {
             if( !vis[i] && dist[i] < minn ) {
                 minn = dist[i];
                 k = i;
             }
         }
         vis[k] = true;
         for( int i=; i<=n; i++ )   {
             if( !vis[i] && dist[i] > dist[k] + field[k][i] )
                 dist[i] = dist[k] + field[k][i];
         }
     }
 }

 void solve()    {
     int ret = -INF;
     dijkstra( x, d, cost );     // 正图 和 反图的最短路
     dijkstra( x, db, costb );
     for( int i=; i<=n; i++ )
         ret = max( ret, d[i]+db[i] );
     printf("%d\n", ret );
 }

 int main()  {
     while( ~scanf("%d%d%d", &n, &m, &x ) )  {
         for( int i=; i<=n; i++ )   {
             for( int j=; j<=n; j++ )   {
                 cost[i][j] = INF;
                 costb[i][j] = INF;
             }
         }
         for( int i=; i<m; i++ )    {
             scanf("%d%d%d", &f, &t, &c );
             cost[f][t] = c;
             costb[t][f] = c;
         }
         solve();
     }
     return ;
 }

邻接表：

 #include <iostream>
 #include <cstring>
 #include <vector>
 #include <cstdio>
 #include <queue>
 #include <algorithm>

 using namespace std;
 typedef pair<int,int> P;
 const int INF = 1e9+;
 const int M = 1e3+;

 struct edge { int to, cost; };
 int n, m, x;
 int f, t, c;
 int d[M];
 int db[M];
 vector<edge> G[M];

 void dijkstra( int s, int *dist )  {
     priority_queue< P, vector<P>, greater<P> > que;
     fill( dist, dist+n+, INF );
     dist[s] = ;
     que.push( P(,s) );
     while( !que.empty() )   {
         P p = que.top(); que.pop();
         int v = p.second;
         if( dist[v] < p.first ) continue;
         for( int i=; i<G[v].size(); i++ )  {
             edge e = G[v][i];
             if( dist[e.to] > dist[v] + e.cost )   {
                 dist[e.to] = dist[v] + e.cost;
                 que.push( P(dist[e.to],e.to) );
             }
         }
     }
 }

 void solve()    {
     dijkstra( x, db );
     int ret = -INF;
     for( int i=; i<=n; i++ )   {
         dijkstra( i, d );
             ret = max( ret, d[x]+db[i] );
     }
     printf("%d\n", ret );
 }
 int main()  {
     while( ~scanf("%d%d%d", &n, &m, &x ) )  {
         for( int i=; i<m; i++ )    {
             scanf("%d%d%d", &f, &t, &c );
             G[f].push_back( (edge){t,c} );
         }
         solve();
     }
     return ;
 }