SPFA or bellman ford松弛法--单源最短路

问题概述：有编号1-n的n个站点，有m条公交车路线，公交车只从一个起点站直接到达终点站，是单向的且每条路线有它自己的车费，有P个人早上从1出发，他们要到达每一个公交站点，然后到了晚上再返回点1，求所有人往返的最小费用之和

输入样例：                                     对应输出：

4 6                                                  210

1 2 10

2 1 60

1 3 20

3 4 10

2 4 5

4 1 50

bellman ford松弛法(专业解决负环问题)：

功能：可以求出单个源点到其他顶点最短路径

适用：有向图 √ 无向图√ 权值为正 √ 权值为负 √

复杂度：n*m(复杂度较高)

参考博客：http://blog.csdn.net/xu3737284/article/details/8973615

SPFA松弛法(省时算法)：

功能：可以求出单个源点到其他顶点最短路径

适用：有向图 √ 无向图 √ 权值为正 √ 权值为负 √

复杂度：2*n(复杂度低)

核心：

建立一个队列q，初始时队列里只有一个起始点(源点)，再建立一个数组best[]记录起始点到所有点的最短路径，并且初始化这个数组，然后进行松弛操作（用队列里面的点去刷新当前点到所有点的最短路，如果刷新成功且刷新点不在队列中则把该点加入到队列最后，重复执行直到队列为空）

没有第二步了

下面是一个详细解析（不是上面那道题）

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
int main(void)
{
int i, j, a, b, c, n, m, now;
int cost[103][103], best[103];
while(scanf("%d%d", &n, &m), n!=0 || m!=0)
{
int used[103] = {0};  /*used[]数组用来检测第i个顶点是否在队列中,是就为1*/
memset(cost, 127, sizeof(cost));
for(i=1;i<=m;i++)
{
scanf("%d%d%d", &a, &b, &c);
cost[a][b] = cost[b][a] = c;
}
for(i=1;i<=n;i++)
best[i] = 100000000;
best[1] = 0;
queue<int> q;    /*如果用队列超时,则改为堆栈*/
q.push(1);
used[1] = 1; /*第一个顶点进入队列*/
while(q.empty()==0)
{
now = q.front();   /*即将要对与第now个顶点连接起来的所有顶点进行松弛*/
q.pop();
used[now] = 0;  /*now离开队列,状态标记为0*/
for(i=1;i<=n;i++)
{
if(best[now]+cost[now][i]<best[i])  /*如果存在一条边的松弛操作次数大于n-1,则说明存在负环*/
{
best[i] = best[now]+cost[now][i];
if(used[i]==0)       /*d[i]被更新了,那么与i连接起来的顶点可能也可以被更新(优化),所以i一定要在队列中*/
{
q.push(i);
used[i] = 1;
}
}
}
}
printf("%d\n",best
);
}
return 0;
}

题解：

其中SPFA用静态链表建边

bellman ford：

#include<stdio.h>
typedef struct
{
int u;
int v;
int len;
}Road;
int main(void)
{
int n, m, i, j, x, y;
Road s[10005];
while(scanf("%d%d", &n, &m), n!=0 || m!=0)
{
int d[10005] = {0};
for(i=1;i<=m;i++)
scanf("%d%d%d", &s[i].u, &s[i].v, &s[i].len);
for(i=2;i<=n;i++)
d[i] = 100000000;
for(i=1;i<=n-1;i++)  /*若在n-1次循环后仍可以更新d[]数组,则说明存在负环,因为既然不包含负环,那么最短路除了源点以外最多只经过n-1个点*/
{
for(j=1;j<=m;j++)
{
x = s[j].u, y = s[j].v;
if(d[x]+s[j].len<d[y] && d[x]<100000000)
d[y] = d[x]+s[j].len;
if(d[y]+s[j].len<d[x] && d[y]<100000000)
d[x] = d[y]+s[j].len;
}
}
/*
for(j=1;j<=m;j++)
{
x = s[j].u, y = s[j].v;
if(d[x]+s[j].len<d[y])
{
printf("error\n");      (检测是否存在负环)
return 0;
}
}
*/
printf("%d\n", d
);
}
return 0;
}

SPFA：

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
typedef struct
{
int y;
int len;
int next;
}Point;
Point s[1000005], re_s[1000005];
int edge[1000005], re_edge[1000005];
__int64 best[1000005];
bool flag[1000005];
void SPFA(int edge[], Point s[])
{
int x, p, y;
memset(flag, 0, sizeof(flag));
memset(best, 127, sizeof(best));
best[1] = 0;
queue<int> q;
q.push(1);
flag[1] = 1;
while(q.empty()==0)
{
x = q.front();
flag[x] = 0;
q.pop();
p = edge[x];
while(p!=0)
{
y = s[p].y;
if(best[x]+s[p].len<best[y])
{
best[y] = best[x]+s[p].len;
if(flag[y]==0)
{
flag[y] = 1;
q.push(y);
}
}
p = s[p].next;
}
}
}
int main(void)
{
int T, n, m, i, x, y, len;
__int64 sum;
scanf("%d", &T);
while(T--)
{
scanf("%d%d", &n, &m);
memset(edge, 0, sizeof(edge));
memset(re_edge, 0, sizeof(re_edge));
for(i=1;i<=m;i++)
{
scanf("%d%d%d", &x, &y, &len);
s[i].y = y;
s[i].len = len;
s[i].next = edge[x];
edge[x] = i;          /*一个顶点x可能连着多个顶点,而一个edge[x]只能存一个顶点(号),所以需要结构体中加个s[i].next将所有和x联通的顶点连接起来*/
re_s[i].y = x;
re_s[i].len = len;
re_s[i].next = re_edge[y];
re_edge[y] = i;
}
sum = 0;
SPFA(edge, s);
for(i=1;i<=n;i++)
sum += best[i];
SPFA(re_edge, re_s);
for(i=1;i<=n;i++)
sum += best[i];
printf("%I64d\n", sum);
}
return 0;
}