算法基础之搜索与图论——SPFA算法( 队列优化过的bellman-ford算法 ) ( 单源最短路，存在负权边，适用于各种图 ) 时间复杂度O(m)，最坏O(nm)

题目：SPFA求最短路

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

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

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

输入格式
第一行包含整数 n 和 m。

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

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 impossible。

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

输入样例：
3 3
1 2 5
2 3 -3
1 3 4

输出样例：
2

思想：bellman-ford算法无脑遍历所有边，直到没有边的dist改变为止，而根据dist[j] = dist[t] + w得知 如果dist[i]没有改变那么dist[j] 就不会发生改变，所以我们可以将改变过的点压入队列，然后对队列中的点进行遍历，如果发现遍历之后改变了其他点，那么就将其他点也压入队列，如此往复直到队列为空。

代码如下：

#include<iostream>
#include<queue>
#include<cstring>

using namespace std;

const int N = 100005;

int n, m;
//以下数组和之前代码作用一样
int h[N],e[N], ne[N], w[N], flag;
int dist[N];
//st为标志数组，标志点是否存在队列中
bool st[N];
//建图
void add(int x, int y, int z)
{
    e[flag] = y;
    w[flag] = z;
    ne[flag] = h[x];
    h[x] = flag;
    flag ++;
}

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变为false表示点t已不在队列
        st[t] = false;
        //对t的邻接点进行遍历，
        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;
                }
            }
        }
    }
    //因为这里不是遍历所有边，而是遍历改变过的点的邻接边
    //所以dist[n]如果不存在是不可能被遍历到的，因此判断条件不用为dist[n] > 0x3f3f3f3f / 2
    if(dist[n] == 0x3f3f3f3f)   cout << "impossible";
    else    cout << dist[n];
}
int main()
{
    cin >> n >> m;
    
    memset(h, -1, sizeof h);
    while(m --){
        int x, y, z;
        cin >> x >> y >> z;
        
        add(x, y, z);
    }
    
    spfa();
}

标签：遍历,dist,int,单源,st,队列,算法,负权,号点
来源： https://blog.csdn.net/qq_48813213/article/details/115443327