基础算法学习---spfa算法

spfa(O(m) ~ O(nm))

可以在正权边的时候代替dijkstra算法，如果时间复杂度为O(nm)就不行了

没有负权回路的时候可以代替bellman-ford算法，一般都用spfa

spfa是对bellman-ford的bfs优化版本

spfa求最短路

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

using namespace std;

const int N = 100010;

//邻接表存储
int e[N],ne[N],h[N],w[N],idx;
int dist[N];
int n,m;
bool st[N];

void add(int a,int b,int c){
    e[idx] = b;
    ne[idx] = h[a];
    w[idx] = c;
    h[a] = idx ++;
}

int spfa(){
    queue<int> q;

    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
//有改变的点入队，只判断有改变的点
    q.push(1);

    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]){
                    st[j] = true;
                    q.push(j);
                }
            }
        }
    }

    if(dist[n] == 0x3f3f3f) return -1;
    return dist[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 t = spfa();
    if(t == -1) cout << "impossible";
    else cout << t;
}