Dijkstra：适用于权值为非负的图的单源最短路径，用斐波那契堆的复杂度O(E+VlgV) BellmanFord：适用于权值有负值的图的单源最短路径，并且能够检测负圈，复杂度O(VE) SPFA：适用于权值有负值，且没有负圈的图的单源最短路径，论文中的复杂度O(kE)，k为每个节点进入Queue的次数，且k一般<=2，但此处的复杂度证明是有问题的，其实SPFA的最坏情况应该是O(VE). Floyd：每对节点之间的最短路径。

先给出结论： (1)当权值为非负时，用Dijkstra。 (2)当权值有负值，且没有负圈，则用SPFA，SPFA能检测负圈，但是不能输出负圈。 (3)当权值有负值，而且可能存在负圈，则用BellmanFord，能够检测并输出负圈。 (4)SPFA检测负环：当存在一个点入队大于等于V次，则有负环，后面有证明。

模板就是这些模板，但是这种题通常不会在比赛中单方面考察最短路算法，更多是最短路与图，与环，负环，负权值，连通块等，一同考察，要学会改版子，考虑有向图有环图，有向无环图，没有直接的最短路算法可以解决时，要考虑数据量，然后选择一种最短路，找到合适的改造方法，构造出可以使用该算法的图，进而使用最短路算法，而构造的方法千奇百怪，这绝不是大量练习就能遇到的，而是在练习中寻找一种思考方式，进而能够对陌生题目进行分析，得出合适的解决方案。

学好最短路原理的方法，不是看大牛的讲解，而是自己举一组样例，按照程序的思路去跑一遍，按照他的想法，就能理解算法的设计界原理，比看要记得牢。

floyd技巧：https://blog.csdn.net/weixin_43627118/article/details/100129268

超级源点&汇点：https://blog.csdn.net/weixin_43627118/article/details/100134565

链式前向星（边集数组）：https://mp.csdn.net/postedit/99612887

90387061

//最基础的Dijkstra，用于理解算法本质原理，适用的类型于队列优化的一样，但是时间复杂度太高，所以，用的比较少。
#include<iostream>
#include<queue>
#include<algorithm>
#include<set>
#include<cmath>
#include<vector>
#include<map>
#include<stack>
#include<bitset>
#include<cstdio>
#include<cstring>
#define Swap(a,b) a^=b^=a^=b
#define cini(n) scanf("%d",&n)
#define cinl(n) scanf("%lld",&n)
#define cinc(n) scanf("%c",&n)
#define cins(s) scanf("%s",s)
#define coui(n) printf("%d",n)
#define couc(n) printf("%c",n)
#define coul(n) printf("%lld",n)
#define speed ios_base::sync_with_stdio(0)
#define Max(a,b) a>b?a:b
#define Min(a,b) a<b?a:b
#define mem(n,x) memset(n,x,sizeof(n))
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=1e3+10;
const double esp=1e-9;
//-------------------------------------------------------//

int n,m; //n个节点，m条边
int dis[maxn][maxn];
bool vis[maxn];
int d[maxn];
inline void dijstra();
int main()
{
    mem(dis,0x3f);
    mem(vis,0);
    mem(d,0x3f);
    for(int i=1; i<=n; i++)dis[i][i]=0;
    cini(m),cini(n);//输入边数//点数
    for(int i=0; i<m; i++)
    {
        int x,y,z;
        cini(x),cini(y),cini(z);
        dis[x][y]=min(dis[x][y],z);
        dis[y][x]=min(dis[y][x],z);
        //cout<<dis[x][y]<<endl;
    }
    dijstra();
    cout<<d[n]<<endl;
}
inline void dijstra()
{
    d[1]=0;
    for(int i=1; i<=n; i++)
    {
        int x=0;
        for(int j=1; j<=n; j++)
            if(!vis[j]&&(d[j]<d[x]||x==0))x=j;

        vis[x]=1;
        for(int j=1;j<=n;j++)
            d[j]=min(d[j],d[x]+dis[x][j]);

    }
}

#include<iostream>
#include<queue>
#include<algorithm>
#include<set>
#include<cmath>
#include<vector>
#include<map>
#include<stack>
#include<bitset>
#include<cstdio>
#include<cstring>
#define Swap(a,b) a^=b^=a^=b
#define cini(n) scanf("%d",&n)
#define cinl(n) scanf("%lld",&n)
#define cinc(n) scanf("%c",&n)
#define cins(s) scanf("%s",s)
#define coui(n) printf("%d",n)
#define couc(n) printf("%c",n)
#define coul(n) printf("%lld",n)
#define speed ios_base::sync_with_stdio(0)
#define Max(a,b) a>b?a:b
#define Min(a,b) a<b?a:b
#define mem(n,x) memset(n,x,sizeof(n))
#define INF  0x3f3f3f3f
#define maxn  100010
#define esp  1e-9
#define mp(a,b) make_pair(a,b)
using namespace std;
typedef long long ll;
//-----------------------*******----------------------------//

