Bellman-ford算法

解决的问题

最短路问题，时间复杂度为$O(n\ast m)$，可以有负权边，一般情况下都是SPFA算法更加优越，一般只有一种情况下必须使用Bellman-ford算法，那就是限制到最小距离的边数k，其他情况下一般SPFA算法更加适用。

思路

对每条边都进行松弛操作n - 1次，一点能实现最短路。
松弛：例如一条边a->b，权值为w，那么$$dist[b]=min(dist[b],dist[a]+w)$$
就是松弛，证明原理可以参考https://zhuanlan.zhihu.com/p/78784174
经过n-1次松弛之后，就能实现结果。
可以假设需要第n次松弛，那么一条最短路上需要有n条边，正常不会有，如果有说明具有负权回路了，在没有边数限制的时候就没有最小值，最小值为-INF。

模版

int dist[maxn];
//存储边即可，无需用邻接表或邻接矩阵
struct Edge{
	int a, b, w;
}edges[maxn]
int bellman_ford(){
	memset(dist, 0x3f, sizeof dist);
	dist[start] = 0;
	for (int i = 0; i < n - 1; i ++){	//循环n - 1次
		for (int j = 0; j < m; j ++){
			int a = edges[j].a, b = edges[j].b, w = edges[j].w;
			dist[b] = min(dist[b], dist[a] + w);
		}
	}
	//注意由于可能有负权边，松弛时可能会减少，不能直接判断等于
	if (dist[n] >= 0x3f3f3f3f / 2) return -1;
}

特定问题

限制：仅能走过k条边的最短路径
代码：

int dist[maxn], backup[maxn];	//多加一个backup数组用来存储上一次的dist
struct Edge{
	int a, b, w;
}edges[maxn]
int bellman_ford(){
	memset(dist, 0x3f, sizeof dist);
	dist[start] = 0;
	for (int i = 0; i < k; i ++){	//循环次数改成k次
		//保证这次松弛使用的是上次的dist，不会出现一次松弛多条边
		memcpy(backup, dist, sizeof dist);	
		for (int j = 0; j < m; j ++){
			int a = edges[j].a, b = edges[j].b, w = edges[j].w;
			dist[b] = min(dist[b], backup[a] + w);
		}
	}
	//注意由于可能有负权边，松弛时可能会减少，不能直接判断等于
	if (dist[n] >= 0x3f3f3f3f / 2) return -1;
}