Bellman_Ford算法和SPFA算法 算法竞赛进阶指南笔记

给定一张有向图，图中的某一个边（x，y，z），有dist[y]<=dist[x]+z成立，称改变满足三角形不等式。若所有边都满足三角形不等式，则dist数组就是所求的最短路

Bellman-Ford

Bellman-Ford算法流程

1.扫描所有边(x,y,z)，若不满足三角形不等式，则更新dist[y]。
2.重复步骤1，直到步骤1没有更新操作。

时间复杂度

O（NM）两个节点相聚非常远，那么最多更新N-1次才更新完成，每次更新M个边。

有边数限制的最短路代码实现

void BF(){
    memset(d,0x3f,sizeof d);
    d[1]=0;
    for(int z = 0;z < k;z++){//k是限制的边数
        memcpy(last,d,sizeof d);//last数组储存d数组上一轮松弛的结果，避免串联。
        for(int i = 1;i<=n;i++){
            for(int j = h[i];j;j=r[j]){
                d[v[j]]=min(d[v[j]],last[i]+e[j]);
            }
        }
    }
}

SPFA

队列优化的Bellman-Ford算法

SPFA算法流程

1.建立一个队列，最初队列中只含有起点1
2.取出队头节点x，扫描它的所有出边（x，y，z），若不满足三角形不等式，更新dist[y],如果y不在队列中，放入队列中。
3.重复2直到队列为空。

代码无负权回路

void spfa(){
memset(d,0x3f,sizeof d);
d[1]=0;
memset(vis,false,sizeof vis);
queue q;
q.push(1),vis[1]=true;
while(q.size()){
int x = q.front();q.pop();
vis[x]=false;
for(int j = h[x];j;j=r[j]){
int y = v[j],z=e[j];
if(d[y]>d[x]+z){
if(!vis[y]) q.push(y),vis[y]=true;
d[y]=d[x]+z;
}
}
}
}

代码判断有无负权回路

bool spfa(){
    memset(d,0x3f,sizeof d);
    d[1]=0;
    memset(st,true,sizeof st);
    memset(cnt,0,sizeof cnt);//cnt是松弛的次数，如果一个节点被松弛n次以上那么图中一定存在负权回路。
    queue<int> q;
    for(int i = 1;i<=n;i++){
        q.push(i);
    }
    while(q.size()){
        int x = q.front();q.pop();
        st[x]=false;
        for(int j = h[x];j;j=r[j]){
            int y=v[j],z = e[j];
            if(d[y]>d[x]+z){
                if(!st[y])st[y]=true,q.push(y);
                d[y]=d[x]+z;
                cnt[y]=cnt[x]+1;
                if(cnt[y]>=n) return true;
            }
        }
    }
    return false;
}

遗留问题

cnt数组是什么

细节

SPFA保存了所有待扩展的节点，避免了对不需要扩展的节点的扫描，时间复杂度是近乎O（M）但是特殊构造的图中会退化到O（NM）