SPFA算法
SPFA算法
SPFA（Shortest Path Faster Algorithm）（队列优化）算法是求单源 最短路径的一种算法，在 Bellman-ford算法的基础上加上一个队列优化，减少了冗余的 松弛操作，是一种高效的最短路算法。
简 称
SPFA
全 称
Shortest Path Faster Algorithm
提出者
段凡丁
目录
1SPFA原理
最短路问题
证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。
期望的 时间复杂度：O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。
对SPFA的一个很直观的理解就是由无权图的 BFS转化而来。在无权图中，BFS首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数)，所以此时利用数组记录节点访问可以使每个顶点只进队一次，但在带权图中，最先到达的顶点所计算出来的路径不一定是最短路。一个解决方法是放弃数组，此时所需时间自然就是指数级的，所以我们不能放弃数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解。
（“算法编程后实际运算情况表明m一般没有超过2n.事实上顶点入队次数m是一个不容易事先分析出来的数,但它确是一个随图的不同而略有不同的常数.所谓常数,就是与e无关,与n也无关,仅与边的权值分布有关.一旦图确定,权值确定,原点确定,m就是一个确定的常数.所以SPFA算法复杂度为O(e)(证毕）"
[1] ——SPFA的论文
但事实上这个证明是非常不严谨甚至错误的，事实上在 bellman算法的论文中已有这方面的内容，所以国际上一般不承认SPFA算法）
SPFA算法有两个优化算法 SLF 和 LLL： SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出队进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的 Dijkstra算法。
2伪代码
SPFA实际上是Bellman-Ford基础上的队列优化
一种伪代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
Procedure SPFA;
Begin
initialize-single-source(G,s);
initialize-queue(Q);
enqueue(Q,s);
while
not empty(Q)
do
begin
u:=dequeue(Q);
for
each v∈adj[u]
do
begin
tmp:=d[v];
relax(u,v);
if
(tmp<>d[v]) and (not v in Q) then
enqueue(Q,v);
end;
end;
End;
|
一种更容易读懂的伪代码:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
ProcedureSPFA;
Begin
initialize-
single
-source(G,s);
initialize-queue(Q);
enqueue(Q,s);
while
not
empty(Q)
do
begin
u:=dequeue(Q);
for
each v∈adj[u]
do
begin
tmp:=d[v];
relax(u,v);
if
(tmp<>d[v])
and
(
not
v
in
Q)
then
enqueue(Q,v);
end
;
end
;
End
;
|
3C++代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
#include <iostream>
#include <deque>
#include <stack>
#include <vector>
using
namespace
std;
const
int
MAXN=100;
const
int
INF=0x7FFFFFFF;
struct
edge
{
int
to,weight;
};
vector<edge> adjmap[MAXN];
//邻接表
bool
in_queue[MAXN];
//顶点是否在队列中
int
in_sum[MAXN];
//顶点入队次数
int
dist[MAXN];
//源点到各点的最短路径
int
path[MAXN];
//存储到达i的前一个顶点
int
nodesum;
//顶点数
int
edgesum;
//边数
bool
SPFA(
int
source)
{
deque<
int
> dq;
int
i,j,x,to;
for
(i=1;i<=nodesum;i++)
{
in_sum[i]=0;
in_queue[i]=
false
;
dist[i]=INF;
path[i]=-1;
}
dq.push_back(source);
in_sum[source]++;
dist[source]=0;
in_queue[source]=
true
;
//初始化完成
while
(!dq.empty())
{
x=dq.front();
dq.pop_front();
in_queue[x]=
false
;
for
(i=0;i<adjmap[x].size();i++)
{
to=adjmap[x][i].to;
if
((dist[x]<INF)&&(dist[to]>dist[x]+adjmap[x][i].weight))
{
dist[to]=dist[x]+adjmap[x][i].weight;
path[to]=x;
if
(!in_queue[to])
{
in_queue[to]=
true
;
in_sum[to]++;
if
(in_sum[to]==nodesum)
return
false
;
if
(!dq.empty())
{
if
(dist[to]>dist[dq.front()]) dq.push_back(to);
else
dq.push_front(to);
}
else
dq.push_back(to);
}
}
}
}
return
true
;
}
void
Print_Path(
int
x)
{
stack<
int
> s;
int
w=x;
while
(path[w]!=-1)
{
s.push(w);
w=path[w];
}
cout<<
"顶点1到顶点"
<<x<<
"的最短路径长度为："
<<dist[x]<<endl;
cout<<
"所经过的路径为：1"
;
while
(!s.empty())
{
cout<<s.top()<<
""
;
s.pop();
}
cout<<endl;
}
int
main()
{
int
i,s,e,w;
edge temp;
cout<<
"输入顶点数和边数："
;
cin>>nodesum>>edgesum;
for
(i=1;i<=nodesum;i++)
adjmap[i].clear();
//清空邻接表
for
(i=1;i<=edgesum;i++)
{
cout<<
"输入第"
<<i<<
"条边的起点、终点还有对应的权值："
;
cin>>s>>e>>w;
temp.to=e;
temp.weight=w;
adjmap[s].push_back(temp);
}
if
(SPFA(1))
{
for
(i=2;i<=nodesum;i++) Print_Path(i);
}
else
cout<<
"图中存在负权回路"
<<endl;
return
0;
}
|