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[n]);
	}
	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[n]);
    }
    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;
}