SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算。

算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。

这个算法,简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法

SPFA——Shortest Path Faster Algorithm,它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单

SPFA可以处理负权边

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

证明:

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

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

判断有无负环:

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

/*********************************************/
// d数组类似迪杰斯特拉的dis数组,记录起点到i点的局部最优解
// c数组用来记录访问 i 点的次数
// vis 记录是否在队列里面
// 用数组模拟邻接表存图,w数组为权值
/*********************************************/
bool spfa_bfs(int s) // s为图的起点
{
queue <int> q; // 队列里存点
memset(d,0x3f,sizeof(d));
memset(c,0,sizeof(c));
memset(vis,0,sizeof(vis));
q.push(s);
vis[s]=1;
c[s]=1;
d[s]=0;
//顶点入队vis要做标记,另外要统计顶点的入队次数
while(!q.empty())
{
int x;
x=q.front();
q.pop();
vis[x]=0;
//队头元素出队,并且消除标记
for(int k=f[x]; k!=0; k=nnext[k]) //遍历顶点x的邻接表
{
int y=v[k];
if( d[x]+w[k] < d[y]) //如果可以松弛
{
d[y]=d[x]+w[k]; //松弛
if(!vis[y]) //顶点y不在队内 不要重复入队列
{
vis[y]=1; //标记
c[y]++; //统计次数
q.push(y); //入队
if(c[y]>NN) //超过入队次数上限,说明有负环
return false;
}
}
}
}
return true;
}

给出一道题目,练练手.

点击打开链接

本人AC代码:  仅供参考 ,不对的地方请指出

大致思路:

用数组模拟邻接表存图,然后直接套模板.

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h> using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAX_SIZE=1005; int first[MAX_SIZE*2],nnext[MAX_SIZE*2];
int edge[MAX_SIZE*2][3],dist[MAX_SIZE],cnt[MAX_SIZE],vis[MAX_SIZE];
int V,E;
bool spfa_bfs(int start)
{
memset(vis,0,sizeof(vis));
memset(cnt,0,sizeof(cnt));
memset(dist,0xf3,sizeof(dist));
queue<int>q;
q.push(start);
vis[start]=1;
dist[start]=0;
while(!q.empty())
{
start=q.front();
q.pop();
vis[start]=0;
int k=first[start];
while(k!=-1)
{
int terminal=edge[k][1];
if(dist[terminal]<dist[start]+edge[k][2])
{
dist[terminal]=dist[start]+edge[k][2];
if(!vis[terminal])
{
q.push(terminal);
cnt[terminal]++;
vis[terminal]=1;
if(cnt[terminal]>V) return false;
}
}
k=nnext[k];
}
}
return true;
}
int main()
{
// printf("sb\n");
int ncase;
scanf("%d",&ncase);
while(ncase--)
{
int i,j;
scanf("%d %d",&V,&E);
for(i=0; i<=1000; i++)
first[i]=-1;
for(i=0; i<E; i++)
{
int a,b,c,d,e,val1,val2;
scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);
val1=d-c;
val2=e-c;
int xiaobiao=(i+1)*2-2;
edge[xiaobiao][0]=a,edge[xiaobiao][1]=b,edge[xiaobiao][2]=val1;
nnext[xiaobiao]=first[a];
first[a]=xiaobiao;
xiaobiao++;
edge[xiaobiao][0]=b,edge[xiaobiao][1]=a,edge[xiaobiao][2]=val2;
nnext[xiaobiao]=first[b];
first[b]=xiaobiao;
}
int ans=spfa_bfs(0);
// for(i=0;i<V;i++)
// printf("%d ",dist[i]);
// printf("\n"); if(!ans) printf("$$$\n");
else printf("%d\n",dist[V-1]);
}
return 0;
}

