最短路算法的证明_图论--SPFA算法(单源最短路)

SPFA 算法详解(最短路径)

算法优点：

1.时间复杂度比普通的Dijkstra和Ford低。

2.能够计算负权图问题。

3.能够判断是否有负环 (即：每跑一圈，路径会减小，所以会一直循环跑下去)。

算法思想：

我们用数组记录每个结点的最短路径估计值，用邻接表来存储图G。

我们采取的方法是动态逼近法：

1.设立一个先进先出的队列用来保存待优化的结点。

2.优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。

3.这样不断从队列中取出结点来进行松弛操作，直至队列空为止

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

实现方法：

1.存入图。可以使用链式前向星或者voctor。

2.开一个队列，先将开始的节点放入。

3.每次从队列中取出一个节点X，遍历与X相通的Y节点，查询比对 Y的长度 和 X的长度+ X与Y的长度

如果X的长度+ X与Y的长度> Y的长度,说明需要更新操作。

1).存入最短路。

2).由于改变了原有的长度，所以需要往后更新，与这个节点相连的最短路。(即：判断下是否在队列，在就不用重复，不在就加入队列，等待更新)。

3).在这期间可以记录这个节点的进队次数，判断是否存在负环。

4.直到队空。

判断有无负环：如果某个点进入队列的次数超过N次则存在负环

模拟过程：

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

首先源点a入队，当队列非空时：

１、队首元素(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的最短路径为１４

例题：

题意：给出几个城市及其连通情况，然后给出多个出发点，和多个终点。求从任意起点出发到任意个终点，最短的那条路。

思路： 求出全部起点的最短路，遍历终点一遍，找最短的路。

SPFA核心代码：bool SPFA(int s,int n){

queue q;

memset(vis,inf,sizeof(vis));

memset(ven,0,sizeof(ven));

memset(nums,0,sizeof(nums));

vis[s]=0;//初始化距离

ven[s]=1,nums[s]++;//标记s节点在队列，队列次数+1

q.push(s);

while(!q.empty())

{

int x=q.front();

q.pop();//出队

ven[x]=0;//标记不在队列

for(int i=pre[x]; ~i; i=a[i].next)//遍历与x节点连通的点

{

int y=a[i].y;

if(vis[y]>vis[x]+a[i].time)//更新

{

vis[y]=vis[x]+a[i].time;

if(!ven[y])

//由于更新了节点，所以后续以这个为基础的最短路，也要更新下

//所以如果在队列就不用加入，不在的话加入更新后续节点

{

q.push(y);

ven[y]=1;//标记这个节点在队列中

nums[y]++;//记录加入次数

if(nums[y]>n)//如果这个点加入超过n次，说明存在负圈，直接返回

return false;

}

}

}

}

return true;

}

完整代码：#include

#define inf 0x3f3f3f3f

using namespace std;

const int M=10005;

struct A{

int y,time,next;

}a[M<<1];

int pre[M],cent=0;//链式前向星数组

int vis[M],ven[M],nums[M];

//SPFS数组，vis记录最短路，ven记录是否在队列，nums记录入队次数

void add(int x,int y,int k)//链式前向星，加入节点{

a[cent].y=y, a[cent].time=k, a[cent].next=pre[x];

pre[x]=cent++;

}

bool SPFA(int s,int n){

queue q;

memset(vis,inf,sizeof(vis));

memset(ven,0,sizeof(ven));

memset(nums,0,sizeof(nums));

vis[s]=0;//初始化距离

ven[s]=1,nums[s]++;//标记s节点在队列，队列次数+1

q.push(s);

while(!q.empty())

{

int x=q.front();

q.pop();//出队

ven[x]=0;//标记不在队列

for(int i=pre[x]; ~i; i=a[i].next)//遍历与x节点连通的点

{

int y=a[i].y;

if(vis[y]>vis[x]+a[i].time)//更新

{

vis[y]=vis[x]+a[i].time;

if(!ven[y])

//由于更新了节点，所以后续以这个为基础的最短路，也要更新下

//所以如果在队列就不用加入，不在的话加入更新后续节点

{

q.push(y);

ven[y]=1;//标记这个节点在队列中

nums[y]++;//记录加入次数

if(nums[y]>n)//如果这个点加入超过n次，说明存在负圈，直接返回

return false;

}

}

}

}

return true;

}

int main(){

int n,m,t;

int b[M],c[M];

while(cin>>n>>m>>t)

{

cent=0;

memset(pre,-1,sizeof(pre));

for(int i=0;i

{

int x,y,k;

cin>>x>>y>>k;

add(x,y,k);

add(y,x,k);

}

for(int i=0;i

{

cin>>b[i];

}

for(int i=0;i

{

cin>>c[i];

}

int minn=inf;

for(int i=0;i

{

SPFA(b[i],n);

for(int j=0;j

minn=min(minn,vis[c[j]]);

}

cout<

}

}