您的位置:首页 > 其它

SPFA算法详解(强大图解,不会都难!)

2017-08-07 08:28 357 查看
适用范围:给定的图存在负权边,这时类似Dijkstra等算法便没有了用武之地,而Bellman-Ford算法的复杂度又过高,SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路,即最短路径一定存在。当然,我们可以在执行该算法前做一次拓扑排序,以判断是否存在负权回路,但这不是我们讨论的重点。

算法思想:我们用数组d记录每个结点的最短路径估计值,用邻接表来存储图G。我们采取的方法是动态逼近法:设立一个先进先出的队列用来保存待优化的结点,优化时每次取出队首结点u,并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作,如果v点的最短路径估计值有所调整,且v点不在当前的队列中,就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作,直至队列空为止

期望的时间复杂度O(ke), 其中k为所有顶点进队的平均次数,可以证明k一般小于等于2。

实现方法:

  建立一个队列,初始时队列里只有起始点,再建立一个表格记录起始点到所有点的最短路径(该表格的初始值要赋为极大值,该点到他本身的路径赋为0)。然后执行松弛操作,用队列里有的点作为起始点去刷新到所有点的最短路,如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。

判断有无负环:

  如果某个点进入队列的次数超过N次则存在负环(SPFA无法处理带负环的图)



首先建立起始点a到其余各点的

最短路径表格



首先源点a入队,当队列非空时:

 1、队首元素(a)出队,对以a为起始点的所有边的终点依次进行松弛操作(此处有b,c,d三个点),此时路径表格状态为:



在松弛时三个点的最短路径估值变小了,而这些点队列中都没有出现,这些点

需要入队,此时,队列中新入队了三个结点b,c,d

队首元素b点出队,对以b为起始点的所有边的终点依次进行松弛操作(此处只有e点),此时路径表格状态为:



在最短路径表中,e的最短路径估值也变小了,e在队列中不存在,因此e也要

入队,此时队列中的元素为c,d,e

队首元素c点出队,对以c为起始点的所有边的终点依次进行松弛操作(此处有e,f两个点),此时路径表格状态为:



在最短路径表中,e,f的最短路径估值变小了,e在队列中存在,f不存在。因此

e不用入队了,f要入队,此时队列中的元素为d,e,f

队首元素d点出队,对以d为起始点的所有边的终点依次进行松弛操作(此处只有g这个点),此时路径表格状态为:



在最短路径表中,g的最短路径估值没有变小(松弛不成功),没有新结点入队,队列中元素为f,g

队首元素f点出队,对以f为起始点的所有边的终点依次进行松弛操作(此处有d,e,g三个点),此时路径表格状态为:



在最短路径表中,e,g的最短路径估值又变小,队列中无e点,e入队,队列中存在g这个点,g不用入队,此时队列中元素为g,e

队首元素g点出队,对以g为起始点的所有边的终点依次进行松弛操作(此处只有b点),此时路径表格状态为:



在最短路径表中,b的最短路径估值又变小,队列中无b点,b入队,此时队列中元素为e,b

队首元素e点出队,对以e为起始点的所有边的终点依次进行松弛操作(此处只有g这个点),此时路径表格状态为:



在最短路径表中,g的最短路径估值没变化(松弛不成功),此时队列中元素为b

队首元素b点出队,对以b为起始点的所有边的终点依次进行松弛操作(此处只有e这个点),此时路径表格状态为:



在最短路径表中,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循环带来影响

}

for(int i=1;i<=m;i++)

{

scanf(“%d%d%d\n”,&u,&v,&w); &nbs
4000
p;

e[i].x=v; //记录后继节点 相当于链表中的创建一个节点,并使得数据域先记录

e[i].value=w;

e[i].next=st[u]; //记录顶点节点的某一个边表节点的下标,相当于在链表中吧该边表节点的next指针先指向他的后继边表节点

st[u]=i; //把该顶点的指针指向边表节点,相当于链表中的插入中,头结点的指针改变

}

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
);

}

return 0;

}

(没有质量,就出数量) 下面一文转载出处:http://blog.csdn.net/morgan_xww/article/details/6279596

/*
SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
是Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算。
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,
并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。
它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。

SPFA 在形式上和BFS非常类似,不同的是BFS中一个点出了队列就不可能重新进入队列,但是SPFA中
一个点可能在出队列之后再次被放入队列,也就是一个点改进过其它的点之后,过了一段时间可能本
身被改进,于是再次用来改进其它的点,这样反复迭代下去。

判断有无负环:如果某个点进入队列的次数超过V次则存在负环(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算法。
*/

//用数组实现邻接表存储,pnt[i,0]表示与i相邻的结点个数,pnt[i,1…k]存储与i相邻的点
int pnt[MAXN][MAXN];
int map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离,并且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算法的一种队列实现,减少了不必要的冗余计算。
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,
并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。
它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。

SPFA 在形式上和BFS非常类似,不同的是BFS中一个点出了队列就不可能重新进入队列,但是SPFA中
一个点可能在出队列之后再次被放入队列,也就是一个点改进过其它的点之后,过了一段时间可能本
身被改进,于是再次用来改进其它的点,这样反复迭代下去。

判断有无负环:如果某个点进入队列的次数超过V次则存在负环(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算法。
*/

//用数组实现邻接表存储,pnt[i,0]表示与i相邻的结点个数,pnt[i,1…k]存储与i相邻的点
int pnt[MAXN][MAXN];
int map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离,并且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;
}

正规邻接表存储:
/* ——- 邻接表存储 ———– */
struct Edge
{
int e; //终点
int v; //边权
struct Edge *nxt;
};
struct
{
struct Edge *head, *last;
} node[MAXN];
/* ——————————– */

/* 添加有向边<起点,终点,边权> */
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有负权回路返回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)
{
&n
d2da
bsp; 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) //有负权回路
return 0;
}
pp = pp->nxt;
}
vst[Q[p]] = 0;
p++;
}
return 1;
}

正规邻接表存储:
/* ——- 邻接表存储 ———– */
struct Edge
{
int e; //终点
int v; //边权
struct Edge *nxt;
};
struct
{
struct Edge *head, *last;
} node[MAXN];
/* ——————————– */

/* 添加有向边<起点,终点,边权> */
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有负权回路返回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) //有负权回路
return 0;
}
pp = pp->nxt;
}
vst[Q[p]] = 0;
p++;
}
return 1;
}

/**通过poj 3159 证明:还是用数组来实现邻接表比用链表来实现邻接表效率高, **/

#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++;
}
/* 该题还证明用栈来实现SPFA比用队列来实现效率高,还节约空间 */
int SPFA(int s0)//栈实现
{
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;
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息