hdu 1874(最短路 Dilkstra +优先队列优化+spfa）

畅通工程续

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 50537    Accepted Submission(s): 18852

Problem Description

某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个城镇到另一个城镇时，都有许多种道路方案可以选择，而某些方案要比另一些方案行走的距离要短很多。这让行人很困扰。
现在，已知起点和终点，请你计算出要从起点到终点，最短需要行走多少距离。

Input

本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<200,0<M<1000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以0～N-1编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0<=A,B<N,A!=B,0<X<10000),表示城镇A和城镇B之间有一条长度为X的双向道路。
再接下一行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。

Output

对于每组数据，请在一行里输出最短需要行走的距离。如果不存在从S到T的路线，就输出-1.

Sample Input

3 3

0 1 1

0 2 3

1 2 1

0 2

3 1

0 1 1

1 2

Sample Output

2

-1

Author

linle

Source

2008浙大研究生复试热身赛（2）——全真模拟

 

1》Dijkstra算法求最短路

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<cstdlib>
#include<string>
#define eps 0.000000001
typedef long long ll;
typedef unsigned long long LL;
using namespace std;
const int N=+;
const int INF=0x3f3f3f3f;
int n,m;
int mp[N][N];
int vis[N];
int dis[N];
void init(){
   // memset(dis,0,sizeof(dis));
    memset(vis,,sizeof(vis));
    for(int i=;i<N;i++)
    for(int j=;j<N;j++){mp[i][j]=INF;
    }

}
void Dijkstra(int v,int e){
    dis[v]=;
    vis[v]=;
    int pos;
    for(int i=;i<n;i++)dis[i]=mp[v][i];
    for(int i=;i<n;i++){
        int minn=INF;
        for(int j=;j<n;j++){
            if(dis[j]<minn&&vis[j]==){
                pos=j;
                minn=dis[j];
            }
        }
        vis[pos]=;
        for(int j=;j<n;j++){
            if(dis[pos]+mp[pos][j]<dis[j]&&vis[j]==)
                dis[j]=dis[pos]+mp[pos][j];
        }
    }
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        init();
        for(int i=;i<m;i++){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(z<mp[x][y])
            mp[x][y]=mp[y][x]=z;
        }
        int v0,v;
        scanf("%d%d",&v0,&v);
         if(v0==v){
            cout<<<<endl;
            continue;
        }
        Dijkstra(v0,v);
        if(dis[v]==INF)cout<<-<<endl;
        else
            cout<<dis[v]<<endl;

    }
}

Dijkstra +优先队列优化

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<map>
 #include<stack>
 #include<set>
 #include<vector>
 #include<cstdlib>
 #include<string>
 #define eps 0.000000001
 typedef long long ll;
 typedef unsigned long long LL;
 using namespace std;
 const int N=+;
 const int INF=0x3f3f3f3f;
 int m,n;
 struct node{
     int to,next,w;
     bool operator<(const node &a)const{
         return w>a.w;
     }
 }edge[N];
 int head[N];
 int t;
 int vis[N],dis[N];
 void init(){
     memset(vis,,sizeof(vis));
     t=;
     memset(head,-,sizeof(head));
     for(int i=;i<N;i++)dis[i]=INF;
 }
 void add(int u,int v,int w){
     edge[t].to=v;
     edge[t].w=w;
     edge[t].next=head[u];
     head[u]=t++;
 }
 int Dijkstra(int x){
     dis[x]=;
     node t1,t2;
     priority_queue<node>q;
     t1.to=x;
     q.push(t1);
     while(!q.empty()){
         t1=q.top();
         q.pop();
         int u=t1.to;
         if(vis[u]==)continue;
         vis[u]=;
         for(int i=head[u];i!=-;i=edge[i].next){
             int v=edge[i].to;
             if(vis[v]==&&dis[v]>dis[u]+edge[i].w){
                 dis[v]=dis[u]+edge[i].w;
                 t2.to=v;
                 t2.w=dis[v];
                 q.push(t2);
             }
         }
     }

 }
 int main(){
     while(scanf("%d%d",&n,&m)!=EOF){
         init();
         for(int i=;i<m;i++){
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             add(u,v,w);
             add(v,u,w);
         }
         int x,y;
         scanf("%d%d",&x,&y);
         Dijkstra(x);
         if(dis[y]==INF)cout<<-<<endl;
         else
             cout<<dis[y]<<endl;

     }
 }

spfa算法求最短路

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<string.h>
 #include<set>
 #include<vector>
 #include<queue>
 #include<stack>
 #include<map>
 #include<cmath>
 typedef long long ll;
 typedef unsigned long long LL;
 using namespace std;
 const double PI=acos(-1.0);
 const double eps=0.0000000001;
 const int INF=0x3f3f3f3f;
 const int N=+;
 int n,m;
 struct node{
     int w,next,to;
 }edge[N<<];
 int head[N];
 int tot;
 void init(){
     memset(head,-,sizeof(head));
     tot=;
 }
 void add(int u,int v,int w){
     edge[tot].to=v;
     edge[tot].w=w;
     edge[tot].next=head[u];
     head[u]=tot++;
 }
 int dis[N];
 int vis[N];
 void spfa(int s){
     queue<int>q;
     memset(dis,INF,sizeof(dis));
     dis[s]=;
     memset(vis,,sizeof(vis));
     q.push(s);
     vis[s]=;
     while(!q.empty()){
         int x=q.front();
         q.pop();
         vis[x]=;
         for(int i=head[x];i!=-;i=edge[i].next){
             int v=edge[i].to;
             if(dis[x]+edge[i].w<dis[v]){
                 dis[v]=dis[x]+edge[i].w;
                 if(vis[v])continue;
                 vis[v]=;
                 q.push(v);
             }

         }
     }
 }
 int main(){
     while(cin>>n>>m){
         init();
         for(int i=;i<m;i++){
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             add(u,v,w);
             add(v,u,w);
         }
         int u,v;
         scanf("%d%d",&u,&v);
         spfa(u);
         if(dis[v]==INF)cout<<-<<endl;
         else{
             cout<<dis[v]<<endl;
         }
     }
 }