最短路径问题（Bellman-Ford算法）

题目链接见下：

https://begin.lydsy.com/JudgeOnline/problem.php?cid=1318&pid=10

今天我们来学习Bellman-Ford算法，它是一种单源的可带负权边最短路径算法，但它不能算出含负权回路的图（PS:负权回路指起点和终点相同的总权重为负的路径，其实就是一个环的总代价为负），因为本身每多走一次负权回路，最短距离便能够减少，但Ford算法能够检测出图中是否含有负权回路。

1.算法解析

Ford算法的原理就是进行连续松弛，在每次松弛的情况下，与原来两点间的最短距离做比较，来更新最短路，最后n-1次松弛操作后即能求出源点到各点间的最短距离。
首先了解一下松弛操作：

1. 松弛操作的根源就是数学中的三角不等式：
   In a rectangle , the longest edge is c(AB) , the other two edges are a(BC) and b(AC) , the relation of three edges is :
   a+b>c (AC+BC>AB)
   好了不装逼秀英语了，其实就是三角形中三边关系。
2. 具体不等式式就是：
   min_w(v)=min(min_w(v),min_w(u)+w(u,v))
   [PS:min_w表示最短距离，w(a,b)表示a,b间的边权]
3. 代码实现就很简单：

if (dis[v]>dis[u]+w[u][v])
	dis[v]=dis[u]+w[u][v];

那么为什么最后松弛的次数一定是n-1呢？
这是因为在一个图中，V为结点数，源点至目标点的最短距离所包含边数最大为V-1（此时这个图变成了一条链）。
而具体的时间复杂度就是里面一层循环1 to E(总边数)来枚举边进行松弛操作，外面套一层1 to V-1的循环来求出所有能求出的最短路，显然是 O(VE) 的。
实际上Ford算法的松弛迭代操作，就是在不断建立与源点s越来越大的层次的最短路，最后逐步形成一棵最短路径树的过程。
在对每条边进行第一遍松弛的时候，就可以找到层次至多为1的边（树枝），也就是找到了与s至多有一条边相连的点的最短路；
在对每条边进行第二遍松弛的时候，就可以找到层次至多为2的边（树枝），也就是找到了与s至多有二条边相连的点的最短路；
以此类推……
而在一个图中，最短路的包含的最多边数为|V|-1，所以只需要外循环|V|-1次。

2.代码实现

我们在读入每条边的数据时，用edge[e].w (e<=E)来表示每条边的边权，然后用edge[e].u和edge[e].v，来表示这条边所连接的两个结点，最后两层循环完成求解。

Code

#include 
#include 
#include 
#include 
#pragma GCC optimize(2)
using namespace std;

int n,m,a,b,s,t;
int x[101],y[101];
double dis[101]; //dis表最短路
struct Edge
{
	int u,v;
	double w;
} edge[4951];

inline void read(int &x) //quickly_read 快读
{
	x=0;int f=1;char ch=getchar();
	while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
	while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x*=f;
}

int main()
{
	read(n);
	for (int i=1;i<=n;i++)
		read(x[i]),read(y[i]);
	read(m);
	memset(dis,0x7f,sizeof(dis)); //dis初始化
	for (int i=1;i<=m;i++)
	{
		read(a),read(b);
		edge[i].u=a,edge[i].v=b; //连接两点
		edge[i].w=sqrt(pow(x[a]-x[b],2)+pow(y[a]-y[b],2)); //勾股定理
	}
	read(s),read(t);
	dis[s]=0; //源点至本身的最短距离为0
	for (int i=1;i<n;i++)
	{
		for (int j=1;j<=m;j++)
		{
			if (dis[edge[j].u]>dis[edge[j].v]+edge[j].w) 
				dis[edge[j].u]=dis[edge[j].v]+edge[j].w,relaxed=true;
			if (dis[edge[j].v]>dis[edge[j].u]+edge[j].w) 
				dis[edge[j].v]=dis[edge[j].u]+edge[j].w,relaxed=true;
		} //无向边双向松弛操作
	}
	printf("%.2f",dis[t]);
	return 0;
}

由于图中可能产生负环，则我们需要再次进行判断，若每条边(u,v)中任意一条满足dis[u]+w[u][v] 代码如下：

bool flag=false;
for (int i=1;i<=m;++i)
	if (dis[edge[i].u]+edge[i].w<dis[edge[i].v]) {flag=true;break;} //判断
if (!flag) printf("%.2f",dis[t]);
else puts("Error");

因为此题不存在负权回路，因此上述代码可省略。

3. 简单的优化

自然我们能够知道，外循环至多为|V|-1次，而实际操作次数则远远小于它，那么我们应该如何在已经完成所有操作的情况下提前退出循环？
也非常简单，我们只需要在第一层循环内定义一个bool变量relaxed，表示当前是否成功松弛，那么初始化为false，然后进行一轮松弛，每成功松弛就将relaxed赋值为true，在松弛完后进行判断，若relaxed为false，则表示当前已将所有路径松弛完毕，或有部分点不可达到，退出循环。

优化AC代码如下

#include 
#include 
#include 
#include 
#pragma GCC optimize(2)
using namespace std;

int n,m,a,b,s,t;
int x[101],y[101];
double dis[101];
struct Edge
{
	int u,v;
	double w;
} edge[4951];

inline void read(int &x)
{
	x=0;int f=1;char ch=getchar();
	while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
	while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	x*=f;
}

int main()
{
	read(n);
	for (int i=1;i<=n;i++)
		read(x[i]),read(y[i]);
	read(m);
	memset(dis,0x7f,sizeof(dis));
	for (int i=1;i<=m;i++)
	{
		read(a),read(b);
		edge[i].u=a,edge[i].v=b;
		edge[i].w=sqrt(pow(x[a]-x[b],2)+pow(y[a]-y[b],2));
	}
	read(s),read(t);
	dis[s]=0;
	for (int i=1;i<n;i++)
	{
		bool relaxed=false; //定义bool变量relaxed并初始化
		for (int j=1;j<=m;j++)
		{
			if (dis[edge[j].u]>dis[edge[j].v]+edge[j].w)
				dis[edge[j].u]=dis[edge[j].v]+edge[j].w,relaxed=true; //赋值
			if (dis[edge[j].v]>dis[edge[j].u]+edge[j].w)
				dis[edge[j].v]=dis[edge[j].u]+edge[j].w,relaxed=true; //同上
		}
		if (!relaxed) break; //判断是否被松弛
	}
	printf("%.2f",dis[t]);
	return 0;
}

3.如有不当之处请各位神犇及时指出！