最短路三种算法模版

以hdu2544为例
（1）floyd适合多点源最短路

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=100000;
const int MAX=105;
int d[MAX][MAX];
int n;
void init()
{
    for(int i=0;i<=n;i++){
        for(int j=0;j<=n;j++){
           if(j==i)d[i][j]=0;
           else d[i][j]=INF;
        }
    }
}
void floyd()
{
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++){
                     d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
}
int main()
{
    int m;
    while(1){
        scanf("%d %d",&n,&m);
        if(n==0&&m==0)break;
        init();
        int u,v,w;
        for(int i=0;i<m;i++){
            cin>>u>>v>>w;
            if(d[u][v]>w){
              d[u][v]=w;
              d[v][u]=w;
            }
        }
        floyd();
        if(min(d[1][n],d[n][1])==INF)cout<<"-1"<<endl;
        else cout<<min(d[1][n],d[n][1])<<endl;
    }
    return 0;
}

（2）dijkstra 适合单源最短路

//第一种 使用优先队列实现 但是hduoj好像无法编译（可以忽略）
//没有按照2544题目来写 提供主体模版 可以根据题目不同改写
#include<bits/stdc++.h>
using namespace std;
//typedef pair<int,int>P;
const int MAX=100;
const int INF=10000000;
const int NN=100;
struct edge
{
    int from,to,cost;//from是不必要的
    edge(int a,int b,int c)
    {
        from=a;
        to=b;
        cost=c;
    }
};
vector<edge>G[NN];
int V;
int cost[MAX][MAX];
int d[MAX];
void dijkstra(int s)
{
    fill(d,d+V,INF);
    priority_queue<P,vector<P>,greater<P> >Q;
    d[s]=0;
    Q.push(P(0,s));
    while(!Q.empty())
    {
        P p=Q.top();
        Q.pop();
        int v=p.second;
        if(d[v]<p.first)continue;
        for(int i=0; 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;
                Q.push(P(d[e.to],e.to));
            }
        }
    }
}
int main()
{
    int T,S,n;//共有T条路，源点是S，共有n个点
    cin>>T>>S>>n;
    int a,b,c;
    for(int i=0; i<T; i++)
    {
        cin>>a>>b>>c;
        edge pp(a,b,c);
        G[a].push_back(pp);
    }
    dijkstra(S);
    int mini=INF;
    for(int i=0;i<n;i++){
        if(i!=S)mini=min(mini,d[i]);
    }
    cout<<mini;
    return 0;
}

//第二种使用set实现，一般情况下这种实现比较高效
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<set>
using namespace std;
//typedef pair<int,int>P;
const int MAX=605;
const int INF=10000000;
struct edge
{
    int from,to,cost;//from是不必要的
    edge(int a,int b,int c)
    {
        from=a;
        to=b;
        cost=c;
    }
};
vector<edge>G[MAX];
int n;
int d[MAX];
void init()
{
    fill(d,d+MAX,INF);
    for(int i=0; i<MAX; i++)G[i].clear();
}
void dijkstra(int s)
{
    set<pair<int,int> >ss;
    d[s]=0;
    ss.insert(make_pair(0,s));
    while(ss.size()!=0)
    {
        set<pair<int,int> >::iterator it=ss.begin();
        pair<int,int>P=*it;
        ss.erase(it);
        int v=P.second;
        if(d[v]<P.first)continue;
        for(int i=0; i<G[v].size(); i++)
        {
            int k=G[v][i].to;
            if(d[k]>d[v]+G[v][i].cost)
            {
                d[k]=d[v]+G[v][i].cost;
                ss.insert(make_pair(d[k],k));
            }
        }
    }
}
int main()
{
    int m;
    while(1)
    {
        scanf("%d %d",&n,&m);
        if(n==0&&m==0)break;
        init();
        int a,b,c;
        for(int i=0; i<m; i++)
        {
            cin>>a>>b>>c;
            edge p1(a,b,c);
            G[a].push_back(p1);
            edge p2(b,a,c);
            G[b].push_back(p2);
        }
        dijkstra(1);
        if(d[n]==INF)cout<<"-1"<<endl;
        else cout<<d[n]<<endl;
    }
    return 0;
}

（3）SPFA 适合单源最短路

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
const int NN=105;
const int INF=0x3f3f3f3f;
struct edge
{
    int from,to,cost;
    edge(int a,int b,int c)
    {
        from=a;
        to=b;
        cost=c;
    }
};
bool vis[NN];//记录有无被访问
int d[NN];//记录距离
int n;
vector<edge>G[NN];
void init()
{
    fill(d,d+NN,INF);
    for(int i=0; i<NN; i++)G[i].clear();
    memset(vis,0,sizeof(vis));
}
void SPFA(int s)
{
    queue<int>Q;
    Q.push(s);
    //num[s]++;
    d[s]=0;
    vis[s]=1;
    while(!Q.empty())
    {
        int p=Q.front();
        Q.pop();
        vis[p]=0;
        for(int i=0; i<G[p].size(); i++)
        {
            int k=G[p][i].to;
            //cout<<"p:"<<p<<" k:"<<k<<endl;
            if(d[k]>d[p]+G[p][i].cost)
            {
                d[k]=d[p]+G[p][i].cost;
                if(vis[k]!=1)
                {
                    vis[k]=1;
                    Q.push(k);
                    //num[k]++;
                    //if(num[k]>n)return 0;//代表有负环
                }
            }
        }
    }
}
int main()
{

    int m;
    while(1)
    {
        scanf("%d %d",&n,&m);
        if(n==0&&m==0)break;
        int a,b,c;
        init();
        for(int i=0; i<m; i++)
        {
            cin>>a>>b>>c;
            edge p1(a,b,c);
            G[a].push_back(p1);
            edge p2(b,a,c);
            G[b].push_back(p2);
        }
        SPFA(1);
        if(d[n]==INF)cout<<"-1"<<endl;
        else cout<<d[n]<<endl;
    }
    return 0;
}