图的最短路径算法：Floyd、Dijkstra、SPFA，C++实现

图的最短路径算法

最短路问题（short-path problem）：

是网络理论解决的典型问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。基本内容是：若网络中的每条边都有一个数值（长度、成本、时间等），则找出两节点（通常是源节点和阱节点）之间总权和最小的路径就是最短路问题。

应用

城市网络、舰船通道、火灾救护，物流选址，网络空间建设等需要得到最快时间，最短路径长度的场景。

算法对比：

算法	适用情况	负权边	判断是否存在负权回路	时间复杂度	空间复杂度
Dijkstra	稠密图,单源最短路径	不可以	不可以	O((M+N)logN), 用堆优化可以达到O(MlogN)	O(M)
Floyd	稠密图，多源最短路径	可以	不可以	O(N³)	O(N²)
Bellman-ford	稀疏图，单源最短路径	可以	可以	O(MN)	O(M)
SPFA	稀疏图，单源最短路径	可以	可以	最坏O(MN)	O(M)

迪杰斯特拉

code: 下面是两种实现

//最短路径-迪杰斯特拉-简单实现
#include<bits/stdc++.h>
using namespace std;
int N;
int R;
vector<int>path(100,-1);//保存到下标i的路径的前面那个节点，path[5]=3 表示 3->5 是个路径
vector<int>dis(100,9999999); //保存从k到所有结点的距离，初始为正无穷
vector<int>vis(100,0);//保存每个结点访问标记
vector<vector<int> >G(100, vector<int>(100,9999999)); //保存整张图，G[0][5] = 2表示节点0到盘节点5的连线的权重是2，G[0][6] = 0表示节点0和6之前无连线；

//void dij_ori(vector<vector<int> >G, int *dis, int *vis, int k){
void dij_ori(vector<vector<int> >G, vector<int>&dis, vector<int>&vis, int k){
    for(int i=1; i<=N; ++i){//初始化dis数组
        dis[i] = G[k][i];
    }
    vis[k] = 1;
    for(int i=1; i<=N; ++i){
        int min_dis = 9999999;
        int u;
        for(int j=1; j<=N; ++j){// 在没访问的节点里找距离 K最近的
            if(vis[j] == 0 && dis[j] < min_dis){
                min_dis = dis[j];
                u = j;
            }
        }
        vis[u] = 1;
        for(int j=1; j<=N; ++j){ //看看节点u会不会是中间节点，让dis【j】更小
            if(vis[j]==0 && dis[j] > dis[u] + G[u][j]){ //注意，前面初始化如果写的是0x7fffffff，这里dis[u]+G[u][j]会溢出变成负的
                dis[j] = dis[u] + G[u][j];
                path[j] = u;
            }
        }
    }
}
/*
6
7
1 2 2 4
2 4 3 3
3 4 2 4
1 3 4 1
4 6 2 1
3 5 2 0
5 4 3 2
*/
int main(){
    cin>>N>>R;
    for(int i=1; i<=R; ++i){
        int a,b,c,d;
        cin>>a>>b>>c>>d;
        G[a][b] = c;
        //G[b][a] = c;
    }
    dij_ori(G,dis,vis,1);
    for(int i=0;i<=N;++i){
        cout<<"i: "<<i<<" dis: "<<dis[i]<<endl;
    }
    for(int i=1;i<=N;++i){
        int now = i;
        cout<<"start..."<<endl;
        cout<<now<<" ";
        while(path[now] != -1){
            cout<<path[now]<<" ";
            now=path[now];//倒着输出
        }
        cout<<endl;
    }
    return 0;
}

floyd

code

int dis[100][100];//保存整张图，使用中不要用原图，可以copy一份更新
void floyd(){
	for(int k=1;k<=n;k++)//要经过的点
	    for(int i=1;i<=n;i++)
	        for(int j=1;j<=n;j++)
	            dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}

SPFA

code

//SPFA
vector<vector<int> >G;
int vis[100];
int dis[100];
void spfa(int k){
    queue<int>q;
    q.push(k);
    vis[k] = 1;
    while(!q.empty()){
        int u = q.top();
        q.pop();
        vis[u] = 0;
        for(int i=0; i<G.size(); ++i){
            if(vis[i])
                continue;
            if(dis[i]>dis[u] + G[u][i]){
                dis[i] = dis[u] + G[u][i];
                q.push(i);
                vis[i] = 1;
            }
        }
    }
}