int next[maxn*10],ege[maxn*10],head[maxn],ver[maxn*10],d[maxn];
bool vis[maxn];
int tot=0;
void add(int x,int y,int z) //аз╫с╠М
{
    ege[++tot]=z;
    next[tot]=head[x];
    head[x]=tot;
    ver[tot]=y;
        //有向图建一条边，无向图反向建边
   // ege[++tot]=z;
   // next[tot]=head[y];
   // head[y]=tot;
   // ver[tot]=x;
}
int n,m;
inline void dijkstra();
int main()
{
    mem(vis,0);
    mem(d,0x3f);
    cini(m);
    cini(n);
    for(int i=0; i<m; i++)
    {
        int x,y,z;
        cini(x),cini(y),cini(z);
        add(x,y,z);
    }
    dijkstra();
    cout<<d[n]<<endl;
}
inline void dijkstra()
{
    d[1]=0;
    priority_queue<pair<int,int> >qu;
    while(qu.size())
        qu.pop();
    qu.push(mp(0,1));
    while(qu.size())
    {
        //cout<<qu.size()<<endl;
        int x=qu.top().second;
        qu.pop();
        if(vis[x])
            continue;
        vis[x]=1;
        for(int i=head[x]; i; i=next[i])
        {
            int y=ver[i],z=ege[i];
            if(d[y]>=d[x]+z)
            {
                d[y]=d[x]+z;
                qu.push(mp(-d[y],y));
            }

        }
    }
}

//Ford 算法有一点DP的思想，同样的松弛操作，但是时间复杂度略高
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<queue>
#include<algorithm>
#include<set>
#include<cmath>
#include<vector>
#include<map>
#include<stack>
#include<bitset>
#include<cstdio>
#include<cstring>
#define Swap(a,b) a^=b^=a^=b
#define cini(n) scanf("%d",&n)
#define cinl(n) scanf("%lld",&n)
#define cinc(n) scanf("%c",&n)
#define cins(s) scanf("%s",s)
#define coui(n) printf("%d",n)
#define couc(n) printf("%c",n)
#define coul(n) printf("%lld",n)
#define speed ios_base::sync_with_stdio(0)
#define Max(a,b) a>b?a:b
#define Min(a,b) a<b?a:b
#define mem(n,x) memset(n,x,sizeof(n))
#define INF  0x3f3f3f3f
#define maxn  100010
#define esp  1e-9
#define mp(a,b) make_pair(a,b)
using namespace std;
typedef long long ll;
//-----------------------*******----------------------------//
int n,m;
int ege[maxn*10],head[maxn],later[maxn*10],dis[maxn];
bool vis[maxn];
inline bool ford()
{
    mem(vis,0);
    mem(dis,0x3f);
    vis[1]=1;
    dis[1]=0;
    for(int i=1; i<n; i++) //n-1´ÎÑ»·
    {
        int check=1;
        for(int j=1; j<=m; j++)
        {
            if(vis[head[j]]||vis[later[j]])
            {
                if(dis[head[j]]+ege[j]<dis[later[j]])
                {
                    dis[later[j]] =dis[head[j]]+ege[j];
                    vis[later[j]]=1;
                    check=0;
                }
                if(dis[later[j]]+ege[j]<dis[head[j]])//有向图，不用反向松弛
                {
                    dis[head[j]] =dis[later[j]]+ege[j];
                    vis[head[j]]=1;
                    check=0;
                }
            }
        }
        if(check)
            break;
    }
    for(int i=1; i<m; i++)
        if(dis[head[i]]+ege[i]<dis[later[i]])
            return 1;
    return 0;
}
int main()
{
    cini(m),cini(n);
    for(int i=1; i<=m; i++)
    {
        cini(head[i]);
        cini(later[i]);
        cini(ege[i]);
    }
    ford();
    cout<<dis[n];
}

SPFA，是队列优化的ford算法
#include<iostream>
#include<queue>
#include<algorithm>
#include<set>
#include<cmath>
#include<vector>
#include<map>
#include<stack>
#include<bitset>
#include<cstdio>
#include<cstring>
#define Swap(a,b) a^=b^=a^=b
#define cini(n) scanf("%d",&n)
#define cinl(n) scanf("%lld",&n)
#define cinc(n) scanf("%c",&n)
#define cins(s) scanf("%s",s)
#define coui(n) printf("%d",n)
#define couc(n) printf("%c",n)
#define coul(n) printf("%lld",n)
#define speed ios_base::sync_with_stdio(0)
#define Max(a,b) a>b?a:b
#define Min(a,b) a<b?a:b
#define mem(n,x) memset(n,x,sizeof(n))
#define INF  0x3f3f3f3f
#define maxn  100010
#define esp  1e-9
#define mp(a,b) make_pair(a,b)
using namespace std;
typedef long long ll;
//-----------------------*******----------------------------//
int next[maxn*10],ege[maxn*10],head[maxn],ver[maxn*10],d[maxn];
bool vis[maxn];
int tot=0,n,m;
void add(int x,int y,int z)
{
    next[++tot]=head[x];
    ege[tot]=z;
    ver[tot]=y;
    head[x]=tot;
    next[++tot]=head[y];
    ege[tot]=z;
    ver[tot]=x;
    head[y]=tot;
}
void spfa(int w)
{
    mem(d,0x3f);
    mem(vis,0);
    vis[w]=1;
    d[w]=0;
    queue<int> q;
    while(q.size()) q.pop();
    q.push(w);
    while(q.size())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=next[i])
        {
            int y=ver[i],z=ege[i];
            if(d[y]>d[x]+z)
            {
                d[y]=d[x]+z;
                if(!vis[y]) q.push(y),vis[y]=1;
            }
        }
    }
}
int main()
{
    cini(m);
    cini(n);
    for(int i=0; i<m; i++)
    {
        int x,y,z;
        cini(x),cini(y),cini(z);
        add(x,y,z);
    }
    int w;
    cin>>w;
    spfa(w);
    for(int i=1;i<=n;i++)
    cout<<d[i]<<endl;
}

疯子的算法总结(八) 最短路算法+模板

Floyd 算法戳这里：https://blog.csdn.net/weixin_43627118/article/details/90387061