图论详解——Bellman-Ford（清晰易懂）_Python

开学第一周，晚上属实作业有点乱

于是就拖更了一周

今天我们来讲解一下图论最短路径算法中

最简单

最清晰易懂

同时时间复杂度最高的算法

它的时间复杂度能达到o(ve)（点的数量*边的数量）

在学习bellman-ford之前，你需要先学会链式前向星

大家可以上网或者其他途径自行查阅一下

原理

这个算法是对图进行v-1次松弛操作（v为点的数量）

完了？

啊完了

松弛看不懂没事

继续往下看

正式开始讲原理：

日常建个小图

有没有权值无所谓，没有权值就当作1

假设我们要求1点到5点的最短路径

第一步：把1连接的所有边的目标点更新最短路径路径

最短路径更新成现在这样

现在更新2的

这是可以发现，1到5的路程可以更新了

2+7<10

所以更新

然后剩下的就没什么可更新的了

这样算出来，1到5的最短路程就是9

上面一套流程，就是我们用贝尔曼福特算法的过程

而2+7<10这步，就叫做松弛操作

松弛n-1次，每次都遍历每个点的每条边，能松则松，不能松就不松

没错贝尔曼福特还是这么简单

但这也造成了他时间复杂度贼高

就比如上图

3的松弛根本没用，也造成了时间上的问题

如果n<=10^6

那浪费的时间不可设想

另外它还有一个优点

就是能处理负权环

怎么处理呢？

先来看下普通代码

# include <iostream>
# include <cstdio>
# include <cmath>
# include <cstring>
using namespace std;
# define int long long
# define n 10005
# define m 10005
int s,t,n,m,m2;
double f[n];
struct node{
    int x,y;
}a[n];
struct node2{
    int to,next;
    double w;
}e[m];
int adj[n];
void add(int u,int v,double w2){
    m2++;
    e[m2].to=v;
    e[m2].w=w2;
    e[m2].next=adj[u];
    adj[u]=m2;
    return ;
}
void relax(int u,int v,double w2){
    if (f[v]>f[u]+w2){
        f[v]=f[u]+w2;
    }
    return ;
}
void ford(){
    memset(f,0x7f7f,sizeof(f));
    f[s]=0;
    for (int i=1;i<=n-1;i++){
        for (int j=1;j<=n;j++){
            for (int k=adj[j];k;k=e[k].next){
                int l=e[k].to;
                relax(j,l,e[k].w);
            }
        }
    }
    return ;
}
signed main(){
    ford();
    printf("%.2lf",f[t]);
    return 0;
}

本代码编写的是从s到t的最短路径，所以f[i]表示s到i的最短路径

解决下刚才的问题：负权环怎么解决

因为我们是n-1次松弛操作

在这种情况下，保证能把这个图的最短路径求出来

而负权环什么意思？他不可能有最短路径