“SPFA”的意思、由来-中文百科全书

SPFA算法

简介

求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。

SPFA算法是西南交通大学段凡丁于1994年发表的.

从名字我们就可以看出，这种算法在效率上一定有过人之处。

很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。

简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

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

原理

定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。

证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）

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

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

判断有无负环：如果某个点进入队列的次数超过N次则存在负环 ( 存在负环则无最短路径,如果有负环则会无限松弛,而一个带n个点的图至多松弛n-1次)

伪代码

SPFA实际上是Bellman-Ford基础上的优化

(这里的q数组表示的是节点是否在队列中，如q[v]=1则点v在队列中)

SPFA(G,w,s)

1. INITIALIZE-SINGLE-SOURCE(G,s)

2. Q ← Ø

3. for each vertex ∈ V[G]

4. q[v]=0

5. ENQUEUE(Q,s)

6. q[s]=1

7. while Q≠Ø

8. dou ← DEQUEUE(Q)

9. q[u]=0

10.for each edge(u,v) ∈ E[G]

11. dot ← d[v]

12. RELAX(u,v,w)

13. π[v] ← u

14. if(d[v] < t) and

15. ENQUEUE(Q,v)

16. q[v]=1

一种更容易读懂的伪代码

pascal

Procedure SPFA;

Begin

initialize-single-source(G,s); // 初始化单源

initialize-queue(Q); //初始化队列

enqueue(Q,s); //插入s到队列Q

while not empty(Q) do begin //如果Q不为空

u:=dequeue(Q); //取Q开头的元素

for each v∈adj[u] do begin //枚举adj[u]的所有节点

tmp:=d[v];

relax(u,v);

if (tmp<>d[v]) and (not v in Q) then enqueue(Q,v); //插入v

end;

End;

c++

