一个人的旅行(floyd+dijskra+SPFA+Bellman)

一个人的旅行

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 23416    Accepted Submission(s): 8154

Problem Description

虽然草儿是个路痴（就是在杭电待了一年多，居然还会在校园里迷路的人，汗~),但是草儿仍然很喜欢旅行，因为在旅途中 会遇见很多人（白马王子，^0^），很多事，还能丰富自己的阅历，还可以看美丽的风景……草儿想去很多地方，她想要去东京铁塔看夜景，去威尼斯看电影，去阳明山上看海芋，去纽约纯粹看雪景，去巴黎喝咖啡写信，去北京探望孟姜女……眼看寒假就快到了，这么一大段时间，可不能浪费啊，一定要给自己好好的放个假，可是也不能荒废了训练啊，所以草儿决定在要在最短的时间去一个自己想去的地方！因为草儿的家在一个小镇上，没有火车经过，所以她只能去邻近的城市坐火车（好可怜啊~）。

 

Input

输入数据有多组，每组的第一行是三个整数T，S和D，表示有T条路，和草儿家相邻的城市的有S个，草儿想去的地方有D个；
接着有T行，每行有三个整数a，b，time,表示a,b城市之间的车程是time小时；(1=<(a,b)<=1000;a,b 之间可能有多条路)
接着的第T+1行有S个数，表示和草儿家相连的城市；
接着的第T+2行有D个数，表示草儿想去地方。

 

Output

输出草儿能去某个喜欢的城市的最短时间。

 

Sample Input

6 2 3 1 3 5 1 4 7 2 8 12 3 8 4 4 9 12 9 10 2 1 2 8 9 10

 

Sample Output

9

题解：floy剪枝优化；

代码：

 #include<stdio.h>
 #include<string.h>
 #define MIN(x,y)(x<y?x:y)
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 int T,S,D,used[MAXN];
 int map[MAXN][MAXN],s[MAXN],e[MAXN];
 int main(){
     int a,b,c;
      while(~scanf("%d%d%d",&T,&S,&D)){
          memset(used,,sizeof(used));
          for(int i=;i<=MAXN;i++)
          for(int j=;j<=MAXN;j++)
              if(i-j)map[i][j]=INF;
              else map[i][j]=;
          while(T--){
              scanf("%d%d%d",&a,&b,&c);
              if(c<map[a][b])map[a][b]=map[b][a]=c;
              used[a]++;used[b]++;
          }
          for(int k=;k<MAXN;k++){
              if(!used[k])continue;
              for(int i=;i<MAXN;i++){
                  if(map[i][k]==INF)continue;
                  for(int j=;j<MAXN;j++){
                      map[i][j]=MIN(map[i][j],map[i][k]+map[k][j]);
                     }
                 }
             }
         for(int i=;i<S;i++){
              scanf("%d",&s[i]);
          }
          for(int i=;i<D;i++){
              scanf("%d",&e[i]);
          }
          int ans=INF;
          for(int i=;i<S;i++)
              for(int j=;j<D;j++)
                      ans=MIN(ans,map[s[i]][e[j]]);
                      printf("%d\n",ans);
      }
     return ;
 }

dijskra代码：

 #include<stdio.h>
 #include<string.h>
 #define MIN(x,y)(x<y?x:y)
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 int map[MAXN][MAXN];
 int vis[MAXN],d[MAXN];
 int N,begin[MAXN],end[MAXN];
 void initial(){
     //memset(map,INF,sizeof(map));
     memset(vis,,sizeof(vis));
     memset(d,INF,sizeof(d));
 }
 void dijskra(int s){
     initial();
     d[s]=;
     int k;
     while(true){
             k=-;
         for(int i=;i<=;i++){
             if(!vis[i]&&(k==-||d[i]<d[k]))k=i;
         }
         if(k==-)break;
         vis[k]=;
         for(int i=;i<=;i++){
             d[i]=MIN(d[i],d[k]+map[k][i]);
         }
     }
 }
 int main(){
     int T,S,D;
     int a,b,c,temp;
     while(~scanf("%d%d%d",&T,&S,&D)){
             memset(map,INF,sizeof(map));
         while(T--){
             scanf("%d%d%d",&a,&b,&c);
         if(c<map[a][b])map[a][b]=map[b][a]=c;
         }
         int ans=INF;
         for(int i=;i<S;i++)scanf("%d",&begin[i]);
         for(int i=;i<D;i++)scanf("%d",&end[i]);
         for(int i=;i<S;i++){
                 dijskra(begin[i]);
             for(int j=;j<D;j++){
                // printf("%d\n",temp);
                 ans=MIN(ans,d[end[j]]);
             }
         }
         printf("%d\n",ans);
     }
 return ;
 }

