NOIP--圖論-SPFA演算法
阿新 • • 發佈：2020-11-05
一.演算法簡介
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){