POJ 3268 Silver Cow Party （ Dijkstra ）

题目大意：

有N个农场每个农场要有一头牛去参加一个聚会，连接每个农场有m条路， 聚会地点是X，并且路是单向的.要求的是所有牛赶到聚会地点并且回到自己原先的农场所需要的最短时间。

题目分析：

其实就是以X为终点，求出X到其他每个点的距离， 再将图反存一下，在做一次最短路， 两次距离相加求出最长的时间。

这里是用Dijkstra写的，我们第一次用邻接矩阵写，第二次用邻接表，并且有优先队列优化

 #include <iostream>
 #include <cmath>
 #include <cstring>
 #include <cstdlib>
 #include <cstdio>
 #include <algorithm>
 #include <vector>
 #include <queue>
 using namespace std;
 #define INF 0xfffffff
 #define maxn 1005
 int G[][maxn][maxn];
 int dist[][maxn];
 bool vis[][maxn];
 int n, m, X;
 void Dijkstra(int Star,int End,int k)
 {
     dist[k][Star] = ;

     for(int i=; i<=n; i++)
     {
         int Min = INF, index;
         for(int j=; j<=n; j++)
         {
             if(dist[k][j] < Min && !vis[k][j])
                 Min = dist[k][j], index = j;
         }

         vis[k][index] = true;

         for(int j=; j<=n; j++)
         {
             if(!vis[k][j])
                 dist[k][j] = min(dist[k][j], dist[k][index] + G[k][index][j]);
         }
     }
 }
 void Init()
 {
     memset(vis,false,sizeof(vis));
     for(int i=; i<=n; i++)
     {
         dist[][i] = dist[][i] = INF;
         for(int j=; j<=n; j++)
             G[][i][j] = G[][j][i] = G[][i][j] = G[][j][i] = INF;
     }
 }

 int Slove()
 {
     int Max = ;
     Dijkstra(X,n,);
     Dijkstra(X,n,);
     for(int i=; i<=n; i++)
     {
         Max = max(dist[][i]+ dist[][i], Max);
     }
     return Max;
 }
 int main()
 {
     while(scanf("%d%d%d",&n,&m,&X) != EOF)
     {
         Init();
         for(int i=; i<m; i++)
         {
             int a, b, c;
             scanf("%d%d%d",&a,&b,&c);
             G[][a][b] = min(G[][a][b],c);
             G[][b][a] = min(G[][b][a],c);
         }
         int ans = Slove();

         cout << ans << endl;
     }
     return ;
 }

优先队列版本

#include <iostream>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;
#define INF 0xfffffff
#define maxn 1006
#define min(a,b) (a<b?a:b)
#define max(a,b) (a>b?a:b)
struct Edge
{
    int e;
    int w;
    friend bool operator < (Edge n1, Edge n2)
    {
        return n1.w > n2.w;
    }
};
vector<Edge>G[2][maxn];

int dist[2][maxn];
bool vis[2][maxn];
int n, m, X;
void Dijkstra(int Star,int End,int k)
{
    Edge P, Pn;
    P.e = Star;
    P.w = 0;
    dist[k][P.e] = 0;
    priority_queue<Edge> Q;
    Q.push(P);

    while( !Q.empty() )
    {
        P = Q.top();
        Q.pop();

        if( vis[k][P.e] )
            continue;

        vis[k][P.e] = true;

        int len = G[k][P.e].size();

        for(int i=0; i<len; i++)
        {
            Pn.e = G[k][P.e][i].e;
            Pn.w = G[k][P.e][i].w + P.w;
            if( !vis[k][Pn.e] )
            {
                 dist[k][Pn.e] = min(dist[k][Pn.e],Pn.w);
                 Q.push(Pn);
            }
        }
    }
}
void Init()
{
    memset(vis,false,sizeof(vis));
    for(int i=0; i<=n; i++)
    {
        G[0][i].clear();
        G[1][i].clear();
        dist[0][i] = dist[1][i] = INF;
    }
}

int Slove()
{
    int Max = 0;
    Dijkstra(X,n,0);
    Dijkstra(X,n,1);
    for(int i=1; i<=n; i++)
    {
        Max = max(dist[0][i]+ dist[1][i], Max);
    }
    return Max;
}
int main()
{
    Edge P;
    while(scanf("%d%d%d",&n,&m,&X) != EOF)
    {
        Init();
        for(int i=0; i<m; i++)
        {
            int a, b, c;
            scanf("%d%d%d",&a,&b,&c);
            P.e = b, P.w = c;
            G[0][a].push_back(P);
            P.e = a;
            G[1][b].push_back(P);
        }
        int ans = Slove();

        cout << ans << endl;
    }
    return 0;
}