P3371 【模板】单源最短路径（弱化版）

原题链接 https://www.luogu.org/problemnew/show/P3371

这道题要用SPFA，偷懒得复制一下百度的解释：知道你们一般直接跳过...给一下一个大佬的博客，挺详细的 传送门

SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于 1994 年发表的论文中的名字。不过，段凡丁的证明是错误的，且在 Bellman-Ford 算法提出后不久（1957 年 [1]  ）已有队列优化内容，所以国际上不承认 SPFA 算法是段凡丁提出的。

为了避免最坏情况的出现，在正权图上应使用效率更高的Dijkstra算法。

若给定的图存在负权边，类似Dijkstra算法等算法便没有了用武之地，SPFA算法便派上用场了。简洁起见，我们约定加权有向图G不存在负权回路，即最短路径一定存在。用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

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

实际上，如果一个点进入队列达到n次，则表明图中存在负环，没有最短路径。

段凡丁论文中的复杂度证明 （O(kE)，k 是小常数）是错误的，在此略去。该算法的最坏复杂度为 O(VE)。

对SPFA的一个很直观的理解就是由无权图的BFS转化而来。在无权图中，BFS首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数)，所以此时利用数组记录节点访问可以使每个顶点只进队一次，但在带权图中，最先到达的顶点所计算出来的路径不一定是最短路。一个解决方法是放弃数组，此时所需时间自然就是指数级的，所以我们不能放弃数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解。

SPFA算法有两个优化策略SLF和LLL——SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾； LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出队进行松弛操作。SLF 和 LLF 在随机数据上表现优秀，但是在正权图上最坏情况为 O(VE)，在负权图上最坏情况为达到指数级复杂度。

先给一下代码，下面讲原理:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const long long inf=2147483647;
long long n,m,s;
long long dis[10001],vis[10001],head[10001],num_edge=0;    //dis[i]储存起点到各个结点的最短路，vis[i]储存第i个结点是否在队列中，head[i]储存以i结点为始点的所有出边中的最后一条，其范围由点个数决定 
struct Edge{
    long long next,to,dis;                                 //next表示该边的始点的所有出边中的倒数第二条，to是该边的终点，dis是该边的权值 
}edge[500001]; 
queue <long long> q;                                       //定义队列 
void addedge(long long from,long long to,long long dis)    //一个从from到to的长度为dis的边，链式前向星 
{
    num_edge++;                                            //边的编号+1 
    edge[num_edge].next=head[from];                        //因为以from为始点的出边数+1，所以出边数未+1时的最后一条边就是现在的倒数第二条边 
    edge[num_edge].to=to;                                  //记录终点 
    edge[num_edge].dis=dis;                                //记录权值 
    head[from]=num_edge;                                   //更新以from为始点的最后一条边 
}
void spfa()                                                //SPFA算法 
{
    for(long long i=1;i<=n;++i)
    {
        dis[i]=inf;                                        //初始化全设为无穷大inf 
        vis[i]=0;                                          //无元素在队列里 
    }
    dis[s]=0;                                              //起点s到自己的距离为0 
    vis[s]=1;                                              //起点入队，标记为1 
    q.push(s);                                             //起点入队 
    while(!q.empty())                                      //保证队列不能为空 
    {
        long long u=q.front();                             //u记录队首元素结点 
        q.pop();                                           //队首元素结点出队 
        vis[u]=0;                                          //既然队首元素结点出队，说明不在队列里了，标记为0 
        for(long long i=head[u];i;i=edge[i].next)          //重点来啦！这步操作是后序访问以u为始点的所有出边 
        {
            long long zhongdian=edge[i].to;                 
            if(dis[zhongdian]>dis[u]+edge[i].dis)          //松弛操作：如果起点到该边的终点结点的最短路>起点到u结点的最短路+该边的权值，则更新最短路 
            {                                              //该边的权值就是u结点到终点结点的距离，因为该边的始点是u结点 
                dis[zhongdian]=dis[u]+edge[i].dis;
                if(!vis[zhongdian])                        //如果终点结点不在队列里 
                {
                    q.push(zhongdian);                     //终点结点入队，以后会对它向周边的边进行松弛操作 
                    vis[zhongdian]=1;                      //入队后标记为1 
                }
            }
        }
    }
}
int main()
{
    scanf("%lld %lld %lld",&n,&m,&s);                      //n个点，m条边，起点是s结点 
    for(long long i=1;i<=m;++i)
    {
        long long u,v,w;                                   //一条从u到v长度为w的边 
        scanf("%lld %lld %lld",&u,&v,&w);
        addedge(u,v,w);                                    //制造链表 
    }
    spfa();                                                //SPFA算法 
    for(long long i=1;i<=n;++i)                            //输出最短路 
    {
        if(i==s) printf("0 ");                             
        else printf("%lld ",dis[i]);
    }
    return 0;
} 

说一下SPFA访问边的原理：

对于一个队首元素u结点，我们要对它所有的出边进行松弛操作，那么就要先访问它所有的边

就是这步操作：  

        for(long long i=head[u];i;i=edge[i].next)          //重点来啦！这步操作是后序访问以u为始点的所有出边 
        {
            long long zhongdian=edge[i].to;                 
            if(dis[zhongdian]>dis[u]+edge[i].dis)          //松弛操作：如果起点到该边的终点结点的最短路>起点到u结点的最短路+该边的权值，则更新最短路 
            {                                              //该边的权值就是u结点到终点结点的距离，因为该边的始点是u结点 
                dis[zhongdian]=dis[u]+edge[i].dis;
                if(!vis[zhongdian])                        //如果终点结点不在队列里 
                {
                    q.push(zhongdian);                     //终点结点入队，以后会对它向周边的边进行松弛操作 
                    vis[zhongdian]=1;                      //入队后标记为1 
                }
            }
        }

解释一下这个for循环的意思：

我们要对u结点所有出边进行后序访问！！！

既然是后序，我们就要先找到出边中的最后一条边，看到上面我们定义的head数组的作用了吗？没错，它就是专门记录最后一条出边的，所以最后一条出边的编号就是：head[i]，就是第一个分号左边的含义

下面就是松弛操作，相信各位大佬看了注释后就懂了，先跳过——来到了第二个分号的右边：

还记得next记录的是啥嘛？没错，它就是记录上一条边的！！！是不是明白了什么————每一条边不仅有head[i]记录着自己的编号，还有edge[i].next记录着上一条边的编号

等到访问上一条边的时候，又记录着上上条边的编号，这就是链式前向星! 其实我也不是很懂啦，只是记住了学长大佬的话

那么这样一来，它就会一直向上访问，直到第一条出边

那么……不就完了？？？

撒花～QAQ～