Bellman-ford算法

一、算法简介：

（1）bellman-ford算法用于求解有负权边的最短路问题

（2）bellman-ford可以用于判断有无负权回路

（3）bellman-ford可以用于求解最多经过k条边的最短路问题

二、注意事项：        

（1）假设图中一共有n个点，如果题目没有最多k条边的限制，bellman-ford最多迭代n-1次，因为迭代到第k次的含义是从起点到终点最多经过k条边的最短路

（2）bellman-ford在每次迭代的时候必须要用一个备份数组来更新，否则会在更新的时候出现串联

（3）如果题目有最多k条边的限制，则数据中有负权回路也无所谓，因为有边数限制的话不可能无限循环

（4）如果题目没有最多k条边的限制，那就要在n-1次迭代之后再来一层松弛操作，如果最后一层的松弛操作还能更新，那么就说明有负权回路

（5）bellman-ford最多只需要执行n-1次松弛操作。实际上，有可能在n-1次之前，所有点的最短路就已经确定了；所以我们可以通过在前面n-1次松弛操作中设置一个bool变量，来判断每一次松弛操作是否还存在更新，如果存在更新，那么就直接break，也算是一个小剪枝

三、代码示例：

例题：        AcWing 853. 有边数限制的最短路 - AcWing（已做笔记）

（1）没有最多k条边的限制

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=100010;
int n,m;
int dist[N],backup[N];
int a[N],b[N],w[N];

int main()
{
    cin >> n >> m;
    for(int i=1;i<=m;i++) cin >> a[i] >> b[i] >> w[i];//不用邻接表和邻接矩阵存图
    
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=1;i<=n-1;i++){//最多迭代n-1次
        memcpy(backup,dist,sizeof dist);//备份数组
        for(int j=1;j<=m;j++){
            dist[b[j]]=min(dist[b[j]],backup[a[j]]+w[j]);//用备份数组来更新
        }
    }
    bool flag=false;
    for(int j=1;j<=m;j++){//再来一层迭代，用于判断有无负权回路
        if(dist[b[j]]>dist[a[j]]+w[j]){//如果还能更新，就有负权回路
            flag=true;
            break;
        }
    }
    if(flag) cout << "有负权回路";
    else cout << dist[n];
    return 0;
}

（2）有最多k条边的限制

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=100010;
int n,m;
int dist[N],backup[N];
int a[N],b[N],w[N];

int main()
{
    cin >> n >> m >> k;
    for(int i=1;i<=m;i++) cin >> a[i] >> b[i] >> w[i];//不用邻接表和邻接矩阵存图
    
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=1;i<=k;i++){//最多迭代n-1次
        memcpy(backup,dist,sizeof dist);//备份数组
        for(int j=1;j<=m;j++){
            dist[b[j]]=min(dist[b[j]],backup[a[j]]+w[j]);//用备份数组来更新
        }
    }
    
    //这段就可以不用要了，因为如果有边数的限制，那么必然不可能无限循环
    /*
    bool flag=false;
    for(int j=1;j<=m;j++){//再来一层迭代，用于判断有无负权回路
        if(dist[b[j]]>dist[a[j]]+w[j]){//如果还能更新，就有负权回路
            flag=true;
            break;
        }
    }
    */
    
    if(dist[n]>0x3f3f3f3f/2) cout << "impossible";//这里判断能不能到达不能直接判断dist[n]==0x3f3f3f3f，因为存在负权边
    else cout << dist[n];
    return 0;
}

（3）最终优化版

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=10010;
int n,m;
int dist[N],backup[N];
int a[N],b[N],w[N];

int main()
{
    cin >> n >> m;
    memset(dist,0x3f,sizeof dist);
    
    for(int i=1;i<=m;i++) cin >> a[i] >> b[i] >> w[i];
    
    for(int i=1;i<=n-1;i++){//最多迭代n-1次
        memcpy(backup,dist,sizeof dist);
        bool st=false;//用于判断能否继续更新
        for(int j=1;j<=m;j++){
            if(dist[b[j]]>backup[a[j]]+w[j]){
                st=true;
                dist[b[j]]=backup[a[j]]+w[j];//用备份数组更新
            }
        }
        if(!st) break;//如果无法继续更新，就直接break
    }
    
    bool flag=false;
    for(int j=1;i<=m;j++){
        if(dist[b[j]]>dist[a[j]]+w[j]){//如果再来一层迭代还可以更新，就说明有负权回路
            flag=true;
            break;
        }
    }
    if(flag) cout << "存在负权回路";
    else cout << diat[n];
    return 0;
}