AcWing 851. spfa求最短路(SPFA算法)

题目链接： 点击查看

题目描述：

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

输入输出格式 ：

输入

第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出

输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 impossible。

输入输出样例 ：

输入

3 3
1 2 5
2 3 -3
1 3 4

输出

2

题目分析 ：

SPFA算法相当于Bellman_ford算法的队列优化版本，Bellman_ford算法是为了找到最短路而遍历所有边，在遍历的过程中对边进行松弛操作，松弛操作代码为

backup[N];//backup数组用来存储d数组上一次遍历的状态
for ( int i = 0; i < m; i ++ ) {
   memcpy(backup, d, sizeof(d));
   for (int i = 0; i < m; i ++ )  {
       auto e = edges[i];//结构体来储存所有边
       d[e.v2] = min(d[e.v2], backup[e.v1] + e.w);
   } 
}

SPFA算法则是对这个松弛操作进行优化。因为在Bellman_ford算法中，即使当前点并没有更新过到源点最短距离，我们还是会用这个点去更新其他点到源点的最短距离，而这一步是没有必要的。在SPFA算法中，我们只需要遍历所有到源点的点距离变小的边，只有当一个点的前驱节点到源点的距离变小，这个点到源点的距离才会变小，最短距离便会在这些边中产生，而完成上述遍历需要通过队列来一步一步实现。

具体实现方法为 ： 我们用邻接表来存储图，在存储过程中，我们用一个w数组来存储相应点出边的权重。在SPFA函数中，我们先将距离数组d数组初始化距离为正无穷(0x3f3f3f3f)，d[1] = 0, 将源点1进行入队，q.push(1), 还需要一个状态数组st，将st[1] = true，表明1这个点在队列中已经存在。然后开始对队列的遍历操作，每一次我们取出相应的队头元素赋给t，同时st[t] = false表示队列中已经没有t节点。我们从所有与t节点相连的节点开始寻找(此处为邻接表的遍历操作，下面为代码)

for (int i = h[t]; i != -1; i = ne[i];)  {
    int j = e[i];
    ……
}

代码中j即为与t相连的节点，然后我们判断通过t节点能否缩短j到源点1的距离(判断是否可以松弛)，即if(d[j] > d[t] + w[i])， 如果可以则进行松弛操作d[j] = d[t] + w[i]，此时j点即为我们之前提到的可以更新最短距离的点，因此将j入队，同时标记st[j] = true。如此循环，直到队列为空。详见如下代码。

代码 ：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
using namespace std;
const int N = 1e5 + 10;
int n, m;
int h[N], w[N], e[N], ne[N], cur;
int d[N];//d[i]记录从节点1到节点i的最短路 
bool st[N];//记录节点是否在队列中 
void add(int v1, int v2, int wg) {//邻接表的方式来存储图 
	e[cur] = v2;
	w[cur] = wg;
	ne[cur] = h[v1];
	h[v1] = cur ++;
} 
int spfa() {
	memset(d, 0x3f, sizeof(d));//初始化
	d[1] = 0;
	queue<int> q;
	q.push(1);//1为图中第一个点且1到其本身的最短路已知，即为0，将1入队 
	st[1] = true;//入队将节点标记为true 
	while (q.size()) {
		int t = q.front();
		q.pop();
		st[t] = false;//出队将节点标记为false 
		for (int i = h[t]; i != -1; i = ne[i]) {//将与节点t直接有边相连的节点j进行遍历，如果j能通过点t进行松弛操作 ， 则将j入队 
			int j = e[i];
			if (d[j] > d[t] + w[i]) {//如果能进行松弛 
				d[j] = d[t] + w[i];
				if (!st[j]) {
					q.push(j);
					st[j] = true;
				}
			}
		}
	}
	return d[n];
}
int main() {
	cin >> n >> m;
	memset(h, -1, sizeof(h));
	while (m -- ) {
		int v1, v2, w;
		cin >> v1 >> v2 >> w;
		add(v1, v2, w);
	}
	int t = spfa();
	if (t == 0x3f3f3f3f) cout << "impossible" << endl;
	else cout << t;
	return 0;
}

---

下面给出SPFA算法的相关模板

时间复杂度 平均情况下 O(m)O(m)，最坏情况下 O(nm)O(nm), nn 表示点数，mm 表示边数
int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto 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])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}