適用范圍:給定的圖存在負(fù)權(quán)邊,這時類似Dijkstra等算法便沒有了用武之地,而Bellman-Ford算法的復(fù)雜度又過高,SPFA算法便派上用場了。 我們約定有向加權(quán)圖G不存在負(fù)權(quán)回路,即最短路徑一定存在。當(dāng)然,我們可以在執(zhí)行該算法前做一次拓?fù)渑判?,以判斷是否存在?fù)權(quán)回路,但這不是我們討論的重點。
算法思想:我們用數(shù)組d記錄每個結(jié)點的最短路徑估計值,用鄰接表來存儲圖G。我們采取的方法是動態(tài)逼近法:設(shè)立一個先進(jìn)先出的隊列用來保存待優(yōu)化的結(jié)點,優(yōu)化時每次取出隊首結(jié)點u,并且用u點當(dāng)前的最短路徑估計值對離開u點所指向的結(jié)點v進(jìn)行松弛操作,如果v點的最短路徑估計值有所調(diào)整,且v點不在當(dāng)前的隊列中,就將v點放入隊尾。這樣不斷從隊列中取出結(jié)點來進(jìn)行松弛操作,直至隊列空為止
期望的時間復(fù)雜度O(ke), 其中k為所有頂點進(jìn)隊的平均次數(shù),可以證明k一般小于等于2。
實現(xiàn)方法:
建立一個隊列,初始時隊列里只有起始點,再建立一個表格記錄起始點到所有點的最短路徑(該表格的初始值要賦為極大值,該點到他本身的路徑賦為0)。然后執(zhí)行松弛操作,用隊列里有的點作為起始點去刷新到所有點的最短路,如果刷新成功且被刷新點不在隊列中則把該點加入到隊列最后。重復(fù)執(zhí)行直到隊列為空。
判斷有無負(fù)環(huán):
如果某個點進(jìn)入隊列的次數(shù)超過N次則存在負(fù)環(huán)(SPFA無法處理帶負(fù)環(huán)的圖)

首先建立起始點a到其余各點的
最短路徑表格

首先源點a入隊,當(dāng)隊列非空時:
1、隊首元素(a)出隊,對以a為起始點的所有邊的終點依次進(jìn)行松弛操作(此處有b,c,d三個點),此時路徑表格狀態(tài)為:

在松弛時三個點的最短路徑估值變小了,而這些點隊列中都沒有出現(xiàn),這些點
需要入隊,此時,隊列中新入隊了三個結(jié)點b,c,d
隊首元素b點出隊,對以b為起始點的所有邊的終點依次進(jìn)行松弛操作(此處只有e點),此時路徑表格狀態(tài)為:

在最短路徑表中,e的最短路徑估值也變小了,e在隊列中不存在,因此e也要
入隊,此時隊列中的元素為c,d,e
隊首元素c點出隊,對以c為起始點的所有邊的終點依次進(jìn)行松弛操作(此處有e,f兩個點),此時路徑表格狀態(tài)為:

在最短路徑表中,e,f的最短路徑估值變小了,e在隊列中存在,f不存在。因此
e不用入隊了,f要入隊,此時隊列中的元素為d,e,f
隊首元素d點出隊,對以d為起始點的所有邊的終點依次進(jìn)行松弛操作(此處只有g(shù)這個點),此時路徑表格狀態(tài)為:

在最短路徑表中,g的最短路徑估值沒有變?。ㄋ沙诓怀晒Γ?,沒有新結(jié)點入隊,隊列中元素為f,g
隊首元素f點出隊,對以f為起始點的所有邊的終點依次進(jìn)行松弛操作(此處有d,e,g三個點),此時路徑表格狀態(tài)為:

在最短路徑表中,e,g的最短路徑估值又變小,隊列中無e點,e入隊,隊列中存在g這個點,g不用入隊,此時隊列中元素為g,e
隊首元素g點出隊,對以g為起始點的所有邊的終點依次進(jìn)行松弛操作(此處只有b點),此時路徑表格狀態(tài)為:

