关于最短路的几个算法

关于最短路的几个算法有Dijkstra，Bellman-Ford，Floyd

Dijkstra：

Dijkstra适用于边权为正的情况，从单个源点出发，到其他所有结点的最短路

算法的核心是用已经知道的结点 i 的距离 d[i] 去更新和这个结点相连的其他结点的距离

struct node
{
int d,u; //d是距离,u是另一个结点的编号
bool operator<(const node A) const
{
return d>A.d;
}
};
struct Dijkstra
{
int n,m;  //点数和边数
vector<Edge> edges;  //边列表
vector<int> G[MAXN];  //每个结点出发的边编号（从0开始编号）
int vis[MAXN];  //判断点是否被访问
int d[MAXN];  //s到各个点的距离
int p[MAXN];  //最短路上的一条边

void init(int n)
{
this->=n;
for(int i=0;i<n;i++) G[i].clear();  //清空邻接表
edges.clear();  //清空边表
}

void  AddEdge(int from,int to,int dist)  //如果是无向边需调用两次AddEdge
{
edges.push_back((Edge){from,to,dist});
m=edges.size();
G[from].push_back(m-1);
}
};
void dijkstra(int s)  //求s到所有点的距离
{
priority_queue<node> Q;
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;i++)
d[i]=INF;
d[s]=0;
node start;
start.d=0,start.u=s;
Q.push(start);
while(!Q.empty())
{
node x=Q.top;Q.pop();
int u=x.u;
if(vis[u]) continue;
vis[u]=1;
for(itn i=0;i<G[u].size();i++)
{
Edge& e=edges[G[u][i]];
if(d[e.to]>d[u]+e.dis)
{
node next;
d[e.to]=d[u]+e.dis;
p[e.to]=G[u][i];
next.d=d[e.to];
next.u=e.to;
Q.push(next);
}
}
}
}

其核心思想还是没有变，依旧是用已经知道的点去更新起点s到其他点的距离，用优先队列，优先级最大的是距离最小的点，然后用这个点去更新其他点

最坏的情况下仍然会循环n-1次，但是从整体上看，每条边恰好被检查过一次，所以松弛操作的执行次数恰好是m次，这样只用找未被访问的d的最小值即可

可以说即使是稠密图，用了priority_queue还是会比用邻接矩阵的Dijstra算法快，因为不满足d[e.to]>d[u]+e.dis是不能入队的，所有push操作会很少

Bellman-Ford:

Bellman-Ford也是一个求最短路的算法，这个算法用于算最短路的时候，如果最短路存在，那么一定是一个不含环的最短路，那么这个算法还有一个用处就是判环，

如果存在负环的话，那么便不会存在最短路（因为会不断松弛下去）

如果不含环的话，那么最多便通过n-1个结点（不包含起点），通过n-1“轮”松弛操作便可以计算出最短路

算法核心就是通过循环n-1次，每次对所有的边进行松弛操作边去更新结点距离

for(int i=1;i<=n;i++)
d[i]=INF;
d[0]=0;
for(int i=0;i<n-1;i++)  //迭代n-1次
{
for(int j=0;j<m;j++)  //检查每一条边
{
int x=u[i],y=v[i];
if(d[x]<INF)
{
d[y]=min(d[y],d[x]+w[i]);  //松弛操作
}
}
}

这个代码很明显没有进行负环的判定，复杂度是O(nm)

可以用FIFO队列进行优化，可以进行循环检查

struct Edge
{
int from,to,dis;
Edge(int u,int v,int d):from(u),to(v),dis(d) {}
};
vector<Edge> edges;
vector<int> G[MAXN];
int vis[MAXN];  //判断结点是否被访问
int p[MAXN];  //最短路上的一条弧
int d[MAXN]; //起点s到各点的距离

bool Bellman-Ford(int s)
{
queue<int> Q;
memset(inq,0,sizeof(inq));
memset(cnt,0,sizeof(cnt));
for(int i=0;i<n;i++)
d[i]=INF;
d[s]=0;
inq[s]=true;
Q.push(s);

while(!Q.empty())
{
int u=Q.front();Q.pop();
inq[u]=false;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges(G[u][i]);
if(d[u]<INF && d[e.to]>d[u]+e.dis) //松弛
{
d[e.to]=d[u]+e.dis;
p[e.to]=G[u][i];
if(!inq[e.to])
{
Q.push(e.to);
inq[e.to]=true;
if(++cnt[e.to]>n) return false;  //如果一个点入队大于n次，那么一定存在负环
}
}
}
return true;
}
}

用队列优化的Bellman-Ford也叫SPFA（Shortest Path Faster Algorithm）

下面讨论下SPFA

先转载这两篇，觉得写的不错，以后慢慢填坑

/article/2251042.html

/article/2250172.html