NOIP--图论-SPFA算法
一.算法简介
SPFA(Shortest Path Faster Algorithm)算法是求单源最短路径的一种算法，它是Bellman-ford的队列优化，它是一种十分高效的最短路算法。
很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。SPFA的复杂度大约是O(kE),k是每个点的平均进队次数(一般的，k是一个常数，在稀疏图中小于2)。
但是，SPFA算法稳定性较差，在稠密图中SPFA算法时间复杂度会退化。
实现方法：建立一个队列，初始时队列里只有起始点，在建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。
此外，SPFA算法还可以判断图中是否有负权环，即一个点入队次数超过N。
二.算法图解
给定一个有向图，求A~E的最短路。
源点A首先入队，并且AB松弛
扩展与A相连的边，B，C 入队并松弛。
B，C分别开始扩展，D入队并松弛
D出队，E入队并松弛。
E出队，此时队列为空，源点到所有点的最短路已被找到，A->E的最短路即为8
以上就是SPFA算法的过程。
三.算法模板
伪代码
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;
代码
最基本的SPFA
bool Relax(long &w,long m){return m<w?(w=m,1):0;}//"松弛"操作const long maxV=1000,maxE=999000;//最大顶点数,最大边数long m,H[maxV],D[maxV];//m为边数,初始化为0;H为链表头,初始化为-1;D为距离struct Edge{long z,y,w;}E[maxE];//静态邻接表,w为权,y为边终点,z为静态指针void addE(long x,long y,long w){E[m].y=y,E[m].w=w,E[m].z=H[x],H[x]=m++;}//加一条从x指向y,权为w的边#include<cstring>#include<queue>void SPFA(long x=0){//默认计算从0点出发到达其他点的最短路
bool F[maxV]={};//初始为0的bool数组表示在不在队内
std::queue<long>Q;//初始空队列
for(memset(D,0x3f,sizeof(D)),D[x]=0,F[x]=1,Q.push(x);!Q.empty();F[x]=0,Q.pop())//迭代到队列再次变空
for(long i=H[x=Q.front()],y;~i;i=E[i].z)//对于所有与x相邻的边
if(Relax(D[y=E[i].y],E[i].w+D[x])&&!F[y]) F[y]=1,Q.push(y);//如果松弛成功,则要确保y已入队}
SPFA(slf优化)
void Spfa(){
d[S]=0;
v[S]=true;
deque <int> q;
for(q.push_back(S);!q.empty();)
{
int x=q.front();
q.pop_front();
for(int k=head[x];k!=-1;k=el[k].next)
{
int y=el[k].y;
if(d[y]>d[x]+el[k].c)
{
d[y]=d[x]+el[k].c;
if(!v[y])
{
v[y]=true;
if(!q.empty())
{
if(d[y]>d[q.front()])
q.push_back(y);
else
q.push_front(y);
}
else
q.push_back(y);
}
}
}
v[x]=false;
}
return ;}
procedure spfa;begin
fillchar(q,sizeof(q),0); h:=0; t:=0;//队列
fillchar(v,sizeof(v),false);//v[i]判断i是否在队列中
for i:=1 to n do
dist[i]:=maxint;//初始化最小值
inc(t);
q[t]:=1;
v[1]:=true;
dist[1]:=0;//这里把1作为源点 while h<>t do
begin
h:=(h mod n)+1;
x:=q[h];
v[x]:=false; for i:=1 to n do
if (cost[x,i]>0) and (dist[x]+cost[x,i]<dist[i]) then
begin
dist[i]:=dist[x]+cost[x,i]; if not(v[i]) then
begin
t:=(t mod n)+1;
q[t]:=i;
v[i]:=true; end; end; end;end;
void SPFA(void){
int i;
queue list;
list.insert(s);
for(i=1;i<=n;i++)
{
if(s==i)
continue;
dist[i]=map[s][i];
way[i]=s;
if(dist[i])
list.insert(i);
}
int p;
while(!list.empty())
{
p=list.fire();
for(i=1;i<=n;i++)
if(map[p][i]&&(dist[i]>dist[p]+map[p][i]||!dist[i])&&i!=s)
{
dist[i]=dist[p]+map[p][i];
way[i]=p;
if(!list.in(i))
list.insert(i);
}
}}
各种加上了注释
/*
* 单源最短路算法SPFA,时间复杂度O(kE),k在一般情况下不大于2,对于每个顶点使用可以在O(VE)的时间内算出每对节点之间的最短路
* 使用了队列,对于任意在队列中的点连着的点进行松弛,同时将不在队列中的连着的点入队,直到队空则算法结束,最短路求出
* SPFA是Bellman-Ford的优化版,可以处理有负权边的情况
* 对于负环,我们可以证明每个点入队次数不会超过V,所以我们可以记录每个点的入队次数,如果超过V则表示其出现负环,算法结束
* 由于要对点的每一条边进行枚举,故采用邻接表时时间复杂度为O(kE),采用矩阵时时间复杂度为O(kV^2)
*/#include<cstdio>#include<vector>#include<queue>#define MAXV 10000#define INF 1000000000 //此处建议不要过大或过小,过大易导致运算时溢出,过小可能会被判定为真正的距离 using std::vector;using std::queue; struct Edge{
int v; //边权
int to; //连接的点};
vector<Edge> e[MAXV]; //由于一般情况下E<<V*V,故在此选用了vector动态数组存储,也可以使用链表存储int dist[MAXV]; //存储到原点0的距离,可以开二维数组存储每对节点之间的距离int cnt[MAXV]; //记录入队次数,超过V则退出queue<int> buff; //队列,用于存储在SPFA算法中的需要松弛的节点bool done[MAXV]; //用于判断该节点是否已经在队列中int V; //节点数int E; //边数 bool spfa(const int st){ //返回值:TRUE为找到最短路返回,FALSE表示出现负环退出
for(int i=0;i<V;i++){ //初始化:将除了原点st的距离外的所有点到st的距离均赋上一个极大值
if(i==st){
dist[st]=0; //原点距离为0;
continue;
}
dist[i]=INF; //非原点距离无穷大
}
buff.push(st); //原点入队
done[st]=1; //标记原点已经入队
cnt[st]=1; //修改入队次数为1
while(!buff.empty()){ //队列非空,需要继续松弛
int tmp=buff.front(); //取出队首元素
for(int i=0;i<(int)e[tmp].size();i++){ //枚举该边连接的每一条边
Edge *t=&e[tmp][i]; //由于vector的寻址速度较慢,故在此进行一次优化
if(dist[tmp]+(*t).v<dist[(*t).to]){ //更改后距离更短,进行松弛操作
dist[(*t).to]=dist[tmp]+(*t).v; //更改边权值
if(!done[(*t).to]){ //没有入队,则将其入队
buff.push((*t).to); //将节点压入队列
done[(*t).to]=1; //标记节点已经入队
cnt[(*t).to]+=1; //节点入队次数自增
if(cnt[(*t).to]>V)