「spfa算法java实现」SPFA算法
今天给各位分享spfa算法java实现的知识，其中也会对SPFA算法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
SPFA算法的PASCAL代码是什么?
SPFA
实现方法：建立一个队列，初始时队列里只有起始点，在建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空
判断有无负环：如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）
program spfaprg;
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..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(d,sizeof(d),0);
fillchar(v,sizeof(v),false);
for j := 1 to p do
dist[ j ]:=maxlongint;
dist[s] := 0; v[s] := true; d[1] := s; {队列的初始状态,s为起点}
head := 1; tail := 1;
while head=tail do {队列不空}
begin
now := d[head]; {取队首元素}
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
inc(tail);
d[tail] := b[now,i];
v[b[now,i]] := true;
end;
end;
v[now] := false; {释放结点}
inc(head); {出队}
end;
end;
procedure print;
begin
writeln(dist[t]);
end;
begin
init;
spfa(s);
print;
end.
关于C++SPFA算法求最短路径的问题
用vs2017调试了一下，主要的问题就是初始化不完全，尤其是没有对vis数组初始化。在调试的过程中，把数据的输入改成文件形式了，不想弄成鼠标手^_^
#include "pch.h"
#define _CRT_SECURE_NO_WARNINGS
#includeiostream
#includecstring
#include iomanip
#include fstream
using namespace std;
const int SIZE = 500;
int dis[SIZE]; // 出发点到各点的最短估计距离
int path[SIZE]; // 路径上到达该点的上一顶点
int a[SIZE][SIZE]; // a[i][j]表示i到j路径的权值
// n为顶点数，s为出发点
// 各顶点编号从1始起
void spfa(int n, int s)
{
const int INF = 999999; // 初始最短路径估计值
int vis[SIZE]; // 该点是否被访问过
int q[SIZE]; // 用于实现spfa的队列
for (int i = 1; i = n; i++)
{
path[i] = -1;
dis[i] = INF;
vis[i] = 0;
}
dis[s] = 0; vis[s] = 1; q[1] = s;
int v, head = 0, tail = 1;
while (head tail)
{
head++;
v = q[head];
vis[v] = 0; // 出队
for (int i = 1; i = n; i++)
{
if (a[v][i] 0 dis[i] dis[v] + a[v][i])
{
dis[i] = dis[v] + a[v][i];
path[i] = v;
if (vis[i] == 0)
{
tail++;
q[tail] = i;
vis[i] = 1; // 入队
}
}
}
}
}
// k为终点
void printpath(int k)
{
if (path[k] != -1)
printpath(path[k]);
cout " - " k;
}
int main()
{
#define W setw(4)
ifstream in("in.txt");
if (!in.is_open())
{
cout "未打开in.txt，请检查文件是否在当前目录下";
return 0;
}
int n, s; // 顶点数，出发点
in n s;
cout "输入顶点数、出发点：" n " " s endl;
cout "输入各条路径的起点、终点、权值：" endl;
int i = 1;
while (in.peek() != EOF) // in.eof()会多读一行
{
int x, y, w;
in x y w;
a[x][y] = w;
//a[y][x] = w;
cout " 第(" W i++ ")条边：";
cout W x W y W w endl;
}
cout endl;
spfa(n, s);
cout "从 " s " 到 " n "的最短路径: " dis[n] endl;
printpath(n);
return 0;
}
in文件内容：
11 1
1 2 5
1 3 3
2 4 1
2 5 3
2 6 6
3 5 8
3 6 7
3 7 6
4 8 6
4 9 8
5 8 3
5 9 5
6 9 3
6 10 3
7 9 8
7 10 4
8 11 3
9 11 2
10 11 2
百科里面有个经典的c++ spfa程序，那个用了一点stl的知识，数组也从0始计数，你可以参考一下：
SPFA算法的原理及证明
求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于1994年发表的。从名字我们就可以看出，这种算法在效率上一定有过人之处。很多时候，给定的图存在负权边，这时类似Dijkstra算法等便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。简洁起见，我们约定加权有向图G不存在负权回路，即最短路径一定存在。如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。
定理：只要最短路径存在，上述SPFA算法必定能求出最小值。证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。
期望时间复杂度：O(me)， 其中m为所有顶点进队的平均次数，可以证明m一般小于等于2：“算法编程后实际运算情况表明m一般没有超过2n.事实上顶点入队次数m是一个不容易事先分析出来的数,但它确是一个随图的不同而略有不同的常数.所谓常数,就是与e无关,与n也无关,仅与边的权值分布有关.一旦图确定,权值确定,原点确定,m就是一个确定的常数.所以SPFA算法复杂度为O(e).证毕.（SPFA的论文）不过，这个证明是非常不严谨甚至错误的，事实上在bellman算法的论文中已有这方面的内容，所以国际上一般不承认SPFA算法。
对SPFA的一个很直观的理解就是由无权图的BFS转化而来。在无权图中，BFS首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数)，所以此时利用数组记录节点访问可以使每个顶点只进队一次，但在带权图中，最先到达的顶点所计算出来的路径不一定是最短路。一个解决方法是放弃数组，此时所需时间自然就是指数级的，所以我们不能放弃数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解。
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算法。
spfa算法java实现的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于SPFA算法、spfa算法java实现的信息别忘了在本站进行查找喔。
发布于：2022-12-27，除非注明，否则均为原创文章，转载请注明出处。