最短路问题中的SPFA算法
spfa算法是对 bellman_ford算法的一种优化,除了边数限制的spfa算法解决不了,其他的负权边问题 spfa 算法都是各方面都 优于 bellman_ford算法的。
spfa算法的思路也是遍历所有的边,但跟bellman_ford算法在代码上有很多的不同
题目
给定一个 n n n 个点 m m m 条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你求出
1
1
1 号点到
n
n
n 号点的最短距离,如果无法从
1
1
1 号点走到
n
n
n 号点,则输出 impossible
。
数据保证不存在负权回路。
输入格式
第一行包含整数 n n n 和 m m m。
接下来 m m m 行每行包含三个整数 x , y , z x,y,z x,y,z,表示存在一条从点 x x x 到点 y y y 的有向边,边长为 z z z。
输出格式
输出一个整数,表示 1 1 1 号点到 n n n 号点的最短距离。
如果路径不存在,则输出 impossible
。
数据范围
1
≤
n
,
m
≤
1
0
5
1 \le n,m \le 10^5
1≤n,m≤105,
图中涉及边长绝对值均不超过
10000
10000
10000。
输入样例:
3 3
1 2 5
2 3 -3
1 3 4
输出样例:
2
由于是稠密图,所以我们用邻接表来存储,数组dist 还是代表点到1号点的距离。
布尔数组 st 跟 dijkstra算法当中的含义完全不同,它的含义只是是否在一个集合当中(这个集合可以是大多数集合,比如队列,栈等等)
建图环节跟之前的 稠密图建图一样,千万记得要给数组 h 初始化。
spfa 算法当中 需要有一个集合,这里我用到了队列。
只要队列不为空,那么循环就不结束,有点像宽搜的感觉。
完整代码:
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1e5+10, M = N;
int h[N], w[M], e[M], ne[M], idx;
int dist[N];
bool st[N];
int n, m;
void add(int a, int b, int c)
{
w[idx] = c;
e[idx] = b;
ne[idx] = h[a];
h[a] = idx ++;
}
void spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
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;
}
}
}
}
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i++)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
spfa();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d\n", dist[n]);
return 0;
}
完