SPFA

 #include<stdio.h>
 #include<string.h>
 #include<queue>
 #define MIN(x,y) (x<y?x:y)
 using namespace std;
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 const int MAXM=;
 int head[MAXM];
 struct Edge{
     int from,to,value,next;
 };
 Edge edg[MAXM];
 int T;
 int S;
 int D;
 int enu;
 int s[MAXN],e[MAXN];
 int vis[MAXN],dis[MAXN],used[MAXN];
 queue<int>dl;
 void initial(){
     memset(dis,INF,sizeof(dis));
     memset(vis,,sizeof(vis));
     while(!dl.empty()){
         dl.pop();
     }
 }
 void SPFA(int sx){
     initial();
     vis[sx]=;dis[sx]=;dl.push(sx);
     while(!dl.empty()){
         int k=dl.front();
         dl.pop();
         vis[k]=;
         for(int i=head[k];i!=-;i=edg[i].next){
             int v=edg[i].to;
             if(dis[k]+edg[i].value<dis[v]){
                 dis[v]=dis[k]+edg[i].value;
                 if(!vis[v])
                     dl.push(v),vis[v]=;
             }
         }
     }
 }
 void add(int u,int v,int value){
     Edge E={u,v,value,head[u]};
     edg[enu]=E;
     head[u]=enu++;
 }
 void get(){
     int a,b,c;
     while(T--){
         scanf("%d%d%d",&a,&b,&c);
         add(a,b,c);
         add(b,a,c);
     }
     for(int i=;i<S;i++)scanf("%d",&s[i]);
     for(int i=;i<D;i++)scanf("%d",&e[i]);
 }
 void print(){
     int ans=INF;
     for(int i=;i<S;i++){
         SPFA(s[i]);
         for(int j=;j<D;j++){
             ans=MIN(ans,dis[e[j]]);
         }
     }
     printf("%d\n",ans);
 }
 int main(){
     while(~scanf("%d%d%d",&T,&S,&D)){
         memset(head,-,sizeof(head));
         enu=;
         get();
         print();
     }
     return ;
 }

Bellman+剪枝：14ms水过；

 #include<stdio.h>
 #include<string.h>
 #define MIN(x,y)(x<y?x:y)
 const int INF=0x3f3f3f3f;
 const int MAXN=;
 const int MAXM=;
 int dis[MAXN],s[MAXN],e[MAXN],used[MAXN];
 struct Node{
     int s,e,dis;
 };
 Node dt[MAXM];
 int T,S,D,top,ans;
 void Bellman(){
     int u,v,w;
     memset(dis,INF,sizeof(dis));
     for(int i=;i<S;i++)dis[s[i]]=;
         for(int j=;j<MAXN;j++){
             if(!used[j])continue;
     for(int i=;i<top;i++){
             u=dt[i].s;v=dt[i].e;w=dt[i].dis;
             dis[v]=MIN(dis[v],dis[u]+w);
         }
     }ans=INF;
     for(int i=;i<D;i++)ans=MIN(dis[e[i]],ans);
     printf("%d\n",ans);
 }
 int main(){
     int a,b,c;
     while(~scanf("%d%d%d",&T,&S,&D)){
         top=;
         memset(used,,sizeof(used));
         while(T--){
         scanf("%d%d%d",&a,&b,&c);
         dt[top].s=a;dt[top].e=b;dt[top++].dis=c;
         dt[top].s=b;dt[top].e=a;dt[top++].dis=c;
         used[a]++;used[b]++;
         }
         for(int i=;i<S;i++)scanf("%d",&s[i]);
         for(int i=;i<D;i++)scanf("%d",&e[i]);
         Bellman();
     }
     return ;
 }