Bellman-Ford算法
Bellman-Ford算法用来计算单源最短路。该算法可以处理边权为负的情况,同时可以判断图中是否有负权环。
松弛一条边(u,v)即判断能否通过u对v的最短路径进行改进,如果可以,则更新d[v]。
松弛操作:d[v]>d[u]+w(u,v) → d[v]=d[u]+w(u,v) 。其中w(u,v)表示边(u,v)的权值。
松弛操作在没有负权环的情况下最多进行|V|-1轮。也就是说,若完成|v|-1轮松弛操作后还能进行松弛操作,那么图中有负权环。
复杂度:O(|V||E|)
struct edge{ int from, to, cost; };
edge es[MAX_E]; //边
int d[MAX_V]; //最短距离
int V, E; //V是顶点数, E是边数
void bellman_ford(int s)
{
fill(d, d + V, INF);
d[s] = 0;
while(true)
{
bool update = false;
for(int i = 0; i < E; i++)
{
edge e = es[i];
if(d[e.from] != INF && d[e.to] > d[e.from] + e.cost)
{
d[e.to] = d[e.from]+e.cost;
update = true;
}
}
if(!update) break;
}
}
SPFA算法
SPFA是Bellman-Ford的队列优化。
Bellman-Ford算法每轮都遍历所有的边试图进行松弛操作,而实际上并不是所有的边都能够进行松弛操作。
SPFA算法通过建立一个队列来保持待优化的顶点,只有当到某个顶点的最短距离缩短后,才用连接该顶点的边对另一端点进行松弛操作。
复杂度:最坏情况O(|V||E|)
struct edge{ int to, cost; };
vector<edge> G[MAX_V];
int d[MAX_V];
bool inQue[MAX_V];
void spfa(int s)
{
queue<int> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(s);
inQue[s] = true;
while(!que.empty())
{
int u = que.front(); que.pop();
for(int i = 0; i < G[u].size(); i++)
{
edge e = G[u][i];
if(d[e.to] > d[u] + e.cost)
{
d[e.to] = d[u] + e.cost;
if(!inQue[e.to])
{
inQue[e.to] = true;
que.push(e.to);
}
}
}
inQue[u] = false;
}
}
Dijkstra算法
在Bellman-Ford算法中,如果d[u]还不是最短距离的话,那么即使对d[v]进行d[v]>d[u]+w(u,v) → d[v]=d[u]+w(u,v)的更新,d[v]也不会变成最短距离。因此Dijkstra算法做了如下修改:
- 找到最短距离已经确定的顶点,从它出发更新相邻顶点的最短距离。
- 此后不再需要关心1中的“最短距离已经确定的顶点”。
代码实现:
int cost[MAX_V][MAX_V]; //邻接矩阵
int d[MAX_V]; //最短距离
bool used[MAX_V]; //已经使用过的顶点
int V; //顶点数
void dijkstra(int s)
{
fill(d, d + V, INF);
fill(used , used + V, false);
d[s] = 0;
while(true)
{
int v = -1;
//从未使用过的顶点中选一个距离最小的顶点
for(int i = 0; i < V; i++)
if(!used[i] && (v == -1 || d[i] < d[v])) v = i;
if(v == -1) break;
used[v] = true;
for(int i = 0; i < V; i++)
d[i] = min(d[i], d[v] + cost[v][i]);
}
}
Dijkstra算法(优先队列优化)
每次查找距离最小的顶点的操作可以用堆来实现。把每个顶点当前的最短距离用堆维护,这样每次从堆中取出的最小值就是下一次要使用的顶点。
复杂度:O(|E|log|V|)
使用优先队列的实现:
struct edge { int to, cost; };
typedef pair<int, int> P;
int d[MAX_V];
vector<edge> G[MAX_V];
int V;
void dijkstra(int s)
{
priority_queue<P, vector<P>, greater<P> > que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while(!que.empty())
{
P p = que.top(); que.pop();
int v = p.second;
if(d[v] < p.first) continue;
for(int i = 0; i < G[v].size(); i++)
{
edge e = G[v][i];
if(d[e.to] > d[v] + e.cost)
{
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
当所有边的权值相等时,比如网格图上求最短路,可以使用BFS。这种情况下优先队列的效果等同于普通队列,最先出队的一定是最短距离的点。
另外,优先队列优化的Dijkstra和SPFA样子有点像,把二者对比一下可以看出:前者每个顶点只出队一次且最短距离已经确定,后者不一定;前者队列中可能有多个相同顶点(但参与排序的权值不同),后者队列中顶点唯一。
Floyd算法
Floyd算法是用来求解带权图中的多源最短路问题。算法的原理是动态规划。
d[i][j]为从i到j的最短距离,如果从i到j以k为中间点距离更短,则更新d[i][j]。
复杂度:O(N³)
void 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]);
}