SPFA

贝尔曼福德的队列优化

算法作用：处理带负权边的单源点最短路问题

①只把距离被更新的点放进队列中，让它更新与它有边的点
②还在队列中的点被更新后，不用再入队
③如果一个点被入队次数大于n-1那么就说明存在负环，该算法不能解决

算法证明：

定理：只要最短路径存在，上述SPFA算法必定能求出最小值。证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。

来源：百度百科 https://baike.baidu.com/item/SPFA%E7%AE%97%E6%B3%95/8297411?fromtitle=SPFA&fromid=11018124&fr=aladdin

时间复杂度：

平均: km (有说是错误的，所以不确定)
k:平均入队次数 m: 边数

最坏 VE
V：顶点数 E：边数

注意各个数组初始化

为什么一个点的入队次数最多为n-1，由下图可以推断
初始时两点有边才有路径，否则没有
所以
T先后被 A（S-A-T)、B(S-A-B-T)、C(S-A-B-C-T）优化，最多进队列n-1次，如果有负权环（环所有边权值和为负数）会不断入队，每次都会让环内两点路径缩小，所以入队次数会>n-1;

代码

#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000;
struct point{
    int w;      //权重
    int to;     //边的终点
    int next;   //给下一条同起点的边记录当前边的位置
};
point edge[MAX]; //存边 双向边开二倍

int head[MAX];  
int dist[MAX];  //点到源点的距离
int ct[MAX];    //点被优化次数
bool vis[MAX];  //判断点是否已经在队列里了。

int n,m,s,t;    //点 边 起点 终点
int cnt = 0;    //存边下标

void addedage(int x,int y,int z){//起点 终点 权重
    edge[++cnt].to = y;
    edge[cnt].w = z;
    edge[cnt].next = head[x];
    head[x] = cnt;
}

bool spfa(int s,int t,int n){   //贝尔曼福德优化算法
    queue<int> q;
    dist[s] = 0;
    vis[s] = true;
    q.push(s);
    while(!q.empty()){
        int x = q.front();
        q.pop();
        vis[x] = false;         //标记为不在队列
                                // -1按位取反 = 0；
        for(int i = head[x];~i;i = edge[i].next){//遍历所有以x为起点的边
            int u = edge[i].to;     //边的终点
            if(dist[u] > dist[x] + edge[i].w){
                dist[u] = dist[x] + edge[i].w;
                if(!vis[u]){        //一个点可能被多个点优化，但被优化的点在队列里就不用再入队
                    q.push(u);
                    vis[u] = true;  //标记为已经入队
                    if(ct[u]++ == n){//如果被优化次数等于n则说明有负环
                        return false;//最多有n-1个点路径优化而带来改点的路径优化
                    }
                }
                
            }
        }
    }
    if(dist[t] >= 0x3f3f3f3f)
        return false;
    return true;
}

int main(){                 //时间复杂度平均 k*m 平均入队次数*边数 最坏n^3 n为点数
    int x,y,z;
    int n,m,s,t;
    cin >> n >> m >> s >> t;
    memset(head,-1,sizeof(head));
    memset(dist,127,sizeof(dist));
    memset(vis,0,sizeof(vis));
    memset(ct,0,sizeof(ct));

    for(int i = 0;i < m;i++){
        cin >> x >> y >> z;
        addedage(x,y,z);
        addedage(y,x,z);//双向边
    }
    if(spfa(s,t,n))
        cout << dist[t];
    else cout << -1 ;
    //system("pause");
    return 0;
}