2021-08-25 四期集训第四天-----Bellman-ford SPFA

Bellman_ford算法

dijkstra 为什么不能解决解决负权边最短路问题

加入每条边去松弛每个点到起点的距离

dist[b] = min(dist[b], backup[a] + w);

为什么需要back[a]数组

为了避免如下的串联情况， 在边数限制为一条的情况下，节点3的距离应该是3，但是由于串联情况，利用本轮更新的节点2更新了节点3的距离，所以现在节点3的距离是2。

正确做法是用上轮节点2更新的距离--无穷大，来更新节点3， 再取最小值，所以节点3离起点的距离是3。

for (int i = 0; i < k; i ++ )
{
    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);
    }
}

为什么是dist[n]>0x3f3f3f3f/2， 而不是dist[n]>0x3f3f3f3f

5号节点距离起点的距离是无穷大，利用5号节点更新n号节点距离起点的距离，将得到109−2109−2, 虽然小于109109, 但并不存在最短路，(在边数限制在k条的条件下)。

if(dist[n]>0x3f3f3f3f/2) return -1;
else return dist[n];

 模板

#include<iostream>
#include<cstring>

using namespace std;

const int N = 510, M = 10010;

struct Edge {
    int a;
    int b;
    int w;
} e[M];//把每个边保存下来即可
int dist[N];
int back[N];//备份数组防止串联
int n, m, k;//k代表最短路径最多包涵k条边

void bellman_ford() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < k; i++) {//k次循环
        memcpy(back, dist, sizeof dist);
        for (int j = 0; j < m; j++) {//遍历所有边
            int a = e[j].a, b = e[j].b, w = e[j].w;
            dist[b] = min(dist[b], back[a] + w);
            //使用backup:避免给a更新后立马更新b, 这样b一次性最短路径就多了两条边出来
        }
    }
}

int main() {
    scanf("%d%d%d", &n, &m, &k);
    for (int i = 0; i < m; i++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        e[i] = {a, b, w};
    }
    bellman_ford();
    if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
    else printf("%d\n", dist[n]);

    return 0;
}

spfa算法

1、什么是spfa算法？

SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA一般情况复杂度是O(m)O(m) 最坏情况下复杂度和朴素 Bellman-Ford 相同，为O(nm)O(nm)。

bellman-ford算法操作如下：

for n次 for 所有边 a,b,w (松弛操作) dist[b] = min(dist[b],back[a] + w)

spfa算法对第二行中所有边进行松弛操作进行了优化，原因是在bellman—ford算法中，即使该点的最短距离尚未更新过，但还是需要用尚未更新过的值去更新其他点，由此可知，该操作是不必要的，我们只需要找到更新过的值去更新其他点即可。

2、spfa算法步骤

queue <– 1 while queue 不为空 (1) t <– 队头 queue.pop() (2)用 t 更新所有出边 t –> b，权值为w queue <– b (若该点被更新过，则拿该点更新其他点)

时间复杂度 一般：O(m) 最坏：O(n*m)

n为点数，m为边数

spfa也能解决权值为正的图的最短距离问题，且一般情况下比Dijkstra算法还好

//spfa算法
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

const int  N = 1e5 + 10;

int n, m;
int h[N], e[N], w[N], ne[N], idx;
int dist[N];
bool st[N];
queue<int>q;

void add(int a,int b,int c) {
	e[idx] = b; w[idx] = c; ne[idx] = h[a]; h[a] = idx++;
}

int spfa() {
	memset(dist, 0x3f, sizeof dist);
	dist[1] = 0;
	q.push(1);
	st[1] = true;

	while (q.size()) {
		int t = q.front();
		q.pop();
		st[t] = false;

		for (int i = h[t]; i != -1; i = ne[i]) {
			int j = e[i];
			if (dist[j] > dist[t] + w[i]) {
				dist[j] = dist[t] + w[i];
				if (!st[j]) {
					q.push(j);
					st[j] = true;
				}
			}
		}
	}
	
	if (dist[n] == 0x3f3f3f3f) return -1;
	return dist[n];
}

int main() {
	scanf("%d %d", &n, &m);
	memset(h, -1, sizeof h);

	while (m--) {
		int a, b, w;
		scanf("%d %d %d", &a, &b, &w);
		add(a, b, w);
	}

	int t = spfa();

	if (t == -1)puts("impossible");
	else printf("%d\n", t);
	return 0;
}