常见的最短路问题
- 稠密图用邻接矩阵存,稀疏图用邻接表存储。
- 稠密图: m 和 n2 一个级别
- 稀疏图: m 和 n 一个级别
五中最短路算法的直观比较:
1,朴素Dijkstra算法
朴素板的Dijkstra算法适用于仅有正权边的稠密图当中;
#include<iostream>
#include<cstring>
using namespace std;
const int N=510;
int g[N][N],dist[N];//g存储图 d存储每个点到源点的最短距离
bool st[N];//判断此点是否更新过
int n,m;
int dijkstra()
{
memset(dist,0x3f,sizeof dist);//将所有点最短距离初始为最大值
dist[1]=0;//第一个点的距离为0
for(int i=0;i<n;i++)
{
int t=-1;
//遍历每个点,找到最短距离的点
for(int j=1;j<=n;j++)
{
if(!st[j]&&(t==-1||dist[j]<dist[t]))
t=j;
}
st[t]=true;
//更新最短距离
for(int j=1;j<=n;j++)
dist[j]=min(dist[j],dist[t]+g[t][j]);
}
if(dist[n] == 0x3f3f3f3f) return -999;
else return dist[n];
}
int main()
{
cin>>n>>m;
memset(g,0x3f,sizeof g);
for(int i=0;i<m;i++)
{
int a,b,c;
cin>>a>>b>>c;
g[a][b]=min(g[a][b],c);
}
int res=dijkstra();
if(res==-999) cout<<"-1";
else cout<<res;
return 0;
}
2,堆优化版Dijkstra算法
堆优化板的Dijkstra算法适用于仅有正权边的稀疏图;
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int N=200010;
typedef pair<int,int> PII;
int n,m;
int h[N],w[N],e[N],ne[N],d[N],idx;
bool st[N];
void add(int a,int b,int c)
{
e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int dijkstra()
{
memset(d,0x3f,sizeof d);
d[1]=0;
priority_queue<PII,vector<PII>,greater<PII>> heap;//小根堆
heap.push({0,1});
while(heap.size())
{
auto t=heap.top();
heap.pop();
int ver=t.second,distance=t.first;
if(st[ver])
continue;
st[ver]=true;
//遍历所有邻边,更新最短边
for(int i=h[ver];i!=-1;i=ne[i])
{
int j=e[i];
if(d[j]>distance+w[i])
{
d[j]=distance+w[i];
heap.push({d[j],j});
}
}
}
if(d[n] == 0x3f3f3f3f) return -999;
else return d[n];
}
int main()
{
cin>>n>>m;
memset(h,-1,sizeof h);
for(int i=0;i<m;i++)
{
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
}
int res=dijkstra();
if(res==-999) cout<<"-1";
else cout<<res;
return 0;
}
3,Bellman-Ford算法
Bellman-Ford算法适用于存在负权边且有边数限制的最短路问题中;
#include<iostream>
#include<cstring>
using namespace std;
const int N = 510, M = 10010;
struct Edge {
int a;
int b;
int w;
} e[M];//把每个边保存下来即可
int n,m,k;
int d[N],backcup[N];//backcup用来赋值d数组,防止串联
int bellman_ford()
{
memset(d,0x3f,sizeof d);
d[1]=0;
for(int i=0;i<k;i++)
{
memcpy(backcup,d,sizeof d);
for(int j=0;j<m;j++)
{
int a=e[j].a,b=e[j].b,w=e[j].w;
d[b]=min(d[b],backcup[a]+w);
}
}
if(d[n]>0x3f3f3f3f/2) return -999;
else return d[n];
}
int main()
{
cin>>n>>m>>k;
for(int i=0;i<m;i++)
{
int a,b,c;
cin>>a>>b>>c;
e[i]={a,b,c};
}
int res=bellman_ford();
if(res==-999) cout<<"impossible";
else cout<<res;
return 0;
}
4,SPFA算法
spfa算法适用与存在负权边的最短路问题,是bellman-ford算法的优化
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int N=200010;
int n,m;
int h[N],w[N],e[N],ne[N],idx,d[N];
bool st[N];
void add(int a,int b,int c)
{
e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
int spfa()
{
memset(d,0x3f,sizeof d);
d[1]=0;
queue<int> q;
q.push(1);
st[1]=true;
while(q.size())
{
int t=q.front();
q.pop();
st[t]=false;
//遍历所有边,更新最短邻边
for(int i=h[t];i!=-1;i=ne[i])
{
int j=e[i];
if(d[j]>d[t]+w[i])
{
d[j]=d[t]+w[i];
if(!st[j])
{
st[j]=true;
q.push(j);
}
}
}
}
if(d[n]>0x3f3f3f3f/2) return -999;
else return d[n];
}
int main()
{
memset(h,-1,sizeof h);
cin>>n>>m;
for(int i=0;i<m;i++)
{
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
}
int res=spfa();
if(res==-999) cout<<"impossible";
else cout<<res;
return 0;
}
5,Floyd算法
Floyd算法仅适用与求多元汇最短路问题;
#include<iostream>
#include<cstring>
using namespace std;
const int N=210;
int n,m,k;
int d[N][N];
int floyd()
{
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
int main()
{
cin>>n>>m>>k;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(i==j)
d[i][j]=0;
else d[i][j]=0x3f3f3f3f;
for(int i=0;i<m;i++)
{
int a,b,c;
cin>>a>>b>>c;
d[a][b]=min(d[a][b],c);
}
floyd();
while(k--)
{
int x,y;
cin>>x>>y;
if(d[x][y] > 0x3f3f3f3f/2) puts("impossible");
//由于有负权边存在所以约大过INF/2也很合理
else cout << d[x][y] << endl;
}
return 0;
}