SPFA 最短路 带负权边的---- 粗了解的更多相关文章

  1. 图之单源Dijkstra算法、带负权值最短路径算法

    1.图类基本组成 存储在邻接表中的基本项 /** * Represents an edge in the graph * */ class Edge implements Comparable< ...

  2. Expm 10_1 带负权值边的有向图中的最短路径问题

    [问题描述] 对于一个带负权值边的有向图,实现Bellman-Ford算法,求出从指定顶点s到其余顶点的最短路径,并判断图中是否存在负环. package org.xiu68.exp.exp10; p ...

  3. hdu 6201 transaction (最短路变形——带负权最长路)

    题意: 给定n个城市的货物买卖价格, 然后给定n-1条道路,每条路有不同的路费, 求出从某两个城市买卖一次的最大利润. 利润 = 卖价 - (买价 + 路费) 样例数据, 最近是从第一个点买入, 第4 ...

  4. SPFA 求带负权的单源最短路

    int spfa_bfs(int s) { ///s表示起点. queue <int> q; memset(d,0x3f,sizeof(d)); ///d数组中存下的就是最短路径(存在的话 ...

  5. [板子]SPFA算法+链式前向星实现最短路及负权最短路

    参考:https://blog.csdn.net/xunalove/article/details/70045815 有关SPFA的介绍就掠过了吧,不是很赞同一些博主说是国内某人最先提出来,Bellm ...

  6. Spfa 求含负权边的最短路 + 判断是否存在负权回路

    在Bellman-Ford算法之后,我们总算迎来了spfa算法,其实就如同堆优化Dijkstra算法之于朴素版Dijkstra算法,spfa算法仅仅是对Bellman-Ford算法的一种优化,但是在形 ...

  7. POJ 3259 Wormholes 虫洞(负权最短路,负环)

    题意: 给一个混合图,求判断是否有负环的存在,若有,输出YES,否则NO.有重边. 思路: 这是spfa的功能范围.一个点入队列超过n次就是有负环了.因为是混合图,所以当你跑一次spfa时发现没有负环 ...

  8. 【SPFA与Dijkstra的对比】CDOJ 1961 咸鱼睡觉觉【差分约束-负权最短路径SPFA】

    差分约束系统,求最小值,跑最长路. 转自:https://www.cnblogs.com/ehanla/p/9134012.html 题解:设sum[x]为前x个咕咕中至少需要赶走的咕咕数,则sum[ ...

  9. Bellman-ford算法与SPFA算法思想详解及判负权环(负权回路)

    我们先看一下负权环为什么这么特殊:在一个图中,只要一个多边结构不是负权环,那么重复经过此结构时就会导致代价不断增大.在多边结构中唯有负权环会导致重复经过时代价不断减小,故在一些最短路径算法中可能会凭借 ...

随机推荐

  1. App后台运行通知函数

    
[[UIApplicationsharedApplication] beginBackgroundTaskWithExpirationHandler: ^() { //程序在10分钟内未被系统关闭或 ...

  2. 使用MYSQL命令直接导入导出SQL文件(转)

    参考:http://blog.csdn.net/jiary5201314/article/details/52026816 1.MYSQL中将数据库导出成SQL文件 其实很简单的,就是一条语句就可以了 ...

  3. Permission denied: user=administrator, access=WRITE, inode="/":root:supergroup:drwxr-xr-x

    参考博文:http://blog.csdn.net/xiaoshunzi111/article/details/52062640 http://www.udpwork.com/item/7047.ht ...

  4. [Bzoj5043][Lydsy1709月赛]密码破译(按位dp)

    5043: [Lydsy1709月赛]密码破译 Time Limit: 10 Sec  Memory Limit: 256 MBSubmit: 477  Solved: 125[Submit][Sta ...

  5. Java普通员工管理系统

    login GUI界面(登录) package 普通员工管理系统; import java.awt.event.ActionEvent; import java.awt.event.ActionLis ...

  6. python type

    基于2.7 版本 type 是内置函数,有两种用法 class type(object) With one argument, return the type of an object. The re ...

  7. js上传文件研究

    https://github.com/shengulong/javascript-file-upload

  8. 利用背景流量数据(contexual flow data) 识别TLS加密恶意流量

    识别出加密流量中潜藏的安全威胁具有很大挑战,现已存在一些检测方法利用数据流的元数据来进行检测,包括包长度和到达间隔时间等.来自思科的研究人员扩展现有的检测方法提出一种新的思路(称之为“dataomni ...

  9. 转:VMware中三种网络连接的区别

    转自:http://www.cnblogs.com/rainman/archive/2013/05/06/3063925.html VMware中三种网络连接的区别   1.概述 2.bridged( ...

  10. 具体解释window.history

    Window.history保存用户在一个会话期间的站点訪问记录,用户每次訪问一个新的URL即创建一个新的历史记录. history.go().history.back().history.forwa ...