图论：最短路-Bellman-Ford

我们之前介绍了一种，（最常用的）SPFA算法，SPFA算法是对Bellman-Ford算法的队列优化，用队列替代了Bellman-Ford中的循环检查部分

然后这里我们介绍Bellman-Ford算法是为了介绍其对负权环的判定部分，以及这部分在SPFA的体现

首先是建图部分，邻接链表，其实对于Bellman-Ford算法来说，边表足矣

int g[maxn],d[maxn];
struct Edge{int u,t,w,next;}e[maxm];
void addedge(int x,int y,int z)
{
    cnt++;e[cnt].u=x;e[cnt].t=y;e[cnt].w=z;
    e[cnt].next=g[x];g[x]=cnt;
}

原本青涩的邻接表变成了现在的样子，自从看了黄学长的代码风格，压行写可能更加舒适一些。。

这里我们对于每一条边，记录其起始节点，和边表结构统一

然后，是算法的核心部分：

    for(int i=;i<=n;i++) d[i]=INF;
    d[s]=;
    for(int k=;k<n-;k++)
    for(int i=;i<=m;i++)
    {
        int x=e[i].u,y=e[i].t;
        if(d[x]<INF) d[y]=min(d[y],d[x]+e[i].w);
    }

其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在n-1次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成

然后是对于负权环的判断部分：

    bool flag=;
    for(int i=;i<=m;i++)
    if(d[e[i].t]>d[e[i].u]+e[i].w){flag = ;break;}
    return flag;  

对于每一条边进行检查，如果发现还能松弛，就存在负权环

最后给出完整实现，请注意如果每一条边的长度过大，在INF处一定不要越界，还有无向图的二倍边一定要记住

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int maxn=;
 const int maxm=;
 const int INF=0x7fffffff;
 int s,n,m,cnt;
 int g[maxn],d[maxn];
 struct Edge{int u,t,w,next;}e[maxm];
 void addedge(int x,int y,int z)
 {
     cnt++;e[cnt].u=x;e[cnt].t=y;e[cnt].w=z;
     e[cnt].next=g[x];g[x]=cnt;
 }
 bool bellman_ford(int s)
 {
     for(int i=;i<=n;i++) d[i]=INF;
     d[s]=;
     for(int k=;k<n-;k++)
     for(int i=;i<=m;i++)
     {
         int x=e[i].u,y=e[i].t;
         if(d[x]<INF) d[y]=min(d[y],d[x]+e[i].w);
     }
     bool flag=;
     for(int i=;i<=m;i++)
     if(d[e[i].t]>d[e[i].u]+e[i].w){flag = ;break;}
     return flag;
 }
 int main()
 {
     scanf("%d%d%d",&n,&m,&s);
     int x,y,z;
     for(int i=;i<=m;i++) {scanf("%d%d%d",&x,&y,&z);addedge(x,y,z);}
     bellman_ford(s);
     for(int i=;i<=n;i++) {printf("%d ",d[i]);}
     return ;
 }

在SPFA中开一个数组记录每一个点的入队次数，如果一个点重复入队了n次，说明存在负权环

总体来说，SPFA算法比Bellman-Ford更加优越，稠密图情况二者的效率是差不多的

稀疏图来说，SPFA可能要快于Dijkstra并且，网格图可以把SPFA卡回原型