void spfa() {

初始化(G,s);

初始化队列Q;

插入s到队列Q;

while(!空(Q)) {

u=Q的开头元素，并删除;

for each v in adj[u] {

tmp = d[v];

relax(u,v);

if((tmp<>d[v])&&(!v in Q)) 插入v到队列Q;

}

期望的时间复杂度O(2e)

对spfa的一个很直观的理解就是由无权图的bfs转化而来.在无权图中,bfs首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数).所以此时利用visit[u],可以使每个顶点只进队一次.在带权图中,最先到达的顶点所计算出来的路径不一定是最短路.一个解决方法是放弃visit数组,此时所需时间自然就是指数级的.所以我们不能放弃visit数组,而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时,直接更新最优解.

标准SPFA过程

(以求某个结点t到某个结点s的最短路为例，稍加修改即为单源最短路)

Pascal语言代码

const

maxp=10000; {最大结点数}

var {变量定义}

p,c,s,t:longint; {p,结点数;c,边数;s:起点;t:终点}

a,b:array[1..maxp,0..maxp] of longint; {a[x,y]存x,y之间边的权;b[x,c]存与x相连的第c个边的另一个结点y}

d:array[1..2*maxp] of integer; {队列}

v:array[1..maxp] of boolean; {是否入队的标记}

dist:array[1..maxp] of longint; {到起点的最短路}

head,tail:longint; {队首/队尾指针}

procedure init;

var i,x,y,z:longint;

begin

read(p,c);

for i := 1 to c do

begin

readln(x,y,z); {x,y:一条边的两个结点;z:这条边的权值}

inc(b[x,0]); b[x,b[x,0]] := y; a[x,y] := z; {b[x,0]：以x为一个结点的边的条数}

inc(b[y,0]); b[y,b[y,0]] := x; a[y,x] := z;{若为有向图,此句删去.(不删去无法处理负边)}

end;

readln(s,t); {读入起点与终点}

end;

procedure spfa(s:longint); {SPFA}

var i,j,now,sum:longint;

begin

fillchar(v,sizeof(v),false);

for j := 1 to p do dist[j]:=maxlongint;

dist[s]:=0; v[s]:=true;now:=s;{队列的初始状态,s为起点}

head:=1;tail:= 1;

d[head]:=s;

while head<=tail do {队列不空}

begin

now:=d[head mod maxp]; {取队首元素}

for i:=1 to b[now,0] do

if dist[b[now,i]]>dist[now]+a[now,b[now,i]] then

begin

dist[b[now,i]]:= dist[now]+a[now,b[now,i]]; {修改最短路}

if not v[b[now,i]] then {扩展结点入队}

begin

tail:=tail+1;

d[tail mod maxp] := b[now,i];

v[b[now,i]] := true;

end;

v[now] := false; {释放结点}

head:=head+1;{出队}

end;

procedure print;

begin

writeln(dist[t]);

end;

begin

init;

spfa(s);

print;

end.

C语言代码

#include<stdio.h>

#define maxint 2139062143

int a[101][101],dist[101],n;

void spfa(int s)

{

int q[101],v[101],h=0,t=1,x,i;//q为队列,v为Boolean数组,表示结点是否在队列中,h为头指针,t为尾指针

memset(q,0,sizeof(q));

memset(v,0,sizeof(v));

for(i=0;i<101;i++)//这里应该用for循环初始化，memset函数只能将值初始化为0或者-1。

dist[i] = INT_MAX;

dist[s]=0;

q[t]=s;v[s]=1;

while(h!=t)//本来是h<t,但这不是循环队列么,不能这么干的...

{

h=(h+1)%(n+1);//这里不能%n否则队满和队空状态一样

x=q[h];

v[x]=0;

for(i=1;i<=n;i++)

if(dist[i]-a[x][i]>dist[x])//这里本来为dist[i]>dist[x]+a[x][i],但这样会越界的,因为后两者加起来太大

{

dist[i]=dist[x]+a[x][i];

if(!v[i])

{

t=(t+1)%(n+1)/*同上*/;q[t]=i;v[i]=1;

}

int main()

{

int m,s,t,i;

scanf("%d%d",&n,&m);

scanf("%d%d",&s,&t);

memset(a,127,sizeof(a));

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

{

int x,y,z;

scanf("%d%d%d",&x,&y,&z);

a[x][y]=z;

a[y][x]=z;

}

spfa(s);

printf("%d",dist[t]);

system("pause");

return 0;

}

a,b,e:array[1..1000] of longint;

vis:array[1..2000] of boolean;

q,d,f:array[1..2001] of longint;

n,m,i,s,t:longint;

procedure qsort(l,r:longint);

var i,j,x,y:longint;

begin

i:=l;

j:=r;

x:=a[(l+r) shr 1];

repeat

while a[i]<x do inc(i);

while a[j]>x do dec(j);

if not(i>j) then begin

y:=a[i]; a[i]:=a[j]; a[j]:=y;

y:=b[i]; b[i]:=b[j]; b[j]:=y;

y:=e[i]; e[i]:=e[j]; e[j]:=y;

inc(i);

dec(j);

end;

until i>j;

if i<r then qsort(i,r);

if l<j then qsort(l,j);

end;

procedure spfa(s:longint);

var i,k,l,t:longint;

begin

fillchar(vis,sizeof(vis),false);

for i:=1 to n do d[i]:=maxlongint;

d[s]:=0;

l:=0;

t:=1;

q[1]:=s;

vis[s]:=true;

repeat

l:=l mod 10000 +1;

k:=q[l];

for i:=f[k] to f[k+1]-1 do

if d[k]+e[i]<d[b[i]] then

begin

d[b[i]]:=d[k]+e[i];

if not vis[b[i]] then begin

t:=t mod 10000 +1;

q[t]:=b[i];

vis[b[i]]:=true;

end;

vis[k]:=false;

until l=t;

end;

Begin

readln(n,m);

for i:=1 to m do

readln(a[i],b[i],e[i]);

qsort(1,m);

for i:=1 to m do

if f[a[i]]=0 then f[a[i]]:=i;

f[n+1]:=m+1;

for i:=n downto 1 do

if f[i]=0 then f[i]:=f[i+1];

readln(s,t);

spfa(s);

writeln(d[t]);

end.

堆排实现(无向图)

const MM=1000;

var

a,b,e:array[1..MM] of longint;

q,d,f:array[1..2*MM+1] of longint;

vis:array[1..MM] of boolean;

n,m,i,s,t:longint;

mh:longint;

procedure heapify(i:longint);

var l,r,max,temp:longint;

begin

l:=2*i;

r:=l+1;

max:=i;

if (l<=mh) and (a[l]>a[max]) then max:=l;

if (r<=mh) and (a[r]>a[max]) then max:=r;

if max<>i then begin

temp:=a[i]; a[i]:=a[max]; a[max]:=temp;

temp:=b[i]; b[i]:=b[max]; b[max]:=temp;

temp:=e[i]; e[i]:=e[max]; e[max]:=temp;

heapify(max);

end;

procedure heap;

var i,temp:longint;

begin

mh:=m;

for i:=(m div 2) downto 1 do heapify(i);

for i:=m downto 2 do begin

temp:=a[i]; a[i]:=a[1]; a[1]:=temp;

temp:=b[i]; b[i]:=b[1]; b[1]:=temp;

temp:=e[i]; e[i]:=e[1]; e[1]:=temp;

dec(mh);

heapify(1);

end;

procedure spfa(s:longint);

var i,k,l,t:longint;

begin

fillchar(vis,sizeof(vis),false);

for i:=1 to n do d[i]:=maxlongint;

d[s]:=0;

l:=0;

t:=1;

vis[s]:=true;

q[1]:=s;

repeat

l:=(l mod (2*MM)) +1;

k:=q[l];

for i:=f[k] to f[k+1]-1 do

if d[k]+e[i]<d[b[i]] then

begin

d[b[i]]:=d[k]+e[i];

if not vis[b[i]] then begin

t:=(t mod (2*MM)) +1;

q[t]:=b[i];

vis[b[i]]:=true;

end;

vis[k]:=false;

until l=t;

end;

Begin

readln(n,m);

for i:=1 to m do begin

readln(a[i],b[i],e[i]);

a[i+m]:=b[i];

b[i+m]:=a[i];

e[i+m]:=e[i];

end;

m:=m+m;

heap;

for i:=1 to m do if f[a[i]]=0 then f[a[i]]:=i;

f[n+1]:=m+1;

for i:=n downto 1 do if f[i]=0 then f[i]:=f[i+1];

readln(s,t);

spfa(s);

writeln(d[t]);

end.

邻接矩阵(无向图)

以上两种是边集数组储存方式,以下是邻接矩阵(无向图):

const MM=100*2;

var

n,m,i,j:longint;

g:array[1..MM,1..MM] of longint;

q,d:array[1..MM] of longint;

vis:array[1..MM] of boolean;

a,b,e,s,t:longint;

procedure spfa(s:longint);

var l,t,i,k:longint;

begin

fillchar(vis,sizeof(vis),false);

for i:=1 to n do d[i]:=maxlongint;

d[s]:=0;

l:=0;

t:=1;

q[1]:=s;

vis[s]:=true;

repeat

l:=l mod MM +1;

k:=q[l];

for i:=1 to n do

if (g[k,i]<maxlongint)and(d[k]+g[k,i]<d[i]) then begin

d[i]:=d[k]+g[k,i];

if not vis[i] then begin

t:=t mod MM +1;

q[t]:=i;

vis[i]:=true;

end;

vis[k]:=false;

until l=t;

end;

begin

readln(n,m);

for i:=1 to n do

for j:=1 to n do g[i,j]:=maxlongint;

for i:=1 to m do

begin

readln(a,b,e);

g[a,b]:=e;

g[b,a]:=e;

end;

readln(s,t);

spfa(s);

writeln(d[t]);

end.

词条	SPFA
释义	SPFA算法(简介原理) 伪代码标准SPFA过程(Pascal语言代码 C语言代码) SPFA的优化 SPFA的实现(最基本的前向星优化的spfa(有向图) 堆排实现(无向图) 邻接矩阵(无向图)) SPFA算法简介求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。 SPFA算法是西南交通大学段凡丁于1994年发表的. 从名字我们就可以看出，这种算法在效率上一定有过人之处。很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是松弛：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。原理定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）期望的时间复杂度O(ke)，其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。实现方法：建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空判断有无负环：如果某个点进入队列的次数超过N次则存在负环 ( 存在负环则无最短路径,如果有负环则会无限松弛,而一个带n个点的图至多松弛n-1次) 伪代码 SPFA实际上是Bellman-Ford基础上的优化 (这里的q数组表示的是节点是否在队列中，如q[v]=1则点v在队列中) SPFA(G,w,s) 1. INITIALIZE-SINGLE-SOURCE(G,s) 2. Q ← Ø 3. for each vertex ∈ V[G] 4. q[v]=0 5. ENQUEUE(Q,s) 6. q[s]=1 7. while Q≠Ø 8. dou ← DEQUEUE(Q) 9. q[u]=0 10.for each edge(u,v) ∈ E[G] 11. dot ← d[v] 12. RELAX(u,v,w) 13. π[v] ← u 14. if(d[v] < t) and 15. ENQUEUE(Q,v) 16. q[v]=1 一种更容易读懂的伪代码 pascal Procedure SPFA; Begin initialize-single-source(G,s); // 初始化单源 initialize-queue(Q); //初始化队列 enqueue(Q,s); //插入s到队列Q while not empty(Q) do begin //如果Q不为空 u:=dequeue(Q); //取Q开头的元素 for each v∈adj[u] do begin //枚举adj[u]的所有节点 tmp:=d[v]; relax(u,v); if (tmp<>d[v]) and (not v in Q) then enqueue(Q,v); //插入v end; end; End; c++ void spfa() { 初始化(G,s); 初始化队列Q; 插入s到队列Q; while(!空(Q)) { u=Q的开头元素，并删除; for each v in adj[u] { tmp = d[v]; relax(u,v); if((tmp<>d[v])&&(!v in Q)) 插入v到队列Q; } } } 期望的时间复杂度O(2e) 对spfa的一个很直观的理解就是由无权图的bfs转化而来.在无权图中,bfs首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数).所以此时利用visit[u],可以使每个顶点只进队一次.在带权图中,最先到达的顶点所计算出来的路径不一定是最短路.一个解决方法是放弃visit数组,此时所需时间自然就是指数级的.所以我们不能放弃visit数组,而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时,直接更新最优解. 标准SPFA过程 (以求某个结点t到某个结点s的最短路为例，稍加修改即为单源最短路) Pascal语言代码 const maxp=10000; {最大结点数} var {变量定义} p,c,s,t:longint; {p,结点数;c,边数;s:起点;t:终点} a,b:array[1..maxp,0..maxp] of longint; {a[x,y]存x,y之间边的权;b[x,c]存与x相连的第c个边的另一个结点y} d:array[1..2maxp] of integer; {队列} v:array[1..maxp] of boolean; {是否入队的标记} dist:array[1..maxp] of longint; {到起点的最短路} head,tail:longint; {队首/队尾指针} procedure init; var i,x,y,z:longint; begin read(p,c); for i := 1 to c do begin readln(x,y,z); {x,y:一条边的两个结点;z:这条边的权值} inc(b[x,0]); b[x,b[x,0]] := y; a[x,y] := z; {b[x,0]：以x为一个结点的边的条数} inc(b[y,0]); b[y,b[y,0]] := x; a[y,x] := z;{若为有向图,此句删去.(不删去无法处理负边)} end; readln(s,t); {读入起点与终点} end; procedure spfa(s:longint); {SPFA} var i,j,now,sum:longint; begin fillchar(v,sizeof(v),false); for j := 1 to p do dist[j]:=maxlongint; dist[s]:=0; v[s]:=true;now:=s;{队列的初始状态,s为起点} head:=1;tail:= 1; d[head]:=s; while head<=tail do {队列不空} begin now:=d[head mod maxp]; {取队首元素} for i:=1 to b[now,0] do if dist[b[now,i]]>dist[now]+a[now,b[now,i]] then begin dist[b[now,i]]:= dist[now]+a[now,b[now,i]]; {修改最短路} if not v[b[now,i]] then {扩展结点入队} begin tail:=tail+1; d[tail mod maxp] := b[now,i]; v[b[now,i]] := true; end; end; v[now] := false; {释放结点} head:=head+1;{出队} end; end; procedure print; begin writeln(dist[t]); end; begin init; spfa(s); print; end. C语言代码 #include<stdio.h> #define maxint 2139062143 int a[101][101],dist[101],n; void spfa(int s) { int q[101],v[101],h=0,t=1,x,i;//q为队列,v为Boolean数组,表示结点是否在队列中,h为头指针,t为尾指针 memset(q,0,sizeof(q)); memset(v,0,sizeof(v)); for(i=0;i<101;i++)//这里应该用for循环初始化，memset函数只能将值初始化为0或者-1。 dist[i] = INT_MAX; dist[s]=0; q[t]=s;v[s]=1; while(h!=t)//本来是h<t,但这不是循环队列么,不能这么干的... { h=(h+1)%(n+1);//这里不能%n否则队满和队空状态一样 x=q[h]; v[x]=0; for(i=1;i<=n;i++) if(dist[i]-a[x][i]>dist[x])//这里本来为dist[i]>dist[x]+a[x][i],但这样会越界的,因为后两者加起来太大 { dist[i]=dist[x]+a[x][i]; if(!v[i]) { t=(t+1)%(n+1)/同上/;q[t]=i;v[i]=1; } } } } int main() { int m,s,t,i; scanf("%d%d",&n,&m); scanf("%d%d",&s,&t); memset(a,127,sizeof(a)); for(i=1;i<=m;i++) { int x,y,z; scanf("%d%d%d",&x,&y,&z); a[x][y]=z; a[y][x]=z; } spfa(s); printf("%d",dist[t]); system("pause"); return 0; } SPFA的优化 SPFA最常用的优化是SLF优化，即将队列用双端队列实现。如果该点源点S到当前节点I的距离小于队列首的节点距离，那么就把该节点放入队列首，否则放入队列尾。 SPFA的实现最基本的前向星优化的spfa(有向图) 复杂度O(ke). var a,b,e:array[1..1000] of longint; vis:array[1..2000] of boolean; q,d,f:array[1..2001] of longint; n,m,i,s,t:longint; procedure qsort(l,r:longint); var i,j,x,y:longint; begin i:=l; j:=r; x:=a[(l+r) shr 1]; repeat while a[i]<x do inc(i); while a[j]>x do dec(j); if not(i>j) then begin y:=a[i]; a[i]:=a[j]; a[j]:=y; y:=b[i]; b[i]:=b[j]; b[j]:=y; y:=e[i]; e[i]:=e[j]; e[j]:=y; inc(i); dec(j); end; until i>j; if i<r then qsort(i,r); if l<j then qsort(l,j); end; procedure spfa(s:longint); var i,k,l,t:longint; begin fillchar(vis,sizeof(vis),false); for i:=1 to n do d[i]:=maxlongint; d[s]:=0; l:=0; t:=1; q[1]:=s; vis[s]:=true; repeat l:=l mod 10000 +1; k:=q[l]; for i:=f[k] to f[k+1]-1 do if d[k]+e[i]<d[b[i]] then begin d[b[i]]:=d[k]+e[i]; if not vis[b[i]] then begin t:=t mod 10000 +1; q[t]:=b[i]; vis[b[i]]:=true; end; end; vis[k]:=false; until l=t; end; Begin readln(n,m); for i:=1 to m do readln(a[i],b[i],e[i]); qsort(1,m); for i:=1 to m do if f[a[i]]=0 then f[a[i]]:=i; f[n+1]:=m+1; for i:=n downto 1 do if f[i]=0 then f[i]:=f[i+1]; readln(s,t); spfa(s); writeln(d[t]); end. 堆排实现(无向图) const MM=1000; var a,b,e:array[1..MM] of longint; q,d,f:array[1..2MM+1] of longint; vis:array[1..MM] of boolean; n,m,i,s,t:longint; mh:longint; procedure heapify(i:longint); var l,r,max,temp:longint; begin l:=2i; r:=l+1; max:=i; if (l<=mh) and (a[l]>a[max]) then max:=l; if (r<=mh) and (a[r]>a[max]) then max:=r; if max<>i then begin temp:=a[i]; a[i]:=a[max]; a[max]:=temp; temp:=b[i]; b[i]:=b[max]; b[max]:=temp; temp:=e[i]; e[i]:=e[max]; e[max]:=temp; heapify(max); end; end; procedure heap; var i,temp:longint; begin mh:=m; for i:=(m div 2) downto 1 do heapify(i); for i:=m downto 2 do begin temp:=a[i]; a[i]:=a[1]; a[1]:=temp; temp:=b[i]; b[i]:=b[1]; b[1]:=temp; temp:=e[i]; e[i]:=e[1]; e[1]:=temp; dec(mh); heapify(1); end; end; procedure spfa(s:longint); var i,k,l,t:longint; begin fillchar(vis,sizeof(vis),false); for i:=1 to n do d[i]:=maxlongint; d[s]:=0; l:=0; t:=1; vis[s]:=true; q[1]:=s; repeat l:=(l mod (2MM)) +1; k:=q[l]; for i:=f[k] to f[k+1]-1 do if d[k]+e[i]<d[b[i]] then begin d[b[i]]:=d[k]+e[i]; if not vis[b[i]] then begin t:=(t mod (2MM)) +1; q[t]:=b[i]; vis[b[i]]:=true; end; end; vis[k]:=false; until l=t; end; Begin readln(n,m); for i:=1 to m do begin readln(a[i],b[i],e[i]); a[i+m]:=b[i]; b[i+m]:=a[i]; e[i+m]:=e[i]; end; m:=m+m; heap; for i:=1 to m do if f[a[i]]=0 then f[a[i]]:=i; f[n+1]:=m+1; for i:=n downto 1 do if f[i]=0 then f[i]:=f[i+1]; readln(s,t); spfa(s); writeln(d[t]); end. 邻接矩阵(无向图) 以上两种是边集数组储存方式,以下是邻接矩阵(无向图): const MM=1002; var n,m,i,j:longint; g:array[1..MM,1..MM] of longint; q,d:array[1..MM] of longint; vis:array[1..MM] of boolean; a,b,e,s,t:longint; procedure spfa(s:longint); var l,t,i,k:longint; begin fillchar(vis,sizeof(vis),false); for i:=1 to n do d[i]:=maxlongint; d[s]:=0; l:=0; t:=1; q[1]:=s; vis[s]:=true; repeat l:=l mod MM +1; k:=q[l]; for i:=1 to n do if (g[k,i]<maxlongint)and(d[k]+g[k,i]<d[i]) then begin d[i]:=d[k]+g[k,i]; if not vis[i] then begin t:=t mod MM +1; q[t]:=i; vis[i]:=true; end; end; vis[k]:=false; until l=t; end; begin readln(n,m); for i:=1 to n do for j:=1 to n do g[i,j]:=maxlongint; for i:=1 to m do begin readln(a,b,e); g[a,b]:=e; g[b,a]:=e; end; readln(s,t); spfa(s); writeln(d[t]); end.
随便看	广东威能动力设备有限公司广东威奇电工材料有限公司广东威王电器有限公司广东威文服装有限公司广东威信纺织有限公司广东威孚包装材料有限公司广东维嘉微波能应用设备有限公司广东维能电气有限公司广东维生温室科技有限公司广东伟佳音像制品有限公司广东伟强铜业科技有限公司广东伟信担保投资有限公司广东伟雄集团有限公司广东伟业铝厂有限公司广东伟英杰科技有限公司广东胃肠网广东温泉行业协会广东温氏佳味食品有限公司广东温氏食品集团有限公司车岗分公司广东温氏食品集团有限公司广西分公司广东温氏食品集团有限公司华北分公司广东温氏食品集团有限公司江苏分公司广东温氏食品集团有限公司浙江分公司广东文化网广东文时特制衣实业有限公司