【模板】最短路径（迪杰斯特拉、SPFA、弗洛伊德）

迪杰斯特拉算法（Dijkstra's Algorithm）

解决单源最短路问题的优秀算法，堆优化后时间复杂度降到O((m+n)logn)。

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define N 10003
#define M 500003
#define INF 2147483647
using namespace std;
int n,m;
int dis[N];

struct edge
{
    int to,cost;
};
vector<edge>E[N];   //这里以邻接表为例

struct node
{          //走到at节点的最短路为path
    int at,path;
    bool operator<(const node &_)const
    {
        return path>_.path;   //path小的先出
    }
};

void dijkstra(int s)
{
    FOR(i,1,n)dis[i]=INF;
    dis[s]=0;
    priority_queue<node>q;
    while(!q.empty())q.pop();    //使用前测试STL是好习惯
    q.push((node){s,0});        //把起点先加入队列
    while(!q.empty())
    {
    	node now=q.top();q.pop();   //取距离最小的节点
    	int u=now.at;
    	if(dis[u]<now.path)continue;   //剪枝，如果已经找到更小的dis[u]那么只需要松弛那一次就够了
    	FOR(i,0,(int)E[u].size()-1)
    	{
    		int v=E[u][i].to,w=E[u][i].cost;
    		if(dis[v]>dis[u]+w)
    		{
    			dis[v]=dis[u]+w;
    			q.push((node){v,dis[v]});
                }
        }
    }
    return;
}

int main()
{
    int s;
    scanf("%d%d%d",&n,&m,&s);
    FOR(i,1,m)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        E[u].push_back((edge){v,w});
    }
    dijkstra(s);
    FOR(i,1,n)printf("%d ",dis[i]);
    printf("\n");
    return 0;
}

Dj算法的流程如上，其实不难理解。从源点出发开始松弛，然后寻找没有作过起点的节点中距离最小的，作为新的起点进行下一轮操作。特别要提示的是，Dj算法只适用于正权图，对于有负边出现的图不好使，这也能解释为什么凡是标红的点一定是找到最短路的。

而堆优化其实是优化了寻找距离最小节点这步，从代码中不难看出，如果出现负边，就会出现死循环。因为已经作过起点的节点还会作无数次起点。

SPFA算法（Shortest Path Faster Algorithm）

实际上是Bellman-Ford算法的优化，时间复杂度为O(kn)，k一般小于等于2n.

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<queue>
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define N 10003
#define M 500003
#define INF 2147483647
using namespace std;
int n,m,tot;
int head[N],dis[N];

struct edge
{
    int next,to,w;   //E[i].next是边i的“下一条”边的序号
}E[M];

void add(int u,int v,int w)  //这里以前向星为例
{
    E[++tot].next=head[u];  //head[u]是以u为起点的“第一条”边的序号
    E[tot].to=v;
    E[tot].w=w;
    head[u]=tot;
    return;
}

void spfa(int s)
{
    bool vis[N]={0};
    vis[s]=1;    //vis[i]表示i是否在队列中
    queue<int>q;
    while(!q.empty())q.pop();
    q.push(s);
    FOR(i,1,n)dis[i]=INF;
    dis[s]=0;
    while(!q.empty())
    {
        int u=q.front();q.pop();
        vis[u]=0;
        for(int i=head[u];i!=0;i=E[i].next) //前向星遍历
        {
        	int v=E[i].to,w=E[i].w;
        	if(dis[v]>dis[u]+w)
        	{
        		dis[v]=dis[u]+w;
        		if(!vis[v])
        		{
        		    vis[v]=1;
        		    q.push(v);
                }
            }
        }
    }
    return;
}

int main()
{
    int s;
    scanf("%d%d%d",&n,&m,&s);
    for(int i=1;i<=m;i++)
    {
    	int u,v,w;
    	scanf("%d%d%d",&u,&v,&w);
    	add(u,v,w);
    }
    spfa(s);
    FOR(i,1,n)printf("%d ",dis[i]);
    printf("\n");
    return 0;
}

spfa比较浅显，这里重点介绍前向星。

前向星是一种存图方式，它将起点相同的边互相用next链起（而邻接表是直接将它们存在同一个vector中），每次加入新的边（u,v）都会链上上一条起点为u的边，然后更新起点为u的“第一条”边。

这种存储方式，使得访问边的顺序与输入顺序相反，不过这也没关系。

弗洛伊德算法（Floyd's Algorithm）

弗洛伊德算法是解决多源最短路问题的优秀算法，基于动态规划，此算法的精妙之处在于核心代码只有4-5行

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define DOR(i,x,y) for(int i=(x);i>=(y);i--)
#define N 1003
#define M 500003
#define INF 2147483647
using namespace std;
int n,m;
int dis[N][N];  //此算法用邻接矩阵存边

int main()
{
    int s;
    scanf("%d%d%d",&n,&m,&s);
    FOR(i,1,n)FOR(j,1,n)dis[i][j]=INF;
    FOR(i,1,n)dis[i][i]=0;
    FOR(i,1,m)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        dis[u][v]=min(dis[u][v],w);
    }
    FOR(k,1,n)          //Floyd
        FOR(i,1,n)
            FOR(j,1,n)
            	if(dis[i][k]!=INF && dis[k][j]!=INF)   //这里因为题目需要，事实上如果2INF<MaxInt，这行代码可以省去
            	    dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
    FOR(i,1,n)printf("%d ",dis[s][i]);
    printf("\n"); 
    return 0;
}

弗洛伊德时间复杂度达到O(n³)，当n在100以内时求多源最短路问题可用它很方便的解决。