poj - 3268 Silver Cow Party (求给定两点之间的最短路）

http://poj.org/problem?id=3268

每头牛都要去标号为X的农场参加一个party,农场总共有N个(标号为1-n),总共有M单向路联通，每头牛参加完party之后需要返回自己的农场，但是他们都想选一条最近的路，并且由于路是单向的，去的路和来的路选择可能不一样，问来去时间之和最大是多少？

这题等于给定了起点和终点，那么求出(d[x][i]+d[i][x])最大的那个即可。

开始错了几次，太不小心了，就是最后求最大值的时候，用了一个临时变量没置0，所以可能会导致错误。

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <set>
 #include <map>
 #include <string>
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
 using namespace std;
 const int maxn= ;
 const int INF = <<;
 struct edge{
     int to,cost;
     edge(){}
     edge(int x,int y) {
         to=x;
         cost=y;
     }
 };
 typedef pair<int,int>P;

 int N,M,X;
 vector<edge>G[maxn];
 int d[maxn];

 int dijkstra(int s,int t) {
     priority_queue<P,vector<P>,greater<P> >que;
     for(int i=;i<=N;i++) d[i]=INF;
     d[s]=;
     que.push(P(,s));

     while(!que.empty()) {
         P p=que.top(); que.pop();
         int v=p.second;
         if(v==t) return d[t];
         if(d[v]<p.first) continue;
         for(int i=;i<G[v].size();i++) {
             edge e=G[v][i];
             if(d[e.to]>d[v]+e.cost) {
                 d[e.to]=d[v]+e.cost;
                 que.push(P(d[e.to],e.to));
             }
         }
     }
 }

 int main()
 {
     //freopen("a.txt","r",stdin);
     //freopen("b.txt","w",stdout);
     int a,b,c;
     while(~scanf("%d%d%d",&N,&M,&X)) {
         for(int i=;i<M;i++) {
             scanf("%d%d%d",&a,&b,&c);
             G[a].push_back(edge(b,c));
         }
         int sum=;
         for(int i=;i<=N;i++) {
             sum=max(sum,dijkstra(i,X)+dijkstra(X,i));
         }
         printf("%d\n",sum);
     }
     return ;
 }

还有一种方法，首先求出点X到各个点i的最短路径，这就是奶牛返回的最短距离，然后把路径反向，在求点X到各个点i的最短距离，就是每个点到点X的最短距离。

最后把两个距离相交即可。

不过对于反向，不是很明白。

时间直接从600多ms降到60多ms。

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <set>
 #include <map>
 #include <string>
 #include <cmath>
 #include <cstdlib>
 #include <ctime>
 using namespace std;
 const int maxn= ;
 const int INF = <<;
 struct edge{
     int to,cost;
     edge(){}
     edge(int x,int y) {
         to=x;
         cost=y;
     }
 };
 typedef pair<int,int>P;

 int N,M,X;
 vector<edge>G[maxn],RG[maxn];
 int d[maxn],rd[maxn];

 void dijkstra(int s) {
     priority_queue<P,vector<P>,greater<P> >que;
     for(int i=;i<=N;i++) d[i]=INF;
     d[s]=;
     que.push(P(,s));

     while(!que.empty()) {
         P p=que.top(); que.pop();
         int v=p.second;
         if(d[v]<p.first) continue;
         for(int i=;i<G[v].size();i++) {
             edge e=G[v][i];
             if(d[e.to]>d[v]+e.cost) {
                 d[e.to]=d[v]+e.cost;
                 que.push(P(d[e.to],e.to));
             }
         }
     }
 }

 int main()
 {
     //freopen("a.txt","r",stdin);
     //freopen("b.txt","w",stdout);
     int a,b,c;
     scanf("%d%d%d",&N,&M,&X);
         for(int i=;i<M;i++) {
             scanf("%d%d%d",&a,&b,&c);
             G[a].push_back(edge(b,c));
             RG[b].push_back(edge(a,c)); //存储 反向边
         }
         dijkstra(X);   //第一次 dijkstra 是求X到各个点的距离
         //for(int i=1;i<=N;i++) printf("%d\n",d[i]);
         for(int i=;i<=N;i++) G[i]=RG[i];  //然后  把反向存储的边赋值给 G
       //  for(int i=1;i<=N;i++) {
           //  for(int j=0;j<G[i].size();j++)
               //  cout<<G[i][j].to<<" "<<G[i][j].cost<<endl;
        //}
         memcpy(rd,d,sizeof(d));  //把第一次的 最短距离  保存

         dijkstra(X);  //反向的 dijkstra 求出每个点到X的最短距离
         //for(int i=1;i<=N;i++) printf("%d\n",d[i]);
         int sum=;   //枚举最大和
         for(int i=;i<=N;i++) {
             sum=max(sum,d[i]+rd[i]);
         }
         printf("%d\n",sum);
     return ;
 }