在最短路徑表中,b的最短路徑估值又變小,隊列中無b點,b入隊,此時隊列中元素為e,b
隊首元素e點出隊,對以e為起始點的所有邊的終點依次進(jìn)行松弛操作(此處只有g(shù)這個點),此時路徑表格狀態(tài)為:

在最短路徑表中,g的最短路徑估值沒變化(松弛不成功),此時隊列中元素為b
隊首元素b點出隊,對以b為起始點的所有邊的終點依次進(jìn)行松弛操作(此處只有e這個點),此時路徑表格狀態(tài)為:

在最短路徑表中,e的最短路徑估值沒變化(松弛不成功),此時隊列為空了
最終a到g的最短路徑為14
program:
#include<cstdio>
using namespace std;
struct node
{int x;
int value;
int next;
};
node e[60000];
int visited[1505],dis[1505],st[1505],queue[1000];
int main()
{
int n,m,u,v,w,start,h,r,cur;
freopen("c.in","r",stdin);
freopen("c.out","w",stdout);
while(scanf("%d%d",&n,&m)!=EOF)
{
for(int i=1;i<=1500;i++)
{visited[i]=0;
dis[i]=-1;
st[i]=-1; //這個初始化給下邊那個while循環(huán)帶來影響
}
for(int i=1;i<=m;i++)
{
scanf("%d%d%d\n",&u,&v,&w);
e[i].x=v; //記錄后繼節(jié)點 相當(dāng)于鏈表中的創(chuàng)建一個節(jié)點,并使得數(shù)據(jù)域先記錄
e[i].value=w;
e[i].next=st[u]; //記錄頂點節(jié)點的某一個邊表節(jié)點的下標(biāo),相當(dāng)于在鏈表中吧該邊表節(jié)點的next指針先指向他的后繼邊表節(jié)點
st[u]=i; //把該頂點的指針指向邊表節(jié)點,相當(dāng)于鏈表中的插入中,頭結(jié)點的指針改變
}
start=1;
visited[start]=1;
dis[start]=0;
h=0;
r=1;
queue[r]=start;
while(h!=r)
{
h=(h+1)%1000;
cur=queue[h];
int tmp=st[cur];
visited[cur]=0;
while(tmp!=-1)
{
if (dis[e[tmp].x]<dis[cur]+e[tmp].value) //改成大于號才對
{
dis[e[tmp].x]=dis[cur]+e[tmp].value;
if(visited[e[tmp].x]==0)
{
visited[e[tmp].x]=1;
r=(r+1)%1000;
queue[r]=e[tmp].x;
}
}
tmp=e[tmp].next;
}
}
printf("%d\n",dis[n]);
}
return 0;
}
(沒有質(zhì)量,就出數(shù)量) 下面一文轉(zhuǎn)載出處:http://blog.csdn.net/morgan_xww/article/details/6279596
- /*
- SPFA(Shortest Path Faster Algorithm) [圖的存儲方式為鄰接表]
- 是Bellman-Ford算法的一種隊列實現(xiàn),減少了不必要的冗余計算。
- 算法大致流程是用一個隊列來進(jìn)行維護(hù)。 初始時將源加入隊列。 每次從隊列中取出一個元素,
- 并對所有與他相鄰的點進(jìn)行松弛,若某個相鄰的點松弛成功,則將其入隊。 直到隊列為空時算法結(jié)束。
- 它可以在O(kE)的時間復(fù)雜度內(nèi)求出源點到其他所有點的最短路徑,可以處理負(fù)邊。
- SPFA 在形式上和BFS非常類似,不同的是BFS中一個點出了隊列就不可能重新進(jìn)入隊列,但是SPFA中
- 一個點可能在出隊列之后再次被放入隊列,也就是一個點改進(jìn)過其它的點之后,過了一段時間可能本
- 身被改進(jìn),于是再次用來改進(jìn)其它的點,這樣反復(fù)迭代下去。
- 判斷有無負(fù)環(huán):如果某個點進(jìn)入隊列的次數(shù)超過V次則存在負(fù)環(huán)(SPFA無法處理帶負(fù)環(huán)的圖)。
- SPFA算法有兩個優(yōu)化算法 SLF 和 LLL:
- SLF:Small Label First 策略,設(shè)要加入的節(jié)點是j,隊首元素為i,若dist(j)<dist(i),則將j插入隊首,
- 否則插入隊尾。
- LLL:Large Label Last 策略,設(shè)隊首元素為i,隊列中所有dist值的平均值為x,若dist(i)>x則將i插入
- 到隊尾,查找下一元素,直到找到某一i使得dist(i)<=x,則將i出對進(jìn)行松弛操作。
- 引用網(wǎng)上資料,SLF 可使速度提高 15 ~ 20%;SLF + LLL 可提高約 50%。
- 在實際的應(yīng)用中SPFA的算法時間效率不是很穩(wěn)定,為了避免最壞情況的出現(xiàn),通常使用效率更加穩(wěn)定的Dijkstra算法。
- */
-
- //用數(shù)組實現(xiàn)鄰接表存儲,pnt[i,0]表示與i相鄰的結(jié)點個數(shù),pnt[i,1...k]存儲與i相鄰的點
- int pnt[MAXN][MAXN];
- int map[MAXN][MAXN];
//map[i,j]為初始輸入的i到j(luò)的距離,并且map[i,i]=0;未知的map[i,j]=INF;
- int dis[MAXN];
- char vst[MAXN];
-
- int SPFA(int n,int s)
- {
- int i, pri, end, p, t;
- memset(vst, 0, sizeof(vst));
- for (i=1; i<=n; i++)
- dis[i] = INF;
- dis[s] = 0;
- vst[s] = 1;
- Q[0] = s; pri = 0; end = 1;
- while (pri < end)
- {
- p = Q[pri];
- for (i=1; i<=pnt[p][0]; i++)
- {
- t = pnt[p][i];
- //先釋放,釋放成功后再判斷是否要加入隊列
- if (dis[p]+map[p][t] < dis[t])
- {
- dis[t] = dis[p]+map[p][t];
- if (!vst[t])
- {
- Q[end++] = t;
- vst[t] = 1;
- }
- }
- }
- vst[p] = 0;
- pri++;
- }
- return 1;
- }
- /*
- SPFA(Shortest Path Faster Algorithm) [圖的存儲方式為鄰接表]
- 是Bellman-Ford算法的一種隊列實現(xiàn),減少了不必要的冗余計算。
- 算法大致流程是用一個隊列來進(jìn)行維護(hù)。 初始時將源加入隊列。 每次從隊列中取出一個元素,
- 并對所有與他相鄰的點進(jìn)行松弛,若某個相鄰的點松弛成功,則將其入隊。 直到隊列為空時算法結(jié)束。
- 它可以在O(kE)的時間復(fù)雜度內(nèi)求出源點到其他所有點的最短路徑,可以處理負(fù)邊。
-
- SPFA 在形式上和BFS非常類似,不同的是BFS中一個點出了隊列就不可能重新進(jìn)入隊列,但是SPFA中
- 一個點可能在出隊列之后再次被放入隊列,也就是一個點改進(jìn)過其它的點之后,過了一段時間可能本
- 身被改進(jìn),于是再次用來改進(jìn)其它的點,這樣反復(fù)迭代下去。
-
- 判斷有無負(fù)環(huán):如果某個點進(jìn)入隊列的次數(shù)超過V次則存在負(fù)環(huán)(SPFA無法處理帶負(fù)環(huán)的圖)。
-
- SPFA算法有兩個優(yōu)化算法 SLF 和 LLL:
- SLF:Small Label First 策略,設(shè)要加入的節(jié)點是j,隊首元素為i,若dist(j)<dist(i),則將j插入隊首,
- 否則插入隊尾。
- LLL:Large Label Last 策略,設(shè)隊首元素為i,隊列中所有dist值的平均值為x,若dist(i)>x則將i插入
- 到隊尾,查找下一元素,直到找到某一i使得dist(i)<=x,則將i出對進(jìn)行松弛操作。
- 引用網(wǎng)上資料,SLF 可使速度提高 15 ~ 20%;SLF + LLL 可提高約 50%。
- 在實際的應(yīng)用中SPFA的算法時間效率不是很穩(wěn)定,為了避免最壞情況的出現(xiàn),通常使用效率更加穩(wěn)定的Dijkstra算法。
- */
-
- //用數(shù)組實現(xiàn)鄰接表存儲,pnt[i,0]表示與i相鄰的結(jié)點個數(shù),pnt[i,1...k]存儲與i相鄰的點
- int pnt[MAXN][MAXN];
- int map[MAXN][MAXN]; //map[i,j]為初始輸入的i到j(luò)的距離,并且map[i,i]=0;未知的map[i,j]=INF;
- int dis[MAXN];
- char vst[MAXN];
-
- int SPFA(int n, int s)
- {
- int i, pri, end, p, t;
- memset(vst, 0, sizeof(vst));
- for (i=1; i<=n; i++)
- dis[i] = INF;
- dis[s] = 0;
- vst[s] = 1;
- Q[0] = s; pri = 0; end = 1;
- while (pri < end)
- {
- p = Q[pri];
- for (i=1; i<=pnt[p][0]; i++)
- {
- t = pnt[p][i];
- //先釋放,釋放成功后再判斷是否要加入隊列
- if (dis[p]+map[p][t] < dis[t])
- {
- dis[t] = dis[p]+map[p][t];
- if (!vst[t])
- {
- Q[end++] = t;
- vst[t] = 1;
- }
- }
- }
- vst[p] = 0;
- pri++;
- }
- return 1;
- }
- 正規(guī)鄰接表存儲:
- /* ------- 鄰接表存儲 ----------- */
- struct Edge
- {
- int e; //終點
- int v; //邊權(quán)
- struct Edge *nxt;
- };
- struct
- {
- struct Edge *head, *last;
- } node[MAXN];
- /* -------------------------------- */
-
- /* 添加有向邊<起點,終點,邊權(quán)> */
- void add(int s,int e,int v)
- {
- struct Edge *p;
- p = (struct Edge*)malloc(sizeof(struct Edge));
- p->e = e;
- p->v = v;
- p->nxt = NULL;
- if (node[s].head == NULL)
- {
- node[s].head = p;
- node[s].last = p;
- }
- else
- {
- node[s].last->nxt = p;
- node[s].last = p;
- }
- }
-
- /* 松弛,成功返回1,否則0 */
- int relax(int s,int e,int v)
- {
- if (dis[s]+v < dis[e])
- {
- dis[e] = dis[s]+v;
- return 1;
- }
- return 0;
- }
-
- /* SPFA有負(fù)權(quán)回路返回0,否則返回1并且最短路徑保存在dis[] */
- int n;
- int vst[MAXN], cnt[MAXN];
- int Q[MAXN*MAXN];
- int SPFA(int s0)
- {
- int i, p, q;
- struct Edge *pp;
-
- memset(vst, 0, sizeof(vst));
- memset(cnt, 0, sizeof(cnt));
- for (i=0; i<=n; i++)
- dis[i] = INF;
- dis[s0] = 0;
-
- Q[0] = s0; p = 0; q = 1;
- vst[s0] = 1;
- cnt[s0]++;
- while (p < q)
- {
- pp = node[Q[p]].head;
- while (pp)
- {
- if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])
- {
- Q[q++] = pp->e;
- vst[pp->e] = 1;
- cnt[pp->e]++;
- if (cnt[pp->e] > n)
//有負(fù)權(quán)回路
- return 0;
- }
- pp = pp->nxt;
- }
- vst[Q[p]] = 0;
- p++;
- }
- return 1;
- }
- 正規(guī)鄰接表存儲:
- /* ------- 鄰接表存儲 ----------- */
- struct Edge
- {
- int e; //終點
- int v; //邊權(quán)
- struct Edge *nxt;
- };
- struct
- {
- struct Edge *head, *last;
- } node[MAXN];
- /* -------------------------------- */
-
- /* 添加有向邊<起點,終點,邊權(quán)> */
- void add(int s, int e, int v)
- {
- struct Edge *p;
- p = (struct Edge*)malloc(sizeof(struct Edge));
- p->e = e;
- p->v = v;
- p->nxt = NULL;
- if (node[s].head == NULL)
- {
- node[s].head = p;
- node[s].last = p;
- }
- else
- {
- node[s].last->nxt = p;
- node[s].last = p;
- }
- }
-
- /* 松弛,成功返回1,否則0 */
- int relax(int s, int e, int v)
- {
- if (dis[s]+v < dis[e])
- {
- dis[e] = dis[s]+v;
- return 1;
- }
- return 0;
- }
-
- /* SPFA有負(fù)權(quán)回路返回0,否則返回1并且最短路徑保存在dis[] */
- int n;
- int vst[MAXN], cnt[MAXN];
- int Q[MAXN*MAXN];
- int SPFA(int s0)
- {
- int i, p, q;
- struct Edge *pp;
-
- memset(vst, 0, sizeof(vst));
- memset(cnt, 0, sizeof(cnt));
- for (i=0; i<=n; i++)
- dis[i] = INF;
- dis[s0] = 0;
-
- Q[0] = s0; p = 0; q = 1;
- vst[s0] = 1;
- cnt[s0]++;
- while (p < q)
- {
- pp = node[Q[p]].head;
- while (pp)
- {
- if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])
- {
- Q[q++] = pp->e;
- vst[pp->e] = 1;
- cnt[pp->e]++;
- if (cnt[pp->e] > n) //有負(fù)權(quán)回路
- return 0;
- }
- pp = pp->nxt;
- }
- vst[Q[p]] = 0;
- p++;
- }
- return 1;
- }
- /**通過poj 3159 證明:還是用數(shù)組來實現(xiàn)鄰接表比用鏈表來實現(xiàn)鄰接表效率高, **/
-
- #define MAX_node 10000
- #define MAX_edge 100000
-
- struct Edge
- {
- int e, v;
- } edge[MAX_edge];
-
- int neg; //number of edge
- int node[MAX_node]; //注意node要用memset初始化全部為-1
- int next[MAX_edge];
-
- void add(int s,int e,int v)
- {
- edge[neg].e = e;
- edge[neg].v = v;
- next[neg] = node[s];
- node[s] = neg++;
- }
- /* 該題還證明用棧來實現(xiàn)SPFA比用隊列來實現(xiàn)效率高,還節(jié)約空間 */
- int SPFA(int s0)//棧實現(xiàn)
- {
- int i, t, p, top;
-
- memset(vst, 0, sizeof(vst));
- for (i=1; i<=n; i++)
- dis[i] = INF;
- dis[s0] = 0;
-
- Q[0] = s0;
- top = 1;
- vst[s0] = 1;
- while (top)
- {
- t = Q[--top];
- vst[t] = 0;
- p = node[t];
- while (p != -1)
- {
- if (relax(t, edge[p].e, edge[p].v) && !vst[edge[p].e])
- {
- Q[top++] = edge[p].e;
- vst[edge[p].e] = 1;
- }
- p = next[p];
- }
- }
- return 1;
- }
|