1.算法描述
SPFA（Shortest Path Faster Algorithm）算法是西南交通大学的段凡丁于1994提出，是队列优化版的Bellman-Ford。将源点加入队列；每次从队列出来一个点，对相邻的点，进行松弛操作；被松弛成功且不在队列的点依次进入队列；重复操作，直至队列为空算法结束。
dis[u]表示源点到点u的最短距离；用数组queue[ ]模拟队列，head, rear分别表示队首、队尾，dequeue表示出队的元素；within[u]标记节点u在队列中。
算法流程：
（1）初始化：将queue元素全部置为-1，源点进入队列queue。
（2）队首出队，dequeue=queue[head]; head++; 松弛与dequeue相邻的节点v：dis[v]=min{dis[v], dis[dequeue]+(dequeue,v)}；
若dis[v]<dis[dequeue]+(dequeue,v)，即标明松弛成功，v如果不在队列中则入队；将dequeue标记为已出队。
（3）判断队列为空：dequeue==-1，若不为空，重复操作。
用邻接表（adjacency list）作为图的存储结构，SPFA算法时间复杂度为O(ke)。
2. 图的邻接表表示
在邻接表中，对每个顶点u建立一个单链表。单链表由c(u)个表结点组成，c(u)表示节点u的出度；每一个单链表都有一个表头结点。
2.1 表结点
--------------------------------
| adjvex | weight | next |
--------------------------------
| adjvex | weight | next |
--------------------------------
adjvex表示与u相邻节点，weight表示权值（边长等），next指向u的另一个相邻节点。
2.2 头结点
------------------------
| vertex | firstarc |
------------------------
| vertex | firstarc |
------------------------
vertex表示顶点u，firstarc指向依附于u的第一条边。
3. Referrence
[1] NOCOW,http://www.nocow.cn/index.php/SPFA算法.
[2]段凡丁，关于最短路径的SPFA快速算法，西南交通大学学报，1994.
[3]xw13106209,有向图的邻接表表示法.
4.问题
4.1 POJ 1511
round trip是从源点s出发，到顶点u，再回到源点s。求解：有向图(n,m)中，n-1个顶点的round trip之和的最小值。
先求源点s到每个顶点的最短路径，然后相加求和；将边反向建立图，求s到每个顶点的最短路径，然后相加求和；将两次的和相加即得最终结果。
在结构题内定义指针要加上struct，比如：typedef struct ArcNode{……ArcNode *next;} ArcNode 是错误的，应该是typedef struct ArcNode{……struct ArcNode *next;} ArcNode ；因此有两次Compile Error。
定义dis[ ]要用__int64或long long，inf 要超过1000000000。自己没注意到，有两次WA。
源代码：
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#define MAXN 1000000
#define inf 1100000000
__int64 sum;
/*表结点*/
typedef struct ArcNode
{
int adjvex, weight;
struct ArcNode *next;
}ArcNode;
ArcNode *pnew, *rpnew;
/*头结点*/
typedef struct VNode
{
int vertex;
struct ArcNode *firstarc;
}VNode;
/*graph represented by adjacency list*/
typedef struct
{
int n,m;
VNode GVertex[MAXN];
}ALGraph;
/*create a graph & a reverse graph by using adjacency-list*/
void CreateGraph(ALGraph *graph,ALGraph *reverse)
{
int i,n,m;
int start,end,wei;
scanf("%d%d",&n,&m);
graph->n=reverse->n=n;
graph->m=reverse->m=m;
for(i=0;i<n;i++)
{
graph->GVertex[i].vertex=i;
graph->GVertex[i].firstarc=NULL;
reverse->GVertex[i].vertex=i;
reverse->GVertex[i].firstarc=NULL;
}
for(i=0;i<m;i++)
{
scanf("%d%d%d",&start,&end,&wei);
pnew=(ArcNode *) malloc(sizeof(ArcNode));
pnew->adjvex=end-1;
pnew->weight=wei;
pnew->next=graph->GVertex[start-1].firstarc;
graph->GVertex[start-1].firstarc=pnew;
rpnew=(ArcNode *) malloc(sizeof(ArcNode));
rpnew->adjvex=start-1;
rpnew->weight=wei;
rpnew->next=reverse->GVertex[end-1].firstarc;
reverse->GVertex[end-1].firstarc=rpnew;
}
}
/*spfa algorithm, the source node is 0*/
void spfa(ALGraph *graph)
{
const int num_ver=graph->n;
int i;
int head,rear,dequeue;
int *within=(int *) malloc(num_ver*sizeof(int));
int *queue=(int *) malloc((num_ver+1)*sizeof(int));
__int64 *dis=(__int64 *)malloc(num_ver*sizeof(__int64));
/*initialization*/
memset(within,0,num_ver*sizeof(int));
memset(queue,-1,(num_ver+1)*sizeof(int));
for(i=0;i<num_ver;i++)
dis[i]=inf;
dis[0]=0;
queue[0]=0;
dequeue=head=rear=0;
for(;dequeue!=-1;dequeue=queue[head],head++)
{
ArcNode *p=graph->GVertex[dequeue].firstarc;
while(p!=NULL)
{
if(dis[p->adjvex]>dis[dequeue]+p->weight)
{
dis[p->adjvex]=dis[dequeue]+p->weight;
if(within[p->adjvex]==0)
{
within[p->adjvex]=1;
queue[rear+1]=p->adjvex;
rear++;
}
}
p=p->next;
}
within[dequeue]=0;
}
/*calculate the sum of the minimum shortest path*/
for(i=0;i<num_ver;i++)
sum+=dis[i];
free(within);
free(queue);
free(dis);
}
int main()
{
int test_case;
ALGraph *graph=(ALGraph *) malloc(sizeof(ALGraph));
ALGraph *reverse=(ALGraph *) malloc(sizeof(ALGraph));
scanf("%d",&test_case);
while(test_case--)
{
CreateGraph(graph,reverse);
sum=0;
spfa(graph);
spfa(reverse);
printf("%I64d\n",sum);
}
return 0;
}4.2 POJ 3037
题目大意：有一个R*C（即R row, C coloumn）的网格，网格中每一点（即location）对应一个速度，速度跟该点的height（elevation）相关，且满足：如果从a移到b，speed[b]=speed[a]*2^(elevation[a]-elevation[b])；求从左上角移到右下角的最短路径。
（1）Titanium指出这个题的巧妙之处：无论怎么走，从起点走到任何一个点，到达的那个点的速度都是固定的。
对于线路a--->b---->c ，c点速度为 speed[c]=speed[b]*2^(elevation[b]-elevation[c]) =speed[a]*2^(elevation[a]-elevation[c]) 。
（2）从一个位置a移到其邻接位置（adjacent location）的距离是1.0，所花费的时间为1.0/speed[a] 。
（3）因为只能东南西北的移动，所以网格隐含着一个邻接表。
（4）这道题可以用BFS+Priority_queue优化求解，具体请参看popopopolo。
函数pow(,)内的两个参数类型因保持一致，因pow(2,)而Compile Error一次，应改成pow(2.0,) 。
源代码（C++）：
| 3037 | Accepted | 524K | 313MS | C++ | 1787B | 2013-08-16 22:36:29 |
#include <iostream>
#include <cmath>
#include <queue>
using namespace std;
#define MAXR 100
#define MAXC 100
#define inf 11000000000
/*describe a location*/
struct location
{
int x,y;
};
/*represent the west, north, east, south*/
const location direction[4]={{-1,0},{0,-1},{1,0},{0,1}};
int init_speed,row,coloumn;
double speed[MAXR][MAXC],dis[MAXR][MAXC];
int elevation[MAXR][MAXC],within[MAXR][MAXC];
/*input and get the speed at each location*/
void get_speed()
{
int i,j;
cin>>init_speed>>row>>coloumn;
speed[0][0]=init_speed;
for(i=0;i<row;i++)
for(j=0;j<coloumn;j++)
{
cin>>elevation[i][j];
speed[i][j]=init_speed*pow(2.0,elevation[0][0]-elevation[i][j]);
}
}
void spfa( )
{
queue<location>Que;
location dequeue,enqueue;
int i,j;
/*initialization*/
for(i=0;i<row;i++)
{
for(j=0;j<coloumn;j++)
{
dis[i][j]=inf;
within[i][j]=0;
}
}
dequeue.x=0; dequeue.y=0;
dis[0][0]=0; within[0][0]=1;
Que.push(dequeue);
while(!Que.empty())
{
int xadj,yadj;
dequeue=Que.front();
Que.pop();
within[dequeue.x][dequeue.y]=0;
for(i=0;i<4;i++)
{
xadj=dequeue.x+direction[i].x; //adjacent location
yadj=dequeue.y+direction[i].y;
if(xadj>=0&&xadj<row&&yadj>=0&&yadj<coloumn)
{
double time=1.0/speed[dequeue.x][dequeue.y];
if(dis[xadj][yadj]>dis[dequeue.x][dequeue.y]+time) //relax
{
dis[xadj][yadj]=dis[dequeue.x][dequeue.y]+time;
if(within[xadj][yadj]==0)
{
within[xadj][yadj]=1;
enqueue.x=xadj;
enqueue.y=yadj;
Que.push(enqueue); //enqueue
}
}
}
}
}
}
int main()
{
get_speed();
spfa();
printf("%.2f\n",dis[row-1][coloumn-1]);
return 0;
}4.3 POJ 3159
题目大意：B的糖果比A至多只能多出c(A, B)个，求编号为N的flymouse比编号为1的snoopy至多多出多少个糖果。
这是一道差分约束题，可以转化为求最短路径的问题。用dis[v]表示点v比源点至多多出糖果数，则有dis[B]-dis[A]>=c(A, B) ；使用松弛：dis[B]=min{dis[B], dis[A]+c(A, B)} 。因此，变成了求源点到点N的最短路径问题。
Discuss中讨论说用queue会TLE，建议用stack。我用stack后，还是TLE。然后参考，将邻接表用边表+firstarc数组所替代，结果还是TLE。最后将cin换成了scanf、cout换成了printf，才AC了。
源代码：
| 3159 | Accepted | 2128K | 672MS | C++ | 1480B | 2013-08-21 20:18:24 |
#include <iostream>
#include <stack>
using namespace std;
#define MAXN 30001
#define MAXM 150001
#define inf INT_MAX
struct EDGE
{
int v,weight;
int next;
};
EDGE edge[MAXM];
int firstarc[MAXN];
/*create a graph by using an adjacency list*/
void CreatGraph(int n, int m)
{
int i,position=1;
int start,end,wei;
memset(firstarc,0,sizeof(firstarc));
for(i=0;i<m;i++)
{
scanf("%d%d%d",&start,&end,&wei);
edge[position].v=end;
edge[position].weight=wei;
edge[position].next=firstarc[start];
firstarc[start]=position++;
}
}
void spfa(int n, int m)
{
stack<int>spfa_stack;
int i, poping; //poping represents the poping element of the stack
int *dis=new int [n];
int *within=new int [n];
/*initialization*/
fill(dis,dis+n+1,inf);
memset(within,0,(n+1)*sizeof(int));
dis[1]=0;
within[1]=1;
spfa_stack.push(1);
while(!spfa_stack.empty())
{
poping=spfa_stack.top();
spfa_stack.pop();
within[poping]=0;
for(i=firstarc[poping];i;i=edge[i].next)
{
if(dis[edge[i].v]>dis[poping]+edge[i].weight) //relax
{
dis[edge[i].v]=dis[poping]+edge[i].weight;
if(!within[edge[i].v]) // push stack
{
spfa_stack.push(edge[i].v);
within[edge[i].v]=1;
}
}
}
}
printf("%d\n",dis[n]);
delete []dis;
delete []within;
}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
CreatGraph(n,m);
spfa(n,m);
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
