题目链接: 点击查看
题目描述:
给定一个 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];
}