最短路模板整理（Dijkstra+Bellman-ford+spfa+Floyd）

最短路问题总览

一、单源最短路

1.所有边权都是正数

（1）朴素dijkstra算法 （时间复杂度：O（n^2）)

（2）堆优化版dijkstra算法（时间复杂度：O(mlogn）)

2.存在负权边

（1）Bellman-ford算法（时间复杂度：O（nm）)

（2）SPFA（时间复杂度：一般O(m），最坏O(nm) )

二、多源最短路

----- Floyd算法（O(n^3)）

---

---

注：上图来自Acwing，上面的n代表点数，m代表边数

1.朴素版dijkstra

#include<iostream>
#include<cstring>
using namespace std;
#define inf 0x3f3f3f3f
const int N =510;
int n,m;
int mp[N][N];
int dis[N];
int vis[N];
int dijkstra()
{
    memset(dis,inf,sizeof(dis));
    dis[1]=0;
    for(int k=1;k<n;k++)
    {
        int mint=inf,v;
        for(int i=1;i<=n;i++)
            if(mint>dis[i]&&!vis[i])
            {
                mint=dis[i];v=i;
            }
        vis[v]=1;
        for(int i=1;i<=n;i++)
            dis[i]=min(dis[i],dis[v]+mp[v][i]);
    }
    if(dis[n]==inf)
        return -1;
    return dis[n];
}
int main()
{
    cin>>n>>m;
    memset(mp,inf,sizeof mp);
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        mp[a][b]=min(mp[a][b],c);
    }
    int ans=dijkstra();
    cout<<ans<<endl;
    return 0;
}

---

---

2.堆优化版dijkstra算法

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
typedef pair<int,int> pa;
int n,m;
const int N = 1e5+10;
int e[N],h[N],w[N],ne[N],idx;
int vis[N];
int dis[N];
void init()
{
    idx=0;
    memset(h,-1,sizeof h);
}
void add(int a,int b,int c)
{
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}
int dijkstra()
{
    memset(dis,inf,sizeof dis);
    memset(vis,0,sizeof vis);
    dis[1]=0;
    priority_queue<pa,vector<pa>,greater<pa> > heap;
    heap.push({0,1});
    while(heap.size())
    {
        pa t=heap.top();
        heap.pop();
        int x=t.second,distance=t.first;
        if(vis[x])
            continue;
        vis[x]=1;
        for(int i=h[x];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dis[j]>distance+w[i])
            {
                dis[j]=distance+w[i];
                heap.push({dis[j],j});
            }
        }
    }
    if(dis[n]==inf)
        return -1;
    return dis[n]; 
}
int main()
{
    init();
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    cout<<dijkstra()<<endl;
    return 0;
}

---

---

3.Bellman-ford算法

#include<iostream>
#include<cstring>
using namespace std;
#define inf 0x3f3f3f3f
const int N = 1e4+10;
struct edge
{
    int a,b,c;
}edges[N];
int n,m,k;
int dis[N],tem[N];
int bellman_ford()
{
    memset(dis,inf,sizeof dis);
    dis[1]=0;
    for(int i=1;i<=k;i++)
    {
        memcpy(tem,dis,sizeof dis);   //每次要存一下原来的状态，防止串联
        for(int j=0;j<m;j++)
        {
            auto t=edges[j];
            dis[t.b]=min(dis[t.b],tem[t.a]+t.c);
        }
    }
    if(dis[n]>inf/2)
        return -1;
    return dis[n];
}
int main()
{
    cin>>n>>m>>k;
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        edges[i]={a,b,c};
    }
    int ans=bellman_ford();
    if(ans==-1)
        printf("impossible\n");
    else
        cout<<ans<<endl;
    return 0;
}

4.SPFA算法

#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3f
int n,m;
const int N = 1e5+10;
int h[N],e[N],ne[N],w[N],idx;
int dis[N],vis[N];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
    memset(dis,inf,sizeof dis);
    dis[1]=0;
    queue<int> q;
    q.push(1);
    vis[1]=1;
    while(q.size())
    {
        int x=q.front();q.pop();
        vis[x]=0;
        for(int i=h[x];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dis[j]>dis[x]+w[i])
            {
                dis[j]=dis[x]+w[i];
                if(!vis[j])
                {
                    q.push(j);vis[j]=1;
                }
            }
        }
    }
    if(dis[n]==inf)
        return -1;
    return dis[n];
}
int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int ans=spfa();
    if(ans==-1)
        printf("impossible\n");
    else
        cout<<ans<<endl;
    return 0;
}

---

---

5.Floyd算法

#include<iostream>
#include<cstring>
using namespace std;
const int inf=0x3f3f3f3f;
int n,m,k;
int dis[205][205];
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]);
    }
}
int main()
{
    cin>>n>>m>>k;
    memset(dis,inf,sizeof dis);
    for(int i=1;i<=n;i++)
        dis[i][i]=0;
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        dis[a][b]=min(dis[a][b],c);
    }
    Floyd();
    for(int i=0;i<k;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if(dis[a][b]> inf/2)
            printf("impossible\n");
        else
            printf("%d\n",dis[a][b]);
    }
    return 0;
}