【题目来源】
https://www.acwing.com/problem/content/853/

【题目描述】
给定一个 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

【数据范围】
1≤n,m≤10^5,
图中涉及边长绝对值均不超过 10000。

【算法分析】
● 链式前向星：https://blog.csdn.net/hnjzsyjyj/article/details/127190456
● 百度百科：SPFA 算法是 Bellman-Ford 算法的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA 最坏情况下时间复杂度和朴素 Bellman-Ford 相同，为 O(VE)。
● Bellman ford 算法可以存在负权回路，是因为其循环的次数是有限制的，因此最终不会发生死循环。但是， SPFA 算法不可以。这是因为，SPFA 算法用队列来存储，只要发生了更新就会不断的入队。因此，假如有负权回路请不要用 SPFA ，否则会死循环。

【算法代码】

#include <bits/stdc++.h>
using namespace std;const int maxn=1e5+5;
int val[maxn],e[maxn],ne[maxn],h[maxn],idx;
int dis[maxn];
bool st[maxn];
int n,m;void add(int a,int b,int w) {val[idx]=w,e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}int spfa() {memset(dis,0x3f,sizeof dis);dis[1]=0;queue<int> Q;Q.push(1);st[1]=true;while(!Q.empty()) {int t=Q.front();Q.pop();st[t]=false;for(int i=h[t]; i!=-1; i=ne[i]) {int j=e[i];if(dis[j]>dis[t]+val[i]) {dis[j]=dis[t]+val[i];if(!st[j]) {Q.push(j);st[j]=true;}}}}return dis[n]==0x3f3f3f3f?-1:dis[n];
}int main() {cin>>n>>m;memset(h,-1,sizeof h);while(m--) {int a,b,c;cin>>a>>b>>c;add(a,b,c);}int ans=spfa();if(ans==-1 && dis[n]!=-1) cout<<"impossible"<<endl;else cout<<ans<<endl;return 0;
}/*
in:
3 3
1 2 5
2 3 -3
1 3 4out:
2
-------
in:
3 2
1 2 1
2 3 -2out:
-1
*/

【参考文献】
https://baike.baidu.com/item/SPFA%E7%AE%97%E6%B3%95/8297411
https://blog.csdn.net/hnjzsyjyj/article/details/102583276
https://en.oi-wiki.org/ds/sgt/
https://www.sanfoundry.com/cpp-program-implement-scapegoat-tree/
https://brilliant.org/wiki/scapegoat-tree/
https://www.acwing.com/solution/content/9306/