Bellman-Ford算法

解决单源最短路经

原理:

Bellman-Ford 算法只对相邻节点进行计算,初始时所有人到起点S的距离都为INF。
①给所有的N个人，每人一次机会，问他的邻居到S的最短距离是多少？
如果他的邻居到S的距离不是INF，则他就能借道这个邻居到S去，并且把自己的INF更新为更短的距离。
显然开始的时候，S的直连邻居(比如U)肯定能保持更新，而U的邻居(例如V)在U更新之后，询问U，那么V有机会更新，否则就只能保持INF不变。
特别的，在第一轮更新中，存在一个与S距离最近的邻居(例如T)，T到S的直连距离就是全图中T到S的最短距离。(因为从别的路径借道到达S，肯定更远)
那么T的最短距离已经得到，后面不会再更新。
一轮更新称为一次 松弛
②重复第一轮的操作，再给每个人一次问邻居的机会，这一轮操作过后，至少存在一个S或者T的邻居(例如W)，可以算出他到S的最短距离。
W要么与S直连，要么通过T到达S。
W的最短距离也得到了，不会再更新。
③重复操作

时间复杂度O(M*N) N节点数 M边数

进行N-1次迭代 每次检查M条边

可以用来检查负环，若第N次仍可以进行松弛操作，则肯定存在负环

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std; 

//有向图  
const int N = 510;
const int M = 10010;

int Dis[N];//记录最短距离
int Backup[N];//上一次最短距离的备份
int n,m;//n为节点个数 m为边的数量
int k;//最多经过K条边

/*
3 3 1
1 2 1
2 3 1
1 3 3
为何需要备份
3个节点 三条边 最多经过一条边 
如果不备份 那么先更新1-->2 距离为1 经过1条边 
3询问他的邻居 2 那么更新 1-->3 距离为2 实则经过两条边   
 */
struct EDGE
{
	int Strat;
	int End;
	int Weight;	
}Edge[M];


void Bellman_Ford()
{
	//初始化Dis数组 
	fill(Dis, Dis+N, 0x3f3f3f3f);
	Dis[1] = 0;
	
	//若没有经过K条边的限制 则换成n 若经过n次还能松弛 则存在负环 
	for(int i = 0; i < k; i++)
	{
		//对Dis进行备份 
		memcpy(Backup, Dis, sizeof(Dis));
		
		//遍历m条边 
		for(int j = 0; j < m; j++)
		{
			int Start = Edge[j].Strat;
			int End = Edge[j].End;
			int Weight = Edge[j].Weight;
			
			//此处为Backup[Start] 
			//是为了防止此次迭代更新 更新了Dis[Start] 
			Dis[End] = min(Dis[End],Backup[Start] + Weight);
		}
	}
}

int main(int argc, char** argv) 
{
	scanf("%d%d%d",&n,&m,&k);
	
	for(int i = 0; i < m; i++)
	{
		scanf("%d%d%d",&Edge[i].Strat, &Edge[i].End,&Edge[i].Weight);	
		
	}
	Bellman_Ford();
	
	for(int i = 1; i <= n; i++)
	{
		cout<<Dis[i]<<endl;	
	}	
	return 0;
}