请问谁能告诉我SPFA的算法

Posted 2023-05-17

很多时候，给定的图存在负权边，这时类似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过程

　　(以求某个结点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;
　　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的优化

　　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..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;
　　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 (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;
　　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;
　　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. 参考技术A 这是一个计算一个节点到其余各点的最短路的算法~
大概的思想是，对于一个图来说，若源点到图中的某一个点A的最短路距离更新了，则需要更新所有与A直接相连的点的最短路距离。
大约步骤是：
1、准备一个队列，与一个数组。这个数组用来记录源点至图上各点的最短路，初始化为无穷大。
2、更新数组，源点到自己的距离设为0，同时源点入队。
3、从队列中取出一个结点，暂时命名为A。对于A可以直接到达的每个节点，进行第4步的操作。
4、该结点暂时命名为B。比较当前源点至B的距离，与源点至A的距离，加上A至B的距离哪个小。即源点先到A再到B，是否比原来到B的距离小。是的话，则更新源点至B的距离，说明B有更短路径。然后，B入队列。
5、若队列不为空，则跳至上述的第3步。直至所有的最短路径都没有更新为止
SPFA算法是存在无解情况的。就是当图里面存在一个环，环内所有边的路径之和为负数的时候，最短路问题是无解的。通俗理解是，每走一个圈，距离就能缩小，那距离就是越走越小，无法确定最小值了。。。 参考技术B 这个~~~不太固定
数组存储的优点是操作简单，但如果数据很大，就可能会挂掉，因为数组开几千万就可能会爆，这时候指针就派上用场了。
指针最大的优点就是省空间，他的空间复杂度是动态的，只与数据有关，操作也比较简单，在数据规模超大时很好用！

谁能告诉我为啥这超过了 2 秒的时间限制？（短代码）

【中文标题】谁能告诉我为啥这超过了 2 秒的时间限制？（短代码）

【英文标题】：Can anyone tell me why does this exceed the time limit of 2 seconds ?(short code)谁能告诉我为什么这超过了 2 秒的时间限制？（短代码）

【发布时间】：2017-04-04 12:38:38

【问题描述】：

我已经为此苦苦挣扎了 2 天。请问，当我使用 20000 和 0 和 40000 之后的数字作为输入时，为什么它会超过时间限制？我试图使变量类型尽可能大，但这似乎也无济于事。

#include <bits/stdc++.h>

using namespace std;

int main()

    /*freopen("file.in", "r", stdin);
    freopen("file.out", "w" , stdout);*/
    long long int aux,i, n, k, j, total = 0;
    cin >> n >> k;
    long long int a[n], b[n], order[n];
    signed long long int profit[n];
    for(i = 0; i < n; i++)
        cin >> a[i];
    for(i = 0; i < n; i++)
        cin >> b[i];
    for(i = 0; i < n; i++)
        profit[i] = a[i] - b[i];
    for(i = 0; i < n; i++)
        order[i] = i;
    for(i = 0; i < n; i++)
        for(j = i + 1; j < n; j++)
            if(profit[order[i]] > profit[order[j]])
            
                aux = order[i];
                order[i] = order[j];
                order[j] = aux;
            
    if(k > 0)
        for(i = 0; i < k; i++)
        
            total += a[order[i]];
        

    for(i = k; i < n; i++)
    
        if(profit[order[i]] < 0)
            total += a[order[i]];
        else
            total += b[order[i]];
    
    cout << total;

    return 0;

【问题讨论】：

您是否分析过您的代码以确定它实际花费的时间？

我该怎么做？

您可以从这里开始阅读：***.com/questions/2229336/linux-application-profiling 和#include <bits/stdc++.h>?!?!?不就是不。不要那样做。见***.com/questions/31816095/…

感谢您让我知道第二个链接 :)。你是个英雄 但我对第一个链接一无所知。请问您在我的代码中进行必要的排序方法替换。我在乞讨，如果代码是在我的上下文中编写的，那么理解代码会容易得多。请:,(

初学者遇到的最大问题是知道在哪里寻找答案。当你使用像#include <bits/stdc++.h> 这样的快捷方式时——除了链接中的问题——你不会学习如何正确使用东西。例如，如果要使用 C++ vector，则需要 #include 正确的标头。如果您想使用 C 风格的基于系统调用的 IO，例如 open()/read()/write() - 您必须学习如何识别正确的标头。例如，要使用 C open() 系统调用，您可以使用 man open 命令查看 open 的手册页。

【参考方案1】：

您的代码复杂度为 O(n^2)，对于 N=20000 来说太过分了。降低复杂性，用 Qsort 代替冒泡排序。试试std::sort的自定义比较功能。

【讨论】：

如何使用 std:sort ？我不熟悉它。而且快速排序也没有性能 O(n^2) 的最坏情况？

这取决于实现。当您选择需要 O(n log n) 的随机枢轴元素时。如果你愿意，你可以使用归并排序或复杂度为 O(log n)

的任何排序