HDU-#2544 最短路（Dijkstra、Floyd、Bellman-Ford、SPFA）

题目大意：给出n个顶点，以及m个关系，求出标记为1到标记为n的最短路径。

解题思路：最短路的入门题目，是用来了解和学习最短路算法的最佳题目之一。数据卡的不是很严，因此用四种求最短路的算法均可以实现，分别为Dijkstra、Floyd、Bellman-Ford、SPFA算法，这四种都是未经过优化的版本，才开始学，了解还不是很深入，后边更新整个优化版本。详见code。

题目来源：http://acm.hdu.edu.cn/showproblem.php?pid=2544

基础的Dijkstra、Floyd、SPFA     code：

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;

const int MAXN = 105;
const int INF = 99999999;
int vis[MAXN],dist[MAXN],map[MAXN][MAXN];
int n,m,a,b,c;

void init(){  //初始化
    for(int i=0;i<MAXN;i++)
        for(int j=0;j<MAXN;j++){
            if(i==j) map[i][j]=0;
            else map[i][j]=map[j][i]=INF;
        }
}

void Dijkstra(){
    memset(vis,0,sizeof(vis)); //清除所有标号
    for(int i=1;i<=n;i++) dist[i]=(i==1 ? 0 : INF); //设d[1]=0，其它置为INF
    for(int i=1;i<=n;i++){ //进行n次循环
        int x,min=INF;
        for(int j=1;j<=n;j++) if(!vis[j] && dist[j]<=min) min=dist[x=j]; //在所有未标记的节点中，选出d值最小的节点x
        vis[x]=1;  //标记x节点
        for(int k=1;k<=n;k++) //对于从x出发的所有边（x，k）进行最小值更新
            if(dist[k]>dist[x]+map[x][k])
                dist[k] = dist[x]+map[x][k];
    }
}

void Floyd(){
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            if(map[i][k]!=INF) //优化减少循环
                for(int j=0;j<=n;j++)//DP
                    if(map[i][j]>map[i][k]+map[k][j])
                        map[i][j]=map[i][k]+map[k][j];
}

void SPFA(){
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++) dist[i]=(i==1 ? 0 :INF); //初始化
    queue<int> q;
    q.push(1);//起点放入队列
    vis[1]=1;//标记
    while(!q.empty()){
        int tmp=q.front(); //取队首元素
        q.pop();
        vis[tmp]=0; //记得标记
        for(int i=1;i<=n;i++){
            if(dist[i]>dist[tmp]+map[tmp][i]){
                dist[i]=dist[tmp]+map[tmp][i];
                if(!vis[i]){
                    q.push(i);
                    vis[i]=1;
                }
            }
        }
    }
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF && (n||m)){
        init();
        while(m--){
            scanf("%d%d%d",&a,&b,&c);
            if(c<map[a][b]) map[a][b]=map[b][a]=c;
        }
        //Dijkstra();
        SPFA();
        //Floyd();
        //printf("%d\n",map[1][n]);
        printf("%d\n",dist[n]);
    }
    return 0;
}

Bellman_Ford   code：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int MAXN = 20000;
const int INF = 0x3fffffff;
int dist[MAXN],u[MAXN],v[MAXN],w[MAXN],d[MAXN];
int n,m,a,b,c;

void Bellman_Ford(){
    for(int i=1;i<=n;i++) dist[i]=(i==1?0:INF); //初始化
    for(int k=1;k<=n;k++) //迭代
        for(int i=1;i<=2*m;i++){
            int x=u[i],y=v[i];
            if(dist[x]<INF)
                if(dist[y]>dist[x]+w[i])
                    dist[y] = dist[x]+w[i];
        }
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF && (n||m)){
        for(int i=1;i<=2*m;i++){  //注意范围
            scanf("%d%d%d",&a,&b,&c);
            u[i]=a;v[i]=b;w[i]=c;  //接收值
            u[++i]=b;v[i]=a;w[i]=c;  //进行关联，记得首先++i,用下一个坐标进行关联
        }
        Bellman_Ford();
        printf("%d\n",dist[n]);
    }
    return 0;
}

再将Dijkstra进行优化一下，用链表和优先队列进行优化。

Dijkstra+邻接表+优先队列 code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

typedef pair<int,int> pii;
const int MAXN=100+10;
const int MAXM = 10000+10;
const int INF=0x3fffffff;
int n,m,a,b;
int first[MAXN],next[MAXM];
int u[MAXM],v[MAXM],w[MAXM],d[MAXN];
bool done[MAXN];

void Dijkstra(){
    priority_queue<pii,vector<pii>,greater<pii> > q;
    for(int i=0;i<n;i++) d[i]=(i==0?0:INF);  //初始化
    memset(done,0,sizeof(done));
    q.push(make_pair(d[0],0)); //起点进入队列
    while(!q.empty()){
        pii u=q.top();q.pop();
        int x=u.second;
        if(done[x]) continue;  //已经计算过则跳过
        done[x]=true;
        for(int e=first[x];e!=-1;e=next[e])
            if(d[v[e]]>d[x]+w[e]){
                d[v[e]]=d[x]+w[e];   //松弛，更新值
                q.push(make_pair(d[v[e]],v[e]));
            }
    }
}

int main(){
    while(scanf("%d%d",&n,&m)!=EOF && (n||m)){
        for(int i=0;i<n;i++) first[i]=-1;  //初始化表头
        for(int i=0;i<2*m;i++){
            scanf("%d%d%d",&a,&b,&w[i]);
            u[i]=--a;v[i]=--b;
            next[i]=first[u[i]];  //插入链表
            first[u[i]]=i;
            next[++i]=first[v[i]];  //因为是无向边，因此要反向插入一次
            first[v[i]]=i;
            u[i]=v[i-1];v[i]=u[i-1];w[i]=w[i-1];  //将边进行关联
        }
        Dijkstra();
        printf("%d\n",d[n-1]);
    }
    return 0;
}